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/ABI/testing/sysfs-fs-xfs+1−1

@@ -33,7 +33,7 @@ Contact: xfs@oss.sgi.com · 32 unmodified lines
33	Description:	33	Description:
34	The current state of the log write grant head. It	34	The current state of the log write grant head. It
35	represents the total log reservation of all currently	35	represents the total log reservation of all currently
36	oustanding transactions, including regrants due to	36	outstanding transactions, including regrants due to
37	rolling transactions. The grant head is exported in	37	rolling transactions. The grant head is exported in
38	"cycle:bytes" format.	38	"cycle:bytes" format.
39	Users: xfstests	39	Users: xfstests

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/devicetree/bindings/sound/fsl,spdif.yaml+4−0

       - fsl,vf610-spdif
       - fsl,imx6sx-spdif
       - fsl,imx8qm-spdif
+      - fsl,imx8qxp-spdif
+      - fsl,imx8mq-spdif
+      - fsl,imx8mm-spdif
+      - fsl,imx8mn-spdif
   reg:
     maxItems: 1

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

Documentation/virt/kvm/api.rst+6−3

 Define which vcpu is the Bootstrap Processor (BSP).  Values are the same
 as the vcpu id in KVM_CREATE_VCPU.  If this ioctl is not called, the default
-is vcpu 0.
+is vcpu 0. This ioctl has to be called before vcpu creation,
+otherwise it will return EBUSY error.
 4.42 KVM_GET_XSAVE
 allows user space to deflect and potentially handle various MSR accesses
 into user space.
-If a vCPU is in running state while this ioctl is invoked, the vCPU may
+Note, invoking this ioctl with a vCPU is running is inherently racy.  However,
-experience inconsistent filtering behavior on MSR accesses.
+KVM does guarantee that vCPUs will see either the previous filter or the new
+filter, e.g. MSRs with identical settings in both the old and new filter will
+have deterministic behavior.
 4.127 KVM_XEN_HVM_SET_ATTR
 --------------------------

MAINTAINERS+31−35

 M:	Christian Brauner <christian@brauner.io>
 M:	Hridya Valsaraju <hridya@google.com>
 M:	Suren Baghdasaryan <surenb@google.com>
-L:	devel@driverdev.osuosl.org
+L:	linux-kernel@vger.kernel.org
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
 F:	drivers/android/
 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/
 HISILICON STAGING DRIVERS FOR HIKEY 960/970
 M:	Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
-L:	devel@driverdev.osuosl.org
 S:	Maintained
 F:	drivers/staging/hikey9xx/
 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*
 STAGING SUBSYSTEM
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
-L:	devel@driverdev.osuosl.org
+L:	linux-staging@lists.linux.dev
 S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
 F:	drivers/staging/
 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
 M:	Martyn Welch <martyn@welchs.me.uk>
 M:	Manohar Vanga <manohar.vanga@gmail.com>
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
-L:	devel@driverdev.osuosl.org
+L:	linux-kernel@vger.kernel.org
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git
 F:	Documentation/driver-api/vme.rst

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 = -rc3	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/csky/kernel/probes/ftrace.c+1−1

@@ -9,7 +9,7 @@ int arch_check_ftrace_location(struct kprobe *p) · 8 unmodified lines
9	return 0;	9	return 0;
10	}	10	}
11		11
12	/* Ftrace callback handler for kprobes -- called under preepmt disabed */	12	/* Ftrace callback handler for kprobes -- called under preepmt disabled */
13	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,	13	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
14	struct ftrace_ops ops, struct ftrace_regs fregs)	14	struct ftrace_ops ops, struct ftrace_regs fregs)
15	{	15	{

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/mips/kernel/vmlinux.lds.S+1−1

@@ -176,7 +176,7 @@ SECTIONS · 175 unmodified lines
176	.fill : {	176	.fill : {
177	FILL(0);	177	FILL(0);
178	BYTE(0);	178	BYTE(0);
179	. = ALIGN(8);	179	STRUCT_ALIGN();
180	}	180	}
181	__appended_dtb = .;	181	__appended_dtb = .;
182	/* leave space for appended DTB */	182	/* leave space for appended DTB */

arch/powerpc/include/asm/cpu_has_feature.h+2−2

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	#include <linux/bug.h>	7	#include <linux/bug.h>
8	#include <asm/cputable.h>	8	#include <asm/cputable.h>
9		9
10	static inline bool early_cpu_has_feature(unsigned long feature)	10	static __always_inline bool early_cpu_has_feature(unsigned long feature)
11	{	11	{
12	return !!((CPU_FTRS_ALWAYS & feature) \|\|	12	return !!((CPU_FTRS_ALWAYS & feature) \|\|
13	(CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature));	13	(CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature));
@@ -46,7 +46,7 @@ static __always_inline bool cpu_has_feature(unsigned long feature) · 32 unmodified lines
46	return static_branch_likely(&cpu_feature_keys[i]);	46	return static_branch_likely(&cpu_feature_keys[i]);
47	}	47	}
48	#else	48	#else
49	static inline bool cpu_has_feature(unsigned long feature)	49	static __always_inline bool cpu_has_feature(unsigned long feature)
50	{	50	{
51	return early_cpu_has_feature(feature);	51	return early_cpu_has_feature(feature);
52	}	52	}

arch/powerpc/kernel/vdso32/gettimeofday.S+11−0

@@ -65,3 +65,14 @@ V_FUNCTION_END(__kernel_clock_getres) · 64 unmodified lines
65	V_FUNCTION_BEGIN(__kernel_time)	65	V_FUNCTION_BEGIN(__kernel_time)
66	cvdso_call_time __c_kernel_time	66	cvdso_call_time __c_kernel_time
67	V_FUNCTION_END(__kernel_time)	67	V_FUNCTION_END(__kernel_time)
		68
		69	/* Routines for restoring integer registers, called by the compiler. */
		70	/* Called with r11 pointing to the stack header word of the caller of the */
		71	/* function, just beyond the end of the integer restore area. */
		72	_GLOBAL(_restgpr_31_x)
		73	_GLOBAL(_rest32gpr_31_x)
		74	lwz r0,4(r11)
		75	lwz r31,-4(r11)
		76	mtlr r0
		77	mr r1,r11
		78	blr

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+3−3

 	select PCI_MSI if PCI
 	select RISCV_INTC
 	select RISCV_TIMER if RISCV_SBI
-	select SPARSEMEM_STATIC if 32BIT
 	select SPARSE_IRQ
 	select SYSCTL_EXCEPTION_TRACE
 	select THREAD_INFO_IN_TASK
 config ARCH_SPARSEMEM_ENABLE
 	def_bool y
 	depends on MMU
-	select SPARSEMEM_VMEMMAP_ENABLE
+	select SPARSEMEM_STATIC if 32BIT && SPARSMEM
+	select SPARSEMEM_VMEMMAP_ENABLE if 64BIT
 config ARCH_SELECT_MEMORY_MODEL
 	def_bool ARCH_SPARSEMEM_ENABLE
 # Common NUMA Features
 config NUMA
 	bool "NUMA Memory Allocation and Scheduler Support"
-	depends on SMP
+	depends on SMP && MMU
 	select GENERIC_ARCH_NUMA
 	select OF_NUMA
 	select ARCH_SUPPORTS_NUMA_BALANCING

arch/riscv/Kconfig.socs+2−0

@@ -31,6 +31,8 @@ config SOC_CANAAN · 30 unmodified lines
31	select SIFIVE_PLIC	31	select SIFIVE_PLIC
32	select ARCH_HAS_RESET_CONTROLLER	32	select ARCH_HAS_RESET_CONTROLLER
33	select PINCTRL	33	select PINCTRL
		34	select COMMON_CLK
		35	select COMMON_CLK_K210
34	help	36	help
35	This enables support for Canaan Kendryte K210 SoC platform hardware.	37	This enables support for Canaan Kendryte K210 SoC platform hardware.
36		38

arch/riscv/include/asm/asm-prototypes.h+16−0

@@ -9,4 +9,20 @@ long long __lshrti3(long long a, int b); · 8 unmodified lines
9	long long __ashrti3(long long a, int b);	9	long long __ashrti3(long long a, int b);
10	long long __ashlti3(long long a, int b);	10	long long __ashlti3(long long a, int b);
11		11
		12
		13	#define DECLARE_DO_ERROR_INFO(name) asmlinkage void name(struct pt_regs *regs)
		14
		15	DECLARE_DO_ERROR_INFO(do_trap_unknown);
		16	DECLARE_DO_ERROR_INFO(do_trap_insn_misaligned);
		17	DECLARE_DO_ERROR_INFO(do_trap_insn_fault);
		18	DECLARE_DO_ERROR_INFO(do_trap_insn_illegal);
		19	DECLARE_DO_ERROR_INFO(do_trap_load_fault);
		20	DECLARE_DO_ERROR_INFO(do_trap_load_misaligned);
		21	DECLARE_DO_ERROR_INFO(do_trap_store_misaligned);
		22	DECLARE_DO_ERROR_INFO(do_trap_store_fault);
		23	DECLARE_DO_ERROR_INFO(do_trap_ecall_u);
		24	DECLARE_DO_ERROR_INFO(do_trap_ecall_s);
		25	DECLARE_DO_ERROR_INFO(do_trap_ecall_m);
		26	DECLARE_DO_ERROR_INFO(do_trap_break);
		27
12	#endif /* _ASM_RISCV_PROTOTYPES_H */	28	#endif /* _ASM_RISCV_PROTOTYPES_H */

arch/riscv/include/asm/irq.h+2−0

@@ -12,4 +12,6 @@ · 11 unmodified lines
12		12
13	#include <asm-generic/irq.h>	13	#include <asm-generic/irq.h>
14		14
		15	extern void __init init_IRQ(void);
		16
15	#endif /* _ASM_RISCV_IRQ_H */	17	#endif /* _ASM_RISCV_IRQ_H */

arch/riscv/include/asm/processor.h+1−0

@@ -71,6 +71,7 @@ int riscv_of_processor_hartid(struct device_node *node); · 70 unmodified lines
71	int riscv_of_parent_hartid(struct device_node *node);	71	int riscv_of_parent_hartid(struct device_node *node);
72		72
73	extern void riscv_fill_hwcap(void);	73	extern void riscv_fill_hwcap(void);
		74	extern int arch_dup_task_struct(struct task_struct dst, struct task_struct src);
74		75
75	#endif /* __ASSEMBLY__ */	76	#endif /* __ASSEMBLY__ */
76		77

arch/riscv/include/asm/ptrace.h+5−0

 extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
 					       unsigned int n);
+void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
+			   unsigned long frame_pointer);
+int do_syscall_trace_enter(struct pt_regs *regs);
+void do_syscall_trace_exit(struct pt_regs *regs);
 /**
  * regs_get_register() - get register value from its offset
  * @regs:	pt_regs from which register value is gotten

arch/riscv/include/asm/sbi.h+2−2

 	SBI_EXT_RFENCE_REMOTE_FENCE_I = 0,
 	SBI_EXT_RFENCE_REMOTE_SFENCE_VMA,
 	SBI_EXT_RFENCE_REMOTE_SFENCE_VMA_ASID,
-	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA,
 	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA_VMID,
-	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA,
+	SBI_EXT_RFENCE_REMOTE_HFENCE_GVMA,
 	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA_ASID,
+	SBI_EXT_RFENCE_REMOTE_HFENCE_VVMA,
 };
 enum sbi_ext_hsm_fid {

arch/riscv/include/asm/timex.h+2−0

@@ -88,4 +88,6 @@ static inline int read_current_timer(unsigned long *timer_val) · 87 unmodified lines
88	return 0;	88	return 0;
89	}	89	}
90		90
		91	extern void time_init(void);
		92
91	#endif /* _ASM_RISCV_TIMEX_H */	93	#endif /* _ASM_RISCV_TIMEX_H */

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/Makefile+1−0

@@ -8,6 +8,7 @@ CFLAGS_REMOVE_ftrace.o = $(CC_FLAGS_FTRACE) · 7 unmodified lines
8	CFLAGS_REMOVE_patch.o = $(CC_FLAGS_FTRACE)	8	CFLAGS_REMOVE_patch.o = $(CC_FLAGS_FTRACE)
9	CFLAGS_REMOVE_sbi.o = $(CC_FLAGS_FTRACE)	9	CFLAGS_REMOVE_sbi.o = $(CC_FLAGS_FTRACE)
10	endif	10	endif
		11	CFLAGS_syscall_table.o += $(call cc-option,-Wno-override-init,)
11		12
12	extra-y += head.o	13	extra-y += head.o
13	extra-y += vmlinux.lds	14	extra-y += vmlinux.lds

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/probes/ftrace.c+10−8

 #include <linux/kprobes.h>
-/* Ftrace callback handler for kprobes -- called under preepmt disabed */
+/* Ftrace callback handler for kprobes -- called under preepmt disabled */
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
-			   struct ftrace_ops *ops, struct ftrace_regs *regs)
+			   struct ftrace_ops *ops, struct ftrace_regs *fregs)
 {
 	struct kprobe *p;
+	struct pt_regs *regs;
 	struct kprobe_ctlblk *kcb;
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (unlikely(!p) || kprobe_disabled(p))
 		return;
+	regs = ftrace_get_regs(fregs);
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
 	} else {
-		unsigned long orig_ip = instruction_pointer(&(regs->regs));
+		unsigned long orig_ip = instruction_pointer(regs);
-		instruction_pointer_set(&(regs->regs), ip);
+		instruction_pointer_set(regs, ip);
 		__this_cpu_write(current_kprobe, p);
 		kcb->kprobe_status = KPROBE_HIT_ACTIVE;
-		if (!p->pre_handler || !p->pre_handler(p, &(regs->regs))) {
+		if (!p->pre_handler || !p->pre_handler(p, regs)) {
 			/*
 			 * Emulate singlestep (and also recover regs->pc)
 			 * as if there is a nop
 			 */
-			instruction_pointer_set(&(regs->regs),
+			instruction_pointer_set(regs,
 				(unsigned long)p->addr + MCOUNT_INSN_SIZE);
 			if (unlikely(p->post_handler)) {
 				kcb->kprobe_status = KPROBE_HIT_SSDONE;
-				p->post_handler(p, &(regs->regs), 0);
+				p->post_handler(p, regs, 0);
 			}
-			instruction_pointer_set(&(regs->regs), orig_ip);
+			instruction_pointer_set(regs, orig_ip);
 		}
 		/*

arch/riscv/kernel/probes/kprobes.c+1−2

@@ -256,8 +256,7 @@ int __kprobes kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr) · 255 unmodified lines
256	* normal page fault.	256	* normal page fault.
257	*/	257	*/
258	regs->epc = (unsigned long) cur->addr;	258	regs->epc = (unsigned long) cur->addr;
259	if (!instruction_pointer(regs))	259	BUG_ON(!instruction_pointer(regs));
260	BUG();
261		260
262	if (kcb->kprobe_status == KPROBE_REENTER)	261	if (kcb->kprobe_status == KPROBE_REENTER)
263	restore_previous_kprobe(kcb);	262	restore_previous_kprobe(kcb);

arch/riscv/kernel/process.c+1−0

@@ -10,6 +10,7 @@ · 9 unmodified lines
10	#include <linux/cpu.h>	10	#include <linux/cpu.h>
11	#include <linux/kernel.h>	11	#include <linux/kernel.h>
12	#include <linux/sched.h>	12	#include <linux/sched.h>
		13	#include <linux/sched/debug.h>
13	#include <linux/sched/task_stack.h>	14	#include <linux/sched/task_stack.h>
14	#include <linux/tick.h>	15	#include <linux/tick.h>
15	#include <linux/ptrace.h>	16	#include <linux/ptrace.h>

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

@@ -116,7 +116,7 @@ void sbi_clear_ipi(void) · 115 unmodified lines
116	EXPORT_SYMBOL(sbi_clear_ipi);	116	EXPORT_SYMBOL(sbi_clear_ipi);
117		117
118	/**	118	/**
119	* sbi_set_timer_v01() - Program the timer for next timer event.	119	* __sbi_set_timer_v01() - Program the timer for next timer event.
120	* @stime_value: The value after which next timer event should fire.	120	* @stime_value: The value after which next timer event should fire.
121	*	121	*
122	* Return: None	122	* Return: None

arch/riscv/kernel/setup.c+2−1

@@ -147,7 +147,8 @@ static void __init init_resources(void) · 146 unmodified lines
147	bss_res.end = __pa_symbol(__bss_stop) - 1;	147	bss_res.end = __pa_symbol(__bss_stop) - 1;
148	bss_res.flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;	148	bss_res.flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;
149		149
150	mem_res_sz = (memblock.memory.cnt + memblock.reserved.cnt) * sizeof(*mem_res);	150	/* + 1 as memblock_alloc() might increase memblock.reserved.cnt */
		151	mem_res_sz = (memblock.memory.cnt + memblock.reserved.cnt + 1) * sizeof(*mem_res);
151	mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES);	152	mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES);
152	if (!mem_res)	153	if (!mem_res)
153	panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz);	154	panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz);

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/kernel/time.c+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#include <linux/delay.h>	9	#include <linux/delay.h>
10	#include <asm/sbi.h>	10	#include <asm/sbi.h>
11	#include <asm/processor.h>	11	#include <asm/processor.h>
		12	#include <asm/timex.h>
12		13
13	unsigned long riscv_timebase;	14	unsigned long riscv_timebase;
14	EXPORT_SYMBOL_GPL(riscv_timebase);	15	EXPORT_SYMBOL_GPL(riscv_timebase);

arch/riscv/kernel/traps.c+1−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/module.h>	17	#include <linux/module.h>
18	#include <linux/irq.h>	18	#include <linux/irq.h>
19		19
		20	#include <asm/asm-prototypes.h>
20	#include <asm/bug.h>	21	#include <asm/bug.h>
21	#include <asm/processor.h>	22	#include <asm/processor.h>
22	#include <asm/ptrace.h>	23	#include <asm/ptrace.h>

arch/riscv/mm/kasan_init.c+4−2

 	memset(start, KASAN_SHADOW_INIT, end - start);
 }
-void __init kasan_shallow_populate(void *start, void *end)
+static void __init kasan_shallow_populate(void *start, void *end)
 {
 	unsigned long vaddr = (unsigned long)start & PAGE_MASK;
 	unsigned long vend = PAGE_ALIGN((unsigned long)end);
 		}
 		vaddr += PAGE_SIZE;
 	}
+	local_flush_tlb_all();
 }
 void __init kasan_init(void)
 			break;
 		kasan_populate(kasan_mem_to_shadow(start), kasan_mem_to_shadow(end));
-	};
+	}
 	for (i = 0; i < PTRS_PER_PTE; i++)
 		set_pte(&kasan_early_shadow_pte[i],

arch/s390/include/asm/pci.h+1−1

@@ -202,7 +202,7 @@ extern unsigned int s390_pci_no_rid; · 201 unmodified lines
202	----------------------------------------------------------------------------- */	202	----------------------------------------------------------------------------- */
203	/* Base stuff */	203	/* Base stuff */
204	int zpci_create_device(u32 fid, u32 fh, enum zpci_state state);	204	int zpci_create_device(u32 fid, u32 fh, enum zpci_state state);
205	void zpci_remove_device(struct zpci_dev *zdev);	205	void zpci_remove_device(struct zpci_dev *zdev, bool set_error);
206	int zpci_enable_device(struct zpci_dev *);	206	int zpci_enable_device(struct zpci_dev *);
207	int zpci_disable_device(struct zpci_dev *);	207	int zpci_disable_device(struct zpci_dev *);
208	int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);	208	int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);

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/perf_cpum_cf_diag.c+2−1

  */
 static size_t cf_diag_needspace(unsigned int sets)
 {
-	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);
+	struct cpu_cf_events *cpuhw = get_cpu_ptr(&cpu_cf_events);
 	size_t bytes = 0;
 	int i;
 		     sizeof(((struct s390_ctrset_cpudata *)0)->no_sets));
 	debug_sprintf_event(cf_diag_dbg, 5, "%s bytes %ld\n", __func__,
 			    bytes);
+	put_cpu_ptr(&cpu_cf_events);
 	return bytes;
 }

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/s390/kernel/vtime.c+1−1

@@ -214,7 +214,7 @@ void vtime_flush(struct task_struct *tsk) · 213 unmodified lines
214	avg_steal = S390_lowcore.avg_steal_timer / 2;	214	avg_steal = S390_lowcore.avg_steal_timer / 2;
215	if ((s64) steal > 0) {	215	if ((s64) steal > 0) {
216	S390_lowcore.steal_timer = 0;	216	S390_lowcore.steal_timer = 0;
217	account_steal_time(steal);	217	account_steal_time(cputime_to_nsecs(steal));
218	avg_steal += steal;	218	avg_steal += steal;
219	}	219	}
220	S390_lowcore.avg_steal_timer = avg_steal;	220	S390_lowcore.avg_steal_timer = avg_steal;

arch/s390/pci/pci.c+24−4

 }
 EXPORT_SYMBOL_GPL(zpci_disable_device);
-void zpci_remove_device(struct zpci_dev *zdev)
+/* zpci_remove_device - Removes the given zdev from the PCI core
+ * @zdev: the zdev to be removed from the PCI core
+ * @set_error: if true the device's error state is set to permanent failure
+ *
+ * Sets a zPCI device to a configured but offline state; the zPCI
+ * device is still accessible through its hotplug slot and the zPCI
+ * API but is removed from the common code PCI bus, making it
+ * no longer available to drivers.
+ */
+void zpci_remove_device(struct zpci_dev *zdev, bool set_error)
 {
 	struct zpci_bus *zbus = zdev->zbus;
 	struct pci_dev *pdev;
+	if (!zdev->zbus->bus)
+		return;
 	pdev = pci_get_slot(zbus->bus, zdev->devfn);
 	if (pdev) {
-		if (pdev->is_virtfn)
+		if (set_error)
-			return zpci_iov_remove_virtfn(pdev, zdev->vfn);
+			pdev->error_state = pci_channel_io_perm_failure;
+		if (pdev->is_virtfn) {
+			zpci_iov_remove_virtfn(pdev, zdev->vfn);
+			/* balance pci_get_slot */
+			pci_dev_put(pdev);
+			return;
+		}
 		pci_stop_and_remove_bus_device_locked(pdev);
+		/* balance pci_get_slot */
+		pci_dev_put(pdev);
 	}
 }
 	struct zpci_dev *zdev = container_of(kref, struct zpci_dev, kref);
 	if (zdev->zbus->bus)
-		zpci_remove_device(zdev);
+		zpci_remove_device(zdev, false);
 	switch (zdev->state) {
 	case ZPCI_FN_STATE_ONLINE:

arch/s390/pci/pci_event.c+6−12

 static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf)
 {
 	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
-	struct pci_dev *pdev = NULL;
 	enum zpci_state state;
+	struct pci_dev *pdev;
 	int ret;
-	if (zdev && zdev->zbus->bus)
-		pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);
 	zpci_err("avail CCDF:\n");
 	zpci_err_hex(ccdf, sizeof(*ccdf));
 	case 0x0303: /* Deconfiguration requested */
 		if (!zdev)
 			break;
-		if (pdev)
+		zpci_remove_device(zdev, false);
-			zpci_remove_device(zdev);
 		ret = zpci_disable_device(zdev);
 		if (ret)
 	case 0x0304: /* Configured -> Standby|Reserved */
 		if (!zdev)
 			break;
-		if (pdev) {
+		/* Give the driver a hint that the function is
-			/* Give the driver a hint that the function is
+		 * already unusable.
-			 * already unusable. */
+		 */
-			pdev->error_state = pci_channel_io_perm_failure;
+		zpci_remove_device(zdev, true);
-			zpci_remove_device(zdev);
-		}
 		zdev->fh = ccdf->fh;
 		zpci_disable_device(zdev);

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/events/intel/core.c+3−0

@@ -3659,6 +3659,9 @@ static int intel_pmu_hw_config(struct perf_event *event) · 3658 unmodified lines
3659	return ret;	3659	return ret;
3660		3660
3661	if (event->attr.precise_ip) {	3661	if (event->attr.precise_ip) {
		3662	if ((event->attr.config & INTEL_ARCH_EVENT_MASK) == INTEL_FIXED_VLBR_EVENT)
		3663	return -EINVAL;
		3664
3662	if (!(event->attr.freq \|\| (event->attr.wakeup_events && !event->attr.watermark))) {	3665	if (!(event->attr.freq \|\| (event->attr.wakeup_events && !event->attr.watermark))) {
3663	event->hw.flags \|= PERF_X86_EVENT_AUTO_RELOAD;	3666	event->hw.flags \|= PERF_X86_EVENT_AUTO_RELOAD;
3664	if (!(event->attr.sample_type &	3667	if (!(event->attr.sample_type &

arch/x86/events/intel/ds.c+1−1

@@ -2010,7 +2010,7 @@ static void intel_pmu_drain_pebs_nhm(struct pt_regs *iregs, struct perf_sample_d · 2009 unmodified lines
2010	*/	2010	*/
2011	if (!pebs_status && cpuc->pebs_enabled &&	2011	if (!pebs_status && cpuc->pebs_enabled &&
2012	!(cpuc->pebs_enabled & (cpuc->pebs_enabled-1)))	2012	!(cpuc->pebs_enabled & (cpuc->pebs_enabled-1)))
2013	pebs_status = cpuc->pebs_enabled;	2013	pebs_status = p->status = cpuc->pebs_enabled;
2014		2014
2015	bit = find_first_bit((unsigned long *)&pebs_status,	2015	bit = find_first_bit((unsigned long *)&pebs_status,
2016	x86_pmu.max_pebs_events);	2016	x86_pmu.max_pebs_events);

arch/x86/include/asm/kvm_host.h+26−8

@@ -884,12 +884,29 @@ struct kvm_hv_syndbg { · 883 unmodified lines
884	u64 options;	884	u64 options;
885	};	885	};
886		886
		887	/* Current state of Hyper-V TSC page clocksource */
		888	enum hv_tsc_page_status {
		889	/* TSC page was not set up or disabled */
		890	HV_TSC_PAGE_UNSET = 0,
		891	/* TSC page MSR was written by the guest, update pending */
		892	HV_TSC_PAGE_GUEST_CHANGED,
		893	/* TSC page MSR was written by KVM userspace, update pending */
		894	HV_TSC_PAGE_HOST_CHANGED,
		895	/* TSC page was properly set up and is currently active */
		896	HV_TSC_PAGE_SET,
		897	/* TSC page is currently being updated and therefore is inactive */
		898	HV_TSC_PAGE_UPDATING,
		899	/* TSC page was set up with an inaccessible GPA */
		900	HV_TSC_PAGE_BROKEN,
		901	};
		902
887	/* Hyper-V emulation context */	903	/* Hyper-V emulation context */
888	struct kvm_hv {	904	struct kvm_hv {
889	struct mutex hv_lock;	905	struct mutex hv_lock;
890	u64 hv_guest_os_id;	906	u64 hv_guest_os_id;
891	u64 hv_hypercall;	907	u64 hv_hypercall;
892	u64 hv_tsc_page;	908	u64 hv_tsc_page;
		909	enum hv_tsc_page_status hv_tsc_page_status;
893		910
894	/* Hyper-v based guest crash (NT kernel bugcheck) parameters */	911	/* Hyper-v based guest crash (NT kernel bugcheck) parameters */
895	u64 hv_crash_param[HV_X64_MSR_CRASH_PARAMS];	912	u64 hv_crash_param[HV_X64_MSR_CRASH_PARAMS];
@@ -931,6 +948,12 @@ enum kvm_irqchip_mode { · 35 unmodified lines
931	KVM_IRQCHIP_SPLIT, /* created with KVM_CAP_SPLIT_IRQCHIP */	948	KVM_IRQCHIP_SPLIT, /* created with KVM_CAP_SPLIT_IRQCHIP */
932	};	949	};
933		950
		951	struct kvm_x86_msr_filter {
		952	u8 count;
		953	bool default_allow:1;
		954	struct msr_bitmap_range ranges[16];
		955	};
		956
934	#define APICV_INHIBIT_REASON_DISABLE 0	957	#define APICV_INHIBIT_REASON_DISABLE 0
935	#define APICV_INHIBIT_REASON_HYPERV 1	958	#define APICV_INHIBIT_REASON_HYPERV 1
936	#define APICV_INHIBIT_REASON_NESTED 2	959	#define APICV_INHIBIT_REASON_NESTED 2
@@ -1025,16 +1048,11 @@ struct kvm_arch { · 88 unmodified lines
1025	bool guest_can_read_msr_platform_info;	1048	bool guest_can_read_msr_platform_info;
1026	bool exception_payload_enabled;	1049	bool exception_payload_enabled;
1027		1050
		1051	bool bus_lock_detection_enabled;
		1052
1028	/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */	1053	/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */
1029	u32 user_space_msr_mask;	1054	u32 user_space_msr_mask;
1030		1055	struct kvm_x86_msr_filter __rcu *msr_filter;
1031	struct {
1032	u8 count;
1033	bool default_allow:1;
1034	struct msr_bitmap_range ranges[16];
1035	} msr_filter;
1036
1037	bool bus_lock_detection_enabled;
1038		1056
1039	struct kvm_pmu_event_filter __rcu *pmu_event_filter;	1057	struct kvm_pmu_event_filter __rcu *pmu_event_filter;
1040	struct task_struct *nx_lpage_recovery_thread;	1058	struct task_struct *nx_lpage_recovery_thread;

arch/x86/include/asm/processor.h+0−9

@@ -551,15 +551,6 @@ static inline void arch_thread_struct_whitelist(unsigned long *offset, · 550 unmodified lines
551	*size = fpu_kernel_xstate_size;	551	*size = fpu_kernel_xstate_size;
552	}	552	}
553		553
554	/*
555	* Thread-synchronous status.
556	*
557	* This is different from the flags in that nobody else
558	* ever touches our thread-synchronous status, so we don't
559	* have to worry about atomic accesses.
560	*/
561	#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
562
563	static inline void	554	static inline void
564	native_load_sp0(unsigned long sp0)	555	native_load_sp0(unsigned long sp0)
565	{	556	{

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/thread_info.h+14−1

@@ -205,10 +205,23 @@ static inline int arch_within_stack_frames(const void * const stack, · 204 unmodified lines
205		205
206	#endif	206	#endif
207		207
		208	/*
		209	* Thread-synchronous status.
		210	*
		211	* This is different from the flags in that nobody else
		212	* ever touches our thread-synchronous status, so we don't
		213	* have to worry about atomic accesses.
		214	*/
		215	#define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/
		216
		217	#ifndef __ASSEMBLY__
208	#ifdef CONFIG_COMPAT	218	#ifdef CONFIG_COMPAT
209	#define TS_I386_REGS_POKED 0x0004 /* regs poked by 32-bit ptracer */	219	#define TS_I386_REGS_POKED 0x0004 /* regs poked by 32-bit ptracer */
		220
		221	#define arch_set_restart_data(restart) \
		222	do { restart->arch_data = current_thread_info()->status; } while (0)
		223
210	#endif	224	#endif
211	#ifndef __ASSEMBLY__
212		225
213	#ifdef CONFIG_X86_32	226	#ifdef CONFIG_X86_32
214	#define in_ia32_syscall() true	227	#define in_ia32_syscall() true

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/apic/apic.c+5−0

 	[0 ... NR_CPUS - 1] = -1,
 };
+bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
+{
+	return phys_id == cpuid_to_apicid[cpu];
+}
 #ifdef CONFIG_SMP
 /**
  * apic_id_is_primary_thread - Check whether APIC ID belongs to a primary thread

arch/x86/kernel/apic/io_apic.c+10−0

@@ -1032,6 +1032,16 @@ static int mp_map_pin_to_irq(u32 gsi, int idx, int ioapic, int pin, · 1031 unmodified lines
1032	if (idx >= 0 && test_bit(mp_irqs[idx].srcbus, mp_bus_not_pci)) {	1032	if (idx >= 0 && test_bit(mp_irqs[idx].srcbus, mp_bus_not_pci)) {
1033	irq = mp_irqs[idx].srcbusirq;	1033	irq = mp_irqs[idx].srcbusirq;
1034	legacy = mp_is_legacy_irq(irq);	1034	legacy = mp_is_legacy_irq(irq);
		1035	/*
		1036	* IRQ2 is unusable for historical reasons on systems which
		1037	* have a legacy PIC. See the comment vs. IRQ2 further down.
		1038	*
		1039	* If this gets removed at some point then the related code
		1040	* in lapic_assign_system_vectors() needs to be adjusted as
		1041	* well.
		1042	*/
		1043	if (legacy && irq == PIC_CASCADE_IR)
		1044	return -EINVAL;
1035	}	1045	}
1036		1046
1037	mutex_lock(&ioapic_mutex);	1047	mutex_lock(&ioapic_mutex);

arch/x86/kernel/kprobes/ftrace.c+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12		12
13	#include "common.h"	13	#include "common.h"
14		14
15	/* Ftrace callback handler for kprobes -- called under preepmt disabed */	15	/* Ftrace callback handler for kprobes -- called under preepmt disabled */
16	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,	16	void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
17	struct ftrace_ops ops, struct ftrace_regs fregs)	17	struct ftrace_ops ops, struct ftrace_regs fregs)
18	{	18	{

arch/x86/kernel/kvm.c+10−13

 static void kvm_wait(u8 *ptr, u8 val)
 {
-	unsigned long flags;
 	if (in_nmi())
 		return;
-	local_irq_save(flags);
-	if (READ_ONCE(*ptr) != val)
-		goto out;
 	/*
 	 * halt until it's our turn and kicked. Note that we do safe halt
 	 * for irq enabled case to avoid hang when lock info is overwritten
 	 * in irq spinlock slowpath and no spurious interrupt occur to save us.
 	 */
-	if (arch_irqs_disabled_flags(flags))
+	if (irqs_disabled()) {
-		halt();
+		if (READ_ONCE(*ptr) == val)
-	else
+			halt();
-		safe_halt();
+	} else {
+		local_irq_disable();
-out:
+		if (READ_ONCE(*ptr) == val)
-	local_irq_restore(flags);
+			safe_halt();
+		local_irq_enable();
+	}
 }
 #ifdef CONFIG_X86_32

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/signal.c+1−23

@@ -766,30 +766,8 @@ handle_signal(struct ksignal ksig, struct pt_regs regs) · 765 unmodified lines
766		766
767	static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)	767	static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)
768	{	768	{
769	/*
770	* This function is fundamentally broken as currently
771	* implemented.
772	*
773	* The idea is that we want to trigger a call to the
774	* restart_block() syscall and that we want in_ia32_syscall(),
775	* in_x32_syscall(), etc. to match whatever they were in the
776	* syscall being restarted. We assume that the syscall
777	* instruction at (regs->ip - 2) matches whatever syscall
778	* instruction we used to enter in the first place.
779	*
780	* The problem is that we can get here when ptrace pokes
781	* syscall-like values into regs even if we're not in a syscall
782	* at all.
783	*
784	* For now, we maintain historical behavior and guess based on
785	* stored state. We could do better by saving the actual
786	* syscall arch in restart_block or (with caveats on x32) by
787	* checking if regs->ip points to 'int $0x80'. The current
788	* behavior is incorrect if a tracer has a different bitness
789	* than the tracee.
790	*/
791	#ifdef CONFIG_IA32_EMULATION	769	#ifdef CONFIG_IA32_EMULATION
792	if (current_thread_info()->status & (TS_COMPAT\|TS_I386_REGS_POKED))	770	if (current->restart_block.arch_data & TS_COMPAT)
793	return __NR_ia32_restart_syscall;	771	return __NR_ia32_restart_syscall;
794	#endif	772	#endif
795	#ifdef CONFIG_X86_X32_ABI	773	#ifdef CONFIG_X86_X32_ABI

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/hyperv.c+81−10

@@ -520,10 +520,10 @@ static u64 get_time_ref_counter(struct kvm *kvm) · 519 unmodified lines
520	u64 tsc;	520	u64 tsc;
521		521
522	/*	522	/*
523	* The guest has not set up the TSC page or the clock isn't	523	* Fall back to get_kvmclock_ns() when TSC page hasn't been set up,
524	* stable, fall back to get_kvmclock_ns.	524	* is broken, disabled or being updated.
525	*/	525	*/
526	if (!hv->tsc_ref.tsc_sequence)	526	if (hv->hv_tsc_page_status != HV_TSC_PAGE_SET)
527	return div_u64(get_kvmclock_ns(kvm), 100);	527	return div_u64(get_kvmclock_ns(kvm), 100);
528		528
529	vcpu = kvm_get_vcpu(kvm, 0);	529	vcpu = kvm_get_vcpu(kvm, 0);
@@ -1077,6 +1077,21 @@ static bool compute_tsc_page_parameters(struct pvclock_vcpu_time_info *hv_clock, · 547 unmodified lines
1077	return true;	1077	return true;
1078	}	1078	}
1079		1079
		1080	/*
		1081	* Don't touch TSC page values if the guest has opted for TSC emulation after
		1082	* migration. KVM doesn't fully support reenlightenment notifications and TSC
		1083	* access emulation and Hyper-V is known to expect the values in TSC page to
		1084	* stay constant before TSC access emulation is disabled from guest side
		1085	* (HV_X64_MSR_TSC_EMULATION_STATUS). KVM userspace is expected to preserve TSC
		1086	* frequency and guest visible TSC value across migration (and prevent it when
		1087	* TSC scaling is unsupported).
		1088	*/
		1089	static inline bool tsc_page_update_unsafe(struct kvm_hv *hv)
		1090	{
		1091	return (hv->hv_tsc_page_status != HV_TSC_PAGE_GUEST_CHANGED) &&
		1092	hv->hv_tsc_emulation_control;
		1093	}
		1094
1080	void kvm_hv_setup_tsc_page(struct kvm *kvm,	1095	void kvm_hv_setup_tsc_page(struct kvm *kvm,
1081	struct pvclock_vcpu_time_info *hv_clock)	1096	struct pvclock_vcpu_time_info *hv_clock)
1082	{	1097	{
@@ -1087,7 +1102,8 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 4 unmodified lines
1087	BUILD_BUG_ON(sizeof(tsc_seq) != sizeof(hv->tsc_ref.tsc_sequence));	1102	BUILD_BUG_ON(sizeof(tsc_seq) != sizeof(hv->tsc_ref.tsc_sequence));
1088	BUILD_BUG_ON(offsetof(struct ms_hyperv_tsc_page, tsc_sequence) != 0);	1103	BUILD_BUG_ON(offsetof(struct ms_hyperv_tsc_page, tsc_sequence) != 0);
1089		1104
1090	if (!(hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE))	1105	if (hv->hv_tsc_page_status == HV_TSC_PAGE_BROKEN \|\|
		1106	hv->hv_tsc_page_status == HV_TSC_PAGE_UNSET)
1091	return;	1107	return;
1092		1108
1093	mutex_lock(&hv->hv_lock);	1109	mutex_lock(&hv->hv_lock);
@@ -1101,7 +1117,15 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 7 unmodified lines
1101	*/	1117	*/
1102	if (unlikely(kvm_read_guest(kvm, gfn_to_gpa(gfn),	1118	if (unlikely(kvm_read_guest(kvm, gfn_to_gpa(gfn),
1103	&tsc_seq, sizeof(tsc_seq))))	1119	&tsc_seq, sizeof(tsc_seq))))
		1120	goto out_err;
		1121
		1122	if (tsc_seq && tsc_page_update_unsafe(hv)) {
		1123	if (kvm_read_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))
		1124	goto out_err;
		1125
		1126	hv->hv_tsc_page_status = HV_TSC_PAGE_SET;
1104	goto out_unlock;	1127	goto out_unlock;
		1128	}
1105		1129
1106	/*	1130	/*
1107	* While we're computing and writing the parameters, force the	1131	* While we're computing and writing the parameters, force the
@@ -1110,15 +1134,15 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 2 unmodified lines
1110	hv->tsc_ref.tsc_sequence = 0;	1134	hv->tsc_ref.tsc_sequence = 0;
1111	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),	1135	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
1112	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))	1136	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
1113	goto out_unlock;	1137	goto out_err;
1114		1138
1115	if (!compute_tsc_page_parameters(hv_clock, &hv->tsc_ref))	1139	if (!compute_tsc_page_parameters(hv_clock, &hv->tsc_ref))
1116	goto out_unlock;	1140	goto out_err;
1117		1141
1118	/* Ensure sequence is zero before writing the rest of the struct. */	1142	/* Ensure sequence is zero before writing the rest of the struct. */
1119	smp_wmb();	1143	smp_wmb();
1120	if (kvm_write_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))	1144	if (kvm_write_guest(kvm, gfn_to_gpa(gfn), &hv->tsc_ref, sizeof(hv->tsc_ref)))
1121	goto out_unlock;	1145	goto out_err;
1122		1146
1123	/*	1147	/*
1124	* Now switch to the TSC page mechanism by writing the sequence.	1148	* Now switch to the TSC page mechanism by writing the sequence.
@@ -1131,8 +1155,45 @@ void kvm_hv_setup_tsc_page(struct kvm *kvm, · 6 unmodified lines
1131	smp_wmb();	1155	smp_wmb();
1132		1156
1133	hv->tsc_ref.tsc_sequence = tsc_seq;	1157	hv->tsc_ref.tsc_sequence = tsc_seq;
1134	kvm_write_guest(kvm, gfn_to_gpa(gfn),	1158	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
1135	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence));	1159	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
		1160	goto out_err;
		1161
		1162	hv->hv_tsc_page_status = HV_TSC_PAGE_SET;
		1163	goto out_unlock;
		1164
		1165	out_err:
		1166	hv->hv_tsc_page_status = HV_TSC_PAGE_BROKEN;
		1167	out_unlock:
		1168	mutex_unlock(&hv->hv_lock);
		1169	}
		1170
		1171	void kvm_hv_invalidate_tsc_page(struct kvm *kvm)
		1172	{
		1173	struct kvm_hv *hv = to_kvm_hv(kvm);
		1174	u64 gfn;
		1175
		1176	if (hv->hv_tsc_page_status == HV_TSC_PAGE_BROKEN \|\|
		1177	hv->hv_tsc_page_status == HV_TSC_PAGE_UNSET \|\|
		1178	tsc_page_update_unsafe(hv))
		1179	return;
		1180
		1181	mutex_lock(&hv->hv_lock);
		1182
		1183	if (!(hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE))
		1184	goto out_unlock;
		1185
		1186	/* Preserve HV_TSC_PAGE_GUEST_CHANGED/HV_TSC_PAGE_HOST_CHANGED states */
		1187	if (hv->hv_tsc_page_status == HV_TSC_PAGE_SET)
		1188	hv->hv_tsc_page_status = HV_TSC_PAGE_UPDATING;
		1189
		1190	gfn = hv->hv_tsc_page >> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT;
		1191
		1192	hv->tsc_ref.tsc_sequence = 0;
		1193	if (kvm_write_guest(kvm, gfn_to_gpa(gfn),
		1194	&hv->tsc_ref, sizeof(hv->tsc_ref.tsc_sequence)))
		1195	hv->hv_tsc_page_status = HV_TSC_PAGE_BROKEN;
		1196
1136	out_unlock:	1197	out_unlock:
1137	mutex_unlock(&hv->hv_lock);	1198	mutex_unlock(&hv->hv_lock);
1138	}	1199	}
@@ -1193,8 +1254,15 @@ static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data, · 54 unmodified lines
1193	}	1254	}
1194	case HV_X64_MSR_REFERENCE_TSC:	1255	case HV_X64_MSR_REFERENCE_TSC:
1195	hv->hv_tsc_page = data;	1256	hv->hv_tsc_page = data;
1196	if (hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE)	1257	if (hv->hv_tsc_page & HV_X64_MSR_TSC_REFERENCE_ENABLE) {
		1258	if (!host)
		1259	hv->hv_tsc_page_status = HV_TSC_PAGE_GUEST_CHANGED;
		1260	else
		1261	hv->hv_tsc_page_status = HV_TSC_PAGE_HOST_CHANGED;
1197	kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);	1262	kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);
		1263	} else {
		1264	hv->hv_tsc_page_status = HV_TSC_PAGE_UNSET;
		1265	}
1198	break;	1266	break;
1199	case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:	1267	case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:
1200	return kvm_hv_msr_set_crash_data(kvm,	1268	return kvm_hv_msr_set_crash_data(kvm,
@@ -1229,6 +1297,9 @@ static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data, · 28 unmodified lines
1229	hv->hv_tsc_emulation_control = data;	1297	hv->hv_tsc_emulation_control = data;
1230	break;	1298	break;
1231	case HV_X64_MSR_TSC_EMULATION_STATUS:	1299	case HV_X64_MSR_TSC_EMULATION_STATUS:
		1300	if (data && !host)
		1301	return 1;
		1302
1232	hv->hv_tsc_emulation_status = data;	1303	hv->hv_tsc_emulation_status = data;
1233	break;	1304	break;
1234	case HV_X64_MSR_TIME_REF_COUNT:	1305	case HV_X64_MSR_TIME_REF_COUNT:

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

@@ -133,6 +133,7 @@ void kvm_hv_process_stimers(struct kvm_vcpu *vcpu); · 132 unmodified lines
133		133
134	void kvm_hv_setup_tsc_page(struct kvm *kvm,	134	void kvm_hv_setup_tsc_page(struct kvm *kvm,
135	struct pvclock_vcpu_time_info *hv_clock);	135	struct pvclock_vcpu_time_info *hv_clock);
		136	void kvm_hv_invalidate_tsc_page(struct kvm *kvm);
136		137
137	void kvm_hv_init_vm(struct kvm *kvm);	138	void kvm_hv_init_vm(struct kvm *kvm);
138	void kvm_hv_destroy_vm(struct kvm *kvm);	139	void kvm_hv_destroy_vm(struct kvm *kvm);

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/mmu_internal.h+5−0

 	return to_shadow_page(__pa(sptep));
 }
+static inline int kvm_mmu_page_as_id(struct kvm_mmu_page *sp)
+{
+	return sp->role.smm ? 1 : 0;
+}
 static inline bool kvm_vcpu_ad_need_write_protect(struct kvm_vcpu *vcpu)
 {
 	/*

arch/x86/kvm/mmu/tdp_iter.c+18−12

 	return gfn & -KVM_PAGES_PER_HPAGE(level);
 }
+/*
+ * Return the TDP iterator to the root PT and allow it to continue its
+ * traversal over the paging structure from there.
+ */
+void tdp_iter_restart(struct tdp_iter *iter)
+{
+	iter->yielded_gfn = iter->next_last_level_gfn;
+	iter->level = iter->root_level;
+	iter->gfn = round_gfn_for_level(iter->next_last_level_gfn, iter->level);
+	tdp_iter_refresh_sptep(iter);
+	iter->valid = true;
+}
 /*
  * Sets a TDP iterator to walk a pre-order traversal of the paging structure
  * rooted at root_pt, starting with the walk to translate next_last_level_gfn.
 	WARN_ON(root_level > PT64_ROOT_MAX_LEVEL);
 	iter->next_last_level_gfn = next_last_level_gfn;
-	iter->yielded_gfn = iter->next_last_level_gfn;
 	iter->root_level = root_level;
 	iter->min_level = min_level;
-	iter->level = root_level;
+	iter->pt_path[iter->root_level - 1] = (tdp_ptep_t)root_pt;
-	iter->pt_path[iter->level - 1] = (tdp_ptep_t)root_pt;
+	iter->as_id = kvm_mmu_page_as_id(sptep_to_sp(root_pt));
-	iter->gfn = round_gfn_for_level(iter->next_last_level_gfn, iter->level);
-	tdp_iter_refresh_sptep(iter);
-	iter->valid = true;
+	tdp_iter_restart(iter);
 }
 /*
 	iter->valid = false;
 }
-tdp_ptep_t tdp_iter_root_pt(struct tdp_iter *iter)
-{
-	return iter->pt_path[iter->root_level - 1];
-}

arch/x86/kvm/mmu/tdp_iter.h+3−1

 	int min_level;
 	/* The iterator's current level within the paging structure */
 	int level;
+	/* The address space ID, i.e. SMM vs. regular. */
+	int as_id;
 	/* A snapshot of the value at sptep */
 	u64 old_spte;
 	/*
 void tdp_iter_start(struct tdp_iter *iter, u64 *root_pt, int root_level,
 		    int min_level, gfn_t next_last_level_gfn);
 void tdp_iter_next(struct tdp_iter *iter);
-tdp_ptep_t tdp_iter_root_pt(struct tdp_iter *iter);
+void tdp_iter_restart(struct tdp_iter *iter);
 #endif /* __KVM_X86_MMU_TDP_ITER_H */

arch/x86/kvm/mmu/tdp_mmu.c+29−37

 	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);
 				u64 old_spte, u64 new_spte, int level,
 				bool shared);
-static int kvm_mmu_page_as_id(struct kvm_mmu_page *sp)
-{
-	return sp->role.smm ? 1 : 0;
-}
 static void handle_changed_spte_acc_track(u64 old_spte, u64 new_spte, int level)
 {
 	bool pfn_changed = spte_to_pfn(old_spte) != spte_to_pfn(new_spte);
  *
  * Given a page table that has been removed from the TDP paging structure,
  * iterates through the page table to clear SPTEs and free child page tables.
+ *
+ * Note that pt is passed in as a tdp_ptep_t, but it does not need RCU
+ * protection. Since this thread removed it from the paging structure,
+ * this thread will be responsible for ensuring the page is freed. Hence the
+ * early rcu_dereferences in the function.
  */
-static void handle_removed_tdp_mmu_page(struct kvm *kvm, u64 *pt,
+static void handle_removed_tdp_mmu_page(struct kvm *kvm, tdp_ptep_t pt,
 					bool shared)
 {
-	struct kvm_mmu_page *sp = sptep_to_sp(pt);
+	struct kvm_mmu_page *sp = sptep_to_sp(rcu_dereference(pt));
 	int level = sp->role.level;
 	gfn_t base_gfn = sp->gfn;
 	u64 old_child_spte;
 	tdp_mmu_unlink_page(kvm, sp, shared);
 	for (i = 0; i < PT64_ENT_PER_PAGE; i++) {
-		sptep = pt + i;
+		sptep = rcu_dereference(pt) + i;
 		gfn = base_gfn + (i * KVM_PAGES_PER_HPAGE(level - 1));
 		if (shared) {
 					   struct tdp_iter *iter,
 					   u64 new_spte)
 {
-	u64 *root_pt = tdp_iter_root_pt(iter);
-	struct kvm_mmu_page *root = sptep_to_sp(root_pt);
-	int as_id = kvm_mmu_page_as_id(root);
 	lockdep_assert_held_read(&kvm->mmu_lock);
 	/*
 		      new_spte) != iter->old_spte)
 		return false;
-	handle_changed_spte(kvm, as_id, iter->gfn, iter->old_spte, new_spte,
+	handle_changed_spte(kvm, iter->as_id, iter->gfn, iter->old_spte,
-			    iter->level, true);
+			    new_spte, iter->level, true);
 	return true;
 }
 	 * here since the SPTE is going from non-present
 	 * to non-present.
 	 */
-	WRITE_ONCE(*iter->sptep, 0);
+	WRITE_ONCE(*rcu_dereference(iter->sptep), 0);
 	return true;
 }
 				      u64 new_spte, bool record_acc_track,
 				      bool record_dirty_log)
 {
-	tdp_ptep_t root_pt = tdp_iter_root_pt(iter);
-	struct kvm_mmu_page *root = sptep_to_sp(root_pt);
-	int as_id = kvm_mmu_page_as_id(root);
 	lockdep_assert_held_write(&kvm->mmu_lock);
 	/*
 	WRITE_ONCE(*rcu_dereference(iter->sptep), new_spte);
-	__handle_changed_spte(kvm, as_id, iter->gfn, iter->old_spte, new_spte,
+	__handle_changed_spte(kvm, iter->as_id, iter->gfn, iter->old_spte,
-			      iter->level, false);
+			      new_spte, iter->level, false);
 	if (record_acc_track)
 		handle_changed_spte_acc_track(iter->old_spte, new_spte,
 					      iter->level);
 	if (record_dirty_log)
-		handle_changed_spte_dirty_log(kvm, as_id, iter->gfn,
+		handle_changed_spte_dirty_log(kvm, iter->as_id, iter->gfn,
 					      iter->old_spte, new_spte,
 					      iter->level);
 }
 		WARN_ON(iter->gfn > iter->next_last_level_gfn);
-		tdp_iter_start(iter, iter->pt_path[iter->root_level - 1],
+		tdp_iter_restart(iter);
-			       iter->root_level, iter->min_level,
-			       iter->next_last_level_gfn);
 		return true;
 	}
  * 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+104−66

@@ -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
@@ -1526,35 +1525,44 @@ EXPORT_SYMBOL_GPL(kvm_enable_efer_bits); · 74 unmodified lines
1526		1525
1527	bool kvm_msr_allowed(struct kvm_vcpu *vcpu, u32 index, u32 type)	1526	bool kvm_msr_allowed(struct kvm_vcpu *vcpu, u32 index, u32 type)
1528	{	1527	{
		1528	struct kvm_x86_msr_filter *msr_filter;
		1529	struct msr_bitmap_range *ranges;
1529	struct kvm *kvm = vcpu->kvm;	1530	struct kvm *kvm = vcpu->kvm;
1530	struct msr_bitmap_range *ranges = kvm->arch.msr_filter.ranges;	1531	bool allowed;
1531	u32 count = kvm->arch.msr_filter.count;
1532	u32 i;
1533	bool r = kvm->arch.msr_filter.default_allow;
1534	int idx;	1532	int idx;
		1533	u32 i;
1535		1534
1536	/* MSR filtering not set up or x2APIC enabled, allow everything */	1535	/* x2APIC MSRs do not support filtering. */
1537	if (!count \|\| (index >= 0x800 && index <= 0x8ff))	1536	if (index >= 0x800 && index <= 0x8ff)
1538	return true;	1537	return true;
1539		1538
1540	/* Prevent collision with set_msr_filter */
1541	idx = srcu_read_lock(&kvm->srcu);	1539	idx = srcu_read_lock(&kvm->srcu);
1542		1540
1543	for (i = 0; i < count; i++) {	1541	msr_filter = srcu_dereference(kvm->arch.msr_filter, &kvm->srcu);
		1542	if (!msr_filter) {
		1543	allowed = true;
		1544	goto out;
		1545	}
		1546
		1547	allowed = msr_filter->default_allow;
		1548	ranges = msr_filter->ranges;
		1549
		1550	for (i = 0; i < msr_filter->count; i++) {
1544	u32 start = ranges[i].base;	1551	u32 start = ranges[i].base;
1545	u32 end = start + ranges[i].nmsrs;	1552	u32 end = start + ranges[i].nmsrs;
1546	u32 flags = ranges[i].flags;	1553	u32 flags = ranges[i].flags;
1547	unsigned long *bitmap = ranges[i].bitmap;	1554	unsigned long *bitmap = ranges[i].bitmap;
1548		1555
1549	if ((index >= start) && (index < end) && (flags & type)) {	1556	if ((index >= start) && (index < end) && (flags & type)) {
1550	r = !!test_bit(index - start, bitmap);	1557	allowed = !!test_bit(index - start, bitmap);
1551	break;	1558	break;
1552	}	1559	}
1553	}	1560	}
1554		1561
		1562	out:
1555	srcu_read_unlock(&kvm->srcu, idx);	1563	srcu_read_unlock(&kvm->srcu, idx);
1556		1564
1557	return r;	1565	return allowed;
1558	}	1566	}
1559	EXPORT_SYMBOL_GPL(kvm_msr_allowed);	1567	EXPORT_SYMBOL_GPL(kvm_msr_allowed);
1560		1568
@@ -1611,7 +1619,7 @@ static int kvm_set_msr_ignored_check(struct kvm_vcpu *vcpu, · 50 unmodified lines
1611	int ret = __kvm_set_msr(vcpu, index, data, host_initiated);	1619	int ret = __kvm_set_msr(vcpu, index, data, host_initiated);
1612		1620
1613	if (ret == KVM_MSR_RET_INVALID)	1621	if (ret == KVM_MSR_RET_INVALID)
1614	if (kvm_msr_ignored_check(vcpu, index, data, true))	1622	if (kvm_msr_ignored_check(index, data, true))
1615	ret = 0;	1623	ret = 0;
1616		1624
1617	return ret;	1625	return ret;
@@ -1649,7 +1657,7 @@ static int kvm_get_msr_ignored_check(struct kvm_vcpu *vcpu, · 31 unmodified lines
1649	if (ret == KVM_MSR_RET_INVALID) {	1657	if (ret == KVM_MSR_RET_INVALID) {
1650	/* Unconditionally clear data for simplicity /	1658	/* Unconditionally clear data for simplicity /
1651	*data = 0;	1659	*data = 0;
1652	if (kvm_msr_ignored_check(vcpu, index, 0, false))	1660	if (kvm_msr_ignored_check(index, 0, false))
1653	ret = 0;	1661	ret = 0;
1654	}	1662	}
1655		1663
@@ -2320,7 +2328,7 @@ static void kvm_synchronize_tsc(struct kvm_vcpu *vcpu, u64 data) · 664 unmodified lines
2320	kvm_vcpu_write_tsc_offset(vcpu, offset);	2328	kvm_vcpu_write_tsc_offset(vcpu, offset);
2321	raw_spin_unlock_irqrestore(&kvm->arch.tsc_write_lock, flags);	2329	raw_spin_unlock_irqrestore(&kvm->arch.tsc_write_lock, flags);
2322		2330
2323	spin_lock(&kvm->arch.pvclock_gtod_sync_lock);	2331	spin_lock_irqsave(&kvm->arch.pvclock_gtod_sync_lock, flags);
2324	if (!matched) {	2332	if (!matched) {
2325	kvm->arch.nr_vcpus_matched_tsc = 0;	2333	kvm->arch.nr_vcpus_matched_tsc = 0;
2326	} else if (!already_matched) {	2334	} else if (!already_matched) {
@@ -2328,7 +2336,7 @@ static void kvm_synchronize_tsc(struct kvm_vcpu *vcpu, u64 data) · 1 unmodified line
2328	}	2336	}
2329		2337
2330	kvm_track_tsc_matching(vcpu);	2338	kvm_track_tsc_matching(vcpu);
2331	spin_unlock(&kvm->arch.pvclock_gtod_sync_lock);	2339	spin_unlock_irqrestore(&kvm->arch.pvclock_gtod_sync_lock, flags);
2332	}	2340	}
2333		2341
2334	static inline void adjust_tsc_offset_guest(struct kvm_vcpu *vcpu,	2342	static inline void adjust_tsc_offset_guest(struct kvm_vcpu *vcpu,
@@ -2550,11 +2558,16 @@ static void kvm_gen_update_masterclock(struct kvm *kvm) · 215 unmodified lines
2550	int i;	2558	int i;
2551	struct kvm_vcpu *vcpu;	2559	struct kvm_vcpu *vcpu;
2552	struct kvm_arch *ka = &kvm->arch;	2560	struct kvm_arch *ka = &kvm->arch;
		2561	unsigned long flags;
		2562
		2563	kvm_hv_invalidate_tsc_page(kvm);
2553		2564
2554	spin_lock(&ka->pvclock_gtod_sync_lock);
2555	kvm_make_mclock_inprogress_request(kvm);	2565	kvm_make_mclock_inprogress_request(kvm);
		2566
2556	/* no guest entries from this point */	2567	/* no guest entries from this point */
		2568	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2557	pvclock_update_vm_gtod_copy(kvm);	2569	pvclock_update_vm_gtod_copy(kvm);
		2570	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2558		2571
2559	kvm_for_each_vcpu(i, vcpu, kvm)	2572	kvm_for_each_vcpu(i, vcpu, kvm)
2560	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);	2573	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
@@ -2562,8 +2575,6 @@ static void kvm_gen_update_masterclock(struct kvm *kvm) · 1 unmodified line
2562	/* guest entries allowed */	2575	/* guest entries allowed */
2563	kvm_for_each_vcpu(i, vcpu, kvm)	2576	kvm_for_each_vcpu(i, vcpu, kvm)
2564	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);	2577	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
2565
2566	spin_unlock(&ka->pvclock_gtod_sync_lock);
2567	#endif	2578	#endif
2568	}	2579	}
2569		2580
@@ -2571,17 +2582,18 @@ u64 get_kvmclock_ns(struct kvm *kvm) · 1 unmodified line
2571	{	2582	{
2572	struct kvm_arch *ka = &kvm->arch;	2583	struct kvm_arch *ka = &kvm->arch;
2573	struct pvclock_vcpu_time_info hv_clock;	2584	struct pvclock_vcpu_time_info hv_clock;
		2585	unsigned long flags;
2574	u64 ret;	2586	u64 ret;
2575		2587
2576	spin_lock(&ka->pvclock_gtod_sync_lock);	2588	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2577	if (!ka->use_master_clock) {	2589	if (!ka->use_master_clock) {
2578	spin_unlock(&ka->pvclock_gtod_sync_lock);	2590	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2579	return get_kvmclock_base_ns() + ka->kvmclock_offset;	2591	return get_kvmclock_base_ns() + ka->kvmclock_offset;
2580	}	2592	}
2581		2593
2582	hv_clock.tsc_timestamp = ka->master_cycle_now;	2594	hv_clock.tsc_timestamp = ka->master_cycle_now;
2583	hv_clock.system_time = ka->master_kernel_ns + ka->kvmclock_offset;	2595	hv_clock.system_time = ka->master_kernel_ns + ka->kvmclock_offset;
2584	spin_unlock(&ka->pvclock_gtod_sync_lock);	2596	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2585		2597
2586	/* 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 */
2587	get_cpu();	2599	get_cpu();
@@ -2675,13 +2687,13 @@ static int kvm_guest_time_update(struct kvm_vcpu *v) · 87 unmodified lines
2675	* If the host uses TSC clock, then passthrough TSC as stable	2687	* If the host uses TSC clock, then passthrough TSC as stable
2676	* to the guest.	2688	* to the guest.
2677	*/	2689	*/
2678	spin_lock(&ka->pvclock_gtod_sync_lock);	2690	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
2679	use_master_clock = ka->use_master_clock;	2691	use_master_clock = ka->use_master_clock;
2680	if (use_master_clock) {	2692	if (use_master_clock) {
2681	host_tsc = ka->master_cycle_now;	2693	host_tsc = ka->master_cycle_now;
2682	kernel_ns = ka->master_kernel_ns;	2694	kernel_ns = ka->master_kernel_ns;
2683	}	2695	}
2684	spin_unlock(&ka->pvclock_gtod_sync_lock);	2696	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
2685		2697
2686	/* Keep irq disabled to prevent changes to the clock */	2698	/* Keep irq disabled to prevent changes to the clock */
2687	local_irq_save(flags);	2699	local_irq_save(flags);
@@ -5352,25 +5364,34 @@ split_irqchip_unlock: · 2664 unmodified lines
5352	return r;	5364	return r;
5353	}	5365	}
5354		5366
5355	static void kvm_clear_msr_filter(struct kvm *kvm)	5367	static struct kvm_x86_msr_filter *kvm_alloc_msr_filter(bool default_allow)
		5368	{
		5369	struct kvm_x86_msr_filter *msr_filter;
		5370
		5371	msr_filter = kzalloc(sizeof(*msr_filter), GFP_KERNEL_ACCOUNT);
		5372	if (!msr_filter)
		5373	return NULL;
		5374
		5375	msr_filter->default_allow = default_allow;
		5376	return msr_filter;
		5377	}
		5378
		5379	static void kvm_free_msr_filter(struct kvm_x86_msr_filter *msr_filter)
5356	{	5380	{
5357	u32 i;	5381	u32 i;
5358	u32 count = kvm->arch.msr_filter.count;
5359	struct msr_bitmap_range ranges[16];
5360		5382
5361	mutex_lock(&kvm->lock);	5383	if (!msr_filter)
5362	kvm->arch.msr_filter.count = 0;	5384	return;
5363	memcpy(ranges, kvm->arch.msr_filter.ranges, count * sizeof(ranges[0]));
5364	mutex_unlock(&kvm->lock);
5365	synchronize_srcu(&kvm->srcu);
5366		5385
5367	for (i = 0; i < count; i++)	5386	for (i = 0; i < msr_filter->count; i++)
5368	kfree(ranges[i].bitmap);	5387	kfree(msr_filter->ranges[i].bitmap);
		5388
		5389	kfree(msr_filter);
5369	}	5390	}
5370		5391
5371	static int kvm_add_msr_filter(struct kvm kvm, struct kvm_msr_filter_range user_range)	5392	static int kvm_add_msr_filter(struct kvm_x86_msr_filter *msr_filter,
		5393	struct kvm_msr_filter_range *user_range)
5372	{	5394	{
5373	struct msr_bitmap_range *ranges = kvm->arch.msr_filter.ranges;
5374	struct msr_bitmap_range range;	5395	struct msr_bitmap_range range;
5375	unsigned long *bitmap = NULL;	5396	unsigned long *bitmap = NULL;
5376	size_t bitmap_size;	5397	size_t bitmap_size;
@@ -5404,11 +5425,9 @@ static int kvm_add_msr_filter(struct kvm kvm, struct kvm_msr_filter_range user · 27 unmodified lines
5404	goto err;	5425	goto err;
5405	}	5426	}
5406		5427
5407	/* Everything ok, add this range identifier to our global pool */	5428	/* Everything ok, add this range identifier. */
5408	ranges[kvm->arch.msr_filter.count] = range;	5429	msr_filter->ranges[msr_filter->count] = range;
5409	/* Make sure we filled the array before we tell anyone to walk it */	5430	msr_filter->count++;
5410	smp_wmb();
5411	kvm->arch.msr_filter.count++;
5412		5431
5413	return 0;	5432	return 0;
5414	err:	5433	err:
@@ -5419,10 +5438,11 @@ err: · 4 unmodified lines
5419	static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp)	5438	static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp)
5420	{	5439	{
5421	struct kvm_msr_filter __user *user_msr_filter = argp;	5440	struct kvm_msr_filter __user *user_msr_filter = argp;
		5441	struct kvm_x86_msr_filter new_filter, old_filter;
5422	struct kvm_msr_filter filter;	5442	struct kvm_msr_filter filter;
5423	bool default_allow;	5443	bool default_allow;
5424	int r = 0;
5425	bool empty = true;	5444	bool empty = true;
		5445	int r = 0;
5426	u32 i;	5446	u32 i;
5427		5447
5428	if (copy_from_user(&filter, user_msr_filter, sizeof(filter)))	5448	if (copy_from_user(&filter, user_msr_filter, sizeof(filter)))
@@ -5435,25 +5455,32 @@ static int kvm_vm_ioctl_set_msr_filter(struct kvm kvm, void __user argp) · 6 unmodified lines
5435	if (empty && !default_allow)	5455	if (empty && !default_allow)
5436	return -EINVAL;	5456	return -EINVAL;
5437		5457
5438	kvm_clear_msr_filter(kvm);	5458	new_filter = kvm_alloc_msr_filter(default_allow);
5439		5459	if (!new_filter)
5440	kvm->arch.msr_filter.default_allow = default_allow;	5460	return -ENOMEM;
5441		5461
5442	/*
5443	* Protect from concurrent calls to this function that could trigger
5444	* a TOCTOU violation on kvm->arch.msr_filter.count.
5445	*/
5446	mutex_lock(&kvm->lock);
5447	for (i = 0; i < ARRAY_SIZE(filter.ranges); i++) {	5462	for (i = 0; i < ARRAY_SIZE(filter.ranges); i++) {
5448	r = kvm_add_msr_filter(kvm, &filter.ranges[i]);	5463	r = kvm_add_msr_filter(new_filter, &filter.ranges[i]);
5449	if (r)	5464	if (r) {
5450	break;	5465	kvm_free_msr_filter(new_filter);
		5466	return r;
		5467	}
5451	}	5468	}
5452		5469
		5470	mutex_lock(&kvm->lock);
		5471
		5472	/* The per-VM filter is protected by kvm->lock... */
		5473	old_filter = srcu_dereference_check(kvm->arch.msr_filter, &kvm->srcu, 1);
		5474
		5475	rcu_assign_pointer(kvm->arch.msr_filter, new_filter);
		5476	synchronize_srcu(&kvm->srcu);
		5477
		5478	kvm_free_msr_filter(old_filter);
		5479
5453	kvm_make_all_cpus_request(kvm, KVM_REQ_MSR_FILTER_CHANGED);	5480	kvm_make_all_cpus_request(kvm, KVM_REQ_MSR_FILTER_CHANGED);
5454	mutex_unlock(&kvm->lock);	5481	mutex_unlock(&kvm->lock);
5455		5482
5456	return r;	5483	return 0;
5457	}	5484	}
5458		5485
5459	long kvm_arch_vm_ioctl(struct file *filp,	5486	long kvm_arch_vm_ioctl(struct file *filp,
@@ -5700,6 +5727,7 @@ set_pit2_out: · 240 unmodified lines
5700	}	5727	}
5701	#endif	5728	#endif
5702	case KVM_SET_CLOCK: {	5729	case KVM_SET_CLOCK: {
		5730	struct kvm_arch *ka = &kvm->arch;
5703	struct kvm_clock_data user_ns;	5731	struct kvm_clock_data user_ns;
5704	u64 now_ns;	5732	u64 now_ns;
5705		5733
@@ -5718,8 +5746,22 @@ set_pit2_out: · 12 unmodified lines
5718	* pvclock_update_vm_gtod_copy().	5746	* pvclock_update_vm_gtod_copy().
5719	*/	5747	*/
5720	kvm_gen_update_masterclock(kvm);	5748	kvm_gen_update_masterclock(kvm);
5721	now_ns = get_kvmclock_ns(kvm);	5749
5722	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
5723	kvm_make_all_cpus_request(kvm, KVM_REQ_CLOCK_UPDATE);	5765	kvm_make_all_cpus_request(kvm, KVM_REQ_CLOCK_UPDATE);
5724	break;	5766	break;
5725	}	5767	}
@@ -6603,7 +6645,7 @@ static int kvm_emulate_wbinvd_noskip(struct kvm_vcpu *vcpu) · 877 unmodified lines
6603	int cpu = get_cpu();	6645	int cpu = get_cpu();
6604		6646
6605	cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask);	6647	cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask);
6606	smp_call_function_many(vcpu->arch.wbinvd_dirty_mask,	6648	on_each_cpu_mask(vcpu->arch.wbinvd_dirty_mask,
6607	wbinvd_ipi, NULL, 1);	6649	wbinvd_ipi, NULL, 1);
6608	put_cpu();	6650	put_cpu();
6609	cpumask_clear(vcpu->arch.wbinvd_dirty_mask);	6651	cpumask_clear(vcpu->arch.wbinvd_dirty_mask);
@@ -7698,6 +7740,7 @@ static void kvm_hyperv_tsc_notifier(void) · 1088 unmodified lines
7698	struct kvm *kvm;	7740	struct kvm *kvm;
7699	struct kvm_vcpu *vcpu;	7741	struct kvm_vcpu *vcpu;
7700	int cpu;	7742	int cpu;
		7743	unsigned long flags;
7701		7744
7702	mutex_lock(&kvm_lock);	7745	mutex_lock(&kvm_lock);
7703	list_for_each_entry(kvm, &vm_list, vm_list)	7746	list_for_each_entry(kvm, &vm_list, vm_list)
@@ -7713,17 +7756,15 @@ static void kvm_hyperv_tsc_notifier(void) · 9 unmodified lines
7713	list_for_each_entry(kvm, &vm_list, vm_list) {	7756	list_for_each_entry(kvm, &vm_list, vm_list) {
7714	struct kvm_arch *ka = &kvm->arch;	7757	struct kvm_arch *ka = &kvm->arch;
7715		7758
7716	spin_lock(&ka->pvclock_gtod_sync_lock);	7759	spin_lock_irqsave(&ka->pvclock_gtod_sync_lock, flags);
7717
7718	pvclock_update_vm_gtod_copy(kvm);	7760	pvclock_update_vm_gtod_copy(kvm);
		7761	spin_unlock_irqrestore(&ka->pvclock_gtod_sync_lock, flags);
7719		7762
7720	kvm_for_each_vcpu(cpu, vcpu, kvm)	7763	kvm_for_each_vcpu(cpu, vcpu, kvm)
7721	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);	7764	kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
7722		7765
7723	kvm_for_each_vcpu(cpu, vcpu, kvm)	7766	kvm_for_each_vcpu(cpu, vcpu, kvm)
7724	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);	7767	kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
7725
7726	spin_unlock(&ka->pvclock_gtod_sync_lock);
7727	}	7768	}
7728	mutex_unlock(&kvm_lock);	7769	mutex_unlock(&kvm_lock);
7729	}	7770	}
@@ -10634,8 +10675,6 @@ void kvm_arch_pre_destroy_vm(struct kvm *kvm) · 2904 unmodified lines
10634		10675
10635	void kvm_arch_destroy_vm(struct kvm *kvm)	10676	void kvm_arch_destroy_vm(struct kvm *kvm)
10636	{	10677	{
10637	u32 i;
10638
10639	if (current->mm == kvm->mm) {	10678	if (current->mm == kvm->mm) {
10640	/*	10679	/*
10641	* Free memory regions allocated on behalf of userspace,	10680	* Free memory regions allocated on behalf of userspace,
@@ -10651,8 +10690,7 @@ void kvm_arch_destroy_vm(struct kvm *kvm) · 9 unmodified lines
10651	mutex_unlock(&kvm->slots_lock);	10690	mutex_unlock(&kvm->slots_lock);
10652	}	10691	}
10653	static_call_cond(kvm_x86_vm_destroy)(kvm);	10692	static_call_cond(kvm_x86_vm_destroy)(kvm);
10654	for (i = 0; i < kvm->arch.msr_filter.count; i++)	10693	kvm_free_msr_filter(srcu_dereference_check(kvm->arch.msr_filter, &kvm->srcu, 1));
10655	kfree(kvm->arch.msr_filter.ranges[i].bitmap);
10656	kvm_pic_destroy(kvm);	10694	kvm_pic_destroy(kvm);
10657	kvm_ioapic_destroy(kvm);	10695	kvm_ioapic_destroy(kvm);
10658	kvm_free_vcpus(kvm);	10696	kvm_free_vcpus(kvm);

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/platform/iris/iris.c+0−1

@@ -27,7 +27,6 @@ · 26 unmodified lines
27	MODULE_LICENSE("GPL");	27	MODULE_LICENSE("GPL");
28	MODULE_AUTHOR("Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>");	28	MODULE_AUTHOR("Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>");
29	MODULE_DESCRIPTION("A power_off handler for Iris devices from EuroBraille");	29	MODULE_DESCRIPTION("A power_off handler for Iris devices from EuroBraille");
30	MODULE_SUPPORTED_DEVICE("Eurobraille/Iris");
31		30
32	static bool force;	31	static bool force;
33		32

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/atm/fore200e.c+0−2

@@ -100,8 +100,6 @@ static LIST_HEAD(fore200e_boards); · 99 unmodified lines
100		100
101	MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");	101	MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
102	MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);	102	MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
103	MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
104
105		103
106	static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {	104	static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
107	{ BUFFER_S1_NBR, BUFFER_L1_NBR },	105	{ BUFFER_S1_NBR, BUFFER_L1_NBR },

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+69−42

@@ -305,7 +305,7 @@ static int rpm_get_suppliers(struct device *dev) · 304 unmodified lines
305	return 0;	305	return 0;
306	}	306	}
307		307
308	static void rpm_put_suppliers(struct device *dev)	308	static void __rpm_put_suppliers(struct device *dev, bool try_to_suspend)
309	{	309	{
310	struct device_link *link;	310	struct device_link *link;
311		311
@@ -313,10 +313,30 @@ static void rpm_put_suppliers(struct device *dev) · 1 unmodified line
313	device_links_read_lock_held()) {	313	device_links_read_lock_held()) {
314		314
315	while (refcount_dec_not_one(&link->rpm_active))	315	while (refcount_dec_not_one(&link->rpm_active))
316	pm_runtime_put(link->supplier);	316	pm_runtime_put_noidle(link->supplier);
		317
		318	if (try_to_suspend)
		319	pm_request_idle(link->supplier);
317	}	320	}
318	}	321	}
319		322
		323	static void rpm_put_suppliers(struct device *dev)
		324	{
		325	__rpm_put_suppliers(dev, true);
		326	}
		327
		328	static void rpm_suspend_suppliers(struct device *dev)
		329	{
		330	struct device_link *link;
		331	int idx = device_links_read_lock();
		332
		333	list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
		334	device_links_read_lock_held())
		335	pm_request_idle(link->supplier);
		336
		337	device_links_read_unlock(idx);
		338	}
		339
320	/**	340	/**
321	* __rpm_callback - Run a given runtime PM callback for a given device.	341	* __rpm_callback - Run a given runtime PM callback for a given device.
322	* @cb: Runtime PM callback to run.	342	* @cb: Runtime PM callback to run.
@@ -325,27 +345,29 @@ static void rpm_put_suppliers(struct device *dev) · 2 unmodified lines
325	static int __rpm_callback(int (cb)(struct device ), struct device *dev)	345	static int __rpm_callback(int (cb)(struct device ), struct device *dev)
326	__releases(&dev->power.lock) __acquires(&dev->power.lock)	346	__releases(&dev->power.lock) __acquires(&dev->power.lock)
327	{	347	{
328	bool use_links = dev->power.links_count > 0;
329	bool get = false;
330	int retval, idx;	348	int retval, idx;
331	bool put;	349	bool use_links = dev->power.links_count > 0;
332		350
333	if (dev->power.irq_safe) {	351	if (dev->power.irq_safe) {
334	spin_unlock(&dev->power.lock);	352	spin_unlock(&dev->power.lock);
335	} else if (!use_links) {
336	spin_unlock_irq(&dev->power.lock);
337	} else {	353	} else {
338	get = dev->power.runtime_status == RPM_RESUMING;
339
340	spin_unlock_irq(&dev->power.lock);	354	spin_unlock_irq(&dev->power.lock);
341		355
342	/* Resume suppliers if necessary. */	356	/*
343	if (get) {	357	* Resume suppliers if necessary.
		358	*
		359	* The device's runtime PM status cannot change until this
		360	* routine returns, so it is safe to read the status outside of
		361	* the lock.
		362	*/
		363	if (use_links && dev->power.runtime_status == RPM_RESUMING) {
344	idx = device_links_read_lock();	364	idx = device_links_read_lock();
345		365
346	retval = rpm_get_suppliers(dev);	366	retval = rpm_get_suppliers(dev);
347	if (retval)	367	if (retval) {
		368	rpm_put_suppliers(dev);
348	goto fail;	369	goto fail;
		370	}
349		371
350	device_links_read_unlock(idx);	372	device_links_read_unlock(idx);
351	}	373	}
@@ -355,36 +377,24 @@ static int __rpm_callback(int (cb)(struct device ), struct device *dev) · 3 unmodified lines
355		377
356	if (dev->power.irq_safe) {	378	if (dev->power.irq_safe) {
357	spin_lock(&dev->power.lock);	379	spin_lock(&dev->power.lock);
358	return retval;	380	} else {
359	}	381	/*
360		382	* If the device is suspending and the callback has returned
361	spin_lock_irq(&dev->power.lock);	383	* success, drop the usage counters of the suppliers that have
362		384	* been reference counted on its resume.
363	if (!use_links)	385	*
364	return retval;	386	* Do that if resume fails too.
365		387	*/
366	/*	388	if (use_links
367	* If the device is suspending and the callback has returned success,	389	&& ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
368	* drop the usage counters of the suppliers that have been reference	390	\|\| (dev->power.runtime_status == RPM_RESUMING && retval))) {
369	* counted on its resume.	391	idx = device_links_read_lock();
370	*
371	* Do that if the resume fails too.
372	*/
373	put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
374	if (put)
375	__update_runtime_status(dev, RPM_SUSPENDED);
376	else
377	put = get && retval;
378
379	if (put) {
380	spin_unlock_irq(&dev->power.lock);
381		392
382	idx = device_links_read_lock();	393	__rpm_put_suppliers(dev, false);
383		394
384	fail:	395	fail:
385	rpm_put_suppliers(dev);	396	device_links_read_unlock(idx);
386		397	}
387	device_links_read_unlock(idx);
388		398
389	spin_lock_irq(&dev->power.lock);	399	spin_lock_irq(&dev->power.lock);
390	}	400	}
@@ -654,8 +664,11 @@ static int rpm_suspend(struct device *dev, int rpmflags) · 263 unmodified lines
654	goto out;	664	goto out;
655	}	665	}
656		666
		667	if (dev->power.irq_safe)
		668	goto out;
		669
657	/* Maybe the parent is now able to suspend. */	670	/* Maybe the parent is now able to suspend. */
658	if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {	671	if (parent && !parent->power.ignore_children) {
659	spin_unlock(&dev->power.lock);	672	spin_unlock(&dev->power.lock);
660		673
661	spin_lock(&parent->power.lock);	674	spin_lock(&parent->power.lock);
@@ -664,6 +677,14 @@ static int rpm_suspend(struct device *dev, int rpmflags) · 2 unmodified lines
664		677
665	spin_lock(&dev->power.lock);	678	spin_lock(&dev->power.lock);
666	}	679	}
		680	/* Maybe the suppliers are now able to suspend. */
		681	if (dev->power.links_count > 0) {
		682	spin_unlock_irq(&dev->power.lock);
		683
		684	rpm_suspend_suppliers(dev);
		685
		686	spin_lock_irq(&dev->power.lock);
		687	}
667		688
668	out:	689	out:
669	trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);	690	trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);
@@ -1669,8 +1690,8 @@ void pm_runtime_get_suppliers(struct device *dev) · 999 unmodified lines
1669	device_links_read_lock_held())	1690	device_links_read_lock_held())
1670	if (link->flags & DL_FLAG_PM_RUNTIME) {	1691	if (link->flags & DL_FLAG_PM_RUNTIME) {
1671	link->supplier_preactivated = true;	1692	link->supplier_preactivated = true;
1672	refcount_inc(&link->rpm_active);
1673	pm_runtime_get_sync(link->supplier);	1693	pm_runtime_get_sync(link->supplier);
		1694	refcount_inc(&link->rpm_active);
1674	}	1695	}
1675		1696
1676	device_links_read_unlock(idx);	1697	device_links_read_unlock(idx);
@@ -1683,6 +1704,8 @@ void pm_runtime_get_suppliers(struct device *dev) · 6 unmodified lines
1683	void pm_runtime_put_suppliers(struct device *dev)	1704	void pm_runtime_put_suppliers(struct device *dev)
1684	{	1705	{
1685	struct device_link *link;	1706	struct device_link *link;
		1707	unsigned long flags;
		1708	bool put;
1686	int idx;	1709	int idx;
1687		1710
1688	idx = device_links_read_lock();	1711	idx = device_links_read_lock();
@@ -1691,7 +1714,11 @@ void pm_runtime_put_suppliers(struct device *dev) · 2 unmodified lines
1691	device_links_read_lock_held())	1714	device_links_read_lock_held())
1692	if (link->supplier_preactivated) {	1715	if (link->supplier_preactivated) {
1693	link->supplier_preactivated = false;	1716	link->supplier_preactivated = false;
1694	if (refcount_dec_not_one(&link->rpm_active))	1717	spin_lock_irqsave(&dev->power.lock, flags);
		1718	put = pm_runtime_status_suspended(dev) &&
		1719	refcount_dec_not_one(&link->rpm_active);
		1720	spin_unlock_irqrestore(&dev->power.lock, flags);
		1721	if (put)
1695	pm_runtime_put(link->supplier);	1722	pm_runtime_put(link->supplier);
1696	}	1723	}
1697		1724

drivers/block/floppy.c+0−1

@@ -5091,7 +5091,6 @@ module_param(floppy, charp, 0); · 5090 unmodified lines
5091	module_param(FLOPPY_IRQ, int, 0);	5091	module_param(FLOPPY_IRQ, int, 0);
5092	module_param(FLOPPY_DMA, int, 0);	5092	module_param(FLOPPY_DMA, int, 0);
5093	MODULE_AUTHOR("Alain L. Knaff");	5093	MODULE_AUTHOR("Alain L. Knaff");
5094	MODULE_SUPPORTED_DEVICE("fd");
5095	MODULE_LICENSE("GPL");	5094	MODULE_LICENSE("GPL");
5096		5095
5097	/* This doesn't actually get used other than for module information */	5096	/* This doesn't actually get used other than for module information */

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/bluetooth/btrsi.c+0−1

@@ -194,5 +194,4 @@ module_init(rsi_91x_bt_module_init); · 193 unmodified lines
194	module_exit(rsi_91x_bt_module_exit);	194	module_exit(rsi_91x_bt_module_exit);
195	MODULE_AUTHOR("Redpine Signals Inc");	195	MODULE_AUTHOR("Redpine Signals Inc");
196	MODULE_DESCRIPTION("RSI BT driver");	196	MODULE_DESCRIPTION("RSI BT driver");
197	MODULE_SUPPORTED_DEVICE("RSI-BT");
198	MODULE_LICENSE("Dual BSD/GPL");	197	MODULE_LICENSE("Dual BSD/GPL");

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/char/applicom.c+0−3

@@ -81,9 +81,6 @@ MODULE_DESCRIPTION("Driver for Applicom Profibus card"); · 80 unmodified lines
81	MODULE_LICENSE("GPL");	81	MODULE_LICENSE("GPL");
82	MODULE_ALIAS_MISCDEV(AC_MINOR);	82	MODULE_ALIAS_MISCDEV(AC_MINOR);
83		83
84	MODULE_SUPPORTED_DEVICE("ac");
85
86
87	static struct applicom_board {	84	static struct applicom_board {
88	unsigned long PhysIO;	85	unsigned long PhysIO;
89	void __iomem *RamIO;	86	void __iomem *RamIO;

drivers/char/toshiba.c+0−1

@@ -64,7 +64,6 @@ · 63 unmodified lines
64	MODULE_LICENSE("GPL");	64	MODULE_LICENSE("GPL");
65	MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");	65	MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");
66	MODULE_DESCRIPTION("Toshiba laptop SMM driver");	66	MODULE_DESCRIPTION("Toshiba laptop SMM driver");
67	MODULE_SUPPORTED_DEVICE("toshiba");
68		67
69	static DEFINE_MUTEX(tosh_mutex);	68	static DEFINE_MUTEX(tosh_mutex);
70	static int tosh_fn;	69	static int tosh_fn;

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/counter/stm32-timer-cnt.c+33−22

 	struct counter_device counter;
 	struct regmap *regmap;
 	struct clk *clk;
-	u32 ceiling;
+	u32 max_arr;
 	bool enabled;
 	struct stm32_timer_regs bak;
 };
  * @STM32_COUNT_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
  */
 enum stm32_count_function {
-	STM32_COUNT_SLAVE_MODE_DISABLED = -1,
+	STM32_COUNT_SLAVE_MODE_DISABLED,
 	STM32_COUNT_ENCODER_MODE_1,
 	STM32_COUNT_ENCODER_MODE_2,
 	STM32_COUNT_ENCODER_MODE_3,
 };
 static enum counter_count_function stm32_count_functions[] = {
+	[STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_COUNT_FUNCTION_INCREASE,
 	[STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
 	[STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
 	[STM32_COUNT_ENCODER_MODE_3] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
 			     const unsigned long val)
 {
 	struct stm32_timer_cnt *const priv = counter->priv;
+	u32 ceiling;
-	if (val > priv->ceiling)
+	regmap_read(priv->regmap, TIM_ARR, &ceiling);
+	if (val > ceiling)
 		return -EINVAL;
 	return regmap_write(priv->regmap, TIM_CNT, val);
 	regmap_read(priv->regmap, TIM_SMCR, &smcr);
 	switch (smcr & TIM_SMCR_SMS) {
+	case 0:
+		*function = STM32_COUNT_SLAVE_MODE_DISABLED;
+		return 0;
 	case 1:
 		*function = STM32_COUNT_ENCODER_MODE_1;
 		return 0;
 	case 3:
 		*function = STM32_COUNT_ENCODER_MODE_3;
 		return 0;
+	default:
+		return -EINVAL;
 	}
-	return -EINVAL;
 }
 static int stm32_count_function_set(struct counter_device *counter,
 	u32 cr1, sms;
 	switch (function) {
+	case STM32_COUNT_SLAVE_MODE_DISABLED:
+		sms = 0;
+		break;
 	case STM32_COUNT_ENCODER_MODE_1:
 		sms = 1;
 		break;
 		sms = 3;
 		break;
 	default:
-		sms = 0;
+		return -EINVAL;
-		break;
 	}
 	/* Store enable status */
 	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN, 0);
-	/* TIMx_ARR register shouldn't be buffered (ARPE=0) */
-	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
-	regmap_write(priv->regmap, TIM_ARR, priv->ceiling);
 	regmap_update_bits(priv->regmap, TIM_SMCR, TIM_SMCR_SMS, sms);
 	/* Make sure that registers are updated */
 	if (ret)
 		return ret;
+	if (ceiling > priv->max_arr)
+		return -ERANGE;
 	/* TIMx_ARR register shouldn't be buffered (ARPE=0) */
 	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
 	regmap_write(priv->regmap, TIM_ARR, ceiling);
-	priv->ceiling = ceiling;
 	return len;
 }
 	size_t function;
 	int err;
-	/* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
-	*action = STM32_SYNAPSE_ACTION_NONE;
 	err = stm32_count_function_get(counter, count, &function);
 	if (err)
-		return 0;
+		return err;
 	switch (function) {
+	case STM32_COUNT_SLAVE_MODE_DISABLED:
+		/* counts on internal clock when CEN=1 */
+		*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_1:
 		/* counts up/down on TI1FP1 edge depending on TI2FP2 level */
 		if (synapse->signal->id == count->synapses[0].signal->id)
 			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		else
+			*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_2:
 		/* counts up/down on TI2FP2 edge depending on TI1FP1 level */
 		if (synapse->signal->id == count->synapses[1].signal->id)
 			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		else
+			*action = STM32_SYNAPSE_ACTION_NONE;
+		return 0;
 	case STM32_COUNT_ENCODER_MODE_3:
 		/* counts up/down on both TI1FP1 and TI2FP2 edges */
 		*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
-		break;
+		return 0;
+	default:
+		return -EINVAL;
 	}
-	return 0;
 }
 static const struct counter_ops stm32_timer_cnt_ops = {
 	priv->regmap = ddata->regmap;
 	priv->clk = ddata->clk;
-	priv->ceiling = ddata->max_arr;
+	priv->max_arr = ddata->max_arr;
 	priv->counter.name = dev_name(dev);
 	priv->counter.parent = dev;

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/firmware/efi/efi.c+2−1

 	}
 	/* first try to find a slot in an existing linked list entry */
-	for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
+	for (prsv = efi_memreserve_root->next; prsv; ) {
 		rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
 		index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
 		if (index < rsv->size) {
 			memunmap(rsv);
 			return efi_mem_reserve_iomem(addr, size);
 		}
+		prsv = rsv->next;
 		memunmap(rsv);
 	}

drivers/firmware/efi/vars.c+4−0

 				}
 			}
+			break;
+		case EFI_UNSUPPORTED:
+			err = -EOPNOTSUPP;
+			status = EFI_NOT_FOUND;
 			break;
 		case EFI_NOT_FOUND:
 			break;

drivers/gpio/gpiolib.c+9−1

 			       struct lock_class_key *lock_key,
 			       struct lock_class_key *request_key)
 {
+	struct fwnode_handle *fwnode = gc->parent ? dev_fwnode(gc->parent) : NULL;
 	unsigned long	flags;
 	int		ret = 0;
 	unsigned	i;
 	of_gpio_dev_init(gc, gdev);
+	/*
+	 * Assign fwnode depending on the result of the previous calls,
+	 * if none of them succeed, assign it to the parent's one.
+	 */
+	gdev->dev.fwnode = dev_fwnode(&gdev->dev) ?: fwnode;
 	gdev->id = ida_alloc(&gpio_ida, GFP_KERNEL);
 	if (gdev->id < 0) {
 		ret = gdev->id;
 		return ret;
 	}
-	if (driver_register(&gpio_stub_drv) < 0) {
+	ret = driver_register(&gpio_stub_drv);
+	if (ret < 0) {
 		pr_err("gpiolib: could not register GPIO stub driver\n");
 		bus_unregister(&gpio_bus_type);
 		return ret;

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_hwseq.c+2−32

@@ -1507,38 +1507,8 @@ static void dcn20_update_dchubp_dpp( · 1506 unmodified lines
1507	if (pipe_ctx->update_flags.bits.enable \|\| pipe_ctx->update_flags.bits.opp_changed	1507	if (pipe_ctx->update_flags.bits.enable \|\| pipe_ctx->update_flags.bits.opp_changed
1508	\|\| pipe_ctx->stream->update_flags.bits.gamut_remap	1508	\|\| pipe_ctx->stream->update_flags.bits.gamut_remap
1509	\|\| pipe_ctx->stream->update_flags.bits.out_csc) {	1509	\|\| pipe_ctx->stream->update_flags.bits.out_csc) {
1510	struct mpc *mpc = pipe_ctx->stream_res.opp->ctx->dc->res_pool->mpc;	1510	/* dpp/cm gamut remap*/
1511		1511	dc->hwss.program_gamut_remap(pipe_ctx);
1512	if (mpc->funcs->set_gamut_remap) {
1513	int i;
1514	int mpcc_id = hubp->inst;
1515	struct mpc_grph_gamut_adjustment adjust;
1516	bool enable_remap_dpp = false;
1517
1518	memset(&adjust, 0, sizeof(adjust));
1519	adjust.gamut_adjust_type = GRAPHICS_GAMUT_ADJUST_TYPE_BYPASS;
1520
1521	/* save the enablement of gamut remap for dpp */
1522	enable_remap_dpp = pipe_ctx->stream->gamut_remap_matrix.enable_remap;
1523
1524	/* force bypass gamut remap for dpp/cm */
1525	pipe_ctx->stream->gamut_remap_matrix.enable_remap = false;
1526	dc->hwss.program_gamut_remap(pipe_ctx);
1527
1528	/* restore gamut remap flag and use this remap into mpc */
1529	pipe_ctx->stream->gamut_remap_matrix.enable_remap = enable_remap_dpp;
1530
1531	/* build remap matrix for top plane if enabled */
1532	if (enable_remap_dpp && pipe_ctx->top_pipe == NULL) {
1533	adjust.gamut_adjust_type = GRAPHICS_GAMUT_ADJUST_TYPE_SW;
1534	for (i = 0; i < CSC_TEMPERATURE_MATRIX_SIZE; i++)
1535	adjust.temperature_matrix[i] =
1536	pipe_ctx->stream->gamut_remap_matrix.matrix[i];
1537	}
1538	mpc->funcs->set_gamut_remap(mpc, mpcc_id, &adjust);
1539	} else
1540	/* dpp/cm gamut remap*/
1541	dc->hwss.program_gamut_remap(pipe_ctx);
1542		1512
1543	/call the dcn2 method which uses mpc csc/	1513	/call the dcn2 method which uses mpc csc/
1544	dc->hwss.program_output_csc(dc,	1514	dc->hwss.program_output_csc(dc,

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/display/dc/dcn21/dcn21_resource.c+5−0

 	dcn2_1_soc.num_chans = bw_params->num_channels;
 	ASSERT(clk_table->num_entries);
+	/* Copy dcn2_1_soc.clock_limits to clock_limits to avoid copying over null states later */
+	for (i = 0; i < dcn2_1_soc.num_states + 1; i++) {
+		clock_limits[i] = dcn2_1_soc.clock_limits[i];
+	}
 	for (i = 0; i < clk_table->num_entries; i++) {
 		/* loop backwards*/
 		for (closest_clk_lvl = 0, j = dcn2_1_soc.num_states - 1; j >= 0; j--) {

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_cm_common.c+18−8

 	struct pwl_result_data *rgb_resulted;
 	struct pwl_result_data *rgb;
 	struct pwl_result_data *rgb_plus_1;
+	struct pwl_result_data *rgb_minus_1;
 	struct fixed31_32 end_value;
 	int32_t region_start, region_end;
 		region_start = -MAX_LOW_POINT;
 		region_end   = NUMBER_REGIONS - MAX_LOW_POINT;
 	} else {
-		/* 10 segments
+		/* 11 segments
 		 * segment is from 2^-10 to 2^0
 		 * There are less than 256 points, for optimization
 		 */
 		seg_distr[7] = 4;
 		seg_distr[8] = 4;
 		seg_distr[9] = 4;
+		seg_distr[10] = 1;
 		region_start = -10;
-		region_end = 0;
+		region_end = 1;
 	}
 	for (i = region_end - region_start; i < MAX_REGIONS_NUMBER ; i++)
 	rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index];
 	rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index];
+	rgb_resulted[hw_points].red = rgb_resulted[hw_points - 1].red;
+	rgb_resulted[hw_points].green = rgb_resulted[hw_points - 1].green;
+	rgb_resulted[hw_points].blue = rgb_resulted[hw_points - 1].blue;
 	// All 3 color channels have same x
 	corner_points[0].red.x = dc_fixpt_pow(dc_fixpt_from_int(2),
 					     dc_fixpt_from_int(region_start));
 	rgb = rgb_resulted;
 	rgb_plus_1 = rgb_resulted + 1;
+	rgb_minus_1 = rgb;
 	i = 1;
 	while (i != hw_points + 1) {
-		if (dc_fixpt_lt(rgb_plus_1->red, rgb->red))
+		if (i >= hw_points - 1) {
-			rgb_plus_1->red = rgb->red;
+			if (dc_fixpt_lt(rgb_plus_1->red, rgb->red))
-		if (dc_fixpt_lt(rgb_plus_1->green, rgb->green))
+				rgb_plus_1->red = dc_fixpt_add(rgb->red, rgb_minus_1->delta_red);
-			rgb_plus_1->green = rgb->green;
+			if (dc_fixpt_lt(rgb_plus_1->green, rgb->green))
-		if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue))
+				rgb_plus_1->green = dc_fixpt_add(rgb->green, rgb_minus_1->delta_green);
-			rgb_plus_1->blue = rgb->blue;
+			if (dc_fixpt_lt(rgb_plus_1->blue, rgb->blue))
+				rgb_plus_1->blue = dc_fixpt_add(rgb->blue, rgb_minus_1->delta_blue);
+		}
 		rgb->delta_red   = dc_fixpt_sub(rgb_plus_1->red,   rgb->red);
 		rgb->delta_green = dc_fixpt_sub(rgb_plus_1->green, rgb->green);
 		}
 		++rgb_plus_1;
+		rgb_minus_1 = rgb;
 		++rgb;
 		++i;
 	}

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/i915_perf.c+5−8

 {
 	int report_size = stream->oa_buffer.format_size;
 	struct drm_i915_perf_record_header header;
-	u32 sample_flags = stream->sample_flags;
 	header.type = DRM_I915_PERF_RECORD_SAMPLE;
 	header.pad = 0;
 		return -EFAULT;
 	buf += sizeof(header);
-	if (sample_flags & SAMPLE_OA_REPORT) {
+	if (copy_to_user(buf, report, report_size))
-		if (copy_to_user(buf, report, report_size))
+		return -EFAULT;
-			return -EFAULT;
-	}
 	(*offset) += header.size;
 	stream->perf->ops.oa_enable(stream);
-	if (stream->periodic)
+	if (stream->sample_flags & SAMPLE_OA_REPORT)
 		hrtimer_start(&stream->poll_check_timer,
 			      ns_to_ktime(stream->poll_oa_period),
 			      HRTIMER_MODE_REL_PINNED);
 {
 	stream->perf->ops.oa_disable(stream);
-	if (stream->periodic)
+	if (stream->sample_flags & SAMPLE_OA_REPORT)
 		hrtimer_cancel(&stream->poll_check_timer);
 }
 	 * disabled stream as an error. In particular it might otherwise lead
 	 * to a deadlock for blocking file descriptors...
 	 */
-	if (!stream->enabled)
+	if (!stream->enabled || !(stream->sample_flags & SAMPLE_OA_REPORT))
 		return -EIO;
 	if (!(file->f_flags & O_NONBLOCK)) {

drivers/gpu/drm/i915/i915_reg.h+22−1

@@ -3316,7 +3316,18 @@ static inline bool i915_mmio_reg_valid(i915_reg_t reg) · 3315 unmodified lines
3316		3316
3317	#define ILK_DISPLAY_CHICKEN1 _MMIO(0x42000)	3317	#define ILK_DISPLAY_CHICKEN1 _MMIO(0x42000)
3318	#define ILK_FBCQ_DIS (1 << 22)	3318	#define ILK_FBCQ_DIS (1 << 22)
3319	#define ILK_PABSTRETCH_DIS (1 << 21)	3319	#define ILK_PABSTRETCH_DIS REG_BIT(21)
		3320	#define ILK_SABSTRETCH_DIS REG_BIT(20)
		3321	#define IVB_PRI_STRETCH_MAX_MASK REG_GENMASK(21, 20)
		3322	#define IVB_PRI_STRETCH_MAX_X8 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 0)
		3323	#define IVB_PRI_STRETCH_MAX_X4 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 1)
		3324	#define IVB_PRI_STRETCH_MAX_X2 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 2)
		3325	#define IVB_PRI_STRETCH_MAX_X1 REG_FIELD_PREP(IVB_PRI_STRETCH_MAX_MASK, 3)
		3326	#define IVB_SPR_STRETCH_MAX_MASK REG_GENMASK(19, 18)
		3327	#define IVB_SPR_STRETCH_MAX_X8 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 0)
		3328	#define IVB_SPR_STRETCH_MAX_X4 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 1)
		3329	#define IVB_SPR_STRETCH_MAX_X2 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 2)
		3330	#define IVB_SPR_STRETCH_MAX_X1 REG_FIELD_PREP(IVB_SPR_STRETCH_MAX_MASK, 3)
3320		3331
3321		3332
3322	/*	3333	/*
@@ -8039,6 +8050,16 @@ enum { · 4716 unmodified lines
8039		8050
8040	#define _CHICKEN_PIPESL_1_A 0x420b0	8051	#define _CHICKEN_PIPESL_1_A 0x420b0
8041	#define _CHICKEN_PIPESL_1_B 0x420b4	8052	#define _CHICKEN_PIPESL_1_B 0x420b4
		8053	#define HSW_PRI_STRETCH_MAX_MASK REG_GENMASK(28, 27)
		8054	#define HSW_PRI_STRETCH_MAX_X8 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 0)
		8055	#define HSW_PRI_STRETCH_MAX_X4 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 1)
		8056	#define HSW_PRI_STRETCH_MAX_X2 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 2)
		8057	#define HSW_PRI_STRETCH_MAX_X1 REG_FIELD_PREP(HSW_PRI_STRETCH_MAX_MASK, 3)
		8058	#define HSW_SPR_STRETCH_MAX_MASK REG_GENMASK(26, 25)
		8059	#define HSW_SPR_STRETCH_MAX_X8 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 0)
		8060	#define HSW_SPR_STRETCH_MAX_X4 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 1)
		8061	#define HSW_SPR_STRETCH_MAX_X2 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 2)
		8062	#define HSW_SPR_STRETCH_MAX_X1 REG_FIELD_PREP(HSW_SPR_STRETCH_MAX_MASK, 3)
8042	#define HSW_FBCQ_DIS (1 << 22)	8063	#define HSW_FBCQ_DIS (1 << 22)
8043	#define BDW_DPRS_MASK_VBLANK_SRD (1 << 0)	8064	#define BDW_DPRS_MASK_VBLANK_SRD (1 << 0)
8044	#define CHICKEN_PIPESL_1(pipe) _MMIO_PIPE(pipe, _CHICKEN_PIPESL_1_A, _CHICKEN_PIPESL_1_B)	8065	#define CHICKEN_PIPESL_1(pipe) _MMIO_PIPE(pipe, _CHICKEN_PIPESL_1_A, _CHICKEN_PIPESL_1_B)

drivers/gpu/drm/i915/intel_pm.c+15−1

 	intel_uncore_write(&dev_priv->uncore, CHICKEN_PAR1_1,
 		   intel_uncore_read(&dev_priv->uncore, CHICKEN_PAR1_1) | DPA_MASK_VBLANK_SRD);
-	/* WaPsrDPRSUnmaskVBlankInSRD:bdw */
 	for_each_pipe(dev_priv, pipe) {
+		/* WaPsrDPRSUnmaskVBlankInSRD:bdw */
 		intel_uncore_write(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
 			   intel_uncore_read(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe)) |
 			   BDW_DPRS_MASK_VBLANK_SRD);
+		/* Undocumented but fixes async flip + VT-d corruption */
+		if (intel_vtd_active())
+			intel_uncore_rmw(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
+					 HSW_PRI_STRETCH_MAX_MASK, HSW_PRI_STRETCH_MAX_X1);
 	}
 	/* WaVSRefCountFullforceMissDisable:bdw */
 static void hsw_init_clock_gating(struct drm_i915_private *dev_priv)
 {
+	enum pipe pipe;
 	/* WaFbcAsynchFlipDisableFbcQueue:hsw,bdw */
 	intel_uncore_write(&dev_priv->uncore, CHICKEN_PIPESL_1(PIPE_A),
 		   intel_uncore_read(&dev_priv->uncore, CHICKEN_PIPESL_1(PIPE_A)) |
 		   HSW_FBCQ_DIS);
+	for_each_pipe(dev_priv, pipe) {
+		/* Undocumented but fixes async flip + VT-d corruption */
+		if (intel_vtd_active())
+			intel_uncore_rmw(&dev_priv->uncore, CHICKEN_PIPESL_1(pipe),
+					 HSW_PRI_STRETCH_MAX_MASK, HSW_PRI_STRETCH_MAX_X1);
+	}
 	/* This is required by WaCatErrorRejectionIssue:hsw */
 	intel_uncore_write(&dev_priv->uncore, GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
 		   intel_uncore_read(&dev_priv->uncore, GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) |

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/nouveau/nouveau_bo.c+8−0

 	if (!ttm_dma)
 		return;
+	if (!ttm_dma->pages) {
+		NV_DEBUG(drm, "ttm_dma 0x%p: pages NULL\n", ttm_dma);
+		return;
+	}
 	/* Don't waste time looping if the object is coherent */
 	if (nvbo->force_coherent)
 	if (!ttm_dma)
 		return;
+	if (!ttm_dma->pages) {
+		NV_DEBUG(drm, "ttm_dma 0x%p: pages NULL\n", ttm_dma);
+		return;
+	}
 	/* Don't waste time looping if the object is coherent */
 	if (nvbo->force_coherent)

drivers/gpu/drm/omapdrm/dss/dsi.c+4−3

 			     const struct mipi_dsi_msg *msg)
 {
 	struct mipi_dsi_packet pkt;
+	int ret;
 	u32 r;
-	r = mipi_dsi_create_packet(&pkt, msg);
+	ret = mipi_dsi_create_packet(&pkt, msg);
-	if (r < 0)
+	if (ret < 0)
-		return r;
+		return ret;
 	WARN_ON(!dsi_bus_is_locked(dsi));

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/iio/adc/Kconfig+3−0

 	select IIO_BUFFER
 	select IIO_BUFFER_HW_CONSUMER
 	select IIO_BUFFER_DMAENGINE
+	depends on HAS_IOMEM
+	depends on OF
 	help
 	  Say yes here to build support for Analog Devices Generic
 	  AXI ADC IP core. The IP core is used for interfacing with
 	depends on ARCH_STM32 || COMPILE_TEST
 	depends on OF
 	depends on REGULATOR
+	depends on HAS_IOMEM
 	select IIO_BUFFER
 	select MFD_STM32_TIMERS
 	select IIO_STM32_TIMER_TRIGGER

drivers/iio/adc/ab8500-gpadc.c+1−1

@@ -918,7 +918,7 @@ static int ab8500_gpadc_read_raw(struct iio_dev *indio_dev, · 917 unmodified lines
918	return processed;	918	return processed;
919		919
920	/* Return millivolt or milliamps or millicentigrades */	920	/* Return millivolt or milliamps or millicentigrades */
921	val = processed 1000;	921	*val = processed;
922	return IIO_VAL_INT;	922	return IIO_VAL_INT;
923	}	923	}
924		924

drivers/iio/adc/ad7949.c+1−1

@@ -91,7 +91,7 @@ static int ad7949_spi_read_channel(struct ad7949_adc_chip ad7949_adc, int val, · 90 unmodified lines
91	int ret;	91	int ret;
92	int i;	92	int i;
93	int bits_per_word = ad7949_adc->resolution;	93	int bits_per_word = ad7949_adc->resolution;
94	int mask = GENMASK(ad7949_adc->resolution, 0);	94	int mask = GENMASK(ad7949_adc->resolution - 1, 0);
95	struct spi_message msg;	95	struct spi_message msg;
96	struct spi_transfer tx[] = {	96	struct spi_transfer tx[] = {
97	{	97	{

drivers/iio/adc/qcom-spmi-vadc.c+1−1

@@ -597,7 +597,7 @@ static const struct vadc_channels vadc_chans[] = { · 596 unmodified lines
597	VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)	597	VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)
598		598
599	VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)	599	VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)
600	VADC_CHAN_NO_SCALE(LR_MUX2_BAT_ID, 0)	600	VADC_CHAN_VOLT(LR_MUX2_BAT_ID, 0, SCALE_DEFAULT)
601	VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)	601	VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)
602	VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)	602	VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)
603	VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)	603	VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)

drivers/iio/gyro/mpu3050-core.c+2−0

@@ -551,6 +551,8 @@ static irqreturn_t mpu3050_trigger_handler(int irq, void *p) · 550 unmodified lines
551	MPU3050_FIFO_R,	551	MPU3050_FIFO_R,
552	&fifo_values[offset],	552	&fifo_values[offset],
553	toread);	553	toread);
		554	if (ret)
		555	goto out_trigger_unlock;
554		556
555	dev_dbg(mpu3050->dev,	557	dev_dbg(mpu3050->dev,
556	"%04x %04x %04x %04x %04x\n",	558	"%04x %04x %04x %04x %04x\n",

drivers/iio/humidity/hid-sensor-humidity.c+7−5

 struct hid_humidity_state {
 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info humidity_attr;
-	s32 humidity_data;
+	struct {
+		s32 humidity_data;
+		u64 timestamp __aligned(8);
+	} scan;
 	int scale_pre_decml;
 	int scale_post_decml;
 	int scale_precision;
 	struct hid_humidity_state *humid_st = iio_priv(indio_dev);
 	if (atomic_read(&humid_st->common_attributes.data_ready))
-		iio_push_to_buffers_with_timestamp(indio_dev,
+		iio_push_to_buffers_with_timestamp(indio_dev, &humid_st->scan,
-					&humid_st->humidity_data,
+						   iio_get_time_ns(indio_dev));
-					iio_get_time_ns(indio_dev));
 	return 0;
 }
 	switch (usage_id) {
 	case HID_USAGE_SENSOR_ATMOSPHERIC_HUMIDITY:
-		humid_st->humidity_data = *(s32 *)raw_data;
+		humid_st->scan.humidity_data = *(s32 *)raw_data;
 		return 0;
 	default:

drivers/iio/imu/adis16400.c+1−2

@@ -462,8 +462,7 @@ static int adis16400_initial_setup(struct iio_dev *indio_dev) · 461 unmodified lines
462	if (ret)	462	if (ret)
463	goto err_ret;	463	goto err_ret;
464		464
465	ret = sscanf(indio_dev->name, "adis%u\n", &device_id);	465	if (sscanf(indio_dev->name, "adis%u\n", &device_id) != 1) {
466	if (ret != 1) {
467	ret = -EINVAL;	466	ret = -EINVAL;
468	goto err_ret;	467	goto err_ret;
469	}	468	}

drivers/iio/light/hid-sensor-prox.c+11−2

 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info prox_attr;
 	u32 human_presence;
+	int scale_pre_decml;
+	int scale_post_decml;
+	int scale_precision;
 };
 /* Channel definitions */
 		ret_type = IIO_VAL_INT;
 		break;
 	case IIO_CHAN_INFO_SCALE:
-		*val = prox_state->prox_attr.units;
+		*val = prox_state->scale_pre_decml;
-		ret_type = IIO_VAL_INT;
+		*val2 = prox_state->scale_post_decml;
+		ret_type = prox_state->scale_precision;
 		break;
 	case IIO_CHAN_INFO_OFFSET:
 		*val = hid_sensor_convert_exponent(
 			HID_USAGE_SENSOR_HUMAN_PRESENCE,
 			&st->common_attributes.sensitivity);
+	st->scale_precision = hid_sensor_format_scale(
+				hsdev->usage,
+				&st->prox_attr,
+				&st->scale_pre_decml, &st->scale_post_decml);
 	return ret;
 }

drivers/iio/temperature/hid-sensor-temperature.c+8−6

 struct temperature_state {
 	struct hid_sensor_common common_attributes;
 	struct hid_sensor_hub_attribute_info temperature_attr;
-	s32 temperature_data;
+	struct {
+		s32 temperature_data;
+		u64 timestamp __aligned(8);
+	} scan;
 	int scale_pre_decml;
 	int scale_post_decml;
 	int scale_precision;
 			BIT(IIO_CHAN_INFO_SAMP_FREQ) |
 			BIT(IIO_CHAN_INFO_HYSTERESIS),
 	},
-	IIO_CHAN_SOFT_TIMESTAMP(3),
+	IIO_CHAN_SOFT_TIMESTAMP(1),
 };
 /* Adjust channel real bits based on report descriptor */
 	struct temperature_state *temp_st = iio_priv(indio_dev);
 	if (atomic_read(&temp_st->common_attributes.data_ready))
-		iio_push_to_buffers_with_timestamp(indio_dev,
+		iio_push_to_buffers_with_timestamp(indio_dev, &temp_st->scan,
-				&temp_st->temperature_data,
+						   iio_get_time_ns(indio_dev));
-				iio_get_time_ns(indio_dev));
 	return 0;
 }
 	switch (usage_id) {
 	case HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE:
-		temp_st->temperature_data = *(s32 *)raw_data;
+		temp_st->scan.temperature_data = *(s32 *)raw_data;
 		return 0;
 	default:
 		return -EINVAL;

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/input/joydev.c+0−1

@@ -26,7 +26,6 @@ · 25 unmodified lines
26		26
27	MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");	27	MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
28	MODULE_DESCRIPTION("Joystick device interfaces");	28	MODULE_DESCRIPTION("Joystick device interfaces");
29	MODULE_SUPPORTED_DEVICE("input/js");
30	MODULE_LICENSE("GPL");	29	MODULE_LICENSE("GPL");
31		30
32	#define JOYDEV_MINOR_BASE 0	31	#define JOYDEV_MINOR_BASE 0

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/iommu/amd/init.c+20−16

 	struct acpi_table_header *ivrs_base;
 	int i, remap_cache_sz, ret;
 	acpi_status status;
-	u32 pci_id;
 	if (!amd_iommu_detected)
 		return -ENODEV;
 	if (ret)
 		goto out;
-	/* Disable IOMMU if there's Stoney Ridge graphics */
-	for (i = 0; i < 32; i++) {
-		pci_id = read_pci_config(0, i, 0, 0);
-		if ((pci_id & 0xffff) == 0x1002 && (pci_id >> 16) == 0x98e4) {
-			pr_info("Disable IOMMU on Stoney Ridge\n");
-			amd_iommu_disabled = true;
-			break;
-		}
-	}
 	/* Disable any previously enabled IOMMUs */
 	if (!is_kdump_kernel() || amd_iommu_disabled)
 		disable_iommus();
 {
 	struct acpi_table_header *ivrs_base;
 	acpi_status status;
+	int i;
 	status = acpi_get_table("IVRS", 0, &ivrs_base);
 	if (status == AE_NOT_FOUND)
 	acpi_put_table(ivrs_base);
+	/* Don't use IOMMU if there is Stoney Ridge graphics */
+	for (i = 0; i < 32; i++) {
+		u32 pci_id;
+		pci_id = read_pci_config(0, i, 0, 0);
+		if ((pci_id & 0xffff) == 0x1002 && (pci_id >> 16) == 0x98e4) {
+			pr_info("Disable IOMMU on Stoney Ridge\n");
+			return false;
+		}
+	}
 	/* Make sure ACS will be enabled during PCI probe */
 	pci_request_acs();
 		}
 		break;
 	case IOMMU_IVRS_DETECTED:
-		ret = early_amd_iommu_init();
+		if (amd_iommu_disabled) {
-		init_state = ret ? IOMMU_INIT_ERROR : IOMMU_ACPI_FINISHED;
-		if (init_state == IOMMU_ACPI_FINISHED && amd_iommu_disabled) {
-			pr_info("AMD IOMMU disabled\n");
 			init_state = IOMMU_CMDLINE_DISABLED;
 			ret = -EINVAL;
+		} else {
+			ret = early_amd_iommu_init();
+			init_state = ret ? IOMMU_INIT_ERROR : IOMMU_ACPI_FINISHED;
 		}
 		break;
 	case IOMMU_ACPI_FINISHED:
 	amd_iommu_irq_remap = true;
 	ret = iommu_go_to_state(IOMMU_ACPI_FINISHED);
-	if (ret)
+	if (ret) {
+		amd_iommu_irq_remap = false;
 		return ret;
+	}
 	return amd_iommu_irq_remap ? 0 : -ENODEV;
 }

drivers/iommu/tegra-smmu.c+3−4

@@ -849,12 +849,11 @@ static struct iommu_device tegra_smmu_probe_device(struct device dev) · 848 unmodified lines
849	smmu = tegra_smmu_find(args.np);	849	smmu = tegra_smmu_find(args.np);
850	if (smmu) {	850	if (smmu) {
851	err = tegra_smmu_configure(smmu, dev, &args);	851	err = tegra_smmu_configure(smmu, dev, &args);
852	of_node_put(args.np);
853		852
854	if (err < 0)	853	if (err < 0) {
		854	of_node_put(args.np);
855	return ERR_PTR(err);	855	return ERR_PTR(err);
856		856	}
857	break;
858	}	857	}
859		858
860	of_node_put(args.np);	859	of_node_put(args.np);

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/media/firewire/firedtv-fw.c+0−1

@@ -430,4 +430,3 @@ MODULE_AUTHOR("Andreas Monitzer <andy@monitzer.com>"); · 429 unmodified lines
430	MODULE_AUTHOR("Ben Backx <ben@bbackx.com>");	430	MODULE_AUTHOR("Ben Backx <ben@bbackx.com>");
431	MODULE_DESCRIPTION("FireDTV DVB Driver");	431	MODULE_DESCRIPTION("FireDTV DVB Driver");
432	MODULE_LICENSE("GPL");	432	MODULE_LICENSE("GPL");
433	MODULE_SUPPORTED_DEVICE("FireDTV DVB");

drivers/media/pci/cx18/cx18-alsa-main.c+0−1

@@ -41,7 +41,6 @@ MODULE_PARM_DESC(debug, · 40 unmodified lines
41		41
42	MODULE_AUTHOR("Andy Walls");	42	MODULE_AUTHOR("Andy Walls");
43	MODULE_DESCRIPTION("CX23418 ALSA Interface");	43	MODULE_DESCRIPTION("CX23418 ALSA Interface");
44	MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
45	MODULE_LICENSE("GPL");	44	MODULE_LICENSE("GPL");
46		45
47	MODULE_VERSION(CX18_VERSION);	46	MODULE_VERSION(CX18_VERSION);

drivers/media/pci/cx18/cx18-driver.c+0−1

@@ -232,7 +232,6 @@ MODULE_PARM_DESC(cx18_first_minor, · 231 unmodified lines
232		232
233	MODULE_AUTHOR("Hans Verkuil");	233	MODULE_AUTHOR("Hans Verkuil");
234	MODULE_DESCRIPTION("CX23418 driver");	234	MODULE_DESCRIPTION("CX23418 driver");
235	MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
236	MODULE_LICENSE("GPL");	235	MODULE_LICENSE("GPL");
237		236
238	MODULE_VERSION(CX18_VERSION);	237	MODULE_VERSION(CX18_VERSION);

drivers/media/pci/cx25821/cx25821-alsa.c+0−1

@@ -104,7 +104,6 @@ MODULE_PARM_DESC(index, "Index value for cx25821 capture interface(s)."); · 103 unmodified lines
104	MODULE_DESCRIPTION("ALSA driver module for cx25821 based capture cards");	104	MODULE_DESCRIPTION("ALSA driver module for cx25821 based capture cards");
105	MODULE_AUTHOR("Hiep Huynh");	105	MODULE_AUTHOR("Hiep Huynh");
106	MODULE_LICENSE("GPL");	106	MODULE_LICENSE("GPL");
107	MODULE_SUPPORTED_DEVICE("{{Conexant,25821}"); /* "{{Conexant,23881}," */
108		107
109	static unsigned int debug;	108	static unsigned int debug;
110	module_param(debug, int, 0644);	109	module_param(debug, int, 0644);

drivers/media/pci/cx88/cx88-alsa.c+0−1

@@ -98,7 +98,6 @@ MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>"); · 97 unmodified lines
98	MODULE_LICENSE("GPL v2");	98	MODULE_LICENSE("GPL v2");
99	MODULE_VERSION(CX88_VERSION);	99	MODULE_VERSION(CX88_VERSION);
100		100
101	MODULE_SUPPORTED_DEVICE("{{Conexant,23881},{{Conexant,23882},{{Conexant,23883}");
102	static unsigned int debug;	101	static unsigned int debug;
103	module_param(debug, int, 0644);	102	module_param(debug, int, 0644);
104	MODULE_PARM_DESC(debug, "enable debug messages");	103	MODULE_PARM_DESC(debug, "enable debug messages");

drivers/media/pci/ivtv/ivtv-alsa-main.c+0−1

@@ -38,7 +38,6 @@ MODULE_PARM_DESC(index, · 37 unmodified lines
38		38
39	MODULE_AUTHOR("Andy Walls");	39	MODULE_AUTHOR("Andy Walls");
40	MODULE_DESCRIPTION("CX23415/CX23416 ALSA Interface");	40	MODULE_DESCRIPTION("CX23415/CX23416 ALSA Interface");
41	MODULE_SUPPORTED_DEVICE("CX23415/CX23416 MPEG2 encoder");
42	MODULE_LICENSE("GPL");	41	MODULE_LICENSE("GPL");
43		42
44	MODULE_VERSION(IVTV_VERSION);	43	MODULE_VERSION(IVTV_VERSION);

drivers/media/pci/ivtv/ivtv-driver.c+0−3

@@ -275,9 +275,6 @@ MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first car · 274 unmodified lines
275		275
276	MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");	276	MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
277	MODULE_DESCRIPTION("CX23415/CX23416 driver");	277	MODULE_DESCRIPTION("CX23415/CX23416 driver");
278	MODULE_SUPPORTED_DEVICE
279	("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
280	"\t\t\tYuan MPG series and similar)");
281	MODULE_LICENSE("GPL");	278	MODULE_LICENSE("GPL");
282		279
283	MODULE_VERSION(IVTV_VERSION);	280	MODULE_VERSION(IVTV_VERSION);

drivers/media/pci/sta2x11/sta2x11_vip.c+0−1

@@ -1269,6 +1269,5 @@ late_initcall_sync(sta2x11_vip_init_module); · 1268 unmodified lines
1269	MODULE_DESCRIPTION("STA2X11 Video Input Port driver");	1269	MODULE_DESCRIPTION("STA2X11 Video Input Port driver");
1270	MODULE_AUTHOR("Wind River");	1270	MODULE_AUTHOR("Wind River");
1271	MODULE_LICENSE("GPL v2");	1271	MODULE_LICENSE("GPL v2");
1272	MODULE_SUPPORTED_DEVICE("sta2x11 video input");
1273	MODULE_VERSION(DRV_VERSION);	1272	MODULE_VERSION(DRV_VERSION);
1274	MODULE_DEVICE_TABLE(pci, sta2x11_vip_pci_tbl);	1273	MODULE_DEVICE_TABLE(pci, sta2x11_vip_pci_tbl);

drivers/media/platform/atmel/atmel-isi.c+0−1

@@ -1363,4 +1363,3 @@ module_platform_driver(atmel_isi_driver); · 1362 unmodified lines
1363	MODULE_AUTHOR("Josh Wu <josh.wu@atmel.com>");	1363	MODULE_AUTHOR("Josh Wu <josh.wu@atmel.com>");
1364	MODULE_DESCRIPTION("The V4L2 driver for Atmel Linux");	1364	MODULE_DESCRIPTION("The V4L2 driver for Atmel Linux");
1365	MODULE_LICENSE("GPL");	1365	MODULE_LICENSE("GPL");
1366	MODULE_SUPPORTED_DEVICE("video");

drivers/media/platform/atmel/atmel-sama5d2-isc.c+0−1

@@ -330,4 +330,3 @@ module_platform_driver(atmel_isc_driver); · 329 unmodified lines
330	MODULE_AUTHOR("Songjun Wu");	330	MODULE_AUTHOR("Songjun Wu");
331	MODULE_DESCRIPTION("The V4L2 driver for Atmel-ISC");	331	MODULE_DESCRIPTION("The V4L2 driver for Atmel-ISC");
332	MODULE_LICENSE("GPL v2");	332	MODULE_LICENSE("GPL v2");
333	MODULE_SUPPORTED_DEVICE("video");

drivers/media/platform/marvell-ccic/cafe-driver.c+0−4

@@ -44,10 +44,6 @@ · 43 unmodified lines
44	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");	44	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
45	MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");	45	MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");
46	MODULE_LICENSE("GPL");	46	MODULE_LICENSE("GPL");
47	MODULE_SUPPORTED_DEVICE("Video");
48
49
50
51		47
52	struct cafe_camera {	48	struct cafe_camera {
53	int registered; /* Fully initialized? */	49	int registered; /* Fully initialized? */

drivers/media/platform/stm32/stm32-dcmi.c+0−1

@@ -2149,4 +2149,3 @@ MODULE_AUTHOR("Yannick Fertre <yannick.fertre@st.com>"); · 2148 unmodified lines
2149	MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");	2149	MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");
2150	MODULE_DESCRIPTION("STMicroelectronics STM32 Digital Camera Memory Interface driver");	2150	MODULE_DESCRIPTION("STMicroelectronics STM32 Digital Camera Memory Interface driver");
2151	MODULE_LICENSE("GPL");	2151	MODULE_LICENSE("GPL");
2152	MODULE_SUPPORTED_DEVICE("video");

drivers/media/usb/cpia2/cpia2_v4l.c+0−1

@@ -56,7 +56,6 @@ MODULE_PARM_DESC(flicker_mode, "Flicker frequency (0 (disabled), " __stringify(5 · 55 unmodified lines
56		56
57	MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");	57	MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");
58	MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");	58	MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");
59	MODULE_SUPPORTED_DEVICE("video");
60	MODULE_LICENSE("GPL");	59	MODULE_LICENSE("GPL");
61	MODULE_VERSION(CPIA_VERSION);	60	MODULE_VERSION(CPIA_VERSION);
62		61

drivers/media/usb/tm6000/tm6000-alsa.c+0−1

@@ -51,7 +51,6 @@ MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s)."); · 50 unmodified lines
51	MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");	51	MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
52	MODULE_AUTHOR("Mauro Carvalho Chehab");	52	MODULE_AUTHOR("Mauro Carvalho Chehab");
53	MODULE_LICENSE("GPL v2");	53	MODULE_LICENSE("GPL v2");
54	MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},{{Trident,tm6000},{{Trident,tm6010}");
55	static unsigned int debug;	54	static unsigned int debug;
56	module_param(debug, int, 0644);	55	module_param(debug, int, 0644);
57	MODULE_PARM_DESC(debug, "enable debug messages");	56	MODULE_PARM_DESC(debug, "enable debug messages");

drivers/media/usb/tm6000/tm6000-dvb.c+0−2

@@ -23,8 +23,6 @@ MODULE_DESCRIPTION("DVB driver extension module for tm5600/6000/6010 based TV ca · 22 unmodified lines
23	MODULE_AUTHOR("Mauro Carvalho Chehab");	23	MODULE_AUTHOR("Mauro Carvalho Chehab");
24	MODULE_LICENSE("GPL");	24	MODULE_LICENSE("GPL");
25		25
26	MODULE_SUPPORTED_DEVICE("{{Trident, tm5600},{{Trident, tm6000},{{Trident, tm6010}");
27
28	static int debug;	26	static int debug;
29		27
30	module_param(debug, int, 0644);	28	module_param(debug, int, 0644);

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/mtd/maps/sun_uflash.c+0−1

@@ -32,7 +32,6 @@ · 31 unmodified lines
32		32
33	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	33	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
34	MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets");	34	MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets");
35	MODULE_SUPPORTED_DEVICE(DRIVER_NAME);
36	MODULE_LICENSE("GPL");	35	MODULE_LICENSE("GPL");
37	MODULE_VERSION("2.1");	36	MODULE_VERSION("2.1");
38		37

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/peak_canfd/peak_pciefd_main.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");
24	MODULE_SUPPORTED_DEVICE("PEAK PCAN PCIe/M.2 FD CAN cards");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define PCIEFD_DRV_NAME "peak_pciefd"	26	#define PCIEFD_DRV_NAME "peak_pciefd"

drivers/net/can/sja1000/ems_pci.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Sebastian Haas <haas@ems-wuenche.com>");	22	MODULE_AUTHOR("Sebastian Haas <haas@ems-wuenche.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-PCI/PCIe/104P CAN cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-PCI/PCIe/104P CAN cards");
24	MODULE_SUPPORTED_DEVICE("EMS CPC-PCI/PCIe/104P CAN card");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define EMS_PCI_V1_MAX_CHAN 2	26	#define EMS_PCI_V1_MAX_CHAN 2

drivers/net/can/sja1000/ems_pcmcia.c+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21		21
22	MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>");	22	MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>");
23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards");	23	MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards");
24	MODULE_SUPPORTED_DEVICE("EMS CPC-CARD CAN card");
25	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
26		25
27	#define EMS_PCMCIA_MAX_CHAN 2	26	#define EMS_PCMCIA_MAX_CHAN 2

drivers/net/can/sja1000/kvaser_pci.c+0−1

@@ -33,7 +33,6 @@ · 32 unmodified lines
33		33
34	MODULE_AUTHOR("Per Dalen <per.dalen@cnw.se>");	34	MODULE_AUTHOR("Per Dalen <per.dalen@cnw.se>");
35	MODULE_DESCRIPTION("Socket-CAN driver for KVASER PCAN PCI cards");	35	MODULE_DESCRIPTION("Socket-CAN driver for KVASER PCAN PCI cards");
36	MODULE_SUPPORTED_DEVICE("KVASER PCAN PCI CAN card");
37	MODULE_LICENSE("GPL v2");	36	MODULE_LICENSE("GPL v2");
38		37
39	#define MAX_NO_OF_CHANNELS 4 /* max no of channels on a single card */	38	#define MAX_NO_OF_CHANNELS 4 /* max no of channels on a single card */

drivers/net/can/sja1000/peak_pci.c+0−2

@@ -24,8 +24,6 @@ · 23 unmodified lines
24		24
25	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	25	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
26	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");	26	MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");
27	MODULE_SUPPORTED_DEVICE("PEAK PCAN PCI/PCIe/PCIeC miniPCI CAN cards");
28	MODULE_SUPPORTED_DEVICE("PEAK PCAN miniPCIe/cPCI PC/104+ PCI/104e CAN Cards");
29	MODULE_LICENSE("GPL v2");	27	MODULE_LICENSE("GPL v2");
30		28
31	#define DRV_NAME "peak_pci"	29	#define DRV_NAME "peak_pci"

drivers/net/can/sja1000/peak_pcmcia.c+0−1

@@ -22,7 +22,6 @@ · 21 unmodified lines
22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");	22	MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
23	MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");	23	MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
24	MODULE_LICENSE("GPL v2");	24	MODULE_LICENSE("GPL v2");
25	MODULE_SUPPORTED_DEVICE("PEAK PCAN-PC Card");
26		25
27	/* PEAK-System PCMCIA driver name */	26	/* PEAK-System PCMCIA driver name */
28	#define PCC_NAME "peak_pcmcia"	27	#define PCC_NAME "peak_pcmcia"

drivers/net/can/sja1000/plx_pci.c+0−12

@@ -25,18 +25,6 @@ · 24 unmodified lines
25	MODULE_AUTHOR("Pavel Cheblakov <P.B.Cheblakov@inp.nsk.su>");	25	MODULE_AUTHOR("Pavel Cheblakov <P.B.Cheblakov@inp.nsk.su>");
26	MODULE_DESCRIPTION("Socket-CAN driver for PLX90xx PCI-bridge cards with "	26	MODULE_DESCRIPTION("Socket-CAN driver for PLX90xx PCI-bridge cards with "
27	"the SJA1000 chips");	27	"the SJA1000 chips");
28	MODULE_SUPPORTED_DEVICE("Adlink PCI-7841/cPCI-7841, "
29	"Adlink PCI-7841/cPCI-7841 SE, "
30	"Marathon CAN-bus-PCI, "
31	"Marathon CAN-bus-PCIe, "
32	"TEWS TECHNOLOGIES TPMC810, "
33	"esd CAN-PCI/CPCI/PCI104/200, "
34	"esd CAN-PCI/PMC/266, "
35	"esd CAN-PCIe/2000, "
36	"Connect Tech Inc. CANpro/104-Plus Opto (CRG001), "
37	"IXXAT PC-I 04/PCI, "
38	"ELCUS CAN-200-PCI, "
39	"ASEM DUAL CAN-RAW")
40	MODULE_LICENSE("GPL v2");	28	MODULE_LICENSE("GPL v2");
41		29
42	#define PLX_PCI_MAX_CHAN 2	30	#define PLX_PCI_MAX_CHAN 2

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/can/usb/peak_usb/pcan_usb.c+0−2

@@ -18,8 +18,6 @@ · 17 unmodified lines
18		18
19	#include "pcan_usb_core.h"	19	#include "pcan_usb_core.h"
20		20
21	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB adapter");
22
23	/* PCAN-USB Endpoints */	21	/* PCAN-USB Endpoints */
24	#define PCAN_USB_EP_CMDOUT 1	22	#define PCAN_USB_EP_CMDOUT 1
25	#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT \| USB_DIR_IN)	23	#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT \| USB_DIR_IN)

drivers/net/can/usb/peak_usb/pcan_usb_fd.c+0−3

@@ -16,9 +16,6 @@ · 15 unmodified lines
16	#include "pcan_usb_core.h"	16	#include "pcan_usb_core.h"
17	#include "pcan_usb_pro.h"	17	#include "pcan_usb_pro.h"
18		18
19	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB FD adapter");
20	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro FD adapter");
21
22	#define PCAN_USBPROFD_CHANNEL_COUNT 2	19	#define PCAN_USBPROFD_CHANNEL_COUNT 2
23	#define PCAN_USBFD_CHANNEL_COUNT 1	20	#define PCAN_USBFD_CHANNEL_COUNT 1
24		21

drivers/net/can/usb/peak_usb/pcan_usb_pro.c+0−2

@@ -17,8 +17,6 @@ · 16 unmodified lines
17	#include "pcan_usb_core.h"	17	#include "pcan_usb_core.h"
18	#include "pcan_usb_pro.h"	18	#include "pcan_usb_pro.h"
19		19
20	MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB Pro adapter");
21
22	#define PCAN_USBPRO_CHANNEL_COUNT 2	20	#define PCAN_USBPRO_CHANNEL_COUNT 2
23		21
24	/* PCAN-USB Pro adapter internal clock (MHz) */	22	/* PCAN-USB Pro adapter internal clock (MHz) */

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/hamradio/scc.c+0−1

@@ -2167,7 +2167,6 @@ static void __exit scc_cleanup_driver(void) · 2166 unmodified lines
2167		2167
2168	MODULE_AUTHOR("Joerg Reuter <jreuter@yaina.de>");	2168	MODULE_AUTHOR("Joerg Reuter <jreuter@yaina.de>");
2169	MODULE_DESCRIPTION("AX.25 Device Driver for Z8530 based HDLC cards");	2169	MODULE_DESCRIPTION("AX.25 Device Driver for Z8530 based HDLC cards");
2170	MODULE_SUPPORTED_DEVICE("Z8530 based SCC cards for Amateur Radio");
2171	MODULE_LICENSE("GPL");	2170	MODULE_LICENSE("GPL");
2172	module_init(scc_init_driver);	2171	module_init(scc_init_driver);
2173	module_exit(scc_cleanup_driver);	2172	module_exit(scc_cleanup_driver);

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/net/wireless/admtek/adm8211.c+0−1

@@ -28,7 +28,6 @@ · 27 unmodified lines
28	MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");	28	MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
29	MODULE_AUTHOR("Jouni Malinen <j@w1.fi>");	29	MODULE_AUTHOR("Jouni Malinen <j@w1.fi>");
30	MODULE_DESCRIPTION("Driver for IEEE 802.11b wireless cards based on ADMtek ADM8211");	30	MODULE_DESCRIPTION("Driver for IEEE 802.11b wireless cards based on ADMtek ADM8211");
31	MODULE_SUPPORTED_DEVICE("ADM8211");
32	MODULE_LICENSE("GPL");	31	MODULE_LICENSE("GPL");
33		32
34	static unsigned int tx_ring_size __read_mostly = 16;	33	static unsigned int tx_ring_size __read_mostly = 16;

drivers/net/wireless/ath/ath5k/base.c+0−1

@@ -90,7 +90,6 @@ MODULE_PARM_DESC(no_hw_rfkill_switch, "Ignore the GPIO RFKill switch state"); · 89 unmodified lines
90	MODULE_AUTHOR("Jiri Slaby");	90	MODULE_AUTHOR("Jiri Slaby");
91	MODULE_AUTHOR("Nick Kossifidis");	91	MODULE_AUTHOR("Nick Kossifidis");
92	MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");	92	MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");
93	MODULE_SUPPORTED_DEVICE("Atheros 5xxx WLAN cards");
94	MODULE_LICENSE("Dual BSD/GPL");	93	MODULE_LICENSE("Dual BSD/GPL");
95		94
96	static int ath5k_init(struct ieee80211_hw *hw);	95	static int ath5k_init(struct ieee80211_hw *hw);

drivers/net/wireless/ath/ath9k/hw.c+0−1

@@ -34,7 +34,6 @@ static bool ath9k_hw_set_reset_reg(struct ath_hw *ah, u32 type); · 33 unmodified lines
34		34
35	MODULE_AUTHOR("Atheros Communications");	35	MODULE_AUTHOR("Atheros Communications");
36	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");	36	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
37	MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
38	MODULE_LICENSE("Dual BSD/GPL");	37	MODULE_LICENSE("Dual BSD/GPL");
39		38
40	static void ath9k_hw_set_clockrate(struct ath_hw *ah)	39	static void ath9k_hw_set_clockrate(struct ath_hw *ah)

drivers/net/wireless/ath/ath9k/init.c+0−1

@@ -37,7 +37,6 @@ static char *dev_info = "ath9k"; · 36 unmodified lines
37		37
38	MODULE_AUTHOR("Atheros Communications");	38	MODULE_AUTHOR("Atheros Communications");
39	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");	39	MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
40	MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
41	MODULE_LICENSE("Dual BSD/GPL");	40	MODULE_LICENSE("Dual BSD/GPL");
42		41
43	static unsigned int ath9k_debug = ATH_DBG_DEFAULT;	42	static unsigned int ath9k_debug = ATH_DBG_DEFAULT;

drivers/net/wireless/atmel/atmel.c+0−1

@@ -75,7 +75,6 @@ · 74 unmodified lines
75	MODULE_AUTHOR("Simon Kelley");	75	MODULE_AUTHOR("Simon Kelley");
76	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	76	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
77	MODULE_LICENSE("GPL");	77	MODULE_LICENSE("GPL");
78	MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards");
79		78
80	/* The name of the firmware file to be loaded	79	/* The name of the firmware file to be loaded
81	over-rides any automatic selection */	80	over-rides any automatic selection */

drivers/net/wireless/atmel/atmel_cs.c+0−1

@@ -57,7 +57,6 @@ · 56 unmodified lines
57	MODULE_AUTHOR("Simon Kelley");	57	MODULE_AUTHOR("Simon Kelley");
58	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	58	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
59	MODULE_LICENSE("GPL");	59	MODULE_LICENSE("GPL");
60	MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
61		60
62	/====================================================================/	61	/====================================================================/
63		62

drivers/net/wireless/atmel/atmel_pci.c+0−1

@@ -16,7 +16,6 @@ · 15 unmodified lines
16	MODULE_AUTHOR("Simon Kelley");	16	MODULE_AUTHOR("Simon Kelley");
17	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");	17	MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
18	MODULE_LICENSE("GPL");	18	MODULE_LICENSE("GPL");
19	MODULE_SUPPORTED_DEVICE("Atmel at76c506 PCI wireless cards");
20		19
21	static const struct pci_device_id card_ids[] = {	20	static const struct pci_device_id card_ids[] = {
22	{ 0x1114, 0x0506, PCI_ANY_ID, PCI_ANY_ID },	21	{ 0x1114, 0x0506, PCI_ANY_ID, PCI_ANY_ID },

drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c+0−1

@@ -87,7 +87,6 @@ static int n_adapters_found; · 86 unmodified lines
87		87
88	MODULE_AUTHOR("Broadcom Corporation");	88	MODULE_AUTHOR("Broadcom Corporation");
89	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");	89	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");
90	MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
91	MODULE_LICENSE("Dual BSD/GPL");	90	MODULE_LICENSE("Dual BSD/GPL");
92	/* This needs to be adjusted when brcms_firmwares changes */	91	/* This needs to be adjusted when brcms_firmwares changes */
93	MODULE_FIRMWARE("brcm/bcm43xx-0.fw");	92	MODULE_FIRMWARE("brcm/bcm43xx-0.fw");

drivers/net/wireless/broadcom/brcm80211/brcmutil/utils.c+0−1

@@ -12,7 +12,6 @@ · 11 unmodified lines
12		12
13	MODULE_AUTHOR("Broadcom Corporation");	13	MODULE_AUTHOR("Broadcom Corporation");
14	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");	14	MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");
15	MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
16	MODULE_LICENSE("Dual BSD/GPL");	15	MODULE_LICENSE("Dual BSD/GPL");
17		16
18	struct sk_buff *brcmu_pkt_buf_get_skb(uint len)	17	struct sk_buff *brcmu_pkt_buf_get_skb(uint len)

drivers/net/wireless/cisco/airo.c+0−1

@@ -251,7 +251,6 @@ MODULE_AUTHOR("Benjamin Reed"); · 250 unmodified lines
251	MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet cards. "	251	MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet cards. "
252	"Direct support for ISA/PCI/MPI cards and support for PCMCIA when used with airo_cs.");	252	"Direct support for ISA/PCI/MPI cards and support for PCMCIA when used with airo_cs.");
253	MODULE_LICENSE("Dual BSD/GPL");	253	MODULE_LICENSE("Dual BSD/GPL");
254	MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
255	module_param_hw_array(io, int, ioport, NULL, 0);	254	module_param_hw_array(io, int, ioport, NULL, 0);
256	module_param_hw_array(irq, int, irq, NULL, 0);	255	module_param_hw_array(irq, int, irq, NULL, 0);
257	module_param_array(rates, int, NULL, 0);	256	module_param_array(rates, int, NULL, 0);

drivers/net/wireless/cisco/airo_cs.c+0−1

@@ -47,7 +47,6 @@ MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet " · 46 unmodified lines
47	"cards. This is the module that links the PCMCIA card "	47	"cards. This is the module that links the PCMCIA card "
48	"with the airo module.");	48	"with the airo module.");
49	MODULE_LICENSE("Dual BSD/GPL");	49	MODULE_LICENSE("Dual BSD/GPL");
50	MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
51		50
52	/====================================================================/	51	/====================================================================/
53		52

drivers/net/wireless/intersil/hostap/hostap_cs.c+0−1

@@ -26,7 +26,6 @@ static char *dev_info = "hostap_cs"; · 25 unmodified lines
26	MODULE_AUTHOR("Jouni Malinen");	26	MODULE_AUTHOR("Jouni Malinen");
27	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "	27	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "
28	"cards (PC Card).");	28	"cards (PC Card).");
29	MODULE_SUPPORTED_DEVICE("Intersil Prism2-based WLAN cards (PC Card)");
30	MODULE_LICENSE("GPL");	29	MODULE_LICENSE("GPL");
31		30
32		31

drivers/net/wireless/intersil/hostap/hostap_pci.c+0−1

@@ -27,7 +27,6 @@ static char *dev_info = "hostap_pci"; · 26 unmodified lines
27	MODULE_AUTHOR("Jouni Malinen");	27	MODULE_AUTHOR("Jouni Malinen");
28	MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "	28	MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
29	"PCI cards.");	29	"PCI cards.");
30	MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
31	MODULE_LICENSE("GPL");	30	MODULE_LICENSE("GPL");
32		31
33		32

drivers/net/wireless/intersil/hostap/hostap_plx.c+0−1

@@ -30,7 +30,6 @@ static char *dev_info = "hostap_plx"; · 29 unmodified lines
30	MODULE_AUTHOR("Jouni Malinen");	30	MODULE_AUTHOR("Jouni Malinen");
31	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "	31	MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN "
32	"cards (PLX).");	32	"cards (PLX).");
33	MODULE_SUPPORTED_DEVICE("Intersil Prism2-based WLAN cards (PLX)");
34	MODULE_LICENSE("GPL");	33	MODULE_LICENSE("GPL");
35		34
36		35

drivers/net/wireless/ralink/rt2x00/rt2400pci.c+0−1

@@ -1821,7 +1821,6 @@ static const struct pci_device_id rt2400pci_device_table[] = { · 1820 unmodified lines
1821	MODULE_AUTHOR(DRV_PROJECT);	1821	MODULE_AUTHOR(DRV_PROJECT);
1822	MODULE_VERSION(DRV_VERSION);	1822	MODULE_VERSION(DRV_VERSION);
1823	MODULE_DESCRIPTION("Ralink RT2400 PCI & PCMCIA Wireless LAN driver.");	1823	MODULE_DESCRIPTION("Ralink RT2400 PCI & PCMCIA Wireless LAN driver.");
1824	MODULE_SUPPORTED_DEVICE("Ralink RT2460 PCI & PCMCIA chipset based cards");
1825	MODULE_DEVICE_TABLE(pci, rt2400pci_device_table);	1824	MODULE_DEVICE_TABLE(pci, rt2400pci_device_table);
1826	MODULE_LICENSE("GPL");	1825	MODULE_LICENSE("GPL");
1827		1826

drivers/net/wireless/ralink/rt2x00/rt2500pci.c+0−1

@@ -2119,7 +2119,6 @@ static const struct pci_device_id rt2500pci_device_table[] = { · 2118 unmodified lines
2119	MODULE_AUTHOR(DRV_PROJECT);	2119	MODULE_AUTHOR(DRV_PROJECT);
2120	MODULE_VERSION(DRV_VERSION);	2120	MODULE_VERSION(DRV_VERSION);
2121	MODULE_DESCRIPTION("Ralink RT2500 PCI & PCMCIA Wireless LAN driver.");	2121	MODULE_DESCRIPTION("Ralink RT2500 PCI & PCMCIA Wireless LAN driver.");
2122	MODULE_SUPPORTED_DEVICE("Ralink RT2560 PCI & PCMCIA chipset based cards");
2123	MODULE_DEVICE_TABLE(pci, rt2500pci_device_table);	2122	MODULE_DEVICE_TABLE(pci, rt2500pci_device_table);
2124	MODULE_LICENSE("GPL");	2123	MODULE_LICENSE("GPL");
2125		2124

drivers/net/wireless/ralink/rt2x00/rt2500usb.c+0−1

@@ -1956,7 +1956,6 @@ static const struct usb_device_id rt2500usb_device_table[] = { · 1955 unmodified lines
1956	MODULE_AUTHOR(DRV_PROJECT);	1956	MODULE_AUTHOR(DRV_PROJECT);
1957	MODULE_VERSION(DRV_VERSION);	1957	MODULE_VERSION(DRV_VERSION);
1958	MODULE_DESCRIPTION("Ralink RT2500 USB Wireless LAN driver.");	1958	MODULE_DESCRIPTION("Ralink RT2500 USB Wireless LAN driver.");
1959	MODULE_SUPPORTED_DEVICE("Ralink RT2570 USB chipset based cards");
1960	MODULE_DEVICE_TABLE(usb, rt2500usb_device_table);	1959	MODULE_DEVICE_TABLE(usb, rt2500usb_device_table);
1961	MODULE_LICENSE("GPL");	1960	MODULE_LICENSE("GPL");
1962		1961

drivers/net/wireless/ralink/rt2x00/rt2800pci.c+0−1

@@ -439,7 +439,6 @@ static const struct pci_device_id rt2800pci_device_table[] = { · 438 unmodified lines
439	MODULE_AUTHOR(DRV_PROJECT);	439	MODULE_AUTHOR(DRV_PROJECT);
440	MODULE_VERSION(DRV_VERSION);	440	MODULE_VERSION(DRV_VERSION);
441	MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver.");	441	MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver.");
442	MODULE_SUPPORTED_DEVICE("Ralink RT2860 PCI & PCMCIA chipset based cards");
443	MODULE_FIRMWARE(FIRMWARE_RT2860);	442	MODULE_FIRMWARE(FIRMWARE_RT2860);
444	MODULE_DEVICE_TABLE(pci, rt2800pci_device_table);	443	MODULE_DEVICE_TABLE(pci, rt2800pci_device_table);
445	MODULE_LICENSE("GPL");	444	MODULE_LICENSE("GPL");

drivers/net/wireless/ralink/rt2x00/rt2800usb.c+0−1

@@ -1248,7 +1248,6 @@ static const struct usb_device_id rt2800usb_device_table[] = { · 1247 unmodified lines
1248	MODULE_AUTHOR(DRV_PROJECT);	1248	MODULE_AUTHOR(DRV_PROJECT);
1249	MODULE_VERSION(DRV_VERSION);	1249	MODULE_VERSION(DRV_VERSION);
1250	MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver.");	1250	MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver.");
1251	MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards");
1252	MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);	1251	MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);
1253	MODULE_FIRMWARE(FIRMWARE_RT2870);	1252	MODULE_FIRMWARE(FIRMWARE_RT2870);
1254	MODULE_LICENSE("GPL");	1253	MODULE_LICENSE("GPL");

drivers/net/wireless/ralink/rt2x00/rt61pci.c+0−2

 MODULE_AUTHOR(DRV_PROJECT);
 MODULE_VERSION(DRV_VERSION);
 MODULE_DESCRIPTION("Ralink RT61 PCI & PCMCIA Wireless LAN driver.");
-MODULE_SUPPORTED_DEVICE("Ralink RT2561, RT2561s & RT2661 "
-			"PCI & PCMCIA chipset based cards");
 MODULE_DEVICE_TABLE(pci, rt61pci_device_table);
 MODULE_FIRMWARE(FIRMWARE_RT2561);
 MODULE_FIRMWARE(FIRMWARE_RT2561s);

drivers/net/wireless/ralink/rt2x00/rt73usb.c+0−1

@@ -2513,7 +2513,6 @@ static const struct usb_device_id rt73usb_device_table[] = { · 2512 unmodified lines
2513	MODULE_AUTHOR(DRV_PROJECT);	2513	MODULE_AUTHOR(DRV_PROJECT);
2514	MODULE_VERSION(DRV_VERSION);	2514	MODULE_VERSION(DRV_VERSION);
2515	MODULE_DESCRIPTION("Ralink RT73 USB Wireless LAN driver.");	2515	MODULE_DESCRIPTION("Ralink RT73 USB Wireless LAN driver.");
2516	MODULE_SUPPORTED_DEVICE("Ralink RT2571W & RT2671 USB chipset based cards");
2517	MODULE_DEVICE_TABLE(usb, rt73usb_device_table);	2516	MODULE_DEVICE_TABLE(usb, rt73usb_device_table);
2518	MODULE_FIRMWARE(FIRMWARE_RT2571);	2517	MODULE_FIRMWARE(FIRMWARE_RT2571);
2519	MODULE_LICENSE("GPL");	2518	MODULE_LICENSE("GPL");

drivers/net/wireless/rsi/rsi_91x_main.c+0−1

@@ -441,6 +441,5 @@ module_init(rsi_91x_hal_module_init); · 440 unmodified lines
441	module_exit(rsi_91x_hal_module_exit);	441	module_exit(rsi_91x_hal_module_exit);
442	MODULE_AUTHOR("Redpine Signals Inc");	442	MODULE_AUTHOR("Redpine Signals Inc");
443	MODULE_DESCRIPTION("Station driver for RSI 91x devices");	443	MODULE_DESCRIPTION("Station driver for RSI 91x devices");
444	MODULE_SUPPORTED_DEVICE("RSI-91x");
445	MODULE_VERSION("0.1");	444	MODULE_VERSION("0.1");
446	MODULE_LICENSE("Dual BSD/GPL");	445	MODULE_LICENSE("Dual BSD/GPL");

drivers/net/wireless/rsi/rsi_91x_sdio.c+0−1

@@ -1571,7 +1571,6 @@ module_exit(rsi_module_exit); · 1570 unmodified lines
1571		1571
1572	MODULE_AUTHOR("Redpine Signals Inc");	1572	MODULE_AUTHOR("Redpine Signals Inc");
1573	MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");	1573	MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");
1574	MODULE_SUPPORTED_DEVICE("RSI-91x");
1575	MODULE_DEVICE_TABLE(sdio, rsi_dev_table);	1574	MODULE_DEVICE_TABLE(sdio, rsi_dev_table);
1576	MODULE_FIRMWARE(FIRMWARE_RSI9113);	1575	MODULE_FIRMWARE(FIRMWARE_RSI9113);
1577	MODULE_VERSION("0.1");	1576	MODULE_VERSION("0.1");

drivers/net/wireless/rsi/rsi_91x_usb.c+0−1

@@ -928,7 +928,6 @@ module_usb_driver(rsi_driver); · 927 unmodified lines
928		928
929	MODULE_AUTHOR("Redpine Signals Inc");	929	MODULE_AUTHOR("Redpine Signals Inc");
930	MODULE_DESCRIPTION("Common USB layer for RSI drivers");	930	MODULE_DESCRIPTION("Common USB layer for RSI drivers");
931	MODULE_SUPPORTED_DEVICE("RSI-91x");
932	MODULE_DEVICE_TABLE(usb, rsi_dev_table);	931	MODULE_DEVICE_TABLE(usb, rsi_dev_table);
933	MODULE_FIRMWARE(FIRMWARE_RSI9113);	932	MODULE_FIRMWARE(FIRMWARE_RSI9113);
934	MODULE_VERSION("0.1");	933	MODULE_VERSION("0.1");

drivers/nvme/host/core.c+21−43

@@ -1226,28 +1226,12 @@ static void nvme_keep_alive_end_io(struct request *rq, blk_status_t status) · 1225 unmodified lines
1226	queue_delayed_work(nvme_wq, &ctrl->ka_work, ctrl->kato * HZ);	1226	queue_delayed_work(nvme_wq, &ctrl->ka_work, ctrl->kato * HZ);
1227	}	1227	}
1228		1228
1229	static int nvme_keep_alive(struct nvme_ctrl *ctrl)
1230	{
1231	struct request *rq;
1232
1233	rq = nvme_alloc_request(ctrl->admin_q, &ctrl->ka_cmd,
1234	BLK_MQ_REQ_RESERVED);
1235	if (IS_ERR(rq))
1236	return PTR_ERR(rq);
1237
1238	rq->timeout = ctrl->kato * HZ;
1239	rq->end_io_data = ctrl;
1240
1241	blk_execute_rq_nowait(NULL, rq, 0, nvme_keep_alive_end_io);
1242
1243	return 0;
1244	}
1245
1246	static void nvme_keep_alive_work(struct work_struct *work)	1229	static void nvme_keep_alive_work(struct work_struct *work)
1247	{	1230	{
1248	struct nvme_ctrl *ctrl = container_of(to_delayed_work(work),	1231	struct nvme_ctrl *ctrl = container_of(to_delayed_work(work),
1249	struct nvme_ctrl, ka_work);	1232	struct nvme_ctrl, ka_work);
1250	bool comp_seen = ctrl->comp_seen;	1233	bool comp_seen = ctrl->comp_seen;
		1234	struct request *rq;
1251		1235
1252	if ((ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) && comp_seen) {	1236	if ((ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) && comp_seen) {
1253	dev_dbg(ctrl->device,	1237	dev_dbg(ctrl->device,
@@ -1257,12 +1241,18 @@ static void nvme_keep_alive_work(struct work_struct *work) · 3 unmodified lines
1257	return;	1241	return;
1258	}	1242	}
1259		1243
1260	if (nvme_keep_alive(ctrl)) {	1244	rq = nvme_alloc_request(ctrl->admin_q, &ctrl->ka_cmd,
		1245	BLK_MQ_REQ_RESERVED \| BLK_MQ_REQ_NOWAIT);
		1246	if (IS_ERR(rq)) {
1261	/* allocation failure, reset the controller */	1247	/* allocation failure, reset the controller */
1262	dev_err(ctrl->device, "keep-alive failed\n");	1248	dev_err(ctrl->device, "keep-alive failed: %ld\n", PTR_ERR(rq));
1263	nvme_reset_ctrl(ctrl);	1249	nvme_reset_ctrl(ctrl);
1264	return;	1250	return;
1265	}	1251	}
		1252
		1253	rq->timeout = ctrl->kato * HZ;
		1254	rq->end_io_data = ctrl;
		1255	blk_execute_rq_nowait(NULL, rq, 0, nvme_keep_alive_end_io);
1266	}	1256	}
1267		1257
1268	static void nvme_start_keep_alive(struct nvme_ctrl *ctrl)	1258	static void nvme_start_keep_alive(struct nvme_ctrl *ctrl)
@@ -1964,30 +1954,18 @@ static void nvme_config_discard(struct gendisk disk, struct nvme_ns ns) · 695 unmodified lines
1964	blk_queue_max_write_zeroes_sectors(queue, UINT_MAX);	1954	blk_queue_max_write_zeroes_sectors(queue, UINT_MAX);
1965	}	1955	}
1966		1956
1967	static void nvme_config_write_zeroes(struct gendisk disk, struct nvme_ns ns)	1957	/*
		1958	* Even though NVMe spec explicitly states that MDTS is not applicable to the
		1959	* write-zeroes, we are cautious and limit the size to the controllers
		1960	* max_hw_sectors value, which is based on the MDTS field and possibly other
		1961	* limiting factors.
		1962	*/
		1963	static void nvme_config_write_zeroes(struct request_queue *q,
		1964	struct nvme_ctrl *ctrl)
1968	{	1965	{
1969	u64 max_blocks;	1966	if ((ctrl->oncs & NVME_CTRL_ONCS_WRITE_ZEROES) &&
1970		1967	!(ctrl->quirks & NVME_QUIRK_DISABLE_WRITE_ZEROES))
1971	if (!(ns->ctrl->oncs & NVME_CTRL_ONCS_WRITE_ZEROES) \|\|	1968	blk_queue_max_write_zeroes_sectors(q, ctrl->max_hw_sectors);
1972	(ns->ctrl->quirks & NVME_QUIRK_DISABLE_WRITE_ZEROES))
1973	return;
1974	/*
1975	* Even though NVMe spec explicitly states that MDTS is not
1976	* applicable to the write-zeroes:- "The restriction does not apply to
1977	* commands that do not transfer data between the host and the
1978	* controller (e.g., Write Uncorrectable ro Write Zeroes command).".
1979	* In order to be more cautious use controller's max_hw_sectors value
1980	* to configure the maximum sectors for the write-zeroes which is
1981	* configured based on the controller's MDTS field in the
1982	* nvme_init_identify() if available.
1983	*/
1984	if (ns->ctrl->max_hw_sectors == UINT_MAX)
1985	max_blocks = (u64)USHRT_MAX + 1;
1986	else
1987	max_blocks = ns->ctrl->max_hw_sectors + 1;
1988
1989	blk_queue_max_write_zeroes_sectors(disk->queue,
1990	nvme_lba_to_sect(ns, max_blocks));
1991	}	1969	}
1992		1970
1993	static bool nvme_ns_ids_valid(struct nvme_ns_ids *ids)	1971	static bool nvme_ns_ids_valid(struct nvme_ns_ids *ids)
@@ -2159,7 +2137,7 @@ static void nvme_update_disk_info(struct gendisk *disk, · 165 unmodified lines
2159	set_capacity_and_notify(disk, capacity);	2137	set_capacity_and_notify(disk, capacity);
2160		2138
2161	nvme_config_discard(disk, ns);	2139	nvme_config_discard(disk, ns);
2162	nvme_config_write_zeroes(disk, ns);	2140	nvme_config_write_zeroes(disk->queue, ns->ctrl);
2163		2141
2164	set_disk_ro(disk, (id->nsattr & NVME_NS_ATTR_RO) \|\|	2142	set_disk_ro(disk, (id->nsattr & NVME_NS_ATTR_RO) \|\|
2165	test_bit(NVME_NS_FORCE_RO, &ns->flags));	2143	test_bit(NVME_NS_FORCE_RO, &ns->flags));

drivers/nvme/host/fabrics.h+7−0

@@ -18,6 +18,13 @@ · 17 unmodified lines
18	/* default is -1: the fail fast mechanism is disabled */	18	/* default is -1: the fail fast mechanism is disabled */
19	#define NVMF_DEF_FAIL_FAST_TMO -1	19	#define NVMF_DEF_FAIL_FAST_TMO -1
20		20
		21	/*
		22	* Reserved one command for internal usage. This command is used for sending
		23	* the connect command, as well as for the keep alive command on the admin
		24	* queue once live.
		25	*/
		26	#define NVMF_RESERVED_TAGS 1
		27
21	/*	28	/*
22	* Define a host as seen by the target. We allocate one at boot, but also	29	* Define a host as seen by the target. We allocate one at boot, but also
23	* allow the override it when creating controllers. This is both to provide	30	* allow the override it when creating controllers. This is both to provide

drivers/nvme/host/fc.c+2−2

drivers/nvme/host/rdma.c+7−4

 		return ret;
 	ctrl->ctrl.queue_count = nr_io_queues + 1;
-	if (ctrl->ctrl.queue_count < 2)
+	if (ctrl->ctrl.queue_count < 2) {
-		return 0;
+		dev_err(ctrl->ctrl.device,
+			"unable to set any I/O queues\n");
+		return -ENOMEM;
+	}
 	dev_info(ctrl->ctrl.device,
 		"creating %d I/O queues.\n", nr_io_queues);
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_rdma_admin_mq_ops;
 		set->queue_depth = NVME_AQ_MQ_TAG_DEPTH;
-		set->reserved_tags = 2; /* connect + keep-alive */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->cmd_size = sizeof(struct nvme_rdma_request) +
 				NVME_RDMA_DATA_SGL_SIZE;
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_rdma_mq_ops;
 		set->queue_depth = nctrl->sqsize + 1;
-		set->reserved_tags = 1; /* fabric connect */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_SHOULD_MERGE;
 		set->cmd_size = sizeof(struct nvme_rdma_request) +

drivers/nvme/host/tcp.c+15−5

 	 * directly, otherwise queue io_work. Also, only do that if we
 	 * are on the same cpu, so we don't introduce contention.
 	 */
-	if (queue->io_cpu == __smp_processor_id() &&
+	if (queue->io_cpu == raw_smp_processor_id() &&
 	    sync && empty && mutex_trylock(&queue->send_mutex)) {
 		queue->more_requests = !last;
 		nvme_tcp_send_all(queue);
 	req->pdu_len = le32_to_cpu(pdu->r2t_length);
 	req->pdu_sent = 0;
+	if (unlikely(!req->pdu_len)) {
+		dev_err(queue->ctrl->ctrl.device,
+			"req %d r2t len is %u, probably a bug...\n",
+			rq->tag, req->pdu_len);
+		return -EPROTO;
+	}
 	if (unlikely(req->data_sent + req->pdu_len > req->data_len)) {
 		dev_err(queue->ctrl->ctrl.device,
 			"req %d r2t len %u exceeded data len %u (%zu sent)\n",
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_tcp_admin_mq_ops;
 		set->queue_depth = NVME_AQ_MQ_TAG_DEPTH;
-		set->reserved_tags = 2; /* connect + keep-alive */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_BLOCKING;
 		set->cmd_size = sizeof(struct nvme_tcp_request);
 		memset(set, 0, sizeof(*set));
 		set->ops = &nvme_tcp_mq_ops;
 		set->queue_depth = nctrl->sqsize + 1;
-		set->reserved_tags = 1; /* fabric connect */
+		set->reserved_tags = NVMF_RESERVED_TAGS;
 		set->numa_node = nctrl->numa_node;
 		set->flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 		set->cmd_size = sizeof(struct nvme_tcp_request);
 		return ret;
 	ctrl->queue_count = nr_io_queues + 1;
-	if (ctrl->queue_count < 2)
+	if (ctrl->queue_count < 2) {
-		return 0;
+		dev_err(ctrl->device,
+			"unable to set any I/O queues\n");
+		return -ENOMEM;
+	}
 	dev_info(ctrl->device,
 		"creating %d I/O queues.\n", nr_io_queues);

drivers/nvme/target/core.c+14−3

@@ -1118,9 +1118,20 @@ static void nvmet_start_ctrl(struct nvmet_ctrl *ctrl) · 1117 unmodified lines
1118	{	1118	{
1119	lockdep_assert_held(&ctrl->lock);	1119	lockdep_assert_held(&ctrl->lock);
1120		1120
1121	if (nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES \|\|	1121	/*
1122	nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES \|\|	1122	* Only I/O controllers should verify iosqes,iocqes.
1123	nvmet_cc_mps(ctrl->cc) != 0 \|\|	1123	* Strictly speaking, the spec says a discovery controller
		1124	* should verify iosqes,iocqes are zeroed, however that
		1125	* would break backwards compatibility, so don't enforce it.
		1126	*/
		1127	if (ctrl->subsys->type != NVME_NQN_DISC &&
		1128	(nvmet_cc_iosqes(ctrl->cc) != NVME_NVM_IOSQES \|\|
		1129	nvmet_cc_iocqes(ctrl->cc) != NVME_NVM_IOCQES)) {
		1130	ctrl->csts = NVME_CSTS_CFS;
		1131	return;
		1132	}
		1133
		1134	if (nvmet_cc_mps(ctrl->cc) != 0 \|\|
1124	nvmet_cc_ams(ctrl->cc) != 0 \|\|	1135	nvmet_cc_ams(ctrl->cc) != 0 \|\|
1125	nvmet_cc_css(ctrl->cc) != 0) {	1136	nvmet_cc_css(ctrl->cc) != 0) {
1126	ctrl->csts = NVME_CSTS_CFS;	1137	ctrl->csts = NVME_CSTS_CFS;

drivers/nvme/target/loop.c+2−2

drivers/nvme/target/tcp.c+1−1

 		cmd->rbytes_done += ret;
 	}
+	nvmet_tcp_unmap_pdu_iovec(cmd);
 	if (queue->data_digest) {
 		nvmet_tcp_prep_recv_ddgst(cmd);
 		return 0;
 	}
-	nvmet_tcp_unmap_pdu_iovec(cmd);
 	if (!(cmd->flags & NVMET_TCP_F_INIT_FAILED) &&
 	    cmd->rbytes_done == cmd->req.transfer_len) {

drivers/parport/parport_amiga.c+0−1

@@ -241,6 +241,5 @@ module_platform_driver_probe(amiga_parallel_driver, amiga_parallel_probe); · 240 unmodified lines
241		241
242	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");	242	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
243	MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");	243	MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");
244	MODULE_SUPPORTED_DEVICE("Amiga builtin Parallel Port");
245	MODULE_LICENSE("GPL");	244	MODULE_LICENSE("GPL");
246	MODULE_ALIAS("platform:amiga-parallel");	245	MODULE_ALIAS("platform:amiga-parallel");

drivers/parport/parport_atari.c+0−1

@@ -218,7 +218,6 @@ static void __exit parport_atari_exit(void) · 217 unmodified lines
218		218
219	MODULE_AUTHOR("Andreas Schwab");	219	MODULE_AUTHOR("Andreas Schwab");
220	MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");	220	MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
221	MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
222	MODULE_LICENSE("GPL");	221	MODULE_LICENSE("GPL");
223		222
224	module_init(parport_atari_init)	223	module_init(parport_atari_init)

drivers/parport/parport_gsc.c+0−1

@@ -41,7 +41,6 @@ · 40 unmodified lines
41		41
42	MODULE_AUTHOR("Helge Deller <deller@gmx.de>");	42	MODULE_AUTHOR("Helge Deller <deller@gmx.de>");
43	MODULE_DESCRIPTION("HP-PARISC PC-style parallel port driver");	43	MODULE_DESCRIPTION("HP-PARISC PC-style parallel port driver");
44	MODULE_SUPPORTED_DEVICE("integrated PC-style parallel port");
45	MODULE_LICENSE("GPL");	44	MODULE_LICENSE("GPL");
46		45
47		46

drivers/parport/parport_mfc3.c+0−1

@@ -359,7 +359,6 @@ static void __exit parport_mfc3_exit(void) · 358 unmodified lines
359		359
360	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");	360	MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
361	MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Parallel Port");	361	MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Parallel Port");
362	MODULE_SUPPORTED_DEVICE("Multiface 3 Parallel Port");
363	MODULE_LICENSE("GPL");	362	MODULE_LICENSE("GPL");
364		363
365	module_init(parport_mfc3_init)	364	module_init(parport_mfc3_init)

drivers/parport/parport_sunbpp.c+0−1

@@ -377,6 +377,5 @@ module_platform_driver(bpp_sbus_driver); · 376 unmodified lines
377		377
378	MODULE_AUTHOR("Derrick J Brashear");	378	MODULE_AUTHOR("Derrick J Brashear");
379	MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");	379	MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
380	MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
381	MODULE_VERSION("2.0");	380	MODULE_VERSION("2.0");
382	MODULE_LICENSE("GPL");	381	MODULE_LICENSE("GPL");

drivers/pci/hotplug/rpadlpar_sysfs.c+6−8

 	if (nbytes >= MAX_DRC_NAME_LEN)
 		return 0;
-	memcpy(drc_name, buf, nbytes);
+	strscpy(drc_name, buf, nbytes + 1);
 	end = strchr(drc_name, '\n');
-	if (!end)
+	if (end)
-		end = &drc_name[nbytes];
+		*end = '\0';
-	*end = '\0';
 	rc = dlpar_add_slot(drc_name);
 	if (rc)
 	if (nbytes >= MAX_DRC_NAME_LEN)
 		return 0;
-	memcpy(drc_name, buf, nbytes);
+	strscpy(drc_name, buf, nbytes + 1);
 	end = strchr(drc_name, '\n');
-	if (!end)
+	if (end)
-		end = &drc_name[nbytes];
+		*end = '\0';
-	*end = '\0';
 	rc = dlpar_remove_slot(drc_name);
 	if (rc)

drivers/pci/hotplug/s390_pci_hpc.c+2−1

@@ -93,8 +93,9 @@ static int disable_slot(struct hotplug_slot *hotplug_slot) · 92 unmodified lines
93	pci_dev_put(pdev);	93	pci_dev_put(pdev);
94	return -EBUSY;	94	return -EBUSY;
95	}	95	}
		96	pci_dev_put(pdev);
96		97
97	zpci_remove_device(zdev);	98	zpci_remove_device(zdev, false);
98		99
99	rc = zpci_disable_device(zdev);	100	rc = zpci_disable_device(zdev);
100	if (rc)	101	if (rc)

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/s390/block/dasd.c+0−1

@@ -63,7 +63,6 @@ void dasd_int_handler(struct ccw_device , unsigned long, struct irb ); · 62 unmodified lines
63	MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");	63	MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
64	MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"	64	MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
65	" Copyright IBM Corp. 2000");	65	" Copyright IBM Corp. 2000");
66	MODULE_SUPPORTED_DEVICE("dasd");
67	MODULE_LICENSE("GPL");	66	MODULE_LICENSE("GPL");
68		67
69	/*	68	/*

drivers/sbus/char/display7seg.c+0−1

@@ -50,7 +50,6 @@ MODULE_PARM_DESC(sol_compat, · 49 unmodified lines
50	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	50	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
51	MODULE_DESCRIPTION("7-Segment Display driver for Sun Microsystems CP1400/1500");	51	MODULE_DESCRIPTION("7-Segment Display driver for Sun Microsystems CP1400/1500");
52	MODULE_LICENSE("GPL");	52	MODULE_LICENSE("GPL");
53	MODULE_SUPPORTED_DEVICE("d7s");
54		53
55	struct d7s {	54	struct d7s {
56	void __iomem *regs;	55	void __iomem *regs;

drivers/scsi/hpsa.c+0−1

@@ -80,7 +80,6 @@ · 79 unmodified lines
80	MODULE_AUTHOR("Hewlett-Packard Company");	80	MODULE_AUTHOR("Hewlett-Packard Company");
81	MODULE_DESCRIPTION("Driver for HP Smart Array Controller version " \	81	MODULE_DESCRIPTION("Driver for HP Smart Array Controller version " \
82	HPSA_DRIVER_VERSION);	82	HPSA_DRIVER_VERSION);
83	MODULE_SUPPORTED_DEVICE("HP Smart Array Controllers");
84	MODULE_VERSION(HPSA_DRIVER_VERSION);	83	MODULE_VERSION(HPSA_DRIVER_VERSION);
85	MODULE_LICENSE("GPL");	84	MODULE_LICENSE("GPL");
86	MODULE_ALIAS("cciss");	85	MODULE_ALIAS("cciss");

drivers/scsi/ibmvscsi/ibmvfc.c+56−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;
 			  vhost->disc_buf_dma);
 	dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
 			  vhost->login_buf, vhost->login_buf_dma);
+	dma_free_coherent(vhost->dev, sizeof(*vhost->channel_setup_buf),
+			  vhost->channel_setup_buf, vhost->channel_setup_dma);
 	dma_pool_destroy(vhost->sg_pool);
 	ibmvfc_free_queue(vhost, async_q);
 	LEAVE;

drivers/scsi/lpfc/lpfc_debugfs.c+2−2

@@ -2421,7 +2421,7 @@ lpfc_debugfs_dif_err_write(struct file file, const char __user buf, · 2420 unmodified lines
2421	memset(dstbuf, 0, 33);	2421	memset(dstbuf, 0, 33);
2422	size = (nbytes < 32) ? nbytes : 32;	2422	size = (nbytes < 32) ? nbytes : 32;
2423	if (copy_from_user(dstbuf, buf, size))	2423	if (copy_from_user(dstbuf, buf, size))
2424	return 0;	2424	return -EFAULT;
2425		2425
2426	if (dent == phba->debug_InjErrLBA) {	2426	if (dent == phba->debug_InjErrLBA) {
2427	if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&	2427	if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&
@@ -2430,7 +2430,7 @@ lpfc_debugfs_dif_err_write(struct file file, const char __user buf, · 2 unmodified lines
2430	}	2430	}
2431		2431
2432	if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))	2432	if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
2433	return 0;	2433	return -EINVAL;
2434		2434
2435	if (dent == phba->debug_writeGuard)	2435	if (dent == phba->debug_writeGuard)
2436	phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;	2436	phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;

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/mpt3sas/mpt3sas_scsih.c+1−1

@@ -413,7 +413,7 @@ mpt3sas_get_port_by_id(struct MPT3SAS_ADAPTER *ioc, · 412 unmodified lines
413	* And add this object to port_table_list.	413	* And add this object to port_table_list.
414	*/	414	*/
415	if (!ioc->multipath_on_hba) {	415	if (!ioc->multipath_on_hba) {
416	port = kzalloc(sizeof(struct hba_port), GFP_KERNEL);	416	port = kzalloc(sizeof(struct hba_port), GFP_ATOMIC);
417	if (!port)	417	if (!port)
418	return NULL;	418	return NULL;
419		419

drivers/scsi/myrs.c+1−1

 	if (cs->mmio_base) {
 		cs->disable_intr(cs);
 		iounmap(cs->mmio_base);
+		cs->mmio_base = NULL;
 	}
 	if (cs->irq)
 		free_irq(cs->irq, cs);
 	if (cs->io_addr)
 		release_region(cs->io_addr, 0x80);
-	iounmap(cs->mmio_base);
 	pci_set_drvdata(pdev, NULL);
 	pci_disable_device(pdev);
 	scsi_host_put(cs->host);

drivers/scsi/pcmcia/nsp_cs.c+0−1

@@ -55,7 +55,6 @@ · 54 unmodified lines
55		55
56	MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");	56	MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");
57	MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");	57	MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");
58	MODULE_SUPPORTED_DEVICE("sd,sr,sg,st");
59	MODULE_LICENSE("GPL");	58	MODULE_LICENSE("GPL");
60		59
61	#include "nsp_io.h"	60	#include "nsp_io.h"

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/qla_target.h+1−1

 	(min(1270, ((ql) > 0) ? (QLA_TGT_DATASEGS_PER_CMD_24XX + \
 		QLA_TGT_DATASEGS_PER_CONT_24XX*((ql) - 1)) : 0))
 #endif
-#endif
 #define GET_TARGET_ID(ha, iocb) ((HAS_EXTENDED_IDS(ha))			\
 			 ? le16_to_cpu((iocb)->u.isp2x.target.extended)	\
 #ifndef CTIO_RET_TYPE
 #define CTIO_RET_TYPE	0x17		/* CTIO return entry */
 #define ATIO_TYPE7 0x06 /* Accept target I/O entry for 24xx */
+#endif
 struct fcp_hdr {
 	uint8_t  r_ctl;

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/scsi/sd_zbc.c+11−8

 static void sd_zbc_update_wp_offset_workfn(struct work_struct *work)
 {
 	struct scsi_disk *sdkp;
+	unsigned long flags;
 	unsigned int zno;
 	int ret;
 	sdkp = container_of(work, struct scsi_disk, zone_wp_offset_work);
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	for (zno = 0; zno < sdkp->nr_zones; zno++) {
 		if (sdkp->zones_wp_offset[zno] != SD_ZBC_UPDATING_WP_OFST)
 			continue;
-		spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+		spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 		ret = sd_zbc_do_report_zones(sdkp, sdkp->zone_wp_update_buf,
 					     SD_BUF_SIZE,
 					     zno * sdkp->zone_blocks, true);
-		spin_lock_bh(&sdkp->zones_wp_offset_lock);
+		spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 		if (!ret)
 			sd_zbc_parse_report(sdkp, sdkp->zone_wp_update_buf + 64,
 					    zno, sd_zbc_update_wp_offset_cb,
 					    sdkp);
 	}
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	scsi_device_put(sdkp->device);
 }
 	struct request *rq = cmd->request;
 	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 	unsigned int wp_offset, zno = blk_rq_zone_no(rq);
+	unsigned long flags;
 	blk_status_t ret;
 	ret = sd_zbc_cmnd_checks(cmd);
 	if (!blk_req_zone_write_trylock(rq))
 		return BLK_STS_ZONE_RESOURCE;
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	wp_offset = sdkp->zones_wp_offset[zno];
 	switch (wp_offset) {
 	case SD_ZBC_INVALID_WP_OFST:
 		*lba += wp_offset;
 	}
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	if (ret)
 		blk_req_zone_write_unlock(rq);
 	return ret;
 	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 	unsigned int zno = blk_rq_zone_no(rq);
 	enum req_opf op = req_op(rq);
+	unsigned long flags;
 	/*
 	 * If we got an error for a command that needs updating the write
 	 * invalid to force an update from disk the next time a zone append
 	 * command is issued.
 	 */
-	spin_lock_bh(&sdkp->zones_wp_offset_lock);
+	spin_lock_irqsave(&sdkp->zones_wp_offset_lock, flags);
 	if (result && op != REQ_OP_ZONE_RESET_ALL) {
 		if (op == REQ_OP_ZONE_APPEND) {
 	}
 unlock_wp_offset:
-	spin_unlock_bh(&sdkp->zones_wp_offset_lock);
+	spin_unlock_irqrestore(&sdkp->zones_wp_offset_lock, flags);
 	return good_bytes;
 }

drivers/scsi/smartpqi/smartpqi_init.c+0−1

@@ -48,7 +48,6 @@ · 47 unmodified lines
48	MODULE_AUTHOR("Microsemi");	48	MODULE_AUTHOR("Microsemi");
49	MODULE_DESCRIPTION("Driver for Microsemi Smart Family Controller version "	49	MODULE_DESCRIPTION("Driver for Microsemi Smart Family Controller version "
50	DRIVER_VERSION);	50	DRIVER_VERSION);
51	MODULE_SUPPORTED_DEVICE("Microsemi Smart Family Controllers");
52	MODULE_VERSION(DRIVER_VERSION);	51	MODULE_VERSION(DRIVER_VERSION);
53	MODULE_LICENSE("GPL");	52	MODULE_LICENSE("GPL");
54		53

drivers/scsi/st.c+1−1

 	spin_lock(&st_use_lock);
 	if (STp->in_use) {
 		spin_unlock(&st_use_lock);
-		scsi_tape_put(STp);
 		DEBC_printk(STp, "Device already in use.\n");
+		scsi_tape_put(STp);
 		return (-EBUSY);
 	}

drivers/scsi/ufs/ufs-mediatek.c+1−1

@@ -911,7 +911,7 @@ static void ufs_mtk_vreg_set_lpm(struct ufs_hba *hba, bool lpm) · 910 unmodified lines
911	if (!hba->vreg_info.vccq2 \|\| !hba->vreg_info.vcc)	911	if (!hba->vreg_info.vccq2 \|\| !hba->vreg_info.vcc)
912	return;	912	return;
913		913
914	if (lpm & !hba->vreg_info.vcc->enabled)	914	if (lpm && !hba->vreg_info.vcc->enabled)
915	regulator_set_mode(hba->vreg_info.vccq2->reg,	915	regulator_set_mode(hba->vreg_info.vccq2->reg,
916	REGULATOR_MODE_IDLE);	916	REGULATOR_MODE_IDLE);
917	else if (!lpm)	917	else if (!lpm)

drivers/sh/maple/maple.c+0−1

@@ -30,7 +30,6 @@ · 29 unmodified lines
30	MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");	30	MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");
31	MODULE_DESCRIPTION("Maple bus driver for Dreamcast");	31	MODULE_DESCRIPTION("Maple bus driver for Dreamcast");
32	MODULE_LICENSE("GPL v2");	32	MODULE_LICENSE("GPL v2");
33	MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
34		33
35	static void maple_dma_handler(struct work_struct *work);	34	static void maple_dma_handler(struct work_struct *work);
36	static void maple_vblank_handler(struct work_struct *work);	35	static void maple_vblank_handler(struct work_struct *work);

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/spi/spi-cadence-quadspi.c+1−0

@@ -1433,6 +1433,7 @@ static int cqspi_probe(struct platform_device *pdev) · 1432 unmodified lines
1433	cqspi = spi_master_get_devdata(master);	1433	cqspi = spi_master_get_devdata(master);
1434		1434
1435	cqspi->pdev = pdev;	1435	cqspi->pdev = pdev;
		1436	platform_set_drvdata(pdev, cqspi);
1436		1437
1437	/* Obtain configuration from OF. */	1438	/* Obtain configuration from OF. */
1438	ret = cqspi_of_get_pdata(cqspi);	1439	ret = cqspi_of_get_pdata(cqspi);

drivers/staging/comedi/drivers/cb_pcidas.c+1−1

@@ -1281,7 +1281,7 @@ static int cb_pcidas_auto_attach(struct comedi_device *dev, · 1280 unmodified lines
1281	devpriv->amcc + AMCC_OP_REG_INTCSR);	1281	devpriv->amcc + AMCC_OP_REG_INTCSR);
1282		1282
1283	ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,	1283	ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,
1284	dev->board_name, dev);	1284	"cb_pcidas", dev);
1285	if (ret) {	1285	if (ret) {
1286	dev_dbg(dev->class_dev, "unable to allocate irq %d\n",	1286	dev_dbg(dev->class_dev, "unable to allocate irq %d\n",
1287	pcidev->irq);	1287	pcidev->irq);

drivers/staging/comedi/drivers/cb_pcidas64.c+1−1

@@ -4035,7 +4035,7 @@ static int auto_attach(struct comedi_device *dev, · 4034 unmodified lines
4035	init_stc_registers(dev);	4035	init_stc_registers(dev);
4036		4036
4037	retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,	4037	retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,
4038	dev->board_name, dev);	4038	"cb_pcidas64", dev);
4039	if (retval) {	4039	if (retval) {
4040	dev_dbg(dev->class_dev, "unable to allocate irq %u\n",	4040	dev_dbg(dev->class_dev, "unable to allocate irq %u\n",
4041	pcidev->irq);	4041	pcidev->irq);

drivers/staging/comedi/drivers/vmk80xx.c+0−1

@@ -877,5 +877,4 @@ module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver); · 876 unmodified lines
877		877
878	MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");	878	MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
879	MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");	879	MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
880	MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
881	MODULE_LICENSE("GPL");	880	MODULE_LICENSE("GPL");

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/staging/vt6655/rxtx.h+2−2

@@ -150,7 +150,7 @@ struct vnt_cts { · 149 unmodified lines
150	u16 reserved;	150	u16 reserved;
151	struct ieee80211_cts data;	151	struct ieee80211_cts data;
152	u16 reserved2;	152	u16 reserved2;
153	} __packed;	153	} __packed __aligned(2);
154		154
155	struct vnt_cts_fb {	155	struct vnt_cts_fb {
156	struct vnt_phy_field b;	156	struct vnt_phy_field b;
@@ -160,7 +160,7 @@ struct vnt_cts_fb { · 3 unmodified lines
160	__le16 cts_duration_ba_f1;	160	__le16 cts_duration_ba_f1;
161	struct ieee80211_cts data;	161	struct ieee80211_cts data;
162	u16 reserved2;	162	u16 reserved2;
163	} __packed;	163	} __packed __aligned(2);
164		164
165	struct vnt_tx_fifo_head {	165	struct vnt_tx_fifo_head {
166	u8 tx_key[WLAN_KEY_LEN_CCMP];	166	u8 tx_key[WLAN_KEY_LEN_CCMP];

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/tee/optee/core.c+0−1

@@ -747,7 +747,6 @@ module_platform_driver(optee_driver); · 746 unmodified lines
747		747
748	MODULE_AUTHOR("Linaro");	748	MODULE_AUTHOR("Linaro");
749	MODULE_DESCRIPTION("OP-TEE driver");	749	MODULE_DESCRIPTION("OP-TEE driver");
750	MODULE_SUPPORTED_DEVICE("");
751	MODULE_VERSION("1.0");	750	MODULE_VERSION("1.0");
752	MODULE_LICENSE("GPL v2");	751	MODULE_LICENSE("GPL v2");
753	MODULE_ALIAS("platform:optee");	752	MODULE_ALIAS("platform:optee");

drivers/thermal/thermal_sysfs.c+3−0

@@ -674,6 +674,9 @@ void thermal_cooling_device_stats_update(struct thermal_cooling_device *cdev, · 673 unmodified lines
674	{	674	{
675	struct cooling_dev_stats *stats = cdev->stats;	675	struct cooling_dev_stats *stats = cdev->stats;
676		676
		677	if (!stats)
		678	return;
		679
677	spin_lock(&stats->lock);	680	spin_lock(&stats->lock);
678		681
679	if (stats->state == new_state)	682	if (stats->state == new_state)

drivers/thunderbolt/switch.c+8−10

 	tb_dump_port(port->sw->tb, &port->config);
-	/* Control port does not need HopID allocation */
-	if (port->port) {
-		ida_init(&port->in_hopids);
-		ida_init(&port->out_hopids);
-	}
 	INIT_LIST_HEAD(&port->list);
 	return 0;
 	dma_port_free(sw->dma_port);
 	tb_switch_for_each_port(sw, port) {
-		if (!port->disabled) {
+		ida_destroy(&port->in_hopids);
-			ida_destroy(&port->in_hopids);
+		ida_destroy(&port->out_hopids);
-			ida_destroy(&port->out_hopids);
-		}
 	}
 	kfree(sw->uuid);
 		/* minimum setup for tb_find_cap and tb_drom_read to work */
 		sw->ports[i].sw = sw;
 		sw->ports[i].port = i;
+		/* Control port does not need HopID allocation */
+		if (i) {
+			ida_init(&sw->ports[i].in_hopids);
+			ida_init(&sw->ports[i].out_hopids);
+		}
 	}
 	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS);

drivers/thunderbolt/tb.c+4−0

 				parent->boot = true;
 				parent = tb_switch_parent(parent);
 			}
+		} else if (tb_tunnel_is_dp(tunnel)) {
+			/* Keep the domain from powering down */
+			pm_runtime_get_sync(&tunnel->src_port->sw->dev);
+			pm_runtime_get_sync(&tunnel->dst_port->sw->dev);
 		}
 		list_add_tail(&tunnel->list, &tcm->tunnel_list);

drivers/tty/serial/icom.c+0−2

@@ -1639,8 +1639,6 @@ module_exit(icom_exit); · 1638 unmodified lines
1639		1639
1640	MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");	1640	MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1641	MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");	1641	MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1642	MODULE_SUPPORTED_DEVICE
1643	("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1644	MODULE_LICENSE("GPL");	1642	MODULE_LICENSE("GPL");
1645	MODULE_FIRMWARE("icom_call_setup.bin");	1643	MODULE_FIRMWARE("icom_call_setup.bin");
1646	MODULE_FIRMWARE("icom_res_dce.bin");	1644	MODULE_FIRMWARE("icom_res_dce.bin");

drivers/tty/serial/jsm/jsm_driver.c+0−1

@@ -19,7 +19,6 @@ · 18 unmodified lines
19	MODULE_AUTHOR("Digi International, https://www.digi.com");	19	MODULE_AUTHOR("Digi International, https://www.digi.com");
20	MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");	20	MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
21	MODULE_LICENSE("GPL");	21	MODULE_LICENSE("GPL");
22	MODULE_SUPPORTED_DEVICE("jsm");
23		22
24	#define JSM_DRIVER_NAME "jsm"	23	#define JSM_DRIVER_NAME "jsm"
25	#define NR_PORTS 32	24	#define NR_PORTS 32

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/cdns3/cdnsp-ring.c+4−1

 	 * inverted in the first TDs isoc TRB.
 	 */
 	field = TRB_TYPE(TRB_ISOC) | TRB_TLBPC(last_burst_pkt) |
-		start_cycle ? 0 : 1 | TRB_SIA | TRB_TBC(burst_count);
+		TRB_SIA | TRB_TBC(burst_count);
+	if (!start_cycle)
+		field |= TRB_CYCLE;
 	/* Fill the rest of the TRB fields, and remaining normal TRBs. */
 	for (i = 0; i < trbs_per_td; i++) {

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+11−11

 	trace_dwc3_gadget_ep_disable(dep);
-	dwc3_remove_requests(dwc, dep);
 	/* make sure HW endpoint isn't stalled */
 	if (dep->flags & DWC3_EP_STALL)
 		__dwc3_gadget_ep_set_halt(dep, 0, false);
 	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;
 		dep->endpoint.desc = NULL;
 	}
+	dwc3_remove_requests(dwc, dep);
+	dep->stream_capable = false;
+	dep->type = 0;
+	dep->flags = 0;
 	return 0;
 }
 {
 	struct dwc3		*dwc = dep->dwc;
-	if (!dep->endpoint.desc || !dwc->pullups_connected) {
+	if (!dep->endpoint.desc || !dwc->pullups_connected || !dwc->connected) {
 		dev_err(dwc->dev, "%s: can't queue to disabled endpoint\n",
 				dep->name);
 		return -ESHUTDOWN;
 	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 &&
 	if (!is_on) {
 		u32 count;
+		dwc->connected = false;
 		/*
 		 * In the Synopsis DesignWare Cores USB3 Databook Rev. 3.30a
 		 * Section 4.1.8 Table 4-7, it states that for a device-initiated
 			dwc->ev_buf->lpos = (dwc->ev_buf->lpos + count) %
 						dwc->ev_buf->length;
 		}
-		dwc->connected = false;
 	} else {
 		__dwc3_gadget_start(dwc);
 	}
 	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);
 }
 {
 	u32			reg;
-	dwc->connected = true;
 	/*
 	 * WORKAROUND: DWC3 revisions <1.88a have an issue which
 	 * would cause a missing Disconnect Event if there's a
 	 * transfers."
 	 */
 	dwc3_stop_active_transfers(dwc);
+	dwc->connected = true;
 	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
 	reg &= ~DWC3_DCTL_TSTCTRL_MASK;

drivers/usb/gadget/configfs.c+10−4

 	struct list_head list;
 };
+#define USB_MAX_STRING_WITH_NULL_LEN	(USB_MAX_STRING_LEN+1)
 static int usb_string_copy(const char *s, char **s_copy)
 {
 	int ret;
 	if (ret > USB_MAX_STRING_LEN)
 		return -EOVERFLOW;
-	str = kstrdup(s, GFP_KERNEL);
+	if (copy) {
-	if (!str)
+		str = copy;
-		return -ENOMEM;
+	} else {
+		str = kmalloc(USB_MAX_STRING_WITH_NULL_LEN, GFP_KERNEL);
+		if (!str)
+			return -ENOMEM;
+	}
+	strcpy(str, s);
 	if (str[ret - 1] == '\n')
 		str[ret - 1] = '\0';
-	kfree(copy);
 	*s_copy = str;
 	return 0;
 }

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/host/xhci-mtk.c+9−1

 	xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
 	if (mtk->lpm_support)
 		xhci->quirks |= XHCI_LPM_SUPPORT;
+	/*
+	 * MTK xHCI 0.96: PSA is 1 by default even if doesn't support stream,
+	 * and it's 3 when support it.
+	 */
+	if (xhci->hci_version < 0x100 && HCC_MAX_PSA(xhci->hcc_params) == 4)
+		xhci->quirks |= XHCI_BROKEN_STREAMS;
 }
 /* called during probe() after chip reset completes */
 	if (ret)
 		goto put_usb3_hcd;
-	if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
+	if (HCC_MAX_PSA(xhci->hcc_params) >= 4 &&
+	    !(xhci->quirks & XHCI_BROKEN_STREAMS))
 		xhci->shared_hcd->can_do_streams = 1;
 	ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);

drivers/usb/misc/ldusb.c+0−1

@@ -117,7 +117,6 @@ MODULE_DEVICE_TABLE(usb, ld_usb_table); · 116 unmodified lines
117	MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");	117	MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");
118	MODULE_DESCRIPTION("LD USB Driver");	118	MODULE_DESCRIPTION("LD USB Driver");
119	MODULE_LICENSE("GPL");	119	MODULE_LICENSE("GPL");
120	MODULE_SUPPORTED_DEVICE("LD USB Devices");
121		120
122	/* All interrupt in transfers are collected in a ring buffer to	121	/* All interrupt in transfers are collected in a ring buffer to
123	* avoid racing conditions and get better performance of the driver.	122	* avoid racing conditions and get better performance of the driver.

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/storage/transport.c+7−0

@@ -656,6 +656,13 @@ void usb_stor_invoke_transport(struct scsi_cmnd srb, struct us_data us) · 655 unmodified lines
656	need_auto_sense = 1;	656	need_auto_sense = 1;
657	}	657	}
658		658
		659	/* Some devices (Kindle) require another command after SYNC CACHE */
		660	if ((us->fflags & US_FL_SENSE_AFTER_SYNC) &&
		661	srb->cmnd[0] == SYNCHRONIZE_CACHE) {
		662	usb_stor_dbg(us, "-- sense after SYNC CACHE\n");
		663	need_auto_sense = 1;
		664	}
		665
659	/*	666	/*
660	* If we have a failure, we're going to do a REQUEST_SENSE	667	* If we have a failure, we're going to do a REQUEST_SENSE
661	* automatically. Note that we differentiate between a command	668	* automatically. Note that we differentiate between a command

drivers/usb/storage/unusual_devs.h+12−0

@@ -2211,6 +2211,18 @@ UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200, · 2210 unmodified lines
2211	USB_SC_DEVICE, USB_PR_DEVICE, NULL,	2211	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
2212	US_FL_NO_READ_DISC_INFO ),	2212	US_FL_NO_READ_DISC_INFO ),
2213		2213
		2214	/*
		2215	* Reported by Matthias Schwarzott <zzam@gentoo.org>
		2216	* The Amazon Kindle treats SYNCHRONIZE CACHE as an indication that
		2217	* the host may be finished with it, and automatically ejects its
		2218	* emulated media unless it receives another command within one second.
		2219	*/
		2220	UNUSUAL_DEV( 0x1949, 0x0004, 0x0000, 0x9999,
		2221	"Amazon",
		2222	"Kindle",
		2223	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
		2224	US_FL_SENSE_AFTER_SYNC ),
		2225
2214	/*	2226	/*
2215	* Reported by Oliver Neukum <oneukum@suse.com>	2227	* Reported by Oliver Neukum <oneukum@suse.com>
2216	* This device morphes spontaneously into another device if the access	2228	* This device morphes spontaneously into another device if the access

drivers/usb/typec/tcpm/tcpm.c+9−2

@@ -942,6 +942,7 @@ static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv) · 941 unmodified lines
942		942
943	port->supply_voltage = mv;	943	port->supply_voltage = mv;
944	port->current_limit = max_ma;	944	port->current_limit = max_ma;
		945	power_supply_changed(port->psy);
945		946
946	if (port->tcpc->set_current_limit)	947	if (port->tcpc->set_current_limit)
947	ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);	948	ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);
@@ -2928,6 +2929,7 @@ static int tcpm_pd_select_pdo(struct tcpm_port port, int sink_pdo, · 1980 unmodified lines
2928		2929
2929	port->pps_data.supported = false;	2930	port->pps_data.supported = false;
2930	port->usb_type = POWER_SUPPLY_USB_TYPE_PD;	2931	port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
		2932	power_supply_changed(port->psy);
2931		2933
2932	/*	2934	/*
2933	* Select the source PDO providing the most power which has a	2935	* Select the source PDO providing the most power which has a
@@ -2952,6 +2954,7 @@ static int tcpm_pd_select_pdo(struct tcpm_port port, int sink_pdo, · 18 unmodified lines
2952	port->pps_data.supported = true;	2954	port->pps_data.supported = true;
2953	port->usb_type =	2955	port->usb_type =
2954	POWER_SUPPLY_USB_TYPE_PD_PPS;	2956	POWER_SUPPLY_USB_TYPE_PD_PPS;
		2957	power_supply_changed(port->psy);
2955	}	2958	}
2956	continue;	2959	continue;
2957	default:	2960	default:
@@ -3109,6 +3112,7 @@ static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port) · 151 unmodified lines
3109	port->pps_data.out_volt));	3112	port->pps_data.out_volt));
3110	port->pps_data.op_curr = min(port->pps_data.max_curr,	3113	port->pps_data.op_curr = min(port->pps_data.max_curr,
3111	port->pps_data.op_curr);	3114	port->pps_data.op_curr);
		3115	power_supply_changed(port->psy);
3112	}	3116	}
3113		3117
3114	return src_pdo;	3118	return src_pdo;
@@ -3344,6 +3348,7 @@ static int tcpm_set_charge(struct tcpm_port *port, bool charge) · 229 unmodified lines
3344	return ret;	3348	return ret;
3345	}	3349	}
3346	port->vbus_charge = charge;	3350	port->vbus_charge = charge;
		3351	power_supply_changed(port->psy);
3347	return 0;	3352	return 0;
3348	}	3353	}
3349		3354
@@ -3523,6 +3528,7 @@ static void tcpm_reset_port(struct tcpm_port *port) · 173 unmodified lines
3523	port->try_src_count = 0;	3528	port->try_src_count = 0;
3524	port->try_snk_count = 0;	3529	port->try_snk_count = 0;
3525	port->usb_type = POWER_SUPPLY_USB_TYPE_C;	3530	port->usb_type = POWER_SUPPLY_USB_TYPE_C;
		3531	power_supply_changed(port->psy);
3526	port->nr_sink_caps = 0;	3532	port->nr_sink_caps = 0;
3527	port->sink_cap_done = false;	3533	port->sink_cap_done = false;
3528	if (port->tcpc->enable_frs)	3534	if (port->tcpc->enable_frs)
@@ -5167,7 +5173,7 @@ static void tcpm_enable_frs_work(struct kthread_work *work) · 1638 unmodified lines
5167	goto unlock;	5173	goto unlock;
5168		5174
5169	/* Send when the state machine is idle */	5175	/* Send when the state machine is idle */
5170	if (port->state != SNK_READY \|\| port->vdm_state != VDM_STATE_DONE \|\| port->send_discover)	5176	if (port->state != SNK_READY \|\| port->vdm_sm_running \|\| port->send_discover)
5171	goto resched;	5177	goto resched;
5172		5178
5173	port->upcoming_state = GET_SINK_CAP;	5179	port->upcoming_state = GET_SINK_CAP;
@@ -5905,7 +5911,7 @@ static int tcpm_psy_set_prop(struct power_supply *psy, · 731 unmodified lines
5905	ret = -EINVAL;	5911	ret = -EINVAL;
5906	break;	5912	break;
5907	}	5913	}
5908		5914	power_supply_changed(port->psy);
5909	return ret;	5915	return ret;
5910	}	5916	}
5911		5917
@@ -6058,6 +6064,7 @@ struct tcpm_port tcpm_register_port(struct device dev, struct tcpc_dev *tcpc) · 146 unmodified lines
6058	err = devm_tcpm_psy_register(port);	6064	err = devm_tcpm_psy_register(port);
6059	if (err)	6065	if (err)
6060	goto out_role_sw_put;	6066	goto out_role_sw_put;
		6067	power_supply_changed(port->psy);
6061		6068
6062	port->typec_port = typec_register_port(port->dev, &port->typec_caps);	6069	port->typec_port = typec_register_port(port->dev, &port->typec_caps);
6063	if (IS_ERR(port->typec_port)) {	6070	if (IS_ERR(port->typec_port)) {

drivers/usb/typec/tps6598x.c+0−1

@@ -64,7 +64,6 @@ enum { · 63 unmodified lines
64	struct tps6598x_rx_identity_reg {	64	struct tps6598x_rx_identity_reg {
65	u8 status;	65	u8 status;
66	struct usb_pd_identity identity;	66	struct usb_pd_identity identity;
67	u32 vdo[3];
68	} __packed;	67	} __packed;
69		68
70	/* Standard Task return codes */	69	/* Standard Task return codes */

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/usb/usbip/vudc_sysfs.c+1−1

@@ -174,7 +174,7 @@ static ssize_t usbip_sockfd_store(struct device *dev, · 173 unmodified lines
174		174
175	udc->ud.tcp_socket = socket;	175	udc->ud.tcp_socket = socket;
176	udc->ud.tcp_rx = tcp_rx;	176	udc->ud.tcp_rx = tcp_rx;
177	udc->ud.tcp_rx = tcp_tx;	177	udc->ud.tcp_tx = tcp_tx;
178	udc->ud.status = SDEV_ST_USED;	178	udc->ud.status = SDEV_ST_USED;
179		179
180	spin_unlock_irq(&udc->ud.lock);	180	spin_unlock_irq(&udc->ud.lock);

drivers/vdpa/ifcvf/ifcvf_main.c+2−3

 	}
 	adapter = vdpa_alloc_device(struct ifcvf_adapter, vdpa,
-				    dev, &ifc_vdpa_ops,
+				    dev, &ifc_vdpa_ops, NULL);
-				    IFCVF_MAX_QUEUE_PAIRS * 2, NULL);
 	if (adapter == NULL) {
 		IFCVF_ERR(pdev, "Failed to allocate vDPA structure");
 		return -ENOMEM;
 	for (i = 0; i < IFCVF_MAX_QUEUE_PAIRS * 2; i++)
 		vf->vring[i].irq = -EINVAL;
-	ret = vdpa_register_device(&adapter->vdpa);
+	ret = vdpa_register_device(&adapter->vdpa, IFCVF_MAX_QUEUE_PAIRS * 2);
 	if (ret) {
 		IFCVF_ERR(pdev, "Failed to register ifcvf to vdpa bus");
 		goto err;

drivers/vdpa/mlx5/net/mlx5_vnet.c+2−2

@@ -1982,7 +1982,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, · 1981 unmodified lines
1982	max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS);	1982	max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS);
1983		1983
1984	ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops,	1984	ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops,
1985	2 * mlx5_vdpa_max_qps(max_vqs), NULL);	1985	NULL);
1986	if (IS_ERR(ndev))	1986	if (IS_ERR(ndev))
1987	return PTR_ERR(ndev);	1987	return PTR_ERR(ndev);
1988		1988
@@ -2009,7 +2009,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, · 20 unmodified lines
2009	if (err)	2009	if (err)
2010	goto err_res;	2010	goto err_res;
2011		2011
2012	err = vdpa_register_device(&mvdev->vdev);	2012	err = vdpa_register_device(&mvdev->vdev, 2 * mlx5_vdpa_max_qps(max_vqs));
2013	if (err)	2013	if (err)
2014	goto err_reg;	2014	goto err_reg;
2015		2015

drivers/vdpa/vdpa.c+10−8

  * initialized but before registered.
  * @parent: the parent device
  * @config: the bus operations that is supported by this device
- * @nvqs: number of virtqueues supported by this device
  * @size: size of the parent structure that contains private data
  * @name: name of the vdpa device; optional.
  *
  */
 struct vdpa_device *__vdpa_alloc_device(struct device *parent,
 					const struct vdpa_config_ops *config,
-					int nvqs, size_t size, const char *name)
+					size_t size, const char *name)
 {
 	struct vdpa_device *vdev;
 	int err = -EINVAL;
 	vdev->index = err;
 	vdev->config = config;
 	vdev->features_valid = false;
-	vdev->nvqs = nvqs;
 	if (name)
 		err = dev_set_name(&vdev->dev, "%s", name);
 	return (strcmp(dev_name(&vdev->dev), data) == 0);
 }
-static int __vdpa_register_device(struct vdpa_device *vdev)
+static int __vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	struct device *dev;
+	vdev->nvqs = nvqs;
 	lockdep_assert_held(&vdpa_dev_mutex);
 	dev = bus_find_device(&vdpa_bus, NULL, dev_name(&vdev->dev), vdpa_name_match);
 	if (dev) {
  * Caller must invoke this routine in the management device dev_add()
  * callback after setting up valid mgmtdev for this vdpa device.
  * @vdev: the vdpa device to be registered to vDPA bus
+ * @nvqs: number of virtqueues supported by this device
  *
  * Returns an error when fail to add device to vDPA bus
  */
-int _vdpa_register_device(struct vdpa_device *vdev)
+int _vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	if (!vdev->mdev)
 		return -EINVAL;
-	return __vdpa_register_device(vdev);
+	return __vdpa_register_device(vdev, nvqs);
 }
 EXPORT_SYMBOL_GPL(_vdpa_register_device);
  * vdpa_register_device - register a vDPA device
  * Callers must have a succeed call of vdpa_alloc_device() before.
  * @vdev: the vdpa device to be registered to vDPA bus
+ * @nvqs: number of virtqueues supported by this device
  *
  * Returns an error when fail to add to vDPA bus
  */
-int vdpa_register_device(struct vdpa_device *vdev)
+int vdpa_register_device(struct vdpa_device *vdev, int nvqs)
 {
 	int err;
 	mutex_lock(&vdpa_dev_mutex);
-	err = __vdpa_register_device(vdev);
+	err = __vdpa_register_device(vdev, nvqs);
 	mutex_unlock(&vdpa_dev_mutex);
 	return err;
 }

drivers/vdpa/vdpa_sim/vdpa_sim.c+1−1

@@ -235,7 +235,7 @@ struct vdpasim vdpasim_create(struct vdpasim_dev_attr dev_attr) · 234 unmodified lines
235	ops = &vdpasim_config_ops;	235	ops = &vdpasim_config_ops;
236		236
237	vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops,	237	vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops,
238	dev_attr->nvqs, dev_attr->name);	238	dev_attr->name);
239	if (!vdpasim)	239	if (!vdpasim)
240	goto err_alloc;	240	goto err_alloc;
241		241

drivers/vdpa/vdpa_sim/vdpa_sim_net.c+2−3

 static void vdpasim_net_get_config(struct vdpasim *vdpasim, void *config)
 {
-	struct virtio_net_config *net_config =
+	struct virtio_net_config *net_config = config;
-		(struct virtio_net_config *)config;
 	net_config->mtu = cpu_to_vdpasim16(vdpasim, 1500);
 	net_config->status = cpu_to_vdpasim16(vdpasim, VIRTIO_NET_S_LINK_UP);
 	if (IS_ERR(simdev))
 		return PTR_ERR(simdev);
-	ret = _vdpa_register_device(&simdev->vdpa);
+	ret = _vdpa_register_device(&simdev->vdpa, VDPASIM_NET_VQ_NUM);
 	if (ret)
 		goto reg_err;

drivers/vfio/Kconfig+2−2

@@ -21,8 +21,8 @@ config VFIO_VIRQFD · 20 unmodified lines
21		21
22	menuconfig VFIO	22	menuconfig VFIO
23	tristate "VFIO Non-Privileged userspace driver framework"	23	tristate "VFIO Non-Privileged userspace driver framework"
24	depends on IOMMU_API	24	select IOMMU_API
25	select VFIO_IOMMU_TYPE1 if (X86 \|\| S390 \|\| ARM \|\| ARM64)	25	select VFIO_IOMMU_TYPE1 if MMU && (X86 \|\| S390 \|\| ARM \|\| ARM64)
26	help	26	help
27	VFIO provides a framework for secure userspace device drivers.	27	VFIO provides a framework for secure userspace device drivers.
28	See Documentation/driver-api/vfio.rst for more details.	28	See Documentation/driver-api/vfio.rst for more details.

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/platform/Kconfig+2−2

@@ -1,7 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	config VFIO_PLATFORM	2	config VFIO_PLATFORM
3	tristate "VFIO support for platform devices"	3	tristate "VFIO support for platform devices"
4	depends on VFIO && EVENTFD && (ARM \|\| ARM64)	4	depends on VFIO && EVENTFD && (ARM \|\| ARM64 \|\| COMPILE_TEST)
5	select VFIO_VIRQFD	5	select VFIO_VIRQFD
6	help	6	help
7	Support for platform devices with VFIO. This is required to make	7	Support for platform devices with VFIO. This is required to make
@@ -12,7 +12,7 @@ config VFIO_PLATFORM · 4 unmodified lines
12		12
13	config VFIO_AMBA	13	config VFIO_AMBA
14	tristate "VFIO support for AMBA devices"	14	tristate "VFIO support for AMBA devices"
15	depends on VFIO_PLATFORM && ARM_AMBA	15	depends on VFIO_PLATFORM && (ARM_AMBA \|\| COMPILE_TEST)
16	help	16	help
17	Support for ARM AMBA devices with VFIO. This is required to make	17	Support for ARM AMBA devices with VFIO. This is required to make
18	use of ARM AMBA devices present on the system using the VFIO	18	use of ARM AMBA devices present on the system using the VFIO

drivers/vfio/vfio_iommu_type1.c+18−8

 }
 static struct rb_node *vfio_find_dma_first_node(struct vfio_iommu *iommu,
-						dma_addr_t start, size_t size)
+						dma_addr_t start, u64 size)
 {
 	struct rb_node *res = NULL;
 	struct rb_node *node = iommu->dma_list.rb_node;
 	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--)
 		return -ENODEV;
 	ret = vaddr_get_pfns(mm, vaddr, 1, dma->prot, pfn_base, pages);
-	if (ret == 1 && do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
+	if (ret != 1)
+		goto out;
+	ret = 0;
+	if (do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
 		ret = vfio_lock_acct(dma, 1, true);
 		if (ret) {
 			put_pfn(*pfn_base, dma->prot);
 		}
 	}
+out:
 	mmput(mm);
 	return ret;
 }
 	int ret = -EINVAL, retries = 0;
 	unsigned long pgshift;
 	dma_addr_t iova = unmap->iova;
-	unsigned long size = unmap->size;
+	u64 size = unmap->size;
 	bool unmap_all = unmap->flags & VFIO_DMA_UNMAP_FLAG_ALL;
 	bool invalidate_vaddr = unmap->flags & VFIO_DMA_UNMAP_FLAG_VADDR;
 	struct rb_node *n, *first_n;
 	if (unmap_all) {
 		if (iova || size)
 			goto unlock;
-		size = SIZE_MAX;
+		size = U64_MAX;
-	} else if (!size || size & (pgsize - 1)) {
+	} else if (!size || size & (pgsize - 1) ||
+		   iova + size - 1 < iova || size > SIZE_MAX) {
 		goto unlock;
 	}
-	if (iova + size - 1 < iova || size > SIZE_MAX)
-		goto unlock;
 	/* When dirty tracking is enabled, allow only min supported pgsize */
 	if ((unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) &&
 	    (!iommu->dirty_page_tracking || (bitmap->pgsize != pgsize))) {

drivers/vhost/vdpa.c+11−9

 static void vhost_vdpa_config_put(struct vhost_vdpa *v)
 {
-	if (v->config_ctx)
+	if (v->config_ctx) {
 		eventfd_ctx_put(v->config_ctx);
+		v->config_ctx = NULL;
+	}
 }
 static long vhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp)
 	if (!IS_ERR_OR_NULL(ctx))
 		eventfd_ctx_put(ctx);
-	if (IS_ERR(v->config_ctx))
+	if (IS_ERR(v->config_ctx)) {
-		return PTR_ERR(v->config_ctx);
+		long ret = PTR_ERR(v->config_ctx);
+		v->config_ctx = NULL;
+		return ret;
+	}
 	v->vdpa->config->set_config_cb(v->vdpa, &cb);
 static void vhost_vdpa_clean_irq(struct vhost_vdpa *v)
 {
-	struct vhost_virtqueue *vq;
 	int i;
-	for (i = 0; i < v->nvqs; i++) {
+	for (i = 0; i < v->nvqs; i++)
-		vq = &v->vqs[i];
+		vhost_vdpa_unsetup_vq_irq(v, i);
-		if (vq->call_ctx.producer.irq)
-			irq_bypass_unregister_producer(&vq->call_ctx.producer);
-	}
 }
 static int vhost_vdpa_release(struct inode *inode, struct file *filep)

drivers/vhost/vhost.c+1−1

 	vq->error_ctx = NULL;
 	vq->kick = NULL;
 	vq->log_ctx = NULL;
-	vhost_reset_is_le(vq);
 	vhost_disable_cross_endian(vq);
+	vhost_reset_is_le(vq);
 	vq->busyloop_timeout = 0;
 	vq->umem = NULL;
 	vq->iotlb = NULL;

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/virtio/virtio.c+2−4

 }
 EXPORT_SYMBOL_GPL(virtio_config_changed);
-void virtio_config_disable(struct virtio_device *dev)
+static void virtio_config_disable(struct virtio_device *dev)
 {
 	spin_lock_irq(&dev->config_lock);
 	dev->config_enabled = false;
 	spin_unlock_irq(&dev->config_lock);
 }
-EXPORT_SYMBOL_GPL(virtio_config_disable);
-void virtio_config_enable(struct virtio_device *dev)
+static void virtio_config_enable(struct virtio_device *dev)
 {
 	spin_lock_irq(&dev->config_lock);
 	dev->config_enabled = true;
 	dev->config_change_pending = false;
 	spin_unlock_irq(&dev->config_lock);
 }
-EXPORT_SYMBOL_GPL(virtio_config_enable);
 void virtio_add_status(struct virtio_device *dev, unsigned int status)
 {

drivers/virtio/virtio_mmio.c+1−2

@@ -548,8 +548,7 @@ static void virtio_mmio_release_dev(struct device *_d) · 547 unmodified lines
548	{	548	{
549	struct virtio_device *vdev =	549	struct virtio_device *vdev =
550	container_of(_d, struct virtio_device, dev);	550	container_of(_d, struct virtio_device, dev);
551	struct virtio_mmio_device *vm_dev =	551	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
552	container_of(vdev, struct virtio_mmio_device, vdev);
553	struct platform_device *pdev = vm_dev->pdev;	552	struct platform_device *pdev = vm_dev->pdev;
554		553
555	devm_kfree(&pdev->dev, vm_dev);	554	devm_kfree(&pdev->dev, vm_dev);

drivers/watchdog/cpu5wdt.c+0−1

@@ -273,7 +273,6 @@ module_exit(cpu5wdt_exit_module); · 272 unmodified lines
273		273
274	MODULE_AUTHOR("Heiko Ronsdorf <hero@ihg.uni-duisburg.de>");	274	MODULE_AUTHOR("Heiko Ronsdorf <hero@ihg.uni-duisburg.de>");
275	MODULE_DESCRIPTION("sma cpu5 watchdog driver");	275	MODULE_DESCRIPTION("sma cpu5 watchdog driver");
276	MODULE_SUPPORTED_DEVICE("sma cpu5 watchdog");
277	MODULE_LICENSE("GPL");	276	MODULE_LICENSE("GPL");
278		277
279	module_param_hw(port, int, ioport, 0);	278	module_param_hw(port, int, ioport, 0);

drivers/watchdog/cpwd.c+0−1

@@ -172,7 +172,6 @@ MODULE_PARM_DESC(wd2_timeout, "Default watchdog2 timeout in 1/10secs"); · 171 unmodified lines
172	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");	172	MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
173	MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");	173	MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500");
174	MODULE_LICENSE("GPL");	174	MODULE_LICENSE("GPL");
175	MODULE_SUPPORTED_DEVICE("watchdog");
176		175
177	static void cpwd_writew(u16 val, void __iomem *addr)	176	static void cpwd_writew(u16 val, void __iomem *addr)
178	{	177	{

drivers/watchdog/riowd.c+0−1

@@ -46,7 +46,6 @@ · 45 unmodified lines
46		46
47	MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");	47	MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
48	MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");	48	MODULE_DESCRIPTION("Hardware watchdog driver for Sun RIO");
49	MODULE_SUPPORTED_DEVICE("watchdog");
50	MODULE_LICENSE("GPL");	49	MODULE_LICENSE("GPL");
51		50
52	#define DRIVER_NAME "riowd"	51	#define DRIVER_NAME "riowd"

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/dir.c+0−1

@@ -70,7 +70,6 @@ const struct inode_operations afs_dir_inode_operations = { · 69 unmodified lines
70	.permission = afs_permission,	70	.permission = afs_permission,
71	.getattr = afs_getattr,	71	.getattr = afs_getattr,
72	.setattr = afs_setattr,	72	.setattr = afs_setattr,
73	.listxattr = afs_listxattr,
74	};	73	};
75		74
76	const struct address_space_operations afs_dir_aops = {	75	const struct address_space_operations afs_dir_aops = {

fs/afs/file.c+0−1

@@ -43,7 +43,6 @@ const struct inode_operations afs_file_inode_operations = { · 42 unmodified lines
43	.getattr = afs_getattr,	43	.getattr = afs_getattr,
44	.setattr = afs_setattr,	44	.setattr = afs_setattr,
45	.permission = afs_permission,	45	.permission = afs_permission,
46	.listxattr = afs_listxattr,
47	};	46	};
48		47
49	const struct address_space_operations afs_fs_aops = {	48	const struct address_space_operations afs_fs_aops = {

fs/afs/fs_operation.c+5−2

 		if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
 		    op->ops->issue_yfs_rpc)
 			op->ops->issue_yfs_rpc(op);
-		else
+		else if (op->ops->issue_afs_rpc)
 			op->ops->issue_afs_rpc(op);
+		else
+			op->ac.error = -ENOTSUPP;
-		op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
+		if (op->call)
+			op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
 	}
 	switch (op->error) {

fs/afs/inode.c+0−1

@@ -27,7 +27,6 @@ · 26 unmodified lines
27		27
28	static const struct inode_operations afs_symlink_inode_operations = {	28	static const struct inode_operations afs_symlink_inode_operations = {
29	.get_link = page_get_link,	29	.get_link = page_get_link,
30	.listxattr = afs_listxattr,
31	};	30	};
32		31
33	static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode parent_vnode)	32	static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode parent_vnode)

fs/afs/internal.h+0−1

@@ -1509,7 +1509,6 @@ extern int afs_launder_page(struct page *); · 1508 unmodified lines
1509	* xattr.c	1509	* xattr.c
1510	*/	1510	*/
1511	extern const struct xattr_handler *afs_xattr_handlers[];	1511	extern const struct xattr_handler *afs_xattr_handlers[];
1512	extern ssize_t afs_listxattr(struct dentry , char , size_t);
1513		1512
1514	/*	1513	/*
1515	* yfsclient.c	1514	* yfsclient.c

fs/afs/mntpt.c+0−1

@@ -32,7 +32,6 @@ const struct inode_operations afs_mntpt_inode_operations = { · 31 unmodified lines
32	.lookup = afs_mntpt_lookup,	32	.lookup = afs_mntpt_lookup,
33	.readlink = page_readlink,	33	.readlink = page_readlink,
34	.getattr = afs_getattr,	34	.getattr = afs_getattr,
35	.listxattr = afs_listxattr,
36	};	35	};
37		36
38	const struct inode_operations afs_autocell_inode_operations = {	37	const struct inode_operations afs_autocell_inode_operations = {

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/afs/xattr.c+7−24

 #include <linux/xattr.h>
 #include "internal.h"
-static const char afs_xattr_list[] =
-	"afs.acl\0"
-	"afs.cell\0"
-	"afs.fid\0"
-	"afs.volume\0"
-	"afs.yfs.acl\0"
-	"afs.yfs.acl_inherited\0"
-	"afs.yfs.acl_num_cleaned\0"
-	"afs.yfs.vol_acl";
-/*
- * Retrieve a list of the supported xattrs.
- */
-ssize_t afs_listxattr(struct dentry *dentry, char *buffer, size_t size)
-{
-	if (size == 0)
-		return sizeof(afs_xattr_list);
-	if (size < sizeof(afs_xattr_list))
-		return -ERANGE;
-	memcpy(buffer, afs_xattr_list, sizeof(afs_xattr_list));
-	return sizeof(afs_xattr_list);
-}
 /*
  * Deal with the result of a successful fetch ACL operation.
  */
 			else
 				ret = -ERANGE;
 		}
+	} else if (ret == -ENOTSUPP) {
+		ret = -ENODATA;
 	}
 error_yacl:
 {
 	struct afs_operation *op;
 	struct afs_vnode *vnode = AFS_FS_I(inode);
+	int ret;
 	if (flags == XATTR_CREATE ||
 	    strcmp(name, "acl") != 0)
 		return afs_put_operation(op);
 	op->ops = &yfs_store_opaque_acl2_operation;
-	return afs_do_sync_operation(op);
+	ret = afs_do_sync_operation(op);
+	if (ret == -ENOTSUPP)
+		ret = -ENODATA;
+	return ret;
 }
 static const struct xattr_handler afs_xattr_yfs_handler = {

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/ctree.c+2−0

 				   "failed to read tree block %llu from get_old_root",
 				   logical);
 		} else {
+			btrfs_tree_read_lock(old);
 			eb = btrfs_clone_extent_buffer(old);
+			btrfs_tree_read_unlock(old);
 			free_extent_buffer(old);
 		}
 	} else if (old_root) {

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/extent-tree.c+22−1

@@ -3323,6 +3323,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, · 3322 unmodified lines
3323		3323
3324	if (last_ref && btrfs_header_generation(buf) == trans->transid) {	3324	if (last_ref && btrfs_header_generation(buf) == trans->transid) {
3325	struct btrfs_block_group *cache;	3325	struct btrfs_block_group *cache;
		3326	bool must_pin = false;
3326		3327
3327	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {	3328	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
3328	ret = check_ref_cleanup(trans, buf->start);	3329	ret = check_ref_cleanup(trans, buf->start);
@@ -3340,7 +3341,27 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, · 11 unmodified lines
3340	goto out;	3341	goto out;
3341	}	3342	}
3342		3343
3343	if (btrfs_is_zoned(fs_info)) {	3344	/*
		3345	* If this is a leaf and there are tree mod log users, we may
		3346	* have recorded mod log operations that point to this leaf.
		3347	* So we must make sure no one reuses this leaf's extent before
		3348	* mod log operations are applied to a node, otherwise after
		3349	* rewinding a node using the mod log operations we get an
		3350	* inconsistent btree, as the leaf's extent may now be used as
		3351	* a node or leaf for another different btree.
		3352	* We are safe from races here because at this point no other
		3353	* node or root points to this extent buffer, so if after this
		3354	* check a new tree mod log user joins, it will not be able to
		3355	* find a node pointing to this leaf and record operations that
		3356	* point to this leaf.
		3357	*/
		3358	if (btrfs_header_level(buf) == 0) {
		3359	read_lock(&fs_info->tree_mod_log_lock);
		3360	must_pin = !list_empty(&fs_info->tree_mod_seq_list);
		3361	read_unlock(&fs_info->tree_mod_log_lock);
		3362	}
		3363
		3364	if (must_pin \|\| btrfs_is_zoned(fs_info)) {
3344	btrfs_redirty_list_add(trans->transaction, buf);	3365	btrfs_redirty_list_add(trans->transaction, buf);
3345	pin_down_extent(trans, cache, buf->start, buf->len, 1);	3366	pin_down_extent(trans, cache, buf->start, buf->len, 1);
3346	btrfs_put_block_group(cache);	3367	btrfs_put_block_group(cache);

fs/btrfs/extent_io.c+31−2

@@ -2885,6 +2885,35 @@ static void end_page_read(struct page *page, bool uptodate, u64 start, u32 len) · 2884 unmodified lines
2885	btrfs_subpage_end_reader(fs_info, page, start, len);	2885	btrfs_subpage_end_reader(fs_info, page, start, len);
2886	}	2886	}
2887		2887
		2888	/*
		2889	* Find extent buffer for a givne bytenr.
		2890	*
		2891	* This is for end_bio_extent_readpage(), thus we can't do any unsafe locking
		2892	* in endio context.
		2893	*/
		2894	static struct extent_buffer *find_extent_buffer_readpage(
		2895	struct btrfs_fs_info fs_info, struct page page, u64 bytenr)
		2896	{
		2897	struct extent_buffer *eb;
		2898
		2899	/*
		2900	* For regular sectorsize, we can use page->private to grab extent
		2901	* buffer
		2902	*/
		2903	if (fs_info->sectorsize == PAGE_SIZE) {
		2904	ASSERT(PagePrivate(page) && page->private);
		2905	return (struct extent_buffer *)page->private;
		2906	}
		2907
		2908	/* For subpage case, we need to lookup buffer radix tree */
		2909	rcu_read_lock();
		2910	eb = radix_tree_lookup(&fs_info->buffer_radix,
		2911	bytenr >> fs_info->sectorsize_bits);
		2912	rcu_read_unlock();
		2913	ASSERT(eb);
		2914	return eb;
		2915	}
		2916
2888	/*	2917	/*
2889	* after a readpage IO is done, we need to:	2918	* after a readpage IO is done, we need to:
2890	* clear the uptodate bits on error	2919	* clear the uptodate bits on error
@@ -2996,7 +3025,7 @@ static void end_bio_extent_readpage(struct bio *bio) · 105 unmodified lines
2996	} else {	3025	} else {
2997	struct extent_buffer *eb;	3026	struct extent_buffer *eb;
2998		3027
2999	eb = (struct extent_buffer *)page->private;	3028	eb = find_extent_buffer_readpage(fs_info, page, start);
3000	set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);	3029	set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
3001	eb->read_mirror = mirror;	3030	eb->read_mirror = mirror;
3002	atomic_dec(&eb->io_pages);	3031	atomic_dec(&eb->io_pages);
@@ -3020,7 +3049,7 @@ readpage_ok: · 17 unmodified lines
3020	*/	3049	*/
3021	if (page->index == end_index && i_size <= end) {	3050	if (page->index == end_index && i_size <= end) {
3022	u32 zero_start = max(offset_in_page(i_size),	3051	u32 zero_start = max(offset_in_page(i_size),
3023	offset_in_page(end));	3052	offset_in_page(start));
3024		3053
3025	zero_user_segment(page, zero_start,	3054	zero_user_segment(page, zero_start,
3026	offset_in_page(end) + 1);	3055	offset_in_page(end) + 1);

fs/btrfs/inode.c+35−20

  * @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);
 	btrfs_free_space_bitmap_cachep = kmem_cache_create("btrfs_free_space_bitmap",
 							PAGE_SIZE, PAGE_SIZE,
-							SLAB_RED_ZONE, NULL);
+							SLAB_MEM_SPREAD, NULL);
 	if (!btrfs_free_space_bitmap_cachep)
 		goto fail;
 	struct btrfs_path *path;
 	u64 start = ins->objectid;
 	u64 len = ins->offset;
+	int qgroup_released;
 	int ret;
 	memset(&stack_fi, 0, sizeof(stack_fi));
 	btrfs_set_stack_file_extent_compression(&stack_fi, BTRFS_COMPRESS_NONE);
 	/* Encryption and other encoding is reserved and all 0 */
-	ret = btrfs_qgroup_release_data(inode, file_offset, len);
+	qgroup_released = btrfs_qgroup_release_data(inode, file_offset, len);
-	if (ret < 0)
+	if (qgroup_released < 0)
-		return ERR_PTR(ret);
+		return ERR_PTR(qgroup_released);
 	if (trans) {
 		ret = insert_reserved_file_extent(trans, inode,
 						  file_offset, &stack_fi,
-						  true, ret);
+						  true, qgroup_released);
 		if (ret)
-			return ERR_PTR(ret);
+			goto free_qgroup;
 		return trans;
 	}
 	extent_info.file_offset = file_offset;
 	extent_info.extent_buf = (char *)&stack_fi;
 	extent_info.is_new_extent = true;
-	extent_info.qgroup_reserved = ret;
+	extent_info.qgroup_reserved = qgroup_released;
 	extent_info.insertions = 0;
 	path = btrfs_alloc_path();
-	if (!path)
+	if (!path) {
-		return ERR_PTR(-ENOMEM);
+		ret = -ENOMEM;
+		goto free_qgroup;
+	}
 	ret = btrfs_replace_file_extents(&inode->vfs_inode, path, file_offset,
 				     file_offset + len - 1, &extent_info,
 				     &trans);
 	btrfs_free_path(path);
 	if (ret)
-		return ERR_PTR(ret);
+		goto free_qgroup;
 	return trans;
+free_qgroup:
+	/*
+	 * We have released qgroup data range at the beginning of the function,
+	 * and normally qgroup_released bytes will be freed when committing
+	 * transaction.
+	 * But if we error out early, we have to free what we have released
+	 * or we leak qgroup data reservation.
+	 */
+	btrfs_qgroup_free_refroot(inode->root->fs_info,
+			inode->root->root_key.objectid, qgroup_released,
+			BTRFS_QGROUP_RSV_DATA);
+	return ERR_PTR(ret);
 }
 static int __btrfs_prealloc_file_range(struct inode *inode, int mode,

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/reada.c+18−17

 	/* find extent */
 	spin_lock(&fs_info->reada_lock);
 	re = radix_tree_lookup(&fs_info->reada_tree,
-			       eb->start >> PAGE_SHIFT);
+			       eb->start >> fs_info->sectorsize_bits);
 	if (re)
 		re->refcnt++;
 	spin_unlock(&fs_info->reada_lock);
 	zone = NULL;
 	spin_lock(&fs_info->reada_lock);
 	ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-				     logical >> PAGE_SHIFT, 1);
+				     logical >> fs_info->sectorsize_bits, 1);
 	if (ret == 1 && logical >= zone->start && logical <= zone->end) {
 		kref_get(&zone->refcnt);
 		spin_unlock(&fs_info->reada_lock);
 	spin_lock(&fs_info->reada_lock);
 	ret = radix_tree_insert(&dev->reada_zones,
-				(unsigned long)(zone->end >> PAGE_SHIFT),
+			(unsigned long)(zone->end >> fs_info->sectorsize_bits),
-				zone);
+			zone);
 	if (ret == -EEXIST) {
 		kfree(zone);
 		ret = radix_tree_gang_lookup(&dev->reada_zones, (void **)&zone,
-					     logical >> PAGE_SHIFT, 1);
+					logical >> fs_info->sectorsize_bits, 1);
 		if (ret == 1 && logical >= zone->start && logical <= zone->end)
 			kref_get(&zone->refcnt);
 		else
 	u64 length;
 	int real_stripes;
 	int nzones = 0;
-	unsigned long index = logical >> PAGE_SHIFT;
+	unsigned long index = logical >> fs_info->sectorsize_bits;
 	int dev_replace_is_ongoing;
 	int have_zone = 0;
 			     struct reada_extent *re)
 {
 	int i;
-	unsigned long index = re->logical >> PAGE_SHIFT;
+	unsigned long index = re->logical >> fs_info->sectorsize_bits;
 	spin_lock(&fs_info->reada_lock);
 	if (--re->refcnt) {
 static void reada_zone_release(struct kref *kref)
 {
 	struct reada_zone *zone = container_of(kref, struct reada_zone, refcnt);
+	struct btrfs_fs_info *fs_info = zone->device->fs_info;
-	lockdep_assert_held(&zone->device->fs_info->reada_lock);
+	lockdep_assert_held(&fs_info->reada_lock);
 	radix_tree_delete(&zone->device->reada_zones,
-			  zone->end >> PAGE_SHIFT);
+			  zone->end >> fs_info->sectorsize_bits);
 	kfree(zone);
 }
 static void reada_peer_zones_set_lock(struct reada_zone *zone, int lock)
 {
 	int i;
-	unsigned long index = zone->end >> PAGE_SHIFT;
+	unsigned long index = zone->end >> zone->device->fs_info->sectorsize_bits;
 	for (i = 0; i < zone->ndevs; ++i) {
 		struct reada_zone *peer;
 					     (void **)&zone, index, 1);
 		if (ret == 0)
 			break;
-		index = (zone->end >> PAGE_SHIFT) + 1;
+		index = (zone->end >> dev->fs_info->sectorsize_bits) + 1;
 		if (zone->locked) {
 			if (zone->elems > top_locked_elems) {
 				top_locked_elems = zone->elems;
 	 * plugging to speed things up
 	 */
 	ret = radix_tree_gang_lookup(&dev->reada_extents, (void **)&re,
-				     dev->reada_next >> PAGE_SHIFT, 1);
+				dev->reada_next >> fs_info->sectorsize_bits, 1);
 	if (ret == 0 || re->logical > dev->reada_curr_zone->end) {
 		ret = reada_pick_zone(dev);
 		if (!ret) {
 		}
 		re = NULL;
 		ret = radix_tree_gang_lookup(&dev->reada_extents, (void **)&re,
-					dev->reada_next >> PAGE_SHIFT, 1);
+				dev->reada_next >> fs_info->sectorsize_bits, 1);
 	}
 	if (ret == 0) {
 		spin_unlock(&fs_info->reada_lock);
 				pr_cont(" curr off %llu",
 					device->reada_next - zone->start);
 			pr_cont("\n");
-			index = (zone->end >> PAGE_SHIFT) + 1;
+			index = (zone->end >> fs_info->sectorsize_bits) + 1;
 		}
 		cnt = 0;
 		index = 0;
 				}
 			}
 			pr_cont("\n");
-			index = (re->logical >> PAGE_SHIFT) + 1;
+			index = (re->logical >> fs_info->sectorsize_bits) + 1;
 			if (++cnt > 15)
 				break;
 		}
 		if (ret == 0)
 			break;
 		if (!re->scheduled) {
-			index = (re->logical >> PAGE_SHIFT) + 1;
+			index = (re->logical >> fs_info->sectorsize_bits) + 1;
 			continue;
 		}
 		pr_debug("re: logical %llu size %u list empty %d scheduled %d",
 			}
 		}
 		pr_cont("\n");
-		index = (re->logical >> PAGE_SHIFT) + 1;
+		index = (re->logical >> fs_info->sectorsize_bits) + 1;
 	}
 	spin_unlock(&fs_info->reada_lock);
 }

fs/btrfs/tree-log.c+4−4

 	mutex_lock(&log_root_tree->log_mutex);
-	index2 = log_root_tree->log_transid % 2;
-	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
-	root_log_ctx.log_transid = log_root_tree->log_transid;
 	if (btrfs_is_zoned(fs_info)) {
 		if (!log_root_tree->node) {
 			ret = btrfs_alloc_log_tree_node(trans, log_root_tree);
 		}
 	}
+	index2 = log_root_tree->log_transid % 2;
+	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
+	root_log_ctx.log_transid = log_root_tree->log_transid;
 	/*
 	 * Now we are safe to update the log_root_tree because we're under the
 	 * log_mutex, and we're a current writer so we're holding the commit

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/cifs_swn.c+1−1

@@ -248,7 +248,7 @@ nlmsg_fail: · 247 unmodified lines
248		248
249	/*	249	/*
250	* Try to find a matching registration for the tcon's server name and share name.	250	* Try to find a matching registration for the tcon's server name and share name.
251	* Calls to this funciton must be protected by cifs_swnreg_idr_mutex.	251	* Calls to this function must be protected by cifs_swnreg_idr_mutex.
252	* TODO Try to avoid memory allocations	252	* TODO Try to avoid memory allocations
253	*/	253	*/
254	static struct cifs_swn_reg cifs_find_swn_reg(struct cifs_tcon tcon)	254	static struct cifs_swn_reg cifs_find_swn_reg(struct cifs_tcon tcon)

fs/cifs/cifsacl.c+5−3

 	/* Retain old ACEs which we can retain */
 	for (i = 0; i < src_num_aces; ++i) {
 		pntace = (struct cifs_ace *) (acl_base + size);
-		pnntace = (struct cifs_ace *) (nacl_base + nsize);
 		if (!new_aces_set && (pntace->flags & INHERITED_ACE)) {
 			/* Place the new ACEs in between existing explicit and inherited */
 		}
 		/* If it's any one of the ACE we're replacing, skip! */
-		if ((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) ||
+		if (((compare_sids(&pntace->sid, &sid_unix_NFS_mode) == 0) ||
 				(compare_sids(&pntace->sid, pownersid) == 0) ||
 				(compare_sids(&pntace->sid, pgrpsid) == 0) ||
 				(compare_sids(&pntace->sid, &sid_everyone) == 0) ||
-				(compare_sids(&pntace->sid, &sid_authusers) == 0)) {
+				(compare_sids(&pntace->sid, &sid_authusers) == 0))) {
 			goto next_ace;
 		}
+		/* update the pointer to the next ACE to populate*/
+		pnntace = (struct cifs_ace *) (nacl_base + nsize);
 		nsize += cifs_copy_ace(pnntace, pntace, NULL);
 		num_aces++;

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/fs_context.c+4−2

 		pr_warn_once("Witness protocol support is experimental\n");
 		break;
 	case Opt_rootfs:
-#ifdef CONFIG_CIFS_ROOT
+#ifndef CONFIG_CIFS_ROOT
-		ctx->rootfs = true;
+		cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
+		goto cifs_parse_mount_err;
 #endif
+		ctx->rootfs = true;
 		break;
 	case Opt_posixpaths:
 		if (result.negated)

fs/cifs/inode.c+9−1

 	 * We need to be sure that all dirty pages are written and the server
 	 * has actual ctime, mtime and file length.
 	 */
-	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
+	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
 	    !CIFS_CACHE_READ(CIFS_I(inode)) &&
 	    inode->i_mapping && inode->i_mapping->nrpages != 0) {
 		rc = filemap_fdatawait(inode->i_mapping);
 	if (rc == 0) {
 		cifsInode->server_eof = attrs->ia_size;
 		cifs_setsize(inode, attrs->ia_size);
+		/*
+		 * i_blocks is not related to (i_size / i_blksize), but instead
+		 * 512 byte (2**9) size is required for calculating num blocks.
+		 * Until we can query the server for actual allocation size,
+		 * this is best estimate we have for blocks allocated for a file
+		 * Number of blocks must be rounded up so size 1 is not 0 blocks
+		 */
+		inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
 		/*
 		 * The man page of truncate says if the size changed,

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/cifs/transport.c+6−1

 	/*
 	 * Compounding is never used during session establish.
 	 */
-	if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP))
+	if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {
+		mutex_lock(&server->srv_mutex);
 		smb311_update_preauth_hash(ses, rqst[0].rq_iov,
 					   rqst[0].rq_nvec);
+		mutex_unlock(&server->srv_mutex);
+	}
 	for (i = 0; i < num_rqst; i++) {
 		rc = wait_for_response(server, midQ[i]);
 			.iov_base = resp_iov[0].iov_base,
 			.iov_len = resp_iov[0].iov_len
 		};
+		mutex_lock(&server->srv_mutex);
 		smb311_update_preauth_hash(ses, &iov, 1);
+		mutex_unlock(&server->srv_mutex);
 	}
 out:

fs/ext4/balloc.c+26−12

@@ -626,27 +626,41 @@ int ext4_claim_free_clusters(struct ext4_sb_info *sbi, · 625 unmodified lines
626		626
627	/**	627	/**
628	* ext4_should_retry_alloc() - check if a block allocation should be retried	628	* ext4_should_retry_alloc() - check if a block allocation should be retried
629	* @sb: super block	629	* @sb: superblock
630	* @retries: number of attemps has been made	630	* @retries: number of retry attempts made so far
631	*	631	*
632	* ext4_should_retry_alloc() is called when ENOSPC is returned, and if	632	* ext4_should_retry_alloc() is called when ENOSPC is returned while
633	* it is profitable to retry the operation, this function will wait	633	* attempting to allocate blocks. If there's an indication that a pending
634	* for the current or committing transaction to complete, and then	634	* journal transaction might free some space and allow another attempt to
635	* return TRUE. We will only retry once.	635	* succeed, this function will wait for the current or committing transaction
		636	* to complete and then return TRUE.
636	*/	637	*/
637	int ext4_should_retry_alloc(struct super_block sb, int retries)	638	int ext4_should_retry_alloc(struct super_block sb, int retries)
638	{	639	{
639	if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) \|\|	640	struct ext4_sb_info *sbi = EXT4_SB(sb);
640	(*retries)++ > 1 \|\|	641
641	!EXT4_SB(sb)->s_journal)	642	if (!sbi->s_journal)
642	return 0;	643	return 0;
643		644
644	smp_mb();	645	if (++(*retries) > 3) {
645	if (EXT4_SB(sb)->s_mb_free_pending == 0)	646	percpu_counter_inc(&sbi->s_sra_exceeded_retry_limit);
646	return 0;	647	return 0;
		648	}
647		649
		650	/*
		651	* if there's no indication that blocks are about to be freed it's
		652	* possible we just missed a transaction commit that did so
		653	*/
		654	smp_mb();
		655	if (sbi->s_mb_free_pending == 0)
		656	return ext4_has_free_clusters(sbi, 1, 0);
		657
		658	/*
		659	* it's possible we've just missed a transaction commit here,
		660	* so ignore the returned status
		661	*/
648	jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);	662	jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
649	jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);	663	(void) jbd2_journal_force_commit_nested(sbi->s_journal);
650	return 1;	664	return 1;
651	}	665	}
652		666

fs/ext4/ext4.h+3−0

 	struct percpu_counter s_freeinodes_counter;
 	struct percpu_counter s_dirs_counter;
 	struct percpu_counter s_dirtyclusters_counter;
+	struct percpu_counter s_sra_exceeded_retry_limit;
 	struct blockgroup_lock *s_blockgroup_lock;
 	struct proc_dir_entry *s_proc;
 	struct kobject s_kobj;
 	struct dentry *dentry);
 void ext4_fc_track_unlink(handle_t *handle, struct dentry *dentry);
 void ext4_fc_track_link(handle_t *handle, struct dentry *dentry);
+void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
+			    struct dentry *dentry);
 void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
 void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
 void ext4_fc_mark_ineligible(struct super_block *sb, int reason);

fs/ext4/extents.c+1−1

@@ -4382,7 +4382,7 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset, · 4381 unmodified lines
4382	{	4382	{
4383	struct inode *inode = file_inode(file);	4383	struct inode *inode = file_inode(file);
4384	handle_t *handle;	4384	handle_t *handle;
4385	int ret, ret2 = 0, ret3 = 0;	4385	int ret = 0, ret2 = 0, ret3 = 0;
4386	int retries = 0;	4386	int retries = 0;
4387	int depth = 0;	4387	int depth = 0;
4388	struct ext4_map_blocks map;	4388	struct ext4_map_blocks map;

fs/ext4/fast_commit.c+7−2

 	__ext4_fc_track_link(handle, d_inode(dentry), dentry);
 }
-void ext4_fc_track_create(handle_t *handle, struct dentry *dentry)
+void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
+			  struct dentry *dentry)
 {
 	struct __track_dentry_update_args args;
-	struct inode *inode = d_inode(dentry);
 	int ret;
 	args.dentry = dentry;
 	trace_ext4_fc_track_create(inode, dentry, ret);
 }
+void ext4_fc_track_create(handle_t *handle, struct dentry *dentry)
+{
+	__ext4_fc_track_create(handle, d_inode(dentry), dentry);
+}
 /* __track_fn for inode tracking */
 static int __track_inode(struct inode *inode, void *arg, bool update)
 {

fs/ext4/inode.c+10−8

 	if (!ret)
 		ret = err;
-	if (!ext4_has_inline_data(inode))
-		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
-				       NULL, bput_one);
 	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
 out:
 	unlock_page(page);
 out_no_pagelock:
+	if (!inline_data && page_bufs)
+		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
+				       NULL, bput_one);
 	brelse(inode_bh);
 	return ret;
 }
 	struct ext4_inode_info *ei = EXT4_I(inode);
 	struct buffer_head *bh = iloc->bh;
 	struct super_block *sb = inode->i_sb;
-	int err = 0, rc, block;
+	int err = 0, block;
 	int need_datasync = 0, set_large_file = 0;
 	uid_t i_uid;
 	gid_t i_gid;
 					      bh->b_data);
 	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
-	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
+	err = ext4_handle_dirty_metadata(handle, NULL, bh);
-	if (!err)
+	if (err)
-		err = rc;
+		goto out_brelse;
 	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
 	if (set_large_file) {
 		BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
 			inode->i_gid = attr->ia_gid;
 		error = ext4_mark_inode_dirty(handle, inode);
 		ext4_journal_stop(handle);
-		if (unlikely(error))
+		if (unlikely(error)) {
+			ext4_fc_stop_update(inode);
 			return error;
+		}
 	}
 	if (attr->ia_valid & ATTR_SIZE) {

fs/ext4/mballoc.c+9−2

 	}
 	if (ext4_has_feature_flex_bg(sb)) {
-		/* a single flex group is supposed to be read by a single IO */
+		/* a single flex group is supposed to be read by a single IO.
-		sbi->s_mb_prefetch = min(1 << sbi->s_es->s_log_groups_per_flex,
+		 * 2 ^ s_log_groups_per_flex != UINT_MAX as s_mb_prefetch is
+		 * unsigned integer, so the maximum shift is 32.
+		 */
+		if (sbi->s_es->s_log_groups_per_flex >= 32) {
+			ext4_msg(sb, KERN_ERR, "too many log groups per flexible block group");
+			goto err_freesgi;
+		}
+		sbi->s_mb_prefetch = min_t(uint, 1 << sbi->s_es->s_log_groups_per_flex,
 			BLK_MAX_SEGMENT_SIZE >> (sb->s_blocksize_bits - 9));
 		sbi->s_mb_prefetch *= 8; /* 8 prefetch IOs in flight at most */
 	} else {

fs/ext4/namei.c+39−11

@@ -3613,6 +3613,31 @@ static int ext4_setent(handle_t handle, struct ext4_renament ent, · 3612 unmodified lines
3613	return retval;	3613	return retval;
3614	}	3614	}
3615		3615
		3616	static void ext4_resetent(handle_t handle, struct ext4_renament ent,
		3617	unsigned ino, unsigned file_type)
		3618	{
		3619	struct ext4_renament old = *ent;
		3620	int retval = 0;
		3621
		3622	/*
		3623	* old->de could have moved from under us during make indexed dir,
		3624	* so the old->de may no longer valid and need to find it again
		3625	* before reset old inode info.
		3626	*/
		3627	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
		3628	if (IS_ERR(old.bh))
		3629	retval = PTR_ERR(old.bh);
		3630	if (!old.bh)
		3631	retval = -ENOENT;
		3632	if (retval) {
		3633	ext4_std_error(old.dir->i_sb, retval);
		3634	return;
		3635	}
		3636
		3637	ext4_setent(handle, &old, ino, file_type);
		3638	brelse(old.bh);
		3639	}
		3640
3616	static int ext4_find_delete_entry(handle_t handle, struct inode dir,	3641	static int ext4_find_delete_entry(handle_t handle, struct inode dir,
3617	const struct qstr *d_name)	3642	const struct qstr *d_name)
3618	{	3643	{
@@ -3774,14 +3799,14 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 155 unmodified lines
3774	*/	3799	*/
3775	retval = -ENOENT;	3800	retval = -ENOENT;
3776	if (!old.bh \|\| le32_to_cpu(old.de->inode) != old.inode->i_ino)	3801	if (!old.bh \|\| le32_to_cpu(old.de->inode) != old.inode->i_ino)
3777	goto end_rename;	3802	goto release_bh;
3778		3803
3779	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,	3804	new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3780	&new.de, &new.inlined);	3805	&new.de, &new.inlined);
3781	if (IS_ERR(new.bh)) {	3806	if (IS_ERR(new.bh)) {
3782	retval = PTR_ERR(new.bh);	3807	retval = PTR_ERR(new.bh);
3783	new.bh = NULL;	3808	new.bh = NULL;
3784	goto end_rename;	3809	goto release_bh;
3785	}	3810	}
3786	if (new.bh) {	3811	if (new.bh) {
3787	if (!new.inode) {	3812	if (!new.inode) {
@@ -3798,15 +3823,13 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 10 unmodified lines
3798	handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);	3823	handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3799	if (IS_ERR(handle)) {	3824	if (IS_ERR(handle)) {
3800	retval = PTR_ERR(handle);	3825	retval = PTR_ERR(handle);
3801	handle = NULL;	3826	goto release_bh;
3802	goto end_rename;
3803	}	3827	}
3804	} else {	3828	} else {
3805	whiteout = ext4_whiteout_for_rename(mnt_userns, &old, credits, &handle);	3829	whiteout = ext4_whiteout_for_rename(mnt_userns, &old, credits, &handle);
3806	if (IS_ERR(whiteout)) {	3830	if (IS_ERR(whiteout)) {
3807	retval = PTR_ERR(whiteout);	3831	retval = PTR_ERR(whiteout);
3808	whiteout = NULL;	3832	goto release_bh;
3809	goto end_rename;
3810	}	3833	}
3811	}	3834	}
3812		3835
@@ -3850,6 +3873,7 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 37 unmodified lines
3850	retval = ext4_mark_inode_dirty(handle, whiteout);	3873	retval = ext4_mark_inode_dirty(handle, whiteout);
3851	if (unlikely(retval))	3874	if (unlikely(retval))
3852	goto end_rename;	3875	goto end_rename;
		3876
3853	}	3877	}
3854	if (!new.bh) {	3878	if (!new.bh) {
3855	retval = ext4_add_entry(handle, new.dentry, old.inode);	3879	retval = ext4_add_entry(handle, new.dentry, old.inode);
@@ -3923,6 +3947,8 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 67 unmodified lines
3923	ext4_fc_track_unlink(handle, new.dentry);	3947	ext4_fc_track_unlink(handle, new.dentry);
3924	__ext4_fc_track_link(handle, old.inode, new.dentry);	3948	__ext4_fc_track_link(handle, old.inode, new.dentry);
3925	__ext4_fc_track_unlink(handle, old.inode, old.dentry);	3949	__ext4_fc_track_unlink(handle, old.inode, old.dentry);
		3950	if (whiteout)
		3951	__ext4_fc_track_create(handle, whiteout, old.dentry);
3926	}	3952	}
3927		3953
3928	if (new.inode) {	3954	if (new.inode) {
@@ -3937,19 +3963,21 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 8 unmodified lines
3937	end_rename:	3963	end_rename:
3938	if (whiteout) {	3964	if (whiteout) {
3939	if (retval) {	3965	if (retval) {
3940	ext4_setent(handle, &old,	3966	ext4_resetent(handle, &old,
3941	old.inode->i_ino, old_file_type);	3967	old.inode->i_ino, old_file_type);
3942	drop_nlink(whiteout);	3968	drop_nlink(whiteout);
		3969	ext4_orphan_add(handle, whiteout);
3943	}	3970	}
3944	unlock_new_inode(whiteout);	3971	unlock_new_inode(whiteout);
		3972	ext4_journal_stop(handle);
3945	iput(whiteout);	3973	iput(whiteout);
3946		3974	} else {
		3975	ext4_journal_stop(handle);
3947	}	3976	}
		3977	release_bh:
3948	brelse(old.dir_bh);	3978	brelse(old.dir_bh);
3949	brelse(old.bh);	3979	brelse(old.bh);
3950	brelse(new.bh);	3980	brelse(new.bh);
3951	if (handle)
3952	ext4_journal_stop(handle);
3953	return retval;	3981	return retval;
3954	}	3982	}
3955		3983

fs/ext4/super.c+6−1

 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
 	percpu_counter_destroy(&sbi->s_dirs_counter);
 	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
+	percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
 	percpu_free_rwsem(&sbi->s_writepages_rwsem);
 #ifdef CONFIG_QUOTA
 	for (i = 0; i < EXT4_MAXQUOTAS; i++)
 	if (!err)
 		err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
 					  GFP_KERNEL);
+	if (!err)
+		err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
+					  GFP_KERNEL);
 	if (!err)
 		err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
 	percpu_counter_destroy(&sbi->s_dirs_counter);
 	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
+	percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
 	percpu_free_rwsem(&sbi->s_writepages_rwsem);
 failed_mount5:
 	ext4_ext_release(sb);
 failed_mount3a:
 	ext4_es_unregister_shrinker(sbi);
 failed_mount3:
-	del_timer_sync(&sbi->s_err_report);
 	flush_work(&sbi->s_error_work);
+	del_timer_sync(&sbi->s_err_report);
 	if (sbi->s_mmp_tsk)
 		kthread_stop(sbi->s_mmp_tsk);
 failed_mount2:

fs/ext4/sysfs.c+7−0

 	attr_session_write_kbytes,
 	attr_lifetime_write_kbytes,
 	attr_reserved_clusters,
+	attr_sra_exceeded_retry_limit,
 	attr_inode_readahead,
 	attr_trigger_test_error,
 	attr_first_error_time,
 EXT4_ATTR_FUNC(session_write_kbytes, 0444);
 EXT4_ATTR_FUNC(lifetime_write_kbytes, 0444);
 EXT4_ATTR_FUNC(reserved_clusters, 0644);
+EXT4_ATTR_FUNC(sra_exceeded_retry_limit, 0444);
 EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, inode_readahead,
 		 ext4_sb_info, s_inode_readahead_blks);
 	ATTR_LIST(session_write_kbytes),
 	ATTR_LIST(lifetime_write_kbytes),
 	ATTR_LIST(reserved_clusters),
+	ATTR_LIST(sra_exceeded_retry_limit),
 	ATTR_LIST(inode_readahead_blks),
 	ATTR_LIST(inode_goal),
 	ATTR_LIST(mb_stats),
 		return snprintf(buf, PAGE_SIZE, "%llu\n",
 				(unsigned long long)
 				atomic64_read(&sbi->s_resv_clusters));
+	case attr_sra_exceeded_retry_limit:
+		return snprintf(buf, PAGE_SIZE, "%llu\n",
+				(unsigned long long)
+			percpu_counter_sum(&sbi->s_sra_exceeded_retry_limit));
 	case attr_inode_readahead:
 	case attr_pointer_ui:
 		if (!ptr)

fs/ext4/verity.c+55−34

@@ -201,55 +201,76 @@ static int ext4_end_enable_verity(struct file filp, const void desc, · 200 unmodified lines
201	struct inode *inode = file_inode(filp);	201	struct inode *inode = file_inode(filp);
202	const int credits = 2; /* superblock and inode for ext4_orphan_del() */	202	const int credits = 2; /* superblock and inode for ext4_orphan_del() */
203	handle_t *handle;	203	handle_t *handle;
		204	struct ext4_iloc iloc;
204	int err = 0;	205	int err = 0;
205	int err2;
206		206
207	if (desc != NULL) {	207	/*
208	/* Succeeded; write the verity descriptor. */	208	* If an error already occurred (which fs/verity/ signals by passing
209	err = ext4_write_verity_descriptor(inode, desc, desc_size,	209	* desc == NULL), then only clean-up is needed.
210	merkle_tree_size);	210	*/
211		211	if (desc == NULL)
212	/* Write all pages before clearing VERITY_IN_PROGRESS. */	212	goto cleanup;
213	if (!err)
214	err = filemap_write_and_wait(inode->i_mapping);
215	}
216		213
217	/* If we failed, truncate anything we wrote past i_size. */	214	/* Append the verity descriptor. */
218	if (desc == NULL \|\| err)	215	err = ext4_write_verity_descriptor(inode, desc, desc_size,
219	ext4_truncate(inode);	216	merkle_tree_size);
		217	if (err)
		218	goto cleanup;
220		219
221	/*	220	/*
222	* We must always clean up by clearing EXT4_STATE_VERITY_IN_PROGRESS and	221	* Write all pages (both data and verity metadata). Note that this must
223	* deleting the inode from the orphan list, even if something failed.	222	* happen before clearing EXT4_STATE_VERITY_IN_PROGRESS; otherwise pages
224	* If everything succeeded, we'll also set the verity bit in the same	223	* beyond i_size won't be written properly. For crash consistency, this
225	* transaction.	224	* also must happen before the verity inode flag gets persisted.
226	*/	225	*/
		226	err = filemap_write_and_wait(inode->i_mapping);
		227	if (err)
		228	goto cleanup;
227		229
228	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);	230	/*
		231	* Finally, set the verity inode flag and remove the inode from the
		232	* orphan list (in a single transaction).
		233	*/
229		234
230	handle = ext4_journal_start(inode, EXT4_HT_INODE, credits);	235	handle = ext4_journal_start(inode, EXT4_HT_INODE, credits);
231	if (IS_ERR(handle)) {	236	if (IS_ERR(handle)) {
232	ext4_orphan_del(NULL, inode);	237	err = PTR_ERR(handle);
233	return PTR_ERR(handle);	238	goto cleanup;
234	}	239	}
235		240
236	err2 = ext4_orphan_del(handle, inode);	241	err = ext4_orphan_del(handle, inode);
237	if (err2)	242	if (err)
238	goto out_stop;	243	goto stop_and_cleanup;
239		244
240	if (desc != NULL && !err) {	245	err = ext4_reserve_inode_write(handle, inode, &iloc);
241	struct ext4_iloc iloc;	246	if (err)
		247	goto stop_and_cleanup;
242		248
243	err = ext4_reserve_inode_write(handle, inode, &iloc);	249	ext4_set_inode_flag(inode, EXT4_INODE_VERITY);
244	if (err)	250	ext4_set_inode_flags(inode, false);
245	goto out_stop;	251	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
246	ext4_set_inode_flag(inode, EXT4_INODE_VERITY);	252	if (err)
247	ext4_set_inode_flags(inode, false);	253	goto stop_and_cleanup;
248	err = ext4_mark_iloc_dirty(handle, inode, &iloc);	254
249	}	255	ext4_journal_stop(handle);
250	out_stop:	256
		257	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
		258	return 0;
		259
		260	stop_and_cleanup:
251	ext4_journal_stop(handle);	261	ext4_journal_stop(handle);
252	return err ?: err2;	262	cleanup:
		263	/*
		264	* Verity failed to be enabled, so clean up by truncating any verity
		265	* metadata that was written beyond i_size (both from cache and from
		266	* disk), removing the inode from the orphan list (if it wasn't done
		267	* already), and clearing EXT4_STATE_VERITY_IN_PROGRESS.
		268	*/
		269	truncate_inode_pages(inode->i_mapping, inode->i_size);
		270	ext4_truncate(inode);
		271	ext4_orphan_del(NULL, inode);
		272	ext4_clear_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
		273	return err;
253	}	274	}
254		275
255	static int ext4_get_verity_descriptor_location(struct inode *inode,	276	static int ext4_get_verity_descriptor_location(struct inode *inode,

fs/ext4/xattr.c+5−1

 	if (!ce)
 		return NULL;
+	WARN_ON_ONCE(ext4_handle_valid(journal_current_handle()) &&
+		     !(current->flags & PF_MEMALLOC_NOFS));
 	ea_data = kvmalloc(value_len, GFP_KERNEL);
 	if (!ea_data) {
 		mb_cache_entry_put(ea_inode_cache, ce);
 			error = -ENOSPC;
 			goto cleanup;
 		}
+		WARN_ON_ONCE(!(current->flags & PF_MEMALLOC_NOFS));
 	}
 	error = ext4_reserve_inode_write(handle, inode, &is.iloc);
 				 * external inode if possible.
 				 */
 				if (ext4_has_feature_ea_inode(inode->i_sb) &&
-				    !i.in_inode) {
+				    i.value_len && !i.in_inode) {
 					i.in_inode = 1;
 					goto retry_inode;
 				}

fs/fuse/dev.c+16−10

 static long fuse_dev_ioctl(struct file *file, unsigned int cmd,
 			   unsigned long arg)
 {
-	int err = -ENOTTY;
+	int res;
+	int oldfd;
+	struct fuse_dev *fud = NULL;
-	if (cmd == FUSE_DEV_IOC_CLONE) {
+	if (_IOC_TYPE(cmd) != FUSE_DEV_IOC_MAGIC)
-		int oldfd;
+		return -ENOTTY;
-		err = -EFAULT;
+	switch (_IOC_NR(cmd)) {
-		if (!get_user(oldfd, (__u32 __user *) arg)) {
+	case _IOC_NR(FUSE_DEV_IOC_CLONE):
+		res = -EFAULT;
+		if (!get_user(oldfd, (__u32 __user *)arg)) {
 			struct file *old = fget(oldfd);
-			err = -EINVAL;
+			res = -EINVAL;
 			if (old) {
-				struct fuse_dev *fud = NULL;
 				/*
 				 * Check against file->f_op because CUSE
 				 * uses the same ioctl handler.
 				if (fud) {
 					mutex_lock(&fuse_mutex);
-					err = fuse_device_clone(fud->fc, file);
+					res = fuse_device_clone(fud->fc, file);
 					mutex_unlock(&fuse_mutex);
 				}
 				fput(old);
 			}
 		}
+		break;
+	default:
+		res = -ENOTTY;
+		break;
 	}
-	return err;
+	return res;
 }
 const struct file_operations fuse_dev_operations = {

fs/fuse/fuse_i.h+1−0

@@ -863,6 +863,7 @@ static inline u64 fuse_get_attr_version(struct fuse_conn *fc) · 862 unmodified lines
863		863
864	static inline void fuse_make_bad(struct inode *inode)	864	static inline void fuse_make_bad(struct inode *inode)
865	{	865	{
		866	remove_inode_hash(inode);
866	set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);	867	set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);
867	}	868	}
868		869

fs/fuse/virtio_fs.c+8−1

 	/* virtiofs allocates and installs its own fuse devices */
 	ctx->fudptr = NULL;
-	if (ctx->dax)
+	if (ctx->dax) {
+		if (!fs->dax_dev) {
+			err = -EINVAL;
+			pr_err("virtio-fs: dax can't be enabled as filesystem"
+			       " device does not support it.\n");
+			goto err_free_fuse_devs;
+		}
 		ctx->dax_dev = fs->dax_dev;
+	}
 	err = fuse_fill_super_common(sb, ctx);
 	if (err < 0)
 		goto err_free_fuse_devs;

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+31−13

 #include <linux/rculist_nulls.h>
 #include <linux/cpu.h>
 #include <linux/tracehook.h>
-#include <linux/freezer.h>
 #include "../kernel/sched/sched.h"
 #include "io-wq.h"
 	return NULL;
 }
-static void io_flush_signals(void)
+static bool io_flush_signals(void)
 {
-	if (unlikely(test_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL))) {
+	if (unlikely(test_thread_flag(TIF_NOTIFY_SIGNAL))) {
-		if (current->task_works)
+		__set_current_state(TASK_RUNNING);
-			task_work_run();
+		tracehook_notify_signal();
-		clear_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL);
+		return true;
 	}
+	return false;
 }
 static void io_assign_current_work(struct io_worker *worker,
 	worker->flags |= (IO_WORKER_F_UP | IO_WORKER_F_RUNNING);
 	io_wqe_inc_running(worker);
-	sprintf(buf, "iou-wrk-%d", wq->task_pid);
+	snprintf(buf, sizeof(buf), "iou-wrk-%d", wq->task_pid);
 	set_task_comm(current, buf);
 	while (!test_bit(IO_WQ_BIT_EXIT, &wq->state)) {
+		long ret;
 		set_current_state(TASK_INTERRUPTIBLE);
 loop:
 		raw_spin_lock_irq(&wqe->lock);
 		}
 		__io_worker_idle(wqe, worker);
 		raw_spin_unlock_irq(&wqe->lock);
-		io_flush_signals();
+		if (io_flush_signals())
-		if (schedule_timeout(WORKER_IDLE_TIMEOUT))
 			continue;
-		if (fatal_signal_pending(current))
+		ret = schedule_timeout(WORKER_IDLE_TIMEOUT);
+		if (signal_pending(current)) {
+			struct ksignal ksig;
+			if (!get_signal(&ksig))
+				continue;
 			break;
+		}
+		if (ret)
+			continue;
 		/* timed out, exit unless we're the fixed worker */
 		if (test_bit(IO_WQ_BIT_EXIT, &wq->state) ||
 		    !(worker->flags & IO_WORKER_F_FIXED))
 	char buf[TASK_COMM_LEN];
 	int node;
-	sprintf(buf, "iou-mgr-%d", wq->task_pid);
+	snprintf(buf, sizeof(buf), "iou-mgr-%d", wq->task_pid);
 	set_task_comm(current, buf);
 	do {
 		set_current_state(TASK_INTERRUPTIBLE);
 		io_wq_check_workers(wq);
 		schedule_timeout(HZ);
-		if (fatal_signal_pending(current))
+		if (signal_pending(current)) {
+			struct ksignal ksig;
+			if (!get_signal(&ksig))
+				continue;
 			set_bit(IO_WQ_BIT_EXIT, &wq->state);
+		}
 	} while (!test_bit(IO_WQ_BIT_EXIT, &wq->state));
 	io_wq_check_workers(wq);
 	for_each_node(node) {
 		struct io_wqe *wqe = wq->wqes[node];
-		WARN_ON_ONCE(!wq_list_empty(&wqe->work_list));
+		struct io_cb_cancel_data match = {
+			.fn		= io_wq_work_match_all,
+			.cancel_all	= true,
+		};
+		io_wqe_cancel_pending_work(wqe, &match);
 		kfree(wqe);
 	}
 	io_wq_put_hash(wq->hash);

fs/io-wq.h+9−1

 #define INTERNAL_IO_WQ_H
 #include <linux/refcount.h>
-#include <linux/io_uring.h>
 struct io_wq;
 	IO_WQ_CANCEL_NOTFOUND,	/* work not found */
 };
+struct io_wq_work_node {
+	struct io_wq_work_node *next;
+};
+struct io_wq_work_list {
+	struct io_wq_work_node *first;
+	struct io_wq_work_node *last;
+};
 static inline void wq_list_add_after(struct io_wq_work_node *node,
 				     struct io_wq_work_node *pos,
 				     struct io_wq_work_list *list)

fs/io_uring.c+216−155

@@ -78,7 +78,6 @@ · 77 unmodified lines
78	#include <linux/task_work.h>	78	#include <linux/task_work.h>
79	#include <linux/pagemap.h>	79	#include <linux/pagemap.h>
80	#include <linux/io_uring.h>	80	#include <linux/io_uring.h>
81	#include <linux/freezer.h>
82		81
83	#define CREATE_TRACE_POINTS	82	#define CREATE_TRACE_POINTS
84	#include <trace/events/io_uring.h>	83	#include <trace/events/io_uring.h>
@@ -258,7 +257,8 @@ enum { · 173 unmodified lines
258		257
259	struct io_sq_data {	258	struct io_sq_data {
260	refcount_t refs;	259	refcount_t refs;
261	struct rw_semaphore rw_lock;	260	atomic_t park_pending;
		261	struct mutex lock;
262		262
263	/* ctx's that are using this sqd */	263	/* ctx's that are using this sqd */
264	struct list_head ctx_list;	264	struct list_head ctx_list;
@@ -273,6 +273,7 @@ struct io_sq_data { · 8 unmodified lines
273		273
274	unsigned long state;	274	unsigned long state;
275	struct completion exited;	275	struct completion exited;
		276	struct callback_head *park_task_work;
276	};	277	};
277		278
278	#define IO_IOPOLL_BATCH 8	279	#define IO_IOPOLL_BATCH 8
@@ -402,7 +403,7 @@ struct io_ring_ctx { · 123 unmodified lines
402	struct socket *ring_sock;	403	struct socket *ring_sock;
403	#endif	404	#endif
404		405
405	struct idr io_buffer_idr;	406	struct xarray io_buffers;
406		407
407	struct xarray personalities;	408	struct xarray personalities;
408	u32 pers_next;	409	u32 pers_next;
@@ -454,6 +455,22 @@ struct io_ring_ctx { · 45 unmodified lines
454	struct list_head tctx_list;	455	struct list_head tctx_list;
455	};	456	};
456		457
		458	struct io_uring_task {
		459	/* submission side */
		460	struct xarray xa;
		461	struct wait_queue_head wait;
		462	const struct io_ring_ctx *last;
		463	struct io_wq *io_wq;
		464	struct percpu_counter inflight;
		465	atomic_t in_idle;
		466	bool sqpoll;
		467
		468	spinlock_t task_lock;
		469	struct io_wq_work_list task_list;
		470	unsigned long task_state;
		471	struct callback_head task_work;
		472	};
		473
457	/*	474	/*
458	* First field must be the file pointer in all the	475	* First field must be the file pointer in all the
459	* iocb unions! See also 'struct kiocb' in <linux/fs.h>	476	* iocb unions! See also 'struct kiocb' in <linux/fs.h>
@@ -680,6 +697,7 @@ enum { · 220 unmodified lines
680	REQ_F_NO_FILE_TABLE_BIT,	697	REQ_F_NO_FILE_TABLE_BIT,
681	REQ_F_LTIMEOUT_ACTIVE_BIT,	698	REQ_F_LTIMEOUT_ACTIVE_BIT,
682	REQ_F_COMPLETE_INLINE_BIT,	699	REQ_F_COMPLETE_INLINE_BIT,
		700	REQ_F_REISSUE_BIT,
683		701
684	/* not a real bit, just to check we're not overflowing the space */	702	/* not a real bit, just to check we're not overflowing the space */
685	__REQ_F_LAST_BIT,	703	__REQ_F_LAST_BIT,
@@ -723,6 +741,8 @@ enum { · 37 unmodified lines
723	REQ_F_LTIMEOUT_ACTIVE = BIT(REQ_F_LTIMEOUT_ACTIVE_BIT),	741	REQ_F_LTIMEOUT_ACTIVE = BIT(REQ_F_LTIMEOUT_ACTIVE_BIT),
724	/* completion is deferred through io_comp_state */	742	/* completion is deferred through io_comp_state */
725	REQ_F_COMPLETE_INLINE = BIT(REQ_F_COMPLETE_INLINE_BIT),	743	REQ_F_COMPLETE_INLINE = BIT(REQ_F_COMPLETE_INLINE_BIT),
		744	/* caller should reissue async */
		745	REQ_F_REISSUE = BIT(REQ_F_REISSUE_BIT),
726	};	746	};
727		747
728	struct async_poll {	748	struct async_poll {
@@ -1077,8 +1097,6 @@ static bool io_match_task(struct io_kiocb *head, · 348 unmodified lines
1077	io_for_each_link(req, head) {	1097	io_for_each_link(req, head) {
1078	if (req->flags & REQ_F_INFLIGHT)	1098	if (req->flags & REQ_F_INFLIGHT)
1079	return true;	1099	return true;
1080	if (req->task->files == files)
1081	return true;
1082	}	1100	}
1083	return false;	1101	return false;
1084	}	1102	}
@@ -1135,7 +1153,7 @@ static struct io_ring_ctx io_ring_ctx_alloc(struct io_uring_params p) · 50 unmodified lines
1135	init_waitqueue_head(&ctx->cq_wait);	1153	init_waitqueue_head(&ctx->cq_wait);
1136	INIT_LIST_HEAD(&ctx->cq_overflow_list);	1154	INIT_LIST_HEAD(&ctx->cq_overflow_list);
1137	init_completion(&ctx->ref_comp);	1155	init_completion(&ctx->ref_comp);
1138	idr_init(&ctx->io_buffer_idr);	1156	xa_init_flags(&ctx->io_buffers, XA_FLAGS_ALLOC1);
1139	xa_init_flags(&ctx->personalities, XA_FLAGS_ALLOC1);	1157	xa_init_flags(&ctx->personalities, XA_FLAGS_ALLOC1);
1140	mutex_init(&ctx->uring_lock);	1158	mutex_init(&ctx->uring_lock);
1141	init_waitqueue_head(&ctx->wait);	1159	init_waitqueue_head(&ctx->wait);
@@ -1198,7 +1216,7 @@ static void io_prep_async_work(struct io_kiocb *req) · 56 unmodified lines
1198	if (req->flags & REQ_F_ISREG) {	1216	if (req->flags & REQ_F_ISREG) {
1199	if (def->hash_reg_file \|\| (ctx->flags & IORING_SETUP_IOPOLL))	1217	if (def->hash_reg_file \|\| (ctx->flags & IORING_SETUP_IOPOLL))
1200	io_wq_hash_work(&req->work, file_inode(req->file));	1218	io_wq_hash_work(&req->work, file_inode(req->file));
1201	} else {	1219	} else if (!req->file \|\| !S_ISBLK(file_inode(req->file)->i_mode)) {
1202	if (def->unbound_nonreg_file)	1220	if (def->unbound_nonreg_file)
1203	req->work.flags \|= IO_WQ_WORK_UNBOUND;	1221	req->work.flags \|= IO_WQ_WORK_UNBOUND;
1204	}	1222	}
@@ -1221,16 +1239,16 @@ static void io_queue_async_work(struct io_kiocb *req) · 16 unmodified lines
1221	BUG_ON(!tctx);	1239	BUG_ON(!tctx);
1222	BUG_ON(!tctx->io_wq);	1240	BUG_ON(!tctx->io_wq);
1223		1241
1224	trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
1225	&req->work, req->flags);
1226	/* init ->work of the whole link before punting */	1242	/* init ->work of the whole link before punting */
1227	io_prep_async_link(req);	1243	io_prep_async_link(req);
		1244	trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
		1245	&req->work, req->flags);
1228	io_wq_enqueue(tctx->io_wq, &req->work);	1246	io_wq_enqueue(tctx->io_wq, &req->work);
1229	if (link)	1247	if (link)
1230	io_queue_linked_timeout(link);	1248	io_queue_linked_timeout(link);
1231	}	1249	}
1232		1250
1233	static void io_kill_timeout(struct io_kiocb *req)	1251	static void io_kill_timeout(struct io_kiocb *req, int status)
1234	{	1252	{
1235	struct io_timeout_data *io = req->async_data;	1253	struct io_timeout_data *io = req->async_data;
1236	int ret;	1254	int ret;
@@ -1240,31 +1258,11 @@ static void io_kill_timeout(struct io_kiocb *req) · 3 unmodified lines
1240	atomic_set(&req->ctx->cq_timeouts,	1258	atomic_set(&req->ctx->cq_timeouts,
1241	atomic_read(&req->ctx->cq_timeouts) + 1);	1259	atomic_read(&req->ctx->cq_timeouts) + 1);
1242	list_del_init(&req->timeout.list);	1260	list_del_init(&req->timeout.list);
1243	io_cqring_fill_event(req, 0);	1261	io_cqring_fill_event(req, status);
1244	io_put_req_deferred(req, 1);	1262	io_put_req_deferred(req, 1);
1245	}	1263	}
1246	}	1264	}
1247		1265
1248	/*
1249	* Returns true if we found and killed one or more timeouts
1250	*/
1251	static bool io_kill_timeouts(struct io_ring_ctx ctx, struct task_struct tsk,
1252	struct files_struct *files)
1253	{
1254	struct io_kiocb req, tmp;
1255	int canceled = 0;
1256
1257	spin_lock_irq(&ctx->completion_lock);
1258	list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list) {
1259	if (io_match_task(req, tsk, files)) {
1260	io_kill_timeout(req);
1261	canceled++;
1262	}
1263	}
1264	spin_unlock_irq(&ctx->completion_lock);
1265	return canceled != 0;
1266	}
1267
1268	static void __io_queue_deferred(struct io_ring_ctx *ctx)	1266	static void __io_queue_deferred(struct io_ring_ctx *ctx)
1269	{	1267	{
1270	do {	1268	do {
@@ -1309,7 +1307,7 @@ static void io_flush_timeouts(struct io_ring_ctx *ctx) · 38 unmodified lines
1309	break;	1307	break;
1310		1308
1311	list_del_init(&req->timeout.list);	1309	list_del_init(&req->timeout.list);
1312	io_kill_timeout(req);	1310	io_kill_timeout(req, 0);
1313	} while (!list_empty(&ctx->timeout_list));	1311	} while (!list_empty(&ctx->timeout_list));
1314		1312
1315	ctx->cq_last_tm_flush = seq;	1313	ctx->cq_last_tm_flush = seq;
@@ -1550,14 +1548,17 @@ static void io_req_complete_post(struct io_kiocb *req, long res, · 234 unmodified lines
1550	io_put_task(req->task, 1);	1548	io_put_task(req->task, 1);
1551	list_add(&req->compl.list, &cs->locked_free_list);	1549	list_add(&req->compl.list, &cs->locked_free_list);
1552	cs->locked_free_nr++;	1550	cs->locked_free_nr++;
1553	} else	1551	} else {
1554	req = NULL;	1552	if (!percpu_ref_tryget(&ctx->refs))
		1553	req = NULL;
		1554	}
1555	io_commit_cqring(ctx);	1555	io_commit_cqring(ctx);
1556	spin_unlock_irqrestore(&ctx->completion_lock, flags);	1556	spin_unlock_irqrestore(&ctx->completion_lock, flags);
1557	io_cqring_ev_posted(ctx);
1558		1557
1559	if (req)	1558	if (req) {
		1559	io_cqring_ev_posted(ctx);
1560	percpu_ref_put(&ctx->refs);	1560	percpu_ref_put(&ctx->refs);
		1561	}
1561	}	1562	}
1562		1563
1563	static void io_req_complete_state(struct io_kiocb *req, long res,	1564	static void io_req_complete_state(struct io_kiocb *req, long res,
@@ -1925,17 +1926,44 @@ static int io_req_task_work_add(struct io_kiocb *req) · 361 unmodified lines
1925	return ret;	1926	return ret;
1926	}	1927	}
1927		1928
1928	static void io_req_task_work_add_fallback(struct io_kiocb *req,	1929	static bool io_run_task_work_head(struct callback_head **work_head)
1929	task_work_func_t cb)	1930	{
		1931	struct callback_head work, next;
		1932	bool executed = false;
		1933
		1934	do {
		1935	work = xchg(work_head, NULL);
		1936	if (!work)
		1937	break;
		1938
		1939	do {
		1940	next = work->next;
		1941	work->func(work);
		1942	work = next;
		1943	cond_resched();
		1944	} while (work);
		1945	executed = true;
		1946	} while (1);
		1947
		1948	return executed;
		1949	}
		1950
		1951	static void io_task_work_add_head(struct callback_head **work_head,
		1952	struct callback_head *task_work)
1930	{	1953	{
1931	struct io_ring_ctx *ctx = req->ctx;
1932	struct callback_head *head;	1954	struct callback_head *head;
1933		1955
1934	init_task_work(&req->task_work, cb);
1935	do {	1956	do {
1936	head = READ_ONCE(ctx->exit_task_work);	1957	head = READ_ONCE(*work_head);
1937	req->task_work.next = head;	1958	task_work->next = head;
1938	} while (cmpxchg(&ctx->exit_task_work, head, &req->task_work) != head);	1959	} while (cmpxchg(work_head, head, task_work) != head);
		1960	}
		1961
		1962	static void io_req_task_work_add_fallback(struct io_kiocb *req,
		1963	task_work_func_t cb)
		1964	{
		1965	init_task_work(&req->task_work, cb);
		1966	io_task_work_add_head(&req->ctx->exit_task_work, &req->task_work);
1939	}	1967	}
1940		1968
1941	static void __io_req_task_cancel(struct io_kiocb *req, int error)	1969	static void __io_req_task_cancel(struct io_kiocb *req, int error)
@@ -2451,6 +2479,11 @@ static bool io_rw_should_reissue(struct io_kiocb *req) · 509 unmodified lines
2451	return false;	2479	return false;
2452	return true;	2480	return true;
2453	}	2481	}
		2482	#else
		2483	static bool io_rw_should_reissue(struct io_kiocb *req)
		2484	{
		2485	return false;
		2486	}
2454	#endif	2487	#endif
2455		2488
2456	static bool io_rw_reissue(struct io_kiocb *req)	2489	static bool io_rw_reissue(struct io_kiocb *req)
@@ -2476,13 +2509,14 @@ static void __io_complete_rw(struct io_kiocb *req, long res, long res2, · 19 unmodified lines
2476	{	2509	{
2477	int cflags = 0;	2510	int cflags = 0;
2478		2511
2479	if ((res == -EAGAIN \|\| res == -EOPNOTSUPP) && io_rw_reissue(req))	2512	if (req->rw.kiocb.ki_flags & IOCB_WRITE)
		2513	kiocb_end_write(req);
		2514	if ((res == -EAGAIN \|\| res == -EOPNOTSUPP) && io_rw_should_reissue(req)) {
		2515	req->flags \|= REQ_F_REISSUE;
2480	return;	2516	return;
		2517	}
2481	if (res != req->result)	2518	if (res != req->result)
2482	req_set_fail_links(req);	2519	req_set_fail_links(req);
2483
2484	if (req->rw.kiocb.ki_flags & IOCB_WRITE)
2485	kiocb_end_write(req);
2486	if (req->flags & REQ_F_BUFFER_SELECTED)	2520	if (req->flags & REQ_F_BUFFER_SELECTED)
2487	cflags = io_put_rw_kbuf(req);	2521	cflags = io_put_rw_kbuf(req);
2488	__io_req_complete(req, issue_flags, res, cflags);	2522	__io_req_complete(req, issue_flags, res, cflags);
@@ -2843,7 +2877,7 @@ static struct io_buffer io_buffer_select(struct io_kiocb req, size_t *len, · 354 unmodified lines
2843		2877
2844	lockdep_assert_held(&req->ctx->uring_lock);	2878	lockdep_assert_held(&req->ctx->uring_lock);
2845		2879
2846	head = idr_find(&req->ctx->io_buffer_idr, bgid);	2880	head = xa_load(&req->ctx->io_buffers, bgid);
2847	if (head) {	2881	if (head) {
2848	if (!list_empty(&head->list)) {	2882	if (!list_empty(&head->list)) {
2849	kbuf = list_last_entry(&head->list, struct io_buffer,	2883	kbuf = list_last_entry(&head->list, struct io_buffer,
@@ -2851,7 +2885,7 @@ static struct io_buffer io_buffer_select(struct io_kiocb req, size_t *len, · 1 unmodified line
2851	list_del(&kbuf->list);	2885	list_del(&kbuf->list);
2852	} else {	2886	} else {
2853	kbuf = head;	2887	kbuf = head;
2854	idr_remove(&req->ctx->io_buffer_idr, bgid);	2888	xa_erase(&req->ctx->io_buffers, bgid);
2855	}	2889	}
2856	if (*len > kbuf->len)	2890	if (*len > kbuf->len)
2857	*len = kbuf->len;	2891	*len = kbuf->len;
@@ -3259,11 +3293,7 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 401 unmodified lines
3259		3293
3260	ret = io_iter_do_read(req, iter);	3294	ret = io_iter_do_read(req, iter);
3261		3295
3262	if (ret == -EIOCBQUEUED) {	3296	if (ret == -EAGAIN \|\| (req->flags & REQ_F_REISSUE)) {
3263	if (req->async_data)
3264	iov_iter_revert(iter, io_size - iov_iter_count(iter));
3265	goto out_free;
3266	} else if (ret == -EAGAIN) {
3267	/* IOPOLL retry should happen for io-wq threads */	3297	/* IOPOLL retry should happen for io-wq threads */
3268	if (!force_nonblock && !(req->ctx->flags & IORING_SETUP_IOPOLL))	3298	if (!force_nonblock && !(req->ctx->flags & IORING_SETUP_IOPOLL))
3269	goto done;	3299	goto done;
@@ -3273,6 +3303,8 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 3 unmodified lines
3273	/* some cases will consume bytes even on error returns */	3303	/* some cases will consume bytes even on error returns */
3274	iov_iter_revert(iter, io_size - iov_iter_count(iter));	3304	iov_iter_revert(iter, io_size - iov_iter_count(iter));
3275	ret = 0;	3305	ret = 0;
		3306	} else if (ret == -EIOCBQUEUED) {
		3307	goto out_free;
3276	} else if (ret <= 0 \|\| ret == io_size \|\| !force_nonblock \|\|	3308	} else if (ret <= 0 \|\| ret == io_size \|\| !force_nonblock \|\|
3277	(req->flags & REQ_F_NOWAIT) \|\| !(req->flags & REQ_F_ISREG)) {	3309	(req->flags & REQ_F_NOWAIT) \|\| !(req->flags & REQ_F_ISREG)) {
3278	/* read all, failed, already did sync or don't want to retry */	3310	/* read all, failed, already did sync or don't want to retry */
@@ -3385,6 +3417,9 @@ static int io_write(struct io_kiocb *req, unsigned int issue_flags) · 106 unmodified lines
3385	else	3417	else
3386	ret2 = -EINVAL;	3418	ret2 = -EINVAL;
3387		3419
		3420	if (req->flags & REQ_F_REISSUE)
		3421	ret2 = -EAGAIN;
		3422
3388	/*	3423	/*
3389	* Raw bdev writes will return -EOPNOTSUPP for IOCB_NOWAIT. Just	3424	* Raw bdev writes will return -EOPNOTSUPP for IOCB_NOWAIT. Just
3390	* retry them without IOCB_NOWAIT.	3425	* retry them without IOCB_NOWAIT.
@@ -3394,8 +3429,6 @@ static int io_write(struct io_kiocb *req, unsigned int issue_flags) · 3 unmodified lines
3394	/* no retry on NONBLOCK nor RWF_NOWAIT */	3429	/* no retry on NONBLOCK nor RWF_NOWAIT */
3395	if (ret2 == -EAGAIN && (req->flags & REQ_F_NOWAIT))	3430	if (ret2 == -EAGAIN && (req->flags & REQ_F_NOWAIT))
3396	goto done;	3431	goto done;
3397	if (ret2 == -EIOCBQUEUED && req->async_data)
3398	iov_iter_revert(iter, io_size - iov_iter_count(iter));
3399	if (!force_nonblock \|\| ret2 != -EAGAIN) {	3432	if (!force_nonblock \|\| ret2 != -EAGAIN) {
3400	/* IOPOLL retry should happen for io-wq threads */	3433	/* IOPOLL retry should happen for io-wq threads */
3401	if ((req->ctx->flags & IORING_SETUP_IOPOLL) && ret2 == -EAGAIN)	3434	if ((req->ctx->flags & IORING_SETUP_IOPOLL) && ret2 == -EAGAIN)
@@ -3892,7 +3925,7 @@ static int __io_remove_buffers(struct io_ring_ctx ctx, struct io_buffer buf, · 490 unmodified lines
3892	}	3925	}
3893	i++;	3926	i++;
3894	kfree(buf);	3927	kfree(buf);
3895	idr_remove(&ctx->io_buffer_idr, bgid);	3928	xa_erase(&ctx->io_buffers, bgid);
3896		3929
3897	return i;	3930	return i;
3898	}	3931	}
@@ -3910,7 +3943,7 @@ static int io_remove_buffers(struct io_kiocb *req, unsigned int issue_flags) · 11 unmodified lines
3910	lockdep_assert_held(&ctx->uring_lock);	3943	lockdep_assert_held(&ctx->uring_lock);
3911		3944
3912	ret = -ENOENT;	3945	ret = -ENOENT;
3913	head = idr_find(&ctx->io_buffer_idr, p->bgid);	3946	head = xa_load(&ctx->io_buffers, p->bgid);
3914	if (head)	3947	if (head)
3915	ret = __io_remove_buffers(ctx, head, p->bgid, p->nbufs);	3948	ret = __io_remove_buffers(ctx, head, p->bgid, p->nbufs);
3916	if (ret < 0)	3949	if (ret < 0)
@@ -3930,6 +3963,7 @@ static int io_remove_buffers(struct io_kiocb *req, unsigned int issue_flags) · 13 unmodified lines
3930	static int io_provide_buffers_prep(struct io_kiocb *req,	3963	static int io_provide_buffers_prep(struct io_kiocb *req,
3931	const struct io_uring_sqe *sqe)	3964	const struct io_uring_sqe *sqe)
3932	{	3965	{
		3966	unsigned long size;
3933	struct io_provide_buf *p = &req->pbuf;	3967	struct io_provide_buf *p = &req->pbuf;
3934	u64 tmp;	3968	u64 tmp;
3935		3969
@@ -3943,7 +3977,8 @@ static int io_provide_buffers_prep(struct io_kiocb *req, · 7 unmodified lines
3943	p->addr = READ_ONCE(sqe->addr);	3977	p->addr = READ_ONCE(sqe->addr);
3944	p->len = READ_ONCE(sqe->len);	3978	p->len = READ_ONCE(sqe->len);
3945		3979
3946	if (!access_ok(u64_to_user_ptr(p->addr), (p->len * p->nbufs)))	3980	size = (unsigned long)p->len * p->nbufs;
		3981	if (!access_ok(u64_to_user_ptr(p->addr), size))
3947	return -EFAULT;	3982	return -EFAULT;
3948		3983
3949	p->bgid = READ_ONCE(sqe->buf_group);	3984	p->bgid = READ_ONCE(sqe->buf_group);
@@ -3993,21 +4028,14 @@ static int io_provide_buffers(struct io_kiocb *req, unsigned int issue_flags) · 43 unmodified lines
3993		4028
3994	lockdep_assert_held(&ctx->uring_lock);	4029	lockdep_assert_held(&ctx->uring_lock);
3995		4030
3996	list = head = idr_find(&ctx->io_buffer_idr, p->bgid);	4031	list = head = xa_load(&ctx->io_buffers, p->bgid);
3997		4032
3998	ret = io_add_buffers(p, &head);	4033	ret = io_add_buffers(p, &head);
3999	if (ret < 0)	4034	if (ret >= 0 && !list) {
4000	goto out;	4035	ret = xa_insert(&ctx->io_buffers, p->bgid, head, GFP_KERNEL);
4001		4036	if (ret < 0)
4002	if (!list) {
4003	ret = idr_alloc(&ctx->io_buffer_idr, head, p->bgid, p->bgid + 1,
4004	GFP_KERNEL);
4005	if (ret < 0) {
4006	__io_remove_buffers(ctx, head, p->bgid, -1U);	4037	__io_remove_buffers(ctx, head, p->bgid, -1U);
4007	goto out;
4008	}
4009	}	4038	}
4010	out:
4011	if (ret < 0)	4039	if (ret < 0)
4012	req_set_fail_links(req);	4040	req_set_fail_links(req);
4013		4041
@@ -4345,6 +4373,7 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 331 unmodified lines
4345	struct io_async_msghdr iomsg, *kmsg;	4373	struct io_async_msghdr iomsg, *kmsg;
4346	struct socket *sock;	4374	struct socket *sock;
4347	unsigned flags;	4375	unsigned flags;
		4376	int min_ret = 0;
4348	int ret;	4377	int ret;
4349		4378
4350	sock = sock_from_file(req->file);	4379	sock = sock_from_file(req->file);
@@ -4359,12 +4388,15 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 8 unmodified lines
4359	kmsg = &iomsg;	4388	kmsg = &iomsg;
4360	}	4389	}
4361		4390
4362	flags = req->sr_msg.msg_flags;	4391	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4363	if (flags & MSG_DONTWAIT)	4392	if (flags & MSG_DONTWAIT)
4364	req->flags \|= REQ_F_NOWAIT;	4393	req->flags \|= REQ_F_NOWAIT;
4365	else if (issue_flags & IO_URING_F_NONBLOCK)	4394	else if (issue_flags & IO_URING_F_NONBLOCK)
4366	flags \|= MSG_DONTWAIT;	4395	flags \|= MSG_DONTWAIT;
4367		4396
		4397	if (flags & MSG_WAITALL)
		4398	min_ret = iov_iter_count(&kmsg->msg.msg_iter);
		4399
4368	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);	4400	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
4369	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)	4401	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)
4370	return io_setup_async_msg(req, kmsg);	4402	return io_setup_async_msg(req, kmsg);
@@ -4375,7 +4407,7 @@ static int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags) · 4 unmodified lines
4375	if (kmsg->free_iov)	4407	if (kmsg->free_iov)
4376	kfree(kmsg->free_iov);	4408	kfree(kmsg->free_iov);
4377	req->flags &= ~REQ_F_NEED_CLEANUP;	4409	req->flags &= ~REQ_F_NEED_CLEANUP;
4378	if (ret < 0)	4410	if (ret < min_ret)
4379	req_set_fail_links(req);	4411	req_set_fail_links(req);
4380	__io_req_complete(req, issue_flags, ret, 0);	4412	__io_req_complete(req, issue_flags, ret, 0);
4381	return 0;	4413	return 0;
@@ -4388,6 +4420,7 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 6 unmodified lines
4388	struct iovec iov;	4420	struct iovec iov;
4389	struct socket *sock;	4421	struct socket *sock;
4390	unsigned flags;	4422	unsigned flags;
		4423	int min_ret = 0;
4391	int ret;	4424	int ret;
4392		4425
4393	sock = sock_from_file(req->file);	4426	sock = sock_from_file(req->file);
@@ -4403,12 +4436,15 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 9 unmodified lines
4403	msg.msg_controllen = 0;	4436	msg.msg_controllen = 0;
4404	msg.msg_namelen = 0;	4437	msg.msg_namelen = 0;
4405		4438
4406	flags = req->sr_msg.msg_flags;	4439	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4407	if (flags & MSG_DONTWAIT)	4440	if (flags & MSG_DONTWAIT)
4408	req->flags \|= REQ_F_NOWAIT;	4441	req->flags \|= REQ_F_NOWAIT;
4409	else if (issue_flags & IO_URING_F_NONBLOCK)	4442	else if (issue_flags & IO_URING_F_NONBLOCK)
4410	flags \|= MSG_DONTWAIT;	4443	flags \|= MSG_DONTWAIT;
4411		4444
		4445	if (flags & MSG_WAITALL)
		4446	min_ret = iov_iter_count(&msg.msg_iter);
		4447
4412	msg.msg_flags = flags;	4448	msg.msg_flags = flags;
4413	ret = sock_sendmsg(sock, &msg);	4449	ret = sock_sendmsg(sock, &msg);
4414	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)	4450	if ((issue_flags & IO_URING_F_NONBLOCK) && ret == -EAGAIN)
@@ -4416,7 +4452,7 @@ static int io_send(struct io_kiocb *req, unsigned int issue_flags) · 1 unmodified line
4416	if (ret == -ERESTARTSYS)	4452	if (ret == -ERESTARTSYS)
4417	ret = -EINTR;	4453	ret = -EINTR;
4418		4454
4419	if (ret < 0)	4455	if (ret < min_ret)
4420	req_set_fail_links(req);	4456	req_set_fail_links(req);
4421	__io_req_complete(req, issue_flags, ret, 0);	4457	__io_req_complete(req, issue_flags, ret, 0);
4422	return 0;	4458	return 0;
@@ -4568,6 +4604,7 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 145 unmodified lines
4568	struct socket *sock;	4604	struct socket *sock;
4569	struct io_buffer *kbuf;	4605	struct io_buffer *kbuf;
4570	unsigned flags;	4606	unsigned flags;
		4607	int min_ret = 0;
4571	int ret, cflags = 0;	4608	int ret, cflags = 0;
4572	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	4609	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
4573		4610
@@ -4593,12 +4630,15 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 19 unmodified lines
4593	1, req->sr_msg.len);	4630	1, req->sr_msg.len);
4594	}	4631	}
4595		4632
4596	flags = req->sr_msg.msg_flags;	4633	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4597	if (flags & MSG_DONTWAIT)	4634	if (flags & MSG_DONTWAIT)
4598	req->flags \|= REQ_F_NOWAIT;	4635	req->flags \|= REQ_F_NOWAIT;
4599	else if (force_nonblock)	4636	else if (force_nonblock)
4600	flags \|= MSG_DONTWAIT;	4637	flags \|= MSG_DONTWAIT;
4601		4638
		4639	if (flags & MSG_WAITALL)
		4640	min_ret = iov_iter_count(&kmsg->msg.msg_iter);
		4641
4602	ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.umsg,	4642	ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.umsg,
4603	kmsg->uaddr, flags);	4643	kmsg->uaddr, flags);
4604	if (force_nonblock && ret == -EAGAIN)	4644	if (force_nonblock && ret == -EAGAIN)
@@ -4612,7 +4652,7 @@ static int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags) · 7 unmodified lines
4612	if (kmsg->free_iov)	4652	if (kmsg->free_iov)
4613	kfree(kmsg->free_iov);	4653	kfree(kmsg->free_iov);
4614	req->flags &= ~REQ_F_NEED_CLEANUP;	4654	req->flags &= ~REQ_F_NEED_CLEANUP;
4615	if (ret < 0)	4655	if (ret < min_ret \|\| ((flags & MSG_WAITALL) && (kmsg->msg.msg_flags & (MSG_TRUNC \| MSG_CTRUNC))))
4616	req_set_fail_links(req);	4656	req_set_fail_links(req);
4617	__io_req_complete(req, issue_flags, ret, cflags);	4657	__io_req_complete(req, issue_flags, ret, cflags);
4618	return 0;	4658	return 0;
@@ -4627,6 +4667,7 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 8 unmodified lines
4627	struct socket *sock;	4667	struct socket *sock;
4628	struct iovec iov;	4668	struct iovec iov;
4629	unsigned flags;	4669	unsigned flags;
		4670	int min_ret = 0;
4630	int ret, cflags = 0;	4671	int ret, cflags = 0;
4631	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	4672	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
4632		4673
@@ -4652,12 +4693,15 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 19 unmodified lines
4652	msg.msg_iocb = NULL;	4693	msg.msg_iocb = NULL;
4653	msg.msg_flags = 0;	4694	msg.msg_flags = 0;
4654		4695
4655	flags = req->sr_msg.msg_flags;	4696	flags = req->sr_msg.msg_flags \| MSG_NOSIGNAL;
4656	if (flags & MSG_DONTWAIT)	4697	if (flags & MSG_DONTWAIT)
4657	req->flags \|= REQ_F_NOWAIT;	4698	req->flags \|= REQ_F_NOWAIT;
4658	else if (force_nonblock)	4699	else if (force_nonblock)
4659	flags \|= MSG_DONTWAIT;	4700	flags \|= MSG_DONTWAIT;
4660		4701
		4702	if (flags & MSG_WAITALL)
		4703	min_ret = iov_iter_count(&msg.msg_iter);
		4704
4661	ret = sock_recvmsg(sock, &msg, flags);	4705	ret = sock_recvmsg(sock, &msg, flags);
4662	if (force_nonblock && ret == -EAGAIN)	4706	if (force_nonblock && ret == -EAGAIN)
4663	return -EAGAIN;	4707	return -EAGAIN;
@@ -4666,7 +4710,7 @@ static int io_recv(struct io_kiocb *req, unsigned int issue_flags) · 2 unmodified lines
4666	out_free:	4710	out_free:
4667	if (req->flags & REQ_F_BUFFER_SELECTED)	4711	if (req->flags & REQ_F_BUFFER_SELECTED)
4668	cflags = io_put_recv_kbuf(req);	4712	cflags = io_put_recv_kbuf(req);
4669	if (ret < 0)	4713	if (ret < min_ret \|\| ((flags & MSG_WAITALL) && (msg.msg_flags & (MSG_TRUNC \| MSG_CTRUNC))))
4670	req_set_fail_links(req);	4714	req_set_fail_links(req);
4671	__io_req_complete(req, issue_flags, ret, cflags);	4715	__io_req_complete(req, issue_flags, ret, cflags);
4672	return 0;	4716	return 0;
@@ -4763,7 +4807,6 @@ static int io_connect(struct io_kiocb *req, unsigned int issue_flags) · 90 unmodified lines
4763	ret = -ENOMEM;	4807	ret = -ENOMEM;
4764	goto out;	4808	goto out;
4765	}	4809	}
4766	io = req->async_data;
4767	memcpy(req->async_data, &__io, sizeof(__io));	4810	memcpy(req->async_data, &__io, sizeof(__io));
4768	return -EAGAIN;	4811	return -EAGAIN;
4769	}	4812	}
@@ -5526,7 +5569,8 @@ static int io_timeout_prep(struct io_kiocb req, const struct io_uring_sqe sqe, · 756 unmodified lines
5526		5569
5527	data->mode = io_translate_timeout_mode(flags);	5570	data->mode = io_translate_timeout_mode(flags);
5528	hrtimer_init(&data->timer, CLOCK_MONOTONIC, data->mode);	5571	hrtimer_init(&data->timer, CLOCK_MONOTONIC, data->mode);
5529	io_req_track_inflight(req);	5572	if (is_timeout_link)
		5573	io_req_track_inflight(req);
5530	return 0;	5574	return 0;
5531	}	5575	}
5532		5576
@@ -6129,6 +6173,7 @@ static void io_wq_submit_work(struct io_wq_work *work) · 596 unmodified lines
6129	ret = -ECANCELED;	6173	ret = -ECANCELED;
6130		6174
6131	if (!ret) {	6175	if (!ret) {
		6176	req->flags &= ~REQ_F_REISSUE;
6132	do {	6177	do {
6133	ret = io_issue_sqe(req, 0);	6178	ret = io_issue_sqe(req, 0);
6134	/*	6179	/*
@@ -6204,7 +6249,6 @@ static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer) · 69 unmodified lines
6204	spin_unlock_irqrestore(&ctx->completion_lock, flags);	6249	spin_unlock_irqrestore(&ctx->completion_lock, flags);
6205		6250
6206	if (prev) {	6251	if (prev) {
6207	req_set_fail_links(prev);
6208	io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);	6252	io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);
6209	io_put_req_deferred(prev, 1);	6253	io_put_req_deferred(prev, 1);
6210	} else {	6254	} else {
@@ -6423,8 +6467,6 @@ static int io_submit_sqe(struct io_ring_ctx ctx, struct io_kiocb req, · 212 unmodified lines
6423	ret = io_init_req(ctx, req, sqe);	6467	ret = io_init_req(ctx, req, sqe);
6424	if (unlikely(ret)) {	6468	if (unlikely(ret)) {
6425	fail_req:	6469	fail_req:
6426	io_put_req(req);
6427	io_req_complete(req, ret);
6428	if (link->head) {	6470	if (link->head) {
6429	/* fail even hard links since we don't submit */	6471	/* fail even hard links since we don't submit */
6430	link->head->flags \|= REQ_F_FAIL_LINK;	6472	link->head->flags \|= REQ_F_FAIL_LINK;
@@ -6432,6 +6474,8 @@ fail_req: · 1 unmodified line
6432	io_req_complete(link->head, -ECANCELED);	6474	io_req_complete(link->head, -ECANCELED);
6433	link->head = NULL;	6475	link->head = NULL;
6434	}	6476	}
		6477	io_put_req(req);
		6478	io_req_complete(req, ret);
6435	return ret;	6479	return ret;
6436	}	6480	}
6437	ret = io_req_prep(req, sqe);	6481	ret = io_req_prep(req, sqe);
@@ -6684,7 +6728,7 @@ static int io_sq_thread(void *data) · 246 unmodified lines
6684	char buf[TASK_COMM_LEN];	6728	char buf[TASK_COMM_LEN];
6685	DEFINE_WAIT(wait);	6729	DEFINE_WAIT(wait);
6686		6730
6687	sprintf(buf, "iou-sqp-%d", sqd->task_pid);	6731	snprintf(buf, sizeof(buf), "iou-sqp-%d", sqd->task_pid);
6688	set_task_comm(current, buf);	6732	set_task_comm(current, buf);
6689	current->pf_io_worker = NULL;	6733	current->pf_io_worker = NULL;
6690		6734
@@ -6694,22 +6738,30 @@ static int io_sq_thread(void *data) · 3 unmodified lines
6694	set_cpus_allowed_ptr(current, cpu_online_mask);	6738	set_cpus_allowed_ptr(current, cpu_online_mask);
6695	current->flags \|= PF_NO_SETAFFINITY;	6739	current->flags \|= PF_NO_SETAFFINITY;
6696		6740
6697	down_read(&sqd->rw_lock);	6741	mutex_lock(&sqd->lock);
6698
6699	while (!test_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state)) {	6742	while (!test_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state)) {
6700	int ret;	6743	int ret;
6701	bool cap_entries, sqt_spin, needs_sched;	6744	bool cap_entries, sqt_spin, needs_sched;
6702		6745
6703	if (test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state)) {	6746	if (test_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state) \|\|
6704	up_read(&sqd->rw_lock);	6747	signal_pending(current)) {
		6748	bool did_sig = false;
		6749
		6750	mutex_unlock(&sqd->lock);
		6751	if (signal_pending(current)) {
		6752	struct ksignal ksig;
		6753
		6754	did_sig = get_signal(&ksig);
		6755	}
6705	cond_resched();	6756	cond_resched();
6706	down_read(&sqd->rw_lock);	6757	mutex_lock(&sqd->lock);
		6758	if (did_sig)
		6759	break;
6707	io_run_task_work();	6760	io_run_task_work();
		6761	io_run_task_work_head(&sqd->park_task_work);
6708	timeout = jiffies + sqd->sq_thread_idle;	6762	timeout = jiffies + sqd->sq_thread_idle;
6709	continue;	6763	continue;
6710	}	6764	}
6711	if (fatal_signal_pending(current))
6712	break;
6713	sqt_spin = false;	6765	sqt_spin = false;
6714	cap_entries = !list_is_singular(&sqd->ctx_list);	6766	cap_entries = !list_is_singular(&sqd->ctx_list);
6715	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {	6767	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {
@@ -6750,32 +6802,27 @@ static int io_sq_thread(void *data) · 34 unmodified lines
6750	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6802	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6751	io_ring_set_wakeup_flag(ctx);	6803	io_ring_set_wakeup_flag(ctx);
6752		6804
6753	up_read(&sqd->rw_lock);	6805	mutex_unlock(&sqd->lock);
6754	schedule();	6806	schedule();
6755	down_read(&sqd->rw_lock);	6807	mutex_lock(&sqd->lock);
6756	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6808	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6757	io_ring_clear_wakeup_flag(ctx);	6809	io_ring_clear_wakeup_flag(ctx);
6758	}	6810	}
6759		6811
6760	finish_wait(&sqd->wait, &wait);	6812	finish_wait(&sqd->wait, &wait);
		6813	io_run_task_work_head(&sqd->park_task_work);
6761	timeout = jiffies + sqd->sq_thread_idle;	6814	timeout = jiffies + sqd->sq_thread_idle;
6762	}	6815	}
6763	up_read(&sqd->rw_lock);
6764	down_write(&sqd->rw_lock);
6765	/*
6766	* someone may have parked and added a cancellation task_work, run
6767	* it first because we don't want it in io_uring_cancel_sqpoll()
6768	*/
6769	io_run_task_work();
6770		6816
6771	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6817	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6772	io_uring_cancel_sqpoll(ctx);	6818	io_uring_cancel_sqpoll(ctx);
6773	sqd->thread = NULL;	6819	sqd->thread = NULL;
6774	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)	6820	list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
6775	io_ring_set_wakeup_flag(ctx);	6821	io_ring_set_wakeup_flag(ctx);
6776	up_write(&sqd->rw_lock);	6822	mutex_unlock(&sqd->lock);
6777		6823
6778	io_run_task_work();	6824	io_run_task_work();
		6825	io_run_task_work_head(&sqd->park_task_work);
6779	complete(&sqd->exited);	6826	complete(&sqd->exited);
6780	do_exit(0);	6827	do_exit(0);
6781	}	6828	}
@@ -6821,7 +6868,7 @@ static int io_run_task_work_sig(void) · 39 unmodified lines
6821	return 1;	6868	return 1;
6822	if (!signal_pending(current))	6869	if (!signal_pending(current))
6823	return 0;	6870	return 0;
6824	if (test_tsk_thread_flag(current, TIF_NOTIFY_SIGNAL))	6871	if (test_thread_flag(TIF_NOTIFY_SIGNAL))
6825	return -ERESTARTSYS;	6872	return -ERESTARTSYS;
6826	return -EINTR;	6873	return -EINTR;
6827	}	6874	}
@@ -7075,23 +7122,28 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) · 247 unmodified lines
7075	}	7122	}
7076		7123
7077	static void io_sq_thread_unpark(struct io_sq_data *sqd)	7124	static void io_sq_thread_unpark(struct io_sq_data *sqd)
7078	__releases(&sqd->rw_lock)	7125	__releases(&sqd->lock)
7079	{	7126	{
7080	WARN_ON_ONCE(sqd->thread == current);	7127	WARN_ON_ONCE(sqd->thread == current);
7081		7128
		7129	/*
		7130	* Do the dance but not conditional clear_bit() because it'd race with
		7131	* other threads incrementing park_pending and setting the bit.
		7132	*/
7082	clear_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);	7133	clear_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7083	up_write(&sqd->rw_lock);	7134	if (atomic_dec_return(&sqd->park_pending))
		7135	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
		7136	mutex_unlock(&sqd->lock);
7084	}	7137	}
7085		7138
7086	static void io_sq_thread_park(struct io_sq_data *sqd)	7139	static void io_sq_thread_park(struct io_sq_data *sqd)
7087	__acquires(&sqd->rw_lock)	7140	__acquires(&sqd->lock)
7088	{	7141	{
7089	WARN_ON_ONCE(sqd->thread == current);	7142	WARN_ON_ONCE(sqd->thread == current);
7090		7143
		7144	atomic_inc(&sqd->park_pending);
7091	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);	7145	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7092	down_write(&sqd->rw_lock);	7146	mutex_lock(&sqd->lock);
7093	/* set again for consistency, in case concurrent parks are happening */
7094	set_bit(IO_SQ_THREAD_SHOULD_PARK, &sqd->state);
7095	if (sqd->thread)	7147	if (sqd->thread)
7096	wake_up_process(sqd->thread);	7148	wake_up_process(sqd->thread);
7097	}	7149	}
@@ -7100,17 +7152,19 @@ static void io_sq_thread_stop(struct io_sq_data *sqd) · 2 unmodified lines
7100	{	7152	{
7101	WARN_ON_ONCE(sqd->thread == current);	7153	WARN_ON_ONCE(sqd->thread == current);
7102		7154
7103	down_write(&sqd->rw_lock);	7155	mutex_lock(&sqd->lock);
7104	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);	7156	set_bit(IO_SQ_THREAD_SHOULD_STOP, &sqd->state);
7105	if (sqd->thread)	7157	if (sqd->thread)
7106	wake_up_process(sqd->thread);	7158	wake_up_process(sqd->thread);
7107	up_write(&sqd->rw_lock);	7159	mutex_unlock(&sqd->lock);
7108	wait_for_completion(&sqd->exited);	7160	wait_for_completion(&sqd->exited);
7109	}	7161	}
7110		7162
7111	static void io_put_sq_data(struct io_sq_data *sqd)	7163	static void io_put_sq_data(struct io_sq_data *sqd)
7112	{	7164	{
7113	if (refcount_dec_and_test(&sqd->refs)) {	7165	if (refcount_dec_and_test(&sqd->refs)) {
		7166	WARN_ON_ONCE(atomic_read(&sqd->park_pending));
		7167
7114	io_sq_thread_stop(sqd);	7168	io_sq_thread_stop(sqd);
7115	kfree(sqd);	7169	kfree(sqd);
7116	}	7170	}
@@ -7184,9 +7238,10 @@ static struct io_sq_data io_get_sq_data(struct io_uring_params p, · 67 unmodified lines
7184	if (!sqd)	7238	if (!sqd)
7185	return ERR_PTR(-ENOMEM);	7239	return ERR_PTR(-ENOMEM);
7186		7240
		7241	atomic_set(&sqd->park_pending, 0);
7187	refcount_set(&sqd->refs, 1);	7242	refcount_set(&sqd->refs, 1);
7188	INIT_LIST_HEAD(&sqd->ctx_list);	7243	INIT_LIST_HEAD(&sqd->ctx_list);
7189	init_rwsem(&sqd->rw_lock);	7244	mutex_init(&sqd->lock);
7190	init_waitqueue_head(&sqd->wait);	7245	init_waitqueue_head(&sqd->wait);
7191	init_completion(&sqd->exited);	7246	init_completion(&sqd->exited);
7192	return sqd;	7247	return sqd;
@@ -7866,22 +7921,17 @@ static int io_sq_offload_create(struct io_ring_ctx *ctx, · 673 unmodified lines
7866		7921
7867	ret = 0;	7922	ret = 0;
7868	io_sq_thread_park(sqd);	7923	io_sq_thread_park(sqd);
		7924	list_add(&ctx->sqd_list, &sqd->ctx_list);
		7925	io_sqd_update_thread_idle(sqd);
7869	/* don't attach to a dying SQPOLL thread, would be racy */	7926	/* don't attach to a dying SQPOLL thread, would be racy */
7870	if (attached && !sqd->thread) {	7927	if (attached && !sqd->thread)
7871	ret = -ENXIO;	7928	ret = -ENXIO;
7872	} else {
7873	list_add(&ctx->sqd_list, &sqd->ctx_list);
7874	io_sqd_update_thread_idle(sqd);
7875	}
7876	io_sq_thread_unpark(sqd);	7929	io_sq_thread_unpark(sqd);
7877		7930
7878	if (ret < 0) {	7931	if (ret < 0)
7879	io_put_sq_data(sqd);	7932	goto err;
7880	ctx->sq_data = NULL;	7933	if (attached)
7881	return ret;
7882	} else if (attached) {
7883	return 0;	7934	return 0;
7884	}
7885		7935
7886	if (p->flags & IORING_SETUP_SQ_AFF) {	7936	if (p->flags & IORING_SETUP_SQ_AFF) {
7887	int cpu = p->sq_thread_cpu;	7937	int cpu = p->sq_thread_cpu;
@@ -8332,19 +8382,13 @@ static int io_eventfd_unregister(struct io_ring_ctx *ctx) · 444 unmodified lines
8332	return -ENXIO;	8382	return -ENXIO;
8333	}	8383	}
8334		8384
8335	static int __io_destroy_buffers(int id, void p, void data)
8336	{
8337	struct io_ring_ctx *ctx = data;
8338	struct io_buffer *buf = p;
8339
8340	__io_remove_buffers(ctx, buf, id, -1U);
8341	return 0;
8342	}
8343
8344	static void io_destroy_buffers(struct io_ring_ctx *ctx)	8385	static void io_destroy_buffers(struct io_ring_ctx *ctx)
8345	{	8386	{
8346	idr_for_each(&ctx->io_buffer_idr, __io_destroy_buffers, ctx);	8387	struct io_buffer *buf;
8347	idr_destroy(&ctx->io_buffer_idr);	8388	unsigned long index;
		8389
		8390	xa_for_each(&ctx->io_buffers, index, buf)
		8391	__io_remove_buffers(ctx, buf, index, -1U);
8348	}	8392	}
8349		8393
8350	static void io_req_cache_free(struct list_head list, struct task_struct tsk)	8394	static void io_req_cache_free(struct list_head list, struct task_struct tsk)
@@ -8386,11 +8430,13 @@ static void io_ring_ctx_free(struct io_ring_ctx *ctx) · 35 unmodified lines
8386	{	8430	{
8387	/*	8431	/*
8388	* Some may use context even when all refs and requests have been put,	8432	* Some may use context even when all refs and requests have been put,
8389	* and they are free to do so while still holding uring_lock, see	8433	* and they are free to do so while still holding uring_lock or
8390	* __io_req_task_submit(). Wait for them to finish.	8434	* completion_lock, see __io_req_task_submit(). Wait for them to finish.
8391	*/	8435	*/
8392	mutex_lock(&ctx->uring_lock);	8436	mutex_lock(&ctx->uring_lock);
8393	mutex_unlock(&ctx->uring_lock);	8437	mutex_unlock(&ctx->uring_lock);
		8438	spin_lock_irq(&ctx->completion_lock);
		8439	spin_unlock_irq(&ctx->completion_lock);
8394		8440
8395	io_sq_thread_finish(ctx);	8441	io_sq_thread_finish(ctx);
8396	io_sqe_buffers_unregister(ctx);	8442	io_sqe_buffers_unregister(ctx);
@@ -8478,26 +8524,9 @@ static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id) · 81 unmodified lines
8478	return -EINVAL;	8524	return -EINVAL;
8479	}	8525	}
8480		8526
8481	static bool io_run_ctx_fallback(struct io_ring_ctx *ctx)	8527	static inline bool io_run_ctx_fallback(struct io_ring_ctx *ctx)
8482	{	8528	{
8483	struct callback_head work, next;	8529	return io_run_task_work_head(&ctx->exit_task_work);
8484	bool executed = false;
8485
8486	do {
8487	work = xchg(&ctx->exit_task_work, NULL);
8488	if (!work)
8489	break;
8490
8491	do {
8492	next = work->next;
8493	work->func(work);
8494	work = next;
8495	cond_resched();
8496	} while (work);
8497	executed = true;
8498	} while (1);
8499
8500	return executed;
8501	}	8530	}
8502		8531
8503	struct io_tctx_exit {	8532	struct io_tctx_exit {
@@ -8529,6 +8558,14 @@ static void io_ring_exit_work(struct work_struct *work) · 25 unmodified lines
8529	struct io_tctx_node *node;	8558	struct io_tctx_node *node;
8530	int ret;	8559	int ret;
8531		8560
		8561	/* prevent SQPOLL from submitting new requests */
		8562	if (ctx->sq_data) {
		8563	io_sq_thread_park(ctx->sq_data);
		8564	list_del_init(&ctx->sqd_list);
		8565	io_sqd_update_thread_idle(ctx->sq_data);
		8566	io_sq_thread_unpark(ctx->sq_data);
		8567	}
		8568
8532	/*	8569	/*
8533	* If we're doing polled IO and end up having requests being	8570	* If we're doing polled IO and end up having requests being
8534	* submitted async (out-of-line), then completions can come in while	8571	* submitted async (out-of-line), then completions can come in while
@@ -8565,6 +8602,28 @@ static void io_ring_exit_work(struct work_struct *work) · 30 unmodified lines
8565	io_ring_ctx_free(ctx);	8602	io_ring_ctx_free(ctx);
8566	}	8603	}
8567		8604
		8605	/* Returns true if we found and killed one or more timeouts */
		8606	static bool io_kill_timeouts(struct io_ring_ctx ctx, struct task_struct tsk,
		8607	struct files_struct *files)
		8608	{
		8609	struct io_kiocb req, tmp;
		8610	int canceled = 0;
		8611
		8612	spin_lock_irq(&ctx->completion_lock);
		8613	list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list) {
		8614	if (io_match_task(req, tsk, files)) {
		8615	io_kill_timeout(req, -ECANCELED);
		8616	canceled++;
		8617	}
		8618	}
		8619	if (canceled != 0)
		8620	io_commit_cqring(ctx);
		8621	spin_unlock_irq(&ctx->completion_lock);
		8622	if (canceled != 0)
		8623	io_cqring_ev_posted(ctx);
		8624	return canceled != 0;
		8625	}
		8626
8568	static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)	8627	static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
8569	{	8628	{
8570	unsigned long index;	8629	unsigned long index;
@@ -8879,7 +8938,7 @@ static void io_sqpoll_cancel_sync(struct io_ring_ctx *ctx) · 308 unmodified lines
8879	if (task) {	8938	if (task) {
8880	init_completion(&work.completion);	8939	init_completion(&work.completion);
8881	init_task_work(&work.task_work, io_sqpoll_cancel_cb);	8940	init_task_work(&work.task_work, io_sqpoll_cancel_cb);
8882	WARN_ON_ONCE(task_work_add(task, &work.task_work, TWA_SIGNAL));	8941	io_task_work_add_head(&sqd->park_task_work, &work.task_work);
8883	wake_up_process(task);	8942	wake_up_process(task);
8884	}	8943	}
8885	io_sq_thread_unpark(sqd);	8944	io_sq_thread_unpark(sqd);
@@ -8956,6 +9015,8 @@ void __io_uring_task_cancel(void) · 70 unmodified lines
8956		9015
8957	/* make sure overflow events are dropped */	9016	/* make sure overflow events are dropped */
8958	atomic_inc(&tctx->in_idle);	9017	atomic_inc(&tctx->in_idle);
		9018	__io_uring_files_cancel(NULL);
		9019
8959	do {	9020	do {
8960	/* read completions before cancelations */	9021	/* read completions before cancelations */
8961	inflight = tctx_inflight(tctx);	9022	inflight = tctx_inflight(tctx);

fs/iomap/swapfile.c+10−0

@@ -170,6 +170,16 @@ int iomap_swapfile_activate(struct swap_info_struct *sis, · 169 unmodified lines
170	return ret;	170	return ret;
171	}	171	}
172		172
		173	/*
		174	* If this swapfile doesn't contain even a single page-aligned
		175	* contiguous range of blocks, reject this useless swapfile to
		176	* prevent confusion later on.
		177	*/
		178	if (isi.nr_pages == 0) {
		179	pr_warn("swapon: Cannot find a single usable page in file.\n");
		180	return -EINVAL;
		181	}
		182
173	*pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;	183	*pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;
174	sis->max = isi.nr_pages;	184	sis->max = isi.nr_pages;
175	sis->pages = isi.nr_pages - 1;	185	sis->pages = isi.nr_pages - 1;

fs/locks.c+0−3

@@ -1808,9 +1808,6 @@ check_conflicting_open(struct file *filp, const long arg, int flags) · 1807 unmodified lines
1808		1808
1809	if (flags & FL_LAYOUT)	1809	if (flags & FL_LAYOUT)
1810	return 0;	1810	return 0;
1811	if (flags & FL_DELEG)
1812	/* We leave these checks to the caller. */
1813	return 0;
1814		1811
1815	if (arg == F_RDLCK)	1812	if (arg == F_RDLCK)
1816	return inode_is_open_for_write(inode) ? -EAGAIN : 0;	1813	return inode_is_open_for_write(inode) ? -EAGAIN : 0;

fs/nfsd/Kconfig+1−0

@@ -73,6 +73,7 @@ config NFSD_V4 · 72 unmodified lines
73	select NFSD_V3	73	select NFSD_V3
74	select FS_POSIX_ACL	74	select FS_POSIX_ACL
75	select SUNRPC_GSS	75	select SUNRPC_GSS
		76	select CRYPTO
76	select CRYPTO_MD5	77	select CRYPTO_MD5
77	select CRYPTO_SHA256	78	select CRYPTO_SHA256
78	select GRACE_PERIOD	79	select GRACE_PERIOD

fs/nfsd/filecache.c+2−0

 			continue;
 		if (!nfsd_match_cred(nf->nf_cred, current_cred()))
 			continue;
+		if (!test_bit(NFSD_FILE_HASHED, &nf->nf_flags))
+			continue;
 		if (nfsd_file_get(nf) != NULL)
 			return nf;
 	}

fs/nfsd/nfs4callback.c+1−0

@@ -1189,6 +1189,7 @@ static void nfsd4_cb_done(struct rpc_task task, void calldata) · 1188 unmodified lines
1189	switch (task->tk_status) {	1189	switch (task->tk_status) {
1190	case -EIO:	1190	case -EIO:
1191	case -ETIMEDOUT:	1191	case -ETIMEDOUT:
		1192	case -EACCES:
1192	nfsd4_mark_cb_down(clp, task->tk_status);	1193	nfsd4_mark_cb_down(clp, task->tk_status);
1193	}	1194	}
1194	break;	1195	break;

fs/nfsd/nfs4proc.c+1−1

@@ -1302,7 +1302,7 @@ nfsd4_cleanup_inter_ssc(struct vfsmount ss_mnt, struct nfsd_file src, · 1301 unmodified lines
1302	struct nfsd_file *dst)	1302	struct nfsd_file *dst)
1303	{	1303	{
1304	nfs42_ssc_close(src->nf_file);	1304	nfs42_ssc_close(src->nf_file);
1305	/* 'src' is freed by nfsd4_do_async_copy */	1305	fput(src->nf_file);
1306	nfsd_file_put(dst);	1306	nfsd_file_put(dst);
1307	mntput(ss_mnt);	1307	mntput(ss_mnt);
1308	}	1308	}

fs/nfsd/nfs4state.c+15−40

 	return fl;
 }
-static int nfsd4_check_conflicting_opens(struct nfs4_client *clp,
-						struct nfs4_file *fp)
-{
-	struct nfs4_clnt_odstate *co;
-	struct file *f = fp->fi_deleg_file->nf_file;
-	struct inode *ino = locks_inode(f);
-	int writes = atomic_read(&ino->i_writecount);
-	if (fp->fi_fds[O_WRONLY])
-		writes--;
-	if (fp->fi_fds[O_RDWR])
-		writes--;
-	if (writes > 0)
-		return -EAGAIN;
-	spin_lock(&fp->fi_lock);
-	list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
-		if (co->co_client != clp) {
-			spin_unlock(&fp->fi_lock);
-			return -EAGAIN;
-		}
-	}
-	spin_unlock(&fp->fi_lock);
-	return 0;
-}
 static struct nfs4_delegation *
 nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
 		    struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
 	nf = find_readable_file(fp);
 	if (!nf) {
-		/*
+		/* We should always have a readable file here */
-		 * We probably could attempt another open and get a read
+		WARN_ON_ONCE(1);
-		 * delegation, but for now, don't bother until the
+		return ERR_PTR(-EBADF);
-		 * client actually sends us one.
-		 */
-		return ERR_PTR(-EAGAIN);
 	}
 	spin_lock(&state_lock);
 	spin_lock(&fp->fi_lock);
 	if (!fl)
 		goto out_clnt_odstate;
-	status = nfsd4_check_conflicting_opens(clp, fp);
-	if (status) {
-		locks_free_lock(fl);
-		goto out_clnt_odstate;
-	}
 	status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL);
 	if (fl)
 		locks_free_lock(fl);
 	if (status)
 		goto out_clnt_odstate;
-	status = nfsd4_check_conflicting_opens(clp, fp);
-	if (status)
-		goto out_clnt_odstate;
 	spin_lock(&state_lock);
 	spin_lock(&fp->fi_lock);
 				goto out_no_deleg;
 			if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
 				goto out_no_deleg;
+			/*
+			 * Also, if the file was opened for write or
+			 * create, there's a good chance the client's
+			 * about to write to it, resulting in an
+			 * immediate recall (since we don't support
+			 * write delegations):
+			 */
+			if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
+				goto out_no_deleg;
+			if (open->op_create == NFS4_OPEN_CREATE)
+				goto out_no_deleg;
 			break;
 		default:
 			goto out_no_deleg;
 	idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
 		cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
 		if (cps->cp_stateid.sc_type == NFS4_COPYNOTIFY_STID &&
-				cps->cpntf_time > cutoff)
+				cps->cpntf_time < cutoff)
 			_free_cpntf_state_locked(nn, cps);
 	}
 	spin_unlock(&nn->s2s_cp_lock);

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/select.c+4−6

@@ -1055,10 +1055,9 @@ static long do_restart_poll(struct restart_block *restart_block) · 1054 unmodified lines
1055		1055
1056	ret = do_sys_poll(ufds, nfds, to);	1056	ret = do_sys_poll(ufds, nfds, to);
1057		1057
1058	if (ret == -ERESTARTNOHAND) {	1058	if (ret == -ERESTARTNOHAND)
1059	restart_block->fn = do_restart_poll;	1059	ret = set_restart_fn(restart_block, do_restart_poll);
1060	ret = -ERESTART_RESTARTBLOCK;	1060
1061	}
1062	return ret;	1061	return ret;
1063	}	1062	}
1064		1063
@@ -1080,7 +1079,6 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, · 15 unmodified lines
1080	struct restart_block *restart_block;	1079	struct restart_block *restart_block;
1081		1080
1082	restart_block = &current->restart_block;	1081	restart_block = &current->restart_block;
1083	restart_block->fn = do_restart_poll;
1084	restart_block->poll.ufds = ufds;	1082	restart_block->poll.ufds = ufds;
1085	restart_block->poll.nfds = nfds;	1083	restart_block->poll.nfds = nfds;
1086		1084
@@ -1091,7 +1089,7 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds, · 4 unmodified lines
1091	} else	1089	} else
1092	restart_block->poll.has_timeout = 0;	1090	restart_block->poll.has_timeout = 0;
1093		1091
1094	ret = -ERESTART_RESTARTBLOCK;	1092	ret = set_restart_fn(restart_block, do_restart_poll);
1095	}	1093	}
1096	return ret;	1094	return ret;
1097	}	1095	}

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);
 	}

fs/xfs/xfs_inode.c+8−6

 	/*
 	 * Make sure that we have allocated dquot(s) on disk.
 	 */
-	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
+	error = xfs_qm_vop_dqalloc(dp, fsuid_into_mnt(mnt_userns),
-					XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			fsgid_into_mnt(mnt_userns), prid,
-					&udqp, &gdqp, &pdqp);
+			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			&udqp, &gdqp, &pdqp);
 	if (error)
 		return error;
 	/*
 	 * Make sure that we have allocated dquot(s) on disk.
 	 */
-	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
+	error = xfs_qm_vop_dqalloc(dp, fsuid_into_mnt(mnt_userns),
-				XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			fsgid_into_mnt(mnt_userns), prid,
-				&udqp, &gdqp, &pdqp);
+			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
+			&udqp, &gdqp, &pdqp);
 	if (error)
 		return error;

fs/xfs/xfs_itable.c+6−0

 	};
 	int			error;
+	if (breq->mnt_userns != &init_user_ns) {
+		xfs_warn_ratelimited(breq->mp,
+			"bulkstat not supported inside of idmapped mounts.");
+		return -EINVAL;
+	}
 	ASSERT(breq->icount == 1);
 	bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),

fs/xfs/xfs_mount.c+44−46

 	return xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
 }
+/*
+ * Flush and reclaim dirty inodes in preparation for unmount. Inodes and
+ * internal inode structures can be sitting in the CIL and AIL at this point,
+ * so we need to unpin them, write them back and/or reclaim them before unmount
+ * can proceed.
+ *
+ * An inode cluster that has been freed can have its buffer still pinned in
+ * memory because the transaction is still sitting in a iclog. The stale inodes
+ * on that buffer will be pinned to the buffer until the transaction hits the
+ * disk and the callbacks run. Pushing the AIL will skip the stale inodes and
+ * may never see the pinned buffer, so nothing will push out the iclog and
+ * unpin the buffer.
+ *
+ * Hence we need to force the log to unpin everything first. However, log
+ * forces don't wait for the discards they issue to complete, so we have to
+ * explicitly wait for them to complete here as well.
+ *
+ * Then we can tell the world we are unmounting so that error handling knows
+ * that the filesystem is going away and we should error out anything that we
+ * have been retrying in the background.  This will prevent never-ending
+ * retries in AIL pushing from hanging the unmount.
+ *
+ * Finally, we can push the AIL to clean all the remaining dirty objects, then
+ * reclaim the remaining inodes that are still in memory at this point in time.
+ */
+static void
+xfs_unmount_flush_inodes(
+	struct xfs_mount	*mp)
+{
+	xfs_log_force(mp, XFS_LOG_SYNC);
+	xfs_extent_busy_wait_all(mp);
+	flush_workqueue(xfs_discard_wq);
+	mp->m_flags |= XFS_MOUNT_UNMOUNTING;
+	xfs_ail_push_all_sync(mp->m_ail);
+	cancel_delayed_work_sync(&mp->m_reclaim_work);
+	xfs_reclaim_inodes(mp);
+	xfs_health_unmount(mp);
+}
 /*
  * This function does the following on an initial mount of a file system:
  *	- reads the superblock from disk and init the mount struct
 	/* Clean out dquots that might be in memory after quotacheck. */
 	xfs_qm_unmount(mp);
 	/*
-	 * Cancel all delayed reclaim work and reclaim the inodes directly.
+	 * Flush all inode reclamation work and flush the log.
 	 * We have to do this /after/ rtunmount and qm_unmount because those
 	 * two will have scheduled delayed reclaim for the rt/quota inodes.
 	 *
 	 * qm_unmount_quotas and therefore rely on qm_unmount to release the
 	 * quota inodes.
 	 */
-	cancel_delayed_work_sync(&mp->m_reclaim_work);
+	xfs_unmount_flush_inodes(mp);
-	xfs_reclaim_inodes(mp);
-	xfs_health_unmount(mp);
  out_log_dealloc:
-	mp->m_flags |= XFS_MOUNT_UNMOUNTING;
 	xfs_log_mount_cancel(mp);
  out_fail_wait:
 	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
 	xfs_rtunmount_inodes(mp);
 	xfs_irele(mp->m_rootip);
-	/*
+	xfs_unmount_flush_inodes(mp);
-	 * We can potentially deadlock here if we have an inode cluster
-	 * that has been freed has its buffer still pinned in memory because
-	 * the transaction is still sitting in a iclog. The stale inodes
-	 * on that buffer will be pinned to the buffer until the
-	 * transaction hits the disk and the callbacks run. Pushing the AIL will
-	 * skip the stale inodes and may never see the pinned buffer, so
-	 * nothing will push out the iclog and unpin the buffer. Hence we
-	 * need to force the log here to ensure all items are flushed into the
-	 * AIL before we go any further.
-	 */
-	xfs_log_force(mp, XFS_LOG_SYNC);
-	/*
-	 * Wait for all busy extents to be freed, including completion of
-	 * any discard operation.
-	 */
-	xfs_extent_busy_wait_all(mp);
-	flush_workqueue(xfs_discard_wq);
-	/*
-	 * We now need to tell the world we are unmounting. This will allow
-	 * us to detect that the filesystem is going away and we should error
-	 * out anything that we have been retrying in the background. This will
-	 * prevent neverending retries in AIL pushing from hanging the unmount.
-	 */
-	mp->m_flags |= XFS_MOUNT_UNMOUNTING;
-	/*
-	 * Flush all pending changes from the AIL.
-	 */
-	xfs_ail_push_all_sync(mp->m_ail);
-	/*
-	 * Reclaim all inodes. At this point there should be no dirty inodes and
-	 * none should be pinned or locked. Stop background inode reclaim here
-	 * if it is still running.
-	 */
-	cancel_delayed_work_sync(&mp->m_reclaim_work);
-	xfs_reclaim_inodes(mp);
-	xfs_health_unmount(mp);
 	xfs_qm_unmount(mp);

fs/xfs/xfs_symlink.c+2−1

 	/*
 	 * Make sure that we have allocated dquot(s) on disk.
 	 */
-	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
+	error = xfs_qm_vop_dqalloc(dp, fsuid_into_mnt(mnt_userns),
+			fsgid_into_mnt(mnt_userns), prid,
 			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
 			&udqp, &gdqp, &pdqp);
 	if (error)

fs/zonefs/super.c+87−14

@@ -165,6 +165,21 @@ static int zonefs_writepages(struct address_space *mapping, · 164 unmodified lines
165	return iomap_writepages(mapping, wbc, &wpc, &zonefs_writeback_ops);	165	return iomap_writepages(mapping, wbc, &wpc, &zonefs_writeback_ops);
166	}	166	}
167		167
		168	static int zonefs_swap_activate(struct swap_info_struct *sis,
		169	struct file swap_file, sector_t span)
		170	{
		171	struct inode *inode = file_inode(swap_file);
		172	struct zonefs_inode_info *zi = ZONEFS_I(inode);
		173
		174	if (zi->i_ztype != ZONEFS_ZTYPE_CNV) {
		175	zonefs_err(inode->i_sb,
		176	"swap file: not a conventional zone file\n");
		177	return -EINVAL;
		178	}
		179
		180	return iomap_swapfile_activate(sis, swap_file, span, &zonefs_iomap_ops);
		181	}
		182
168	static const struct address_space_operations zonefs_file_aops = {	183	static const struct address_space_operations zonefs_file_aops = {
169	.readpage = zonefs_readpage,	184	.readpage = zonefs_readpage,
170	.readahead = zonefs_readahead,	185	.readahead = zonefs_readahead,
@@ -177,6 +192,7 @@ static const struct address_space_operations zonefs_file_aops = { · 6 unmodified lines
177	.is_partially_uptodate = iomap_is_partially_uptodate,	192	.is_partially_uptodate = iomap_is_partially_uptodate,
178	.error_remove_page = generic_error_remove_page,	193	.error_remove_page = generic_error_remove_page,
179	.direct_IO = noop_direct_IO,	194	.direct_IO = noop_direct_IO,
		195	.swap_activate = zonefs_swap_activate,
180	};	196	};
181		197
182	static void zonefs_update_stats(struct inode *inode, loff_t new_isize)	198	static void zonefs_update_stats(struct inode *inode, loff_t new_isize)
@@ -727,6 +743,68 @@ out_release: · 544 unmodified lines
727	return ret;	743	return ret;
728	}	744	}
729		745
		746	/*
		747	* Do not exceed the LFS limits nor the file zone size. If pos is under the
		748	* limit it becomes a short access. If it exceeds the limit, return -EFBIG.
		749	*/
		750	static loff_t zonefs_write_check_limits(struct file *file, loff_t pos,
		751	loff_t count)
		752	{
		753	struct inode *inode = file_inode(file);
		754	struct zonefs_inode_info *zi = ZONEFS_I(inode);
		755	loff_t limit = rlimit(RLIMIT_FSIZE);
		756	loff_t max_size = zi->i_max_size;
		757
		758	if (limit != RLIM_INFINITY) {
		759	if (pos >= limit) {
		760	send_sig(SIGXFSZ, current, 0);
		761	return -EFBIG;
		762	}
		763	count = min(count, limit - pos);
		764	}
		765
		766	if (!(file->f_flags & O_LARGEFILE))
		767	max_size = min_t(loff_t, MAX_NON_LFS, max_size);
		768
		769	if (unlikely(pos >= max_size))
		770	return -EFBIG;
		771
		772	return min(count, max_size - pos);
		773	}
		774
		775	static ssize_t zonefs_write_checks(struct kiocb iocb, struct iov_iter from)
		776	{
		777	struct file *file = iocb->ki_filp;
		778	struct inode *inode = file_inode(file);
		779	struct zonefs_inode_info *zi = ZONEFS_I(inode);
		780	loff_t count;
		781
		782	if (IS_SWAPFILE(inode))
		783	return -ETXTBSY;
		784
		785	if (!iov_iter_count(from))
		786	return 0;
		787
		788	if ((iocb->ki_flags & IOCB_NOWAIT) && !(iocb->ki_flags & IOCB_DIRECT))
		789	return -EINVAL;
		790
		791	if (iocb->ki_flags & IOCB_APPEND) {
		792	if (zi->i_ztype != ZONEFS_ZTYPE_SEQ)
		793	return -EINVAL;
		794	mutex_lock(&zi->i_truncate_mutex);
		795	iocb->ki_pos = zi->i_wpoffset;
		796	mutex_unlock(&zi->i_truncate_mutex);
		797	}
		798
		799	count = zonefs_write_check_limits(file, iocb->ki_pos,
		800	iov_iter_count(from));
		801	if (count < 0)
		802	return count;
		803
		804	iov_iter_truncate(from, count);
		805	return iov_iter_count(from);
		806	}
		807
730	/*	808	/*
731	* Handle direct writes. For sequential zone files, this is the only possible	809	* Handle direct writes. For sequential zone files, this is the only possible
732	* write path. For these files, check that the user is issuing writes	810	* write path. For these files, check that the user is issuing writes
@@ -744,8 +822,7 @@ static ssize_t zonefs_file_dio_write(struct kiocb iocb, struct iov_iter from) · 11 unmodified lines
744	struct super_block *sb = inode->i_sb;	822	struct super_block *sb = inode->i_sb;
745	bool sync = is_sync_kiocb(iocb);	823	bool sync = is_sync_kiocb(iocb);
746	bool append = false;	824	bool append = false;
747	size_t count;	825	ssize_t ret, count;
748	ssize_t ret;
749		826
750	/*	827	/*
751	* For async direct IOs to sequential zone files, refuse IOCB_NOWAIT	828	* For async direct IOs to sequential zone files, refuse IOCB_NOWAIT
@@ -763,12 +840,11 @@ static ssize_t zonefs_file_dio_write(struct kiocb iocb, struct iov_iter from) · 11 unmodified lines
763	inode_lock(inode);	840	inode_lock(inode);
764	}	841	}
765		842
766	ret = generic_write_checks(iocb, from);	843	count = zonefs_write_checks(iocb, from);
767	if (ret <= 0)	844	if (count <= 0) {
		845	ret = count;
768	goto inode_unlock;	846	goto inode_unlock;
769		847	}
770	iov_iter_truncate(from, zi->i_max_size - iocb->ki_pos);
771	count = iov_iter_count(from);
772		848
773	if ((iocb->ki_pos \| count) & (sb->s_blocksize - 1)) {	849	if ((iocb->ki_pos \| count) & (sb->s_blocksize - 1)) {
774	ret = -EINVAL;	850	ret = -EINVAL;
@@ -828,12 +904,10 @@ static ssize_t zonefs_file_buffered_write(struct kiocb *iocb, · 53 unmodified lines
828	inode_lock(inode);	904	inode_lock(inode);
829	}	905	}
830		906
831	ret = generic_write_checks(iocb, from);	907	ret = zonefs_write_checks(iocb, from);
832	if (ret <= 0)	908	if (ret <= 0)
833	goto inode_unlock;	909	goto inode_unlock;
834		910
835	iov_iter_truncate(from, zi->i_max_size - iocb->ki_pos);
836
837	ret = iomap_file_buffered_write(iocb, from, &zonefs_iomap_ops);	911	ret = iomap_file_buffered_write(iocb, from, &zonefs_iomap_ops);
838	if (ret > 0)	912	if (ret > 0)
839	iocb->ki_pos += ret;	913	iocb->ki_pos += ret;
@@ -966,9 +1040,7 @@ static int zonefs_open_zone(struct inode *inode) · 126 unmodified lines
966		1040
967	mutex_lock(&zi->i_truncate_mutex);	1041	mutex_lock(&zi->i_truncate_mutex);
968		1042
969	zi->i_wr_refcnt++;	1043	if (!zi->i_wr_refcnt) {
970	if (zi->i_wr_refcnt == 1) {
971
972	if (atomic_inc_return(&sbi->s_open_zones) > sbi->s_max_open_zones) {	1044	if (atomic_inc_return(&sbi->s_open_zones) > sbi->s_max_open_zones) {
973	atomic_dec(&sbi->s_open_zones);	1045	atomic_dec(&sbi->s_open_zones);
974	ret = -EBUSY;	1046	ret = -EBUSY;
@@ -978,7 +1050,6 @@ static int zonefs_open_zone(struct inode *inode) · 3 unmodified lines
978	if (i_size_read(inode) < zi->i_max_size) {	1050	if (i_size_read(inode) < zi->i_max_size) {
979	ret = zonefs_zone_mgmt(inode, REQ_OP_ZONE_OPEN);	1051	ret = zonefs_zone_mgmt(inode, REQ_OP_ZONE_OPEN);
980	if (ret) {	1052	if (ret) {
981	zi->i_wr_refcnt--;
982	atomic_dec(&sbi->s_open_zones);	1053	atomic_dec(&sbi->s_open_zones);
983	goto unlock;	1054	goto unlock;
984	}	1055	}
@@ -986,6 +1057,8 @@ static int zonefs_open_zone(struct inode *inode) · 1 unmodified line
986	}	1057	}
987	}	1058	}
988		1059
		1060	zi->i_wr_refcnt++;
		1061
989	unlock:	1062	unlock:
990	mutex_unlock(&zi->i_truncate_mutex);	1063	mutex_unlock(&zi->i_truncate_mutex);
991		1064

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/drm/ttm/ttm_bo_api.h+4−2

 static inline void ttm_bo_unpin(struct ttm_buffer_object *bo)
 {
 	dma_resv_assert_held(bo->base.resv);
-	WARN_ON_ONCE(!bo->pin_count);
 	WARN_ON_ONCE(!kref_read(&bo->kref));
-	--bo->pin_count;
+	if (bo->pin_count)
+		--bo->pin_count;
+	else
+		WARN_ON_ONCE(true);
 }
 int ttm_mem_evict_first(struct ttm_bo_device *bdev,

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/amba/bus.h+11−0

@@ -105,8 +105,19 @@ extern struct bus_type amba_bustype; · 104 unmodified lines
105	#define amba_get_drvdata(d) dev_get_drvdata(&d->dev)	105	#define amba_get_drvdata(d) dev_get_drvdata(&d->dev)
106	#define amba_set_drvdata(d,p) dev_set_drvdata(&d->dev, p)	106	#define amba_set_drvdata(d,p) dev_set_drvdata(&d->dev, p)
107		107
		108	#ifdef CONFIG_ARM_AMBA
108	int amba_driver_register(struct amba_driver *);	109	int amba_driver_register(struct amba_driver *);
109	void amba_driver_unregister(struct amba_driver *);	110	void amba_driver_unregister(struct amba_driver *);
		111	#else
		112	static inline int amba_driver_register(struct amba_driver *drv)
		113	{
		114	return -EINVAL;
		115	}
		116	static inline void amba_driver_unregister(struct amba_driver *drv)
		117	{
		118	}
		119	#endif
		120
110	struct amba_device amba_device_alloc(const char , resource_size_t, size_t);	121	struct amba_device amba_device_alloc(const char , resource_size_t, size_t);
111	void amba_device_put(struct amba_device *);	122	void amba_device_put(struct amba_device *);
112	int amba_device_add(struct amba_device , struct resource );	123	int amba_device_add(struct amba_device , struct resource );

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/efi.h+4−2

  */
 typedef guid_t efi_guid_t __aligned(__alignof__(u32));
-#define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
+#define EFI_GUID(a, b, c, d...) (efi_guid_t){ {					\
-	GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)
+	(a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff,	\
+	(b) & 0xff, ((b) >> 8) & 0xff,						\
+	(c) & 0xff, ((c) >> 8) & 0xff, d } }
 /*
  * Generic EFI table header

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/io_uring.h+0−25

@@ -5,31 +5,6 @@ · 4 unmodified lines
5	#include <linux/sched.h>	5	#include <linux/sched.h>
6	#include <linux/xarray.h>	6	#include <linux/xarray.h>
7		7
8	struct io_wq_work_node {
9	struct io_wq_work_node *next;
10	};
11
12	struct io_wq_work_list {
13	struct io_wq_work_node *first;
14	struct io_wq_work_node *last;
15	};
16
17	struct io_uring_task {
18	/* submission side */
19	struct xarray xa;
20	struct wait_queue_head wait;
21	void *last;
22	void *io_wq;
23	struct percpu_counter inflight;
24	atomic_t in_idle;
25	bool sqpoll;
26
27	spinlock_t task_lock;
28	struct io_wq_work_list task_list;
29	unsigned long task_state;
30	struct callback_head task_work;
31	};
32
33	#if defined(CONFIG_IO_URING)	8	#if defined(CONFIG_IO_URING)
34	struct sock io_uring_get_socket(struct file file);	9	struct sock io_uring_get_socket(struct file file);
35	void __io_uring_task_cancel(void);	10	void __io_uring_task_cancel(void);

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/module.h+0−3

@@ -30,9 +30,6 @@ · 29 unmodified lines
30	#include <linux/percpu.h>	30	#include <linux/percpu.h>
31	#include <asm/module.h>	31	#include <asm/module.h>
32		32
33	/* Not Yet Implemented */
34	#define MODULE_SUPPORTED_DEVICE(name)
35
36	#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN	33	#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
37		34
38	struct modversion_info {	35	struct modversion_info {

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/restart_block.h+1−0

@@ -23,6 +23,7 @@ enum timespec_type { · 22 unmodified lines
23	* System call restart block.	23	* System call restart block.
24	*/	24	*/
25	struct restart_block {	25	struct restart_block {
		26	unsigned long arch_data;
26	long (fn)(struct restart_block );	27	long (fn)(struct restart_block );
27	union {	28	union {
28	/* For futex_wait and futex_wait_requeue_pi */	29	/* For futex_wait and futex_wait_requeue_pi */

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/sunrpc/svc_rdma.h+0−1

@@ -104,7 +104,6 @@ struct svcxprt_rdma { · 103 unmodified lines
104		104
105	wait_queue_head_t sc_send_wait; /* SQ exhaustion waitlist */	105	wait_queue_head_t sc_send_wait; /* SQ exhaustion waitlist */
106	unsigned long sc_flags;	106	unsigned long sc_flags;
107	u32 sc_pending_recvs;
108	struct list_head sc_read_complete_q;	107	struct list_head sc_read_complete_q;
109	struct work_struct sc_work;	108	struct work_struct sc_work;
110		109

include/linux/thread_info.h+13−0

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include <linux/types.h>	11	#include <linux/types.h>
12	#include <linux/bug.h>	12	#include <linux/bug.h>
13	#include <linux/restart_block.h>	13	#include <linux/restart_block.h>
		14	#include <linux/errno.h>
14		15
15	#ifdef CONFIG_THREAD_INFO_IN_TASK	16	#ifdef CONFIG_THREAD_INFO_IN_TASK
16	/*	17	/*
@@ -59,6 +60,18 @@ enum syscall_work_bit { · 42 unmodified lines
59		60
60	#ifdef __KERNEL__	61	#ifdef __KERNEL__
61		62
		63	#ifndef arch_set_restart_data
		64	#define arch_set_restart_data(restart) do { } while (0)
		65	#endif
		66
		67	static inline long set_restart_fn(struct restart_block *restart,
		68	long (fn)(struct restart_block ))
		69	{
		70	restart->fn = fn;
		71	arch_set_restart_data(restart);
		72	return -ERESTART_RESTARTBLOCK;
		73	}
		74
62	#ifndef THREAD_ALIGN	75	#ifndef THREAD_ALIGN
63	#define THREAD_ALIGN THREAD_SIZE	76	#define THREAD_ALIGN THREAD_SIZE
64	#endif	77	#endif

include/linux/usb_usual.h+2−0

@@ -86,6 +86,8 @@ · 85 unmodified lines
86	/* lies about caching, so always sync */ \	86	/* lies about caching, so always sync */ \
87	US_FLAG(NO_SAME, 0x40000000) \	87	US_FLAG(NO_SAME, 0x40000000) \
88	/* Cannot handle WRITE_SAME */ \	88	/* Cannot handle WRITE_SAME */ \
		89	US_FLAG(SENSE_AFTER_SYNC, 0x80000000) \
		90	/* Do REQUEST_SENSE after SYNCHRONIZE_CACHE */ \
89		91
90	#define US_FLAG(name, value) US_FL_##name = value ,	92	#define US_FLAG(name, value) US_FL_##name = value ,
91	enum { US_DO_ALL_FLAGS };	93	enum { US_DO_ALL_FLAGS };

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/vdpa.h+5−5

include/linux/virtio.h+0−2

@@ -132,8 +132,6 @@ bool is_virtio_device(struct device *dev); · 131 unmodified lines
132	void virtio_break_device(struct virtio_device *dev);	132	void virtio_break_device(struct virtio_device *dev);
133		133
134	void virtio_config_changed(struct virtio_device *dev);	134	void virtio_config_changed(struct virtio_device *dev);
135	void virtio_config_disable(struct virtio_device *dev);
136	void virtio_config_enable(struct virtio_device *dev);
137	int virtio_finalize_features(struct virtio_device *dev);	135	int virtio_finalize_features(struct virtio_device *dev);
138	#ifdef CONFIG_PM_SLEEP	136	#ifdef CONFIG_PM_SLEEP
139	int virtio_device_freeze(struct virtio_device *dev);	137	int virtio_device_freeze(struct virtio_device *dev);

include/linux/ww_mutex.h+3−2

@@ -173,9 +173,10 @@ static inline void ww_acquire_done(struct ww_acquire_ctx *ctx) · 172 unmodified lines
173	*/	173	*/
174	static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)	174	static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)
175	{	175	{
176	#ifdef CONFIG_DEBUG_MUTEXES	176	#ifdef CONFIG_DEBUG_LOCK_ALLOC
177	mutex_release(&ctx->dep_map, _THIS_IP_);	177	mutex_release(&ctx->dep_map, _THIS_IP_);
178		178	#endif
		179	#ifdef CONFIG_DEBUG_MUTEXES
179	DEBUG_LOCKS_WARN_ON(ctx->acquired);	180	DEBUG_LOCKS_WARN_ON(ctx->acquired);
180	if (!IS_ENABLED(CONFIG_PROVE_LOCKING))	181	if (!IS_ENABLED(CONFIG_PROVE_LOCKING))
181	/*	182	/*

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/trace/events/workqueue.h+3−3

@@ -30,7 +30,7 @@ TRACE_EVENT(workqueue_queue_work, · 29 unmodified lines
30	TP_STRUCT__entry(	30	TP_STRUCT__entry(
31	__field( void *, work )	31	__field( void *, work )
32	__field( void *, function)	32	__field( void *, function)
33	__field( const char *, workqueue)	33	__string( workqueue, pwq->wq->name)
34	__field( unsigned int, req_cpu )	34	__field( unsigned int, req_cpu )
35	__field( unsigned int, cpu )	35	__field( unsigned int, cpu )
36	),	36	),
@@ -38,13 +38,13 @@ TRACE_EVENT(workqueue_queue_work, · 1 unmodified line
38	TP_fast_assign(	38	TP_fast_assign(
39	__entry->work = work;	39	__entry->work = work;
40	__entry->function = work->func;	40	__entry->function = work->func;
41	__entry->workqueue = pwq->wq->name;	41	__assign_str(workqueue, pwq->wq->name);
42	__entry->req_cpu = req_cpu;	42	__entry->req_cpu = req_cpu;
43	__entry->cpu = pwq->pool->cpu;	43	__entry->cpu = pwq->pool->cpu;
44	),	44	),
45		45
46	TP_printk("work struct=%p function=%ps workqueue=%s req_cpu=%u cpu=%u",	46	TP_printk("work struct=%p function=%ps workqueue=%s req_cpu=%u cpu=%u",
47	__entry->work, __entry->function, __entry->workqueue,	47	__entry->work, __entry->function, __get_str(workqueue),
48	__entry->req_cpu, __entry->cpu)	48	__entry->req_cpu, __entry->cpu)
49	);	49	);
50		50

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/fuse.h+2−1

@@ -903,7 +903,8 @@ struct fuse_notify_retrieve_in { · 902 unmodified lines
903	};	903	};
904		904
905	/* Device ioctls: */	905	/* Device ioctls: */
906	#define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t)	906	#define FUSE_DEV_IOC_MAGIC 229
		907	#define FUSE_DEV_IOC_CLONE _IOR(FUSE_DEV_IOC_MAGIC, 0, uint32_t)
907		908
908	struct fuse_lseek_in {	909	struct fuse_lseek_in {
909	uint64_t fh;	910	uint64_t fh;

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−9

 	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));
-		tsk->flags |= PF_NOFREEZE;
-	}
-	return tsk;
 }
 /*

kernel/futex.c+1−2

 		goto out;
 	restart = &current->restart_block;
-	restart->fn = futex_wait_restart;
 	restart->futex.uaddr = uaddr;
 	restart->futex.val = val;
 	restart->futex.time = *abs_time;
 	restart->futex.bitset = bitset;
 	restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
-	ret = -ERESTART_RESTARTBLOCK;
+	ret = set_restart_fn(restart, futex_wait_restart);
 out:
 	if (to) {

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/irq/irq_sim.c+2−2

@@ -159,7 +159,7 @@ static const struct irq_domain_ops irq_sim_domain_ops = { · 158 unmodified lines
159	* irq_domain_create_sim - Create a new interrupt simulator irq_domain and	159	* irq_domain_create_sim - Create a new interrupt simulator irq_domain and
160	* allocate a range of dummy interrupts.	160	* allocate a range of dummy interrupts.
161	*	161	*
162	* @fnode: struct fwnode_handle to be associated with this domain.	162	* @fwnode: struct fwnode_handle to be associated with this domain.
163	* @num_irqs: Number of interrupts to allocate.	163	* @num_irqs: Number of interrupts to allocate.
164	*	164	*
165	* On success: return a new irq_domain object.	165	* On success: return a new irq_domain object.
@@ -228,7 +228,7 @@ static void devm_irq_domain_release_sim(struct device dev, void res) · 62 unmodified lines
228	* a managed device.	228	* a managed device.
229	*	229	*
230	* @dev: Device to initialize the simulator object for.	230	* @dev: Device to initialize the simulator object for.
231	* @fnode: struct fwnode_handle to be associated with this domain.	231	* @fwnode: struct fwnode_handle to be associated with this domain.
232	* @num_irqs: Number of interrupts to allocate	232	* @num_irqs: Number of interrupts to allocate
233	*	233	*
234	* On success: return a new irq_domain object.	234	* On success: return a new irq_domain object.

kernel/irq/manage.c+4−0

 	irqreturn_t ret;
 	local_bh_disable();
+	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
+		local_irq_disable();
 	ret = action->thread_fn(action->irq, action->dev_id);
 	if (ret == IRQ_HANDLED)
 		atomic_inc(&desc->threads_handled);
 	irq_finalize_oneshot(desc, action);
+	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
+		local_irq_enable();
 	local_bh_enable();
 	return ret;
 }

kernel/jump_label.c+8−0

@@ -407,6 +407,14 @@ static bool jump_label_can_update(struct jump_entry *entry, bool init) · 406 unmodified lines
407	return false;	407	return false;
408		408
409	if (!kernel_text_address(jump_entry_code(entry))) {	409	if (!kernel_text_address(jump_entry_code(entry))) {
		410	/*
		411	* This skips patching built-in __exit, which
		412	* is part of init_section_contains() but is
		413	* not part of kernel_text_address().
		414	*
		415	* Skipping built-in __exit is fine since it
		416	* will never be executed.
		417	*/
410	WARN_ONCE(!jump_entry_is_init(entry),	418	WARN_ONCE(!jump_entry_is_init(entry),
411	"can't patch jump_label at %pS",	419	"can't patch jump_label at %pS",
412	(void *)jump_entry_code(entry));	420	(void *)jump_entry_code(entry));

kernel/locking/mutex.c+14−11

  */
 static __always_inline bool
 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,
-		      const bool use_ww_ctx, struct mutex_waiter *waiter)
+		      struct mutex_waiter *waiter)
 {
 	if (!waiter) {
 		/*
 #else
 static __always_inline bool
 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,
-		      const bool use_ww_ctx, struct mutex_waiter *waiter)
+		      struct mutex_waiter *waiter)
 {
 	return false;
 }
 	struct ww_mutex *ww;
 	int ret;
+	if (!use_ww_ctx)
+		ww_ctx = NULL;
 	might_sleep();
 #ifdef CONFIG_DEBUG_MUTEXES
 #endif
 	ww = container_of(lock, struct ww_mutex, base);
-	if (use_ww_ctx && ww_ctx) {
+	if (ww_ctx) {
 		if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
 			return -EALREADY;
 	mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);
 	if (__mutex_trylock(lock) ||
-	    mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, NULL)) {
+	    mutex_optimistic_spin(lock, ww_ctx, NULL)) {
 		/* got the lock, yay! */
 		lock_acquired(&lock->dep_map, ip);
-		if (use_ww_ctx && ww_ctx)
+		if (ww_ctx)
 			ww_mutex_set_context_fastpath(ww, ww_ctx);
 		preempt_enable();
 		return 0;
 	 * After waiting to acquire the wait_lock, try again.
 	 */
 	if (__mutex_trylock(lock)) {
-		if (use_ww_ctx && ww_ctx)
+		if (ww_ctx)
 			__ww_mutex_check_waiters(lock, ww_ctx);
 		goto skip_wait;
 			goto err;
 		}
-		if (use_ww_ctx && ww_ctx) {
+		if (ww_ctx) {
 			ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx);
 			if (ret)
 				goto err;
 		 * ww_mutex needs to always recheck its position since its waiter
 		 * list is not FIFO ordered.
 		 */
-		if ((use_ww_ctx && ww_ctx) || !first) {
+		if (ww_ctx || !first) {
 			first = __mutex_waiter_is_first(lock, &waiter);
 			if (first)
 				__mutex_set_flag(lock, MUTEX_FLAG_HANDOFF);
 		 * or we must see its unlock and acquire.
 		 */
 		if (__mutex_trylock(lock) ||
-		    (first && mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, &waiter)))
+		    (first && mutex_optimistic_spin(lock, ww_ctx, &waiter)))
 			break;
 		spin_lock(&lock->wait_lock);
 acquired:
 	__set_current_state(TASK_RUNNING);
-	if (use_ww_ctx && ww_ctx) {
+	if (ww_ctx) {
 		/*
 		 * Wound-Wait; we stole the lock (!first_waiter), check the
 		 * waiters as anyone might want to wound us.
 	/* got the lock - cleanup and rejoice! */
 	lock_acquired(&lock->dep_map, ip);
-	if (use_ww_ctx && ww_ctx)
+	if (ww_ctx)
 		ww_mutex_lock_acquired(ww, ww_ctx);
 	spin_unlock(&lock->wait_lock);

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/reboot.c+0−2

 void kernel_restart(char *cmd)
 {
 	kernel_restart_prepare(cmd);
-	if (pm_power_off_prepare)
-		pm_power_off_prepare();
 	migrate_to_reboot_cpu();
 	syscore_shutdown();
 	if (!cmd)

kernel/signal.c+11−3

@@ -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
@@ -1096,7 +1096,7 @@ static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struc · 998 unmodified lines
1096	/*	1096	/*
1097	* Skip useless siginfo allocation for SIGKILL and kernel threads.	1097	* Skip useless siginfo allocation for SIGKILL and kernel threads.
1098	*/	1098	*/
1099	if ((sig == SIGKILL) \|\| (t->flags & (PF_KTHREAD \| PF_IO_WORKER)))	1099	if ((sig == SIGKILL) \|\| (t->flags & PF_KTHREAD))
1100	goto out_set;	1100	goto out_set;
1101		1101
1102	/*	1102	/*
@@ -2767,6 +2767,14 @@ relock: · 1664 unmodified lines
2767	do_coredump(&ksig->info);	2767	do_coredump(&ksig->info);
2768	}	2768	}
2769		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
2770	/*	2778	/*
2771	* Death signals, no core dump.	2779	* Death signals, no core dump.
2772	*/	2780	*/
@@ -2774,7 +2782,7 @@ relock: · 1 unmodified line
2774	/* NOTREACHED */	2782	/* NOTREACHED */
2775	}	2783	}
2776	spin_unlock_irq(&sighand->siglock);	2784	spin_unlock_irq(&sighand->siglock);
2777		2785	out:
2778	ksig->sig = signr;	2786	ksig->sig = signr;
2779		2787
2780	if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))	2788	if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))

kernel/static_call.c+24−18

 	return (void *)((long)site->addr + (long)&site->addr);
 }
+static inline unsigned long __static_call_key(const struct static_call_site *site)
+{
+	return (long)site->key + (long)&site->key;
+}
 static inline struct static_call_key *static_call_key(const struct static_call_site *site)
 {
-	return (struct static_call_key *)
+	return (void *)(__static_call_key(site) & ~STATIC_CALL_SITE_FLAGS);
-		(((long)site->key + (long)&site->key) & ~STATIC_CALL_SITE_FLAGS);
 }
 /* These assume the key is word-aligned. */
 static inline bool static_call_is_init(struct static_call_site *site)
 {
-	return ((long)site->key + (long)&site->key) & STATIC_CALL_SITE_INIT;
+	return __static_call_key(site) & STATIC_CALL_SITE_INIT;
 }
 static inline bool static_call_is_tail(struct static_call_site *site)
 {
-	return ((long)site->key + (long)&site->key) & STATIC_CALL_SITE_TAIL;
+	return __static_call_key(site) & STATIC_CALL_SITE_TAIL;
 }
 static inline void static_call_set_init(struct static_call_site *site)
 {
-	site->key = ((long)static_call_key(site) | STATIC_CALL_SITE_INIT) -
+	site->key = (__static_call_key(site) | STATIC_CALL_SITE_INIT) -
 		    (long)&site->key;
 }
 	};
 	for (site_mod = &first; site_mod; site_mod = site_mod->next) {
+		bool init = system_state < SYSTEM_RUNNING;
 		struct module *mod = site_mod->mod;
 		if (!site_mod->sites) {
 		if (mod) {
 			stop = mod->static_call_sites +
 			       mod->num_static_call_sites;
+			init = mod->state == MODULE_STATE_COMING;
 		}
 #endif
 		     site < stop && static_call_key(site) == key; site++) {
 			void *site_addr = static_call_addr(site);
-			if (static_call_is_init(site)) {
+			if (!init && static_call_is_init(site))
-				/*
+				continue;
-				 * Don't write to call sites which were in
-				 * initmem and have since been freed.
-				 */
-				if (!mod && system_state >= SYSTEM_RUNNING)
-					continue;
-				if (mod && !within_module_init((unsigned long)site_addr, mod))
-					continue;
-			}
 			if (!kernel_text_address((unsigned long)site_addr)) {
-				WARN_ONCE(1, "can't patch static call site at %pS",
+				/*
+				 * This skips patching built-in __exit, which
+				 * is part of init_section_contains() but is
+				 * not part of kernel_text_address().
+				 *
+				 * Skipping built-in __exit is fine since it
+				 * will never be executed.
+				 */
+				WARN_ONCE(!static_call_is_init(site),
+					  "can't patch static call site at %pS",
 					  site_addr);
 				continue;
 			}
 			arch_static_call_transform(site_addr, NULL, func,
-				static_call_is_tail(site));
+						   static_call_is_tail(site));
 		}
 	}
 	struct static_call_site *site;
 	for (site = start; site != stop; site++) {
-		unsigned long s_key = (long)site->key + (long)&site->key;
+		unsigned long s_key = __static_call_key(site);
 		unsigned long addr = s_key & ~STATIC_CALL_SITE_FLAGS;
 		unsigned long key;

kernel/time/alarmtimer.c+1−1

 	if (flags == TIMER_ABSTIME)
 		return -ERESTARTNOHAND;
-	restart->fn = alarm_timer_nsleep_restart;
 	restart->nanosleep.clockid = type;
 	restart->nanosleep.expires = exp;
+	set_restart_fn(restart, alarm_timer_nsleep_restart);
 	return ret;
 }

kernel/time/hrtimer.c+1−1

 	}
 	restart = &current->restart_block;
-	restart->fn = hrtimer_nanosleep_restart;
 	restart->nanosleep.clockid = t.timer.base->clockid;
 	restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
+	set_restart_fn(restart, hrtimer_nanosleep_restart);
 out:
 	destroy_hrtimer_on_stack(&t.timer);
 	return ret;

kernel/time/posix-cpu-timers.c+1−1

 		if (flags & TIMER_ABSTIME)
 			return -ERESTARTNOHAND;
-		restart_block->fn = posix_cpu_nsleep_restart;
 		restart_block->nanosleep.clockid = which_clock;
+		set_restart_fn(restart_block, posix_cpu_nsleep_restart);
 	}
 	return error;
 }

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/batman-adv/main.c+0−1

@@ -702,7 +702,6 @@ MODULE_LICENSE("GPL"); · 701 unmodified lines
702		702
703	MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);	703	MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
704	MODULE_DESCRIPTION(BATADV_DRIVER_DESC);	704	MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
705	MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
706	MODULE_VERSION(BATADV_SOURCE_VERSION);	705	MODULE_VERSION(BATADV_SOURCE_VERSION);
707	MODULE_ALIAS_RTNL_LINK("batadv");	706	MODULE_ALIAS_RTNL_LINK("batadv");
708	MODULE_ALIAS_GENL_FAMILY(BATADV_NL_NAME);	707	MODULE_ALIAS_GENL_FAMILY(BATADV_NL_NAME);

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

14 more lines aren’t shown here.

net/mac80211/ibss.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/mac80211/main.c+12−1

This diff is large: its 21 lines aren’t shown here.

net/mac80211/mlme.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/mac80211/rc80211_minstrel_ht.c+0−2

This diff is large: its 16 lines aren’t shown here.

net/mac80211/util.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/mptcp/options.c+14−10

This diff is large: its 75 lines aren’t shown here.

net/mptcp/protocol.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/mptcp/subflow.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/netfilter/nf_conntrack_netlink.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/netfilter/nf_conntrack_proto_gre.c+0−3

This diff is large: its 10 lines aren’t shown here.

net/netfilter/nf_flow_table_core.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/netfilter/nf_tables_api.c+21−1

This diff is large: its 65 lines aren’t shown here.

net/netfilter/x_tables.c+34−15

This diff is large: its 99 lines aren’t shown here.

net/openvswitch/conntrack.c+5−3

This diff is large: its 23 lines aren’t shown here.

net/openvswitch/conntrack.h+4−2

This diff is large: its 20 lines aren’t shown here.

net/openvswitch/flow.c+3−1

This diff is large: its 25 lines aren’t shown here.

net/qrtr/qrtr.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/sched/act_ct.c+4−2

This diff is large: its 27 lines aren’t shown here.

net/sched/cls_api.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/sched/cls_flower.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_choke.c+4−3

This diff is large: its 28 lines aren’t shown here.

net/sched/sch_gred.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_htb.c+13−6

This diff is large: its 60 lines aren’t shown here.

net/sched/sch_red.c+5−2

This diff is large: its 28 lines aren’t shown here.

net/sched/sch_sfq.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sctp/output.c+0−7

This diff is large: its 14 lines aren’t shown here.

net/sctp/outqueue.c+7−0

This diff is large: its 21 lines aren’t shown here.

net/sunrpc/auth_gss/svcauth_gss.c+7−4

This diff is large: its 30 lines aren’t shown here.

net/sunrpc/svc.c+4−2

This diff is large: its 27 lines aren’t shown here.

net/sunrpc/svc_xprt.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/sunrpc/xprtrdma/svc_rdma_backchannel.c+3−3

This diff is large: its 13 lines aren’t shown here.

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c+39−43

This diff is large: its 136 lines aren’t shown here.

net/tipc/node.c+8−3

This diff is large: its 26 lines aren’t shown here.

net/vmw_vsock/af_vsock.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/wireless/nl80211.c+8−4

This diff is large: its 47 lines aren’t shown here.

scripts/module.lds.S+2−0

This diff is large: its 16 lines aren’t shown here.

security/integrity/iint.c+8−0

This diff is large: its 15 lines aren’t shown here.

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

This diff is large: its 26 lines aren’t shown here.

security/selinux/selinuxfs.c+9−13

This diff is large: its 59 lines aren’t shown here.

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

This diff is large: its 145 lines aren’t shown here.

security/tomoyo/network.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/drivers/aloop.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/dummy.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/mtpav.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/mts64.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/pcsp/pcsp.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/portman2x4.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/serial-u16550.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/drivers/virmidi.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/firewire/dice/dice-stream.c+2−3

This diff is large: its 14 lines aren’t shown here.

sound/isa/ad1816a/ad1816a.c+0−7

This diff is large: its 14 lines aren’t shown here.

sound/isa/ad1848/ad1848.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/als100.c+0−11

This diff is large: its 18 lines aren’t shown here.

sound/isa/azt2320.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/isa/cmi8330.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/cs423x/cs4231.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/cs423x/cs4236.c+0−34

This diff is large: its 41 lines aren’t shown here.

sound/isa/es1688/es1688.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/isa/es18xx.c+1−9

This diff is large: its 19 lines aren’t shown here.

sound/isa/gus/gusclassic.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/gusextreme.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/gusmax.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/gus/interwave.c+0−6

This diff is large: its 15 lines aren’t shown here.

sound/isa/opl3sa2.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/isa/opti9xx/miro.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/opti9xx/opti92x-ad1848.c+0−6

This diff is large: its 18 lines aren’t shown here.

sound/isa/sb/jazz16.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/sb/sb16.c+0−8

This diff is large: its 17 lines aren’t shown here.

sound/isa/sb/sb8.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/isa/sc6000.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/isa/wavefront/wavefront.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/mips/sgio2audio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ad1889.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ali5451/ali5451.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/als300.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/als4000.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/atiixp.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/atiixp_modem.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/au88x0/au88x0.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/azt3328.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/bt87x.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/ca0106/ca0106_main.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/cmipci.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/cs4281.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/cs46xx/cs46xx.c+0−7

This diff is large: its 14 lines aren’t shown here.

sound/pci/cs5535audio/cs5535audio.c+0−1

This diff is large: its 5 lines aren’t shown here.

sound/pci/ctxfi/xfi.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/echoaudio/echoaudio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/emu10k1/emu10k1.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/emu10k1/emu10k1x.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ens1370.c+0−8

This diff is large: its 18 lines aren’t shown here.

sound/pci/es1938.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/es1968.c+0−4

This diff is large: its 11 lines aren’t shown here.

sound/pci/fm801.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/hda/hda_generic.c+1−1

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 66 lines aren’t shown here.

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

This diff is large: its 73 lines aren’t shown here.

sound/pci/ice1712/ice1712.c+0−6

This diff is large: its 13 lines aren’t shown here.

sound/pci/ice1712/ice1724.c+0−19

This diff is large: its 26 lines aren’t shown here.

sound/pci/intel8x0.c+0−23

This diff is large: its 30 lines aren’t shown here.

sound/pci/intel8x0m.c+0−15

This diff is large: its 22 lines aren’t shown here.

sound/pci/korg1212/korg1212.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/lola/lola.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/lx6464es/lx6464es.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/maestro3.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/pci/mixart/mixart.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/nm256/nm256.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/oxygen/oxygen.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/pci/oxygen/se6x.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/oxygen/virtuoso.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/pcxhr/pcxhr.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/riptide/riptide.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme32.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme96.c+0−5

This diff is large: its 12 lines aren’t shown here.

sound/pci/rme9652/hdsp.c+0−3

This diff is large: its 10 lines aren’t shown here.

sound/pci/rme9652/hdspm.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/rme9652/rme9652.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/pci/sis7019.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/sonicvibes.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/trident/trident.c+0−12

This diff is large: its 19 lines aren’t shown here.

sound/pci/via82xx.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/via82xx_modem.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/vx222/vx222.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pci/ymfpci/ymfpci.c+0−6

This diff is large: its 13 lines aren’t shown here.

sound/pcmcia/pdaudiocf/pdaudiocf.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/pcmcia/vx/vxpocket.c+0−4

This diff is large: its 14 lines aren’t shown here.

sound/ppc/powermac.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sh/aica.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sh/sh_dac_audio.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/Kconfig+0−5

This diff is large: its 19 lines aren’t shown here.

sound/soc/codecs/ak4458.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/ak5558.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/cs42l42.c+34−78

This diff is large: its 195 lines aren’t shown here.

sound/soc/codecs/cs42l42.h+7−6

This diff is large: its 34 lines aren’t shown here.

sound/soc/codecs/es8316.c+2−7

This diff is large: its 16 lines aren’t shown here.

sound/soc/codecs/lpass-rx-macro.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/codecs/lpass-va-macro.c+13−15

This diff is large: its 52 lines aren’t shown here.

sound/soc/codecs/lpass-wsa-macro.c+11−9

This diff is large: its 49 lines aren’t shown here.

sound/soc/codecs/rt1015.c+2−0

This diff is large: its 16 lines aren’t shown here.

sound/soc/codecs/rt5640.c+2−2

This diff is large: its 12 lines aren’t shown here.

sound/soc/codecs/rt5651.c+2−2

This diff is large: its 12 lines aren’t shown here.

sound/soc/codecs/rt5659.c+5−0

This diff is large: its 18 lines aren’t shown here.

sound/soc/codecs/rt5670.c+96−14

This diff is large: its 157 lines aren’t shown here.

sound/soc/codecs/rt5670.h+5−4

This diff is large: its 25 lines aren’t shown here.

sound/soc/codecs/rt711.c+8−0

This diff is large: its 22 lines aren’t shown here.

sound/soc/codecs/sgtl5000.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/codecs/sirf-audio-codec.h+0−124

This diff is large: its 125 lines aren’t shown here.

sound/soc/codecs/wcd934x.c+6−0

This diff is large: its 13 lines aren’t shown here.

sound/soc/fsl/fsl_ssi.c+4−2

This diff is large: its 22 lines aren’t shown here.

sound/soc/generic/simple-card-utils.c+7−6

This diff is large: its 23 lines aren’t shown here.

sound/soc/intel/boards/bytcr_rt5640.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/mediatek/mt8192/mt8192-dai-tdm.c+3−1

This diff is large: its 11 lines aren’t shown here.

sound/soc/mediatek/mt8192/mt8192-reg.h+5−3

This diff is large: its 22 lines aren’t shown here.

sound/soc/qcom/lpass-cpu.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/qcom/sdm845.c+3−3

This diff is large: its 22 lines aren’t shown here.

sound/soc/soc-core.c+4−0

This diff is large: its 18 lines aren’t shown here.

sound/soc/sof/intel/hda-dsp.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/sof/intel/hda.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/sparc/amd7930.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sparc/cs4231.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/sparc/dbri.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/6fire/chip.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/caiaq/device.c+0−14

This diff is large: its 21 lines aren’t shown here.

sound/usb/card.c+0−2

This diff is large: its 9 lines aren’t shown here.

sound/usb/hiface/chip.c+0−17

This diff is large: its 24 lines aren’t shown here.

sound/usb/misc/ua101.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/usb/mixer_quirks.c+2−2

This diff is large: its 18 lines aren’t shown here.

sound/usb/quirks.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/usb/usx2y/usbusx2y.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/x86/intel_hdmi_audio.c+0−1

This diff is large: its 5 lines aren’t shown here.

sound/xen/xen_snd_front.c+0−1

This diff is large: its 5 lines aren’t shown here.

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

This diff is large: its 33 lines aren’t shown here.

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

This diff is large: its 8 lines aren’t shown here.

tools/lib/bpf/Makefile+1−1

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 10 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 117 lines aren’t shown here.

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

This diff is large: its 23 lines aren’t shown here.

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

This diff is large: its 6 lines aren’t shown here.

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

This diff is large: its 11 lines aren’t shown here.

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

This diff is large: its 36 lines aren’t shown here.

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

This diff is large: its 10 lines aren’t shown here.

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

This diff is large: its 37 lines aren’t shown here.

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

This diff is large: its 8 lines aren’t shown here.

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

This diff is large: its 34 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 6 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 53 lines aren’t shown here.

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

Empty file deleted.

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

This diff is large: its 10 lines aren’t shown here.

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

This diff is large: its 14 lines aren’t shown here.

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

This diff is large: its 34 lines aren’t shown here.

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

This diff is large: its 18 lines aren’t shown here.

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

This diff is large: its 83 lines aren’t shown here.

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

This diff is large: its 22 lines aren’t shown here.

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

This diff is large: its 32 lines aren’t shown here.

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

This diff is large: its 103 lines aren’t shown here.

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

This diff is large: its 13 lines aren’t shown here.

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

This diff is large: its 103 lines aren’t shown here.

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

This diff is large: its 17 lines aren’t shown here.

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

This diff is large: its 29 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/value_ptr_arith.c+22−1

This diff is large: its 37 lines aren’t shown here.

tools/testing/selftests/kvm/.gitignore+3−0

This diff is large: its 14 lines aren’t shown here.

tools/testing/selftests/kvm/Makefile+3−0

This diff is large: its 16 lines aren’t shown here.

tools/testing/selftests/kvm/hardware_disable_test.c+5−5

This diff is large: its 38 lines aren’t shown here.

tools/testing/selftests/kvm/include/kvm_util.h+2−0

This diff is large: its 16 lines aren’t shown here.

tools/testing/selftests/kvm/lib/kvm_util.c+6−1

This diff is large: its 18 lines aren’t shown here.

tools/testing/selftests/kvm/lib/kvm_util_internal.h+0−2

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/get_msr_index_features.c+134−0

This diff is large: its 135 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/hyperv_clock.c+269−0

This diff is large: its 270 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/set_boot_cpu_id.c+166−0

This diff is large: its 167 lines aren’t shown here.

tools/testing/selftests/net/forwarding/vxlan_bridge_1d.sh+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/net/mptcp/mptcp_join.sh+20−10

This diff is large: its 71 lines aren’t shown here.

tools/testing/selftests/net/reuseaddr_ports_exhausted.c+16−16

This diff is large: its 42 lines aren’t shown here.

tools/testing/selftests/vm/Makefile+2−2

This diff is large: its 18 lines aren’t shown here.

@@ -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);

@@ -2863,7 +2863,7 @@ nvme_fc_create_io_queues(struct nvme_fc_ctrl *ctrl) · 2862 unmodified lines
2863	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));	2863	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));
2864	ctrl->tag_set.ops = &nvme_fc_mq_ops;	2864	ctrl->tag_set.ops = &nvme_fc_mq_ops;
2865	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;	2865	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;
2866	ctrl->tag_set.reserved_tags = 1; /* fabric connect */	2866	ctrl->tag_set.reserved_tags = NVMF_RESERVED_TAGS;
2867	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;	2867	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;
2868	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;	2868	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
2869	ctrl->tag_set.cmd_size =	2869	ctrl->tag_set.cmd_size =
@@ -3485,7 +3485,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts, · 615 unmodified lines
3485	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));	3485	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));
3486	ctrl->admin_tag_set.ops = &nvme_fc_admin_mq_ops;	3486	ctrl->admin_tag_set.ops = &nvme_fc_admin_mq_ops;
3487	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;	3487	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
3488	ctrl->admin_tag_set.reserved_tags = 2; /* fabric connect + Keep-Alive */	3488	ctrl->admin_tag_set.reserved_tags = NVMF_RESERVED_TAGS;
3489	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;	3489	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;
3490	ctrl->admin_tag_set.cmd_size =	3490	ctrl->admin_tag_set.cmd_size =
3491	struct_size((struct nvme_fcp_op_w_sgl *)NULL, priv,	3491	struct_size((struct nvme_fcp_op_w_sgl *)NULL, priv,

@@ -349,7 +349,7 @@ static int nvme_loop_configure_admin_queue(struct nvme_loop_ctrl *ctrl) · 348 unmodified lines
349	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));	349	memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));
350	ctrl->admin_tag_set.ops = &nvme_loop_admin_mq_ops;	350	ctrl->admin_tag_set.ops = &nvme_loop_admin_mq_ops;
351	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;	351	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
352	ctrl->admin_tag_set.reserved_tags = 2; /* connect + keep-alive */	352	ctrl->admin_tag_set.reserved_tags = NVMF_RESERVED_TAGS;
353	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;	353	ctrl->admin_tag_set.numa_node = ctrl->ctrl.numa_node;
354	ctrl->admin_tag_set.cmd_size = sizeof(struct nvme_loop_iod) +	354	ctrl->admin_tag_set.cmd_size = sizeof(struct nvme_loop_iod) +
355	NVME_INLINE_SG_CNT * sizeof(struct scatterlist);	355	NVME_INLINE_SG_CNT * sizeof(struct scatterlist);
@@ -520,7 +520,7 @@ static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) · 164 unmodified lines
520	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));	520	memset(&ctrl->tag_set, 0, sizeof(ctrl->tag_set));
521	ctrl->tag_set.ops = &nvme_loop_mq_ops;	521	ctrl->tag_set.ops = &nvme_loop_mq_ops;
522	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;	522	ctrl->tag_set.queue_depth = ctrl->ctrl.opts->queue_size;
523	ctrl->tag_set.reserved_tags = 1; /* fabric connect */	523	ctrl->tag_set.reserved_tags = NVMF_RESERVED_TAGS;
524	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;	524	ctrl->tag_set.numa_node = ctrl->ctrl.numa_node;
525	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;	525	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
526	ctrl->tag_set.cmd_size = sizeof(struct nvme_loop_iod) +	526	ctrl->tag_set.cmd_size = sizeof(struct nvme_loop_iod) +

@@ -250,20 +250,20 @@ struct vdpa_config_ops { · 249 unmodified lines
250		250
251	struct vdpa_device __vdpa_alloc_device(struct device parent,	251	struct vdpa_device __vdpa_alloc_device(struct device parent,
252	const struct vdpa_config_ops *config,	252	const struct vdpa_config_ops *config,
253	int nvqs, size_t size, const char *name);	253	size_t size, const char *name);
254		254
255	#define vdpa_alloc_device(dev_struct, member, parent, config, nvqs, name) \	255	#define vdpa_alloc_device(dev_struct, member, parent, config, name) \
256	container_of(__vdpa_alloc_device( \	256	container_of(__vdpa_alloc_device( \
257	parent, config, nvqs, \	257	parent, config, \
258	sizeof(dev_struct) + \	258	sizeof(dev_struct) + \
259	BUILD_BUG_ON_ZERO(offsetof( \	259	BUILD_BUG_ON_ZERO(offsetof( \
260	dev_struct, member)), name), \	260	dev_struct, member)), name), \
261	dev_struct, member)	261	dev_struct, member)
262		262
263	int vdpa_register_device(struct vdpa_device *vdev);	263	int vdpa_register_device(struct vdpa_device *vdev, int nvqs);
264	void vdpa_unregister_device(struct vdpa_device *vdev);	264	void vdpa_unregister_device(struct vdpa_device *vdev);
265		265
266	int _vdpa_register_device(struct vdpa_device *vdev);	266	int _vdpa_register_device(struct vdpa_device *vdev, int nvqs);
267	void _vdpa_unregister_device(struct vdpa_device *vdev);	267	void _vdpa_unregister_device(struct vdpa_device *vdev);
268		268
269	/**	269	/**