lael-labs/linux

.mailmap+3−0

 Andrew Murray <amurray@thegoodpenguin.co.uk> <amurray@embedded-bits.co.uk>
 Andrew Murray <amurray@thegoodpenguin.co.uk> <andrew.murray@arm.com>
 Andrew Vasquez <andrew.vasquez@qlogic.com>
+Andrey Konovalov <andreyknvl@gmail.com> <andreyknvl@google.com>
 Andrey Ryabinin <ryabinin.a.a@gmail.com> <a.ryabinin@samsung.com>
 Andrey Ryabinin <ryabinin.a.a@gmail.com> <aryabinin@virtuozzo.com>
 Andy Adamson <andros@citi.umich.edu>
 Changbin Du <changbin.du@intel.com> <changbin.du@intel.com>
 Chao Yu <chao@kernel.org> <chao2.yu@samsung.com>
 Chao Yu <chao@kernel.org> <yuchao0@huawei.com>
+Chris Chiu <chris.chiu@canonical.com> <chiu@endlessm.com>
+Chris Chiu <chris.chiu@canonical.com> <chiu@endlessos.org>
 Christophe Ricard <christophe.ricard@gmail.com>
 Christoph Hellwig <hch@lst.de>
 Corey Minyard <minyard@acm.org>

Documentation/arm64/acpi_object_usage.rst+5−5

@@ -17,12 +17,12 @@ For ACPI on arm64, tables also fall into the following categories: · 16 unmodified lines
17		17
18	- Recommended: BERT, EINJ, ERST, HEST, PCCT, SSDT	18	- Recommended: BERT, EINJ, ERST, HEST, PCCT, SSDT
19		19
20	- Optional: BGRT, CPEP, CSRT, DBG2, DRTM, ECDT, FACS, FPDT, IORT,	20	- Optional: BGRT, CPEP, CSRT, DBG2, DRTM, ECDT, FACS, FPDT, IBFT,
21	MCHI, MPST, MSCT, NFIT, PMTT, RASF, SBST, SLIT, SPMI, SRAT, STAO,	21	IORT, MCHI, MPST, MSCT, NFIT, PMTT, RASF, SBST, SLIT, SPMI, SRAT,
22	TCPA, TPM2, UEFI, XENV	22	STAO, TCPA, TPM2, UEFI, XENV
23		23
24	- Not supported: BOOT, DBGP, DMAR, ETDT, HPET, IBFT, IVRS, LPIT,	24	- Not supported: BOOT, DBGP, DMAR, ETDT, HPET, IVRS, LPIT, MSDM, OEMx,
25	MSDM, OEMx, PSDT, RSDT, SLIC, WAET, WDAT, WDRT, WPBT	25	PSDT, RSDT, SLIC, WAET, WDAT, WDRT, WPBT
26		26
27	====== ========================================================================	27	====== ========================================================================
28	Table Usage for ARMv8 Linux	28	Table Usage for ARMv8 Linux

Documentation/arm64/silicon-errata.rst+3−0

 | Marvell        | ARM-MMU-500     | #582743         | N/A                         |
 +----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+
+| NVIDIA         | Carmel Core     | N/A             | NVIDIA_CARMEL_CNP_ERRATUM   |
++----------------+-----------------+-----------------+-----------------------------+
++----------------+-----------------+-----------------+-----------------------------+
 | Freescale/NXP  | LS2080A/LS1043A | A-008585        | FSL_ERRATUM_A008585         |
 +----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+

Documentation/networking/device_drivers/ethernet/amazon/ena.rst+1−1

@@ -267,7 +267,7 @@ DATA PATH · 266 unmodified lines
267	Tx	267	Tx
268	--	268	--
269		269
270	end_start_xmit() is called by the stack. This function does the following:	270	ena_start_xmit() is called by the stack. This function does the following:
271		271
272	- Maps data buffers (skb->data and frags).	272	- Maps data buffers (skb->data and frags).
273	- Populates ena_buf for the push buffer (if the driver and device are	273	- Populates ena_buf for the push buffer (if the driver and device are

Documentation/networking/devlink/devlink-dpipe.rst+1−1

@@ -52,7 +52,7 @@ purposes as a standard complementary tool. The system's view from · 51 unmodified lines
52	``devlink-dpipe`` should change according to the changes done by the	52	``devlink-dpipe`` should change according to the changes done by the
53	standard configuration tools.	53	standard configuration tools.
54		54
55	For example, it’s quiet common to implement Access Control Lists (ACL)	55	For example, it’s quite common to implement Access Control Lists (ACL)
56	using Ternary Content Addressable Memory (TCAM). The TCAM memory can be	56	using Ternary Content Addressable Memory (TCAM). The TCAM memory can be
57	divided into TCAM regions. Complex TC filters can have multiple rules with	57	divided into TCAM regions. Complex TC filters can have multiple rules with
58	different priorities and different lookup keys. On the other hand hardware	58	different priorities and different lookup keys. On the other hand hardware

Documentation/networking/devlink/devlink-port.rst+2−2

@@ -151,7 +151,7 @@ representor netdevice. · 150 unmodified lines
151	-------------	151	-------------
152	A subfunction devlink port is created but it is not active yet. That means the	152	A subfunction devlink port is created but it is not active yet. That means the
153	entities are created on devlink side, the e-switch port representor is created,	153	entities are created on devlink side, the e-switch port representor is created,
154	but the subfunction device itself it not created. A user might use e-switch port	154	but the subfunction device itself is not created. A user might use e-switch port
155	representor to do settings, putting it into bridge, adding TC rules, etc. A user	155	representor to do settings, putting it into bridge, adding TC rules, etc. A user
156	might as well configure the hardware address (such as MAC address) of the	156	might as well configure the hardware address (such as MAC address) of the
157	subfunction while subfunction is inactive.	157	subfunction while subfunction is inactive.
@@ -173,7 +173,7 @@ Terms and Definitions · 15 unmodified lines
173	* - Term	173	* - Term
174	- Definitions	174	- Definitions
175	* - ``PCI device``	175	* - ``PCI device``
176	- A physical PCI device having one or more PCI bus consists of one or	176	- A physical PCI device having one or more PCI buses consists of one or
177	more PCI controllers.	177	more PCI controllers.
178	* - ``PCI controller``	178	* - ``PCI controller``
179	- A controller consists of potentially multiple physical functions,	179	- A controller consists of potentially multiple physical functions,

Documentation/networking/xfrm_device.rst+1−1

@@ -50,7 +50,7 @@ Callbacks to implement · 49 unmodified lines
50		50
51	The NIC driver offering ipsec offload will need to implement these	51	The NIC driver offering ipsec offload will need to implement these
52	callbacks to make the offload available to the network stack's	52	callbacks to make the offload available to the network stack's
53	XFRM subsytem. Additionally, the feature bits NETIF_F_HW_ESP and	53	XFRM subsystem. Additionally, the feature bits NETIF_F_HW_ESP and
54	NETIF_F_HW_ESP_TX_CSUM will signal the availability of the offload.	54	NETIF_F_HW_ESP_TX_CSUM will signal the availability of the offload.
55		55
56		56

MAINTAINERS+28−31

 N:	sc2731
 ARM/STI ARCHITECTURE
-M:	Patrice Chotard <patrice.chotard@st.com>
+M:	Patrice Chotard <patrice.chotard@foss.st.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
 W:	http://www.stlinux.com
 ARM/STM32 ARCHITECTURE
 M:	Maxime Coquelin <mcoquelin.stm32@gmail.com>
-M:	Alexandre Torgue <alexandre.torgue@st.com>
+M:	Alexandre Torgue <alexandre.torgue@foss.st.com>
 L:	linux-stm32@st-md-mailman.stormreply.com (moderated for non-subscribers)
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
 F:	drivers/md/bcache/
 BDISP ST MEDIA DRIVER
-M:	Fabien Dessenne <fabien.dessenne@st.com>
+M:	Fabien Dessenne <fabien.dessenne@foss.st.com>
 L:	linux-media@vger.kernel.org
 S:	Supported
 W:	https://linuxtv.org
 L:	linux-pm@vger.kernel.org
 S:	Maintained
 T:	git git://github.com/broadcom/stblinux.git
-F:	drivers/soc/bcm/bcm-pmb.c
+F:	drivers/soc/bcm/bcm63xx/bcm-pmb.c
 F:	include/dt-bindings/soc/bcm-pmb.h
 BROADCOM SPECIFIC AMBA DRIVER (BCMA)
 F:	drivers/platform/x86/dell/dell-wmi.c
 DELTA ST MEDIA DRIVER
-M:	Hugues Fruchet <hugues.fruchet@st.com>
+M:	Hugues Fruchet <hugues.fruchet@foss.st.com>
 L:	linux-media@vger.kernel.org
 S:	Supported
 W:	https://linuxtv.org
 DRM DRIVERS FOR STI
 M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
-M:	Vincent Abriou <vincent.abriou@st.com>
 L:	dri-devel@lists.freedesktop.org
 S:	Maintained
 T:	git git://anongit.freedesktop.org/drm/drm-misc
 F:	drivers/gpu/drm/sti
 DRM DRIVERS FOR STM
-M:	Yannick Fertre <yannick.fertre@st.com>
+M:	Yannick Fertre <yannick.fertre@foss.st.com>
-M:	Philippe Cornu <philippe.cornu@st.com>
+M:	Philippe Cornu <philippe.cornu@foss.st.com>
 M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
-M:	Vincent Abriou <vincent.abriou@st.com>
 L:	dri-devel@lists.freedesktop.org
 S:	Maintained
 T:	git git://anongit.freedesktop.org/drm/drm-misc
 GENERIC PHY FRAMEWORK
 M:	Kishon Vijay Abraham I <kishon@ti.com>
 M:	Vinod Koul <vkoul@kernel.org>
-L:	linux-kernel@vger.kernel.org
+L:	linux-phy@lists.infradead.org
 S:	Supported
+Q:	https://patchwork.kernel.org/project/linux-phy/list/
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/phy/linux-phy.git
 F:	Documentation/devicetree/bindings/phy/
 F:	drivers/phy/
 F:	mm/hugetlb.c
 HVA ST MEDIA DRIVER
-M:	Jean-Christophe Trotin <jean-christophe.trotin@st.com>
+M:	Jean-Christophe Trotin <jean-christophe.trotin@foss.st.com>
 L:	linux-media@vger.kernel.org
 S:	Supported
 W:	https://linuxtv.org
 M:	Dany Madden <drt@linux.ibm.com>
 M:	Lijun Pan <ljp@linux.ibm.com>
 M:	Sukadev Bhattiprolu <sukadev@linux.ibm.com>
+R:	Thomas Falcon <tlfalcon@linux.ibm.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 F:	drivers/net/ethernet/ibm/ibmvnic.*
 LED SUBSYSTEM
 M:	Pavel Machek <pavel@ucw.cz>
-R:	Dan Murphy <dmurphy@ti.com>
 L:	linux-leds@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pavel/linux-leds.git
 F:	drivers/media/radio/radio-maxiradio*
 MCAN MMIO DEVICE DRIVER
-M:	Dan Murphy <dmurphy@ti.com>
 M:	Pankaj Sharma <pankj.sharma@samsung.com>
 L:	linux-can@vger.kernel.org
 S:	Maintained
 F:	drivers/media/dvb-frontends/stv6111*
 MEDIA DRIVERS FOR STM32 - DCMI
-M:	Hugues Fruchet <hugues.fruchet@st.com>
+M:	Hugues Fruchet <hugues.fruchet@foss.st.com>
 L:	linux-media@vger.kernel.org
 S:	Supported
 T:	git git://linuxtv.org/media_tree.git
 M:	Mat Martineau <mathew.j.martineau@linux.intel.com>
 M:	Matthieu Baerts <matthieu.baerts@tessares.net>
 L:	netdev@vger.kernel.org
-L:	mptcp@lists.01.org
+L:	mptcp@lists.linux.dev
 S:	Maintained
 W:	https://github.com/multipath-tcp/mptcp_net-next/wiki
 B:	https://github.com/multipath-tcp/mptcp_net-next/issues
 QLOGIC QLGE 10Gb ETHERNET DRIVER
 M:	Manish Chopra <manishc@marvell.com>
 M:	GR-Linux-NIC-Dev@marvell.com
-L:	netdev@vger.kernel.org
-S:	Supported
-F:	drivers/staging/qlge/
-QLOGIC QLGE 10Gb ETHERNET DRIVER
 M:	Coiby Xu <coiby.xu@gmail.com>
 L:	netdev@vger.kernel.org
-S:	Maintained
+S:	Supported
 F:	Documentation/networking/device_drivers/qlogic/qlge.rst
+F:	drivers/staging/qlge/
 QM1D1B0004 MEDIA DRIVER
 M:	Akihiro Tsukada <tskd08@gmail.com>
 S390 VFIO AP DRIVER
 M:	Tony Krowiak <akrowiak@linux.ibm.com>
-M:	Pierre Morel <pmorel@linux.ibm.com>
 M:	Halil Pasic <pasic@linux.ibm.com>
+M:	Jason Herne <jjherne@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 S:	Supported
 W:	http://www.ibm.com/developerworks/linux/linux390/
 S390 VFIO-CCW DRIVER
 M:	Cornelia Huck <cohuck@redhat.com>
 M:	Eric Farman <farman@linux.ibm.com>
+M:	Matthew Rosato <mjrosato@linux.ibm.com>
 R:	Halil Pasic <pasic@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 L:	kvm@vger.kernel.org
 S390 VFIO-PCI DRIVER
 M:	Matthew Rosato <mjrosato@linux.ibm.com>
+M:	Eric Farman <farman@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 L:	kvm@vger.kernel.org
 S:	Supported
 SPIDERNET NETWORK DRIVER for CELL
 M:	Ishizaki Kou <kou.ishizaki@toshiba.co.jp>
+M:	Geoff Levand <geoff@infradead.org>
 L:	netdev@vger.kernel.org
-S:	Supported
+L:	linuxppc-dev@lists.ozlabs.org
+S:	Maintained
 F:	Documentation/networking/device_drivers/ethernet/toshiba/spider_net.rst
 F:	drivers/net/ethernet/toshiba/spider_net*
 F:	drivers/media/i2c/st-mipid02.c
 ST STM32 I2C/SMBUS DRIVER
-M:	Pierre-Yves MORDRET <pierre-yves.mordret@st.com>
+M:	Pierre-Yves MORDRET <pierre-yves.mordret@foss.st.com>
+M:	Alain Volmat <alain.volmat@foss.st.com>
 L:	linux-i2c@vger.kernel.org
 S:	Maintained
 F:	drivers/i2c/busses/i2c-stm32*
 F:	kernel/static_call.c
 STI AUDIO (ASoC) DRIVERS
-M:	Arnaud Pouliquen <arnaud.pouliquen@st.com>
+M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
 L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
 S:	Maintained
 F:	Documentation/devicetree/bindings/sound/st,sti-asoc-card.txt
 F:	drivers/media/usb/stk1160/
 STM32 AUDIO (ASoC) DRIVERS
-M:	Olivier Moysan <olivier.moysan@st.com>
+M:	Olivier Moysan <olivier.moysan@foss.st.com>
-M:	Arnaud Pouliquen <arnaud.pouliquen@st.com>
+M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
 L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
 S:	Maintained
 F:	Documentation/devicetree/bindings/iio/adc/st,stm32-*.yaml
 F:	sound/soc/stm/
 STM32 TIMER/LPTIMER DRIVERS
-M:	Fabrice Gasnier <fabrice.gasnier@st.com>
+M:	Fabrice Gasnier <fabrice.gasnier@foss.st.com>
 S:	Maintained
 F:	Documentation/ABI/testing/*timer-stm32
 F:	Documentation/devicetree/bindings/*/*stm32-*timer*
 STMMAC ETHERNET DRIVER
 M:	Giuseppe Cavallaro <peppe.cavallaro@st.com>
-M:	Alexandre Torgue <alexandre.torgue@st.com>
+M:	Alexandre Torgue <alexandre.torgue@foss.st.com>
 M:	Jose Abreu <joabreu@synopsys.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 F:	drivers/thermal/ti-soc-thermal/
 TI BQ27XXX POWER SUPPLY DRIVER
-R:	Dan Murphy <dmurphy@ti.com>
 F:	drivers/power/supply/bq27xxx_battery.c
 F:	drivers/power/supply/bq27xxx_battery_i2c.c
 F:	include/linux/power/bq27xxx_battery.h
 F:	sound/soc/codecs/tas571x*
 TI TCAN4X5X DEVICE DRIVER
-M:	Dan Murphy <dmurphy@ti.com>
 L:	linux-can@vger.kernel.org
 S:	Maintained
 F:	Documentation/devicetree/bindings/net/can/tcan4x5x.txt

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 12	3	PATCHLEVEL = 12
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc4	5	EXTRAVERSION = -rc6
6	NAME = Frozen Wasteland	6	NAME = Frozen Wasteland
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/am33xx.dtsi+3−0

 		ethernet1 = &cpsw_emac1;
 		spi0 = &spi0;
 		spi1 = &spi1;
+		mmc0 = &mmc1;
+		mmc1 = &mmc2;
+		mmc2 = &mmc3;
 	};
 	cpus {

arch/arm/boot/dts/at91-sam9x60ek.dts+0−8

@@ -334,14 +334,6 @@ · 333 unmodified lines
334	};	334	};
335		335
336	&pinctrl {	336	&pinctrl {
337	atmel,mux-mask = <
338	/* A B C */
339	0xFFFFFE7F 0xC0E0397F 0xEF00019D /* pioA */
340	0x03FFFFFF 0x02FC7E68 0x00780000 /* pioB */
341	0xffffffff 0xF83FFFFF 0xB800F3FC /* pioC */
342	0x003FFFFF 0x003F8000 0x00000000 /* pioD */
343	>;
344
345	adc {	337	adc {
346	pinctrl_adc_default: adc_default {	338	pinctrl_adc_default: adc_default {
347	atmel,pins = <AT91_PIOB 15 AT91_PERIPH_A AT91_PINCTRL_NONE>;	339	atmel,pins = <AT91_PIOB 15 AT91_PERIPH_A AT91_PINCTRL_NONE>;

arch/arm/boot/dts/at91-sama5d27_som1.dtsi+2−2

@@ -84,8 +84,8 @@ · 83 unmodified lines
84	pinctrl-0 = <&pinctrl_macb0_default>;	84	pinctrl-0 = <&pinctrl_macb0_default>;
85	phy-mode = "rmii";	85	phy-mode = "rmii";
86		86
87	ethernet-phy@0 {	87	ethernet-phy@7 {
88	reg = <0x0>;	88	reg = <0x7>;
89	interrupt-parent = <&pioA>;	89	interrupt-parent = <&pioA>;
90	interrupts = <PIN_PD31 IRQ_TYPE_LEVEL_LOW>;	90	interrupts = <PIN_PD31 IRQ_TYPE_LEVEL_LOW>;
91	pinctrl-names = "default";	91	pinctrl-names = "default";

arch/arm/boot/dts/imx6ul-14x14-evk.dtsi+16−6

 			micrel,led-mode = <1>;
 			clocks = <&clks IMX6UL_CLK_ENET_REF>;
 			clock-names = "rmii-ref";
-			reset-gpios = <&gpio_spi 1 GPIO_ACTIVE_LOW>;
-			reset-assert-us = <10000>;
-			reset-deassert-us = <100>;
 		};
 			micrel,led-mode = <1>;
 			clocks = <&clks IMX6UL_CLK_ENET2_REF>;
 			clock-names = "rmii-ref";
-			reset-gpios = <&gpio_spi 2 GPIO_ACTIVE_LOW>;
-			reset-assert-us = <10000>;
-			reset-deassert-us = <100>;
 		};
 	};
 };
 	status = "okay";
 };
+&gpio_spi {
+	eth0-phy-hog {
+		gpio-hog;
+		gpios = <1 GPIO_ACTIVE_HIGH>;
+		output-high;
+		line-name = "eth0-phy";
+	};
+	eth1-phy-hog {
+		gpio-hog;
+		gpios = <2 GPIO_ACTIVE_HIGH>;
+		output-high;
+		line-name = "eth1-phy";
+	};
+};
 &i2c1 {
 	clock-frequency = <100000>;
 	pinctrl-names = "default";

arch/arm/boot/dts/imx6ull-myir-mys-6ulx-eval.dts+1−0

@@ -14,5 +14,6 @@ · 13 unmodified lines
14	};	14	};
15		15
16	&gpmi {	16	&gpmi {
		17	fsl,use-minimum-ecc;
17	status = "okay";	18	status = "okay";
18	};	19	};

arch/arm/boot/dts/sam9x60.dtsi+9−0

@@ -606,6 +606,15 @@ · 605 unmodified lines
606	compatible = "microchip,sam9x60-pinctrl", "atmel,at91sam9x5-pinctrl", "atmel,at91rm9200-pinctrl", "simple-bus";	606	compatible = "microchip,sam9x60-pinctrl", "atmel,at91sam9x5-pinctrl", "atmel,at91rm9200-pinctrl", "simple-bus";
607	ranges = <0xfffff400 0xfffff400 0x800>;	607	ranges = <0xfffff400 0xfffff400 0x800>;
608		608
		609	/* mux-mask corresponding to sam9x60 SoC in TFBGA228L package */
		610	atmel,mux-mask = <
		611	/* A B C */
		612	0xffffffff 0xffe03fff 0xef00019d /* pioA */
		613	0x03ffffff 0x02fc7e7f 0x00780000 /* pioB */
		614	0xffffffff 0xffffffff 0xf83fffff /* pioC */
		615	0x003fffff 0x003f8000 0x00000000 /* pioD */
		616	>;
		617
609	pioA: gpio@fffff400 {	618	pioA: gpio@fffff400 {
610	compatible = "microchip,sam9x60-gpio", "atmel,at91sam9x5-gpio", "atmel,at91rm9200-gpio";	619	compatible = "microchip,sam9x60-gpio", "atmel,at91sam9x5-gpio", "atmel,at91rm9200-gpio";
611	reg = <0xfffff400 0x200>;	620	reg = <0xfffff400 0x200>;

arch/arm/mach-imx/avic.c+15−1

 #include <linux/module.h>
 #include <linux/irq.h>
 #include <linux/irqdomain.h>
+#include <linux/irqchip.h>
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
  * interrupts. It registers the interrupt enable and disable functions
  * to the kernel for each interrupt source.
  */
-void __init mxc_init_irq(void __iomem *irqbase)
+static void __init mxc_init_irq(void __iomem *irqbase)
 {
 	struct device_node *np;
 	int irq_base;
 	printk(KERN_INFO "MXC IRQ initialized\n");
 }
+static int __init imx_avic_init(struct device_node *node,
+			       struct device_node *parent)
+{
+	void __iomem *avic_base;
+	avic_base = of_iomap(node, 0);
+	BUG_ON(!avic_base);
+	mxc_init_irq(avic_base);
+	return 0;
+}
+IRQCHIP_DECLARE(imx_avic, "fsl,avic", imx_avic_init);

arch/arm/mach-imx/common.h+0−1

@@ -22,7 +22,6 @@ void mx35_map_io(void); · 21 unmodified lines
22	void imx21_init_early(void);	22	void imx21_init_early(void);
23	void imx31_init_early(void);	23	void imx31_init_early(void);
24	void imx35_init_early(void);	24	void imx35_init_early(void);
25	void mxc_init_irq(void __iomem *);
26	void mx31_init_irq(void);	25	void mx31_init_irq(void);
27	void mx35_init_irq(void);	26	void mx35_init_irq(void);
28	void mxc_set_cpu_type(unsigned int type);	27	void mxc_set_cpu_type(unsigned int type);

arch/arm/mach-imx/mach-imx1.c+0−11

 	mxc_set_cpu_type(MXC_CPU_MX1);
 }
-static void __init imx1_init_irq(void)
-{
-	void __iomem *avic_addr;
-	avic_addr = ioremap(MX1_AVIC_ADDR, SZ_4K);
-	WARN_ON(!avic_addr);
-	mxc_init_irq(avic_addr);
-}
 static const char * const imx1_dt_board_compat[] __initconst = {
 	"fsl,imx1",
 	NULL
 DT_MACHINE_START(IMX1_DT, "Freescale i.MX1 (Device Tree Support)")
 	.init_early	= imx1_init_early,
-	.init_irq	= imx1_init_irq,
 	.dt_compat	= imx1_dt_board_compat,
 	.restart	= mxc_restart,
 MACHINE_END

arch/arm/mach-imx/mach-imx25.c+0−12

@@ -22,17 +22,6 @@ static void __init imx25_dt_init(void) · 21 unmodified lines
22	imx_aips_allow_unprivileged_access("fsl,imx25-aips");	22	imx_aips_allow_unprivileged_access("fsl,imx25-aips");
23	}	23	}
24		24
25	static void __init mx25_init_irq(void)
26	{
27	struct device_node *np;
28	void __iomem *avic_base;
29
30	np = of_find_compatible_node(NULL, NULL, "fsl,avic");
31	avic_base = of_iomap(np, 0);
32	BUG_ON(!avic_base);
33	mxc_init_irq(avic_base);
34	}
35
36	static const char * const imx25_dt_board_compat[] __initconst = {	25	static const char * const imx25_dt_board_compat[] __initconst = {
37	"fsl,imx25",	26	"fsl,imx25",
38	NULL	27	NULL
@@ -42,6 +31,5 @@ DT_MACHINE_START(IMX25_DT, "Freescale i.MX25 (Device Tree Support)") · 3 unmodified lines
42	.init_early = imx25_init_early,	31	.init_early = imx25_init_early,
43	.init_machine = imx25_dt_init,	32	.init_machine = imx25_dt_init,
44	.init_late = imx25_pm_init,	33	.init_late = imx25_pm_init,
45	.init_irq = mx25_init_irq,
46	.dt_compat = imx25_dt_board_compat,	34	.dt_compat = imx25_dt_board_compat,
47	MACHINE_END	35	MACHINE_END

arch/arm/mach-imx/mach-imx27.c+0−12

 	mxc_set_cpu_type(MXC_CPU_MX27);
 }
-static void __init mx27_init_irq(void)
-{
-	void __iomem *avic_base;
-	struct device_node *np;
-	np = of_find_compatible_node(NULL, NULL, "fsl,avic");
-	avic_base = of_iomap(np, 0);
-	BUG_ON(!avic_base);
-	mxc_init_irq(avic_base);
-}
 static const char * const imx27_dt_board_compat[] __initconst = {
 	"fsl,imx27",
 	NULL
 DT_MACHINE_START(IMX27_DT, "Freescale i.MX27 (Device Tree Support)")
 	.map_io		= mx27_map_io,
 	.init_early	= imx27_init_early,
-	.init_irq	= mx27_init_irq,
 	.init_late	= imx27_pm_init,
 	.dt_compat	= imx27_dt_board_compat,
 MACHINE_END

arch/arm/mach-imx/mach-imx31.c+0−1

@@ -14,6 +14,5 @@ static const char * const imx31_dt_board_compat[] __initconst = { · 13 unmodified lines
14	DT_MACHINE_START(IMX31_DT, "Freescale i.MX31 (Device Tree Support)")	14	DT_MACHINE_START(IMX31_DT, "Freescale i.MX31 (Device Tree Support)")
15	.map_io = mx31_map_io,	15	.map_io = mx31_map_io,
16	.init_early = imx31_init_early,	16	.init_early = imx31_init_early,
17	.init_irq = mx31_init_irq,
18	.dt_compat = imx31_dt_board_compat,	17	.dt_compat = imx31_dt_board_compat,
19	MACHINE_END	18	MACHINE_END

arch/arm/mach-imx/mach-imx35.c+0−1

@@ -27,6 +27,5 @@ DT_MACHINE_START(IMX35_DT, "Freescale i.MX35 (Device Tree Support)") · 26 unmodified lines
27	.l2c_aux_mask = ~0,	27	.l2c_aux_mask = ~0,
28	.map_io = mx35_map_io,	28	.map_io = mx35_map_io,
29	.init_early = imx35_init_early,	29	.init_early = imx35_init_early,
30	.init_irq = mx35_init_irq,
31	.dt_compat = imx35_dt_board_compat,	30	.dt_compat = imx35_dt_board_compat,
32	MACHINE_END	31	MACHINE_END

arch/arm/mach-imx/mm-imx3.c+0−24

@@ -109,18 +109,6 @@ void __init imx31_init_early(void) · 108 unmodified lines
109	mx3_ccm_base = of_iomap(np, 0);	109	mx3_ccm_base = of_iomap(np, 0);
110	BUG_ON(!mx3_ccm_base);	110	BUG_ON(!mx3_ccm_base);
111	}	111	}
112
113	void __init mx31_init_irq(void)
114	{
115	void __iomem *avic_base;
116	struct device_node *np;
117
118	np = of_find_compatible_node(NULL, NULL, "fsl,imx31-avic");
119	avic_base = of_iomap(np, 0);
120	BUG_ON(!avic_base);
121
122	mxc_init_irq(avic_base);
123	}
124	#endif /* ifdef CONFIG_SOC_IMX31 */	112	#endif /* ifdef CONFIG_SOC_IMX31 */
125		113
126	#ifdef CONFIG_SOC_IMX35	114	#ifdef CONFIG_SOC_IMX35
@@ -158,16 +146,4 @@ void __init imx35_init_early(void) · 31 unmodified lines
158	mx3_ccm_base = of_iomap(np, 0);	146	mx3_ccm_base = of_iomap(np, 0);
159	BUG_ON(!mx3_ccm_base);	147	BUG_ON(!mx3_ccm_base);
160	}	148	}
161
162	void __init mx35_init_irq(void)
163	{
164	void __iomem *avic_base;
165	struct device_node *np;
166
167	np = of_find_compatible_node(NULL, NULL, "fsl,imx35-avic");
168	avic_base = of_iomap(np, 0);
169	BUG_ON(!avic_base);
170
171	mxc_init_irq(avic_base);
172	}
173	#endif /* ifdef CONFIG_SOC_IMX35 */	149	#endif /* ifdef CONFIG_SOC_IMX35 */

arch/arm/mach-omap2/sr_device.c+58−17

 extern struct omap_sr_data omap_sr_pdata[];
-static int __init sr_dev_init(struct omap_hwmod *oh, void *user)
+static int __init sr_init_by_name(const char *name, const char *voltdm)
 {
 	struct omap_sr_data *sr_data = NULL;
 	struct omap_volt_data *volt_data;
-	struct omap_smartreflex_dev_attr *sr_dev_attr;
 	static int i;
-	if (!strncmp(oh->name, "smartreflex_mpu_iva", 20) ||
+	if (!strncmp(name, "smartreflex_mpu_iva", 20) ||
-	    !strncmp(oh->name, "smartreflex_mpu", 16))
+	    !strncmp(name, "smartreflex_mpu", 16))
 		sr_data = &omap_sr_pdata[OMAP_SR_MPU];
-	else if (!strncmp(oh->name, "smartreflex_core", 17))
+	else if (!strncmp(name, "smartreflex_core", 17))
 		sr_data = &omap_sr_pdata[OMAP_SR_CORE];
-	else if (!strncmp(oh->name, "smartreflex_iva", 16))
+	else if (!strncmp(name, "smartreflex_iva", 16))
 		sr_data = &omap_sr_pdata[OMAP_SR_IVA];
 	if (!sr_data) {
-		pr_err("%s: Unknown instance %s\n", __func__, oh->name);
+		pr_err("%s: Unknown instance %s\n", __func__, name);
 		return -EINVAL;
 	}
-	sr_dev_attr = (struct omap_smartreflex_dev_attr *)oh->dev_attr;
+	sr_data->name = name;
-	if (!sr_dev_attr || !sr_dev_attr->sensor_voltdm_name) {
-		pr_err("%s: No voltage domain specified for %s. Cannot initialize\n",
-		       __func__, oh->name);
-		goto exit;
-	}
-	sr_data->name = oh->name;
 	if (cpu_is_omap343x())
 		sr_data->ip_type = 1;
 	else
 		}
 	}
-	sr_data->voltdm = voltdm_lookup(sr_dev_attr->sensor_voltdm_name);
+	sr_data->voltdm = voltdm_lookup(voltdm);
 	if (!sr_data->voltdm) {
 		pr_err("%s: Unable to get voltage domain pointer for VDD %s\n",
-			__func__, sr_dev_attr->sensor_voltdm_name);
+			__func__, voltdm);
 		goto exit;
 	}
 	return 0;
 }
+static int __init sr_dev_init(struct omap_hwmod *oh, void *user)
+{
+	struct omap_smartreflex_dev_attr *sr_dev_attr;
+	sr_dev_attr = (struct omap_smartreflex_dev_attr *)oh->dev_attr;
+	if (!sr_dev_attr || !sr_dev_attr->sensor_voltdm_name) {
+		pr_err("%s: No voltage domain specified for %s. Cannot initialize\n",
+		       __func__, oh->name);
+		return 0;
+	}
+	return sr_init_by_name(oh->name, sr_dev_attr->sensor_voltdm_name);
+}
 /*
  * API to be called from board files to enable smartreflex
  * autocompensation at init.
 	sr_enable_on_init = true;
 }
+static const char * const omap4_sr_instances[] = {
+	"mpu",
+	"iva",
+	"core",
+};
+static const char * const dra7_sr_instances[] = {
+	"mpu",
+	"core",
+};
 int __init omap_devinit_smartreflex(void)
 {
+	const char * const *sr_inst;
+	int i, nr_sr = 0;
+	if (soc_is_omap44xx()) {
+		sr_inst = omap4_sr_instances;
+		nr_sr = ARRAY_SIZE(omap4_sr_instances);
+	} else if (soc_is_dra7xx()) {
+		sr_inst = dra7_sr_instances;
+		nr_sr = ARRAY_SIZE(dra7_sr_instances);
+	}
+	if (nr_sr) {
+		const char *name, *voltdm;
+		for (i = 0; i < nr_sr; i++) {
+			name = kasprintf(GFP_KERNEL, "smartreflex_%s", sr_inst[i]);
+			voltdm = sr_inst[i];
+			sr_init_by_name(name, voltdm);
+		}
+		return 0;
+	}
 	return omap_hwmod_for_each_by_class("smartreflex", sr_dev_init, NULL);
 }

arch/arm64/Kconfig+10−0

@@ -810,6 +810,16 @@ config QCOM_FALKOR_ERRATUM_E1041 · 809 unmodified lines
810		810
811	If unsure, say Y.	811	If unsure, say Y.
812		812
		813	config NVIDIA_CARMEL_CNP_ERRATUM
		814	bool "NVIDIA Carmel CNP: CNP on Carmel semantically different than ARM cores"
		815	default y
		816	help
		817	If CNP is enabled on Carmel cores, non-sharable TLBIs on a core will not
		818	invalidate shared TLB entries installed by a different core, as it would
		819	on standard ARM cores.
		820
		821	If unsure, say Y.
		822
813	config SOCIONEXT_SYNQUACER_PREITS	823	config SOCIONEXT_SYNQUACER_PREITS
814	bool "Socionext Synquacer: Workaround for GICv3 pre-ITS"	824	bool "Socionext Synquacer: Workaround for GICv3 pre-ITS"
815	default y	825	default y

arch/arm64/boot/dts/freescale/fsl-ls1012a.dtsi+1−0

@@ -198,6 +198,7 @@ · 197 unmodified lines
198	ranges = <0x0 0x00 0x1700000 0x100000>;	198	ranges = <0x0 0x00 0x1700000 0x100000>;
199	reg = <0x00 0x1700000 0x0 0x100000>;	199	reg = <0x00 0x1700000 0x0 0x100000>;
200	interrupts = <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;	200	interrupts = <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
		201	dma-coherent;
201		202
202	sec_jr0: jr@10000 {	203	sec_jr0: jr@10000 {
203	compatible = "fsl,sec-v5.4-job-ring",	204	compatible = "fsl,sec-v5.4-job-ring",

arch/arm64/boot/dts/freescale/fsl-ls1043a.dtsi+1−0

@@ -348,6 +348,7 @@ · 347 unmodified lines
348	ranges = <0x0 0x00 0x1700000 0x100000>;	348	ranges = <0x0 0x00 0x1700000 0x100000>;
349	reg = <0x00 0x1700000 0x0 0x100000>;	349	reg = <0x00 0x1700000 0x0 0x100000>;
350	interrupts = <0 75 0x4>;	350	interrupts = <0 75 0x4>;
		351	dma-coherent;
351		352
352	sec_jr0: jr@10000 {	353	sec_jr0: jr@10000 {
353	compatible = "fsl,sec-v5.4-job-ring",	354	compatible = "fsl,sec-v5.4-job-ring",

arch/arm64/boot/dts/freescale/fsl-ls1046a.dtsi+1−0

@@ -354,6 +354,7 @@ · 353 unmodified lines
354	ranges = <0x0 0x00 0x1700000 0x100000>;	354	ranges = <0x0 0x00 0x1700000 0x100000>;
355	reg = <0x00 0x1700000 0x0 0x100000>;	355	reg = <0x00 0x1700000 0x0 0x100000>;
356	interrupts = <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;	356	interrupts = <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
		357	dma-coherent;
357		358
358	sec_jr0: jr@10000 {	359	sec_jr0: jr@10000 {
359	compatible = "fsl,sec-v5.4-job-ring",	360	compatible = "fsl,sec-v5.4-job-ring",

arch/arm64/boot/dts/freescale/imx8mp-phyboard-pollux-rdk.dts+1−1

@@ -35,7 +35,7 @@ · 34 unmodified lines
35		35
36	&i2c2 {	36	&i2c2 {
37	clock-frequency = <400000>;	37	clock-frequency = <400000>;
38	pinctrl-names = "default";	38	pinctrl-names = "default", "gpio";
39	pinctrl-0 = <&pinctrl_i2c2>;	39	pinctrl-0 = <&pinctrl_i2c2>;
40	pinctrl-1 = <&pinctrl_i2c2_gpio>;	40	pinctrl-1 = <&pinctrl_i2c2_gpio>;
41	sda-gpios = <&gpio5 17 (GPIO_ACTIVE_HIGH \| GPIO_OPEN_DRAIN)>;	41	sda-gpios = <&gpio5 17 (GPIO_ACTIVE_HIGH \| GPIO_OPEN_DRAIN)>;

arch/arm64/boot/dts/freescale/imx8mp-phycore-som.dtsi+1−1

@@ -67,7 +67,7 @@ · 66 unmodified lines
67		67
68	&i2c1 {	68	&i2c1 {
69	clock-frequency = <400000>;	69	clock-frequency = <400000>;
70	pinctrl-names = "default";	70	pinctrl-names = "default", "gpio";
71	pinctrl-0 = <&pinctrl_i2c1>;	71	pinctrl-0 = <&pinctrl_i2c1>;
72	pinctrl-1 = <&pinctrl_i2c1_gpio>;	72	pinctrl-1 = <&pinctrl_i2c1_gpio>;
73	sda-gpios = <&gpio5 15 (GPIO_ACTIVE_HIGH \| GPIO_OPEN_DRAIN)>;	73	sda-gpios = <&gpio5 15 (GPIO_ACTIVE_HIGH \| GPIO_OPEN_DRAIN)>;

arch/arm64/include/asm/checksum.h+1−1

@@ -37,7 +37,7 @@ static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl) · 36 unmodified lines
37	} while (--n > 0);	37	} while (--n > 0);
38		38
39	sum += ((sum >> 32) \| (sum << 32));	39	sum += ((sum >> 32) \| (sum << 32));
40	return csum_fold((__force u32)(sum >> 32));	40	return csum_fold((__force __wsum)(sum >> 32));
41	}	41	}
42	#define ip_fast_csum ip_fast_csum	42	#define ip_fast_csum ip_fast_csum
43		43

arch/arm64/include/asm/cpucaps.h+2−1

@@ -66,7 +66,8 @@ · 65 unmodified lines
66	#define ARM64_WORKAROUND_1508412 58	66	#define ARM64_WORKAROUND_1508412 58
67	#define ARM64_HAS_LDAPR 59	67	#define ARM64_HAS_LDAPR 59
68	#define ARM64_KVM_PROTECTED_MODE 60	68	#define ARM64_KVM_PROTECTED_MODE 60
		69	#define ARM64_WORKAROUND_NVIDIA_CARMEL_CNP 61
69		70
70	#define ARM64_NCAPS 61	71	#define ARM64_NCAPS 62
71		72
72	#endif /* __ASM_CPUCAPS_H */	73	#endif /* __ASM_CPUCAPS_H */

arch/arm64/include/asm/kvm_arm.h+1−0

@@ -278,6 +278,7 @@ · 277 unmodified lines
278	#define CPTR_EL2_DEFAULT CPTR_EL2_RES1	278	#define CPTR_EL2_DEFAULT CPTR_EL2_RES1
279		279
280	/* Hyp Debug Configuration Register bits */	280	/* Hyp Debug Configuration Register bits */
		281	#define MDCR_EL2_TTRF (1 << 19)
281	#define MDCR_EL2_TPMS (1 << 14)	282	#define MDCR_EL2_TPMS (1 << 14)
282	#define MDCR_EL2_E2PB_MASK (UL(0x3))	283	#define MDCR_EL2_E2PB_MASK (UL(0x3))
283	#define MDCR_EL2_E2PB_SHIFT (UL(12))	284	#define MDCR_EL2_E2PB_SHIFT (UL(12))

arch/arm64/include/asm/processor.h+2−0

@@ -251,6 +251,8 @@ unsigned long get_wchan(struct task_struct *p); · 250 unmodified lines
251	extern struct task_struct cpu_switch_to(struct task_struct prev,	251	extern struct task_struct cpu_switch_to(struct task_struct prev,
252	struct task_struct *next);	252	struct task_struct *next);
253		253
		254	asmlinkage void arm64_preempt_schedule_irq(void);
		255
254	#define task_pt_regs(p) \	256	#define task_pt_regs(p) \
255	((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)	257	((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)
256		258

arch/arm64/include/asm/thread_info.h+2−0

@@ -55,6 +55,8 @@ void arch_setup_new_exec(void); · 54 unmodified lines
55	#define arch_setup_new_exec arch_setup_new_exec	55	#define arch_setup_new_exec arch_setup_new_exec
56		56
57	void arch_release_task_struct(struct task_struct *tsk);	57	void arch_release_task_struct(struct task_struct *tsk);
		58	int arch_dup_task_struct(struct task_struct *dst,
		59	struct task_struct *src);
58		60
59	#endif	61	#endif
60		62

arch/arm64/kernel/cpu_errata.c+8−0

@@ -525,6 +525,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 524 unmodified lines
525	0, 0,	525	0, 0,
526	1, 0),	526	1, 0),
527	},	527	},
		528	#endif
		529	#ifdef CONFIG_NVIDIA_CARMEL_CNP_ERRATUM
		530	{
		531	/* NVIDIA Carmel */
		532	.desc = "NVIDIA Carmel CNP erratum",
		533	.capability = ARM64_WORKAROUND_NVIDIA_CARMEL_CNP,
		534	ERRATA_MIDR_ALL_VERSIONS(MIDR_NVIDIA_CARMEL),
		535	},
528	#endif	536	#endif
529	{	537	{
530	}	538	}

arch/arm64/kernel/cpufeature.c+4−2

 	 * of support.
 	 */
 	S_ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_EXACT, ID_AA64DFR0_PMUVER_SHIFT, 4, 0),
-	ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_EXACT, ID_AA64DFR0_TRACEVER_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_EXACT, ID_AA64DFR0_DEBUGVER_SHIFT, 4, 0x6),
 	ARM64_FTR_END,
 };
 	 * may share TLB entries with a CPU stuck in the crashed
 	 * kernel.
 	 */
-	 if (is_kdump_kernel())
+	if (is_kdump_kernel())
+		return false;
+	if (cpus_have_const_cap(ARM64_WORKAROUND_NVIDIA_CARMEL_CNP))
 		return false;
 	return has_cpuid_feature(entry, scope);

arch/arm64/kernel/cpuinfo.c+1−1

@@ -353,7 +353,7 @@ static void __cpuinfo_store_cpu(struct cpuinfo_arm64 *info) · 352 unmodified lines
353	* with the CLIDR_EL1 fields to avoid triggering false warnings	353	* with the CLIDR_EL1 fields to avoid triggering false warnings
354	* when there is a mismatch across the CPUs. Keep track of the	354	* when there is a mismatch across the CPUs. Keep track of the
355	* effective value of the CTR_EL0 in our internal records for	355	* effective value of the CTR_EL0 in our internal records for
356	* acurate sanity check and feature enablement.	356	* accurate sanity check and feature enablement.
357	*/	357	*/
358	info->reg_ctr = read_cpuid_effective_cachetype();	358	info->reg_ctr = read_cpuid_effective_cachetype();
359	info->reg_dczid = read_cpuid(DCZID_EL0);	359	info->reg_dczid = read_cpuid(DCZID_EL0);

arch/arm64/kernel/crash_dump.c+2−0

@@ -64,5 +64,7 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf, · 63 unmodified lines
64	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)	64	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)
65	{	65	{
66	memcpy(buf, phys_to_virt((phys_addr_t)*ppos), count);	66	memcpy(buf, phys_to_virt((phys_addr_t)*ppos), count);
		67	*ppos += count;
		68
67	return count;	69	return count;
68	}	70	}

arch/arm64/kernel/process.c+2−0

@@ -57,6 +57,8 @@ · 56 unmodified lines
57	#include <asm/processor.h>	57	#include <asm/processor.h>
58	#include <asm/pointer_auth.h>	58	#include <asm/pointer_auth.h>
59	#include <asm/stacktrace.h>	59	#include <asm/stacktrace.h>
		60	#include <asm/switch_to.h>
		61	#include <asm/system_misc.h>
60		62
61	#if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)	63	#if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)
62	#include <linux/stackprotector.h>	64	#include <linux/stackprotector.h>

arch/arm64/kernel/stacktrace.c+5−4

 #ifdef CONFIG_STACKTRACE
-void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
+noinline void arch_stack_walk(stack_trace_consume_fn consume_entry,
-		     struct task_struct *task, struct pt_regs *regs)
+			      void *cookie, struct task_struct *task,
+			      struct pt_regs *regs)
 {
 	struct stackframe frame;
 		start_backtrace(&frame, regs->regs[29], regs->pc);
 	else if (task == current)
 		start_backtrace(&frame,
-				(unsigned long)__builtin_frame_address(0),
+				(unsigned long)__builtin_frame_address(1),
-				(unsigned long)arch_stack_walk);
+				(unsigned long)__builtin_return_address(0));
 	else
 		start_backtrace(&frame, thread_saved_fp(task),
 				thread_saved_pc(task));

arch/arm64/kvm/debug.c+2−0

  *  - Debug ROM Address (MDCR_EL2_TDRA)
  *  - OS related registers (MDCR_EL2_TDOSA)
  *  - Statistical profiler (MDCR_EL2_TPMS/MDCR_EL2_E2PB)
+ *  - Self-hosted Trace Filter controls (MDCR_EL2_TTRF)
  *
  * Additionally, KVM only traps guest accesses to the debug registers if
  * the guest is not actively using them (see the KVM_ARM64_DEBUG_DIRTY
 	vcpu->arch.mdcr_el2 = __this_cpu_read(mdcr_el2) & MDCR_EL2_HPMN_MASK;
 	vcpu->arch.mdcr_el2 |= (MDCR_EL2_TPM |
 				MDCR_EL2_TPMS |
+				MDCR_EL2_TTRF |
 				MDCR_EL2_TPMCR |
 				MDCR_EL2_TDRA |
 				MDCR_EL2_TDOSA);

arch/arm64/kvm/hyp/vgic-v3-sr.c+9−0

 	if (has_vhe())
 		flags = local_daif_save();
+	/*
+	 * Table 11-2 "Permitted ICC_SRE_ELx.SRE settings" indicates
+	 * that to be able to set ICC_SRE_EL1.SRE to 0, all the
+	 * interrupt overrides must be set. You've got to love this.
+	 */
+	sysreg_clear_set(hcr_el2, 0, HCR_AMO | HCR_FMO | HCR_IMO);
+	isb();
 	write_gicreg(0, ICC_SRE_EL1);
 	isb();
 	write_gicreg(sre, ICC_SRE_EL1);
 	isb();
+	sysreg_clear_set(hcr_el2, HCR_AMO | HCR_FMO | HCR_IMO, 0);
+	isb();
 	if (has_vhe())
 		local_daif_restore(flags);

arch/arm64/mm/mmu.c+19−2

@@ -1448,6 +1448,22 @@ static void __remove_pgd_mapping(pgd_t *pgdir, unsigned long start, u64 size) · 1447 unmodified lines
1448	struct range arch_get_mappable_range(void)	1448	struct range arch_get_mappable_range(void)
1449	{	1449	{
1450	struct range mhp_range;	1450	struct range mhp_range;
		1451	u64 start_linear_pa = __pa(_PAGE_OFFSET(vabits_actual));
		1452	u64 end_linear_pa = __pa(PAGE_END - 1);
		1453
		1454	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
		1455	/*
		1456	* Check for a wrap, it is possible because of randomized linear
		1457	* mapping the start physical address is actually bigger than
		1458	* the end physical address. In this case set start to zero
		1459	* because [0, end_linear_pa] range must still be able to cover
		1460	* all addressable physical addresses.
		1461	*/
		1462	if (start_linear_pa > end_linear_pa)
		1463	start_linear_pa = 0;
		1464	}
		1465
		1466	WARN_ON(start_linear_pa > end_linear_pa);
1451		1467
1452	/*	1468	/*
1453	* Linear mapping region is the range [PAGE_OFFSET..(PAGE_END - 1)]	1469	* Linear mapping region is the range [PAGE_OFFSET..(PAGE_END - 1)]
@@ -1455,8 +1471,9 @@ struct range arch_get_mappable_range(void) · 1 unmodified line
1455	* range which can be mapped inside this linear mapping range, must	1471	* range which can be mapped inside this linear mapping range, must
1456	* also be derived from its end points.	1472	* also be derived from its end points.
1457	*/	1473	*/
1458	mhp_range.start = __pa(_PAGE_OFFSET(vabits_actual));	1474	mhp_range.start = start_linear_pa;
1459	mhp_range.end = __pa(PAGE_END - 1);	1475	mhp_range.end = end_linear_pa;
		1476
1460	return mhp_range;	1477	return mhp_range;
1461	}	1478	}
1462		1479

arch/ia64/kernel/err_inject.c+11−11

@@ -59,7 +59,7 @@ show_##name(struct device dev, struct device_attribute attr, \ · 58 unmodified lines
59	char *buf) \	59	char *buf) \
60	{ \	60	{ \
61	u32 cpu=dev->id; \	61	u32 cpu=dev->id; \
62	return sprintf(buf, "%lx\n", name[cpu]); \	62	return sprintf(buf, "%llx\n", name[cpu]); \
63	}	63	}
64		64
65	#define store(name) \	65	#define store(name) \
@@ -86,9 +86,9 @@ store_call_start(struct device dev, struct device_attribute attr, · 20 unmodified lines
86		86
87	#ifdef ERR_INJ_DEBUG	87	#ifdef ERR_INJ_DEBUG
88	printk(KERN_DEBUG "pal_mc_err_inject for cpu%d:\n", cpu);	88	printk(KERN_DEBUG "pal_mc_err_inject for cpu%d:\n", cpu);
89	printk(KERN_DEBUG "err_type_info=%lx,\n", err_type_info[cpu]);	89	printk(KERN_DEBUG "err_type_info=%llx,\n", err_type_info[cpu]);
90	printk(KERN_DEBUG "err_struct_info=%lx,\n", err_struct_info[cpu]);	90	printk(KERN_DEBUG "err_struct_info=%llx,\n", err_struct_info[cpu]);
91	printk(KERN_DEBUG "err_data_buffer=%lx, %lx, %lx.\n",	91	printk(KERN_DEBUG "err_data_buffer=%llx, %llx, %llx.\n",
92	err_data_buffer[cpu].data1,	92	err_data_buffer[cpu].data1,
93	err_data_buffer[cpu].data2,	93	err_data_buffer[cpu].data2,
94	err_data_buffer[cpu].data3);	94	err_data_buffer[cpu].data3);
@@ -117,8 +117,8 @@ store_call_start(struct device dev, struct device_attribute attr, · 22 unmodified lines
117		117
118	#ifdef ERR_INJ_DEBUG	118	#ifdef ERR_INJ_DEBUG
119	printk(KERN_DEBUG "Returns: status=%d,\n", (int)status[cpu]);	119	printk(KERN_DEBUG "Returns: status=%d,\n", (int)status[cpu]);
120	printk(KERN_DEBUG "capabilities=%lx,\n", capabilities[cpu]);	120	printk(KERN_DEBUG "capabilities=%llx,\n", capabilities[cpu]);
121	printk(KERN_DEBUG "resources=%lx\n", resources[cpu]);	121	printk(KERN_DEBUG "resources=%llx\n", resources[cpu]);
122	#endif	122	#endif
123	return size;	123	return size;
124	}	124	}
@@ -131,7 +131,7 @@ show_virtual_to_phys(struct device dev, struct device_attribute attr, · 6 unmodified lines
131	char *buf)	131	char *buf)
132	{	132	{
133	unsigned int cpu=dev->id;	133	unsigned int cpu=dev->id;
134	return sprintf(buf, "%lx\n", phys_addr[cpu]);	134	return sprintf(buf, "%llx\n", phys_addr[cpu]);
135	}	135	}
136		136
137	static ssize_t	137	static ssize_t
@@ -145,7 +145,7 @@ store_virtual_to_phys(struct device dev, struct device_attribute attr, · 7 unmodified lines
145	ret = get_user_pages_fast(virt_addr, 1, FOLL_WRITE, NULL);	145	ret = get_user_pages_fast(virt_addr, 1, FOLL_WRITE, NULL);
146	if (ret<=0) {	146	if (ret<=0) {
147	#ifdef ERR_INJ_DEBUG	147	#ifdef ERR_INJ_DEBUG
148	printk("Virtual address %lx is not existing.\n",virt_addr);	148	printk("Virtual address %llx is not existing.\n", virt_addr);
149	#endif	149	#endif
150	return -EINVAL;	150	return -EINVAL;
151	}	151	}
@@ -163,7 +163,7 @@ show_err_data_buffer(struct device *dev, · 11 unmodified lines
163	{	163	{
164	unsigned int cpu=dev->id;	164	unsigned int cpu=dev->id;
165		165
166	return sprintf(buf, "%lx, %lx, %lx\n",	166	return sprintf(buf, "%llx, %llx, %llx\n",
167	err_data_buffer[cpu].data1,	167	err_data_buffer[cpu].data1,
168	err_data_buffer[cpu].data2,	168	err_data_buffer[cpu].data2,
169	err_data_buffer[cpu].data3);	169	err_data_buffer[cpu].data3);
@@ -178,13 +178,13 @@ store_err_data_buffer(struct device *dev, · 8 unmodified lines
178	int ret;	178	int ret;
179		179
180	#ifdef ERR_INJ_DEBUG	180	#ifdef ERR_INJ_DEBUG
181	printk("write err_data_buffer=[%lx,%lx,%lx] on cpu%d\n",	181	printk("write err_data_buffer=[%llx,%llx,%llx] on cpu%d\n",
182	err_data_buffer[cpu].data1,	182	err_data_buffer[cpu].data1,
183	err_data_buffer[cpu].data2,	183	err_data_buffer[cpu].data2,
184	err_data_buffer[cpu].data3,	184	err_data_buffer[cpu].data3,
185	cpu);	185	cpu);
186	#endif	186	#endif
187	ret=sscanf(buf, "%lx, %lx, %lx",	187	ret = sscanf(buf, "%llx, %llx, %llx",
188	&err_data_buffer[cpu].data1,	188	&err_data_buffer[cpu].data1,
189	&err_data_buffer[cpu].data2,	189	&err_data_buffer[cpu].data2,
190	&err_data_buffer[cpu].data3);	190	&err_data_buffer[cpu].data3);

arch/ia64/kernel/mca.c+1−1

@@ -1824,7 +1824,7 @@ ia64_mca_cpu_init(void *cpu_data) · 1823 unmodified lines
1824	data = mca_bootmem();	1824	data = mca_bootmem();
1825	first_time = 0;	1825	first_time = 0;
1826	} else	1826	} else
1827	data = (void *)__get_free_pages(GFP_KERNEL,	1827	data = (void *)__get_free_pages(GFP_ATOMIC,
1828	get_order(sz));	1828	get_order(sz));
1829	if (!data)	1829	if (!data)
1830	panic("Could not allocate MCA memory for cpu %d\n",	1830	panic("Could not allocate MCA memory for cpu %d\n",

arch/mips/kernel/setup.c+1−1

@@ -43,7 +43,7 @@ · 42 unmodified lines
43	#include <asm/prom.h>	43	#include <asm/prom.h>
44		44
45	#ifdef CONFIG_MIPS_ELF_APPENDED_DTB	45	#ifdef CONFIG_MIPS_ELF_APPENDED_DTB
46	const char __section(".appended_dtb") __appended_dtb[0x100000];	46	char __section(".appended_dtb") __appended_dtb[0x100000];
47	#endif /* CONFIG_MIPS_ELF_APPENDED_DTB */	47	#endif /* CONFIG_MIPS_ELF_APPENDED_DTB */
48		48
49	struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly;	49	struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly;

arch/powerpc/platforms/pseries/lpar.c+2−1

@@ -887,7 +887,8 @@ static long pSeries_lpar_hpte_updatepp(unsigned long slot, · 886 unmodified lines
887		887
888	want_v = hpte_encode_avpn(vpn, psize, ssize);	888	want_v = hpte_encode_avpn(vpn, psize, ssize);
889		889
890	flags = (newpp & 7) \| H_AVPN;	890	flags = (newpp & (HPTE_R_PP \| HPTE_R_N \| HPTE_R_KEY_LO)) \| H_AVPN;
		891	flags \|= (newpp & HPTE_R_KEY_HI) >> 48;
891	if (mmu_has_feature(MMU_FTR_KERNEL_RO))	892	if (mmu_has_feature(MMU_FTR_KERNEL_RO))
892	/* Move pp0 into bit 8 (IBM 55) */	893	/* Move pp0 into bit 8 (IBM 55) */
893	flags \|= (newpp & HPTE_R_PP0) >> 55;	894	flags \|= (newpp & HPTE_R_PP0) >> 55;

arch/powerpc/platforms/pseries/mobility.c+44−4

@@ -452,12 +452,28 @@ static int do_suspend(void) · 451 unmodified lines
452	return ret;	452	return ret;
453	}	453	}
454		454
		455	/**
		456	* struct pseries_suspend_info - State shared between CPUs for join/suspend.
		457	* @counter: Threads are to increment this upon resuming from suspend
		458	* or if an error is received from H_JOIN. The thread which performs
		459	* the first increment (i.e. sets it to 1) is responsible for
		460	* waking the other threads.
		461	* @done: False if join/suspend is in progress. True if the operation is
		462	* complete (successful or not).
		463	*/
		464	struct pseries_suspend_info {
		465	atomic_t counter;
		466	bool done;
		467	};
		468
455	static int do_join(void *arg)	469	static int do_join(void *arg)
456	{	470	{
457	atomic_t *counter = arg;	471	struct pseries_suspend_info *info = arg;
		472	atomic_t *counter = &info->counter;
458	long hvrc;	473	long hvrc;
459	int ret;	474	int ret;
460		475
		476	retry:
461	/* Must ensure MSR.EE off for H_JOIN. */	477	/* Must ensure MSR.EE off for H_JOIN. */
462	hard_irq_disable();	478	hard_irq_disable();
463	hvrc = plpar_hcall_norets(H_JOIN);	479	hvrc = plpar_hcall_norets(H_JOIN);
@@ -473,8 +489,20 @@ static int do_join(void *arg) · 9 unmodified lines
473	case H_SUCCESS:	489	case H_SUCCESS:
474	/*	490	/*
475	* The suspend is complete and this cpu has received a	491	* The suspend is complete and this cpu has received a
476	* prod.	492	* prod, or we've received a stray prod from unrelated
		493	* code (e.g. paravirt spinlocks) and we need to join
		494	* again.
		495	*
		496	* This barrier orders the return from H_JOIN above vs
		497	* the load of info->done. It pairs with the barrier
		498	* in the wakeup/prod path below.
477	*/	499	*/
		500	smp_mb();
		501	if (READ_ONCE(info->done) == false) {
		502	pr_info_ratelimited("premature return from H_JOIN on CPU %i, retrying",
		503	smp_processor_id());
		504	goto retry;
		505	}
478	ret = 0;	506	ret = 0;
479	break;	507	break;
480	case H_BAD_MODE:	508	case H_BAD_MODE:
@@ -488,6 +516,13 @@ static int do_join(void *arg) · 7 unmodified lines
488		516
489	if (atomic_inc_return(counter) == 1) {	517	if (atomic_inc_return(counter) == 1) {
490	pr_info("CPU %u waking all threads\n", smp_processor_id());	518	pr_info("CPU %u waking all threads\n", smp_processor_id());
		519	WRITE_ONCE(info->done, true);
		520	/*
		521	* This barrier orders the store to info->done vs subsequent
		522	* H_PRODs to wake the other CPUs. It pairs with the barrier
		523	* in the H_SUCCESS case above.
		524	*/
		525	smp_mb();
491	prod_others();	526	prod_others();
492	}	527	}
493	/*	528	/*
@@ -535,11 +570,16 @@ static int pseries_suspend(u64 handle) · 41 unmodified lines
535	int ret;	570	int ret;
536		571
537	while (true) {	572	while (true) {
538	atomic_t counter = ATOMIC_INIT(0);	573	struct pseries_suspend_info info;
539	unsigned long vasi_state;	574	unsigned long vasi_state;
540	int vasi_err;	575	int vasi_err;
541		576
542	ret = stop_machine(do_join, &counter, cpu_online_mask);	577	info = (struct pseries_suspend_info) {
		578	.counter = ATOMIC_INIT(0),
		579	.done = false,
		580	};
		581
		582	ret = stop_machine(do_join, &info, cpu_online_mask);
543	if (ret == 0)	583	if (ret == 0)
544	break;	584	break;
545	/*	585	/*

arch/riscv/Kconfig+1−1

@@ -314,7 +314,7 @@ endchoice · 313 unmodified lines
314	# Common NUMA Features	314	# Common NUMA Features
315	config NUMA	315	config NUMA
316	bool "NUMA Memory Allocation and Scheduler Support"	316	bool "NUMA Memory Allocation and Scheduler Support"
317	depends on SMP	317	depends on SMP && MMU
318	select GENERIC_ARCH_NUMA	318	select GENERIC_ARCH_NUMA
319	select OF_NUMA	319	select OF_NUMA
320	select ARCH_SUPPORTS_NUMA_BALANCING	320	select ARCH_SUPPORTS_NUMA_BALANCING

arch/riscv/include/asm/uaccess.h+5−2

  * data types like structures or arrays.
  *
  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
- * to the result of dereferencing @ptr.
+ * to the result of dereferencing @ptr. The value of @x is copied to avoid
+ * re-ordering where @x is evaluated inside the block that enables user-space
+ * access (thus bypassing user space protection if @x is a function).
  *
  * Caller must check the pointer with access_ok() before calling this
  * function.
 #define __put_user(x, ptr)					\
 ({								\
 	__typeof__(*(ptr)) __user *__gu_ptr = (ptr);		\
+	__typeof__(*__gu_ptr) __val = (x);			\
 	long __pu_err = 0;					\
 								\
 	__chk_user_ptr(__gu_ptr);				\
 								\
 	__enable_user_access();					\
-	__put_user_nocheck(x, __gu_ptr, __pu_err);		\
+	__put_user_nocheck(__val, __gu_ptr, __pu_err);		\
 	__disable_user_access();				\
 								\
 	__pu_err;						\

arch/riscv/kernel/entry.S+1−0

@@ -447,6 +447,7 @@ ENDPROC(__switch_to) · 446 unmodified lines
447	#endif	447	#endif
448		448
449	.section ".rodata"	449	.section ".rodata"
		450	.align LGREG
450	/* Exception vector table */	451	/* Exception vector table */
451	ENTRY(excp_vect_table)	452	ENTRY(excp_vect_table)
452	RISCV_PTR do_trap_insn_misaligned	453	RISCV_PTR do_trap_insn_misaligned

arch/riscv/kernel/stacktrace.c+1−1

@@ -14,7 +14,7 @@ · 13 unmodified lines
14		14
15	#include <asm/stacktrace.h>	15	#include <asm/stacktrace.h>
16		16
17	register const unsigned long sp_in_global __asm__("sp");	17	register unsigned long sp_in_global __asm__("sp");
18		18
19	#ifdef CONFIG_FRAME_POINTER	19	#ifdef CONFIG_FRAME_POINTER
20		20

arch/riscv/mm/kasan_init.c+1−1

@@ -216,7 +216,7 @@ void __init kasan_init(void) · 215 unmodified lines
216	break;	216	break;
217		217
218	kasan_populate(kasan_mem_to_shadow(start), kasan_mem_to_shadow(end));	218	kasan_populate(kasan_mem_to_shadow(start), kasan_mem_to_shadow(end));
219	};	219	}
220		220
221	for (i = 0; i < PTRS_PER_PTE; i++)	221	for (i = 0; i < PTRS_PER_PTE; i++)
222	set_pte(&kasan_early_shadow_pte[i],	222	set_pte(&kasan_early_shadow_pte[i],

arch/s390/include/asm/vdso/data.h+1−1

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	#include <vdso/datapage.h>	6	#include <vdso/datapage.h>
7		7
8	struct arch_vdso_data {	8	struct arch_vdso_data {
9	__u64 tod_steering_delta;	9	__s64 tod_steering_delta;
10	__u64 tod_steering_end;	10	__u64 tod_steering_end;
11	};	11	};
12		12

arch/s390/kernel/time.c+8−2

 {
 	struct ptff_qto qto;
 	struct ptff_qui qui;
+	int cs;
 	/* Initialize TOD steering parameters */
 	tod_steering_end = tod_clock_base.tod;
-	vdso_data->arch_data.tod_steering_end = tod_steering_end;
+	for (cs = 0; cs < CS_BASES; cs++)
+		vdso_data[cs].arch_data.tod_steering_end = tod_steering_end;
 	if (!test_facility(28))
 		return;
 {
 	unsigned long now, adj;
 	struct ptff_qto qto;
+	int cs;
 	/* Fixup the monotonic sched clock. */
 	tod_clock_base.eitod += delta;
 		panic("TOD clock sync offset %li is too large to drift\n",
 		      tod_steering_delta);
 	tod_steering_end = now + (abs(tod_steering_delta) << 15);
-	vdso_data->arch_data.tod_steering_end = tod_steering_end;
+	for (cs = 0; cs < CS_BASES; cs++) {
+		vdso_data[cs].arch_data.tod_steering_end = tod_steering_end;
+		vdso_data[cs].arch_data.tod_steering_delta = tod_steering_delta;
+	}
 	/* Update LPAR offset. */
 	if (ptff_query(PTFF_QTO) && ptff(&qto, sizeof(qto), PTFF_QTO) == 0)

arch/x86/Makefile+1−1

@@ -27,7 +27,7 @@ endif · 26 unmodified lines
27	REALMODE_CFLAGS := -m16 -g -Os -DDISABLE_BRANCH_PROFILING \	27	REALMODE_CFLAGS := -m16 -g -Os -DDISABLE_BRANCH_PROFILING \
28	-Wall -Wstrict-prototypes -march=i386 -mregparm=3 \	28	-Wall -Wstrict-prototypes -march=i386 -mregparm=3 \
29	-fno-strict-aliasing -fomit-frame-pointer -fno-pic \	29	-fno-strict-aliasing -fomit-frame-pointer -fno-pic \
30	-mno-mmx -mno-sse	30	-mno-mmx -mno-sse $(call cc-option,-fcf-protection=none)
31		31
32	REALMODE_CFLAGS += -ffreestanding	32	REALMODE_CFLAGS += -ffreestanding
33	REALMODE_CFLAGS += -fno-stack-protector	33	REALMODE_CFLAGS += -fno-stack-protector

arch/x86/include/asm/smp.h+1−0

@@ -132,6 +132,7 @@ void native_play_dead(void); · 131 unmodified lines
132	void play_dead_common(void);	132	void play_dead_common(void);
133	void wbinvd_on_cpu(int cpu);	133	void wbinvd_on_cpu(int cpu);
134	int wbinvd_on_all_cpus(void);	134	int wbinvd_on_all_cpus(void);
		135	bool wakeup_cpu0(void);
135		136
136	void native_smp_send_reschedule(int cpu);	137	void native_smp_send_reschedule(int cpu);
137	void native_send_call_func_ipi(const struct cpumask *mask);	138	void native_send_call_func_ipi(const struct cpumask *mask);

arch/x86/include/asm/xen/page.h+0−12

@@ -86,18 +86,6 @@ clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops, · 85 unmodified lines
86	}	86	}
87	#endif	87	#endif
88		88
89	/*
90	* The maximum amount of extra memory compared to the base size. The
91	* main scaling factor is the size of struct page. At extreme ratios
92	* of base:extra, all the base memory can be filled with page
93	* structures for the extra memory, leaving no space for anything
94	* else.
95	*
96	* 10x seems like a reasonable balance between scaling flexibility and
97	* leaving a practically usable system.
98	*/
99	#define XEN_EXTRA_MEM_RATIO (10)
100
101	/*	89	/*
102	* Helper functions to write or read unsigned long values to/from	90	* Helper functions to write or read unsigned long values to/from
103	* memory, when the access may fault.	91	* memory, when the access may fault.

arch/x86/kernel/acpi/boot.c+12−13

 	/*
 	 * Initialize the ACPI boot-time table parser.
 	 */
-	if (acpi_table_init()) {
+	if (acpi_locate_initial_tables())
 		disable_acpi();
-		return;
+	else
-	}
+		acpi_reserve_initial_tables();
+}
+int __init early_acpi_boot_init(void)
+{
+	if (acpi_disabled)
+		return 1;
+	acpi_table_init_complete();
 	acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
 		} else {
 			printk(KERN_WARNING PREFIX "Disabling ACPI support\n");
 			disable_acpi();
-			return;
+			return 1;
 		}
 	}
-}
-int __init early_acpi_boot_init(void)
-{
-	/*
-	 * If acpi_disabled, bail out
-	 */
-	if (acpi_disabled)
-		return 1;
 	/*
 	 * Process the Multiple APIC Description Table (MADT), if present

arch/x86/kernel/setup.c+3−5

 	cleanup_highmap();
+	/* Look for ACPI tables and reserve memory occupied by them. */
+	acpi_boot_table_init();
 	memblock_set_current_limit(ISA_END_ADDRESS);
 	e820__memblock_setup();
 	early_platform_quirks();
-	/*
-	 * Parse the ACPI tables for possible boot-time SMP configuration.
-	 */
-	acpi_boot_table_init();
 	early_acpi_boot_init();
 	initmem_init();

arch/x86/kernel/smpboot.c+1−1

@@ -1659,7 +1659,7 @@ void play_dead_common(void) · 1658 unmodified lines
1659	local_irq_disable();	1659	local_irq_disable();
1660	}	1660	}
1661		1661
1662	static bool wakeup_cpu0(void)	1662	bool wakeup_cpu0(void)
1663	{	1663	{
1664	if (smp_processor_id() == 0 && enable_start_cpu0)	1664	if (smp_processor_id() == 0 && enable_start_cpu0)
1665	return true;	1665	return true;

arch/x86/kvm/Makefile+1−1

@@ -1,6 +1,6 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	ccflags-y += -Iarch/x86/kvm	3	ccflags-y += -I $(srctree)/arch/x86/kvm
4	ccflags-$(CONFIG_KVM_WERROR) += -Werror	4	ccflags-$(CONFIG_KVM_WERROR) += -Werror
5		5
6	ifeq ($(CONFIG_FRAME_POINTER),y)	6	ifeq ($(CONFIG_FRAME_POINTER),y)

arch/x86/kvm/mmu/mmu.c+5−4

 	struct kvm_mmu_page *sp;
 	unsigned int ratio;
 	LIST_HEAD(invalid_list);
+	bool flush = false;
 	ulong to_zap;
 	rcu_idx = srcu_read_lock(&kvm->srcu);
 				      lpage_disallowed_link);
 		WARN_ON_ONCE(!sp->lpage_disallowed);
 		if (is_tdp_mmu_page(sp)) {
-			kvm_tdp_mmu_zap_gfn_range(kvm, sp->gfn,
+			flush = kvm_tdp_mmu_zap_sp(kvm, sp);
-				sp->gfn + KVM_PAGES_PER_HPAGE(sp->role.level));
 		} else {
 			kvm_mmu_prepare_zap_page(kvm, sp, &invalid_list);
 			WARN_ON_ONCE(sp->lpage_disallowed);
 		}
 		if (need_resched() || rwlock_needbreak(&kvm->mmu_lock)) {
-			kvm_mmu_commit_zap_page(kvm, &invalid_list);
+			kvm_mmu_remote_flush_or_zap(kvm, &invalid_list, flush);
 			cond_resched_rwlock_write(&kvm->mmu_lock);
+			flush = false;
 		}
 	}
-	kvm_mmu_commit_zap_page(kvm, &invalid_list);
+	kvm_mmu_remote_flush_or_zap(kvm, &invalid_list, flush);
 	write_unlock(&kvm->mmu_lock);
 	srcu_read_unlock(&kvm->srcu, rcu_idx);

arch/x86/kvm/mmu/tdp_mmu.c+14−12

 	list_for_each_entry(_root, &_kvm->arch.tdp_mmu_roots, link)
 static bool zap_gfn_range(struct kvm *kvm, struct kvm_mmu_page *root,
-			  gfn_t start, gfn_t end, bool can_yield);
+			  gfn_t start, gfn_t end, bool can_yield, bool flush);
 void kvm_tdp_mmu_free_root(struct kvm *kvm, struct kvm_mmu_page *root)
 {
 	list_del(&root->link);
-	zap_gfn_range(kvm, root, 0, max_gfn, false);
+	zap_gfn_range(kvm, root, 0, max_gfn, false, false);
 	free_page((unsigned long)root->spt);
 	kmem_cache_free(mmu_page_header_cache, root);
  * scheduler needs the CPU or there is contention on the MMU lock. If this
  * function cannot yield, it will not release the MMU lock or reschedule and
  * the caller must ensure it does not supply too large a GFN range, or the
- * operation can cause a soft lockup.
+ * operation can cause a soft lockup.  Note, in some use cases a flush may be
+ * required by prior actions.  Ensure the pending flush is performed prior to
+ * yielding.
  */
 static bool zap_gfn_range(struct kvm *kvm, struct kvm_mmu_page *root,
-			  gfn_t start, gfn_t end, bool can_yield)
+			  gfn_t start, gfn_t end, bool can_yield, bool flush)
 {
 	struct tdp_iter iter;
-	bool flush_needed = false;
 	rcu_read_lock();
 	tdp_root_for_each_pte(iter, root, start, end) {
 		if (can_yield &&
-		    tdp_mmu_iter_cond_resched(kvm, &iter, flush_needed)) {
+		    tdp_mmu_iter_cond_resched(kvm, &iter, flush)) {
-			flush_needed = false;
+			flush = false;
 			continue;
 		}
 			continue;
 		tdp_mmu_set_spte(kvm, &iter, 0);
-		flush_needed = true;
+		flush = true;
 	}
 	rcu_read_unlock();
-	return flush_needed;
+	return flush;
 }
 /*
  * SPTEs have been cleared and a TLB flush is needed before releasing the
  * MMU lock.
  */
-bool kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, gfn_t start, gfn_t end)
+bool __kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, gfn_t start, gfn_t end,
+				 bool can_yield)
 {
 	struct kvm_mmu_page *root;
 	bool flush = false;
 	for_each_tdp_mmu_root_yield_safe(kvm, root)
-		flush |= zap_gfn_range(kvm, root, start, end, true);
+		flush = zap_gfn_range(kvm, root, start, end, can_yield, flush);
 	return flush;
 }
 				     struct kvm_mmu_page *root, gfn_t start,
 				     gfn_t end, unsigned long unused)
 {
-	return zap_gfn_range(kvm, root, start, end, false);
+	return zap_gfn_range(kvm, root, start, end, false, false);
 }
 int kvm_tdp_mmu_zap_hva_range(struct kvm *kvm, unsigned long start,

arch/x86/kvm/mmu/tdp_mmu.h+23−1

@@ -8,7 +8,29 @@ · 7 unmodified lines
8	hpa_t kvm_tdp_mmu_get_vcpu_root_hpa(struct kvm_vcpu *vcpu);	8	hpa_t kvm_tdp_mmu_get_vcpu_root_hpa(struct kvm_vcpu *vcpu);
9	void kvm_tdp_mmu_free_root(struct kvm kvm, struct kvm_mmu_page root);	9	void kvm_tdp_mmu_free_root(struct kvm kvm, struct kvm_mmu_page root);
10		10
11	bool kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, gfn_t start, gfn_t end);	11	bool __kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, gfn_t start, gfn_t end,
		12	bool can_yield);
		13	static inline bool kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, gfn_t start,
		14	gfn_t end)
		15	{
		16	return __kvm_tdp_mmu_zap_gfn_range(kvm, start, end, true);
		17	}
		18	static inline bool kvm_tdp_mmu_zap_sp(struct kvm kvm, struct kvm_mmu_page sp)
		19	{
		20	gfn_t end = sp->gfn + KVM_PAGES_PER_HPAGE(sp->role.level);
		21
		22	/*
		23	* Don't allow yielding, as the caller may have a flush pending. Note,
		24	* if mmu_lock is held for write, zapping will never yield in this case,
		25	* but explicitly disallow it for safety. The TDP MMU does not yield
		26	* until it has made forward progress (steps sideways), and when zapping
		27	* a single shadow page that it's guaranteed to see (thus the mmu_lock
		28	* requirement), its "step sideways" will always step beyond the bounds
		29	* of the shadow page's gfn range and stop iterating before yielding.
		30	*/
		31	lockdep_assert_held_write(&kvm->mmu_lock);
		32	return __kvm_tdp_mmu_zap_gfn_range(kvm, sp->gfn, end, false);
		33	}
12	void kvm_tdp_mmu_zap_all(struct kvm *kvm);	34	void kvm_tdp_mmu_zap_all(struct kvm *kvm);
13		35
14	int kvm_tdp_mmu_map(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,	36	int kvm_tdp_mmu_map(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,

arch/x86/kvm/svm/nested.c+23−5

@@ -246,11 +246,18 @@ static bool nested_vmcb_check_controls(struct vmcb_control_area *control) · 245 unmodified lines
246	return true;	246	return true;
247	}	247	}
248		248
249	static bool nested_vmcb_checks(struct vcpu_svm svm, struct vmcb vmcb12)	249	static bool nested_vmcb_check_save(struct vcpu_svm svm, struct vmcb vmcb12)
250	{	250	{
251	struct kvm_vcpu *vcpu = &svm->vcpu;	251	struct kvm_vcpu *vcpu = &svm->vcpu;
252	bool vmcb12_lma;	252	bool vmcb12_lma;
253		253
		254	/*
		255	* FIXME: these should be done after copying the fields,
		256	* to avoid TOC/TOU races. For these save area checks
		257	* the possible damage is limited since kvm_set_cr0 and
		258	* kvm_set_cr4 handle failure; EFER_SVME is an exception
		259	* so it is force-set later in nested_prepare_vmcb_save.
		260	*/
254	if ((vmcb12->save.efer & EFER_SVME) == 0)	261	if ((vmcb12->save.efer & EFER_SVME) == 0)
255	return false;	262	return false;
256		263
@@ -271,7 +278,7 @@ static bool nested_vmcb_checks(struct vcpu_svm svm, struct vmcb vmcb12) · 14 unmodified lines
271	if (!kvm_is_valid_cr4(&svm->vcpu, vmcb12->save.cr4))	278	if (!kvm_is_valid_cr4(&svm->vcpu, vmcb12->save.cr4))
272	return false;	279	return false;
273		280
274	return nested_vmcb_check_controls(&vmcb12->control);	281	return true;
275	}	282	}
276		283
277	static void load_nested_vmcb_control(struct vcpu_svm *svm,	284	static void load_nested_vmcb_control(struct vcpu_svm *svm,
@@ -396,7 +403,14 @@ static void nested_prepare_vmcb_save(struct vcpu_svm svm, struct vmcb vmcb12) · 118 unmodified lines
396	svm->vmcb->save.gdtr = vmcb12->save.gdtr;	403	svm->vmcb->save.gdtr = vmcb12->save.gdtr;
397	svm->vmcb->save.idtr = vmcb12->save.idtr;	404	svm->vmcb->save.idtr = vmcb12->save.idtr;
398	kvm_set_rflags(&svm->vcpu, vmcb12->save.rflags \| X86_EFLAGS_FIXED);	405	kvm_set_rflags(&svm->vcpu, vmcb12->save.rflags \| X86_EFLAGS_FIXED);
399	svm_set_efer(&svm->vcpu, vmcb12->save.efer);	406
		407	/*
		408	* Force-set EFER_SVME even though it is checked earlier on the
		409	* VMCB12, because the guest can flip the bit between the check
		410	* and now. Clearing EFER_SVME would call svm_free_nested.
		411	*/
		412	svm_set_efer(&svm->vcpu, vmcb12->save.efer \| EFER_SVME);
		413
400	svm_set_cr0(&svm->vcpu, vmcb12->save.cr0);	414	svm_set_cr0(&svm->vcpu, vmcb12->save.cr0);
401	svm_set_cr4(&svm->vcpu, vmcb12->save.cr4);	415	svm_set_cr4(&svm->vcpu, vmcb12->save.cr4);
402	svm->vmcb->save.cr2 = svm->vcpu.arch.cr2 = vmcb12->save.cr2;	416	svm->vmcb->save.cr2 = svm->vcpu.arch.cr2 = vmcb12->save.cr2;
@@ -468,7 +482,6 @@ int enter_svm_guest_mode(struct vcpu_svm *svm, u64 vmcb12_gpa, · 65 unmodified lines
468		482
469		483
470	svm->nested.vmcb12_gpa = vmcb12_gpa;	484	svm->nested.vmcb12_gpa = vmcb12_gpa;
471	load_nested_vmcb_control(svm, &vmcb12->control);
472	nested_prepare_vmcb_control(svm);	485	nested_prepare_vmcb_control(svm);
473	nested_prepare_vmcb_save(svm, vmcb12);	486	nested_prepare_vmcb_save(svm, vmcb12);
474		487
@@ -515,7 +528,10 @@ int nested_svm_vmrun(struct vcpu_svm *svm) · 40 unmodified lines
515	if (WARN_ON_ONCE(!svm->nested.initialized))	528	if (WARN_ON_ONCE(!svm->nested.initialized))
516	return -EINVAL;	529	return -EINVAL;
517		530
518	if (!nested_vmcb_checks(svm, vmcb12)) {	531	load_nested_vmcb_control(svm, &vmcb12->control);
		532
		533	if (!nested_vmcb_check_save(svm, vmcb12) \|\|
		534	!nested_vmcb_check_controls(&svm->nested.ctl)) {
519	vmcb12->control.exit_code = SVM_EXIT_ERR;	535	vmcb12->control.exit_code = SVM_EXIT_ERR;
520	vmcb12->control.exit_code_hi = 0;	536	vmcb12->control.exit_code_hi = 0;
521	vmcb12->control.exit_info_1 = 0;	537	vmcb12->control.exit_info_1 = 0;
@@ -1209,6 +1225,8 @@ static int svm_set_nested_state(struct kvm_vcpu *vcpu, · 687 unmodified lines
1209	*/	1225	*/
1210	if (!(save->cr0 & X86_CR0_PG))	1226	if (!(save->cr0 & X86_CR0_PG))
1211	goto out_free;	1227	goto out_free;
		1228	if (!(save->efer & EFER_SVME))
		1229	goto out_free;
1212		1230
1213	/*	1231	/*
1214	* All checks done, we can enter guest mode. L1 control fields	1232	* All checks done, we can enter guest mode. L1 control fields

arch/x86/kvm/svm/pmu.c+8−0

 static inline struct kvm_pmc *get_gp_pmc_amd(struct kvm_pmu *pmu, u32 msr,
 					     enum pmu_type type)
 {
+	struct kvm_vcpu *vcpu = pmu_to_vcpu(pmu);
 	switch (msr) {
 	case MSR_F15H_PERF_CTL0:
 	case MSR_F15H_PERF_CTL1:
 	case MSR_F15H_PERF_CTL3:
 	case MSR_F15H_PERF_CTL4:
 	case MSR_F15H_PERF_CTL5:
+		if (!guest_cpuid_has(vcpu, X86_FEATURE_PERFCTR_CORE))
+			return NULL;
+		fallthrough;
 	case MSR_K7_EVNTSEL0 ... MSR_K7_EVNTSEL3:
 		if (type != PMU_TYPE_EVNTSEL)
 			return NULL;
 	case MSR_F15H_PERF_CTR3:
 	case MSR_F15H_PERF_CTR4:
 	case MSR_F15H_PERF_CTR5:
+		if (!guest_cpuid_has(vcpu, X86_FEATURE_PERFCTR_CORE))
+			return NULL;
+		fallthrough;
 	case MSR_K7_PERFCTR0 ... MSR_K7_PERFCTR3:
 		if (type != PMU_TYPE_COUNTER)
 			return NULL;

arch/x86/kvm/x86.c+36−21

@@ -271,8 +271,7 @@ static struct kmem_cache *x86_emulator_cache; · 270 unmodified lines
271	* When called, it means the previous get/set msr reached an invalid msr.	271	* When called, it means the previous get/set msr reached an invalid msr.
272	* Return true if we want to ignore/silent this failed msr access.	272	* Return true if we want to ignore/silent this failed msr access.
273	*/	273	*/
274	static bool kvm_msr_ignored_check(struct kvm_vcpu *vcpu, u32 msr,	274	static bool kvm_msr_ignored_check(u32 msr, u64 data, bool write)
275	u64 data, bool write)
276	{	275	{
277	const char *op = write ? "wrmsr" : "rdmsr";	276	const char *op = write ? "wrmsr" : "rdmsr";
278		277
@@ -1445,7 +1444,7 @@ static int do_get_msr_feature(struct kvm_vcpu vcpu, unsigned index, u64 data) · 1166 unmodified lines
1445	if (r == KVM_MSR_RET_INVALID) {	1444	if (r == KVM_MSR_RET_INVALID) {
1446	/* Unconditionally clear the output for simplicity */	1445	/* Unconditionally clear the output for simplicity */
1447	*data = 0;	1446	*data = 0;
1448	if (kvm_msr_ignored_check(vcpu, index, 0, false))	1447	if (kvm_msr_ignored_check(index, 0, false))
1449	r = 0;	1448	r = 0;
1450	}	1449	}
1451		1450
@@ -1620,7 +1619,7 @@ static int kvm_set_msr_ignored_check(struct kvm_vcpu *vcpu, · 168 unmodified lines
1620	int ret = __kvm_set_msr(vcpu, index, data, host_initiated);	1619	int ret = __kvm_set_msr(vcpu, index, data, host_initiated);
1621		1620
1622	if (ret == KVM_MSR_RET_INVALID)	1621	if (ret == KVM_MSR_RET_INVALID)
1623	if (kvm_msr_ignored_check(vcpu, index, data, true))	1622	if (kvm_msr_ignored_check(index, data, true))
1624	ret = 0;	1623	ret = 0;
1625		1624
1626	return ret;	1625	return ret;
@@ -1658,7 +1657,7 @@ static int kvm_get_msr_ignored_check(struct kvm_vcpu *vcpu, · 31 unmodified lines
1658	if (ret == KVM_MSR_RET_INVALID) {	1657	if (ret == KVM_MSR_RET_INVALID) {
1659	/* Unconditionally clear data for simplicity /	1658	/* Unconditionally clear data for simplicity /
1660	*data = 0;	1659	*data = 0;
1661	if (kvm_msr_ignored_check(vcpu, index, 0, false))	1660	if (kvm_msr_ignored_check(index, 0, false))
1662	ret = 0;	1661	ret = 0;
1663	}	1662	}
1664		1663
@@ -2329,7 +2328,7 @@ static void kvm_synchronize_tsc(struct kvm_vcpu *vcpu, u64 data) · 664 unmodified lines
2329	kvm_vcpu_write_tsc_offset(vcpu, offset);	2328	kvm_vcpu_write_tsc_offset(vcpu, offset);
2330	raw_spin_unlock_irqrestore(&kvm->arch.tsc_write_lock, flags);	2329	raw_spin_unlock_irqrestore(&kvm->arch.tsc_write_lock, flags);
2331		2330
2332	spin_lock(&kvm->arch.pvclock_gtod_sync_lock);	2331	spin_lock_irqsave(&kvm->arch.pvclock_gtod_sync_lock, flags);
2333	if (!matched) {	2332	if (!matched) {
2334	kvm->arch.nr_vcpus_matched_tsc = 0;	2333	kvm->arch.nr_vcpus_matched_tsc = 0;
2335	} else if (!already_matched) {	2334	} else if (!already_matched) {
@@ -2337,7 +2336,7 @@ static void kvm_synchronize_tsc(struct kvm_vcpu *vcpu, u64 data) · 1 unmodified line
2337	}	2336	}
2338		2337
2339	kvm_track_tsc_matching(vcpu);	2338	kvm_track_tsc_matching(vcpu);
2340	spin_unlock(&kvm->arch.pvclock_gtod_sync_lock);	2339	spin_unlock_irqrestore(&kvm->arch.pvclock_gtod_sync_lock, flags);
2341	}	2340	}
2342		2341
2343	static inline void adjust_tsc_offset_guest(struct kvm_vcpu *vcpu,	2342	static inline void adjust_tsc_offset_guest(struct kvm_vcpu *vcpu,
@@ -2559,13 +2558,16 @@ static void kvm_gen_update_masterclock(struct kvm *kvm) · 215 unmodified lines
2559	int i;	2558	int i;
2560	struct kvm_vcpu *vcpu;	2559	struct kvm_vcpu *vcpu;
2561	struct kvm_arch *ka = &kvm->arch;	2560	struct kvm_arch *ka = &kvm->arch;
		2561	unsigned long flags;
2562		2562
2563	kvm_hv_invalidate_tsc_page(kvm);	2563	kvm_hv_invalidate_tsc_page(kvm);
2564		2564
2565	spin_lock(&ka->pvclock_gtod_sync_lock);
2566	kvm_make_mclock_inprogress_request(kvm);	2565	kvm_make_mclock_inprogress_request(kvm);
		2566
2567	/* no guest entries from this point */	2567	/* no guest entries from this point */
		2568	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2568	pvclock_update_vm_gtod_copy(kvm);	2569	pvclock_update_vm_gtod_copy(kvm);
		2570	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2569		2571
2570	kvm_for_each_vcpu(i, vcpu, kvm)	2572	kvm_for_each_vcpu(i, vcpu, kvm)
2571	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);	2573	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
@@ -2573,8 +2575,6 @@ static void kvm_gen_update_masterclock(struct kvm *kvm) · 1 unmodified line
2573	/* guest entries allowed */	2575	/* guest entries allowed */
2574	kvm_for_each_vcpu(i, vcpu, kvm)	2576	kvm_for_each_vcpu(i, vcpu, kvm)
2575	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);	2577	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
2576
2577	spin_unlock(&ka->pvclock_gtod_sync_lock);
2578	#endif	2578	#endif
2579	}	2579	}
2580		2580
@@ -2582,17 +2582,18 @@ u64 get_kvmclock_ns(struct kvm *kvm) · 1 unmodified line
2582	{	2582	{
2583	struct kvm_arch *ka = &kvm->arch;	2583	struct kvm_arch *ka = &kvm->arch;
2584	struct pvclock_vcpu_time_info hv_clock;	2584	struct pvclock_vcpu_time_info hv_clock;
		2585	unsigned long flags;
2585	u64 ret;	2586	u64 ret;
2586		2587
2587	spin_lock(&ka->pvclock_gtod_sync_lock);	2588	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2588	if (!ka->use_master_clock) {	2589	if (!ka->use_master_clock) {
2589	spin_unlock(&ka->pvclock_gtod_sync_lock);	2590	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2590	return get_kvmclock_base_ns() + ka->kvmclock_offset;	2591	return get_kvmclock_base_ns() + ka->kvmclock_offset;
2591	}	2592	}
2592		2593
2593	hv_clock.tsc_timestamp = ka->master_cycle_now;	2594	hv_clock.tsc_timestamp = ka->master_cycle_now;
2594	hv_clock.system_time = ka->master_kernel_ns + ka->kvmclock_offset;	2595	hv_clock.system_time = ka->master_kernel_ns + ka->kvmclock_offset;
2595	spin_unlock(&ka->pvclock_gtod_sync_lock);	2596	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2596		2597
2597	/* both __this_cpu_read() and rdtsc() should be on the same cpu */	2598	/* both __this_cpu_read() and rdtsc() should be on the same cpu */
2598	get_cpu();	2599	get_cpu();
@@ -2686,13 +2687,13 @@ static int kvm_guest_time_update(struct kvm_vcpu *v) · 87 unmodified lines
2686	* If the host uses TSC clock, then passthrough TSC as stable	2687	* If the host uses TSC clock, then passthrough TSC as stable
2687	* to the guest.	2688	* to the guest.
2688	*/	2689	*/
2689	spin_lock(&ka->pvclock_gtod_sync_lock);	2690	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2690	use_master_clock = ka->use_master_clock;	2691	use_master_clock = ka->use_master_clock;
2691	if (use_master_clock) {	2692	if (use_master_clock) {
2692	host_tsc = ka->master_cycle_now;	2693	host_tsc = ka->master_cycle_now;
2693	kernel_ns = ka->master_kernel_ns;	2694	kernel_ns = ka->master_kernel_ns;
2694	}	2695	}
2695	spin_unlock(&ka->pvclock_gtod_sync_lock);	2696	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2696		2697
2697	/* Keep irq disabled to prevent changes to the clock */	2698	/* Keep irq disabled to prevent changes to the clock */
2698	local_irq_save(flags);	2699	local_irq_save(flags);
@@ -5726,6 +5727,7 @@ set_pit2_out: · 3027 unmodified lines
5726	}	5727	}
5727	#endif	5728	#endif
5728	case KVM_SET_CLOCK: {	5729	case KVM_SET_CLOCK: {
		5730	struct kvm_arch *ka = &kvm->arch;
5729	struct kvm_clock_data user_ns;	5731	struct kvm_clock_data user_ns;
5730	u64 now_ns;	5732	u64 now_ns;
5731		5733
@@ -5744,8 +5746,22 @@ set_pit2_out: · 12 unmodified lines
5744	* pvclock_update_vm_gtod_copy().	5746	* pvclock_update_vm_gtod_copy().
5745	*/	5747	*/
5746	kvm_gen_update_masterclock(kvm);	5748	kvm_gen_update_masterclock(kvm);
5747	now_ns = get_kvmclock_ns(kvm);	5749
5748	kvm->arch.kvmclock_offset += user_ns.clock - now_ns;	5750	/*
		5751	* This pairs with kvm_guest_time_update(): when masterclock is
		5752	* in use, we use master_kernel_ns + kvmclock_offset to set
		5753	* unsigned 'system_time' so if we use get_kvmclock_ns() (which
		5754	* is slightly ahead) here we risk going negative on unsigned
		5755	* 'system_time' when 'user_ns.clock' is very small.
		5756	*/
		5757	spin_lock_irq(&ka->pvclock_gtod_sync_lock);
		5758	if (kvm->arch.use_master_clock)
		5759	now_ns = ka->master_kernel_ns;
		5760	else
		5761	now_ns = get_kvmclock_base_ns();
		5762	ka->kvmclock_offset = user_ns.clock - now_ns;
		5763	spin_unlock_irq(&ka->pvclock_gtod_sync_lock);
		5764
5749	kvm_make_all_cpus_request(kvm, KVM_REQ_CLOCK_UPDATE);	5765	kvm_make_all_cpus_request(kvm, KVM_REQ_CLOCK_UPDATE);
5750	break;	5766	break;
5751	}	5767	}
@@ -7724,6 +7740,7 @@ static void kvm_hyperv_tsc_notifier(void) · 1972 unmodified lines
7724	struct kvm *kvm;	7740	struct kvm *kvm;
7725	struct kvm_vcpu *vcpu;	7741	struct kvm_vcpu *vcpu;
7726	int cpu;	7742	int cpu;
		7743	unsigned long flags;
7727		7744
7728	mutex_lock(&kvm_lock);	7745	mutex_lock(&kvm_lock);
7729	list_for_each_entry(kvm, &vm_list, vm_list)	7746	list_for_each_entry(kvm, &vm_list, vm_list)
@@ -7739,17 +7756,15 @@ static void kvm_hyperv_tsc_notifier(void) · 9 unmodified lines
7739	list_for_each_entry(kvm, &vm_list, vm_list) {	7756	list_for_each_entry(kvm, &vm_list, vm_list) {
7740	struct kvm_arch *ka = &kvm->arch;	7757	struct kvm_arch *ka = &kvm->arch;
7741		7758
7742	spin_lock(&ka->pvclock_gtod_sync_lock);	7759	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
7743
7744	pvclock_update_vm_gtod_copy(kvm);	7760	pvclock_update_vm_gtod_copy(kvm);
		7761	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
7745		7762
7746	kvm_for_each_vcpu(cpu, vcpu, kvm)	7763	kvm_for_each_vcpu(cpu, vcpu, kvm)
7747	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);	7764	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
7748		7765
7749	kvm_for_each_vcpu(cpu, vcpu, kvm)	7766	kvm_for_each_vcpu(cpu, vcpu, kvm)
7750	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);	7767	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
7751
7752	spin_unlock(&ka->pvclock_gtod_sync_lock);
7753	}	7768	}
7754	mutex_unlock(&kvm_lock);	7769	mutex_unlock(&kvm_lock);
7755	}	7770	}

arch/x86/kvm/x86.h+0−1

@@ -250,7 +250,6 @@ static inline bool kvm_vcpu_latch_init(struct kvm_vcpu *vcpu) · 249 unmodified lines
250	void kvm_write_wall_clock(struct kvm *kvm, gpa_t wall_clock, int sec_hi_ofs);	250	void kvm_write_wall_clock(struct kvm *kvm, gpa_t wall_clock, int sec_hi_ofs);
251	void kvm_inject_realmode_interrupt(struct kvm_vcpu *vcpu, int irq, int inc_eip);	251	void kvm_inject_realmode_interrupt(struct kvm_vcpu *vcpu, int irq, int inc_eip);
252		252
253	void kvm_write_tsc(struct kvm_vcpu vcpu, struct msr_data msr);
254	u64 get_kvmclock_ns(struct kvm *kvm);	253	u64 get_kvmclock_ns(struct kvm *kvm);
255		254
256	int kvm_read_guest_virt(struct kvm_vcpu *vcpu,	255	int kvm_read_guest_virt(struct kvm_vcpu *vcpu,

arch/x86/mm/mem_encrypt.c+1−1

@@ -262,7 +262,7 @@ static void __init __set_clr_pte_enc(pte_t *kpte, int level, bool enc) · 261 unmodified lines
262	if (pgprot_val(old_prot) == pgprot_val(new_prot))	262	if (pgprot_val(old_prot) == pgprot_val(new_prot))
263	return;	263	return;
264		264
265	pa = pfn << page_level_shift(level);	265	pa = pfn << PAGE_SHIFT;
266	size = page_level_size(level);	266	size = page_level_size(level);
267		267
268	/*	268	/*

arch/x86/net/bpf_jit_comp.c+25−6

  * add rsp, 8                      // skip eth_type_trans's frame
  * ret                             // return to its caller
  */
-int arch_prepare_bpf_trampoline(void *image, void *image_end,
+int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *image_end,
 				const struct btf_func_model *m, u32 flags,
 				struct bpf_tramp_progs *tprogs,
 				void *orig_call)
 	save_regs(m, &prog, nr_args, stack_size);
+	if (flags & BPF_TRAMP_F_CALL_ORIG) {
+		/* arg1: mov rdi, im */
+		emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);
+		if (emit_call(&prog, __bpf_tramp_enter, prog)) {
+			ret = -EINVAL;
+			goto cleanup;
+		}
+	}
 	if (fentry->nr_progs)
 		if (invoke_bpf(m, &prog, fentry, stack_size))
 			return -EINVAL;
 	}
 	if (flags & BPF_TRAMP_F_CALL_ORIG) {
-		if (fentry->nr_progs || fmod_ret->nr_progs)
+		restore_regs(m, &prog, nr_args, stack_size);
-			restore_regs(m, &prog, nr_args, stack_size);
 		/* call original function */
 		if (emit_call(&prog, orig_call, prog)) {
 		}
 		/* remember return value in a stack for bpf prog to access */
 		emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);
+		im->ip_after_call = prog;
+		memcpy(prog, ideal_nops[NOP_ATOMIC5], X86_PATCH_SIZE);
+		prog += X86_PATCH_SIZE;
 	}
 	if (fmod_ret->nr_progs) {
 	 * the return value is only updated on the stack and still needs to be
 	 * restored to R0.
 	 */
-	if (flags & BPF_TRAMP_F_CALL_ORIG)
+	if (flags & BPF_TRAMP_F_CALL_ORIG) {
+		im->ip_epilogue = prog;
+		/* arg1: mov rdi, im */
+		emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);
+		if (emit_call(&prog, __bpf_tramp_exit, prog)) {
+			ret = -EINVAL;
+			goto cleanup;
+		}
 		/* restore original return value back into RAX */
 		emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8);
+	}
 	EMIT1(0x5B); /* pop rbx */
 	EMIT1(0xC9); /* leave */
 		padding = true;
 		goto skip_init_addrs;
 	}
-	addrs = kmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
+	addrs = kvmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
 	if (!addrs) {
 		prog = orig_prog;
 		goto out_addrs;
 		if (image)
 			bpf_prog_fill_jited_linfo(prog, addrs + 1);
 out_addrs:
-		kfree(addrs);
+		kvfree(addrs);
 		kfree(jit_data);
 		prog->aux->jit_data = NULL;
 	}

arch/x86/xen/p2m.c+2−5

 unsigned long xen_max_p2m_pfn __read_mostly;
 EXPORT_SYMBOL_GPL(xen_max_p2m_pfn);
-#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG_LIMIT
+#ifdef CONFIG_XEN_MEMORY_HOTPLUG_LIMIT
-#define P2M_LIMIT CONFIG_XEN_BALLOON_MEMORY_HOTPLUG_LIMIT
+#define P2M_LIMIT CONFIG_XEN_MEMORY_HOTPLUG_LIMIT
 #else
 #define P2M_LIMIT 0
 #endif
 	xen_p2m_last_pfn = xen_max_p2m_pfn;
 	p2m_limit = (phys_addr_t)P2M_LIMIT * 1024 * 1024 * 1024 / PAGE_SIZE;
-	if (!p2m_limit && IS_ENABLED(CONFIG_XEN_UNPOPULATED_ALLOC))
-		p2m_limit = xen_start_info->nr_pages * XEN_EXTRA_MEM_RATIO;
 	vm.flags = VM_ALLOC;
 	vm.size = ALIGN(sizeof(unsigned long) * max(xen_max_p2m_pfn, p2m_limit),
 			PMD_SIZE * PMDS_PER_MID_PAGE);

arch/x86/xen/setup.c+14−2

 } xen_remap_buf __initdata __aligned(PAGE_SIZE);
 static unsigned long xen_remap_mfn __initdata = INVALID_P2M_ENTRY;
+/*
+ * The maximum amount of extra memory compared to the base size.  The
+ * main scaling factor is the size of struct page.  At extreme ratios
+ * of base:extra, all the base memory can be filled with page
+ * structures for the extra memory, leaving no space for anything
+ * else.
+ *
+ * 10x seems like a reasonable balance between scaling flexibility and
+ * leaving a practically usable system.
+ */
+#define EXTRA_MEM_RATIO		(10)
 static bool xen_512gb_limit __initdata = IS_ENABLED(CONFIG_XEN_512GB);
 static void __init xen_parse_512gb(void)
 		extra_pages += max_pages - max_pfn;
 	/*
-	 * Clamp the amount of extra memory to a XEN_EXTRA_MEM_RATIO
+	 * Clamp the amount of extra memory to a EXTRA_MEM_RATIO
 	 * factor the base size.
 	 *
 	 * Make sure we have no memory above max_pages, as this area
 	 * isn't handled by the p2m management.
 	 */
-	extra_pages = min3(XEN_EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)),
+	extra_pages = min3(EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)),
 			   extra_pages, max_pages - max_pfn);
 	i = 0;
 	addr = xen_e820_table.entries[0].addr;

arch/xtensa/kernel/coprocessor.S+33−31

 	LOAD_CP_REGS_TAB(6)
 	LOAD_CP_REGS_TAB(7)
-/*
- * coprocessor_flush(struct thread_info*, index)
- *                             a2        a3
- *
- * Save coprocessor registers for coprocessor 'index'.
- * The register values are saved to or loaded from the coprocessor area
- * inside the task_info structure.
- *
- * Note that this function doesn't update the coprocessor_owner information!
- *
- */
-ENTRY(coprocessor_flush)
-	/* reserve 4 bytes on stack to save a0 */
-	abi_entry(4)
-	s32i	a0, a1, 0
-	movi	a0, .Lsave_cp_regs_jump_table
-	addx8	a3, a3, a0
-	l32i	a4, a3, 4
-	l32i	a3, a3, 0
-	add	a2, a2, a4
-	beqz	a3, 1f
-	callx0	a3
-1:	l32i	a0, a1, 0
-	abi_ret(4)
-ENDPROC(coprocessor_flush)
 /*
  * Entry condition:
  *
 ENDPROC(fast_coprocessor)
+	.text
+/*
+ * coprocessor_flush(struct thread_info*, index)
+ *                             a2        a3
+ *
+ * Save coprocessor registers for coprocessor 'index'.
+ * The register values are saved to or loaded from the coprocessor area
+ * inside the task_info structure.
+ *
+ * Note that this function doesn't update the coprocessor_owner information!
+ *
+ */
+ENTRY(coprocessor_flush)
+	/* reserve 4 bytes on stack to save a0 */
+	abi_entry(4)
+	s32i	a0, a1, 0
+	movi	a0, .Lsave_cp_regs_jump_table
+	addx8	a3, a3, a0
+	l32i	a4, a3, 4
+	l32i	a3, a3, 0
+	add	a2, a2, a4
+	beqz	a3, 1f
+	callx0	a3
+1:	l32i	a0, a1, 0
+	abi_ret(4)
+ENDPROC(coprocessor_flush)
 	.data
 ENTRY(coprocessor_owner)

arch/xtensa/mm/fault.c+4−1

 	 */
 	fault = handle_mm_fault(vma, address, flags, regs);
-	if (fault_signal_pending(fault, regs))
+	if (fault_signal_pending(fault, regs)) {
+		if (!user_mode(regs))
+			goto bad_page_fault;
 		return;
+	}
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)

block/bio.c+19−4

 {
 	struct bio *parent = bio->bi_private;
-	if (!parent->bi_status)
+	if (bio->bi_status && !parent->bi_status)
 		parent->bi_status = bio->bi_status;
 	bio_put(bio);
 	return parent;
 }
 EXPORT_SYMBOL_GPL(bio_release_pages);
-static int bio_iov_bvec_set(struct bio *bio, struct iov_iter *iter)
+static void __bio_iov_bvec_set(struct bio *bio, struct iov_iter *iter)
 {
 	WARN_ON_ONCE(bio->bi_max_vecs);
 	bio->bi_iter.bi_size = iter->count;
 	bio_set_flag(bio, BIO_NO_PAGE_REF);
 	bio_set_flag(bio, BIO_CLONED);
+}
+static int bio_iov_bvec_set(struct bio *bio, struct iov_iter *iter)
+{
+	__bio_iov_bvec_set(bio, iter);
 	iov_iter_advance(iter, iter->count);
 	return 0;
 }
+static int bio_iov_bvec_set_append(struct bio *bio, struct iov_iter *iter)
+{
+	struct request_queue *q = bio->bi_bdev->bd_disk->queue;
+	struct iov_iter i = *iter;
+	iov_iter_truncate(&i, queue_max_zone_append_sectors(q) << 9);
+	__bio_iov_bvec_set(bio, &i);
+	iov_iter_advance(iter, i.count);
+	return 0;
+}
 #define PAGE_PTRS_PER_BVEC     (sizeof(struct bio_vec) / sizeof(struct page *))
 /**
 	int ret = 0;
 	if (iov_iter_is_bvec(iter)) {
-		if (WARN_ON_ONCE(bio_op(bio) == REQ_OP_ZONE_APPEND))
+		if (bio_op(bio) == REQ_OP_ZONE_APPEND)
-			return -EINVAL;
+			return bio_iov_bvec_set_append(bio, iter);
 		return bio_iov_bvec_set(bio, iter);
 	}

block/blk-merge.c+8−0

@@ -382,6 +382,14 @@ unsigned int blk_recalc_rq_segments(struct request *rq) · 381 unmodified lines
382	switch (bio_op(rq->bio)) {	382	switch (bio_op(rq->bio)) {
383	case REQ_OP_DISCARD:	383	case REQ_OP_DISCARD:
384	case REQ_OP_SECURE_ERASE:	384	case REQ_OP_SECURE_ERASE:
		385	if (queue_max_discard_segments(rq->q) > 1) {
		386	struct bio *bio = rq->bio;
		387
		388	for_each_bio(bio)
		389	nr_phys_segs++;
		390	return nr_phys_segs;
		391	}
		392	return 1;
385	case REQ_OP_WRITE_ZEROES:	393	case REQ_OP_WRITE_ZEROES:
386	return 0;	394	return 0;
387	case REQ_OP_WRITE_SAME:	395	case REQ_OP_WRITE_SAME:

block/blk-mq-debugfs.c+0−1

@@ -302,7 +302,6 @@ static const char *const rqf_name[] = { · 301 unmodified lines
302	RQF_NAME(QUIET),	302	RQF_NAME(QUIET),
303	RQF_NAME(ELVPRIV),	303	RQF_NAME(ELVPRIV),
304	RQF_NAME(IO_STAT),	304	RQF_NAME(IO_STAT),
305	RQF_NAME(ALLOCED),
306	RQF_NAME(PM),	305	RQF_NAME(PM),
307	RQF_NAME(HASHED),	306	RQF_NAME(HASHED),
308	RQF_NAME(STATS),	307	RQF_NAME(STATS),

block/partitions/core.c+7−0

@@ -322,6 +322,13 @@ static struct block_device add_partition(struct gendisk disk, int partno, · 321 unmodified lines
322	const char *dname;	322	const char *dname;
323	int err;	323	int err;
324		324
		325	/*
		326	* disk_max_parts() won't be zero, either GENHD_FL_EXT_DEVT is set
		327	* or 'minors' is passed to alloc_disk().
		328	*/
		329	if (partno >= disk_max_parts(disk))
		330	return ERR_PTR(-EINVAL);
		331
325	/*	332	/*
326	* Partitions are not supported on zoned block devices that are used as	333	* Partitions are not supported on zoned block devices that are used as
327	* such.	334	* such.

drivers/acpi/acpica/nsaccess.c+1−2

 		 * just create and link the new node(s) here.
 		 */
 		new_node =
-		    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_namespace_node));
+		    acpi_ns_create_node(*ACPI_CAST_PTR(u32, init_val->name));
 		if (!new_node) {
 			status = AE_NO_MEMORY;
 			goto unlock_and_exit;
 		}
-		ACPI_COPY_NAMESEG(new_node->name.ascii, init_val->name);
 		new_node->descriptor_type = ACPI_DESC_TYPE_NAMED;
 		new_node->type = init_val->type;

drivers/acpi/internal.h+5−1

 #ifndef _ACPI_INTERNAL_H_
 #define _ACPI_INTERNAL_H_
+#include <linux/idr.h>
 #define PREFIX "ACPI: "
 int early_acpi_osi_init(void);
 extern struct list_head acpi_bus_id_list;
+#define ACPI_MAX_DEVICE_INSTANCES	4096
 struct acpi_device_bus_id {
 	const char *bus_id;
-	unsigned int instance_no;
+	struct ida instance_ida;
 	struct list_head node;
 };

drivers/acpi/processor_idle.c+7−0

  */
 #ifdef CONFIG_X86
 #include <asm/apic.h>
+#include <asm/cpu.h>
 #endif
 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
 			wait_for_freeze();
 		} else
 			return -ENODEV;
+#if defined(CONFIG_X86) && defined(CONFIG_HOTPLUG_CPU)
+		/* If NMI wants to wake up CPU0, start CPU0. */
+		if (wakeup_cpu0())
+			start_cpu0();
+#endif
 	}
 	/* Never reached */

drivers/acpi/scan.c+39−6

 	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
 		if (!strcmp(acpi_device_bus_id->bus_id,
 			    acpi_device_hid(device))) {
-			if (acpi_device_bus_id->instance_no > 0)
+			ida_simple_remove(&acpi_device_bus_id->instance_ida, device->pnp.instance_no);
-				acpi_device_bus_id->instance_no--;
+			if (ida_is_empty(&acpi_device_bus_id->instance_ida)) {
-			else {
 				list_del(&acpi_device_bus_id->node);
 				kfree_const(acpi_device_bus_id->bus_id);
 				kfree(acpi_device_bus_id);
 	return NULL;
 }
+static int acpi_device_set_name(struct acpi_device *device,
+				struct acpi_device_bus_id *acpi_device_bus_id)
+{
+	struct ida *instance_ida = &acpi_device_bus_id->instance_ida;
+	int result;
+	result = ida_simple_get(instance_ida, 0, ACPI_MAX_DEVICE_INSTANCES, GFP_KERNEL);
+	if (result < 0)
+		return result;
+	device->pnp.instance_no = result;
+	dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, result);
+	return 0;
+}
 int acpi_device_add(struct acpi_device *device,
 		    void (*release)(struct device *))
 {
 	acpi_device_bus_id = acpi_device_bus_id_match(acpi_device_hid(device));
 	if (acpi_device_bus_id) {
-		acpi_device_bus_id->instance_no++;
+		result = acpi_device_set_name(device, acpi_device_bus_id);
+		if (result)
+			goto err_unlock;
 	} else {
 		acpi_device_bus_id = kzalloc(sizeof(*acpi_device_bus_id),
 					     GFP_KERNEL);
 			goto err_unlock;
 		}
+		ida_init(&acpi_device_bus_id->instance_ida);
+		result = acpi_device_set_name(device, acpi_device_bus_id);
+		if (result) {
+			kfree(acpi_device_bus_id);
+			goto err_unlock;
+		}
 		list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
 	}
-	dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 	if (device->parent)
 		list_add_tail(&device->node, &device->parent->children);
 	device_initialize(&device->dev);
 	dev_set_uevent_suppress(&device->dev, true);
 	acpi_init_coherency(device);
+	/* Assume there are unmet deps to start with. */
+	device->dep_unmet = 1;
 }
 void acpi_device_add_finalize(struct acpi_device *device)
 {
 	struct acpi_dep_data *dep;
+	adev->dep_unmet = 0;
 	mutex_lock(&acpi_dep_list_lock);
 	list_for_each_entry(dep, &acpi_dep_list, node) {
 		return AE_CTRL_DEPTH;
 	acpi_scan_init_hotplug(device);
-	if (!check_dep)
+	/*
+	 * If check_dep is true at this point, the device has no dependencies,
+	 * or the creation of the device object would have been postponed above.
+	 */
+	if (check_dep)
+		device->dep_unmet = 0;
+	else
 		acpi_scan_dep_init(device);
 out:

drivers/acpi/tables.c+39−3

@@ -780,7 +780,7 @@ acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, · 779 unmodified lines
780	}	780	}
781		781
782	/*	782	/*
783	* acpi_table_init()	783	* acpi_locate_initial_tables()
784	*	784	*
785	* find RSDP, find and checksum SDT/XSDT.	785	* find RSDP, find and checksum SDT/XSDT.
786	* checksum all tables, print SDT/XSDT	786	* checksum all tables, print SDT/XSDT
@@ -788,7 +788,7 @@ acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, · 1 unmodified line
788	* result: sdt_entry[] is initialized	788	* result: sdt_entry[] is initialized
789	*/	789	*/
790		790
791	int __init acpi_table_init(void)	791	int __init acpi_locate_initial_tables(void)
792	{	792	{
793	acpi_status status;	793	acpi_status status;
794		794
@@ -803,9 +803,45 @@ int __init acpi_table_init(void) · 8 unmodified lines
803	status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0);	803	status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0);
804	if (ACPI_FAILURE(status))	804	if (ACPI_FAILURE(status))
805	return -EINVAL;	805	return -EINVAL;
806	acpi_table_initrd_scan();
807		806
		807	return 0;
		808	}
		809
		810	void __init acpi_reserve_initial_tables(void)
		811	{
		812	int i;
		813
		814	for (i = 0; i < ACPI_MAX_TABLES; i++) {
		815	struct acpi_table_desc *table_desc = &initial_tables[i];
		816	u64 start = table_desc->address;
		817	u64 size = table_desc->length;
		818
		819	if (!start \|\| !size)
		820	break;
		821
		822	pr_info("Reserving %4s table memory at [mem 0x%llx-0x%llx]\n",
		823	table_desc->signature.ascii, start, start + size - 1);
		824
		825	memblock_reserve(start, size);
		826	}
		827	}
		828
		829	void __init acpi_table_init_complete(void)
		830	{
		831	acpi_table_initrd_scan();
808	check_multiple_madt();	832	check_multiple_madt();
		833	}
		834
		835	int __init acpi_table_init(void)
		836	{
		837	int ret;
		838
		839	ret = acpi_locate_initial_tables();
		840	if (ret)
		841	return ret;
		842
		843	acpi_table_init_complete();
		844
809	return 0;	845	return 0;
810	}	846	}
811		847

drivers/acpi/video_detect.c+1−0

@@ -147,6 +147,7 @@ static const struct dmi_system_id video_detect_dmi_table[] = { · 146 unmodified lines
147	},	147	},
148	},	148	},
149	{	149	{
		150	.callback = video_detect_force_vendor,
150	.ident = "Sony VPCEH3U1E",	151	.ident = "Sony VPCEH3U1E",
151	.matches = {	152	.matches = {
152	DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),	153	DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),

drivers/auxdisplay/charlcd.c+8−10

 	char c;
 	for (; count-- > 0; (*ppos)++, tmp++) {
-		if (!in_interrupt() && (((count + 1) & 0x1f) == 0))
+		if (((count + 1) & 0x1f) == 0) {
 			/*
-			 * let's be a little nice with other processes
+			 * charlcd_write() is invoked as a VFS->write() callback
-			 * that need some CPU
+			 * and as such it is always invoked from preemptible
+			 * context and may sleep.
 			 */
-			schedule();
+			cond_resched();
+		}
 		if (get_user(c, tmp))
 			return -EFAULT;
 	int count = strlen(s);
 	for (; count-- > 0; tmp++) {
-		if (!in_interrupt() && (((count + 1) & 0x1f) == 0))
+		if (((count + 1) & 0x1f) == 0)
-			/*
+			cond_resched();
-			 * let's be a little nice with other processes
-			 * that need some CPU
-			 */
-			schedule();
 		charlcd_write_char(lcd, *tmp);
 	}

drivers/base/dd.c+3−0

@@ -97,6 +97,9 @@ static void deferred_probe_work_func(struct work_struct *work) · 96 unmodified lines
97		97
98	get_device(dev);	98	get_device(dev);
99		99
		100	kfree(dev->p->deferred_probe_reason);
		101	dev->p->deferred_probe_reason = NULL;
		102
100	/*	103	/*
101	* Drop the mutex while probing each device; the probe path may	104	* Drop the mutex while probing each device; the probe path may
102	* manipulate the deferred list	105	* manipulate the deferred list

drivers/base/power/runtime.c+47−8

 	return 0;
 }
-static void rpm_put_suppliers(struct device *dev)
+static void __rpm_put_suppliers(struct device *dev, bool try_to_suspend)
 {
 	struct device_link *link;
 				device_links_read_lock_held()) {
 		while (refcount_dec_not_one(&link->rpm_active))
-			pm_runtime_put(link->supplier);
+			pm_runtime_put_noidle(link->supplier);
+		if (try_to_suspend)
+			pm_request_idle(link->supplier);
 	}
 }
+static void rpm_put_suppliers(struct device *dev)
+{
+	__rpm_put_suppliers(dev, true);
+}
+static void rpm_suspend_suppliers(struct device *dev)
+{
+	struct device_link *link;
+	int idx = device_links_read_lock();
+	list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
+				device_links_read_lock_held())
+		pm_request_idle(link->supplier);
+	device_links_read_unlock(idx);
+}
 /**
  * __rpm_callback - Run a given runtime PM callback for a given device.
  * @cb: Runtime PM callback to run.
 			idx = device_links_read_lock();
 			retval = rpm_get_suppliers(dev);
-			if (retval)
+			if (retval) {
+				rpm_put_suppliers(dev);
 				goto fail;
+			}
 			device_links_read_unlock(idx);
 		}
 		    || (dev->power.runtime_status == RPM_RESUMING && retval))) {
 			idx = device_links_read_lock();
- fail:
+			__rpm_put_suppliers(dev, false);
-			rpm_put_suppliers(dev);
+fail:
 			device_links_read_unlock(idx);
 		}
 		goto out;
 	}
+	if (dev->power.irq_safe)
+		goto out;
 	/* Maybe the parent is now able to suspend. */
-	if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {
+	if (parent && !parent->power.ignore_children) {
 		spin_unlock(&dev->power.lock);
 		spin_lock(&parent->power.lock);
 		spin_lock(&dev->power.lock);
 	}
+	/* Maybe the suppliers are now able to suspend. */
+	if (dev->power.links_count > 0) {
+		spin_unlock_irq(&dev->power.lock);
+		rpm_suspend_suppliers(dev);
+		spin_lock_irq(&dev->power.lock);
+	}
  out:
 	trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);
 				device_links_read_lock_held())
 		if (link->flags & DL_FLAG_PM_RUNTIME) {
 			link->supplier_preactivated = true;
-			refcount_inc(&link->rpm_active);
 			pm_runtime_get_sync(link->supplier);
+			refcount_inc(&link->rpm_active);
 		}
 	device_links_read_unlock(idx);
 void pm_runtime_put_suppliers(struct device *dev)
 {
 	struct device_link *link;
+	unsigned long flags;
+	bool put;
 	int idx;
 	idx = device_links_read_lock();
 				device_links_read_lock_held())
 		if (link->supplier_preactivated) {
 			link->supplier_preactivated = false;
-			if (refcount_dec_not_one(&link->rpm_active))
+			spin_lock_irqsave(&dev->power.lock, flags);
+			put = pm_runtime_status_suspended(dev) &&
+			      refcount_dec_not_one(&link->rpm_active);
+			spin_unlock_irqrestore(&dev->power.lock, flags);
+			if (put)
 				pm_runtime_put(link->supplier);
 		}

drivers/block/null_blk/main.c+21−5

@@ -1369,10 +1369,13 @@ static blk_status_t null_handle_cmd(struct nullb_cmd *cmd, sector_t sector, · 1368 unmodified lines
1369	}	1369	}
1370		1370
1371	if (dev->zoned)	1371	if (dev->zoned)
1372	cmd->error = null_process_zoned_cmd(cmd, op,	1372	sts = null_process_zoned_cmd(cmd, op, sector, nr_sectors);
1373	sector, nr_sectors);
1374	else	1373	else
1375	cmd->error = null_process_cmd(cmd, op, sector, nr_sectors);	1374	sts = null_process_cmd(cmd, op, sector, nr_sectors);
		1375
		1376	/* Do not overwrite errors (e.g. timeout errors) */
		1377	if (cmd->error == BLK_STS_OK)
		1378	cmd->error = sts;
1376		1379
1377	out:	1380	out:
1378	nullb_complete_cmd(cmd);	1381	nullb_complete_cmd(cmd);
@@ -1451,8 +1454,20 @@ static bool should_requeue_request(struct request *rq) · 72 unmodified lines
1451		1454
1452	static enum blk_eh_timer_return null_timeout_rq(struct request *rq, bool res)	1455	static enum blk_eh_timer_return null_timeout_rq(struct request *rq, bool res)
1453	{	1456	{
		1457	struct nullb_cmd *cmd = blk_mq_rq_to_pdu(rq);
		1458
1454	pr_info("rq %p timed out\n", rq);	1459	pr_info("rq %p timed out\n", rq);
1455	blk_mq_complete_request(rq);	1460
		1461	/*
		1462	* If the device is marked as blocking (i.e. memory backed or zoned
		1463	* device), the submission path may be blocked waiting for resources
		1464	* and cause real timeouts. For these real timeouts, the submission
		1465	* path will complete the request using blk_mq_complete_request().
		1466	* Only fake timeouts need to execute blk_mq_complete_request() here.
		1467	*/
		1468	cmd->error = BLK_STS_TIMEOUT;
		1469	if (cmd->fake_timeout)
		1470	blk_mq_complete_request(rq);
1456	return BLK_EH_DONE;	1471	return BLK_EH_DONE;
1457	}	1472	}
1458		1473
@@ -1473,6 +1488,7 @@ static blk_status_t null_queue_rq(struct blk_mq_hw_ctx *hctx, · 14 unmodified lines
1473	cmd->rq = bd->rq;	1488	cmd->rq = bd->rq;
1474	cmd->error = BLK_STS_OK;	1489	cmd->error = BLK_STS_OK;
1475	cmd->nq = nq;	1490	cmd->nq = nq;
		1491	cmd->fake_timeout = should_timeout_request(bd->rq);
1476		1492
1477	blk_mq_start_request(bd->rq);	1493	blk_mq_start_request(bd->rq);
1478		1494
@@ -1489,7 +1505,7 @@ static blk_status_t null_queue_rq(struct blk_mq_hw_ctx *hctx, · 10 unmodified lines
1489	return BLK_STS_OK;	1505	return BLK_STS_OK;
1490	}	1506	}
1491	}	1507	}
1492	if (should_timeout_request(bd->rq))	1508	if (cmd->fake_timeout)
1493	return BLK_STS_OK;	1509	return BLK_STS_OK;
1494		1510
1495	return null_handle_cmd(cmd, sector, nr_sectors, req_op(bd->rq));	1511	return null_handle_cmd(cmd, sector, nr_sectors, req_op(bd->rq));

drivers/block/null_blk/null_blk.h+1−0

@@ -22,6 +22,7 @@ struct nullb_cmd { · 21 unmodified lines
22	blk_status_t error;	22	blk_status_t error;
23	struct nullb_queue *nq;	23	struct nullb_queue *nq;
24	struct hrtimer timer;	24	struct hrtimer timer;
		25	bool fake_timeout;
25	};	26	};
26		27
27	struct nullb_queue {	28	struct nullb_queue {

drivers/block/xen-blkback/blkback.c+1−1

@@ -891,7 +891,7 @@ next: · 890 unmodified lines
891	out:	891	out:
892	for (i = last_map; i < num; i++) {	892	for (i = last_map; i < num; i++) {
893	/* Don't zap current batch's valid persistent grants. */	893	/* Don't zap current batch's valid persistent grants. */
894	if(i >= last_map + segs_to_map)	894	if(i >= map_until)
895	pages[i]->persistent_gnt = NULL;	895	pages[i]->persistent_gnt = NULL;
896	pages[i]->handle = BLKBACK_INVALID_HANDLE;	896	pages[i]->handle = BLKBACK_INVALID_HANDLE;
897	}	897	}

drivers/bus/omap_l3_noc.c+2−2

@@ -285,7 +285,7 @@ static int omap_l3_probe(struct platform_device *pdev) · 284 unmodified lines
285	*/	285	*/
286	l3->debug_irq = platform_get_irq(pdev, 0);	286	l3->debug_irq = platform_get_irq(pdev, 0);
287	ret = devm_request_irq(l3->dev, l3->debug_irq, l3_interrupt_handler,	287	ret = devm_request_irq(l3->dev, l3->debug_irq, l3_interrupt_handler,
288	0x0, "l3-dbg-irq", l3);	288	IRQF_NO_THREAD, "l3-dbg-irq", l3);
289	if (ret) {	289	if (ret) {
290	dev_err(l3->dev, "request_irq failed for %d\n",	290	dev_err(l3->dev, "request_irq failed for %d\n",
291	l3->debug_irq);	291	l3->debug_irq);
@@ -294,7 +294,7 @@ static int omap_l3_probe(struct platform_device *pdev) · 2 unmodified lines
294		294
295	l3->app_irq = platform_get_irq(pdev, 1);	295	l3->app_irq = platform_get_irq(pdev, 1);
296	ret = devm_request_irq(l3->dev, l3->app_irq, l3_interrupt_handler,	296	ret = devm_request_irq(l3->dev, l3->app_irq, l3_interrupt_handler,
297	0x0, "l3-app-irq", l3);	297	IRQF_NO_THREAD, "l3-app-irq", l3);
298	if (ret)	298	if (ret)
299	dev_err(l3->dev, "request_irq failed for %d\n", l3->app_irq);	299	dev_err(l3->dev, "request_irq failed for %d\n", l3->app_irq);
300		300

drivers/bus/ti-sysc.c+3−1

@@ -3053,7 +3053,9 @@ static int sysc_remove(struct platform_device *pdev) · 3052 unmodified lines
3053		3053
3054	pm_runtime_put_sync(&pdev->dev);	3054	pm_runtime_put_sync(&pdev->dev);
3055	pm_runtime_disable(&pdev->dev);	3055	pm_runtime_disable(&pdev->dev);
3056	reset_control_assert(ddata->rsts);	3056
		3057	if (!reset_control_status(ddata->rsts))
		3058	reset_control_assert(ddata->rsts);
3057		3059
3058	unprepare:	3060	unprepare:
3059	sysc_unprepare(ddata);	3061	sysc_unprepare(ddata);

drivers/clk/qcom/clk-rcg2.c+9−8

@@ -730,7 +730,8 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 729 unmodified lines
730	struct clk_rate_request parent_req = { };	730	struct clk_rate_request parent_req = { };
731	struct clk_rcg2_gfx3d *cgfx = to_clk_rcg2_gfx3d(hw);	731	struct clk_rcg2_gfx3d *cgfx = to_clk_rcg2_gfx3d(hw);
732	struct clk_hw xo, p0, p1, p2;	732	struct clk_hw xo, p0, p1, p2;
733	unsigned long request, p0_rate;	733	unsigned long p0_rate;
		734	u8 mux_div = cgfx->div;
734	int ret;	735	int ret;
735		736
736	p0 = cgfx->hws[0];	737	p0 = cgfx->hws[0];
@@ -750,14 +751,15 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 13 unmodified lines
750	return 0;	751	return 0;
751	}	752	}
752		753
753	request = req->rate;	754	if (mux_div == 0)
754	if (cgfx->div > 1)	755	mux_div = 1;
755	parent_req.rate = request = request * cgfx->div;	756
		757	parent_req.rate = req->rate * mux_div;
756		758
757	/* This has to be a fixed rate PLL */	759	/* This has to be a fixed rate PLL */
758	p0_rate = clk_hw_get_rate(p0);	760	p0_rate = clk_hw_get_rate(p0);
759		761
760	if (request == p0_rate) {	762	if (parent_req.rate == p0_rate) {
761	req->rate = req->best_parent_rate = p0_rate;	763	req->rate = req->best_parent_rate = p0_rate;
762	req->best_parent_hw = p0;	764	req->best_parent_hw = p0;
763	return 0;	765	return 0;
@@ -765,7 +767,7 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 1 unmodified line
765		767
766	if (req->best_parent_hw == p0) {	768	if (req->best_parent_hw == p0) {
767	/* Are we going back to a previously used rate? */	769	/* Are we going back to a previously used rate? */
768	if (clk_hw_get_rate(p2) == request)	770	if (clk_hw_get_rate(p2) == parent_req.rate)
769	req->best_parent_hw = p2;	771	req->best_parent_hw = p2;
770	else	772	else
771	req->best_parent_hw = p1;	773	req->best_parent_hw = p1;
@@ -780,8 +782,7 @@ static int clk_gfx3d_determine_rate(struct clk_hw *hw, · 8 unmodified lines
780	return ret;	782	return ret;
781		783
782	req->rate = req->best_parent_rate = parent_req.rate;	784	req->rate = req->best_parent_rate = parent_req.rate;
783	if (cgfx->div > 1)	785	req->rate /= mux_div;
784	req->rate /= cgfx->div;
785		786
786	return 0;	787	return 0;
787	}	788	}

drivers/clk/qcom/clk-rpmh.c+5−2

 	.num_clks = ARRAY_SIZE(sm8350_rpmh_clocks),
 };
+/* Resource name must match resource id present in cmd-db */
+DEFINE_CLK_RPMH_ARC(sc7280, bi_tcxo, bi_tcxo_ao, "xo.lvl", 0x3, 4);
 static struct clk_hw *sc7280_rpmh_clocks[] = {
-	[RPMH_CXO_CLK]      = &sdm845_bi_tcxo.hw,
+	[RPMH_CXO_CLK]      = &sc7280_bi_tcxo.hw,
-	[RPMH_CXO_CLK_A]    = &sdm845_bi_tcxo_ao.hw,
+	[RPMH_CXO_CLK_A]    = &sc7280_bi_tcxo_ao.hw,
 	[RPMH_LN_BB_CLK2]   = &sdm845_ln_bb_clk2.hw,
 	[RPMH_LN_BB_CLK2_A] = &sdm845_ln_bb_clk2_ao.hw,
 	[RPMH_RF_CLK1]      = &sdm845_rf_clk1.hw,

drivers/clk/qcom/gcc-sc7180.c+2−2

@@ -620,7 +620,7 @@ static struct clk_rcg2 gcc_sdcc1_apps_clk_src = { · 619 unmodified lines
620	.name = "gcc_sdcc1_apps_clk_src",	620	.name = "gcc_sdcc1_apps_clk_src",
621	.parent_data = gcc_parent_data_1,	621	.parent_data = gcc_parent_data_1,
622	.num_parents = 5,	622	.num_parents = 5,
623	.ops = &clk_rcg2_ops,	623	.ops = &clk_rcg2_floor_ops,
624	},	624	},
625	};	625	};
626		626
@@ -642,7 +642,7 @@ static struct clk_rcg2 gcc_sdcc1_ice_core_clk_src = { · 15 unmodified lines
642	.name = "gcc_sdcc1_ice_core_clk_src",	642	.name = "gcc_sdcc1_ice_core_clk_src",
643	.parent_data = gcc_parent_data_0,	643	.parent_data = gcc_parent_data_0,
644	.num_parents = 4,	644	.num_parents = 4,
645	.ops = &clk_rcg2_floor_ops,	645	.ops = &clk_rcg2_ops,
646	},	646	},
647	};	647	};
648		648

drivers/cpufreq/freq_table.c+2−2

@@ -267,7 +267,7 @@ struct freq_attr cpufreq_freq_attr_##_name##_freqs = \ · 266 unmodified lines
267	__ATTR_RO(_name##_frequencies)	267	__ATTR_RO(_name##_frequencies)
268		268
269	/*	269	/*
270	* show_scaling_available_frequencies - show available normal frequencies for	270	* scaling_available_frequencies_show - show available normal frequencies for
271	* the specified CPU	271	* the specified CPU
272	*/	272	*/
273	static ssize_t scaling_available_frequencies_show(struct cpufreq_policy *policy,	273	static ssize_t scaling_available_frequencies_show(struct cpufreq_policy *policy,
@@ -279,7 +279,7 @@ cpufreq_attr_available_freq(scaling_available); · 5 unmodified lines
279	EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);	279	EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
280		280
281	/*	281	/*
282	* show_available_boost_freqs - show available boost frequencies for	282	* scaling_boost_frequencies_show - show available boost frequencies for
283	* the specified CPU	283	* the specified CPU
284	*/	284	*/
285	static ssize_t scaling_boost_frequencies_show(struct cpufreq_policy *policy,	285	static ssize_t scaling_boost_frequencies_show(struct cpufreq_policy *policy,

drivers/extcon/extcon.c+1−0

@@ -1241,6 +1241,7 @@ int extcon_dev_register(struct extcon_dev *edev) · 1240 unmodified lines
1241	sizeof(*edev->nh), GFP_KERNEL);	1241	sizeof(*edev->nh), GFP_KERNEL);
1242	if (!edev->nh) {	1242	if (!edev->nh) {
1243	ret = -ENOMEM;	1243	ret = -ENOMEM;
		1244	device_unregister(&edev->dev);
1244	goto err_dev;	1245	goto err_dev;
1245	}	1246	}
1246		1247

drivers/firewire/nosy.c+7−2

 	struct client *client = file->private_data;
 	spinlock_t *client_list_lock = &client->lynx->client_list_lock;
 	struct nosy_stats stats;
+	int ret;
 	switch (cmd) {
 	case NOSY_IOC_GET_STATS:
 			return 0;
 	case NOSY_IOC_START:
+		ret = -EBUSY;
 		spin_lock_irq(client_list_lock);
-		list_add_tail(&client->link, &client->lynx->client_list);
+		if (list_empty(&client->link)) {
+			list_add_tail(&client->link, &client->lynx->client_list);
+			ret = 0;
+		}
 		spin_unlock_irq(client_list_lock);
-		return 0;
+		return ret;
 	case NOSY_IOC_STOP:
 		spin_lock_irq(client_list_lock);

drivers/gpu/drm/amd/amdgpu/amdgpu.h+3−7

@@ -1007,13 +1007,9 @@ struct amdgpu_device { · 1006 unmodified lines
1007		1007
1008	/* s3/s4 mask */	1008	/* s3/s4 mask */
1009	bool in_suspend;	1009	bool in_suspend;
1010	bool in_hibernate;	1010	bool in_s3;
1011		1011	bool in_s4;
1012	/*	1012	bool in_s0ix;
1013	* The combination flag in_poweroff_reboot_com used to identify the poweroff
1014	* and reboot opt in the s0i3 system-wide suspend.
1015	*/
1016	bool in_poweroff_reboot_com;
1017		1013
1018	atomic_t in_gpu_reset;	1014	atomic_t in_gpu_reset;
1019	enum pp_mp1_state mp1_state;	1015	enum pp_mp1_state mp1_state;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c+34−98

 		i = state == AMD_CG_STATE_GATE ? j : adev->num_ip_blocks - j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
+		/* skip CG for GFX on S0ix */
+		if (adev->in_s0ix &&
+		    adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX)
+			continue;
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_UVD &&
 		    adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_VCE &&
 		i = state == AMD_PG_STATE_GATE ? j : adev->num_ip_blocks - j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
+		/* skip PG for GFX on S0ix */
+		if (adev->in_s0ix &&
+		    adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX)
+			continue;
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_UVD &&
 		    adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_VCE &&
 {
 	int i, r;
-	if (adev->in_poweroff_reboot_com ||
+	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-	    !amdgpu_acpi_is_s0ix_supported(adev) || amdgpu_in_reset(adev)) {
+	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-		amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-		amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-	}
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.valid)
 {
 	int i, r;
+	if (adev->in_s0ix)
+		amdgpu_gfx_state_change_set(adev, sGpuChangeState_D3Entry);
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
 			adev->ip_blocks[i].status.hw = false;
 			continue;
 		}
+		/* skip suspend of gfx and psp for S0ix
+		 * gfx is in gfxoff state, so on resume it will exit gfxoff just
+		 * like at runtime. PSP is also part of the always on hardware
+		 * so no need to suspend it.
+		 */
+		if (adev->in_s0ix &&
+		    (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_PSP ||
+		     adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX))
+			continue;
 		/* XXX handle errors */
 		r = adev->ip_blocks[i].version->funcs->suspend(adev);
 		/* XXX handle errors */
  */
 int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
 {
-	struct amdgpu_device *adev;
+	struct amdgpu_device *adev = drm_to_adev(dev);
-	struct drm_crtc *crtc;
-	struct drm_connector *connector;
-	struct drm_connector_list_iter iter;
 	int r;
-	adev = drm_to_adev(dev);
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
 	cancel_delayed_work_sync(&adev->delayed_init_work);
-	if (!amdgpu_device_has_dc_support(adev)) {
-		/* turn off display hw */
-		drm_modeset_lock_all(dev);
-		drm_connector_list_iter_begin(dev, &iter);
-		drm_for_each_connector_iter(connector, &iter)
-			drm_helper_connector_dpms(connector,
-						  DRM_MODE_DPMS_OFF);
-		drm_connector_list_iter_end(&iter);
-		drm_modeset_unlock_all(dev);
-			/* unpin the front buffers and cursors */
-		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-			struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
-			struct drm_framebuffer *fb = crtc->primary->fb;
-			struct amdgpu_bo *robj;
-			if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
-				struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
-				r = amdgpu_bo_reserve(aobj, true);
-				if (r == 0) {
-					amdgpu_bo_unpin(aobj);
-					amdgpu_bo_unreserve(aobj);
-				}
-			}
-			if (fb == NULL || fb->obj[0] == NULL) {
-				continue;
-			}
-			robj = gem_to_amdgpu_bo(fb->obj[0]);
-			/* don't unpin kernel fb objects */
-			if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
-				r = amdgpu_bo_reserve(robj, true);
-				if (r == 0) {
-					amdgpu_bo_unpin(robj);
-					amdgpu_bo_unreserve(robj);
-				}
-			}
-		}
-	}
 	amdgpu_ras_suspend(adev);
 	r = amdgpu_device_ip_suspend_phase1(adev);
-	amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+	if (!adev->in_s0ix)
+		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
 	/* evict vram memory */
 	amdgpu_bo_evict_vram(adev);
 	amdgpu_fence_driver_suspend(adev);
-	if (adev->in_poweroff_reboot_com ||
+	r = amdgpu_device_ip_suspend_phase2(adev);
-	    !amdgpu_acpi_is_s0ix_supported(adev) || amdgpu_in_reset(adev))
-		r = amdgpu_device_ip_suspend_phase2(adev);
-	else
-		amdgpu_gfx_state_change_set(adev, sGpuChangeState_D3Entry);
 	/* evict remaining vram memory
 	 * This second call to evict vram is to evict the gart page table
 	 * using the CPU.
  */
 int amdgpu_device_resume(struct drm_device *dev, bool fbcon)
 {
-	struct drm_connector *connector;
-	struct drm_connector_list_iter iter;
 	struct amdgpu_device *adev = drm_to_adev(dev);
-	struct drm_crtc *crtc;
 	int r = 0;
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
-	if (amdgpu_acpi_is_s0ix_supported(adev))
+	if (adev->in_s0ix)
 		amdgpu_gfx_state_change_set(adev, sGpuChangeState_D0Entry);
 	/* post card */
 	queue_delayed_work(system_wq, &adev->delayed_init_work,
 			   msecs_to_jiffies(AMDGPU_RESUME_MS));
-	if (!amdgpu_device_has_dc_support(adev)) {
+	if (!adev->in_s0ix) {
-		/* pin cursors */
+		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
-		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+		if (r)
-			struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
+			return r;
-			if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
-				struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
-				r = amdgpu_bo_reserve(aobj, true);
-				if (r == 0) {
-					r = amdgpu_bo_pin(aobj, AMDGPU_GEM_DOMAIN_VRAM);
-					if (r != 0)
-						dev_err(adev->dev, "Failed to pin cursor BO (%d)\n", r);
-					amdgpu_crtc->cursor_addr = amdgpu_bo_gpu_offset(aobj);
-					amdgpu_bo_unreserve(aobj);
-				}
-			}
-		}
 	}
-	r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
-	if (r)
-		return r;
 	/* Make sure IB tests flushed */
 	flush_delayed_work(&adev->delayed_init_work);
-	/* blat the mode back in */
+	if (fbcon)
-	if (fbcon) {
-		if (!amdgpu_device_has_dc_support(adev)) {
-			/* pre DCE11 */
-			drm_helper_resume_force_mode(dev);
-			/* turn on display hw */
-			drm_modeset_lock_all(dev);
-			drm_connector_list_iter_begin(dev, &iter);
-			drm_for_each_connector_iter(connector, &iter)
-				drm_helper_connector_dpms(connector,
-							  DRM_MODE_DPMS_ON);
-			drm_connector_list_iter_end(&iter);
-			drm_modeset_unlock_all(dev);
-		}
 		amdgpu_fbdev_set_suspend(adev, 0);
-	}
 	drm_kms_helper_poll_enable(dev);

drivers/gpu/drm/amd/amdgpu/amdgpu_display.c+89−0

@@ -1310,3 +1310,92 @@ bool amdgpu_crtc_get_scanout_position(struct drm_crtc *crtc, · 1309 unmodified lines
1310	return amdgpu_display_get_crtc_scanoutpos(dev, pipe, 0, vpos, hpos,	1310	return amdgpu_display_get_crtc_scanoutpos(dev, pipe, 0, vpos, hpos,
1311	stime, etime, mode);	1311	stime, etime, mode);
1312	}	1312	}
		1313
		1314	int amdgpu_display_suspend_helper(struct amdgpu_device *adev)
		1315	{
		1316	struct drm_device *dev = adev_to_drm(adev);
		1317	struct drm_crtc *crtc;
		1318	struct drm_connector *connector;
		1319	struct drm_connector_list_iter iter;
		1320	int r;
		1321
		1322	/* turn off display hw */
		1323	drm_modeset_lock_all(dev);
		1324	drm_connector_list_iter_begin(dev, &iter);
		1325	drm_for_each_connector_iter(connector, &iter)
		1326	drm_helper_connector_dpms(connector,
		1327	DRM_MODE_DPMS_OFF);
		1328	drm_connector_list_iter_end(&iter);
		1329	drm_modeset_unlock_all(dev);
		1330	/* unpin the front buffers and cursors */
		1331	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		1332	struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
		1333	struct drm_framebuffer *fb = crtc->primary->fb;
		1334	struct amdgpu_bo *robj;
		1335
		1336	if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
		1337	struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
		1338	r = amdgpu_bo_reserve(aobj, true);
		1339	if (r == 0) {
		1340	amdgpu_bo_unpin(aobj);
		1341	amdgpu_bo_unreserve(aobj);
		1342	}
		1343	}
		1344
		1345	if (fb == NULL \|\| fb->obj[0] == NULL) {
		1346	continue;
		1347	}
		1348	robj = gem_to_amdgpu_bo(fb->obj[0]);
		1349	/* don't unpin kernel fb objects */
		1350	if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
		1351	r = amdgpu_bo_reserve(robj, true);
		1352	if (r == 0) {
		1353	amdgpu_bo_unpin(robj);
		1354	amdgpu_bo_unreserve(robj);
		1355	}
		1356	}
		1357	}
		1358	return r;
		1359	}
		1360
		1361	int amdgpu_display_resume_helper(struct amdgpu_device *adev)
		1362	{
		1363	struct drm_device *dev = adev_to_drm(adev);
		1364	struct drm_connector *connector;
		1365	struct drm_connector_list_iter iter;
		1366	struct drm_crtc *crtc;
		1367	int r;
		1368
		1369	/* pin cursors */
		1370	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		1371	struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
		1372
		1373	if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
		1374	struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
		1375	r = amdgpu_bo_reserve(aobj, true);
		1376	if (r == 0) {
		1377	r = amdgpu_bo_pin(aobj, AMDGPU_GEM_DOMAIN_VRAM);
		1378	if (r != 0)
		1379	dev_err(adev->dev, "Failed to pin cursor BO (%d)\n", r);
		1380	amdgpu_crtc->cursor_addr = amdgpu_bo_gpu_offset(aobj);
		1381	amdgpu_bo_unreserve(aobj);
		1382	}
		1383	}
		1384	}
		1385
		1386	drm_helper_resume_force_mode(dev);
		1387
		1388	/* turn on display hw */
		1389	drm_modeset_lock_all(dev);
		1390
		1391	drm_connector_list_iter_begin(dev, &iter);
		1392	drm_for_each_connector_iter(connector, &iter)
		1393	drm_helper_connector_dpms(connector,
		1394	DRM_MODE_DPMS_ON);
		1395	drm_connector_list_iter_end(&iter);
		1396
		1397	drm_modeset_unlock_all(dev);
		1398
		1399	return 0;
		1400	}
		1401

drivers/gpu/drm/amd/amdgpu/amdgpu_display.h+3−0

@@ -47,4 +47,7 @@ amdgpu_display_user_framebuffer_create(struct drm_device *dev, · 46 unmodified lines
47	const struct drm_format_info *	47	const struct drm_format_info *
48	amdgpu_lookup_format_info(u32 format, uint64_t modifier);	48	amdgpu_lookup_format_info(u32 format, uint64_t modifier);
49		49
		50	int amdgpu_display_suspend_helper(struct amdgpu_device *adev);
		51	int amdgpu_display_resume_helper(struct amdgpu_device *adev);
		52
50	#endif	53	#endif

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+19−12

 	{0x1002, 0x73A3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SIENNA_CICHLID},
 	{0x1002, 0x73AB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SIENNA_CICHLID},
 	{0x1002, 0x73AE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SIENNA_CICHLID},
+	{0x1002, 0x73AF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SIENNA_CICHLID},
 	{0x1002, 0x73BF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SIENNA_CICHLID},
 	/* Van Gogh */
 	 */
 	if (!amdgpu_passthrough(adev))
 		adev->mp1_state = PP_MP1_STATE_UNLOAD;
-	adev->in_poweroff_reboot_com = true;
 	amdgpu_device_ip_suspend(adev);
-	adev->in_poweroff_reboot_com = false;
 	adev->mp1_state = PP_MP1_STATE_NONE;
 }
 static int amdgpu_pmops_suspend(struct device *dev)
 {
 	struct drm_device *drm_dev = dev_get_drvdata(dev);
+	struct amdgpu_device *adev = drm_to_adev(drm_dev);
+	int r;
-	return amdgpu_device_suspend(drm_dev, true);
+	if (amdgpu_acpi_is_s0ix_supported(adev))
+		adev->in_s0ix = true;
+	adev->in_s3 = true;
+	r = amdgpu_device_suspend(drm_dev, true);
+	adev->in_s3 = false;
+	return r;
 }
 static int amdgpu_pmops_resume(struct device *dev)
 {
 	struct drm_device *drm_dev = dev_get_drvdata(dev);
+	struct amdgpu_device *adev = drm_to_adev(drm_dev);
+	int r;
-	return amdgpu_device_resume(drm_dev, true);
+	r = amdgpu_device_resume(drm_dev, true);
+	if (amdgpu_acpi_is_s0ix_supported(adev))
+		adev->in_s0ix = false;
+	return r;
 }
 static int amdgpu_pmops_freeze(struct device *dev)
 	struct amdgpu_device *adev = drm_to_adev(drm_dev);
 	int r;
-	adev->in_hibernate = true;
+	adev->in_s4 = true;
 	r = amdgpu_device_suspend(drm_dev, true);
-	adev->in_hibernate = false;
+	adev->in_s4 = false;
 	if (r)
 		return r;
 	return amdgpu_asic_reset(adev);
 static int amdgpu_pmops_poweroff(struct device *dev)
 {
 	struct drm_device *drm_dev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(drm_dev);
-	int r;
-	adev->in_poweroff_reboot_com = true;
+	return amdgpu_device_suspend(drm_dev, true);
-	r =  amdgpu_device_suspend(drm_dev, true);
-	adev->in_poweroff_reboot_com = false;
-	return r;
 }
 static int amdgpu_pmops_restore(struct device *dev)

drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c+2−2

@@ -778,9 +778,9 @@ int amdgpu_info_ioctl(struct drm_device dev, void data, struct drm_file *filp) · 777 unmodified lines
778	dev_info->high_va_offset = AMDGPU_GMC_HOLE_END;	778	dev_info->high_va_offset = AMDGPU_GMC_HOLE_END;
779	dev_info->high_va_max = AMDGPU_GMC_HOLE_END \| vm_size;	779	dev_info->high_va_max = AMDGPU_GMC_HOLE_END \| vm_size;
780	}	780	}
781	dev_info->virtual_address_alignment = max((int)PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);	781	dev_info->virtual_address_alignment = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
782	dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;	782	dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;
783	dev_info->gart_page_size = AMDGPU_GPU_PAGE_SIZE;	783	dev_info->gart_page_size = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
784	dev_info->cu_active_number = adev->gfx.cu_info.number;	784	dev_info->cu_active_number = adev->gfx.cu_info.number;
785	dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;	785	dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;
786	dev_info->ce_ram_size = adev->gfx.ce_ram_size;	786	dev_info->ce_ram_size = adev->gfx.ce_ram_size;

drivers/gpu/drm/amd/amdgpu/amdgpu_object.c+2−5

 {
 	struct ttm_resource_manager *man;
-	/* late 2.6.33 fix IGP hibernate - we need pm ops to do this correct */
+	if (adev->in_s3 && (adev->flags & AMD_IS_APU)) {
-#ifndef CONFIG_HIBERNATION
+		/* No need to evict vram on APUs for suspend to ram */
-	if (adev->flags & AMD_IS_APU) {
-		/* Useless to evict on IGP chips */
 		return 0;
 	}
-#endif
 	man = ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM);
 	return ttm_resource_manager_evict_all(&adev->mman.bdev, man);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c+5−5

@@ -2197,8 +2197,8 @@ int amdgpu_vm_bo_map(struct amdgpu_device *adev, · 2196 unmodified lines
2197	uint64_t eaddr;	2197	uint64_t eaddr;
2198		2198
2199	/* validate the parameters */	2199	/* validate the parameters */
2200	if (saddr & AMDGPU_GPU_PAGE_MASK \|\| offset & AMDGPU_GPU_PAGE_MASK \|\|	2200	if (saddr & ~PAGE_MASK \|\| offset & ~PAGE_MASK \|\|
2201	size == 0 \|\| size & AMDGPU_GPU_PAGE_MASK)	2201	size == 0 \|\| size & ~PAGE_MASK)
2202	return -EINVAL;	2202	return -EINVAL;
2203		2203
2204	/* make sure object fit at this offset */	2204	/* make sure object fit at this offset */
@@ -2263,8 +2263,8 @@ int amdgpu_vm_bo_replace_map(struct amdgpu_device *adev, · 58 unmodified lines
2263	int r;	2263	int r;
2264		2264
2265	/* validate the parameters */	2265	/* validate the parameters */
2266	if (saddr & AMDGPU_GPU_PAGE_MASK \|\| offset & AMDGPU_GPU_PAGE_MASK \|\|	2266	if (saddr & ~PAGE_MASK \|\| offset & ~PAGE_MASK \|\|
2267	size == 0 \|\| size & AMDGPU_GPU_PAGE_MASK)	2267	size == 0 \|\| size & ~PAGE_MASK)
2268	return -EINVAL;	2268	return -EINVAL;
2269		2269
2270	/* make sure object fit at this offset */	2270	/* make sure object fit at this offset */
@@ -2409,7 +2409,7 @@ int amdgpu_vm_bo_clear_mappings(struct amdgpu_device *adev, · 138 unmodified lines
2409	after->start = eaddr + 1;	2409	after->start = eaddr + 1;
2410	after->last = tmp->last;	2410	after->last = tmp->last;
2411	after->offset = tmp->offset;	2411	after->offset = tmp->offset;
2412	after->offset += after->start - tmp->start;	2412	after->offset += (after->start - tmp->start) << PAGE_SHIFT;
2413	after->flags = tmp->flags;	2413	after->flags = tmp->flags;
2414	after->bo_va = tmp->bo_va;	2414	after->bo_va = tmp->bo_va;
2415	list_add(&after->list, &tmp->bo_va->invalids);	2415	list_add(&after->list, &tmp->bo_va->invalids);

drivers/gpu/drm/amd/amdgpu/dce_v10_0.c+8−1

 static int dce_v10_0_suspend(void *handle)
 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = amdgpu_display_suspend_helper(adev);
+	if (r)
+		return r;
 	adev->mode_info.bl_level =
 		amdgpu_atombios_encoder_get_backlight_level_from_reg(adev);
 		amdgpu_display_backlight_set_level(adev, adev->mode_info.bl_encoder,
 						    bl_level);
 	}
+	if (ret)
+		return ret;
-	return ret;
+	return amdgpu_display_resume_helper(adev);
 }
 static bool dce_v10_0_is_idle(void *handle)

drivers/gpu/drm/amd/amdgpu/dce_v11_0.c+8−1

 static int dce_v11_0_suspend(void *handle)
 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = amdgpu_display_suspend_helper(adev);
+	if (r)
+		return r;
 	adev->mode_info.bl_level =
 		amdgpu_atombios_encoder_get_backlight_level_from_reg(adev);
 		amdgpu_display_backlight_set_level(adev, adev->mode_info.bl_encoder,
 						    bl_level);
 	}
+	if (ret)
+		return ret;
-	return ret;
+	return amdgpu_display_resume_helper(adev);
 }
 static bool dce_v11_0_is_idle(void *handle)

drivers/gpu/drm/amd/amdgpu/dce_v6_0.c+7−1

 static int dce_v6_0_suspend(void *handle)
 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = amdgpu_display_suspend_helper(adev);
+	if (r)
+		return r;
 	adev->mode_info.bl_level =
 		amdgpu_atombios_encoder_get_backlight_level_from_reg(adev);
 		amdgpu_display_backlight_set_level(adev, adev->mode_info.bl_encoder,
 						    bl_level);
 	}
+	if (ret)
+		return ret;
-	return ret;
+	return amdgpu_display_resume_helper(adev);
 }
 static bool dce_v6_0_is_idle(void *handle)

drivers/gpu/drm/amd/amdgpu/dce_v8_0.c+8−1

 static int dce_v8_0_suspend(void *handle)
 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = amdgpu_display_suspend_helper(adev);
+	if (r)
+		return r;
 	adev->mode_info.bl_level =
 		amdgpu_atombios_encoder_get_backlight_level_from_reg(adev);
 		amdgpu_display_backlight_set_level(adev, adev->mode_info.bl_encoder,
 						    bl_level);
 	}
+	if (ret)
+		return ret;
-	return ret;
+	return amdgpu_display_resume_helper(adev);
 }
 static bool dce_v8_0_is_idle(void *handle)

drivers/gpu/drm/amd/amdgpu/dce_virtual.c+14−1

 #include "dce_v11_0.h"
 #include "dce_virtual.h"
 #include "ivsrcid/ivsrcid_vislands30.h"
+#include "amdgpu_display.h"
 #define DCE_VIRTUAL_VBLANK_PERIOD 16666666
 static int dce_virtual_suspend(void *handle)
 {
+	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = amdgpu_display_suspend_helper(adev);
+	if (r)
+		return r;
 	return dce_virtual_hw_fini(handle);
 }
 static int dce_virtual_resume(void *handle)
 {
-	return dce_virtual_hw_init(handle);
+	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int r;
+	r = dce_virtual_hw_init(handle);
+	if (r)
+		return r;
+	return amdgpu_display_resume_helper(adev);
 }
 static bool dce_virtual_is_idle(void *handle)

drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c+1−1

@@ -155,7 +155,7 @@ static int dbgdev_diq_submit_ib(struct kfd_dbgdev *dbgdev, · 154 unmodified lines
155		155
156	/* Wait till CP writes sync code: */	156	/* Wait till CP writes sync code: */
157	status = amdkfd_fence_wait_timeout(	157	status = amdkfd_fence_wait_timeout(
158	(unsigned int *) rm_state,	158	rm_state,
159	QUEUESTATE__ACTIVE, 1500);	159	QUEUESTATE__ACTIVE, 1500);
160		160
161	kfd_gtt_sa_free(dbgdev->dev, mem_obj);	161	kfd_gtt_sa_free(dbgdev->dev, mem_obj);

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c+3−3

@@ -1167,7 +1167,7 @@ static int start_cpsch(struct device_queue_manager *dqm) · 1166 unmodified lines
1167	if (retval)	1167	if (retval)
1168	goto fail_allocate_vidmem;	1168	goto fail_allocate_vidmem;
1169		1169
1170	dqm->fence_addr = dqm->fence_mem->cpu_ptr;	1170	dqm->fence_addr = (uint64_t *)dqm->fence_mem->cpu_ptr;
1171	dqm->fence_gpu_addr = dqm->fence_mem->gpu_addr;	1171	dqm->fence_gpu_addr = dqm->fence_mem->gpu_addr;
1172		1172
1173	init_interrupts(dqm);	1173	init_interrupts(dqm);
@@ -1340,8 +1340,8 @@ out: · 166 unmodified lines
1340	return retval;	1340	return retval;
1341	}	1341	}
1342		1342
1343	int amdkfd_fence_wait_timeout(unsigned int *fence_addr,	1343	int amdkfd_fence_wait_timeout(uint64_t *fence_addr,
1344	unsigned int fence_value,	1344	uint64_t fence_value,
1345	unsigned int timeout_ms)	1345	unsigned int timeout_ms)
1346	{	1346	{
1347	unsigned long end_jiffies = msecs_to_jiffies(timeout_ms) + jiffies;	1347	unsigned long end_jiffies = msecs_to_jiffies(timeout_ms) + jiffies;

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h+1−1

@@ -192,7 +192,7 @@ struct device_queue_manager { · 191 unmodified lines
192	uint16_t vmid_pasid[VMID_NUM];	192	uint16_t vmid_pasid[VMID_NUM];
193	uint64_t pipelines_addr;	193	uint64_t pipelines_addr;
194	uint64_t fence_gpu_addr;	194	uint64_t fence_gpu_addr;
195	unsigned int *fence_addr;	195	uint64_t *fence_addr;
196	struct kfd_mem_obj *fence_mem;	196	struct kfd_mem_obj *fence_mem;
197	bool active_runlist;	197	bool active_runlist;
198	int sched_policy;	198	int sched_policy;

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c+1−1

@@ -347,7 +347,7 @@ fail_create_runlist_ib: · 346 unmodified lines
347	}	347	}
348		348
349	int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,	349	int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
350	uint32_t fence_value)	350	uint64_t fence_value)
351	{	351	{
352	uint32_t *buffer, size;	352	uint32_t *buffer, size;
353	int retval = 0;	353	int retval = 0;

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_v9.c+1−1

@@ -283,7 +283,7 @@ static int pm_unmap_queues_v9(struct packet_manager pm, uint32_t buffer, · 282 unmodified lines
283	}	283	}
284		284
285	static int pm_query_status_v9(struct packet_manager pm, uint32_t buffer,	285	static int pm_query_status_v9(struct packet_manager pm, uint32_t buffer,
286	uint64_t fence_address, uint32_t fence_value)	286	uint64_t fence_address, uint64_t fence_value)
287	{	287	{
288	struct pm4_mes_query_status *packet;	288	struct pm4_mes_query_status *packet;
289		289

drivers/gpu/drm/amd/amdkfd/kfd_packet_manager_vi.c+1−1

@@ -263,7 +263,7 @@ static int pm_unmap_queues_vi(struct packet_manager pm, uint32_t buffer, · 262 unmodified lines
263	}	263	}
264		264
265	static int pm_query_status_vi(struct packet_manager pm, uint32_t buffer,	265	static int pm_query_status_vi(struct packet_manager pm, uint32_t buffer,
266	uint64_t fence_address, uint32_t fence_value)	266	uint64_t fence_address, uint64_t fence_value)
267	{	267	{
268	struct pm4_mes_query_status *packet;	268	struct pm4_mes_query_status *packet;
269		269

drivers/gpu/drm/amd/amdkfd/kfd_priv.h+4−4

@@ -1003,8 +1003,8 @@ int pqm_get_wave_state(struct process_queue_manager *pqm, · 1002 unmodified lines
1003	u32 *ctl_stack_used_size,	1003	u32 *ctl_stack_used_size,
1004	u32 *save_area_used_size);	1004	u32 *save_area_used_size);
1005		1005
1006	int amdkfd_fence_wait_timeout(unsigned int *fence_addr,	1006	int amdkfd_fence_wait_timeout(uint64_t *fence_addr,
1007	unsigned int fence_value,	1007	uint64_t fence_value,
1008	unsigned int timeout_ms);	1008	unsigned int timeout_ms);
1009		1009
1010	/* Packet Manager */	1010	/* Packet Manager */
@@ -1040,7 +1040,7 @@ struct packet_manager_funcs { · 29 unmodified lines
1040	uint32_t filter_param, bool reset,	1040	uint32_t filter_param, bool reset,
1041	unsigned int sdma_engine);	1041	unsigned int sdma_engine);
1042	int (query_status)(struct packet_manager pm, uint32_t *buffer,	1042	int (query_status)(struct packet_manager pm, uint32_t *buffer,
1043	uint64_t fence_address, uint32_t fence_value);	1043	uint64_t fence_address, uint64_t fence_value);
1044	int (release_mem)(uint64_t gpu_addr, uint32_t buffer);	1044	int (release_mem)(uint64_t gpu_addr, uint32_t buffer);
1045		1045
1046	/* Packet sizes */	1046	/* Packet sizes */
@@ -1062,7 +1062,7 @@ int pm_send_set_resources(struct packet_manager *pm, · 15 unmodified lines
1062	struct scheduling_resources *res);	1062	struct scheduling_resources *res);
1063	int pm_send_runlist(struct packet_manager pm, struct list_head dqm_queues);	1063	int pm_send_runlist(struct packet_manager pm, struct list_head dqm_queues);
1064	int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,	1064	int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
1065	uint32_t fence_value);	1065	uint64_t fence_value);
1066		1066
1067	int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,	1067	int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
1068	enum kfd_unmap_queues_filter mode,	1068	enum kfd_unmap_queues_filter mode,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_link_encoder.c+1−2

@@ -341,8 +341,7 @@ void enc2_hw_init(struct link_encoder *enc) · 340 unmodified lines
341	} else {	341	} else {
342	AUX_REG_WRITE(AUX_DPHY_RX_CONTROL0, 0x103d1110);	342	AUX_REG_WRITE(AUX_DPHY_RX_CONTROL0, 0x103d1110);
343		343
344	AUX_REG_WRITE(AUX_DPHY_TX_CONTROL, 0x21c4d);	344	AUX_REG_WRITE(AUX_DPHY_TX_CONTROL, 0x21c7a);
345
346	}	345	}
347		346
348	//AUX_DPHY_TX_REF_CONTROL'AUX_TX_REF_DIV HW default is 0x32;	347	//AUX_DPHY_TX_REF_CONTROL'AUX_TX_REF_DIV HW default is 0x32;

drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c+56−1

@@ -587,6 +587,48 @@ static int smu7_force_switch_to_arbf0(struct pp_hwmgr *hwmgr) · 586 unmodified lines
587	tmp, MC_CG_ARB_FREQ_F0);	587	tmp, MC_CG_ARB_FREQ_F0);
588	}	588	}
589		589
		590	static uint16_t smu7_override_pcie_speed(struct pp_hwmgr *hwmgr)
		591	{
		592	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);
		593	uint16_t pcie_gen = 0;
		594
		595	if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4 &&
		596	adev->pm.pcie_gen_mask & CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN4)
		597	pcie_gen = 3;
		598	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3 &&
		599	adev->pm.pcie_gen_mask & CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3)
		600	pcie_gen = 2;
		601	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2 &&
		602	adev->pm.pcie_gen_mask & CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2)
		603	pcie_gen = 1;
		604	else if (adev->pm.pcie_gen_mask & CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 &&
		605	adev->pm.pcie_gen_mask & CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN1)
		606	pcie_gen = 0;
		607
		608	return pcie_gen;
		609	}
		610
		611	static uint16_t smu7_override_pcie_width(struct pp_hwmgr *hwmgr)
		612	{
		613	struct amdgpu_device adev = (struct amdgpu_device )(hwmgr->adev);
		614	uint16_t pcie_width = 0;
		615
		616	if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X16)
		617	pcie_width = 16;
		618	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X12)
		619	pcie_width = 12;
		620	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X8)
		621	pcie_width = 8;
		622	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X4)
		623	pcie_width = 4;
		624	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X2)
		625	pcie_width = 2;
		626	else if (adev->pm.pcie_mlw_mask & CAIL_PCIE_LINK_WIDTH_SUPPORT_X1)
		627	pcie_width = 1;
		628
		629	return pcie_width;
		630	}
		631
590	static int smu7_setup_default_pcie_table(struct pp_hwmgr *hwmgr)	632	static int smu7_setup_default_pcie_table(struct pp_hwmgr *hwmgr)
591	{	633	{
592	struct smu7_hwmgr data = (struct smu7_hwmgr )(hwmgr->backend);	634	struct smu7_hwmgr data = (struct smu7_hwmgr )(hwmgr->backend);
@@ -683,6 +725,11 @@ static int smu7_setup_default_pcie_table(struct pp_hwmgr *hwmgr) · 90 unmodified lines
683	PP_Min_PCIEGen),	725	PP_Min_PCIEGen),
684	get_pcie_lane_support(data->pcie_lane_cap,	726	get_pcie_lane_support(data->pcie_lane_cap,
685	PP_Max_PCIELane));	727	PP_Max_PCIELane));
		728
		729	if (data->pcie_dpm_key_disabled)
		730	phm_setup_pcie_table_entry(&data->dpm_table.pcie_speed_table,
		731	data->dpm_table.pcie_speed_table.count,
		732	smu7_override_pcie_speed(hwmgr), smu7_override_pcie_width(hwmgr));
686	}	733	}
687	return 0;	734	return 0;
688	}	735	}
@@ -1248,6 +1295,13 @@ static int smu7_start_dpm(struct pp_hwmgr *hwmgr) · 559 unmodified lines
1248	NULL)),	1295	NULL)),
1249	"Failed to enable pcie DPM during DPM Start Function!",	1296	"Failed to enable pcie DPM during DPM Start Function!",
1250	return -EINVAL);	1297	return -EINVAL);
		1298	} else {
		1299	PP_ASSERT_WITH_CODE(
		1300	(0 == smum_send_msg_to_smc(hwmgr,
		1301	PPSMC_MSG_PCIeDPM_Disable,
		1302	NULL)),
		1303	"Failed to disble pcie DPM during DPM Start Function!",
		1304	return -EINVAL);
1251	}	1305	}
1252		1306
1253	if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,	1307	if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
@@ -3276,7 +3330,8 @@ static int smu7_apply_state_adjust_rules(struct pp_hwmgr *hwmgr, · 2022 unmodified lines
3276		3330
3277	disable_mclk_switching_for_display = ((1 < hwmgr->display_config->num_display) &&	3331	disable_mclk_switching_for_display = ((1 < hwmgr->display_config->num_display) &&
3278	!hwmgr->display_config->multi_monitor_in_sync) \|\|	3332	!hwmgr->display_config->multi_monitor_in_sync) \|\|
3279	smu7_vblank_too_short(hwmgr, hwmgr->display_config->min_vblank_time);	3333	(hwmgr->display_config->num_display &&
		3334	smu7_vblank_too_short(hwmgr, hwmgr->display_config->min_vblank_time));
3280		3335
3281	disable_mclk_switching = disable_mclk_switching_for_frame_lock \|\|	3336	disable_mclk_switching = disable_mclk_switching_for_frame_lock \|\|
3282	disable_mclk_switching_for_display;	3337	disable_mclk_switching_for_display;

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c+63−11

@@ -54,6 +54,9 @@ · 53 unmodified lines
54	#include "smuio/smuio_9_0_offset.h"	54	#include "smuio/smuio_9_0_offset.h"
55	#include "smuio/smuio_9_0_sh_mask.h"	55	#include "smuio/smuio_9_0_sh_mask.h"
56		56
		57	#define smnPCIE_LC_SPEED_CNTL 0x11140290
		58	#define smnPCIE_LC_LINK_WIDTH_CNTL 0x11140288
		59
57	#define HBM_MEMORY_CHANNEL_WIDTH 128	60	#define HBM_MEMORY_CHANNEL_WIDTH 128
58		61
59	static const uint32_t channel_number[] = {1, 2, 0, 4, 0, 8, 0, 16, 2};	62	static const uint32_t channel_number[] = {1, 2, 0, 4, 0, 8, 0, 16, 2};
@@ -443,8 +446,7 @@ static void vega10_init_dpm_defaults(struct pp_hwmgr *hwmgr) · 383 unmodified lines
443	if (PP_CAP(PHM_PlatformCaps_VCEDPM))	446	if (PP_CAP(PHM_PlatformCaps_VCEDPM))
444	data->smu_features[GNLD_DPM_VCE].supported = true;	447	data->smu_features[GNLD_DPM_VCE].supported = true;
445		448
446	if (!data->registry_data.pcie_dpm_key_disabled)	449	data->smu_features[GNLD_DPM_LINK].supported = true;
447	data->smu_features[GNLD_DPM_LINK].supported = true;
448		450
449	if (!data->registry_data.dcefclk_dpm_key_disabled)	451	if (!data->registry_data.dcefclk_dpm_key_disabled)
450	data->smu_features[GNLD_DPM_DCEFCLK].supported = true;	452	data->smu_features[GNLD_DPM_DCEFCLK].supported = true;
@@ -1544,6 +1546,13 @@ static int vega10_override_pcie_parameters(struct pp_hwmgr *hwmgr) · 1093 unmodified lines
1544	pp_table->PcieLaneCount[i] = pcie_width;	1546	pp_table->PcieLaneCount[i] = pcie_width;
1545	}	1547	}
1546		1548
		1549	if (data->registry_data.pcie_dpm_key_disabled) {
		1550	for (i = 0; i < NUM_LINK_LEVELS; i++) {
		1551	pp_table->PcieGenSpeed[i] = pcie_gen;
		1552	pp_table->PcieLaneCount[i] = pcie_width;
		1553	}
		1554	}
		1555
1547	return 0;	1556	return 0;
1548	}	1557	}
1549		1558
@@ -2966,6 +2975,14 @@ static int vega10_start_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap) · 1416 unmodified lines
2966	}	2975	}
2967	}	2976	}
2968		2977
		2978	if (data->registry_data.pcie_dpm_key_disabled) {
		2979	PP_ASSERT_WITH_CODE(!vega10_enable_smc_features(hwmgr,
		2980	false, data->smu_features[GNLD_DPM_LINK].smu_feature_bitmap),
		2981	"Attempt to Disable Link DPM feature Failed!", return -EINVAL);
		2982	data->smu_features[GNLD_DPM_LINK].enabled = false;
		2983	data->smu_features[GNLD_DPM_LINK].supported = false;
		2984	}
		2985
2969	return 0;	2986	return 0;
2970	}	2987	}
2971		2988
@@ -4584,6 +4601,24 @@ static int vega10_set_ppfeature_status(struct pp_hwmgr *hwmgr, uint64_t new_ppfe · 1612 unmodified lines
4584	return 0;	4601	return 0;
4585	}	4602	}
4586		4603
		4604	static int vega10_get_current_pcie_link_width_level(struct pp_hwmgr *hwmgr)
		4605	{
		4606	struct amdgpu_device *adev = hwmgr->adev;
		4607
		4608	return (RREG32_PCIE(smnPCIE_LC_LINK_WIDTH_CNTL) &
		4609	PCIE_LC_LINK_WIDTH_CNTL__LC_LINK_WIDTH_RD_MASK)
		4610	>> PCIE_LC_LINK_WIDTH_CNTL__LC_LINK_WIDTH_RD__SHIFT;
		4611	}
		4612
		4613	static int vega10_get_current_pcie_link_speed_level(struct pp_hwmgr *hwmgr)
		4614	{
		4615	struct amdgpu_device *adev = hwmgr->adev;
		4616
		4617	return (RREG32_PCIE(smnPCIE_LC_SPEED_CNTL) &
		4618	PSWUSP0_PCIE_LC_SPEED_CNTL__LC_CURRENT_DATA_RATE_MASK)
		4619	>> PSWUSP0_PCIE_LC_SPEED_CNTL__LC_CURRENT_DATA_RATE__SHIFT;
		4620	}
		4621
4587	static int vega10_print_clock_levels(struct pp_hwmgr *hwmgr,	4622	static int vega10_print_clock_levels(struct pp_hwmgr *hwmgr,
4588	enum pp_clock_type type, char *buf)	4623	enum pp_clock_type type, char *buf)
4589	{	4624	{
@@ -4592,8 +4627,9 @@ static int vega10_print_clock_levels(struct pp_hwmgr *hwmgr, · 2 unmodified lines
4592	struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);	4627	struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);
4593	struct vega10_single_dpm_table *soc_table = &(data->dpm_table.soc_table);	4628	struct vega10_single_dpm_table *soc_table = &(data->dpm_table.soc_table);
4594	struct vega10_single_dpm_table *dcef_table = &(data->dpm_table.dcef_table);	4629	struct vega10_single_dpm_table *dcef_table = &(data->dpm_table.dcef_table);
4595	struct vega10_pcie_table *pcie_table = &(data->dpm_table.pcie_table);
4596	struct vega10_odn_clock_voltage_dependency_table *podn_vdd_dep = NULL;	4630	struct vega10_odn_clock_voltage_dependency_table *podn_vdd_dep = NULL;
		4631	uint32_t gen_speed, lane_width, current_gen_speed, current_lane_width;
		4632	PPTable_t *pptable = &(data->smc_state_table.pp_table);
4597		4633
4598	int i, now, size = 0, count = 0;	4634	int i, now, size = 0, count = 0;
4599		4635
@@ -4650,15 +4686,31 @@ static int vega10_print_clock_levels(struct pp_hwmgr *hwmgr, · 50 unmodified lines
4650	"*" : "");	4686	"*" : "");
4651	break;	4687	break;
4652	case PP_PCIE:	4688	case PP_PCIE:
4653	smum_send_msg_to_smc(hwmgr, PPSMC_MSG_GetCurrentLinkIndex, &now);	4689	current_gen_speed =
4654		4690	vega10_get_current_pcie_link_speed_level(hwmgr);
4655	for (i = 0; i < pcie_table->count; i++)	4691	current_lane_width =
4656	size += sprintf(buf + size, "%d: %s %s\n", i,	4692	vega10_get_current_pcie_link_width_level(hwmgr);
4657	(pcie_table->pcie_gen[i] == 0) ? "2.5GT/s, x1" :	4693	for (i = 0; i < NUM_LINK_LEVELS; i++) {
4658	(pcie_table->pcie_gen[i] == 1) ? "5.0GT/s, x16" :	4694	gen_speed = pptable->PcieGenSpeed[i];
4659	(pcie_table->pcie_gen[i] == 2) ? "8.0GT/s, x16" : "",	4695	lane_width = pptable->PcieLaneCount[i];
4660	(i == now) ? "*" : "");	4696
		4697	size += sprintf(buf + size, "%d: %s %s %s\n", i,
		4698	(gen_speed == 0) ? "2.5GT/s," :
		4699	(gen_speed == 1) ? "5.0GT/s," :
		4700	(gen_speed == 2) ? "8.0GT/s," :
		4701	(gen_speed == 3) ? "16.0GT/s," : "",
		4702	(lane_width == 1) ? "x1" :
		4703	(lane_width == 2) ? "x2" :
		4704	(lane_width == 3) ? "x4" :
		4705	(lane_width == 4) ? "x8" :
		4706	(lane_width == 5) ? "x12" :
		4707	(lane_width == 6) ? "x16" : "",
		4708	(current_gen_speed == gen_speed) &&
		4709	(current_lane_width == lane_width) ?
		4710	"*" : "");
		4711	}
4661	break;	4712	break;
		4713
4662	case OD_SCLK:	4714	case OD_SCLK:
4663	if (hwmgr->od_enabled) {	4715	if (hwmgr->od_enabled) {
4664	size = sprintf(buf, "%s:\n", "OD_SCLK");	4716	size = sprintf(buf, "%s:\n", "OD_SCLK");

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega12_hwmgr.c+24−0

@@ -133,6 +133,7 @@ static void vega12_set_default_registry_data(struct pp_hwmgr *hwmgr) · 132 unmodified lines
133	data->registry_data.auto_wattman_debug = 0;	133	data->registry_data.auto_wattman_debug = 0;
134	data->registry_data.auto_wattman_sample_period = 100;	134	data->registry_data.auto_wattman_sample_period = 100;
135	data->registry_data.auto_wattman_threshold = 50;	135	data->registry_data.auto_wattman_threshold = 50;
		136	data->registry_data.pcie_dpm_key_disabled = !(hwmgr->feature_mask & PP_PCIE_DPM_MASK);
136	}	137	}
137		138
138	static int vega12_set_features_platform_caps(struct pp_hwmgr *hwmgr)	139	static int vega12_set_features_platform_caps(struct pp_hwmgr *hwmgr)
@@ -539,6 +540,29 @@ static int vega12_override_pcie_parameters(struct pp_hwmgr *hwmgr) · 400 unmodified lines
539	pp_table->PcieLaneCount[i] = pcie_width_arg;	540	pp_table->PcieLaneCount[i] = pcie_width_arg;
540	}	541	}
541		542
		543	/* override to the highest if it's disabled from ppfeaturmask */
		544	if (data->registry_data.pcie_dpm_key_disabled) {
		545	for (i = 0; i < NUM_LINK_LEVELS; i++) {
		546	smu_pcie_arg = (i << 16) \| (pcie_gen << 8) \| pcie_width;
		547	ret = smum_send_msg_to_smc_with_parameter(hwmgr,
		548	PPSMC_MSG_OverridePcieParameters, smu_pcie_arg,
		549	NULL);
		550	PP_ASSERT_WITH_CODE(!ret,
		551	"[OverridePcieParameters] Attempt to override pcie params failed!",
		552	return ret);
		553
		554	pp_table->PcieGenSpeed[i] = pcie_gen;
		555	pp_table->PcieLaneCount[i] = pcie_width;
		556	}
		557	ret = vega12_enable_smc_features(hwmgr,
		558	false,
		559	data->smu_features[GNLD_DPM_LINK].smu_feature_bitmap);
		560	PP_ASSERT_WITH_CODE(!ret,
		561	"Attempt to Disable DPM LINK Failed!",
		562	return ret);
		563	data->smu_features[GNLD_DPM_LINK].enabled = false;
		564	data->smu_features[GNLD_DPM_LINK].supported = false;
		565	}
542	return 0;	566	return 0;
543	}	567	}
544		568

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_hwmgr.c+25−0

@@ -171,6 +171,7 @@ static void vega20_set_default_registry_data(struct pp_hwmgr *hwmgr) · 170 unmodified lines
171	data->registry_data.gfxoff_controlled_by_driver = 1;	171	data->registry_data.gfxoff_controlled_by_driver = 1;
172	data->gfxoff_allowed = false;	172	data->gfxoff_allowed = false;
173	data->counter_gfxoff = 0;	173	data->counter_gfxoff = 0;
		174	data->registry_data.pcie_dpm_key_disabled = !(hwmgr->feature_mask & PP_PCIE_DPM_MASK);
174	}	175	}
175		176
176	static int vega20_set_features_platform_caps(struct pp_hwmgr *hwmgr)	177	static int vega20_set_features_platform_caps(struct pp_hwmgr *hwmgr)
@@ -884,6 +885,30 @@ static int vega20_override_pcie_parameters(struct pp_hwmgr *hwmgr) · 707 unmodified lines
884	pp_table->PcieLaneCount[i] = pcie_width_arg;	885	pp_table->PcieLaneCount[i] = pcie_width_arg;
885	}	886	}
886		887
		888	/* override to the highest if it's disabled from ppfeaturmask */
		889	if (data->registry_data.pcie_dpm_key_disabled) {
		890	for (i = 0; i < NUM_LINK_LEVELS; i++) {
		891	smu_pcie_arg = (i << 16) \| (pcie_gen << 8) \| pcie_width;
		892	ret = smum_send_msg_to_smc_with_parameter(hwmgr,
		893	PPSMC_MSG_OverridePcieParameters, smu_pcie_arg,
		894	NULL);
		895	PP_ASSERT_WITH_CODE(!ret,
		896	"[OverridePcieParameters] Attempt to override pcie params failed!",
		897	return ret);
		898
		899	pp_table->PcieGenSpeed[i] = pcie_gen;
		900	pp_table->PcieLaneCount[i] = pcie_width;
		901	}
		902	ret = vega20_enable_smc_features(hwmgr,
		903	false,
		904	data->smu_features[GNLD_DPM_LINK].smu_feature_bitmap);
		905	PP_ASSERT_WITH_CODE(!ret,
		906	"Attempt to Disable DPM LINK Failed!",
		907	return ret);
		908	data->smu_features[GNLD_DPM_LINK].enabled = false;
		909	data->smu_features[GNLD_DPM_LINK].supported = false;
		910	}
		911
887	return 0;	912	return 0;
888	}	913	}
889		914

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c+3−2

 	bool use_baco = !smu->is_apu &&
 		((amdgpu_in_reset(adev) &&
 		  (amdgpu_asic_reset_method(adev) == AMD_RESET_METHOD_BACO)) ||
-		 ((adev->in_runpm || adev->in_hibernate) && amdgpu_asic_supports_baco(adev)));
+		 ((adev->in_runpm || adev->in_s4) && amdgpu_asic_supports_baco(adev)));
 	/*
 	 * For custom pptable uploading, skip the DPM features
 	smu->watermarks_bitmap &= ~(WATERMARKS_LOADED);
-	if (smu->is_apu)
+	/* skip CGPG when in S0ix */
+	if (smu->is_apu && !adev->in_s0ix)
 		smu_set_gfx_cgpg(&adev->smu, false);
 	return 0;

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c+5−0

 static bool vangogh_is_dpm_running(struct smu_context *smu)
 {
+	struct amdgpu_device *adev = smu->adev;
 	int ret = 0;
 	uint32_t feature_mask[2];
 	uint64_t feature_enabled;
+	/* we need to re-init after suspend so return false */
+	if (adev->in_suspend)
+		return false;
 	ret = smu_cmn_get_enabled_32_bits_mask(smu, feature_mask, 2);
 	if (ret)

drivers/gpu/drm/etnaviv/etnaviv_gem.c+2−1

@@ -689,7 +689,8 @@ static int etnaviv_gem_userptr_get_pages(struct etnaviv_gem_object *etnaviv_obj) · 688 unmodified lines
689	struct page **pages = pvec + pinned;	689	struct page **pages = pvec + pinned;
690		690
691	ret = pin_user_pages_fast(ptr, num_pages,	691	ret = pin_user_pages_fast(ptr, num_pages,
692	!userptr->ro ? FOLL_WRITE : 0, pages);	692	FOLL_WRITE \| FOLL_FORCE \| FOLL_LONGTERM,
		693	pages);
693	if (ret < 0) {	694	if (ret < 0) {
694	unpin_user_pages(pvec, pinned);	695	unpin_user_pages(pvec, pinned);
695	kvfree(pvec);	696	kvfree(pvec);

drivers/gpu/drm/exynos/exynos5433_drm_decon.c+0−1

@@ -13,7 +13,6 @@ · 12 unmodified lines
13	#include <linux/irq.h>	13	#include <linux/irq.h>
14	#include <linux/mfd/syscon.h>	14	#include <linux/mfd/syscon.h>
15	#include <linux/of_device.h>	15	#include <linux/of_device.h>
16	#include <linux/of_gpio.h>
17	#include <linux/platform_device.h>	16	#include <linux/platform_device.h>
18	#include <linux/pm_runtime.h>	17	#include <linux/pm_runtime.h>
19	#include <linux/regmap.h>	18	#include <linux/regmap.h>

drivers/gpu/drm/i915/display/intel_atomic_plane.c+3−2

 	if (!new_plane_state->hw.crtc && !old_plane_state->hw.crtc)
 		return 0;
-	new_crtc_state->enabled_planes |= BIT(plane->id);
 	ret = plane->check_plane(new_crtc_state, new_plane_state);
 	if (ret)
 		return ret;
+	if (fb)
+		new_crtc_state->enabled_planes |= BIT(plane->id);
 	/* FIXME pre-g4x don't work like this */
 	if (new_plane_state->uapi.visible)
 		new_crtc_state->active_planes |= BIT(plane->id);

drivers/gpu/drm/i915/display/intel_dp.c+1−3

@@ -3619,9 +3619,7 @@ intel_dp_get_dpcd(struct intel_dp *intel_dp) · 3618 unmodified lines
3619	{	3619	{
3620	int ret;	3620	int ret;
3621		3621
3622	intel_dp_lttpr_init(intel_dp);	3622	if (intel_dp_init_lttpr_and_dprx_caps(intel_dp) < 0)
3623
3624	if (drm_dp_read_dpcd_caps(&intel_dp->aux, intel_dp->dpcd))
3625	return false;	3623	return false;
3626		3624
3627	/*	3625	/*

drivers/gpu/drm/i915/display/intel_dp_aux.c+7−0

 	else
 		precharge = 5;
+	/* Max timeout value on G4x-BDW: 1.6ms */
 	if (IS_BROADWELL(dev_priv))
 		timeout = DP_AUX_CH_CTL_TIME_OUT_600us;
 	else
 	enum phy phy = intel_port_to_phy(i915, dig_port->base.port);
 	u32 ret;
+	/*
+	 * Max timeout values:
+	 * SKL-GLK: 1.6ms
+	 * CNL: 3.2ms
+	 * ICL+: 4ms
+	 */
 	ret = DP_AUX_CH_CTL_SEND_BUSY |
 	      DP_AUX_CH_CTL_DONE |
 	      DP_AUX_CH_CTL_INTERRUPT |

drivers/gpu/drm/i915/display/intel_dp_link_training.c+58−17

@@ -34,6 +34,11 @@ intel_dp_dump_link_status(const u8 link_status[DP_LINK_STATUS_SIZE]) · 33 unmodified lines
34	link_status[3], link_status[4], link_status[5]);	34	link_status[3], link_status[4], link_status[5]);
35	}	35	}
36		36
		37	static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
		38	{
		39	memset(&intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
		40	}
		41
37	static void intel_dp_reset_lttpr_count(struct intel_dp *intel_dp)	42	static void intel_dp_reset_lttpr_count(struct intel_dp *intel_dp)
38	{	43	{
39	intel_dp->lttpr_common_caps[DP_PHY_REPEATER_CNT -	44	intel_dp->lttpr_common_caps[DP_PHY_REPEATER_CNT -
@@ -81,19 +86,36 @@ static void intel_dp_read_lttpr_phy_caps(struct intel_dp *intel_dp, · 41 unmodified lines
81		86
82	static bool intel_dp_read_lttpr_common_caps(struct intel_dp *intel_dp)	87	static bool intel_dp_read_lttpr_common_caps(struct intel_dp *intel_dp)
83	{	88	{
84	if (drm_dp_read_lttpr_common_caps(&intel_dp->aux,	89	struct drm_i915_private *i915 = dp_to_i915(intel_dp);
85	intel_dp->lttpr_common_caps) < 0) {	90
86	memset(intel_dp->lttpr_common_caps, 0,	91	if (intel_dp_is_edp(intel_dp))
87	sizeof(intel_dp->lttpr_common_caps));
88	return false;	92	return false;
89	}	93
		94	/*
		95	* Detecting LTTPRs must be avoided on platforms with an AUX timeout
		96	* period < 3.2ms. (see DP Standard v2.0, 2.11.2, 3.6.6.1).
		97	*/
		98	if (INTEL_GEN(i915) < 10)
		99	return false;
		100
		101	if (drm_dp_read_lttpr_common_caps(&intel_dp->aux,
		102	intel_dp->lttpr_common_caps) < 0)
		103	goto reset_caps;
90		104
91	drm_dbg_kms(&dp_to_i915(intel_dp)->drm,	105	drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
92	"LTTPR common capabilities: %*ph\n",	106	"LTTPR common capabilities: %*ph\n",
93	(int)sizeof(intel_dp->lttpr_common_caps),	107	(int)sizeof(intel_dp->lttpr_common_caps),
94	intel_dp->lttpr_common_caps);	108	intel_dp->lttpr_common_caps);
95		109
		110	/* The minimum value of LT_TUNABLE_PHY_REPEATER_FIELD_DATA_STRUCTURE_REV is 1.4 */
		111	if (intel_dp->lttpr_common_caps[0] < 0x14)
		112	goto reset_caps;
		113
96	return true;	114	return true;
		115
		116	reset_caps:
		117	intel_dp_reset_lttpr_common_caps(intel_dp);
		118	return false;
97	}	119	}
98		120
99	static bool	121	static bool
@@ -106,33 +128,49 @@ intel_dp_set_lttpr_transparent_mode(struct intel_dp *intel_dp, bool enable) · 6 unmodified lines
106	}	128	}
107		129
108	/**	130	/**
109	* intel_dp_lttpr_init - detect LTTPRs and init the LTTPR link training mode	131	* intel_dp_init_lttpr_and_dprx_caps - detect LTTPR and DPRX caps, init the LTTPR link training mode
110	* @intel_dp: Intel DP struct	132	* @intel_dp: Intel DP struct
111	*	133	*
112	* Read the LTTPR common capabilities, switch to non-transparent link training	134	* Read the LTTPR common and DPRX capabilities and switch to non-transparent
113	* mode if any is detected and read the PHY capabilities for all detected	135	* link training mode if any is detected and read the PHY capabilities for all
114	* LTTPRs. In case of an LTTPR detection error or if the number of	136	* detected LTTPRs. In case of an LTTPR detection error or if the number of
115	* LTTPRs is more than is supported (8), fall back to the no-LTTPR,	137	* LTTPRs is more than is supported (8), fall back to the no-LTTPR,
116	* transparent mode link training mode.	138	* transparent mode link training mode.
117	*	139	*
118	* Returns:	140	* Returns:
119	* >0 if LTTPRs were detected and the non-transparent LT mode was set	141	* >0 if LTTPRs were detected and the non-transparent LT mode was set. The
		142	* DPRX capabilities are read out.
120	* 0 if no LTTPRs or more than 8 LTTPRs were detected or in case of a	143	* 0 if no LTTPRs or more than 8 LTTPRs were detected or in case of a
121	* detection failure and the transparent LT mode was set	144	* detection failure and the transparent LT mode was set. The DPRX
		145	* capabilities are read out.
		146	* <0 Reading out the DPRX capabilities failed.
122	*/	147	*/
123	int intel_dp_lttpr_init(struct intel_dp *intel_dp)	148	int intel_dp_init_lttpr_and_dprx_caps(struct intel_dp *intel_dp)
124	{	149	{
125	int lttpr_count;	150	int lttpr_count;
126	bool ret;	151	bool ret;
127	int i;	152	int i;
128		153
129	if (intel_dp_is_edp(intel_dp))
130	return 0;
131
132	ret = intel_dp_read_lttpr_common_caps(intel_dp);	154	ret = intel_dp_read_lttpr_common_caps(intel_dp);
		155
		156	/* The DPTX shall read the DPRX caps after LTTPR detection. */
		157	if (drm_dp_read_dpcd_caps(&intel_dp->aux, intel_dp->dpcd)) {
		158	intel_dp_reset_lttpr_common_caps(intel_dp);
		159	return -EIO;
		160	}
		161
133	if (!ret)	162	if (!ret)
134	return 0;	163	return 0;
135		164
		165	/*
		166	* The 0xF0000-0xF02FF range is only valid if the DPCD revision is
		167	* at least 1.4.
		168	*/
		169	if (intel_dp->dpcd[DP_DPCD_REV] < 0x14) {
		170	intel_dp_reset_lttpr_common_caps(intel_dp);
		171	return 0;
		172	}
		173
136	lttpr_count = drm_dp_lttpr_count(intel_dp->lttpr_common_caps);	174	lttpr_count = drm_dp_lttpr_count(intel_dp->lttpr_common_caps);
137	/*	175	/*
138	* Prevent setting LTTPR transparent mode explicitly if no LTTPRs are	176	* Prevent setting LTTPR transparent mode explicitly if no LTTPRs are
@@ -172,7 +210,7 @@ int intel_dp_lttpr_init(struct intel_dp *intel_dp) · 33 unmodified lines
172		210
173	return lttpr_count;	211	return lttpr_count;
174	}	212	}
175	EXPORT_SYMBOL(intel_dp_lttpr_init);	213	EXPORT_SYMBOL(intel_dp_init_lttpr_and_dprx_caps);
176		214
177	static u8 dp_voltage_max(u8 preemph)	215	static u8 dp_voltage_max(u8 preemph)
178	{	216	{
@@ -807,7 +845,10 @@ void intel_dp_start_link_train(struct intel_dp *intel_dp, · 628 unmodified lines
807	* TODO: Reiniting LTTPRs here won't be needed once proper connector	845	* TODO: Reiniting LTTPRs here won't be needed once proper connector
808	* HW state readout is added.	846	* HW state readout is added.
809	*/	847	*/
810	int lttpr_count = intel_dp_lttpr_init(intel_dp);	848	int lttpr_count = intel_dp_init_lttpr_and_dprx_caps(intel_dp);
		849
		850	if (lttpr_count < 0)
		851	return;
811		852
812	if (!intel_dp_link_train_all_phys(intel_dp, crtc_state, lttpr_count))	853	if (!intel_dp_link_train_all_phys(intel_dp, crtc_state, lttpr_count))
813	intel_dp_schedule_fallback_link_training(intel_dp, crtc_state);	854	intel_dp_schedule_fallback_link_training(intel_dp, crtc_state);

drivers/gpu/drm/i915/display/intel_dp_link_training.h+1−1

@@ -11,7 +11,7 @@ · 10 unmodified lines
11	struct intel_crtc_state;	11	struct intel_crtc_state;
12	struct intel_dp;	12	struct intel_dp;
13		13
14	int intel_dp_lttpr_init(struct intel_dp *intel_dp);	14	int intel_dp_init_lttpr_and_dprx_caps(struct intel_dp *intel_dp);
15		15
16	void intel_dp_get_adjust_train(struct intel_dp *intel_dp,	16	void intel_dp_get_adjust_train(struct intel_dp *intel_dp,
17	const struct intel_crtc_state *crtc_state,	17	const struct intel_crtc_state *crtc_state,

drivers/gpu/drm/i915/display/intel_vdsc.c+2−8

 {
 	enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
-	if (crtc_state->cpu_transcoder == TRANSCODER_EDP)
+	return is_pipe_dsc(crtc_state) ? ICL_PIPE_DSS_CTL1(pipe) : DSS_CTL1;
-		return DSS_CTL1;
-	return ICL_PIPE_DSS_CTL1(pipe);
 }
 static i915_reg_t dss_ctl2_reg(const struct intel_crtc_state *crtc_state)
 {
 	enum pipe pipe = to_intel_crtc(crtc_state->uapi.crtc)->pipe;
-	if (crtc_state->cpu_transcoder == TRANSCODER_EDP)
+	return is_pipe_dsc(crtc_state) ? ICL_PIPE_DSS_CTL2(pipe) : DSS_CTL2;
-		return DSS_CTL2;
-	return ICL_PIPE_DSS_CTL2(pipe);
 }
 void intel_dsc_enable(struct intel_encoder *encoder,

drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c+12−1

@@ -316,7 +316,18 @@ void i915_vma_revoke_fence(struct i915_vma *vma) · 315 unmodified lines
316	WRITE_ONCE(fence->vma, NULL);	316	WRITE_ONCE(fence->vma, NULL);
317	vma->fence = NULL;	317	vma->fence = NULL;
318		318
319	with_intel_runtime_pm_if_in_use(fence_to_uncore(fence)->rpm, wakeref)	319	/*
		320	* Skip the write to HW if and only if the device is currently
		321	* suspended.
		322	*
		323	* If the driver does not currently hold a wakeref (if_in_use == 0),
		324	* the device may currently be runtime suspended, or it may be woken
		325	* up before the suspend takes place. If the device is not suspended
		326	* (powered down) and we skip clearing the fence register, the HW is
		327	* left in an undefined state where we may end up with multiple
		328	* registers overlapping.
		329	*/
		330	with_intel_runtime_pm_if_active(fence_to_uncore(fence)->rpm, wakeref)
320	fence_write(fence);	331	fence_write(fence);
321	}	332	}
322		333

drivers/gpu/drm/i915/intel_runtime_pm.c+24−5

 }
 /**
- * intel_runtime_pm_get_if_in_use - grab a runtime pm reference if device in use
+ * __intel_runtime_pm_get_if_active - grab a runtime pm reference if device is active
  * @rpm: the intel_runtime_pm structure
+ * @ignore_usecount: get a ref even if dev->power.usage_count is 0
  *
  * This function grabs a device-level runtime pm reference if the device is
- * already in use and ensures that it is powered up. It is illegal to try
+ * already active and ensures that it is powered up. It is illegal to try
- * and access the HW should intel_runtime_pm_get_if_in_use() report failure.
+ * and access the HW should intel_runtime_pm_get_if_active() report failure.
+ *
+ * If @ignore_usecount=true, a reference will be acquired even if there is no
+ * user requiring the device to be powered up (dev->power.usage_count == 0).
+ * If the function returns false in this case then it's guaranteed that the
+ * device's runtime suspend hook has been called already or that it will be
+ * called (and hence it's also guaranteed that the device's runtime resume
+ * hook will be called eventually).
  *
  * Any runtime pm reference obtained by this function must have a symmetric
  * call to intel_runtime_pm_put() to release the reference again.
  * Returns: the wakeref cookie to pass to intel_runtime_pm_put(), evaluates
  * as True if the wakeref was acquired, or False otherwise.
  */
-intel_wakeref_t intel_runtime_pm_get_if_in_use(struct intel_runtime_pm *rpm)
+static intel_wakeref_t __intel_runtime_pm_get_if_active(struct intel_runtime_pm *rpm,
+							bool ignore_usecount)
 {
 	if (IS_ENABLED(CONFIG_PM)) {
 		/*
 		 * function, since the power state is undefined. This applies
 		 * atm to the late/early system suspend/resume handlers.
 		 */
-		if (pm_runtime_get_if_in_use(rpm->kdev) <= 0)
+		if (pm_runtime_get_if_active(rpm->kdev, ignore_usecount) <= 0)
 			return 0;
 	}
 	return track_intel_runtime_pm_wakeref(rpm);
 }
+intel_wakeref_t intel_runtime_pm_get_if_in_use(struct intel_runtime_pm *rpm)
+{
+	return __intel_runtime_pm_get_if_active(rpm, false);
+}
+intel_wakeref_t intel_runtime_pm_get_if_active(struct intel_runtime_pm *rpm)
+{
+	return __intel_runtime_pm_get_if_active(rpm, true);
+}
 /**
  * intel_runtime_pm_get_noresume - grab a runtime pm reference
  * @rpm: the intel_runtime_pm structure

drivers/gpu/drm/i915/intel_runtime_pm.h+5−0

 intel_wakeref_t intel_runtime_pm_get(struct intel_runtime_pm *rpm);
 intel_wakeref_t intel_runtime_pm_get_if_in_use(struct intel_runtime_pm *rpm);
+intel_wakeref_t intel_runtime_pm_get_if_active(struct intel_runtime_pm *rpm);
 intel_wakeref_t intel_runtime_pm_get_noresume(struct intel_runtime_pm *rpm);
 intel_wakeref_t intel_runtime_pm_get_raw(struct intel_runtime_pm *rpm);
 	for ((wf) = intel_runtime_pm_get_if_in_use(rpm); (wf); \
 	     intel_runtime_pm_put((rpm), (wf)), (wf) = 0)
+#define with_intel_runtime_pm_if_active(rpm, wf) \
+	for ((wf) = intel_runtime_pm_get_if_active(rpm); (wf); \
+	     intel_runtime_pm_put((rpm), (wf)), (wf) = 0)
 void intel_runtime_pm_put_unchecked(struct intel_runtime_pm *rpm);
 #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)
 void intel_runtime_pm_put(struct intel_runtime_pm *rpm, intel_wakeref_t wref);

drivers/gpu/drm/imx/imx-drm-core.c+1−1

@@ -215,7 +215,7 @@ static int imx_drm_bind(struct device *dev) · 214 unmodified lines
215		215
216	ret = drmm_mode_config_init(drm);	216	ret = drmm_mode_config_init(drm);
217	if (ret)	217	if (ret)
218	return ret;	218	goto err_kms;
219		219
220	ret = drm_vblank_init(drm, MAX_CRTC);	220	ret = drm_vblank_init(drm, MAX_CRTC);
221	if (ret)	221	if (ret)

drivers/gpu/drm/imx/imx-ldb.c+11−1

 	int dual = ldb->ldb_ctrl & LDB_SPLIT_MODE_EN;
 	int mux = drm_of_encoder_active_port_id(imx_ldb_ch->child, encoder);
+	if (mux < 0 || mux >= ARRAY_SIZE(ldb->clk_sel)) {
+		dev_warn(ldb->dev, "%s: invalid mux %d\n", __func__, mux);
+		return;
+	}
 	drm_panel_prepare(imx_ldb_ch->panel);
 	if (dual) {
 	int mux = drm_of_encoder_active_port_id(imx_ldb_ch->child, encoder);
 	u32 bus_format = imx_ldb_ch->bus_format;
+	if (mux < 0 || mux >= ARRAY_SIZE(ldb->clk_sel)) {
+		dev_warn(ldb->dev, "%s: invalid mux %d\n", __func__, mux);
+		return;
+	}
 	if (mode->clock > 170000) {
 		dev_warn(ldb->dev,
 			 "%s: mode exceeds 170 MHz pixel clock\n", __func__);
 		struct imx_ldb_channel *channel = &imx_ldb->channel[i];
 		if (!channel->ldb)
-			break;
+			continue;
 		ret = imx_ldb_register(drm, channel);
 		if (ret)

drivers/gpu/drm/msm/adreno/a5xx_power.c+1−1

@@ -304,7 +304,7 @@ int a5xx_power_init(struct msm_gpu *gpu) · 303 unmodified lines
304	/* Set up the limits management */	304	/* Set up the limits management */
305	if (adreno_is_a530(adreno_gpu))	305	if (adreno_is_a530(adreno_gpu))
306	a530_lm_setup(gpu);	306	a530_lm_setup(gpu);
307	else	307	else if (adreno_is_a540(adreno_gpu))
308	a540_lm_setup(gpu);	308	a540_lm_setup(gpu);
309		309
310	/* Set up SP/TP power collpase */	310	/* Set up SP/TP power collpase */

drivers/gpu/drm/msm/adreno/a6xx_gmu.c+1−1

@@ -339,7 +339,7 @@ void a6xx_gmu_clear_oob(struct a6xx_gmu *gmu, enum a6xx_gmu_oob_state state) · 338 unmodified lines
339	else	339	else
340	bit = a6xx_gmu_oob_bits[state].ack_new;	340	bit = a6xx_gmu_oob_bits[state].ack_new;
341		341
342	gmu_write(gmu, REG_A6XX_GMU_HOST2GMU_INTR_SET, bit);	342	gmu_write(gmu, REG_A6XX_GMU_HOST2GMU_INTR_SET, 1 << bit);
343	}	343	}
344		344
345	/* Enable CPU control of SPTP power power collapse */	345	/* Enable CPU control of SPTP power power collapse */

drivers/gpu/drm/msm/adreno/a6xx_gpu.c+72−36

@@ -522,28 +522,73 @@ static int a6xx_cp_init(struct msm_gpu *gpu) · 521 unmodified lines
522	return a6xx_idle(gpu, ring) ? 0 : -EINVAL;	522	return a6xx_idle(gpu, ring) ? 0 : -EINVAL;
523	}	523	}
524		524
525	static void a6xx_ucode_check_version(struct a6xx_gpu *a6xx_gpu,	525	/*
		526	* Check that the microcode version is new enough to include several key
		527	* security fixes. Return true if the ucode is safe.
		528	*/
		529	static bool a6xx_ucode_check_version(struct a6xx_gpu *a6xx_gpu,
526	struct drm_gem_object *obj)	530	struct drm_gem_object *obj)
527	{	531	{
		532	struct adreno_gpu *adreno_gpu = &a6xx_gpu->base;
		533	struct msm_gpu *gpu = &adreno_gpu->base;
528	u32 *buf = msm_gem_get_vaddr(obj);	534	u32 *buf = msm_gem_get_vaddr(obj);
		535	bool ret = false;
529		536
530	if (IS_ERR(buf))	537	if (IS_ERR(buf))
531	return;	538	return false;
532		539
533	/*	540	/*
534	* If the lowest nibble is 0xa that is an indication that this microcode	541	* Targets up to a640 (a618, a630 and a640) need to check for a
535	* has been patched. The actual version is in dword [3] but we only care	542	* microcode version that is patched to support the whereami opcode or
536	* about the patchlevel which is the lowest nibble of dword [3]	543	* one that is new enough to include it by default.
537	*
538	* Otherwise check that the firmware is greater than or equal to 1.90
539	* which was the first version that had this fix built in
540	*/	544	*/
541	if (((buf[0] & 0xf) == 0xa) && (buf[2] & 0xf) >= 1)	545	if (adreno_is_a618(adreno_gpu) \|\| adreno_is_a630(adreno_gpu) \|\|
542	a6xx_gpu->has_whereami = true;	546	adreno_is_a640(adreno_gpu)) {
543	else if ((buf[0] & 0xfff) > 0x190)	547	/*
544	a6xx_gpu->has_whereami = true;	548	* If the lowest nibble is 0xa that is an indication that this
		549	* microcode has been patched. The actual version is in dword
		550	* [3] but we only care about the patchlevel which is the lowest
		551	* nibble of dword [3]
		552	*
		553	* Otherwise check that the firmware is greater than or equal
		554	* to 1.90 which was the first version that had this fix built
		555	* in
		556	*/
		557	if ((((buf[0] & 0xf) == 0xa) && (buf[2] & 0xf) >= 1) \|\|
		558	(buf[0] & 0xfff) >= 0x190) {
		559	a6xx_gpu->has_whereami = true;
		560	ret = true;
		561	goto out;
		562	}
		563
		564	DRM_DEV_ERROR(&gpu->pdev->dev,
		565	"a630 SQE ucode is too old. Have version %x need at least %x\n",
		566	buf[0] & 0xfff, 0x190);
		567	} else {
		568	/*
		569	* a650 tier targets don't need whereami but still need to be
		570	* equal to or newer than 1.95 for other security fixes
		571	*/
		572	if (adreno_is_a650(adreno_gpu)) {
		573	if ((buf[0] & 0xfff) >= 0x195) {
		574	ret = true;
		575	goto out;
		576	}
		577
		578	DRM_DEV_ERROR(&gpu->pdev->dev,
		579	"a650 SQE ucode is too old. Have version %x need at least %x\n",
		580	buf[0] & 0xfff, 0x195);
		581	}
545		582
		583	/*
		584	* When a660 is added those targets should return true here
		585	* since those have all the critical security fixes built in
		586	* from the start
		587	*/
		588	}
		589	out:
546	msm_gem_put_vaddr(obj);	590	msm_gem_put_vaddr(obj);
		591	return ret;
547	}	592	}
548		593
549	static int a6xx_ucode_init(struct msm_gpu *gpu)	594	static int a6xx_ucode_init(struct msm_gpu *gpu)
@@ -566,7 +611,13 @@ static int a6xx_ucode_init(struct msm_gpu *gpu) · 16 unmodified lines
566	}	611	}
567		612
568	msm_gem_object_set_name(a6xx_gpu->sqe_bo, "sqefw");	613	msm_gem_object_set_name(a6xx_gpu->sqe_bo, "sqefw");
569	a6xx_ucode_check_version(a6xx_gpu, a6xx_gpu->sqe_bo);	614	if (!a6xx_ucode_check_version(a6xx_gpu, a6xx_gpu->sqe_bo)) {
		615	msm_gem_unpin_iova(a6xx_gpu->sqe_bo, gpu->aspace);
		616	drm_gem_object_put(a6xx_gpu->sqe_bo);
		617
		618	a6xx_gpu->sqe_bo = NULL;
		619	return -EPERM;
		620	}
570	}	621	}
571		622
572	gpu_write64(gpu, REG_A6XX_CP_SQE_INSTR_BASE_LO,	623	gpu_write64(gpu, REG_A6XX_CP_SQE_INSTR_BASE_LO,
@@ -1350,35 +1401,20 @@ static int a6xx_set_supported_hw(struct device dev, struct a6xx_gpu a6xx_gpu, · 777 unmodified lines
1350	u32 revn)	1401	u32 revn)
1351	{	1402	{
1352	struct opp_table *opp_table;	1403	struct opp_table *opp_table;
1353	struct nvmem_cell *cell;
1354	u32 supp_hw = UINT_MAX;	1404	u32 supp_hw = UINT_MAX;
1355	void *buf;	1405	u16 speedbin;
1356		1406	int ret;
1357	cell = nvmem_cell_get(dev, "speed_bin");
1358	/*
1359	* -ENOENT means that the platform doesn't support speedbin which is
1360	* fine
1361	*/
1362	if (PTR_ERR(cell) == -ENOENT)
1363	return 0;
1364	else if (IS_ERR(cell)) {
1365	DRM_DEV_ERROR(dev,
1366	"failed to read speed-bin. Some OPPs may not be supported by hardware");
1367	goto done;
1368	}
1369		1407
1370	buf = nvmem_cell_read(cell, NULL);	1408	ret = nvmem_cell_read_u16(dev, "speed_bin", &speedbin);
1371	if (IS_ERR(buf)) {	1409	if (ret) {
1372	nvmem_cell_put(cell);
1373	DRM_DEV_ERROR(dev,	1410	DRM_DEV_ERROR(dev,
1374	"failed to read speed-bin. Some OPPs may not be supported by hardware");	1411	"failed to read speed-bin (%d). Some OPPs may not be supported by hardware",
		1412	ret);
1375	goto done;	1413	goto done;
1376	}	1414	}
		1415	speedbin = le16_to_cpu(speedbin);
1377		1416
1378	supp_hw = fuse_to_supp_hw(dev, revn, ((u32 ) buf));	1417	supp_hw = fuse_to_supp_hw(dev, revn, speedbin);
1379
1380	kfree(buf);
1381	nvmem_cell_put(cell);
1382		1418
1383	done:	1419	done:
1384	opp_table = dev_pm_opp_set_supported_hw(dev, &supp_hw, 1);	1420	opp_table = dev_pm_opp_set_supported_hw(dev, &supp_hw, 1);

drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c+7−5

 #define DPU_DEBUGFS_DIR "msm_dpu"
 #define DPU_DEBUGFS_HWMASKNAME "hw_log_mask"
+#define MIN_IB_BW	400000000ULL /* Min ib vote 400MB */
 static int dpu_kms_hw_init(struct msm_kms *kms);
 static void _dpu_kms_mmu_destroy(struct dpu_kms *dpu_kms);
 		DPU_DEBUG("REG_DMA is not defined");
 	}
+	if (of_device_is_compatible(dev->dev->of_node, "qcom,sc7180-mdss"))
+		dpu_kms_parse_data_bus_icc_path(dpu_kms);
 	pm_runtime_get_sync(&dpu_kms->pdev->dev);
 	dpu_kms->core_rev = readl_relaxed(dpu_kms->mmio + 0x0);
 	dpu_vbif_init_memtypes(dpu_kms);
-	if (of_device_is_compatible(dev->dev->of_node, "qcom,sc7180-mdss"))
-		dpu_kms_parse_data_bus_icc_path(dpu_kms);
 	pm_runtime_put_sync(&dpu_kms->pdev->dev);
 	return 0;
 	ddev = dpu_kms->dev;
+	WARN_ON(!(dpu_kms->num_paths));
 	/* Min vote of BW is required before turning on AXI clk */
 	for (i = 0; i < dpu_kms->num_paths; i++)
-		icc_set_bw(dpu_kms->path[i], 0,
+		icc_set_bw(dpu_kms->path[i], 0, Bps_to_icc(MIN_IB_BW));
-			dpu_kms->catalog->perf.min_dram_ib);
 	rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, true);
 	if (rc) {

drivers/gpu/drm/msm/dp/dp_aux.c+7−0

 	struct drm_dp_aux dp_aux;
 };
+#define MAX_AUX_RETRIES			5
 static const char *dp_aux_get_error(u32 aux_error)
 {
 	switch (aux_error) {
 	ret = dp_aux_cmd_fifo_tx(aux, msg);
 	if (ret < 0) {
+		if (aux->native) {
+			aux->retry_cnt++;
+			if (!(aux->retry_cnt % MAX_AUX_RETRIES))
+				dp_catalog_aux_update_cfg(aux->catalog);
+		}
 		usleep_range(400, 500); /* at least 400us to next try */
 		goto unlock_exit;
 	}

drivers/gpu/drm/msm/dsi/pll/dsi_pll.c+1−1

@@ -163,7 +163,7 @@ struct msm_dsi_pll msm_dsi_pll_init(struct platform_device pdev, · 162 unmodified lines
163	break;	163	break;
164	case MSM_DSI_PHY_7NM:	164	case MSM_DSI_PHY_7NM:
165	case MSM_DSI_PHY_7NM_V4_1:	165	case MSM_DSI_PHY_7NM_V4_1:
166	pll = msm_dsi_pll_7nm_init(pdev, id);	166	pll = msm_dsi_pll_7nm_init(pdev, type, id);
167	break;	167	break;
168	default:	168	default:
169	pll = ERR_PTR(-ENXIO);	169	pll = ERR_PTR(-ENXIO);

drivers/gpu/drm/msm/dsi/pll/dsi_pll.h+4−2

 }
 #endif
 #ifdef CONFIG_DRM_MSM_DSI_7NM_PHY
-struct msm_dsi_pll *msm_dsi_pll_7nm_init(struct platform_device *pdev, int id);
+struct msm_dsi_pll *msm_dsi_pll_7nm_init(struct platform_device *pdev,
+					enum msm_dsi_phy_type type, int id);
 #else
 static inline struct msm_dsi_pll *
-msm_dsi_pll_7nm_init(struct platform_device *pdev, int id)
+msm_dsi_pll_7nm_init(struct platform_device *pdev,
+					enum msm_dsi_phy_type type, int id)
 {
 	return ERR_PTR(-ENODEV);
 }

drivers/gpu/drm/msm/dsi/pll/dsi_pll_7nm.c+6−5

 	pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_LOW_1, reg->frac_div_start_low);
 	pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_MID_1, reg->frac_div_start_mid);
 	pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_HIGH_1, reg->frac_div_start_high);
-	pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCKDET_RATE_1, 0x40);
+	pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCKDET_RATE_1, reg->pll_lockdet_rate);
 	pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCK_DELAY, 0x06);
 	pll_write(base + REG_DSI_7nm_PHY_PLL_CMODE_1, 0x10); /* TODO: 0x00 for CPHY */
 	pll_write(base + REG_DSI_7nm_PHY_PLL_CLOCK_INVERTERS, reg->pll_clock_inverters);
 {
 	struct msm_dsi_pll *pll = hw_clk_to_pll(hw);
 	struct dsi_pll_7nm *pll_7nm = to_pll_7nm(pll);
+	struct dsi_pll_config *config = &pll_7nm->pll_configuration;
 	void __iomem *base = pll_7nm->mmio;
 	u64 ref_clk = pll_7nm->vco_ref_clk_rate;
 	u64 vco_rate = 0x0;
 	/*
 	 * TODO:
 	 *	1. Assumes prescaler is disabled
-	 *	2. Multiplier is 2^18. it should be 2^(num_of_frac_bits)
 	 */
-	multiplier = 1 << 18;
+	multiplier = 1 << config->frac_bits;
 	pll_freq = dec * (ref_clk * 2);
 	tmp64 = (ref_clk * 2 * frac);
 	pll_freq += div_u64(tmp64, multiplier);
 	return ret;
 }
-struct msm_dsi_pll *msm_dsi_pll_7nm_init(struct platform_device *pdev, int id)
+struct msm_dsi_pll *msm_dsi_pll_7nm_init(struct platform_device *pdev,
+					enum msm_dsi_phy_type type, int id)
 {
 	struct dsi_pll_7nm *pll_7nm;
 	struct msm_dsi_pll *pll;
 	pll = &pll_7nm->base;
 	pll->min_rate = 1000000000UL;
 	pll->max_rate = 3500000000UL;
-	if (pll->type == MSM_DSI_PHY_7NM_V4_1) {
+	if (type == MSM_DSI_PHY_7NM_V4_1) {
 		pll->min_rate = 600000000UL;
 		pll->max_rate = (unsigned long)5000000000ULL;
 		/* workaround for max rate overflowing on 32-bit builds: */

drivers/gpu/drm/msm/msm_atomic.c+5−2

 static void lock_crtcs(struct msm_kms *kms, unsigned int crtc_mask)
 {
+	int crtc_index;
 	struct drm_crtc *crtc;
-	for_each_crtc_mask(kms->dev, crtc, crtc_mask)
+	for_each_crtc_mask(kms->dev, crtc, crtc_mask) {
-		mutex_lock(&kms->commit_lock[drm_crtc_index(crtc)]);
+		crtc_index = drm_crtc_index(crtc);
+		mutex_lock_nested(&kms->commit_lock[crtc_index], crtc_index);
+	}
 }
 static void unlock_crtcs(struct msm_kms *kms, unsigned int crtc_mask)

drivers/gpu/drm/msm/msm_drv.c+12−0

 static int __maybe_unused msm_pm_prepare(struct device *dev)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
+	struct msm_drm_private *priv = ddev ? ddev->dev_private : NULL;
+	if (!priv || !priv->kms)
+		return 0;
 	return drm_mode_config_helper_suspend(ddev);
 }
 static void __maybe_unused msm_pm_complete(struct device *dev)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
+	struct msm_drm_private *priv = ddev ? ddev->dev_private : NULL;
+	if (!priv || !priv->kms)
+		return;
 	drm_mode_config_helper_resume(ddev);
 }
 static void msm_pdev_shutdown(struct platform_device *pdev)
 {
 	struct drm_device *drm = platform_get_drvdata(pdev);
+	struct msm_drm_private *priv = drm ? drm->dev_private : NULL;
+	if (!priv || !priv->kms)
+		return;
 	drm_atomic_helper_shutdown(drm);
 }

drivers/gpu/drm/msm/msm_fence.c+1−1

@@ -45,7 +45,7 @@ int msm_wait_fence(struct msm_fence_context *fctx, uint32_t fence, · 44 unmodified lines
45	int ret;	45	int ret;
46		46
47	if (fence > fctx->last_fence) {	47	if (fence > fctx->last_fence) {
48	DRM_ERROR("%s: waiting on invalid fence: %u (of %u)\n",	48	DRM_ERROR_RATELIMITED("%s: waiting on invalid fence: %u (of %u)\n",
49	fctx->name, fence, fctx->last_fence);	49	fctx->name, fence, fctx->last_fence);
50	return -EINVAL;	50	return -EINVAL;
51	}	51	}

drivers/gpu/drm/msm/msm_kms.h+2−6

 	 * from the crtc's pending_timer close to end of the frame:
 	 */
 	struct mutex commit_lock[MAX_CRTCS];
-	struct lock_class_key commit_lock_keys[MAX_CRTCS];
 	unsigned pending_crtc_mask;
 	struct msm_pending_timer pending_timers[MAX_CRTCS];
 };
 {
 	unsigned i, ret;
-	for (i = 0; i < ARRAY_SIZE(kms->commit_lock); i++) {
+	for (i = 0; i < ARRAY_SIZE(kms->commit_lock); i++)
-		lockdep_register_key(&kms->commit_lock_keys[i]);
+		mutex_init(&kms->commit_lock[i]);
-		__mutex_init(&kms->commit_lock[i], "&kms->commit_lock[i]",
-			     &kms->commit_lock_keys[i]);
-	}
 	kms->funcs = funcs;

drivers/gpu/drm/nouveau/dispnv50/disp.c+12−1

@@ -2693,9 +2693,20 @@ nv50_display_create(struct drm_device *dev) · 2692 unmodified lines
2693	else	2693	else
2694	nouveau_display(dev)->format_modifiers = disp50xx_modifiers;	2694	nouveau_display(dev)->format_modifiers = disp50xx_modifiers;
2695		2695
2696	if (disp->disp->object.oclass >= GK104_DISP) {	2696	/* FIXME: 256x256 cursors are supported on Kepler, however unlike Maxwell and later
		2697	* generations Kepler requires that we use small pages (4K) for cursor scanout surfaces. The
		2698	* proper fix for this is to teach nouveau to migrate fbs being used for the cursor plane to
		2699	* small page allocations in prepare_fb(). When this is implemented, we should also force
		2700	* large pages (128K) for ovly fbs in order to fix Kepler ovlys.
		2701	* But until then, just limit cursors to 128x128 - which is small enough to avoid ever using
		2702	* large pages.
		2703	*/
		2704	if (disp->disp->object.oclass >= GM107_DISP) {
2697	dev->mode_config.cursor_width = 256;	2705	dev->mode_config.cursor_width = 256;
2698	dev->mode_config.cursor_height = 256;	2706	dev->mode_config.cursor_height = 256;
		2707	} else if (disp->disp->object.oclass >= GK104_DISP) {
		2708	dev->mode_config.cursor_width = 128;
		2709	dev->mode_config.cursor_height = 128;
2699	} else {	2710	} else {
2700	dev->mode_config.cursor_width = 64;	2711	dev->mode_config.cursor_width = 64;
2701	dev->mode_config.cursor_height = 64;	2712	dev->mode_config.cursor_height = 64;

drivers/gpu/drm/rcar-du/rcar_du_encoder.c+6−25

 static const struct drm_encoder_funcs rcar_du_encoder_funcs = {
 };
-static void rcar_du_encoder_release(struct drm_device *dev, void *res)
-{
-	struct rcar_du_encoder *renc = res;
-	drm_encoder_cleanup(&renc->base);
-	kfree(renc);
-}
 int rcar_du_encoder_init(struct rcar_du_device *rcdu,
 			 enum rcar_du_output output,
 			 struct device_node *enc_node)
 {
 	struct rcar_du_encoder *renc;
 	struct drm_bridge *bridge;
-	int ret;
 	/*
 	 * Locate the DRM bridge from the DT node. For the DPAD outputs, if the
 			return -ENOLINK;
 	}
-	renc = kzalloc(sizeof(*renc), GFP_KERNEL);
-	if (renc == NULL)
-		return -ENOMEM;
-	renc->output = output;
 	dev_dbg(rcdu->dev, "initializing encoder %pOF for output %u\n",
 		enc_node, output);
-	ret = drm_encoder_init(&rcdu->ddev, &renc->base, &rcar_du_encoder_funcs,
+	renc = drmm_encoder_alloc(&rcdu->ddev, struct rcar_du_encoder, base,
-			       DRM_MODE_ENCODER_NONE, NULL);
+				  &rcar_du_encoder_funcs, DRM_MODE_ENCODER_NONE,
-	if (ret < 0) {
+				  NULL);
-		kfree(renc);
+	if (!renc)
-		return ret;
+		return -ENOMEM;
-	}
-	ret = drmm_add_action_or_reset(&rcdu->ddev, rcar_du_encoder_release,
+	renc->output = output;
-				       renc);
-	if (ret)
-		return ret;
 	/*
 	 * Attach the bridge to the encoder. The bridge will create the

drivers/gpu/drm/tegra/dc.c+13−17

 			dev_err(dc->dev,
 				"failed to set clock rate to %lu Hz\n",
 				state->pclk);
+		err = clk_set_rate(dc->clk, state->pclk);
+		if (err < 0)
+			dev_err(dc->dev, "failed to set clock %pC to %lu Hz: %d\n",
+				dc->clk, state->pclk, err);
 	}
 	DRM_DEBUG_KMS("rate: %lu, div: %u\n", clk_get_rate(dc->clk),
 		value = SHIFT_CLK_DIVIDER(state->div) | PIXEL_CLK_DIVIDER_PCD1;
 		tegra_dc_writel(dc, value, DC_DISP_DISP_CLOCK_CONTROL);
 	}
-	err = clk_set_rate(dc->clk, state->pclk);
-	if (err < 0)
-		dev_err(dc->dev, "failed to set clock %pC to %lu Hz: %d\n",
-			dc->clk, state->pclk, err);
 }
 static void tegra_dc_stop(struct tegra_dc *dc)
 	 * POWER_CONTROL registers during CRTC enabling.
 	 */
 	if (dc->soc->coupled_pm && dc->pipe == 1) {
-		u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER;
+		struct device *companion;
-		struct device_link *link;
+		struct tegra_dc *parent;
-		struct device *partner;
-		partner = driver_find_device(dc->dev->driver, NULL, NULL,
+		companion = driver_find_device(dc->dev->driver, NULL, (const void *)0,
-					     tegra_dc_match_by_pipe);
+					       tegra_dc_match_by_pipe);
-		if (!partner)
+		if (!companion)
 			return -EPROBE_DEFER;
-		link = device_link_add(dc->dev, partner, flags);
+		parent = dev_get_drvdata(companion);
-		if (!link) {
+		dc->client.parent = &parent->client;
-			dev_err(dc->dev, "failed to link controllers\n");
-			return -EINVAL;
-		}
-		dev_dbg(dc->dev, "coupled to %s\n", dev_name(partner));
+		dev_dbg(dc->dev, "coupled to %s\n", dev_name(companion));
 	}
 	return 0;

drivers/gpu/drm/tegra/sor.c+7−0

 	 * kernel is possible.
 	 */
 	if (sor->rst) {
+		err = pm_runtime_resume_and_get(sor->dev);
+		if (err < 0) {
+			dev_err(sor->dev, "failed to get runtime PM: %d\n", err);
+			return err;
+		}
 		err = reset_control_acquire(sor->rst);
 		if (err < 0) {
 			dev_err(sor->dev, "failed to acquire SOR reset: %d\n",
 		}
 		reset_control_release(sor->rst);
+		pm_runtime_put(sor->dev);
 	}
 	err = clk_prepare_enable(sor->clk_safe);

drivers/gpu/host1x/bus.c+6−4

 EXPORT_SYMBOL(host1x_driver_unregister);
 /**
- * host1x_client_register() - register a host1x client
+ * __host1x_client_register() - register a host1x client
  * @client: host1x client
+ * @key: lock class key for the client-specific mutex
  *
  * Registers a host1x client with each host1x controller instance. Note that
  * each client will only match their parent host1x controller and will only be
  * device and call host1x_device_init(), which will in turn call each client's
  * &host1x_client_ops.init implementation.
  */
-int host1x_client_register(struct host1x_client *client)
+int __host1x_client_register(struct host1x_client *client,
+			     struct lock_class_key *key)
 {
 	struct host1x *host1x;
 	int err;
 	INIT_LIST_HEAD(&client->list);
-	mutex_init(&client->lock);
+	__mutex_init(&client->lock, "host1x client lock", key);
 	client->usecount = 0;
 	mutex_lock(&devices_lock);
 	return 0;
 }
-EXPORT_SYMBOL(host1x_client_register);
+EXPORT_SYMBOL(__host1x_client_register);
 /**
  * host1x_client_unregister() - unregister a host1x client

drivers/infiniband/hw/cxgb4/cm.c+2−2

@@ -3610,13 +3610,13 @@ int c4iw_destroy_listen(struct iw_cm_id *cm_id) · 3609 unmodified lines
3610	ep->com.local_addr.ss_family == AF_INET) {	3610	ep->com.local_addr.ss_family == AF_INET) {
3611	err = cxgb4_remove_server_filter(	3611	err = cxgb4_remove_server_filter(
3612	ep->com.dev->rdev.lldi.ports[0], ep->stid,	3612	ep->com.dev->rdev.lldi.ports[0], ep->stid,
3613	ep->com.dev->rdev.lldi.rxq_ids[0], 0);	3613	ep->com.dev->rdev.lldi.rxq_ids[0], false);
3614	} else {	3614	} else {
3615	struct sockaddr_in6 *sin6;	3615	struct sockaddr_in6 *sin6;
3616	c4iw_init_wr_wait(ep->com.wr_waitp);	3616	c4iw_init_wr_wait(ep->com.wr_waitp);
3617	err = cxgb4_remove_server(	3617	err = cxgb4_remove_server(
3618	ep->com.dev->rdev.lldi.ports[0], ep->stid,	3618	ep->com.dev->rdev.lldi.ports[0], ep->stid,
3619	ep->com.dev->rdev.lldi.rxq_ids[0], 0);	3619	ep->com.dev->rdev.lldi.rxq_ids[0], true);
3620	if (err)	3620	if (err)
3621	goto done;	3621	goto done;
3622	err = c4iw_wait_for_reply(&ep->com.dev->rdev, ep->com.wr_waitp,	3622	err = c4iw_wait_for_reply(&ep->com.dev->rdev, ep->com.wr_waitp,

drivers/infiniband/hw/hns/hns_roce_hw_v2.c+3−1

@@ -1194,8 +1194,10 @@ static void hns_roce_cmq_init_regs(struct hns_roce_dev *hr_dev, bool ring_type) · 1193 unmodified lines
1194	upper_32_bits(dma));	1194	upper_32_bits(dma));
1195	roce_write(hr_dev, ROCEE_TX_CMQ_DEPTH_REG,	1195	roce_write(hr_dev, ROCEE_TX_CMQ_DEPTH_REG,
1196	(u32)ring->desc_num >> HNS_ROCE_CMQ_DESC_NUM_S);	1196	(u32)ring->desc_num >> HNS_ROCE_CMQ_DESC_NUM_S);
1197	roce_write(hr_dev, ROCEE_TX_CMQ_HEAD_REG, 0);	1197
		1198	/* Make sure to write tail first and then head */
1198	roce_write(hr_dev, ROCEE_TX_CMQ_TAIL_REG, 0);	1199	roce_write(hr_dev, ROCEE_TX_CMQ_TAIL_REG, 0);
		1200	roce_write(hr_dev, ROCEE_TX_CMQ_HEAD_REG, 0);
1199	} else {	1201	} else {
1200	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_L_REG, (u32)dma);	1202	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_L_REG, (u32)dma);
1201	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_H_REG,	1203	roce_write(hr_dev, ROCEE_RX_CMQ_BASEADDR_H_REG,

drivers/infiniband/hw/mlx5/devx.c+1−1

@@ -1116,7 +1116,7 @@ static void devx_obj_build_destroy_cmd(void in, void out, void *din, · 1115 unmodified lines
1116	case MLX5_CMD_OP_CREATE_MKEY:	1116	case MLX5_CMD_OP_CREATE_MKEY:
1117	MLX5_SET(destroy_mkey_in, din, opcode,	1117	MLX5_SET(destroy_mkey_in, din, opcode,
1118	MLX5_CMD_OP_DESTROY_MKEY);	1118	MLX5_CMD_OP_DESTROY_MKEY);
1119	MLX5_SET(destroy_mkey_in, in, mkey_index, *obj_id);	1119	MLX5_SET(destroy_mkey_in, din, mkey_index, *obj_id);
1120	break;	1120	break;
1121	case MLX5_CMD_OP_CREATE_CQ:	1121	case MLX5_CMD_OP_CREATE_CQ:
1122	MLX5_SET(destroy_cq_in, din, opcode, MLX5_CMD_OP_DESTROY_CQ);	1122	MLX5_SET(destroy_cq_in, din, opcode, MLX5_CMD_OP_DESTROY_CQ);

drivers/infiniband/hw/mlx5/qp.c+14−4

 	qpc = MLX5_ADDR_OF(create_qp_in, *in, qpc);
 	MLX5_SET(qpc, qpc, uar_page, uar_index);
-	MLX5_SET(qpc, qpc, ts_format, MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(dev->mdev));
 	MLX5_SET(qpc, qpc, log_page_size, qp->buf.page_shift - MLX5_ADAPTER_PAGE_SHIFT);
 	/* Set "fast registration enabled" for all kernel QPs */
 		}
 		return MLX5_RQC_TIMESTAMP_FORMAT_FREE_RUNNING;
 	}
-	return MLX5_RQC_TIMESTAMP_FORMAT_DEFAULT;
+	return fr_supported ? MLX5_RQC_TIMESTAMP_FORMAT_FREE_RUNNING :
+			      MLX5_RQC_TIMESTAMP_FORMAT_DEFAULT;
 }
 static int get_sq_ts_format(struct mlx5_ib_dev *dev, struct mlx5_ib_cq *send_cq)
 		}
 		return MLX5_SQC_TIMESTAMP_FORMAT_FREE_RUNNING;
 	}
-	return MLX5_SQC_TIMESTAMP_FORMAT_DEFAULT;
+	return fr_supported ? MLX5_SQC_TIMESTAMP_FORMAT_FREE_RUNNING :
+			      MLX5_SQC_TIMESTAMP_FORMAT_DEFAULT;
 }
 static int get_qp_ts_format(struct mlx5_ib_dev *dev, struct mlx5_ib_cq *send_cq,
 			MLX5_QP_TIMESTAMP_FORMAT_CAP_FREE_RUNNING ||
 		MLX5_CAP_ROCE(dev->mdev, qp_ts_format) ==
 			MLX5_QP_TIMESTAMP_FORMAT_CAP_FREE_RUNNING_AND_REAL_TIME;
-	int ts_format = MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT;
+	int ts_format = fr_supported ? MLX5_QPC_TIMESTAMP_FORMAT_FREE_RUNNING :
+				       MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT;
 	if (recv_cq &&
 	    recv_cq->create_flags & IB_UVERBS_CQ_FLAGS_TIMESTAMP_COMPLETION)
 	if (qp->flags & IB_QP_CREATE_MANAGED_RECV)
 		MLX5_SET(qpc, qpc, cd_slave_receive, 1);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(dev->mdev));
 	MLX5_SET(qpc, qpc, rq_type, MLX5_SRQ_RQ);
 	MLX5_SET(qpc, qpc, no_sq, 1);
 	MLX5_SET(qpc, qpc, cqn_rcv, to_mcq(devr->c0)->mcq.cqn);
 	struct mlx5_ib_dev *dev;
 	int has_net_offloads;
 	__be64 *rq_pas0;
+	int ts_format;
 	void *in;
 	void *rqc;
 	void *wq;
 	dev = to_mdev(pd->device);
+	ts_format = get_rq_ts_format(dev, to_mcq(init_attr->cq));
+	if (ts_format < 0)
+		return ts_format;
 	inlen = MLX5_ST_SZ_BYTES(create_rq_in) + sizeof(u64) * rwq->rq_num_pas;
 	in = kvzalloc(inlen, GFP_KERNEL);
 	if (!in)
 	rqc = MLX5_ADDR_OF(create_rq_in, in, ctx);
 	MLX5_SET(rqc,  rqc, mem_rq_type,
 		 MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_INLINE);
+	MLX5_SET(rqc, rqc, ts_format, ts_format);
 	MLX5_SET(rqc, rqc, user_index, rwq->user_index);
 	MLX5_SET(rqc,  rqc, cqn, to_mcq(init_attr->cq)->mcq.cqn);
 	MLX5_SET(rqc,  rqc, state, MLX5_RQC_STATE_RST);

drivers/interconnect/bulk.c+1−1

@@ -53,7 +53,7 @@ void icc_bulk_put(int num_paths, struct icc_bulk_data *paths) · 52 unmodified lines
53	EXPORT_SYMBOL_GPL(icc_bulk_put);	53	EXPORT_SYMBOL_GPL(icc_bulk_put);
54		54
55	/**	55	/**
56	* icc_bulk_set() - set bandwidth to a set of paths	56	* icc_bulk_set_bw() - set bandwidth to a set of paths
57	* @num_paths: the number of icc_bulk_data	57	* @num_paths: the number of icc_bulk_data
58	* @paths: the icc_bulk_data table containing the paths and bandwidth	58	* @paths: the icc_bulk_data table containing the paths and bandwidth
59	*	59	*

drivers/interconnect/core.c+2−0

@@ -942,6 +942,8 @@ int icc_link_destroy(struct icc_node src, struct icc_node dst) · 941 unmodified lines
942	GFP_KERNEL);	942	GFP_KERNEL);
943	if (new)	943	if (new)
944	src->links = new;	944	src->links = new;
		945	else
		946	ret = -ENOMEM;
945		947
946	out:	948	out:
947	mutex_unlock(&icc_lock);	949	mutex_unlock(&icc_lock);

drivers/interconnect/qcom/msm8939.c+8−8

drivers/isdn/capi/kcapi.c+2−2

@@ -721,7 +721,7 @@ u16 capi20_put_message(struct capi20_appl ap, struct sk_buff skb) · 720 unmodified lines
721	* Return value: CAPI result code	721	* Return value: CAPI result code
722	*/	722	*/
723		723
724	u16 capi20_get_manufacturer(u32 contr, u8 *buf)	724	u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN])
725	{	725	{
726	struct capi_ctr *ctr;	726	struct capi_ctr *ctr;
727	u16 ret;	727	u16 ret;
@@ -787,7 +787,7 @@ u16 capi20_get_version(u32 contr, struct capi_version *verp) · 59 unmodified lines
787	* Return value: CAPI result code	787	* Return value: CAPI result code
788	*/	788	*/
789		789
790	u16 capi20_get_serial(u32 contr, u8 *serial)	790	u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN])
791	{	791	{
792	struct capi_ctr *ctr;	792	struct capi_ctr *ctr;
793	u16 ret;	793	u16 ret;

drivers/isdn/hardware/mISDN/mISDNipac.c+1−1

@@ -694,7 +694,7 @@ isac_release(struct isac_hw *isac) · 693 unmodified lines
694	{	694	{
695	if (isac->type & IPAC_TYPE_ISACX)	695	if (isac->type & IPAC_TYPE_ISACX)
696	WriteISAC(isac, ISACX_MASK, 0xff);	696	WriteISAC(isac, ISACX_MASK, 0xff);
697	else	697	else if (isac->type != 0)
698	WriteISAC(isac, ISAC_MASK, 0xff);	698	WriteISAC(isac, ISAC_MASK, 0xff);
699	if (isac->dch.timer.function != NULL) {	699	if (isac->dch.timer.function != NULL) {
700	del_timer(&isac->dch.timer);	700	del_timer(&isac->dch.timer);

drivers/md/dm-ioctl.c+1−1

@@ -529,7 +529,7 @@ static int list_devices(struct file filp, struct dm_ioctl param, size_t param_ · 528 unmodified lines
529	* Grab our output buffer.	529	* Grab our output buffer.
530	*/	530	*/
531	nl = orig_nl = get_result_buffer(param, param_size, &len);	531	nl = orig_nl = get_result_buffer(param, param_size, &len);
532	if (len < needed) {	532	if (len < needed \|\| len < sizeof(nl->dev)) {
533	param->flags \|= DM_BUFFER_FULL_FLAG;	533	param->flags \|= DM_BUFFER_FULL_FLAG;
534	goto out;	534	goto out;
535	}	535	}

drivers/md/dm-table.c+25−8

@@ -1594,6 +1594,13 @@ static int device_not_zoned_model(struct dm_target ti, struct dm_dev dev, · 1593 unmodified lines
1594	return blk_queue_zoned_model(q) != *zoned_model;	1594	return blk_queue_zoned_model(q) != *zoned_model;
1595	}	1595	}
1596		1596
		1597	/*
		1598	* Check the device zoned model based on the target feature flag. If the target
		1599	* has the DM_TARGET_ZONED_HM feature flag set, host-managed zoned devices are
		1600	* also accepted but all devices must have the same zoned model. If the target
		1601	* has the DM_TARGET_MIXED_ZONED_MODEL feature set, the devices can have any
		1602	* zoned model with all zoned devices having the same zone size.
		1603	*/
1597	static bool dm_table_supports_zoned_model(struct dm_table *t,	1604	static bool dm_table_supports_zoned_model(struct dm_table *t,
1598	enum blk_zoned_model zoned_model)	1605	enum blk_zoned_model zoned_model)
1599	{	1606	{
@@ -1603,13 +1610,15 @@ static bool dm_table_supports_zoned_model(struct dm_table *t, · 3 unmodified lines
1603	for (i = 0; i < dm_table_get_num_targets(t); i++) {	1610	for (i = 0; i < dm_table_get_num_targets(t); i++) {
1604	ti = dm_table_get_target(t, i);	1611	ti = dm_table_get_target(t, i);
1605		1612
1606	if (zoned_model == BLK_ZONED_HM &&	1613	if (dm_target_supports_zoned_hm(ti->type)) {
1607	!dm_target_supports_zoned_hm(ti->type))	1614	if (!ti->type->iterate_devices \|\|
1608	return false;	1615	ti->type->iterate_devices(ti, device_not_zoned_model,
1609		1616	&zoned_model))
1610	if (!ti->type->iterate_devices \|\|	1617	return false;
1611	ti->type->iterate_devices(ti, device_not_zoned_model, &zoned_model))	1618	} else if (!dm_target_supports_mixed_zoned_model(ti->type)) {
1612	return false;	1619	if (zoned_model == BLK_ZONED_HM)
		1620	return false;
		1621	}
1613	}	1622	}
1614		1623
1615	return true;	1624	return true;
@@ -1621,9 +1630,17 @@ static int device_not_matches_zone_sectors(struct dm_target ti, struct dm_dev · 5 unmodified lines
1621	struct request_queue *q = bdev_get_queue(dev->bdev);	1630	struct request_queue *q = bdev_get_queue(dev->bdev);
1622	unsigned int *zone_sectors = data;	1631	unsigned int *zone_sectors = data;
1623		1632
		1633	if (!blk_queue_is_zoned(q))
		1634	return 0;
		1635
1624	return blk_queue_zone_sectors(q) != *zone_sectors;	1636	return blk_queue_zone_sectors(q) != *zone_sectors;
1625	}	1637	}
1626		1638
		1639	/*
		1640	* Check consistency of zoned model and zone sectors across all targets. For
		1641	* zone sectors, if the destination device is a zoned block device, it shall
		1642	* have the specified zone_sectors.
		1643	*/
1627	static int validate_hardware_zoned_model(struct dm_table *table,	1644	static int validate_hardware_zoned_model(struct dm_table *table,
1628	enum blk_zoned_model zoned_model,	1645	enum blk_zoned_model zoned_model,
1629	unsigned int zone_sectors)	1646	unsigned int zone_sectors)
@@ -1642,7 +1659,7 @@ static int validate_hardware_zoned_model(struct dm_table *table, · 12 unmodified lines
1642	return -EINVAL;	1659	return -EINVAL;
1643		1660
1644	if (dm_table_any_dev_attr(table, device_not_matches_zone_sectors, &zone_sectors)) {	1661	if (dm_table_any_dev_attr(table, device_not_matches_zone_sectors, &zone_sectors)) {
1645	DMERR("%s: zone sectors is not consistent across all devices",	1662	DMERR("%s: zone sectors is not consistent across all zoned devices",
1646	dm_device_name(table->md));	1663	dm_device_name(table->md));
1647	return -EINVAL;	1664	return -EINVAL;
1648	}	1665	}

drivers/md/dm-verity-target.c+1−1

@@ -34,7 +34,7 @@ · 33 unmodified lines
34	#define DM_VERITY_OPT_IGN_ZEROES "ignore_zero_blocks"	34	#define DM_VERITY_OPT_IGN_ZEROES "ignore_zero_blocks"
35	#define DM_VERITY_OPT_AT_MOST_ONCE "check_at_most_once"	35	#define DM_VERITY_OPT_AT_MOST_ONCE "check_at_most_once"
36		36
37	#define DM_VERITY_OPTS_MAX (2 + DM_VERITY_OPTS_FEC + \	37	#define DM_VERITY_OPTS_MAX (3 + DM_VERITY_OPTS_FEC + \
38	DM_VERITY_ROOT_HASH_VERIFICATION_OPTS)	38	DM_VERITY_ROOT_HASH_VERIFICATION_OPTS)
39		39
40	static unsigned dm_verity_prefetch_cluster = DM_VERITY_DEFAULT_PREFETCH_SIZE;	40	static unsigned dm_verity_prefetch_cluster = DM_VERITY_DEFAULT_PREFETCH_SIZE;

drivers/md/dm-zoned-target.c+1−1

@@ -1143,7 +1143,7 @@ static int dmz_message(struct dm_target ti, unsigned int argc, char *argv, · 1142 unmodified lines
1143	static struct target_type dmz_type = {	1143	static struct target_type dmz_type = {
1144	.name = "zoned",	1144	.name = "zoned",
1145	.version = {2, 0, 0},	1145	.version = {2, 0, 0},
1146	.features = DM_TARGET_SINGLETON \| DM_TARGET_ZONED_HM,	1146	.features = DM_TARGET_SINGLETON \| DM_TARGET_MIXED_ZONED_MODEL,
1147	.module = THIS_MODULE,	1147	.module = THIS_MODULE,
1148	.ctr = dmz_ctr,	1148	.ctr = dmz_ctr,
1149	.dtr = dmz_dtr,	1149	.dtr = dmz_dtr,

drivers/md/dm.c+4−1

@@ -2036,7 +2036,10 @@ static struct dm_table __bind(struct mapped_device md, struct dm_table *t, · 2035 unmodified lines
2036	if (size != dm_get_size(md))	2036	if (size != dm_get_size(md))
2037	memset(&md->geometry, 0, sizeof(md->geometry));	2037	memset(&md->geometry, 0, sizeof(md->geometry));
2038		2038
2039	set_capacity_and_notify(md->disk, size);	2039	if (!get_capacity(md->disk))
		2040	set_capacity(md->disk, size);
		2041	else
		2042	set_capacity_and_notify(md->disk, size);
2040		2043
2041	dm_table_event_callback(t, event_callback, md);	2044	dm_table_event_callback(t, event_callback, md);
2042		2045

drivers/mfd/intel_quark_i2c_gpio.c+4−2

 	{}
 };
-static const struct resource intel_quark_i2c_res[] = {
+/* This is used as a place holder and will be modified at run-time */
+static struct resource intel_quark_i2c_res[] = {
 	[INTEL_QUARK_IORES_MEM] = {
 		.flags = IORESOURCE_MEM,
 	},
 	.adr = MFD_ACPI_MATCH_I2C,
 };
-static const struct resource intel_quark_gpio_res[] = {
+/* This is used as a place holder and will be modified at run-time */
+static struct resource intel_quark_gpio_res[] = {
 	[INTEL_QUARK_IORES_MEM] = {
 		.flags = IORESOURCE_MEM,
 	},

drivers/misc/mei/client.c+7−10

 	if (buffer_id == 0)
 		return -EINVAL;
-	if (!mei_cl_is_connected(cl))
+	if (mei_cl_is_connected(cl))
-		return -ENODEV;
+		return -EPROTO;
 	if (cl->dma_mapped)
 		return -EPROTO;
 	mutex_unlock(&dev->device_lock);
 	wait_event_timeout(cl->wait,
-			   cl->dma_mapped ||
+			   cl->dma_mapped || cl->status,
-			   cl->status ||
-			   !mei_cl_is_connected(cl),
 			   mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
 	mutex_lock(&dev->device_lock);
 		return -EOPNOTSUPP;
 	}
-	if (!mei_cl_is_connected(cl))
+	/* do not allow unmap for connected client */
-		return -ENODEV;
+	if (mei_cl_is_connected(cl))
+		return -EPROTO;
 	if (!cl->dma_mapped)
 		return -EPROTO;
 	mutex_unlock(&dev->device_lock);
 	wait_event_timeout(cl->wait,
-			   !cl->dma_mapped ||
+			   !cl->dma_mapped || cl->status,
-			   cl->status ||
-			   !mei_cl_is_connected(cl),
 			   mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
 	mutex_lock(&dev->device_lock);

drivers/net/arcnet/com20020-pci.c+19−15

@@ -127,6 +127,8 @@ static int com20020pci_probe(struct pci_dev *pdev, · 126 unmodified lines
127	int i, ioaddr, ret;	127	int i, ioaddr, ret;
128	struct resource *r;	128	struct resource *r;
129		129
		130	ret = 0;
		131
130	if (pci_enable_device(pdev))	132	if (pci_enable_device(pdev))
131	return -EIO;	133	return -EIO;
132		134
@@ -139,6 +141,8 @@ static int com20020pci_probe(struct pci_dev *pdev, · 6 unmodified lines
139	priv->ci = ci;	141	priv->ci = ci;
140	mm = &ci->misc_map;	142	mm = &ci->misc_map;
141		143
		144	pci_set_drvdata(pdev, priv);
		145
142	INIT_LIST_HEAD(&priv->list_dev);	146	INIT_LIST_HEAD(&priv->list_dev);
143		147
144	if (mm->size) {	148	if (mm->size) {
@@ -161,7 +165,7 @@ static int com20020pci_probe(struct pci_dev *pdev, · 16 unmodified lines
161	dev = alloc_arcdev(device);	165	dev = alloc_arcdev(device);
162	if (!dev) {	166	if (!dev) {
163	ret = -ENOMEM;	167	ret = -ENOMEM;
164	goto out_port;	168	break;
165	}	169	}
166	dev->dev_port = i;	170	dev->dev_port = i;
167		171
@@ -178,7 +182,7 @@ static int com20020pci_probe(struct pci_dev *pdev, · 10 unmodified lines
178	pr_err("IO region %xh-%xh already allocated\n",	182	pr_err("IO region %xh-%xh already allocated\n",
179	ioaddr, ioaddr + cm->size - 1);	183	ioaddr, ioaddr + cm->size - 1);
180	ret = -EBUSY;	184	ret = -EBUSY;
181	goto out_port;	185	goto err_free_arcdev;
182	}	186	}
183		187
184	/* Dummy access after Reset	188	/* Dummy access after Reset
@@ -216,18 +220,18 @@ static int com20020pci_probe(struct pci_dev *pdev, · 31 unmodified lines
216	if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) {	220	if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) {
217	pr_err("IO address %Xh is empty!\n", ioaddr);	221	pr_err("IO address %Xh is empty!\n", ioaddr);
218	ret = -EIO;	222	ret = -EIO;
219	goto out_port;	223	goto err_free_arcdev;
220	}	224	}
221	if (com20020_check(dev)) {	225	if (com20020_check(dev)) {
222	ret = -EIO;	226	ret = -EIO;
223	goto out_port;	227	goto err_free_arcdev;
224	}	228	}
225		229
226	card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev),	230	card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev),
227	GFP_KERNEL);	231	GFP_KERNEL);
228	if (!card) {	232	if (!card) {
229	ret = -ENOMEM;	233	ret = -ENOMEM;
230	goto out_port;	234	goto err_free_arcdev;
231	}	235	}
232		236
233	card->index = i;	237	card->index = i;
@@ -253,29 +257,29 @@ static int com20020pci_probe(struct pci_dev *pdev, · 19 unmodified lines
253		257
254	ret = devm_led_classdev_register(&pdev->dev, &card->tx_led);	258	ret = devm_led_classdev_register(&pdev->dev, &card->tx_led);
255	if (ret)	259	if (ret)
256	goto out_port;	260	goto err_free_arcdev;
257		261
258	ret = devm_led_classdev_register(&pdev->dev, &card->recon_led);	262	ret = devm_led_classdev_register(&pdev->dev, &card->recon_led);
259	if (ret)	263	if (ret)
260	goto out_port;	264	goto err_free_arcdev;
261		265
262	dev_set_drvdata(&dev->dev, card);	266	dev_set_drvdata(&dev->dev, card);
263		267
264	ret = com20020_found(dev, IRQF_SHARED);	268	ret = com20020_found(dev, IRQF_SHARED);
265	if (ret)	269	if (ret)
266	goto out_port;	270	goto err_free_arcdev;
267		271
268	devm_arcnet_led_init(dev, dev->dev_id, i);	272	devm_arcnet_led_init(dev, dev->dev_id, i);
269		273
270	list_add(&card->list, &priv->list_dev);	274	list_add(&card->list, &priv->list_dev);
271	}	275	continue;
272		276
273	pci_set_drvdata(pdev, priv);	277	err_free_arcdev:
274		278	free_arcdev(dev);
275	return 0;	279	break;
276		280	}
277	out_port:	281	if (ret)
278	com20020pci_remove(pdev);	282	com20020pci_remove(pdev);
279	return ret;	283	return ret;
280	}	284	}
281		285

drivers/net/bonding/bond_main.c+2−6

 	rcu_read_lock();
 	slave = bond_first_slave_rcu(bond);
-	if (!slave) {
+	if (!slave)
-		ret = -EINVAL;
 		goto out;
-	}
 	slave_ops = slave->dev->netdev_ops;
-	if (!slave_ops->ndo_neigh_setup) {
+	if (!slave_ops->ndo_neigh_setup)
-		ret = -EINVAL;
 		goto out;
-	}
 	/* TODO: find another way [1] to implement this.
 	 * Passing a zeroed structure is fragile,

drivers/net/can/c_can/c_can.c+1−23

 	.brp_inc = 1,
 };
-static inline void c_can_pm_runtime_enable(const struct c_can_priv *priv)
-{
-	if (priv->device)
-		pm_runtime_enable(priv->device);
-}
-static inline void c_can_pm_runtime_disable(const struct c_can_priv *priv)
-{
-	if (priv->device)
-		pm_runtime_disable(priv->device);
-}
 static inline void c_can_pm_runtime_get_sync(const struct c_can_priv *priv)
 {
 	if (priv->device)
 int register_c_can_dev(struct net_device *dev)
 {
-	struct c_can_priv *priv = netdev_priv(dev);
 	int err;
 	/* Deactivate pins to prevent DRA7 DCAN IP from being
 	 */
 	pinctrl_pm_select_sleep_state(dev->dev.parent);
-	c_can_pm_runtime_enable(priv);
 	dev->flags |= IFF_ECHO;	/* we support local echo */
 	dev->netdev_ops = &c_can_netdev_ops;
 	err = register_candev(dev);
-	if (err)
+	if (!err)
-		c_can_pm_runtime_disable(priv);
-	else
 		devm_can_led_init(dev);
 	return err;
 }
 EXPORT_SYMBOL_GPL(register_c_can_dev);
 void unregister_c_can_dev(struct net_device *dev)
 {
-	struct c_can_priv *priv = netdev_priv(dev);
 	unregister_candev(dev);
-	c_can_pm_runtime_disable(priv);
 }
 EXPORT_SYMBOL_GPL(unregister_c_can_dev);

drivers/net/can/c_can/c_can_pci.c+2−1

 {
 	struct net_device *dev = pci_get_drvdata(pdev);
 	struct c_can_priv *priv = netdev_priv(dev);
+	void __iomem *addr = priv->base;
 	unregister_c_can_dev(dev);
 	free_c_can_dev(dev);
-	pci_iounmap(pdev, priv->base);
+	pci_iounmap(pdev, addr);
 	pci_disable_msi(pdev);
 	pci_clear_master(pdev);
 	pci_release_regions(pdev);

drivers/net/can/c_can/c_can_platform.c+5−1

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include <linux/list.h>	29	#include <linux/list.h>
30	#include <linux/io.h>	30	#include <linux/io.h>
31	#include <linux/platform_device.h>	31	#include <linux/platform_device.h>
		32	#include <linux/pm_runtime.h>
32	#include <linux/clk.h>	33	#include <linux/clk.h>
33	#include <linux/of.h>	34	#include <linux/of.h>
34	#include <linux/of_device.h>	35	#include <linux/of_device.h>
@@ -386,6 +387,7 @@ static int c_can_plat_probe(struct platform_device *pdev) · 351 unmodified lines
386	platform_set_drvdata(pdev, dev);	387	platform_set_drvdata(pdev, dev);
387	SET_NETDEV_DEV(dev, &pdev->dev);	388	SET_NETDEV_DEV(dev, &pdev->dev);
388		389
		390	pm_runtime_enable(priv->device);
389	ret = register_c_can_dev(dev);	391	ret = register_c_can_dev(dev);
390	if (ret) {	392	if (ret) {
391	dev_err(&pdev->dev, "registering %s failed (err=%d)\n",	393	dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
@@ -398,6 +400,7 @@ static int c_can_plat_probe(struct platform_device *pdev) · 6 unmodified lines
398	return 0;	400	return 0;
399		401
400	exit_free_device:	402	exit_free_device:
		403	pm_runtime_disable(priv->device);
401	free_c_can_dev(dev);	404	free_c_can_dev(dev);
402	exit:	405	exit:
403	dev_err(&pdev->dev, "probe failed\n");	406	dev_err(&pdev->dev, "probe failed\n");
@@ -408,9 +411,10 @@ exit: · 4 unmodified lines
408	static int c_can_plat_remove(struct platform_device *pdev)	411	static int c_can_plat_remove(struct platform_device *pdev)
409	{	412	{
410	struct net_device *dev = platform_get_drvdata(pdev);	413	struct net_device *dev = platform_get_drvdata(pdev);
		414	struct c_can_priv *priv = netdev_priv(dev);
411		415
412	unregister_c_can_dev(dev);	416	unregister_c_can_dev(dev);
413		417	pm_runtime_disable(priv->device);
414	free_c_can_dev(dev);	418	free_c_can_dev(dev);
415		419
416	return 0;	420	return 0;

drivers/net/can/dev/netlink.c+1−0

@@ -355,6 +355,7 @@ static void can_dellink(struct net_device dev, struct list_head head) · 354 unmodified lines
355		355
356	struct rtnl_link_ops can_link_ops __read_mostly = {	356	struct rtnl_link_ops can_link_ops __read_mostly = {
357	.kind = "can",	357	.kind = "can",
		358	.netns_refund = true,
358	.maxtype = IFLA_CAN_MAX,	359	.maxtype = IFLA_CAN_MAX,
359	.policy = can_policy,	360	.policy = can_policy,
360	.setup = can_setup,	361	.setup = can_setup,

drivers/net/can/flexcan.c+7−1

 static int flexcan_chip_freeze(struct flexcan_priv *priv)
 {
 	struct flexcan_regs __iomem *regs = priv->regs;
-	unsigned int timeout = 1000 * 1000 * 10 / priv->can.bittiming.bitrate;
+	unsigned int timeout;
+	u32 bitrate = priv->can.bittiming.bitrate;
 	u32 reg;
+	if (bitrate)
+		timeout = 1000 * 1000 * 10 / bitrate;
+	else
+		timeout = FLEXCAN_TIMEOUT_US / 10;
 	reg = priv->read(&regs->mcr);
 	reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT;
 	priv->write(reg, &regs->mcr);

drivers/net/can/kvaser_pciefd.c+4−0

 #define KVASER_PCIEFD_KCAN_STAT_REG 0x418
 #define KVASER_PCIEFD_KCAN_MODE_REG 0x41c
 #define KVASER_PCIEFD_KCAN_BTRN_REG 0x420
+#define KVASER_PCIEFD_KCAN_BUS_LOAD_REG 0x424
 #define KVASER_PCIEFD_KCAN_BTRD_REG 0x428
 #define KVASER_PCIEFD_KCAN_PWM_REG 0x430
 /* Loopback control register */
 		timer_setup(&can->bec_poll_timer, kvaser_pciefd_bec_poll_timer,
 			    0);
+		/* Disable Bus load reporting */
+		iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_BUS_LOAD_REG);
 		tx_npackets = ioread32(can->reg_base +
 				       KVASER_PCIEFD_KCAN_TX_NPACKETS_REG);
 		if (((tx_npackets >> KVASER_PCIEFD_KCAN_TX_NPACKETS_MAX_SHIFT) &

drivers/net/can/m_can/m_can.c+1−4

 	}
 	while ((rxfs & RXFS_FFL_MASK) && (quota > 0)) {
-		if (rxfs & RXFS_RFL)
-			netdev_warn(dev, "Rx FIFO 0 Message Lost\n");
 		m_can_read_fifo(dev, rxfs);
 		quota--;
 {
 	struct m_can_classdev *cdev = netdev_priv(dev);
-	m_can_rx_handler(dev, 1);
+	m_can_rx_handler(dev, M_CAN_NAPI_WEIGHT);
 	m_can_enable_all_interrupts(cdev);

drivers/net/can/usb/Kconfig+1−0

@@ -73,6 +73,7 @@ config CAN_KVASER_USB · 72 unmodified lines
73	- Kvaser Memorator Pro 5xHS	73	- Kvaser Memorator Pro 5xHS
74	- Kvaser USBcan Light 4xHS	74	- Kvaser USBcan Light 4xHS
75	- Kvaser USBcan Pro 2xHS v2	75	- Kvaser USBcan Pro 2xHS v2
		76	- Kvaser USBcan Pro 4xHS
76	- Kvaser USBcan Pro 5xHS	77	- Kvaser USBcan Pro 5xHS
77	- Kvaser U100	78	- Kvaser U100
78	- Kvaser U100P	79	- Kvaser U100P

drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c+3−1

 #define USB_U100_PRODUCT_ID			273
 #define USB_U100P_PRODUCT_ID			274
 #define USB_U100S_PRODUCT_ID			275
+#define USB_USBCAN_PRO_4HS_PRODUCT_ID		276
 #define USB_HYDRA_PRODUCT_ID_END \
-	USB_U100S_PRODUCT_ID
+	USB_USBCAN_PRO_4HS_PRODUCT_ID
 static inline bool kvaser_is_leaf(const struct usb_device_id *id)
 {
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID) },
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID) },
 	{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID) },
+	{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID) },
 	{ }
 };
 MODULE_DEVICE_TABLE(usb, kvaser_usb_table);

drivers/net/dsa/b53/b53_common.c+7−7

 			b53_disable_port(ds, port);
 	}
-	/* Let DSA handle the case were multiple bridges span the same switch
-	 * device and different VLAN awareness settings are requested, which
-	 * would be breaking filtering semantics for any of the other bridge
-	 * devices. (not hardware supported)
-	 */
-	ds->vlan_filtering_is_global = true;
 	return b53_setup_devlink_resources(ds);
 }
 	ds->ops = &b53_switch_ops;
 	ds->untag_bridge_pvid = true;
 	dev->vlan_enabled = true;
+	/* Let DSA handle the case were multiple bridges span the same switch
+	 * device and different VLAN awareness settings are requested, which
+	 * would be breaking filtering semantics for any of the other bridge
+	 * devices. (not hardware supported)
+	 */
+	ds->vlan_filtering_is_global = true;
 	mutex_init(&dev->reg_mutex);
 	mutex_init(&dev->stats_mutex);

drivers/net/dsa/bcm_sf2.c+8−3

@@ -114,7 +114,10 @@ static void bcm_sf2_imp_setup(struct dsa_switch *ds, int port) · 113 unmodified lines
114	/* Force link status for IMP port */	114	/* Force link status for IMP port */
115	reg = core_readl(priv, offset);	115	reg = core_readl(priv, offset);
116	reg \|= (MII_SW_OR \| LINK_STS);	116	reg \|= (MII_SW_OR \| LINK_STS);
117	reg &= ~GMII_SPEED_UP_2G;	117	if (priv->type == BCM4908_DEVICE_ID)
		118	reg \|= GMII_SPEED_UP_2G;
		119	else
		120	reg &= ~GMII_SPEED_UP_2G;
118	core_writel(priv, reg, offset);	121	core_writel(priv, reg, offset);
119		122
120	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */	123	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */
@@ -585,8 +588,10 @@ static u32 bcm_sf2_sw_get_phy_flags(struct dsa_switch *ds, int port) · 464 unmodified lines
585	* in bits 15:8 and the patch level in bits 7:0 which is exactly what	588	* in bits 15:8 and the patch level in bits 7:0 which is exactly what
586	* the REG_PHY_REVISION register layout is.	589	* the REG_PHY_REVISION register layout is.
587	*/	590	*/
588		591	if (priv->int_phy_mask & BIT(port))
589	return priv->hw_params.gphy_rev;	592	return priv->hw_params.gphy_rev;
		593	else
		594	return 0;
590	}	595	}
591		596
592	static void bcm_sf2_sw_validate(struct dsa_switch *ds, int port,	597	static void bcm_sf2_sw_validate(struct dsa_switch *ds, int port,

drivers/net/dsa/mt7530.c+25−27

@@ -436,34 +436,32 @@ mt7530_pad_clk_setup(struct dsa_switch *ds, phy_interface_t interface) · 435 unmodified lines
436	TD_DM_DRVP(8) \| TD_DM_DRVN(8));	436	TD_DM_DRVP(8) \| TD_DM_DRVN(8));
437		437
438	/* Setup core clock for MT7530 */	438	/* Setup core clock for MT7530 */
439	if (!trgint) {	439	/* Disable MT7530 core clock */
440	/* Disable MT7530 core clock */	440	core_clear(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
441	core_clear(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
442
443	/* Disable PLL, since phy_device has not yet been created
444	* provided for phy_[read,write]_mmd_indirect is called, we
445	* provide our own core_write_mmd_indirect to complete this
446	* function.
447	*/
448	core_write_mmd_indirect(priv,
449	CORE_GSWPLL_GRP1,
450	MDIO_MMD_VEND2,
451	0);
452
453	/* Set core clock into 500Mhz */
454	core_write(priv, CORE_GSWPLL_GRP2,
455	RG_GSWPLL_POSDIV_500M(1) \|
456	RG_GSWPLL_FBKDIV_500M(25));
457		441
458	/* Enable PLL */	442	/* Disable PLL, since phy_device has not yet been created
459	core_write(priv, CORE_GSWPLL_GRP1,	443	* provided for phy_[read,write]_mmd_indirect is called, we
460	RG_GSWPLL_EN_PRE \|	444	* provide our own core_write_mmd_indirect to complete this
461	RG_GSWPLL_POSDIV_200M(2) \|	445	* function.
462	RG_GSWPLL_FBKDIV_200M(32));	446	*/
463		447	core_write_mmd_indirect(priv,
464	/* Enable MT7530 core clock */	448	CORE_GSWPLL_GRP1,
465	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);	449	MDIO_MMD_VEND2,
466	}	450	0);
		451
		452	/* Set core clock into 500Mhz */
		453	core_write(priv, CORE_GSWPLL_GRP2,
		454	RG_GSWPLL_POSDIV_500M(1) \|
		455	RG_GSWPLL_FBKDIV_500M(25));
		456
		457	/* Enable PLL */
		458	core_write(priv, CORE_GSWPLL_GRP1,
		459	RG_GSWPLL_EN_PRE \|
		460	RG_GSWPLL_POSDIV_200M(2) \|
		461	RG_GSWPLL_FBKDIV_200M(32));
		462
		463	/* Enable MT7530 core clock */
		464	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);
467		465
468	/* Setup the MT7530 TRGMII Tx Clock */	466	/* Setup the MT7530 TRGMII Tx Clock */
469	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);	467	core_set(priv, CORE_TRGMII_GSW_CLK_CG, REG_GSWCK_EN);

drivers/net/ethernet/broadcom/Kconfig+1−1

@@ -54,7 +54,7 @@ config B44_PCI · 53 unmodified lines
54	config BCM4908_ENET	54	config BCM4908_ENET
55	tristate "Broadcom BCM4908 internal mac support"	55	tristate "Broadcom BCM4908 internal mac support"
56	depends on ARCH_BCM4908 \|\| COMPILE_TEST	56	depends on ARCH_BCM4908 \|\| COMPILE_TEST
57	default y	57	default y if ARCH_BCM4908
58	help	58	help
59	This driver supports Ethernet controller integrated into Broadcom	59	This driver supports Ethernet controller integrated into Broadcom
60	BCM4908 family SoCs.	60	BCM4908 family SoCs.

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c+1−1

@@ -722,7 +722,7 @@ static int chcr_ktls_cpl_set_tcb_rpl(struct adapter adap, unsigned char input) · 721 unmodified lines
722	kvfree(tx_info);	722	kvfree(tx_info);
723	return 0;	723	return 0;
724	}	724	}
725	tx_info->open_state = false;	725	tx_info->open_state = CH_KTLS_OPEN_SUCCESS;
726	spin_unlock(&tx_info->lock);	726	spin_unlock(&tx_info->lock);
727		727
728	complete(&tx_info->completion);	728	complete(&tx_info->completion);

drivers/net/ethernet/faraday/ftgmac100.c+1−0

@@ -1337,6 +1337,7 @@ static int ftgmac100_poll(struct napi_struct *napi, int budget) · 1336 unmodified lines
1337	*/	1337	*/
1338	if (unlikely(priv->need_mac_restart)) {	1338	if (unlikely(priv->need_mac_restart)) {
1339	ftgmac100_start_hw(priv);	1339	ftgmac100_start_hw(priv);
		1340	priv->need_mac_restart = false;
1340		1341
1341	/* Re-enable "bad" interrupts */	1342	/* Re-enable "bad" interrupts */
1342	iowrite32(FTGMAC100_INT_BAD,	1343	iowrite32(FTGMAC100_INT_BAD,

drivers/net/ethernet/intel/e1000e/82571.c+2−0

 	} else {
 		data &= ~IGP02E1000_PM_D0_LPLU;
 		ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data);
+		if (ret_val)
+			return ret_val;
 		/* LPLU and SmartSpeed are mutually exclusive.  LPLU is used
 		 * during Dx states where the power conservation is most
 		 * important.  During driver activity we should enable

drivers/net/ethernet/intel/e1000e/hw.h+3−3

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright(c) 1999 - 2018 Intel Corporation. */	2	/* Copyright(c) 1999 - 2018 Intel Corporation. */
3		3
4	#ifndef _E1000_HW_H_	4	#ifndef _E1000E_HW_H_
5	#define _E1000_HW_H_	5	#define _E1000E_HW_H_
6		6
7	#include "regs.h"	7	#include "regs.h"
8	#include "defines.h"	8	#include "defines.h"
@@ -714,4 +714,4 @@ struct e1000_hw { · 705 unmodified lines
714	#include "80003es2lan.h"	714	#include "80003es2lan.h"
715	#include "ich8lan.h"	715	#include "ich8lan.h"
716		716
717	#endif	717	#endif /* _E1000E_HW_H_ */

drivers/net/ethernet/intel/e1000e/netdev.c+5−1

 	struct e1000_adapter *adapter;
 	adapter = container_of(work, struct e1000_adapter, reset_task);
+	rtnl_lock();
 	/* don't run the task if already down */
-	if (test_bit(__E1000_DOWN, &adapter->state))
+	if (test_bit(__E1000_DOWN, &adapter->state)) {
+		rtnl_unlock();
 		return;
+	}
 	if (!(adapter->flags & FLAG_RESTART_NOW)) {
 		e1000e_dump(adapter);
 		e_err("Reset adapter unexpectedly\n");
 	}
 	e1000e_reinit_locked(adapter);
+	rtnl_unlock();
 }
 /**

drivers/net/ethernet/intel/i40e/i40e_main.c+13−0

@@ -3258,6 +3258,17 @@ static int i40e_configure_tx_ring(struct i40e_ring *ring) · 3257 unmodified lines
3258	return 0;	3258	return 0;
3259	}	3259	}
3260		3260
		3261	/**
		3262	* i40e_rx_offset - Return expected offset into page to access data
		3263	* @rx_ring: Ring we are requesting offset of
		3264	*
		3265	* Returns the offset value for ring into the data buffer.
		3266	*/
		3267	static unsigned int i40e_rx_offset(struct i40e_ring *rx_ring)
		3268	{
		3269	return ring_uses_build_skb(rx_ring) ? I40E_SKB_PAD : 0;
		3270	}
		3271
3261	/**	3272	/**
3262	* i40e_configure_rx_ring - Configure a receive ring context	3273	* i40e_configure_rx_ring - Configure a receive ring context
3263	* @ring: The Rx ring to configure	3274	* @ring: The Rx ring to configure
@@ -3369,6 +3380,8 @@ static int i40e_configure_rx_ring(struct i40e_ring *ring) · 105 unmodified lines
3369	else	3380	else
3370	set_ring_build_skb_enabled(ring);	3381	set_ring_build_skb_enabled(ring);
3371		3382
		3383	ring->rx_offset = i40e_rx_offset(ring);
		3384
3372	/* cache tail for quicker writes, and clear the reg before use */	3385	/* cache tail for quicker writes, and clear the reg before use */
3373	ring->tail = hw->hw_addr + I40E_QRX_TAIL(pf_q);	3386	ring->tail = hw->hw_addr + I40E_QRX_TAIL(pf_q);
3374	writel(0, ring->tail);	3387	writel(0, ring->tail);

drivers/net/ethernet/intel/i40e/i40e_txrx.c+0−12

 	}
 }
-/**
- * i40e_rx_offset - Return expected offset into page to access data
- * @rx_ring: Ring we are requesting offset of
- *
- * Returns the offset value for ring into the data buffer.
- */
-static unsigned int i40e_rx_offset(struct i40e_ring *rx_ring)
-{
-	return ring_uses_build_skb(rx_ring) ? I40E_SKB_PAD : 0;
-}
 /**
  * i40e_setup_rx_descriptors - Allocate Rx descriptors
  * @rx_ring: Rx descriptor ring (for a specific queue) to setup
 	rx_ring->next_to_alloc = 0;
 	rx_ring->next_to_clean = 0;
 	rx_ring->next_to_use = 0;
-	rx_ring->rx_offset = i40e_rx_offset(rx_ring);
 	/* XDP RX-queue info only needed for RX rings exposed to XDP */
 	if (rx_ring->vsi->type == I40E_VSI_MAIN) {

drivers/net/ethernet/intel/ice/ice_base.c+22−2

 	tlan_ctx->legacy_int = ICE_TX_LEGACY;
 }
+/**
+ * ice_rx_offset - Return expected offset into page to access data
+ * @rx_ring: Ring we are requesting offset of
+ *
+ * Returns the offset value for ring into the data buffer.
+ */
+static unsigned int ice_rx_offset(struct ice_ring *rx_ring)
+{
+	if (ice_ring_uses_build_skb(rx_ring))
+		return ICE_SKB_PAD;
+	else if (ice_is_xdp_ena_vsi(rx_ring->vsi))
+		return XDP_PACKET_HEADROOM;
+	return 0;
+}
 /**
  * ice_setup_rx_ctx - Configure a receive ring context
  * @ring: The Rx ring to configure
 	else
 		ice_set_ring_build_skb_ena(ring);
+	ring->rx_offset = ice_rx_offset(ring);
 	/* init queue specific tail register */
 	ring->tail = hw->hw_addr + QRX_TAIL(pf_q);
 	writel(0, ring->tail);
 	if (ring->xsk_pool) {
+		bool ok;
 		if (!xsk_buff_can_alloc(ring->xsk_pool, num_bufs)) {
 			dev_warn(dev, "XSK buffer pool does not provide enough addresses to fill %d buffers on Rx ring %d\n",
 				 num_bufs, ring->q_index);
 			return 0;
 		}
-		err = ice_alloc_rx_bufs_zc(ring, num_bufs);
+		ok = ice_alloc_rx_bufs_zc(ring, num_bufs);
-		if (err)
+		if (!ok)
 			dev_info(dev, "Failed to allocate some buffers on XSK buffer pool enabled Rx ring %d (pf_q %d)\n",
 				 ring->q_index, pf_q);
 		return 0;

drivers/net/ethernet/intel/ice/ice_txrx.c+0−17

@@ -443,22 +443,6 @@ void ice_free_rx_ring(struct ice_ring *rx_ring) · 442 unmodified lines
443	}	443	}
444	}	444	}
445		445
446	/**
447	* ice_rx_offset - Return expected offset into page to access data
448	* @rx_ring: Ring we are requesting offset of
449	*
450	* Returns the offset value for ring into the data buffer.
451	*/
452	static unsigned int ice_rx_offset(struct ice_ring *rx_ring)
453	{
454	if (ice_ring_uses_build_skb(rx_ring))
455	return ICE_SKB_PAD;
456	else if (ice_is_xdp_ena_vsi(rx_ring->vsi))
457	return XDP_PACKET_HEADROOM;
458
459	return 0;
460	}
461
462	/**	446	/**
463	* ice_setup_rx_ring - Allocate the Rx descriptors	447	* ice_setup_rx_ring - Allocate the Rx descriptors
464	* @rx_ring: the Rx ring to set up	448	* @rx_ring: the Rx ring to set up
@@ -493,7 +477,6 @@ int ice_setup_rx_ring(struct ice_ring *rx_ring) · 28 unmodified lines
493		477
494	rx_ring->next_to_use = 0;	478	rx_ring->next_to_use = 0;
495	rx_ring->next_to_clean = 0;	479	rx_ring->next_to_clean = 0;
496	rx_ring->rx_offset = ice_rx_offset(rx_ring);
497		480
498	if (ice_is_xdp_ena_vsi(rx_ring->vsi))	481	if (ice_is_xdp_ena_vsi(rx_ring->vsi))
499	WRITE_ONCE(rx_ring->xdp_prog, rx_ring->vsi->xdp_prog);	482	WRITE_ONCE(rx_ring->xdp_prog, rx_ring->vsi->xdp_prog);

drivers/net/ethernet/intel/ice/ice_xsk.c+5−5

@@ -358,18 +358,18 @@ xsk_pool_if_up: · 357 unmodified lines
358	* This function allocates a number of Rx buffers from the fill ring	358	* This function allocates a number of Rx buffers from the fill ring
359	* or the internal recycle mechanism and places them on the Rx ring.	359	* or the internal recycle mechanism and places them on the Rx ring.
360	*	360	*
361	* Returns false if all allocations were successful, true if any fail.	361	* Returns true if all allocations were successful, false if any fail.
362	*/	362	*/
363	bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count)	363	bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count)
364	{	364	{
365	union ice_32b_rx_flex_desc *rx_desc;	365	union ice_32b_rx_flex_desc *rx_desc;
366	u16 ntu = rx_ring->next_to_use;	366	u16 ntu = rx_ring->next_to_use;
367	struct ice_rx_buf *rx_buf;	367	struct ice_rx_buf *rx_buf;
368	bool ret = false;	368	bool ok = true;
369	dma_addr_t dma;	369	dma_addr_t dma;
370		370
371	if (!count)	371	if (!count)
372	return false;	372	return true;
373		373
374	rx_desc = ICE_RX_DESC(rx_ring, ntu);	374	rx_desc = ICE_RX_DESC(rx_ring, ntu);
375	rx_buf = &rx_ring->rx_buf[ntu];	375	rx_buf = &rx_ring->rx_buf[ntu];
@@ -377,7 +377,7 @@ bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count) · 1 unmodified line
377	do {	377	do {
378	rx_buf->xdp = xsk_buff_alloc(rx_ring->xsk_pool);	378	rx_buf->xdp = xsk_buff_alloc(rx_ring->xsk_pool);
379	if (!rx_buf->xdp) {	379	if (!rx_buf->xdp) {
380	ret = true;	380	ok = false;
381	break;	381	break;
382	}	382	}
383		383
@@ -402,7 +402,7 @@ bool ice_alloc_rx_bufs_zc(struct ice_ring *rx_ring, u16 count) · 18 unmodified lines
402	ice_release_rx_desc(rx_ring, ntu);	402	ice_release_rx_desc(rx_ring, ntu);
403	}	403	}
404		404
405	return ret;	405	return ok;
406	}	406	}
407		407
408	/**	408	/**

drivers/net/ethernet/intel/igb/e1000_hw.h+3−3

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright(c) 2007 - 2018 Intel Corporation. */	2	/* Copyright(c) 2007 - 2018 Intel Corporation. */
3		3
4	#ifndef _E1000_HW_H_	4	#ifndef _E1000_IGB_HW_H_
5	#define _E1000_HW_H_	5	#define _E1000_IGB_HW_H_
6		6
7	#include <linux/types.h>	7	#include <linux/types.h>
8	#include <linux/delay.h>	8	#include <linux/delay.h>
@@ -551,4 +551,4 @@ s32 igb_write_pcie_cap_reg(struct e1000_hw hw, u32 reg, u16 value); · 542 unmodified lines
551		551
552	void igb_read_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);	552	void igb_read_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);
553	void igb_write_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);	553	void igb_write_pci_cfg(struct e1000_hw hw, u32 reg, u16 value);
554	#endif /* _E1000_HW_H_ */	554	#endif /* _E1000_IGB_HW_H_ */

drivers/net/ethernet/intel/igb/igb.h+2−2

@@ -748,8 +748,8 @@ void igb_ptp_suspend(struct igb_adapter *adapter); · 747 unmodified lines
748	void igb_ptp_rx_hang(struct igb_adapter *adapter);	748	void igb_ptp_rx_hang(struct igb_adapter *adapter);
749	void igb_ptp_tx_hang(struct igb_adapter *adapter);	749	void igb_ptp_tx_hang(struct igb_adapter *adapter);
750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);	750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);
751	void igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,	751	int igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,
752	struct sk_buff *skb);	752	struct sk_buff *skb);
753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);	753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);
754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);	754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);
755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);	755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);

drivers/net/ethernet/intel/igb/igb_main.c+21−12

 	new_buff->pagecnt_bias	= old_buff->pagecnt_bias;
 }
-static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer)
+static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer,
+				  int rx_buf_pgcnt)
 {
 	unsigned int pagecnt_bias = rx_buffer->pagecnt_bias;
 	struct page *page = rx_buffer->page;
 #if (PAGE_SIZE < 8192)
 	/* if we are only owner of page we can reuse it */
-	if (unlikely((page_ref_count(page) - pagecnt_bias) > 1))
+	if (unlikely((rx_buf_pgcnt - pagecnt_bias) > 1))
 		return false;
 #else
 #define IGB_LAST_OFFSET \
 		return NULL;
 	if (unlikely(igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP))) {
-		igb_ptp_rx_pktstamp(rx_ring->q_vector, xdp->data, skb);
+		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, xdp->data, skb)) {
-		xdp->data += IGB_TS_HDR_LEN;
+			xdp->data += IGB_TS_HDR_LEN;
-		size -= IGB_TS_HDR_LEN;
+			size -= IGB_TS_HDR_LEN;
+		}
 	}
 	/* Determine available headroom for copy */
 	/* pull timestamp out of packet data */
 	if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
-		igb_ptp_rx_pktstamp(rx_ring->q_vector, skb->data, skb);
+		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, skb->data, skb))
-		__skb_pull(skb, IGB_TS_HDR_LEN);
+			__skb_pull(skb, IGB_TS_HDR_LEN);
 	}
 	/* update buffer offset */
 }
 static struct igb_rx_buffer *igb_get_rx_buffer(struct igb_ring *rx_ring,
-					       const unsigned int size)
+					       const unsigned int size, int *rx_buf_pgcnt)
 {
 	struct igb_rx_buffer *rx_buffer;
 	rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
+	*rx_buf_pgcnt =
+#if (PAGE_SIZE < 8192)
+		page_count(rx_buffer->page);
+#else
+		0;
+#endif
 	prefetchw(rx_buffer->page);
 	/* we are reusing so sync this buffer for CPU use */
 }
 static void igb_put_rx_buffer(struct igb_ring *rx_ring,
-			      struct igb_rx_buffer *rx_buffer)
+			      struct igb_rx_buffer *rx_buffer, int rx_buf_pgcnt)
 {
-	if (igb_can_reuse_rx_page(rx_buffer)) {
+	if (igb_can_reuse_rx_page(rx_buffer, rx_buf_pgcnt)) {
 		/* hand second half of page back to the ring */
 		igb_reuse_rx_page(rx_ring, rx_buffer);
 	} else {
 	unsigned int xdp_xmit = 0;
 	struct xdp_buff xdp;
 	u32 frame_sz = 0;
+	int rx_buf_pgcnt;
 	/* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
 		 */
 		dma_rmb();
-		rx_buffer = igb_get_rx_buffer(rx_ring, size);
+		rx_buffer = igb_get_rx_buffer(rx_ring, size, &rx_buf_pgcnt);
 		/* retrieve a buffer from the ring */
 		if (!skb) {
 			break;
 		}
-		igb_put_rx_buffer(rx_ring, rx_buffer);
+		igb_put_rx_buffer(rx_ring, rx_buffer, rx_buf_pgcnt);
 		cleaned_count++;
 		/* fetch next buffer in frame if non-eop */

drivers/net/ethernet/intel/igb/igb_ptp.c+24−7

 	dev_kfree_skb_any(skb);
 }
+#define IGB_RET_PTP_DISABLED 1
+#define IGB_RET_PTP_INVALID 2
 /**
  * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp
  * @q_vector: Pointer to interrupt specific structure
  *
  * This function is meant to retrieve a timestamp from the first buffer of an
  * incoming frame.  The value is stored in little endian format starting on
- * byte 8.
+ * byte 8
+ *
+ * Returns: 0 if success, nonzero if failure
  **/
-void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
+int igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
-			 struct sk_buff *skb)
+			struct sk_buff *skb)
 {
-	__le64 *regval = (__le64 *)va;
 	struct igb_adapter *adapter = q_vector->adapter;
+	__le64 *regval = (__le64 *)va;
 	int adjust = 0;
+	if (!(adapter->ptp_flags & IGB_PTP_ENABLED))
+		return IGB_RET_PTP_DISABLED;
 	/* The timestamp is recorded in little endian format.
 	 * DWORD: 0        1        2        3
 	 * Field: Reserved Reserved SYSTIML  SYSTIMH
 	 */
+	/* check reserved dwords are zero, be/le doesn't matter for zero */
+	if (regval[0])
+		return IGB_RET_PTP_INVALID;
 	igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),
 				   le64_to_cpu(regval[1]));
 	}
 	skb_hwtstamps(skb)->hwtstamp =
 		ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);
+	return 0;
 }
 /**
  * This function is meant to retrieve a timestamp from the internal registers
  * of the adapter and store it in the skb.
  **/
-void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
+void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector, struct sk_buff *skb)
-			 struct sk_buff *skb)
 {
 	struct igb_adapter *adapter = q_vector->adapter;
 	struct e1000_hw *hw = &adapter->hw;
-	u64 regval;
 	int adjust = 0;
+	u64 regval;
+	if (!(adapter->ptp_flags & IGB_PTP_ENABLED))
+		return;
 	/* If this bit is set, then the RX registers contain the time stamp. No
 	 * other packet will be time stamped until we read these registers, so

drivers/net/ethernet/intel/igc/igc.h+1−1

@@ -547,7 +547,7 @@ void igc_ptp_init(struct igc_adapter *adapter); · 546 unmodified lines
547	void igc_ptp_reset(struct igc_adapter *adapter);	547	void igc_ptp_reset(struct igc_adapter *adapter);
548	void igc_ptp_suspend(struct igc_adapter *adapter);	548	void igc_ptp_suspend(struct igc_adapter *adapter);
549	void igc_ptp_stop(struct igc_adapter *adapter);	549	void igc_ptp_stop(struct igc_adapter *adapter);
550	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, void va,	550	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, __le32 va,
551	struct sk_buff *skb);	551	struct sk_buff *skb);
552	int igc_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);	552	int igc_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);
553	int igc_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);	553	int igc_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);

drivers/net/ethernet/intel/igc/igc_ethtool.c+4−3

 						     Autoneg);
 	}
+	/* Set pause flow control settings */
+	ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
 	switch (hw->fc.requested_mode) {
 	case igc_fc_full:
 		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
 						     Asym_Pause);
 		break;
 	default:
-		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
+		break;
-		ethtool_link_ksettings_add_link_mode(cmd, advertising,
-						     Asym_Pause);
 	}
 	status = pm_runtime_suspended(&adapter->pdev->dev) ?

drivers/net/ethernet/intel/igc/igc_main.c+9−0

 	adapter = container_of(work, struct igc_adapter, reset_task);
+	rtnl_lock();
+	/* If we're already down or resetting, just bail */
+	if (test_bit(__IGC_DOWN, &adapter->state) ||
+	    test_bit(__IGC_RESETTING, &adapter->state)) {
+		rtnl_unlock();
+		return;
+	}
 	igc_rings_dump(adapter);
 	igc_regs_dump(adapter);
 	netdev_err(adapter->netdev, "Reset adapter\n");
 	igc_reinit_locked(adapter);
+	rtnl_unlock();
 }
 /**

drivers/net/ethernet/intel/igc/igc_ptp.c+40−32

@@ -152,46 +152,54 @@ static void igc_ptp_systim_to_hwtstamp(struct igc_adapter *adapter, · 151 unmodified lines
152	}	152	}
153		153
154	/**	154	/**
155	* igc_ptp_rx_pktstamp - retrieve Rx per packet timestamp	155	* igc_ptp_rx_pktstamp - Retrieve timestamp from Rx packet buffer
156	* @q_vector: Pointer to interrupt specific structure	156	* @q_vector: Pointer to interrupt specific structure
157	* @va: Pointer to address containing Rx buffer	157	* @va: Pointer to address containing Rx buffer
158	* @skb: Buffer containing timestamp and packet	158	* @skb: Buffer containing timestamp and packet
159	*	159	*
160	* This function is meant to retrieve the first timestamp from the	160	* This function retrieves the timestamp saved in the beginning of packet
161	* first buffer of an incoming frame. The value is stored in little	161	* buffer. While two timestamps are available, one in timer0 reference and the
162	* endian format starting on byte 0. There's a second timestamp	162	* other in timer1 reference, this function considers only the timestamp in
163	* starting on byte 8.	163	* timer0 reference.
164	**/	164	*/
165	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, void va,	165	void igc_ptp_rx_pktstamp(struct igc_q_vector q_vector, __le32 va,
166	struct sk_buff *skb)	166	struct sk_buff *skb)
167	{	167	{
168	struct igc_adapter *adapter = q_vector->adapter;	168	struct igc_adapter *adapter = q_vector->adapter;
169	__le64 regval = (__le64 )va;	169	u64 regval;
170	int adjust = 0;	170	int adjust;
171		171
172	/* The timestamp is recorded in little endian format.	172	/* Timestamps are saved in little endian at the beginning of the packet
173	* DWORD: \| 0 \| 1 \| 2 \| 3	173	* buffer following the layout:
174	* Field: \| Timer0 Low \| Timer0 High \| Timer1 Low \| Timer1 High	174	*
		175	* DWORD: \| 0 \| 1 \| 2 \| 3 \|
		176	* Field: \| Timer1 SYSTIML \| Timer1 SYSTIMH \| Timer0 SYSTIML \| Timer0 SYSTIMH \|
		177	*
		178	* SYSTIML holds the nanoseconds part while SYSTIMH holds the seconds
		179	* part of the timestamp.
175	*/	180	*/
176	igc_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),	181	regval = le32_to_cpu(va[2]);
177	le64_to_cpu(regval[0]));	182	regval \|= (u64)le32_to_cpu(va[3]) << 32;
178		183	igc_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), regval);
179	/* adjust timestamp for the RX latency based on link speed */	184
180	if (adapter->hw.mac.type == igc_i225) {	185	/* Adjust timestamp for the RX latency based on link speed */
181	switch (adapter->link_speed) {	186	switch (adapter->link_speed) {
182	case SPEED_10:	187	case SPEED_10:
183	adjust = IGC_I225_RX_LATENCY_10;	188	adjust = IGC_I225_RX_LATENCY_10;
184	break;	189	break;
185	case SPEED_100:	190	case SPEED_100:
186	adjust = IGC_I225_RX_LATENCY_100;	191	adjust = IGC_I225_RX_LATENCY_100;
187	break;	192	break;
188	case SPEED_1000:	193	case SPEED_1000:
189	adjust = IGC_I225_RX_LATENCY_1000;	194	adjust = IGC_I225_RX_LATENCY_1000;
190	break;	195	break;
191	case SPEED_2500:	196	case SPEED_2500:
192	adjust = IGC_I225_RX_LATENCY_2500;	197	adjust = IGC_I225_RX_LATENCY_2500;
193	break;	198	break;
194	}	199	default:
		200	adjust = 0;
		201	netdev_warn_once(adapter->netdev, "Imprecise timestamp\n");
		202	break;
195	}	203	}
196	skb_hwtstamps(skb)->hwtstamp =	204	skb_hwtstamps(skb)->hwtstamp =
197	ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);	205	ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+2−1

 #endif
 	}
+	ring->rx_offset = ixgbe_rx_offset(ring);
 	if (ring->xsk_pool && hw->mac.type != ixgbe_mac_82599EB) {
 		u32 xsk_buf_len = xsk_pool_get_rx_frame_size(ring->xsk_pool);
 	rx_ring->next_to_clean = 0;
 	rx_ring->next_to_use = 0;
-	rx_ring->rx_offset = ixgbe_rx_offset(rx_ring);
 	/* XDP RX-queue info */
 	if (xdp_rxq_info_reg(&rx_ring->xdp_rxq, adapter->netdev,

drivers/net/ethernet/marvell/Kconfig+2−2

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	config NET_VENDOR_MARVELL	6	config NET_VENDOR_MARVELL
7	bool "Marvell devices"	7	bool "Marvell devices"
8	default y	8	default y
9	depends on PCI \|\| CPU_PXA168 \|\| MV64X60 \|\| PPC32 \|\| PLAT_ORION \|\| INET \|\| COMPILE_TEST	9	depends on PCI \|\| CPU_PXA168 \|\| PPC32 \|\| PLAT_ORION \|\| INET \|\| COMPILE_TEST
10	help	10	help
11	If you have a network (Ethernet) card belonging to this class, say Y.	11	If you have a network (Ethernet) card belonging to this class, say Y.
12		12
@@ -19,7 +19,7 @@ if NET_VENDOR_MARVELL · 6 unmodified lines
19		19
20	config MV643XX_ETH	20	config MV643XX_ETH
21	tristate "Marvell Discovery (643XX) and Orion ethernet support"	21	tristate "Marvell Discovery (643XX) and Orion ethernet support"
22	depends on MV64X60 \|\| PPC32 \|\| PLAT_ORION \|\| COMPILE_TEST	22	depends on PPC32 \|\| PLAT_ORION \|\| COMPILE_TEST
23	depends on INET	23	depends on INET
24	select PHYLIB	24	select PHYLIB
25	select MVMDIO	25	select MVMDIO

drivers/net/ethernet/marvell/mv643xx_eth.c+1−1

@@ -2684,7 +2684,7 @@ static const struct of_device_id mv643xx_eth_shared_ids[] = { · 2683 unmodified lines
2684	MODULE_DEVICE_TABLE(of, mv643xx_eth_shared_ids);	2684	MODULE_DEVICE_TABLE(of, mv643xx_eth_shared_ids);
2685	#endif	2685	#endif
2686		2686
2687	#if defined(CONFIG_OF_IRQ) && !defined(CONFIG_MV64X60)	2687	#ifdef CONFIG_OF_IRQ
2688	#define mv643xx_eth_property(_np, _name, _v) \	2688	#define mv643xx_eth_property(_np, _name, _v) \
2689	do { \	2689	do { \
2690	u32 tmp; \	2690	u32 tmp; \

drivers/net/ethernet/marvell/octeontx2/af/npc_profile.h+0−2

 			[NPC_LT_LC_IP] = {
 				/* SIP+DIP: 8 bytes, KW2[63:0] */
 				KEX_LD_CFG(0x07, 0xc, 0x1, 0x0, 0x10),
-				/* TOS: 1 byte, KW1[63:56] */
-				KEX_LD_CFG(0x0, 0x1, 0x1, 0x0, 0xf),
 			},
 			/* Layer C: IPv6 */
 			[NPC_LT_LC_IP6] = {

drivers/net/ethernet/marvell/octeontx2/af/rvu.c+4−2

 		    INTR_MASK(rvu->hw->total_pfs) & ~1ULL);
 	for (irq = 0; irq < rvu->num_vec; irq++) {
-		if (rvu->irq_allocated[irq])
+		if (rvu->irq_allocated[irq]) {
 			free_irq(pci_irq_vector(rvu->pdev, irq), rvu);
+			rvu->irq_allocated[irq] = false;
+		}
 	}
 	pci_free_irq_vectors(rvu->pdev);
 	struct rvu *rvu = pci_get_drvdata(pdev);
 	rvu_dbg_exit(rvu);
-	rvu_unregister_interrupts(rvu);
 	rvu_unregister_dl(rvu);
+	rvu_unregister_interrupts(rvu);
 	rvu_flr_wq_destroy(rvu);
 	rvu_cgx_exit(rvu);
 	rvu_fwdata_exit(rvu);

drivers/net/ethernet/marvell/octeontx2/af/rvu.h+1−0

@@ -678,6 +678,7 @@ void npc_read_mcam_entry(struct rvu rvu, struct npc_mcam mcam, · 677 unmodified lines
678	u8 intf, u8 ena);	678	u8 intf, u8 ena);
679	bool is_mac_feature_supported(struct rvu *rvu, int pf, int feature);	679	bool is_mac_feature_supported(struct rvu *rvu, int pf, int feature);
680	u32 rvu_cgx_get_fifolen(struct rvu *rvu);	680	u32 rvu_cgx_get_fifolen(struct rvu *rvu);
		681	void rvu_first_cgx_pdata(struct rvu rvu);
681		682
682	/* CPT APIs */	683	/* CPT APIs */
683	int rvu_cpt_lf_teardown(struct rvu *rvu, u16 pcifunc, int lf, int slot);	684	int rvu_cpt_lf_teardown(struct rvu *rvu, u16 pcifunc, int lf, int slot);

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c+16−2

 	return rvu->cgx_idmap[cgx_id];
 }
+/* Return first enabled CGX instance if none are enabled then return NULL */
+void *rvu_first_cgx_pdata(struct rvu *rvu)
+{
+	int first_enabled_cgx = 0;
+	void *cgxd = NULL;
+	for (; first_enabled_cgx < rvu->cgx_cnt_max; first_enabled_cgx++) {
+		cgxd = rvu_cgx_pdata(first_enabled_cgx, rvu);
+		if (cgxd)
+			break;
+	}
+	return cgxd;
+}
 /* Based on P2X connectivity find mapped NIX block for a PF */
 static void rvu_map_cgx_nix_block(struct rvu *rvu, int pf,
 				  int cgx_id, int lmac_id)
 u32 rvu_cgx_get_fifolen(struct rvu *rvu)
 {
 	struct mac_ops *mac_ops;
-	int rvu_def_cgx_id = 0;
 	u32 fifo_len;
-	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));
+	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
 	fifo_len = mac_ops ? mac_ops->fifo_len : 0;
 	return fifo_len;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c+36−21

@@ -234,12 +234,14 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 233 unmodified lines
234	char __user *buffer,	234	char __user *buffer,
235	size_t count, loff_t *ppos)	235	size_t count, loff_t *ppos)
236	{	236	{
237	int index, off = 0, flag = 0, go_back = 0, off_prev;	237	int index, off = 0, flag = 0, go_back = 0, len = 0;
238	struct rvu *rvu = filp->private_data;	238	struct rvu *rvu = filp->private_data;
239	int lf, pf, vf, pcifunc;	239	int lf, pf, vf, pcifunc;
240	struct rvu_block block;	240	struct rvu_block block;
241	int bytes_not_copied;	241	int bytes_not_copied;
		242	int lf_str_size = 12;
242	int buf_size = 2048;	243	int buf_size = 2048;
		244	char *lfs;
243	char *buf;	245	char *buf;
244		246
245	/* don't allow partial reads */	247	/* don't allow partial reads */
@@ -249,12 +251,20 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 3 unmodified lines
249	buf = kzalloc(buf_size, GFP_KERNEL);	251	buf = kzalloc(buf_size, GFP_KERNEL);
250	if (!buf)	252	if (!buf)
251	return -ENOSPC;	253	return -ENOSPC;
252	off += scnprintf(&buf[off], buf_size - 1 - off, "\npcifunc\t\t");	254
		255	lfs = kzalloc(lf_str_size, GFP_KERNEL);
		256	if (!lfs) {
		257	kfree(buf);
		258	return -ENOMEM;
		259	}
		260	off += scnprintf(&buf[off], buf_size - 1 - off, "%-*s", lf_str_size,
		261	"pcifunc");
253	for (index = 0; index < BLK_COUNT; index++)	262	for (index = 0; index < BLK_COUNT; index++)
254	if (strlen(rvu->hw->block[index].name))	263	if (strlen(rvu->hw->block[index].name)) {
255	off += scnprintf(&buf[off], buf_size - 1 - off,	264	off += scnprintf(&buf[off], buf_size - 1 - off,
256	"%s\t", (index - 1) 2,	265	"%-*s", lf_str_size,
257	rvu->hw->block[index].name);	266	rvu->hw->block[index].name);
		267	}
258	off += scnprintf(&buf[off], buf_size - 1 - off, "\n");	268	off += scnprintf(&buf[off], buf_size - 1 - off, "\n");
259	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {	269	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {
260	for (vf = 0; vf <= rvu->hw->total_vfs; vf++) {	270	for (vf = 0; vf <= rvu->hw->total_vfs; vf++) {
@@ -263,14 +273,15 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 2 unmodified lines
263	continue;	273	continue;
264		274
265	if (vf) {	275	if (vf) {
		276	sprintf(lfs, "PF%d:VF%d", pf, vf - 1);
266	go_back = scnprintf(&buf[off],	277	go_back = scnprintf(&buf[off],
267	buf_size - 1 - off,	278	buf_size - 1 - off,
268	"PF%d:VF%d\t\t", pf,	279	"%-*s", lf_str_size, lfs);
269	vf - 1);
270	} else {	280	} else {
		281	sprintf(lfs, "PF%d", pf);
271	go_back = scnprintf(&buf[off],	282	go_back = scnprintf(&buf[off],
272	buf_size - 1 - off,	283	buf_size - 1 - off,
273	"PF%d\t\t", pf);	284	"%-*s", lf_str_size, lfs);
274	}	285	}
275		286
276	off += go_back;	287	off += go_back;
@@ -278,20 +289,22 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 1 unmodified line
278	block = rvu->hw->block[index];	289	block = rvu->hw->block[index];
279	if (!strlen(block.name))	290	if (!strlen(block.name))
280	continue;	291	continue;
281	off_prev = off;	292	len = 0;
		293	lfs[len] = '\0';
282	for (lf = 0; lf < block.lf.max; lf++) {	294	for (lf = 0; lf < block.lf.max; lf++) {
283	if (block.fn_map[lf] != pcifunc)	295	if (block.fn_map[lf] != pcifunc)
284	continue;	296	continue;
285	flag = 1;	297	flag = 1;
286	off += scnprintf(&buf[off], buf_size - 1	298	len += sprintf(&lfs[len], "%d,", lf);
287	- off, "%3d,", lf);
288	}	299	}
289	if (flag && off_prev != off)	300
290	off--;	301	if (flag)
291	else	302	len--;
292	go_back++;	303	lfs[len] = '\0';
293	off += scnprintf(&buf[off], buf_size - 1 - off,	304	off += scnprintf(&buf[off], buf_size - 1 - off,
294	"\t");	305	"%-*s", lf_str_size, lfs);
		306	if (!strlen(lfs))
		307	go_back += lf_str_size;
295	}	308	}
296	if (!flag)	309	if (!flag)
297	off -= go_back;	310	off -= go_back;
@@ -303,6 +316,7 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, · 5 unmodified lines
303	}	316	}
304		317
305	bytes_not_copied = copy_to_user(buffer, buf, off);	318	bytes_not_copied = copy_to_user(buffer, buf, off);
		319	kfree(lfs);
306	kfree(buf);	320	kfree(buf);
307		321
308	if (bytes_not_copied)	322	if (bytes_not_copied)
@@ -319,7 +333,6 @@ static int rvu_dbg_rvu_pf_cgx_map_display(struct seq_file filp, void unused) · 10 unmodified lines
319	struct rvu *rvu = filp->private;	333	struct rvu *rvu = filp->private;
320	struct pci_dev *pdev = NULL;	334	struct pci_dev *pdev = NULL;
321	struct mac_ops *mac_ops;	335	struct mac_ops *mac_ops;
322	int rvu_def_cgx_id = 0;
323	char cgx[10], lmac[10];	336	char cgx[10], lmac[10];
324	struct rvu_pfvf *pfvf;	337	struct rvu_pfvf *pfvf;
325	int pf, domain, blkid;	338	int pf, domain, blkid;
@@ -327,7 +340,10 @@ static int rvu_dbg_rvu_pf_cgx_map_display(struct seq_file filp, void unused) · 1 unmodified line
327	u16 pcifunc;	340	u16 pcifunc;
328		341
329	domain = 2;	342	domain = 2;
330	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));	343	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
		344	/* There can be no CGX devices at all */
		345	if (!mac_ops)
		346	return 0;
331	seq_printf(filp, "PCI dev\t\tRVU PF Func\tNIX block\t%s\tLMAC\n",	347	seq_printf(filp, "PCI dev\t\tRVU PF Func\tNIX block\t%s\tLMAC\n",
332	mac_ops->name);	348	mac_ops->name);
333	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {	349	for (pf = 0; pf < rvu->hw->total_pfs; pf++) {
@@ -1818,7 +1834,6 @@ static void rvu_dbg_cgx_init(struct rvu *rvu) · 1484 unmodified lines
1818	{	1834	{
1819	struct mac_ops *mac_ops;	1835	struct mac_ops *mac_ops;
1820	unsigned long lmac_bmap;	1836	unsigned long lmac_bmap;
1821	int rvu_def_cgx_id = 0;
1822	int i, lmac_id;	1837	int i, lmac_id;
1823	char dname[20];	1838	char dname[20];
1824	void *cgx;	1839	void *cgx;
@@ -1826,7 +1841,7 @@ static void rvu_dbg_cgx_init(struct rvu *rvu) · 1 unmodified line
1826	if (!cgx_get_cgxcnt_max())	1841	if (!cgx_get_cgxcnt_max())
1827	return;	1842	return;
1828		1843
1829	mac_ops = get_mac_ops(rvu_cgx_pdata(rvu_def_cgx_id, rvu));	1844	mac_ops = get_mac_ops(rvu_first_cgx_pdata(rvu));
1830	if (!mac_ops)	1845	if (!mac_ops)
1831	return;	1846	return;
1832		1847

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c+1−1

@@ -2629,7 +2629,7 @@ static int set_flowkey_fields(struct nix_rx_flowkey_alg *alg, u32 flow_cfg) · 2628 unmodified lines
2629	struct nix_rx_flowkey_alg *field;	2629	struct nix_rx_flowkey_alg *field;
2630	struct nix_rx_flowkey_alg tmp;	2630	struct nix_rx_flowkey_alg tmp;
2631	u32 key_type, valid_key;	2631	u32 key_type, valid_key;
2632	int l4_key_offset;	2632	int l4_key_offset = 0;
2633		2633
2634	if (!alg)	2634	if (!alg)
2635	return -EINVAL;	2635	return -EINVAL;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c+1−1

 		index = find_next_bit(mcam->bmap, mcam->bmap_entries, entry);
 		if (index >= mcam->bmap_entries)
 			break;
+		entry = index + 1;
 		if (mcam->entry2cntr_map[index] != req->cntr)
 			continue;
-		entry = index + 1;
 		npc_unmap_mcam_entry_and_cntr(rvu, mcam, blkaddr,
 					      index, req->cntr);
 	}

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c+3−1

 int otx2_get_all_flows(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
 		       u32 *rule_locs)
 {
+	u32 rule_cnt = nfc->rule_cnt;
 	u32 location = 0;
 	int idx = 0;
 	int err = 0;
 	nfc->data = pfvf->flow_cfg->ntuple_max_flows;
-	while ((!err || err == -ENOENT) && idx < nfc->rule_cnt) {
+	while ((!err || err == -ENOENT) && idx < rule_cnt) {
 		err = otx2_get_flow(pfvf, nfc, location);
 		if (!err)
 			rule_locs[idx++] = location;
 		location++;
 	}
+	nfc->rule_cnt = rule_cnt;
 	return err;
 }

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c+5−0

 	struct otx2_nic *pf = netdev_priv(netdev);
 	struct otx2_cq_poll *cq_poll = NULL;
 	struct otx2_qset *qset = &pf->qset;
+	struct otx2_rss_info *rss;
 	int qidx, vec, wrk;
 	netif_carrier_off(netdev);
 	/* First stop packet Rx/Tx */
 	otx2_rxtx_enable(pf, false);
+	/* Clear RSS enable flag */
+	rss = &pf->hw.rss_info;
+	rss->enable = false;
 	/* Cleanup Queue IRQ */
 	vec = pci_irq_vector(pf->pdev,
 			     pf->hw.nix_msixoff + NIX_LF_QINT_VEC_START);

drivers/net/ethernet/marvell/pxa168_eth.c+1−1

 	clk_disable_unprepare(pep->clk);
 	mdiobus_unregister(pep->smi_bus);
 	mdiobus_free(pep->smi_bus);
-	unregister_netdev(dev);
 	cancel_work_sync(&pep->tx_timeout_task);
+	unregister_netdev(dev);
 	free_netdev(dev);
 	return 0;
 }

drivers/net/ethernet/mellanox/mlx5/core/en.h+4−3

 				    MLX5_MPWRQ_LOG_WQE_SZ - PAGE_SHIFT : 0)
 #define MLX5_MPWRQ_PAGES_PER_WQE		BIT(MLX5_MPWRQ_WQE_PAGE_ORDER)
-#define MLX5_MTT_OCTW(npages) (ALIGN(npages, 8) / 2)
+#define MLX5_ALIGN_MTTS(mtts)		(ALIGN(mtts, 8))
+#define MLX5_ALIGNED_MTTS_OCTW(mtts)	((mtts) / 2)
+#define MLX5_MTT_OCTW(mtts)		(MLX5_ALIGNED_MTTS_OCTW(MLX5_ALIGN_MTTS(mtts)))
 /* Add another page to MLX5E_REQUIRED_WQE_MTTS as a buffer between
  * WQEs, This page will absorb write overflow by the hardware, when
  * receiving packets larger than MTU. These oversize packets are
  * dropped by the driver at a later stage.
  */
-#define MLX5E_REQUIRED_WQE_MTTS		(ALIGN(MLX5_MPWRQ_PAGES_PER_WQE + 1, 8))
+#define MLX5E_REQUIRED_WQE_MTTS		(MLX5_ALIGN_MTTS(MLX5_MPWRQ_PAGES_PER_WQE + 1))
-#define MLX5E_LOG_ALIGNED_MPWQE_PPW	(ilog2(MLX5E_REQUIRED_WQE_MTTS))
 #define MLX5E_REQUIRED_MTTS(wqes)	(wqes * MLX5E_REQUIRED_WQE_MTTS)
 #define MLX5E_MAX_RQ_NUM_MTTS	\
 	((1 << 16) * 2) /* So that MLX5_MTT_OCTW(num_mtts) fits into u16 */

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c+2−1

@@ -1181,7 +1181,8 @@ int mlx5_tc_ct_add_no_trk_match(struct mlx5_flow_spec *spec) · 1180 unmodified lines
1181		1181
1182	mlx5e_tc_match_to_reg_get_match(spec, CTSTATE_TO_REG,	1182	mlx5e_tc_match_to_reg_get_match(spec, CTSTATE_TO_REG,
1183	&ctstate, &ctstate_mask);	1183	&ctstate, &ctstate_mask);
1184	if (ctstate_mask)	1184
		1185	if ((ctstate & ctstate_mask) == MLX5_CT_STATE_TRK_BIT)
1185	return -EOPNOTSUPP;	1186	return -EOPNOTSUPP;
1186		1187
1187	ctstate_mask \|= MLX5_CT_STATE_TRK_BIT;	1188	ctstate_mask \|= MLX5_CT_STATE_TRK_BIT;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c+4−4

@@ -685,14 +685,14 @@ int mlx5e_tc_tun_route_lookup(struct mlx5e_priv *priv, · 684 unmodified lines
685	u16 vport_num;	685	u16 vport_num;
686	int err = 0;	686	int err = 0;
687		687
688	if (flow_attr->ip_version == 4) {	688	if (flow_attr->tun_ip_version == 4) {
689	/* Addresses are swapped for decap */	689	/* Addresses are swapped for decap */
690	attr.fl.fl4.saddr = esw_attr->rx_tun_attr->dst_ip.v4;	690	attr.fl.fl4.saddr = esw_attr->rx_tun_attr->dst_ip.v4;
691	attr.fl.fl4.daddr = esw_attr->rx_tun_attr->src_ip.v4;	691	attr.fl.fl4.daddr = esw_attr->rx_tun_attr->src_ip.v4;
692	err = mlx5e_route_lookup_ipv4_get(priv, priv->netdev, &attr);	692	err = mlx5e_route_lookup_ipv4_get(priv, priv->netdev, &attr);
693	}	693	}
694	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)	694	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)
695	else if (flow_attr->ip_version == 6) {	695	else if (flow_attr->tun_ip_version == 6) {
696	/* Addresses are swapped for decap */	696	/* Addresses are swapped for decap */
697	attr.fl.fl6.saddr = esw_attr->rx_tun_attr->dst_ip.v6;	697	attr.fl.fl6.saddr = esw_attr->rx_tun_attr->dst_ip.v6;
698	attr.fl.fl6.daddr = esw_attr->rx_tun_attr->src_ip.v6;	698	attr.fl.fl6.daddr = esw_attr->rx_tun_attr->src_ip.v6;
@@ -718,10 +718,10 @@ int mlx5e_tc_tun_route_lookup(struct mlx5e_priv *priv, · 19 unmodified lines
718	esw_attr->rx_tun_attr->decap_vport = vport_num;	718	esw_attr->rx_tun_attr->decap_vport = vport_num;
719		719
720	out:	720	out:
721	if (flow_attr->ip_version == 4)	721	if (flow_attr->tun_ip_version == 4)
722	mlx5e_route_lookup_ipv4_put(&attr);	722	mlx5e_route_lookup_ipv4_put(&attr);
723	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)	723	#if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6)
724	else if (flow_attr->ip_version == 6)	724	else if (flow_attr->tun_ip_version == 6)
725	mlx5e_route_lookup_ipv6_put(&attr);	725	mlx5e_route_lookup_ipv6_put(&attr);
726	#endif	726	#endif
727	return err;	727	return err;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_encap.c+2−1

 	 * required to establish routing.
 	 */
 	flow_flag_set(flow, TUN_RX);
+	flow->attr->tun_ip_version = ip_version;
 	return 0;
 }
 	if (err || !esw_attr->rx_tun_attr->decap_vport)
 		goto out;
-	key.ip_version = attr->ip_version;
+	key.ip_version = attr->tun_ip_version;
 	if (key.ip_version == 4)
 		key.endpoint_ip.v4 = esw_attr->rx_tun_attr->dst_ip.v4;
 	else

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_geneve.c+4−0

 	option_key = (struct geneve_opt *)&enc_opts.key->data[0];
 	option_mask = (struct geneve_opt *)&enc_opts.mask->data[0];
+	if (option_mask->opt_class == 0 && option_mask->type == 0 &&
+	    !memchr_inv(option_mask->opt_data, 0, option_mask->length * 4))
+		return 0;
 	if (option_key->length > max_tlv_option_data_len) {
 		NL_SET_ERR_MSG_MOD(extack,
 				   "Matching on GENEVE options: unsupported option len");

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+10−1

 {
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	struct mlx5_core_dev *mdev = priv->mdev;
+	int err;
 	if (!MLX5_CAP_GEN(mdev, cqe_compression))
 		return -EOPNOTSUPP;
 		return -EINVAL;
 	}
-	mlx5e_modify_rx_cqe_compression_locked(priv, enable);
+	err = mlx5e_modify_rx_cqe_compression_locked(priv, enable);
+	if (err)
+		return err;
 	priv->channels.params.rx_cqe_compress_def = enable;
 	return 0;
 	 */
 	if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
+		struct mlx5e_params old_params;
+		old_params = priv->channels.params;
 		priv->channels.params = new_channels.params;
 		err = mlx5e_num_channels_changed(priv);
+		if (err)
+			priv->channels.params = old_params;
 		goto out;
 	}

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+57−24

 				     rq->wqe_overflow.addr);
 }
-static inline u64 mlx5e_get_mpwqe_offset(struct mlx5e_rq *rq, u16 wqe_ix)
+static u64 mlx5e_get_mpwqe_offset(u16 wqe_ix)
 {
-	return (wqe_ix << MLX5E_LOG_ALIGNED_MPWQE_PPW) << PAGE_SHIFT;
+	return MLX5E_REQUIRED_MTTS(wqe_ix) << PAGE_SHIFT;
 }
 static void mlx5e_init_frags_partition(struct mlx5e_rq *rq)
 				mlx5_wq_ll_get_wqe(&rq->mpwqe.wq, i);
 			u32 byte_count =
 				rq->mpwqe.num_strides << rq->mpwqe.log_stride_sz;
-			u64 dma_offset = mlx5e_get_mpwqe_offset(rq, i);
+			u64 dma_offset = mlx5e_get_mpwqe_offset(i);
 			wqe->data[0].addr = cpu_to_be64(dma_offset + rq->buff.headroom);
 			wqe->data[0].byte_count = cpu_to_be32(byte_count);
 {
 	switch (params->rq_wq_type) {
 	case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ:
-		return order_base_2(MLX5E_UMR_WQEBBS) +
+		return max_t(u8, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE,
-			mlx5e_get_rq_log_wq_sz(rqp->rqc);
+			     order_base_2(MLX5E_UMR_WQEBBS) +
+			     mlx5e_get_rq_log_wq_sz(rqp->rqc));
 	default: /* MLX5_WQ_TYPE_CYCLIC */
 		return MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE;
 	}
 {
 	int i;
-	if (chs->port_ptp)
+	if (chs->port_ptp) {
 		mlx5e_port_ptp_close(chs->port_ptp);
+		chs->port_ptp = NULL;
+	}
 	for (i = 0; i < chs->num; i++)
 		mlx5e_close_channel(chs->c[i]);
 		for (j = 0; j < priv->max_opened_tc; j++) {
 			struct mlx5e_sq_stats *sq_stats = &channel_stats->sq[j];
+			s->tx_packets    += sq_stats->packets;
+			s->tx_bytes      += sq_stats->bytes;
+			s->tx_dropped    += sq_stats->dropped;
+		}
+	}
+	if (priv->port_ptp_opened) {
+		for (i = 0; i < priv->max_opened_tc; i++) {
+			struct mlx5e_sq_stats *sq_stats = &priv->port_ptp_stats.sq[i];
 			s->tx_packets    += sq_stats->packets;
 			s->tx_bytes      += sq_stats->bytes;
 			s->tx_dropped    += sq_stats->dropped;
 	}
 	if (mlx5e_is_uplink_rep(priv)) {
+		struct mlx5e_vport_stats *vstats = &priv->stats.vport;
 		stats->rx_packets = PPORT_802_3_GET(pstats, a_frames_received_ok);
 		stats->rx_bytes   = PPORT_802_3_GET(pstats, a_octets_received_ok);
 		stats->tx_packets = PPORT_802_3_GET(pstats, a_frames_transmitted_ok);
 		stats->tx_bytes   = PPORT_802_3_GET(pstats, a_octets_transmitted_ok);
+		/* vport multicast also counts packets that are dropped due to steering
+		 * or rx out of buffer
+		 */
+		stats->multicast = VPORT_COUNTER_GET(vstats, received_eth_multicast.packets);
 	} else {
 		mlx5e_fold_sw_stats64(priv, stats);
 	}
 		struct mlx5e_channel *c = priv->channels.c[i];
 		mlx5e_rq_replace_xdp_prog(&c->rq, prog);
-		if (test_bit(MLX5E_CHANNEL_STATE_XSK, c->state))
+		if (test_bit(MLX5E_CHANNEL_STATE_XSK, c->state)) {
+			bpf_prog_inc(prog);
 			mlx5e_rq_replace_xdp_prog(&c->xskrq, prog);
+		}
 	}
 unlock:
 				     priv->max_nch);
 	params->num_tc       = 1;
+	/* Set an initial non-zero value, so that mlx5e_select_queue won't
+	 * divide by zero if called before first activating channels.
+	 */
+	priv->num_tc_x_num_ch = params->num_channels * params->num_tc;
 	/* SQ */
 	params->log_sq_size = is_kdump_kernel() ?
 		MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE :
 		    struct net_device *netdev,
 		    struct mlx5_core_dev *mdev)
 {
-	memset(priv, 0, sizeof(*priv));
 	/* priv init */
 	priv->mdev        = mdev;
 	priv->netdev      = netdev;
 {
 	int i;
+	/* bail if change profile failed and also rollback failed */
+	if (!priv->mdev)
+		return;
 	destroy_workqueue(priv->wq);
 	free_cpumask_var(priv->scratchpad.cpumask);
 	for (i = 0; i < priv->htb.max_qos_sqs; i++)
 		kfree(priv->htb.qos_sq_stats[i]);
 	kvfree(priv->htb.qos_sq_stats);
+	memset(priv, 0, sizeof(*priv));
 }
 struct net_device *
 }
 static int
-mlx5e_netdev_attach_profile(struct mlx5e_priv *priv,
+mlx5e_netdev_attach_profile(struct net_device *netdev, struct mlx5_core_dev *mdev,
 			    const struct mlx5e_profile *new_profile, void *new_ppriv)
 {
-	struct net_device *netdev = priv->netdev;
+	struct mlx5e_priv *priv = netdev_priv(netdev);
-	struct mlx5_core_dev *mdev = priv->mdev;
 	int err;
 	err = mlx5e_priv_init(priv, netdev, mdev);
 	priv->ppriv = new_ppriv;
 	err = new_profile->init(priv->mdev, priv->netdev);
 	if (err)
-		return err;
+		goto priv_cleanup;
 	err = mlx5e_attach_netdev(priv);
 	if (err)
-		new_profile->cleanup(priv);
+		goto profile_cleanup;
+	return err;
+profile_cleanup:
+	new_profile->cleanup(priv);
+priv_cleanup:
+	mlx5e_priv_cleanup(priv);
 	return err;
 }
 {
 	unsigned int new_max_nch = mlx5e_calc_max_nch(priv, new_profile);
 	const struct mlx5e_profile *orig_profile = priv->profile;
+	struct net_device *netdev = priv->netdev;
+	struct mlx5_core_dev *mdev = priv->mdev;
 	void *orig_ppriv = priv->ppriv;
 	int err, rollback_err;
 	/* sanity */
 	if (new_max_nch != priv->max_nch) {
-		netdev_warn(priv->netdev,
+		netdev_warn(netdev, "%s: Replacing profile with different max channels\n",
-			    "%s: Replacing profile with different max channels\n",
 			    __func__);
 		return -EINVAL;
 	}
 	priv->profile->cleanup(priv);
 	mlx5e_priv_cleanup(priv);
-	err = mlx5e_netdev_attach_profile(priv, new_profile, new_ppriv);
+	err = mlx5e_netdev_attach_profile(netdev, mdev, new_profile, new_ppriv);
 	if (err) { /* roll back to original profile */
-		netdev_warn(priv->netdev, "%s: new profile init failed, %d\n",
+		netdev_warn(netdev, "%s: new profile init failed, %d\n", __func__, err);
-			    __func__, err);
 		goto rollback;
 	}
 	return 0;
 rollback:
-	rollback_err = mlx5e_netdev_attach_profile(priv, orig_profile, orig_ppriv);
+	rollback_err = mlx5e_netdev_attach_profile(netdev, mdev, orig_profile, orig_ppriv);
-	if (rollback_err) {
+	if (rollback_err)
-		netdev_err(priv->netdev,
+		netdev_err(netdev, "%s: failed to rollback to orig profile, %d\n",
-			   "%s: failed to rollback to orig profile, %d\n",
 			   __func__, rollback_err);
-	}
 	return err;
 }

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+2−2

 	struct mlx5e_icosq *sq = rq->icosq;
 	struct mlx5_wq_cyc *wq = &sq->wq;
 	struct mlx5e_umr_wqe *umr_wqe;
-	u16 xlt_offset = ix << (MLX5E_LOG_ALIGNED_MPWQE_PPW - 1);
 	u16 pi;
 	int err;
 	int i;
 	umr_wqe->ctrl.opmod_idx_opcode =
 		cpu_to_be32((sq->pc << MLX5_WQE_CTRL_WQE_INDEX_SHIFT) |
 			    MLX5_OPCODE_UMR);
-	umr_wqe->uctrl.xlt_offset = cpu_to_be16(xlt_offset);
+	umr_wqe->uctrl.xlt_offset =
+		cpu_to_be16(MLX5_ALIGNED_MTTS_OCTW(MLX5E_REQUIRED_MTTS(ix)));
 	sq->db.wqe_info[pi] = (struct mlx5e_icosq_wqe_info) {
 		.wqe_type   = MLX5E_ICOSQ_WQE_UMR_RX,

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+45−12

@@ -2296,6 +2296,16 @@ static int __parse_cls_flower(struct mlx5e_priv *priv, · 2295 unmodified lines
2296	*match_level = MLX5_MATCH_L4;	2296	*match_level = MLX5_MATCH_L4;
2297	}	2297	}
2298		2298
		2299	/* Currenlty supported only for MPLS over UDP */
		2300	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_MPLS) &&
		2301	!netif_is_bareudp(filter_dev)) {
		2302	NL_SET_ERR_MSG_MOD(extack,
		2303	"Matching on MPLS is supported only for MPLS over UDP");
		2304	netdev_err(priv->netdev,
		2305	"Matching on MPLS is supported only for MPLS over UDP\n");
		2306	return -EOPNOTSUPP;
		2307	}
		2308
2299	return 0;	2309	return 0;
2300	}	2310	}
2301		2311
@@ -2899,6 +2909,37 @@ static int is_action_keys_supported(const struct flow_action_entry *act, · 597 unmodified lines
2899	return 0;	2909	return 0;
2900	}	2910	}
2901		2911
		2912	static bool modify_tuple_supported(bool modify_tuple, bool ct_clear,
		2913	bool ct_flow, struct netlink_ext_ack *extack,
		2914	struct mlx5e_priv *priv,
		2915	struct mlx5_flow_spec *spec)
		2916	{
		2917	if (!modify_tuple \|\| ct_clear)
		2918	return true;
		2919
		2920	if (ct_flow) {
		2921	NL_SET_ERR_MSG_MOD(extack,
		2922	"can't offload tuple modification with non-clear ct()");
		2923	netdev_info(priv->netdev,
		2924	"can't offload tuple modification with non-clear ct()");
		2925	return false;
		2926	}
		2927
		2928	/* Add ct_state=-trk match so it will be offloaded for non ct flows
		2929	* (or after clear action), as otherwise, since the tuple is changed,
		2930	* we can't restore ct state
		2931	*/
		2932	if (mlx5_tc_ct_add_no_trk_match(spec)) {
		2933	NL_SET_ERR_MSG_MOD(extack,
		2934	"can't offload tuple modification with ct matches and no ct(clear) action");
		2935	netdev_info(priv->netdev,
		2936	"can't offload tuple modification with ct matches and no ct(clear) action");
		2937	return false;
		2938	}
		2939
		2940	return true;
		2941	}
		2942
2902	static bool modify_header_match_supported(struct mlx5e_priv *priv,	2943	static bool modify_header_match_supported(struct mlx5e_priv *priv,
2903	struct mlx5_flow_spec *spec,	2944	struct mlx5_flow_spec *spec,
2904	struct flow_action *flow_action,	2945	struct flow_action *flow_action,
@@ -2937,18 +2978,9 @@ static bool modify_header_match_supported(struct mlx5e_priv *priv, · 32 unmodified lines
2937	return err;	2978	return err;
2938	}	2979	}
2939		2980
2940	/* Add ct_state=-trk match so it will be offloaded for non ct flows	2981	if (!modify_tuple_supported(modify_tuple, ct_clear, ct_flow, extack,
2941	* (or after clear action), as otherwise, since the tuple is changed,	2982	priv, spec))
2942	* we can't restore ct state
2943	*/
2944	if (!ct_clear && modify_tuple &&
2945	mlx5_tc_ct_add_no_trk_match(spec)) {
2946	NL_SET_ERR_MSG_MOD(extack,
2947	"can't offload tuple modify header with ct matches");
2948	netdev_info(priv->netdev,
2949	"can't offload tuple modify header with ct matches");
2950	return false;	2983	return false;
2951	}
2952		2984
2953	ip_proto = MLX5_GET(fte_match_set_lyr_2_4, headers_v, ip_protocol);	2985	ip_proto = MLX5_GET(fte_match_set_lyr_2_4, headers_v, ip_protocol);
2954	if (modify_ip_header && ip_proto != IPPROTO_TCP &&	2986	if (modify_ip_header && ip_proto != IPPROTO_TCP &&
@@ -4445,7 +4477,8 @@ static int apply_police_params(struct mlx5e_priv *priv, u64 rate, · 1490 unmodified lines
4445	*/	4477	*/
4446	if (rate) {	4478	if (rate) {
4447	rate = (rate * BITS_PER_BYTE) + 500000;	4479	rate = (rate * BITS_PER_BYTE) + 500000;
4448	rate_mbps = max_t(u64, do_div(rate, 1000000), 1);	4480	do_div(rate, 1000000);
		4481	rate_mbps = max_t(u32, rate, 1);
4449	}	4482	}
4450		4483
4451	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);	4484	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h+1−0

@@ -79,6 +79,7 @@ struct mlx5_flow_attr { · 78 unmodified lines
79	u8 inner_match_level;	79	u8 inner_match_level;
80	u8 outer_match_level;	80	u8 outer_match_level;
81	u8 ip_version;	81	u8 ip_version;
		82	u8 tun_ip_version;
82	u32 flags;	83	u32 flags;
83	union {	84	union {
84	struct mlx5_esw_flow_attr esw_attr[0];	85	struct mlx5_esw_flow_attr esw_attr[0];

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+2−1

@@ -551,7 +551,8 @@ esw_setup_dests(struct mlx5_flow_destination *dest, · 550 unmodified lines
551		551
552	if (!mlx5_eswitch_termtbl_required(esw, attr, flow_act, spec) &&	552	if (!mlx5_eswitch_termtbl_required(esw, attr, flow_act, spec) &&
553	MLX5_CAP_GEN(esw_attr->in_mdev, reg_c_preserve) &&	553	MLX5_CAP_GEN(esw_attr->in_mdev, reg_c_preserve) &&
554	mlx5_eswitch_vport_match_metadata_enabled(esw))	554	mlx5_eswitch_vport_match_metadata_enabled(esw) &&
		555	MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ignore_flow_level))
555	attr->flags \|= MLX5_ESW_ATTR_FLAG_SRC_REWRITE;	556	attr->flags \|= MLX5_ESW_ATTR_FLAG_SRC_REWRITE;
556		557
557	if (attr->dest_ft) {	558	if (attr->dest_ft) {

drivers/net/ethernet/mellanox/mlx5/core/fpga/conn.c+1−0

@@ -575,6 +575,7 @@ static int mlx5_fpga_conn_create_qp(struct mlx5_fpga_conn *conn, · 574 unmodified lines
575	MLX5_SET(qpc, qpc, log_sq_size, ilog2(conn->qp.sq.size));	575	MLX5_SET(qpc, qpc, log_sq_size, ilog2(conn->qp.sq.size));
576	MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);	576	MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);
577	MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);	577	MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);
		578	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(mdev));
578	MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);	579	MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);
579	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)	580	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)
580	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);	581	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);

drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c+3−1

 	}
 	qpc = MLX5_ADDR_OF(create_qp_in, in, qpc);
+	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(priv->mdev));
 	MLX5_SET(qpc, qpc, st, MLX5_QP_ST_UD);
 	MLX5_SET(qpc, qpc, pm_state, MLX5_QP_PM_MIGRATED);
 	MLX5_SET(qpc, qpc, ulp_stateless_offload_mode,
 static void mlx5_rdma_netdev_free(struct net_device *netdev)
 {
 	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
+	struct mlx5_core_dev *mdev = priv->mdev;
 	struct mlx5i_priv *ipriv = priv->ppriv;
 	const struct mlx5e_profile *profile = priv->profile;
 	if (!ipriv->sub_interface) {
 		mlx5i_pkey_qpn_ht_cleanup(netdev);
-		mlx5e_destroy_mdev_resources(priv->mdev);
+		mlx5e_destroy_mdev_resources(mdev);
 	}
 }

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c+4−4

 		return -EINVAL;
 	field_select = MLX5_MTPPS_FS_ENABLE;
+	pin = ptp_find_pin(clock->ptp, PTP_PF_PEROUT, rq->perout.index);
+	if (pin < 0)
+		return -EBUSY;
 	if (on) {
 		bool rt_mode = mlx5_real_time_mode(mdev);
 		u32 nsec;
 		s64 sec;
-		pin = ptp_find_pin(clock->ptp, PTP_PF_PEROUT, rq->perout.index);
-		if (pin < 0)
-			return -EBUSY;
 		pin_mode = MLX5_PIN_MODE_OUT;
 		pattern = MLX5_OUT_PATTERN_PERIODIC;
 		ts.tv_sec = rq->perout.period.sec;

drivers/net/ethernet/mellanox/mlx5/core/sf/dev/dev.c+1−3

 	u16 max_functions;
 	u16 function_id;
 	int err = 0;
-	bool ecpu;
 	int i;
 	max_functions = mlx5_sf_max_functions(dev);
 	function_id = MLX5_CAP_GEN(dev, sf_base_id);
-	ecpu = mlx5_read_embedded_cpu(dev);
 	/* Arm the vhca context as the vhca event notifier */
 	for (i = 0; i < max_functions; i++) {
-		err = mlx5_vhca_event_arm(dev, function_id, ecpu);
+		err = mlx5_vhca_event_arm(dev, function_id);
 		if (err)
 			return err;

drivers/net/ethernet/mellanox/mlx5/core/sf/hw_table.c+4−6

 #include "sf.h"
 #include "mlx5_ifc_vhca_event.h"
 #include "vhca_event.h"
-#include "ecpf.h"
+#include "mlx5_core.h"
 struct mlx5_sf_hw {
 	u32 usr_sfnum;
 	struct mlx5_core_dev *dev;
 	struct mlx5_sf_hw *sfs;
 	int max_local_functions;
-	u8 ecpu: 1;
 	struct mutex table_lock; /* Serializes sf deletion and vhca state change handler. */
 	struct notifier_block vhca_nb;
 };
 	}
 	if (sw_id == -ENOSPC) {
 		err = -ENOSPC;
-		goto err;
+		goto exist_err;
 	}
 	hw_fn_id = mlx5_sf_sw_to_hw_id(table->dev, sw_id);
 	if (err)
 		goto err;
-	err = mlx5_modify_vhca_sw_id(dev, hw_fn_id, table->ecpu, usr_sfnum);
+	err = mlx5_modify_vhca_sw_id(dev, hw_fn_id, usr_sfnum);
 	if (err)
 		goto vhca_err;
 	hw_fn_id = mlx5_sf_sw_to_hw_id(dev, id);
 	mutex_lock(&table->table_lock);
-	err = mlx5_cmd_query_vhca_state(dev, hw_fn_id, table->ecpu, out, sizeof(out));
+	err = mlx5_cmd_query_vhca_state(dev, hw_fn_id, out, sizeof(out));
 	if (err)
 		goto err;
 	state = MLX5_GET(query_vhca_state_out, out, vhca_state_context.vhca_state);
 	table->dev = dev;
 	table->sfs = sfs;
 	table->max_local_functions = max_functions;
-	table->ecpu = mlx5_read_embedded_cpu(dev);
 	dev->priv.sf_hw_table = table;
 	mlx5_core_dbg(dev, "SF HW table: max sfs = %d\n", max_functions);
 	return 0;

drivers/net/ethernet/mellanox/mlx5/core/sf/mlx5_ifc_vhca_event.h+1−1

@@ -20,7 +20,7 @@ struct mlx5_ifc_vhca_state_context_bits { · 19 unmodified lines
20		20
21	u8 sw_function_id[0x20];	21	u8 sw_function_id[0x20];
22		22
23	u8 reserved_at_40[0x80];	23	u8 reserved_at_40[0x40];
24	};	24	};
25		25
26	struct mlx5_ifc_query_vhca_state_out_bits {	26	struct mlx5_ifc_query_vhca_state_out_bits {

drivers/net/ethernet/mellanox/mlx5/core/sf/vhca_event.c+11−12

 	struct mlx5_vhca_state_event event;
 };
-int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
+int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id, u32 *out, u32 outlen)
-			      bool ecpu, u32 *out, u32 outlen)
 {
 	u32 in[MLX5_ST_SZ_DW(query_vhca_state_in)] = {};
 	MLX5_SET(query_vhca_state_in, in, opcode, MLX5_CMD_OP_QUERY_VHCA_STATE);
 	MLX5_SET(query_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(query_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(query_vhca_state_in, in, embedded_cpu_function, 0);
 	return mlx5_cmd_exec(dev, in, sizeof(in), out, outlen);
 }
 static int mlx5_cmd_modify_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
-				      bool ecpu, u32 *in, u32 inlen)
+				      u32 *in, u32 inlen)
 {
 	u32 out[MLX5_ST_SZ_DW(modify_vhca_state_out)] = {};
 	MLX5_SET(modify_vhca_state_in, in, opcode, MLX5_CMD_OP_MODIFY_VHCA_STATE);
 	MLX5_SET(modify_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, 0);
 	return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
 }
-int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, bool ecpu, u32 sw_fn_id)
+int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, u32 sw_fn_id)
 {
 	u32 out[MLX5_ST_SZ_DW(modify_vhca_state_out)] = {};
 	u32 in[MLX5_ST_SZ_DW(modify_vhca_state_in)] = {};
 	MLX5_SET(modify_vhca_state_in, in, opcode, MLX5_CMD_OP_MODIFY_VHCA_STATE);
 	MLX5_SET(modify_vhca_state_in, in, function_id, function_id);
-	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, ecpu);
+	MLX5_SET(modify_vhca_state_in, in, embedded_cpu_function, 0);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_field_select.sw_function_id, 1);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_context.sw_function_id, sw_fn_id);
 	return mlx5_cmd_exec_inout(dev, modify_vhca_state, in, out);
 }
-int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id, bool ecpu)
+int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id)
 {
 	u32 in[MLX5_ST_SZ_DW(modify_vhca_state_in)] = {};
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_context.arm_change_event, 1);
 	MLX5_SET(modify_vhca_state_in, in, vhca_state_field_select.arm_change_event, 1);
-	return mlx5_cmd_modify_vhca_state(dev, function_id, ecpu, in, sizeof(in));
+	return mlx5_cmd_modify_vhca_state(dev, function_id, in, sizeof(in));
 }
 static void
 	u32 out[MLX5_ST_SZ_DW(query_vhca_state_out)] = {};
 	int err;
-	err = mlx5_cmd_query_vhca_state(dev, event->function_id, event->ecpu, out, sizeof(out));
+	err = mlx5_cmd_query_vhca_state(dev, event->function_id, out, sizeof(out));
 	if (err)
 		return;
 	event->new_vhca_state = MLX5_GET(query_vhca_state_out, out,
 					 vhca_state_context.vhca_state);
-	mlx5_vhca_event_arm(dev, event->function_id, event->ecpu);
+	mlx5_vhca_event_arm(dev, event->function_id);
 	blocking_notifier_call_chain(&dev->priv.vhca_state_notifier->n_head, 0, event);
 }
 	struct mlx5_core_dev *dev = notifier->dev;
 	mlx5_vhca_event_notify(dev, &work->event);
+	kfree(work);
 }
 static int
 	INIT_WORK(&work->work, &mlx5_vhca_state_work_handler);
 	work->notifier = notifier;
 	work->event.function_id = be16_to_cpu(eqe->data.vhca_state.function_id);
-	work->event.ecpu = be16_to_cpu(eqe->data.vhca_state.ec_function);
 	mlx5_events_work_enqueue(notifier->dev, &work->work);
 	return NOTIFY_OK;
 }

drivers/net/ethernet/mellanox/mlx5/core/sf/vhca_event.h+3−4

 	u16 function_id;
 	u16 sw_function_id;
 	u8 new_vhca_state;
-	bool ecpu;
 };
 static inline bool mlx5_vhca_event_supported(const struct mlx5_core_dev *dev)
 void mlx5_vhca_event_stop(struct mlx5_core_dev *dev);
 int mlx5_vhca_event_notifier_register(struct mlx5_core_dev *dev, struct notifier_block *nb);
 void mlx5_vhca_event_notifier_unregister(struct mlx5_core_dev *dev, struct notifier_block *nb);
-int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, bool ecpu, u32 sw_fn_id);
+int mlx5_modify_vhca_sw_id(struct mlx5_core_dev *dev, u16 function_id, u32 sw_fn_id);
-int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id, bool ecpu);
+int mlx5_vhca_event_arm(struct mlx5_core_dev *dev, u16 function_id);
 int mlx5_cmd_query_vhca_state(struct mlx5_core_dev *dev, u16 function_id,
-			      bool ecpu, u32 *out, u32 outlen);
+			      u32 *out, u32 outlen);
 #else
 static inline void mlx5_vhca_state_cap_handle(struct mlx5_core_dev *dev, void *set_hca_cap)

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_send.c+1−0

@@ -169,6 +169,7 @@ static struct mlx5dr_qp dr_create_rc_qp(struct mlx5_core_dev mdev, · 168 unmodified lines
169	MLX5_SET(qpc, qpc, log_rq_size, ilog2(dr_qp->rq.wqe_cnt));	169	MLX5_SET(qpc, qpc, log_rq_size, ilog2(dr_qp->rq.wqe_cnt));
170	MLX5_SET(qpc, qpc, rq_type, MLX5_NON_ZERO_RQ);	170	MLX5_SET(qpc, qpc, rq_type, MLX5_NON_ZERO_RQ);
171	MLX5_SET(qpc, qpc, log_sq_size, ilog2(dr_qp->sq.wqe_cnt));	171	MLX5_SET(qpc, qpc, log_sq_size, ilog2(dr_qp->sq.wqe_cnt));
		172	MLX5_SET(qpc, qpc, ts_format, mlx5_get_qp_default_ts(mdev));
172	MLX5_SET64(qpc, qpc, dbr_addr, dr_qp->wq_ctrl.db.dma);	173	MLX5_SET64(qpc, qpc, dbr_addr, dr_qp->wq_ctrl.db.dma);
173	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)	174	if (MLX5_CAP_GEN(mdev, cqe_version) == 1)
174	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);	175	MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste_v1.c+2−2

@@ -264,8 +264,8 @@ static void dr_ste_v1_set_miss_addr(u8 *hw_ste_p, u64 miss_addr) · 263 unmodified lines
264	static u64 dr_ste_v1_get_miss_addr(u8 *hw_ste_p)	264	static u64 dr_ste_v1_get_miss_addr(u8 *hw_ste_p)
265	{	265	{
266	u64 index =	266	u64 index =
267	(MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_31_6) \|	267	((u64)MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_31_6) \|
268	MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_39_32) << 26);	268	((u64)MLX5_GET(ste_match_bwc_v1, hw_ste_p, miss_address_39_32)) << 26);
269		269
270	return index << 6;	270	return index << 6;
271	}	271	}

drivers/net/ethernet/netronome/nfp/flower/metadata.c+17−7

 		goto err_free_ctx_entry;
 	}
+	/* Do net allocate a mask-id for pre_tun_rules. These flows are used to
+	 * configure the pre_tun table and are never actually send to the
+	 * firmware as an add-flow message. This causes the mask-id allocation
+	 * on the firmware to get out of sync if allocated here.
+	 */
 	new_mask_id = 0;
-	if (!nfp_check_mask_add(app, nfp_flow->mask_data,
+	if (!nfp_flow->pre_tun_rule.dev &&
+	    !nfp_check_mask_add(app, nfp_flow->mask_data,
 				nfp_flow->meta.mask_len,
 				&nfp_flow->meta.flags, &new_mask_id)) {
 		NL_SET_ERR_MSG_MOD(extack, "invalid entry: cannot allocate a new mask id");
 			goto err_remove_mask;
 		}
-		if (!nfp_check_mask_remove(app, nfp_flow->mask_data,
+		if (!nfp_flow->pre_tun_rule.dev &&
+		    !nfp_check_mask_remove(app, nfp_flow->mask_data,
 					   nfp_flow->meta.mask_len,
 					   NULL, &new_mask_id)) {
 			NL_SET_ERR_MSG_MOD(extack, "invalid entry: cannot release mask id");
 	return 0;
 err_remove_mask:
-	nfp_check_mask_remove(app, nfp_flow->mask_data, nfp_flow->meta.mask_len,
+	if (!nfp_flow->pre_tun_rule.dev)
-			      NULL, &new_mask_id);
+		nfp_check_mask_remove(app, nfp_flow->mask_data,
+				      nfp_flow->meta.mask_len,
+				      NULL, &new_mask_id);
 err_remove_rhash:
 	WARN_ON_ONCE(rhashtable_remove_fast(&priv->stats_ctx_table,
 					    &ctx_entry->ht_node,
 	__nfp_modify_flow_metadata(priv, nfp_flow);
-	nfp_check_mask_remove(app, nfp_flow->mask_data,
+	if (!nfp_flow->pre_tun_rule.dev)
-			      nfp_flow->meta.mask_len, &nfp_flow->meta.flags,
+		nfp_check_mask_remove(app, nfp_flow->mask_data,
-			      &new_mask_id);
+				      nfp_flow->meta.mask_len, &nfp_flow->meta.flags,
+				      &new_mask_id);
 	/* Update flow payload with mask ids. */
 	nfp_flow->unmasked_data[NFP_FL_MASK_ID_LOCATION] = new_mask_id;

drivers/net/ethernet/netronome/nfp/flower/offload.c+18−0

 		return -EOPNOTSUPP;
 	}
+	if (!(key_layer & NFP_FLOWER_LAYER_IPV4) &&
+	    !(key_layer & NFP_FLOWER_LAYER_IPV6)) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: match on ipv4/ipv6 eth_type must be present");
+		return -EOPNOTSUPP;
+	}
 	/* Skip fields known to exist. */
 	mask += sizeof(struct nfp_flower_meta_tci);
 	ext += sizeof(struct nfp_flower_meta_tci);
 	mask += sizeof(struct nfp_flower_in_port);
 	ext += sizeof(struct nfp_flower_in_port);
+	/* Ensure destination MAC address matches pre_tun_dev. */
+	mac = (struct nfp_flower_mac_mpls *)ext;
+	if (memcmp(&mac->mac_dst[0], flow->pre_tun_rule.dev->dev_addr, 6)) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: dest MAC must match output dev MAC");
+		return -EOPNOTSUPP;
+	}
 	/* Ensure destination MAC address is fully matched. */
 	mac = (struct nfp_flower_mac_mpls *)mask;
 	if (!is_broadcast_ether_addr(&mac->mac_dst[0])) {
 		return -EOPNOTSUPP;
 	}
+	if (mac->mpls_lse) {
+		NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: MPLS not supported");
+		return -EOPNOTSUPP;
+	}
 	mask += sizeof(struct nfp_flower_mac_mpls);
 	ext += sizeof(struct nfp_flower_mac_mpls);
 	if (key_layer & NFP_FLOWER_LAYER_IPV4 ||

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c+13−2

 #define NFP_FL_MAX_ROUTES               32
 #define NFP_TUN_PRE_TUN_RULE_LIMIT	32
-#define NFP_TUN_PRE_TUN_RULE_DEL	0x1
+#define NFP_TUN_PRE_TUN_RULE_DEL	BIT(0)
-#define NFP_TUN_PRE_TUN_IDX_BIT		0x8
+#define NFP_TUN_PRE_TUN_IDX_BIT		BIT(3)
+#define NFP_TUN_PRE_TUN_IPV6_BIT	BIT(7)
 /**
  * struct nfp_tun_pre_run_rule - rule matched before decap
 {
 	struct nfp_flower_priv *app_priv = app->priv;
 	struct nfp_tun_offloaded_mac *mac_entry;
+	struct nfp_flower_meta_tci *key_meta;
 	struct nfp_tun_pre_tun_rule payload;
 	struct net_device *internal_dev;
 	int err;
 	if (!mac_entry)
 		return -ENOENT;
+	/* Set/clear IPV6 bit. cpu_to_be16() swap will lead to MSB being
+	 * set/clear for port_idx.
+	 */
+	key_meta = (struct nfp_flower_meta_tci *)flow->unmasked_data;
+	if (key_meta->nfp_flow_key_layer & NFP_FLOWER_LAYER_IPV6)
+		mac_entry->index |= NFP_TUN_PRE_TUN_IPV6_BIT;
+	else
+		mac_entry->index &= ~NFP_TUN_PRE_TUN_IPV6_BIT;
 	payload.port_idx = cpu_to_be16(mac_entry->index);
 	/* Copy mac id and vlan to flow - dev may not exist at delete time. */

drivers/net/ethernet/pensando/ionic/ionic_txrx.c+7−6

 {
 	int sg_elems = q->lif->qtype_info[IONIC_QTYPE_TXQ].max_sg_elems;
 	struct ionic_tx_stats *stats = q_to_tx_stats(q);
+	int ndescs;
 	int err;
-	/* If TSO, need roundup(skb->len/mss) descs */
+	/* Each desc is mss long max, so a descriptor for each gso_seg */
 	if (skb_is_gso(skb))
-		return (skb->len / skb_shinfo(skb)->gso_size) + 1;
+		ndescs = skb_shinfo(skb)->gso_segs;
+	else
+		ndescs = 1;
-	/* If non-TSO, just need 1 desc and nr_frags sg elems */
 	if (skb_shinfo(skb)->nr_frags <= sg_elems)
-		return 1;
+		return ndescs;
 	/* Too many frags, so linearize */
 	err = skb_linearize(skb);
 	stats->linearize++;
-	/* Need 1 desc and zero sg elems */
+	return ndescs;
-	return 1;
 }
 static int ionic_maybe_stop_tx(struct ionic_queue *q, int ndescs)

drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c+3−0

 	if (fw_dump->tmpl_hdr == NULL || current_version > prev_version) {
 		vfree(fw_dump->tmpl_hdr);
+		fw_dump->tmpl_hdr = NULL;
 		if (qlcnic_83xx_md_check_extended_dump_capability(adapter))
 			extended = !qlcnic_83xx_extend_md_capab(adapter);
 			struct qlcnic_83xx_dump_template_hdr *hdr;
 			hdr = fw_dump->tmpl_hdr;
+			if (!hdr)
+				return;
 			hdr->drv_cap_mask = 0x1f;
 			fw_dump->cap_mask = 0x1f;
 			dev_info(&pdev->dev,

drivers/net/ethernet/realtek/r8169_main.c+4−2

 	rtl8169_update_counters(tp);
+	pci_clear_master(tp->pci_dev);
+	rtl_pci_commit(tp);
 	rtl8169_cleanup(tp, true);
 	rtl_prepare_power_down(tp);
 static void rtl8169_up(struct rtl8169_private *tp)
 {
+	pci_set_master(tp->pci_dev);
 	phy_resume(tp->phydev);
 	rtl8169_init_phy(tp);
 	napi_enable(&tp->napi);
 	rtl_hw_reset(tp);
-	pci_set_master(pdev);
 	rc = rtl_alloc_irq(tp);
 	if (rc < 0) {
 		dev_err(&pdev->dev, "Can't allocate interrupt\n");

drivers/net/ethernet/socionext/netsec.c+6−3

 		goto err1;
 	/* set phy power down */
-	data = netsec_phy_read(priv->mii_bus, priv->phy_addr, MII_BMCR) |
+	data = netsec_phy_read(priv->mii_bus, priv->phy_addr, MII_BMCR);
-		BMCR_PDOWN;
+	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR,
-	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR, data);
+			 data | BMCR_PDOWN);
 	ret = netsec_reset_hardware(priv, true);
 	if (ret)
 		goto err2;
+	/* Restore phy power state */
+	netsec_phy_write(priv->mii_bus, priv->phy_addr, MII_BMCR, data);
 	spin_lock_init(&priv->desc_ring[NETSEC_RING_TX].lock);
 	spin_lock_init(&priv->desc_ring[NETSEC_RING_RX].lock);

drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c+2−0

@@ -1214,6 +1214,8 @@ static int sun8i_dwmac_probe(struct platform_device *pdev) · 1213 unmodified lines
1214	plat_dat->init = sun8i_dwmac_init;	1214	plat_dat->init = sun8i_dwmac_init;
1215	plat_dat->exit = sun8i_dwmac_exit;	1215	plat_dat->exit = sun8i_dwmac_exit;
1216	plat_dat->setup = sun8i_dwmac_setup;	1216	plat_dat->setup = sun8i_dwmac_setup;
		1217	plat_dat->tx_fifo_size = 4096;
		1218	plat_dat->rx_fifo_size = 16384;
1217		1219
1218	ret = sun8i_dwmac_set_syscon(&pdev->dev, plat_dat);	1220	ret = sun8i_dwmac_set_syscon(&pdev->dev, plat_dat);
1219	if (ret)	1221	if (ret)

drivers/net/ethernet/xilinx/xilinx_axienet_main.c+25−12

 	if (IS_ERR(lp->regs)) {
 		dev_err(&pdev->dev, "could not map Axi Ethernet regs.\n");
 		ret = PTR_ERR(lp->regs);
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	lp->regs_start = ethres->start;
 			break;
 		default:
 			ret = -EINVAL;
-			goto free_netdev;
+			goto cleanup_clk;
 		}
 	} else {
 		ret = of_get_phy_mode(pdev->dev.of_node, &lp->phy_mode);
 		if (ret)
-			goto free_netdev;
+			goto cleanup_clk;
 	}
 	if (lp->switch_x_sgmii && lp->phy_mode != PHY_INTERFACE_MODE_SGMII &&
 	    lp->phy_mode != PHY_INTERFACE_MODE_1000BASEX) {
 		dev_err(&pdev->dev, "xlnx,switch-x-sgmii only supported with SGMII or 1000BaseX\n");
 		ret = -EINVAL;
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Find the DMA node, map the DMA registers, and decode the DMA IRQs */
 			dev_err(&pdev->dev,
 				"unable to get DMA resource\n");
 			of_node_put(np);
-			goto free_netdev;
+			goto cleanup_clk;
 		}
 		lp->dma_regs = devm_ioremap_resource(&pdev->dev,
 						     &dmares);
 	if (IS_ERR(lp->dma_regs)) {
 		dev_err(&pdev->dev, "could not map DMA regs\n");
 		ret = PTR_ERR(lp->dma_regs);
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	if ((lp->rx_irq <= 0) || (lp->tx_irq <= 0)) {
 		dev_err(&pdev->dev, "could not determine irqs\n");
 		ret = -ENOMEM;
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Autodetect the need for 64-bit DMA pointers.
 	ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(addr_width));
 	if (ret) {
 		dev_err(&pdev->dev, "No suitable DMA available\n");
-		goto free_netdev;
+		goto cleanup_clk;
 	}
 	/* Check for Ethernet core IRQ (optional) */
 		if (!lp->phy_node) {
 			dev_err(&pdev->dev, "phy-handle required for 1000BaseX/SGMII\n");
 			ret = -EINVAL;
-			goto free_netdev;
+			goto cleanup_mdio;
 		}
 		lp->pcs_phy = of_mdio_find_device(lp->phy_node);
 		if (!lp->pcs_phy) {
 			ret = -EPROBE_DEFER;
-			goto free_netdev;
+			goto cleanup_mdio;
 		}
 		lp->phylink_config.pcs_poll = true;
 	}
 	if (IS_ERR(lp->phylink)) {
 		ret = PTR_ERR(lp->phylink);
 		dev_err(&pdev->dev, "phylink_create error (%i)\n", ret);
-		goto free_netdev;
+		goto cleanup_mdio;
 	}
 	ret = register_netdev(lp->ndev);
 	if (ret) {
 		dev_err(lp->dev, "register_netdev() error (%i)\n", ret);
-		goto free_netdev;
+		goto cleanup_phylink;
 	}
 	return 0;
+cleanup_phylink:
+	phylink_destroy(lp->phylink);
+cleanup_mdio:
+	if (lp->pcs_phy)
+		put_device(&lp->pcs_phy->dev);
+	if (lp->mii_bus)
+		axienet_mdio_teardown(lp);
+	of_node_put(lp->phy_node);
+cleanup_clk:
+	clk_disable_unprepare(lp->clk);
 free_netdev:
 	free_netdev(ndev);

drivers/net/ipa/ipa_cmd.c+33−17

@@ -175,21 +175,23 @@ bool ipa_cmd_table_valid(struct ipa ipa, const struct ipa_mem mem, · 174 unmodified lines
175	: field_max(IP_FLTRT_FLAGS_NHASH_ADDR_FMASK);	175	: field_max(IP_FLTRT_FLAGS_NHASH_ADDR_FMASK);
176	if (mem->offset > offset_max \|\|	176	if (mem->offset > offset_max \|\|
177	ipa->mem_offset > offset_max - mem->offset) {	177	ipa->mem_offset > offset_max - mem->offset) {
178	dev_err(dev, "IPv%c %s%s table region offset too large "	178	dev_err(dev, "IPv%c %s%s table region offset too large\n",
179	"(0x%04x + 0x%04x > 0x%04x)\n",	179	ipv6 ? '6' : '4', hashed ? "hashed " : "",
180	ipv6 ? '6' : '4', hashed ? "hashed " : "",	180	route ? "route" : "filter");
181	route ? "route" : "filter",	181	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
182	ipa->mem_offset, mem->offset, offset_max);	182	ipa->mem_offset, mem->offset, offset_max);
		183
183	return false;	184	return false;
184	}	185	}
185		186
186	if (mem->offset > ipa->mem_size \|\|	187	if (mem->offset > ipa->mem_size \|\|
187	mem->size > ipa->mem_size - mem->offset) {	188	mem->size > ipa->mem_size - mem->offset) {
188	dev_err(dev, "IPv%c %s%s table region out of range "	189	dev_err(dev, "IPv%c %s%s table region out of range\n",
189	"(0x%04x + 0x%04x > 0x%04x)\n",	190	ipv6 ? '6' : '4', hashed ? "hashed " : "",
190	ipv6 ? '6' : '4', hashed ? "hashed " : "",	191	route ? "route" : "filter");
191	route ? "route" : "filter",	192	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
192	mem->offset, mem->size, ipa->mem_size);	193	mem->offset, mem->size, ipa->mem_size);
		194
193	return false;	195	return false;
194	}	196	}
195		197
@@ -205,22 +207,36 @@ static bool ipa_cmd_header_valid(struct ipa *ipa) · 9 unmodified lines
205	u32 size_max;	207	u32 size_max;
206	u32 size;	208	u32 size;
207		209
		210	/* In ipa_cmd_hdr_init_local_add() we record the offset and size
		211	* of the header table memory area. Make sure the offset and size
		212	* fit in the fields that need to hold them, and that the entire
		213	* range is within the overall IPA memory range.
		214	*/
208	offset_max = field_max(HDR_INIT_LOCAL_FLAGS_HDR_ADDR_FMASK);	215	offset_max = field_max(HDR_INIT_LOCAL_FLAGS_HDR_ADDR_FMASK);
209	if (mem->offset > offset_max \|\|	216	if (mem->offset > offset_max \|\|
210	ipa->mem_offset > offset_max - mem->offset) {	217	ipa->mem_offset > offset_max - mem->offset) {
211	dev_err(dev, "header table region offset too large "	218	dev_err(dev, "header table region offset too large\n");
212	"(0x%04x + 0x%04x > 0x%04x)\n",	219	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
213	ipa->mem_offset + mem->offset, offset_max);	220	ipa->mem_offset, mem->offset, offset_max);
		221
214	return false;	222	return false;
215	}	223	}
216		224
217	size_max = field_max(HDR_INIT_LOCAL_FLAGS_TABLE_SIZE_FMASK);	225	size_max = field_max(HDR_INIT_LOCAL_FLAGS_TABLE_SIZE_FMASK);
218	size = ipa->mem[IPA_MEM_MODEM_HEADER].size;	226	size = ipa->mem[IPA_MEM_MODEM_HEADER].size;
219	size += ipa->mem[IPA_MEM_AP_HEADER].size;	227	size += ipa->mem[IPA_MEM_AP_HEADER].size;
220	if (mem->offset > ipa->mem_size \|\| size > ipa->mem_size - mem->offset) {	228
221	dev_err(dev, "header table region out of range "	229	if (size > size_max) {
222	"(0x%04x + 0x%04x > 0x%04x)\n",	230	dev_err(dev, "header table region size too large\n");
223	mem->offset, size, ipa->mem_size);	231	dev_err(dev, " (0x%04x > 0x%08x)\n", size, size_max);
		232
		233	return false;
		234	}
		235	if (size > ipa->mem_size \|\| mem->offset > ipa->mem_size - size) {
		236	dev_err(dev, "header table region out of range\n");
		237	dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n",
		238	mem->offset, size, ipa->mem_size);
		239
224	return false;	240	return false;
225	}	241	}
226		242

drivers/net/ipa/ipa_qmi.c+2−0

 		.decoded_size	= IPA_QMI_DRIVER_INIT_COMPLETE_REQ_SZ,
 		.fn		= ipa_server_driver_init_complete,
 	},
+	{ },
 };
 /* Handle an INIT_DRIVER response message from the modem. */
 		.decoded_size	= IPA_QMI_INIT_DRIVER_RSP_SZ,
 		.fn		= ipa_client_init_driver,
 	},
+	{ },
 };
 /* Return a pointer to an init modem driver request structure, which contains

drivers/net/phy/broadcom.c+9−0

 	bcm54xx_adjust_rxrefclk(phydev);
 	switch (BRCM_PHY_MODEL(phydev)) {
+	case PHY_ID_BCM50610:
+	case PHY_ID_BCM50610M:
+		err = bcm54xx_config_clock_delay(phydev);
+		break;
 	case PHY_ID_BCM54210E:
 		err = bcm54210e_config_init(phydev);
 		break;
 	if (ret < 0)
 		return ret;
+	/* Upon exiting power down, the PHY remains in an internal reset state
+	 * for 40us
+	 */
+	fsleep(40);
 	return bcm54xx_config_init(phydev);
 }

drivers/net/phy/phylink.c+1−1

@@ -476,7 +476,7 @@ static void phylink_major_config(struct phylink *pl, bool restart, · 475 unmodified lines
476	err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,	476	err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,
477	state->interface);	477	state->interface);
478	if (err < 0)	478	if (err < 0)
479	phylink_err(pl, "mac_prepare failed: %pe\n",	479	phylink_err(pl, "mac_finish failed: %pe\n",
480	ERR_PTR(err));	480	ERR_PTR(err));
481	}	481	}
482	}	482	}

drivers/net/usb/cdc-phonet.c+2−0

@@ -387,6 +387,8 @@ static int usbpn_probe(struct usb_interface intf, const struct usb_device_id i · 386 unmodified lines
387		387
388	err = register_netdev(dev);	388	err = register_netdev(dev);
389	if (err) {	389	if (err) {
		390	/* Set disconnected flag so that disconnect() returns early. */
		391	pnd->disconnected = 1;
390	usb_driver_release_interface(&usbpn_driver, data_intf);	392	usb_driver_release_interface(&usbpn_driver, data_intf);
391	goto out;	393	goto out;
392	}	394	}

drivers/net/usb/r8152.c+4−1

 		ops->in_nway		= rtl8153_in_nway;
 		ops->hw_phy_cfg		= r8153_hw_phy_cfg;
 		ops->autosuspend_en	= rtl8153_runtime_enable;
-		tp->rx_buf_sz		= 32 * 1024;
+		if (tp->udev->speed < USB_SPEED_SUPER)
+			tp->rx_buf_sz	= 16 * 1024;
+		else
+			tp->rx_buf_sz	= 32 * 1024;
 		tp->eee_en		= true;
 		tp->eee_adv		= MDIO_EEE_1000T | MDIO_EEE_100TX;
 		break;

drivers/net/veth.c+1−2

@@ -302,8 +302,7 @@ static netdev_tx_t veth_xmit(struct sk_buff skb, struct net_device dev) · 301 unmodified lines
302	if (rxq < rcv->real_num_rx_queues) {	302	if (rxq < rcv->real_num_rx_queues) {
303	rq = &rcv_priv->rq[rxq];	303	rq = &rcv_priv->rq[rxq];
304	rcv_xdp = rcu_access_pointer(rq->xdp_prog);	304	rcv_xdp = rcu_access_pointer(rq->xdp_prog);
305	if (rcv_xdp)	305	skb_record_rx_queue(skb, rxq);
306	skb_record_rx_queue(skb, rxq);
307	}	306	}
308		307
309	skb_tx_timestamp(skb);	308	skb_tx_timestamp(skb);

drivers/net/wan/hdlc_x25.c+41−1

 struct x25_state {
 	x25_hdlc_proto settings;
+	bool up;
+	spinlock_t up_lock; /* Protects "up" */
 };
 static int x25_ioctl(struct net_device *dev, struct ifreq *ifr);
 static netdev_tx_t x25_xmit(struct sk_buff *skb, struct net_device *dev)
 {
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	int result;
 	/* There should be a pseudo header of 1 byte added by upper layers.
 		return NETDEV_TX_OK;
 	}
+	spin_lock_bh(&x25st->up_lock);
+	if (!x25st->up) {
+		spin_unlock_bh(&x25st->up_lock);
+		kfree_skb(skb);
+		return NETDEV_TX_OK;
+	}
 	switch (skb->data[0]) {
 	case X25_IFACE_DATA:	/* Data to be transmitted */
 		skb_pull(skb, 1);
 		if ((result = lapb_data_request(dev, skb)) != LAPB_OK)
 			dev_kfree_skb(skb);
+		spin_unlock_bh(&x25st->up_lock);
 		return NETDEV_TX_OK;
 	case X25_IFACE_CONNECT:
 		break;
 	}
+	spin_unlock_bh(&x25st->up_lock);
 	dev_kfree_skb(skb);
 	return NETDEV_TX_OK;
 }
 		.data_transmit = x25_data_transmit,
 	};
 	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	struct lapb_parms_struct params;
 	int result;
 	if (result != LAPB_OK)
 		return -EINVAL;
+	spin_lock_bh(&x25st->up_lock);
+	x25st->up = true;
+	spin_unlock_bh(&x25st->up_lock);
 	return 0;
 }
 static void x25_close(struct net_device *dev)
 {
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
+	spin_lock_bh(&x25st->up_lock);
+	x25st->up = false;
+	spin_unlock_bh(&x25st->up_lock);
 	lapb_unregister(dev);
 }
 static int x25_rx(struct sk_buff *skb)
 {
 	struct net_device *dev = skb->dev;
+	hdlc_device *hdlc = dev_to_hdlc(dev);
+	struct x25_state *x25st = state(hdlc);
 	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
 		dev->stats.rx_dropped++;
 		return NET_RX_DROP;
 	}
-	if (lapb_data_received(dev, skb) == LAPB_OK)
+	spin_lock_bh(&x25st->up_lock);
+	if (!x25st->up) {
+		spin_unlock_bh(&x25st->up_lock);
+		kfree_skb(skb);
+		dev->stats.rx_dropped++;
+		return NET_RX_DROP;
+	}
+	if (lapb_data_received(dev, skb) == LAPB_OK) {
+		spin_unlock_bh(&x25st->up_lock);
 		return NET_RX_SUCCESS;
+	}
+	spin_unlock_bh(&x25st->up_lock);
 	dev->stats.rx_errors++;
 	dev_kfree_skb_any(skb);
 	return NET_RX_DROP;
 			return result;
 		memcpy(&state(hdlc)->settings, &new_settings, size);
+		state(hdlc)->up = false;
+		spin_lock_init(&state(hdlc)->up_lock);
 		/* There's no header_ops so hard_header_len should be 0. */
 		dev->hard_header_len = 0;

drivers/pinctrl/intel/pinctrl-intel.c+8−1

 				gpps[i].gpio_base = 0;
 				break;
 			case INTEL_GPIO_BASE_NOMAP:
+				break;
 			default:
 				break;
 		}
 		gpps[i].size = min(gpp_size, npins);
 		npins -= gpps[i].size;
+		gpps[i].gpio_base = gpps[i].base;
 		gpps[i].padown_num = padown_num;
 		/*
 		if (IS_ERR(regs))
 			return PTR_ERR(regs);
-		/* Determine community features based on the revision */
+		/*
+		 * Determine community features based on the revision.
+		 * A value of all ones means the device is not present.
+		 */
 		value = readl(regs + REVID);
+		if (value == ~0u)
+			return -ENODEV;
 		if (((value & REVID_MASK) >> REVID_SHIFT) >= 0x94) {
 			community->features |= PINCTRL_FEATURE_DEBOUNCE;
 			community->features |= PINCTRL_FEATURE_1K_PD;

drivers/pinctrl/pinctrl-microchip-sgpio.c+1−1

@@ -572,7 +572,7 @@ static void microchip_sgpio_irq_settype(struct irq_data *data, · 571 unmodified lines
572	/* Type value spread over 2 registers sets: low, high bit */	572	/* Type value spread over 2 registers sets: low, high bit */
573	sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER, addr.bit,	573	sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER, addr.bit,
574	BIT(addr.port), (!!(type & 0x1)) << addr.port);	574	BIT(addr.port), (!!(type & 0x1)) << addr.port);
575	sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER + SGPIO_MAX_BITS, addr.bit,	575	sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER, SGPIO_MAX_BITS + addr.bit,
576	BIT(addr.port), (!!(type & 0x2)) << addr.port);	576	BIT(addr.port), (!!(type & 0x2)) << addr.port);
577		577
578	if (type == SGPIO_INT_TRG_LEVEL)	578	if (type == SGPIO_INT_TRG_LEVEL)

drivers/pinctrl/pinctrl-rockchip.c+8−5

 static int __maybe_unused rockchip_pinctrl_resume(struct device *dev)
 {
 	struct rockchip_pinctrl *info = dev_get_drvdata(dev);
-	int ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
+	int ret;
-			       rk3288_grf_gpio6c_iomux |
-			       GPIO6C6_SEL_WRITE_ENABLE);
-	if (ret)
+	if (info->ctrl->type == RK3288) {
-		return ret;
+		ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
+				   rk3288_grf_gpio6c_iomux |
+				   GPIO6C6_SEL_WRITE_ENABLE);
+		if (ret)
+			return ret;
+	}
 	return pinctrl_force_default(info->pctl_dev);
 }

drivers/pinctrl/qcom/pinctrl-lpass-lpi.c+1−1

@@ -392,7 +392,7 @@ static int lpi_config_set(struct pinctrl_dev *pctldev, unsigned int group, · 391 unmodified lines
392	unsigned long *configs, unsigned int nconfs)	392	unsigned long *configs, unsigned int nconfs)
393	{	393	{
394	struct lpi_pinctrl *pctrl = dev_get_drvdata(pctldev->dev);	394	struct lpi_pinctrl *pctrl = dev_get_drvdata(pctldev->dev);
395	unsigned int param, arg, pullup, strength;	395	unsigned int param, arg, pullup = LPI_GPIO_BIAS_DISABLE, strength = 2;
396	bool value, output_enabled = false;	396	bool value, output_enabled = false;
397	const struct lpi_pingroup *g;	397	const struct lpi_pingroup *g;
398	unsigned long sval;	398	unsigned long sval;

drivers/pinctrl/qcom/pinctrl-sc7280.c+8−8

@@ -1439,14 +1439,14 @@ static const struct msm_pingroup sc7280_groups[] = { · 1438 unmodified lines
1439	[172] = PINGROUP(172, qdss, _, _, _, _, _, _, _, _),	1439	[172] = PINGROUP(172, qdss, _, _, _, _, _, _, _, _),
1440	[173] = PINGROUP(173, qdss, _, _, _, _, _, _, _, _),	1440	[173] = PINGROUP(173, qdss, _, _, _, _, _, _, _, _),
1441	[174] = PINGROUP(174, qdss, _, _, _, _, _, _, _, _),	1441	[174] = PINGROUP(174, qdss, _, _, _, _, _, _, _, _),
1442	[175] = UFS_RESET(ufs_reset, 0x1be000),	1442	[175] = UFS_RESET(ufs_reset, 0xbe000),
1443	[176] = SDC_QDSD_PINGROUP(sdc1_rclk, 0x1b3000, 15, 0),	1443	[176] = SDC_QDSD_PINGROUP(sdc1_rclk, 0xb3004, 0, 6),
1444	[177] = SDC_QDSD_PINGROUP(sdc1_clk, 0x1b3000, 13, 6),	1444	[177] = SDC_QDSD_PINGROUP(sdc1_clk, 0xb3000, 13, 6),
1445	[178] = SDC_QDSD_PINGROUP(sdc1_cmd, 0x1b3000, 11, 3),	1445	[178] = SDC_QDSD_PINGROUP(sdc1_cmd, 0xb3000, 11, 3),
1446	[179] = SDC_QDSD_PINGROUP(sdc1_data, 0x1b3000, 9, 0),	1446	[179] = SDC_QDSD_PINGROUP(sdc1_data, 0xb3000, 9, 0),
1447	[180] = SDC_QDSD_PINGROUP(sdc2_clk, 0x1b4000, 14, 6),	1447	[180] = SDC_QDSD_PINGROUP(sdc2_clk, 0xb4000, 14, 6),
1448	[181] = SDC_QDSD_PINGROUP(sdc2_cmd, 0x1b4000, 11, 3),	1448	[181] = SDC_QDSD_PINGROUP(sdc2_cmd, 0xb4000, 11, 3),
1449	[182] = SDC_QDSD_PINGROUP(sdc2_data, 0x1b4000, 9, 0),	1449	[182] = SDC_QDSD_PINGROUP(sdc2_data, 0xb4000, 9, 0),
1450	};	1450	};
1451		1451
1452	static const struct msm_pinctrl_soc_data sc7280_pinctrl = {	1452	static const struct msm_pinctrl_soc_data sc7280_pinctrl = {

drivers/pinctrl/qcom/pinctrl-sdx55.c+1−1

@@ -423,7 +423,7 @@ static const char * const gpio_groups[] = { · 422 unmodified lines
423		423
424	static const char * const qdss_stm_groups[] = {	424	static const char * const qdss_stm_groups[] = {
425	"gpio0", "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", "gpio12", "gpio13",	425	"gpio0", "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", "gpio12", "gpio13",
426	"gpio14", "gpio15", "gpio16", "gpio17", "gpio18", "gpio19" "gpio20", "gpio21", "gpio22",	426	"gpio14", "gpio15", "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21", "gpio22",
427	"gpio23", "gpio44", "gpio45", "gpio52", "gpio53", "gpio56", "gpio57", "gpio61", "gpio62",	427	"gpio23", "gpio44", "gpio45", "gpio52", "gpio53", "gpio56", "gpio57", "gpio61", "gpio62",
428	"gpio63", "gpio64", "gpio65", "gpio66",	428	"gpio63", "gpio64", "gpio65", "gpio66",
429	};	429	};

drivers/platform/x86/Kconfig+8−3

 	depends on PCI
 	help
 	  The Intel Platform Controller Hub for Intel Core SoCs provides access
-	  to Power Management Controller registers via a PCI interface. This
+	  to Power Management Controller registers via various interfaces. This
 	  driver can utilize debugging capabilities and supported features as
-	  exposed by the Power Management Controller.
+	  exposed by the Power Management Controller. It also may perform some
+	  tasks in the PMC in order to enable transition into the SLPS0 state.
+	  It should be selected on all Intel platforms supported by the driver.
 	  Supported features:
 		- SLP_S0_RESIDENCY counter
 		- PCH IP Power Gating status
-		- LTR Ignore
+		- LTR Ignore / LTR Show
 		- MPHY/PLL gating status (Sunrisepoint PCH only)
+		- SLPS0 Debug registers (Cannonlake/Icelake PCH)
+		- Low Power Mode registers (Tigerlake and beyond)
+		- PMC quirks as needed to enable SLPS0/S0ix
 config INTEL_PMT_CLASS
 	tristate

drivers/platform/x86/dell/dell-wmi-sysman/enum-attributes.c+3−0

@@ -185,5 +185,8 @@ void exit_enum_attributes(void) · 184 unmodified lines
185	sysfs_remove_group(wmi_priv.enumeration_data[instance_id].attr_name_kobj,	185	sysfs_remove_group(wmi_priv.enumeration_data[instance_id].attr_name_kobj,
186	&enumeration_attr_group);	186	&enumeration_attr_group);
187	}	187	}
		188	wmi_priv.enumeration_instances_count = 0;
		189
188	kfree(wmi_priv.enumeration_data);	190	kfree(wmi_priv.enumeration_data);
		191	wmi_priv.enumeration_data = NULL;
189	}	192	}

drivers/platform/x86/dell/dell-wmi-sysman/int-attributes.c+3−0

@@ -175,5 +175,8 @@ void exit_int_attributes(void) · 174 unmodified lines
175	sysfs_remove_group(wmi_priv.integer_data[instance_id].attr_name_kobj,	175	sysfs_remove_group(wmi_priv.integer_data[instance_id].attr_name_kobj,
176	&integer_attr_group);	176	&integer_attr_group);
177	}	177	}
		178	wmi_priv.integer_instances_count = 0;
		179
178	kfree(wmi_priv.integer_data);	180	kfree(wmi_priv.integer_data);
		181	wmi_priv.integer_data = NULL;
179	}	182	}

drivers/platform/x86/dell/dell-wmi-sysman/passobj-attributes.c+3−0

@@ -183,5 +183,8 @@ void exit_po_attributes(void) · 182 unmodified lines
183	sysfs_remove_group(wmi_priv.po_data[instance_id].attr_name_kobj,	183	sysfs_remove_group(wmi_priv.po_data[instance_id].attr_name_kobj,
184	&po_attr_group);	184	&po_attr_group);
185	}	185	}
		186	wmi_priv.po_instances_count = 0;
		187
186	kfree(wmi_priv.po_data);	188	kfree(wmi_priv.po_data);
		189	wmi_priv.po_data = NULL;
187	}	190	}

drivers/platform/x86/dell/dell-wmi-sysman/string-attributes.c+3−0

@@ -155,5 +155,8 @@ void exit_str_attributes(void) · 154 unmodified lines
155	sysfs_remove_group(wmi_priv.str_data[instance_id].attr_name_kobj,	155	sysfs_remove_group(wmi_priv.str_data[instance_id].attr_name_kobj,
156	&str_attr_group);	156	&str_attr_group);
157	}	157	}
		158	wmi_priv.str_instances_count = 0;
		159
158	kfree(wmi_priv.str_data);	160	kfree(wmi_priv.str_data);
		161	wmi_priv.str_data = NULL;
159	}	162	}

drivers/platform/x86/dell/dell-wmi-sysman/sysman.c+32−52

@@ -210,25 +210,17 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot); · 209 unmodified lines
210	*/	210	*/
211	static int create_attributes_level_sysfs_files(void)	211	static int create_attributes_level_sysfs_files(void)
212	{	212	{
213	int ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);	213	int ret;
214		214
215	if (ret) {	215	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
216	pr_debug("could not create reset_bios file\n");	216	if (ret)
217	return ret;	217	return ret;
218	}
219		218
220	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);	219	ret = sysfs_create_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
221	if (ret) {	220	if (ret)
222	pr_debug("could not create changing_pending_reboot file\n");	221	return ret;
223	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
224	}
225	return ret;
226	}
227		222
228	static void release_reset_bios_data(void)	223	return 0;
229	{
230	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
231	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
232	}	224	}
233		225
234	static ssize_t wmi_sysman_attr_show(struct kobject kobj, struct attribute attr,	226	static ssize_t wmi_sysman_attr_show(struct kobject kobj, struct attribute attr,
@@ -373,8 +365,6 @@ static void destroy_attribute_objs(struct kset *kset) · 138 unmodified lines
373	*/	365	*/
374	static void release_attributes_data(void)	366	static void release_attributes_data(void)
375	{	367	{
376	release_reset_bios_data();
377
378	mutex_lock(&wmi_priv.mutex);	368	mutex_lock(&wmi_priv.mutex);
379	exit_enum_attributes();	369	exit_enum_attributes();
380	exit_int_attributes();	370	exit_int_attributes();
@@ -386,11 +376,13 @@ static void release_attributes_data(void) · 5 unmodified lines
386	wmi_priv.authentication_dir_kset = NULL;	376	wmi_priv.authentication_dir_kset = NULL;
387	}	377	}
388	if (wmi_priv.main_dir_kset) {	378	if (wmi_priv.main_dir_kset) {
		379	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &reset_bios.attr);
		380	sysfs_remove_file(&wmi_priv.main_dir_kset->kobj, &pending_reboot.attr);
389	destroy_attribute_objs(wmi_priv.main_dir_kset);	381	destroy_attribute_objs(wmi_priv.main_dir_kset);
390	kset_unregister(wmi_priv.main_dir_kset);	382	kset_unregister(wmi_priv.main_dir_kset);
		383	wmi_priv.main_dir_kset = NULL;
391	}	384	}
392	mutex_unlock(&wmi_priv.mutex);	385	mutex_unlock(&wmi_priv.mutex);
393
394	}	386	}
395		387
396	/**	388	/**
@@ -497,7 +489,6 @@ nextobj: · 100 unmodified lines
497		489
498	err_attr_init:	490	err_attr_init:
499	mutex_unlock(&wmi_priv.mutex);	491	mutex_unlock(&wmi_priv.mutex);
500	release_attributes_data();
501	kfree(obj);	492	kfree(obj);
502	return retval;	493	return retval;
503	}	494	}
@@ -513,102 +504,91 @@ static int __init sysman_init(void) · 9 unmodified lines
513	}	504	}
514		505
515	ret = init_bios_attr_set_interface();	506	ret = init_bios_attr_set_interface();
516	if (ret \|\| !wmi_priv.bios_attr_wdev) {	507	if (ret)
517	pr_debug("failed to initialize set interface\n");	508	return ret;
518	goto fail_set_interface;
519	}
520		509
521	ret = init_bios_attr_pass_interface();	510	ret = init_bios_attr_pass_interface();
522	if (ret \|\| !wmi_priv.password_attr_wdev) {	511	if (ret)
523	pr_debug("failed to initialize pass interface\n");	512	goto err_exit_bios_attr_set_interface;
524	goto fail_pass_interface;	513
		514	if (!wmi_priv.bios_attr_wdev \|\| !wmi_priv.password_attr_wdev) {
		515	pr_debug("failed to find set or pass interface\n");
		516	ret = -ENODEV;
		517	goto err_exit_bios_attr_pass_interface;
525	}	518	}
526		519
527	ret = class_register(&firmware_attributes_class);	520	ret = class_register(&firmware_attributes_class);
528	if (ret)	521	if (ret)
529	goto fail_class;	522	goto err_exit_bios_attr_pass_interface;
530		523
531	wmi_priv.class_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),	524	wmi_priv.class_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
532	NULL, "%s", DRIVER_NAME);	525	NULL, "%s", DRIVER_NAME);
533	if (IS_ERR(wmi_priv.class_dev)) {	526	if (IS_ERR(wmi_priv.class_dev)) {
534	ret = PTR_ERR(wmi_priv.class_dev);	527	ret = PTR_ERR(wmi_priv.class_dev);
535	goto fail_classdev;	528	goto err_unregister_class;
536	}	529	}
537		530
538	wmi_priv.main_dir_kset = kset_create_and_add("attributes", NULL,	531	wmi_priv.main_dir_kset = kset_create_and_add("attributes", NULL,
539	&wmi_priv.class_dev->kobj);	532	&wmi_priv.class_dev->kobj);
540	if (!wmi_priv.main_dir_kset) {	533	if (!wmi_priv.main_dir_kset) {
541	ret = -ENOMEM;	534	ret = -ENOMEM;
542	goto fail_main_kset;	535	goto err_destroy_classdev;
543	}	536	}
544		537
545	wmi_priv.authentication_dir_kset = kset_create_and_add("authentication", NULL,	538	wmi_priv.authentication_dir_kset = kset_create_and_add("authentication", NULL,
546	&wmi_priv.class_dev->kobj);	539	&wmi_priv.class_dev->kobj);
547	if (!wmi_priv.authentication_dir_kset) {	540	if (!wmi_priv.authentication_dir_kset) {
548	ret = -ENOMEM;	541	ret = -ENOMEM;
549	goto fail_authentication_kset;	542	goto err_release_attributes_data;
550	}	543	}
551		544
552	ret = create_attributes_level_sysfs_files();	545	ret = create_attributes_level_sysfs_files();
553	if (ret) {	546	if (ret) {
554	pr_debug("could not create reset BIOS attribute\n");	547	pr_debug("could not create reset BIOS attribute\n");
555	goto fail_reset_bios;	548	goto err_release_attributes_data;
556	}	549	}
557		550
558	ret = init_bios_attributes(ENUM, DELL_WMI_BIOS_ENUMERATION_ATTRIBUTE_GUID);	551	ret = init_bios_attributes(ENUM, DELL_WMI_BIOS_ENUMERATION_ATTRIBUTE_GUID);
559	if (ret) {	552	if (ret) {
560	pr_debug("failed to populate enumeration type attributes\n");	553	pr_debug("failed to populate enumeration type attributes\n");
561	goto fail_create_group;	554	goto err_release_attributes_data;
562	}	555	}
563		556
564	ret = init_bios_attributes(INT, DELL_WMI_BIOS_INTEGER_ATTRIBUTE_GUID);	557	ret = init_bios_attributes(INT, DELL_WMI_BIOS_INTEGER_ATTRIBUTE_GUID);
565	if (ret) {	558	if (ret) {
566	pr_debug("failed to populate integer type attributes\n");	559	pr_debug("failed to populate integer type attributes\n");
567	goto fail_create_group;	560	goto err_release_attributes_data;
568	}	561	}
569		562
570	ret = init_bios_attributes(STR, DELL_WMI_BIOS_STRING_ATTRIBUTE_GUID);	563	ret = init_bios_attributes(STR, DELL_WMI_BIOS_STRING_ATTRIBUTE_GUID);
571	if (ret) {	564	if (ret) {
572	pr_debug("failed to populate string type attributes\n");	565	pr_debug("failed to populate string type attributes\n");
573	goto fail_create_group;	566	goto err_release_attributes_data;
574	}	567	}
575		568
576	ret = init_bios_attributes(PO, DELL_WMI_BIOS_PASSOBJ_ATTRIBUTE_GUID);	569	ret = init_bios_attributes(PO, DELL_WMI_BIOS_PASSOBJ_ATTRIBUTE_GUID);
577	if (ret) {	570	if (ret) {
578	pr_debug("failed to populate pass object type attributes\n");	571	pr_debug("failed to populate pass object type attributes\n");
579	goto fail_create_group;	572	goto err_release_attributes_data;
580	}	573	}
581		574
582	return 0;	575	return 0;
583		576
584	fail_create_group:	577	err_release_attributes_data:
585	release_attributes_data();	578	release_attributes_data();
586		579
587	fail_reset_bios:	580	err_destroy_classdev:
588	if (wmi_priv.authentication_dir_kset) {
589	kset_unregister(wmi_priv.authentication_dir_kset);
590	wmi_priv.authentication_dir_kset = NULL;
591	}
592
593	fail_authentication_kset:
594	if (wmi_priv.main_dir_kset) {
595	kset_unregister(wmi_priv.main_dir_kset);
596	wmi_priv.main_dir_kset = NULL;
597	}
598
599	fail_main_kset:
600	device_destroy(&firmware_attributes_class, MKDEV(0, 0));	581	device_destroy(&firmware_attributes_class, MKDEV(0, 0));
601		582
602	fail_classdev:	583	err_unregister_class:
603	class_unregister(&firmware_attributes_class);	584	class_unregister(&firmware_attributes_class);
604		585
605	fail_class:	586	err_exit_bios_attr_pass_interface:
606	exit_bios_attr_pass_interface();	587	exit_bios_attr_pass_interface();
607		588
608	fail_pass_interface:	589	err_exit_bios_attr_set_interface:
609	exit_bios_attr_set_interface();	590	exit_bios_attr_set_interface();
610		591
611	fail_set_interface:
612	return ret;	592	return ret;
613	}	593	}
614		594

drivers/platform/x86/intel-hid.c+7−0

@@ -90,6 +90,13 @@ static const struct dmi_system_id button_array_table[] = { · 89 unmodified lines
90	DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"),	90	DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"),
91	},	91	},
92	},	92	},
		93	{
		94	.ident = "Lenovo ThinkPad X1 Tablet Gen 2",
		95	.matches = {
		96	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		97	DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"),
		98	},
		99	},
93	{ }	100	{ }
94	};	101	};
95		102

drivers/platform/x86/intel-vbtn.c+10−2

 };
 static const struct key_entry intel_vbtn_switchmap[] = {
-	{ KE_SW,     0xCA, { .sw = { SW_DOCK, 1 } } },		/* Docked */
+	/*
-	{ KE_SW,     0xCB, { .sw = { SW_DOCK, 0 } } },		/* Undocked */
+	 * SW_DOCK should only be reported for docking stations, but DSDTs using the
+	 * intel-vbtn code, always seem to use this for 2-in-1s / convertibles and set
+	 * SW_DOCK=1 when in laptop-mode (in tandem with setting SW_TABLET_MODE=0).
+	 * This causes userspace to think the laptop is docked to a port-replicator
+	 * and to disable suspend-on-lid-close, which is undesirable.
+	 * Map the dock events to KEY_IGNORE to avoid this broken SW_DOCK reporting.
+	 */
+	{ KE_IGNORE, 0xCA, { .sw = { SW_DOCK, 1 } } },		/* Docked */
+	{ KE_IGNORE, 0xCB, { .sw = { SW_DOCK, 0 } } },		/* Undocked */
 	{ KE_SW,     0xCC, { .sw = { SW_TABLET_MODE, 1 } } },	/* Tablet */
 	{ KE_SW,     0xCD, { .sw = { SW_TABLET_MODE, 0 } } },	/* Laptop */
 	{ KE_END }

drivers/platform/x86/intel_pmc_core.c+35−15

 }
 DEFINE_SHOW_ATTRIBUTE(pmc_core_pll);
-static ssize_t pmc_core_ltr_ignore_write(struct file *file,
+static int pmc_core_send_ltr_ignore(u32 value)
-					 const char __user *userbuf,
-					 size_t count, loff_t *ppos)
 {
 	struct pmc_dev *pmcdev = &pmc;
 	const struct pmc_reg_map *map = pmcdev->map;
-	u32 val, buf_size, fd;
+	u32 reg;
-	int err;
+	int err = 0;
-	buf_size = count < 64 ? count : 64;
-	err = kstrtou32_from_user(userbuf, buf_size, 10, &val);
-	if (err)
-		return err;
 	mutex_lock(&pmcdev->lock);
-	if (val > map->ltr_ignore_max) {
+	if (value > map->ltr_ignore_max) {
 		err = -EINVAL;
 		goto out_unlock;
 	}
-	fd = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset);
+	reg = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset);
-	fd |= (1U << val);
+	reg |= BIT(value);
-	pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, fd);
+	pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, reg);
 out_unlock:
 	mutex_unlock(&pmcdev->lock);
+	return err;
+}
+static ssize_t pmc_core_ltr_ignore_write(struct file *file,
+					 const char __user *userbuf,
+					 size_t count, loff_t *ppos)
+{
+	u32 buf_size, value;
+	int err;
+	buf_size = min_t(u32, count, 64);
+	err = kstrtou32_from_user(userbuf, buf_size, 10, &value);
+	if (err)
+		return err;
+	err = pmc_core_send_ltr_ignore(value);
 	return err == 0 ? count : err;
 }
 	pmcdev->pmc_xram_read_bit = pmc_core_check_read_lock_bit();
 	dmi_check_system(pmc_core_dmi_table);
+	/*
+	 * On TGL, due to a hardware limitation, the GBE LTR blocks PC10 when
+	 * a cable is attached. Tell the PMC to ignore it.
+	 */
+	if (pmcdev->map == &tgl_reg_map) {
+		dev_dbg(&pdev->dev, "ignoring GBE LTR\n");
+		pmc_core_send_ltr_ignore(3);
+	}
 	pmc_core_dbgfs_register(pmcdev);
 	device_initialized = true;

drivers/platform/x86/intel_pmt_class.c+1−1

@@ -173,7 +173,7 @@ static int intel_pmt_dev_register(struct intel_pmt_entry *entry, · 172 unmodified lines
173	struct intel_pmt_namespace *ns,	173	struct intel_pmt_namespace *ns,
174	struct device *parent)	174	struct device *parent)
175	{	175	{
176	struct resource res;	176	struct resource res = {0};
177	struct device *dev;	177	struct device *dev;
178	int ret;	178	int ret;
179		179

drivers/platform/x86/intel_pmt_crashlog.c+6−7

 #define CRASH_TYPE_OOBMSM	1
 /* Control Flags */
-#define CRASHLOG_FLAG_DISABLE		BIT(27)
+#define CRASHLOG_FLAG_DISABLE		BIT(28)
 /*
- * Bits 28 and 29 control the state of bit 31.
+ * Bits 29 and 30 control the state of bit 31.
  *
- * Bit 28 will clear bit 31, if set, allowing a new crashlog to be captured.
+ * Bit 29 will clear bit 31, if set, allowing a new crashlog to be captured.
- * Bit 29 will immediately trigger a crashlog to be generated, setting bit 31.
+ * Bit 30 will immediately trigger a crashlog to be generated, setting bit 31.
- * Bit 30 is read-only and reserved as 0.
  * Bit 31 is the read-only status with a 1 indicating log is complete.
  */
-#define CRASHLOG_FLAG_TRIGGER_CLEAR	BIT(28)
+#define CRASHLOG_FLAG_TRIGGER_CLEAR	BIT(29)
-#define CRASHLOG_FLAG_TRIGGER_EXECUTE	BIT(29)
+#define CRASHLOG_FLAG_TRIGGER_EXECUTE	BIT(30)
 #define CRASHLOG_FLAG_TRIGGER_COMPLETE	BIT(31)
 #define CRASHLOG_FLAG_TRIGGER_MASK	GENMASK(31, 28)

drivers/platform/x86/thinkpad_acpi.c+79−29

@@ -4081,13 +4081,19 @@ static bool hotkey_notify_6xxx(const u32 hkey, · 4080 unmodified lines
4081		4081
4082	case TP_HKEY_EV_KEY_NUMLOCK:	4082	case TP_HKEY_EV_KEY_NUMLOCK:
4083	case TP_HKEY_EV_KEY_FN:	4083	case TP_HKEY_EV_KEY_FN:
4084	case TP_HKEY_EV_KEY_FN_ESC:
4085	/* key press events, we just ignore them as long as the EC	4084	/* key press events, we just ignore them as long as the EC
4086	* is still reporting them in the normal keyboard stream */	4085	* is still reporting them in the normal keyboard stream */
4087	*send_acpi_ev = false;	4086	*send_acpi_ev = false;
4088	*ignore_acpi_ev = true;	4087	*ignore_acpi_ev = true;
4089	return true;	4088	return true;
4090		4089
		4090	case TP_HKEY_EV_KEY_FN_ESC:
		4091	/* Get the media key status to foce the status LED to update */
		4092	acpi_evalf(hkey_handle, NULL, "GMKS", "v");
		4093	*send_acpi_ev = false;
		4094	*ignore_acpi_ev = true;
		4095	return true;
		4096
4091	case TP_HKEY_EV_TABLET_CHANGED:	4097	case TP_HKEY_EV_TABLET_CHANGED:
4092	tpacpi_input_send_tabletsw();	4098	tpacpi_input_send_tabletsw();
4093	hotkey_tablet_mode_notify_change();	4099	hotkey_tablet_mode_notify_change();
@@ -9845,6 +9851,11 @@ static struct ibm_struct lcdshadow_driver_data = { · 5751 unmodified lines
9845	* Thinkpad sensor interfaces	9851	* Thinkpad sensor interfaces
9846	*/	9852	*/
9847		9853
		9854	#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */
		9855	#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */
		9856	#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
		9857	#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */
		9858
9848	#define DYTC_CMD_GET 2 /* To get current IC function and mode */	9859	#define DYTC_CMD_GET 2 /* To get current IC function and mode */
9849	#define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */	9860	#define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */
9850		9861
@@ -9855,6 +9866,7 @@ static bool has_palmsensor; · 4 unmodified lines
9855	static bool has_lapsensor;	9866	static bool has_lapsensor;
9856	static bool palm_state;	9867	static bool palm_state;
9857	static bool lap_state;	9868	static bool lap_state;
		9869	static int dytc_version;
9858		9870
9859	static int dytc_command(int command, int *output)	9871	static int dytc_command(int command, int *output)
9860	{	9872	{
@@ -9869,6 +9881,33 @@ static int dytc_command(int command, int *output) · 8 unmodified lines
9869	return 0;	9881	return 0;
9870	}	9882	}
9871		9883
		9884	static int dytc_get_version(void)
		9885	{
		9886	int err, output;
		9887
		9888	/* Check if we've been called before - and just return cached value */
		9889	if (dytc_version)
		9890	return dytc_version;
		9891
		9892	/* Otherwise query DYTC and extract version information */
		9893	err = dytc_command(DYTC_CMD_QUERY, &output);
		9894	/*
		9895	* If support isn't available (ENODEV) then don't return an error
		9896	* and don't create the sysfs group
		9897	*/
		9898	if (err == -ENODEV)
		9899	return 0;
		9900	/* For all other errors we can flag the failure */
		9901	if (err)
		9902	return err;
		9903
		9904	/* Check DYTC is enabled and supports mode setting */
		9905	if (output & BIT(DYTC_QUERY_ENABLE_BIT))
		9906	dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;
		9907
		9908	return 0;
		9909	}
		9910
9872	static int lapsensor_get(bool present, bool state)	9911	static int lapsensor_get(bool present, bool state)
9873	{	9912	{
9874	int output, err;	9913	int output, err;
@@ -9974,7 +10013,18 @@ static int tpacpi_proxsensor_init(struct ibm_init_struct *iibm) · 99 unmodified lines
9974	if (err)	10013	if (err)
9975	return err;	10014	return err;
9976	}	10015	}
9977	if (has_lapsensor) {	10016
		10017	/* Check if we know the DYTC version, if we don't then get it */
		10018	if (!dytc_version) {
		10019	err = dytc_get_version();
		10020	if (err)
		10021	return err;
		10022	}
		10023	/*
		10024	* Platforms before DYTC version 5 claim to have a lap sensor, but it doesn't work, so we
		10025	* ignore them
		10026	*/
		10027	if (has_lapsensor && (dytc_version >= 5)) {
9978	err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);	10028	err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);
9979	if (err)	10029	if (err)
9980	return err;	10030	return err;
@@ -9999,14 +10049,9 @@ static struct ibm_struct proxsensor_driver_data = { · 18 unmodified lines
9999	* DYTC Platform Profile interface	10049	* DYTC Platform Profile interface
10000	*/	10050	*/
10001		10051
10002	#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */
10003	#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */	10052	#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */
10004	#define DYTC_CMD_RESET 0x1ff /* To reset back to default */	10053	#define DYTC_CMD_RESET 0x1ff /* To reset back to default */
10005		10054
10006	#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */
10007	#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
10008	#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */
10009
10010	#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */	10055	#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */
10011	#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */	10056	#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */
10012		10057
@@ -10142,8 +10187,13 @@ static int dytc_profile_set(struct platform_profile_handler *pprof, · 129 unmodified lines
10142	return err;	10187	return err;
10143		10188
10144	if (profile == PLATFORM_PROFILE_BALANCED) {	10189	if (profile == PLATFORM_PROFILE_BALANCED) {
10145	/* To get back to balanced mode we just issue a reset command */	10190	/*
10146	err = dytc_command(DYTC_CMD_RESET, &output);	10191	* To get back to balanced mode we need to issue a reset command.
		10192	* Note we still need to disable CQL mode before hand and re-enable
		10193	* it afterwards, otherwise dytc_lapmode gets reset to 0 and stays
		10194	* stuck at 0 for aprox. 30 minutes.
		10195	*/
		10196	err = dytc_cql_command(DYTC_CMD_RESET, &output);
10147	if (err)	10197	if (err)
10148	goto unlock;	10198	goto unlock;
10149	} else {	10199	} else {
@@ -10211,28 +10261,28 @@ static int tpacpi_dytc_profile_init(struct ibm_init_struct *iibm) · 61 unmodified lines
10211	if (err)	10261	if (err)
10212	return err;	10262	return err;
10213		10263
		10264	/* Check if we know the DYTC version, if we don't then get it */
		10265	if (!dytc_version) {
		10266	err = dytc_get_version();
		10267	if (err)
		10268	return err;
		10269	}
10214	/* Check DYTC is enabled and supports mode setting */	10270	/* Check DYTC is enabled and supports mode setting */
10215	if (output & BIT(DYTC_QUERY_ENABLE_BIT)) {	10271	if (dytc_version >= 5) {
10216	/* Only DYTC v5.0 and later has this feature. */	10272	dbg_printk(TPACPI_DBG_INIT,
10217	int dytc_version;	10273	"DYTC version %d: thermal mode available\n", dytc_version);
10218		10274	/* Create platform_profile structure and register */
10219	dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;	10275	err = platform_profile_register(&dytc_profile);
10220	if (dytc_version >= 5) {	10276	/*
10221	dbg_printk(TPACPI_DBG_INIT,	10277	* If for some reason platform_profiles aren't enabled
10222	"DYTC version %d: thermal mode available\n", dytc_version);	10278	* don't quit terminally.
10223	/* Create platform_profile structure and register */	10279	*/
10224	err = platform_profile_register(&dytc_profile);	10280	if (err)
10225	/*	10281	return 0;
10226	* If for some reason platform_profiles aren't enabled
10227	* don't quit terminally.
10228	*/
10229	if (err)
10230	return 0;
10231		10282
10232	dytc_profile_available = true;	10283	dytc_profile_available = true;
10233	/* Ensure initial values are correct */	10284	/* Ensure initial values are correct */
10234	dytc_profile_refresh();	10285	dytc_profile_refresh();
10235	}
10236	}	10286	}
10237	return 0;	10287	return 0;
10238	}	10288	}

drivers/ptp/ptp_qoriq.c+7−6

 	tmr_add = ptp_qoriq->tmr_add;
 	adj = tmr_add;
-	/* calculate diff as adj*(scaled_ppm/65536)/1000000
+	/*
-	 * and round() to the nearest integer
+	 * Calculate diff and round() to the nearest integer
+	 *
+	 * diff = adj * (ppb / 1000000000)
+	 *      = adj * scaled_ppm / 65536000000
 	 */
-	adj *= scaled_ppm;
+	diff = mul_u64_u64_div_u64(adj, scaled_ppm, 32768000000);
-	diff = div_u64(adj, 8000000);
+	diff = DIV64_U64_ROUND_UP(diff, 2);
-	diff = (diff >> 13) + ((diff >> 12) & 1);
 	tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff;
 	ptp_qoriq->write(&regs->ctrl_regs->tmr_add, tmr_add);
 	return 0;

drivers/scsi/ibmvscsi/ibmvfc.c+54−13

 	return 0;
 }
+/**
+ * ibmvfc_event_is_free - Check if event is free or not
+ * @evt:	ibmvfc event struct
+ *
+ * Returns:
+ *	true / false
+ **/
+static bool ibmvfc_event_is_free(struct ibmvfc_event *evt)
+{
+	struct ibmvfc_event *loop_evt;
+	list_for_each_entry(loop_evt, &evt->queue->free, queue_list)
+		if (loop_evt == evt)
+			return true;
+	return false;
+}
 /**
  * ibmvfc_wait_for_ops - Wait for ops to complete
  * @vhost:	ibmvfc host struct
 {
 	struct ibmvfc_event *evt;
 	DECLARE_COMPLETION_ONSTACK(comp);
-	int wait;
+	int wait, i, q_index, q_size;
 	unsigned long flags;
 	signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
+	struct ibmvfc_queue *queues;
 	ENTER;
+	if (vhost->mq_enabled && vhost->using_channels) {
+		queues = vhost->scsi_scrqs.scrqs;
+		q_size = vhost->scsi_scrqs.active_queues;
+	} else {
+		queues = &vhost->crq;
+		q_size = 1;
+	}
 	do {
 		wait = 0;
-		spin_lock_irqsave(&vhost->crq.l_lock, flags);
+		spin_lock_irqsave(vhost->host->host_lock, flags);
-		list_for_each_entry(evt, &vhost->crq.sent, queue_list) {
+		for (q_index = 0; q_index < q_size; q_index++) {
-			if (match(evt, device)) {
+			spin_lock(&queues[q_index].l_lock);
-				evt->eh_comp = &comp;
+			for (i = 0; i < queues[q_index].evt_pool.size; i++) {
-				wait++;
+				evt = &queues[q_index].evt_pool.events[i];
+				if (!ibmvfc_event_is_free(evt)) {
+					if (match(evt, device)) {
+						evt->eh_comp = &comp;
+						wait++;
+					}
+				}
 			}
+			spin_unlock(&queues[q_index].l_lock);
 		}
-		spin_unlock_irqrestore(&vhost->crq.l_lock, flags);
+		spin_unlock_irqrestore(vhost->host->host_lock, flags);
 		if (wait) {
 			timeout = wait_for_completion_timeout(&comp, timeout);
 			if (!timeout) {
 				wait = 0;
-				spin_lock_irqsave(&vhost->crq.l_lock, flags);
+				spin_lock_irqsave(vhost->host->host_lock, flags);
-				list_for_each_entry(evt, &vhost->crq.sent, queue_list) {
+				for (q_index = 0; q_index < q_size; q_index++) {
-					if (match(evt, device)) {
+					spin_lock(&queues[q_index].l_lock);
-						evt->eh_comp = NULL;
+					for (i = 0; i < queues[q_index].evt_pool.size; i++) {
-						wait++;
+						evt = &queues[q_index].evt_pool.events[i];
+						if (!ibmvfc_event_is_free(evt)) {
+							if (match(evt, device)) {
+								evt->eh_comp = NULL;
+								wait++;
+							}
+						}
 					}
+					spin_unlock(&queues[q_index].l_lock);
 				}
-				spin_unlock_irqrestore(&vhost->crq.l_lock, flags);
+				spin_unlock_irqrestore(vhost->host->host_lock, flags);
 				if (wait)
 					dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
 				LEAVE;

drivers/scsi/mpt3sas/mpt3sas_base.c+6−2

 		ioc->pend_os_device_add_sz++;
 	ioc->pend_os_device_add = kzalloc(ioc->pend_os_device_add_sz,
 	    GFP_KERNEL);
-	if (!ioc->pend_os_device_add)
+	if (!ioc->pend_os_device_add) {
+		r = -ENOMEM;
 		goto out_free_resources;
+	}
 	ioc->device_remove_in_progress_sz = ioc->pend_os_device_add_sz;
 	ioc->device_remove_in_progress =
 		kzalloc(ioc->device_remove_in_progress_sz, GFP_KERNEL);
-	if (!ioc->device_remove_in_progress)
+	if (!ioc->device_remove_in_progress) {
+		r = -ENOMEM;
 		goto out_free_resources;
+	}
 	ioc->fwfault_debug = mpt3sas_fwfault_debug;

drivers/scsi/qedi/qedi_main.c+1−0

@@ -1675,6 +1675,7 @@ static int qedi_alloc_global_queues(struct qedi_ctx *qedi) · 1674 unmodified lines
1675	if (!qedi->global_queues[i]) {	1675	if (!qedi->global_queues[i]) {
1676	QEDI_ERR(&qedi->dbg_ctx,	1676	QEDI_ERR(&qedi->dbg_ctx,
1677	"Unable to allocation global queue %d.\n", i);	1677	"Unable to allocation global queue %d.\n", i);
		1678	status = -ENOMEM;
1678	goto mem_alloc_failure;	1679	goto mem_alloc_failure;
1679	}	1680	}
1680		1681

drivers/scsi/qla2xxx/qla_target.c+5−8

 	if (!qpair->fw_started || (cmd->reset_count != qpair->chip_reset) ||
 	    (cmd->sess && cmd->sess->deleted)) {
 		cmd->state = QLA_TGT_STATE_PROCESSED;
-		res = 0;
+		return 0;
-		goto free;
 	}
 	ql_dbg_qp(ql_dbg_tgt, qpair, 0xe018,
 	res = qlt_pre_xmit_response(cmd, &prm, xmit_type, scsi_status,
 	    &full_req_cnt);
-	if (unlikely(res != 0))
+	if (unlikely(res != 0)) {
-		goto free;
+		return res;
+	}
 	spin_lock_irqsave(qpair->qp_lock_ptr, flags);
 			vha->flags.online, qla2x00_reset_active(vha),
 			cmd->reset_count, qpair->chip_reset);
 		spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
-		res = 0;
+		return 0;
-		goto free;
 	}
 	/* Does F/W have an IOCBs for this request */
 	qlt_unmap_sg(vha, cmd);
 	spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
-free:
-	vha->hw->tgt.tgt_ops->free_cmd(cmd);
 	return res;
 }
 EXPORT_SYMBOL(qlt_xmit_response);

drivers/scsi/qla2xxx/tcm_qla2xxx.c+0−4

 {
 	struct qla_tgt_cmd *cmd = container_of(se_cmd,
 				struct qla_tgt_cmd, se_cmd);
-	struct scsi_qla_host *vha = cmd->vha;
 	if (cmd->aborted) {
 		/* Cmd can loop during Q-full.  tcm_qla2xxx_aborted_task
 			cmd->se_cmd.transport_state,
 			cmd->se_cmd.t_state,
 			cmd->se_cmd.se_cmd_flags);
-		vha->hw->tgt.tgt_ops->free_cmd(cmd);
 		return 0;
 	}
 {
 	struct qla_tgt_cmd *cmd = container_of(se_cmd,
 				struct qla_tgt_cmd, se_cmd);
-	struct scsi_qla_host *vha = cmd->vha;
 	int xmit_type = QLA_TGT_XMIT_STATUS;
 	if (cmd->aborted) {
 		    cmd, kref_read(&cmd->se_cmd.cmd_kref),
 		    cmd->se_cmd.transport_state, cmd->se_cmd.t_state,
 		    cmd->se_cmd.se_cmd_flags);
-		vha->hw->tgt.tgt_ops->free_cmd(cmd);
 		return 0;
 	}
 	cmd->bufflen = se_cmd->data_length;

drivers/scsi/scsi_transport_iscsi.c+13−1

 	 */
 	mutex_lock(&conn_mutex);
 	conn->transport->stop_conn(conn, flag);
+	conn->state = ISCSI_CONN_DOWN;
 	mutex_unlock(&conn_mutex);
 }
 	default:
 		err = transport->set_param(conn, ev->u.set_param.param,
 					   data, ev->u.set_param.len);
+		if ((conn->state == ISCSI_CONN_BOUND) ||
+			(conn->state == ISCSI_CONN_UP)) {
+			err = transport->set_param(conn, ev->u.set_param.param,
+					data, ev->u.set_param.len);
+		} else {
+			return -ENOTCONN;
+		}
 	}
 	return err;
 		mutex_lock(&conn->ep_mutex);
 		conn->ep = NULL;
 		mutex_unlock(&conn->ep_mutex);
+		conn->state = ISCSI_CONN_DOWN;
 	}
 	transport->ep_disconnect(ep);
 		ev->r.retcode =	transport->bind_conn(session, conn,
 						ev->u.b_conn.transport_eph,
 						ev->u.b_conn.is_leading);
+		if (!ev->r.retcode)
+			conn->state = ISCSI_CONN_BOUND;
 		mutex_unlock(&conn_mutex);
 		if (ev->r.retcode || !transport->ep_connect)
 static const char *const connection_state_names[] = {
 	[ISCSI_CONN_UP] = "up",
 	[ISCSI_CONN_DOWN] = "down",
-	[ISCSI_CONN_FAILED] = "failed"
+	[ISCSI_CONN_FAILED] = "failed",
+	[ISCSI_CONN_BOUND] = "bound"
 };
 static ssize_t show_conn_state(struct device *dev,

drivers/soc/litex/litex_soc_ctrl.c+0−1

@@ -13,7 +13,6 @@ · 12 unmodified lines
13	#include <linux/platform_device.h>	13	#include <linux/platform_device.h>
14	#include <linux/printk.h>	14	#include <linux/printk.h>
15	#include <linux/module.h>	15	#include <linux/module.h>
16	#include <linux/errno.h>
17	#include <linux/io.h>	16	#include <linux/io.h>
18	#include <linux/reboot.h>	17	#include <linux/reboot.h>
19		18

drivers/soc/qcom/qcom-geni-se.c+0−74

@@ -3,7 +3,6 @@ · 2 unmodified lines
3		3
4	#include <linux/acpi.h>	4	#include <linux/acpi.h>
5	#include <linux/clk.h>	5	#include <linux/clk.h>
6	#include <linux/console.h>
7	#include <linux/slab.h>	6	#include <linux/slab.h>
8	#include <linux/dma-mapping.h>	7	#include <linux/dma-mapping.h>
9	#include <linux/io.h>	8	#include <linux/io.h>
@@ -92,14 +91,11 @@ struct geni_wrapper { · 82 unmodified lines
92	struct device *dev;	91	struct device *dev;
93	void __iomem *base;	92	void __iomem *base;
94	struct clk_bulk_data ahb_clks[NUM_AHB_CLKS];	93	struct clk_bulk_data ahb_clks[NUM_AHB_CLKS];
95	struct geni_icc_path to_core;
96	};	94	};
97		95
98	static const char * const icc_path_names[] = {"qup-core", "qup-config",	96	static const char * const icc_path_names[] = {"qup-core", "qup-config",
99	"qup-memory"};	97	"qup-memory"};
100		98
101	static struct geni_wrapper *earlycon_wrapper;
102
103	#define QUP_HW_VER_REG 0x4	99	#define QUP_HW_VER_REG 0x4
104		100
105	/* Common SE registers */	101	/* Common SE registers */
@@ -843,44 +839,11 @@ int geni_icc_disable(struct geni_se *se) · 737 unmodified lines
843	}	839	}
844	EXPORT_SYMBOL(geni_icc_disable);	840	EXPORT_SYMBOL(geni_icc_disable);
845		841
846	void geni_remove_earlycon_icc_vote(void)
847	{
848	struct platform_device *pdev;
849	struct geni_wrapper *wrapper;
850	struct device_node *parent;
851	struct device_node *child;
852
853	if (!earlycon_wrapper)
854	return;
855
856	wrapper = earlycon_wrapper;
857	parent = of_get_next_parent(wrapper->dev->of_node);
858	for_each_child_of_node(parent, child) {
859	if (!of_device_is_compatible(child, "qcom,geni-se-qup"))
860	continue;
861
862	pdev = of_find_device_by_node(child);
863	if (!pdev)
864	continue;
865
866	wrapper = platform_get_drvdata(pdev);
867	icc_put(wrapper->to_core.path);
868	wrapper->to_core.path = NULL;
869
870	}
871	of_node_put(parent);
872
873	earlycon_wrapper = NULL;
874	}
875	EXPORT_SYMBOL(geni_remove_earlycon_icc_vote);
876
877	static int geni_se_probe(struct platform_device *pdev)	842	static int geni_se_probe(struct platform_device *pdev)
878	{	843	{
879	struct device *dev = &pdev->dev;	844	struct device *dev = &pdev->dev;
880	struct resource *res;	845	struct resource *res;
881	struct geni_wrapper *wrapper;	846	struct geni_wrapper *wrapper;
882	struct console __maybe_unused *bcon;
883	bool __maybe_unused has_earlycon = false;
884	int ret;	847	int ret;
885		848
886	wrapper = devm_kzalloc(dev, sizeof(*wrapper), GFP_KERNEL);	849	wrapper = devm_kzalloc(dev, sizeof(*wrapper), GFP_KERNEL);
@@ -903,43 +866,6 @@ static int geni_se_probe(struct platform_device *pdev) · 16 unmodified lines
903	}	866	}
904	}	867	}
905		868
906	#ifdef CONFIG_SERIAL_EARLYCON
907	for_each_console(bcon) {
908	if (!strcmp(bcon->name, "qcom_geni")) {
909	has_earlycon = true;
910	break;
911	}
912	}
913	if (!has_earlycon)
914	goto exit;
915
916	wrapper->to_core.path = devm_of_icc_get(dev, "qup-core");
917	if (IS_ERR(wrapper->to_core.path))
918	return PTR_ERR(wrapper->to_core.path);
919	/*
920	* Put minmal BW request on core clocks on behalf of early console.
921	* The vote will be removed earlycon exit function.
922	*
923	* Note: We are putting vote on each QUP wrapper instead only to which
924	* earlycon is connected because QUP core clock of different wrapper
925	* share same voltage domain. If core1 is put to 0, then core2 will
926	* also run at 0, if not voted. Default ICC vote will be removed ASA
927	* we touch any of the core clock.
928	* core1 = core2 = max(core1, core2)
929	*/
930	ret = icc_set_bw(wrapper->to_core.path, GENI_DEFAULT_BW,
931	GENI_DEFAULT_BW);
932	if (ret) {
933	dev_err(&pdev->dev, "%s: ICC BW voting failed for core: %d\n",
934	__func__, ret);
935	return ret;
936	}
937
938	if (of_get_compatible_child(pdev->dev.of_node, "qcom,geni-debug-uart"))
939	earlycon_wrapper = wrapper;
940	of_node_put(pdev->dev.of_node);
941	exit:
942	#endif
943	dev_set_drvdata(dev, wrapper);	869	dev_set_drvdata(dev, wrapper);
944	dev_dbg(dev, "GENI SE Driver probed\n");	870	dev_dbg(dev, "GENI SE Driver probed\n");
945	return devm_of_platform_populate(dev);	871	return devm_of_platform_populate(dev);

drivers/soc/ti/omap_prm.c+6−2

 	{
 		.name = "l3init", .base = 0x4ae07300,
 		.pwrstctrl = 0x0, .pwrstst = 0x4, .dmap = &omap_prm_alwon,
-		.rstctrl = 0x10, .rstst = 0x14, .rstmap = rst_map_012,
+		.rstctrl = 0x10, .rstst = 0x14, .rstmap = rst_map_01,
 		.clkdm_name = "pcie"
 	},
 	{
 		       reset->prm->data->name, id);
 exit:
-	if (reset->clkdm)
+	if (reset->clkdm) {
+		/* At least dra7 iva needs a delay before clkdm idle */
+		if (has_rstst)
+			udelay(1);
 		pdata->clkdm_allow_idle(reset->clkdm);
+	}
 	return ret;
 }

drivers/staging/rtl8192e/rtllib.h+1−1

@@ -1105,7 +1105,7 @@ struct rtllib_network { · 1104 unmodified lines
1105	bool bWithAironetIE;	1105	bool bWithAironetIE;
1106	bool bCkipSupported;	1106	bool bCkipSupported;
1107	bool bCcxRmEnable;	1107	bool bCcxRmEnable;
1108	u16 CcxRmState[2];	1108	u8 CcxRmState[2];
1109	bool bMBssidValid;	1109	bool bMBssidValid;
1110	u8 MBssidMask;	1110	u8 MBssidMask;
1111	u8 MBssid[ETH_ALEN];	1111	u8 MBssid[ETH_ALEN];

drivers/staging/rtl8192e/rtllib_rx.c+1−1

@@ -1967,7 +1967,7 @@ static void rtllib_parse_mife_generic(struct rtllib_device *ieee, · 1966 unmodified lines
1967	info_element->data[2] == 0x96 &&	1967	info_element->data[2] == 0x96 &&
1968	info_element->data[3] == 0x01) {	1968	info_element->data[3] == 0x01) {
1969	if (info_element->len == 6) {	1969	if (info_element->len == 6) {
1970	memcpy(network->CcxRmState, &info_element[4], 2);	1970	memcpy(network->CcxRmState, &info_element->data[4], 2);
1971	if (network->CcxRmState[0] != 0)	1971	if (network->CcxRmState[0] != 0)
1972	network->bCcxRmEnable = true;	1972	network->bCcxRmEnable = true;
1973	else	1973	else

drivers/target/target_core_pscsi.c+8−1

 			if (!bio) {
 new_bio:
 				nr_vecs = bio_max_segs(nr_pages);
-				nr_pages -= nr_vecs;
 				/*
 				 * Calls bio_kmalloc() and sets bio->bi_end_io()
 				 */
 	return 0;
 fail:
+	if (bio)
+		bio_put(bio);
+	while (req->bio) {
+		bio = req->bio;
+		req->bio = bio->bi_next;
+		bio_put(bio);
+	}
+	req->biotail = NULL;
 	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 }

drivers/tty/serial/qcom_geni_serial.c+0−7

 						      struct console *con) { }
 #endif
-static int qcom_geni_serial_earlycon_exit(struct console *con)
-{
-	geni_remove_earlycon_icc_vote();
-	return 0;
-}
 static struct qcom_geni_private_data earlycon_private_data;
 static int __init qcom_geni_serial_earlycon_setup(struct earlycon_device *dev,
 	writel(stop_bit_len, uport->membase + SE_UART_TX_STOP_BIT_LEN);
 	dev->con->write = qcom_geni_serial_earlycon_write;
-	dev->con->exit = qcom_geni_serial_earlycon_exit;
 	dev->con->setup = NULL;
 	qcom_geni_serial_enable_early_read(&se, dev->con);

drivers/usb/class/cdc-acm.c+70−50

@@ -147,17 +147,29 @@ static inline int acm_set_control(struct acm *acm, int control) · 146 unmodified lines
147	#define acm_send_break(acm, ms) \	147	#define acm_send_break(acm, ms) \
148	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)	148	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
149		149
150	static void acm_kill_urbs(struct acm *acm)	150	static void acm_poison_urbs(struct acm *acm)
151	{	151	{
152	int i;	152	int i;
153		153
154	usb_kill_urb(acm->ctrlurb);	154	usb_poison_urb(acm->ctrlurb);
155	for (i = 0; i < ACM_NW; i++)	155	for (i = 0; i < ACM_NW; i++)
156	usb_kill_urb(acm->wb[i].urb);	156	usb_poison_urb(acm->wb[i].urb);
157	for (i = 0; i < acm->rx_buflimit; i++)	157	for (i = 0; i < acm->rx_buflimit; i++)
158	usb_kill_urb(acm->read_urbs[i]);	158	usb_poison_urb(acm->read_urbs[i]);
		159	}
		160
		161	static void acm_unpoison_urbs(struct acm *acm)
		162	{
		163	int i;
		164
		165	for (i = 0; i < acm->rx_buflimit; i++)
		166	usb_unpoison_urb(acm->read_urbs[i]);
		167	for (i = 0; i < ACM_NW; i++)
		168	usb_unpoison_urb(acm->wb[i].urb);
		169	usb_unpoison_urb(acm->ctrlurb);
159	}	170	}
160		171
		172
161	/*	173	/*
162	* Write buffer management.	174	* Write buffer management.
163	* All of these assume proper locks taken by the caller.	175	* All of these assume proper locks taken by the caller.
@@ -226,9 +238,10 @@ static int acm_start_wb(struct acm acm, struct acm_wb wb) · 62 unmodified lines
226		238
227	rc = usb_submit_urb(wb->urb, GFP_ATOMIC);	239	rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
228	if (rc < 0) {	240	if (rc < 0) {
229	dev_err(&acm->data->dev,	241	if (rc != -EPERM)
230	"%s - usb_submit_urb(write bulk) failed: %d\n",	242	dev_err(&acm->data->dev,
231	__func__, rc);	243	"%s - usb_submit_urb(write bulk) failed: %d\n",
		244	__func__, rc);
232	acm_write_done(acm, wb);	245	acm_write_done(acm, wb);
233	}	246	}
234	return rc;	247	return rc;
@@ -313,8 +326,10 @@ static void acm_process_notification(struct acm acm, unsigned char buf) · 78 unmodified lines
313	acm->iocount.dsr++;	326	acm->iocount.dsr++;
314	if (difference & ACM_CTRL_DCD)	327	if (difference & ACM_CTRL_DCD)
315	acm->iocount.dcd++;	328	acm->iocount.dcd++;
316	if (newctrl & ACM_CTRL_BRK)	329	if (newctrl & ACM_CTRL_BRK) {
317	acm->iocount.brk++;	330	acm->iocount.brk++;
		331	tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
		332	}
318	if (newctrl & ACM_CTRL_RI)	333	if (newctrl & ACM_CTRL_RI)
319	acm->iocount.rng++;	334	acm->iocount.rng++;
320	if (newctrl & ACM_CTRL_FRAMING)	335	if (newctrl & ACM_CTRL_FRAMING)
@@ -480,11 +495,6 @@ static void acm_read_bulk_callback(struct urb *urb) · 159 unmodified lines
480	dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",	495	dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
481	rb->index, urb->actual_length, status);	496	rb->index, urb->actual_length, status);
482		497
483	if (!acm->dev) {
484	dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
485	return;
486	}
487
488	switch (status) {	498	switch (status) {
489	case 0:	499	case 0:
490	usb_mark_last_busy(acm->dev);	500	usb_mark_last_busy(acm->dev);
@@ -649,7 +659,8 @@ static void acm_port_dtr_rts(struct tty_port *port, int raise) · 158 unmodified lines
649		659
650	res = acm_set_control(acm, val);	660	res = acm_set_control(acm, val);
651	if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))	661	if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
652	dev_err(&acm->control->dev, "failed to set dtr/rts\n");	662	/* This is broken in too many devices to spam the logs */
		663	dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
653	}	664	}
654		665
655	static int acm_port_activate(struct tty_port port, struct tty_struct tty)	666	static int acm_port_activate(struct tty_port port, struct tty_struct tty)
@@ -731,6 +742,7 @@ static void acm_port_shutdown(struct tty_port *port) · 75 unmodified lines
731	* Need to grab write_lock to prevent race with resume, but no need to	742	* Need to grab write_lock to prevent race with resume, but no need to
732	* hold it due to the tty-port initialised flag.	743	* hold it due to the tty-port initialised flag.
733	*/	744	*/
		745	acm_poison_urbs(acm);
734	spin_lock_irq(&acm->write_lock);	746	spin_lock_irq(&acm->write_lock);
735	spin_unlock_irq(&acm->write_lock);	747	spin_unlock_irq(&acm->write_lock);
736		748
@@ -747,7 +759,8 @@ static void acm_port_shutdown(struct tty_port *port) · 10 unmodified lines
747	usb_autopm_put_interface_async(acm->control);	759	usb_autopm_put_interface_async(acm->control);
748	}	760	}
749		761
750	acm_kill_urbs(acm);	762	acm_unpoison_urbs(acm);
		763
751	}	764	}
752		765
753	static void acm_tty_cleanup(struct tty_struct *tty)	766	static void acm_tty_cleanup(struct tty_struct *tty)
@@ -1296,13 +1309,6 @@ skip_normal_probe: · 542 unmodified lines
1296	if (!combined_interfaces && intf != control_interface)	1309	if (!combined_interfaces && intf != control_interface)
1297	return -ENODEV;	1310	return -ENODEV;
1298		1311
1299	if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1300	/* valid in this context */
1301	dev_dbg(&intf->dev, "The data interface isn't available\n");
1302	return -EBUSY;
1303	}
1304
1305
1306	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 \|\|	1312	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 \|\|
1307	control_interface->cur_altsetting->desc.bNumEndpoints == 0)	1313	control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1308	return -EINVAL;	1314	return -EINVAL;
@@ -1323,8 +1329,8 @@ made_compressed_probe: · 14 unmodified lines
1323	dev_dbg(&intf->dev, "interfaces are valid\n");	1329	dev_dbg(&intf->dev, "interfaces are valid\n");
1324		1330
1325	acm = kzalloc(sizeof(struct acm), GFP_KERNEL);	1331	acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1326	if (acm == NULL)	1332	if (!acm)
1327	goto alloc_fail;	1333	return -ENOMEM;
1328		1334
1329	tty_port_init(&acm->port);	1335	tty_port_init(&acm->port);
1330	acm->port.ops = &acm_port_ops;	1336	acm->port.ops = &acm_port_ops;
@@ -1341,7 +1347,7 @@ made_compressed_probe: · 10 unmodified lines
1341		1347
1342	minor = acm_alloc_minor(acm);	1348	minor = acm_alloc_minor(acm);
1343	if (minor < 0)	1349	if (minor < 0)
1344	goto alloc_fail1;	1350	goto err_put_port;
1345		1351
1346	acm->minor = minor;	1352	acm->minor = minor;
1347	acm->dev = usb_dev;	1353	acm->dev = usb_dev;
@@ -1372,15 +1378,15 @@ made_compressed_probe: · 24 unmodified lines
1372		1378
1373	buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);	1379	buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1374	if (!buf)	1380	if (!buf)
1375	goto alloc_fail1;	1381	goto err_put_port;
1376	acm->ctrl_buffer = buf;	1382	acm->ctrl_buffer = buf;
1377		1383
1378	if (acm_write_buffers_alloc(acm) < 0)	1384	if (acm_write_buffers_alloc(acm) < 0)
1379	goto alloc_fail2;	1385	goto err_free_ctrl_buffer;
1380		1386
1381	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);	1387	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1382	if (!acm->ctrlurb)	1388	if (!acm->ctrlurb)
1383	goto alloc_fail3;	1389	goto err_free_write_buffers;
1384		1390
1385	for (i = 0; i < num_rx_buf; i++) {	1391	for (i = 0; i < num_rx_buf; i++) {
1386	struct acm_rb *rb = &(acm->read_buffers[i]);	1392	struct acm_rb *rb = &(acm->read_buffers[i]);
@@ -1389,13 +1395,13 @@ made_compressed_probe: · 2 unmodified lines
1389	rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,	1395	rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1390	&rb->dma);	1396	&rb->dma);
1391	if (!rb->base)	1397	if (!rb->base)
1392	goto alloc_fail4;	1398	goto err_free_read_urbs;
1393	rb->index = i;	1399	rb->index = i;
1394	rb->instance = acm;	1400	rb->instance = acm;
1395		1401
1396	urb = usb_alloc_urb(0, GFP_KERNEL);	1402	urb = usb_alloc_urb(0, GFP_KERNEL);
1397	if (!urb)	1403	if (!urb)
1398	goto alloc_fail4;	1404	goto err_free_read_urbs;
1399		1405
1400	urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;	1406	urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
1401	urb->transfer_dma = rb->dma;	1407	urb->transfer_dma = rb->dma;
@@ -1416,8 +1422,8 @@ made_compressed_probe: · 14 unmodified lines
1416	struct acm_wb *snd = &(acm->wb[i]);	1422	struct acm_wb *snd = &(acm->wb[i]);
1417		1423
1418	snd->urb = usb_alloc_urb(0, GFP_KERNEL);	1424	snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1419	if (snd->urb == NULL)	1425	if (!snd->urb)
1420	goto alloc_fail5;	1426	goto err_free_write_urbs;
1421		1427
1422	if (usb_endpoint_xfer_int(epwrite))	1428	if (usb_endpoint_xfer_int(epwrite))
1423	usb_fill_int_urb(snd->urb, usb_dev, acm->out,	1429	usb_fill_int_urb(snd->urb, usb_dev, acm->out,
@@ -1435,7 +1441,7 @@ made_compressed_probe: · 11 unmodified lines
1435		1441
1436	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);	1442	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1437	if (i < 0)	1443	if (i < 0)
1438	goto alloc_fail5;	1444	goto err_free_write_urbs;
1439		1445
1440	if (h.usb_cdc_country_functional_desc) { /* export the country data */	1446	if (h.usb_cdc_country_functional_desc) { /* export the country data */
1441	struct usb_cdc_country_functional_desc * cfd =	1447	struct usb_cdc_country_functional_desc * cfd =
@@ -1480,20 +1486,21 @@ skip_countries: · 38 unmodified lines
1480	acm->nb_index = 0;	1486	acm->nb_index = 0;
1481	acm->nb_size = 0;	1487	acm->nb_size = 0;
1482		1488
1483	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1484
1485	acm->line.dwDTERate = cpu_to_le32(9600);	1489	acm->line.dwDTERate = cpu_to_le32(9600);
1486	acm->line.bDataBits = 8;	1490	acm->line.bDataBits = 8;
1487	acm_set_line(acm, &acm->line);	1491	acm_set_line(acm, &acm->line);
1488		1492
1489	usb_driver_claim_interface(&acm_driver, data_interface, acm);	1493	if (!acm->combined_interfaces) {
1490	usb_set_intfdata(data_interface, acm);	1494	rv = usb_driver_claim_interface(&acm_driver, data_interface, acm);
		1495	if (rv)
		1496	goto err_remove_files;
		1497	}
1491		1498
1492	tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,	1499	tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1493	&control_interface->dev);	1500	&control_interface->dev);
1494	if (IS_ERR(tty_dev)) {	1501	if (IS_ERR(tty_dev)) {
1495	rv = PTR_ERR(tty_dev);	1502	rv = PTR_ERR(tty_dev);
1496	goto alloc_fail6;	1503	goto err_release_data_interface;
1497	}	1504	}
1498		1505
1499	if (quirks & CLEAR_HALT_CONDITIONS) {	1506	if (quirks & CLEAR_HALT_CONDITIONS) {
@@ -1501,32 +1508,39 @@ skip_countries: · 1 unmodified line
1501	usb_clear_halt(usb_dev, acm->out);	1508	usb_clear_halt(usb_dev, acm->out);
1502	}	1509	}
1503		1510
		1511	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
		1512
1504	return 0;	1513	return 0;
1505	alloc_fail6:	1514
		1515	err_release_data_interface:
		1516	if (!acm->combined_interfaces) {
		1517	/* Clear driver data so that disconnect() returns early. */
		1518	usb_set_intfdata(data_interface, NULL);
		1519	usb_driver_release_interface(&acm_driver, data_interface);
		1520	}
		1521	err_remove_files:
1506	if (acm->country_codes) {	1522	if (acm->country_codes) {
1507	device_remove_file(&acm->control->dev,	1523	device_remove_file(&acm->control->dev,
1508	&dev_attr_wCountryCodes);	1524	&dev_attr_wCountryCodes);
1509	device_remove_file(&acm->control->dev,	1525	device_remove_file(&acm->control->dev,
1510	&dev_attr_iCountryCodeRelDate);	1526	&dev_attr_iCountryCodeRelDate);
1511	kfree(acm->country_codes);
1512	}	1527	}
1513	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);	1528	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1514	alloc_fail5:	1529	err_free_write_urbs:
1515	usb_set_intfdata(intf, NULL);
1516	for (i = 0; i < ACM_NW; i++)	1530	for (i = 0; i < ACM_NW; i++)
1517	usb_free_urb(acm->wb[i].urb);	1531	usb_free_urb(acm->wb[i].urb);
1518	alloc_fail4:	1532	err_free_read_urbs:
1519	for (i = 0; i < num_rx_buf; i++)	1533	for (i = 0; i < num_rx_buf; i++)
1520	usb_free_urb(acm->read_urbs[i]);	1534	usb_free_urb(acm->read_urbs[i]);
1521	acm_read_buffers_free(acm);	1535	acm_read_buffers_free(acm);
1522	usb_free_urb(acm->ctrlurb);	1536	usb_free_urb(acm->ctrlurb);
1523	alloc_fail3:	1537	err_free_write_buffers:
1524	acm_write_buffers_free(acm);	1538	acm_write_buffers_free(acm);
1525	alloc_fail2:	1539	err_free_ctrl_buffer:
1526	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);	1540	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1527	alloc_fail1:	1541	err_put_port:
1528	tty_port_put(&acm->port);	1542	tty_port_put(&acm->port);
1529	alloc_fail:	1543
1530	return rv;	1544	return rv;
1531	}	1545	}
1532		1546
@@ -1540,8 +1554,14 @@ static void acm_disconnect(struct usb_interface *intf) · 7 unmodified lines
1540	if (!acm)	1554	if (!acm)
1541	return;	1555	return;
1542		1556
1543	mutex_lock(&acm->mutex);
1544	acm->disconnected = true;	1557	acm->disconnected = true;
		1558	/*
		1559	* there is a circular dependency. acm_softint() can resubmit
		1560	* the URBs in error handling so we need to block any
		1561	* submission right away
		1562	*/
		1563	acm_poison_urbs(acm);
		1564	mutex_lock(&acm->mutex);
1545	if (acm->country_codes) {	1565	if (acm->country_codes) {
1546	device_remove_file(&acm->control->dev,	1566	device_remove_file(&acm->control->dev,
1547	&dev_attr_wCountryCodes);	1567	&dev_attr_wCountryCodes);
@@ -1560,7 +1580,6 @@ static void acm_disconnect(struct usb_interface *intf) · 12 unmodified lines
1560	tty_kref_put(tty);	1580	tty_kref_put(tty);
1561	}	1581	}
1562		1582
1563	acm_kill_urbs(acm);
1564	cancel_delayed_work_sync(&acm->dwork);	1583	cancel_delayed_work_sync(&acm->dwork);
1565		1584
1566	tty_unregister_device(acm_tty_driver, acm->minor);	1585	tty_unregister_device(acm_tty_driver, acm->minor);
@@ -1602,7 +1621,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message) · 35 unmodified lines
1602	if (cnt)	1621	if (cnt)
1603	return 0;	1622	return 0;
1604		1623
1605	acm_kill_urbs(acm);	1624	acm_poison_urbs(acm);
1606	cancel_delayed_work_sync(&acm->dwork);	1625	cancel_delayed_work_sync(&acm->dwork);
1607	acm->urbs_in_error_delay = 0;	1626	acm->urbs_in_error_delay = 0;
1608		1627
@@ -1615,6 +1634,7 @@ static int acm_resume(struct usb_interface *intf) · 6 unmodified lines
1615	struct urb *urb;	1634	struct urb *urb;
1616	int rv = 0;	1635	int rv = 0;
1617		1636
		1637	acm_unpoison_urbs(acm);
1618	spin_lock_irq(&acm->write_lock);	1638	spin_lock_irq(&acm->write_lock);
1619		1639
1620	if (--acm->susp_count)	1640	if (--acm->susp_count)

drivers/usb/core/quirks.c+4−0

@@ -498,6 +498,10 @@ static const struct usb_device_id usb_quirk_list[] = { · 497 unmodified lines
498	/* DJI CineSSD */	498	/* DJI CineSSD */
499	{ USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM },	499	{ USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM },
500		500
		501	/* Fibocom L850-GL LTE Modem */
		502	{ USB_DEVICE(0x2cb7, 0x0007), .driver_info =
		503	USB_QUIRK_IGNORE_REMOTE_WAKEUP },
		504
501	/* INTEL VALUE SSD */	505	/* INTEL VALUE SSD */
502	{ USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME },	506	{ USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME },
503		507

drivers/usb/dwc2/hcd.c+3−2

 	if (hsotg->op_state == OTG_STATE_B_PERIPHERAL)
 		goto unlock;
-	if (hsotg->params.power_down > DWC2_POWER_DOWN_PARAM_PARTIAL)
+	if (hsotg->params.power_down != DWC2_POWER_DOWN_PARAM_PARTIAL ||
+	    hsotg->flags.b.port_connect_status == 0)
 		goto skip_power_saving;
 	/*
 	dwc2_writel(hsotg, hprt0, HPRT0);
 	/* Wait for the HPRT0.PrtSusp register field to be set */
-	if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 3000))
+	if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 5000))
 		dev_warn(hsotg->dev, "Suspend wasn't generated\n");
 	/*

drivers/usb/dwc3/dwc3-pci.c+2−0

 static const struct property_entry dwc3_pci_mrfld_properties[] = {
 	PROPERTY_ENTRY_STRING("dr_mode", "otg"),
 	PROPERTY_ENTRY_STRING("linux,extcon-name", "mrfld_bcove_pwrsrc"),
+	PROPERTY_ENTRY_BOOL("snps,dis_u3_susphy_quirk"),
+	PROPERTY_ENTRY_BOOL("snps,dis_u2_susphy_quirk"),
 	PROPERTY_ENTRY_BOOL("linux,sysdev_is_parent"),
 	{}
 };

drivers/usb/dwc3/dwc3-qcom.c+3−0

@@ -244,6 +244,9 @@ static int dwc3_qcom_interconnect_init(struct dwc3_qcom *qcom) · 243 unmodified lines
244	struct device *dev = qcom->dev;	244	struct device *dev = qcom->dev;
245	int ret;	245	int ret;
246		246
		247	if (has_acpi_companion(dev))
		248	return 0;
		249
247	qcom->icc_path_ddr = of_icc_get(dev, "usb-ddr");	250	qcom->icc_path_ddr = of_icc_get(dev, "usb-ddr");
248	if (IS_ERR(qcom->icc_path_ddr)) {	251	if (IS_ERR(qcom->icc_path_ddr)) {
249	dev_err(dev, "failed to get usb-ddr path: %ld\n",	252	dev_err(dev, "failed to get usb-ddr path: %ld\n",

drivers/usb/dwc3/gadget.c+6−5

 	reg &= ~DWC3_DALEPENA_EP(dep->number);
 	dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
-	dep->stream_capable = false;
-	dep->type = 0;
-	dep->flags = 0;
 	/* Clear out the ep descriptors for non-ep0 */
 	if (dep->number > 1) {
 		dep->endpoint.comp_desc = NULL;
 	dwc3_remove_requests(dwc, dep);
+	dep->stream_capable = false;
+	dep->type = 0;
+	dep->flags = 0;
 	return 0;
 }
 	u32			reg;
 	speed = dwc->gadget_max_speed;
-	if (speed > dwc->maximum_speed)
+	if (speed == USB_SPEED_UNKNOWN || speed > dwc->maximum_speed)
 		speed = dwc->maximum_speed;
 	if (speed == USB_SPEED_SUPER_PLUS &&
 	unsigned long		flags;
 	spin_lock_irqsave(&dwc->lock, flags);
+	dwc->gadget_max_speed = USB_SPEED_SUPER_PLUS;
 	dwc->gadget_ssp_rate = rate;
 	spin_unlock_irqrestore(&dwc->lock, flags);
 }

drivers/usb/gadget/udc/amd5536udc_pci.c+5−5

 	pci_set_master(pdev);
 	pci_try_set_mwi(pdev);
+	dev->phys_addr = resource;
+	dev->irq = pdev->irq;
+	dev->pdev = pdev;
+	dev->dev = &pdev->dev;
 	/* init dma pools */
 	if (use_dma) {
 		retval = init_dma_pools(dev);
 			goto err_dma;
 	}
-	dev->phys_addr = resource;
-	dev->irq = pdev->irq;
-	dev->pdev = pdev;
-	dev->dev = &pdev->dev;
 	/* general probing */
 	if (udc_probe(dev)) {
 		retval = -ENODEV;

drivers/usb/musb/musb_core.c+8−4

 		MUSB_DEVCTL_HR;
 	switch (devctl & ~s) {
 	case MUSB_QUIRK_B_DISCONNECT_99:
-		musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
+		if (musb->quirk_retries && !musb->flush_irq_work) {
-		schedule_delayed_work(&musb->irq_work,
+			musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
-				      msecs_to_jiffies(1000));
+			schedule_delayed_work(&musb->irq_work,
-		break;
+					      msecs_to_jiffies(1000));
+			musb->quirk_retries--;
+			break;
+		}
+		fallthrough;
 	case MUSB_QUIRK_B_INVALID_VBUS_91:
 		if (musb->quirk_retries && !musb->flush_irq_work) {
 			musb_dbg(musb,

drivers/usb/usbip/vhci_hcd.c+2−0

 				pr_err("invalid port number %d\n", wIndex);
 				goto error;
 			}
+			if (wValue >= 32)
+				goto error;
 			if (hcd->speed == HCD_USB3) {
 				if ((vhci_hcd->port_status[rhport] &
 				     USB_SS_PORT_STAT_POWER) != 0) {

drivers/vfio/pci/Kconfig+1−1

@@ -42,6 +42,6 @@ config VFIO_PCI_IGD · 41 unmodified lines
42		42
43	config VFIO_PCI_NVLINK2	43	config VFIO_PCI_NVLINK2
44	def_bool y	44	def_bool y
45	depends on VFIO_PCI && PPC_POWERNV	45	depends on VFIO_PCI && PPC_POWERNV && SPAPR_TCE_IOMMU
46	help	46	help
47	VFIO PCI support for P9 Witherspoon machine with NVIDIA V100 GPUs	47	VFIO PCI support for P9 Witherspoon machine with NVIDIA V100 GPUs

drivers/vfio/vfio_iommu_type1.c+6−0

 	ret = vfio_lock_acct(dma, lock_acct, false);
 unpin_out:
+	if (batch->size == 1 && !batch->offset) {
+		/* May be a VM_PFNMAP pfn, which the batch can't remember. */
+		put_pfn(pfn, dma->prot);
+		batch->size = 0;
+	}
 	if (ret < 0) {
 		if (pinned && !rsvd) {
 			for (pfn = *pfn_base ; pinned ; pfn++, pinned--)

drivers/video/fbdev/core/fbcon.c+3−0

@@ -1333,6 +1333,9 @@ static void fbcon_cursor(struct vc_data *vc, int mode) · 1332 unmodified lines
1333		1333
1334	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;	1334	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
1335		1335
		1336	if (!ops->cursor)
		1337	return;
		1338
1336	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),	1339	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
1337	get_color(vc, info, c, 0));	1340	get_color(vc, info, c, 0));
1338	}	1341	}

drivers/video/fbdev/hyperv_fb.c+0−3

 			PCI_DEVICE_ID_HYPERV_VIDEO, NULL);
 		if (!pdev) {
 			pr_err("Unable to find PCI Hyper-V video\n");
-			kfree(info->apertures);
 			return -ENODEV;
 		}
 	} else {
 		pci_dev_put(pdev);
 	}
-	kfree(info->apertures);
 	return 0;
 err1:
 	if (!gen2vm)
 		pci_dev_put(pdev);
-	kfree(info->apertures);
 	return -ENOMEM;
 }

drivers/xen/Kconfig+2−2

@@ -50,11 +50,11 @@ config XEN_BALLOON_MEMORY_HOTPLUG · 49 unmodified lines
50		50
51	SUBSYSTEM=="memory", ACTION=="add", RUN+="/bin/sh -c '[ -f /sys$devpath/state ] && echo online > /sys$devpath/state'"	51	SUBSYSTEM=="memory", ACTION=="add", RUN+="/bin/sh -c '[ -f /sys$devpath/state ] && echo online > /sys$devpath/state'"
52		52
53	config XEN_BALLOON_MEMORY_HOTPLUG_LIMIT	53	config XEN_MEMORY_HOTPLUG_LIMIT
54	int "Hotplugged memory limit (in GiB) for a PV guest"	54	int "Hotplugged memory limit (in GiB) for a PV guest"
55	default 512	55	default 512
56	depends on XEN_HAVE_PVMMU	56	depends on XEN_HAVE_PVMMU
57	depends on XEN_BALLOON_MEMORY_HOTPLUG	57	depends on MEMORY_HOTPLUG
58	help	58	help
59	Maxmium amount of memory (in GiB) that a PV guest can be	59	Maxmium amount of memory (in GiB) that a PV guest can be
60	expanded to when using memory hotplug.	60	expanded to when using memory hotplug.

fs/afs/write.c+1−2

@@ -851,8 +851,7 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) · 850 unmodified lines
851	fscache_wait_on_page_write(vnode->cache, vmf->page);	851	fscache_wait_on_page_write(vnode->cache, vmf->page);
852	#endif	852	#endif
853		853
854	if (PageWriteback(vmf->page) &&	854	if (wait_on_page_writeback_killable(vmf->page))
855	wait_on_page_bit_killable(vmf->page, PG_writeback) < 0)
856	return VM_FAULT_RETRY;	855	return VM_FAULT_RETRY;
857		856
858	if (lock_page_killable(vmf->page) < 0)	857	if (lock_page_killable(vmf->page) < 0)

fs/block_dev.c+6−2

 		bio.bi_opf = dio_bio_write_op(iocb);
 		task_io_account_write(ret);
 	}
+	if (iocb->ki_flags & IOCB_NOWAIT)
+		bio.bi_opf |= REQ_NOWAIT;
 	if (iocb->ki_flags & IOCB_HIPRI)
 		bio_set_polled(&bio, iocb);
 			bio->bi_opf = dio_bio_write_op(iocb);
 			task_io_account_write(bio->bi_iter.bi_size);
 		}
+		if (iocb->ki_flags & IOCB_NOWAIT)
+			bio->bi_opf |= REQ_NOWAIT;
 		dio->size += bio->bi_iter.bi_size;
 		pos += bio->bi_iter.bi_size;
 	lockdep_assert_held(&bdev->bd_mutex);
-	clear_bit(GD_NEED_PART_SCAN, &bdev->bd_disk->state);
 rescan:
 	ret = blk_drop_partitions(bdev);
 	if (ret)
 		return ret;
+	clear_bit(GD_NEED_PART_SCAN, &disk->state);
 	/*
 	 * Historically we only set the capacity to zero for devices that
 	 * support partitions (independ of actually having partitions created).

fs/btrfs/Makefile+6−4

 subdir-ccflags-y += -Wmissing-prototypes
 subdir-ccflags-y += -Wold-style-definition
 subdir-ccflags-y += -Wmissing-include-dirs
-subdir-ccflags-y += $(call cc-option, -Wunused-but-set-variable)
+condflags := \
-subdir-ccflags-y += $(call cc-option, -Wunused-const-variable)
+	$(call cc-option, -Wunused-but-set-variable)		\
-subdir-ccflags-y += $(call cc-option, -Wpacked-not-aligned)
+	$(call cc-option, -Wunused-const-variable)		\
-subdir-ccflags-y += $(call cc-option, -Wstringop-truncation)
+	$(call cc-option, -Wpacked-not-aligned)			\
+	$(call cc-option, -Wstringop-truncation)
+subdir-ccflags-y += $(condflags)
 # The following turn off the warnings enabled by -Wextra
 subdir-ccflags-y += -Wno-missing-field-initializers
 subdir-ccflags-y += -Wno-sign-compare

fs/btrfs/dev-replace.c+3−0

@@ -81,6 +81,9 @@ int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info) · 80 unmodified lines
81	struct btrfs_dev_replace_item *ptr;	81	struct btrfs_dev_replace_item *ptr;
82	u64 src_devid;	82	u64 src_devid;
83		83
		84	if (!dev_root)
		85	return 0;
		86
84	path = btrfs_alloc_path();	87	path = btrfs_alloc_path();
85	if (!path) {	88	if (!path) {
86	ret = -ENOMEM;	89	ret = -ENOMEM;

fs/btrfs/disk-io.c+17−2

 	} else {
 		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
 		fs_info->dev_root = root;
-		btrfs_init_devices_late(fs_info);
 	}
+	/* Initialize fs_info for all devices in any case */
+	btrfs_init_devices_late(fs_info);
 	/* If IGNOREDATACSUMS is set don't bother reading the csum root. */
 	if (!btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {
 		}
 	}
+	/*
+	 * btrfs_find_orphan_roots() is responsible for finding all the dead
+	 * roots (with 0 refs), flag them with BTRFS_ROOT_DEAD_TREE and load
+	 * them into the fs_info->fs_roots_radix tree. This must be done before
+	 * calling btrfs_orphan_cleanup() on the tree root. If we don't do it
+	 * first, then btrfs_orphan_cleanup() will delete a dead root's orphan
+	 * item before the root's tree is deleted - this means that if we unmount
+	 * or crash before the deletion completes, on the next mount we will not
+	 * delete what remains of the tree because the orphan item does not
+	 * exists anymore, which is what tells us we have a pending deletion.
+	 */
+	ret = btrfs_find_orphan_roots(fs_info);
+	if (ret)
+		goto out;
 	ret = btrfs_cleanup_fs_roots(fs_info);
 	if (ret)
 		goto out;
 		}
 	}
-	ret = btrfs_find_orphan_roots(fs_info);
 out:
 	return ret;
 }

fs/btrfs/inode.c+9−9

  * @bio_offset:	offset to the beginning of the bio (in bytes)
  * @page:	page where is the data to be verified
  * @pgoff:	offset inside the page
+ * @start:	logical offset in the file
  *
  * The length of such check is always one sector size.
  */
 static int check_data_csum(struct inode *inode, struct btrfs_io_bio *io_bio,
-			   u32 bio_offset, struct page *page, u32 pgoff)
+			   u32 bio_offset, struct page *page, u32 pgoff,
+			   u64 start)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
 	kunmap_atomic(kaddr);
 	return 0;
 zeroit:
-	btrfs_print_data_csum_error(BTRFS_I(inode), page_offset(page) + pgoff,
+	btrfs_print_data_csum_error(BTRFS_I(inode), start, csum, csum_expected,
-				    csum, csum_expected, io_bio->mirror_num);
+				    io_bio->mirror_num);
 	if (io_bio->device)
 		btrfs_dev_stat_inc_and_print(io_bio->device,
 					     BTRFS_DEV_STAT_CORRUPTION_ERRS);
 	     pg_off += sectorsize, bio_offset += sectorsize) {
 		int ret;
-		ret = check_data_csum(inode, io_bio, bio_offset, page, pg_off);
+		ret = check_data_csum(inode, io_bio, bio_offset, page, pg_off,
+				      page_offset(page) + pg_off);
 		if (ret < 0)
 			return -EIO;
 	}
 			ASSERT(pgoff < PAGE_SIZE);
 			if (uptodate &&
 			    (!csum || !check_data_csum(inode, io_bio,
-					bio_offset, bvec.bv_page, pgoff))) {
+						       bio_offset, bvec.bv_page,
+						       pgoff, start))) {
 				clean_io_failure(fs_info, failure_tree, io_tree,
 						 start, bvec.bv_page,
 						 btrfs_ino(BTRFS_I(inode)),
 		bio->bi_end_io = btrfs_end_dio_bio;
 		btrfs_io_bio(bio)->logical = file_offset;
-		WARN_ON_ONCE(write && btrfs_is_zoned(fs_info) &&
-			     fs_info->max_zone_append_size &&
-			     bio_op(bio) != REQ_OP_ZONE_APPEND);
 		if (bio_op(bio) == REQ_OP_ZONE_APPEND) {
 			status = extract_ordered_extent(BTRFS_I(inode), bio,
 							file_offset);

fs/btrfs/qgroup.c+10−2

 {
 	struct btrfs_qgroup_list *list;
-	btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
 	list_del(&qgroup->dirty);
 	while (!list_empty(&qgroup->groups)) {
 		list = list_first_entry(&qgroup->groups,
 		list_del(&list->next_member);
 		kfree(list);
 	}
-	kfree(qgroup);
 }
 /* must be called with qgroup_lock held */
 		qgroup = rb_entry(n, struct btrfs_qgroup, node);
 		rb_erase(n, &fs_info->qgroup_tree);
 		__del_qgroup_rb(fs_info, qgroup);
+		btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
+		kfree(qgroup);
 	}
 	/*
 	 * We call btrfs_free_qgroup_config() when unmounting
 	spin_lock(&fs_info->qgroup_lock);
 	del_qgroup_rb(fs_info, qgroupid);
 	spin_unlock(&fs_info->qgroup_lock);
+	/*
+	 * Remove the qgroup from sysfs now without holding the qgroup_lock
+	 * spinlock, since the sysfs_remove_group() function needs to take
+	 * the mutex kernfs_mutex through kernfs_remove_by_name_ns().
+	 */
+	btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
+	kfree(qgroup);
 out:
 	mutex_unlock(&fs_info->qgroup_ioctl_lock);
 	return ret;

fs/btrfs/volumes.c+3−0

@@ -7448,6 +7448,9 @@ static int btrfs_device_init_dev_stats(struct btrfs_device *device, · 7447 unmodified lines
7448	int item_size;	7448	int item_size;
7449	int i, ret, slot;	7449	int i, ret, slot;
7450		7450
		7451	if (!device->fs_info->dev_root)
		7452	return 0;
		7453
7451	key.objectid = BTRFS_DEV_STATS_OBJECTID;	7454	key.objectid = BTRFS_DEV_STATS_OBJECTID;
7452	key.type = BTRFS_PERSISTENT_ITEM_KEY;	7455	key.type = BTRFS_PERSISTENT_ITEM_KEY;
7453	key.offset = device->devid;	7456	key.offset = device->devid;

fs/cachefiles/bind.c+6−0

 	cache->mnt = path.mnt;
 	root = path.dentry;
+	ret = -EINVAL;
+	if (mnt_user_ns(path.mnt) != &init_user_ns) {
+		pr_warn("File cache on idmapped mounts not supported");
+		goto error_unsupported;
+	}
 	/* check parameters */
 	ret = -EOPNOTSUPP;
 	if (d_is_negative(root) ||

fs/cachefiles/rdwr.c+3−4

 		container_of(wait, struct cachefiles_one_read, monitor);
 	struct cachefiles_object *object;
 	struct fscache_retrieval *op = monitor->op;
-	struct wait_bit_key *key = _key;
+	struct wait_page_key *key = _key;
 	struct page *page = wait->private;
 	ASSERT(key);
 	_enter("{%lu},%u,%d,{%p,%u}",
 	       monitor->netfs_page->index, mode, sync,
-	       key->flags, key->bit_nr);
+	       key->page, key->bit_nr);
-	if (key->flags != &page->flags ||
+	if (key->page != page || key->bit_nr != PG_locked)
-	    key->bit_nr != PG_locked)
 		return 0;
 	_debug("--- monitor %p %lx ---", page, page->flags);

fs/cifs/cifsacl.c+1−2

@@ -1130,8 +1130,7 @@ static int set_chmod_dacl(struct cifs_acl pdacl, struct cifs_acl pndacl, · 1129 unmodified lines
1130	}	1130	}
1131		1131
1132	/* If it's any one of the ACE we're replacing, skip! */	1132	/* If it's any one of the ACE we're replacing, skip! */
1133	if (!mode_from_sid &&	1133	if (((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) \|\|
1134	((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) \|\|
1135	(compare_sids(&pntace->sid, pownersid) == 0) \|\|	1134	(compare_sids(&pntace->sid, pownersid) == 0) \|\|
1136	(compare_sids(&pntace->sid, pgrpsid) == 0) \|\|	1135	(compare_sids(&pntace->sid, pgrpsid) == 0) \|\|
1137	(compare_sids(&pntace->sid, &sid_everyone) == 0) \|\|	1136	(compare_sids(&pntace->sid, &sid_everyone) == 0) \|\|

fs/cifs/cifsglob.h+2−2

@@ -919,8 +919,8 @@ struct cifs_ses { · 918 unmodified lines
919	bool binding:1; /* are we binding the session? */	919	bool binding:1; /* are we binding the session? */
920	__u16 session_flags;	920	__u16 session_flags;
921	__u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];	921	__u8 smb3signingkey[SMB3_SIGN_KEY_SIZE];
922	__u8 smb3encryptionkey[SMB3_SIGN_KEY_SIZE];	922	__u8 smb3encryptionkey[SMB3_ENC_DEC_KEY_SIZE];
923	__u8 smb3decryptionkey[SMB3_SIGN_KEY_SIZE];	923	__u8 smb3decryptionkey[SMB3_ENC_DEC_KEY_SIZE];
924	__u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];	924	__u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];
925		925
926	__u8 binding_preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];	926	__u8 binding_preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE];

fs/cifs/cifspdu.h+5−0

  */
 #define SMB3_SIGN_KEY_SIZE (16)
+/*
+ * Size of the smb3 encryption/decryption keys
+ */
+#define SMB3_ENC_DEC_KEY_SIZE (32)
 #define CIFS_CLIENT_CHALLENGE_SIZE (8)
 #define CIFS_SERVER_CHALLENGE_SIZE (8)
 #define CIFS_HMAC_MD5_HASH_SIZE (16)

fs/cifs/file.c+1−0

@@ -165,6 +165,7 @@ int cifs_posix_open(char full_path, struct inode *pinode, · 164 unmodified lines
165	goto posix_open_ret;	165	goto posix_open_ret;
166	}	166	}
167	} else {	167	} else {
		168	cifs_revalidate_mapping(*pinode);
168	cifs_fattr_to_inode(*pinode, &fattr);	169	cifs_fattr_to_inode(*pinode, &fattr);
169	}	170	}
170		171

fs/cifs/smb2glob.h+1−0

@@ -58,6 +58,7 @@ · 57 unmodified lines
58	#define SMB2_HMACSHA256_SIZE (32)	58	#define SMB2_HMACSHA256_SIZE (32)
59	#define SMB2_CMACAES_SIZE (16)	59	#define SMB2_CMACAES_SIZE (16)
60	#define SMB3_SIGNKEY_SIZE (16)	60	#define SMB3_SIGNKEY_SIZE (16)
		61	#define SMB3_GCM128_CRYPTKEY_SIZE (16)
61	#define SMB3_GCM256_CRYPTKEY_SIZE (32)	62	#define SMB3_GCM256_CRYPTKEY_SIZE (32)
62		63
63	/* Maximum buffer size value we can send with 1 credit */	64	/* Maximum buffer size value we can send with 1 credit */

fs/cifs/smb2misc.c+2−2

@@ -754,8 +754,8 @@ smb2_is_valid_oplock_break(char buffer, struct TCP_Server_Info server) · 753 unmodified lines
754	}	754	}
755	}	755	}
756	spin_unlock(&cifs_tcp_ses_lock);	756	spin_unlock(&cifs_tcp_ses_lock);
757	cifs_dbg(FYI, "Can not process oplock break for non-existent connection\n");	757	cifs_dbg(FYI, "No file id matched, oplock break ignored\n");
758	return false;	758	return true;
759	}	759	}
760		760
761	void	761	void

fs/cifs/smb2ops.c+20−7

 {
 	int rc;
 	unsigned int ret_data_len;
+	struct inode *inode;
 	struct duplicate_extents_to_file dup_ext_buf;
 	struct cifs_tcon *tcon = tlink_tcon(trgtfile->tlink);
 	cifs_dbg(FYI, "Duplicate extents: src off %lld dst off %lld len %lld\n",
 		src_off, dest_off, len);
-	rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false);
+	inode = d_inode(trgtfile->dentry);
-	if (rc)
+	if (inode->i_size < dest_off + len) {
-		goto duplicate_extents_out;
+		rc = smb2_set_file_size(xid, tcon, trgtfile, dest_off + len, false);
+		if (rc)
+			goto duplicate_extents_out;
+		/*
+		 * Although also could set plausible allocation size (i_blocks)
+		 * here in addition to setting the file size, in reflink
+		 * it is likely that the target file is sparse. Its allocation
+		 * size will be queried on next revalidate, but it is important
+		 * to make sure that file's cached size is updated immediately
+		 */
+		cifs_setsize(inode, dest_off + len);
+	}
 	rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
 			trgtfile->fid.volatile_fid,
 			FSCTL_DUPLICATE_EXTENTS_TO_FILE,
 			if (ses->Suid == ses_id) {
 				ses_enc_key = enc ? ses->smb3encryptionkey :
 					ses->smb3decryptionkey;
-				memcpy(key, ses_enc_key, SMB3_SIGN_KEY_SIZE);
+				memcpy(key, ses_enc_key, SMB3_ENC_DEC_KEY_SIZE);
 				spin_unlock(&cifs_tcp_ses_lock);
 				return 0;
 			}
 	int rc = 0;
 	struct scatterlist *sg;
 	u8 sign[SMB2_SIGNATURE_SIZE] = {};
-	u8 key[SMB3_SIGN_KEY_SIZE];
+	u8 key[SMB3_ENC_DEC_KEY_SIZE];
 	struct aead_request *req;
 	char *iv;
 	unsigned int iv_len;
 	tfm = enc ? server->secmech.ccmaesencrypt :
 						server->secmech.ccmaesdecrypt;
-	if (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)
+	if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
+		(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
 		rc = crypto_aead_setkey(tfm, key, SMB3_GCM256_CRYPTKEY_SIZE);
 	else
-		rc = crypto_aead_setkey(tfm, key, SMB3_SIGN_KEY_SIZE);
+		rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE);
 	if (rc) {
 		cifs_server_dbg(VFS, "%s: Failed to set aead key %d\n", __func__, rc);

fs/cifs/smb2transport.c+28−9

 {
 	unsigned char zero = 0x0;
 	__u8 i[4] = {0, 0, 0, 1};
-	__u8 L[4] = {0, 0, 0, 128};
+	__u8 L128[4] = {0, 0, 0, 128};
+	__u8 L256[4] = {0, 0, 1, 0};
 	int rc = 0;
 	unsigned char prfhash[SMB2_HMACSHA256_SIZE];
 	unsigned char *hashptr = prfhash;
 		goto smb3signkey_ret;
 	}
-	rc = crypto_shash_update(&server->secmech.sdeschmacsha256->shash,
+	if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
-				L, 4);
+		(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
+		rc = crypto_shash_update(&server->secmech.sdeschmacsha256->shash,
+				L256, 4);
+	} else {
+		rc = crypto_shash_update(&server->secmech.sdeschmacsha256->shash,
+				L128, 4);
+	}
 	if (rc) {
 		cifs_server_dbg(VFS, "%s: Could not update with L\n", __func__);
 		goto smb3signkey_ret;
 			const struct derivation_triplet *ptriplet)
 {
 	int rc;
+#ifdef CONFIG_CIFS_DEBUG_DUMP_KEYS
+	struct TCP_Server_Info *server = ses->server;
+#endif
 	/*
 	 * All channels use the same encryption/decryption keys but
 		rc = generate_key(ses, ptriplet->encryption.label,
 				  ptriplet->encryption.context,
 				  ses->smb3encryptionkey,
-				  SMB3_SIGN_KEY_SIZE);
+				  SMB3_ENC_DEC_KEY_SIZE);
 		rc = generate_key(ses, ptriplet->decryption.label,
 				  ptriplet->decryption.context,
 				  ses->smb3decryptionkey,
-				  SMB3_SIGN_KEY_SIZE);
+				  SMB3_ENC_DEC_KEY_SIZE);
 		if (rc)
 			return rc;
 	}
 	 */
 	cifs_dbg(VFS, "Session Id    %*ph\n", (int)sizeof(ses->Suid),
 			&ses->Suid);
+	cifs_dbg(VFS, "Cipher type   %d\n", server->cipher_type);
 	cifs_dbg(VFS, "Session Key   %*ph\n",
 		 SMB2_NTLMV2_SESSKEY_SIZE, ses->auth_key.response);
 	cifs_dbg(VFS, "Signing Key   %*ph\n",
 		 SMB3_SIGN_KEY_SIZE, ses->smb3signingkey);
-	cifs_dbg(VFS, "ServerIn Key  %*ph\n",
+	if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
-		 SMB3_SIGN_KEY_SIZE, ses->smb3encryptionkey);
+		(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
-	cifs_dbg(VFS, "ServerOut Key %*ph\n",
+		cifs_dbg(VFS, "ServerIn Key  %*ph\n",
-		 SMB3_SIGN_KEY_SIZE, ses->smb3decryptionkey);
+				SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3encryptionkey);
+		cifs_dbg(VFS, "ServerOut Key %*ph\n",
+				SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3decryptionkey);
+	} else {
+		cifs_dbg(VFS, "ServerIn Key  %*ph\n",
+				SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3encryptionkey);
+		cifs_dbg(VFS, "ServerOut Key %*ph\n",
+				SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3decryptionkey);
+	}
 #endif
 	return rc;
 }

fs/gfs2/super.c+9−5

 	int error;
 	error = init_threads(sdp);
-	if (error)
+	if (error) {
+		gfs2_withdraw_delayed(sdp);
 		return error;
+	}
 	j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
 	if (gfs2_withdrawn(sdp)) {
 static int gfs2_freeze(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
-	int error = 0;
+	int error;
 	mutex_lock(&sdp->sd_freeze_mutex);
-	if (atomic_read(&sdp->sd_freeze_state) != SFS_UNFROZEN)
+	if (atomic_read(&sdp->sd_freeze_state) != SFS_UNFROZEN) {
+		error = -EBUSY;
 		goto out;
+	}
 	for (;;) {
 		if (gfs2_withdrawn(sdp)) {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	mutex_lock(&sdp->sd_freeze_mutex);
-        if (atomic_read(&sdp->sd_freeze_state) != SFS_FROZEN ||
+	if (atomic_read(&sdp->sd_freeze_state) != SFS_FROZEN ||
 	    !gfs2_holder_initialized(&sdp->sd_freeze_gh)) {
 		mutex_unlock(&sdp->sd_freeze_mutex);
-                return 0;
+		return -EINVAL;
 	}
 	gfs2_freeze_unlock(&sdp->sd_freeze_gh);

fs/io-wq.c+23−13

@@ -16,7 +16,6 @@ · 15 unmodified lines
16	#include <linux/rculist_nulls.h>	16	#include <linux/rculist_nulls.h>
17	#include <linux/cpu.h>	17	#include <linux/cpu.h>
18	#include <linux/tracehook.h>	18	#include <linux/tracehook.h>
19	#include <linux/freezer.h>
20		19
21	#include "../kernel/sched/sched.h"	20	#include "../kernel/sched/sched.h"
22	#include "io-wq.h"	21	#include "io-wq.h"
@@ -388,11 +387,9 @@ static struct io_wq_work io_get_next_work(struct io_wqe wqe) · 365 unmodified lines
388		387
389	static bool io_flush_signals(void)	388	static bool io_flush_signals(void)
390	{	389	{
391	if (unlikely(test_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL))) {	390	if (unlikely(test_thread_flag(TIF_NOTIFY_SIGNAL))) {
392	__set_current_state(TASK_RUNNING);	391	__set_current_state(TASK_RUNNING);
393	if (current->task_works)	392	tracehook_notify_signal();
394	task_work_run();
395	clear_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL);
396	return true;	393	return true;
397	}	394	}
398	return false;	395	return false;
@@ -487,7 +484,7 @@ static int io_wqe_worker(void *data) · 88 unmodified lines
487	worker->flags \|= (IO_WORKER_F_UP \| IO_WORKER_F_RUNNING);	484	worker->flags \|= (IO_WORKER_F_UP \| IO_WORKER_F_RUNNING);
488	io_wqe_inc_running(worker);	485	io_wqe_inc_running(worker);
489		486
490	sprintf(buf, "iou-wrk-%d", wq->task_pid);	487	snprintf(buf, sizeof(buf), "iou-wrk-%d", wq->task_pid);
491	set_task_comm(current, buf);	488	set_task_comm(current, buf);
492		489
493	while (!test_bit(IO_WQ_BIT_EXIT, &wq->state)) {	490	while (!test_bit(IO_WQ_BIT_EXIT, &wq->state)) {
@@ -505,10 +502,15 @@ loop: · 11 unmodified lines
505	if (io_flush_signals())	502	if (io_flush_signals())
506	continue;	503	continue;
507	ret = schedule_timeout(WORKER_IDLE_TIMEOUT);	504	ret = schedule_timeout(WORKER_IDLE_TIMEOUT);
508	if (try_to_freeze() \|\| ret)	505	if (signal_pending(current)) {
509	continue;	506	struct ksignal ksig;
510	if (fatal_signal_pending(current))	507
		508	if (!get_signal(&ksig))
		509	continue;
511	break;	510	break;
		511	}
		512	if (ret)
		513	continue;
512	/* timed out, exit unless we're the fixed worker */	514	/* timed out, exit unless we're the fixed worker */
513	if (test_bit(IO_WQ_BIT_EXIT, &wq->state) \|\|	515	if (test_bit(IO_WQ_BIT_EXIT, &wq->state) \|\|
514	!(worker->flags & IO_WORKER_F_FIXED))	516	!(worker->flags & IO_WORKER_F_FIXED))
@@ -709,16 +711,20 @@ static int io_wq_manager(void *data) · 194 unmodified lines
709	char buf[TASK_COMM_LEN];	711	char buf[TASK_COMM_LEN];
710	int node;	712	int node;
711		713
712	sprintf(buf, "iou-mgr-%d", wq->task_pid);	714	snprintf(buf, sizeof(buf), "iou-mgr-%d", wq->task_pid);
713	set_task_comm(current, buf);	715	set_task_comm(current, buf);
714		716
715	do {	717	do {
716	set_current_state(TASK_INTERRUPTIBLE);	718	set_current_state(TASK_INTERRUPTIBLE);
717	io_wq_check_workers(wq);	719	io_wq_check_workers(wq);
718	schedule_timeout(HZ);	720	schedule_timeout(HZ);
719	try_to_freeze();	721	if (signal_pending(current)) {
720	if (fatal_signal_pending(current))	722	struct ksignal ksig;
		723
		724	if (!get_signal(&ksig))
		725	continue;
721	set_bit(IO_WQ_BIT_EXIT, &wq->state);	726	set_bit(IO_WQ_BIT_EXIT, &wq->state);
		727	}
722	} while (!test_bit(IO_WQ_BIT_EXIT, &wq->state));	728	} while (!test_bit(IO_WQ_BIT_EXIT, &wq->state));
723		729
724	io_wq_check_workers(wq);	730	io_wq_check_workers(wq);
@@ -1065,7 +1071,11 @@ static void io_wq_destroy(struct io_wq *wq) · 340 unmodified lines
1065		1071
1066	for_each_node(node) {	1072	for_each_node(node) {
1067	struct io_wqe *wqe = wq->wqes[node];	1073	struct io_wqe *wqe = wq->wqes[node];
1068	WARN_ON_ONCE(!wq_list_empty(&wqe->work_list));	1074	struct io_cb_cancel_data match = {
		1075	.fn = io_wq_work_match_all,
		1076	.cancel_all = true,
		1077	};
		1078	io_wqe_cancel_pending_work(wqe, &match);
1069	kfree(wqe);	1079	kfree(wqe);
1070	}	1080	}
1071	io_wq_put_hash(wq->hash);	1081	io_wq_put_hash(wq->hash);

fs/io_uring.c+78−59

 #include <linux/task_work.h>
 #include <linux/pagemap.h>
 #include <linux/io_uring.h>
-#include <linux/freezer.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/io_uring.h>
 	REQ_F_NO_FILE_TABLE_BIT,
 	REQ_F_LTIMEOUT_ACTIVE_BIT,
 	REQ_F_COMPLETE_INLINE_BIT,
+	REQ_F_REISSUE_BIT,
 	/* not a real bit, just to check we're not overflowing the space */
 	__REQ_F_LAST_BIT,
 	REQ_F_LTIMEOUT_ACTIVE	= BIT(REQ_F_LTIMEOUT_ACTIVE_BIT),
 	/* completion is deferred through io_comp_state */
 	REQ_F_COMPLETE_INLINE	= BIT(REQ_F_COMPLETE_INLINE_BIT),
+	/* caller should reissue async */
+	REQ_F_REISSUE		= BIT(REQ_F_REISSUE_BIT),
 };
 struct async_poll {
 	io_for_each_link(req, head) {
 		if (req->flags & REQ_F_INFLIGHT)
 			return true;
-		if (req->task->files == files)
-			return true;
 	}
 	return false;
 }
 	if (req->flags & REQ_F_ISREG) {
 		if (def->hash_reg_file || (ctx->flags & IORING_SETUP_IOPOLL))
 			io_wq_hash_work(&req->work, file_inode(req->file));
-	} else {
+	} else if (!req->file || !S_ISBLK(file_inode(req->file)->i_mode)) {
 		if (def->unbound_nonreg_file)
 			req->work.flags |= IO_WQ_WORK_UNBOUND;
 	}
 	BUG_ON(!tctx);
 	BUG_ON(!tctx->io_wq);
-	trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
-					&req->work, req->flags);
 	/* init ->work of the whole link before punting */
 	io_prep_async_link(req);
+	trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
+					&req->work, req->flags);
 	io_wq_enqueue(tctx->io_wq, &req->work);
 	if (link)
 		io_queue_linked_timeout(link);
 }
-static void io_kill_timeout(struct io_kiocb *req)
+static void io_kill_timeout(struct io_kiocb *req, int status)
 {
 	struct io_timeout_data *io = req->async_data;
 	int ret;
 		atomic_set(&req->ctx->cq_timeouts,
 			atomic_read(&req->ctx->cq_timeouts) + 1);
 		list_del_init(&req->timeout.list);
-		io_cqring_fill_event(req, 0);
+		io_cqring_fill_event(req, status);
 		io_put_req_deferred(req, 1);
 	}
 }
-/*
- * Returns true if we found and killed one or more timeouts
- */
-static bool io_kill_timeouts(struct io_ring_ctx *ctx, struct task_struct *tsk,
-			     struct files_struct *files)
-{
-	struct io_kiocb *req, *tmp;
-	int canceled = 0;
-	spin_lock_irq(&ctx->completion_lock);
-	list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list) {
-		if (io_match_task(req, tsk, files)) {
-			io_kill_timeout(req);
-			canceled++;
-		}
-	}
-	spin_unlock_irq(&ctx->completion_lock);
-	return canceled != 0;
-}
 static void __io_queue_deferred(struct io_ring_ctx *ctx)
 {
 	do {
 			break;
 		list_del_init(&req->timeout.list);
-		io_kill_timeout(req);
+		io_kill_timeout(req, 0);
 	} while (!list_empty(&ctx->timeout_list));
 	ctx->cq_last_tm_flush = seq;
 		return false;
 	return true;
 }
+#else
+static bool io_rw_should_reissue(struct io_kiocb *req)
+{
+	return false;
+}
 #endif
 static bool io_rw_reissue(struct io_kiocb *req)
 {
 	int cflags = 0;
-	if ((res == -EAGAIN || res == -EOPNOTSUPP) && io_rw_reissue(req))
+	if (req->rw.kiocb.ki_flags & IOCB_WRITE)
+		kiocb_end_write(req);
+	if ((res == -EAGAIN || res == -EOPNOTSUPP) && io_rw_should_reissue(req)) {
+		req->flags |= REQ_F_REISSUE;
 		return;
+	}
 	if (res != req->result)
 		req_set_fail_links(req);
-	if (req->rw.kiocb.ki_flags & IOCB_WRITE)
-		kiocb_end_write(req);
 	if (req->flags & REQ_F_BUFFER_SELECTED)
 		cflags = io_put_rw_kbuf(req);
 	__io_req_complete(req, issue_flags, res, cflags);
 	ret = io_iter_do_read(req, iter);
-	if (ret == -EIOCBQUEUED) {
+	if (ret == -EAGAIN || (req->flags & REQ_F_REISSUE)) {
-		if (req->async_data)
-			iov_iter_revert(iter, io_size - iov_iter_count(iter));
-		goto out_free;
-	} else if (ret == -EAGAIN) {
 		/* IOPOLL retry should happen for io-wq threads */
 		if (!force_nonblock && !(req->ctx->flags & IORING_SETUP_IOPOLL))
 			goto done;
 		/* some cases will consume bytes even on error returns */
 		iov_iter_revert(iter, io_size - iov_iter_count(iter));
 		ret = 0;
+	} else if (ret == -EIOCBQUEUED) {
+		goto out_free;
 	} else if (ret <= 0 || ret == io_size || !force_nonblock ||
 		   (req->flags & REQ_F_NOWAIT) || !(req->flags & REQ_F_ISREG)) {
 		/* read all, failed, already did sync or don't want to retry */
 	else
 		ret2 = -EINVAL;
+	if (req->flags & REQ_F_REISSUE)
+		ret2 = -EAGAIN;
 	/*
 	 * Raw bdev writes will return -EOPNOTSUPP for IOCB_NOWAIT. Just
 	 * retry them without IOCB_NOWAIT.
 	/* no retry on NONBLOCK nor RWF_NOWAIT */
 	if (ret2 == -EAGAIN && (req->flags & REQ_F_NOWAIT))
 		goto done;
-	if (ret2 == -EIOCBQUEUED && req->async_data)
-		iov_iter_revert(iter, io_size - iov_iter_count(iter));
 	if (!force_nonblock || ret2 != -EAGAIN) {
 		/* IOPOLL retry should happen for io-wq threads */
 		if ((req->ctx->flags & IORING_SETUP_IOPOLL) && ret2 == -EAGAIN)
 static int io_provide_buffers_prep(struct io_kiocb *req,
 				   const struct io_uring_sqe *sqe)
 {
+	unsigned long size;
 	struct io_provide_buf *p = &req->pbuf;
 	u64 tmp;
 	p->addr = READ_ONCE(sqe->addr);
 	p->len = READ_ONCE(sqe->len);
-	if (!access_ok(u64_to_user_ptr(p->addr), (p->len * p->nbufs)))
+	size = (unsigned long)p->len * p->nbufs;
+	if (!access_ok(u64_to_user_ptr(p->addr), size))
 		return -EFAULT;
 	p->bgid = READ_ONCE(sqe->buf_group);
 			ret = -ENOMEM;
 			goto out;
 		}
-		io = req->async_data;
 		memcpy(req->async_data, &__io, sizeof(__io));
 		return -EAGAIN;
 	}
 	data->mode = io_translate_timeout_mode(flags);
 	hrtimer_init(&data->timer, CLOCK_MONOTONIC, data->mode);
-	io_req_track_inflight(req);
+	if (is_timeout_link)
+		io_req_track_inflight(req);
 	return 0;
 }
 		ret = -ECANCELED;
 	if (!ret) {
+		req->flags &= ~REQ_F_REISSUE;
 		do {
 			ret = io_issue_sqe(req, 0);
 			/*
 	ret = io_init_req(ctx, req, sqe);
 	if (unlikely(ret)) {
 fail_req:
-		io_put_req(req);
-		io_req_complete(req, ret);
 		if (link->head) {
 			/* fail even hard links since we don't submit */
 			link->head->flags |= REQ_F_FAIL_LINK;
 			io_req_complete(link->head, -ECANCELED);
 			link->head = NULL;
 		}
+		io_put_req(req);
+		io_req_complete(req, ret);
 		return ret;
 	}
 	ret = io_req_prep(req, sqe);
 	char buf[TASK_COMM_LEN];
 	DEFINE_WAIT(wait);
-	sprintf(buf, "iou-sqp-%d", sqd->task_pid);
+	snprintf(buf, sizeof(buf), "iou-sqp-%d", sqd->task_pid);
 	set_task_comm(current, buf);
 	current->pf_io_worker = NULL;
 		int ret;
 		bool cap_entries, sqt_spin, needs_sched;
-		if (test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state)) {
+		if (test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state) ||
+		    signal_pending(current)) {
+			bool did_sig = false;
 			mutex_unlock(&sqd->lock);
+			if (signal_pending(current)) {
+				struct ksignal ksig;
+				did_sig = get_signal(&ksig);
+			}
 			cond_resched();
 			mutex_lock(&sqd->lock);
+			if (did_sig)
+				break;
 			io_run_task_work();
 			io_run_task_work_head(&sqd->park_task_work);
 			timeout = jiffies + sqd->sq_thread_idle;
 			continue;
 		}
-		if (fatal_signal_pending(current))
-			break;
 		sqt_spin = false;
 		cap_entries = !list_is_singular(&sqd->ctx_list);
 		list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {
 			mutex_unlock(&sqd->lock);
 			schedule();
-			try_to_freeze();
 			mutex_lock(&sqd->lock);
 			list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
 				io_ring_clear_wakeup_flag(ctx);
 		return 1;
 	if (!signal_pending(current))
 		return 0;
-	if (test_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL))
+	if (test_thread_flag(TIF_NOTIFY_SIGNAL))
 		return -ERESTARTSYS;
 	return -EINTR;
 }
 	struct io_tctx_node *node;
 	int ret;
+	/* prevent SQPOLL from submitting new requests */
+	if (ctx->sq_data) {
+		io_sq_thread_park(ctx->sq_data);
+		list_del_init(&ctx->sqd_list);
+		io_sqd_update_thread_idle(ctx->sq_data);
+		io_sq_thread_unpark(ctx->sq_data);
+	}
 	/*
 	 * If we're doing polled IO and end up having requests being
 	 * submitted async (out-of-line), then completions can come in while
 	io_ring_ctx_free(ctx);
 }
+/* Returns true if we found and killed one or more timeouts */
+static bool io_kill_timeouts(struct io_ring_ctx *ctx, struct task_struct *tsk,
+			     struct files_struct *files)
+{
+	struct io_kiocb *req, *tmp;
+	int canceled = 0;
+	spin_lock_irq(&ctx->completion_lock);
+	list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list) {
+		if (io_match_task(req, tsk, files)) {
+			io_kill_timeout(req, -ECANCELED);
+			canceled++;
+		}
+	}
+	if (canceled != 0)
+		io_commit_cqring(ctx);
+	spin_unlock_irq(&ctx->completion_lock);
+	if (canceled != 0)
+		io_cqring_ev_posted(ctx);
+	return canceled != 0;
+}
 static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
 {
 	unsigned long index;
 		io_unregister_personality(ctx, index);
 	mutex_unlock(&ctx->uring_lock);
-	/* prevent SQPOLL from submitting new requests */
-	if (ctx->sq_data) {
-		io_sq_thread_park(ctx->sq_data);
-		list_del_init(&ctx->sqd_list);
-		io_sqd_update_thread_idle(ctx->sq_data);
-		io_sq_thread_unpark(ctx->sq_data);
-	}
 	io_kill_timeouts(ctx, NULL, NULL);
 	io_poll_remove_all(ctx, NULL, NULL);
 	/* make sure overflow events are dropped */
 	atomic_inc(&tctx->in_idle);
+	__io_uring_files_cancel(NULL);
 	do {
 		/* read completions before cancelations */
 		inflight = tctx_inflight(tctx);

fs/reiserfs/xattr.h+1−1

@@ -44,7 +44,7 @@ void reiserfs_security_free(struct reiserfs_security_handle *sec); · 43 unmodified lines
44		44
45	static inline int reiserfs_xattrs_initialized(struct super_block *sb)	45	static inline int reiserfs_xattrs_initialized(struct super_block *sb)
46	{	46	{
47	return REISERFS_SB(sb)->priv_root != NULL;	47	return REISERFS_SB(sb)->priv_root && REISERFS_SB(sb)->xattr_root;
48	}	48	}
49		49
50	#define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header))	50	#define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header))

fs/squashfs/export.c+6−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end
+		    || (end - start) >
+		    (SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= lookup_table_start || (lookup_table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= lookup_table_start ||
+	    (lookup_table_start - start) >
+	    (SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

fs/squashfs/id.c+4−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end || (end - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= id_table_start || (id_table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= id_table_start || (id_table_start - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

fs/squashfs/squashfs_fs.h+1−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17		17
18	/* size of metadata (inode and directory) blocks */	18	/* size of metadata (inode and directory) blocks */
19	#define SQUASHFS_METADATA_SIZE 8192	19	#define SQUASHFS_METADATA_SIZE 8192
		20	#define SQUASHFS_BLOCK_OFFSET 2
20		21
21	/* default size of block device I/O */	22	/* default size of block device I/O */
22	#ifdef CONFIG_SQUASHFS_4K_DEVBLK_SIZE	23	#ifdef CONFIG_SQUASHFS_4K_DEVBLK_SIZE

fs/squashfs/xattr_id.c+4−2

 		start = le64_to_cpu(table[n]);
 		end = le64_to_cpu(table[n + 1]);
-		if (start >= end || (end - start) > SQUASHFS_METADATA_SIZE) {
+		if (start >= end || (end - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 			kfree(table);
 			return ERR_PTR(-EINVAL);
 		}
 	}
 	start = le64_to_cpu(table[indexes - 1]);
-	if (start >= table_start || (table_start - start) > SQUASHFS_METADATA_SIZE) {
+	if (start >= table_start || (table_start - start) >
+				(SQUASHFS_METADATA_SIZE + SQUASHFS_BLOCK_OFFSET)) {
 		kfree(table);
 		return ERR_PTR(-EINVAL);
 	}

include/acpi/acpi_bus.h+1−0

@@ -233,6 +233,7 @@ struct acpi_pnp_type { · 232 unmodified lines
233		233
234	struct acpi_device_pnp {	234	struct acpi_device_pnp {
235	acpi_bus_id bus_id; /* Object name */	235	acpi_bus_id bus_id; /* Object name */
		236	int instance_no; /* Instance number of this object */
236	struct acpi_pnp_type type; /* ID type */	237	struct acpi_pnp_type type; /* ID type */
237	acpi_bus_address bus_address; /* _ADR */	238	acpi_bus_address bus_address; /* _ADR */
238	char unique_id; / _UID */	239	char unique_id; / _UID */

include/linux/acpi.h+8−1

 void __acpi_unmap_table(void __iomem *map, unsigned long size);
 int early_acpi_boot_init(void);
 int acpi_boot_init (void);
+void acpi_boot_table_prepare (void);
 void acpi_boot_table_init (void);
 int acpi_mps_check (void);
 int acpi_numa_init (void);
+int acpi_locate_initial_tables (void);
+void acpi_reserve_initial_tables (void);
+void acpi_table_init_complete (void);
 int acpi_table_init (void);
 int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
 	return 0;
 }
+static inline void acpi_boot_table_prepare(void)
+{
+}
 static inline void acpi_boot_table_init(void)
 {
-	return;
 }
 static inline int acpi_mps_check(void)

include/linux/blkdev.h+0−2

 #define RQF_ELVPRIV		((__force req_flags_t)(1 << 12))
 /* account into disk and partition IO statistics */
 #define RQF_IO_STAT		((__force req_flags_t)(1 << 13))
-/* request came from our alloc pool */
-#define RQF_ALLOCED		((__force req_flags_t)(1 << 14))
 /* runtime pm request */
 #define RQF_PM			((__force req_flags_t)(1 << 15))
 /* on IO scheduler merge hash */

include/linux/bpf.h+25−8

 #include <linux/capability.h>
 #include <linux/sched/mm.h>
 #include <linux/slab.h>
+#include <linux/percpu-refcount.h>
 struct bpf_verifier_env;
 struct bpf_verifier_log;
  *      fentry = a set of program to run before calling original function
  *      fexit = a set of program to run after original function
  */
-int arch_prepare_bpf_trampoline(void *image, void *image_end,
+struct bpf_tramp_image;
+int arch_prepare_bpf_trampoline(struct bpf_tramp_image *tr, void *image, void *image_end,
 				const struct btf_func_model *m, u32 flags,
 				struct bpf_tramp_progs *tprogs,
 				void *orig_call);
 void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start);
 u64 notrace __bpf_prog_enter_sleepable(struct bpf_prog *prog);
 void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start);
+void notrace __bpf_tramp_enter(struct bpf_tramp_image *tr);
+void notrace __bpf_tramp_exit(struct bpf_tramp_image *tr);
 struct bpf_ksym {
 	unsigned long		 start;
 	BPF_TRAMP_REPLACE, /* more than MAX */
 };
+struct bpf_tramp_image {
+	void *image;
+	struct bpf_ksym ksym;
+	struct percpu_ref pcref;
+	void *ip_after_call;
+	void *ip_epilogue;
+	union {
+		struct rcu_head rcu;
+		struct work_struct work;
+	};
+};
 struct bpf_trampoline {
 	/* hlist for trampoline_table */
 	struct hlist_node hlist;
 	/* Number of attached programs. A counter per kind. */
 	int progs_cnt[BPF_TRAMP_MAX];
 	/* Executable image of trampoline */
-	void *image;
+	struct bpf_tramp_image *cur_image;
 	u64 selector;
-	struct bpf_ksym ksym;
 };
 struct bpf_attach_target_info {
 void bpf_image_ksym_del(struct bpf_ksym *ksym);
 void bpf_ksym_add(struct bpf_ksym *ksym);
 void bpf_ksym_del(struct bpf_ksym *ksym);
+int bpf_jit_charge_modmem(u32 pages);
+void bpf_jit_uncharge_modmem(u32 pages);
 #else
 static inline int bpf_trampoline_link_prog(struct bpf_prog *prog,
 					   struct bpf_trampoline *tr)
 	bool func_proto_unreliable;
 	bool sleepable;
 	bool tail_call_reachable;
-	enum bpf_tramp_prog_type trampoline_prog_type;
 	struct hlist_node tramp_hlist;
 	/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */
 	const struct btf_type *attach_func_proto;
 		_ret;							\
 	 })
-#define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null)	\
+#define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null, set_cg_storage)	\
 	({						\
 		struct bpf_prog_array_item *_item;	\
 		struct bpf_prog *_prog;			\
 			goto _out;			\
 		_item = &_array->items[0];		\
 		while ((_prog = READ_ONCE(_item->prog))) {		\
-			bpf_cgroup_storage_set(_item->cgroup_storage);	\
+			if (set_cg_storage)		\
+				bpf_cgroup_storage_set(_item->cgroup_storage);	\
 			_ret &= func(_prog, ctx);	\
 			_item++;			\
 		}					\
 	})
 #define BPF_PROG_RUN_ARRAY(array, ctx, func)		\
-	__BPF_PROG_RUN_ARRAY(array, ctx, func, false)
+	__BPF_PROG_RUN_ARRAY(array, ctx, func, false, true)
 #define BPF_PROG_RUN_ARRAY_CHECK(array, ctx, func)	\
-	__BPF_PROG_RUN_ARRAY(array, ctx, func, true)
+	__BPF_PROG_RUN_ARRAY(array, ctx, func, true, false)
 #ifdef CONFIG_BPF_SYSCALL
 DECLARE_PER_CPU(int, bpf_prog_active);

include/linux/device-mapper.h+14−1

 #define dm_target_passes_integrity(type) ((type)->features & DM_TARGET_PASSES_INTEGRITY)
 /*
- * Indicates that a target supports host-managed zoned block devices.
+ * Indicates support for zoned block devices:
+ * - DM_TARGET_ZONED_HM: the target also supports host-managed zoned
+ *   block devices but does not support combining different zoned models.
+ * - DM_TARGET_MIXED_ZONED_MODEL: the target supports combining multiple
+ *   devices with different zoned models.
  */
 #ifdef CONFIG_BLK_DEV_ZONED
 #define DM_TARGET_ZONED_HM		0x00000040
 #define DM_TARGET_PASSES_CRYPTO		0x00000100
 #define dm_target_passes_crypto(type) ((type)->features & DM_TARGET_PASSES_CRYPTO)
+#ifdef CONFIG_BLK_DEV_ZONED
+#define DM_TARGET_MIXED_ZONED_MODEL	0x00000200
+#define dm_target_supports_mixed_zoned_model(type) \
+	((type)->features & DM_TARGET_MIXED_ZONED_MODEL)
+#else
+#define DM_TARGET_MIXED_ZONED_MODEL	0x00000000
+#define dm_target_supports_mixed_zoned_model(type) (false)
+#endif
 struct dm_target {
 	struct dm_table *table;
 	struct target_type *type;

include/linux/extcon.h+23−0

@@ -271,6 +271,29 @@ static inline void devm_extcon_unregister_notifier(struct device *dev, · 270 unmodified lines
271	struct extcon_dev *edev, unsigned int id,	271	struct extcon_dev *edev, unsigned int id,
272	struct notifier_block *nb) { }	272	struct notifier_block *nb) { }
273		273
		274	static inline int extcon_register_notifier_all(struct extcon_dev *edev,
		275	struct notifier_block *nb)
		276	{
		277	return 0;
		278	}
		279
		280	static inline int extcon_unregister_notifier_all(struct extcon_dev *edev,
		281	struct notifier_block *nb)
		282	{
		283	return 0;
		284	}
		285
		286	static inline int devm_extcon_register_notifier_all(struct device *dev,
		287	struct extcon_dev *edev,
		288	struct notifier_block *nb)
		289	{
		290	return 0;
		291	}
		292
		293	static inline void devm_extcon_unregister_notifier_all(struct device *dev,
		294	struct extcon_dev *edev,
		295	struct notifier_block *nb) { }
		296
274	static inline struct extcon_dev extcon_get_extcon_dev(const char extcon_name)	297	static inline struct extcon_dev extcon_get_extcon_dev(const char extcon_name)
275	{	298	{
276	return ERR_PTR(-ENODEV);	299	return ERR_PTR(-ENODEV);

include/linux/firmware/intel/stratix10-svc-client.h+1−1

@@ -56,7 +56,7 @@ · 55 unmodified lines
56	* COMMAND_RECONFIG_FLAG_PARTIAL:	56	* COMMAND_RECONFIG_FLAG_PARTIAL:
57	* Set to FPGA configuration type (full or partial).	57	* Set to FPGA configuration type (full or partial).
58	*/	58	*/
59	#define COMMAND_RECONFIG_FLAG_PARTIAL 1	59	#define COMMAND_RECONFIG_FLAG_PARTIAL 0
60		60
61	/*	61	/*
62	* Timeout settings for service clients:	62	* Timeout settings for service clients:

include/linux/host1x.h+8−1

 int host1x_device_init(struct host1x_device *device);
 int host1x_device_exit(struct host1x_device *device);
-int host1x_client_register(struct host1x_client *client);
+int __host1x_client_register(struct host1x_client *client,
+			     struct lock_class_key *key);
+#define host1x_client_register(class) \
+	({ \
+		static struct lock_class_key __key; \
+		__host1x_client_register(class, &__key); \
+	})
 int host1x_client_unregister(struct host1x_client *client);
 int host1x_client_suspend(struct host1x_client *client);

include/linux/hugetlb_cgroup.h+13−2

 	return !cgroup_subsys_enabled(hugetlb_cgrp_subsys);
 }
+static inline void hugetlb_cgroup_put_rsvd_cgroup(struct hugetlb_cgroup *h_cg)
+{
+	css_put(&h_cg->css);
+}
 extern int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
 					struct hugetlb_cgroup **ptr);
 extern int hugetlb_cgroup_charge_cgroup_rsvd(int idx, unsigned long nr_pages,
 extern void hugetlb_cgroup_uncharge_file_region(struct resv_map *resv,
 						struct file_region *rg,
-						unsigned long nr_pages);
+						unsigned long nr_pages,
+						bool region_del);
 extern void hugetlb_cgroup_file_init(void) __init;
 extern void hugetlb_cgroup_migrate(struct page *oldhpage,
 #else
 static inline void hugetlb_cgroup_uncharge_file_region(struct resv_map *resv,
 						       struct file_region *rg,
-						       unsigned long nr_pages)
+						       unsigned long nr_pages,
+						       bool region_del)
 {
 }
 	return true;
 }
+static inline void hugetlb_cgroup_put_rsvd_cgroup(struct hugetlb_cgroup *h_cg)
+{
+}
 static inline int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
 					       struct hugetlb_cgroup **ptr)
 {

include/linux/if_macvlan.h+2−1

 	if (likely(success)) {
 		struct vlan_pcpu_stats *pcpu_stats;
-		pcpu_stats = this_cpu_ptr(vlan->pcpu_stats);
+		pcpu_stats = get_cpu_ptr(vlan->pcpu_stats);
 		u64_stats_update_begin(&pcpu_stats->syncp);
 		pcpu_stats->rx_packets++;
 		pcpu_stats->rx_bytes += len;
 		if (multicast)
 			pcpu_stats->rx_multicast++;
 		u64_stats_update_end(&pcpu_stats->syncp);
+		put_cpu_ptr(vlan->pcpu_stats);
 	} else {
 		this_cpu_inc(vlan->pcpu_stats->rx_errors);
 	}

include/linux/memblock.h+2−2

@@ -460,7 +460,7 @@ static inline void memblock_free_late(phys_addr_t base, phys_addr_t size) · 459 unmodified lines
460	/*	460	/*
461	* Set the allocation direction to bottom-up or top-down.	461	* Set the allocation direction to bottom-up or top-down.
462	*/	462	*/
463	static inline __init void memblock_set_bottom_up(bool enable)	463	static inline __init_memblock void memblock_set_bottom_up(bool enable)
464	{	464	{
465	memblock.bottom_up = enable;	465	memblock.bottom_up = enable;
466	}	466	}
@@ -470,7 +470,7 @@ static inline __init void memblock_set_bottom_up(bool enable) · 3 unmodified lines
470	* if this is true, that said, memblock will allocate memory	470	* if this is true, that said, memblock will allocate memory
471	* in bottom-up direction.	471	* in bottom-up direction.
472	*/	472	*/
473	static inline __init bool memblock_bottom_up(void)	473	static inline __init_memblock bool memblock_bottom_up(void)
474	{	474	{
475	return memblock.bottom_up;	475	return memblock.bottom_up;
476	}	476	}

include/linux/mlx5/qp.h+7−0

@@ -547,4 +547,11 @@ static inline const char *mlx5_qp_state_str(int state) · 546 unmodified lines
547	}	547	}
548	}	548	}
549		549
		550	static inline int mlx5_get_qp_default_ts(struct mlx5_core_dev *dev)
		551	{
		552	return !MLX5_CAP_ROCE(dev, qp_ts_format) ?
		553	MLX5_QPC_TIMESTAMP_FORMAT_FREE_RUNNING :
		554	MLX5_QPC_TIMESTAMP_FORMAT_DEFAULT;
		555	}
		556
550	#endif /* MLX5_QP_H */	557	#endif /* MLX5_QP_H */

include/linux/mm.h+15−3

@@ -1461,16 +1461,28 @@ static inline bool cpupid_match_pid(struct task_struct *task, int cpupid) · 1460 unmodified lines
1461		1461
1462	#if defined(CONFIG_KASAN_SW_TAGS) \|\| defined(CONFIG_KASAN_HW_TAGS)	1462	#if defined(CONFIG_KASAN_SW_TAGS) \|\| defined(CONFIG_KASAN_HW_TAGS)
1463		1463
		1464	/*
		1465	* KASAN per-page tags are stored xor'ed with 0xff. This allows to avoid
		1466	* setting tags for all pages to native kernel tag value 0xff, as the default
		1467	* value 0x00 maps to 0xff.
		1468	*/
		1469
1464	static inline u8 page_kasan_tag(const struct page *page)	1470	static inline u8 page_kasan_tag(const struct page *page)
1465	{	1471	{
1466	if (kasan_enabled())	1472	u8 tag = 0xff;
1467	return (page->flags >> KASAN_TAG_PGSHIFT) & KASAN_TAG_MASK;	1473
1468	return 0xff;	1474	if (kasan_enabled()) {
		1475	tag = (page->flags >> KASAN_TAG_PGSHIFT) & KASAN_TAG_MASK;
		1476	tag ^= 0xff;
		1477	}
		1478
		1479	return tag;
1469	}	1480	}
1470		1481
1471	static inline void page_kasan_tag_set(struct page *page, u8 tag)	1482	static inline void page_kasan_tag_set(struct page *page, u8 tag)
1472	{	1483	{
1473	if (kasan_enabled()) {	1484	if (kasan_enabled()) {
		1485	tag ^= 0xff;
1474	page->flags &= ~(KASAN_TAG_MASK << KASAN_TAG_PGSHIFT);	1486	page->flags &= ~(KASAN_TAG_MASK << KASAN_TAG_PGSHIFT);
1475	page->flags \|= (tag & KASAN_TAG_MASK) << KASAN_TAG_PGSHIFT;	1487	page->flags \|= (tag & KASAN_TAG_MASK) << KASAN_TAG_PGSHIFT;
1476	}	1488	}

include/linux/mmu_notifier.h+5−5

@@ -169,11 +169,11 @@ struct mmu_notifier_ops { · 168 unmodified lines
169	* the last refcount is dropped.	169	* the last refcount is dropped.
170	*	170	*
171	* If blockable argument is set to false then the callback cannot	171	* If blockable argument is set to false then the callback cannot
172	* sleep and has to return with -EAGAIN. 0 should be returned	172	* sleep and has to return with -EAGAIN if sleeping would be required.
173	* otherwise. Please note that if invalidate_range_start approves	173	* 0 should be returned otherwise. Please note that notifiers that can
174	* a non-blocking behavior then the same applies to	174	* fail invalidate_range_start are not allowed to implement
175	* invalidate_range_end.	175	* invalidate_range_end, as there is no mechanism for informing the
176	*	176	* notifier that its start failed.
177	*/	177	*/
178	int (invalidate_range_start)(struct mmu_notifier subscription,	178	int (invalidate_range_start)(struct mmu_notifier subscription,
179	const struct mmu_notifier_range *range);	179	const struct mmu_notifier_range *range);

include/linux/mutex.h+1−1

@@ -185,7 +185,7 @@ extern void mutex_lock_io(struct mutex *lock); · 184 unmodified lines
185	# define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)	185	# define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)
186	# define mutex_lock_killable_nested(lock, subclass) mutex_lock_killable(lock)	186	# define mutex_lock_killable_nested(lock, subclass) mutex_lock_killable(lock)
187	# define mutex_lock_nest_lock(lock, nest_lock) mutex_lock(lock)	187	# define mutex_lock_nest_lock(lock, nest_lock) mutex_lock(lock)
188	# define mutex_lock_io_nested(lock, subclass) mutex_lock(lock)	188	# define mutex_lock_io_nested(lock, subclass) mutex_lock_io(lock)
189	#endif	189	#endif
190		190
191	/*	191	/*

include/linux/netdevice.h+2−0

 	NAPI_STATE_IN_BUSY_POLL,	/* sk_busy_loop() owns this NAPI */
 	NAPI_STATE_PREFER_BUSY_POLL,	/* prefer busy-polling over softirq processing*/
 	NAPI_STATE_THREADED,		/* The poll is performed inside its own thread*/
+	NAPI_STATE_SCHED_THREADED,	/* Napi is currently scheduled in threaded mode */
 };
 enum {
 	NAPIF_STATE_IN_BUSY_POLL	= BIT(NAPI_STATE_IN_BUSY_POLL),
 	NAPIF_STATE_PREFER_BUSY_POLL	= BIT(NAPI_STATE_PREFER_BUSY_POLL),
 	NAPIF_STATE_THREADED		= BIT(NAPI_STATE_THREADED),
+	NAPIF_STATE_SCHED_THREADED	= BIT(NAPI_STATE_SCHED_THREADED),
 };
 enum gro_result {

include/linux/netfilter/x_tables.h+2−5

 	unsigned int valid_hooks;
 	/* Man behind the curtain... */
-	struct xt_table_info __rcu *private;
+	struct xt_table_info *private;
 	/* Set this to THIS_MODULE if you are a module, otherwise NULL */
 	struct module *me;
 	 * since addend is most likely 1
 	 */
 	__this_cpu_add(xt_recseq.sequence, addend);
-	smp_wmb();
+	smp_mb();
 	return addend;
 }
 struct nf_hook_ops *xt_hook_ops_alloc(const struct xt_table *, nf_hookfn *);
-struct xt_table_info
-*xt_table_get_private_protected(const struct xt_table *table);
 #ifdef CONFIG_COMPAT
 #include <net/compat.h>

include/linux/pagemap.h+1−1

 	return pgoff;
 }
-/* This has the same layout as wait_bit_key - see fs/cachefiles/rdwr.c */
 struct wait_page_key {
 	struct page *page;
 	int bit_nr;
 int put_and_wait_on_page_locked(struct page *page, int state);
 void wait_on_page_writeback(struct page *page);
+int wait_on_page_writeback_killable(struct page *page);
 extern void end_page_writeback(struct page *page);
 void wait_for_stable_page(struct page *page);

include/linux/qcom-geni-se.h+0−2

@@ -460,7 +460,5 @@ void geni_icc_set_tag(struct geni_se *se, u32 tag); · 459 unmodified lines
460	int geni_icc_enable(struct geni_se *se);	460	int geni_icc_enable(struct geni_se *se);
461		461
462	int geni_icc_disable(struct geni_se *se);	462	int geni_icc_disable(struct geni_se *se);
463
464	void geni_remove_earlycon_icc_vote(void);
465	#endif	463	#endif
466	#endif	464	#endif

include/linux/skbuff.h+1−0

@@ -285,6 +285,7 @@ struct nf_bridge_info { · 284 unmodified lines
285	struct tc_skb_ext {	285	struct tc_skb_ext {
286	__u32 chain;	286	__u32 chain;
287	__u16 mru;	287	__u16 mru;
		288	bool post_ct;
288	};	289	};
289	#endif	290	#endif
290		291

include/linux/usermode_driver.h+1−0

@@ -14,5 +14,6 @@ struct umd_info { · 13 unmodified lines
14	int umd_load_blob(struct umd_info info, const void data, size_t len);	14	int umd_load_blob(struct umd_info info, const void data, size_t len);
15	int umd_unload_blob(struct umd_info *info);	15	int umd_unload_blob(struct umd_info *info);
16	int fork_usermode_driver(struct umd_info *info);	16	int fork_usermode_driver(struct umd_info *info);
		17	void umd_cleanup_helper(struct umd_info *info);
17		18
18	#endif /* __LINUX_USERMODE_DRIVER_H__ */	19	#endif /* __LINUX_USERMODE_DRIVER_H__ */

include/linux/xarray.h+3−1

  *
  * This structure is used either directly or via the XA_LIMIT() macro
  * to communicate the range of IDs that are valid for allocation.
- * Two common ranges are predefined for you:
+ * Three common ranges are predefined for you:
  * * xa_limit_32b	- [0 - UINT_MAX]
  * * xa_limit_31b	- [0 - INT_MAX]
+ * * xa_limit_16b	- [0 - USHRT_MAX]
  */
 struct xa_limit {
 	u32 max;
 #define xa_limit_32b	XA_LIMIT(0, UINT_MAX)
 #define xa_limit_31b	XA_LIMIT(0, INT_MAX)
+#define xa_limit_16b	XA_LIMIT(0, USHRT_MAX)
 typedef unsigned __bitwise xa_mark_t;
 #define XA_MARK_0		((__force xa_mark_t)0U)

include/net/dst.h+11−0

@@ -550,4 +550,15 @@ static inline void skb_dst_update_pmtu_no_confirm(struct sk_buff *skb, u32 mtu) · 549 unmodified lines
550	dst->ops->update_pmtu(dst, NULL, skb, mtu, false);	550	dst->ops->update_pmtu(dst, NULL, skb, mtu, false);
551	}	551	}
552		552
		553	struct dst_entry dst_blackhole_check(struct dst_entry dst, u32 cookie);
		554	void dst_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,
		555	struct sk_buff *skb, u32 mtu, bool confirm_neigh);
		556	void dst_blackhole_redirect(struct dst_entry dst, struct sock sk,
		557	struct sk_buff *skb);
		558	u32 dst_blackhole_cow_metrics(struct dst_entry dst, unsigned long old);
		559	struct neighbour dst_blackhole_neigh_lookup(const struct dst_entry dst,
		560	struct sk_buff *skb,
		561	const void *daddr);
		562	unsigned int dst_blackhole_mtu(const struct dst_entry *dst);
		563
553	#endif /* _NET_DST_H */	564	#endif /* _NET_DST_H */

include/net/inet_connection_sock.h+1−1

@@ -282,7 +282,7 @@ static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk) · 281 unmodified lines
282	return inet_csk_reqsk_queue_len(sk) >= sk->sk_max_ack_backlog;	282	return inet_csk_reqsk_queue_len(sk) >= sk->sk_max_ack_backlog;
283	}	283	}
284		284
285	void inet_csk_reqsk_queue_drop(struct sock sk, struct request_sock req);	285	bool inet_csk_reqsk_queue_drop(struct sock sk, struct request_sock req);
286	void inet_csk_reqsk_queue_drop_and_put(struct sock sk, struct request_sock req);	286	void inet_csk_reqsk_queue_drop_and_put(struct sock sk, struct request_sock req);
287		287
288	static inline void inet_csk_prepare_for_destroy_sock(struct sock *sk)	288	static inline void inet_csk_prepare_for_destroy_sock(struct sock *sk)

include/net/netfilter/nf_tables.h+3−0

 	struct nft_flowtable		*flowtable;
 	bool				update;
 	struct list_head		hook_list;
+	u32				flags;
 };
 #define nft_trans_flowtable(trans)	\
 	(((struct nft_trans_flowtable *)trans->data)->update)
 #define nft_trans_flowtable_hooks(trans)	\
 	(((struct nft_trans_flowtable *)trans->data)->hook_list)
+#define nft_trans_flowtable_flags(trans)	\
+	(((struct nft_trans_flowtable *)trans->data)->flags)
 int __init nft_chain_filter_init(void);
 void nft_chain_filter_fini(void);

include/net/nexthop.h+24−0

@@ -410,6 +410,7 @@ static inline struct fib_nh fib_info_nh(struct fib_info fi, int nhsel) · 409 unmodified lines
410	int fib6_check_nexthop(struct nexthop nh, struct fib6_config cfg,	410	int fib6_check_nexthop(struct nexthop nh, struct fib6_config cfg,
411	struct netlink_ext_ack *extack);	411	struct netlink_ext_ack *extack);
412		412
		413	/* Caller should either hold rcu_read_lock(), or RTNL. */
413	static inline struct fib6_nh nexthop_fib6_nh(struct nexthop nh)	414	static inline struct fib6_nh nexthop_fib6_nh(struct nexthop nh)
414	{	415	{
415	struct nh_info *nhi;	416	struct nh_info *nhi;
@@ -430,6 +431,29 @@ static inline struct fib6_nh nexthop_fib6_nh(struct nexthop nh) · 14 unmodified lines
430	return NULL;	431	return NULL;
431	}	432	}
432		433
		434	/* Variant of nexthop_fib6_nh().
		435	* Caller should either hold rcu_read_lock_bh(), or RTNL.
		436	*/
		437	static inline struct fib6_nh nexthop_fib6_nh_bh(struct nexthop nh)
		438	{
		439	struct nh_info *nhi;
		440
		441	if (nh->is_group) {
		442	struct nh_group *nh_grp;
		443
		444	nh_grp = rcu_dereference_bh_rtnl(nh->nh_grp);
		445	nh = nexthop_mpath_select(nh_grp, 0);
		446	if (!nh)
		447	return NULL;
		448	}
		449
		450	nhi = rcu_dereference_bh_rtnl(nh->nh_info);
		451	if (nhi->family == AF_INET6)
		452	return &nhi->fib6_nh;
		453
		454	return NULL;
		455	}
		456
433	static inline struct net_device fib6_info_nh_dev(struct fib6_info f6i)	457	static inline struct net_device fib6_info_nh_dev(struct fib6_info f6i)
434	{	458	{
435	struct fib6_nh *fib6_nh;	459	struct fib6_nh *fib6_nh;

include/net/red.h+10−2

 	v->qcount	= -1;
 }
-static inline bool red_check_params(u32 qth_min, u32 qth_max, u8 Wlog, u8 Scell_log)
+static inline bool red_check_params(u32 qth_min, u32 qth_max, u8 Wlog,
+				    u8 Scell_log, u8 *stab)
 {
 	if (fls(qth_min) + Wlog > 32)
 		return false;
 		return false;
 	if (qth_max < qth_min)
 		return false;
+	if (stab) {
+		int i;
+		for (i = 0; i < RED_STAB_SIZE; i++)
+			if (stab[i] >= 32)
+				return false;
+	}
 	return true;
 }
 	int  shift;
 	/*
-	 * The problem: ideally, average length queue recalcultion should
+	 * The problem: ideally, average length queue recalculation should
 	 * be done over constant clock intervals. This is too expensive, so
 	 * that the calculation is driven by outgoing packets.
 	 * When the queue is idle we have to model this clock by hand.

include/net/rtnetlink.h+2−0

  *
  *	@list: Used internally
  *	@kind: Identifier
+ *	@netns_refund: Physical device, move to init_net on netns exit
  *	@maxtype: Highest device specific netlink attribute number
  *	@policy: Netlink policy for device specific attribute validation
  *	@validate: Optional validation function for netlink/changelink parameters
 	size_t			priv_size;
 	void			(*setup)(struct net_device *dev);
+	bool			netns_refund;
 	unsigned int		maxtype;
 	const struct nla_policy	*policy;
 	int			(*validate)(struct nlattr *tb[],

include/net/sock.h+1−1

@@ -936,7 +936,7 @@ static inline void sk_acceptq_added(struct sock *sk) · 935 unmodified lines
936		936
937	static inline bool sk_acceptq_is_full(const struct sock *sk)	937	static inline bool sk_acceptq_is_full(const struct sock *sk)
938	{	938	{
939	return READ_ONCE(sk->sk_ack_backlog) > READ_ONCE(sk->sk_max_ack_backlog);	939	return READ_ONCE(sk->sk_ack_backlog) >= READ_ONCE(sk->sk_max_ack_backlog);
940	}	940	}
941		941
942	/*	942	/*

include/scsi/scsi_transport_iscsi.h+1−0

@@ -193,6 +193,7 @@ enum iscsi_connection_state { · 192 unmodified lines
193	ISCSI_CONN_UP = 0,	193	ISCSI_CONN_UP = 0,
194	ISCSI_CONN_DOWN,	194	ISCSI_CONN_DOWN,
195	ISCSI_CONN_FAILED,	195	ISCSI_CONN_FAILED,
		196	ISCSI_CONN_BOUND,
196	};	197	};
197		198
198	struct iscsi_cls_conn {	199	struct iscsi_cls_conn {

include/uapi/linux/blkpg.h+2−26

@@ -2,29 +2,6 @@ · 1 unmodified line
2	#ifndef _UAPI__LINUX_BLKPG_H	2	#ifndef _UAPI__LINUX_BLKPG_H
3	#define _UAPI__LINUX_BLKPG_H	3	#define _UAPI__LINUX_BLKPG_H
4		4
5	/*
6	* Partition table and disk geometry handling
7	*
8	* A single ioctl with lots of subfunctions:
9	*
10	* Device number stuff:
11	* get_whole_disk() (given the device number of a partition,
12	* find the device number of the encompassing disk)
13	* get_all_partitions() (given the device number of a disk, return the
14	* device numbers of all its known partitions)
15	*
16	* Partition stuff:
17	* add_partition()
18	* delete_partition()
19	* test_partition_in_use() (also for test_disk_in_use)
20	*
21	* Geometry stuff:
22	* get_geometry()
23	* set_geometry()
24	* get_bios_drivedata()
25	*
26	* For today, only the partition stuff - aeb, 990515
27	*/
28	#include <linux/compiler.h>	5	#include <linux/compiler.h>
29	#include <linux/ioctl.h>	6	#include <linux/ioctl.h>
30		7
@@ -52,9 +29,8 @@ struct blkpg_partition { · 21 unmodified lines
52	long long start; /* starting offset in bytes */	29	long long start; /* starting offset in bytes */
53	long long length; /* length in bytes */	30	long long length; /* length in bytes */
54	int pno; /* partition number */	31	int pno; /* partition number */
55	char devname[BLKPG_DEVNAMELTH]; /* partition name, like sda5 or c0d1p2,	32	char devname[BLKPG_DEVNAMELTH]; /* unused / ignored */
56	to be used in kernel messages */	33	char volname[BLKPG_VOLNAMELTH]; /* unused / ignore */
57	char volname[BLKPG_VOLNAMELTH]; /* volume label */
58	};	34	};
59		35
60	#endif /* _UAPI__LINUX_BLKPG_H */	36	#endif /* _UAPI__LINUX_BLKPG_H */

include/uapi/linux/bpf.h+11−5

  *
  * long bpf_check_mtu(void *ctx, u32 ifindex, u32 *mtu_len, s32 len_diff, u64 flags)
  *	Description
- *		Check ctx packet size against exceeding MTU of net device (based
+ *		Check packet size against exceeding MTU of net device (based
  *		on *ifindex*).  This helper will likely be used in combination
  *		with helpers that adjust/change the packet size.
  *
  *		against the current net device.  This is practical if this isn't
  *		used prior to redirect.
  *
+ *		On input *mtu_len* must be a valid pointer, else verifier will
+ *		reject BPF program.  If the value *mtu_len* is initialized to
+ *		zero then the ctx packet size is use.  When value *mtu_len* is
+ *		provided as input this specify the L3 length that the MTU check
+ *		is done against. Remember XDP and TC length operate at L2, but
+ *		this value is L3 as this correlate to MTU and IP-header tot_len
+ *		values which are L3 (similar behavior as bpf_fib_lookup).
+ *
  *		The Linux kernel route table can configure MTUs on a more
  *		specific per route level, which is not provided by this helper.
  *		For route level MTU checks use the **bpf_fib_lookup**\ ()
  *
  *		On return *mtu_len* pointer contains the MTU value of the net
  *		device.  Remember the net device configured MTU is the L3 size,
- *		which is returned here and XDP and TX length operate at L2.
+ *		which is returned here and XDP and TC length operate at L2.
  *		Helper take this into account for you, but remember when using
- *		MTU value in your BPF-code.  On input *mtu_len* must be a valid
+ *		MTU value in your BPF-code.
- *		pointer and be initialized (to zero), else verifier will reject
- *		BPF program.
  *
  *	Return
  *		* 0 on success, and populate MTU value in *mtu_len* pointer.

include/uapi/linux/psample.h+1−4

 #define __UAPI_PSAMPLE_H
 enum {
-	/* sampled packet metadata */
 	PSAMPLE_ATTR_IIFINDEX,
 	PSAMPLE_ATTR_OIFINDEX,
 	PSAMPLE_ATTR_ORIGSIZE,
 	PSAMPLE_ATTR_GROUP_SEQ,
 	PSAMPLE_ATTR_SAMPLE_RATE,
 	PSAMPLE_ATTR_DATA,
-	PSAMPLE_ATTR_TUNNEL,
-	/* commands attributes */
 	PSAMPLE_ATTR_GROUP_REFCOUNT,
+	PSAMPLE_ATTR_TUNNEL,
 	__PSAMPLE_ATTR_MAX
 };

kernel/bpf/bpf_inode_storage.c+1−1

@@ -109,7 +109,7 @@ static void bpf_fd_inode_storage_lookup_elem(struct bpf_map map, void *key) · 108 unmodified lines
109	fd = (int )key;	109	fd = (int )key;
110	f = fget_raw(fd);	110	f = fget_raw(fd);
111	if (!f)	111	if (!f)
112	return NULL;	112	return ERR_PTR(-EBADF);
113		113
114	sdata = inode_storage_lookup(f->f_inode, map, true);	114	sdata = inode_storage_lookup(f->f_inode, map, true);
115	fput(f);	115	fput(f);

kernel/bpf/bpf_struct_ops.c+1−1

@@ -430,7 +430,7 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map map, void key, · 429 unmodified lines
430		430
431	tprogs[BPF_TRAMP_FENTRY].progs[0] = prog;	431	tprogs[BPF_TRAMP_FENTRY].progs[0] = prog;
432	tprogs[BPF_TRAMP_FENTRY].nr_progs = 1;	432	tprogs[BPF_TRAMP_FENTRY].nr_progs = 1;
433	err = arch_prepare_bpf_trampoline(image,	433	err = arch_prepare_bpf_trampoline(NULL, image,
434	st_map->image + PAGE_SIZE,	434	st_map->image + PAGE_SIZE,
435	&st_ops->func_models[i], 0,	435	&st_ops->func_models[i], 0,
436	tprogs, NULL);	436	tprogs, NULL);

kernel/bpf/core.c+2−2

@@ -827,7 +827,7 @@ static int __init bpf_jit_charge_init(void) · 826 unmodified lines
827	}	827	}
828	pure_initcall(bpf_jit_charge_init);	828	pure_initcall(bpf_jit_charge_init);
829		829
830	static int bpf_jit_charge_modmem(u32 pages)	830	int bpf_jit_charge_modmem(u32 pages)
831	{	831	{
832	if (atomic_long_add_return(pages, &bpf_jit_current) >	832	if (atomic_long_add_return(pages, &bpf_jit_current) >
833	(bpf_jit_limit >> PAGE_SHIFT)) {	833	(bpf_jit_limit >> PAGE_SHIFT)) {
@@ -840,7 +840,7 @@ static int bpf_jit_charge_modmem(u32 pages) · 6 unmodified lines
840	return 0;	840	return 0;
841	}	841	}
842		842
843	static void bpf_jit_uncharge_modmem(u32 pages)	843	void bpf_jit_uncharge_modmem(u32 pages)
844	{	844	{
845	atomic_long_sub(pages, &bpf_jit_current);	845	atomic_long_sub(pages, &bpf_jit_current);
846	}	846	}

kernel/bpf/preload/bpf_preload_kern.c+15−4

 			 &magic, sizeof(magic), &pos);
 	if (n != sizeof(magic))
 		return -EPIPE;
 	tgid = umd_ops.info.tgid;
-	wait_event(tgid->wait_pidfd, thread_group_exited(tgid));
+	if (tgid) {
-	umd_ops.info.tgid = NULL;
+		wait_event(tgid->wait_pidfd, thread_group_exited(tgid));
+		umd_cleanup_helper(&umd_ops.info);
+	}
 	return 0;
 }
 static void __exit fini_umd(void)
 {
+	struct pid *tgid;
 	bpf_preload_ops = NULL;
 	/* kill UMD in case it's still there due to earlier error */
-	kill_pid(umd_ops.info.tgid, SIGKILL, 1);
+	tgid = umd_ops.info.tgid;
-	umd_ops.info.tgid = NULL;
+	if (tgid) {
+		kill_pid(tgid, SIGKILL, 1);
+		wait_event(tgid->wait_pidfd, thread_group_exited(tgid));
+		umd_cleanup_helper(&umd_ops.info);
+	}
 	umd_unload_blob(&umd_ops.info);
 }
 late_initcall(load_umd);

kernel/bpf/syscall.c+5−0

 			err = PTR_ERR(btf);
 			goto free_map;
 		}
+		if (btf_is_kernel(btf)) {
+			btf_put(btf);
+			err = -EACCES;
+			goto free_map;
+		}
 		map->btf = btf;
 		if (attr->btf_value_type_id) {

kernel/bpf/trampoline.c+168−50

@@ -57,19 +57,10 @@ void bpf_image_ksym_del(struct bpf_ksym *ksym) · 56 unmodified lines
57	PAGE_SIZE, true, ksym->name);	57	PAGE_SIZE, true, ksym->name);
58	}	58	}
59		59
60	static void bpf_trampoline_ksym_add(struct bpf_trampoline *tr)
61	{
62	struct bpf_ksym *ksym = &tr->ksym;
63
64	snprintf(ksym->name, KSYM_NAME_LEN, "bpf_trampoline_%llu", tr->key);
65	bpf_image_ksym_add(tr->image, ksym);
66	}
67
68	static struct bpf_trampoline *bpf_trampoline_lookup(u64 key)	60	static struct bpf_trampoline *bpf_trampoline_lookup(u64 key)
69	{	61	{
70	struct bpf_trampoline *tr;	62	struct bpf_trampoline *tr;
71	struct hlist_head *head;	63	struct hlist_head *head;
72	void *image;
73	int i;	64	int i;
74		65
75	mutex_lock(&trampoline_mutex);	66	mutex_lock(&trampoline_mutex);
@@ -84,14 +75,6 @@ static struct bpf_trampoline *bpf_trampoline_lookup(u64 key) · 8 unmodified lines
84	if (!tr)	75	if (!tr)
85	goto out;	76	goto out;
86		77
87	/* is_root was checked earlier. No need for bpf_jit_charge_modmem() */
88	image = bpf_jit_alloc_exec_page();
89	if (!image) {
90	kfree(tr);
91	tr = NULL;
92	goto out;
93	}
94
95	tr->key = key;	78	tr->key = key;
96	INIT_HLIST_NODE(&tr->hlist);	79	INIT_HLIST_NODE(&tr->hlist);
97	hlist_add_head(&tr->hlist, head);	80	hlist_add_head(&tr->hlist, head);
@@ -99,9 +82,6 @@ static struct bpf_trampoline *bpf_trampoline_lookup(u64 key) · 1 unmodified line
99	mutex_init(&tr->mutex);	82	mutex_init(&tr->mutex);
100	for (i = 0; i < BPF_TRAMP_MAX; i++)	83	for (i = 0; i < BPF_TRAMP_MAX; i++)
101	INIT_HLIST_HEAD(&tr->progs_hlist[i]);	84	INIT_HLIST_HEAD(&tr->progs_hlist[i]);
102	tr->image = image;
103	INIT_LIST_HEAD_RCU(&tr->ksym.lnode);
104	bpf_trampoline_ksym_add(tr);
105	out:	85	out:
106	mutex_unlock(&trampoline_mutex);	86	mutex_unlock(&trampoline_mutex);
107	return tr;	87	return tr;
@@ -185,10 +165,142 @@ bpf_trampoline_get_progs(const struct bpf_trampoline tr, int total) · 77 unmodified lines
185	return tprogs;	165	return tprogs;
186	}	166	}
187		167
		168	static void __bpf_tramp_image_put_deferred(struct work_struct *work)
		169	{
		170	struct bpf_tramp_image *im;
		171
		172	im = container_of(work, struct bpf_tramp_image, work);
		173	bpf_image_ksym_del(&im->ksym);
		174	bpf_jit_free_exec(im->image);
		175	bpf_jit_uncharge_modmem(1);
		176	percpu_ref_exit(&im->pcref);
		177	kfree_rcu(im, rcu);
		178	}
		179
		180	/* callback, fexit step 3 or fentry step 2 */
		181	static void __bpf_tramp_image_put_rcu(struct rcu_head *rcu)
		182	{
		183	struct bpf_tramp_image *im;
		184
		185	im = container_of(rcu, struct bpf_tramp_image, rcu);
		186	INIT_WORK(&im->work, __bpf_tramp_image_put_deferred);
		187	schedule_work(&im->work);
		188	}
		189
		190	/* callback, fexit step 2. Called after percpu_ref_kill confirms. */
		191	static void __bpf_tramp_image_release(struct percpu_ref *pcref)
		192	{
		193	struct bpf_tramp_image *im;
		194
		195	im = container_of(pcref, struct bpf_tramp_image, pcref);
		196	call_rcu_tasks(&im->rcu, __bpf_tramp_image_put_rcu);
		197	}
		198
		199	/* callback, fexit or fentry step 1 */
		200	static void __bpf_tramp_image_put_rcu_tasks(struct rcu_head *rcu)
		201	{
		202	struct bpf_tramp_image *im;
		203
		204	im = container_of(rcu, struct bpf_tramp_image, rcu);
		205	if (im->ip_after_call)
		206	/* the case of fmod_ret/fexit trampoline and CONFIG_PREEMPTION=y */
		207	percpu_ref_kill(&im->pcref);
		208	else
		209	/* the case of fentry trampoline */
		210	call_rcu_tasks(&im->rcu, __bpf_tramp_image_put_rcu);
		211	}
		212
		213	static void bpf_tramp_image_put(struct bpf_tramp_image *im)
		214	{
		215	/* The trampoline image that calls original function is using:
		216	* rcu_read_lock_trace to protect sleepable bpf progs
		217	* rcu_read_lock to protect normal bpf progs
		218	* percpu_ref to protect trampoline itself
		219	* rcu tasks to protect trampoline asm not covered by percpu_ref
		220	* (which are few asm insns before __bpf_tramp_enter and
		221	* after __bpf_tramp_exit)
		222	*
		223	* The trampoline is unreachable before bpf_tramp_image_put().
		224	*
		225	* First, patch the trampoline to avoid calling into fexit progs.
		226	* The progs will be freed even if the original function is still
		227	* executing or sleeping.
		228	* In case of CONFIG_PREEMPT=y use call_rcu_tasks() to wait on
		229	* first few asm instructions to execute and call into
		230	* __bpf_tramp_enter->percpu_ref_get.
		231	* Then use percpu_ref_kill to wait for the trampoline and the original
		232	* function to finish.
		233	* Then use call_rcu_tasks() to make sure few asm insns in
		234	* the trampoline epilogue are done as well.
		235	*
		236	* In !PREEMPT case the task that got interrupted in the first asm
		237	* insns won't go through an RCU quiescent state which the
		238	* percpu_ref_kill will be waiting for. Hence the first
		239	* call_rcu_tasks() is not necessary.
		240	*/
		241	if (im->ip_after_call) {
		242	int err = bpf_arch_text_poke(im->ip_after_call, BPF_MOD_JUMP,
		243	NULL, im->ip_epilogue);
		244	WARN_ON(err);
		245	if (IS_ENABLED(CONFIG_PREEMPTION))
		246	call_rcu_tasks(&im->rcu, __bpf_tramp_image_put_rcu_tasks);
		247	else
		248	percpu_ref_kill(&im->pcref);
		249	return;
		250	}
		251
		252	/* The trampoline without fexit and fmod_ret progs doesn't call original
		253	* function and doesn't use percpu_ref.
		254	* Use call_rcu_tasks_trace() to wait for sleepable progs to finish.
		255	* Then use call_rcu_tasks() to wait for the rest of trampoline asm
		256	* and normal progs.
		257	*/
		258	call_rcu_tasks_trace(&im->rcu, __bpf_tramp_image_put_rcu_tasks);
		259	}
		260
		261	static struct bpf_tramp_image *bpf_tramp_image_alloc(u64 key, u32 idx)
		262	{
		263	struct bpf_tramp_image *im;
		264	struct bpf_ksym *ksym;
		265	void *image;
		266	int err = -ENOMEM;
		267
		268	im = kzalloc(sizeof(*im), GFP_KERNEL);
		269	if (!im)
		270	goto out;
		271
		272	err = bpf_jit_charge_modmem(1);
		273	if (err)
		274	goto out_free_im;
		275
		276	err = -ENOMEM;
		277	im->image = image = bpf_jit_alloc_exec_page();
		278	if (!image)
		279	goto out_uncharge;
		280
		281	err = percpu_ref_init(&im->pcref, __bpf_tramp_image_release, 0, GFP_KERNEL);
		282	if (err)
		283	goto out_free_image;
		284
		285	ksym = &im->ksym;
		286	INIT_LIST_HEAD_RCU(&ksym->lnode);
		287	snprintf(ksym->name, KSYM_NAME_LEN, "bpf_trampoline_%llu_%u", key, idx);
		288	bpf_image_ksym_add(image, ksym);
		289	return im;
		290
		291	out_free_image:
		292	bpf_jit_free_exec(im->image);
		293	out_uncharge:
		294	bpf_jit_uncharge_modmem(1);
		295	out_free_im:
		296	kfree(im);
		297	out:
		298	return ERR_PTR(err);
		299	}
		300
188	static int bpf_trampoline_update(struct bpf_trampoline *tr)	301	static int bpf_trampoline_update(struct bpf_trampoline *tr)
189	{	302	{
190	void old_image = tr->image + ((tr->selector + 1) & 1) PAGE_SIZE/2;	303	struct bpf_tramp_image *im;
191	void new_image = tr->image + (tr->selector & 1) PAGE_SIZE/2;
192	struct bpf_tramp_progs *tprogs;	304	struct bpf_tramp_progs *tprogs;
193	u32 flags = BPF_TRAMP_F_RESTORE_REGS;	305	u32 flags = BPF_TRAMP_F_RESTORE_REGS;
194	int err, total;	306	int err, total;
@@ -198,41 +310,42 @@ static int bpf_trampoline_update(struct bpf_trampoline *tr) · 3 unmodified lines
198	return PTR_ERR(tprogs);	310	return PTR_ERR(tprogs);
199		311
200	if (total == 0) {	312	if (total == 0) {
201	err = unregister_fentry(tr, old_image);	313	err = unregister_fentry(tr, tr->cur_image->image);
		314	bpf_tramp_image_put(tr->cur_image);
		315	tr->cur_image = NULL;
202	tr->selector = 0;	316	tr->selector = 0;
203	goto out;	317	goto out;
204	}	318	}
205		319
		320	im = bpf_tramp_image_alloc(tr->key, tr->selector);
		321	if (IS_ERR(im)) {
		322	err = PTR_ERR(im);
		323	goto out;
		324	}
		325
206	if (tprogs[BPF_TRAMP_FEXIT].nr_progs \|\|	326	if (tprogs[BPF_TRAMP_FEXIT].nr_progs \|\|
207	tprogs[BPF_TRAMP_MODIFY_RETURN].nr_progs)	327	tprogs[BPF_TRAMP_MODIFY_RETURN].nr_progs)
208	flags = BPF_TRAMP_F_CALL_ORIG \| BPF_TRAMP_F_SKIP_FRAME;	328	flags = BPF_TRAMP_F_CALL_ORIG \| BPF_TRAMP_F_SKIP_FRAME;
209		329
210	/* Though the second half of trampoline page is unused a task could be	330	err = arch_prepare_bpf_trampoline(im, im->image, im->image + PAGE_SIZE,
211	* preempted in the middle of the first half of trampoline and two
212	* updates to trampoline would change the code from underneath the
213	* preempted task. Hence wait for tasks to voluntarily schedule or go
214	* to userspace.
215	* The same trampoline can hold both sleepable and non-sleepable progs.
216	* synchronize_rcu_tasks_trace() is needed to make sure all sleepable
217	* programs finish executing.
218	* Wait for these two grace periods together.
219	*/
220	synchronize_rcu_mult(call_rcu_tasks, call_rcu_tasks_trace);
221
222	err = arch_prepare_bpf_trampoline(new_image, new_image + PAGE_SIZE / 2,
223	&tr->func.model, flags, tprogs,	331	&tr->func.model, flags, tprogs,
224	tr->func.addr);	332	tr->func.addr);
225	if (err < 0)	333	if (err < 0)
226	goto out;	334	goto out;
227		335
228	if (tr->selector)	336	WARN_ON(tr->cur_image && tr->selector == 0);
		337	WARN_ON(!tr->cur_image && tr->selector);
		338	if (tr->cur_image)
229	/* progs already running at this address */	339	/* progs already running at this address */
230	err = modify_fentry(tr, old_image, new_image);	340	err = modify_fentry(tr, tr->cur_image->image, im->image);
231	else	341	else
232	/* first time registering */	342	/* first time registering */
233	err = register_fentry(tr, new_image);	343	err = register_fentry(tr, im->image);
234	if (err)	344	if (err)
235	goto out;	345	goto out;
		346	if (tr->cur_image)
		347	bpf_tramp_image_put(tr->cur_image);
		348	tr->cur_image = im;
236	tr->selector++;	349	tr->selector++;
237	out:	350	out:
238	kfree(tprogs);	351	kfree(tprogs);
@@ -364,17 +477,12 @@ void bpf_trampoline_put(struct bpf_trampoline *tr) · 125 unmodified lines
364	goto out;	477	goto out;
365	if (WARN_ON_ONCE(!hlist_empty(&tr->progs_hlist[BPF_TRAMP_FEXIT])))	478	if (WARN_ON_ONCE(!hlist_empty(&tr->progs_hlist[BPF_TRAMP_FEXIT])))
366	goto out;	479	goto out;
367	bpf_image_ksym_del(&tr->ksym);	480	/* This code will be executed even when the last bpf_tramp_image
368	/* This code will be executed when all bpf progs (both sleepable and	481	* is alive. All progs are detached from the trampoline and the
369	* non-sleepable) went through	482	* trampoline image is patched with jmp into epilogue to skip
370	* bpf_prog_put()->call_rcu[_tasks_trace]()->bpf_prog_free_deferred().	483	* fexit progs. The fentry-only trampoline will be freed via
371	* Hence no need for another synchronize_rcu_tasks_trace() here,	484	* multiple rcu callbacks.
372	* but synchronize_rcu_tasks() is still needed, since trampoline
373	* may not have had any sleepable programs and we need to wait
374	* for tasks to get out of trampoline code before freeing it.
375	*/	485	*/
376	synchronize_rcu_tasks();
377	bpf_jit_free_exec(tr->image);
378	hlist_del(&tr->hlist);	486	hlist_del(&tr->hlist);
379	kfree(tr);	487	kfree(tr);
380	out:	488	out:
@@ -478,8 +586,18 @@ void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start) · 97 unmodified lines
478	rcu_read_unlock_trace();	586	rcu_read_unlock_trace();
479	}	587	}
480		588
		589	void notrace __bpf_tramp_enter(struct bpf_tramp_image *tr)
		590	{
		591	percpu_ref_get(&tr->pcref);
		592	}
		593
		594	void notrace __bpf_tramp_exit(struct bpf_tramp_image *tr)
		595	{
		596	percpu_ref_put(&tr->pcref);
		597	}
		598
481	int __weak	599	int __weak
482	arch_prepare_bpf_trampoline(void image, void image_end,	600	arch_prepare_bpf_trampoline(struct bpf_tramp_image tr, void image, void *image_end,
483	const struct btf_func_model *m, u32 flags,	601	const struct btf_func_model *m, u32 flags,
484	struct bpf_tramp_progs *tprogs,	602	struct bpf_tramp_progs *tprogs,
485	void *orig_call)	603	void *orig_call)

kernel/bpf/verifier.c+25−12

@@ -5861,10 +5861,14 @@ static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg, · 5860 unmodified lines
5861	{	5861	{
5862	bool mask_to_left = (opcode == BPF_ADD && off_is_neg) \|\|	5862	bool mask_to_left = (opcode == BPF_ADD && off_is_neg) \|\|
5863	(opcode == BPF_SUB && !off_is_neg);	5863	(opcode == BPF_SUB && !off_is_neg);
5864	u32 off;	5864	u32 off, max;
5865		5865
5866	switch (ptr_reg->type) {	5866	switch (ptr_reg->type) {
5867	case PTR_TO_STACK:	5867	case PTR_TO_STACK:
		5868	/* Offset 0 is out-of-bounds, but acceptable start for the
		5869	* left direction, see BPF_REG_FP.
		5870	*/
		5871	max = MAX_BPF_STACK + mask_to_left;
5868	/* Indirect variable offset stack access is prohibited in	5872	/* Indirect variable offset stack access is prohibited in
5869	* unprivileged mode so it's not handled here.	5873	* unprivileged mode so it's not handled here.
5870	*/	5874	*/
@@ -5872,16 +5876,17 @@ static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg, · 1 unmodified line
5872	if (mask_to_left)	5876	if (mask_to_left)
5873	*ptr_limit = MAX_BPF_STACK + off;	5877	*ptr_limit = MAX_BPF_STACK + off;
5874	else	5878	else
5875	*ptr_limit = -off;	5879	*ptr_limit = -off - 1;
5876	return 0;	5880	return *ptr_limit >= max ? -ERANGE : 0;
5877	case PTR_TO_MAP_VALUE:	5881	case PTR_TO_MAP_VALUE:
		5882	max = ptr_reg->map_ptr->value_size;
5878	if (mask_to_left) {	5883	if (mask_to_left) {
5879	*ptr_limit = ptr_reg->umax_value + ptr_reg->off;	5884	*ptr_limit = ptr_reg->umax_value + ptr_reg->off;
5880	} else {	5885	} else {
5881	off = ptr_reg->smin_value + ptr_reg->off;	5886	off = ptr_reg->smin_value + ptr_reg->off;
5882	*ptr_limit = ptr_reg->map_ptr->value_size - off;	5887	*ptr_limit = ptr_reg->map_ptr->value_size - off - 1;
5883	}	5888	}
5884	return 0;	5889	return *ptr_limit >= max ? -ERANGE : 0;
5885	default:	5890	default:
5886	return -EINVAL;	5891	return -EINVAL;
5887	}	5892	}
@@ -5934,6 +5939,7 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, · 46 unmodified lines
5934	u32 alu_state, alu_limit;	5939	u32 alu_state, alu_limit;
5935	struct bpf_reg_state tmp;	5940	struct bpf_reg_state tmp;
5936	bool ret;	5941	bool ret;
		5942	int err;
5937		5943
5938	if (can_skip_alu_sanitation(env, insn))	5944	if (can_skip_alu_sanitation(env, insn))
5939	return 0;	5945	return 0;
@@ -5949,10 +5955,13 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, · 9 unmodified lines
5949	alu_state \|= ptr_is_dst_reg ?	5955	alu_state \|= ptr_is_dst_reg ?
5950	BPF_ALU_SANITIZE_SRC : BPF_ALU_SANITIZE_DST;	5956	BPF_ALU_SANITIZE_SRC : BPF_ALU_SANITIZE_DST;
5951		5957
5952	if (retrieve_ptr_limit(ptr_reg, &alu_limit, opcode, off_is_neg))	5958	err = retrieve_ptr_limit(ptr_reg, &alu_limit, opcode, off_is_neg);
5953	return 0;	5959	if (err < 0)
5954	if (update_alu_sanitation_state(aux, alu_state, alu_limit))	5960	return err;
5955	return -EACCES;	5961
		5962	err = update_alu_sanitation_state(aux, alu_state, alu_limit);
		5963	if (err < 0)
		5964	return err;
5956	do_sim:	5965	do_sim:
5957	/* Simulate and find potential out-of-bounds access under	5966	/* Simulate and find potential out-of-bounds access under
5958	* speculative execution from truncation as a result of	5967	* speculative execution from truncation as a result of
@@ -6103,7 +6112,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, · 144 unmodified lines
6103	case BPF_ADD:	6112	case BPF_ADD:
6104	ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);	6113	ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
6105	if (ret < 0) {	6114	if (ret < 0) {
6106	verbose(env, "R%d tried to add from different maps or paths\n", dst);	6115	verbose(env, "R%d tried to add from different maps, paths, or prohibited types\n", dst);
6107	return ret;	6116	return ret;
6108	}	6117	}
6109	/* We can take a fixed offset as long as it doesn't overflow	6118	/* We can take a fixed offset as long as it doesn't overflow
@@ -6158,7 +6167,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, · 48 unmodified lines
6158	case BPF_SUB:	6167	case BPF_SUB:
6159	ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);	6168	ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
6160	if (ret < 0) {	6169	if (ret < 0) {
6161	verbose(env, "R%d tried to sub from different maps or paths\n", dst);	6170	verbose(env, "R%d tried to sub from different maps, paths, or prohibited types\n", dst);
6162	return ret;	6171	return ret;
6163	}	6172	}
6164	if (dst_reg == off_reg) {	6173	if (dst_reg == off_reg) {
@@ -9056,6 +9065,10 @@ static int check_btf_info(struct bpf_verifier_env *env, · 2891 unmodified lines
9056	btf = btf_get_by_fd(attr->prog_btf_fd);	9065	btf = btf_get_by_fd(attr->prog_btf_fd);
9057	if (IS_ERR(btf))	9066	if (IS_ERR(btf))
9058	return PTR_ERR(btf);	9067	return PTR_ERR(btf);
		9068	if (btf_is_kernel(btf)) {
		9069	btf_put(btf);
		9070	return -EACCES;
		9071	}
9059	env->prog->aux->btf = btf;	9072	env->prog->aux->btf = btf;
9060		9073
9061	err = check_btf_func(env, attr, uattr);	9074	err = check_btf_func(env, attr, uattr);
@@ -11660,7 +11673,7 @@ static int fixup_bpf_calls(struct bpf_verifier_env *env) · 2598 unmodified lines
11660	off_reg = issrc ? insn->src_reg : insn->dst_reg;	11673	off_reg = issrc ? insn->src_reg : insn->dst_reg;
11661	if (isneg)	11674	if (isneg)
11662	*patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1);	11675	*patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1);
11663	*patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit - 1);	11676	*patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit);
11664	*patch++ = BPF_ALU64_REG(BPF_SUB, BPF_REG_AX, off_reg);	11677	*patch++ = BPF_ALU64_REG(BPF_SUB, BPF_REG_AX, off_reg);
11665	*patch++ = BPF_ALU64_REG(BPF_OR, BPF_REG_AX, off_reg);	11678	*patch++ = BPF_ALU64_REG(BPF_OR, BPF_REG_AX, off_reg);
11666	*patch++ = BPF_ALU64_IMM(BPF_NEG, BPF_REG_AX, 0);	11679	*patch++ = BPF_ALU64_IMM(BPF_NEG, BPF_REG_AX, 0);

kernel/fork.c+8−8

 	p = dup_task_struct(current, node);
 	if (!p)
 		goto fork_out;
-	if (args->io_thread)
+	if (args->io_thread) {
+		/*
+		 * Mark us an IO worker, and block any signal that isn't
+		 * fatal or STOP
+		 */
 		p->flags |= PF_IO_WORKER;
+		siginitsetinv(&p->blocked, sigmask(SIGKILL)|sigmask(SIGSTOP));
+	}
 	/*
 	 * This _must_ happen before we call free_task(), i.e. before we jump
 		.stack_size	= (unsigned long)arg,
 		.io_thread	= 1,
 	};
-	struct task_struct *tsk;
-	tsk = copy_process(NULL, 0, node, &args);
+	return copy_process(NULL, 0, node, &args);
-	if (!IS_ERR(tsk)) {
-		sigfillset(&tsk->blocked);
-		sigdelsetmask(&tsk->blocked, sigmask(SIGKILL));
-	}
-	return tsk;
 }
 /*

kernel/freezer.c+1−1

@@ -134,7 +134,7 @@ bool freeze_task(struct task_struct *p) · 133 unmodified lines
134	return false;	134	return false;
135	}	135	}
136		136
137	if (!(p->flags & (PF_KTHREAD \| PF_IO_WORKER)))	137	if (!(p->flags & PF_KTHREAD))
138	fake_signal_wake_up(p);	138	fake_signal_wake_up(p);
139	else	139	else
140	wake_up_state(p, TASK_INTERRUPTIBLE);	140	wake_up_state(p, TASK_INTERRUPTIBLE);

kernel/gcov/clang.c+69−0

@@ -75,7 +75,9 @@ struct gcov_fn_info { · 74 unmodified lines
75		75
76	u32 num_counters;	76	u32 num_counters;
77	u64 *counters;	77	u64 *counters;
		78	#if CONFIG_CLANG_VERSION < 110000
78	const char *function_name;	79	const char *function_name;
		80	#endif
79	};	81	};
80		82
81	static struct gcov_info *current_info;	83	static struct gcov_info *current_info;
@@ -105,6 +107,7 @@ void llvm_gcov_init(llvm_gcov_callback writeout, llvm_gcov_callback flush) · 23 unmodified lines
105	}	107	}
106	EXPORT_SYMBOL(llvm_gcov_init);	108	EXPORT_SYMBOL(llvm_gcov_init);
107		109
		110	#if CONFIG_CLANG_VERSION < 110000
108	void llvm_gcda_start_file(const char *orig_filename, const char version[4],	111	void llvm_gcda_start_file(const char *orig_filename, const char version[4],
109	u32 checksum)	112	u32 checksum)
110	{	113	{
@@ -113,7 +116,17 @@ void llvm_gcda_start_file(const char *orig_filename, const char version[4], · 2 unmodified lines
113	current_info->checksum = checksum;	116	current_info->checksum = checksum;
114	}	117	}
115	EXPORT_SYMBOL(llvm_gcda_start_file);	118	EXPORT_SYMBOL(llvm_gcda_start_file);
		119	#else
		120	void llvm_gcda_start_file(const char *orig_filename, u32 version, u32 checksum)
		121	{
		122	current_info->filename = orig_filename;
		123	current_info->version = version;
		124	current_info->checksum = checksum;
		125	}
		126	EXPORT_SYMBOL(llvm_gcda_start_file);
		127	#endif
116		128
		129	#if CONFIG_CLANG_VERSION < 110000
117	void llvm_gcda_emit_function(u32 ident, const char *function_name,	130	void llvm_gcda_emit_function(u32 ident, const char *function_name,
118	u32 func_checksum, u8 use_extra_checksum, u32 cfg_checksum)	131	u32 func_checksum, u8 use_extra_checksum, u32 cfg_checksum)
119	{	132	{
@@ -133,6 +146,24 @@ void llvm_gcda_emit_function(u32 ident, const char *function_name, · 13 unmodified lines
133	list_add_tail(&info->head, &current_info->functions);	146	list_add_tail(&info->head, &current_info->functions);
134	}	147	}
135	EXPORT_SYMBOL(llvm_gcda_emit_function);	148	EXPORT_SYMBOL(llvm_gcda_emit_function);
		149	#else
		150	void llvm_gcda_emit_function(u32 ident, u32 func_checksum,
		151	u8 use_extra_checksum, u32 cfg_checksum)
		152	{
		153	struct gcov_fn_info info = kzalloc(sizeof(info), GFP_KERNEL);
		154
		155	if (!info)
		156	return;
		157
		158	INIT_LIST_HEAD(&info->head);
		159	info->ident = ident;
		160	info->checksum = func_checksum;
		161	info->use_extra_checksum = use_extra_checksum;
		162	info->cfg_checksum = cfg_checksum;
		163	list_add_tail(&info->head, &current_info->functions);
		164	}
		165	EXPORT_SYMBOL(llvm_gcda_emit_function);
		166	#endif
136		167
137	void llvm_gcda_emit_arcs(u32 num_counters, u64 *counters)	168	void llvm_gcda_emit_arcs(u32 num_counters, u64 *counters)
138	{	169	{
@@ -295,6 +326,7 @@ void gcov_info_add(struct gcov_info dst, struct gcov_info src) · 156 unmodified lines
295	}	326	}
296	}	327	}
297		328
		329	#if CONFIG_CLANG_VERSION < 110000
298	static struct gcov_fn_info gcov_fn_info_dup(struct gcov_fn_info fn)	330	static struct gcov_fn_info gcov_fn_info_dup(struct gcov_fn_info fn)
299	{	331	{
300	size_t cv_size; /* counter values size */	332	size_t cv_size; /* counter values size */
@@ -322,6 +354,28 @@ err_name: · 21 unmodified lines
322	kfree(fn_dup);	354	kfree(fn_dup);
323	return NULL;	355	return NULL;
324	}	356	}
		357	#else
		358	static struct gcov_fn_info gcov_fn_info_dup(struct gcov_fn_info fn)
		359	{
		360	size_t cv_size; /* counter values size */
		361	struct gcov_fn_info fn_dup = kmemdup(fn, sizeof(fn),
		362	GFP_KERNEL);
		363	if (!fn_dup)
		364	return NULL;
		365	INIT_LIST_HEAD(&fn_dup->head);
		366
		367	cv_size = fn->num_counters * sizeof(fn->counters[0]);
		368	fn_dup->counters = vmalloc(cv_size);
		369	if (!fn_dup->counters) {
		370	kfree(fn_dup);
		371	return NULL;
		372	}
		373
		374	memcpy(fn_dup->counters, fn->counters, cv_size);
		375
		376	return fn_dup;
		377	}
		378	#endif
325		379
326	/**	380	/**
327	* gcov_info_dup - duplicate profiling data set	381	* gcov_info_dup - duplicate profiling data set
@@ -362,6 +416,7 @@ err: · 34 unmodified lines
362	* gcov_info_free - release memory for profiling data set duplicate	416	* gcov_info_free - release memory for profiling data set duplicate
363	* @info: profiling data set duplicate to free	417	* @info: profiling data set duplicate to free
364	*/	418	*/
		419	#if CONFIG_CLANG_VERSION < 110000
365	void gcov_info_free(struct gcov_info *info)	420	void gcov_info_free(struct gcov_info *info)
366	{	421	{
367	struct gcov_fn_info fn, tmp;	422	struct gcov_fn_info fn, tmp;
@@ -375,6 +430,20 @@ void gcov_info_free(struct gcov_info *info) · 7 unmodified lines
375	kfree(info->filename);	430	kfree(info->filename);
376	kfree(info);	431	kfree(info);
377	}	432	}
		433	#else
		434	void gcov_info_free(struct gcov_info *info)
		435	{
		436	struct gcov_fn_info fn, tmp;
		437
		438	list_for_each_entry_safe(fn, tmp, &info->functions, head) {
		439	vfree(fn->counters);
		440	list_del(&fn->head);
		441	kfree(fn);
		442	}
		443	kfree(info->filename);
		444	kfree(info);
		445	}
		446	#endif
378		447
379	#define ITER_STRIDE PAGE_SIZE	448	#define ITER_STRIDE PAGE_SIZE
380		449

kernel/power/energy_model.c+1−1

@@ -98,7 +98,7 @@ static int __init em_debug_init(void) · 97 unmodified lines
98		98
99	return 0;	99	return 0;
100	}	100	}
101	core_initcall(em_debug_init);	101	fs_initcall(em_debug_init);
102	#else /* CONFIG_DEBUG_FS */	102	#else /* CONFIG_DEBUG_FS */
103	static void em_debug_create_pd(struct device *dev) {}	103	static void em_debug_create_pd(struct device *dev) {}
104	static void em_debug_remove_pd(struct device *dev) {}	104	static void em_debug_remove_pd(struct device *dev) {}

kernel/ptrace.c+1−1

@@ -375,7 +375,7 @@ static int ptrace_attach(struct task_struct *task, long request, · 374 unmodified lines
375	audit_ptrace(task);	375	audit_ptrace(task);
376		376
377	retval = -EPERM;	377	retval = -EPERM;
378	if (unlikely(task->flags & (PF_KTHREAD \| PF_IO_WORKER)))	378	if (unlikely(task->flags & PF_KTHREAD))
379	goto out;	379	goto out;
380	if (same_thread_group(task, current))	380	if (same_thread_group(task, current))
381	goto out;	381	goto out;

kernel/signal.c+12−8

@@ -91,7 +91,7 @@ static bool sig_task_ignored(struct task_struct *t, int sig, bool force) · 90 unmodified lines
91	return true;	91	return true;
92		92
93	/* Only allow kernel generated signals to this kthread */	93	/* Only allow kernel generated signals to this kthread */
94	if (unlikely((t->flags & (PF_KTHREAD \| PF_IO_WORKER)) &&	94	if (unlikely((t->flags & PF_KTHREAD) &&
95	(handler == SIG_KTHREAD_KERNEL) && !force))	95	(handler == SIG_KTHREAD_KERNEL) && !force))
96	return true;	96	return true;
97		97
@@ -288,8 +288,7 @@ bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask) · 190 unmodified lines
288	JOBCTL_STOP_SIGMASK \| JOBCTL_TRAPPING));	288	JOBCTL_STOP_SIGMASK \| JOBCTL_TRAPPING));
289	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));	289	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
290		290
291	if (unlikely(fatal_signal_pending(task) \|\|	291	if (unlikely(fatal_signal_pending(task) \|\| (task->flags & PF_EXITING)))
292	(task->flags & (PF_EXITING \| PF_IO_WORKER))))
293	return false;	292	return false;
294		293
295	if (mask & JOBCTL_STOP_SIGMASK)	294	if (mask & JOBCTL_STOP_SIGMASK)
@@ -834,9 +833,6 @@ static int check_kill_permission(int sig, struct kernel_siginfo *info, · 538 unmodified lines
834		833
835	if (!valid_signal(sig))	834	if (!valid_signal(sig))
836	return -EINVAL;	835	return -EINVAL;
837	/* PF_IO_WORKER threads don't take any signals */
838	if (t->flags & PF_IO_WORKER)
839	return -ESRCH;
840		836
841	if (!si_fromuser(info))	837	if (!si_fromuser(info))
842	return 0;	838	return 0;
@@ -1100,7 +1096,7 @@ static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struc · 257 unmodified lines
1100	/*	1096	/*
1101	* Skip useless siginfo allocation for SIGKILL and kernel threads.	1097	* Skip useless siginfo allocation for SIGKILL and kernel threads.
1102	*/	1098	*/
1103	if ((sig == SIGKILL) \|\| (t->flags & (PF_KTHREAD \| PF_IO_WORKER)))	1099	if ((sig == SIGKILL) \|\| (t->flags & PF_KTHREAD))
1104	goto out_set;	1100	goto out_set;
1105		1101
1106	/*	1102	/*
@@ -2771,6 +2767,14 @@ relock: · 1664 unmodified lines
2771	do_coredump(&ksig->info);	2767	do_coredump(&ksig->info);
2772	}	2768	}
2773		2769
		2770	/*
		2771	* PF_IO_WORKER threads will catch and exit on fatal signals
		2772	* themselves. They have cleanup that must be performed, so
		2773	* we cannot call do_exit() on their behalf.
		2774	*/
		2775	if (current->flags & PF_IO_WORKER)
		2776	goto out;
		2777
2774	/*	2778	/*
2775	* Death signals, no core dump.	2779	* Death signals, no core dump.
2776	*/	2780	*/
@@ -2778,7 +2782,7 @@ relock: · 1 unmodified line
2778	/* NOTREACHED */	2782	/* NOTREACHED */
2779	}	2783	}
2780	spin_unlock_irq(&sighand->siglock);	2784	spin_unlock_irq(&sighand->siglock);
2781		2785	out:
2782	ksig->sig = signr;	2786	ksig->sig = signr;
2783		2787
2784	if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))	2788	if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))

kernel/trace/ftrace.c+44−8

 	pg = start_pg;
 	while (pg) {
 		order = get_count_order(pg->size / ENTRIES_PER_PAGE);
-		free_pages((unsigned long)pg->records, order);
+		if (order >= 0)
+			free_pages((unsigned long)pg->records, order);
 		start_pg = pg->next;
 		kfree(pg);
 		pg = start_pg;
 	return NULL;
 }
+static struct ftrace_direct_func *ftrace_alloc_direct_func(unsigned long addr)
+{
+	struct ftrace_direct_func *direct;
+	direct = kmalloc(sizeof(*direct), GFP_KERNEL);
+	if (!direct)
+		return NULL;
+	direct->addr = addr;
+	direct->count = 0;
+	list_add_rcu(&direct->next, &ftrace_direct_funcs);
+	ftrace_direct_func_count++;
+	return direct;
+}
 /**
  * register_ftrace_direct - Call a custom trampoline directly
  * @ip: The address of the nop at the beginning of a function
 	direct = ftrace_find_direct_func(addr);
 	if (!direct) {
-		direct = kmalloc(sizeof(*direct), GFP_KERNEL);
+		direct = ftrace_alloc_direct_func(addr);
 		if (!direct) {
 			kfree(entry);
 			goto out_unlock;
 		}
-		direct->addr = addr;
-		direct->count = 0;
-		list_add_rcu(&direct->next, &ftrace_direct_funcs);
-		ftrace_direct_func_count++;
 	}
 	entry->ip = ip;
 int modify_ftrace_direct(unsigned long ip,
 			 unsigned long old_addr, unsigned long new_addr)
 {
+	struct ftrace_direct_func *direct, *new_direct = NULL;
 	struct ftrace_func_entry *entry;
 	struct dyn_ftrace *rec;
 	int ret = -ENODEV;
 	if (entry->direct != old_addr)
 		goto out_unlock;
+	direct = ftrace_find_direct_func(old_addr);
+	if (WARN_ON(!direct))
+		goto out_unlock;
+	if (direct->count > 1) {
+		ret = -ENOMEM;
+		new_direct = ftrace_alloc_direct_func(new_addr);
+		if (!new_direct)
+			goto out_unlock;
+		direct->count--;
+		new_direct->count++;
+	} else {
+		direct->addr = new_addr;
+	}
 	/*
 	 * If there's no other ftrace callback on the rec->ip location,
 	 * then it can be changed directly by the architecture.
 		ret = 0;
 	}
+	if (unlikely(ret && new_direct)) {
+		direct->count++;
+		list_del_rcu(&new_direct->next);
+		synchronize_rcu_tasks();
+		kfree(new_direct);
+		ftrace_direct_func_count--;
+	}
  out_unlock:
 	mutex_unlock(&ftrace_lock);
 	mutex_unlock(&direct_mutex);
 		clear_mod_from_hashes(pg);
 		order = get_count_order(pg->size / ENTRIES_PER_PAGE);
-		free_pages((unsigned long)pg->records, order);
+		if (order >= 0)
+			free_pages((unsigned long)pg->records, order);
 		tmp_page = pg->next;
 		kfree(pg);
 		ftrace_number_of_pages -= 1 << order;
 		if (!pg->index) {
 			*last_pg = pg->next;
 			order = get_count_order(pg->size / ENTRIES_PER_PAGE);
-			free_pages((unsigned long)pg->records, order);
+			if (order >= 0)
+				free_pages((unsigned long)pg->records, order);
 			ftrace_number_of_pages -= 1 << order;
 			ftrace_number_of_groups--;
 			kfree(pg);

kernel/trace/trace.c+2−1

@@ -2984,7 +2984,8 @@ static void __ftrace_trace_stack(struct trace_buffer *buffer, · 2983 unmodified lines
2984		2984
2985	size = nr_entries * sizeof(unsigned long);	2985	size = nr_entries * sizeof(unsigned long);
2986	event = __trace_buffer_lock_reserve(buffer, TRACE_STACK,	2986	event = __trace_buffer_lock_reserve(buffer, TRACE_STACK,
2987	sizeof(*entry) + size, trace_ctx);	2987	(sizeof(*entry) - sizeof(entry->caller)) + size,
		2988	trace_ctx);
2988	if (!event)	2989	if (!event)
2989	goto out;	2990	goto out;
2990	entry = ring_buffer_event_data(event);	2991	entry = ring_buffer_event_data(event);

kernel/usermode_driver.c+15−6

@@ -139,13 +139,22 @@ static void umd_cleanup(struct subprocess_info *info) · 138 unmodified lines
139	struct umd_info *umd_info = info->data;	139	struct umd_info *umd_info = info->data;
140		140
141	/* cleanup if umh_setup() was successful but exec failed */	141	/* cleanup if umh_setup() was successful but exec failed */
142	if (info->retval) {	142	if (info->retval)
143	fput(umd_info->pipe_to_umh);	143	umd_cleanup_helper(umd_info);
144	fput(umd_info->pipe_from_umh);	144	}
145	put_pid(umd_info->tgid);	145
146	umd_info->tgid = NULL;	146	/**
147	}	147	* umd_cleanup_helper - release the resources which were allocated in umd_setup
		148	* @info: information about usermode driver
		149	*/
		150	void umd_cleanup_helper(struct umd_info *info)
		151	{
		152	fput(info->pipe_to_umh);
		153	fput(info->pipe_from_umh);
		154	put_pid(info->tgid);
		155	info->tgid = NULL;
148	}	156	}
		157	EXPORT_SYMBOL_GPL(umd_cleanup_helper);
149		158
150	/**	159	/**
151	* fork_usermode_driver - fork a usermode driver	160	* fork_usermode_driver - fork a usermode driver

lib/math/div64.c+1−0

@@ -232,4 +232,5 @@ u64 mul_u64_u64_div_u64(u64 a, u64 b, u64 c) · 231 unmodified lines
232		232
233	return res + div64_u64(a * b, c);	233	return res + div64_u64(a * b, c);
234	}	234	}
		235	EXPORT_SYMBOL(mul_u64_u64_div_u64);
235	#endif	236	#endif

lib/test_xarray.c+14−12

 #ifdef CONFIG_XARRAY_MULTI
 static void check_split_1(struct xarray *xa, unsigned long index,
-							unsigned int order)
+				unsigned int order, unsigned int new_order)
 {
-	XA_STATE(xas, xa, index);
+	XA_STATE_ORDER(xas, xa, index, new_order);
-	void *entry;
+	unsigned int i;
-	unsigned int i = 0;
 	xa_store_order(xa, index, order, xa, GFP_KERNEL);
 	xas_split_alloc(&xas, xa, order, GFP_KERNEL);
 	xas_lock(&xas);
 	xas_split(&xas, xa, order);
+	for (i = 0; i < (1 << order); i += (1 << new_order))
+		__xa_store(xa, index + i, xa_mk_index(index + i), 0);
 	xas_unlock(&xas);
-	xa_for_each(xa, index, entry) {
+	for (i = 0; i < (1 << order); i++) {
-		XA_BUG_ON(xa, entry != xa);
+		unsigned int val = index + (i & ~((1 << new_order) - 1));
-		i++;
+		XA_BUG_ON(xa, xa_load(xa, index + i) != xa_mk_index(val));
 	}
-	XA_BUG_ON(xa, i != 1 << order);
 	xa_set_mark(xa, index, XA_MARK_0);
 	XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));
 static noinline void check_split(struct xarray *xa)
 {
-	unsigned int order;
+	unsigned int order, new_order;
 	XA_BUG_ON(xa, !xa_empty(xa));
 	for (order = 1; order < 2 * XA_CHUNK_SHIFT; order++) {
-		check_split_1(xa, 0, order);
+		for (new_order = 0; new_order < order; new_order++) {
-		check_split_1(xa, 1UL << order, order);
+			check_split_1(xa, 0, order, new_order);
-		check_split_1(xa, 3UL << order, order);
+			check_split_1(xa, 1UL << order, order, new_order);
+			check_split_1(xa, 3UL << order, order, new_order);
+		}
 	}
 }
 #else

lib/xarray.c+6−5

  * xas_split_alloc() - Allocate memory for splitting an entry.
  * @xas: XArray operation state.
  * @entry: New entry which will be stored in the array.
- * @order: New entry order.
+ * @order: Current entry order.
  * @gfp: Memory allocation flags.
  *
  * This function should be called before calling xas_split().
 	do {
 		unsigned int i;
-		void *sibling;
+		void *sibling = NULL;
 		struct xa_node *node;
 		node = kmem_cache_alloc(radix_tree_node_cachep, gfp);
 		for (i = 0; i < XA_CHUNK_SIZE; i++) {
 			if ((i & mask) == 0) {
 				RCU_INIT_POINTER(node->slots[i], entry);
-				sibling = xa_mk_sibling(0);
+				sibling = xa_mk_sibling(i);
 			} else {
 				RCU_INIT_POINTER(node->slots[i], sibling);
 			}
  * xas_split() - Split a multi-index entry into smaller entries.
  * @xas: XArray operation state.
  * @entry: New entry to store in the array.
- * @order: New entry order.
+ * @order: Current entry order.
  *
- * The value in the entry is copied to all the replacement entries.
+ * The size of the new entries is set in @xas.  The value in @entry is
+ * copied to all the replacement entries.
  *
  * Context: Any context.  The caller should hold the xa_lock.
  */

mm/highmem.c+2−2

@@ -618,7 +618,7 @@ void __kmap_local_sched_out(void) · 617 unmodified lines
618	int idx;	618	int idx;
619		619
620	/* With debug all even slots are unmapped and act as guard */	620	/* With debug all even slots are unmapped and act as guard */
621	if (IS_ENABLED(CONFIG_DEBUG_HIGHMEM) && !(i & 0x01)) {	621	if (IS_ENABLED(CONFIG_DEBUG_KMAP_LOCAL) && !(i & 0x01)) {
622	WARN_ON_ONCE(!pte_none(pteval));	622	WARN_ON_ONCE(!pte_none(pteval));
623	continue;	623	continue;
624	}	624	}
@@ -654,7 +654,7 @@ void __kmap_local_sched_in(void) · 29 unmodified lines
654	int idx;	654	int idx;
655		655
656	/* With debug all even slots are unmapped and act as guard */	656	/* With debug all even slots are unmapped and act as guard */
657	if (IS_ENABLED(CONFIG_DEBUG_HIGHMEM) && !(i & 0x01)) {	657	if (IS_ENABLED(CONFIG_DEBUG_KMAP_LOCAL) && !(i & 0x01)) {
658	WARN_ON_ONCE(!pte_none(pteval));	658	WARN_ON_ONCE(!pte_none(pteval));
659	continue;	659	continue;
660	}	660	}

mm/hugetlb.c+37−4

 		nrg->reservation_counter =
 			&h_cg->rsvd_hugepage[hstate_index(h)];
 		nrg->css = &h_cg->css;
+		/*
+		 * The caller will hold exactly one h_cg->css reference for the
+		 * whole contiguous reservation region. But this area might be
+		 * scattered when there are already some file_regions reside in
+		 * it. As a result, many file_regions may share only one css
+		 * reference. In order to ensure that one file_region must hold
+		 * exactly one h_cg->css reference, we should do css_get for
+		 * each file_region and leave the reference held by caller
+		 * untouched.
+		 */
+		css_get(&h_cg->css);
 		if (!resv->pages_per_hpage)
 			resv->pages_per_hpage = pages_per_huge_page(h);
 		/* pages_per_hpage should be the same for all entries in
 #endif
 }
+static void put_uncharge_info(struct file_region *rg)
+{
+#ifdef CONFIG_CGROUP_HUGETLB
+	if (rg->css)
+		css_put(rg->css);
+#endif
+}
 static bool has_same_uncharge_info(struct file_region *rg,
 				   struct file_region *org)
 {
 		prg->to = rg->to;
 		list_del(&rg->link);
+		put_uncharge_info(rg);
 		kfree(rg);
 		rg = prg;
 		nrg->from = rg->from;
 		list_del(&rg->link);
+		put_uncharge_info(rg);
 		kfree(rg);
 	}
 }
 			del += t - f;
 			hugetlb_cgroup_uncharge_file_region(
-				resv, rg, t - f);
+				resv, rg, t - f, false);
 			/* New entry for end of split region */
 			nrg->from = t;
 		if (f <= rg->from && t >= rg->to) { /* Remove entire region */
 			del += rg->to - rg->from;
 			hugetlb_cgroup_uncharge_file_region(resv, rg,
-							    rg->to - rg->from);
+							    rg->to - rg->from, true);
 			list_del(&rg->link);
 			kfree(rg);
 			continue;
 		if (f <= rg->from) {	/* Trim beginning of region */
 			hugetlb_cgroup_uncharge_file_region(resv, rg,
-							    t - rg->from);
+							    t - rg->from, false);
 			del += t - rg->from;
 			rg->from = t;
 		} else {		/* Trim end of region */
 			hugetlb_cgroup_uncharge_file_region(resv, rg,
-							    rg->to - f);
+							    rg->to - f, false);
 			del += rg->to - f;
 			rg->to = f;
 			 */
 			long rsv_adjust;
+			/*
+			 * hugetlb_cgroup_uncharge_cgroup_rsvd() will put the
+			 * reference to h_cg->css. See comment below for detail.
+			 */
 			hugetlb_cgroup_uncharge_cgroup_rsvd(
 				hstate_index(h),
 				(chg - add) * pages_per_huge_page(h), h_cg);
 			rsv_adjust = hugepage_subpool_put_pages(spool,
 								chg - add);
 			hugetlb_acct_memory(h, -rsv_adjust);
+		} else if (h_cg) {
+			/*
+			 * The file_regions will hold their own reference to
+			 * h_cg->css. So we should release the reference held
+			 * via hugetlb_cgroup_charge_cgroup_rsvd() when we are
+			 * done.
+			 */
+			hugetlb_cgroup_put_rsvd_cgroup(h_cg);
 		}
 	}
 	return true;

mm/hugetlb_cgroup.c+8−2

 void hugetlb_cgroup_uncharge_file_region(struct resv_map *resv,
 					 struct file_region *rg,
-					 unsigned long nr_pages)
+					 unsigned long nr_pages,
+					 bool region_del)
 {
 	if (hugetlb_cgroup_disabled() || !resv || !rg || !nr_pages)
 		return;
 	    !resv->reservation_counter) {
 		page_counter_uncharge(rg->reservation_counter,
 				      nr_pages * resv->pages_per_hpage);
-		css_put(rg->css);
+		/*
+		 * Only do css_put(rg->css) when we delete the entire region
+		 * because one file_region must hold exactly one css reference.
+		 */
+		if (region_del)
+			css_put(rg->css);
 	}
 }

mm/kfence/core.c+9−0

 #include <linux/debugfs.h>
 #include <linux/kcsan-checks.h>
 #include <linux/kfence.h>
+#include <linux/kmemleak.h>
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/memblock.h>
 		addr += 2 * PAGE_SIZE;
 	}
+	/*
+	 * The pool is live and will never be deallocated from this point on.
+	 * Remove the pool object from the kmemleak object tree, as it would
+	 * otherwise overlap with allocations returned by kfence_alloc(), which
+	 * are registered with kmemleak through the slab post-alloc hook.
+	 */
+	kmemleak_free(__kfence_pool);
 	return true;
 err:

mm/kmemleak.c+2−1

 #include <linux/atomic.h>
 #include <linux/kasan.h>
+#include <linux/kfence.h>
 #include <linux/kmemleak.h>
 #include <linux/memory_hotplug.h>
 	atomic_set(&object->use_count, 1);
 	object->flags = OBJECT_ALLOCATED;
 	object->pointer = ptr;
-	object->size = size;
+	object->size = kfence_ksize((void *)ptr) ?: size;
 	object->excess_ref = 0;
 	object->min_count = min_count;
 	object->count = 0;			/* white color initially */

mm/memory.c+1−1

@@ -166,7 +166,7 @@ static int __init init_zero_pfn(void) · 165 unmodified lines
166	zero_pfn = page_to_pfn(ZERO_PAGE(0));	166	zero_pfn = page_to_pfn(ZERO_PAGE(0));
167	return 0;	167	return 0;
168	}	168	}
169	core_initcall(init_zero_pfn);	169	early_initcall(init_zero_pfn);
170		170
171	void mm_trace_rss_stat(struct mm_struct *mm, int member, long count)	171	void mm_trace_rss_stat(struct mm_struct *mm, int member, long count)
172	{	172	{

mm/mmu_notifier.c+23−0

@@ -501,10 +501,33 @@ static int mn_hlist_invalidate_range_start( · 500 unmodified lines
501	"");	501	"");
502	WARN_ON(mmu_notifier_range_blockable(range) \|\|	502	WARN_ON(mmu_notifier_range_blockable(range) \|\|
503	_ret != -EAGAIN);	503	_ret != -EAGAIN);
		504	/*
		505	* We call all the notifiers on any EAGAIN,
		506	* there is no way for a notifier to know if
		507	* its start method failed, thus a start that
		508	* does EAGAIN can't also do end.
		509	*/
		510	WARN_ON(ops->invalidate_range_end);
504	ret = _ret;	511	ret = _ret;
505	}	512	}
506	}	513	}
507	}	514	}
		515
		516	if (ret) {
		517	/*
		518	* Must be non-blocking to get here. If there are multiple
		519	* notifiers and one or more failed start, any that succeeded
		520	* start are expecting their end to be called. Do so now.
		521	*/
		522	hlist_for_each_entry_rcu(subscription, &subscriptions->list,
		523	hlist, srcu_read_lock_held(&srcu)) {
		524	if (!subscription->ops->invalidate_range_end)
		525	continue;
		526
		527	subscription->ops->invalidate_range_end(subscription,
		528	range);
		529	}
		530	}
508	srcu_read_unlock(&srcu, id);	531	srcu_read_unlock(&srcu, id);
509		532
510	return ret;	533	return ret;

mm/page-writeback.c+16−0

@@ -2833,6 +2833,22 @@ void wait_on_page_writeback(struct page *page) · 2832 unmodified lines
2833	}	2833	}
2834	EXPORT_SYMBOL_GPL(wait_on_page_writeback);	2834	EXPORT_SYMBOL_GPL(wait_on_page_writeback);
2835		2835
		2836	/*
		2837	* Wait for a page to complete writeback. Returns -EINTR if we get a
		2838	* fatal signal while waiting.
		2839	*/
		2840	int wait_on_page_writeback_killable(struct page *page)
		2841	{
		2842	while (PageWriteback(page)) {
		2843	trace_wait_on_page_writeback(page, page_mapping(page));
		2844	if (wait_on_page_bit_killable(page, PG_writeback))
		2845	return -EINTR;
		2846	}
		2847
		2848	return 0;
		2849	}
		2850	EXPORT_SYMBOL_GPL(wait_on_page_writeback_killable);
		2851
2836	/**	2852	/**
2837	* wait_for_stable_page() - wait for writeback to finish, if necessary.	2853	* wait_for_stable_page() - wait for writeback to finish, if necessary.
2838	* @page: The page to wait on.	2854	* @page: The page to wait on.

mm/z3fold.c+15−1

@@ -1346,8 +1346,22 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries) · 1345 unmodified lines
1346	page = list_entry(pos, struct page, lru);	1346	page = list_entry(pos, struct page, lru);
1347		1347
1348	zhdr = page_address(page);	1348	zhdr = page_address(page);
1349	if (test_bit(PAGE_HEADLESS, &page->private))	1349	if (test_bit(PAGE_HEADLESS, &page->private)) {
		1350	/*
		1351	* For non-headless pages, we wait to do this
		1352	* until we have the page lock to avoid racing
		1353	* with __z3fold_alloc(). Headless pages don't
		1354	* have a lock (and __z3fold_alloc() will never
		1355	* see them), but we still need to test and set
		1356	* PAGE_CLAIMED to avoid racing with
		1357	* z3fold_free(), so just do it now before
		1358	* leaving the loop.
		1359	*/
		1360	if (test_and_set_bit(PAGE_CLAIMED, &page->private))
		1361	continue;
		1362
1350	break;	1363	break;
		1364	}
1351		1365
1352	if (kref_get_unless_zero(&zhdr->refcount) == 0) {	1366	if (kref_get_unless_zero(&zhdr->refcount) == 0) {
1353	zhdr = NULL;	1367	zhdr = NULL;

net/bridge/br_switchdev.c+2−0

@@ -128,6 +128,8 @@ br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb, int type) · 127 unmodified lines
128	{	128	{
129	if (!fdb->dst)	129	if (!fdb->dst)
130	return;	130	return;
		131	if (test_bit(BR_FDB_LOCAL, &fdb->flags))
		132	return;
131		133
132	switch (type) {	134	switch (type) {
133	case RTM_DELNEIGH:	135	case RTM_DELNEIGH:

net/can/isotp.c+8−10

 	nskb->dev = dev;
 	can_skb_set_owner(nskb, sk);
 	ncf = (struct canfd_frame *)nskb->data;
-	skb_put(nskb, so->ll.mtu);
+	skb_put_zero(nskb, so->ll.mtu);
 	/* create & send flow control reply */
 	ncf->can_id = so->txid;
 	if (ae)
 		ncf->data[0] = so->opt.ext_address;
-	if (so->ll.mtu == CANFD_MTU)
+	ncf->flags = so->ll.tx_flags;
-		ncf->flags = so->ll.tx_flags;
 	can_send_ret = can_send(nskb, 1);
 	if (can_send_ret)
 		can_skb_prv(skb)->skbcnt = 0;
 		cf = (struct canfd_frame *)skb->data;
-		skb_put(skb, so->ll.mtu);
+		skb_put_zero(skb, so->ll.mtu);
 		/* create consecutive frame */
 		isotp_fill_dataframe(cf, so, ae, 0);
 		so->tx.sn %= 16;
 		so->tx.bs++;
-		if (so->ll.mtu == CANFD_MTU)
+		cf->flags = so->ll.tx_flags;
-			cf->flags = so->ll.tx_flags;
 		skb->dev = dev;
 		can_skb_set_owner(skb, sk);
 	so->tx.idx = 0;
 	cf = (struct canfd_frame *)skb->data;
-	skb_put(skb, so->ll.mtu);
+	skb_put_zero(skb, so->ll.mtu);
 	/* check for single frame transmission depending on TX_DL */
 	if (size <= so->tx.ll_dl - SF_PCI_SZ4 - ae - off) {
 	}
 	/* send the first or only CAN frame */
-	if (so->ll.mtu == CANFD_MTU)
+	cf->flags = so->ll.tx_flags;
-		cf->flags = so->ll.tx_flags;
 	skb->dev = dev;
 	skb->sk = sk;
 			if (ll.mtu != CAN_MTU && ll.mtu != CANFD_MTU)
 				return -EINVAL;
-			if (ll.mtu == CAN_MTU && ll.tx_dl > CAN_MAX_DLEN)
+			if (ll.mtu == CAN_MTU &&
+			    (ll.tx_dl > CAN_MAX_DLEN || ll.tx_flags != 0))
 				return -EINVAL;
 			memcpy(&so->ll, &ll, sizeof(ll));

net/core/dev.c+31−2

 			return -ENOMEM;
 		for_each_netdev(net, d) {
+			struct netdev_name_node *name_node;
+			list_for_each_entry(name_node, &d->name_node->list, list) {
+				if (!sscanf(name_node->name, name, &i))
+					continue;
+				if (i < 0 || i >= max_netdevices)
+					continue;
+				/*  avoid cases where sscanf is not exact inverse of printf */
+				snprintf(buf, IFNAMSIZ, name, i);
+				if (!strncmp(buf, name_node->name, IFNAMSIZ))
+					set_bit(i, inuse);
+			}
 			if (!sscanf(d->name, name, &i))
 				continue;
 			if (i < 0 || i >= max_netdevices)
 		 */
 		thread = READ_ONCE(napi->thread);
 		if (thread) {
+			/* Avoid doing set_bit() if the thread is in
+			 * INTERRUPTIBLE state, cause napi_thread_wait()
+			 * makes sure to proceed with napi polling
+			 * if the thread is explicitly woken from here.
+			 */
+			if (READ_ONCE(thread->state) != TASK_INTERRUPTIBLE)
+				set_bit(NAPI_STATE_SCHED_THREADED, &napi->state);
 			wake_up_process(thread);
 			return;
 		}
 		WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED));
 		new = val & ~(NAPIF_STATE_MISSED | NAPIF_STATE_SCHED |
+			      NAPIF_STATE_SCHED_THREADED |
 			      NAPIF_STATE_PREFER_BUSY_POLL);
 		/* If STATE_MISSED was set, leave STATE_SCHED set,
 static int napi_thread_wait(struct napi_struct *napi)
 {
+	bool woken = false;
 	set_current_state(TASK_INTERRUPTIBLE);
 	while (!kthread_should_stop() && !napi_disable_pending(napi)) {
-		if (test_bit(NAPI_STATE_SCHED, &napi->state)) {
+		/* Testing SCHED_THREADED bit here to make sure the current
+		 * kthread owns this napi and could poll on this napi.
+		 * Testing SCHED bit is not enough because SCHED bit might be
+		 * set by some other busy poll thread or by napi_disable().
+		 */
+		if (test_bit(NAPI_STATE_SCHED_THREADED, &napi->state) || woken) {
 			WARN_ON(!list_empty(&napi->poll_list));
 			__set_current_state(TASK_RUNNING);
 			return 0;
 		}
 		schedule();
+		/* woken being true indicates this thread owns this napi. */
+		woken = true;
 		set_current_state(TASK_INTERRUPTIBLE);
 	}
 	__set_current_state(TASK_RUNNING);
 			continue;
 		/* Leave virtual devices for the generic cleanup */
-		if (dev->rtnl_link_ops)
+		if (dev->rtnl_link_ops && !dev->rtnl_link_ops->netns_refund)
 			continue;
 		/* Push remaining network devices to init_net */

net/core/drop_monitor.c+23−0

@@ -1053,6 +1053,20 @@ static int net_dm_hw_monitor_start(struct netlink_ext_ack *extack) · 1052 unmodified lines
1053	return 0;	1053	return 0;
1054		1054
1055	err_module_put:	1055	err_module_put:
		1056	for_each_possible_cpu(cpu) {
		1057	struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);
		1058	struct sk_buff *skb;
		1059
		1060	del_timer_sync(&hw_data->send_timer);
		1061	cancel_work_sync(&hw_data->dm_alert_work);
		1062	while ((skb = __skb_dequeue(&hw_data->drop_queue))) {
		1063	struct devlink_trap_metadata *hw_metadata;
		1064
		1065	hw_metadata = NET_DM_SKB_CB(skb)->hw_metadata;
		1066	net_dm_hw_metadata_free(hw_metadata);
		1067	consume_skb(skb);
		1068	}
		1069	}
1056	module_put(THIS_MODULE);	1070	module_put(THIS_MODULE);
1057	return rc;	1071	return rc;
1058	}	1072	}
@@ -1134,6 +1148,15 @@ static int net_dm_trace_on_set(struct netlink_ext_ack *extack) · 75 unmodified lines
1134	err_unregister_trace:	1148	err_unregister_trace:
1135	unregister_trace_kfree_skb(ops->kfree_skb_probe, NULL);	1149	unregister_trace_kfree_skb(ops->kfree_skb_probe, NULL);
1136	err_module_put:	1150	err_module_put:
		1151	for_each_possible_cpu(cpu) {
		1152	struct per_cpu_dm_data *data = &per_cpu(dm_cpu_data, cpu);
		1153	struct sk_buff *skb;
		1154
		1155	del_timer_sync(&data->send_timer);
		1156	cancel_work_sync(&data->dm_alert_work);
		1157	while ((skb = __skb_dequeue(&data->drop_queue)))
		1158	consume_skb(skb);
		1159	}
1137	module_put(THIS_MODULE);	1160	module_put(THIS_MODULE);
1138	return rc;	1161	return rc;
1139	}	1162	}

net/core/dst.c+42−17

@@ -237,37 +237,62 @@ void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old) · 236 unmodified lines
237	}	237	}
238	EXPORT_SYMBOL(__dst_destroy_metrics_generic);	238	EXPORT_SYMBOL(__dst_destroy_metrics_generic);
239		239
240	static struct dst_ops md_dst_ops = {	240	struct dst_entry dst_blackhole_check(struct dst_entry dst, u32 cookie)
241	.family = AF_UNSPEC,	241	{
242	};	242	return NULL;
		243	}
243		244
244	static int dst_md_discard_out(struct net net, struct sock sk, struct sk_buff *skb)	245	u32 dst_blackhole_cow_metrics(struct dst_entry dst, unsigned long old)
245	{	246	{
246	WARN_ONCE(1, "Attempting to call output on metadata dst\n");	247	return NULL;
247	kfree_skb(skb);
248	return 0;
249	}	248	}
250		249
251	static int dst_md_discard(struct sk_buff *skb)	250	struct neighbour dst_blackhole_neigh_lookup(const struct dst_entry dst,
		251	struct sk_buff *skb,
		252	const void *daddr)
252	{	253	{
253	WARN_ONCE(1, "Attempting to call input on metadata dst\n");	254	return NULL;
254	kfree_skb(skb);	255	}
255	return 0;	256
		257	void dst_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,
		258	struct sk_buff *skb, u32 mtu,
		259	bool confirm_neigh)
		260	{
		261	}
		262	EXPORT_SYMBOL_GPL(dst_blackhole_update_pmtu);
		263
		264	void dst_blackhole_redirect(struct dst_entry dst, struct sock sk,
		265	struct sk_buff *skb)
		266	{
		267	}
		268	EXPORT_SYMBOL_GPL(dst_blackhole_redirect);
		269
		270	unsigned int dst_blackhole_mtu(const struct dst_entry *dst)
		271	{
		272	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
		273
		274	return mtu ? : dst->dev->mtu;
256	}	275	}
		276	EXPORT_SYMBOL_GPL(dst_blackhole_mtu);
		277
		278	static struct dst_ops dst_blackhole_ops = {
		279	.family = AF_UNSPEC,
		280	.neigh_lookup = dst_blackhole_neigh_lookup,
		281	.check = dst_blackhole_check,
		282	.cow_metrics = dst_blackhole_cow_metrics,
		283	.update_pmtu = dst_blackhole_update_pmtu,
		284	.redirect = dst_blackhole_redirect,
		285	.mtu = dst_blackhole_mtu,
		286	};
257		287
258	static void __metadata_dst_init(struct metadata_dst *md_dst,	288	static void __metadata_dst_init(struct metadata_dst *md_dst,
259	enum metadata_type type, u8 optslen)	289	enum metadata_type type, u8 optslen)
260
261	{	290	{
262	struct dst_entry *dst;	291	struct dst_entry *dst;
263		292
264	dst = &md_dst->dst;	293	dst = &md_dst->dst;
265	dst_init(dst, &md_dst_ops, NULL, 1, DST_OBSOLETE_NONE,	294	dst_init(dst, &dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE,
266	DST_METADATA \| DST_NOCOUNT);	295	DST_METADATA \| DST_NOCOUNT);
267
268	dst->input = dst_md_discard;
269	dst->output = dst_md_discard_out;
270
271	memset(dst + 1, 0, sizeof(md_dst) + optslen - sizeof(dst));	296	memset(dst + 1, 0, sizeof(md_dst) + optslen - sizeof(dst));
272	md_dst->type = type;	297	md_dst->type = type;
273	}	298	}

net/core/filter.c+10−2

@@ -5658,7 +5658,7 @@ BPF_CALL_5(bpf_skb_check_mtu, struct sk_buff *, skb, · 5657 unmodified lines
5658	if (unlikely(flags & ~(BPF_MTU_CHK_SEGS)))	5658	if (unlikely(flags & ~(BPF_MTU_CHK_SEGS)))
5659	return -EINVAL;	5659	return -EINVAL;
5660		5660
5661	if (unlikely(flags & BPF_MTU_CHK_SEGS && len_diff))	5661	if (unlikely(flags & BPF_MTU_CHK_SEGS && (len_diff \|\| *mtu_len)))
5662	return -EINVAL;	5662	return -EINVAL;
5663		5663
5664	dev = __dev_via_ifindex(dev, ifindex);	5664	dev = __dev_via_ifindex(dev, ifindex);
@@ -5668,7 +5668,11 @@ BPF_CALL_5(bpf_skb_check_mtu, struct sk_buff *, skb, · 3 unmodified lines
5668	mtu = READ_ONCE(dev->mtu);	5668	mtu = READ_ONCE(dev->mtu);
5669		5669
5670	dev_len = mtu + dev->hard_header_len;	5670	dev_len = mtu + dev->hard_header_len;
5671	skb_len = skb->len + len_diff; /* minus result pass check */	5671
		5672	/* If set use mtu_len as input, L3 as iph->tot_len (like fib_lookup) /
		5673	skb_len = mtu_len ? mtu_len + dev->hard_header_len : skb->len;
		5674
		5675	skb_len += len_diff; /* minus result pass check */
5672	if (skb_len <= dev_len) {	5676	if (skb_len <= dev_len) {
5673	ret = BPF_MTU_CHK_RET_SUCCESS;	5677	ret = BPF_MTU_CHK_RET_SUCCESS;
5674	goto out;	5678	goto out;
@@ -5713,6 +5717,10 @@ BPF_CALL_5(bpf_xdp_check_mtu, struct xdp_buff *, xdp, · 38 unmodified lines
5713	/* Add L2-header as dev MTU is L3 size */	5717	/* Add L2-header as dev MTU is L3 size */
5714	dev_len = mtu + dev->hard_header_len;	5718	dev_len = mtu + dev->hard_header_len;
5715		5719
		5720	/* Use mtu_len as input, L3 as iph->tot_len (like fib_lookup) /
		5721	if (*mtu_len)
		5722	xdp_len = *mtu_len + dev->hard_header_len;
		5723
5716	xdp_len += len_diff; /* minus result pass check */	5724	xdp_len += len_diff; /* minus result pass check */
5717	if (xdp_len > dev_len)	5725	if (xdp_len > dev_len)
5718	ret = BPF_MTU_CHK_RET_FRAG_NEEDED;	5726	ret = BPF_MTU_CHK_RET_FRAG_NEEDED;

net/core/flow_dissector.c+1−1

@@ -176,7 +176,7 @@ void skb_flow_get_icmp_tci(const struct sk_buff *skb, · 175 unmodified lines
176	* avoid confusion with packets without such field	176	* avoid confusion with packets without such field
177	*/	177	*/
178	if (icmp_has_id(ih->type))	178	if (icmp_has_id(ih->type))
179	key_icmp->id = ih->un.echo.id ? : 1;	179	key_icmp->id = ih->un.echo.id ? ntohs(ih->un.echo.id) : 1;
180	else	180	else
181	key_icmp->id = 0;	181	key_icmp->id = 0;
182	}	182	}

net/core/sock.c+28−16

 	twsk_prot->twsk_slab = NULL;
 }
+static int tw_prot_init(const struct proto *prot)
+{
+	struct timewait_sock_ops *twsk_prot = prot->twsk_prot;
+	if (!twsk_prot)
+		return 0;
+	twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s",
+					      prot->name);
+	if (!twsk_prot->twsk_slab_name)
+		return -ENOMEM;
+	twsk_prot->twsk_slab =
+		kmem_cache_create(twsk_prot->twsk_slab_name,
+				  twsk_prot->twsk_obj_size, 0,
+				  SLAB_ACCOUNT | prot->slab_flags,
+				  NULL);
+	if (!twsk_prot->twsk_slab) {
+		pr_crit("%s: Can't create timewait sock SLAB cache!\n",
+			prot->name);
+		return -ENOMEM;
+	}
+	return 0;
+}
 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
 {
 	if (!rsk_prot)
 		if (req_prot_init(prot))
 			goto out_free_request_sock_slab;
-		if (prot->twsk_prot != NULL) {
+		if (tw_prot_init(prot))
-			prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
+			goto out_free_timewait_sock_slab;
-			if (prot->twsk_prot->twsk_slab_name == NULL)
-				goto out_free_request_sock_slab;
-			prot->twsk_prot->twsk_slab =
-				kmem_cache_create(prot->twsk_prot->twsk_slab_name,
-						  prot->twsk_prot->twsk_obj_size,
-						  0,
-						  SLAB_ACCOUNT |
-						  prot->slab_flags,
-						  NULL);
-			if (prot->twsk_prot->twsk_slab == NULL)
-				goto out_free_timewait_sock_slab;
-		}
 	}
 	mutex_lock(&proto_list_mutex);

net/dccp/ipv6.c+5−0

 	if (!ipv6_unicast_destination(skb))
 		return 0;	/* discard, don't send a reset here */
+	if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
+		__IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
+		return 0;
+	}
 	if (dccp_bad_service_code(sk, service)) {
 		dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
 		goto drop;

net/dsa/dsa2.c+7−4

 {
 	struct dsa_switch *ds = dp->ds;
 	struct dsa_switch_tree *dst = ds->dst;
+	const struct dsa_device_ops *tag_ops;
 	enum dsa_tag_protocol tag_protocol;
 	tag_protocol = dsa_get_tag_protocol(dp, master);
 		 * nothing to do here.
 		 */
 	} else {
-		dst->tag_ops = dsa_tag_driver_get(tag_protocol);
+		tag_ops = dsa_tag_driver_get(tag_protocol);
-		if (IS_ERR(dst->tag_ops)) {
+		if (IS_ERR(tag_ops)) {
-			if (PTR_ERR(dst->tag_ops) == -ENOPROTOOPT)
+			if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
 				return -EPROBE_DEFER;
 			dev_warn(ds->dev, "No tagger for this switch\n");
 			dp->master = NULL;
-			return PTR_ERR(dst->tag_ops);
+			return PTR_ERR(tag_ops);
 		}
+		dst->tag_ops = tag_ops;
 	}
 	dp->master = master;

net/ipv4/inet_connection_sock.c+5−2

 	return found;
 }
-void inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req)
+bool inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req)
 {
-	if (reqsk_queue_unlink(req)) {
+	bool unlinked = reqsk_queue_unlink(req);
+	if (unlinked) {
 		reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);
 		reqsk_put(req);
 	}
+	return unlinked;
 }
 EXPORT_SYMBOL(inet_csk_reqsk_queue_drop);

net/ipv4/ipconfig.c+8−6

  */
 static void __init ic_close_devs(void)
 {
-	struct net_device *selected_dev = ic_dev->dev;
+	struct net_device *selected_dev = ic_dev ? ic_dev->dev : NULL;
 	struct ic_device *d, *next;
 	struct net_device *dev;
 	next = ic_first_dev;
 	while ((d = next)) {
 		bool bring_down = (d != ic_dev);
-		struct net_device *lower_dev;
+		struct net_device *lower;
 		struct list_head *iter;
 		next = d->next;
 		dev = d->dev;
-		netdev_for_each_lower_dev(selected_dev, lower_dev, iter) {
+		if (selected_dev) {
-			if (dev == lower_dev) {
+			netdev_for_each_lower_dev(selected_dev, lower, iter) {
-				bring_down = false;
+				if (dev == lower) {
-				break;
+					bring_down = false;
+					break;
+				}
 			}
 		}
 		if (bring_down) {

net/ipv4/netfilter/arp_tables.c+8−8

@@ -203,7 +203,7 @@ unsigned int arpt_do_table(struct sk_buff *skb, · 202 unmodified lines
203		203
204	local_bh_disable();	204	local_bh_disable();
205	addend = xt_write_recseq_begin();	205	addend = xt_write_recseq_begin();
206	private = rcu_access_pointer(table->private);	206	private = READ_ONCE(table->private); /* Address dependency. */
207	cpu = smp_processor_id();	207	cpu = smp_processor_id();
208	table_base = private->entries;	208	table_base = private->entries;
209	jumpstack = (struct arpt_entry **)private->jumpstack[cpu];	209	jumpstack = (struct arpt_entry **)private->jumpstack[cpu];
@@ -649,7 +649,7 @@ static struct xt_counters alloc_counters(const struct xt_table table) · 439 unmodified lines
649	{	649	{
650	unsigned int countersize;	650	unsigned int countersize;
651	struct xt_counters *counters;	651	struct xt_counters *counters;
652	const struct xt_table_info *private = xt_table_get_private_protected(table);	652	const struct xt_table_info *private = table->private;
653		653
654	/* We need atomic snapshot of counters: rest doesn't change	654	/* We need atomic snapshot of counters: rest doesn't change
655	* (other than comefrom, which userspace doesn't care	655	* (other than comefrom, which userspace doesn't care
@@ -673,7 +673,7 @@ static int copy_entries_to_user(unsigned int total_size, · 17 unmodified lines
673	unsigned int off, num;	673	unsigned int off, num;
674	const struct arpt_entry *e;	674	const struct arpt_entry *e;
675	struct xt_counters *counters;	675	struct xt_counters *counters;
676	struct xt_table_info *private = xt_table_get_private_protected(table);	676	struct xt_table_info *private = table->private;
677	int ret = 0;	677	int ret = 0;
678	void *loc_cpu_entry;	678	void *loc_cpu_entry;
679		679
@@ -807,7 +807,7 @@ static int get_info(struct net net, void __user user, const int *len) · 127 unmodified lines
807	t = xt_request_find_table_lock(net, NFPROTO_ARP, name);	807	t = xt_request_find_table_lock(net, NFPROTO_ARP, name);
808	if (!IS_ERR(t)) {	808	if (!IS_ERR(t)) {
809	struct arpt_getinfo info;	809	struct arpt_getinfo info;
810	const struct xt_table_info *private = xt_table_get_private_protected(t);	810	const struct xt_table_info *private = t->private;
811	#ifdef CONFIG_COMPAT	811	#ifdef CONFIG_COMPAT
812	struct xt_table_info tmp;	812	struct xt_table_info tmp;
813		813
@@ -860,7 +860,7 @@ static int get_entries(struct net net, struct arpt_get_entries __user uptr, · 46 unmodified lines
860		860
861	t = xt_find_table_lock(net, NFPROTO_ARP, get.name);	861	t = xt_find_table_lock(net, NFPROTO_ARP, get.name);
862	if (!IS_ERR(t)) {	862	if (!IS_ERR(t)) {
863	const struct xt_table_info *private = xt_table_get_private_protected(t);	863	const struct xt_table_info *private = t->private;
864		864
865	if (get.size == private->size)	865	if (get.size == private->size)
866	ret = copy_entries_to_user(private->size,	866	ret = copy_entries_to_user(private->size,
@@ -1017,7 +1017,7 @@ static int do_add_counters(struct net *net, sockptr_t arg, unsigned int len) · 150 unmodified lines
1017	}	1017	}
1018		1018
1019	local_bh_disable();	1019	local_bh_disable();
1020	private = xt_table_get_private_protected(t);	1020	private = t->private;
1021	if (private->number != tmp.num_counters) {	1021	if (private->number != tmp.num_counters) {
1022	ret = -EINVAL;	1022	ret = -EINVAL;
1023	goto unlock_up_free;	1023	goto unlock_up_free;
@@ -1330,7 +1330,7 @@ static int compat_copy_entries_to_user(unsigned int total_size, · 306 unmodified lines
1330	void __user *userptr)	1330	void __user *userptr)
1331	{	1331	{
1332	struct xt_counters *counters;	1332	struct xt_counters *counters;
1333	const struct xt_table_info *private = xt_table_get_private_protected(table);	1333	const struct xt_table_info *private = table->private;
1334	void __user *pos;	1334	void __user *pos;
1335	unsigned int size;	1335	unsigned int size;
1336	int ret = 0;	1336	int ret = 0;
@@ -1379,7 +1379,7 @@ static int compat_get_entries(struct net *net, · 42 unmodified lines
1379	xt_compat_lock(NFPROTO_ARP);	1379	xt_compat_lock(NFPROTO_ARP);
1380	t = xt_find_table_lock(net, NFPROTO_ARP, get.name);	1380	t = xt_find_table_lock(net, NFPROTO_ARP, get.name);
1381	if (!IS_ERR(t)) {	1381	if (!IS_ERR(t)) {
1382	const struct xt_table_info *private = xt_table_get_private_protected(t);	1382	const struct xt_table_info *private = t->private;
1383	struct xt_table_info info;	1383	struct xt_table_info info;
1384		1384
1385	ret = compat_table_info(private, &info);	1385	ret = compat_table_info(private, &info);

net/ipv4/netfilter/ip_tables.c+8−8

@@ -258,7 +258,7 @@ ipt_do_table(struct sk_buff *skb, · 257 unmodified lines
258	WARN_ON(!(table->valid_hooks & (1 << hook)));	258	WARN_ON(!(table->valid_hooks & (1 << hook)));
259	local_bh_disable();	259	local_bh_disable();
260	addend = xt_write_recseq_begin();	260	addend = xt_write_recseq_begin();
261	private = rcu_access_pointer(table->private);	261	private = READ_ONCE(table->private); /* Address dependency. */
262	cpu = smp_processor_id();	262	cpu = smp_processor_id();
263	table_base = private->entries;	263	table_base = private->entries;
264	jumpstack = (struct ipt_entry **)private->jumpstack[cpu];	264	jumpstack = (struct ipt_entry **)private->jumpstack[cpu];
@@ -791,7 +791,7 @@ static struct xt_counters alloc_counters(const struct xt_table table) · 526 unmodified lines
791	{	791	{
792	unsigned int countersize;	792	unsigned int countersize;
793	struct xt_counters *counters;	793	struct xt_counters *counters;
794	const struct xt_table_info *private = xt_table_get_private_protected(table);	794	const struct xt_table_info *private = table->private;
795		795
796	/* We need atomic snapshot of counters: rest doesn't change	796	/* We need atomic snapshot of counters: rest doesn't change
797	(other than comefrom, which userspace doesn't care	797	(other than comefrom, which userspace doesn't care
@@ -815,7 +815,7 @@ copy_entries_to_user(unsigned int total_size, · 17 unmodified lines
815	unsigned int off, num;	815	unsigned int off, num;
816	const struct ipt_entry *e;	816	const struct ipt_entry *e;
817	struct xt_counters *counters;	817	struct xt_counters *counters;
818	const struct xt_table_info *private = xt_table_get_private_protected(table);	818	const struct xt_table_info *private = table->private;
819	int ret = 0;	819	int ret = 0;
820	const void *loc_cpu_entry;	820	const void *loc_cpu_entry;
821		821
@@ -964,7 +964,7 @@ static int get_info(struct net net, void __user user, const int *len) · 142 unmodified lines
964	t = xt_request_find_table_lock(net, AF_INET, name);	964	t = xt_request_find_table_lock(net, AF_INET, name);
965	if (!IS_ERR(t)) {	965	if (!IS_ERR(t)) {
966	struct ipt_getinfo info;	966	struct ipt_getinfo info;
967	const struct xt_table_info *private = xt_table_get_private_protected(t);	967	const struct xt_table_info *private = t->private;
968	#ifdef CONFIG_COMPAT	968	#ifdef CONFIG_COMPAT
969	struct xt_table_info tmp;	969	struct xt_table_info tmp;
970		970
@@ -1018,7 +1018,7 @@ get_entries(struct net net, struct ipt_get_entries __user uptr, · 47 unmodified lines
1018		1018
1019	t = xt_find_table_lock(net, AF_INET, get.name);	1019	t = xt_find_table_lock(net, AF_INET, get.name);
1020	if (!IS_ERR(t)) {	1020	if (!IS_ERR(t)) {
1021	const struct xt_table_info *private = xt_table_get_private_protected(t);	1021	const struct xt_table_info *private = t->private;
1022	if (get.size == private->size)	1022	if (get.size == private->size)
1023	ret = copy_entries_to_user(private->size,	1023	ret = copy_entries_to_user(private->size,
1024	t, uptr->entrytable);	1024	t, uptr->entrytable);
@@ -1173,7 +1173,7 @@ do_add_counters(struct net *net, sockptr_t arg, unsigned int len) · 148 unmodified lines
1173	}	1173	}
1174		1174
1175	local_bh_disable();	1175	local_bh_disable();
1176	private = xt_table_get_private_protected(t);	1176	private = t->private;
1177	if (private->number != tmp.num_counters) {	1177	if (private->number != tmp.num_counters) {
1178	ret = -EINVAL;	1178	ret = -EINVAL;
1179	goto unlock_up_free;	1179	goto unlock_up_free;
@@ -1543,7 +1543,7 @@ compat_copy_entries_to_user(unsigned int total_size, struct xt_table *table, · 363 unmodified lines
1543	void __user *userptr)	1543	void __user *userptr)
1544	{	1544	{
1545	struct xt_counters *counters;	1545	struct xt_counters *counters;
1546	const struct xt_table_info *private = xt_table_get_private_protected(table);	1546	const struct xt_table_info *private = table->private;
1547	void __user *pos;	1547	void __user *pos;
1548	unsigned int size;	1548	unsigned int size;
1549	int ret = 0;	1549	int ret = 0;
@@ -1589,7 +1589,7 @@ compat_get_entries(struct net net, struct compat_ipt_get_entries __user uptr, · 39 unmodified lines
1589	xt_compat_lock(AF_INET);	1589	xt_compat_lock(AF_INET);
1590	t = xt_find_table_lock(net, AF_INET, get.name);	1590	t = xt_find_table_lock(net, AF_INET, get.name);
1591	if (!IS_ERR(t)) {	1591	if (!IS_ERR(t)) {
1592	const struct xt_table_info *private = xt_table_get_private_protected(t);	1592	const struct xt_table_info *private = t->private;
1593	struct xt_table_info info;	1593	struct xt_table_info info;
1594	ret = compat_table_info(private, &info);	1594	ret = compat_table_info(private, &info);
1595	if (!ret && get.size == info.size)	1595	if (!ret && get.size == info.size)

net/ipv4/route.c+8−37

@@ -2687,44 +2687,15 @@ out: · 2686 unmodified lines
2687	return rth;	2687	return rth;
2688	}	2688	}
2689		2689
2690	static struct dst_entry ipv4_blackhole_dst_check(struct dst_entry dst, u32 cookie)
2691	{
2692	return NULL;
2693	}
2694
2695	static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2696	{
2697	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2698
2699	return mtu ? : dst->dev->mtu;
2700	}
2701
2702	static void ipv4_rt_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,
2703	struct sk_buff *skb, u32 mtu,
2704	bool confirm_neigh)
2705	{
2706	}
2707
2708	static void ipv4_rt_blackhole_redirect(struct dst_entry dst, struct sock sk,
2709	struct sk_buff *skb)
2710	{
2711	}
2712
2713	static u32 ipv4_rt_blackhole_cow_metrics(struct dst_entry dst,
2714	unsigned long old)
2715	{
2716	return NULL;
2717	}
2718
2719	static struct dst_ops ipv4_dst_blackhole_ops = {	2690	static struct dst_ops ipv4_dst_blackhole_ops = {
2720	.family = AF_INET,	2691	.family = AF_INET,
2721	.check = ipv4_blackhole_dst_check,	2692	.default_advmss = ipv4_default_advmss,
2722	.mtu = ipv4_blackhole_mtu,	2693	.neigh_lookup = ipv4_neigh_lookup,
2723	.default_advmss = ipv4_default_advmss,	2694	.check = dst_blackhole_check,
2724	.update_pmtu = ipv4_rt_blackhole_update_pmtu,	2695	.cow_metrics = dst_blackhole_cow_metrics,
2725	.redirect = ipv4_rt_blackhole_redirect,	2696	.update_pmtu = dst_blackhole_update_pmtu,
2726	.cow_metrics = ipv4_rt_blackhole_cow_metrics,	2697	.redirect = dst_blackhole_redirect,
2727	.neigh_lookup = ipv4_neigh_lookup,	2698	.mtu = dst_blackhole_mtu,
2728	};	2699	};
2729		2700
2730	struct dst_entry ipv4_blackhole_route(struct net net, struct dst_entry *dst_orig)	2701	struct dst_entry ipv4_blackhole_route(struct net net, struct dst_entry *dst_orig)

net/ipv4/tcp_minisocks.c+5−2

@@ -804,8 +804,11 @@ embryonic_reset: · 803 unmodified lines
804	tcp_reset(sk, skb);	804	tcp_reset(sk, skb);
805	}	805	}
806	if (!fastopen) {	806	if (!fastopen) {
807	inet_csk_reqsk_queue_drop(sk, req);	807	bool unlinked = inet_csk_reqsk_queue_drop(sk, req);
808	__NET_INC_STATS(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);	808
		809	if (unlinked)
		810	__NET_INC_STATS(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
		811	*req_stolen = !unlinked;
809	}	812	}
810	return NULL;	813	return NULL;
811	}	814	}

net/ipv6/ip6_fib.c+1−1

@@ -2486,7 +2486,7 @@ static int ipv6_route_native_seq_show(struct seq_file seq, void v) · 2485 unmodified lines
2486	const struct net_device *dev;	2486	const struct net_device *dev;
2487		2487
2488	if (rt->nh)	2488	if (rt->nh)
2489	fib6_nh = nexthop_fib6_nh(rt->nh);	2489	fib6_nh = nexthop_fib6_nh_bh(rt->nh);
2490		2490
2491	seq_printf(seq, "%pi6 %02x ", &rt->fib6_dst.addr, rt->fib6_dst.plen);	2491	seq_printf(seq, "%pi6 %02x ", &rt->fib6_dst.addr, rt->fib6_dst.plen);
2492		2492

net/ipv6/ip6_input.c+0−10

@@ -245,16 +245,6 @@ static struct sk_buff ip6_rcv_core(struct sk_buff skb, struct net_device *dev, · 244 unmodified lines
245	if (ipv6_addr_is_multicast(&hdr->saddr))	245	if (ipv6_addr_is_multicast(&hdr->saddr))
246	goto err;	246	goto err;
247		247
248	/* While RFC4291 is not explicit about v4mapped addresses
249	* in IPv6 headers, it seems clear linux dual-stack
250	* model can not deal properly with these.
251	* Security models could be fooled by ::ffff:127.0.0.1 for example.
252	*
253	* https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02
254	*/
255	if (ipv6_addr_v4mapped(&hdr->saddr))
256	goto err;
257
258	skb->transport_header = skb->network_header + sizeof(*hdr);	248	skb->transport_header = skb->network_header + sizeof(*hdr);
259	IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);	249	IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
260		250

net/ipv6/netfilter/ip6_tables.c+8−8

@@ -280,7 +280,7 @@ ip6t_do_table(struct sk_buff *skb, · 279 unmodified lines
280		280
281	local_bh_disable();	281	local_bh_disable();
282	addend = xt_write_recseq_begin();	282	addend = xt_write_recseq_begin();
283	private = rcu_access_pointer(table->private);	283	private = READ_ONCE(table->private); /* Address dependency. */
284	cpu = smp_processor_id();	284	cpu = smp_processor_id();
285	table_base = private->entries;	285	table_base = private->entries;
286	jumpstack = (struct ip6t_entry **)private->jumpstack[cpu];	286	jumpstack = (struct ip6t_entry **)private->jumpstack[cpu];
@@ -807,7 +807,7 @@ static struct xt_counters alloc_counters(const struct xt_table table) · 520 unmodified lines
807	{	807	{
808	unsigned int countersize;	808	unsigned int countersize;
809	struct xt_counters *counters;	809	struct xt_counters *counters;
810	const struct xt_table_info *private = xt_table_get_private_protected(table);	810	const struct xt_table_info *private = table->private;
811		811
812	/* We need atomic snapshot of counters: rest doesn't change	812	/* We need atomic snapshot of counters: rest doesn't change
813	(other than comefrom, which userspace doesn't care	813	(other than comefrom, which userspace doesn't care
@@ -831,7 +831,7 @@ copy_entries_to_user(unsigned int total_size, · 17 unmodified lines
831	unsigned int off, num;	831	unsigned int off, num;
832	const struct ip6t_entry *e;	832	const struct ip6t_entry *e;
833	struct xt_counters *counters;	833	struct xt_counters *counters;
834	const struct xt_table_info *private = xt_table_get_private_protected(table);	834	const struct xt_table_info *private = table->private;
835	int ret = 0;	835	int ret = 0;
836	const void *loc_cpu_entry;	836	const void *loc_cpu_entry;
837		837
@@ -980,7 +980,7 @@ static int get_info(struct net net, void __user user, const int *len) · 142 unmodified lines
980	t = xt_request_find_table_lock(net, AF_INET6, name);	980	t = xt_request_find_table_lock(net, AF_INET6, name);
981	if (!IS_ERR(t)) {	981	if (!IS_ERR(t)) {
982	struct ip6t_getinfo info;	982	struct ip6t_getinfo info;
983	const struct xt_table_info *private = xt_table_get_private_protected(t);	983	const struct xt_table_info *private = t->private;
984	#ifdef CONFIG_COMPAT	984	#ifdef CONFIG_COMPAT
985	struct xt_table_info tmp;	985	struct xt_table_info tmp;
986		986
@@ -1035,7 +1035,7 @@ get_entries(struct net net, struct ip6t_get_entries __user uptr, · 48 unmodified lines
1035		1035
1036	t = xt_find_table_lock(net, AF_INET6, get.name);	1036	t = xt_find_table_lock(net, AF_INET6, get.name);
1037	if (!IS_ERR(t)) {	1037	if (!IS_ERR(t)) {
1038	struct xt_table_info *private = xt_table_get_private_protected(t);	1038	struct xt_table_info *private = t->private;
1039	if (get.size == private->size)	1039	if (get.size == private->size)
1040	ret = copy_entries_to_user(private->size,	1040	ret = copy_entries_to_user(private->size,
1041	t, uptr->entrytable);	1041	t, uptr->entrytable);
@@ -1189,7 +1189,7 @@ do_add_counters(struct net *net, sockptr_t arg, unsigned int len) · 147 unmodified lines
1189	}	1189	}
1190		1190
1191	local_bh_disable();	1191	local_bh_disable();
1192	private = xt_table_get_private_protected(t);	1192	private = t->private;
1193	if (private->number != tmp.num_counters) {	1193	if (private->number != tmp.num_counters) {
1194	ret = -EINVAL;	1194	ret = -EINVAL;
1195	goto unlock_up_free;	1195	goto unlock_up_free;
@@ -1552,7 +1552,7 @@ compat_copy_entries_to_user(unsigned int total_size, struct xt_table *table, · 356 unmodified lines
1552	void __user *userptr)	1552	void __user *userptr)
1553	{	1553	{
1554	struct xt_counters *counters;	1554	struct xt_counters *counters;
1555	const struct xt_table_info *private = xt_table_get_private_protected(table);	1555	const struct xt_table_info *private = table->private;
1556	void __user *pos;	1556	void __user *pos;
1557	unsigned int size;	1557	unsigned int size;
1558	int ret = 0;	1558	int ret = 0;
@@ -1598,7 +1598,7 @@ compat_get_entries(struct net net, struct compat_ip6t_get_entries __user uptr, · 39 unmodified lines
1598	xt_compat_lock(AF_INET6);	1598	xt_compat_lock(AF_INET6);
1599	t = xt_find_table_lock(net, AF_INET6, get.name);	1599	t = xt_find_table_lock(net, AF_INET6, get.name);
1600	if (!IS_ERR(t)) {	1600	if (!IS_ERR(t)) {
1601	const struct xt_table_info *private = xt_table_get_private_protected(t);	1601	const struct xt_table_info *private = t->private;
1602	struct xt_table_info info;	1602	struct xt_table_info info;
1603	ret = compat_table_info(private, &info);	1603	ret = compat_table_info(private, &info);
1604	if (!ret && get.size == info.size)	1604	if (!ret && get.size == info.size)

net/ipv6/route.c+9−27

@@ -260,34 +260,16 @@ static struct dst_ops ip6_dst_ops_template = { · 259 unmodified lines
260	.confirm_neigh = ip6_confirm_neigh,	260	.confirm_neigh = ip6_confirm_neigh,
261	};	261	};
262		262
263	static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
264	{
265	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
266
267	return mtu ? : dst->dev->mtu;
268	}
269
270	static void ip6_rt_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,
271	struct sk_buff *skb, u32 mtu,
272	bool confirm_neigh)
273	{
274	}
275
276	static void ip6_rt_blackhole_redirect(struct dst_entry dst, struct sock sk,
277	struct sk_buff *skb)
278	{
279	}
280
281	static struct dst_ops ip6_dst_blackhole_ops = {	263	static struct dst_ops ip6_dst_blackhole_ops = {
282	.family = AF_INET6,	264	.family = AF_INET6,
283	.destroy = ip6_dst_destroy,	265	.default_advmss = ip6_default_advmss,
284	.check = ip6_dst_check,	266	.neigh_lookup = ip6_dst_neigh_lookup,
285	.mtu = ip6_blackhole_mtu,	267	.check = ip6_dst_check,
286	.default_advmss = ip6_default_advmss,	268	.destroy = ip6_dst_destroy,
287	.update_pmtu = ip6_rt_blackhole_update_pmtu,	269	.cow_metrics = dst_cow_metrics_generic,
288	.redirect = ip6_rt_blackhole_redirect,	270	.update_pmtu = dst_blackhole_update_pmtu,
289	.cow_metrics = dst_cow_metrics_generic,	271	.redirect = dst_blackhole_redirect,
290	.neigh_lookup = ip6_dst_neigh_lookup,	272	.mtu = dst_blackhole_mtu,
291	};	273	};
292		274
293	static const u32 ip6_template_metrics[RTAX_MAX] = {	275	static const u32 ip6_template_metrics[RTAX_MAX] = {

net/ipv6/tcp_ipv6.c+5−0

 	if (!ipv6_unicast_destination(skb))
 		goto drop;
+	if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
+		__IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
+		return 0;
+	}
 	return tcp_conn_request(&tcp6_request_sock_ops,
 				&tcp_request_sock_ipv6_ops, sk, skb);

net/mac80211/aead_api.c+3−2

 	struct aead_request *aead_req;
 	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
 	u8 *__aad;
+	int ret;
 	aead_req = kzalloc(reqsize + aad_len, GFP_ATOMIC);
 	if (!aead_req)
 	aead_request_set_crypt(aead_req, sg, sg, data_len, b_0);
 	aead_request_set_ad(aead_req, sg[0].length);
-	crypto_aead_encrypt(aead_req);
+	ret = crypto_aead_encrypt(aead_req);
 	kfree_sensitive(aead_req);
-	return 0;
+	return ret;
 }
 int aead_decrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad, size_t aad_len,

net/mac80211/aes_gmac.c+3−2

 	struct aead_request *aead_req;
 	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
 	const __le16 *fc;
+	int ret;
 	if (data_len < GMAC_MIC_LEN)
 		return -EINVAL;
 	aead_request_set_crypt(aead_req, sg, sg, 0, iv);
 	aead_request_set_ad(aead_req, GMAC_AAD_LEN + data_len);
-	crypto_aead_encrypt(aead_req);
+	ret = crypto_aead_encrypt(aead_req);
 	kfree_sensitive(aead_req);
-	return 0;
+	return ret;
 }
 struct crypto_aead *ieee80211_aes_gmac_key_setup(const u8 key[],

net/mac80211/cfg.c+2−2

@@ -2950,14 +2950,14 @@ static int ieee80211_set_bitrate_mask(struct wiphy *wiphy, · 2949 unmodified lines
2950	continue;	2950	continue;
2951		2951
2952	for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++) {	2952	for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++) {
2953	if (~sdata->rc_rateidx_mcs_mask[i][j]) {	2953	if (sdata->rc_rateidx_mcs_mask[i][j] != 0xff) {
2954	sdata->rc_has_mcs_mask[i] = true;	2954	sdata->rc_has_mcs_mask[i] = true;
2955	break;	2955	break;
2956	}	2956	}
2957	}	2957	}
2958		2958
2959	for (j = 0; j < NL80211_VHT_NSS_MAX; j++) {	2959	for (j = 0; j < NL80211_VHT_NSS_MAX; j++) {
2960	if (~sdata->rc_rateidx_vht_mcs_mask[i][j]) {	2960	if (sdata->rc_rateidx_vht_mcs_mask[i][j] != 0xffff) {
2961	sdata->rc_has_vht_mcs_mask[i] = true;	2961	sdata->rc_has_vht_mcs_mask[i] = true;
2962	break;	2962	break;
2963	}	2963	}

net/mac80211/ibss.c+2−0

@@ -1874,6 +1874,8 @@ int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata) · 1873 unmodified lines
1874		1874
1875	/* remove beacon */	1875	/* remove beacon */
1876	kfree(sdata->u.ibss.ie);	1876	kfree(sdata->u.ibss.ie);
		1877	sdata->u.ibss.ie = NULL;
		1878	sdata->u.ibss.ie_len = 0;
1877		1879
1878	/* on the next join, re-program HT parameters */	1880	/* on the next join, re-program HT parameters */
1879	memset(&ifibss->ht_capa, 0, sizeof(ifibss->ht_capa));	1881	memset(&ifibss->ht_capa, 0, sizeof(ifibss->ht_capa));

net/mac80211/main.c+12−1

@@ -973,8 +973,19 @@ int ieee80211_register_hw(struct ieee80211_hw *hw) · 972 unmodified lines
973	continue;	973	continue;
974		974
975	if (!dflt_chandef.chan) {	975	if (!dflt_chandef.chan) {
		976	/*
		977	* Assign the first enabled channel to dflt_chandef
		978	* from the list of channels
		979	*/
		980	for (i = 0; i < sband->n_channels; i++)
		981	if (!(sband->channels[i].flags &
		982	IEEE80211_CHAN_DISABLED))
		983	break;
		984	/* if none found then use the first anyway */
		985	if (i == sband->n_channels)
		986	i = 0;
976	cfg80211_chandef_create(&dflt_chandef,	987	cfg80211_chandef_create(&dflt_chandef,
977	&sband->channels[0],	988	&sband->channels[i],
978	NL80211_CHAN_NO_HT);	989	NL80211_CHAN_NO_HT);
979	/* init channel we're on */	990	/* init channel we're on */
980	if (!local->use_chanctx && !local->_oper_chandef.chan) {	991	if (!local->use_chanctx && !local->_oper_chandef.chan) {

net/mac80211/mlme.c+1−1

@@ -5071,7 +5071,7 @@ static int ieee80211_prep_channel(struct ieee80211_sub_if_data *sdata, · 5070 unmodified lines
5071	he_oper_ie = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_OPERATION,	5071	he_oper_ie = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_OPERATION,
5072	ies->data, ies->len);	5072	ies->data, ies->len);
5073	if (he_oper_ie &&	5073	if (he_oper_ie &&
5074	he_oper_ie[1] == ieee80211_he_oper_size(&he_oper_ie[3]))	5074	he_oper_ie[1] >= ieee80211_he_oper_size(&he_oper_ie[3]))
5075	he_oper = (void *)(he_oper_ie + 3);	5075	he_oper = (void *)(he_oper_ie + 3);
5076	else	5076	else
5077	he_oper = NULL;	5077	he_oper = NULL;

net/mac80211/rc80211_minstrel_ht.c+0−2

 static u16
 minstrel_ht_next_inc_rate(struct minstrel_ht_sta *mi, u32 fast_rate_dur)
 {
-	struct minstrel_mcs_group_data *mg;
 	u8 type = MINSTREL_SAMPLE_TYPE_INC;
 	int i, index = 0;
 	u8 group;
 	group = mi->sample[type].sample_group;
 	for (i = 0; i < ARRAY_SIZE(minstrel_mcs_groups); i++) {
 		group = (group + 1) % ARRAY_SIZE(minstrel_mcs_groups);
-		mg = &mi->groups[group];
 		index = minstrel_ht_group_min_rate_offset(mi, group,
 							  fast_rate_dur);

net/mac80211/util.c+1−1

@@ -968,7 +968,7 @@ static void ieee80211_parse_extension_element(u32 *crc, · 967 unmodified lines
968	break;	968	break;
969	case WLAN_EID_EXT_HE_OPERATION:	969	case WLAN_EID_EXT_HE_OPERATION:
970	if (len >= sizeof(*elems->he_operation) &&	970	if (len >= sizeof(*elems->he_operation) &&
971	len == ieee80211_he_oper_size(data) - 1) {	971	len >= ieee80211_he_oper_size(data) - 1) {
972	if (crc)	972	if (crc)
973	crc = crc32_be(crc, (void *)elem,	973	crc = crc32_be(crc, (void *)elem,
974	elem->datalen + 2);	974	elem->datalen + 2);

net/mptcp/options.c+14−10

 }
 static u64 add_addr_generate_hmac(u64 key1, u64 key2, u8 addr_id,
-				  struct in_addr *addr)
+				  struct in_addr *addr, u16 port)
 {
 	u8 hmac[SHA256_DIGEST_SIZE];
 	u8 msg[7];
 	msg[0] = addr_id;
 	memcpy(&msg[1], &addr->s_addr, 4);
-	msg[5] = 0;
+	msg[5] = port >> 8;
-	msg[6] = 0;
+	msg[6] = port & 0xFF;
 	mptcp_crypto_hmac_sha(key1, key2, msg, 7, hmac);
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 static u64 add_addr6_generate_hmac(u64 key1, u64 key2, u8 addr_id,
-				   struct in6_addr *addr)
+				   struct in6_addr *addr, u16 port)
 {
 	u8 hmac[SHA256_DIGEST_SIZE];
 	u8 msg[19];
 	msg[0] = addr_id;
 	memcpy(&msg[1], &addr->s6_addr, 16);
-	msg[17] = 0;
+	msg[17] = port >> 8;
-	msg[18] = 0;
+	msg[18] = port & 0xFF;
 	mptcp_crypto_hmac_sha(key1, key2, msg, 19, hmac);
 			opts->ahmac = add_addr_generate_hmac(msk->local_key,
 							     msk->remote_key,
 							     opts->addr_id,
-							     &opts->addr);
+							     &opts->addr,
+							     opts->port);
 		}
 	}
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 			opts->ahmac = add_addr6_generate_hmac(msk->local_key,
 							      msk->remote_key,
 							      opts->addr_id,
-							      &opts->addr6);
+							      &opts->addr6,
+							      opts->port);
 		}
 	}
 #endif
 	if (mp_opt->family == MPTCP_ADDR_IPVERSION_4)
 		hmac = add_addr_generate_hmac(msk->remote_key,
 					      msk->local_key,
-					      mp_opt->addr_id, &mp_opt->addr);
+					      mp_opt->addr_id, &mp_opt->addr,
+					      mp_opt->port);
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 	else
 		hmac = add_addr6_generate_hmac(msk->remote_key,
 					       msk->local_key,
-					       mp_opt->addr_id, &mp_opt->addr6);
+					       mp_opt->addr_id, &mp_opt->addr6,
+					       mp_opt->port);
 #endif
 	pr_debug("msk=%p, ahmac=%llu, mp_opt->ahmac=%llu\n",

net/mptcp/protocol.c+2−2

@@ -2968,7 +2968,7 @@ static void mptcp_release_cb(struct sock *sk) · 2967 unmodified lines
2968	for (;;) {	2968	for (;;) {
2969	flags = 0;	2969	flags = 0;
2970	if (test_and_clear_bit(MPTCP_PUSH_PENDING, &mptcp_sk(sk)->flags))	2970	if (test_and_clear_bit(MPTCP_PUSH_PENDING, &mptcp_sk(sk)->flags))
2971	flags \|= MPTCP_PUSH_PENDING;	2971	flags \|= BIT(MPTCP_PUSH_PENDING);
2972	if (!flags)	2972	if (!flags)
2973	break;	2973	break;
2974		2974
@@ -2981,7 +2981,7 @@ static void mptcp_release_cb(struct sock *sk) · 6 unmodified lines
2981	*/	2981	*/
2982		2982
2983	spin_unlock_bh(&sk->sk_lock.slock);	2983	spin_unlock_bh(&sk->sk_lock.slock);
2984	if (flags & MPTCP_PUSH_PENDING)	2984	if (flags & BIT(MPTCP_PUSH_PENDING))
2985	__mptcp_push_pending(sk, 0);	2985	__mptcp_push_pending(sk, 0);
2986		2986
2987	cond_resched();	2987	cond_resched();

net/mptcp/subflow.c+5−0

 	if (!ipv6_unicast_destination(skb))
 		goto drop;
+	if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
+		__IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
+		return 0;
+	}
 	return tcp_conn_request(&mptcp_subflow_request_sock_ops,
 				&subflow_request_sock_ipv6_ops, sk, skb);

net/netfilter/nf_conntrack_netlink.c+1−0

@@ -2962,6 +2962,7 @@ static int ctnetlink_exp_dump_mask(struct sk_buff *skb, · 2961 unmodified lines
2962	memset(&m, 0xFF, sizeof(m));	2962	memset(&m, 0xFF, sizeof(m));
2963	memcpy(&m.src.u3, &mask->src.u3, sizeof(m.src.u3));	2963	memcpy(&m.src.u3, &mask->src.u3, sizeof(m.src.u3));
2964	m.src.u.all = mask->src.u.all;	2964	m.src.u.all = mask->src.u.all;
		2965	m.src.l3num = tuple->src.l3num;
2965	m.dst.protonum = tuple->dst.protonum;	2966	m.dst.protonum = tuple->dst.protonum;
2966		2967
2967	nest_parms = nla_nest_start(skb, CTA_EXPECT_MASK);	2968	nest_parms = nla_nest_start(skb, CTA_EXPECT_MASK);

net/netfilter/nf_conntrack_proto_gre.c+0−3

@@ -218,9 +218,6 @@ int nf_conntrack_gre_packet(struct nf_conn *ct, · 217 unmodified lines
218	enum ip_conntrack_info ctinfo,	218	enum ip_conntrack_info ctinfo,
219	const struct nf_hook_state *state)	219	const struct nf_hook_state *state)
220	{	220	{
221	if (state->pf != NFPROTO_IPV4)
222	return -NF_ACCEPT;
223
224	if (!nf_ct_is_confirmed(ct)) {	221	if (!nf_ct_is_confirmed(ct)) {
225	unsigned int *timeouts = nf_ct_timeout_lookup(ct);	222	unsigned int *timeouts = nf_ct_timeout_lookup(ct);
226		223

net/netfilter/nf_flow_table_core.c+1−1

@@ -506,7 +506,7 @@ int nf_flow_table_init(struct nf_flowtable *flowtable) · 505 unmodified lines
506	{	506	{
507	int err;	507	int err;
508		508
509	INIT_DEFERRABLE_WORK(&flowtable->gc_work, nf_flow_offload_work_gc);	509	INIT_DELAYED_WORK(&flowtable->gc_work, nf_flow_offload_work_gc);
510	flow_block_init(&flowtable->flow_block);	510	flow_block_init(&flowtable->flow_block);
511	init_rwsem(&flowtable->flow_block_lock);	511	init_rwsem(&flowtable->flow_block_lock);
512		512

net/netfilter/nf_tables_api.c+21−1

 	list_for_each_entry(hook, hook_list, list) {
 		list_for_each_entry(ft, &table->flowtables, list) {
+			if (!nft_is_active_next(net, ft))
+				continue;
 			list_for_each_entry(hook2, &ft->hook_list, list) {
 				if (hook->ops.dev == hook2->ops.dev &&
 				    hook->ops.pf == hook2->ops.pf) {
 	struct nft_hook *hook, *next;
 	struct nft_trans *trans;
 	bool unregister = false;
+	u32 flags;
 	int err;
 	err = nft_flowtable_parse_hook(ctx, nla[NFTA_FLOWTABLE_HOOK],
 		}
 	}
+	if (nla[NFTA_FLOWTABLE_FLAGS]) {
+		flags = ntohl(nla_get_be32(nla[NFTA_FLOWTABLE_FLAGS]));
+		if (flags & ~NFT_FLOWTABLE_MASK)
+			return -EOPNOTSUPP;
+		if ((flowtable->data.flags & NFT_FLOWTABLE_HW_OFFLOAD) ^
+		    (flags & NFT_FLOWTABLE_HW_OFFLOAD))
+			return -EOPNOTSUPP;
+	} else {
+		flags = flowtable->data.flags;
+	}
 	err = nft_register_flowtable_net_hooks(ctx->net, ctx->table,
 					       &flowtable_hook.list, flowtable);
 	if (err < 0)
 		goto err_flowtable_update_hook;
 	}
+	nft_trans_flowtable_flags(trans) = flags;
 	nft_trans_flowtable(trans) = flowtable;
 	nft_trans_flowtable_update(trans) = true;
 	INIT_LIST_HEAD(&nft_trans_flowtable_hooks(trans));
 	if (nla[NFTA_FLOWTABLE_FLAGS]) {
 		flowtable->data.flags =
 			ntohl(nla_get_be32(nla[NFTA_FLOWTABLE_FLAGS]));
-		if (flowtable->data.flags & ~NFT_FLOWTABLE_MASK)
+		if (flowtable->data.flags & ~NFT_FLOWTABLE_MASK) {
+			err = -EOPNOTSUPP;
 			goto err3;
+		}
 	}
 	write_pnet(&flowtable->data.net, net);
 			break;
 		case NFT_MSG_NEWFLOWTABLE:
 			if (nft_trans_flowtable_update(trans)) {
+				nft_trans_flowtable(trans)->data.flags =
+					nft_trans_flowtable_flags(trans);
 				nf_tables_flowtable_notify(&trans->ctx,
 							   nft_trans_flowtable(trans),
 							   &nft_trans_flowtable_hooks(trans),

net/netfilter/x_tables.c+34−15

 }
 EXPORT_SYMBOL(xt_counters_alloc);
-struct xt_table_info
-*xt_table_get_private_protected(const struct xt_table *table)
-{
-	return rcu_dereference_protected(table->private,
-					 mutex_is_locked(&xt[table->af].mutex));
-}
-EXPORT_SYMBOL(xt_table_get_private_protected);
 struct xt_table_info *
 xt_replace_table(struct xt_table *table,
 	      unsigned int num_counters,
 	      int *error)
 {
 	struct xt_table_info *private;
+	unsigned int cpu;
 	int ret;
 	ret = xt_jumpstack_alloc(newinfo);
 	}
 	/* Do the substitution. */
-	private = xt_table_get_private_protected(table);
+	local_bh_disable();
+	private = table->private;
 	/* Check inside lock: is the old number correct? */
 	if (num_counters != private->number) {
 		pr_debug("num_counters != table->private->number (%u/%u)\n",
 			 num_counters, private->number);
+		local_bh_enable();
 		*error = -EAGAIN;
 		return NULL;
 	}
 	newinfo->initial_entries = private->initial_entries;
+	/*
+	 * Ensure contents of newinfo are visible before assigning to
+	 * private.
+	 */
+	smp_wmb();
+	table->private = newinfo;
+	/* make sure all cpus see new ->private value */
+	smp_mb();
-	rcu_assign_pointer(table->private, newinfo);
+	/*
-	synchronize_rcu();
+	 * Even though table entries have now been swapped, other CPU's
+	 * may still be using the old entries...
+	 */
+	local_bh_enable();
+	/* ... so wait for even xt_recseq on all cpus */
+	for_each_possible_cpu(cpu) {
+		seqcount_t *s = &per_cpu(xt_recseq, cpu);
+		u32 seq = raw_read_seqcount(s);
+		if (seq & 1) {
+			do {
+				cond_resched();
+				cpu_relax();
+			} while (seq == raw_read_seqcount(s));
+		}
+	}
 	audit_log_nfcfg(table->name, table->af, private->number,
 			!private->number ? AUDIT_XT_OP_REGISTER :
 	}
 	/* Simplifies replace_table code. */
-	rcu_assign_pointer(table->private, bootstrap);
+	table->private = bootstrap;
 	if (!xt_replace_table(table, 0, newinfo, &ret))
 		goto unlock;
-	private = xt_table_get_private_protected(table);
+	private = table->private;
 	pr_debug("table->private->number = %u\n", private->number);
 	/* save number of initial entries */
 	struct xt_table_info *private;
 	mutex_lock(&xt[table->af].mutex);
-	private = xt_table_get_private_protected(table);
+	private = table->private;
-	RCU_INIT_POINTER(table->private, NULL);
 	list_del(&table->list);
 	mutex_unlock(&xt[table->af].mutex);
 	audit_log_nfcfg(table->name, table->af, private->number,

net/openvswitch/conntrack.c+5−3

 /* This is called to initialize CT key fields possibly coming in from the local
  * stack.
  */
-void ovs_ct_fill_key(const struct sk_buff *skb, struct sw_flow_key *key)
+void ovs_ct_fill_key(const struct sk_buff *skb,
+		     struct sw_flow_key *key,
+		     bool post_ct)
 {
-	ovs_ct_update_key(skb, NULL, key, false, false);
+	ovs_ct_update_key(skb, NULL, key, post_ct, false);
 }
 int ovs_ct_put_key(const struct sw_flow_key *swkey,
 	if (skb_nfct(skb)) {
 		nf_conntrack_put(skb_nfct(skb));
 		nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
-		ovs_ct_fill_key(skb, key);
+		ovs_ct_fill_key(skb, key, false);
 	}
 	return 0;

net/openvswitch/conntrack.h+4−2

 		   const struct ovs_conntrack_info *);
 int ovs_ct_clear(struct sk_buff *skb, struct sw_flow_key *key);
-void ovs_ct_fill_key(const struct sk_buff *skb, struct sw_flow_key *key);
+void ovs_ct_fill_key(const struct sk_buff *skb, struct sw_flow_key *key,
+		     bool post_ct);
 int ovs_ct_put_key(const struct sw_flow_key *swkey,
 		   const struct sw_flow_key *output, struct sk_buff *skb);
 void ovs_ct_free_action(const struct nlattr *a);
 }
 static inline void ovs_ct_fill_key(const struct sk_buff *skb,
-				   struct sw_flow_key *key)
+				   struct sw_flow_key *key,
+				   bool post_ct)
 {
 	key->ct_state = 0;
 	key->ct_zone = 0;

net/openvswitch/flow.c+3−1

 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
 	struct tc_skb_ext *tc_ext;
 #endif
+	bool post_ct = false;
 	int res, err;
 	/* Extract metadata from packet. */
 		tc_ext = skb_ext_find(skb, TC_SKB_EXT);
 		key->recirc_id = tc_ext ? tc_ext->chain : 0;
 		OVS_CB(skb)->mru = tc_ext ? tc_ext->mru : 0;
+		post_ct = tc_ext ? tc_ext->post_ct : false;
 	} else {
 		key->recirc_id = 0;
 	}
 	err = key_extract(skb, key);
 	if (!err)
-		ovs_ct_fill_key(skb, key);   /* Must be after key_extract(). */
+		ovs_ct_fill_key(skb, key, post_ct);   /* Must be after key_extract(). */
 	return err;
 }

net/qrtr/qrtr.c+5−0

 	rc = copied;
 	if (addr) {
+		/* There is an anonymous 2-byte hole after sq_family,
+		 * make sure to clear it.
+		 */
+		memset(addr, 0, sizeof(*addr));
 		addr->sq_family = AF_QIPCRTR;
 		addr->sq_node = cb->src_node;
 		addr->sq_port = cb->src_port;

net/sched/act_ct.c+4−2

 	tcf_lastuse_update(&c->tcf_tm);
 	if (clear) {
+		qdisc_skb_cb(skb)->post_ct = false;
 		ct = nf_ct_get(skb, &ctinfo);
 		if (ct) {
 			nf_conntrack_put(&ct->ct_general);
 			nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
 		}
-		goto out;
+		goto out_clear;
 	}
 	family = tcf_ct_skb_nf_family(skb);
 	skb_push_rcsum(skb, nh_ofs);
 out:
-	tcf_action_update_bstats(&c->common, skb);
 	qdisc_skb_cb(skb)->post_ct = true;
+out_clear:
+	tcf_action_update_bstats(&c->common, skb);
 	if (defrag)
 		qdisc_skb_cb(skb)->pkt_len = skb->len;
 	return retval;

net/sched/cls_api.c+1−0

@@ -1629,6 +1629,7 @@ int tcf_classify_ingress(struct sk_buff *skb, · 1628 unmodified lines
1629	return TC_ACT_SHOT;	1629	return TC_ACT_SHOT;
1630	ext->chain = last_executed_chain;	1630	ext->chain = last_executed_chain;
1631	ext->mru = qdisc_skb_cb(skb)->mru;	1631	ext->mru = qdisc_skb_cb(skb)->mru;
		1632	ext->post_ct = qdisc_skb_cb(skb)->post_ct;
1632	}	1633	}
1633		1634
1634	return ret;	1635	return ret;

net/sched/cls_flower.c+1−1

@@ -1451,7 +1451,7 @@ static int fl_set_key_ct(struct nlattr **tb, · 1450 unmodified lines
1451	&mask->ct_state, TCA_FLOWER_KEY_CT_STATE_MASK,	1451	&mask->ct_state, TCA_FLOWER_KEY_CT_STATE_MASK,
1452	sizeof(key->ct_state));	1452	sizeof(key->ct_state));
1453		1453
1454	err = fl_validate_ct_state(mask->ct_state,	1454	err = fl_validate_ct_state(key->ct_state & mask->ct_state,
1455	tb[TCA_FLOWER_KEY_CT_STATE_MASK],	1455	tb[TCA_FLOWER_KEY_CT_STATE_MASK],
1456	extack);	1456	extack);
1457	if (err)	1457	if (err)

net/sched/sch_choke.c+4−3

@@ -345,6 +345,7 @@ static int choke_change(struct Qdisc sch, struct nlattr opt, · 344 unmodified lines
345	struct sk_buff **old = NULL;	345	struct sk_buff **old = NULL;
346	unsigned int mask;	346	unsigned int mask;
347	u32 max_P;	347	u32 max_P;
		348	u8 *stab;
348		349
349	if (opt == NULL)	350	if (opt == NULL)
350	return -EINVAL;	351	return -EINVAL;
@@ -361,8 +362,8 @@ static int choke_change(struct Qdisc sch, struct nlattr opt, · 10 unmodified lines
361	max_P = tb[TCA_CHOKE_MAX_P] ? nla_get_u32(tb[TCA_CHOKE_MAX_P]) : 0;	362	max_P = tb[TCA_CHOKE_MAX_P] ? nla_get_u32(tb[TCA_CHOKE_MAX_P]) : 0;
362		363
363	ctl = nla_data(tb[TCA_CHOKE_PARMS]);	364	ctl = nla_data(tb[TCA_CHOKE_PARMS]);
364		365	stab = nla_data(tb[TCA_CHOKE_STAB]);
365	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log))	366	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log, stab))
366	return -EINVAL;	367	return -EINVAL;
367		368
368	if (ctl->limit > CHOKE_MAX_QUEUE)	369	if (ctl->limit > CHOKE_MAX_QUEUE)
@@ -412,7 +413,7 @@ static int choke_change(struct Qdisc sch, struct nlattr opt, · 43 unmodified lines
412		413
413	red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,	414	red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,
414	ctl->Plog, ctl->Scell_log,	415	ctl->Plog, ctl->Scell_log,
415	nla_data(tb[TCA_CHOKE_STAB]),	416	stab,
416	max_P);	417	max_P);
417	red_set_vars(&q->vars);	418	red_set_vars(&q->vars);
418		419

net/sched/sch_gred.c+1−1

@@ -480,7 +480,7 @@ static inline int gred_change_vq(struct Qdisc *sch, int dp, · 479 unmodified lines
480	struct gred_sched *table = qdisc_priv(sch);	480	struct gred_sched *table = qdisc_priv(sch);
481	struct gred_sched_data *q = table->tab[dp];	481	struct gred_sched_data *q = table->tab[dp];
482		482
483	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log)) {	483	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log, stab)) {
484	NL_SET_ERR_MSG_MOD(extack, "invalid RED parameters");	484	NL_SET_ERR_MSG_MOD(extack, "invalid RED parameters");
485	return -EINVAL;	485	return -EINVAL;
486	}	486	}

net/sched/sch_htb.c+13−6

 	struct nlattr *tb[TCA_HTB_MAX + 1];
 	struct tc_htb_glob *gopt;
 	unsigned int ntx;
+	bool offload;
 	int err;
 	qdisc_watchdog_init(&q->watchdog, sch);
 	if (gopt->version != HTB_VER >> 16)
 		return -EINVAL;
-	q->offload = nla_get_flag(tb[TCA_HTB_OFFLOAD]);
+	offload = nla_get_flag(tb[TCA_HTB_OFFLOAD]);
-	if (q->offload) {
+	if (offload) {
 		if (sch->parent != TC_H_ROOT)
 			return -EOPNOTSUPP;
 		q->rate2quantum = 1;
 	q->defcls = gopt->defcls;
-	if (!q->offload)
+	if (!offload)
 		return 0;
 	for (ntx = 0; ntx < q->num_direct_qdiscs; ntx++) {
 	if (err)
 		goto err_free_qdiscs;
+	/* Defer this assignment, so that htb_destroy skips offload-related
+	 * parts (especially calling ndo_setup_tc) on errors.
+	 */
+	q->offload = true;
 	return 0;
 err_free_qdiscs:
-	/* TC_HTB_CREATE call failed, avoid any further calls to the driver. */
-	q->offload = false;
 	for (ntx = 0; ntx < q->num_direct_qdiscs && q->direct_qdiscs[ntx];
 	     ntx++)
 		qdisc_put(q->direct_qdiscs[ntx]);
 {
 	struct net_device *dev = qdisc_dev(sch);
 	struct tc_htb_qopt_offload offload_opt;
+	struct htb_sched *q = qdisc_priv(sch);
 	int err;
+	if (!q->offload)
+		return sch->dev_queue;
 	offload_opt = (struct tc_htb_qopt_offload) {
 		.command = TC_HTB_LEAF_QUERY_QUEUE,
 		.classid = TC_H_MIN(tcm->tcm_parent),

net/sched/sch_red.c+5−2

 	unsigned char flags;
 	int err;
 	u32 max_P;
+	u8 *stab;
 	if (tb[TCA_RED_PARMS] == NULL ||
 	    tb[TCA_RED_STAB] == NULL)
 	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
 	ctl = nla_data(tb[TCA_RED_PARMS]);
-	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log))
+	stab = nla_data(tb[TCA_RED_STAB]);
+	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog,
+			      ctl->Scell_log, stab))
 		return -EINVAL;
 	err = red_get_flags(ctl->flags, TC_RED_HISTORIC_FLAGS,
 	red_set_parms(&q->parms,
 		      ctl->qth_min, ctl->qth_max, ctl->Wlog,
 		      ctl->Plog, ctl->Scell_log,
-		      nla_data(tb[TCA_RED_STAB]),
+		      stab,
 		      max_P);
 	red_set_vars(&q->vars);

net/sched/sch_sfq.c+1−1

@@ -647,7 +647,7 @@ static int sfq_change(struct Qdisc sch, struct nlattr opt) · 646 unmodified lines
647	}	647	}
648		648
649	if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,	649	if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,
650	ctl_v1->Wlog, ctl_v1->Scell_log))	650	ctl_v1->Wlog, ctl_v1->Scell_log, NULL))
651	return -EINVAL;	651	return -EINVAL;
652	if (ctl_v1 && ctl_v1->qth_min) {	652	if (ctl_v1 && ctl_v1->qth_min) {
653	p = kmalloc(sizeof(*p), GFP_KERNEL);	653	p = kmalloc(sizeof(*p), GFP_KERNEL);

net/sctp/output.c+0−7

@@ -584,13 +584,6 @@ int sctp_packet_transmit(struct sctp_packet *packet, gfp_t gfp) · 583 unmodified lines
584	goto out;	584	goto out;
585	}	585	}
586		586
587	rcu_read_lock();
588	if (__sk_dst_get(sk) != tp->dst) {
589	dst_hold(tp->dst);
590	sk_setup_caps(sk, tp->dst);
591	}
592	rcu_read_unlock();
593
594	/* pack up chunks */	587	/* pack up chunks */
595	pkt_count = sctp_packet_pack(packet, head, gso, gfp);	588	pkt_count = sctp_packet_pack(packet, head, gso, gfp);
596	if (!pkt_count) {	589	if (!pkt_count) {

net/sctp/outqueue.c+7−0

 static void sctp_outq_flush_transports(struct sctp_flush_ctx *ctx)
 {
+	struct sock *sk = ctx->asoc->base.sk;
 	struct list_head *ltransport;
 	struct sctp_packet *packet;
 	struct sctp_transport *t;
 		t = list_entry(ltransport, struct sctp_transport, send_ready);
 		packet = &t->packet;
 		if (!sctp_packet_empty(packet)) {
+			rcu_read_lock();
+			if (t->dst && __sk_dst_get(sk) != t->dst) {
+				dst_hold(t->dst);
+				sk_setup_caps(sk, t->dst);
+			}
+			rcu_read_unlock();
 			error = sctp_packet_transmit(packet, ctx->gfp);
 			if (error < 0)
 				ctx->q->asoc->base.sk->sk_err = -error;

net/tipc/node.c+8−3

 #ifdef CONFIG_TIPC_CRYPTO
 static int tipc_nl_retrieve_key(struct nlattr **attrs,
-				struct tipc_aead_key **key)
+				struct tipc_aead_key **pkey)
 {
 	struct nlattr *attr = attrs[TIPC_NLA_NODE_KEY];
+	struct tipc_aead_key *key;
 	if (!attr)
 		return -ENODATA;
-	*key = (struct tipc_aead_key *)nla_data(attr);
+	if (nla_len(attr) < sizeof(*key))
-	if (nla_len(attr) < tipc_aead_key_size(*key))
+		return -EINVAL;
+	key = (struct tipc_aead_key *)nla_data(attr);
+	if (key->keylen > TIPC_AEAD_KEYLEN_MAX ||
+	    nla_len(attr) < tipc_aead_key_size(key))
 		return -EINVAL;
+	*pkey = key;
 	return 0;
 }

net/vmw_vsock/af_vsock.c+1−0

@@ -755,6 +755,7 @@ static struct sock __vsock_create(struct net net, · 754 unmodified lines
755	vsk->buffer_size = psk->buffer_size;	755	vsk->buffer_size = psk->buffer_size;
756	vsk->buffer_min_size = psk->buffer_min_size;	756	vsk->buffer_min_size = psk->buffer_min_size;
757	vsk->buffer_max_size = psk->buffer_max_size;	757	vsk->buffer_max_size = psk->buffer_max_size;
		758	security_sk_clone(parent, sk);
758	} else {	759	} else {
759	vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN);	760	vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN);
760	vsk->owner = get_current_cred();	761	vsk->owner = get_current_cred();

net/wireless/nl80211.c+8−4

 	struct wireless_dev *result = NULL;
 	bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
 	bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
-	u64 wdev_id;
+	u64 wdev_id = 0;
 	int wiphy_idx = -1;
 	int ifidx = -1;
 #define NL80211_FLAG_NEED_WDEV_UP	(NL80211_FLAG_NEED_WDEV |\
 					 NL80211_FLAG_CHECK_NETDEV_UP)
 #define NL80211_FLAG_CLEAR_SKB		0x20
+#define NL80211_FLAG_NO_WIPHY_MTX	0x40
 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
 			    struct genl_info *info)
 		info->user_ptr[0] = rdev;
 	}
-	if (rdev) {
+	if (rdev && !(ops->internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
 		wiphy_lock(&rdev->wiphy);
 		/* we keep the mutex locked until post_doit */
 		__release(&rdev->wiphy.mtx);
 		}
 	}
-	if (info->user_ptr[0]) {
+	if (info->user_ptr[0] &&
+	    !(ops->internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
 		struct cfg80211_registered_device *rdev = info->user_ptr[0];
 		/* we kept the mutex locked since pre_doit */
 		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
 		.doit = nl80211_wiphy_netns,
 		.flags = GENL_UNS_ADMIN_PERM,
-		.internal_flags = NL80211_FLAG_NEED_WIPHY,
+		.internal_flags = NL80211_FLAG_NEED_WIPHY |
+				  NL80211_FLAG_NEED_RTNL |
+				  NL80211_FLAG_NO_WIPHY_MTX,
 	},
 	{
 		.cmd = NL80211_CMD_GET_SURVEY,

scripts/module.lds.S+2−0

 	__patchable_function_entries : { *(__patchable_function_entries) }
+#ifdef CONFIG_LTO_CLANG
 	/*
 	 * With CONFIG_LTO_CLANG, LLD always enables -fdata-sections and
 	 * -ffunction-sections, which increases the size of the final module.
 	}
 	.text : { *(.text .text.[0-9a-zA-Z_]*) }
+#endif
 }
 /* bring in arch-specific sections */

security/integrity/iint.c+8−0

@@ -98,6 +98,14 @@ struct integrity_iint_cache integrity_inode_get(struct inode inode) · 97 unmodified lines
98	struct rb_node node, parent = NULL;	98	struct rb_node node, parent = NULL;
99	struct integrity_iint_cache iint, test_iint;	99	struct integrity_iint_cache iint, test_iint;
100		100
		101	/*
		102	* The integrity's "iint_cache" is initialized at security_init(),
		103	* unless it is not included in the ordered list of LSMs enabled
		104	* on the boot command line.
		105	*/
		106	if (!iint_cache)
		107	panic("%s: lsm=integrity required.\n", __func__);
		108
101	iint = integrity_iint_find(inode);	109	iint = integrity_iint_find(inode);
102	if (iint)	110	if (iint)
103	return iint;	111	return iint;

security/selinux/include/security.h+11−4

 	return READ_ONCE(state->policycap[POLICYDB_CAPABILITY_GENFS_SECLABEL_SYMLINKS]);
 }
+struct selinux_policy_convert_data;
+struct selinux_load_state {
+	struct selinux_policy *policy;
+	struct selinux_policy_convert_data *convert_data;
+};
 int security_mls_enabled(struct selinux_state *state);
 int security_load_policy(struct selinux_state *state,
-			void *data, size_t len,
+			 void *data, size_t len,
-			struct selinux_policy **newpolicyp);
+			 struct selinux_load_state *load_state);
 void selinux_policy_commit(struct selinux_state *state,
-			struct selinux_policy *newpolicy);
+			   struct selinux_load_state *load_state);
 void selinux_policy_cancel(struct selinux_state *state,
-			struct selinux_policy *policy);
+			   struct selinux_load_state *load_state);
 int security_read_policy(struct selinux_state *state,
 			 void **data, size_t *len);
 int security_read_state_kernel(struct selinux_state *state,

security/selinux/selinuxfs.c+9−13

 	ret = sel_make_bools(newpolicy, tmp_bool_dir, &tmp_bool_num,
 			     &tmp_bool_names, &tmp_bool_values);
-	if (ret) {
+	if (ret)
-		pr_err("SELinux: failed to load policy booleans\n");
 		goto out;
-	}
 	ret = sel_make_classes(newpolicy, tmp_class_dir,
 			       &fsi->last_class_ino);
-	if (ret) {
+	if (ret)
-		pr_err("SELinux: failed to load policy classes\n");
 		goto out;
-	}
 	/* booleans */
 	old_dentry = fsi->bool_dir;
 {
 	struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
-	struct selinux_policy *newpolicy;
+	struct selinux_load_state load_state;
 	ssize_t length;
 	void *data = NULL;
 	if (copy_from_user(data, buf, count) != 0)
 		goto out;
-	length = security_load_policy(fsi->state, data, count, &newpolicy);
+	length = security_load_policy(fsi->state, data, count, &load_state);
 	if (length) {
 		pr_warn_ratelimited("SELinux: failed to load policy\n");
 		goto out;
 	}
-	length = sel_make_policy_nodes(fsi, newpolicy);
+	length = sel_make_policy_nodes(fsi, load_state.policy);
 	if (length) {
-		selinux_policy_cancel(fsi->state, newpolicy);
+		pr_warn_ratelimited("SELinux: failed to initialize selinuxfs\n");
-		goto out1;
+		selinux_policy_cancel(fsi->state, &load_state);
+		goto out;
 	}
-	selinux_policy_commit(fsi->state, newpolicy);
+	selinux_policy_commit(fsi->state, &load_state);
 	length = count;
-out1:
 	audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
 		"auid=%u ses=%u lsm=selinux res=1",
 		from_kuid(&init_user_ns, audit_get_loginuid(current)),

security/selinux/ss/services.c+39−24

 #include "policycap_names.h"
 #include "ima.h"
+struct convert_context_args {
+	struct selinux_state *state;
+	struct policydb *oldp;
+	struct policydb *newp;
+};
+struct selinux_policy_convert_data {
+	struct convert_context_args args;
+	struct sidtab_convert_params sidtab_params;
+};
 /* Forward declaration. */
 static int context_struct_to_string(struct policydb *policydb,
 				    struct context *context,
 	return 0;
 }
-struct convert_context_args {
-	struct selinux_state *state;
-	struct policydb *oldp;
-	struct policydb *newp;
-};
 /*
  * Convert the values in the security context
  * structure `oldc' from the values specified
 }
 void selinux_policy_cancel(struct selinux_state *state,
-			struct selinux_policy *policy)
+			   struct selinux_load_state *load_state)
 {
 	struct selinux_policy *oldpolicy;
 					lockdep_is_held(&state->policy_mutex));
 	sidtab_cancel_convert(oldpolicy->sidtab);
-	selinux_policy_free(policy);
+	selinux_policy_free(load_state->policy);
+	kfree(load_state->convert_data);
 }
 static void selinux_notify_policy_change(struct selinux_state *state,
 }
 void selinux_policy_commit(struct selinux_state *state,
-			struct selinux_policy *newpolicy)
+			   struct selinux_load_state *load_state)
 {
-	struct selinux_policy *oldpolicy;
+	struct selinux_policy *oldpolicy, *newpolicy = load_state->policy;
 	u32 seqno;
 	oldpolicy = rcu_dereference_protected(state->policy,
 	/* Free the old policy */
 	synchronize_rcu();
 	selinux_policy_free(oldpolicy);
+	kfree(load_state->convert_data);
 	/* Notify others of the policy change */
 	selinux_notify_policy_change(state, seqno);
  * loading the new policy.
  */
 int security_load_policy(struct selinux_state *state, void *data, size_t len,
-			struct selinux_policy **newpolicyp)
+			 struct selinux_load_state *load_state)
 {
 	struct selinux_policy *newpolicy, *oldpolicy;
-	struct sidtab_convert_params convert_params;
+	struct selinux_policy_convert_data *convert_data;
-	struct convert_context_args args;
 	int rc = 0;
 	struct policy_file file = { data, len }, *fp = &file;
 		goto err_mapping;
 	}
 	if (!selinux_initialized(state)) {
 		/* First policy load, so no need to preserve state from old policy */
-		*newpolicyp = newpolicy;
+		load_state->policy = newpolicy;
+		load_state->convert_data = NULL;
 		return 0;
 	}
 		goto err_free_isids;
 	}
+	convert_data = kmalloc(sizeof(*convert_data), GFP_KERNEL);
+	if (!convert_data) {
+		rc = -ENOMEM;
+		goto err_free_isids;
+	}
 	/*
 	 * Convert the internal representations of contexts
 	 * in the new SID table.
 	 */
-	args.state = state;
+	convert_data->args.state = state;
-	args.oldp = &oldpolicy->policydb;
+	convert_data->args.oldp = &oldpolicy->policydb;
-	args.newp = &newpolicy->policydb;
+	convert_data->args.newp = &newpolicy->policydb;
-	convert_params.func = convert_context;
+	convert_data->sidtab_params.func = convert_context;
-	convert_params.args = &args;
+	convert_data->sidtab_params.args = &convert_data->args;
-	convert_params.target = newpolicy->sidtab;
+	convert_data->sidtab_params.target = newpolicy->sidtab;
-	rc = sidtab_convert(oldpolicy->sidtab, &convert_params);
+	rc = sidtab_convert(oldpolicy->sidtab, &convert_data->sidtab_params);
 	if (rc) {
 		pr_err("SELinux:  unable to convert the internal"
 			" representation of contexts in the new SID"
 			" table\n");
-		goto err_free_isids;
+		goto err_free_convert_data;
 	}
-	*newpolicyp = newpolicy;
+	load_state->policy = newpolicy;
+	load_state->convert_data = convert_data;
 	return 0;
+err_free_convert_data:
+	kfree(convert_data);
 err_free_isids:
 	sidtab_destroy(newpolicy->sidtab);
 err_mapping:

security/tomoyo/network.c+1−1

@@ -613,7 +613,7 @@ static int tomoyo_check_unix_address(struct sockaddr *addr, · 612 unmodified lines
613	static bool tomoyo_kernel_service(void)	613	static bool tomoyo_kernel_service(void)
614	{	614	{
615	/* Nothing to do if I am a kernel service. */	615	/* Nothing to do if I am a kernel service. */
616	return (current->flags & (PF_KTHREAD \| PF_IO_WORKER)) == PF_KTHREAD;	616	return current->flags & PF_KTHREAD;
617	}	617	}
618		618
619	/**	619	/**

sound/pci/hda/hda_intel.c+8−0

 	struct snd_card *card = dev_get_drvdata(dev);
 	struct azx *chip;
+	if (!azx_is_pm_ready(card))
+		return 0;
 	chip = card->private_data;
 	chip->pm_prepared = 1;
+	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 	flush_work(&azx_bus(chip)->unsol_work);
 	struct snd_card *card = dev_get_drvdata(dev);
 	struct azx *chip;
+	if (!azx_is_pm_ready(card))
+		return;
 	chip = card->private_data;
+	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 	chip->pm_prepared = 0;
 }

sound/pci/hda/patch_realtek.c+3−1

 	case 0x10ec0274:
 	case 0x10ec0294:
 		alc_process_coef_fw(codec, coef0274);
-		msleep(80);
+		msleep(850);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x00f0) == 0x00f0;
 		break;
 				       struct hda_jack_callback *jack)
 {
 	snd_hda_gen_hp_automute(codec, jack);
+	alc_update_headset_mode(codec);
 }
 static void alc_probe_headset_mode(struct hda_codec *codec)
 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
 	SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
+	SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),

sound/usb/quirks.c+1−0

@@ -1521,6 +1521,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip) · 1520 unmodified lines
1521	case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */	1521	case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
1522	case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */	1522	case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */
1523	case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */	1523	case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */
		1524	case USB_ID(0x046d, 0x084c): /* Logitech ConferenceCam Connect */
1524	return true;	1525	return true;
1525	}	1526	}
1526		1527

tools/include/uapi/linux/kvm.h+13−0

 #define KVM_XEN_HVM_CONFIG_HYPERCALL_MSR	(1 << 0)
 #define KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL	(1 << 1)
 #define KVM_XEN_HVM_CONFIG_SHARED_INFO		(1 << 2)
+#define KVM_XEN_HVM_CONFIG_RUNSTATE		(1 << 3)
 struct kvm_xen_hvm_config {
 	__u32 flags;
 	union {
 		__u64 gpa;
 		__u64 pad[8];
+		struct {
+			__u64 state;
+			__u64 state_entry_time;
+			__u64 time_running;
+			__u64 time_runnable;
+			__u64 time_blocked;
+			__u64 time_offline;
+		} runstate;
 	} u;
 };
 /* Available with KVM_CAP_XEN_HVM / KVM_XEN_HVM_CONFIG_SHARED_INFO */
 #define KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO	0x0
 #define KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO	0x1
+#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR	0x2
+#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_CURRENT	0x3
+#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA	0x4
+#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST	0x5
 /* Secure Encrypted Virtualization command */
 enum sev_cmd_id {

tools/kvm/kvm_stat/kvm_stat.service+1−0

@@ -9,6 +9,7 @@ Type=simple · 8 unmodified lines
9	ExecStart=/usr/bin/kvm_stat -dtcz -s 10 -L /var/log/kvm_stat.csv	9	ExecStart=/usr/bin/kvm_stat -dtcz -s 10 -L /var/log/kvm_stat.csv
10	ExecReload=/bin/kill -HUP $MAINPID	10	ExecReload=/bin/kill -HUP $MAINPID
11	Restart=always	11	Restart=always
		12	RestartSec=60s
12	SyslogIdentifier=kvm_stat	13	SyslogIdentifier=kvm_stat
13	SyslogLevel=debug	14	SyslogLevel=debug
14		15

tools/lib/bpf/Makefile+1−1

@@ -215,7 +215,7 @@ define do_install · 214 unmodified lines
215	if [ ! -d '$(DESTDIR_SQ)$2' ]; then \	215	if [ ! -d '$(DESTDIR_SQ)$2' ]; then \
216	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$2'; \	216	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$2'; \
217	fi; \	217	fi; \
218	$(INSTALL) $1 $(if $3,-m $3,) '$(DESTDIR_SQ)$2'	218	$(INSTALL) $(if $3,-m $3,) $1 '$(DESTDIR_SQ)$2'
219	endef	219	endef
220		220
221	install_lib: all_cmd	221	install_lib: all_cmd

tools/lib/bpf/btf_dump.c+1−1

@@ -462,7 +462,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) · 461 unmodified lines
462	return err;	462	return err;
463		463
464	case BTF_KIND_ARRAY:	464	case BTF_KIND_ARRAY:
465	return btf_dump_order_type(d, btf_array(t)->type, through_ptr);	465	return btf_dump_order_type(d, btf_array(t)->type, false);
466		466
467	case BTF_KIND_STRUCT:	467	case BTF_KIND_STRUCT:
468	case BTF_KIND_UNION: {	468	case BTF_KIND_UNION: {

tools/lib/bpf/libbpf.c+2−1

@@ -1181,7 +1181,8 @@ static int bpf_object__elf_init(struct bpf_object *obj) · 1180 unmodified lines
1181	if (!elf_rawdata(elf_getscn(obj->efile.elf, obj->efile.shstrndx), NULL)) {	1181	if (!elf_rawdata(elf_getscn(obj->efile.elf, obj->efile.shstrndx), NULL)) {
1182	pr_warn("elf: failed to get section names strings from %s: %s\n",	1182	pr_warn("elf: failed to get section names strings from %s: %s\n",
1183	obj->path, elf_errmsg(-1));	1183	obj->path, elf_errmsg(-1));
1184	return -LIBBPF_ERRNO__FORMAT;	1184	err = -LIBBPF_ERRNO__FORMAT;
		1185	goto errout;
1185	}	1186	}
1186		1187
1187	/* Old LLVM set e_machine to EM_NONE */	1188	/* Old LLVM set e_machine to EM_NONE */

tools/lib/bpf/netlink.c+1−1

@@ -40,7 +40,7 @@ static int libbpf_netlink_open(__u32 *nl_pid) · 39 unmodified lines
40	memset(&sa, 0, sizeof(sa));	40	memset(&sa, 0, sizeof(sa));
41	sa.nl_family = AF_NETLINK;	41	sa.nl_family = AF_NETLINK;
42		42
43	sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);	43	sock = socket(AF_NETLINK, SOCK_RAW \| SOCK_CLOEXEC, NETLINK_ROUTE);
44	if (sock < 0)	44	if (sock < 0)
45	return -errno;	45	return -errno;
46		46

tools/perf/builtin-daemon.c+33−24

 	int status;
 	pid_t pid;
+	/*
+	 * Take signal fd data as pure signal notification and check all
+	 * the sessions state. The reason is that multiple signals can get
+	 * coalesced in kernel and we can receive only single signal even
+	 * if multiple SIGCHLD were generated.
+	 */
 	err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
-	if (err != sizeof(struct signalfd_siginfo))
+	if (err != sizeof(struct signalfd_siginfo)) {
+		pr_err("failed to read signal fd\n");
 		return -1;
+	}
 	list_for_each_entry(session, &daemon->sessions, list) {
+		if (session->pid == -1)
+			continue;
-		if (session->pid != (int) si.ssi_pid)
+		pid = waitpid(session->pid, &status, WNOHANG);
+		if (pid <= 0)
 			continue;
-		pid = waitpid(session->pid, &status, 0);
+		if (WIFEXITED(status)) {
-		if (pid == session->pid) {
+			pr_info("session '%s' exited, status=%d\n",
-			if (WIFEXITED(status)) {
+				session->name, WEXITSTATUS(status));
-				pr_info("session '%s' exited, status=%d\n",
+		} else if (WIFSIGNALED(status)) {
-					session->name, WEXITSTATUS(status));
+			pr_info("session '%s' killed (signal %d)\n",
-			} else if (WIFSIGNALED(status)) {
+				session->name, WTERMSIG(status));
-				pr_info("session '%s' killed (signal %d)\n",
+		} else if (WIFSTOPPED(status)) {
-					session->name, WTERMSIG(status));
+			pr_info("session '%s' stopped (signal %d)\n",
-			} else if (WIFSTOPPED(status)) {
+				session->name, WSTOPSIG(status));
-				pr_info("session '%s' stopped (signal %d)\n",
+		} else {
-					session->name, WSTOPSIG(status));
+			pr_info("session '%s' Unexpected status (0x%x)\n",
-			} else {
+				session->name, status);
-				pr_info("session '%s' Unexpected status (0x%x)\n",
-					session->name, status);
-			}
 		}
 		session->state = KILL;
 		session->pid = -1;
-		return pid;
 	}
 	return 0;
 		.fd	= daemon->signal_fd,
 		.events	= POLLIN,
 	};
-	pid_t wpid = 0, pid = session->pid;
 	time_t start;
 	start = time(NULL);
 		int err = poll(&pollfd, 1, 1000);
 		if (err > 0) {
-			wpid = handle_signalfd(daemon);
+			handle_signalfd(daemon);
 		} else if (err < 0) {
 			perror("failed: poll\n");
 			return -1;
 		if (start + secs < time(NULL))
 			return -1;
-	} while (wpid != pid);
+	} while (session->pid != -1);
 	return 0;
 }
 			daemon_session__signal(session, SIGKILL);
 			break;
 		default:
-			break;
+			pr_err("failed to wait for session %s\n",
+			       session->name);
+			return;
 		}
 		how++;
 			daemon__signal(daemon, SIGKILL);
 			break;
 		default:
-			break;
+			pr_err("failed to wait for sessions\n");
+			return;
 		}
 		how++;
 		close(sock_fd);
 	if (conf_fd != -1)
 		close(conf_fd);
-	if (conf_fd != -1)
+	if (signal_fd != -1)
 		close(signal_fd);
 	pr_info("daemon exited\n");

tools/perf/tests/bpf.c+1−8

 		.msg_load_fail	  = "check your vmlinux setting?",
 		.target_func	  = &epoll_pwait_loop,
 		.expect_result	  = (NR_ITERS + 1) / 2,
-		.pin 		  = true,
+		.pin		  = true,
 	},
 #ifdef HAVE_BPF_PROLOGUE
 	{
 		.expect_result	  = (NR_ITERS + 1) / 4,
 	},
 #endif
-	{
-		.prog_id	  = LLVM_TESTCASE_BPF_RELOCATION,
-		.desc		  = "BPF relocation checker",
-		.name		  = "[bpf_relocation_test]",
-		.msg_compile_fail = "fix 'perf test LLVM' first",
-		.msg_load_fail	  = "libbpf error when dealing with relocation",
-	},
 };
 static int do_test(struct bpf_object *obj, int (*func)(void),

tools/perf/tests/shell/daemon.sh+1−1

@@ -1,4 +1,4 @@
1	#!/bin/sh	1	#!/bin/bash
2	# daemon operations	2	# daemon operations
3	# SPDX-License-Identifier: GPL-2.0	3	# SPDX-License-Identifier: GPL-2.0
4		4

tools/perf/util/auxtrace.c+0−4

 		queue->set = true;
 		queue->tid = buffer->tid;
 		queue->cpu = buffer->cpu;
-	} else if (buffer->cpu != queue->cpu || buffer->tid != queue->tid) {
-		pr_err("auxtrace queue conflict: cpu %d, tid %d vs cpu %d, tid %d\n",
-		       queue->cpu, queue->tid, buffer->cpu, buffer->tid);
-		return -EINVAL;
 	}
 	buffer->buffer_nr = queues->next_buffer_nr++;

tools/perf/util/bpf-event.c+10−3

 	}
 	if (info_linear->info_len < offsetof(struct bpf_prog_info, prog_tags)) {
+		free(info_linear);
 		pr_debug("%s: the kernel is too old, aborting\n", __func__);
 		return -2;
 	}
 	info = &info_linear->info;
+	if (!info->jited_ksyms) {
+		free(info_linear);
+		return -1;
+	}
 	/* number of ksyms, func_lengths, and tags should match */
 	sub_prog_cnt = info->nr_jited_ksyms;
 	if (sub_prog_cnt != info->nr_prog_tags ||
-	    sub_prog_cnt != info->nr_jited_func_lens)
+	    sub_prog_cnt != info->nr_jited_func_lens) {
+		free(info_linear);
 		return -1;
+	}
 	/* check BTF func info support */
 	if (info->btf_id && info->nr_func_info && info->func_info_rec_size) {
 		/* btf func info number should be same as sub_prog_cnt */
 		if (sub_prog_cnt != info->nr_func_info) {
 			pr_debug("%s: mismatch in BPF sub program count and BTF function info count, aborting\n", __func__);
-			err = -1;
+			free(info_linear);
-			goto out;
+			return -1;
 		}
 		if (btf__get_from_id(info->btf_id, &btf)) {
 			pr_debug("%s: failed to get BTF of id %u, aborting\n", __func__, info->btf_id);

tools/perf/util/parse-events.c+3−0

@@ -356,6 +356,9 @@ __add_event(struct list_head list, int idx, · 355 unmodified lines
356	struct perf_cpu_map *cpus = pmu ? perf_cpu_map__get(pmu->cpus) :	356	struct perf_cpu_map *cpus = pmu ? perf_cpu_map__get(pmu->cpus) :
357	cpu_list ? perf_cpu_map__new(cpu_list) : NULL;	357	cpu_list ? perf_cpu_map__new(cpu_list) : NULL;
358		358
		359	if (pmu && attr->type == PERF_TYPE_RAW)
		360	perf_pmu__warn_invalid_config(pmu, attr->config, name);
		361
359	if (init_attr)	362	if (init_attr)
360	event_attr_init(attr);	363	event_attr_init(attr);
361		364

tools/perf/util/pmu.c+33−0

@@ -1812,3 +1812,36 @@ int perf_pmu__caps_parse(struct perf_pmu *pmu) · 1811 unmodified lines
1812		1812
1813	return nr_caps;	1813	return nr_caps;
1814	}	1814	}
		1815
		1816	void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
		1817	char *name)
		1818	{
		1819	struct perf_pmu_format *format;
		1820	__u64 masks = 0, bits;
		1821	char buf[100];
		1822	unsigned int i;
		1823
		1824	list_for_each_entry(format, &pmu->format, list) {
		1825	if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG)
		1826	continue;
		1827
		1828	for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
		1829	masks \|= 1ULL << i;
		1830	}
		1831
		1832	/*
		1833	* Kernel doesn't export any valid format bits.
		1834	*/
		1835	if (masks == 0)
		1836	return;
		1837
		1838	bits = config & ~masks;
		1839	if (bits == 0)
		1840	return;
		1841
		1842	bitmap_scnprintf((unsigned long )&bits, sizeof(bits) 8, buf, sizeof(buf));
		1843
		1844	pr_warning("WARNING: event '%s' not valid (bits %s of config "
		1845	"'%llx' not supported by kernel)!\n",
		1846	name ?: "N/A", buf, config);
		1847	}

tools/perf/util/pmu.h+3−0

@@ -123,4 +123,7 @@ int perf_pmu__convert_scale(const char scale, char end, double sval); · 122 unmodified lines
123		123
124	int perf_pmu__caps_parse(struct perf_pmu *pmu);	124	int perf_pmu__caps_parse(struct perf_pmu *pmu);
125		125
		126	void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
		127	char *name);
		128
126	#endif /* __PMU_H */	129	#endif /* __PMU_H */

tools/perf/util/synthetic-events.c+6−5

 	while (!io.eof) {
 		static const char anonstr[] = "//anon";
-		size_t size;
+		size_t size, aligned_size;
 		/* ensure null termination since stack will be reused. */
 		event->mmap2.filename[0] = '\0';
 		}
 		size = strlen(event->mmap2.filename) + 1;
-		size = PERF_ALIGN(size, sizeof(u64));
+		aligned_size = PERF_ALIGN(size, sizeof(u64));
 		event->mmap2.len -= event->mmap.start;
 		event->mmap2.header.size = (sizeof(event->mmap2) -
-					(sizeof(event->mmap2.filename) - size));
+					(sizeof(event->mmap2.filename) - aligned_size));
-		memset(event->mmap2.filename + size, 0, machine->id_hdr_size);
+		memset(event->mmap2.filename + size, 0, machine->id_hdr_size +
+			(aligned_size - size));
 		event->mmap2.header.size += machine->id_hdr_size;
 		event->mmap2.pid = tgid;
 		event->mmap2.tid = pid;
 	for (i = 0; i < n; i++) {
 		char *end;
 		pid_t _pid;
-		bool kernel_thread;
+		bool kernel_thread = false;
 		_pid = strtol(dirent[i]->d_name, &end, 10);
 		if (*end)

tools/perf/util/vdso.c+2−0

@@ -133,6 +133,8 @@ static struct dso __machine__addnew_vdso(struct machine machine, const char *s · 132 unmodified lines
133	if (dso != NULL) {	133	if (dso != NULL) {
134	__dsos__add(&machine->dsos, dso);	134	__dsos__add(&machine->dsos, dso);
135	dso__set_long_name(dso, long_name, false);	135	dso__set_long_name(dso, long_name, false);
		136	/* Put dso here because __dsos_add already got it */
		137	dso__put(dso);
136	}	138	}
137		139
138	return dso;	140	return dso;

tools/testing/kunit/configs/broken_on_uml.config+2−0

@@ -40,3 +40,5 @@ · 39 unmodified lines
40	# CONFIG_RESET_BRCMSTB_RESCAL is not set	40	# CONFIG_RESET_BRCMSTB_RESCAL is not set
41	# CONFIG_RESET_INTEL_GW is not set	41	# CONFIG_RESET_INTEL_GW is not set
42	# CONFIG_ADI_AXI_ADC is not set	42	# CONFIG_ADI_AXI_ADC is not set
		43	# CONFIG_DEBUG_PAGEALLOC is not set
		44	# CONFIG_PAGE_POISONING is not set

tools/testing/kunit/kunit_config.py+1−1

@@ -13,7 +13,7 @@ from typing import List, Set · 12 unmodified lines
13	CONFIG_IS_NOT_SET_PATTERN = r'^# CONFIG_(\w+) is not set$'	13	CONFIG_IS_NOT_SET_PATTERN = r'^# CONFIG_(\w+) is not set$'
14	CONFIG_PATTERN = r'^CONFIG_(\w+)=(\S+\|".*")$'	14	CONFIG_PATTERN = r'^CONFIG_(\w+)=(\S+\|".*")$'
15		15
16	KconfigEntryBase = collections.namedtuple('KconfigEntry', ['name', 'value'])	16	KconfigEntryBase = collections.namedtuple('KconfigEntryBase', ['name', 'value'])
17		17
18	class KconfigEntry(KconfigEntryBase):	18	class KconfigEntry(KconfigEntryBase):
19		19

tools/testing/radix-tree/idr-test.c+18−3

 	return NULL;
 }
+/*
+ * There are always either 1 or 2 objects in the IDR.  If we find nothing,
+ * or we find something at an ID we didn't expect, that's a bug.
+ */
 void idr_find_test_1(int anchor_id, int throbber_id)
 {
 	pthread_t throbber;
 	time_t start = time(NULL);
-	pthread_create(&throbber, NULL, idr_throbber, &throbber_id);
 	BUG_ON(idr_alloc(&find_idr, xa_mk_value(anchor_id), anchor_id,
 				anchor_id + 1, GFP_KERNEL) != anchor_id);
+	pthread_create(&throbber, NULL, idr_throbber, &throbber_id);
+	rcu_read_lock();
 	do {
 		int id = 0;
 		void *entry = idr_get_next(&find_idr, &id);
-		BUG_ON(entry != xa_mk_value(id));
+		rcu_read_unlock();
+		if ((id != anchor_id && id != throbber_id) ||
+		    entry != xa_mk_value(id)) {
+			printf("%s(%d, %d): %p at %d\n", __func__, anchor_id,
+				throbber_id, entry, id);
+			abort();
+		}
+		rcu_read_lock();
 	} while (time(NULL) < start + 11);
+	rcu_read_unlock();
 	pthread_join(throbber, NULL);
 int __weak main(void)
 {
+	rcu_register_thread();
 	radix_tree_init();
 	idr_checks();
 	ida_tests();
 	rcu_barrier();
 	if (nr_allocated)
 		printf("nr_allocated = %d\n", nr_allocated);
+	rcu_unregister_thread();
 	return 0;
 }

tools/testing/radix-tree/linux/compiler_types.h+0−0

Empty file deleted.

tools/testing/radix-tree/multiorder.c+2−0

 int __weak main(void)
 {
+	rcu_register_thread();
 	radix_tree_init();
 	multiorder_checks();
+	rcu_unregister_thread();
 	return 0;
 }

tools/testing/radix-tree/xarray.c+2−0

 int __weak main(void)
 {
+	rcu_register_thread();
 	radix_tree_init();
 	xarray_tests();
 	radix_tree_cpu_dead(1);
 	rcu_barrier();
 	if (nr_allocated)
 		printf("nr_allocated = %d\n", nr_allocated);
+	rcu_unregister_thread();
 	return 0;
 }

tools/testing/selftests/arm64/fp/sve-test.S+17−5

 // Set up test pattern in the FFR
 // x0: pid
 // x2: generation
+//
+// We need to generate a canonical FFR value, which consists of a number of
+// low "1" bits, followed by a number of zeros. This gives us 17 unique values
+// per 16 bits of FFR, so we create a 4 bit signature out of the PID and
+// generation, and use that as the initial number of ones in the pattern.
+// We fill the upper lanes of FFR with zeros.
 // Beware: corrupts P0.
 function setup_ffr
 	mov	x4, x30
-	bl	pattern
+	and	w0, w0, #0x3
+	bfi	w0, w2, #2, #2
+	mov	w1, #1
+	lsl	w1, w1, w0
+	sub	w1, w1, #1
 	ldr	x0, =ffrref
-	ldr	x1, =scratch
+	strh	w1, [x0], 2
-	rdvl	x2, #1
+	rdvl	x1, #1
-	lsr	x2, x2, #3
+	lsr	x1, x1, #3
-	bl	memcpy
+	sub	x1, x1, #2
+	bl	memclr
 	mov	x0, #0
 	ldr	x1, =ffrref

tools/testing/selftests/bpf/prog_tests/check_mtu.c+4−0

 	test_check_mtu_run_xdp(skel, skel->progs.xdp_use_helper, mtu);
 	test_check_mtu_run_xdp(skel, skel->progs.xdp_exceed_mtu, mtu);
 	test_check_mtu_run_xdp(skel, skel->progs.xdp_minus_delta, mtu);
+	test_check_mtu_run_xdp(skel, skel->progs.xdp_input_len, mtu);
+	test_check_mtu_run_xdp(skel, skel->progs.xdp_input_len_exceed, mtu);
 cleanup:
 	test_check_mtu__destroy(skel);
 	test_check_mtu_run_tc(skel, skel->progs.tc_exceed_mtu, mtu);
 	test_check_mtu_run_tc(skel, skel->progs.tc_exceed_mtu_da, mtu);
 	test_check_mtu_run_tc(skel, skel->progs.tc_minus_delta, mtu);
+	test_check_mtu_run_tc(skel, skel->progs.tc_input_len, mtu);
+	test_check_mtu_run_tc(skel, skel->progs.tc_input_len_exceed, mtu);
 cleanup:
 	test_check_mtu__destroy(skel);
 }

tools/testing/selftests/bpf/prog_tests/fexit_sleep.c+82−0

@@ -0,0 +1,82 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2021 Facebook */
	3	#define _GNU_SOURCE
	4	#include <sched.h>
	5	#include <test_progs.h>
	6	#include <time.h>
	7	#include <sys/mman.h>
	8	#include <sys/syscall.h>
	9	#include "fexit_sleep.skel.h"
	10
	11	static int do_sleep(void *skel)
	12	{
	13	struct fexit_sleep *fexit_skel = skel;
	14	struct timespec ts1 = { .tv_nsec = 1 };
	15	struct timespec ts2 = { .tv_sec = 10 };
	16
	17	fexit_skel->bss->pid = getpid();
	18	(void)syscall(__NR_nanosleep, &ts1, NULL);
	19	(void)syscall(__NR_nanosleep, &ts2, NULL);
	20	return 0;
	21	}
	22
	23	#define STACK_SIZE (1024 * 1024)
	24	static char child_stack[STACK_SIZE];
	25
	26	void test_fexit_sleep(void)
	27	{
	28	struct fexit_sleep *fexit_skel = NULL;
	29	int wstatus, duration = 0;
	30	pid_t cpid;
	31	int err, fexit_cnt;
	32
	33	fexit_skel = fexit_sleep__open_and_load();
	34	if (CHECK(!fexit_skel, "fexit_skel_load", "fexit skeleton failed\n"))
	35	goto cleanup;
	36
	37	err = fexit_sleep__attach(fexit_skel);
	38	if (CHECK(err, "fexit_attach", "fexit attach failed: %d\n", err))
	39	goto cleanup;
	40
	41	cpid = clone(do_sleep, child_stack + STACK_SIZE, CLONE_FILES \| SIGCHLD, fexit_skel);
	42	if (CHECK(cpid == -1, "clone", strerror(errno)))
	43	goto cleanup;
	44
	45	/* wait until first sys_nanosleep ends and second sys_nanosleep starts */
	46	while (READ_ONCE(fexit_skel->bss->fentry_cnt) != 2);
	47	fexit_cnt = READ_ONCE(fexit_skel->bss->fexit_cnt);
	48	if (CHECK(fexit_cnt != 1, "fexit_cnt", "%d", fexit_cnt))
	49	goto cleanup;
	50
	51	/* close progs and detach them. That will trigger two nop5->jmp5 rewrites
	52	* in the trampolines to skip nanosleep_fexit prog.
	53	* The nanosleep_fentry prog will get detached first.
	54	* The nanosleep_fexit prog will get detached second.
	55	* Detaching will trigger freeing of both progs JITed images.
	56	* There will be two dying bpf_tramp_image-s, but only the initial
	57	* bpf_tramp_image (with both _fentry and _fexit progs will be stuck
	58	* waiting for percpu_ref_kill to confirm). The other one
	59	* will be freed quickly.
	60	*/
	61	close(bpf_program__fd(fexit_skel->progs.nanosleep_fentry));
	62	close(bpf_program__fd(fexit_skel->progs.nanosleep_fexit));
	63	fexit_sleep__detach(fexit_skel);
	64
	65	/* kill the thread to unwind sys_nanosleep stack through the trampoline */
	66	kill(cpid, 9);
	67
	68	if (CHECK(waitpid(cpid, &wstatus, 0) == -1, "waitpid", strerror(errno)))
	69	goto cleanup;
	70	if (CHECK(WEXITSTATUS(wstatus) != 0, "exitstatus", "failed"))
	71	goto cleanup;
	72
	73	/* The bypassed nanosleep_fexit prog shouldn't have executed.
	74	* Unlike progs the maps were not freed and directly accessible.
	75	*/
	76	fexit_cnt = READ_ONCE(fexit_skel->bss->fexit_cnt);
	77	if (CHECK(fexit_cnt != 1, "fexit_cnt", "%d", fexit_cnt))
	78	goto cleanup;
	79
	80	cleanup:
	81	fexit_sleep__destroy(fexit_skel);
	82	}

tools/testing/selftests/bpf/progs/btf_dump_test_case_syntax.c+8−0

 	};
 };
+struct struct_in_array {};
+struct struct_in_array_typed {};
+typedef struct struct_in_array_typed struct_in_array_t[2];
 struct struct_with_embedded_stuff {
 	int a;
 	struct {
 	} r[5];
 	struct struct_in_struct s[10];
 	int t[11];
+	struct struct_in_array (*u)[2];
+	struct_in_array_t *v;
 };
 struct root_struct {

tools/testing/selftests/bpf/progs/fexit_sleep.c+31−0

@@ -0,0 +1,31 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2021 Facebook */
	3	#include "vmlinux.h"
	4	#include <bpf/bpf_helpers.h>
	5	#include <bpf/bpf_tracing.h>
	6
	7	char LICENSE[] SEC("license") = "GPL";
	8
	9	int pid = 0;
	10	int fentry_cnt = 0;
	11	int fexit_cnt = 0;
	12
	13	SEC("fentry/__x64_sys_nanosleep")
	14	int BPF_PROG(nanosleep_fentry, const struct pt_regs *regs)
	15	{
	16	if ((int)bpf_get_current_pid_tgid() != pid)
	17	return 0;
	18
	19	fentry_cnt++;
	20	return 0;
	21	}
	22
	23	SEC("fexit/__x64_sys_nanosleep")
	24	int BPF_PROG(nanosleep_fexit, const struct pt_regs *regs, int ret)
	25	{
	26	if ((int)bpf_get_current_pid_tgid() != pid)
	27	return 0;
	28
	29	fexit_cnt++;
	30	return 0;
	31	}

tools/testing/selftests/bpf/progs/test_check_mtu.c+92−0

@@ -105,6 +105,54 @@ int xdp_minus_delta(struct xdp_md *ctx) · 104 unmodified lines
105	return retval;	105	return retval;
106	}	106	}
107		107
		108	SEC("xdp")
		109	int xdp_input_len(struct xdp_md *ctx)
		110	{
		111	int retval = XDP_PASS; /* Expected retval on successful test */
		112	void data_end = (void )(long)ctx->data_end;
		113	void data = (void )(long)ctx->data;
		114	__u32 ifindex = GLOBAL_USER_IFINDEX;
		115	__u32 data_len = data_end - data;
		116
		117	/* API allow user give length to check as input via mtu_len param,
		118	* resulting MTU value is still output in mtu_len param after call.
		119	*
		120	* Input len is L3, like MTU and iph->tot_len.
		121	* Remember XDP data_len is L2.
		122	*/
		123	__u32 mtu_len = data_len - ETH_HLEN;
		124
		125	if (bpf_check_mtu(ctx, ifindex, &mtu_len, 0, 0))
		126	retval = XDP_ABORTED;
		127
		128	global_bpf_mtu_xdp = mtu_len;
		129	return retval;
		130	}
		131
		132	SEC("xdp")
		133	int xdp_input_len_exceed(struct xdp_md *ctx)
		134	{
		135	int retval = XDP_ABORTED; /* Fail */
		136	__u32 ifindex = GLOBAL_USER_IFINDEX;
		137	int err;
		138
		139	/* API allow user give length to check as input via mtu_len param,
		140	* resulting MTU value is still output in mtu_len param after call.
		141	*
		142	* Input length value is L3 size like MTU.
		143	*/
		144	__u32 mtu_len = GLOBAL_USER_MTU;
		145
		146	mtu_len += 1; /* Exceed with 1 */
		147
		148	err = bpf_check_mtu(ctx, ifindex, &mtu_len, 0, 0);
		149	if (err == BPF_MTU_CHK_RET_FRAG_NEEDED)
		150	retval = XDP_PASS ; /* Success in exceeding MTU check */
		151
		152	global_bpf_mtu_xdp = mtu_len;
		153	return retval;
		154	}
		155
108	SEC("classifier")	156	SEC("classifier")
109	int tc_use_helper(struct __sk_buff *ctx)	157	int tc_use_helper(struct __sk_buff *ctx)
110	{	158	{
@@ -196,3 +244,47 @@ int tc_minus_delta(struct __sk_buff *ctx) · 85 unmodified lines
196	global_bpf_mtu_xdp = mtu_len;	244	global_bpf_mtu_xdp = mtu_len;
197	return retval;	245	return retval;
198	}	246	}
		247
		248	SEC("classifier")
		249	int tc_input_len(struct __sk_buff *ctx)
		250	{
		251	int retval = BPF_OK; /* Expected retval on successful test */
		252	__u32 ifindex = GLOBAL_USER_IFINDEX;
		253
		254	/* API allow user give length to check as input via mtu_len param,
		255	* resulting MTU value is still output in mtu_len param after call.
		256	*
		257	* Input length value is L3 size.
		258	*/
		259	__u32 mtu_len = GLOBAL_USER_MTU;
		260
		261	if (bpf_check_mtu(ctx, ifindex, &mtu_len, 0, 0))
		262	retval = BPF_DROP;
		263
		264	global_bpf_mtu_xdp = mtu_len;
		265	return retval;
		266	}
		267
		268	SEC("classifier")
		269	int tc_input_len_exceed(struct __sk_buff *ctx)
		270	{
		271	int retval = BPF_DROP; /* Fail */
		272	__u32 ifindex = GLOBAL_USER_IFINDEX;
		273	int err;
		274
		275	/* API allow user give length to check as input via mtu_len param,
		276	* resulting MTU value is still output in mtu_len param after call.
		277	*
		278	* Input length value is L3 size like MTU.
		279	*/
		280	__u32 mtu_len = GLOBAL_USER_MTU;
		281
		282	mtu_len += 1; /* Exceed with 1 */
		283
		284	err = bpf_check_mtu(ctx, ifindex, &mtu_len, 0, 0);
		285	if (err == BPF_MTU_CHK_RET_FRAG_NEEDED)
		286	retval = BPF_OK; /* Success in exceeding MTU check */
		287
		288	global_bpf_mtu_xdp = mtu_len;
		289	return retval;
		290	}

tools/testing/selftests/bpf/progs/test_tunnel_kern.c+2−4

 	}
 	ret = bpf_skb_get_tunnel_opt(skb, &gopt, sizeof(gopt));
-	if (ret < 0) {
+	if (ret < 0)
-		ERROR(ret);
+		gopt.opt_class = 0;
-		return TC_ACT_SHOT;
-	}
 	bpf_trace_printk(fmt, sizeof(fmt),
 			key.tunnel_id, key.remote_ipv4, gopt.opt_class);

tools/testing/selftests/bpf/verifier/bounds_deduction.c+19−8

 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "R0 tried to subtract pointer from scalar",
+	.result = REJECT,
 },
 {
 	"check deducing bounds from const, 2",
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
 		BPF_EXIT_INSN(),
 	},
+	.errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
+	.result_unpriv = REJECT,
 	.result = ACCEPT,
 	.retval = 1,
 },
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "R0 tried to subtract pointer from scalar",
+	.result = REJECT,
 },
 {
 	"check deducing bounds from const, 4",
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
 		BPF_EXIT_INSN(),
 	},
+	.errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
+	.result_unpriv = REJECT,
 	.result = ACCEPT,
 },
 {
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "R0 tried to subtract pointer from scalar",
+	.result = REJECT,
 },
 {
 	"check deducing bounds from const, 6",
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "R0 tried to subtract pointer from scalar",
+	.result = REJECT,
 },
 {
 	"check deducing bounds from const, 7",
 			    offsetof(struct __sk_buff, mark)),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "dereference of modified ctx ptr",
+	.result = REJECT,
 	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 },
 {
 			    offsetof(struct __sk_buff, mark)),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
 	.errstr = "dereference of modified ctx ptr",
+	.result = REJECT,
 	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 },
 {
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
+	.errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
 	.errstr = "R0 tried to subtract pointer from scalar",
+	.result = REJECT,
 },
 {
 	"check deducing bounds from const, 10",
 		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 		BPF_EXIT_INSN(),
 	},
-	.result = REJECT,
 	.errstr = "math between ctx pointer and register with unbounded min value is not allowed",
+	.result = REJECT,
 },

tools/testing/selftests/bpf/verifier/map_ptr.c+4−0

 	BPF_EXIT_INSN(),
 	},
 	.fixup_map_hash_16b = { 4 },
+	.result_unpriv = REJECT,
+	.errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
 	.result = ACCEPT,
 },
 {
 	BPF_EXIT_INSN(),
 	},
 	.fixup_map_hash_16b = { 4 },
+	.result_unpriv = REJECT,
+	.errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
 	.result = ACCEPT,
 },

tools/testing/selftests/bpf/verifier/unpriv.c+14−1

 	.result = ACCEPT,
 },
 {
-	"unpriv: adding of fp",
+	"unpriv: adding of fp, reg",
 	.insns = {
 	BPF_MOV64_IMM(BPF_REG_0, 0),
 	BPF_MOV64_IMM(BPF_REG_1, 0),
 	BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
 	BPF_EXIT_INSN(),
 	},
+	.errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
+	.result_unpriv = REJECT,
+	.result = ACCEPT,
+},
+{
+	"unpriv: adding of fp, imm",
+	.insns = {
+	BPF_MOV64_IMM(BPF_REG_0, 0),
+	BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),
+	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 0),
+	BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
+	BPF_EXIT_INSN(),
+	},
 	.errstr_unpriv = "R1 stack pointer arithmetic goes out of range",
 	.result_unpriv = REJECT,
 	.result = ACCEPT,

tools/testing/selftests/bpf/verifier/value_ptr_arith.c+22−1

@@ -169,7 +169,7 @@ · 168 unmodified lines
169	.fixup_map_array_48b = { 1 },	169	.fixup_map_array_48b = { 1 },
170	.result = ACCEPT,	170	.result = ACCEPT,
171	.result_unpriv = REJECT,	171	.result_unpriv = REJECT,
172	.errstr_unpriv = "R2 tried to add from different maps or paths",	172	.errstr_unpriv = "R2 tried to add from different maps, paths, or prohibited types",
173	.retval = 0,	173	.retval = 0,
174	},	174	},
175	{	175	{
@@ -516,6 +516,27 @@ · 340 unmodified lines
516	.result = ACCEPT,	516	.result = ACCEPT,
517	.retval = 0xabcdef12,	517	.retval = 0xabcdef12,
518	},	518	},
		519	{
		520	"map access: value_ptr += N, value_ptr -= N known scalar",
		521	.insns = {
		522	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
		523	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		524	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		525	BPF_LD_MAP_FD(BPF_REG_1, 0),
		526	BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
		527	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
		528	BPF_MOV32_IMM(BPF_REG_1, 0x12345678),
		529	BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
		530	BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 2),
		531	BPF_MOV64_IMM(BPF_REG_1, 2),
		532	BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
		533	BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0),
		534	BPF_EXIT_INSN(),
		535	},
		536	.fixup_map_array_48b = { 3 },
		537	.result = ACCEPT,
		538	.retval = 0x12345678,
		539	},
519	{	540	{
520	"map access: unknown scalar += value_ptr, 1",	541	"map access: unknown scalar += value_ptr, 1",
521	.insns = {	542	.insns = {

tools/testing/selftests/kvm/hardware_disable_test.c+5−5

@@ -108,7 +108,7 @@ static void run_test(uint32_t run) · 107 unmodified lines
108	kvm_vm_elf_load(vm, program_invocation_name, 0, 0);	108	kvm_vm_elf_load(vm, program_invocation_name, 0, 0);
109	vm_create_irqchip(vm);	109	vm_create_irqchip(vm);
110		110
111	fprintf(stderr, "%s: [%d] start vcpus\n", __func__, run);	111	pr_debug("%s: [%d] start vcpus\n", __func__, run);
112	for (i = 0; i < VCPU_NUM; ++i) {	112	for (i = 0; i < VCPU_NUM; ++i) {
113	vm_vcpu_add_default(vm, i, guest_code);	113	vm_vcpu_add_default(vm, i, guest_code);
114	payloads[i].vm = vm;	114	payloads[i].vm = vm;
@@ -124,7 +124,7 @@ static void run_test(uint32_t run) · 9 unmodified lines
124	check_set_affinity(throw_away, &cpu_set);	124	check_set_affinity(throw_away, &cpu_set);
125	}	125	}
126	}	126	}
127	fprintf(stderr, "%s: [%d] all threads launched\n", __func__, run);	127	pr_debug("%s: [%d] all threads launched\n", __func__, run);
128	sem_post(sem);	128	sem_post(sem);
129	for (i = 0; i < VCPU_NUM; ++i)	129	for (i = 0; i < VCPU_NUM; ++i)
130	check_join(threads[i], &b);	130	check_join(threads[i], &b);
@@ -147,16 +147,16 @@ int main(int argc, char **argv) · 16 unmodified lines
147	if (pid == 0)	147	if (pid == 0)
148	run_test(i); /* This function always exits */	148	run_test(i); /* This function always exits */
149		149
150	fprintf(stderr, "%s: [%d] waiting semaphore\n", __func__, i);	150	pr_debug("%s: [%d] waiting semaphore\n", __func__, i);
151	sem_wait(sem);	151	sem_wait(sem);
152	r = (rand() % DELAY_US_MAX) + 1;	152	r = (rand() % DELAY_US_MAX) + 1;
153	fprintf(stderr, "%s: [%d] waiting %dus\n", __func__, i, r);	153	pr_debug("%s: [%d] waiting %dus\n", __func__, i, r);
154	usleep(r);	154	usleep(r);
155	r = waitpid(pid, &s, WNOHANG);	155	r = waitpid(pid, &s, WNOHANG);
156	TEST_ASSERT(r != pid,	156	TEST_ASSERT(r != pid,
157	"%s: [%d] child exited unexpectedly status: [%d]",	157	"%s: [%d] child exited unexpectedly status: [%d]",
158	__func__, i, s);	158	__func__, i, s);
159	fprintf(stderr, "%s: [%d] killing child\n", __func__, i);	159	pr_debug("%s: [%d] killing child\n", __func__, i);
160	kill(pid, SIGKILL);	160	kill(pid, SIGKILL);
161	}	161	}
162		162

tools/testing/selftests/kvm/x86_64/hyperv_clock.c+11−2

 	GUEST_ASSERT(delta_ns * 100 < (t2 - t1) * 100);
 }
+static inline u64 get_tscpage_ts(struct ms_hyperv_tsc_page *tsc_page)
+{
+	return mul_u64_u64_shr64(rdtsc(), tsc_page->tsc_scale) + tsc_page->tsc_offset;
+}
 static inline void check_tsc_msr_tsc_page(struct ms_hyperv_tsc_page *tsc_page)
 {
 	u64 r1, r2, t1, t2;
 	/* Compare TSC page clocksource with HV_X64_MSR_TIME_REF_COUNT */
-	t1 = mul_u64_u64_shr64(rdtsc(), tsc_page->tsc_scale) + tsc_page->tsc_offset;
+	t1 = get_tscpage_ts(tsc_page);
 	r1 = rdmsr(HV_X64_MSR_TIME_REF_COUNT);
 	/* 10 ms tolerance */
 	GUEST_ASSERT(r1 >= t1 && r1 - t1 < 100000);
 	nop_loop();
-	t2 = mul_u64_u64_shr64(rdtsc(), tsc_page->tsc_scale) + tsc_page->tsc_offset;
+	t2 = get_tscpage_ts(tsc_page);
 	r2 = rdmsr(HV_X64_MSR_TIME_REF_COUNT);
 	GUEST_ASSERT(r2 >= t1 && r2 - t2 < 100000);
 }
 	tsc_offset = tsc_page->tsc_offset;
 	/* Call KVM_SET_CLOCK from userspace, check that TSC page was updated */
 	GUEST_SYNC(7);
+	/* Sanity check TSC page timestamp, it should be close to 0 */
+	GUEST_ASSERT(get_tscpage_ts(tsc_page) < 100000);
 	GUEST_ASSERT(tsc_page->tsc_offset != tsc_offset);
 	nop_loop();

tools/testing/selftests/net/forwarding/vxlan_bridge_1d.sh+1−1

@@ -658,7 +658,7 @@ test_ecn_decap() · 657 unmodified lines
658	# In accordance with INET_ECN_decapsulate()	658	# In accordance with INET_ECN_decapsulate()
659	__test_ecn_decap 00 00 0x00	659	__test_ecn_decap 00 00 0x00
660	__test_ecn_decap 01 01 0x01	660	__test_ecn_decap 01 01 0x01
661	__test_ecn_decap 02 01 0x02	661	__test_ecn_decap 02 01 0x01
662	__test_ecn_decap 01 03 0x03	662	__test_ecn_decap 01 03 0x03
663	__test_ecn_decap 02 03 0x03	663	__test_ecn_decap 02 03 0x03
664	test_ecn_decap_error	664	test_ecn_decap_error

tools/testing/selftests/net/mptcp/mptcp_join.sh+20−10

 timeout=30
 mptcp_connect=""
 capture=0
+do_all_tests=1
 TEST_COUNT=0
 		-j DROP
 }
-for arg in "$@"; do
-	if [ "$arg" = "-c" ]; then
-		capture=1
-	fi
-done
 ip -Version > /dev/null 2>&1
 if [ $? -ne 0 ];then
 	echo "SKIP: Could not run test without ip tool"
 	echo "  -4 v4mapped_tests"
 	echo "  -b backup_tests"
 	echo "  -p add_addr_ports_tests"
-	echo "  -c syncookies_tests"
+	echo "  -k syncookies_tests"
+	echo "  -c capture pcap files"
 	echo "  -h help"
 }
 make_file "$sin" "server" 1
 trap cleanup EXIT
-if [ -z $1 ]; then
+for arg in "$@"; do
+	# check for "capture" arg before launching tests
+	if [[ "${arg}" =~ ^"-"[0-9a-zA-Z]*"c"[0-9a-zA-Z]*$ ]]; then
+		capture=1
+	fi
+	# exception for the capture option, the rest means: a part of the tests
+	if [ "${arg}" != "-c" ]; then
+		do_all_tests=0
+	fi
+done
+if [ $do_all_tests -eq 1 ]; then
 	all_tests
 	exit $ret
 fi
-while getopts 'fsltra64bpch' opt; do
+while getopts 'fsltra64bpkch' opt; do
 	case $opt in
 		f)
 			subflows_tests
 		p)
 			add_addr_ports_tests
 			;;
-		c)
+		k)
 			syncookies_tests
 			;;
+		c)
+			;;
 		h | *)
 			usage
 			;;

tools/testing/selftests/net/reuseaddr_ports_exhausted.c+16−16

@@ -30,25 +30,25 @@ struct reuse_opts { · 29 unmodified lines
30	};	30	};
31		31
32	struct reuse_opts unreusable_opts[12] = {	32	struct reuse_opts unreusable_opts[12] = {
33	{0, 0, 0, 0},	33	{{0, 0}, {0, 0}},
34	{0, 0, 0, 1},	34	{{0, 0}, {0, 1}},
35	{0, 0, 1, 0},	35	{{0, 0}, {1, 0}},
36	{0, 0, 1, 1},	36	{{0, 0}, {1, 1}},
37	{0, 1, 0, 0},	37	{{0, 1}, {0, 0}},
38	{0, 1, 0, 1},	38	{{0, 1}, {0, 1}},
39	{0, 1, 1, 0},	39	{{0, 1}, {1, 0}},
40	{0, 1, 1, 1},	40	{{0, 1}, {1, 1}},
41	{1, 0, 0, 0},	41	{{1, 0}, {0, 0}},
42	{1, 0, 0, 1},	42	{{1, 0}, {0, 1}},
43	{1, 0, 1, 0},	43	{{1, 0}, {1, 0}},
44	{1, 0, 1, 1},	44	{{1, 0}, {1, 1}},
45	};	45	};
46		46
47	struct reuse_opts reusable_opts[4] = {	47	struct reuse_opts reusable_opts[4] = {
48	{1, 1, 0, 0},	48	{{1, 1}, {0, 0}},
49	{1, 1, 0, 1},	49	{{1, 1}, {0, 1}},
50	{1, 1, 1, 0},	50	{{1, 1}, {1, 0}},
51	{1, 1, 1, 1},	51	{{1, 1}, {1, 1}},
52	};	52	};
53		53
54	int bind_port(struct __test_metadata *_metadata, int reuseaddr, int reuseport)	54	int bind_port(struct __test_metadata *_metadata, int reuseaddr, int reuseport)

tools/testing/selftests/vm/Makefile+2−2

@@ -101,7 +101,7 @@ endef · 100 unmodified lines
101	ifeq ($(CAN_BUILD_I386),1)	101	ifeq ($(CAN_BUILD_I386),1)
102	$(BINARIES_32): CFLAGS += -m32	102	$(BINARIES_32): CFLAGS += -m32
103	$(BINARIES_32): LDLIBS += -lrt -ldl -lm	103	$(BINARIES_32): LDLIBS += -lrt -ldl -lm
104	$(BINARIES_32): %_32: %.c	104	$(BINARIES_32): $(OUTPUT)/%_32: %.c
105	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@	105	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@
106	$(foreach t,$(TARGETS),$(eval $(call gen-target-rule-32,$(t))))	106	$(foreach t,$(TARGETS),$(eval $(call gen-target-rule-32,$(t))))
107	endif	107	endif
@@ -109,7 +109,7 @@ endif · 1 unmodified line
109	ifeq ($(CAN_BUILD_X86_64),1)	109	ifeq ($(CAN_BUILD_X86_64),1)
110	$(BINARIES_64): CFLAGS += -m64	110	$(BINARIES_64): CFLAGS += -m64
111	$(BINARIES_64): LDLIBS += -lrt -ldl	111	$(BINARIES_64): LDLIBS += -lrt -ldl
112	$(BINARIES_64): %_64: %.c	112	$(BINARIES_64): $(OUTPUT)/%_64: %.c
113	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@	113	$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@
114	$(foreach t,$(TARGETS),$(eval $(call gen-target-rule-64,$(t))))	114	$(foreach t,$(TARGETS),$(eval $(call gen-target-rule-64,$(t))))
115	endif	115	endif

@@ -131,7 +131,7 @@ DEFINE_QNODE(mas_pcnoc_sdcc_1, MSM8939_MASTER_SDCC_1, 8, -1, -1, MSM8939_PNOC_IN · 130 unmodified lines
131	DEFINE_QNODE(mas_pcnoc_sdcc_2, MSM8939_MASTER_SDCC_2, 8, -1, -1, MSM8939_PNOC_INT_1);	131	DEFINE_QNODE(mas_pcnoc_sdcc_2, MSM8939_MASTER_SDCC_2, 8, -1, -1, MSM8939_PNOC_INT_1);
132	DEFINE_QNODE(mas_qdss_bam, MSM8939_MASTER_QDSS_BAM, 8, -1, -1, MSM8939_SNOC_QDSS_INT);	132	DEFINE_QNODE(mas_qdss_bam, MSM8939_MASTER_QDSS_BAM, 8, -1, -1, MSM8939_SNOC_QDSS_INT);
133	DEFINE_QNODE(mas_qdss_etr, MSM8939_MASTER_QDSS_ETR, 8, -1, -1, MSM8939_SNOC_QDSS_INT);	133	DEFINE_QNODE(mas_qdss_etr, MSM8939_MASTER_QDSS_ETR, 8, -1, -1, MSM8939_SNOC_QDSS_INT);
134	DEFINE_QNODE(mas_snoc_cfg, MSM8939_MASTER_SNOC_CFG, 4, 20, -1, MSM8939_SLAVE_SRVC_SNOC);	134	DEFINE_QNODE(mas_snoc_cfg, MSM8939_MASTER_SNOC_CFG, 4, -1, -1, MSM8939_SLAVE_SRVC_SNOC);
135	DEFINE_QNODE(mas_spdm, MSM8939_MASTER_SPDM, 4, -1, -1, MSM8939_PNOC_MAS_0);	135	DEFINE_QNODE(mas_spdm, MSM8939_MASTER_SPDM, 4, -1, -1, MSM8939_PNOC_MAS_0);
136	DEFINE_QNODE(mas_tcu0, MSM8939_MASTER_TCU0, 16, -1, -1, MSM8939_SLAVE_EBI_CH0, MSM8939_BIMC_SNOC_MAS, MSM8939_SLAVE_AMPSS_L2);	136	DEFINE_QNODE(mas_tcu0, MSM8939_MASTER_TCU0, 16, -1, -1, MSM8939_SLAVE_EBI_CH0, MSM8939_BIMC_SNOC_MAS, MSM8939_SLAVE_AMPSS_L2);
137	DEFINE_QNODE(mas_usb_hs1, MSM8939_MASTER_USB_HS1, 4, -1, -1, MSM8939_PNOC_MAS_1);	137	DEFINE_QNODE(mas_usb_hs1, MSM8939_MASTER_USB_HS1, 4, -1, -1, MSM8939_PNOC_MAS_1);
@@ -156,14 +156,14 @@ DEFINE_QNODE(pcnoc_snoc_mas, MSM8939_PNOC_SNOC_MAS, 8, 29, -1, MSM8939_PNOC_SNOC · 18 unmodified lines
156	DEFINE_QNODE(pcnoc_snoc_slv, MSM8939_PNOC_SNOC_SLV, 8, -1, 45, MSM8939_SNOC_INT_0, MSM8939_SNOC_INT_BIMC, MSM8939_SNOC_INT_1);	156	DEFINE_QNODE(pcnoc_snoc_slv, MSM8939_PNOC_SNOC_SLV, 8, -1, 45, MSM8939_SNOC_INT_0, MSM8939_SNOC_INT_BIMC, MSM8939_SNOC_INT_1);
157	DEFINE_QNODE(qdss_int, MSM8939_SNOC_QDSS_INT, 8, -1, -1, MSM8939_SNOC_INT_0, MSM8939_SNOC_INT_BIMC);	157	DEFINE_QNODE(qdss_int, MSM8939_SNOC_QDSS_INT, 8, -1, -1, MSM8939_SNOC_INT_0, MSM8939_SNOC_INT_BIMC);
158	DEFINE_QNODE(slv_apps_l2, MSM8939_SLAVE_AMPSS_L2, 16, -1, -1, 0);	158	DEFINE_QNODE(slv_apps_l2, MSM8939_SLAVE_AMPSS_L2, 16, -1, -1, 0);
159	DEFINE_QNODE(slv_apss, MSM8939_SLAVE_APSS, 4, -1, 20, 0);	159	DEFINE_QNODE(slv_apss, MSM8939_SLAVE_APSS, 4, -1, -1, 0);
160	DEFINE_QNODE(slv_audio, MSM8939_SLAVE_LPASS, 4, -1, -1, 0);	160	DEFINE_QNODE(slv_audio, MSM8939_SLAVE_LPASS, 4, -1, -1, 0);
161	DEFINE_QNODE(slv_bimc_cfg, MSM8939_SLAVE_BIMC_CFG, 4, -1, -1, 0);	161	DEFINE_QNODE(slv_bimc_cfg, MSM8939_SLAVE_BIMC_CFG, 4, -1, -1, 0);
162	DEFINE_QNODE(slv_blsp_1, MSM8939_SLAVE_BLSP_1, 4, -1, -1, 0);	162	DEFINE_QNODE(slv_blsp_1, MSM8939_SLAVE_BLSP_1, 4, -1, -1, 0);
163	DEFINE_QNODE(slv_boot_rom, MSM8939_SLAVE_BOOT_ROM, 4, -1, -1, 0);	163	DEFINE_QNODE(slv_boot_rom, MSM8939_SLAVE_BOOT_ROM, 4, -1, -1, 0);
164	DEFINE_QNODE(slv_camera_cfg, MSM8939_SLAVE_CAMERA_CFG, 4, -1, -1, 0);	164	DEFINE_QNODE(slv_camera_cfg, MSM8939_SLAVE_CAMERA_CFG, 4, -1, -1, 0);
165	DEFINE_QNODE(slv_cats_0, MSM8939_SLAVE_CATS_128, 16, -1, 106, 0);	165	DEFINE_QNODE(slv_cats_0, MSM8939_SLAVE_CATS_128, 16, -1, -1, 0);
166	DEFINE_QNODE(slv_cats_1, MSM8939_SLAVE_OCMEM_64, 8, -1, 107, 0);	166	DEFINE_QNODE(slv_cats_1, MSM8939_SLAVE_OCMEM_64, 8, -1, -1, 0);
167	DEFINE_QNODE(slv_clk_ctl, MSM8939_SLAVE_CLK_CTL, 4, -1, -1, 0);	167	DEFINE_QNODE(slv_clk_ctl, MSM8939_SLAVE_CLK_CTL, 4, -1, -1, 0);
168	DEFINE_QNODE(slv_crypto_0_cfg, MSM8939_SLAVE_CRYPTO_0_CFG, 4, -1, -1, 0);	168	DEFINE_QNODE(slv_crypto_0_cfg, MSM8939_SLAVE_CRYPTO_0_CFG, 4, -1, -1, 0);
169	DEFINE_QNODE(slv_dehr_cfg, MSM8939_SLAVE_DEHR_CFG, 4, -1, -1, 0);	169	DEFINE_QNODE(slv_dehr_cfg, MSM8939_SLAVE_DEHR_CFG, 4, -1, -1, 0);
@@ -187,20 +187,20 @@ DEFINE_QNODE(slv_sdcc_2, MSM8939_SLAVE_SDCC_2, 4, -1, -1, 0); · 17 unmodified lines
187	DEFINE_QNODE(slv_security, MSM8939_SLAVE_SECURITY, 4, -1, -1, 0);	187	DEFINE_QNODE(slv_security, MSM8939_SLAVE_SECURITY, 4, -1, -1, 0);
188	DEFINE_QNODE(slv_snoc_cfg, MSM8939_SLAVE_SNOC_CFG, 4, -1, -1, 0);	188	DEFINE_QNODE(slv_snoc_cfg, MSM8939_SLAVE_SNOC_CFG, 4, -1, -1, 0);
189	DEFINE_QNODE(slv_spdm, MSM8939_SLAVE_SPDM, 4, -1, -1, 0);	189	DEFINE_QNODE(slv_spdm, MSM8939_SLAVE_SPDM, 4, -1, -1, 0);
190	DEFINE_QNODE(slv_srvc_snoc, MSM8939_SLAVE_SRVC_SNOC, 8, -1, 29, 0);	190	DEFINE_QNODE(slv_srvc_snoc, MSM8939_SLAVE_SRVC_SNOC, 8, -1, -1, 0);
191	DEFINE_QNODE(slv_tcsr, MSM8939_SLAVE_TCSR, 4, -1, -1, 0);	191	DEFINE_QNODE(slv_tcsr, MSM8939_SLAVE_TCSR, 4, -1, -1, 0);
192	DEFINE_QNODE(slv_tlmm, MSM8939_SLAVE_TLMM, 4, -1, -1, 0);	192	DEFINE_QNODE(slv_tlmm, MSM8939_SLAVE_TLMM, 4, -1, -1, 0);
193	DEFINE_QNODE(slv_usb_hs1, MSM8939_SLAVE_USB_HS1, 4, -1, -1, 0);	193	DEFINE_QNODE(slv_usb_hs1, MSM8939_SLAVE_USB_HS1, 4, -1, -1, 0);
194	DEFINE_QNODE(slv_usb_hs2, MSM8939_SLAVE_USB_HS2, 4, -1, -1, 0);	194	DEFINE_QNODE(slv_usb_hs2, MSM8939_SLAVE_USB_HS2, 4, -1, -1, 0);
195	DEFINE_QNODE(slv_venus_cfg, MSM8939_SLAVE_VENUS_CFG, 4, -1, -1, 0);	195	DEFINE_QNODE(slv_venus_cfg, MSM8939_SLAVE_VENUS_CFG, 4, -1, -1, 0);
196	DEFINE_QNODE(snoc_bimc_0_mas, MSM8939_SNOC_BIMC_0_MAS, 16, 3, -1, MSM8939_SNOC_BIMC_0_SLV);	196	DEFINE_QNODE(snoc_bimc_0_mas, MSM8939_SNOC_BIMC_0_MAS, 16, -1, -1, MSM8939_SNOC_BIMC_0_SLV);
197	DEFINE_QNODE(snoc_bimc_0_slv, MSM8939_SNOC_BIMC_0_SLV, 16, -1, 24, MSM8939_SLAVE_EBI_CH0);	197	DEFINE_QNODE(snoc_bimc_0_slv, MSM8939_SNOC_BIMC_0_SLV, 16, -1, -1, MSM8939_SLAVE_EBI_CH0);
198	DEFINE_QNODE(snoc_bimc_1_mas, MSM8939_SNOC_BIMC_1_MAS, 16, 76, -1, MSM8939_SNOC_BIMC_1_SLV);	198	DEFINE_QNODE(snoc_bimc_1_mas, MSM8939_SNOC_BIMC_1_MAS, 16, 76, -1, MSM8939_SNOC_BIMC_1_SLV);
199	DEFINE_QNODE(snoc_bimc_1_slv, MSM8939_SNOC_BIMC_1_SLV, 16, -1, 104, MSM8939_SLAVE_EBI_CH0);	199	DEFINE_QNODE(snoc_bimc_1_slv, MSM8939_SNOC_BIMC_1_SLV, 16, -1, 104, MSM8939_SLAVE_EBI_CH0);
200	DEFINE_QNODE(snoc_bimc_2_mas, MSM8939_SNOC_BIMC_2_MAS, 16, -1, -1, MSM8939_SNOC_BIMC_2_SLV);	200	DEFINE_QNODE(snoc_bimc_2_mas, MSM8939_SNOC_BIMC_2_MAS, 16, -1, -1, MSM8939_SNOC_BIMC_2_SLV);
201	DEFINE_QNODE(snoc_bimc_2_slv, MSM8939_SNOC_BIMC_2_SLV, 16, -1, -1, MSM8939_SLAVE_EBI_CH0);	201	DEFINE_QNODE(snoc_bimc_2_slv, MSM8939_SNOC_BIMC_2_SLV, 16, -1, -1, MSM8939_SLAVE_EBI_CH0);
202	DEFINE_QNODE(snoc_int_0, MSM8939_SNOC_INT_0, 8, 99, 130, MSM8939_SLAVE_QDSS_STM, MSM8939_SLAVE_IMEM, MSM8939_SNOC_PNOC_MAS);	202	DEFINE_QNODE(snoc_int_0, MSM8939_SNOC_INT_0, 8, 99, 130, MSM8939_SLAVE_QDSS_STM, MSM8939_SLAVE_IMEM, MSM8939_SNOC_PNOC_MAS);
203	DEFINE_QNODE(snoc_int_1, MSM8939_SNOC_INT_1, 8, 100, 131, MSM8939_SLAVE_APSS, MSM8939_SLAVE_CATS_128, MSM8939_SLAVE_OCMEM_64);	203	DEFINE_QNODE(snoc_int_1, MSM8939_SNOC_INT_1, 8, -1, -1, MSM8939_SLAVE_APSS, MSM8939_SLAVE_CATS_128, MSM8939_SLAVE_OCMEM_64);
204	DEFINE_QNODE(snoc_int_bimc, MSM8939_SNOC_INT_BIMC, 8, 101, 132, MSM8939_SNOC_BIMC_1_MAS);	204	DEFINE_QNODE(snoc_int_bimc, MSM8939_SNOC_INT_BIMC, 8, 101, 132, MSM8939_SNOC_BIMC_1_MAS);
205	DEFINE_QNODE(snoc_pcnoc_mas, MSM8939_SNOC_PNOC_MAS, 8, -1, -1, MSM8939_SNOC_PNOC_SLV);	205	DEFINE_QNODE(snoc_pcnoc_mas, MSM8939_SNOC_PNOC_MAS, 8, -1, -1, MSM8939_SNOC_PNOC_SLV);
206	DEFINE_QNODE(snoc_pcnoc_slv, MSM8939_SNOC_PNOC_SLV, 8, -1, -1, MSM8939_PNOC_INT_0);	206	DEFINE_QNODE(snoc_pcnoc_slv, MSM8939_SNOC_PNOC_SLV, 8, -1, -1, MSM8939_PNOC_INT_0);