lael-labs/linux

.mailmap+2−0

 Greg Kroah-Hartman <greg@kroah.com>
 Greg Kurz <groug@kaod.org> <gkurz@linux.vnet.ibm.com>
 Gregory CLEMENT <gregory.clement@bootlin.com> <gregory.clement@free-electrons.com>
+Guo Ren <guoren@kernel.org> <guoren@linux.alibaba.com>
+Guo Ren <guoren@kernel.org> <ren_guo@c-sky.com>
 Gustavo Padovan <gustavo@las.ic.unicamp.br>
 Gustavo Padovan <padovan@profusion.mobi>
 Hanjun Guo <guohanjun@huawei.com> <hanjun.guo@linaro.org>

Documentation/devicetree/bindings/i2c/apple,i2c.yaml+4−4

@@ -20,9 +20,9 @@ allOf: · 19 unmodified lines
20		20
21	properties:	21	properties:
22	compatible:	22	compatible:
23	enum:	23	items:
24	- apple,t8103-i2c	24	- const: apple,t8103-i2c
25	- apple,i2c	25	- const: apple,i2c
26		26
27	reg:	27	reg:
28	maxItems: 1	28	maxItems: 1
@@ -51,7 +51,7 @@ unevaluatedProperties: false · 22 unmodified lines
51	examples:	51	examples:
52	- \|	52	- \|
53	i2c@35010000 {	53	i2c@35010000 {
54	compatible = "apple,t8103-i2c";	54	compatible = "apple,t8103-i2c", "apple,i2c";
55	reg = <0x35010000 0x4000>;	55	reg = <0x35010000 0x4000>;
56	interrupt-parent = <&aic>;	56	interrupt-parent = <&aic>;
57	interrupts = <0 627 4>;	57	interrupts = <0 627 4>;

Documentation/devicetree/bindings/iio/adc/samsung,exynos-adc.yaml+1−1

@@ -136,7 +136,7 @@ examples: · 135 unmodified lines
136	samsung,syscon-phandle = <&pmu_system_controller>;	136	samsung,syscon-phandle = <&pmu_system_controller>;
137		137
138	/* NTC thermistor is a hwmon device */	138	/* NTC thermistor is a hwmon device */
139	ncp15wb473 {	139	thermistor {
140	compatible = "murata,ncp15wb473";	140	compatible = "murata,ncp15wb473";
141	pullup-uv = <1800000>;	141	pullup-uv = <1800000>;
142	pullup-ohm = <47000>;	142	pullup-ohm = <47000>;

Documentation/devicetree/bindings/input/gpio-keys.yaml+1−1

@@ -142,7 +142,7 @@ examples: · 141 unmodified lines
142	down {	142	down {
143	label = "GPIO Key DOWN";	143	label = "GPIO Key DOWN";
144	linux,code = <108>;	144	linux,code = <108>;
145	interrupts = <1 IRQ_TYPE_LEVEL_HIGH 7>;	145	interrupts = <1 IRQ_TYPE_EDGE_FALLING>;
146	};	146	};
147	};	147	};
148		148

Documentation/devicetree/bindings/media/nxp,imx7-mipi-csi2.yaml+2−12

             properties:
               data-lanes:
+                description:
+                  Note that 'fsl,imx7-mipi-csi2' only supports up to 2 data lines.
                 items:
                   minItems: 1
                   maxItems: 4
             required:
               - data-lanes
-            allOf:
-              - if:
-                  properties:
-                    compatible:
-                      contains:
-                        const: fsl,imx7-mipi-csi2
-                then:
-                  properties:
-                    data-lanes:
-                      items:
-                        maxItems: 2
       port@1:
         $ref: /schemas/graph.yaml#/properties/port
         description:

Documentation/devicetree/bindings/net/ethernet-phy.yaml+8−0

@@ -91,6 +91,14 @@ properties: · 90 unmodified lines
91	compensate for the board being designed with the lanes	91	compensate for the board being designed with the lanes
92	swapped.	92	swapped.
93		93
		94	enet-phy-lane-no-swap:
		95	$ref: /schemas/types.yaml#/definitions/flag
		96	description:
		97	If set, indicates that PHY will disable swap of the
		98	TX/RX lanes. This property allows the PHY to work correcly after
		99	e.g. wrong bootstrap configuration caused by issues in PCB
		100	layout design.
		101
94	eee-broken-100tx:	102	eee-broken-100tx:
95	$ref: /schemas/types.yaml#/definitions/flag	103	$ref: /schemas/types.yaml#/definitions/flag
96	description:	104	description:

Documentation/devicetree/bindings/phy/xlnx,zynqmp-psgtr.yaml+1−1

@@ -29,7 +29,7 @@ properties: · 28 unmodified lines
29	- PHY_TYPE_PCIE	29	- PHY_TYPE_PCIE
30	- PHY_TYPE_SATA	30	- PHY_TYPE_SATA
31	- PHY_TYPE_SGMII	31	- PHY_TYPE_SGMII
32	- PHY_TYPE_USB	32	- PHY_TYPE_USB3
33	- description: The PHY instance	33	- description: The PHY instance
34	minimum: 0	34	minimum: 0
35	maximum: 1 # for DP, SATA or USB	35	maximum: 1 # for DP, SATA or USB

Documentation/devicetree/bindings/power/supply/bq25980.yaml+1−1

@@ -105,7 +105,7 @@ examples: · 104 unmodified lines
105	reg = <0x65>;	105	reg = <0x65>;
106	interrupt-parent = <&gpio1>;	106	interrupt-parent = <&gpio1>;
107	interrupts = <16 IRQ_TYPE_EDGE_FALLING>;	107	interrupts = <16 IRQ_TYPE_EDGE_FALLING>;
108	ti,watchdog-timer = <0>;	108	ti,watchdog-timeout-ms = <0>;
109	ti,sc-ocp-limit-microamp = <2000000>;	109	ti,sc-ocp-limit-microamp = <2000000>;
110	ti,sc-ovp-limit-microvolt = <17800000>;	110	ti,sc-ovp-limit-microvolt = <17800000>;
111	monitored-battery = <&bat>;	111	monitored-battery = <&bat>;

Documentation/devicetree/bindings/sound/wlf,wm8962.yaml+3−0

@@ -19,6 +19,9 @@ properties: · 18 unmodified lines
19	clocks:	19	clocks:
20	maxItems: 1	20	maxItems: 1
21		21
		22	interrupts:
		23	maxItems: 1
		24
22	"#sound-dai-cells":	25	"#sound-dai-cells":
23	const: 0	26	const: 0
24		27

Documentation/networking/device_drivers/ethernet/intel/ixgbe.rst+16−0

@@ -440,6 +440,22 @@ NOTE: For 82599-based network connections, if you are enabling jumbo frames in · 439 unmodified lines
440	a virtual function (VF), jumbo frames must first be enabled in the physical	440	a virtual function (VF), jumbo frames must first be enabled in the physical
441	function (PF). The VF MTU setting cannot be larger than the PF MTU.	441	function (PF). The VF MTU setting cannot be larger than the PF MTU.
442		442
		443	NBASE-T Support
		444	---------------
		445	The ixgbe driver supports NBASE-T on some devices. However, the advertisement
		446	of NBASE-T speeds is suppressed by default, to accommodate broken network
		447	switches which cannot cope with advertised NBASE-T speeds. Use the ethtool
		448	command to enable advertising NBASE-T speeds on devices which support it::
		449
		450	ethtool -s eth? advertise 0x1800000001028
		451
		452	On Linux systems with INTERFACES(5), this can be specified as a pre-up command
		453	in /etc/network/interfaces so that the interface is always brought up with
		454	NBASE-T support, e.g.::
		455
		456	iface eth? inet dhcp
		457	pre-up ethtool -s eth? advertise 0x1800000001028 \|\| true
		458
443	Generic Receive Offload, aka GRO	459	Generic Receive Offload, aka GRO
444	--------------------------------	460	--------------------------------
445	The driver supports the in-kernel software implementation of GRO. GRO has	461	The driver supports the in-kernel software implementation of GRO. GRO has

MAINTAINERS+16−8

@@ -3066,7 +3066,7 @@ F: Documentation/devicetree/bindings/phy/phy-ath79-usb.txt · 3065 unmodified lines
3066	F: drivers/phy/qualcomm/phy-ath79-usb.c	3066	F: drivers/phy/qualcomm/phy-ath79-usb.c
3067		3067
3068	ATHEROS ATH GENERIC UTILITIES	3068	ATHEROS ATH GENERIC UTILITIES
3069	M: Kalle Valo <kvalo@codeaurora.org>	3069	M: Kalle Valo <kvalo@kernel.org>
3070	L: linux-wireless@vger.kernel.org	3070	L: linux-wireless@vger.kernel.org
3071	S: Supported	3071	S: Supported
3072	F: drivers/net/wireless/ath/*	3072	F: drivers/net/wireless/ath/*
@@ -3081,7 +3081,7 @@ W: https://wireless.wiki.kernel.org/en/users/Drivers/ath5k · 8 unmodified lines
3081	F: drivers/net/wireless/ath/ath5k/	3081	F: drivers/net/wireless/ath/ath5k/
3082		3082
3083	ATHEROS ATH6KL WIRELESS DRIVER	3083	ATHEROS ATH6KL WIRELESS DRIVER
3084	M: Kalle Valo <kvalo@codeaurora.org>	3084	M: Kalle Valo <kvalo@kernel.org>
3085	L: linux-wireless@vger.kernel.org	3085	L: linux-wireless@vger.kernel.org
3086	S: Supported	3086	S: Supported
3087	W: https://wireless.wiki.kernel.org/en/users/Drivers/ath6kl	3087	W: https://wireless.wiki.kernel.org/en/users/Drivers/ath6kl
@@ -9329,7 +9329,6 @@ S: Maintained · 6241 unmodified lines
9329	F: drivers/iio/pressure/dps310.c	9329	F: drivers/iio/pressure/dps310.c
9330		9330
9331	INFINIBAND SUBSYSTEM	9331	INFINIBAND SUBSYSTEM
9332	M: Doug Ledford <dledford@redhat.com>
9333	M: Jason Gunthorpe <jgg@nvidia.com>	9332	M: Jason Gunthorpe <jgg@nvidia.com>
9334	L: linux-rdma@vger.kernel.org	9333	L: linux-rdma@vger.kernel.org
9335	S: Supported	9334	S: Supported
@@ -10280,9 +10279,9 @@ F: lib/Kconfig.kcsan · 944 unmodified lines
10280	F: scripts/Makefile.kcsan	10279	F: scripts/Makefile.kcsan
10281		10280
10282	KDUMP	10281	KDUMP
10283	M: Dave Young <dyoung@redhat.com>
10284	M: Baoquan He <bhe@redhat.com>	10282	M: Baoquan He <bhe@redhat.com>
10285	R: Vivek Goyal <vgoyal@redhat.com>	10283	R: Vivek Goyal <vgoyal@redhat.com>
		10284	R: Dave Young <dyoung@redhat.com>
10286	L: kexec@lists.infradead.org	10285	L: kexec@lists.infradead.org
10287	S: Maintained	10286	S: Maintained
10288	W: http://lse.sourceforge.net/kdump/	10287	W: http://lse.sourceforge.net/kdump/
@@ -13256,7 +13255,7 @@ F: include/uapi/linux/if_* · 2967 unmodified lines
13256	F: include/uapi/linux/netdevice.h	13255	F: include/uapi/linux/netdevice.h
13257		13256
13258	NETWORKING DRIVERS (WIRELESS)	13257	NETWORKING DRIVERS (WIRELESS)
13259	M: Kalle Valo <kvalo@codeaurora.org>	13258	M: Kalle Valo <kvalo@kernel.org>
13260	L: linux-wireless@vger.kernel.org	13259	L: linux-wireless@vger.kernel.org
13261	S: Maintained	13260	S: Maintained
13262	Q: http://patchwork.kernel.org/project/linux-wireless/list/	13261	Q: http://patchwork.kernel.org/project/linux-wireless/list/
@@ -15712,7 +15711,7 @@ T: git git://linuxtv.org/anttip/media_tree.git · 2449 unmodified lines
15712	F: drivers/media/tuners/qt1010*	15711	F: drivers/media/tuners/qt1010*
15713		15712
15714	QUALCOMM ATHEROS ATH10K WIRELESS DRIVER	15713	QUALCOMM ATHEROS ATH10K WIRELESS DRIVER
15715	M: Kalle Valo <kvalo@codeaurora.org>	15714	M: Kalle Valo <kvalo@kernel.org>
15716	L: ath10k@lists.infradead.org	15715	L: ath10k@lists.infradead.org
15717	S: Supported	15716	S: Supported
15718	W: https://wireless.wiki.kernel.org/en/users/Drivers/ath10k	15717	W: https://wireless.wiki.kernel.org/en/users/Drivers/ath10k
@@ -15720,7 +15719,7 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git · 1 unmodified line
15720	F: drivers/net/wireless/ath/ath10k/	15719	F: drivers/net/wireless/ath/ath10k/
15721		15720
15722	QUALCOMM ATHEROS ATH11K WIRELESS DRIVER	15721	QUALCOMM ATHEROS ATH11K WIRELESS DRIVER
15723	M: Kalle Valo <kvalo@codeaurora.org>	15722	M: Kalle Valo <kvalo@kernel.org>
15724	L: ath11k@lists.infradead.org	15723	L: ath11k@lists.infradead.org
15725	S: Supported	15724	S: Supported
15726	T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git	15725	T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
@@ -15786,6 +15785,15 @@ S: Maintained · 59 unmodified lines
15786	F: Documentation/devicetree/bindings/net/qcom,ethqos.txt	15785	F: Documentation/devicetree/bindings/net/qcom,ethqos.txt
15787	F: drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c	15786	F: drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c
15788		15787
		15788	QUALCOMM FASTRPC DRIVER
		15789	M: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
		15790	M: Amol Maheshwari <amahesh@qti.qualcomm.com>
		15791	L: linux-arm-msm@vger.kernel.org
		15792	S: Maintained
		15793	F: Documentation/devicetree/bindings/misc/qcom,fastrpc.txt
		15794	F: drivers/misc/fastrpc.c
		15795	F: include/uapi/misc/fastrpc.h
		15796
15789	QUALCOMM GENERIC INTERFACE I2C DRIVER	15797	QUALCOMM GENERIC INTERFACE I2C DRIVER
15790	M: Akash Asthana <akashast@codeaurora.org>	15798	M: Akash Asthana <akashast@codeaurora.org>
15791	M: Mukesh Savaliya <msavaliy@codeaurora.org>	15799	M: Mukesh Savaliya <msavaliy@codeaurora.org>
@@ -15892,7 +15900,7 @@ F: Documentation/devicetree/bindings/media/venus · 100 unmodified lines
15892	F: drivers/media/platform/qcom/venus/	15900	F: drivers/media/platform/qcom/venus/
15893		15901
15894	QUALCOMM WCN36XX WIRELESS DRIVER	15902	QUALCOMM WCN36XX WIRELESS DRIVER
15895	M: Kalle Valo <kvalo@codeaurora.org>	15903	M: Kalle Valo <kvalo@kernel.org>
15896	L: wcn36xx@lists.infradead.org	15904	L: wcn36xx@lists.infradead.org
15897	S: Supported	15905	S: Supported
15898	W: https://wireless.wiki.kernel.org/en/users/Drivers/wcn36xx	15906	W: https://wireless.wiki.kernel.org/en/users/Drivers/wcn36xx

Makefile+6−6

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 16	3	PATCHLEVEL = 16
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc4	5	EXTRAVERSION = -rc5
6	NAME = Gobble Gobble	6	NAME = Gobble Gobble
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION
@@ -1374,17 +1374,17 @@ endif · 1365 unmodified lines
1374		1374
1375	ifneq ($(dtstree),)	1375	ifneq ($(dtstree),)
1376		1376
1377	%.dtb: dt_binding_check include/config/kernel.release scripts_dtc	1377	%.dtb: include/config/kernel.release scripts_dtc
1378	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@ $(dtstree)/$*.dt.yaml	1378	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@
1379		1379
1380	%.dtbo: dt_binding_check include/config/kernel.release scripts_dtc	1380	%.dtbo: include/config/kernel.release scripts_dtc
1381	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@ $(dtstree)/$*.dt.yaml	1381	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@
1382		1382
1383	PHONY += dtbs dtbs_install dtbs_check	1383	PHONY += dtbs dtbs_install dtbs_check
1384	dtbs: include/config/kernel.release scripts_dtc	1384	dtbs: include/config/kernel.release scripts_dtc
1385	$(Q)$(MAKE) $(build)=$(dtstree)	1385	$(Q)$(MAKE) $(build)=$(dtstree)
1386		1386
1387	ifneq ($(filter dtbs_check %.dtb %.dtbo, $(MAKECMDGOALS)),)	1387	ifneq ($(filter dtbs_check, $(MAKECMDGOALS)),)
1388	export CHECK_DTBS=y	1388	export CHECK_DTBS=y
1389	dtbs: dt_binding_check	1389	dtbs: dt_binding_check
1390	endif	1390	endif

arch/arm/boot/dts/imx6qp-prtwd3.dts+2−0

@@ -178,6 +178,8 @@ · 177 unmodified lines
178	label = "cpu";	178	label = "cpu";
179	ethernet = <&fec>;	179	ethernet = <&fec>;
180	phy-mode = "rgmii-id";	180	phy-mode = "rgmii-id";
		181	rx-internal-delay-ps = <2000>;
		182	tx-internal-delay-ps = <2000>;
181		183
182	fixed-link {	184	fixed-link {
183	speed = <100>;	185	speed = <100>;

arch/arm/boot/dts/imx6ull-pinfunc.h+1−1

@@ -82,6 +82,6 @@ · 81 unmodified lines
82	#define MX6ULL_PAD_CSI_DATA04__ESAI_TX_FS 0x01F4 0x0480 0x0000 0x9 0x0	82	#define MX6ULL_PAD_CSI_DATA04__ESAI_TX_FS 0x01F4 0x0480 0x0000 0x9 0x0
83	#define MX6ULL_PAD_CSI_DATA05__ESAI_TX_CLK 0x01F8 0x0484 0x0000 0x9 0x0	83	#define MX6ULL_PAD_CSI_DATA05__ESAI_TX_CLK 0x01F8 0x0484 0x0000 0x9 0x0
84	#define MX6ULL_PAD_CSI_DATA06__ESAI_TX5_RX0 0x01FC 0x0488 0x0000 0x9 0x0	84	#define MX6ULL_PAD_CSI_DATA06__ESAI_TX5_RX0 0x01FC 0x0488 0x0000 0x9 0x0
85	#define MX6ULL_PAD_CSI_DATA07__ESAI_T0 0x0200 0x048C 0x0000 0x9 0x0	85	#define MX6ULL_PAD_CSI_DATA07__ESAI_TX0 0x0200 0x048C 0x0000 0x9 0x0
86		86
87	#endif /* __DTS_IMX6ULL_PINFUNC_H */	87	#endif /* __DTS_IMX6ULL_PINFUNC_H */

arch/arm/boot/dts/ls1021a-tsn.dts+2−0

@@ -91,6 +91,8 @@ · 90 unmodified lines
91	/* Internal port connected to eth2 */	91	/* Internal port connected to eth2 */
92	ethernet = <&enet2>;	92	ethernet = <&enet2>;
93	phy-mode = "rgmii";	93	phy-mode = "rgmii";
		94	rx-internal-delay-ps = <0>;
		95	tx-internal-delay-ps = <0>;
94	reg = <4>;	96	reg = <4>;
95		97
96	fixed-link {	98	fixed-link {

arch/arm/boot/dts/socfpga_arria10_socdk_qspi.dts+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	flash0: n25q00@0 {	12	flash0: n25q00@0 {
13	#address-cells = <1>;	13	#address-cells = <1>;
14	#size-cells = <1>;	14	#size-cells = <1>;
15	compatible = "n25q00aa";	15	compatible = "micron,mt25qu02g", "jedec,spi-nor";
16	reg = <0>;	16	reg = <0>;
17	spi-max-frequency = <100000000>;	17	spi-max-frequency = <100000000>;
18		18

arch/arm/boot/dts/socfpga_arria5_socdk.dts+1−1

@@ -119,7 +119,7 @@ · 118 unmodified lines
119	flash: flash@0 {	119	flash: flash@0 {
120	#address-cells = <1>;	120	#address-cells = <1>;
121	#size-cells = <1>;	121	#size-cells = <1>;
122	compatible = "n25q256a";	122	compatible = "micron,n25q256a", "jedec,spi-nor";
123	reg = <0>;	123	reg = <0>;
124	spi-max-frequency = <100000000>;	124	spi-max-frequency = <100000000>;
125		125

arch/arm/boot/dts/socfpga_cyclone5_socdk.dts+1−1

@@ -124,7 +124,7 @@ · 123 unmodified lines
124	flash0: n25q00@0 {	124	flash0: n25q00@0 {
125	#address-cells = <1>;	125	#address-cells = <1>;
126	#size-cells = <1>;	126	#size-cells = <1>;
127	compatible = "n25q00";	127	compatible = "micron,mt25qu02g", "jedec,spi-nor";
128	reg = <0>; /* chip select */	128	reg = <0>; /* chip select */
129	spi-max-frequency = <100000000>;	129	spi-max-frequency = <100000000>;
130		130

arch/arm/boot/dts/socfpga_cyclone5_sockit.dts+1−1

@@ -169,7 +169,7 @@ · 168 unmodified lines
169	flash: flash@0 {	169	flash: flash@0 {
170	#address-cells = <1>;	170	#address-cells = <1>;
171	#size-cells = <1>;	171	#size-cells = <1>;
172	compatible = "n25q00";	172	compatible = "micron,mt25qu02g", "jedec,spi-nor";
173	reg = <0>;	173	reg = <0>;
174	spi-max-frequency = <100000000>;	174	spi-max-frequency = <100000000>;
175		175

arch/arm/boot/dts/socfpga_cyclone5_socrates.dts+1−1

@@ -80,7 +80,7 @@ · 79 unmodified lines
80	flash: flash@0 {	80	flash: flash@0 {
81	#address-cells = <1>;	81	#address-cells = <1>;
82	#size-cells = <1>;	82	#size-cells = <1>;
83	compatible = "n25q256a";	83	compatible = "micron,n25q256a", "jedec,spi-nor";
84	reg = <0>;	84	reg = <0>;
85	spi-max-frequency = <100000000>;	85	spi-max-frequency = <100000000>;
86	m25p,fast-read;	86	m25p,fast-read;

arch/arm/boot/dts/socfpga_cyclone5_sodia.dts+1−1

@@ -116,7 +116,7 @@ · 115 unmodified lines
116	flash0: n25q512a@0 {	116	flash0: n25q512a@0 {
117	#address-cells = <1>;	117	#address-cells = <1>;
118	#size-cells = <1>;	118	#size-cells = <1>;
119	compatible = "n25q512a";	119	compatible = "micron,n25q512a", "jedec,spi-nor";
120	reg = <0>;	120	reg = <0>;
121	spi-max-frequency = <100000000>;	121	spi-max-frequency = <100000000>;
122		122

arch/arm/boot/dts/socfpga_cyclone5_vining_fpga.dts+2−2

@@ -224,7 +224,7 @@ · 223 unmodified lines
224	n25q128@0 {	224	n25q128@0 {
225	#address-cells = <1>;	225	#address-cells = <1>;
226	#size-cells = <1>;	226	#size-cells = <1>;
227	compatible = "n25q128";	227	compatible = "micron,n25q128", "jedec,spi-nor";
228	reg = <0>; /* chip select */	228	reg = <0>; /* chip select */
229	spi-max-frequency = <100000000>;	229	spi-max-frequency = <100000000>;
230	m25p,fast-read;	230	m25p,fast-read;
@@ -241,7 +241,7 @@ · 10 unmodified lines
241	n25q00@1 {	241	n25q00@1 {
242	#address-cells = <1>;	242	#address-cells = <1>;
243	#size-cells = <1>;	243	#size-cells = <1>;
244	compatible = "n25q00";	244	compatible = "micron,mt25qu02g", "jedec,spi-nor";
245	reg = <1>; /* chip select */	245	reg = <1>; /* chip select */
246	spi-max-frequency = <100000000>;	246	spi-max-frequency = <100000000>;
247	m25p,fast-read;	247	m25p,fast-read;

arch/arm/mach-rockchip/platsmp.c+1−1

@@ -189,7 +189,7 @@ static int __init rockchip_smp_prepare_sram(struct device_node *node) · 188 unmodified lines
189	rockchip_boot_fn = __pa_symbol(secondary_startup);	189	rockchip_boot_fn = __pa_symbol(secondary_startup);
190		190
191	/* copy the trampoline to sram, that runs during startup of the core */	191	/* copy the trampoline to sram, that runs during startup of the core */
192	memcpy(sram_base_addr, &rockchip_secondary_trampoline, trampoline_sz);	192	memcpy_toio(sram_base_addr, &rockchip_secondary_trampoline, trampoline_sz);
193	flush_cache_all();	193	flush_cache_all();
194	outer_clean_range(0, trampoline_sz);	194	outer_clean_range(0, trampoline_sz);
195		195

arch/arm64/Kconfig.platforms+0−1

@@ -161,7 +161,6 @@ config ARCH_MEDIATEK · 160 unmodified lines
161		161
162	config ARCH_MESON	162	config ARCH_MESON
163	bool "Amlogic Platforms"	163	bool "Amlogic Platforms"
164	select COMMON_CLK
165	help	164	help
166	This enables support for the arm64 based Amlogic SoCs	165	This enables support for the arm64 based Amlogic SoCs
167	such as the s905, S905X/D, S912, A113X/D or S905X/D2	166	such as the s905, S905X/D, S912, A113X/D or S905X/D2

arch/arm64/boot/dts/amlogic/meson-axg-jethome-jethub-j100.dts+15−15

arch/arm64/boot/dts/apple/t8103-j274.dts+1−1

@@ -60,7 +60,7 @@ · 59 unmodified lines
60		60
61	&port02 {	61	&port02 {
62	bus-range = <3 3>;	62	bus-range = <3 3>;
63	ethernet0: pci@0,0 {	63	ethernet0: ethernet@0,0 {
64	reg = <0x30000 0x0 0x0 0x0 0x0>;	64	reg = <0x30000 0x0 0x0 0x0 0x0>;
65	/* To be filled by the loader */	65	/* To be filled by the loader */
66	local-mac-address = [00 10 18 00 00 00];	66	local-mac-address = [00 10 18 00 00 00];

arch/arm64/boot/dts/apple/t8103.dtsi+8−3

  * Copyright The Asahi Linux Contributors
  */
+#include <dt-bindings/gpio/gpio.h>
 #include <dt-bindings/interrupt-controller/apple-aic.h>
 #include <dt-bindings/interrupt-controller/irq.h>
 #include <dt-bindings/pinctrl/apple.h>
 			apple,npins = <212>;
 			interrupt-controller;
+			#interrupt-cells = <2>;
 			interrupt-parent = <&aic>;
 			interrupts = <AIC_IRQ 190 IRQ_TYPE_LEVEL_HIGH>,
 				     <AIC_IRQ 191 IRQ_TYPE_LEVEL_HIGH>,
 			apple,npins = <42>;
 			interrupt-controller;
+			#interrupt-cells = <2>;
 			interrupt-parent = <&aic>;
 			interrupts = <AIC_IRQ 268 IRQ_TYPE_LEVEL_HIGH>,
 				     <AIC_IRQ 269 IRQ_TYPE_LEVEL_HIGH>,
 			apple,npins = <23>;
 			interrupt-controller;
+			#interrupt-cells = <2>;
 			interrupt-parent = <&aic>;
 			interrupts = <AIC_IRQ 330 IRQ_TYPE_LEVEL_HIGH>,
 				     <AIC_IRQ 331 IRQ_TYPE_LEVEL_HIGH>,
 			apple,npins = <16>;
 			interrupt-controller;
+			#interrupt-cells = <2>;
 			interrupt-parent = <&aic>;
 			interrupts = <AIC_IRQ 391 IRQ_TYPE_LEVEL_HIGH>,
 				     <AIC_IRQ 392 IRQ_TYPE_LEVEL_HIGH>,
 			port00: pci@0,0 {
 				device_type = "pci";
 				reg = <0x0 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 152 0>;
+				reset-gpios = <&pinctrl_ap 152 GPIO_ACTIVE_LOW>;
 				max-link-speed = <2>;
 				#address-cells = <3>;
 			port01: pci@1,0 {
 				device_type = "pci";
 				reg = <0x800 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 153 0>;
+				reset-gpios = <&pinctrl_ap 153 GPIO_ACTIVE_LOW>;
 				max-link-speed = <2>;
 				#address-cells = <3>;
 			port02: pci@2,0 {
 				device_type = "pci";
 				reg = <0x1000 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 33 0>;
+				reset-gpios = <&pinctrl_ap 33 GPIO_ACTIVE_LOW>;
 				max-link-speed = <1>;
 				#address-cells = <3>;

arch/arm64/boot/dts/freescale/fsl-ls1088a-ten64.dts+0−2

 		powerdn {
 			label = "External Power Down";
 			gpios = <&gpio1 17 GPIO_ACTIVE_LOW>;
-			interrupts = <&gpio1 17 IRQ_TYPE_EDGE_FALLING>;
 			linux,code = <KEY_POWER>;
 		};
 		admin {
 			label = "ADMIN button";
 			gpios = <&gpio3 8 GPIO_ACTIVE_HIGH>;
-			interrupts = <&gpio3 8 IRQ_TYPE_EDGE_RISING>;
 			linux,code = <KEY_WPS_BUTTON>;
 		};
 	};

arch/arm64/boot/dts/freescale/fsl-lx2160a-bluebox3.dts+4−0

 				reg = <2>;
 				ethernet = <&dpmac17>;
 				phy-mode = "rgmii-id";
+				rx-internal-delay-ps = <2000>;
+				tx-internal-delay-ps = <2000>;
 				fixed-link {
 					speed = <1000>;
 				reg = <2>;
 				ethernet = <&dpmac18>;
 				phy-mode = "rgmii-id";
+				rx-internal-delay-ps = <2000>;
+				tx-internal-delay-ps = <2000>;
 				fixed-link {
 					speed = <1000>;

arch/arm64/boot/dts/freescale/imx8mq.dtsi+0−2

@@ -524,8 +524,6 @@ · 523 unmodified lines
524	<&clk IMX8MQ_VIDEO_PLL1>,	524	<&clk IMX8MQ_VIDEO_PLL1>,
525	<&clk IMX8MQ_VIDEO_PLL1_OUT>;	525	<&clk IMX8MQ_VIDEO_PLL1_OUT>;
526	assigned-clock-rates = <0>, <0>, <0>, <594000000>;	526	assigned-clock-rates = <0>, <0>, <0>, <594000000>;
527	interconnects = <&noc IMX8MQ_ICM_LCDIF &noc IMX8MQ_ICS_DRAM>;
528	interconnect-names = "dram";
529	status = "disabled";	527	status = "disabled";
530		528
531	port@0 {	529	port@0 {

arch/arm64/boot/dts/rockchip/rk3308-roc-cc.dts+1−1

@@ -97,7 +97,7 @@ · 96 unmodified lines
97	regulator-max-microvolt = <3300000>;	97	regulator-max-microvolt = <3300000>;
98	regulator-always-on;	98	regulator-always-on;
99	regulator-boot-on;	99	regulator-boot-on;
100	vim-supply = <&vcc_io>;	100	vin-supply = <&vcc_io>;
101	};	101	};
102		102
103	vdd_core: vdd-core {	103	vdd_core: vdd-core {

arch/arm64/boot/dts/rockchip/rk3399-khadas-edge.dtsi+0−1

@@ -705,7 +705,6 @@ · 704 unmodified lines
705	&sdhci {	705	&sdhci {
706	bus-width = <8>;	706	bus-width = <8>;
707	mmc-hs400-1_8v;	707	mmc-hs400-1_8v;
708	mmc-hs400-enhanced-strobe;
709	non-removable;	708	non-removable;
710	status = "okay";	709	status = "okay";
711	};	710	};

arch/arm64/boot/dts/rockchip/rk3399-kobol-helios64.dts+1−0

@@ -276,6 +276,7 @@ · 275 unmodified lines
276	clock-output-names = "xin32k", "rk808-clkout2";	276	clock-output-names = "xin32k", "rk808-clkout2";
277	pinctrl-names = "default";	277	pinctrl-names = "default";
278	pinctrl-0 = <&pmic_int_l>;	278	pinctrl-0 = <&pmic_int_l>;
		279	rockchip,system-power-controller;
279	vcc1-supply = <&vcc5v0_sys>;	280	vcc1-supply = <&vcc5v0_sys>;
280	vcc2-supply = <&vcc5v0_sys>;	281	vcc2-supply = <&vcc5v0_sys>;
281	vcc3-supply = <&vcc5v0_sys>;	282	vcc3-supply = <&vcc5v0_sys>;

arch/arm64/boot/dts/rockchip/rk3399-leez-p710.dts+1−1

@@ -55,7 +55,7 @@ · 54 unmodified lines
55	regulator-boot-on;	55	regulator-boot-on;
56	regulator-min-microvolt = <3300000>;	56	regulator-min-microvolt = <3300000>;
57	regulator-max-microvolt = <3300000>;	57	regulator-max-microvolt = <3300000>;
58	vim-supply = <&vcc3v3_sys>;	58	vin-supply = <&vcc3v3_sys>;
59	};	59	};
60		60
61	vcc3v3_sys: vcc3v3-sys {	61	vcc3v3_sys: vcc3v3-sys {

arch/arm64/boot/dts/rockchip/rk3399-rock-pi-4.dtsi+1−1

@@ -502,7 +502,7 @@ · 501 unmodified lines
502	status = "okay";	502	status = "okay";
503		503
504	bt656-supply = <&vcc_3v0>;	504	bt656-supply = <&vcc_3v0>;
505	audio-supply = <&vcc_3v0>;	505	audio-supply = <&vcc1v8_codec>;
506	sdmmc-supply = <&vcc_sdio>;	506	sdmmc-supply = <&vcc_sdio>;
507	gpio1830-supply = <&vcc_3v0>;	507	gpio1830-supply = <&vcc_3v0>;
508	};	508	};

arch/arm64/kernel/machine_kexec_file.c+1−0

@@ -149,6 +149,7 @@ int load_other_segments(struct kimage *image, · 148 unmodified lines
149	initrd_len, cmdline, 0);	149	initrd_len, cmdline, 0);
150	if (!dtb) {	150	if (!dtb) {
151	pr_err("Preparing for new dtb failed\n");	151	pr_err("Preparing for new dtb failed\n");
		152	ret = -EINVAL;
152	goto out_err;	153	goto out_err;
153	}	154	}
154		155

arch/csky/kernel/traps.c+2−2

@@ -209,7 +209,7 @@ asmlinkage void do_trap_illinsn(struct pt_regs *regs) · 208 unmodified lines
209		209
210	asmlinkage void do_trap_fpe(struct pt_regs *regs)	210	asmlinkage void do_trap_fpe(struct pt_regs *regs)
211	{	211	{
212	#ifdef CONFIG_CPU_HAS_FP	212	#ifdef CONFIG_CPU_HAS_FPU
213	return fpu_fpe(regs);	213	return fpu_fpe(regs);
214	#else	214	#else
215	do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc,	215	do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc,
@@ -219,7 +219,7 @@ asmlinkage void do_trap_fpe(struct pt_regs *regs) · 3 unmodified lines
219		219
220	asmlinkage void do_trap_priv(struct pt_regs *regs)	220	asmlinkage void do_trap_priv(struct pt_regs *regs)
221	{	221	{
222	#ifdef CONFIG_CPU_HAS_FP	222	#ifdef CONFIG_CPU_HAS_FPU
223	if (user_mode(regs) && fpu_libc_helper(regs))	223	if (user_mode(regs) && fpu_libc_helper(regs))
224	return;	224	return;
225	#endif	225	#endif

arch/s390/configs/debug_defconfig+2−0

 CONFIG_UNIX_DIAG=m
 CONFIG_XFRM_USER=m
 CONFIG_NET_KEY=m
+CONFIG_NET_SWITCHDEV=y
 CONFIG_SMC=m
 CONFIG_SMC_DIAG=m
 CONFIG_INET=y
 CONFIG_MLX4_EN=m
 CONFIG_MLX5_CORE=m
 CONFIG_MLX5_CORE_EN=y
+CONFIG_MLX5_ESWITCH=y
 # CONFIG_NET_VENDOR_MICREL is not set
 # CONFIG_NET_VENDOR_MICROCHIP is not set
 # CONFIG_NET_VENDOR_MICROSEMI is not set

arch/s390/configs/defconfig+2−0

 CONFIG_UNIX_DIAG=m
 CONFIG_XFRM_USER=m
 CONFIG_NET_KEY=m
+CONFIG_NET_SWITCHDEV=y
 CONFIG_SMC=m
 CONFIG_SMC_DIAG=m
 CONFIG_INET=y
 CONFIG_MLX4_EN=m
 CONFIG_MLX5_CORE=m
 CONFIG_MLX5_CORE_EN=y
+CONFIG_MLX5_ESWITCH=y
 # CONFIG_NET_VENDOR_MICREL is not set
 # CONFIG_NET_VENDOR_MICROCHIP is not set
 # CONFIG_NET_VENDOR_MICROSEMI is not set

arch/s390/kernel/ftrace.c+0−2

 		return;
 	regs = ftrace_get_regs(fregs);
-	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (unlikely(!p) || kprobe_disabled(p))
 		goto out;
 	}
 	__this_cpu_write(current_kprobe, NULL);
 out:
-	preempt_enable_notrace();
 	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);

arch/s390/kernel/irq.c+5−4

@@ -138,7 +138,7 @@ void noinstr do_io_irq(struct pt_regs *regs) · 137 unmodified lines
138	struct pt_regs *old_regs = set_irq_regs(regs);	138	struct pt_regs *old_regs = set_irq_regs(regs);
139	int from_idle;	139	int from_idle;
140		140
141	irq_enter();	141	irq_enter_rcu();
142		142
143	if (user_mode(regs)) {	143	if (user_mode(regs)) {
144	update_timer_sys();	144	update_timer_sys();
@@ -158,7 +158,8 @@ void noinstr do_io_irq(struct pt_regs *regs) · 13 unmodified lines
158	do_irq_async(regs, IO_INTERRUPT);	158	do_irq_async(regs, IO_INTERRUPT);
159	} while (MACHINE_IS_LPAR && irq_pending(regs));	159	} while (MACHINE_IS_LPAR && irq_pending(regs));
160		160
161	irq_exit();	161	irq_exit_rcu();
		162
162	set_irq_regs(old_regs);	163	set_irq_regs(old_regs);
163	irqentry_exit(regs, state);	164	irqentry_exit(regs, state);
164		165
@@ -172,7 +173,7 @@ void noinstr do_ext_irq(struct pt_regs *regs) · 7 unmodified lines
172	struct pt_regs *old_regs = set_irq_regs(regs);	173	struct pt_regs *old_regs = set_irq_regs(regs);
173	int from_idle;	174	int from_idle;
174		175
175	irq_enter();	176	irq_enter_rcu();
176		177
177	if (user_mode(regs)) {	178	if (user_mode(regs)) {
178	update_timer_sys();	179	update_timer_sys();
@@ -190,7 +191,7 @@ void noinstr do_ext_irq(struct pt_regs *regs) · 11 unmodified lines
190		191
191	do_irq_async(regs, EXT_INTERRUPT);	192	do_irq_async(regs, EXT_INTERRUPT);
192		193
193	irq_exit();	194	irq_exit_rcu();
194	set_irq_regs(old_regs);	195	set_irq_regs(old_regs);
195	irqentry_exit(regs, state);	196	irqentry_exit(regs, state);
196		197

arch/s390/kernel/machine_kexec_file.c+34−4

@@ -7,6 +7,8 @@ · 6 unmodified lines
7	* Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>	7	* Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>
8	*/	8	*/
9		9
		10	#define pr_fmt(fmt) "kexec: " fmt
		11
10	#include <linux/elf.h>	12	#include <linux/elf.h>
11	#include <linux/errno.h>	13	#include <linux/errno.h>
12	#include <linux/kexec.h>	14	#include <linux/kexec.h>
@@ -290,8 +292,16 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi, · 277 unmodified lines
290	const Elf_Shdr *relsec,	292	const Elf_Shdr *relsec,
291	const Elf_Shdr *symtab)	293	const Elf_Shdr *symtab)
292	{	294	{
		295	const char strtab, name, *shstrtab;
		296	const Elf_Shdr *sechdrs;
293	Elf_Rela *relas;	297	Elf_Rela *relas;
294	int i, r_type;	298	int i, r_type;
		299	int ret;
		300
		301	/* String & section header string table */
		302	sechdrs = (void *)pi->ehdr + pi->ehdr->e_shoff;
		303	strtab = (char *)pi->ehdr + sechdrs[symtab->sh_link].sh_offset;
		304	shstrtab = (char *)pi->ehdr + sechdrs[pi->ehdr->e_shstrndx].sh_offset;
295		305
296	relas = (void *)pi->ehdr + relsec->sh_offset;	306	relas = (void *)pi->ehdr + relsec->sh_offset;
297		307
@@ -304,15 +314,27 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi, · 6 unmodified lines
304	sym = (void *)pi->ehdr + symtab->sh_offset;	314	sym = (void *)pi->ehdr + symtab->sh_offset;
305	sym += ELF64_R_SYM(relas[i].r_info);	315	sym += ELF64_R_SYM(relas[i].r_info);
306		316
307	if (sym->st_shndx == SHN_UNDEF)	317	if (sym->st_name)
		318	name = strtab + sym->st_name;
		319	else
		320	name = shstrtab + sechdrs[sym->st_shndx].sh_name;
		321
		322	if (sym->st_shndx == SHN_UNDEF) {
		323	pr_err("Undefined symbol: %s\n", name);
308	return -ENOEXEC;	324	return -ENOEXEC;
		325	}
309		326
310	if (sym->st_shndx == SHN_COMMON)	327	if (sym->st_shndx == SHN_COMMON) {
		328	pr_err("symbol '%s' in common section\n", name);
311	return -ENOEXEC;	329	return -ENOEXEC;
		330	}
312		331
313	if (sym->st_shndx >= pi->ehdr->e_shnum &&	332	if (sym->st_shndx >= pi->ehdr->e_shnum &&
314	sym->st_shndx != SHN_ABS)	333	sym->st_shndx != SHN_ABS) {
		334	pr_err("Invalid section %d for symbol %s\n",
		335	sym->st_shndx, name);
315	return -ENOEXEC;	336	return -ENOEXEC;
		337	}
316		338
317	loc = pi->purgatory_buf;	339	loc = pi->purgatory_buf;
318	loc += section->sh_offset;	340	loc += section->sh_offset;
@@ -326,7 +348,15 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi, · 7 unmodified lines
326	addr = section->sh_addr + relas[i].r_offset;	348	addr = section->sh_addr + relas[i].r_offset;
327		349
328	r_type = ELF64_R_TYPE(relas[i].r_info);	350	r_type = ELF64_R_TYPE(relas[i].r_info);
329	arch_kexec_do_relocs(r_type, loc, val, addr);	351
		352	if (r_type == R_390_PLT32DBL)
		353	r_type = R_390_PC32DBL;
		354
		355	ret = arch_kexec_do_relocs(r_type, loc, val, addr);
		356	if (ret) {
		357	pr_err("Unknown rela relocation: %d\n", r_type);
		358	return -ENOEXEC;
		359	}
330	}	360	}
331	return 0;	361	return 0;
332	}	362	}

arch/x86/include/asm/kvm_host.h+1−1

@@ -97,7 +97,7 @@ · 96 unmodified lines
97	KVM_ARCH_REQ_FLAGS(25, KVM_REQUEST_WAIT \| KVM_REQUEST_NO_WAKEUP)	97	KVM_ARCH_REQ_FLAGS(25, KVM_REQUEST_WAIT \| KVM_REQUEST_NO_WAKEUP)
98	#define KVM_REQ_TLB_FLUSH_CURRENT KVM_ARCH_REQ(26)	98	#define KVM_REQ_TLB_FLUSH_CURRENT KVM_ARCH_REQ(26)
99	#define KVM_REQ_TLB_FLUSH_GUEST \	99	#define KVM_REQ_TLB_FLUSH_GUEST \
100	KVM_ARCH_REQ_FLAGS(27, KVM_REQUEST_NO_WAKEUP)	100	KVM_ARCH_REQ_FLAGS(27, KVM_REQUEST_WAIT \| KVM_REQUEST_NO_WAKEUP)
101	#define KVM_REQ_APF_READY KVM_ARCH_REQ(28)	101	#define KVM_REQ_APF_READY KVM_ARCH_REQ(28)
102	#define KVM_REQ_MSR_FILTER_CHANGED KVM_ARCH_REQ(29)	102	#define KVM_REQ_MSR_FILTER_CHANGED KVM_ARCH_REQ(29)
103	#define KVM_REQ_UPDATE_CPU_DIRTY_LOGGING \	103	#define KVM_REQ_UPDATE_CPU_DIRTY_LOGGING \

arch/x86/kernel/smpboot.c+14−0

 	{ NULL, },
 };
+static struct sched_domain_topology_level x86_hybrid_topology[] = {
+#ifdef CONFIG_SCHED_SMT
+	{ cpu_smt_mask, x86_smt_flags, SD_INIT_NAME(SMT) },
+#endif
+#ifdef CONFIG_SCHED_MC
+	{ cpu_coregroup_mask, x86_core_flags, SD_INIT_NAME(MC) },
+#endif
+	{ cpu_cpu_mask, SD_INIT_NAME(DIE) },
+	{ NULL, },
+};
 static struct sched_domain_topology_level x86_topology[] = {
 #ifdef CONFIG_SCHED_SMT
 	{ cpu_smt_mask, x86_smt_flags, SD_INIT_NAME(SMT) },
 	calculate_max_logical_packages();
+	/* XXX for now assume numa-in-package and hybrid don't overlap */
 	if (x86_has_numa_in_package)
 		set_sched_topology(x86_numa_in_package_topology);
+	if (cpu_feature_enabled(X86_FEATURE_HYBRID_CPU))
+		set_sched_topology(x86_hybrid_topology);
 	nmi_selftest();
 	impress_friends();

arch/x86/kvm/hyperv.c+5−2

 		all_cpus = send_ipi_ex.vp_set.format == HV_GENERIC_SET_ALL;
+		if (all_cpus)
+			goto check_and_send_ipi;
 		if (!sparse_banks_len)
 			goto ret_success;
-		if (!all_cpus &&
+		if (kvm_read_guest(kvm,
-		    kvm_read_guest(kvm,
 				   hc->ingpa + offsetof(struct hv_send_ipi_ex,
 							vp_set.bank_contents),
 				   sparse_banks,
 			return HV_STATUS_INVALID_HYPERCALL_INPUT;
 	}
+check_and_send_ipi:
 	if ((vector < HV_IPI_LOW_VECTOR) || (vector > HV_IPI_HIGH_VECTOR))
 		return HV_STATUS_INVALID_HYPERCALL_INPUT;

arch/x86/kvm/vmx/vmx.c+13−9

 		if (!loaded_vmcs->msr_bitmap)
 			goto out_vmcs;
 		memset(loaded_vmcs->msr_bitmap, 0xff, PAGE_SIZE);
-		if (IS_ENABLED(CONFIG_HYPERV) &&
-		    static_branch_unlikely(&enable_evmcs) &&
-		    (ms_hyperv.nested_features & HV_X64_NESTED_MSR_BITMAP)) {
-			struct hv_enlightened_vmcs *evmcs =
-				(struct hv_enlightened_vmcs *)loaded_vmcs->vmcs;
-			evmcs->hv_enlightenments_control.msr_bitmap = 1;
-		}
 	}
 	memset(&loaded_vmcs->host_state, 0, sizeof(struct vmcs_host_state));
 	if (err < 0)
 		goto free_pml;
+	/*
+	 * Use Hyper-V 'Enlightened MSR Bitmap' feature when KVM runs as a
+	 * nested (L1) hypervisor and Hyper-V in L0 supports it. Enable the
+	 * feature only for vmcs01, KVM currently isn't equipped to realize any
+	 * performance benefits from enabling it for vmcs02.
+	 */
+	if (IS_ENABLED(CONFIG_HYPERV) && static_branch_unlikely(&enable_evmcs) &&
+	    (ms_hyperv.nested_features & HV_X64_NESTED_MSR_BITMAP)) {
+		struct hv_enlightened_vmcs *evmcs = (void *)vmx->vmcs01.vmcs;
+		evmcs->hv_enlightenments_control.msr_bitmap = 1;
+	}
 	/* The MSR bitmap starts with all ones */
 	bitmap_fill(vmx->shadow_msr_intercept.read, MAX_POSSIBLE_PASSTHROUGH_MSRS);
 	bitmap_fill(vmx->shadow_msr_intercept.write, MAX_POSSIBLE_PASSTHROUGH_MSRS);

arch/x86/kvm/x86.c+9−3

 	    !load_pdptrs(vcpu, vcpu->arch.walk_mmu, kvm_read_cr3(vcpu)))
 		return 1;
-	if (!(cr0 & X86_CR0_PG) && kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE))
+	if (!(cr0 & X86_CR0_PG) &&
+	    (is_64_bit_mode(vcpu) || kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE)))
 		return 1;
 	static_call(kvm_x86_set_cr0)(vcpu, cr0);
 			   unsigned short port, void *val, unsigned int count)
 {
 	if (vcpu->arch.pio.count) {
-		/* Complete previous iteration.  */
+		/*
+		 * Complete a previous iteration that required userspace I/O.
+		 * Note, @count isn't guaranteed to match pio.count as userspace
+		 * can modify ECX before rerunning the vCPU.  Ignore any such
+		 * shenanigans as KVM doesn't support modifying the rep count,
+		 * and the emulator ensures @count doesn't overflow the buffer.
+		 */
 	} else {
 		int r = __emulator_pio_in(vcpu, size, port, count);
 		if (!r)
 		/* Results already available, fall through.  */
 	}
-	WARN_ON(count != vcpu->arch.pio.count);
 	complete_emulator_pio_in(vcpu, val);
 	return 1;
 }

arch/x86/net/bpf_jit_comp.c+43−8

@@ -1252,19 +1252,54 @@ st: if (is_imm8(insn->off)) · 1251 unmodified lines
1252	case BPF_LDX \| BPF_MEM \| BPF_DW:	1252	case BPF_LDX \| BPF_MEM \| BPF_DW:
1253	case BPF_LDX \| BPF_PROBE_MEM \| BPF_DW:	1253	case BPF_LDX \| BPF_PROBE_MEM \| BPF_DW:
1254	if (BPF_MODE(insn->code) == BPF_PROBE_MEM) {	1254	if (BPF_MODE(insn->code) == BPF_PROBE_MEM) {
1255	/* test src_reg, src_reg */	1255	/* Though the verifier prevents negative insn->off in BPF_PROBE_MEM
1256	maybe_emit_mod(&prog, src_reg, src_reg, true); /* always 1 byte */	1256	* add abs(insn->off) to the limit to make sure that negative
1257	EMIT2(0x85, add_2reg(0xC0, src_reg, src_reg));	1257	* offset won't be an issue.
1258	/* jne start_of_ldx */	1258	* insn->off is s16, so it won't affect valid pointers.
1259	EMIT2(X86_JNE, 0);	1259	*/
		1260	u64 limit = TASK_SIZE_MAX + PAGE_SIZE + abs(insn->off);
		1261	u8 end_of_jmp1, end_of_jmp2;
		1262
		1263	/* Conservatively check that src_reg + insn->off is a kernel address:
		1264	* 1. src_reg + insn->off >= limit
		1265	* 2. src_reg + insn->off doesn't become small positive.
		1266	* Cannot do src_reg + insn->off >= limit in one branch,
		1267	* since it needs two spare registers, but JIT has only one.
		1268	*/
		1269
		1270	/* movabsq r11, limit */
		1271	EMIT2(add_1mod(0x48, AUX_REG), add_1reg(0xB8, AUX_REG));
		1272	EMIT((u32)limit, 4);
		1273	EMIT(limit >> 32, 4);
		1274	/* cmp src_reg, r11 */
		1275	maybe_emit_mod(&prog, src_reg, AUX_REG, true);
		1276	EMIT2(0x39, add_2reg(0xC0, src_reg, AUX_REG));
		1277	/* if unsigned '<' goto end_of_jmp2 */
		1278	EMIT2(X86_JB, 0);
		1279	end_of_jmp1 = prog;
		1280
		1281	/* mov r11, src_reg */
		1282	emit_mov_reg(&prog, true, AUX_REG, src_reg);
		1283	/* add r11, insn->off */
		1284	maybe_emit_1mod(&prog, AUX_REG, true);
		1285	EMIT2_off32(0x81, add_1reg(0xC0, AUX_REG), insn->off);
		1286	/* jmp if not carry to start_of_ldx
		1287	* Otherwise ERR_PTR(-EINVAL) + 128 will be the user addr
		1288	* that has to be rejected.
		1289	*/
		1290	EMIT2(0x73 /* JNC */, 0);
		1291	end_of_jmp2 = prog;
		1292
1260	/* xor dst_reg, dst_reg */	1293	/* xor dst_reg, dst_reg */
1261	emit_mov_imm32(&prog, false, dst_reg, 0);	1294	emit_mov_imm32(&prog, false, dst_reg, 0);
1262	/* jmp byte_after_ldx */	1295	/* jmp byte_after_ldx */
1263	EMIT2(0xEB, 0);	1296	EMIT2(0xEB, 0);
1264		1297
1265	/* populate jmp_offset for JNE above */	1298	/* populate jmp_offset for JB above to jump to xor dst_reg */
1266	temp[4] = prog - temp - 5 /* sizeof(test + jne) */;	1299	end_of_jmp1[-1] = end_of_jmp2 - end_of_jmp1;
		1300	/* populate jmp_offset for JNC above to jump to start_of_ldx */
1267	start_of_ldx = prog;	1301	start_of_ldx = prog;
		1302	end_of_jmp2[-1] = start_of_ldx - end_of_jmp2;
1268	}	1303	}
1269	emit_ldx(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);	1304	emit_ldx(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);
1270	if (BPF_MODE(insn->code) == BPF_PROBE_MEM) {	1305	if (BPF_MODE(insn->code) == BPF_PROBE_MEM) {
@@ -1305,7 +1340,7 @@ st: if (is_imm8(insn->off)) · 34 unmodified lines
1305	* End result: x86 insn "mov rbx, qword ptr [rax+0x14]"	1340	* End result: x86 insn "mov rbx, qword ptr [rax+0x14]"
1306	* of 4 bytes will be ignored and rbx will be zero inited.	1341	* of 4 bytes will be ignored and rbx will be zero inited.
1307	*/	1342	*/
1308	ex->fixup = (prog - temp) \| (reg2pt_regs[dst_reg] << 8);	1343	ex->fixup = (prog - start_of_ldx) \| (reg2pt_regs[dst_reg] << 8);
1309	}	1344	}
1310	break;	1345	break;
1311		1346

block/fops.c+1−2

 	} else {
 		ret = bio_iov_iter_get_pages(bio, iter);
 		if (unlikely(ret)) {
-			bio->bi_status = BLK_STS_IOERR;
+			bio_put(bio);
-			bio_endio(bio);
 			return ret;
 		}
 	}

block/ioprio.c+3−0

 				pgrp = task_pgrp(current);
 			else
 				pgrp = find_vpid(who);
+			read_lock(&tasklist_lock);
 			do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
 				tmpio = get_task_ioprio(p);
 				if (tmpio < 0)
 				else
 					ret = ioprio_best(ret, tmpio);
 			} while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
+			read_unlock(&tasklist_lock);
 			break;
 		case IOPRIO_WHO_USER:
 			uid = make_kuid(current_user_ns(), who);

drivers/Makefile+1−2

@@ -41,8 +41,7 @@ obj-$(CONFIG_DMADEVICES) += dma/ · 40 unmodified lines
41	# SOC specific infrastructure drivers.	41	# SOC specific infrastructure drivers.
42	obj-y += soc/	42	obj-y += soc/
43		43
44	obj-$(CONFIG_VIRTIO) += virtio/	44	obj-y += virtio/
45	obj-$(CONFIG_VIRTIO_PCI_LIB) += virtio/
46	obj-$(CONFIG_VDPA) += vdpa/	45	obj-$(CONFIG_VDPA) += vdpa/
47	obj-$(CONFIG_XEN) += xen/	46	obj-$(CONFIG_XEN) += xen/
48		47

drivers/android/binder.c+9−12

 	__release(&t->lock);
 	/*
-	 * If this thread used poll, make sure we remove the waitqueue
+	 * If this thread used poll, make sure we remove the waitqueue from any
-	 * from any epoll data structures holding it with POLLFREE.
+	 * poll data structures holding it.
-	 * waitqueue_active() is safe to use here because we're holding
-	 * the inner lock.
 	 */
-	if ((thread->looper & BINDER_LOOPER_STATE_POLL) &&
+	if (thread->looper & BINDER_LOOPER_STATE_POLL)
-	    waitqueue_active(&thread->wait)) {
+		wake_up_pollfree(&thread->wait);
-		wake_up_poll(&thread->wait, EPOLLHUP | POLLFREE);
-	}
 	binder_inner_proc_unlock(thread->proc);
 	/*
-	 * This is needed to avoid races between wake_up_poll() above and
+	 * This is needed to avoid races between wake_up_pollfree() above and
-	 * and ep_remove_waitqueue() called for other reasons (eg the epoll file
+	 * someone else removing the last entry from the queue for other reasons
-	 * descriptor being closed); ep_remove_waitqueue() holds an RCU read
+	 * (e.g. ep_remove_wait_queue() being called due to an epoll file
-	 * lock, so we can be sure it's done after calling synchronize_rcu().
+	 * descriptor being closed).  Such other users hold an RCU read lock, so
+	 * we can be sure they're done after we call synchronize_rcu().
 	 */
 	if (thread->looper & BINDER_LOOPER_STATE_POLL)
 		synchronize_rcu();

drivers/ata/ahci_ceva.c+2−1

 static unsigned int ceva_ahci_read_id(struct ata_device *dev,
 					struct ata_taskfile *tf, u16 *id)
 {
+	__le16 *__id = (__le16 *)id;
 	u32 err_mask;
 	err_mask = ata_do_dev_read_id(dev, tf, id);
 	 * Since CEVA controller does not support device sleep feature, we
 	 * need to clear DEVSLP (bit 8) in word78 of the IDENTIFY DEVICE data.
 	 */
-	id[ATA_ID_FEATURE_SUPP] &= cpu_to_le16(~(1 << 8));
+	__id[ATA_ID_FEATURE_SUPP] &= cpu_to_le16(~(1 << 8));
 	return 0;
 }

drivers/ata/libata-core.c+2−0

@@ -3920,6 +3920,8 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { · 3919 unmodified lines
3920	{ "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },	3920	{ "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3921	/* Odd clown on sil3726/4726 PMPs */	3921	/* Odd clown on sil3726/4726 PMPs */
3922	{ "Config Disk", NULL, ATA_HORKAGE_DISABLE },	3922	{ "Config Disk", NULL, ATA_HORKAGE_DISABLE },
		3923	/* Similar story with ASMedia 1092 */
		3924	{ "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE },
3923		3925
3924	/* Weird ATAPI devices */	3926	/* Weird ATAPI devices */
3925	{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },	3927	{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },

drivers/bus/mhi/core/pm.c+18−3

 }
 EXPORT_SYMBOL_GPL(mhi_pm_suspend);
-int mhi_pm_resume(struct mhi_controller *mhi_cntrl)
+static int __mhi_pm_resume(struct mhi_controller *mhi_cntrl, bool force)
 {
 	struct mhi_chan *itr, *tmp;
 	struct device *dev = &mhi_cntrl->mhi_dev->dev;
 	if (MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state))
 		return -EIO;
-	if (mhi_get_mhi_state(mhi_cntrl) != MHI_STATE_M3)
+	if (mhi_get_mhi_state(mhi_cntrl) != MHI_STATE_M3) {
-		return -EINVAL;
+		dev_warn(dev, "Resuming from non M3 state (%s)\n",
+			 TO_MHI_STATE_STR(mhi_get_mhi_state(mhi_cntrl)));
+		if (!force)
+			return -EINVAL;
+	}
 	/* Notify clients about exiting LPM */
 	list_for_each_entry_safe(itr, tmp, &mhi_cntrl->lpm_chans, node) {
 	return 0;
 }
+int mhi_pm_resume(struct mhi_controller *mhi_cntrl)
+{
+	return __mhi_pm_resume(mhi_cntrl, false);
+}
 EXPORT_SYMBOL_GPL(mhi_pm_resume);
+int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl)
+{
+	return __mhi_pm_resume(mhi_cntrl, true);
+}
+EXPORT_SYMBOL_GPL(mhi_pm_resume_force);
 int __mhi_device_get_sync(struct mhi_controller *mhi_cntrl)
 {
 	int ret;

drivers/bus/mhi/pci_generic.c+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20		20
21	#define MHI_PCI_DEFAULT_BAR_NUM 0	21	#define MHI_PCI_DEFAULT_BAR_NUM 0
22		22
23	#define MHI_POST_RESET_DELAY_MS 500	23	#define MHI_POST_RESET_DELAY_MS 2000
24		24
25	#define HEALTH_CHECK_PERIOD (HZ * 2)	25	#define HEALTH_CHECK_PERIOD (HZ * 2)
26		26

drivers/clk/clk.c+12−3

 	clk_prepare_lock();
+	/*
+	 * Set hw->core after grabbing the prepare_lock to synchronize with
+	 * callers of clk_core_fill_parent_index() where we treat hw->core
+	 * being NULL as the clk not being registered yet. This is crucial so
+	 * that clks aren't parented until their parent is fully registered.
+	 */
+	core->hw->core = core;
 	ret = clk_pm_runtime_get(core);
 	if (ret)
 		goto unlock;
 out:
 	clk_pm_runtime_put(core);
 unlock:
-	if (ret)
+	if (ret) {
 		hlist_del_init(&core->child_node);
+		core->hw->core = NULL;
+	}
 	clk_prepare_unlock();
 	core->num_parents = init->num_parents;
 	core->min_rate = 0;
 	core->max_rate = ULONG_MAX;
-	hw->core = core;
 	ret = clk_core_populate_parent_map(core, init);
 	if (ret)
 		goto fail_create_clk;
 	}
-	clk_core_link_consumer(hw->core, hw->clk);
+	clk_core_link_consumer(core, hw->clk);
 	ret = __clk_core_init(core);
 	if (!ret)

drivers/clk/imx/clk-imx8qxp-lpcg.c+1−1

@@ -370,7 +370,7 @@ static struct platform_driver imx8qxp_lpcg_clk_driver = { · 369 unmodified lines
370	.probe = imx8qxp_lpcg_clk_probe,	370	.probe = imx8qxp_lpcg_clk_probe,
371	};	371	};
372		372
373	builtin_platform_driver(imx8qxp_lpcg_clk_driver);	373	module_platform_driver(imx8qxp_lpcg_clk_driver);
374		374
375	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");	375	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");
376	MODULE_DESCRIPTION("NXP i.MX8QXP LPCG clock driver");	376	MODULE_DESCRIPTION("NXP i.MX8QXP LPCG clock driver");

drivers/clk/imx/clk-imx8qxp.c+1−1

@@ -308,7 +308,7 @@ static struct platform_driver imx8qxp_clk_driver = { · 307 unmodified lines
308	},	308	},
309	.probe = imx8qxp_clk_probe,	309	.probe = imx8qxp_clk_probe,
310	};	310	};
311	builtin_platform_driver(imx8qxp_clk_driver);	311	module_platform_driver(imx8qxp_clk_driver);
312		312
313	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");	313	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");
314	MODULE_DESCRIPTION("NXP i.MX8QXP clock driver");	314	MODULE_DESCRIPTION("NXP i.MX8QXP clock driver");

drivers/clk/qcom/clk-alpha-pll.c+9−0

@@ -1429,6 +1429,15 @@ EXPORT_SYMBOL_GPL(clk_alpha_pll_postdiv_fabia_ops); · 1428 unmodified lines
1429	void clk_trion_pll_configure(struct clk_alpha_pll pll, struct regmap regmap,	1429	void clk_trion_pll_configure(struct clk_alpha_pll pll, struct regmap regmap,
1430	const struct alpha_pll_config *config)	1430	const struct alpha_pll_config *config)
1431	{	1431	{
		1432	/*
		1433	* If the bootloader left the PLL enabled it's likely that there are
		1434	* RCGs that will lock up if we disable the PLL below.
		1435	*/
		1436	if (trion_pll_is_enabled(pll, regmap)) {
		1437	pr_debug("Trion PLL is already enabled, skipping configuration\n");
		1438	return;
		1439	}
		1440
1432	clk_alpha_pll_write_config(regmap, PLL_L_VAL(pll), config->l);	1441	clk_alpha_pll_write_config(regmap, PLL_L_VAL(pll), config->l);
1433	regmap_write(regmap, PLL_CAL_L_VAL(pll), TRION_PLL_CAL_VAL);	1442	regmap_write(regmap, PLL_CAL_L_VAL(pll), TRION_PLL_CAL_VAL);
1434	clk_alpha_pll_write_config(regmap, PLL_ALPHA_VAL(pll), config->alpha);	1443	clk_alpha_pll_write_config(regmap, PLL_ALPHA_VAL(pll), config->alpha);

drivers/clk/qcom/clk-regmap-mux.c+1−1

@@ -28,7 +28,7 @@ static u8 mux_get_parent(struct clk_hw *hw) · 27 unmodified lines
28	val &= mask;	28	val &= mask;
29		29
30	if (mux->parent_map)	30	if (mux->parent_map)
31	return qcom_find_src_index(hw, mux->parent_map, val);	31	return qcom_find_cfg_index(hw, mux->parent_map, val);
32		32
33	return val;	33	return val;
34	}	34	}

drivers/clk/qcom/common.c+12−0

@@ -69,6 +69,18 @@ int qcom_find_src_index(struct clk_hw hw, const struct parent_map map, u8 src) · 68 unmodified lines
69	}	69	}
70	EXPORT_SYMBOL_GPL(qcom_find_src_index);	70	EXPORT_SYMBOL_GPL(qcom_find_src_index);
71		71
		72	int qcom_find_cfg_index(struct clk_hw hw, const struct parent_map map, u8 cfg)
		73	{
		74	int i, num_parents = clk_hw_get_num_parents(hw);
		75
		76	for (i = 0; i < num_parents; i++)
		77	if (cfg == map[i].cfg)
		78	return i;
		79
		80	return -ENOENT;
		81	}
		82	EXPORT_SYMBOL_GPL(qcom_find_cfg_index);
		83
72	struct regmap *	84	struct regmap *
73	qcom_cc_map(struct platform_device pdev, const struct qcom_cc_desc desc)	85	qcom_cc_map(struct platform_device pdev, const struct qcom_cc_desc desc)
74	{	86	{

drivers/clk/qcom/common.h+2−0

@@ -49,6 +49,8 @@ extern void · 48 unmodified lines
49	qcom_pll_set_fsm_mode(struct regmap *m, u32 reg, u8 bias_count, u8 lock_count);	49	qcom_pll_set_fsm_mode(struct regmap *m, u32 reg, u8 bias_count, u8 lock_count);
50	extern int qcom_find_src_index(struct clk_hw hw, const struct parent_map map,	50	extern int qcom_find_src_index(struct clk_hw hw, const struct parent_map map,
51	u8 src);	51	u8 src);
		52	extern int qcom_find_cfg_index(struct clk_hw hw, const struct parent_map map,
		53	u8 cfg);
52		54
53	extern int qcom_cc_register_board_clk(struct device dev, const char path,	55	extern int qcom_cc_register_board_clk(struct device dev, const char path,
54	const char *name, unsigned long rate);	56	const char *name, unsigned long rate);

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

@@ -1121,7 +1121,7 @@ static struct clk_rcg2 gcc_sdcc1_apps_clk_src = { · 1120 unmodified lines
1121	.name = "gcc_sdcc1_apps_clk_src",	1121	.name = "gcc_sdcc1_apps_clk_src",
1122	.parent_data = gcc_parent_data_1,	1122	.parent_data = gcc_parent_data_1,
1123	.num_parents = ARRAY_SIZE(gcc_parent_data_1),	1123	.num_parents = ARRAY_SIZE(gcc_parent_data_1),
1124	.ops = &clk_rcg2_ops,	1124	.ops = &clk_rcg2_floor_ops,
1125	},	1125	},
1126	};	1126	};
1127		1127
@@ -1143,7 +1143,7 @@ static struct clk_rcg2 gcc_sdcc1_ice_core_clk_src = { · 15 unmodified lines
1143	.name = "gcc_sdcc1_ice_core_clk_src",	1143	.name = "gcc_sdcc1_ice_core_clk_src",
1144	.parent_data = gcc_parent_data_0,	1144	.parent_data = gcc_parent_data_0,
1145	.num_parents = ARRAY_SIZE(gcc_parent_data_0),	1145	.num_parents = ARRAY_SIZE(gcc_parent_data_0),
1146	.ops = &clk_rcg2_floor_ops,	1146	.ops = &clk_rcg2_ops,
1147	},	1147	},
1148	};	1148	};
1149		1149

drivers/clk/versatile/clk-icst.c+1−1

 	regclk = icst_clk_setup(NULL, &icst_desc, name, parent_name, map, ctype);
 	if (IS_ERR(regclk)) {
-		kfree(name);
 		pr_err("error setting up syscon ICST clock %s\n", name);
+		kfree(name);
 		return;
 	}
 	of_clk_add_provider(np, of_clk_src_simple_get, regclk);

drivers/clocksource/arm_arch_timer.c+7−2

 static atomic_t timer_unstable_counter_workaround_in_use = ATOMIC_INIT(0);
-static void erratum_set_next_event_generic(const int access, unsigned long evt,
+/*
-						struct clock_event_device *clk)
+ * Force the inlining of this function so that the register accesses
+ * can be themselves correctly inlined.
+ */
+static __always_inline
+void erratum_set_next_event_generic(const int access, unsigned long evt,
+				    struct clock_event_device *clk)
 {
 	unsigned long ctrl;
 	u64 cval;

drivers/clocksource/dw_apb_timer_of.c+1−1

@@ -47,7 +47,7 @@ static int __init timer_get_base_and_rate(struct device_node *np, · 46 unmodified lines
47	pr_warn("pclk for %pOFn is present, but could not be activated\n",	47	pr_warn("pclk for %pOFn is present, but could not be activated\n",
48	np);	48	np);
49		49
50	if (!of_property_read_u32(np, "clock-freq", rate) &&	50	if (!of_property_read_u32(np, "clock-freq", rate) \|\|
51	!of_property_read_u32(np, "clock-frequency", rate))	51	!of_property_read_u32(np, "clock-frequency", rate))
52	return 0;	52	return 0;
53		53

drivers/firmware/scpi_pm_domain.c+7−3

 	struct generic_pm_domain genpd;
 	struct scpi_ops *ops;
 	u32 domain;
-	char name[30];
 };
 /*
 		scpi_pd->domain = i;
 		scpi_pd->ops = scpi_ops;
-		sprintf(scpi_pd->name, "%pOFn.%d", np, i);
+		scpi_pd->genpd.name = devm_kasprintf(dev, GFP_KERNEL,
-		scpi_pd->genpd.name = scpi_pd->name;
+						     "%pOFn.%d", np, i);
+		if (!scpi_pd->genpd.name) {
+			dev_err(dev, "Failed to allocate genpd name:%pOFn.%d\n",
+				np, i);
+			continue;
+		}
 		scpi_pd->genpd.power_off = scpi_pd_power_off;
 		scpi_pd->genpd.power_on = scpi_pd_power_on;

drivers/firmware/tegra/bpmp-debugfs.c+3−2

 	const char *root_path, *filename = NULL;
 	char *root_path_buf;
 	size_t root_len;
+	size_t root_path_buf_len = 512;
-	root_path_buf = kzalloc(512, GFP_KERNEL);
+	root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL);
 	if (!root_path_buf)
 		goto out;
 	root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf,
-				sizeof(root_path_buf));
+				root_path_buf_len);
 	if (IS_ERR(root_path))
 		goto out;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+6−1

 		 */
 		link_enc_cfg_init(dm->dc, dc_state);
-		amdgpu_dm_outbox_init(adev);
+		if (dc_enable_dmub_notifications(adev->dm.dc))
+			amdgpu_dm_outbox_init(adev);
 		r = dm_dmub_hw_init(adev);
 		if (r)
 	/* TODO: Remove dc_state->dccg, use dc->dccg directly. */
 	dc_resource_state_construct(dm->dc, dm_state->context);
+	/* Re-enable outbox interrupts for DPIA. */
+	if (dc_enable_dmub_notifications(adev->dm.dc))
+		amdgpu_dm_outbox_init(adev);
 	/* Before powering on DC we need to re-initialize DMUB. */
 	r = dm_dmub_hw_init(adev);
 	if (r)

drivers/gpu/drm/amd/display/dc/dc_link.h+2−0

 	*edp_num = 0;
 	for (i = 0; i < dc->link_count; i++) {
 		// report any eDP links, even unconnected DDI's
+		if (!dc->links[i])
+			continue;
 		if (dc->links[i]->connector_signal == SIGNAL_TYPE_EDP) {
 			edp_links[*edp_num] = dc->links[i];
 			if (++(*edp_num) == MAX_NUM_EDP)

drivers/gpu/drm/drm_syncobj.c+10−1

@@ -404,8 +404,17 @@ int drm_syncobj_find_fence(struct drm_file *file_private, · 403 unmodified lines
404		404
405	if (*fence) {	405	if (*fence) {
406	ret = dma_fence_chain_find_seqno(fence, point);	406	ret = dma_fence_chain_find_seqno(fence, point);
407	if (!ret)	407	if (!ret) {
		408	/* If the requested seqno is already signaled
		409	* drm_syncobj_find_fence may return a NULL
		410	* fence. To make sure the recipient gets
		411	* signalled, use a new fence instead.
		412	*/
		413	if (!*fence)
		414	*fence = dma_fence_get_stub();
		415
408	goto out;	416	goto out;
		417	}
409	dma_fence_put(*fence);	418	dma_fence_put(*fence);
410	} else {	419	} else {
411	ret = -EINVAL;	420	ret = -EINVAL;

drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c+1−0

@@ -3277,6 +3277,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, · 3276 unmodified lines
3277	out_fence = eb_requests_create(&eb, in_fence, out_fence_fd);	3277	out_fence = eb_requests_create(&eb, in_fence, out_fence_fd);
3278	if (IS_ERR(out_fence)) {	3278	if (IS_ERR(out_fence)) {
3279	err = PTR_ERR(out_fence);	3279	err = PTR_ERR(out_fence);
		3280	out_fence = NULL;
3280	if (eb.requests[0])	3281	if (eb.requests[0])
3281	goto err_request;	3282	goto err_request;
3282	else	3283	else

drivers/gpu/drm/i915/gt/intel_workarounds.c+9−9

 		    GAMT_CHKN_BIT_REG,
 		    GAMT_CHKN_DISABLE_L3_COH_PIPE);
+	/* Wa_1407352427:icl,ehl */
+	wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE2,
+		    PSDUNIT_CLKGATE_DIS);
+	/* Wa_1406680159:icl,ehl */
+	wa_write_or(wal,
+		    SUBSLICE_UNIT_LEVEL_CLKGATE,
+		    GWUNIT_CLKGATE_DIS);
 	/* Wa_1607087056:icl,ehl,jsl */
 	if (IS_ICELAKE(i915) ||
 	    IS_JSL_EHL_GT_STEP(i915, STEP_A0, STEP_B0))
 		wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE,
 			    VSUNIT_CLKGATE_DIS | HSUNIT_CLKGATE_DIS);
-		/* Wa_1407352427:icl,ehl */
-		wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE2,
-			    PSDUNIT_CLKGATE_DIS);
-		/* Wa_1406680159:icl,ehl */
-		wa_write_or(wal,
-			    SUBSLICE_UNIT_LEVEL_CLKGATE,
-			    GWUNIT_CLKGATE_DIS);
 		/*
 		 * Wa_1408767742:icl[a2..forever],ehl[all]
 		 * Wa_1605460711:icl[a0..c0]

drivers/gpu/drm/ttm/ttm_bo.c+2−1

 	 * as an indication that we're about to swap out.
 	 */
 	memset(&place, 0, sizeof(place));
-	place.mem_type = TTM_PL_SYSTEM;
+	place.mem_type = bo->resource->mem_type;
 	if (!ttm_bo_evict_swapout_allowable(bo, ctx, &place, &locked, NULL))
 		return -EBUSY;
 		struct ttm_place hop;
 		memset(&hop, 0, sizeof(hop));
+		place.mem_type = TTM_PL_SYSTEM;
 		ret = ttm_resource_alloc(bo, &place, &evict_mem);
 		if (unlikely(ret))
 			goto out;

drivers/hv/Kconfig+1−0

@@ -19,6 +19,7 @@ config HYPERV_TIMER · 18 unmodified lines
19	config HYPERV_UTILS	19	config HYPERV_UTILS
20	tristate "Microsoft Hyper-V Utilities driver"	20	tristate "Microsoft Hyper-V Utilities driver"
21	depends on HYPERV && CONNECTOR && NLS	21	depends on HYPERV && CONNECTOR && NLS
		22	depends on PTP_1588_CLOCK_OPTIONAL
22	help	23	help
23	Select this option to enable the Hyper-V Utilities.	24	Select this option to enable the Hyper-V Utilities.
24		25

drivers/hwmon/corsair-psu.c+1−1

@@ -729,7 +729,7 @@ static int corsairpsu_probe(struct hid_device *hdev, const struct hid_device_id · 728 unmodified lines
729	corsairpsu_check_cmd_support(priv);	729	corsairpsu_check_cmd_support(priv);
730		730
731	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "corsairpsu", priv,	731	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "corsairpsu", priv,
732	&corsairpsu_chip_info, 0);	732	&corsairpsu_chip_info, NULL);
733		733
734	if (IS_ERR(priv->hwmon_dev)) {	734	if (IS_ERR(priv->hwmon_dev)) {
735	ret = PTR_ERR(priv->hwmon_dev);	735	ret = PTR_ERR(priv->hwmon_dev);

drivers/hwmon/dell-smm-hwmon.c+3−4

@@ -627,10 +627,9 @@ static void __init i8k_init_procfs(struct device *dev) · 626 unmodified lines
627	{	627	{
628	struct dell_smm_data *data = dev_get_drvdata(dev);	628	struct dell_smm_data *data = dev_get_drvdata(dev);
629		629
630	/* Register the proc entry */	630	/* Only register exit function if creation was successful */
631	proc_create_data("i8k", 0, NULL, &i8k_proc_ops, data);	631	if (proc_create_data("i8k", 0, NULL, &i8k_proc_ops, data))
632		632	devm_add_action_or_reset(dev, i8k_exit_procfs, NULL);
633	devm_add_action_or_reset(dev, i8k_exit_procfs, NULL);
634	}	633	}
635		634
636	#else	635	#else

drivers/hwmon/nct6775.c+1−1

@@ -1527,7 +1527,7 @@ static u16 nct6775_wmi_read_value(struct nct6775_data *data, u16 reg) · 1526 unmodified lines
1527		1527
1528	nct6775_wmi_set_bank(data, reg);	1528	nct6775_wmi_set_bank(data, reg);
1529		1529
1530	err = nct6775_asuswmi_read(data->bank, reg, &tmp);	1530	err = nct6775_asuswmi_read(data->bank, reg & 0xff, &tmp);
1531	if (err)	1531	if (err)
1532	return 0;	1532	return 0;
1533		1533

drivers/hwmon/pwm-fan.c+0−2

@@ -336,8 +336,6 @@ static int pwm_fan_probe(struct platform_device *pdev) · 335 unmodified lines
336	return ret;	336	return ret;
337	}	337	}
338		338
339	ctx->pwm_value = MAX_PWM;
340
341	pwm_init_state(ctx->pwm, &ctx->pwm_state);	339	pwm_init_state(ctx->pwm, &ctx->pwm_state);
342		340
343	/*	341	/*

drivers/hwmon/sht4x.c+2−2

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	/*	23	/*
24	* I2C command delays (in microseconds)	24	* I2C command delays (in microseconds)
25	*/	25	*/
26	#define SHT4X_MEAS_DELAY 1000	26	#define SHT4X_MEAS_DELAY_HPM 8200 /* see t_MEAS,h in datasheet */
27	#define SHT4X_DELAY_EXTRA 10000	27	#define SHT4X_DELAY_EXTRA 10000
28		28
29	/*	29	/*
@@ -90,7 +90,7 @@ static int sht4x_read_values(struct sht4x_data *data) · 60 unmodified lines
90	if (ret < 0)	90	if (ret < 0)
91	goto unlock;	91	goto unlock;
92		92
93	usleep_range(SHT4X_MEAS_DELAY, SHT4X_MEAS_DELAY + SHT4X_DELAY_EXTRA);	93	usleep_range(SHT4X_MEAS_DELAY_HPM, SHT4X_MEAS_DELAY_HPM + SHT4X_DELAY_EXTRA);
94		94
95	ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH);	95	ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH);
96	if (ret != SHT4X_RESPONSE_LENGTH) {	96	if (ret != SHT4X_RESPONSE_LENGTH) {

drivers/i2c/busses/i2c-mpc.c+1−1

@@ -636,7 +636,7 @@ static irqreturn_t mpc_i2c_isr(int irq, void *dev_id) · 635 unmodified lines
636	status = readb(i2c->base + MPC_I2C_SR);	636	status = readb(i2c->base + MPC_I2C_SR);
637	if (status & CSR_MIF) {	637	if (status & CSR_MIF) {
638	/* Wait up to 100us for transfer to properly complete */	638	/* Wait up to 100us for transfer to properly complete */
639	readb_poll_timeout(i2c->base + MPC_I2C_SR, status, !(status & CSR_MCF), 0, 100);	639	readb_poll_timeout_atomic(i2c->base + MPC_I2C_SR, status, status & CSR_MCF, 0, 100);
640	writeb(0, i2c->base + MPC_I2C_SR);	640	writeb(0, i2c->base + MPC_I2C_SR);
641	mpc_i2c_do_intr(i2c, status);	641	mpc_i2c_do_intr(i2c, status);
642	return IRQ_HANDLED;	642	return IRQ_HANDLED;

drivers/i2c/busses/i2c-virtio.c+12−20

@@ -22,24 +22,24 @@ · 21 unmodified lines
22	/**	22	/**
23	* struct virtio_i2c - virtio I2C data	23	* struct virtio_i2c - virtio I2C data
24	* @vdev: virtio device for this controller	24	* @vdev: virtio device for this controller
25	* @completion: completion of virtio I2C message
26	* @adap: I2C adapter for this controller	25	* @adap: I2C adapter for this controller
27	* @vq: the virtio virtqueue for communication	26	* @vq: the virtio virtqueue for communication
28	*/	27	*/
29	struct virtio_i2c {	28	struct virtio_i2c {
30	struct virtio_device *vdev;	29	struct virtio_device *vdev;
31	struct completion completion;
32	struct i2c_adapter adap;	30	struct i2c_adapter adap;
33	struct virtqueue *vq;	31	struct virtqueue *vq;
34	};	32	};
35		33
36	/**	34	/**
37	* struct virtio_i2c_req - the virtio I2C request structure	35	* struct virtio_i2c_req - the virtio I2C request structure
		36	* @completion: completion of virtio I2C message
38	* @out_hdr: the OUT header of the virtio I2C message	37	* @out_hdr: the OUT header of the virtio I2C message
39	* @buf: the buffer into which data is read, or from which it's written	38	* @buf: the buffer into which data is read, or from which it's written
40	* @in_hdr: the IN header of the virtio I2C message	39	* @in_hdr: the IN header of the virtio I2C message
41	*/	40	*/
42	struct virtio_i2c_req {	41	struct virtio_i2c_req {
		42	struct completion completion;
43	struct virtio_i2c_out_hdr out_hdr ____cacheline_aligned;	43	struct virtio_i2c_out_hdr out_hdr ____cacheline_aligned;
44	uint8_t *buf ____cacheline_aligned;	44	uint8_t *buf ____cacheline_aligned;
45	struct virtio_i2c_in_hdr in_hdr ____cacheline_aligned;	45	struct virtio_i2c_in_hdr in_hdr ____cacheline_aligned;
@@ -47,9 +47,11 @@ struct virtio_i2c_req { · 1 unmodified line
47		47
48	static void virtio_i2c_msg_done(struct virtqueue *vq)	48	static void virtio_i2c_msg_done(struct virtqueue *vq)
49	{	49	{
50	struct virtio_i2c *vi = vq->vdev->priv;	50	struct virtio_i2c_req *req;
		51	unsigned int len;
51		52
52	complete(&vi->completion);	53	while ((req = virtqueue_get_buf(vq, &len)))
		54	complete(&req->completion);
53	}	55	}
54		56
55	static int virtio_i2c_prepare_reqs(struct virtqueue *vq,	57	static int virtio_i2c_prepare_reqs(struct virtqueue *vq,
@@ -62,6 +64,8 @@ static int virtio_i2c_prepare_reqs(struct virtqueue *vq, · 6 unmodified lines
62	for (i = 0; i < num; i++) {	64	for (i = 0; i < num; i++) {
63	int outcnt = 0, incnt = 0;	65	int outcnt = 0, incnt = 0;
64		66
		67	init_completion(&reqs[i].completion);
		68
65	/*	69	/*
66	* Only 7-bit mode supported for this moment. For the address	70	* Only 7-bit mode supported for this moment. For the address
67	* format, Please check the Virtio I2C Specification.	71	* format, Please check the Virtio I2C Specification.
@@ -106,21 +110,15 @@ static int virtio_i2c_complete_reqs(struct virtqueue *vq, · 38 unmodified lines
106	struct virtio_i2c_req *reqs,	110	struct virtio_i2c_req *reqs,
107	struct i2c_msg *msgs, int num)	111	struct i2c_msg *msgs, int num)
108	{	112	{
109	struct virtio_i2c_req *req;
110	bool failed = false;	113	bool failed = false;
111	unsigned int len;
112	int i, j = 0;	114	int i, j = 0;
113		115
114	for (i = 0; i < num; i++) {	116	for (i = 0; i < num; i++) {
115	/* Detach the ith request from the vq */	117	struct virtio_i2c_req *req = &reqs[i];
116	req = virtqueue_get_buf(vq, &len);
117		118
118	/*	119	wait_for_completion(&req->completion);
119	* Condition req == &reqs[i] should always meet since we have	120
120	* total num requests in the vq. reqs[i] can never be NULL here.	121	if (!failed && req->in_hdr.status != VIRTIO_I2C_MSG_OK)
121	*/
122	if (!failed && (WARN_ON(req != &reqs[i]) \|\|
123	req->in_hdr.status != VIRTIO_I2C_MSG_OK))
124	failed = true;	122	failed = true;
125		123
126	i2c_put_dma_safe_msg_buf(reqs[i].buf, &msgs[i], !failed);	124	i2c_put_dma_safe_msg_buf(reqs[i].buf, &msgs[i], !failed);
@@ -156,12 +154,8 @@ static int virtio_i2c_xfer(struct i2c_adapter adap, struct i2c_msg msgs, · 29 unmodified lines
156	* remote here to clear the virtqueue, so we can try another set of	154	* remote here to clear the virtqueue, so we can try another set of
157	* messages later on.	155	* messages later on.
158	*/	156	*/
159
160	reinit_completion(&vi->completion);
161	virtqueue_kick(vq);	157	virtqueue_kick(vq);
162		158
163	wait_for_completion(&vi->completion);
164
165	count = virtio_i2c_complete_reqs(vq, reqs, msgs, count);	159	count = virtio_i2c_complete_reqs(vq, reqs, msgs, count);
166		160
167	err_free:	161	err_free:
@@ -210,8 +204,6 @@ static int virtio_i2c_probe(struct virtio_device *vdev) · 42 unmodified lines
210	vdev->priv = vi;	204	vdev->priv = vi;
211	vi->vdev = vdev;	205	vi->vdev = vdev;
212		206
213	init_completion(&vi->completion);
214
215	ret = virtio_i2c_setup_vqs(vi);	207	ret = virtio_i2c_setup_vqs(vi);
216	if (ret)	208	if (ret)
217	return ret;	209	return ret;

drivers/iio/accel/kxcjk-1013.c+2−3

 	return 0;
 err_buffer_cleanup:
-	if (data->dready_trig)
+	iio_triggered_buffer_cleanup(indio_dev);
-		iio_triggered_buffer_cleanup(indio_dev);
 err_trigger_unregister:
 	if (data->dready_trig)
 		iio_trigger_unregister(data->dready_trig);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
+	iio_triggered_buffer_cleanup(indio_dev);
 	if (data->dready_trig) {
-		iio_triggered_buffer_cleanup(indio_dev);
 		iio_trigger_unregister(data->dready_trig);
 		iio_trigger_unregister(data->motion_trig);
 	}

drivers/iio/accel/kxsd9.c+3−3

 			       hw_values.chan,
 			       sizeof(hw_values.chan));
 	if (ret) {
-		dev_err(st->dev,
+		dev_err(st->dev, "error reading data: %d\n", ret);
-			"error reading data\n");
+		goto out;
-		return ret;
 	}
 	iio_push_to_buffers_with_timestamp(indio_dev,
 					   &hw_values,
 					   iio_get_time_ns(indio_dev));
+out:
 	iio_trigger_notify_done(indio_dev->trig);
 	return IRQ_HANDLED;

drivers/iio/accel/mma8452.c+1−1

@@ -1470,7 +1470,7 @@ static int mma8452_trigger_setup(struct iio_dev *indio_dev) · 1469 unmodified lines
1470	if (ret)	1470	if (ret)
1471	return ret;	1471	return ret;
1472		1472
1473	indio_dev->trig = trig;	1473	indio_dev->trig = iio_trigger_get(trig);
1474		1474
1475	return 0;	1475	return 0;
1476	}	1476	}

drivers/iio/adc/Kconfig+1−1

@@ -532,7 +532,7 @@ config IMX7D_ADC · 531 unmodified lines
532		532
533	config IMX8QXP_ADC	533	config IMX8QXP_ADC
534	tristate "NXP IMX8QXP ADC driver"	534	tristate "NXP IMX8QXP ADC driver"
535	depends on ARCH_MXC_ARM64 \|\| COMPILE_TEST	535	depends on ARCH_MXC \|\| COMPILE_TEST
536	depends on HAS_IOMEM	536	depends on HAS_IOMEM
537	help	537	help
538	Say yes here to build support for IMX8QXP ADC.	538	Say yes here to build support for IMX8QXP ADC.

drivers/iio/adc/ad7768-1.c+1−1

@@ -480,8 +480,8 @@ static irqreturn_t ad7768_trigger_handler(int irq, void *p) · 479 unmodified lines
480	iio_push_to_buffers_with_timestamp(indio_dev, &st->data.scan,	480	iio_push_to_buffers_with_timestamp(indio_dev, &st->data.scan,
481	iio_get_time_ns(indio_dev));	481	iio_get_time_ns(indio_dev));
482		482
483	iio_trigger_notify_done(indio_dev->trig);
484	err_unlock:	483	err_unlock:
		484	iio_trigger_notify_done(indio_dev->trig);
485	mutex_unlock(&st->lock);	485	mutex_unlock(&st->lock);
486		486
487	return IRQ_HANDLED;	487	return IRQ_HANDLED;

drivers/iio/adc/at91-sama5d2_adc.c+2−1

@@ -1586,7 +1586,8 @@ static int at91_adc_read_info_raw(struct iio_dev *indio_dev, · 1585 unmodified lines
1586	*val = st->conversion_value;	1586	*val = st->conversion_value;
1587	ret = at91_adc_adjust_val_osr(st, val);	1587	ret = at91_adc_adjust_val_osr(st, val);
1588	if (chan->scan_type.sign == 's')	1588	if (chan->scan_type.sign == 's')
1589	val = sign_extend32(val, 11);	1589	val = sign_extend32(val,
		1590	chan->scan_type.realbits - 1);
1590	st->conversion_done = false;	1591	st->conversion_done = false;
1591	}	1592	}
1592		1593

drivers/iio/adc/axp20x_adc.c+3−15

 			  struct iio_chan_spec const *chan, int *val)
 {
 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
-	int size;
-	/*
+	*val = axp20x_read_variable_width(info->regmap, chan->address, 12);
-	 * N.B.: Unlike the Chinese datasheets tell, the charging current is
-	 * stored on 12 bits, not 13 bits. Only discharging current is on 13
-	 * bits.
-	 */
-	if (chan->type == IIO_CURRENT && chan->channel == AXP22X_BATT_DISCHRG_I)
-		size = 13;
-	else
-		size = 12;
-	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
 	if (*val < 0)
 		return *val;
 		return IIO_VAL_INT_PLUS_MICRO;
 	case IIO_CURRENT:
-		*val = 0;
+		*val = 1;
-		*val2 = 500000;
+		return IIO_VAL_INT;
-		return IIO_VAL_INT_PLUS_MICRO;
 	case IIO_TEMP:
 		*val = 100;

drivers/iio/adc/dln2-adc.c+12−9

 static int dln2_adc_read(struct dln2_adc *dln2, unsigned int channel)
 {
 	int ret, i;
-	struct iio_dev *indio_dev = platform_get_drvdata(dln2->pdev);
 	u16 conflict;
 	__le16 value;
 	int olen = sizeof(value);
 		.chan = channel,
 	};
-	ret = iio_device_claim_direct_mode(indio_dev);
-	if (ret < 0)
-		return ret;
 	ret = dln2_adc_set_chan_enabled(dln2, channel, true);
 	if (ret < 0)
-		goto release_direct;
+		return ret;
 	ret = dln2_adc_set_port_enabled(dln2, true, &conflict);
 	if (ret < 0) {
 	dln2_adc_set_port_enabled(dln2, false, NULL);
 disable_chan:
 	dln2_adc_set_chan_enabled(dln2, channel, false);
-release_direct:
-	iio_device_release_direct_mode(indio_dev);
 	return ret;
 }
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
+		ret = iio_device_claim_direct_mode(indio_dev);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&dln2->mutex);
 		ret = dln2_adc_read(dln2, chan->channel);
 		mutex_unlock(&dln2->mutex);
+		iio_device_release_direct_mode(indio_dev);
 		if (ret < 0)
 			return ret;
 		return -ENOMEM;
 	}
 	iio_trigger_set_drvdata(dln2->trig, dln2);
-	devm_iio_trigger_register(dev, dln2->trig);
+	ret = devm_iio_trigger_register(dev, dln2->trig);
+	if (ret) {
+		dev_err(dev, "failed to register trigger: %d\n", ret);
+		return ret;
+	}
 	iio_trigger_set_immutable(indio_dev, dln2->trig);
 	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,

drivers/iio/adc/stm32-adc.c+2−1

 {
 	struct stm32_adc *adc = iio_priv(indio_dev);
+	stm32_adc_writel(adc, STM32H7_ADC_PCSEL, 0);
 	stm32h7_adc_disable(indio_dev);
 	stm32_adc_int_ch_disable(adc);
 	stm32h7_adc_enter_pwr_down(adc);
 			/* Get calibration data for vrefint channel */
 			ret = nvmem_cell_read_u16(&indio_dev->dev, "vrefint", &vrefint);
 			if (ret && ret != -ENOENT) {
-				return dev_err_probe(&indio_dev->dev, ret,
+				return dev_err_probe(indio_dev->dev.parent, ret,
 						     "nvmem access error\n");
 			}
 			if (ret == -ENOENT)

drivers/iio/gyro/adxrs290.c+3−2

  */
 #include <linux/bitfield.h>
+#include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 		goto err_unlock;
 	}
-	*val = temp;
+	*val = sign_extend32(temp, 15);
 err_unlock:
 	mutex_unlock(&st->lock);
 	}
 	/* extract lower 12 bits temperature reading */
-	*val = temp & 0x0FFF;
+	*val = sign_extend32(temp, 11);
 err_unlock:
 	mutex_unlock(&st->lock);

drivers/iio/gyro/itg3200_buffer.c+1−1

@@ -61,9 +61,9 @@ static irqreturn_t itg3200_trigger_handler(int irq, void *p) · 60 unmodified lines
61		61
62	iio_push_to_buffers_with_timestamp(indio_dev, &scan, pf->timestamp);	62	iio_push_to_buffers_with_timestamp(indio_dev, &scan, pf->timestamp);
63		63
		64	error_ret:
64	iio_trigger_notify_done(indio_dev->trig);	65	iio_trigger_notify_done(indio_dev->trig);
65		66
66	error_ret:
67	return IRQ_HANDLED;	67	return IRQ_HANDLED;
68	}	68	}
69		69

drivers/iio/industrialio-trigger.c+0−1

@@ -556,7 +556,6 @@ struct iio_trigger viio_trigger_alloc(struct device parent, · 555 unmodified lines
556	irq_modify_status(trig->subirq_base + i,	556	irq_modify_status(trig->subirq_base + i,
557	IRQ_NOREQUEST \| IRQ_NOAUTOEN, IRQ_NOPROBE);	557	IRQ_NOREQUEST \| IRQ_NOAUTOEN, IRQ_NOPROBE);
558	}	558	}
559	get_device(&trig->dev);
560		559
561	return trig;	560	return trig;
562		561

drivers/iio/light/ltr501.c+1−1

@@ -1275,7 +1275,7 @@ static irqreturn_t ltr501_trigger_handler(int irq, void *p) · 1274 unmodified lines
1275	ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,	1275	ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
1276	als_buf, sizeof(als_buf));	1276	als_buf, sizeof(als_buf));
1277	if (ret < 0)	1277	if (ret < 0)
1278	return ret;	1278	goto done;
1279	if (test_bit(0, indio_dev->active_scan_mask))	1279	if (test_bit(0, indio_dev->active_scan_mask))
1280	scan.channels[j++] = le16_to_cpu(als_buf[1]);	1280	scan.channels[j++] = le16_to_cpu(als_buf[1]);
1281	if (test_bit(1, indio_dev->active_scan_mask))	1281	if (test_bit(1, indio_dev->active_scan_mask))

drivers/iio/light/stk3310.c+3−3

 	mutex_lock(&data->lock);
 	ret = regmap_field_read(data->reg_flag_nf, &dir);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "register read failed\n");
+		dev_err(&data->client->dev, "register read failed: %d\n", ret);
-		mutex_unlock(&data->lock);
+		goto out;
-		return ret;
 	}
 	event = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1,
 				     IIO_EV_TYPE_THRESH,
 	ret = regmap_field_write(data->reg_flag_psint, 0);
 	if (ret < 0)
 		dev_err(&data->client->dev, "failed to reset interrupts\n");
+out:
 	mutex_unlock(&data->lock);
 	return IRQ_HANDLED;

drivers/iio/trigger/stm32-timer-trigger.c+1−1

@@ -912,6 +912,6 @@ static struct platform_driver stm32_timer_trigger_driver = { · 911 unmodified lines
912	};	912	};
913	module_platform_driver(stm32_timer_trigger_driver);	913	module_platform_driver(stm32_timer_trigger_driver);
914		914
915	MODULE_ALIAS("platform: stm32-timer-trigger");	915	MODULE_ALIAS("platform:stm32-timer-trigger");
916	MODULE_DESCRIPTION("STMicroelectronics STM32 Timer Trigger driver");	916	MODULE_DESCRIPTION("STMicroelectronics STM32 Timer Trigger driver");
917	MODULE_LICENSE("GPL v2");	917	MODULE_LICENSE("GPL v2");

drivers/infiniband/hw/hfi1/chip.c+2−0

  */
 static void __hfi1_rcd_eoi_intr(struct hfi1_ctxtdata *rcd)
 {
+	if (!rcd->rcvhdrq)
+		return;
 	clear_recv_intr(rcd);
 	if (check_packet_present(rcd))
 		force_recv_intr(rcd);

drivers/infiniband/hw/hfi1/driver.c+2−0

@@ -1012,6 +1012,8 @@ int handle_receive_interrupt(struct hfi1_ctxtdata *rcd, int thread) · 1011 unmodified lines
1012	struct hfi1_packet packet;	1012	struct hfi1_packet packet;
1013	int skip_pkt = 0;	1013	int skip_pkt = 0;
1014		1014
		1015	if (!rcd->rcvhdrq)
		1016	return RCV_PKT_OK;
1015	/* Control context will always use the slow path interrupt handler */	1017	/* Control context will always use the slow path interrupt handler */
1016	needset = (rcd->ctxt == HFI1_CTRL_CTXT) ? 0 : 1;	1018	needset = (rcd->ctxt == HFI1_CTRL_CTXT) ? 0 : 1;
1017		1019

drivers/infiniband/hw/hfi1/init.c+17−23

 	rcd->fast_handler = get_dma_rtail_setting(rcd) ?
 				handle_receive_interrupt_dma_rtail :
 				handle_receive_interrupt_nodma_rtail;
-	rcd->slow_handler = handle_receive_interrupt;
 	hfi1_set_seq_cnt(rcd, 1);
 		rcd->numa_id = numa;
 		rcd->rcv_array_groups = dd->rcv_entries.ngroups;
 		rcd->rhf_rcv_function_map = normal_rhf_rcv_functions;
+		rcd->slow_handler = handle_receive_interrupt;
+		rcd->do_interrupt = rcd->slow_handler;
 		rcd->msix_intr = CCE_NUM_MSIX_VECTORS;
 		mutex_init(&rcd->exp_mutex);
 	if (ret)
 		goto done;
-	/* allocate dummy tail memory for all receive contexts */
-	dd->rcvhdrtail_dummy_kvaddr = dma_alloc_coherent(&dd->pcidev->dev,
-							 sizeof(u64),
-							 &dd->rcvhdrtail_dummy_dma,
-							 GFP_KERNEL);
-	if (!dd->rcvhdrtail_dummy_kvaddr) {
-		dd_dev_err(dd, "cannot allocate dummy tail memory\n");
-		ret = -ENOMEM;
-		goto done;
-	}
 	/* dd->rcd can be NULL if early initialization failed */
 	for (i = 0; dd->rcd && i < dd->first_dyn_alloc_ctxt; ++i) {
 		/*
 		if (!rcd)
 			continue;
-		rcd->do_interrupt = &handle_receive_interrupt;
 		lastfail = hfi1_create_rcvhdrq(dd, rcd);
 		if (!lastfail)
 			lastfail = hfi1_setup_eagerbufs(rcd);
 	rcd->egrbufs.rcvtids = NULL;
 	for (e = 0; e < rcd->egrbufs.alloced; e++) {
-		if (rcd->egrbufs.buffers[e].dma)
+		if (rcd->egrbufs.buffers[e].addr)
 			dma_free_coherent(&dd->pcidev->dev,
 					  rcd->egrbufs.buffers[e].len,
 					  rcd->egrbufs.buffers[e].addr,
 	dd->tx_opstats    = NULL;
 	kfree(dd->comp_vect);
 	dd->comp_vect = NULL;
+	if (dd->rcvhdrtail_dummy_kvaddr)
+		dma_free_coherent(&dd->pcidev->dev, sizeof(u64),
+				  (void *)dd->rcvhdrtail_dummy_kvaddr,
+				  dd->rcvhdrtail_dummy_dma);
+	dd->rcvhdrtail_dummy_kvaddr = NULL;
 	sdma_clean(dd, dd->num_sdma);
 	rvt_dealloc_device(&dd->verbs_dev.rdi);
 }
 		goto bail;
 	}
+	/* allocate dummy tail memory for all receive contexts */
+	dd->rcvhdrtail_dummy_kvaddr =
+		dma_alloc_coherent(&dd->pcidev->dev, sizeof(u64),
+				   &dd->rcvhdrtail_dummy_dma, GFP_KERNEL);
+	if (!dd->rcvhdrtail_dummy_kvaddr) {
+		ret = -ENOMEM;
+		goto bail;
+	}
 	atomic_set(&dd->ipoib_rsm_usr_num, 0);
 	return dd;
 	free_credit_return(dd);
-	if (dd->rcvhdrtail_dummy_kvaddr) {
-		dma_free_coherent(&dd->pcidev->dev, sizeof(u64),
-				  (void *)dd->rcvhdrtail_dummy_kvaddr,
-				  dd->rcvhdrtail_dummy_dma);
-		dd->rcvhdrtail_dummy_kvaddr = NULL;
-	}
 	/*
 	 * Free any resources still in use (usually just kernel contexts)
 	 * at unload; we do for ctxtcnt, because that's what we allocate.

drivers/infiniband/hw/hfi1/sdma.c+1−1

@@ -838,8 +838,8 @@ struct sdma_engine sdma_select_user_engine(struct hfi1_devdata dd, · 837 unmodified lines
838	if (current->nr_cpus_allowed != 1)	838	if (current->nr_cpus_allowed != 1)
839	goto out;	839	goto out;
840		840
841	cpu_id = smp_processor_id();
842	rcu_read_lock();	841	rcu_read_lock();
		842	cpu_id = smp_processor_id();
843	rht_node = rhashtable_lookup(dd->sdma_rht, &cpu_id,	843	rht_node = rhashtable_lookup(dd->sdma_rht, &cpu_id,
844	sdma_rht_params);	844	sdma_rht_params);
845		845

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

@@ -33,6 +33,7 @@ · 32 unmodified lines
33	#include <linux/acpi.h>	33	#include <linux/acpi.h>
34	#include <linux/etherdevice.h>	34	#include <linux/etherdevice.h>
35	#include <linux/interrupt.h>	35	#include <linux/interrupt.h>
		36	#include <linux/iopoll.h>
36	#include <linux/kernel.h>	37	#include <linux/kernel.h>
37	#include <linux/types.h>	38	#include <linux/types.h>
38	#include <net/addrconf.h>	39	#include <net/addrconf.h>
@@ -1050,9 +1051,14 @@ static u32 hns_roce_v2_cmd_hw_resetting(struct hns_roce_dev *hr_dev, · 1011 unmodified lines
1050	unsigned long instance_stage,	1051	unsigned long instance_stage,
1051	unsigned long reset_stage)	1052	unsigned long reset_stage)
1052	{	1053	{
		1054	#define HW_RESET_TIMEOUT_US 1000000
		1055	#define HW_RESET_SLEEP_US 1000
		1056
1053	struct hns_roce_v2_priv *priv = hr_dev->priv;	1057	struct hns_roce_v2_priv *priv = hr_dev->priv;
1054	struct hnae3_handle *handle = priv->handle;	1058	struct hnae3_handle *handle = priv->handle;
1055	const struct hnae3_ae_ops *ops = handle->ae_algo->ops;	1059	const struct hnae3_ae_ops *ops = handle->ae_algo->ops;
		1060	unsigned long val;
		1061	int ret;
1056		1062
1057	/* When hardware reset is detected, we should stop sending mailbox&cmq&	1063	/* When hardware reset is detected, we should stop sending mailbox&cmq&
1058	* doorbell to hardware. If now in .init_instance() function, we should	1064	* doorbell to hardware. If now in .init_instance() function, we should
@@ -1064,7 +1070,11 @@ static u32 hns_roce_v2_cmd_hw_resetting(struct hns_roce_dev *hr_dev, · 5 unmodified lines
1064	* again.	1070	* again.
1065	*/	1071	*/
1066	hr_dev->dis_db = true;	1072	hr_dev->dis_db = true;
1067	if (!ops->get_hw_reset_stat(handle))	1073
		1074	ret = read_poll_timeout(ops->ae_dev_reset_cnt, val,
		1075	val > hr_dev->reset_cnt, HW_RESET_SLEEP_US,
		1076	HW_RESET_TIMEOUT_US, false, handle);
		1077	if (!ret)
1068	hr_dev->is_reset = true;	1078	hr_dev->is_reset = true;
1069		1079
1070	if (!hr_dev->is_reset \|\| reset_stage == HNS_ROCE_STATE_RST_INIT \|\|	1080	if (!hr_dev->is_reset \|\| reset_stage == HNS_ROCE_STATE_RST_INIT \|\|
@@ -6387,10 +6397,8 @@ static int hns_roce_hw_v2_reset_notify_down(struct hnae3_handle *handle) · 5316 unmodified lines
6387	if (!hr_dev)	6397	if (!hr_dev)
6388	return 0;	6398	return 0;
6389		6399
6390	hr_dev->is_reset = true;
6391	hr_dev->active = false;	6400	hr_dev->active = false;
6392	hr_dev->dis_db = true;	6401	hr_dev->dis_db = true;
6393
6394	hr_dev->state = HNS_ROCE_DEVICE_STATE_RST_DOWN;	6402	hr_dev->state = HNS_ROCE_DEVICE_STATE_RST_DOWN;
6395		6403
6396	return 0;	6404	return 0;

drivers/infiniband/hw/irdma/hw.c+6−1

 {
 	struct irdma_cq *cq = iwcq->back_cq;
+	if (!cq->user_mode)
+		cq->armed = false;
 	if (cq->ibcq.comp_handler)
 		cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
 }
 		qp->flush_code = FLUSH_PROT_ERR;
 		break;
 	case IRDMA_AE_AMP_BAD_QP:
+	case IRDMA_AE_WQE_UNEXPECTED_OPCODE:
 		qp->flush_code = FLUSH_LOC_QP_OP_ERR;
 		break;
 	case IRDMA_AE_AMP_BAD_STAG_KEY:
 	case IRDMA_AE_PRIV_OPERATION_DENIED:
 	case IRDMA_AE_IB_INVALID_REQUEST:
 	case IRDMA_AE_IB_REMOTE_ACCESS_ERROR:
-	case IRDMA_AE_IB_REMOTE_OP_ERROR:
 		qp->flush_code = FLUSH_REM_ACCESS_ERR;
 		qp->event_type = IRDMA_QP_EVENT_ACCESS_ERR;
 		break;
 	case IRDMA_AE_AMP_MWBIND_INVALID_BOUNDS:
 		qp->flush_code = FLUSH_MW_BIND_ERR;
 		break;
+	case IRDMA_AE_IB_REMOTE_OP_ERROR:
+		qp->flush_code = FLUSH_REM_OP_ERR;
+		break;
 	default:
 		qp->flush_code = FLUSH_FATAL_ERR;
 		break;

drivers/infiniband/hw/irdma/main.h+1−0

@@ -542,6 +542,7 @@ int irdma_ah_cqp_op(struct irdma_pci_f rf, struct irdma_sc_ah sc_ah, u8 cmd, · 541 unmodified lines
542	void (callback_fcn)(struct irdma_cqp_request cqp_request),	542	void (callback_fcn)(struct irdma_cqp_request cqp_request),
543	void *cb_param);	543	void *cb_param);
544	void irdma_gsi_ud_qp_ah_cb(struct irdma_cqp_request *cqp_request);	544	void irdma_gsi_ud_qp_ah_cb(struct irdma_cqp_request *cqp_request);
		545	bool irdma_cq_empty(struct irdma_cq *iwcq);
545	int irdma_inetaddr_event(struct notifier_block *notifier, unsigned long event,	546	int irdma_inetaddr_event(struct notifier_block *notifier, unsigned long event,
546	void *ptr);	547	void *ptr);
547	int irdma_inet6addr_event(struct notifier_block *notifier, unsigned long event,	548	int irdma_inet6addr_event(struct notifier_block *notifier, unsigned long event,

drivers/infiniband/hw/irdma/pble.c+3−5

 		list_del(&chunk->list);
 		if (chunk->type == PBLE_SD_PAGED)
 			irdma_pble_free_paged_mem(chunk);
-		if (chunk->bitmapbuf)
+		bitmap_free(chunk->bitmapbuf);
-			kfree(chunk->bitmapmem.va);
 		kfree(chunk->chunkmem.va);
 	}
 }
 		  "PBLE: next_fpm_addr = %llx chunk_size[%llu] = 0x%llx\n",
 		  pble_rsrc->next_fpm_addr, chunk->size, chunk->size);
 	pble_rsrc->unallocated_pble -= (u32)(chunk->size >> 3);
-	list_add(&chunk->list, &pble_rsrc->pinfo.clist);
 	sd_reg_val = (sd_entry_type == IRDMA_SD_TYPE_PAGED) ?
 			     sd_entry->u.pd_table.pd_page_addr.pa :
 			     sd_entry->u.bp.addr.pa;
 			goto error;
 	}
+	list_add(&chunk->list, &pble_rsrc->pinfo.clist);
 	sd_entry->valid = true;
 	return 0;
 error:
-	if (chunk->bitmapbuf)
+	bitmap_free(chunk->bitmapbuf);
-		kfree(chunk->bitmapmem.va);
 	kfree(chunk->chunkmem.va);
 	return ret_code;

drivers/infiniband/hw/irdma/pble.h+0−1

@@ -78,7 +78,6 @@ struct irdma_chunk { · 77 unmodified lines
78	u32 pg_cnt;	78	u32 pg_cnt;
79	enum irdma_alloc_type type;	79	enum irdma_alloc_type type;
80	struct irdma_sc_dev *dev;	80	struct irdma_sc_dev *dev;
81	struct irdma_virt_mem bitmapmem;
82	struct irdma_virt_mem chunkmem;	81	struct irdma_virt_mem chunkmem;
83	};	82	};
84		83

drivers/infiniband/hw/irdma/utils.c+17−7

 	sizeofbitmap = (u64)pchunk->size >> pprm->pble_shift;
-	pchunk->bitmapmem.size = sizeofbitmap >> 3;
+	pchunk->bitmapbuf = bitmap_zalloc(sizeofbitmap, GFP_KERNEL);
-	pchunk->bitmapmem.va = kzalloc(pchunk->bitmapmem.size, GFP_KERNEL);
+	if (!pchunk->bitmapbuf)
-	if (!pchunk->bitmapmem.va)
 		return IRDMA_ERR_NO_MEMORY;
-	pchunk->bitmapbuf = pchunk->bitmapmem.va;
-	bitmap_zero(pchunk->bitmapbuf, sizeofbitmap);
 	pchunk->sizeofbitmap = sizeofbitmap;
 	/* each pble is 8 bytes hence shift by 3 */
 	pprm->total_pble_alloc += pchunk->size >> 3;
 	ibevent.element.qp = &iwqp->ibqp;
 	iwqp->ibqp.event_handler(&ibevent, iwqp->ibqp.qp_context);
 }
+bool irdma_cq_empty(struct irdma_cq *iwcq)
+{
+	struct irdma_cq_uk *ukcq;
+	u64 qword3;
+	__le64 *cqe;
+	u8 polarity;
+	ukcq  = &iwcq->sc_cq.cq_uk;
+	cqe = IRDMA_GET_CURRENT_CQ_ELEM(ukcq);
+	get_64bit_val(cqe, 24, &qword3);
+	polarity = (u8)FIELD_GET(IRDMA_CQ_VALID, qword3);
+	return polarity != ukcq->polarity;
+}

drivers/infiniband/hw/irdma/verbs.c+18−5

 	struct irdma_cq *iwcq;
 	struct irdma_cq_uk *ukcq;
 	unsigned long flags;
-	enum irdma_cmpl_notify cq_notify = IRDMA_CQ_COMPL_EVENT;
+	enum irdma_cmpl_notify cq_notify;
+	bool promo_event = false;
+	int ret = 0;
+	cq_notify = notify_flags == IB_CQ_SOLICITED ?
+		    IRDMA_CQ_COMPL_SOLICITED : IRDMA_CQ_COMPL_EVENT;
 	iwcq = to_iwcq(ibcq);
 	ukcq = &iwcq->sc_cq.cq_uk;
-	if (notify_flags == IB_CQ_SOLICITED)
-		cq_notify = IRDMA_CQ_COMPL_SOLICITED;
 	spin_lock_irqsave(&iwcq->lock, flags);
-	irdma_uk_cq_request_notification(ukcq, cq_notify);
+	/* Only promote to arm the CQ for any event if the last arm event was solicited. */
+	if (iwcq->last_notify == IRDMA_CQ_COMPL_SOLICITED && notify_flags != IB_CQ_SOLICITED)
+		promo_event = true;
+	if (!iwcq->armed || promo_event) {
+		iwcq->armed = true;
+		iwcq->last_notify = cq_notify;
+		irdma_uk_cq_request_notification(ukcq, cq_notify);
+	}
+	if ((notify_flags & IB_CQ_REPORT_MISSED_EVENTS) && !irdma_cq_empty(iwcq))
+		ret = 1;
 	spin_unlock_irqrestore(&iwcq->lock, flags);
-	return 0;
+	return ret;
 }
 static int irdma_roce_port_immutable(struct ib_device *ibdev, u32 port_num,

drivers/infiniband/hw/irdma/verbs.h+2−0

 	u16 cq_size;
 	u16 cq_num;
 	bool user_mode;
+	bool armed;
+	enum irdma_cmpl_notify last_notify;
 	u32 polled_cmpls;
 	u32 cq_mem_size;
 	struct irdma_dma_mem kmem;

drivers/infiniband/hw/mlx5/mlx5_ib.h+3−3

 	/* User MR data */
 	struct mlx5_cache_ent *cache_ent;
-	struct ib_umem *umem;
 	/* This is zero'd when the MR is allocated */
 	union {
 			struct list_head list;
 		};
-		/* Used only by kernel MRs (umem == NULL) */
+		/* Used only by kernel MRs */
 		struct {
 			void *descs;
 			void *descs_alloc;
 			int data_length;
 		};
-		/* Used only by User MRs (umem != NULL) */
+		/* Used only by User MRs */
 		struct {
+			struct ib_umem *umem;
 			unsigned int page_shift;
 			/* Current access_flags */
 			int access_flags;

drivers/infiniband/hw/mlx5/mr.c+12−14

@@ -1904,19 +1904,18 @@ err: · 1903 unmodified lines
1904	return ret;	1904	return ret;
1905	}	1905	}
1906		1906
1907	static void	1907	static void mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1908	mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1909	{	1908	{
1910	if (!mr->umem && mr->descs) {	1909	struct mlx5_ib_dev *dev = to_mdev(mr->ibmr.device);
1911	struct ib_device *device = mr->ibmr.device;	1910	int size = mr->max_descs * mr->desc_size;
1912	int size = mr->max_descs * mr->desc_size;
1913	struct mlx5_ib_dev *dev = to_mdev(device);
1914		1911
1915	dma_unmap_single(&dev->mdev->pdev->dev, mr->desc_map, size,	1912	if (!mr->descs)
1916	DMA_TO_DEVICE);	1913	return;
1917	kfree(mr->descs_alloc);	1914
1918	mr->descs = NULL;	1915	dma_unmap_single(&dev->mdev->pdev->dev, mr->desc_map, size,
1919	}	1916	DMA_TO_DEVICE);
		1917	kfree(mr->descs_alloc);
		1918	mr->descs = NULL;
1920	}	1919	}
1921		1920
1922	int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata)	1921	int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata)
@@ -1992,7 +1991,8 @@ int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata) · 69 unmodified lines
1992	if (mr->cache_ent) {	1991	if (mr->cache_ent) {
1993	mlx5_mr_cache_free(dev, mr);	1992	mlx5_mr_cache_free(dev, mr);
1994	} else {	1993	} else {
1995	mlx5_free_priv_descs(mr);	1994	if (!udata)
		1995	mlx5_free_priv_descs(mr);
1996	kfree(mr);	1996	kfree(mr);
1997	}	1997	}
1998	return 0;	1998	return 0;
@@ -2079,7 +2079,6 @@ static struct mlx5_ib_mr mlx5_ib_alloc_pi_mr(struct ib_pd pd, · 80 unmodified lines
2079	if (err)	2079	if (err)
2080	goto err_free_in;	2080	goto err_free_in;
2081		2081
2082	mr->umem = NULL;
2083	kfree(in);	2082	kfree(in);
2084		2083
2085	return mr;	2084	return mr;
@@ -2206,7 +2205,6 @@ static struct ib_mr __mlx5_ib_alloc_mr(struct ib_pd pd, · 120 unmodified lines
2206	}	2205	}
2207		2206
2208	mr->ibmr.device = pd->device;	2207	mr->ibmr.device = pd->device;
2209	mr->umem = NULL;
2210		2208
2211	switch (mr_type) {	2209	switch (mr_type) {
2212	case IB_MR_TYPE_MEM_REG:	2210	case IB_MR_TYPE_MEM_REG:

drivers/infiniband/sw/rxe/rxe_qp.c+1−0

@@ -359,6 +359,7 @@ int rxe_qp_from_init(struct rxe_dev rxe, struct rxe_qp qp, struct rxe_pd *pd, · 358 unmodified lines
359		359
360	err2:	360	err2:
361	rxe_queue_cleanup(qp->sq.queue);	361	rxe_queue_cleanup(qp->sq.queue);
		362	qp->sq.queue = NULL;
362	err1:	363	err1:
363	qp->pd = NULL;	364	qp->pd = NULL;
364	qp->rcq = NULL;	365	qp->rcq = NULL;

drivers/infiniband/ulp/rtrs/rtrs-clt-stats.c+6−3

 	int cpu;
 	cpu = raw_smp_processor_id();
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	if (con->cpu != cpu) {
 		s->cpu_migr.to++;
 		s = per_cpu_ptr(stats->pcpu_stats, con->cpu);
 		atomic_inc(&s->cpu_migr.from);
 	}
+	put_cpu_ptr(stats->pcpu_stats);
 }
 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *stats)
 {
 	struct rtrs_clt_stats_pcpu *s;
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	s->rdma.failover_cnt++;
+	put_cpu_ptr(stats->pcpu_stats);
 }
 int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf)
 {
 	struct rtrs_clt_stats_pcpu *s;
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	s->rdma.dir[d].cnt++;
 	s->rdma.dir[d].size_total += size;
+	put_cpu_ptr(stats->pcpu_stats);
 }
 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir)

drivers/irqchip/irq-apple-aic.c+1−1

@@ -707,7 +707,7 @@ static const struct irq_domain_ops aic_ipi_domain_ops = { · 706 unmodified lines
707	.free = aic_ipi_free,	707	.free = aic_ipi_free,
708	};	708	};
709		709
710	static int aic_init_smp(struct aic_irq_chip irqc, struct device_node node)	710	static int __init aic_init_smp(struct aic_irq_chip irqc, struct device_node node)
711	{	711	{
712	struct irq_domain *ipi_domain;	712	struct irq_domain *ipi_domain;
713	int base_ipi;	713	int base_ipi;

drivers/irqchip/irq-armada-370-xp.c+6−10

 	int hwirq, i;
 	mutex_lock(&msi_used_lock);
+	hwirq = bitmap_find_free_region(msi_used, PCI_MSI_DOORBELL_NR,
+					order_base_2(nr_irqs));
+	mutex_unlock(&msi_used_lock);
-	hwirq = bitmap_find_next_zero_area(msi_used, PCI_MSI_DOORBELL_NR,
+	if (hwirq < 0)
-					   0, nr_irqs, 0);
-	if (hwirq >= PCI_MSI_DOORBELL_NR) {
-		mutex_unlock(&msi_used_lock);
 		return -ENOSPC;
-	}
-	bitmap_set(msi_used, hwirq, nr_irqs);
-	mutex_unlock(&msi_used_lock);
 	for (i = 0; i < nr_irqs; i++) {
 		irq_domain_set_info(domain, virq + i, hwirq + i,
 				    NULL, NULL);
 	}
-	return hwirq;
+	return 0;
 }
 static void armada_370_xp_msi_free(struct irq_domain *domain,
 	struct irq_data *d = irq_domain_get_irq_data(domain, virq);
 	mutex_lock(&msi_used_lock);
-	bitmap_clear(msi_used, d->hwirq, nr_irqs);
+	bitmap_release_region(msi_used, d->hwirq, order_base_2(nr_irqs));
 	mutex_unlock(&msi_used_lock);
 }

drivers/irqchip/irq-aspeed-scu-ic.c+2−2

@@ -76,8 +76,8 @@ static void aspeed_scu_ic_irq_handler(struct irq_desc *desc) · 75 unmodified lines
76	generic_handle_domain_irq(scu_ic->irq_domain,	76	generic_handle_domain_irq(scu_ic->irq_domain,
77	bit - scu_ic->irq_shift);	77	bit - scu_ic->irq_shift);
78		78
79	regmap_update_bits(scu_ic->scu, scu_ic->reg, mask,	79	regmap_write_bits(scu_ic->scu, scu_ic->reg, mask,
80	BIT(bit + ASPEED_SCU_IC_STATUS_SHIFT));	80	BIT(bit + ASPEED_SCU_IC_STATUS_SHIFT));
81	}	81	}
82		82
83	chained_irq_exit(chip, desc);	83	chained_irq_exit(chip, desc);

drivers/irqchip/irq-bcm7120-l2.c+1−0

@@ -238,6 +238,7 @@ static int __init bcm7120_l2_intc_probe(struct device_node *dn, · 237 unmodified lines
238	}	238	}
239		239
240	data->num_parent_irqs = platform_irq_count(pdev);	240	data->num_parent_irqs = platform_irq_count(pdev);
		241	put_device(&pdev->dev);
241	if (data->num_parent_irqs <= 0) {	242	if (data->num_parent_irqs <= 0) {
242	pr_err("invalid number of parent interrupts\n");	243	pr_err("invalid number of parent interrupts\n");
243	ret = -ENOMEM;	244	ret = -ENOMEM;

drivers/irqchip/irq-gic-v3-its.c+1−1

@@ -742,7 +742,7 @@ static struct its_collection its_build_invall_cmd(struct its_node its, · 741 unmodified lines
742		742
743	its_fixup_cmd(cmd);	743	its_fixup_cmd(cmd);
744		744
745	return NULL;	745	return desc->its_invall_cmd.col;
746	}	746	}
747		747
748	static struct its_vpe its_build_vinvall_cmd(struct its_node its,	748	static struct its_vpe its_build_vinvall_cmd(struct its_node its,

drivers/irqchip/irq-mips-gic.c+2−2

 #define pr_fmt(fmt) "irq-mips-gic: " fmt
+#include <linux/bitfield.h>
 #include <linux/bitmap.h>
 #include <linux/clocksource.h>
 #include <linux/cpuhotplug.h>
 	mips_gic_base = ioremap(gic_base, gic_len);
 	gicconfig = read_gic_config();
-	gic_shared_intrs = gicconfig & GIC_CONFIG_NUMINTERRUPTS;
+	gic_shared_intrs = FIELD_GET(GIC_CONFIG_NUMINTERRUPTS, gicconfig);
-	gic_shared_intrs >>= __ffs(GIC_CONFIG_NUMINTERRUPTS);
 	gic_shared_intrs = (gic_shared_intrs + 1) * 8;
 	if (cpu_has_veic) {

drivers/irqchip/irq-nvic.c+1−1

@@ -26,7 +26,7 @@ · 25 unmodified lines
26		26
27	#define NVIC_ISER 0x000	27	#define NVIC_ISER 0x000
28	#define NVIC_ICER 0x080	28	#define NVIC_ICER 0x080
29	#define NVIC_IPR 0x300	29	#define NVIC_IPR 0x400
30		30
31	#define NVIC_MAX_BANKS 16	31	#define NVIC_MAX_BANKS 16
32	/*	32	/*

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

@@ -1963,7 +1963,7 @@ static bool __journal_read_write(struct dm_integrity_io dio, struct bio bio, · 1962 unmodified lines
1963	n_sectors -= bv.bv_len >> SECTOR_SHIFT;	1963	n_sectors -= bv.bv_len >> SECTOR_SHIFT;
1964	bio_advance_iter(bio, &bio->bi_iter, bv.bv_len);	1964	bio_advance_iter(bio, &bio->bi_iter, bv.bv_len);
1965	retry_kmap:	1965	retry_kmap:
1966	mem = bvec_kmap_local(&bv);	1966	mem = kmap_local_page(bv.bv_page);
1967	if (likely(dio->op == REQ_OP_WRITE))	1967	if (likely(dio->op == REQ_OP_WRITE))
1968	flush_dcache_page(bv.bv_page);	1968	flush_dcache_page(bv.bv_page);
1969		1969

drivers/md/md.c+3−1

 		if (!num_sectors || num_sectors > max_sectors)
 			num_sectors = max_sectors;
+		rdev->sb_start = sb_start;
 	}
 	sb = page_address(rdev->sb_page);
 	sb->data_size = cpu_to_le64(num_sectors);
 	spin_lock(&mddev->lock);
 	mddev->pers = NULL;
 	spin_unlock(&mddev->lock);
-	pers->free(mddev, mddev->private);
+	if (mddev->private)
+		pers->free(mddev, mddev->private);
 	mddev->private = NULL;
 	if (pers->sync_request && mddev->to_remove == NULL)
 		mddev->to_remove = &md_redundancy_group;

drivers/md/persistent-data/dm-btree-remove.c+1−1

@@ -423,9 +423,9 @@ static int rebalance_children(struct shadow_spine *s, · 422 unmodified lines
423		423
424	memcpy(n, dm_block_data(child),	424	memcpy(n, dm_block_data(child),
425	dm_bm_block_size(dm_tm_get_bm(info->tm)));	425	dm_bm_block_size(dm_tm_get_bm(info->tm)));
426	dm_tm_unlock(info->tm, child);
427		426
428	dm_tm_dec(info->tm, dm_block_location(child));	427	dm_tm_dec(info->tm, dm_block_location(child));
		428	dm_tm_unlock(info->tm, child);
429	return 0;	429	return 0;
430	}	430	}
431		431

drivers/misc/cardreader/rtsx_pcr.c+0−4

 	mutex_lock(&pcr->pcr_mutex);
 	rtsx_pci_power_off(pcr, HOST_ENTER_S3);
-	free_irq(pcr->irq, (void *)pcr);
 	mutex_unlock(&pcr->pcr_mutex);
 	pcr->is_runtime_suspended = true;
 	mutex_lock(&pcr->pcr_mutex);
 	rtsx_pci_write_register(pcr, HOST_SLEEP_STATE, 0x03, 0x00);
-	rtsx_pci_acquire_irq(pcr);
-	synchronize_irq(pcr->irq);
 	if (pcr->ops->fetch_vendor_settings)
 		pcr->ops->fetch_vendor_settings(pcr);

drivers/misc/eeprom/at25.c+18−20

 static int at25_probe(struct spi_device *spi)
 {
 	struct at25_data	*at25 = NULL;
-	struct spi_eeprom	chip;
 	int			err;
 	int			sr;
 	u8 id[FM25_ID_LEN];
 	if (match && !strcmp(match->compatible, "cypress,fm25"))
 		is_fram = 1;
+	at25 = devm_kzalloc(&spi->dev, sizeof(struct at25_data), GFP_KERNEL);
+	if (!at25)
+		return -ENOMEM;
 	/* Chip description */
-	if (!spi->dev.platform_data) {
+	if (spi->dev.platform_data) {
-		if (!is_fram) {
+		memcpy(&at25->chip, spi->dev.platform_data, sizeof(at25->chip));
-			err = at25_fw_to_chip(&spi->dev, &chip);
+	} else if (!is_fram) {
-			if (err)
+		err = at25_fw_to_chip(&spi->dev, &at25->chip);
-				return err;
+		if (err)
-		}
+			return err;
-	} else
+	}
-		chip = *(struct spi_eeprom *)spi->dev.platform_data;
 	/* Ping the chip ... the status register is pretty portable,
 	 * unlike probing manufacturer IDs.  We do expect that system
 		return -ENXIO;
 	}
-	at25 = devm_kzalloc(&spi->dev, sizeof(struct at25_data), GFP_KERNEL);
-	if (!at25)
-		return -ENOMEM;
 	mutex_init(&at25->lock);
-	at25->chip = chip;
 	at25->spi = spi;
 	spi_set_drvdata(spi, at25);
 			dev_err(&spi->dev, "Error: unsupported size (id %02x)\n", id[7]);
 			return -ENODEV;
 		}
-		chip.byte_len = int_pow(2, id[7] - 0x21 + 4) * 1024;
+		at25->chip.byte_len = int_pow(2, id[7] - 0x21 + 4) * 1024;
 		if (at25->chip.byte_len > 64 * 1024)
 			at25->chip.flags |= EE_ADDR3;
 	at25->nvmem_config.type = is_fram ? NVMEM_TYPE_FRAM : NVMEM_TYPE_EEPROM;
 	at25->nvmem_config.name = dev_name(&spi->dev);
 	at25->nvmem_config.dev = &spi->dev;
-	at25->nvmem_config.read_only = chip.flags & EE_READONLY;
+	at25->nvmem_config.read_only = at25->chip.flags & EE_READONLY;
 	at25->nvmem_config.root_only = true;
 	at25->nvmem_config.owner = THIS_MODULE;
 	at25->nvmem_config.compat = true;
 	at25->nvmem_config.priv = at25;
 	at25->nvmem_config.stride = 1;
 	at25->nvmem_config.word_size = 1;
-	at25->nvmem_config.size = chip.byte_len;
+	at25->nvmem_config.size = at25->chip.byte_len;
 	at25->nvmem = devm_nvmem_register(&spi->dev, &at25->nvmem_config);
 	if (IS_ERR(at25->nvmem))
 		return PTR_ERR(at25->nvmem);
 	dev_info(&spi->dev, "%d %s %s %s%s, pagesize %u\n",
-		 (chip.byte_len < 1024) ? chip.byte_len : (chip.byte_len / 1024),
+		 (at25->chip.byte_len < 1024) ?
-		 (chip.byte_len < 1024) ? "Byte" : "KByte",
+			at25->chip.byte_len : (at25->chip.byte_len / 1024),
+		 (at25->chip.byte_len < 1024) ? "Byte" : "KByte",
 		 at25->chip.name, is_fram ? "fram" : "eeprom",
-		 (chip.flags & EE_READONLY) ? " (readonly)" : "",
+		 (at25->chip.flags & EE_READONLY) ? " (readonly)" : "",
 		 at25->chip.page_size);
 	return 0;
 }

drivers/misc/fastrpc.c+6−4

 static u64 fastrpc_get_payload_size(struct fastrpc_invoke_ctx *ctx, int metalen)
 {
 	u64 size = 0;
-	int i;
+	int oix;
 	size = ALIGN(metalen, FASTRPC_ALIGN);
-	for (i = 0; i < ctx->nscalars; i++) {
+	for (oix = 0; oix < ctx->nbufs; oix++) {
+		int i = ctx->olaps[oix].raix;
 		if (ctx->args[i].fd == 0 || ctx->args[i].fd == -1) {
-			if (ctx->olaps[i].offset == 0)
+			if (ctx->olaps[oix].offset == 0)
 				size = ALIGN(size, FASTRPC_ALIGN);
-			size += (ctx->olaps[i].mend - ctx->olaps[i].mstart);
+			size += (ctx->olaps[oix].mend - ctx->olaps[oix].mstart);
 		}
 	}

drivers/mmc/host/mtk-sd.c+3−1

 			sdr_set_field(host->base + PAD_DS_TUNE,
 				      PAD_DS_TUNE_DLY1, i);
 		ret = mmc_get_ext_csd(card, &ext_csd);
-		if (!ret)
+		if (!ret) {
 			result_dly1 |= (1 << i);
+			kfree(ext_csd);
+		}
 	}
 	host->hs400_tuning = false;

drivers/mmc/host/renesas_sdhi_core.c+1−1

@@ -673,7 +673,7 @@ static int renesas_sdhi_execute_tuning(struct mmc_host *mmc, u32 opcode) · 672 unmodified lines
673		673
674	/* Issue CMD19 twice for each tap */	674	/* Issue CMD19 twice for each tap */
675	for (i = 0; i < 2 * priv->tap_num; i++) {	675	for (i = 0; i < 2 * priv->tap_num; i++) {
676	int cmd_error;	676	int cmd_error = 0;
677		677
678	/* Set sampling clock position */	678	/* Set sampling clock position */
679	sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, i % priv->tap_num);	679	sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, i % priv->tap_num);

drivers/net/dsa/mv88e6xxx/chip.c+4−0

 	if ((!mv88e6xxx_port_ppu_updates(chip, port) ||
 	     mode == MLO_AN_FIXED) && ops->port_sync_link)
 		err = ops->port_sync_link(chip, port, mode, false);
+	if (!err && ops->port_set_speed_duplex)
+		err = ops->port_set_speed_duplex(chip, port, SPEED_UNFORCED,
+						 DUPLEX_UNFORCED);
 	mv88e6xxx_reg_unlock(chip);
 	if (err)

drivers/net/dsa/mv88e6xxx/port.c+2−2

@@ -283,7 +283,7 @@ static int mv88e6xxx_port_set_speed_duplex(struct mv88e6xxx_chip *chip, · 282 unmodified lines
283	if (err)	283	if (err)
284	return err;	284	return err;
285		285
286	if (speed)	286	if (speed != SPEED_UNFORCED)
287	dev_dbg(chip->dev, "p%d: Speed set to %d Mbps\n", port, speed);	287	dev_dbg(chip->dev, "p%d: Speed set to %d Mbps\n", port, speed);
288	else	288	else
289	dev_dbg(chip->dev, "p%d: Speed unforced\n", port);	289	dev_dbg(chip->dev, "p%d: Speed unforced\n", port);
@@ -516,7 +516,7 @@ int mv88e6393x_port_set_speed_duplex(struct mv88e6xxx_chip *chip, int port, · 226 unmodified lines
516	if (err)	516	if (err)
517	return err;	517	return err;
518		518
519	if (speed)	519	if (speed != SPEED_UNFORCED)
520	dev_dbg(chip->dev, "p%d: Speed set to %d Mbps\n", port, speed);	520	dev_dbg(chip->dev, "p%d: Speed set to %d Mbps\n", port, speed);
521	else	521	else
522	dev_dbg(chip->dev, "p%d: Speed unforced\n", port);	522	dev_dbg(chip->dev, "p%d: Speed unforced\n", port);

drivers/net/ethernet/broadcom/bcmsysport.c+4−1

 	struct bcm_sysport_priv *priv = netdev_priv(dev);
 	struct device *kdev = &priv->pdev->dev;
 	struct bcm_sysport_tx_ring *ring;
+	unsigned long flags, desc_flags;
 	struct bcm_sysport_cb *cb;
 	struct netdev_queue *txq;
 	u32 len_status, addr_lo;
 	unsigned int skb_len;
-	unsigned long flags;
 	dma_addr_t mapping;
 	u16 queue;
 	int ret;
 	ring->desc_count--;
 	/* Ports are latched, so write upper address first */
+	spin_lock_irqsave(&priv->desc_lock, desc_flags);
 	tdma_writel(priv, len_status, TDMA_WRITE_PORT_HI(ring->index));
 	tdma_writel(priv, addr_lo, TDMA_WRITE_PORT_LO(ring->index));
+	spin_unlock_irqrestore(&priv->desc_lock, desc_flags);
 	/* Check ring space and update SW control flow */
 	if (ring->desc_count == 0)
 	}
 	/* Initialize both hardware and software ring */
+	spin_lock_init(&priv->desc_lock);
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		ret = bcm_sysport_init_tx_ring(priv, i);
 		if (ret) {

drivers/net/ethernet/broadcom/bcmsysport.h+1−0

@@ -711,6 +711,7 @@ struct bcm_sysport_priv { · 710 unmodified lines
711	int wol_irq;	711	int wol_irq;
712		712
713	/* Transmit rings */	713	/* Transmit rings */
		714	spinlock_t desc_lock;
714	struct bcm_sysport_tx_ring *tx_rings;	715	struct bcm_sysport_tx_ring *tx_rings;
715		716
716	/* Receive queue */	717	/* Receive queue */

drivers/net/ethernet/broadcom/genet/bcmmii.c+2−2

@@ -589,9 +589,9 @@ static int bcmgenet_mii_pd_init(struct bcmgenet_priv *priv) · 588 unmodified lines
589	* Internal or external PHY with MDIO access	589	* Internal or external PHY with MDIO access
590	*/	590	*/
591	phydev = phy_attach(priv->dev, phy_name, pd->phy_interface);	591	phydev = phy_attach(priv->dev, phy_name, pd->phy_interface);
592	if (!phydev) {	592	if (IS_ERR(phydev)) {
593	dev_err(kdev, "failed to register PHY device\n");	593	dev_err(kdev, "failed to register PHY device\n");
594	return -ENODEV;	594	return PTR_ERR(phydev);
595	}	595	}
596	} else {	596	} else {
597	/*	597	/*

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h+2−0

@@ -388,6 +388,8 @@ struct dpaa2_eth_ch_stats { · 387 unmodified lines
388	__u64 bytes_per_cdan;	388	__u64 bytes_per_cdan;
389	};	389	};
390		390
		391	#define DPAA2_ETH_CH_STATS 7
		392
391	/* Maximum number of queues associated with a DPNI */	393	/* Maximum number of queues associated with a DPNI */
392	#define DPAA2_ETH_MAX_TCS 8	394	#define DPAA2_ETH_MAX_TCS 8
393	#define DPAA2_ETH_MAX_RX_QUEUES_PER_TC 16	395	#define DPAA2_ETH_MAX_RX_QUEUES_PER_TC 16

drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c+1−1

@@ -278,7 +278,7 @@ static void dpaa2_eth_get_ethtool_stats(struct net_device *net_dev, · 277 unmodified lines
278	/* Per-channel stats */	278	/* Per-channel stats */
279	for (k = 0; k < priv->num_channels; k++) {	279	for (k = 0; k < priv->num_channels; k++) {
280	ch_stats = &priv->channel[k]->stats;	280	ch_stats = &priv->channel[k]->stats;
281	for (j = 0; j < sizeof(*ch_stats) / sizeof(__u64) - 1; j++)	281	for (j = 0; j < DPAA2_ETH_CH_STATS; j++)
282	((__u64 )data + i + j) += ((__u64 )ch_stats + j);	282	((__u64 )data + i + j) += ((__u64 )ch_stats + j);
283	}	283	}
284	i += j;	284	i += j;

drivers/net/ethernet/hisilicon/hns3/hnae3.h+2−0

@@ -839,6 +839,8 @@ struct hnae3_handle { · 838 unmodified lines
839		839
840	u8 netdev_flags;	840	u8 netdev_flags;
841	struct dentry *hnae3_dbgfs;	841	struct dentry *hnae3_dbgfs;
		842	/* protects concurrent contention between debugfs commands */
		843	struct mutex dbgfs_lock;
842		844
843	/* Network interface message level enabled bits */	845	/* Network interface message level enabled bits */
844	u32 msg_enable;	846	u32 msg_enable;

drivers/net/ethernet/hisilicon/hns3/hns3_debugfs.c+14−6

 	if (ret)
 		return ret;
+	mutex_lock(&handle->dbgfs_lock);
 	save_buf = &hns3_dbg_cmd[index].buf;
 	if (!test_bit(HNS3_NIC_STATE_INITED, &priv->state) ||
 		read_buf = *save_buf;
 	} else {
 		read_buf = kvzalloc(hns3_dbg_cmd[index].buf_len, GFP_KERNEL);
-		if (!read_buf)
+		if (!read_buf) {
-			return -ENOMEM;
+			ret = -ENOMEM;
+			goto out;
+		}
 		/* save the buffer addr until the last read operation */
 		*save_buf = read_buf;
-	}
-	/* get data ready for the first time to read */
+		/* get data ready for the first time to read */
-	if (!*ppos) {
 		ret = hns3_dbg_read_cmd(dbg_data, hns3_dbg_cmd[index].cmd,
 					read_buf, hns3_dbg_cmd[index].buf_len);
 		if (ret)
 	size = simple_read_from_buffer(buffer, count, ppos, read_buf,
 				       strlen(read_buf));
-	if (size > 0)
+	if (size > 0) {
+		mutex_unlock(&handle->dbgfs_lock);
 		return size;
+	}
 out:
 	/* free the buffer for the last read operation */
 		*save_buf = NULL;
 	}
+	mutex_unlock(&handle->dbgfs_lock);
 	return ret;
 }
 			debugfs_create_dir(hns3_dbg_dentry[i].name,
 					   handle->hnae3_dbgfs);
+	mutex_init(&handle->dbgfs_lock);
 	for (i = 0; i < ARRAY_SIZE(hns3_dbg_cmd); i++) {
 		if ((hns3_dbg_cmd[i].cmd == HNAE3_DBG_CMD_TM_NODES &&
 		     ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2) ||
 	return 0;
 out:
+	mutex_destroy(&handle->dbgfs_lock);
 	debugfs_remove_recursive(handle->hnae3_dbgfs);
 	handle->hnae3_dbgfs = NULL;
 	return ret;
 			hns3_dbg_cmd[i].buf = NULL;
 		}
+	mutex_destroy(&handle->dbgfs_lock);
 	debugfs_remove_recursive(handle->hnae3_dbgfs);
 	handle->hnae3_dbgfs = NULL;
 }

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_mbx.c+2−1

@@ -114,7 +114,8 @@ int hclgevf_send_mbx_msg(struct hclgevf_dev *hdev, · 113 unmodified lines
114		114
115	memcpy(&req->msg, send_msg, sizeof(struct hclge_vf_to_pf_msg));	115	memcpy(&req->msg, send_msg, sizeof(struct hclge_vf_to_pf_msg));
116		116
117	trace_hclge_vf_mbx_send(hdev, req);	117	if (test_bit(HCLGEVF_STATE_NIC_REGISTERED, &hdev->state))
		118	trace_hclge_vf_mbx_send(hdev, req);
118		119
119	/* synchronous send */	120	/* synchronous send */
120	if (need_resp) {	121	if (need_resp) {

drivers/net/ethernet/intel/iavf/iavf_main.c+2−3

 		}
 		adapter->aq_required = 0;
 		adapter->current_op = VIRTCHNL_OP_UNKNOWN;
+		mutex_unlock(&adapter->crit_lock);
 		queue_delayed_work(iavf_wq,
 				   &adapter->watchdog_task,
 				   msecs_to_jiffies(10));
 			iavf_detect_recover_hung(&adapter->vsi);
 		break;
 	case __IAVF_REMOVE:
-		mutex_unlock(&adapter->crit_lock);
-		return;
 	default:
+		mutex_unlock(&adapter->crit_lock);
 		return;
 	}
 	/* check for hw reset */
 	reg_val = rd32(hw, IAVF_VF_ARQLEN1) & IAVF_VF_ARQLEN1_ARQENABLE_MASK;
 	if (!reg_val) {
-		iavf_change_state(adapter, __IAVF_RESETTING);
 		adapter->flags |= IAVF_FLAG_RESET_PENDING;
 		adapter->aq_required = 0;
 		adapter->current_op = VIRTCHNL_OP_UNKNOWN;

drivers/net/ethernet/intel/ice/ice_ptp.c+5−8

 		scaled_ppm = -scaled_ppm;
 	}
-	while ((u64)scaled_ppm > div_u64(U64_MAX, incval)) {
+	while ((u64)scaled_ppm > div64_u64(U64_MAX, incval)) {
 		/* handle overflow by scaling down the scaled_ppm and
 		 * the divisor, losing some precision
 		 */
 		if (err)
 			continue;
-		/* Check if the timestamp is valid */
+		/* Check if the timestamp is invalid or stale */
-		if (!(raw_tstamp & ICE_PTP_TS_VALID))
+		if (!(raw_tstamp & ICE_PTP_TS_VALID) ||
+		    raw_tstamp == tx->tstamps[idx].cached_tstamp)
 			continue;
-		/* clear the timestamp register, so that it won't show valid
-		 * again when re-used.
-		 */
-		ice_clear_phy_tstamp(hw, tx->quad, phy_idx);
 		/* The timestamp is valid, so we'll go ahead and clear this
 		 * index and then send the timestamp up to the stack.
 		 */
 		spin_lock(&tx->lock);
+		tx->tstamps[idx].cached_tstamp = raw_tstamp;
 		clear_bit(idx, tx->in_use);
 		skb = tx->tstamps[idx].skb;
 		tx->tstamps[idx].skb = NULL;

drivers/net/ethernet/intel/ice/ice_ptp.h+6−0

  * struct ice_tx_tstamp - Tracking for a single Tx timestamp
  * @skb: pointer to the SKB for this timestamp request
  * @start: jiffies when the timestamp was first requested
+ * @cached_tstamp: last read timestamp
  *
  * This structure tracks a single timestamp request. The SKB pointer is
  * provided when initiating a request. The start time is used to ensure that
  * we discard old requests that were not fulfilled within a 2 second time
  * window.
+ * Timestamp values in the PHY are read only and do not get cleared except at
+ * hardware reset or when a new timestamp value is captured. The cached_tstamp
+ * field is used to detect the case where a new timestamp has not yet been
+ * captured, ensuring that we avoid sending stale timestamp data to the stack.
  */
 struct ice_tx_tstamp {
 	struct sk_buff *skb;
 	unsigned long start;
+	u64 cached_tstamp;
 };
 /**

drivers/net/ethernet/intel/igb/igb_main.c+14−14

 	struct vf_mac_filter *entry = NULL;
 	int ret = 0;
+	if ((vf_data->flags & IGB_VF_FLAG_PF_SET_MAC) &&
+	    !vf_data->trusted) {
+		dev_warn(&pdev->dev,
+			 "VF %d requested MAC filter but is administratively denied\n",
+			  vf);
+		return -EINVAL;
+	}
+	if (!is_valid_ether_addr(addr)) {
+		dev_warn(&pdev->dev,
+			 "VF %d attempted to set invalid MAC filter\n",
+			  vf);
+		return -EINVAL;
+	}
 	switch (info) {
 	case E1000_VF_MAC_FILTER_CLR:
 		/* remove all unicast MAC filters related to the current VF */
 		}
 		break;
 	case E1000_VF_MAC_FILTER_ADD:
-		if ((vf_data->flags & IGB_VF_FLAG_PF_SET_MAC) &&
-		    !vf_data->trusted) {
-			dev_warn(&pdev->dev,
-				 "VF %d requested MAC filter but is administratively denied\n",
-				 vf);
-			return -EINVAL;
-		}
-		if (!is_valid_ether_addr(addr)) {
-			dev_warn(&pdev->dev,
-				 "VF %d attempted to set invalid MAC filter\n",
-				 vf);
-			return -EINVAL;
-		}
 		/* try to find empty slot in the list */
 		list_for_each(pos, &adapter->vf_macs.l) {
 			entry = list_entry(pos, struct vf_mac_filter, l);

drivers/net/ethernet/intel/igbvf/netdev.c+1−0

@@ -2859,6 +2859,7 @@ static int igbvf_probe(struct pci_dev pdev, const struct pci_device_id ent) · 2858 unmodified lines
2859	return 0;	2859	return 0;
2860		2860
2861	err_hw_init:	2861	err_hw_init:
		2862	netif_napi_del(&adapter->rx_ring->napi);
2862	kfree(adapter->tx_ring);	2863	kfree(adapter->tx_ring);
2863	kfree(adapter->rx_ring);	2864	kfree(adapter->rx_ring);
2864	err_sw_init:	2865	err_sw_init:

drivers/net/ethernet/intel/igc/igc_i225.c+1−1

@@ -636,7 +636,7 @@ s32 igc_set_ltr_i225(struct igc_hw *hw, bool link) · 635 unmodified lines
636	ltrv = rd32(IGC_LTRMAXV);	636	ltrv = rd32(IGC_LTRMAXV);
637	if (ltr_max != (ltrv & IGC_LTRMAXV_LTRV_MASK)) {	637	if (ltr_max != (ltrv & IGC_LTRMAXV_LTRV_MASK)) {
638	ltrv = IGC_LTRMAXV_LSNP_REQ \| ltr_max \|	638	ltrv = IGC_LTRMAXV_LSNP_REQ \| ltr_max \|
639	(scale_min << IGC_LTRMAXV_SCALE_SHIFT);	639	(scale_max << IGC_LTRMAXV_SCALE_SHIFT);
640	wr32(IGC_LTRMAXV, ltrv);	640	wr32(IGC_LTRMAXV, ltrv);
641	}	641	}
642	}	642	}

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+4−0

 	if (!speed && hw->mac.ops.get_link_capabilities) {
 		ret = hw->mac.ops.get_link_capabilities(hw, &speed,
 							&autoneg);
+		/* remove NBASE-T speeds from default autonegotiation
+		 * to accommodate broken network switches in the field
+		 * which cannot cope with advertised NBASE-T speeds
+		 */
 		speed &= ~(IXGBE_LINK_SPEED_5GB_FULL |
 			   IXGBE_LINK_SPEED_2_5GB_FULL);
 	}

drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c+3−0

@@ -3405,6 +3405,9 @@ static s32 ixgbe_reset_hw_X550em(struct ixgbe_hw *hw) · 3404 unmodified lines
3405	/* flush pending Tx transactions */	3405	/* flush pending Tx transactions */
3406	ixgbe_clear_tx_pending(hw);	3406	ixgbe_clear_tx_pending(hw);
3407		3407
		3408	/* set MDIO speed before talking to the PHY in case it's the 1st time */
		3409	ixgbe_set_mdio_speed(hw);
		3410
3408	/* PHY ops must be identified and initialized prior to reset */	3411	/* PHY ops must be identified and initialized prior to reset */
3409	status = hw->phy.ops.init(hw);	3412	status = hw->phy.ops.init(hw);
3410	if (status == IXGBE_ERR_SFP_NOT_SUPPORTED \|\|	3413	if (status == IXGBE_ERR_SFP_NOT_SUPPORTED \|\|

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+2−1

@@ -8505,7 +8505,8 @@ mlxsw_sp_rif_mac_profile_replace(struct mlxsw_sp *mlxsw_sp, · 8504 unmodified lines
8505	u8 mac_profile;	8505	u8 mac_profile;
8506	int err;	8506	int err;
8507		8507
8508	if (!mlxsw_sp_rif_mac_profile_is_shared(rif))	8508	if (!mlxsw_sp_rif_mac_profile_is_shared(rif) &&
		8509	!mlxsw_sp_rif_mac_profile_find(mlxsw_sp, new_mac))
8509	return mlxsw_sp_rif_mac_profile_edit(rif, new_mac);	8510	return mlxsw_sp_rif_mac_profile_edit(rif, new_mac);
8510		8511
8511	err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, new_mac,	8512	err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, new_mac,

drivers/net/ethernet/sfc/ef100_nic.c+3−0

@@ -609,6 +609,9 @@ static size_t ef100_update_stats(struct efx_nic *efx, · 608 unmodified lines
609	ef100_common_stat_mask(mask);	609	ef100_common_stat_mask(mask);
610	ef100_ethtool_stat_mask(mask);	610	ef100_ethtool_stat_mask(mask);
611		611
		612	if (!mc_stats)
		613	return 0;
		614
612	efx_nic_copy_stats(efx, mc_stats);	615	efx_nic_copy_stats(efx, mc_stats);
613	efx_nic_update_stats(ef100_stat_desc, EF100_STAT_COUNT, mask,	616	efx_nic_update_stats(ef100_stat_desc, EF100_STAT_COUNT, mask,
614	stats, mc_stats, false);	617	stats, mc_stats, false);

drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c+3−1

 	void (*set_rgmii_speed)(struct rk_priv_data *bsp_priv, int speed);
 	void (*set_rmii_speed)(struct rk_priv_data *bsp_priv, int speed);
 	void (*integrated_phy_powerup)(struct rk_priv_data *bsp_priv);
+	bool regs_valid;
 	u32 regs[];
 };
 	.set_to_rmii = rk3568_set_to_rmii,
 	.set_rgmii_speed = rk3568_set_gmac_speed,
 	.set_rmii_speed = rk3568_set_gmac_speed,
+	.regs_valid = true,
 	.regs = {
 		0xfe2a0000, /* gmac0 */
 		0xfe010000, /* gmac1 */
 	 * to be distinguished.
 	 */
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (res) {
+	if (res && ops->regs_valid) {
 		int i = 0;
 		while (ops->regs[i]) {

drivers/net/ethernet/stmicro/stmmac/stmmac.h+17−0

@@ -171,6 +171,19 @@ struct stmmac_flow_entry { · 170 unmodified lines
171	int is_l4;	171	int is_l4;
172	};	172	};
173		173
		174	/* Rx Frame Steering */
		175	enum stmmac_rfs_type {
		176	STMMAC_RFS_T_VLAN,
		177	STMMAC_RFS_T_MAX,
		178	};
		179
		180	struct stmmac_rfs_entry {
		181	unsigned long cookie;
		182	int in_use;
		183	int type;
		184	int tc;
		185	};
		186
174	struct stmmac_priv {	187	struct stmmac_priv {
175	/* Frequently used values are kept adjacent for cache effect */	188	/* Frequently used values are kept adjacent for cache effect */
176	u32 tx_coal_frames[MTL_MAX_TX_QUEUES];	189	u32 tx_coal_frames[MTL_MAX_TX_QUEUES];
@@ -288,6 +301,10 @@ struct stmmac_priv { · 111 unmodified lines
288	struct stmmac_tc_entry *tc_entries;	301	struct stmmac_tc_entry *tc_entries;
289	unsigned int flow_entries_max;	302	unsigned int flow_entries_max;
290	struct stmmac_flow_entry *flow_entries;	303	struct stmmac_flow_entry *flow_entries;
		304	unsigned int rfs_entries_max[STMMAC_RFS_T_MAX];
		305	unsigned int rfs_entries_cnt[STMMAC_RFS_T_MAX];
		306	unsigned int rfs_entries_total;
		307	struct stmmac_rfs_entry *rfs_entries;
291		308
292	/* Pulse Per Second output */	309	/* Pulse Per Second output */
293	struct stmmac_pps_cfg pps[STMMAC_PPS_MAX];	310	struct stmmac_pps_cfg pps[STMMAC_PPS_MAX];

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+12−4

 {
 	struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue];
 	struct stmmac_rx_buffer *buf = &rx_q->buf_pool[i];
+	gfp_t gfp = (GFP_ATOMIC | __GFP_NOWARN);
+	if (priv->dma_cap.addr64 <= 32)
+		gfp |= GFP_DMA32;
 	if (!buf->page) {
-		buf->page = page_pool_dev_alloc_pages(rx_q->page_pool);
+		buf->page = page_pool_alloc_pages(rx_q->page_pool, gfp);
 		if (!buf->page)
 			return -ENOMEM;
 		buf->page_offset = stmmac_rx_offset(priv);
 	}
 	if (priv->sph && !buf->sec_page) {
-		buf->sec_page = page_pool_dev_alloc_pages(rx_q->page_pool);
+		buf->sec_page = page_pool_alloc_pages(rx_q->page_pool, gfp);
 		if (!buf->sec_page)
 			return -ENOMEM;
 	struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue];
 	int dirty = stmmac_rx_dirty(priv, queue);
 	unsigned int entry = rx_q->dirty_rx;
+	gfp_t gfp = (GFP_ATOMIC | __GFP_NOWARN);
+	if (priv->dma_cap.addr64 <= 32)
+		gfp |= GFP_DMA32;
 	while (dirty-- > 0) {
 		struct stmmac_rx_buffer *buf = &rx_q->buf_pool[entry];
 			p = rx_q->dma_rx + entry;
 		if (!buf->page) {
-			buf->page = page_pool_dev_alloc_pages(rx_q->page_pool);
+			buf->page = page_pool_alloc_pages(rx_q->page_pool, gfp);
 			if (!buf->page)
 				break;
 		}
 		if (priv->sph && !buf->sec_page) {
-			buf->sec_page = page_pool_dev_alloc_pages(rx_q->page_pool);
+			buf->sec_page = page_pool_alloc_pages(rx_q->page_pool, gfp);
 			if (!buf->sec_page)
 				break;

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c+73−13

@@ -232,11 +232,33 @@ static int tc_setup_cls_u32(struct stmmac_priv *priv, · 231 unmodified lines
232	}	232	}
233	}	233	}
234		234
		235	static int tc_rfs_init(struct stmmac_priv *priv)
		236	{
		237	int i;
		238
		239	priv->rfs_entries_max[STMMAC_RFS_T_VLAN] = 8;
		240
		241	for (i = 0; i < STMMAC_RFS_T_MAX; i++)
		242	priv->rfs_entries_total += priv->rfs_entries_max[i];
		243
		244	priv->rfs_entries = devm_kcalloc(priv->device,
		245	priv->rfs_entries_total,
		246	sizeof(*priv->rfs_entries),
		247	GFP_KERNEL);
		248	if (!priv->rfs_entries)
		249	return -ENOMEM;
		250
		251	dev_info(priv->device, "Enabled RFS Flow TC (entries=%d)\n",
		252	priv->rfs_entries_total);
		253
		254	return 0;
		255	}
		256
235	static int tc_init(struct stmmac_priv *priv)	257	static int tc_init(struct stmmac_priv *priv)
236	{	258	{
237	struct dma_features *dma_cap = &priv->dma_cap;	259	struct dma_features *dma_cap = &priv->dma_cap;
238	unsigned int count;	260	unsigned int count;
239	int i;	261	int ret, i;
240		262
241	if (dma_cap->l3l4fnum) {	263	if (dma_cap->l3l4fnum) {
242	priv->flow_entries_max = dma_cap->l3l4fnum;	264	priv->flow_entries_max = dma_cap->l3l4fnum;
@@ -250,10 +272,14 @@ static int tc_init(struct stmmac_priv *priv) · 7 unmodified lines
250	for (i = 0; i < priv->flow_entries_max; i++)	272	for (i = 0; i < priv->flow_entries_max; i++)
251	priv->flow_entries[i].idx = i;	273	priv->flow_entries[i].idx = i;
252		274
253	dev_info(priv->device, "Enabled Flow TC (entries=%d)\n",	275	dev_info(priv->device, "Enabled L3L4 Flow TC (entries=%d)\n",
254	priv->flow_entries_max);	276	priv->flow_entries_max);
255	}	277	}
256		278
		279	ret = tc_rfs_init(priv);
		280	if (ret)
		281	return -ENOMEM;
		282
257	if (!priv->plat->fpe_cfg) {	283	if (!priv->plat->fpe_cfg) {
258	priv->plat->fpe_cfg = devm_kzalloc(priv->device,	284	priv->plat->fpe_cfg = devm_kzalloc(priv->device,
259	sizeof(*priv->plat->fpe_cfg),	285	sizeof(*priv->plat->fpe_cfg),
@@ -607,16 +633,45 @@ static int tc_del_flow(struct stmmac_priv *priv, · 347 unmodified lines
607	return ret;	633	return ret;
608	}	634	}
609		635
		636	static struct stmmac_rfs_entry tc_find_rfs(struct stmmac_priv priv,
		637	struct flow_cls_offload *cls,
		638	bool get_free)
		639	{
		640	int i;
		641
		642	for (i = 0; i < priv->rfs_entries_total; i++) {
		643	struct stmmac_rfs_entry *entry = &priv->rfs_entries[i];
		644
		645	if (entry->cookie == cls->cookie)
		646	return entry;
		647	if (get_free && entry->in_use == false)
		648	return entry;
		649	}
		650
		651	return NULL;
		652	}
		653
610	#define VLAN_PRIO_FULL_MASK (0x07)	654	#define VLAN_PRIO_FULL_MASK (0x07)
611		655
612	static int tc_add_vlan_flow(struct stmmac_priv *priv,	656	static int tc_add_vlan_flow(struct stmmac_priv *priv,
613	struct flow_cls_offload *cls)	657	struct flow_cls_offload *cls)
614	{	658	{
		659	struct stmmac_rfs_entry *entry = tc_find_rfs(priv, cls, false);
615	struct flow_rule *rule = flow_cls_offload_flow_rule(cls);	660	struct flow_rule *rule = flow_cls_offload_flow_rule(cls);
616	struct flow_dissector *dissector = rule->match.dissector;	661	struct flow_dissector *dissector = rule->match.dissector;
617	int tc = tc_classid_to_hwtc(priv->dev, cls->classid);	662	int tc = tc_classid_to_hwtc(priv->dev, cls->classid);
618	struct flow_match_vlan match;	663	struct flow_match_vlan match;
619		664
		665	if (!entry) {
		666	entry = tc_find_rfs(priv, cls, true);
		667	if (!entry)
		668	return -ENOENT;
		669	}
		670
		671	if (priv->rfs_entries_cnt[STMMAC_RFS_T_VLAN] >=
		672	priv->rfs_entries_max[STMMAC_RFS_T_VLAN])
		673	return -ENOENT;
		674
620	/* Nothing to do here */	675	/* Nothing to do here */
621	if (!dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN))	676	if (!dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN))
622	return -EINVAL;	677	return -EINVAL;
@@ -638,6 +693,12 @@ static int tc_add_vlan_flow(struct stmmac_priv *priv, · 15 unmodified lines
638		693
639	prio = BIT(match.key->vlan_priority);	694	prio = BIT(match.key->vlan_priority);
640	stmmac_rx_queue_prio(priv, priv->hw, prio, tc);	695	stmmac_rx_queue_prio(priv, priv->hw, prio, tc);
		696
		697	entry->in_use = true;
		698	entry->cookie = cls->cookie;
		699	entry->tc = tc;
		700	entry->type = STMMAC_RFS_T_VLAN;
		701	priv->rfs_entries_cnt[STMMAC_RFS_T_VLAN]++;
641	}	702	}
642		703
643	return 0;	704	return 0;
@@ -646,20 +707,19 @@ static int tc_add_vlan_flow(struct stmmac_priv *priv, · 2 unmodified lines
646	static int tc_del_vlan_flow(struct stmmac_priv *priv,	707	static int tc_del_vlan_flow(struct stmmac_priv *priv,
647	struct flow_cls_offload *cls)	708	struct flow_cls_offload *cls)
648	{	709	{
649	struct flow_rule *rule = flow_cls_offload_flow_rule(cls);	710	struct stmmac_rfs_entry *entry = tc_find_rfs(priv, cls, false);
650	struct flow_dissector *dissector = rule->match.dissector;
651	int tc = tc_classid_to_hwtc(priv->dev, cls->classid);
652		711
653	/* Nothing to do here */	712	if (!entry \|\| !entry->in_use \|\| entry->type != STMMAC_RFS_T_VLAN)
654	if (!dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN))	713	return -ENOENT;
655	return -EINVAL;
656		714
657	if (tc < 0) {	715	stmmac_rx_queue_prio(priv, priv->hw, 0, entry->tc);
658	netdev_err(priv->dev, "Invalid traffic class\n");	716
659	return -EINVAL;	717	entry->in_use = false;
660	}	718	entry->cookie = 0;
		719	entry->tc = 0;
		720	entry->type = 0;
661		721
662	stmmac_rx_queue_prio(priv, priv->hw, 0, tc);	722	priv->rfs_entries_cnt[STMMAC_RFS_T_VLAN]--;
663		723
664	return 0;	724	return 0;
665	}	725	}

drivers/net/ethernet/ti/am65-cpsw-nuss.c+20−9

 		if (ret < 0) {
 			dev_err(dev, "%pOF error reading port_id %d\n",
 				port_np, ret);
-			return ret;
+			goto of_node_put;
 		}
 		if (!port_id || port_id > common->port_num) {
 			dev_err(dev, "%pOF has invalid port_id %u %s\n",
 				port_np, port_id, port_np->name);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto of_node_put;
 		}
 		port = am65_common_get_port(common, port_id);
 				(AM65_CPSW_NU_FRAM_PORT_OFFSET * (port_id - 1));
 		port->slave.mac_sl = cpsw_sl_get("am65", dev, port->port_base);
-		if (IS_ERR(port->slave.mac_sl))
+		if (IS_ERR(port->slave.mac_sl)) {
-			return PTR_ERR(port->slave.mac_sl);
+			ret = PTR_ERR(port->slave.mac_sl);
+			goto of_node_put;
+		}
 		port->disabled = !of_device_is_available(port_np);
 		if (port->disabled) {
 			ret = PTR_ERR(port->slave.ifphy);
 			dev_err(dev, "%pOF error retrieving port phy: %d\n",
 				port_np, ret);
-			return ret;
+			goto of_node_put;
 		}
 		port->slave.mac_only =
 		/* get phy/link info */
 		if (of_phy_is_fixed_link(port_np)) {
 			ret = of_phy_register_fixed_link(port_np);
-			if (ret)
+			if (ret) {
-				return dev_err_probe(dev, ret,
+				ret = dev_err_probe(dev, ret,
 						     "failed to register fixed-link phy %pOF\n",
 						     port_np);
+				goto of_node_put;
+			}
 			port->slave.phy_node = of_node_get(port_np);
 		} else {
 			port->slave.phy_node =
 		if (!port->slave.phy_node) {
 			dev_err(dev,
 				"slave[%d] no phy found\n", port_id);
-			return -ENODEV;
+			ret = -ENODEV;
+			goto of_node_put;
 		}
 		ret = of_get_phy_mode(port_np, &port->slave.phy_if);
 		if (ret) {
 			dev_err(dev, "%pOF read phy-mode err %d\n",
 				port_np, ret);
-			return ret;
+			goto of_node_put;
 		}
 		ret = of_get_mac_address(port_np, port->slave.mac_addr);
 	}
 	return 0;
+of_node_put:
+	of_node_put(port_np);
+	of_node_put(node);
+	return ret;
 }
 static void am65_cpsw_pcpu_stats_free(void *data)

drivers/net/netdevsim/bpf.c+1−0

@@ -514,6 +514,7 @@ nsim_bpf_map_alloc(struct netdevsim ns, struct bpf_offloaded_map offmap) · 513 unmodified lines
514	goto err_free;	514	goto err_free;
515	key = nmap->entry[i].key;	515	key = nmap->entry[i].key;
516	*key = i;	516	*key = i;
		517	memset(nmap->entry[i].value, 0, offmap->map.value_size);
517	}	518	}
518	}	519	}
519		520

drivers/net/netdevsim/ethtool.c+4−1

 {
 	struct netdevsim *ns = netdev_priv(dev);
-	memcpy(&ns->ethtool.ring, ring, sizeof(ns->ethtool.ring));
+	ns->ethtool.ring.rx_pending = ring->rx_pending;
+	ns->ethtool.ring.rx_jumbo_pending = ring->rx_jumbo_pending;
+	ns->ethtool.ring.rx_mini_pending = ring->rx_mini_pending;
+	ns->ethtool.ring.tx_pending = ring->tx_pending;
 	return 0;
 }

drivers/net/phy/mdio_bus.c+3−0

 		if (addr == mdiodev->addr) {
 			device_set_node(dev, of_fwnode_handle(child));
+			/* The refcount on "child" is passed to the mdio
+			 * device. Do _not_ use of_node_put(child) here.
+			 */
 			return;
 		}
 	}

drivers/net/usb/lan78xx.c+6−0

 #define LAN7801_USB_PRODUCT_ID		(0x7801)
 #define LAN78XX_EEPROM_MAGIC		(0x78A5)
 #define LAN78XX_OTP_MAGIC		(0x78F3)
+#define AT29M2AF_USB_VENDOR_ID		(0x07C9)
+#define AT29M2AF_USB_PRODUCT_ID	(0x0012)
 #define	MII_READ			1
 #define	MII_WRITE			0
 	/* LAN7801 USB Gigabit Ethernet Device */
 	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
 	},
+	{
+	/* ATM2-AF USB Gigabit Ethernet Device */
+	USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
+	},
 	{},
 };
 MODULE_DEVICE_TABLE(usb, products);

drivers/net/usb/qmi_wwan.c+1−0

@@ -1358,6 +1358,7 @@ static const struct usb_device_id products[] = { · 1357 unmodified lines
1358	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */	1358	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */
1359	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */	1359	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */
1360	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1060, 2)}, /* Telit LN920 */	1360	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1060, 2)}, /* Telit LN920 */
		1361	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1070, 2)}, /* Telit FN990 */
1361	{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */	1362	{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */
1362	{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */	1363	{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */
1363	{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */	1364	{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */

drivers/net/virtio_net.c+3−6

 		pr_debug("%s: rx error: len %u exceeds max size %d\n",
 			 dev->name, len, GOOD_PACKET_LEN);
 		dev->stats.rx_length_errors++;
-		goto err_len;
+		goto err;
 	}
 	if (likely(!vi->xdp_enabled)) {
 skip_xdp:
 	skb = build_skb(buf, buflen);
-	if (!skb) {
+	if (!skb)
-		put_page(page);
 		goto err;
-	}
 	skb_reserve(skb, headroom - delta);
 	skb_put(skb, len);
 	if (!xdp_prog) {
 	if (metasize)
 		skb_metadata_set(skb, metasize);
-err:
 	return skb;
 err_xdp:
 	rcu_read_unlock();
 	stats->xdp_drops++;
-err_len:
+err:
 	stats->drops++;
 	put_page(page);
 xdp_xmit:

drivers/net/wireless/ath/ath11k/mhi.c+5−1

 		ret = mhi_pm_suspend(ab_pci->mhi_ctrl);
 		break;
 	case ATH11K_MHI_RESUME:
-		ret = mhi_pm_resume(ab_pci->mhi_ctrl);
+		/* Do force MHI resume as some devices like QCA6390, WCN6855
+		 * are not in M3 state but they are functional. So just ignore
+		 * the MHI state while resuming.
+		 */
+		ret = mhi_pm_resume_force(ab_pci->mhi_ctrl);
 		break;
 	case ATH11K_MHI_TRIGGER_RDDM:
 		ret = mhi_force_rddm_mode(ab_pci->mhi_ctrl);

drivers/net/wireless/broadcom/brcm80211/Kconfig+9−5

@@ -7,16 +7,20 @@ config BRCMSMAC · 6 unmodified lines
7	depends on MAC80211	7	depends on MAC80211
8	depends on BCMA_POSSIBLE	8	depends on BCMA_POSSIBLE
9	select BCMA	9	select BCMA
10	select NEW_LEDS if BCMA_DRIVER_GPIO
11	select LEDS_CLASS if BCMA_DRIVER_GPIO
12	select BRCMUTIL	10	select BRCMUTIL
13	select FW_LOADER	11	select FW_LOADER
14	select CORDIC	12	select CORDIC
15	help	13	help
16	This module adds support for PCIe wireless adapters based on Broadcom	14	This module adds support for PCIe wireless adapters based on Broadcom
17	IEEE802.11n SoftMAC chipsets. It also has WLAN led support, which will	15	IEEE802.11n SoftMAC chipsets. If you choose to build a module, the
18	be available if you select BCMA_DRIVER_GPIO. If you choose to build a	16	driver will be called brcmsmac.ko.
19	module, the driver will be called brcmsmac.ko.	17
		18	config BRCMSMAC_LEDS
		19	def_bool BRCMSMAC && BCMA_DRIVER_GPIO && MAC80211_LEDS
		20	help
		21	The brcmsmac LED support depends on the presence of the
		22	BCMA_DRIVER_GPIO driver, and it only works if LED support
		23	is enabled and reachable from the driver module.
20		24
21	source "drivers/net/wireless/broadcom/brcm80211/brcmfmac/Kconfig"	25	source "drivers/net/wireless/broadcom/brcm80211/brcmfmac/Kconfig"
22		26

drivers/net/wireless/broadcom/brcm80211/brcmsmac/Makefile+1−1

@@ -42,6 +42,6 @@ brcmsmac-y := \ · 41 unmodified lines
42	brcms_trace_events.o \	42	brcms_trace_events.o \
43	debug.o	43	debug.o
44		44
45	brcmsmac-$(CONFIG_BCMA_DRIVER_GPIO) += led.o	45	brcmsmac-$(CONFIG_BRCMSMAC_LEDS) += led.o
46		46
47	obj-$(CONFIG_BRCMSMAC) += brcmsmac.o	47	obj-$(CONFIG_BRCMSMAC) += brcmsmac.o

drivers/net/wireless/broadcom/brcm80211/brcmsmac/led.h+1−1

@@ -24,7 +24,7 @@ struct brcms_led { · 23 unmodified lines
24	struct gpio_desc *gpiod;	24	struct gpio_desc *gpiod;
25	};	25	};
26		26
27	#ifdef CONFIG_BCMA_DRIVER_GPIO	27	#ifdef CONFIG_BRCMSMAC_LEDS
28	void brcms_led_unregister(struct brcms_info *wl);	28	void brcms_led_unregister(struct brcms_info *wl);
29	int brcms_led_register(struct brcms_info *wl);	29	int brcms_led_register(struct brcms_info *wl);
30	#else	30	#else

drivers/net/wireless/intel/iwlegacy/Kconfig+2−2

 config IWLEGACY
 	tristate
 	select FW_LOADER
-	select NEW_LEDS
-	select LEDS_CLASS
 	select LEDS_TRIGGERS
 	select MAC80211_LEDS
 config IWL4965
 	tristate "Intel Wireless WiFi 4965AGN (iwl4965)"
 	depends on PCI && MAC80211
+	depends on LEDS_CLASS=y || LEDS_CLASS=MAC80211
 	select IWLEGACY
 	help
 	  This option enables support for
 config IWL3945
 	tristate "Intel PRO/Wireless 3945ABG/BG Network Connection (iwl3945)"
 	depends on PCI && MAC80211
+	depends on LEDS_CLASS=y || LEDS_CLASS=MAC80211
 	select IWLEGACY
 	help
 	  Select to build the driver supporting the:

drivers/net/wireless/intel/iwlwifi/Kconfig+1−1

@@ -47,7 +47,7 @@ if IWLWIFI · 46 unmodified lines
47		47
48	config IWLWIFI_LEDS	48	config IWLWIFI_LEDS
49	bool	49	bool
50	depends on LEDS_CLASS=y \|\| LEDS_CLASS=IWLWIFI	50	depends on LEDS_CLASS=y \|\| LEDS_CLASS=MAC80211
51	depends on IWLMVM \|\| IWLDVM	51	depends on IWLMVM \|\| IWLDVM
52	select LEDS_TRIGGERS	52	select LEDS_TRIGGERS
53	select MAC80211_LEDS	53	select MAC80211_LEDS

drivers/net/wireless/intel/iwlwifi/mvm/tx.c+3−2

 	u8 rate_plcp;
 	u32 rate_flags = 0;
 	bool is_cck;
-	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 	/* info->control is only relevant for non HW rate control */
 	if (!ieee80211_hw_check(mvm->hw, HAS_RATE_CONTROL)) {
+		struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 		/* HT rate doesn't make sense for a non data frame */
 		WARN_ONCE(info->control.rates[0].flags & IEEE80211_TX_RC_MCS &&
 			  !ieee80211_is_data(fc),
 			  "Got a HT rate (flags:0x%x/mcs:%d/fc:0x%x/state:%d) for a non data frame\n",
 			  info->control.rates[0].flags,
 			  info->control.rates[0].idx,
-			  le16_to_cpu(fc), mvmsta->sta_state);
+			  le16_to_cpu(fc), sta ? mvmsta->sta_state : -1);
 		rate_idx = info->control.rates[0].idx;
 	}

drivers/net/wireless/mediatek/mt76/Makefile+1−1

@@ -34,4 +34,4 @@ obj-$(CONFIG_MT76x2_COMMON) += mt76x2/ · 33 unmodified lines
34	obj-$(CONFIG_MT7603E) += mt7603/	34	obj-$(CONFIG_MT7603E) += mt7603/
35	obj-$(CONFIG_MT7615_COMMON) += mt7615/	35	obj-$(CONFIG_MT7615_COMMON) += mt7615/
36	obj-$(CONFIG_MT7915E) += mt7915/	36	obj-$(CONFIG_MT7915E) += mt7915/
37	obj-$(CONFIG_MT7921E) += mt7921/	37	obj-$(CONFIG_MT7921_COMMON) += mt7921/

drivers/nvme/host/core.c+18−5

@@ -666,6 +666,7 @@ blk_status_t nvme_fail_nonready_command(struct nvme_ctrl *ctrl, · 665 unmodified lines
666	struct request *rq)	666	struct request *rq)
667	{	667	{
668	if (ctrl->state != NVME_CTRL_DELETING_NOIO &&	668	if (ctrl->state != NVME_CTRL_DELETING_NOIO &&
		669	ctrl->state != NVME_CTRL_DELETING &&
669	ctrl->state != NVME_CTRL_DEAD &&	670	ctrl->state != NVME_CTRL_DEAD &&
670	!test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ctrl->flags) &&	671	!test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ctrl->flags) &&
671	!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))	672	!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
@@ -1749,9 +1750,20 @@ static int nvme_configure_metadata(struct nvme_ns ns, struct nvme_id_ns id) · 1077 unmodified lines
1749	*/	1750	*/
1750	if (WARN_ON_ONCE(!(id->flbas & NVME_NS_FLBAS_META_EXT)))	1751	if (WARN_ON_ONCE(!(id->flbas & NVME_NS_FLBAS_META_EXT)))
1751	return -EINVAL;	1752	return -EINVAL;
1752	if (ctrl->max_integrity_segments)	1753
1753	ns->features \|=	1754	ns->features \|= NVME_NS_EXT_LBAS;
1754	(NVME_NS_METADATA_SUPPORTED \| NVME_NS_EXT_LBAS);	1755
		1756	/*
		1757	* The current fabrics transport drivers support namespace
		1758	* metadata formats only if nvme_ns_has_pi() returns true.
		1759	* Suppress support for all other formats so the namespace will
		1760	* have a 0 capacity and not be usable through the block stack.
		1761	*
		1762	* Note, this check will need to be modified if any drivers
		1763	* gain the ability to use other metadata formats.
		1764	*/
		1765	if (ctrl->max_integrity_segments && nvme_ns_has_pi(ns))
		1766	ns->features \|= NVME_NS_METADATA_SUPPORTED;
1755	} else {	1767	} else {
1756	/*	1768	/*
1757	* For PCIe controllers, we can't easily remap the separate	1769	* For PCIe controllers, we can't easily remap the separate
@@ -2696,8 +2708,9 @@ static bool nvme_validate_cntlid(struct nvme_subsystem *subsys, · 938 unmodified lines
2696		2708
2697	if (tmp->cntlid == ctrl->cntlid) {	2709	if (tmp->cntlid == ctrl->cntlid) {
2698	dev_err(ctrl->device,	2710	dev_err(ctrl->device,
2699	"Duplicate cntlid %u with %s, rejecting\n",	2711	"Duplicate cntlid %u with %s, subsys %s, rejecting\n",
2700	ctrl->cntlid, dev_name(tmp->device));	2712	ctrl->cntlid, dev_name(tmp->device),
		2713	subsys->subnqn);
2701	return false;	2714	return false;
2702	}	2715	}
2703		2716

drivers/nvme/host/multipath.c+2−1

 	}
 	if (ana_log_size > ctrl->ana_log_size) {
 		nvme_mpath_stop(ctrl);
-		kfree(ctrl->ana_log_buf);
+		nvme_mpath_uninit(ctrl);
 		ctrl->ana_log_buf = kmalloc(ana_log_size, GFP_KERNEL);
 		if (!ctrl->ana_log_buf)
 			return -ENOMEM;
 {
 	kfree(ctrl->ana_log_buf);
 	ctrl->ana_log_buf = NULL;
+	ctrl->ana_log_size = 0;
 }

drivers/nvme/host/nvme.h+1−1

@@ -709,7 +709,7 @@ static inline bool nvme_check_ready(struct nvme_ctrl ctrl, struct request rq, · 708 unmodified lines
709	return true;	709	return true;
710	if (ctrl->ops->flags & NVME_F_FABRICS &&	710	if (ctrl->ops->flags & NVME_F_FABRICS &&
711	ctrl->state == NVME_CTRL_DELETING)	711	ctrl->state == NVME_CTRL_DELETING)
712	return true;	712	return queue_live;
713	return __nvme_check_ready(ctrl, rq, queue_live);	713	return __nvme_check_ready(ctrl, rq, queue_live);
714	}	714	}
715	int nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,	715	int nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,

drivers/nvme/host/zns.c+4−1

 	zone.len = ns->zsze;
 	zone.capacity = nvme_lba_to_sect(ns, le64_to_cpu(entry->zcap));
 	zone.start = nvme_lba_to_sect(ns, le64_to_cpu(entry->zslba));
-	zone.wp = nvme_lba_to_sect(ns, le64_to_cpu(entry->wp));
+	if (zone.cond == BLK_ZONE_COND_FULL)
+		zone.wp = zone.start + zone.len;
+	else
+		zone.wp = nvme_lba_to_sect(ns, le64_to_cpu(entry->wp));
 	return cb(&zone, idx, data);
 }

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

 	size_t data_len = le32_to_cpu(req->cmd->common.dptr.sgl.length);
 	int ret;
-	if (!nvme_is_write(cmd->req.cmd) ||
+	/*
+	 * This command has not been processed yet, hence we are trying to
+	 * figure out if there is still pending data left to receive. If
+	 * we don't, we can simply prepare for the next pdu and bail out,
+	 * otherwise we will need to prepare a buffer and receive the
+	 * stale data before continuing forward.
+	 */
+	if (!nvme_is_write(cmd->req.cmd) || !data_len ||
 	    data_len > cmd->req.port->inline_data_size) {
 		nvmet_prepare_receive_pdu(queue);
 		return;

drivers/of/irq.c+25−2

@@ -76,6 +76,26 @@ struct device_node of_irq_find_parent(struct device_node child) · 75 unmodified lines
76	}	76	}
77	EXPORT_SYMBOL_GPL(of_irq_find_parent);	77	EXPORT_SYMBOL_GPL(of_irq_find_parent);
78		78
		79	/*
		80	* These interrupt controllers abuse interrupt-map for unspeakable
		81	* reasons and rely on the core code to ignore it (the drivers do
		82	* their own parsing of the property).
		83	*
		84	* If you think of adding to the list for something new, think
		85	* again. There is a high chance that you will be sent back to the
		86	* drawing board.
		87	*/
		88	static const char * const of_irq_imap_abusers[] = {
		89	"CBEA,platform-spider-pic",
		90	"sti,platform-spider-pic",
		91	"realtek,rtl-intc",
		92	"fsl,ls1021a-extirq",
		93	"fsl,ls1043a-extirq",
		94	"fsl,ls1088a-extirq",
		95	"renesas,rza1-irqc",
		96	NULL,
		97	};
		98
79	/**	99	/**
80	* of_irq_parse_raw - Low level interrupt tree parsing	100	* of_irq_parse_raw - Low level interrupt tree parsing
81	* @addr: address specifier (start of "reg" property of the device) in be32 format	101	* @addr: address specifier (start of "reg" property of the device) in be32 format
@@ -159,12 +179,15 @@ int of_irq_parse_raw(const __be32 addr, struct of_phandle_args out_irq) · 77 unmodified lines
159	/*	179	/*
160	* Now check if cursor is an interrupt-controller and	180	* Now check if cursor is an interrupt-controller and
161	* if it is then we are done, unless there is an	181	* if it is then we are done, unless there is an
162	* interrupt-map which takes precedence.	182	* interrupt-map which takes precedence except on one
		183	* of these broken platforms that want to parse
		184	* interrupt-map themselves for $reason.
163	*/	185	*/
164	bool intc = of_property_read_bool(ipar, "interrupt-controller");	186	bool intc = of_property_read_bool(ipar, "interrupt-controller");
165		187
166	imap = of_get_property(ipar, "interrupt-map", &imaplen);	188	imap = of_get_property(ipar, "interrupt-map", &imaplen);
167	if (imap == NULL && intc) {	189	if (intc &&
		190	(!imap \|\| of_device_compatible_match(ipar, of_irq_imap_abusers))) {
168	pr_debug(" -> got it !\n");	191	pr_debug(" -> got it !\n");
169	return 0;	192	return 0;
170	}	193	}

drivers/pci/controller/Kconfig+2−2

@@ -332,8 +332,8 @@ config PCIE_APPLE · 331 unmodified lines
332	If unsure, say Y if you have an Apple Silicon system.	332	If unsure, say Y if you have an Apple Silicon system.
333		333
334	config PCIE_MT7621	334	config PCIE_MT7621
335	tristate "MediaTek MT7621 PCIe Controller"	335	bool "MediaTek MT7621 PCIe Controller"
336	depends on (RALINK && SOC_MT7621) \|\| (MIPS && COMPILE_TEST)	336	depends on SOC_MT7621 \|\| (MIPS && COMPILE_TEST)
337	select PHY_MT7621_PCI	337	select PHY_MT7621_PCI
338	default SOC_MT7621	338	default SOC_MT7621
339	help	339	help

drivers/pci/controller/pci-aardvark.c+0−9

 #define PCIE_CORE_DEV_ID_REG					0x0
 #define PCIE_CORE_CMD_STATUS_REG				0x4
 #define PCIE_CORE_DEV_REV_REG					0x8
-#define PCIE_CORE_EXP_ROM_BAR_REG				0x30
 #define PCIE_CORE_PCIEXP_CAP					0xc0
 #define PCIE_CORE_ERR_CAPCTL_REG				0x118
 #define     PCIE_CORE_ERR_CAPCTL_ECRC_CHK_TX			BIT(5)
 		*value = advk_readl(pcie, PCIE_CORE_CMD_STATUS_REG);
 		return PCI_BRIDGE_EMUL_HANDLED;
-	case PCI_ROM_ADDRESS1:
-		*value = advk_readl(pcie, PCIE_CORE_EXP_ROM_BAR_REG);
-		return PCI_BRIDGE_EMUL_HANDLED;
 	case PCI_INTERRUPT_LINE: {
 		/*
 		 * From the whole 32bit register we support reading from HW only
 		advk_writel(pcie, new, PCIE_CORE_CMD_STATUS_REG);
 		break;
-	case PCI_ROM_ADDRESS1:
-		advk_writel(pcie, new, PCIE_CORE_EXP_ROM_BAR_REG);
-		break;
 	case PCI_INTERRUPT_LINE:
 		if (mask & (PCI_BRIDGE_CTL_BUS_RESET << 16)) {
 			u32 val = advk_readl(pcie, PCIE_CORE_CTRL1_REG);

drivers/pci/controller/pcie-apple.c+12−2

 	int ret, i;
 	reset = gpiod_get_from_of_node(np, "reset-gpios", 0,
-				       GPIOD_OUT_LOW, "#PERST");
+				       GPIOD_OUT_LOW, "PERST#");
 	if (IS_ERR(reset))
 		return PTR_ERR(reset);
 	rmw_set(PORT_APPCLK_EN, port->base + PORT_APPCLK);
+	/* Assert PERST# before setting up the clock */
+	gpiod_set_value(reset, 1);
 	ret = apple_pcie_setup_refclk(pcie, port);
 	if (ret < 0)
 		return ret;
+	/* The minimal Tperst-clk value is 100us (PCIe CEM r5.0, 2.9.2) */
+	usleep_range(100, 200);
+	/* Deassert PERST# */
 	rmw_set(PORT_PERST_OFF, port->base + PORT_PERST);
-	gpiod_set_value(reset, 1);
+	gpiod_set_value(reset, 0);
+	/* Wait for 100ms after PERST# deassertion (PCIe r5.0, 6.6.1) */
+	msleep(100);
 	ret = readl_relaxed_poll_timeout(port->base + PORT_STATUS, stat,
 					 stat & PORT_STATUS_READY, 100, 250000);

drivers/phy/hisilicon/phy-hi3670-pcie.c+2−2

@@ -757,8 +757,8 @@ static int hi3670_pcie_phy_get_resources(struct hi3670_pcie_phy *phy, · 756 unmodified lines
757	return PTR_ERR(phy->sysctrl);	757	return PTR_ERR(phy->sysctrl);
758		758
759	phy->pmctrl = syscon_regmap_lookup_by_compatible("hisilicon,hi3670-pmctrl");	759	phy->pmctrl = syscon_regmap_lookup_by_compatible("hisilicon,hi3670-pmctrl");
760	if (IS_ERR(phy->sysctrl))	760	if (IS_ERR(phy->pmctrl))
761	return PTR_ERR(phy->sysctrl);	761	return PTR_ERR(phy->pmctrl);
762		762
763	/* clocks */	763	/* clocks */
764	phy->phy_ref_clk = devm_clk_get(dev, "phy_ref");	764	phy->phy_ref_clk = devm_clk_get(dev, "phy_ref");

drivers/phy/marvell/phy-mvebu-cp110-utmi.c+2−2

@@ -82,9 +82,9 @@ · 81 unmodified lines
82	* struct mvebu_cp110_utmi - PHY driver data	82	* struct mvebu_cp110_utmi - PHY driver data
83	*	83	*
84	* @regs: PHY registers	84	* @regs: PHY registers
85	* @syscom: Regmap with system controller registers	85	* @syscon: Regmap with system controller registers
86	* @dev: device driver handle	86	* @dev: device driver handle
87	* @caps: PHY capabilities	87	* @ops: phy ops
88	*/	88	*/
89	struct mvebu_cp110_utmi {	89	struct mvebu_cp110_utmi {
90	void __iomem *regs;	90	void __iomem *regs;

drivers/phy/qualcomm/phy-qcom-ipq806x-usb.c+14−12

 };
 /**
- * Write register and read back masked value to confirm it is written
+ * usb_phy_write_readback() - Write register and read back masked value to
+ * confirm it is written
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @offset - register offset.
+ * @offset: register offset.
- * @mask - register bitmask specifying what should be updated
+ * @mask: register bitmask specifying what should be updated
- * @val - value to write.
+ * @val: value to write.
  */
 static inline void usb_phy_write_readback(struct usb_phy *phy_dwc3,
 					  u32 offset,
 }
 /**
- * Write SSPHY register
+ * usb_ss_write_phycreg() - Write SSPHY register
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @addr - SSPHY address to write.
+ * @addr: SSPHY address to write.
- * @val - value to write.
+ * @val: value to write.
  */
 static int usb_ss_write_phycreg(struct usb_phy *phy_dwc3,
 				u32 addr, u32 val)
 }
 /**
- * Read SSPHY register.
+ * usb_ss_read_phycreg() - Read SSPHY register.
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @addr - SSPHY address to read.
+ * @addr: SSPHY address to read.
+ * @val: pointer in which read is store.
  */
 static int usb_ss_read_phycreg(struct usb_phy *phy_dwc3,
 			       u32 addr, u32 *val)

drivers/phy/qualcomm/phy-qcom-qmp.c+3−0

  * @qmp: QMP phy to which this lane belongs
  * @lane_rst: lane's reset controller
  * @mode: current PHY mode
+ * @dp_aux_cfg: Display port aux config
+ * @dp_opts: Display port optional config
+ * @dp_clks: Display port clocks
  */
 struct qmp_phy {
 	struct phy *phy;

drivers/phy/qualcomm/phy-qcom-usb-hsic.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/**	2	/*
3	* Copyright (C) 2016 Linaro Ltd	3	* Copyright (C) 2016 Linaro Ltd
4	*/	4	*/
5	#include <linux/module.h>	5	#include <linux/module.h>

drivers/phy/st/phy-stm32-usbphyc.c+1−1

@@ -478,7 +478,7 @@ static void stm32_usbphyc_phy_tuning(struct stm32_usbphyc *usbphyc, · 477 unmodified lines
478	if (!of_property_read_bool(np, "st,no-lsfs-fb-cap"))	478	if (!of_property_read_bool(np, "st,no-lsfs-fb-cap"))
479	usbphyc_phy->tune \|= LFSCAPEN;	479	usbphyc_phy->tune \|= LFSCAPEN;
480		480
481	if (of_property_read_bool(np, "st,slow-hs-slew-rate"))	481	if (of_property_read_bool(np, "st,decrease-hs-slew-rate"))
482	usbphyc_phy->tune \|= HSDRVSLEW;	482	usbphyc_phy->tune \|= HSDRVSLEW;
483		483
484	ret = of_property_read_u32(np, "st,tune-hs-dc-level", &val);	484	ret = of_property_read_u32(np, "st,tune-hs-dc-level", &val);

drivers/phy/ti/phy-am654-serdes.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/**	2	/*
3	* PCIe SERDES driver for AM654x SoC	3	* PCIe SERDES driver for AM654x SoC
4	*	4	*
5	* Copyright (C) 2018 - 2019 Texas Instruments Incorporated - http://www.ti.com/	5	* Copyright (C) 2018 - 2019 Texas Instruments Incorporated - http://www.ti.com/

drivers/phy/ti/phy-j721e-wiz.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/**	2	/*
3	* Wrapper driver for SERDES used in J721E	3	* Wrapper driver for SERDES used in J721E
4	*	4	*
5	* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/	5	* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/

drivers/phy/ti/phy-omap-usb2.c+3−3

@@ -89,9 +89,9 @@ static inline void omap_usb_writel(void __iomem *addr, unsigned int offset, · 88 unmodified lines
89	}	89	}
90		90
91	/**	91	/**
92	* omap_usb2_set_comparator - links the comparator present in the system with	92	* omap_usb2_set_comparator() - links the comparator present in the system with this phy
93	* this phy	93	*
94	* @comparator - the companion phy(comparator) for this phy	94	* @comparator: the companion phy(comparator) for this phy
95	*	95	*
96	* The phy companion driver should call this API passing the phy_companion	96	* The phy companion driver should call this API passing the phy_companion
97	* filled with set_vbus and start_srp to be used by usb phy.	97	* filled with set_vbus and start_srp to be used by usb phy.

drivers/phy/ti/phy-tusb1210.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/**	2	/*
3	* tusb1210.c - TUSB1210 USB ULPI PHY driver	3	* tusb1210.c - TUSB1210 USB ULPI PHY driver
4	*	4	*
5	* Copyright (C) 2015 Intel Corporation	5	* Copyright (C) 2015 Intel Corporation

drivers/reset/tegra/reset-bpmp.c+1−8

 	struct tegra_bpmp *bpmp = to_tegra_bpmp(rstc);
 	struct mrq_reset_request request;
 	struct tegra_bpmp_message msg;
-	int err;
 	memset(&request, 0, sizeof(request));
 	request.cmd = command;
 	msg.tx.data = &request;
 	msg.tx.size = sizeof(request);
-	err = tegra_bpmp_transfer(bpmp, &msg);
+	return tegra_bpmp_transfer(bpmp, &msg);
-	if (err)
-		return err;
-	if (msg.rx.ret)
-		return -EINVAL;
-	return 0;
 }
 static int tegra_bpmp_reset_module(struct reset_controller_dev *rstc,

drivers/scsi/pm8001/pm8001_init.c+2−4

 	if (rc) {
 		pm8001_dbg(pm8001_ha, FAIL,
 			   "pm8001_setup_irq failed [ret: %d]\n", rc);
-		goto err_out_shost;
+		goto err_out;
 	}
 	/* Request Interrupt */
 	rc = pm8001_request_irq(pm8001_ha);
 	if (rc)
-		goto err_out_shost;
+		goto err_out;
 	count = pm8001_ha->max_q_num;
 	/* Queues are chosen based on the number of cores/msix availability */
 	pm8001_tag_init(pm8001_ha);
 	return 0;
-err_out_shost:
-	scsi_remove_host(pm8001_ha->shost);
 err_out_nodev:
 	for (i = 0; i < pm8001_ha->max_memcnt; i++) {
 		if (pm8001_ha->memoryMap.region[i].virt_ptr != NULL) {

drivers/scsi/qedi/qedi_fw.c+15−22

 {
 	struct qedi_work_map *work, *work_tmp;
 	u32 proto_itt = cqe->itid;
-	itt_t protoitt = 0;
 	int found = 0;
 	struct qedi_cmd *qedi_cmd = NULL;
 	u32 iscsi_cid;
 	return;
 check_cleanup_reqs:
-	if (qedi_conn->cmd_cleanup_req > 0) {
+	if (atomic_inc_return(&qedi_conn->cmd_cleanup_cmpl) ==
-		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_TID,
+	    qedi_conn->cmd_cleanup_req) {
+		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 			  "Freeing tid=0x%x for cid=0x%x\n",
 			  cqe->itid, qedi_conn->iscsi_conn_id);
-		qedi_conn->cmd_cleanup_cmpl++;
 		wake_up(&qedi_conn->wait_queue);
-	} else {
-		QEDI_ERR(&qedi->dbg_ctx,
-			 "Delayed or untracked cleanup response, itt=0x%x, tid=0x%x, cid=0x%x\n",
-			 protoitt, cqe->itid, qedi_conn->iscsi_conn_id);
 	}
 }
 	}
 	qedi_conn->cmd_cleanup_req = 0;
-	qedi_conn->cmd_cleanup_cmpl = 0;
+	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 		  "active_cmd_count=%d, cid=0x%x, in_recovery=%d, lun_reset=%d\n",
 		  qedi_conn->iscsi_conn_id);
 	rval  = wait_event_interruptible_timeout(qedi_conn->wait_queue,
-						 ((qedi_conn->cmd_cleanup_req ==
+				(qedi_conn->cmd_cleanup_req ==
-						 qedi_conn->cmd_cleanup_cmpl) ||
+				 atomic_read(&qedi_conn->cmd_cleanup_cmpl)) ||
-						 test_bit(QEDI_IN_RECOVERY,
+				test_bit(QEDI_IN_RECOVERY, &qedi->flags),
-							  &qedi->flags)),
+				5 * HZ);
-						 5 * HZ);
 	if (rval) {
 		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 			  "i/o cmd_cleanup_req=%d, equal to cmd_cleanup_cmpl=%d, cid=0x%x\n",
 			  qedi_conn->cmd_cleanup_req,
-			  qedi_conn->cmd_cleanup_cmpl,
+			  atomic_read(&qedi_conn->cmd_cleanup_cmpl),
 			  qedi_conn->iscsi_conn_id);
 		return 0;
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 		  "i/o cmd_cleanup_req=%d, not equal to cmd_cleanup_cmpl=%d, cid=0x%x\n",
 		  qedi_conn->cmd_cleanup_req,
-		  qedi_conn->cmd_cleanup_cmpl,
+		  atomic_read(&qedi_conn->cmd_cleanup_cmpl),
 		  qedi_conn->iscsi_conn_id);
 	iscsi_host_for_each_session(qedi->shost,
 	/* Enable IOs for all other sessions except current.*/
 	if (!wait_event_interruptible_timeout(qedi_conn->wait_queue,
-					      (qedi_conn->cmd_cleanup_req ==
+				(qedi_conn->cmd_cleanup_req ==
-					       qedi_conn->cmd_cleanup_cmpl) ||
+				 atomic_read(&qedi_conn->cmd_cleanup_cmpl)) ||
-					       test_bit(QEDI_IN_RECOVERY,
+				test_bit(QEDI_IN_RECOVERY, &qedi->flags),
-							&qedi->flags),
+				5 * HZ)) {
-					      5 * HZ)) {
 		iscsi_host_for_each_session(qedi->shost,
 					    qedi_mark_device_available);
 		return -1;
 	qedi_ep = qedi_conn->ep;
 	qedi_conn->cmd_cleanup_req = 0;
-	qedi_conn->cmd_cleanup_cmpl = 0;
+	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
 	if (!qedi_ep) {
 		QEDI_WARN(&qedi->dbg_ctx,

drivers/scsi/qedi/qedi_iscsi.c+1−1

@@ -412,7 +412,7 @@ static int qedi_conn_bind(struct iscsi_cls_session *cls_session, · 411 unmodified lines
412	qedi_conn->iscsi_conn_id = qedi_ep->iscsi_cid;	412	qedi_conn->iscsi_conn_id = qedi_ep->iscsi_cid;
413	qedi_conn->fw_cid = qedi_ep->fw_cid;	413	qedi_conn->fw_cid = qedi_ep->fw_cid;
414	qedi_conn->cmd_cleanup_req = 0;	414	qedi_conn->cmd_cleanup_req = 0;
415	qedi_conn->cmd_cleanup_cmpl = 0;	415	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
416		416
417	if (qedi_bind_conn_to_iscsi_cid(qedi, qedi_conn)) {	417	if (qedi_bind_conn_to_iscsi_cid(qedi, qedi_conn)) {
418	rc = -EINVAL;	418	rc = -EINVAL;

drivers/scsi/qedi/qedi_iscsi.h+1−1

@@ -155,7 +155,7 @@ struct qedi_conn { · 154 unmodified lines
155	spinlock_t list_lock; /* internal conn lock */	155	spinlock_t list_lock; /* internal conn lock */
156	u32 active_cmd_count;	156	u32 active_cmd_count;
157	u32 cmd_cleanup_req;	157	u32 cmd_cleanup_req;
158	u32 cmd_cleanup_cmpl;	158	atomic_t cmd_cleanup_cmpl;
159		159
160	u32 iscsi_conn_id;	160	u32 iscsi_conn_id;
161	int itt;	161	int itt;

drivers/scsi/qla2xxx/qla_dbg.c+3−0

@@ -2491,6 +2491,9 @@ ql_dbg(uint level, scsi_qla_host_t vha, uint id, const char fmt, ...) · 2490 unmodified lines
2491	struct va_format vaf;	2491	struct va_format vaf;
2492	char pbuf[64];	2492	char pbuf[64];
2493		2493
		2494	if (!ql_mask_match(level) && !trace_ql_dbg_log_enabled())
		2495	return;
		2496
2494	va_start(va, fmt);	2497	va_start(va, fmt);
2495		2498
2496	vaf.fmt = fmt;	2499	vaf.fmt = fmt;

drivers/scsi/scsi_debug.c+1−1

@@ -4342,7 +4342,7 @@ static int resp_report_zones(struct scsi_cmnd *scp, · 4341 unmodified lines
4342	rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),	4342	rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),
4343	max_zones);	4343	max_zones);
4344		4344
4345	arr = kcalloc(RZONES_DESC_HD, alloc_len, GFP_ATOMIC);	4345	arr = kzalloc(alloc_len, GFP_ATOMIC);
4346	if (!arr) {	4346	if (!arr) {
4347	mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,	4347	mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4348	INSUFF_RES_ASCQ);	4348	INSUFF_RES_ASCQ);

drivers/soc/imx/imx8m-blk-ctrl.c+19−0

 #define BLK_SFT_RSTN	0x0
 #define BLK_CLK_EN	0x4
+#define BLK_MIPI_RESET_DIV	0x8 /* Mini/Nano DISPLAY_BLK_CTRL only */
 struct imx8m_blk_ctrl_domain;
 	const char *gpc_name;
 	u32 rst_mask;
 	u32 clk_mask;
+	/*
+	 * i.MX8M Mini and Nano have a third DISPLAY_BLK_CTRL register
+	 * which is used to control the reset for the MIPI Phy.
+	 * Since it's only present in certain circumstances,
+	 * an if-statement should be used before setting and clearing this
+	 * register.
+	 */
+	u32 mipi_phy_rst_mask;
 };
 #define DOMAIN_MAX_CLKS 3
 	/* put devices into reset */
 	regmap_clear_bits(bc->regmap, BLK_SFT_RSTN, data->rst_mask);
+	if (data->mipi_phy_rst_mask)
+		regmap_clear_bits(bc->regmap, BLK_MIPI_RESET_DIV, data->mipi_phy_rst_mask);
 	/* enable upstream and blk-ctrl clocks to allow reset to propagate */
 	ret = clk_bulk_prepare_enable(data->num_clks, domain->clks);
 	/* release reset */
 	regmap_set_bits(bc->regmap, BLK_SFT_RSTN, data->rst_mask);
+	if (data->mipi_phy_rst_mask)
+		regmap_set_bits(bc->regmap, BLK_MIPI_RESET_DIV, data->mipi_phy_rst_mask);
 	/* disable upstream clocks */
 	clk_bulk_disable_unprepare(data->num_clks, domain->clks);
 	struct imx8m_blk_ctrl *bc = domain->bc;
 	/* put devices into reset and disable clocks */
+	if (data->mipi_phy_rst_mask)
+		regmap_clear_bits(bc->regmap, BLK_MIPI_RESET_DIV, data->mipi_phy_rst_mask);
 	regmap_clear_bits(bc->regmap, BLK_SFT_RSTN, data->rst_mask);
 	regmap_clear_bits(bc->regmap, BLK_CLK_EN, data->clk_mask);
 		.gpc_name = "mipi-dsi",
 		.rst_mask = BIT(5),
 		.clk_mask = BIT(8) | BIT(9),
+		.mipi_phy_rst_mask = BIT(17),
 	},
 	[IMX8MM_DISPBLK_PD_MIPI_CSI] = {
 		.name = "dispblk-mipi-csi",
 		.gpc_name = "mipi-csi",
 		.rst_mask = BIT(3) | BIT(4),
 		.clk_mask = BIT(10) | BIT(11),
+		.mipi_phy_rst_mask = BIT(16),
 	},
 };

drivers/soc/imx/soc-imx.c+4−0

@@ -36,6 +36,10 @@ static int __init imx_soc_device_init(void) · 35 unmodified lines
36	int ret;	36	int ret;
37	int i;	37	int i;
38		38
		39	/* Return early if this is running on devices with different SoCs */
		40	if (!__mxc_cpu_type)
		41	return 0;
		42
39	if (of_machine_is_compatible("fsl,ls1021a"))	43	if (of_machine_is_compatible("fsl,ls1021a"))
40	return 0;	44	return 0;
41		45

drivers/soc/tegra/fuse/fuse-tegra.c+1−1

@@ -320,7 +320,7 @@ static struct platform_driver tegra_fuse_driver = { · 319 unmodified lines
320	};	320	};
321	builtin_platform_driver(tegra_fuse_driver);	321	builtin_platform_driver(tegra_fuse_driver);
322		322
323	bool __init tegra_fuse_read_spare(unsigned int spare)	323	u32 __init tegra_fuse_read_spare(unsigned int spare)
324	{	324	{
325	unsigned int offset = fuse->soc->info->spare + spare * 4;	325	unsigned int offset = fuse->soc->info->spare + spare * 4;
326		326

drivers/soc/tegra/fuse/fuse.h+1−1

@@ -65,7 +65,7 @@ struct tegra_fuse { · 64 unmodified lines
65	void tegra_init_revision(void);	65	void tegra_init_revision(void);
66	void tegra_init_apbmisc(void);	66	void tegra_init_apbmisc(void);
67		67
68	bool __init tegra_fuse_read_spare(unsigned int spare);	68	u32 __init tegra_fuse_read_spare(unsigned int spare);
69	u32 __init tegra_fuse_read_early(unsigned int offset);	69	u32 __init tegra_fuse_read_early(unsigned int offset);
70		70
71	u8 tegra_get_major_rev(void);	71	u8 tegra_get_major_rev(void);

drivers/tee/amdtee/core.c+2−3

 	*ta_size = roundup(fw->size, PAGE_SIZE);
 	*ta = (void *)__get_free_pages(GFP_KERNEL, get_order(*ta_size));
-	if (IS_ERR(*ta)) {
+	if (!*ta) {
-		pr_err("%s: get_free_pages failed 0x%llx\n", __func__,
+		pr_err("%s: get_free_pages failed\n", __func__);
-		       (u64)*ta);
 		rc = -ENOMEM;
 		goto rel_fw;
 	}

drivers/thermal/intel/int340x_thermal/processor_thermal_rfim.c+1−1

@@ -29,7 +29,7 @@ static const char * const fivr_strings[] = { · 28 unmodified lines
29	};	29	};
30		30
31	static const struct mmio_reg tgl_fivr_mmio_regs[] = {	31	static const struct mmio_reg tgl_fivr_mmio_regs[] = {
32	{ 0, 0x5A18, 3, 0x7, 12}, /* vco_ref_code_lo */	32	{ 0, 0x5A18, 3, 0x7, 11}, /* vco_ref_code_lo */
33	{ 0, 0x5A18, 8, 0xFF, 16}, /* vco_ref_code_hi */	33	{ 0, 0x5A18, 8, 0xFF, 16}, /* vco_ref_code_hi */
34	{ 0, 0x5A08, 8, 0xFF, 0}, /* spread_spectrum_pct */	34	{ 0, 0x5A08, 8, 0xFF, 0}, /* spread_spectrum_pct */
35	{ 0, 0x5A08, 1, 0x1, 8}, /* spread_spectrum_clk_enable */	35	{ 0, 0x5A08, 1, 0x1, 8}, /* spread_spectrum_clk_enable */

drivers/usb/core/config.c+3−3

@@ -406,7 +406,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, · 405 unmodified lines
406	* the USB-2 spec requires such endpoints to have wMaxPacketSize = 0	406	* the USB-2 spec requires such endpoints to have wMaxPacketSize = 0
407	* (see the end of section 5.6.3), so don't warn about them.	407	* (see the end of section 5.6.3), so don't warn about them.
408	*/	408	*/
409	maxp = usb_endpoint_maxp(&endpoint->desc);	409	maxp = le16_to_cpu(endpoint->desc.wMaxPacketSize);
410	if (maxp == 0 && !(usb_endpoint_xfer_isoc(d) && asnum == 0)) {	410	if (maxp == 0 && !(usb_endpoint_xfer_isoc(d) && asnum == 0)) {
411	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has invalid wMaxPacketSize 0\n",	411	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has invalid wMaxPacketSize 0\n",
412	cfgno, inum, asnum, d->bEndpointAddress);	412	cfgno, inum, asnum, d->bEndpointAddress);
@@ -422,9 +422,9 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, · 9 unmodified lines
422	maxpacket_maxes = full_speed_maxpacket_maxes;	422	maxpacket_maxes = full_speed_maxpacket_maxes;
423	break;	423	break;
424	case USB_SPEED_HIGH:	424	case USB_SPEED_HIGH:
425	/* Bits 12..11 are allowed only for HS periodic endpoints */	425	/* Multiple-transactions bits are allowed only for HS periodic endpoints */
426	if (usb_endpoint_xfer_int(d) \|\| usb_endpoint_xfer_isoc(d)) {	426	if (usb_endpoint_xfer_int(d) \|\| usb_endpoint_xfer_isoc(d)) {
427	i = maxp & (BIT(12) \| BIT(11));	427	i = maxp & USB_EP_MAXP_MULT_MASK;
428	maxp &= ~i;	428	maxp &= ~i;
429	}	429	}
430	fallthrough;	430	fallthrough;

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

@@ -649,7 +649,6 @@ static int dwc3_qcom_of_register_core(struct platform_device *pdev) · 648 unmodified lines
649	struct dwc3_qcom *qcom = platform_get_drvdata(pdev);	649	struct dwc3_qcom *qcom = platform_get_drvdata(pdev);
650	struct device_node np = pdev->dev.of_node, dwc3_np;	650	struct device_node np = pdev->dev.of_node, dwc3_np;
651	struct device *dev = &pdev->dev;	651	struct device *dev = &pdev->dev;
652	struct property *prop;
653	int ret;	652	int ret;
654		653
655	dwc3_np = of_get_compatible_child(np, "snps,dwc3");	654	dwc3_np = of_get_compatible_child(np, "snps,dwc3");
@@ -658,20 +657,6 @@ static int dwc3_qcom_of_register_core(struct platform_device *pdev) · 2 unmodified lines
658	return -ENODEV;	657	return -ENODEV;
659	}	658	}
660		659
661	prop = devm_kzalloc(dev, sizeof(*prop), GFP_KERNEL);
662	if (!prop) {
663	ret = -ENOMEM;
664	dev_err(dev, "unable to allocate memory for property\n");
665	goto node_put;
666	}
667
668	prop->name = "tx-fifo-resize";
669	ret = of_add_property(dwc3_np, prop);
670	if (ret) {
671	dev_err(dev, "unable to add property\n");
672	goto node_put;
673	}
674
675	ret = of_platform_populate(np, NULL, NULL, dev);	660	ret = of_platform_populate(np, NULL, NULL, dev);
676	if (ret) {	661	if (ret) {
677	dev_err(dev, "failed to register dwc3 core - %d\n", ret);	662	dev_err(dev, "failed to register dwc3 core - %d\n", ret);

drivers/usb/gadget/composite.c+13−1

 	struct usb_function		*f = NULL;
 	u8				endp;
+	if (w_length > USB_COMP_EP0_BUFSIZ) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			goto done;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(USB_COMP_EP0_BUFSIZ);
+			w_length = USB_COMP_EP0_BUFSIZ;
+		}
+	}
 	/* partial re-init of the response message; the function or the
 	 * gadget might need to intercept e.g. a control-OUT completion
 	 * when we delegate to it.
 	if (!cdev->req)
 		return -ENOMEM;
-	cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
+	cdev->req->buf = kzalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
 	if (!cdev->req->buf)
 		goto fail;

drivers/usb/gadget/legacy/dbgp.c+14−1

 		goto fail_1;
 	}
-	req->buf = kmalloc(DBGP_REQ_LEN, GFP_KERNEL);
+	req->buf = kzalloc(DBGP_REQ_LEN, GFP_KERNEL);
 	if (!req->buf) {
 		err = -ENOMEM;
 		stp = 2;
 	void *data = NULL;
 	u16 len = 0;
+	if (length > DBGP_REQ_LEN) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			return err;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(DBGP_REQ_LEN);
+			length = DBGP_REQ_LEN;
+		}
+	}
 	if (request == USB_REQ_GET_DESCRIPTOR) {
 		switch (value>>8) {
 		case USB_DT_DEVICE:

drivers/usb/gadget/legacy/inode.c+15−1

 /* enough for the whole queue: most events invalidate others */
 #define	N_EVENT			5
+#define RBUF_SIZE		256
 struct dev_data {
 	spinlock_t			lock;
 	refcount_t			count;
 	struct dentry			*dentry;
 	/* except this scratch i/o buffer for ep0 */
-	u8				rbuf [256];
+	u8				rbuf[RBUF_SIZE];
 };
 static inline void get_dev (struct dev_data *data)
 	u16				w_value = le16_to_cpu(ctrl->wValue);
 	u16				w_length = le16_to_cpu(ctrl->wLength);
+	if (w_length > RBUF_SIZE) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			return value;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(RBUF_SIZE);
+			w_length = RBUF_SIZE;
+		}
+	}
 	spin_lock (&dev->lock);
 	dev->setup_abort = 0;
 	if (dev->state == STATE_DEV_UNCONNECTED) {

drivers/usb/host/xhci-hub.c+1−0

@@ -717,6 +717,7 @@ static int xhci_enter_test_mode(struct xhci_hcd *xhci, · 716 unmodified lines
717	continue;	717	continue;
718		718
719	retval = xhci_disable_slot(xhci, i);	719	retval = xhci_disable_slot(xhci, i);
		720	xhci_free_virt_device(xhci, i);
720	if (retval)	721	if (retval)
721	xhci_err(xhci, "Failed to disable slot %d, %d. Enter test mode anyway\n",	722	xhci_err(xhci, "Failed to disable slot %d, %d. Enter test mode anyway\n",
722	i, retval);	723	i, retval);

drivers/usb/host/xhci-ring.c+0−1

@@ -1525,7 +1525,6 @@ static void xhci_handle_cmd_disable_slot(struct xhci_hcd *xhci, int slot_id) · 1524 unmodified lines
1525	if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)	1525	if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
1526	/* Delete default control endpoint resources */	1526	/* Delete default control endpoint resources */
1527	xhci_free_device_endpoint_resources(xhci, virt_dev, true);	1527	xhci_free_device_endpoint_resources(xhci, virt_dev, true);
1528	xhci_free_virt_device(xhci, slot_id);
1529	}	1528	}
1530		1529
1531	static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,	1530	static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,

drivers/usb/host/xhci.c+15−11

 	struct xhci_slot_ctx *slot_ctx;
 	int i, ret;
-#ifndef CONFIG_USB_DEFAULT_PERSIST
 	/*
 	 * We called pm_runtime_get_noresume when the device was attached.
 	 * Decrement the counter here to allow controller to runtime suspend
 	 */
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		pm_runtime_put_noidle(hcd->self.controller);
-#endif
 	ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
 	/* If the host is halted due to driver unload, we still need to free the
 		del_timer_sync(&virt_dev->eps[i].stop_cmd_timer);
 	}
 	virt_dev->udev = NULL;
-	ret = xhci_disable_slot(xhci, udev->slot_id);
+	xhci_disable_slot(xhci, udev->slot_id);
-	if (ret)
+	xhci_free_virt_device(xhci, udev->slot_id);
-		xhci_free_virt_device(xhci, udev->slot_id);
 }
 int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id)
 	u32 state;
 	int ret = 0;
-	command = xhci_alloc_command(xhci, false, GFP_KERNEL);
+	command = xhci_alloc_command(xhci, true, GFP_KERNEL);
 	if (!command)
 		return -ENOMEM;
 	}
 	xhci_ring_cmd_db(xhci);
 	spin_unlock_irqrestore(&xhci->lock, flags);
+	wait_for_completion(command->completion);
+	if (command->status != COMP_SUCCESS)
+		xhci_warn(xhci, "Unsuccessful disable slot %u command, status %d\n",
+			  slot_id, command->status);
+	xhci_free_command(xhci, command);
 	return ret;
 }
 	xhci_debugfs_create_slot(xhci, slot_id);
-#ifndef CONFIG_USB_DEFAULT_PERSIST
 	/*
 	 * If resetting upon resume, we can't put the controller into runtime
 	 * suspend if there is a device attached.
 	 */
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		pm_runtime_get_noresume(hcd->self.controller);
-#endif
 	/* Is this a LS or FS device under a HS hub? */
 	/* Hub or peripherial? */
 	return 1;
 disable_slot:
-	ret = xhci_disable_slot(xhci, udev->slot_id);
+	xhci_disable_slot(xhci, udev->slot_id);
-	if (ret)
+	xhci_free_virt_device(xhci, udev->slot_id);
-		xhci_free_virt_device(xhci, udev->slot_id);
 	return 0;
 }
 		mutex_unlock(&xhci->mutex);
 		ret = xhci_disable_slot(xhci, udev->slot_id);
+		xhci_free_virt_device(xhci, udev->slot_id);
 		if (!ret)
 			xhci_alloc_dev(hcd, udev);
 		kfree(command->completion);

drivers/vdpa/vdpa.c+2−1

@@ -404,7 +404,8 @@ static int vdpa_mgmtdev_fill(const struct vdpa_mgmt_dev mdev, struct sk_buff m · 403 unmodified lines
404	goto msg_err;	404	goto msg_err;
405		405
406	while (mdev->id_table[i].device) {	406	while (mdev->id_table[i].device) {
407	supported_classes \|= BIT(mdev->id_table[i].device);	407	if (mdev->id_table[i].device <= 63)
		408	supported_classes \|= BIT_ULL(mdev->id_table[i].device);
408	i++;	409	i++;
409	}	410	}
410		411

drivers/vdpa/vdpa_user/vduse_dev.c+4−2

 {
 	struct vduse_dev *dev = vdpa_to_vduse(vdpa);
-	if (len > dev->config_size - offset)
+	if (offset > dev->config_size ||
+	    len > dev->config_size - offset)
 		return;
 	memcpy(buf, dev->config + offset, len);
 			break;
 		ret = -EINVAL;
-		if (config.length == 0 ||
+		if (config.offset > dev->config_size ||
+		    config.length == 0 ||
 		    config.length > dev->config_size - config.offset)
 			break;

drivers/vhost/vdpa.c+1−1

@@ -197,7 +197,7 @@ static int vhost_vdpa_config_validate(struct vhost_vdpa *v, · 196 unmodified lines
197	struct vdpa_device *vdpa = v->vdpa;	197	struct vdpa_device *vdpa = v->vdpa;
198	long size = vdpa->config->get_config_size(vdpa);	198	long size = vdpa->config->get_config_size(vdpa);
199		199
200	if (c->len == 0)	200	if (c->len == 0 \|\| c->off > size)
201	return -EINVAL;	201	return -EINVAL;
202		202
203	if (c->len > size - c->off)	203	if (c->len > size - c->off)

drivers/virtio/virtio_ring.c+1−1

@@ -268,7 +268,7 @@ size_t virtio_max_dma_size(struct virtio_device *vdev) · 267 unmodified lines
268	size_t max_segment_size = SIZE_MAX;	268	size_t max_segment_size = SIZE_MAX;
269		269
270	if (vring_use_dma_api(vdev))	270	if (vring_use_dma_api(vdev))
271	max_segment_size = dma_max_mapping_size(&vdev->dev);	271	max_segment_size = dma_max_mapping_size(vdev->dev.parent);
272		272
273	return max_segment_size;	273	return max_segment_size;
274	}	274	}

fs/afs/file.c+3−2

@@ -514,8 +514,9 @@ static void afs_add_open_mmap(struct afs_vnode *vnode) · 513 unmodified lines
514	if (atomic_inc_return(&vnode->cb_nr_mmap) == 1) {	514	if (atomic_inc_return(&vnode->cb_nr_mmap) == 1) {
515	down_write(&vnode->volume->cell->fs_open_mmaps_lock);	515	down_write(&vnode->volume->cell->fs_open_mmaps_lock);
516		516
517	list_add_tail(&vnode->cb_mmap_link,	517	if (list_empty(&vnode->cb_mmap_link))
518	&vnode->volume->cell->fs_open_mmaps);	518	list_add_tail(&vnode->cb_mmap_link,
		519	&vnode->volume->cell->fs_open_mmaps);
519		520
520	up_write(&vnode->volume->cell->fs_open_mmaps_lock);	521	up_write(&vnode->volume->cell->fs_open_mmaps_lock);
521	}	522	}

fs/afs/super.c+1−0

@@ -667,6 +667,7 @@ static void afs_i_init_once(void *_vnode) · 666 unmodified lines
667	INIT_LIST_HEAD(&vnode->pending_locks);	667	INIT_LIST_HEAD(&vnode->pending_locks);
668	INIT_LIST_HEAD(&vnode->granted_locks);	668	INIT_LIST_HEAD(&vnode->granted_locks);
669	INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);	669	INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);
		670	INIT_LIST_HEAD(&vnode->cb_mmap_link);
670	seqlock_init(&vnode->cb_lock);	671	seqlock_init(&vnode->cb_lock);
671	}	672	}
672		673

fs/aio.c+152−34

@@ -181,8 +181,9 @@ struct poll_iocb { · 180 unmodified lines
181	struct file *file;	181	struct file *file;
182	struct wait_queue_head *head;	182	struct wait_queue_head *head;
183	__poll_t events;	183	__poll_t events;
184	bool done;
185	bool cancelled;	184	bool cancelled;
		185	bool work_scheduled;
		186	bool work_need_resched;
186	struct wait_queue_entry wait;	187	struct wait_queue_entry wait;
187	struct work_struct work;	188	struct work_struct work;
188	};	189	};
@@ -1619,6 +1620,51 @@ static void aio_poll_put_work(struct work_struct *work) · 1430 unmodified lines
1619	iocb_put(iocb);	1620	iocb_put(iocb);
1620	}	1621	}
1621		1622
		1623	/*
		1624	* Safely lock the waitqueue which the request is on, synchronizing with the
		1625	* case where the ->poll() provider decides to free its waitqueue early.
		1626	*
		1627	* Returns true on success, meaning that req->head->lock was locked, req->wait
		1628	* is on req->head, and an RCU read lock was taken. Returns false if the
		1629	* request was already removed from its waitqueue (which might no longer exist).
		1630	*/
		1631	static bool poll_iocb_lock_wq(struct poll_iocb *req)
		1632	{
		1633	wait_queue_head_t *head;
		1634
		1635	/*
		1636	* While we hold the waitqueue lock and the waitqueue is nonempty,
		1637	* wake_up_pollfree() will wait for us. However, taking the waitqueue
		1638	* lock in the first place can race with the waitqueue being freed.
		1639	*
		1640	* We solve this as eventpoll does: by taking advantage of the fact that
		1641	* all users of wake_up_pollfree() will RCU-delay the actual free. If
		1642	* we enter rcu_read_lock() and see that the pointer to the queue is
		1643	* non-NULL, we can then lock it without the memory being freed out from
		1644	* under us, then check whether the request is still on the queue.
		1645	*
		1646	* Keep holding rcu_read_lock() as long as we hold the queue lock, in
		1647	* case the caller deletes the entry from the queue, leaving it empty.
		1648	* In that case, only RCU prevents the queue memory from being freed.
		1649	*/
		1650	rcu_read_lock();
		1651	head = smp_load_acquire(&req->head);
		1652	if (head) {
		1653	spin_lock(&head->lock);
		1654	if (!list_empty(&req->wait.entry))
		1655	return true;
		1656	spin_unlock(&head->lock);
		1657	}
		1658	rcu_read_unlock();
		1659	return false;
		1660	}
		1661
		1662	static void poll_iocb_unlock_wq(struct poll_iocb *req)
		1663	{
		1664	spin_unlock(&req->head->lock);
		1665	rcu_read_unlock();
		1666	}
		1667
1622	static void aio_poll_complete_work(struct work_struct *work)	1668	static void aio_poll_complete_work(struct work_struct *work)
1623	{	1669	{
1624	struct poll_iocb *req = container_of(work, struct poll_iocb, work);	1670	struct poll_iocb *req = container_of(work, struct poll_iocb, work);
@@ -1638,14 +1684,27 @@ static void aio_poll_complete_work(struct work_struct *work) · 13 unmodified lines
1638	* avoid further branches in the fast path.	1684	* avoid further branches in the fast path.
1639	*/	1685	*/
1640	spin_lock_irq(&ctx->ctx_lock);	1686	spin_lock_irq(&ctx->ctx_lock);
1641	if (!mask && !READ_ONCE(req->cancelled)) {	1687	if (poll_iocb_lock_wq(req)) {
1642	add_wait_queue(req->head, &req->wait);	1688	if (!mask && !READ_ONCE(req->cancelled)) {
1643	spin_unlock_irq(&ctx->ctx_lock);	1689	/*
1644	return;	1690	* The request isn't actually ready to be completed yet.
1645	}	1691	* Reschedule completion if another wakeup came in.
		1692	*/
		1693	if (req->work_need_resched) {
		1694	schedule_work(&req->work);
		1695	req->work_need_resched = false;
		1696	} else {
		1697	req->work_scheduled = false;
		1698	}
		1699	poll_iocb_unlock_wq(req);
		1700	spin_unlock_irq(&ctx->ctx_lock);
		1701	return;
		1702	}
		1703	list_del_init(&req->wait.entry);
		1704	poll_iocb_unlock_wq(req);
		1705	} /* else, POLLFREE has freed the waitqueue, so we must complete */
1646	list_del_init(&iocb->ki_list);	1706	list_del_init(&iocb->ki_list);
1647	iocb->ki_res.res = mangle_poll(mask);	1707	iocb->ki_res.res = mangle_poll(mask);
1648	req->done = true;
1649	spin_unlock_irq(&ctx->ctx_lock);	1708	spin_unlock_irq(&ctx->ctx_lock);
1650		1709
1651	iocb_put(iocb);	1710	iocb_put(iocb);
@@ -1657,13 +1716,14 @@ static int aio_poll_cancel(struct kiocb *iocb) · 5 unmodified lines
1657	struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);	1716	struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);
1658	struct poll_iocb *req = &aiocb->poll;	1717	struct poll_iocb *req = &aiocb->poll;
1659		1718
1660	spin_lock(&req->head->lock);	1719	if (poll_iocb_lock_wq(req)) {
1661	WRITE_ONCE(req->cancelled, true);	1720	WRITE_ONCE(req->cancelled, true);
1662	if (!list_empty(&req->wait.entry)) {	1721	if (!req->work_scheduled) {
1663	list_del_init(&req->wait.entry);	1722	schedule_work(&aiocb->poll.work);
1664	schedule_work(&aiocb->poll.work);	1723	req->work_scheduled = true;
1665	}	1724	}
1666	spin_unlock(&req->head->lock);	1725	poll_iocb_unlock_wq(req);
		1726	} /* else, the request was force-cancelled by POLLFREE already */
1667		1727
1668	return 0;	1728	return 0;
1669	}	1729	}
@@ -1680,21 +1740,27 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 10 unmodified lines
1680	if (mask && !(mask & req->events))	1740	if (mask && !(mask & req->events))
1681	return 0;	1741	return 0;
1682		1742
1683	list_del_init(&req->wait.entry);	1743	/*
1684		1744	* Complete the request inline if possible. This requires that three
1685	if (mask && spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {	1745	* conditions be met:
		1746	* 1. An event mask must have been passed. If a plain wakeup was done
		1747	* instead, then mask == 0 and we have to call vfs_poll() to get
		1748	* the events, so inline completion isn't possible.
		1749	* 2. The completion work must not have already been scheduled.
		1750	* 3. ctx_lock must not be busy. We have to use trylock because we
		1751	* already hold the waitqueue lock, so this inverts the normal
		1752	* locking order. Use irqsave/irqrestore because not all
		1753	* filesystems (e.g. fuse) call this function with IRQs disabled,
		1754	* yet IRQs have to be disabled before ctx_lock is obtained.
		1755	*/
		1756	if (mask && !req->work_scheduled &&
		1757	spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {
1686	struct kioctx *ctx = iocb->ki_ctx;	1758	struct kioctx *ctx = iocb->ki_ctx;
1687		1759
1688	/*	1760	list_del_init(&req->wait.entry);
1689	* Try to complete the iocb inline if we can. Use
1690	* irqsave/irqrestore because not all filesystems (e.g. fuse)
1691	* call this function with IRQs disabled and because IRQs
1692	* have to be disabled before ctx_lock is obtained.
1693	*/
1694	list_del(&iocb->ki_list);	1761	list_del(&iocb->ki_list);
1695	iocb->ki_res.res = mangle_poll(mask);	1762	iocb->ki_res.res = mangle_poll(mask);
1696	req->done = true;	1763	if (iocb->ki_eventfd && !eventfd_signal_allowed()) {
1697	if (iocb->ki_eventfd && eventfd_signal_allowed()) {
1698	iocb = NULL;	1764	iocb = NULL;
1699	INIT_WORK(&req->work, aio_poll_put_work);	1765	INIT_WORK(&req->work, aio_poll_put_work);
1700	schedule_work(&req->work);	1766	schedule_work(&req->work);
@@ -1703,7 +1769,43 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 2 unmodified lines
1703	if (iocb)	1769	if (iocb)
1704	iocb_put(iocb);	1770	iocb_put(iocb);
1705	} else {	1771	} else {
1706	schedule_work(&req->work);	1772	/*
		1773	* Schedule the completion work if needed. If it was already
		1774	* scheduled, record that another wakeup came in.
		1775	*
		1776	* Don't remove the request from the waitqueue here, as it might
		1777	* not actually be complete yet (we won't know until vfs_poll()
		1778	* is called), and we must not miss any wakeups. POLLFREE is an
		1779	* exception to this; see below.
		1780	*/
		1781	if (req->work_scheduled) {
		1782	req->work_need_resched = true;
		1783	} else {
		1784	schedule_work(&req->work);
		1785	req->work_scheduled = true;
		1786	}
		1787
		1788	/*
		1789	* If the waitqueue is being freed early but we can't complete
		1790	* the request inline, we have to tear down the request as best
		1791	* we can. That means immediately removing the request from its
		1792	* waitqueue and preventing all further accesses to the
		1793	* waitqueue via the request. We also need to schedule the
		1794	* completion work (done above). Also mark the request as
		1795	* cancelled, to potentially skip an unneeded call to ->poll().
		1796	*/
		1797	if (mask & POLLFREE) {
		1798	WRITE_ONCE(req->cancelled, true);
		1799	list_del_init(&req->wait.entry);
		1800
		1801	/*
		1802	* Careful: this must be the last step, since as soon
		1803	* as req->head is NULL'ed out, the request can be
		1804	* completed and freed, since aio_poll_complete_work()
		1805	* will no longer need to take the waitqueue lock.
		1806	*/
		1807	smp_store_release(&req->head, NULL);
		1808	}
1707	}	1809	}
1708	return 1;	1810	return 1;
1709	}	1811	}
@@ -1711,6 +1813,7 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 1 unmodified line
1711	struct aio_poll_table {	1813	struct aio_poll_table {
1712	struct poll_table_struct pt;	1814	struct poll_table_struct pt;
1713	struct aio_kiocb *iocb;	1815	struct aio_kiocb *iocb;
		1816	bool queued;
1714	int error;	1817	int error;
1715	};	1818	};
1716		1819
@@ -1721,11 +1824,12 @@ aio_poll_queue_proc(struct file file, struct wait_queue_head head, · 4 unmodified lines
1721	struct aio_poll_table *pt = container_of(p, struct aio_poll_table, pt);	1824	struct aio_poll_table *pt = container_of(p, struct aio_poll_table, pt);
1722		1825
1723	/* multiple wait queues per file are not supported */	1826	/* multiple wait queues per file are not supported */
1724	if (unlikely(pt->iocb->poll.head)) {	1827	if (unlikely(pt->queued)) {
1725	pt->error = -EINVAL;	1828	pt->error = -EINVAL;
1726	return;	1829	return;
1727	}	1830	}
1728		1831
		1832	pt->queued = true;
1729	pt->error = 0;	1833	pt->error = 0;
1730	pt->iocb->poll.head = head;	1834	pt->iocb->poll.head = head;
1731	add_wait_queue(head, &pt->iocb->poll.wait);	1835	add_wait_queue(head, &pt->iocb->poll.wait);
@@ -1750,12 +1854,14 @@ static int aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 18 unmodified lines
1750	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;	1854	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;
1751		1855
1752	req->head = NULL;	1856	req->head = NULL;
1753	req->done = false;
1754	req->cancelled = false;	1857	req->cancelled = false;
		1858	req->work_scheduled = false;
		1859	req->work_need_resched = false;
1755		1860
1756	apt.pt._qproc = aio_poll_queue_proc;	1861	apt.pt._qproc = aio_poll_queue_proc;
1757	apt.pt._key = req->events;	1862	apt.pt._key = req->events;
1758	apt.iocb = aiocb;	1863	apt.iocb = aiocb;
		1864	apt.queued = false;
1759	apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */	1865	apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */
1760		1866
1761	/* initialized the list so that we can do list_empty checks */	1867	/* initialized the list so that we can do list_empty checks */
@@ -1764,23 +1870,35 @@ static int aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 2 unmodified lines
1764		1870
1765	mask = vfs_poll(req->file, &apt.pt) & req->events;	1871	mask = vfs_poll(req->file, &apt.pt) & req->events;
1766	spin_lock_irq(&ctx->ctx_lock);	1872	spin_lock_irq(&ctx->ctx_lock);
1767	if (likely(req->head)) {	1873	if (likely(apt.queued)) {
1768	spin_lock(&req->head->lock);	1874	bool on_queue = poll_iocb_lock_wq(req);
1769	if (unlikely(list_empty(&req->wait.entry))) {	1875
1770	if (apt.error)	1876	if (!on_queue \|\| req->work_scheduled) {
		1877	/*
		1878	* aio_poll_wake() already either scheduled the async
		1879	* completion work, or completed the request inline.
		1880	*/
		1881	if (apt.error) /* unsupported case: multiple queues */
1771	cancel = true;	1882	cancel = true;
1772	apt.error = 0;	1883	apt.error = 0;
1773	mask = 0;	1884	mask = 0;
1774	}	1885	}
1775	if (mask \|\| apt.error) {	1886	if (mask \|\| apt.error) {
		1887	/* Steal to complete synchronously. */
1776	list_del_init(&req->wait.entry);	1888	list_del_init(&req->wait.entry);
1777	} else if (cancel) {	1889	} else if (cancel) {
		1890	/* Cancel if possible (may be too late though). */
1778	WRITE_ONCE(req->cancelled, true);	1891	WRITE_ONCE(req->cancelled, true);
1779	} else if (!req->done) { /* actually waiting for an event */	1892	} else if (on_queue) {
		1893	/*
		1894	* Actually waiting for an event, so add the request to
		1895	* active_reqs so that it can be cancelled if needed.
		1896	*/
1780	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);	1897	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
1781	aiocb->ki_cancel = aio_poll_cancel;	1898	aiocb->ki_cancel = aio_poll_cancel;
1782	}	1899	}
1783	spin_unlock(&req->head->lock);	1900	if (on_queue)
		1901	poll_iocb_unlock_wq(req);
1784	}	1902	}
1785	if (mask) { /* no async, we'd stolen it */	1903	if (mask) { /* no async, we'd stolen it */
1786	aiocb->ki_res.res = mangle_poll(mask);	1904	aiocb->ki_res.res = mangle_poll(mask);

fs/btrfs/delalloc-space.c+9−3

 	/* Use new btrfs_qgroup_reserve_data to reserve precious data space. */
 	ret = btrfs_qgroup_reserve_data(inode, reserved, start, len);
-	if (ret < 0)
+	if (ret < 0) {
 		btrfs_free_reserved_data_space_noquota(fs_info, len);
-	else
+		extent_changeset_free(*reserved);
+		*reserved = NULL;
+	} else {
 		ret = 0;
+	}
 	return ret;
 }
 	if (ret < 0)
 		return ret;
 	ret = btrfs_delalloc_reserve_metadata(inode, len);
-	if (ret < 0)
+	if (ret < 0) {
 		btrfs_free_reserved_data_space(inode, *reserved, start, len);
+		extent_changeset_free(*reserved);
+		*reserved = NULL;
+	}
 	return ret;
 }

fs/btrfs/extent-tree.c+3−0

@@ -6051,6 +6051,9 @@ int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range) · 6050 unmodified lines
6051	int dev_ret = 0;	6051	int dev_ret = 0;
6052	int ret = 0;	6052	int ret = 0;
6053		6053
		6054	if (range->start == U64_MAX)
		6055	return -EINVAL;
		6056
6054	/*	6057	/*
6055	* Check range overflow if range->len is set.	6058	* Check range overflow if range->len is set.
6056	* The default range->len is U64_MAX.	6059	* The default range->len is U64_MAX.

fs/btrfs/extent_io.c+14−0

@@ -4313,6 +4313,20 @@ static void set_btree_ioerr(struct page page, struct extent_buffer eb) · 4312 unmodified lines
4313	if (test_and_set_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags))	4313	if (test_and_set_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags))
4314	return;	4314	return;
4315		4315
		4316	/*
		4317	* A read may stumble upon this buffer later, make sure that it gets an
		4318	* error and knows there was an error.
		4319	*/
		4320	clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
		4321
		4322	/*
		4323	* We need to set the mapping with the io error as well because a write
		4324	* error will flip the file system readonly, and then syncfs() will
		4325	* return a 0 because we are readonly if we don't modify the err seq for
		4326	* the superblock.
		4327	*/
		4328	mapping_set_error(page->mapping, -EIO);
		4329
4316	/*	4330	/*
4317	* If we error out, we should add back the dirty_metadata_bytes	4331	* If we error out, we should add back the dirty_metadata_bytes
4318	* to make it consistent.	4332	* to make it consistent.

fs/btrfs/ioctl.c+2−4

 		return -EPERM;
 	vol_args = memdup_user(arg, sizeof(*vol_args));
-	if (IS_ERR(vol_args)) {
+	if (IS_ERR(vol_args))
-		ret = PTR_ERR(vol_args);
+		return PTR_ERR(vol_args);
-		goto out;
-	}
 	if (vol_args->flags & ~BTRFS_DEVICE_REMOVE_ARGS_MASK) {
 		ret = -EOPNOTSUPP;

fs/btrfs/root-tree.c+2−1

 	key.offset = ref_id;
 again:
 	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
-	BUG_ON(ret < 0);
+	if (ret < 0)
+		goto out;
 	if (ret == 0) {
 		leaf = path->nodes[0];
 		ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/tree-log.c+3−2

 						     path->nodes[*level]->len);
 					if (ret)
 						return ret;
+					btrfs_redirty_list_add(trans->transaction,
+							       next);
 				} else {
 					if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
 						clear_extent_buffer_dirty(next);
 						next->start, next->len);
 				if (ret)
 					goto out;
+				btrfs_redirty_list_add(trans->transaction, next);
 			} else {
 				if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
 					clear_extent_buffer_dirty(next);
 			  EXTENT_DIRTY | EXTENT_NEW | EXTENT_NEED_WAIT);
 	extent_io_tree_release(&log->log_csum_range);
-	if (trans && log->node)
-		btrfs_redirty_list_add(trans->transaction, log->node);
 	btrfs_put_root(log);
 }

fs/btrfs/zoned.c+2−0

 	block_group->alloc_offset = block_group->zone_capacity;
 	block_group->free_space_ctl->free_space = 0;
 	btrfs_clear_treelog_bg(block_group);
+	btrfs_clear_data_reloc_bg(block_group);
 	spin_unlock(&block_group->lock);
 	ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_FINISH,
 	ASSERT(block_group->alloc_offset == block_group->zone_capacity);
 	ASSERT(block_group->free_space_ctl->free_space == 0);
 	btrfs_clear_treelog_bg(block_group);
+	btrfs_clear_data_reloc_bg(block_group);
 	spin_unlock(&block_group->lock);
 	map = block_group->physical_map;

fs/ceph/caps.c+8−8

 {
 	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
 	int bits = (fmode << 1) | 1;
-	bool is_opened = false;
+	bool already_opened = false;
 	int i;
 	if (count == 1)
 	spin_lock(&ci->i_ceph_lock);
 	for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
-		if (bits & (1 << i))
-			ci->i_nr_by_mode[i] += count;
 		/*
-		 * If any of the mode ref is larger than 1,
+		 * If any of the mode ref is larger than 0,
 		 * that means it has been already opened by
 		 * others. Just skip checking the PIN ref.
 		 */
-		if (i && ci->i_nr_by_mode[i] > 1)
+		if (i && ci->i_nr_by_mode[i])
-			is_opened = true;
+			already_opened = true;
+		if (bits & (1 << i))
+			ci->i_nr_by_mode[i] += count;
 	}
-	if (!is_opened)
+	if (!already_opened)
 		percpu_counter_inc(&mdsc->metric.opened_inodes);
 	spin_unlock(&ci->i_ceph_lock);
 }

fs/ceph/file.c+16−4

 	in.cap.realm = cpu_to_le64(ci->i_snap_realm->ino);
 	in.cap.flags = CEPH_CAP_FLAG_AUTH;
 	in.ctime = in.mtime = in.atime = iinfo.btime;
-	in.mode = cpu_to_le32((u32)mode);
 	in.truncate_seq = cpu_to_le32(1);
 	in.truncate_size = cpu_to_le64(-1ULL);
 	in.xattr_version = cpu_to_le64(1);
 	in.uid = cpu_to_le32(from_kuid(&init_user_ns, current_fsuid()));
-	in.gid = cpu_to_le32(from_kgid(&init_user_ns, dir->i_mode & S_ISGID ?
+	if (dir->i_mode & S_ISGID) {
-				dir->i_gid : current_fsgid()));
+		in.gid = cpu_to_le32(from_kgid(&init_user_ns, dir->i_gid));
+		/* Directories always inherit the setgid bit. */
+		if (S_ISDIR(mode))
+			mode |= S_ISGID;
+		else if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP) &&
+			 !in_group_p(dir->i_gid) &&
+			 !capable_wrt_inode_uidgid(&init_user_ns, dir, CAP_FSETID))
+			mode &= ~S_ISGID;
+	} else {
+		in.gid = cpu_to_le32(from_kgid(&init_user_ns, current_fsgid()));
+	}
+	in.mode = cpu_to_le32((u32)mode);
 	in.nlink = cpu_to_le32(1);
 	in.max_size = cpu_to_le64(lo->stripe_unit);
 	ssize_t ret;
 	u64 off = iocb->ki_pos;
 	u64 len = iov_iter_count(to);
-	u64 i_size;
+	u64 i_size = i_size_read(inode);
 	dout("sync_read on file %p %llu~%u %s\n", file, off, (unsigned)len,
 	     (file->f_flags & O_DIRECT) ? "O_DIRECT" : "");

fs/ceph/mds_client.c+1−2

 	struct ceph_pagelist *pagelist = recon_state->pagelist;
 	struct dentry *dentry;
 	char *path;
-	int pathlen, err;
+	int pathlen = 0, err;
 	u64 pathbase;
 	u64 snap_follows;
 		}
 	} else {
 		path = NULL;
-		pathlen = 0;
 		pathbase = 0;
 	}

fs/cifs/sess.c+36−18

@@ -590,8 +590,8 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, · 589 unmodified lines
590	{	590	{
591	unsigned int tioffset; /* challenge message target info area */	591	unsigned int tioffset; /* challenge message target info area */
592	unsigned int tilen; /* challenge message target info area length */	592	unsigned int tilen; /* challenge message target info area length */
593
594	CHALLENGE_MESSAGE pblob = (CHALLENGE_MESSAGE )bcc_ptr;	593	CHALLENGE_MESSAGE pblob = (CHALLENGE_MESSAGE )bcc_ptr;
		594	__u32 server_flags;
595		595
596	if (blob_len < sizeof(CHALLENGE_MESSAGE)) {	596	if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
597	cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);	597	cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
@@ -609,12 +609,37 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, · 11 unmodified lines
609	return -EINVAL;	609	return -EINVAL;
610	}	610	}
611		611
		612	server_flags = le32_to_cpu(pblob->NegotiateFlags);
		613	cifs_dbg(FYI, "%s: negotiate=0x%08x challenge=0x%08x\n", __func__,
		614	ses->ntlmssp->client_flags, server_flags);
		615
		616	if ((ses->ntlmssp->client_flags & (NTLMSSP_NEGOTIATE_SEAL \| NTLMSSP_NEGOTIATE_SIGN)) &&
		617	(!(server_flags & NTLMSSP_NEGOTIATE_56) && !(server_flags & NTLMSSP_NEGOTIATE_128))) {
		618	cifs_dbg(VFS, "%s: requested signing/encryption but server did not return either 56-bit or 128-bit session key size\n",
		619	__func__);
		620	return -EINVAL;
		621	}
		622	if (!(server_flags & NTLMSSP_NEGOTIATE_NTLM) && !(server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) {
		623	cifs_dbg(VFS, "%s: server does not seem to support either NTLMv1 or NTLMv2\n", __func__);
		624	return -EINVAL;
		625	}
		626	if (ses->server->sign && !(server_flags & NTLMSSP_NEGOTIATE_SIGN)) {
		627	cifs_dbg(VFS, "%s: forced packet signing but server does not seem to support it\n",
		628	__func__);
		629	return -EOPNOTSUPP;
		630	}
		631	if ((ses->ntlmssp->client_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
		632	!(server_flags & NTLMSSP_NEGOTIATE_KEY_XCH))
		633	pr_warn_once("%s: authentication has been weakened as server does not support key exchange\n",
		634	__func__);
		635
		636	ses->ntlmssp->server_flags = server_flags;
		637
612	memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);	638	memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
613	/* BB we could decode pblob->NegotiateFlags; some may be useful */
614	/* In particular we can examine sign flags */	639	/* In particular we can examine sign flags */
615	/* BB spec says that if AvId field of MsvAvTimestamp is populated then	640	/* BB spec says that if AvId field of MsvAvTimestamp is populated then
616	we must set the MIC field of the AUTHENTICATE_MESSAGE */	641	we must set the MIC field of the AUTHENTICATE_MESSAGE */
617	ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);	642
618	tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);	643	tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
619	tilen = le16_to_cpu(pblob->TargetInfoArray.Length);	644	tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
620	if (tioffset > blob_len \|\| tioffset + tilen > blob_len) {	645	if (tioffset > blob_len \|\| tioffset + tilen > blob_len) {
@@ -721,13 +746,13 @@ int build_ntlmssp_negotiate_blob(unsigned char **pbuffer, · 100 unmodified lines
721	flags = NTLMSSP_NEGOTIATE_56 \| NTLMSSP_REQUEST_TARGET \|	746	flags = NTLMSSP_NEGOTIATE_56 \| NTLMSSP_REQUEST_TARGET \|
722	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|	747	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|
723	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|	748	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|
724	NTLMSSP_NEGOTIATE_SEAL;	749	NTLMSSP_NEGOTIATE_ALWAYS_SIGN \| NTLMSSP_NEGOTIATE_SEAL \|
725	if (server->sign)	750	NTLMSSP_NEGOTIATE_SIGN;
726	flags \|= NTLMSSP_NEGOTIATE_SIGN;
727	if (!server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)	751	if (!server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)
728	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;	752	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;
729		753
730	tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);	754	tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);
		755	ses->ntlmssp->client_flags = flags;
731	sec_blob->NegotiateFlags = cpu_to_le32(flags);	756	sec_blob->NegotiateFlags = cpu_to_le32(flags);
732		757
733	/* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */	758	/* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */
@@ -779,15 +804,8 @@ int build_ntlmssp_auth_blob(unsigned char **pbuffer, · 45 unmodified lines
779	memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);	804	memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
780	sec_blob->MessageType = NtLmAuthenticate;	805	sec_blob->MessageType = NtLmAuthenticate;
781		806
782	flags = NTLMSSP_NEGOTIATE_56 \|	807	flags = ses->ntlmssp->server_flags \| NTLMSSP_REQUEST_TARGET \|
783	NTLMSSP_REQUEST_TARGET \| NTLMSSP_NEGOTIATE_TARGET_INFO \|	808	NTLMSSP_NEGOTIATE_TARGET_INFO \| NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
784	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|
785	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|
786	NTLMSSP_NEGOTIATE_SEAL \| NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
787	if (ses->server->sign)
788	flags \|= NTLMSSP_NEGOTIATE_SIGN;
789	if (!ses->server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)
790	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;
791		809
792	tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);	810	tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);
793	sec_blob->NegotiateFlags = cpu_to_le32(flags);	811	sec_blob->NegotiateFlags = cpu_to_le32(flags);
@@ -834,9 +852,9 @@ int build_ntlmssp_auth_blob(unsigned char **pbuffer, · 40 unmodified lines
834	*pbuffer, &tmp,	852	*pbuffer, &tmp,
835	nls_cp);	853	nls_cp);
836		854
837	if (((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) \|\|	855	if ((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
838	(ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))	856	(!ses->server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess) &&
839	&& !calc_seckey(ses)) {	857	!calc_seckey(ses)) {
840	memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);	858	memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
841	sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);	859	sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
842	sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);	860	sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);

fs/file.c+56−16

@@ -841,28 +841,68 @@ void do_close_on_exec(struct files_struct *files) · 840 unmodified lines
841	spin_unlock(&files->file_lock);	841	spin_unlock(&files->file_lock);
842	}	842	}
843		843
844	static struct file __fget_files(struct files_struct files, unsigned int fd,	844	static inline struct file __fget_files_rcu(struct files_struct files,
845	fmode_t mask, unsigned int refs)	845	unsigned int fd, fmode_t mask, unsigned int refs)
846	{	846	{
847	struct file *file;	847	for (;;) {
		848	struct file *file;
		849	struct fdtable *fdt = rcu_dereference_raw(files->fdt);
		850	struct file __rcu **fdentry;
848		851
849	rcu_read_lock();	852	if (unlikely(fd >= fdt->max_fds))
850	loop:	853	return NULL;
851	file = files_lookup_fd_rcu(files, fd);	854
852	if (file) {	855	fdentry = fdt->fd + array_index_nospec(fd, fdt->max_fds);
853	/* File object ref couldn't be taken.	856	file = rcu_dereference_raw(*fdentry);
854	* dup2() atomicity guarantee is the reason	857	if (unlikely(!file))
855	* we loop to catch the new file (or NULL pointer)	858	return NULL;
		859
		860	if (unlikely(file->f_mode & mask))
		861	return NULL;
		862
		863	/*
		864	* Ok, we have a file pointer. However, because we do
		865	* this all locklessly under RCU, we may be racing with
		866	* that file being closed.
		867	*
		868	* Such a race can take two forms:
		869	*
		870	* (a) the file ref already went down to zero,
		871	* and get_file_rcu_many() fails. Just try
		872	* again:
856	*/	873	*/
857	if (file->f_mode & mask)	874	if (unlikely(!get_file_rcu_many(file, refs)))
858	file = NULL;	875	continue;
859	else if (!get_file_rcu_many(file, refs))	876
860	goto loop;	877	/*
861	else if (files_lookup_fd_raw(files, fd) != file) {	878	* (b) the file table entry has changed under us.
		879	* Note that we don't need to re-check the 'fdt->fd'
		880	* pointer having changed, because it always goes
		881	* hand-in-hand with 'fdt'.
		882	*
		883	* If so, we need to put our refs and try again.
		884	*/
		885	if (unlikely(rcu_dereference_raw(files->fdt) != fdt) \|\|
		886	unlikely(rcu_dereference_raw(*fdentry) != file)) {
862	fput_many(file, refs);	887	fput_many(file, refs);
863	goto loop;	888	continue;
864	}	889	}
		890
		891	/*
		892	* Ok, we have a ref to the file, and checked that it
		893	* still exists.
		894	*/
		895	return file;
865	}	896	}
		897	}
		898
		899	static struct file __fget_files(struct files_struct files, unsigned int fd,
		900	fmode_t mask, unsigned int refs)
		901	{
		902	struct file *file;
		903
		904	rcu_read_lock();
		905	file = __fget_files_rcu(files, fd, mask, refs);
866	rcu_read_unlock();	906	rcu_read_unlock();
867		907
868	return file;	908	return file;

fs/io-wq.c+23−6

 					struct io_wqe_acct *acct,
 					struct io_cb_cancel_data *match);
 static void create_worker_cb(struct callback_head *cb);
+static void io_wq_cancel_tw_create(struct io_wq *wq);
 static bool io_worker_get(struct io_worker *worker)
 {
 	    test_and_set_bit_lock(0, &worker->create_state))
 		goto fail_release;
+	atomic_inc(&wq->worker_refs);
 	init_task_work(&worker->create_work, func);
 	worker->create_index = acct->index;
 	if (!task_work_add(wq->task, &worker->create_work, TWA_SIGNAL)) {
-		clear_bit_unlock(0, &worker->create_state);
+		/*
+		 * EXIT may have been set after checking it above, check after
+		 * adding the task_work and remove any creation item if it is
+		 * now set. wq exit does that too, but we can have added this
+		 * work item after we canceled in io_wq_exit_workers().
+		 */
+		if (test_bit(IO_WQ_BIT_EXIT, &wq->state))
+			io_wq_cancel_tw_create(wq);
+		io_worker_ref_put(wq);
 		return true;
 	}
+	io_worker_ref_put(wq);
 	clear_bit_unlock(0, &worker->create_state);
 fail_release:
 	io_worker_release(worker);
 	set_bit(IO_WQ_BIT_EXIT, &wq->state);
 }
-static void io_wq_exit_workers(struct io_wq *wq)
+static void io_wq_cancel_tw_create(struct io_wq *wq)
 {
 	struct callback_head *cb;
-	int node;
-	if (!wq->task)
-		return;
 	while ((cb = task_work_cancel_match(wq->task, io_task_work_match, wq)) != NULL) {
 		struct io_worker *worker;
 		worker = container_of(cb, struct io_worker, create_work);
 		io_worker_cancel_cb(worker);
 	}
+}
+static void io_wq_exit_workers(struct io_wq *wq)
+{
+	int node;
+	if (!wq->task)
+		return;
+	io_wq_cancel_tw_create(wq);
 	rcu_read_lock();
 	for_each_node(node) {

fs/io_uring.c+4−2

 /*
  * Find any io_uring ctx that this task has registered or done IO on, and cancel
- * requests. @sqd should be not-null IIF it's an SQPOLL thread cancellation.
+ * requests. @sqd should be not-null IFF it's an SQPOLL thread cancellation.
  */
 static __cold void io_uring_cancel_generic(bool cancel_all,
 					   struct io_sq_data *sqd)
 							     cancel_all);
 		}
-		prepare_to_wait(&tctx->wait, &wait, TASK_UNINTERRUPTIBLE);
+		prepare_to_wait(&tctx->wait, &wait, TASK_INTERRUPTIBLE);
+		io_run_task_work();
 		io_uring_drop_tctx_refs(current);
 		/*
 		 * If we've seen completions, retry without waiting. This
 		 * avoids a race where a completion comes in before we did

fs/nfsd/nfs4recover.c+1−0

@@ -2156,6 +2156,7 @@ static struct notifier_block nfsd4_cld_block = { · 2155 unmodified lines
2156	int	2156	int
2157	register_cld_notifier(void)	2157	register_cld_notifier(void)
2158	{	2158	{
		2159	WARN_ON(!nfsd_net_id);
2159	return rpc_pipefs_notifier_register(&nfsd4_cld_block);	2160	return rpc_pipefs_notifier_register(&nfsd4_cld_block);
2160	}	2161	}
2161		2162

fs/nfsd/nfs4state.c+7−2

 	return 0;
 }
+static bool delegation_hashed(struct nfs4_delegation *dp)
+{
+	return !(list_empty(&dp->dl_perfile));
+}
 static bool
 unhash_delegation_locked(struct nfs4_delegation *dp)
 {
 	lockdep_assert_held(&state_lock);
-	if (list_empty(&dp->dl_perfile))
+	if (!delegation_hashed(dp))
 		return false;
 	dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
 	 * queued for a lease break. Don't queue it again.
 	 */
 	spin_lock(&state_lock);
-	if (dp->dl_time == 0) {
+	if (delegation_hashed(dp) && dp->dl_time == 0) {
 		dp->dl_time = ktime_get_boottime_seconds();
 		list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
 	}

fs/nfsd/nfsctl.c+7−7

 	int retval;
 	printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
-	retval = register_cld_notifier();
-	if (retval)
-		return retval;
 	retval = nfsd4_init_slabs();
 	if (retval)
-		goto out_unregister_notifier;
+		return retval;
 	retval = nfsd4_init_pnfs();
 	if (retval)
 		goto out_free_slabs;
 		goto out_free_exports;
 	retval = register_pernet_subsys(&nfsd_net_ops);
 	if (retval < 0)
+		goto out_free_filesystem;
+	retval = register_cld_notifier();
+	if (retval)
 		goto out_free_all;
 	return 0;
 out_free_all:
+	unregister_pernet_subsys(&nfsd_net_ops);
+out_free_filesystem:
 	unregister_filesystem(&nfsd_fs_type);
 out_free_exports:
 	remove_proc_entry("fs/nfs/exports", NULL);
 	nfsd4_exit_pnfs();
 out_free_slabs:
 	nfsd4_free_slabs();
-out_unregister_notifier:
-	unregister_cld_notifier();
 	return retval;
 }
 static void __exit exit_nfsd(void)
 {
+	unregister_cld_notifier();
 	unregister_pernet_subsys(&nfsd_net_ops);
 	nfsd_drc_slab_free();
 	remove_proc_entry("fs/nfs/exports", NULL);
 	nfsd4_free_slabs();
 	nfsd4_exit_pnfs();
 	unregister_filesystem(&nfsd_fs_type);
-	unregister_cld_notifier();
 }
 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");

fs/signalfd.c+1−11

@@ -35,17 +35,7 @@ · 34 unmodified lines
35		35
36	void signalfd_cleanup(struct sighand_struct *sighand)	36	void signalfd_cleanup(struct sighand_struct *sighand)
37	{	37	{
38	wait_queue_head_t *wqh = &sighand->signalfd_wqh;	38	wake_up_pollfree(&sighand->signalfd_wqh);
39	/*
40	* The lockless check can race with remove_wait_queue() in progress,
41	* but in this case its caller should run under rcu_read_lock() and
42	* sighand_cachep is SLAB_TYPESAFE_BY_RCU, we can safely return.
43	*/
44	if (likely(!waitqueue_active(wqh)))
45	return;
46
47	/* wait_queue_entry_t->func(POLLFREE) should do remove_wait_queue() */
48	wake_up_poll(wqh, EPOLLHUP \| POLLFREE);
49	}	39	}
50		40
51	struct signalfd_ctx {	41	struct signalfd_ctx {

fs/smbfs_common/cifs_arc4.c+0−13

@@ -72,16 +72,3 @@ void cifs_arc4_crypt(struct arc4_ctx ctx, u8 out, const u8 *in, unsigned int l · 71 unmodified lines
72	ctx->y = y;	72	ctx->y = y;
73	}	73	}
74	EXPORT_SYMBOL_GPL(cifs_arc4_crypt);	74	EXPORT_SYMBOL_GPL(cifs_arc4_crypt);
75
76	static int __init
77	init_smbfs_common(void)
78	{
79	return 0;
80	}
81	static void __init
82	exit_smbfs_common(void)
83	{
84	}
85
86	module_init(init_smbfs_common)
87	module_exit(exit_smbfs_common)

fs/tracefs/inode.c+76−0

@@ -161,6 +161,77 @@ struct tracefs_fs_info { · 160 unmodified lines
161	struct tracefs_mount_opts mount_opts;	161	struct tracefs_mount_opts mount_opts;
162	};	162	};
163		163
		164	static void change_gid(struct dentry *dentry, kgid_t gid)
		165	{
		166	if (!dentry->d_inode)
		167	return;
		168	dentry->d_inode->i_gid = gid;
		169	}
		170
		171	/*
		172	* Taken from d_walk, but without he need for handling renames.
		173	* Nothing can be renamed while walking the list, as tracefs
		174	* does not support renames. This is only called when mounting
		175	* or remounting the file system, to set all the files to
		176	* the given gid.
		177	*/
		178	static void set_gid(struct dentry *parent, kgid_t gid)
		179	{
		180	struct dentry *this_parent;
		181	struct list_head *next;
		182
		183	this_parent = parent;
		184	spin_lock(&this_parent->d_lock);
		185
		186	change_gid(this_parent, gid);
		187	repeat:
		188	next = this_parent->d_subdirs.next;
		189	resume:
		190	while (next != &this_parent->d_subdirs) {
		191	struct list_head *tmp = next;
		192	struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
		193	next = tmp->next;
		194
		195	spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		196
		197	change_gid(dentry, gid);
		198
		199	if (!list_empty(&dentry->d_subdirs)) {
		200	spin_unlock(&this_parent->d_lock);
		201	spin_release(&dentry->d_lock.dep_map, _RET_IP_);
		202	this_parent = dentry;
		203	spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
		204	goto repeat;
		205	}
		206	spin_unlock(&dentry->d_lock);
		207	}
		208	/*
		209	* All done at this level ... ascend and resume the search.
		210	*/
		211	rcu_read_lock();
		212	ascend:
		213	if (this_parent != parent) {
		214	struct dentry *child = this_parent;
		215	this_parent = child->d_parent;
		216
		217	spin_unlock(&child->d_lock);
		218	spin_lock(&this_parent->d_lock);
		219
		220	/* go into the first sibling still alive */
		221	do {
		222	next = child->d_child.next;
		223	if (next == &this_parent->d_subdirs)
		224	goto ascend;
		225	child = list_entry(next, struct dentry, d_child);
		226	} while (unlikely(child->d_flags & DCACHE_DENTRY_KILLED));
		227	rcu_read_unlock();
		228	goto resume;
		229	}
		230	rcu_read_unlock();
		231	spin_unlock(&this_parent->d_lock);
		232	return;
		233	}
		234
164	static int tracefs_parse_options(char data, struct tracefs_mount_opts opts)	235	static int tracefs_parse_options(char data, struct tracefs_mount_opts opts)
165	{	236	{
166	substring_t args[MAX_OPT_ARGS];	237	substring_t args[MAX_OPT_ARGS];
@@ -193,6 +264,7 @@ static int tracefs_parse_options(char data, struct tracefs_mount_opts opts) · 26 unmodified lines
193	if (!gid_valid(gid))	264	if (!gid_valid(gid))
194	return -EINVAL;	265	return -EINVAL;
195	opts->gid = gid;	266	opts->gid = gid;
		267	set_gid(tracefs_mount->mnt_root, gid);
196	break;	268	break;
197	case Opt_mode:	269	case Opt_mode:
198	if (match_octal(&args[0], &option))	270	if (match_octal(&args[0], &option))
@@ -414,6 +486,8 @@ struct dentry tracefs_create_file(const char name, umode_t mode, · 215 unmodified lines
414	inode->i_mode = mode;	486	inode->i_mode = mode;
415	inode->i_fop = fops ? fops : &tracefs_file_operations;	487	inode->i_fop = fops ? fops : &tracefs_file_operations;
416	inode->i_private = data;	488	inode->i_private = data;
		489	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
		490	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
417	d_instantiate(dentry, inode);	491	d_instantiate(dentry, inode);
418	fsnotify_create(dentry->d_parent->d_inode, dentry);	492	fsnotify_create(dentry->d_parent->d_inode, dentry);
419	return end_creating(dentry);	493	return end_creating(dentry);
@@ -436,6 +510,8 @@ static struct dentry __create_dir(const char name, struct dentry *parent, · 16 unmodified lines
436	inode->i_mode = S_IFDIR \| S_IRWXU \| S_IRUSR\| S_IRGRP \| S_IXUSR \| S_IXGRP;	510	inode->i_mode = S_IFDIR \| S_IRWXU \| S_IRUSR\| S_IRGRP \| S_IXUSR \| S_IXGRP;
437	inode->i_op = ops;	511	inode->i_op = ops;
438	inode->i_fop = &simple_dir_operations;	512	inode->i_fop = &simple_dir_operations;
		513	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
		514	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
439		515
440	/* directory inodes start off with i_nlink == 2 (for "." entry) */	516	/* directory inodes start off with i_nlink == 2 (for "." entry) */
441	inc_nlink(inode);	517	inc_nlink(inode);

fs/xfs/xfs_super.c+11−3

 xfs_remount_ro(
 	struct xfs_mount	*mp)
 {
-	int error;
+	struct xfs_icwalk	icw = {
+		.icw_flags	= XFS_ICWALK_FLAG_SYNC,
+	};
+	int			error;
 	/*
 	 * Cancel background eofb scanning so it cannot race with the final
 	 */
 	xfs_blockgc_stop(mp);
-	/* Get rid of any leftover CoW reservations... */
+	/*
-	error = xfs_blockgc_free_space(mp, NULL);
+	 * Clear out all remaining COW staging extents and speculative post-EOF
+	 * preallocations so that we don't leave inodes requiring inactivation
+	 * cleanups during reclaim on a read-only mount.  We must process every
+	 * cached inode, so this requires a synchronous cache scan.
+	 */
+	error = xfs_blockgc_free_space(mp, &icw);
 	if (error) {
 		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 		return error;

include/linux/delay.h+13−1

  */
 #include <linux/math.h>
+#include <linux/sched.h>
 extern unsigned long loops_per_jiffy;
 void __attribute__((weak)) calibration_delay_done(void);
 void msleep(unsigned int msecs);
 unsigned long msleep_interruptible(unsigned int msecs);
-void usleep_range(unsigned long min, unsigned long max);
+void usleep_range_state(unsigned long min, unsigned long max,
+			unsigned int state);
+static inline void usleep_range(unsigned long min, unsigned long max)
+{
+	usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
+}
+static inline void usleep_idle_range(unsigned long min, unsigned long max)
+{
+	usleep_range_state(min, max, TASK_IDLE);
+}
 static inline void ssleep(unsigned int seconds)
 {

include/linux/mhi.h+13−0

@@ -663,6 +663,19 @@ int mhi_pm_suspend(struct mhi_controller *mhi_cntrl); · 662 unmodified lines
663	*/	663	*/
664	int mhi_pm_resume(struct mhi_controller *mhi_cntrl);	664	int mhi_pm_resume(struct mhi_controller *mhi_cntrl);
665		665
		666	/**
		667	* mhi_pm_resume_force - Force resume MHI from suspended state
		668	* @mhi_cntrl: MHI controller
		669	*
		670	* Resume the device irrespective of its MHI state. As per the MHI spec, devices
		671	* has to be in M3 state during resume. But some devices seem to be in a
		672	* different MHI state other than M3 but they continue working fine if allowed.
		673	* This API is intented to be used for such devices.
		674	*
		675	* Return: 0 if the resume succeeds, a negative error code otherwise
		676	*/
		677	int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl);
		678
666	/**	679	/**
667	* mhi_download_rddm_image - Download ramdump image from device for	680	* mhi_download_rddm_image - Download ramdump image from device for
668	* debugging purpose.	681	* debugging purpose.

include/linux/percpu-refcount.h+1−1

 #define _LINUX_PERCPU_REFCOUNT_H
 #include <linux/atomic.h>
-#include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/rcupdate.h>
+#include <linux/types.h>
 #include <linux/gfp.h>
 struct percpu_ref;

include/linux/pm_runtime.h+1−1

@@ -129,7 +129,7 @@ static inline bool pm_runtime_suspended(struct device *dev) · 128 unmodified lines
129	* pm_runtime_active - Check whether or not a device is runtime-active.	129	* pm_runtime_active - Check whether or not a device is runtime-active.
130	* @dev: Target device.	130	* @dev: Target device.
131	*	131	*
132	* Return %true if runtime PM is enabled for @dev and its runtime PM status is	132	* Return %true if runtime PM is disabled for @dev or its runtime PM status is
133	* %RPM_ACTIVE, or %false otherwise.	133	* %RPM_ACTIVE, or %false otherwise.
134	*	134	*
135	* Note that the return value of this function can only be trusted if it is	135	* Note that the return value of this function can only be trusted if it is

include/linux/wait.h+26−0

@@ -217,6 +217,7 @@ void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void · 216 unmodified lines
217	void __wake_up_locked_sync_key(struct wait_queue_head wq_head, unsigned int mode, void key);	217	void __wake_up_locked_sync_key(struct wait_queue_head wq_head, unsigned int mode, void key);
218	void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);	218	void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
219	void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);	219	void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
		220	void __wake_up_pollfree(struct wait_queue_head *wq_head);
220		221
221	#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)	222	#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
222	#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)	223	#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
@@ -245,6 +246,31 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode); · 22 unmodified lines
245	#define wake_up_interruptible_sync_poll_locked(x, m) \	246	#define wake_up_interruptible_sync_poll_locked(x, m) \
246	__wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))	247	__wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
247		248
		249	/**
		250	* wake_up_pollfree - signal that a polled waitqueue is going away
		251	* @wq_head: the wait queue head
		252	*
		253	* In the very rare cases where a ->poll() implementation uses a waitqueue whose
		254	* lifetime is tied to a task rather than to the 'struct file' being polled,
		255	* this function must be called before the waitqueue is freed so that
		256	* non-blocking polls (e.g. epoll) are notified that the queue is going away.
		257	*
		258	* The caller must also RCU-delay the freeing of the wait_queue_head, e.g. via
		259	* an explicit synchronize_rcu() or call_rcu(), or via SLAB_TYPESAFE_BY_RCU.
		260	*/
		261	static inline void wake_up_pollfree(struct wait_queue_head *wq_head)
		262	{
		263	/*
		264	* For performance reasons, we don't always take the queue lock here.
		265	* Therefore, we might race with someone removing the last entry from
		266	* the queue, and proceed while they still hold the queue lock.
		267	* However, rcu_read_lock() is required to be held in such cases, so we
		268	* can safely proceed with an RCU-delayed free.
		269	*/
		270	if (waitqueue_active(wq_head))
		271	__wake_up_pollfree(wq_head);
		272	}
		273
248	#define ___wait_cond_timeout(condition) \	274	#define ___wait_cond_timeout(condition) \
249	({ \	275	({ \
250	bool __cond = (condition); \	276	bool __cond = (condition); \

include/uapi/asm-generic/poll.h+1−1

@@ -29,7 +29,7 @@ · 28 unmodified lines
29	#define POLLRDHUP 0x2000	29	#define POLLRDHUP 0x2000
30	#endif	30	#endif
31		31
32	#define POLLFREE (__force __poll_t)0x4000 /* currently only for epoll */	32	#define POLLFREE (__force __poll_t)0x4000
33		33
34	#define POLL_BUSY_LOOP (__force __poll_t)0x8000	34	#define POLL_BUSY_LOOP (__force __poll_t)0x8000
35		35

include/uapi/linux/mptcp.h+10−8

  * MPTCP_EVENT_REMOVED: token, rem_id
  * An address has been lost by the peer.
  *
- * MPTCP_EVENT_SUB_ESTABLISHED: token, family, saddr4 | saddr6,
+ * MPTCP_EVENT_SUB_ESTABLISHED: token, family, loc_id, rem_id,
- *                              daddr4 | daddr6, sport, dport, backup,
+ *                              saddr4 | saddr6, daddr4 | daddr6, sport,
- *                              if_idx [, error]
+ *                              dport, backup, if_idx [, error]
  * A new subflow has been established. 'error' should not be set.
  *
- * MPTCP_EVENT_SUB_CLOSED: token, family, saddr4 | saddr6, daddr4 | daddr6,
+ * MPTCP_EVENT_SUB_CLOSED: token, family, loc_id, rem_id, saddr4 | saddr6,
- *                         sport, dport, backup, if_idx [, error]
+ *                         daddr4 | daddr6, sport, dport, backup, if_idx
+ *                         [, error]
  * A subflow has been closed. An error (copy of sk_err) could be set if an
  * error has been detected for this subflow.
  *
- * MPTCP_EVENT_SUB_PRIORITY: token, family, saddr4 | saddr6, daddr4 | daddr6,
+ * MPTCP_EVENT_SUB_PRIORITY: token, family, loc_id, rem_id, saddr4 | saddr6,
- *                           sport, dport, backup, if_idx [, error]
+ *                           daddr4 | daddr6, sport, dport, backup, if_idx
- *       The priority of a subflow has changed. 'error' should not be set.
+ *                           [, error]
+ * The priority of a subflow has changed. 'error' should not be set.
  */
 enum mptcp_event_type {
 	MPTCP_EVENT_UNSPEC = 0,

include/uapi/linux/resource.h+10−3

 #define _STK_LIM	(8*1024*1024)
 /*
- * GPG2 wants 64kB of mlocked memory, to make sure pass phrases
+ * Limit the amount of locked memory by some sane default:
- * and other sensitive information are never written to disk.
+ * root can always increase this limit if needed.
+ *
+ * The main use-cases are (1) preventing sensitive memory
+ * from being swapped; (2) real-time operations; (3) via
+ * IOURING_REGISTER_BUFFERS.
+ *
+ * The first two don't need much. The latter will take as
+ * much as it can get. 8MB is a reasonably sane default.
  */
-#define MLOCK_LIMIT	((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)
+#define MLOCK_LIMIT	(8*1024*1024)
 /*
  * Due to binary compatibility, the actual resource numbers

kernel/audit.c+10−11

 {
 	int rc = 0;
 	struct sk_buff *skb;
-	static unsigned int failed = 0;
+	unsigned int failed = 0;
 	/* NOTE: kauditd_thread takes care of all our locking, we just use
 	 *       the netlink info passed to us (e.g. sk and portid) */
 			continue;
 		}
+retry:
 		/* grab an extra skb reference in case of error */
 		skb_get(skb);
 		rc = netlink_unicast(sk, skb, portid, 0);
 		if (rc < 0) {
-			/* fatal failure for our queue flush attempt? */
+			/* send failed - try a few times unless fatal error */
 			if (++failed >= retry_limit ||
 			    rc == -ECONNREFUSED || rc == -EPERM) {
-				/* yes - error processing for the queue */
 				sk = NULL;
 				if (err_hook)
 					(*err_hook)(skb);
-				if (!skb_hook)
+				if (rc == -EAGAIN)
-					goto out;
+					rc = 0;
-				/* keep processing with the skb_hook */
+				/* continue to drain the queue */
 				continue;
 			} else
-				/* no - requeue to preserve ordering */
+				goto retry;
-				skb_queue_head(queue, skb);
 		} else {
-			/* it worked - drop the extra reference and continue */
+			/* skb sent - drop the extra reference and continue */
 			consume_skb(skb);
 			failed = 0;
 		}
 	}
-out:
 	return (rc >= 0 ? 0 : rc);
 }
 		audit_panic("cannot initialize netlink socket in namespace");
 		return -ENOMEM;
 	}
-	aunet->sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
+	/* limit the timeout in case auditd is blocked/stopped */
+	aunet->sk->sk_sndtimeo = HZ / 10;
 	return 0;
 }

kernel/bpf/verifier.c+36−17

@@ -1368,22 +1368,28 @@ static void __reg_bound_offset(struct bpf_reg_state *reg) · 1367 unmodified lines
1368	reg->var_off = tnum_or(tnum_clear_subreg(var64_off), var32_off);	1368	reg->var_off = tnum_or(tnum_clear_subreg(var64_off), var32_off);
1369	}	1369	}
1370		1370
		1371	static bool __reg32_bound_s64(s32 a)
		1372	{
		1373	return a >= 0 && a <= S32_MAX;
		1374	}
		1375
1371	static void __reg_assign_32_into_64(struct bpf_reg_state *reg)	1376	static void __reg_assign_32_into_64(struct bpf_reg_state *reg)
1372	{	1377	{
1373	reg->umin_value = reg->u32_min_value;	1378	reg->umin_value = reg->u32_min_value;
1374	reg->umax_value = reg->u32_max_value;	1379	reg->umax_value = reg->u32_max_value;
1375	/* Attempt to pull 32-bit signed bounds into 64-bit bounds	1380
1376	* but must be positive otherwise set to worse case bounds	1381	/* Attempt to pull 32-bit signed bounds into 64-bit bounds but must
1377	* and refine later from tnum.	1382	* be positive otherwise set to worse case bounds and refine later
		1383	* from tnum.
1378	*/	1384	*/
1379	if (reg->s32_min_value >= 0 && reg->s32_max_value >= 0)	1385	if (__reg32_bound_s64(reg->s32_min_value) &&
1380	reg->smax_value = reg->s32_max_value;	1386	__reg32_bound_s64(reg->s32_max_value)) {
1381	else
1382	reg->smax_value = U32_MAX;
1383	if (reg->s32_min_value >= 0)
1384	reg->smin_value = reg->s32_min_value;	1387	reg->smin_value = reg->s32_min_value;
1385	else	1388	reg->smax_value = reg->s32_max_value;
		1389	} else {
1386	reg->smin_value = 0;	1390	reg->smin_value = 0;
		1391	reg->smax_value = U32_MAX;
		1392	}
1387	}	1393	}
1388		1394
1389	static void __reg_combine_32_into_64(struct bpf_reg_state *reg)	1395	static void __reg_combine_32_into_64(struct bpf_reg_state *reg)
@@ -2381,8 +2387,6 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, · 991 unmodified lines
2381	*/	2387	*/
2382	if (insn->src_reg != BPF_REG_FP)	2388	if (insn->src_reg != BPF_REG_FP)
2383	return 0;	2389	return 0;
2384	if (BPF_SIZE(insn->code) != BPF_DW)
2385	return 0;
2386		2390
2387	/* dreg = (u64 )[fp - off] was a fill from the stack.	2391	/* dreg = (u64 )[fp - off] was a fill from the stack.
2388	* that [fp - off] slot contains scalar that needs to be	2392	* that [fp - off] slot contains scalar that needs to be
@@ -2405,8 +2409,6 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, · 16 unmodified lines
2405	/* scalars can only be spilled into stack */	2409	/* scalars can only be spilled into stack */
2406	if (insn->dst_reg != BPF_REG_FP)	2410	if (insn->dst_reg != BPF_REG_FP)
2407	return 0;	2411	return 0;
2408	if (BPF_SIZE(insn->code) != BPF_DW)
2409	return 0;
2410	spi = (-insn->off - 1) / BPF_REG_SIZE;	2412	spi = (-insn->off - 1) / BPF_REG_SIZE;
2411	if (spi >= 64) {	2413	if (spi >= 64) {
2412	verbose(env, "BUG spi %d\n", spi);	2414	verbose(env, "BUG spi %d\n", spi);
@@ -4553,9 +4555,16 @@ static int check_atomic(struct bpf_verifier_env *env, int insn_idx, struct bpf_i · 2140 unmodified lines
4553		4555
4554	if (insn->imm == BPF_CMPXCHG) {	4556	if (insn->imm == BPF_CMPXCHG) {
4555	/* Check comparison of R0 with memory location */	4557	/* Check comparison of R0 with memory location */
4556	err = check_reg_arg(env, BPF_REG_0, SRC_OP);	4558	const u32 aux_reg = BPF_REG_0;
		4559
		4560	err = check_reg_arg(env, aux_reg, SRC_OP);
4557	if (err)	4561	if (err)
4558	return err;	4562	return err;
		4563
		4564	if (is_pointer_value(env, aux_reg)) {
		4565	verbose(env, "R%d leaks addr into mem\n", aux_reg);
		4566	return -EACCES;
		4567	}
4559	}	4568	}
4560		4569
4561	if (is_pointer_value(env, insn->src_reg)) {	4570	if (is_pointer_value(env, insn->src_reg)) {
@@ -4590,13 +4599,19 @@ static int check_atomic(struct bpf_verifier_env *env, int insn_idx, struct bpf_i · 28 unmodified lines
4590	load_reg = -1;	4599	load_reg = -1;
4591	}	4600	}
4592		4601
4593	/* check whether we can read the memory */	4602	/* Check whether we can read the memory, with second call for fetch
		4603	* case to simulate the register fill.
		4604	*/
4594	err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,	4605	err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
4595	BPF_SIZE(insn->code), BPF_READ, load_reg, true);	4606	BPF_SIZE(insn->code), BPF_READ, -1, true);
		4607	if (!err && load_reg >= 0)
		4608	err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
		4609	BPF_SIZE(insn->code), BPF_READ, load_reg,
		4610	true);
4596	if (err)	4611	if (err)
4597	return err;	4612	return err;
4598		4613
4599	/* check whether we can write into the same memory */	4614	/* Check whether we can write into the same memory. */
4600	err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,	4615	err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
4601	BPF_SIZE(insn->code), BPF_WRITE, -1, true);	4616	BPF_SIZE(insn->code), BPF_WRITE, -1, true);
4602	if (err)	4617	if (err)
@@ -8364,6 +8379,10 @@ static int check_alu_op(struct bpf_verifier_env env, struct bpf_insn insn) · 3761 unmodified lines
8364	insn->dst_reg);	8379	insn->dst_reg);
8365	}	8380	}
8366	zext_32_to_64(dst_reg);	8381	zext_32_to_64(dst_reg);
		8382
		8383	__update_reg_bounds(dst_reg);
		8384	__reg_deduce_bounds(dst_reg);
		8385	__reg_bound_offset(dst_reg);
8367	}	8386	}
8368	} else {	8387	} else {
8369	/* case: R = imm	8388	/* case: R = imm

kernel/sched/wait.c+7−0

@@ -238,6 +238,13 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode) · 237 unmodified lines
238	}	238	}
239	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */	239	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
240		240
		241	void __wake_up_pollfree(struct wait_queue_head *wq_head)
		242	{
		243	__wake_up(wq_head, TASK_NORMAL, 0, poll_to_key(EPOLLHUP \| POLLFREE));
		244	/* POLLFREE must have cleared the queue. */
		245	WARN_ON_ONCE(waitqueue_active(wq_head));
		246	}
		247
241	/*	248	/*
242	* Note: we use "set_current_state()" _after_ the wait-queue add,	249	* Note: we use "set_current_state()" _after_ the wait-queue add,
243	* because we need a memory barrier there on SMP, so that any	250	* because we need a memory barrier there on SMP, so that any

kernel/time/timer.c+9−7

 EXPORT_SYMBOL(msleep_interruptible);
 /**
- * usleep_range - Sleep for an approximate time
+ * usleep_range_state - Sleep for an approximate time in a given state
- * @min: Minimum time in usecs to sleep
+ * @min:	Minimum time in usecs to sleep
- * @max: Maximum time in usecs to sleep
+ * @max:	Maximum time in usecs to sleep
+ * @state:	State of the current task that will be while sleeping
  *
  * In non-atomic context where the exact wakeup time is flexible, use
- * usleep_range() instead of udelay().  The sleep improves responsiveness
+ * usleep_range_state() instead of udelay().  The sleep improves responsiveness
  * by avoiding the CPU-hogging busy-wait of udelay(), and the range reduces
  * power usage by allowing hrtimers to take advantage of an already-
  * scheduled interrupt instead of scheduling a new one just for this sleep.
  */
-void __sched usleep_range(unsigned long min, unsigned long max)
+void __sched usleep_range_state(unsigned long min, unsigned long max,
+				unsigned int state)
 {
 	ktime_t exp = ktime_add_us(ktime_get(), min);
 	u64 delta = (u64)(max - min) * NSEC_PER_USEC;
 	for (;;) {
-		__set_current_state(TASK_UNINTERRUPTIBLE);
+		__set_current_state(state);
 		/* Do not return before the requested sleep time has elapsed */
 		if (!schedule_hrtimeout_range(&exp, delta, HRTIMER_MODE_ABS))
 			break;
 	}
 }
-EXPORT_SYMBOL(usleep_range);
+EXPORT_SYMBOL(usleep_range_state);

kernel/trace/ftrace.c+7−1

 {
 	struct ftrace_direct_func *direct;
 	struct ftrace_func_entry *entry;
+	struct ftrace_hash *hash;
 	int ret = -ENODEV;
 	mutex_lock(&direct_mutex);
 	if (!entry)
 		goto out_unlock;
-	if (direct_functions->count == 1)
+	hash = direct_ops.func_hash->filter_hash;
+	if (hash->count == 1)
 		unregister_ftrace_function(&direct_ops);
 	ret = ftrace_set_filter_ip(&direct_ops, ip, 1, 0);
 	err = unregister_ftrace_function(ops);
 	remove_direct_functions_hash(hash, addr);
 	mutex_unlock(&direct_mutex);
+	/* cleanup for possible another register call */
+	ops->func = NULL;
+	ops->trampoline = 0;
 	return err;
 }
 EXPORT_SYMBOL_GPL(unregister_ftrace_direct_multi);

kernel/trace/trace_events_synth.c+6−5

 						  argv + consumed, &consumed,
 						  &field_version);
 			if (IS_ERR(field)) {
-				argv_free(argv);
 				ret = PTR_ERR(field);
-				goto err;
+				goto err_free_arg;
 			}
 			/*
 			if (cmd_version > 1 && n_fields_this_loop >= 1) {
 				synth_err(SYNTH_ERR_INVALID_CMD, errpos(field_str));
 				ret = -EINVAL;
-				goto err;
+				goto err_free_arg;
 			}
 			fields[n_fields++] = field;
 			if (n_fields == SYNTH_FIELDS_MAX) {
 				synth_err(SYNTH_ERR_TOO_MANY_FIELDS, 0);
 				ret = -EINVAL;
-				goto err;
+				goto err_free_arg;
 			}
 			n_fields_this_loop++;
 		}
+		argv_free(argv);
 		if (consumed < argc) {
 			synth_err(SYNTH_ERR_INVALID_CMD, 0);
 			goto err;
 		}
-		argv_free(argv);
 	}
 	if (n_fields == 0) {
 	kfree(saved_fields);
 	return ret;
+ err_free_arg:
+	argv_free(argv);
  err:
 	for (i = 0; i < n_fields; i++)
 		free_synth_field(fields[i]);

mm/Kconfig+1−1

@@ -428,7 +428,7 @@ config THP_SWAP · 427 unmodified lines
428	# UP and nommu archs use km based percpu allocator	428	# UP and nommu archs use km based percpu allocator
429	#	429	#
430	config NEED_PER_CPU_KM	430	config NEED_PER_CPU_KM
431	depends on !SMP	431	depends on !SMP \|\| !MMU
432	bool	432	bool
433	default y	433	default y
434		434

mm/backing-dev.c+7−0

@@ -945,6 +945,13 @@ void bdi_unregister(struct backing_dev_info *bdi) · 944 unmodified lines
945	wb_shutdown(&bdi->wb);	945	wb_shutdown(&bdi->wb);
946	cgwb_bdi_unregister(bdi);	946	cgwb_bdi_unregister(bdi);
947		947
		948	/*
		949	* If this BDI's min ratio has been set, use bdi_set_min_ratio() to
		950	* update the global bdi_min_ratio.
		951	*/
		952	if (bdi->min_ratio)
		953	bdi_set_min_ratio(bdi, 0);
		954
948	if (bdi->dev) {	955	if (bdi->dev) {
949	bdi_debug_unregister(bdi);	956	bdi_debug_unregister(bdi);
950	device_unregister(bdi->dev);	957	device_unregister(bdi->dev);

mm/damon/core.c+7−13

 	for (i = 0; i < nr_ids; i++) {
 		t = damon_new_target(ids[i]);
 		if (!t) {
-			pr_err("Failed to alloc damon_target\n");
 			/* The caller should do cleanup of the ids itself */
 			damon_for_each_target_safe(t, next, ctx)
 				damon_destroy_target(t);
 		    unsigned long aggr_int, unsigned long primitive_upd_int,
 		    unsigned long min_nr_reg, unsigned long max_nr_reg)
 {
-	if (min_nr_reg < 3) {
+	if (min_nr_reg < 3)
-		pr_err("min_nr_regions (%lu) must be at least 3\n",
-				min_nr_reg);
 		return -EINVAL;
-	}
+	if (min_nr_reg > max_nr_reg)
-	if (min_nr_reg > max_nr_reg) {
-		pr_err("invalid nr_regions.  min (%lu) > max (%lu)\n",
-				min_nr_reg, max_nr_reg);
 		return -EINVAL;
-	}
 	ctx->sample_interval = sample_int;
 	ctx->aggr_interval = aggr_int;
 static void kdamond_usleep(unsigned long usecs)
 {
-	if (usecs > 100 * 1000)
+	/* See Documentation/timers/timers-howto.rst for the thresholds */
-		schedule_timeout_interruptible(usecs_to_jiffies(usecs));
+	if (usecs > 20 * USEC_PER_MSEC)
+		schedule_timeout_idle(usecs_to_jiffies(usecs));
 	else
-		usleep_range(usecs, usecs + 1);
+		usleep_idle_range(usecs, usecs + 1);
 }
 /* Returns negative error code if it's not activated but should return */
 				ctx->callback.after_sampling(ctx))
 			done = true;
-		usleep_range(ctx->sample_interval, ctx->sample_interval + 1);
+		kdamond_usleep(ctx->sample_interval);
 		if (ctx->primitive.check_accesses)
 			max_nr_accesses = ctx->primitive.check_accesses(ctx);

mm/damon/dbgfs.c+1−3

 				&wmarks.low, &parsed);
 		if (ret != 18)
 			break;
-		if (!damos_action_valid(action)) {
+		if (!damos_action_valid(action))
-			pr_err("wrong action %d\n", action);
 			goto fail;
-		}
 		pos += parsed;
 		scheme = damon_new_scheme(min_sz, max_sz, min_nr_a, max_nr_a,

mm/damon/vaddr-test.h+37−42

 				struct damon_addr_range *three_regions,
 				unsigned long *expected, int nr_expected)
 {
-	struct damon_ctx *ctx = damon_new_ctx();
 	struct damon_target *t;
 	struct damon_region *r;
 	int i;
 		r = damon_new_region(regions[i * 2], regions[i * 2 + 1]);
 		damon_add_region(r, t);
 	}
-	damon_add_target(ctx, t);
 	damon_va_apply_three_regions(t, three_regions);
 		KUNIT_EXPECT_EQ(test, r->ar.start, expected[i * 2]);
 		KUNIT_EXPECT_EQ(test, r->ar.end, expected[i * 2 + 1]);
 	}
-	damon_destroy_ctx(ctx);
 }
 /*
 			new_three_regions, expected, ARRAY_SIZE(expected));
 }
-static void damon_test_split_evenly(struct kunit *test)
+static void damon_test_split_evenly_fail(struct kunit *test,
+		unsigned long start, unsigned long end, unsigned int nr_pieces)
 {
-	struct damon_ctx *c = damon_new_ctx();
+	struct damon_target *t = damon_new_target(42);
-	struct damon_target *t;
+	struct damon_region *r = damon_new_region(start, end);
-	struct damon_region *r;
-	unsigned long i;
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(NULL, NULL, 5),
-			-EINVAL);
-	t = damon_new_target(42);
-	r = damon_new_region(0, 100);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 0), -EINVAL);
 	damon_add_region(r, t);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 10), 0);
+	KUNIT_EXPECT_EQ(test,
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 10u);
+			damon_va_evenly_split_region(t, r, nr_pieces), -EINVAL);
+	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1u);
-	i = 0;
 	damon_for_each_region(r, t) {
-		KUNIT_EXPECT_EQ(test, r->ar.start, i++ * 10);
+		KUNIT_EXPECT_EQ(test, r->ar.start, start);
-		KUNIT_EXPECT_EQ(test, r->ar.end, i * 10);
+		KUNIT_EXPECT_EQ(test, r->ar.end, end);
 	}
 	damon_free_target(t);
+}
+static void damon_test_split_evenly_succ(struct kunit *test,
+	unsigned long start, unsigned long end, unsigned int nr_pieces)
+{
+	struct damon_target *t = damon_new_target(42);
+	struct damon_region *r = damon_new_region(start, end);
+	unsigned long expected_width = (end - start) / nr_pieces;
+	unsigned long i = 0;
-	t = damon_new_target(42);
-	r = damon_new_region(5, 59);
 	damon_add_region(r, t);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 5), 0);
+	KUNIT_EXPECT_EQ(test,
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 5u);
+			damon_va_evenly_split_region(t, r, nr_pieces), 0);
+	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), nr_pieces);
-	i = 0;
 	damon_for_each_region(r, t) {
-		if (i == 4)
+		if (i == nr_pieces - 1)
 			break;
-		KUNIT_EXPECT_EQ(test, r->ar.start, 5 + 10 * i++);
+		KUNIT_EXPECT_EQ(test,
-		KUNIT_EXPECT_EQ(test, r->ar.end, 5 + 10 * i);
+				r->ar.start, start + i++ * expected_width);
+		KUNIT_EXPECT_EQ(test, r->ar.end, start + i * expected_width);
 	}
-	KUNIT_EXPECT_EQ(test, r->ar.start, 5 + 10 * i);
+	KUNIT_EXPECT_EQ(test, r->ar.start, start + i * expected_width);
-	KUNIT_EXPECT_EQ(test, r->ar.end, 59ul);
+	KUNIT_EXPECT_EQ(test, r->ar.end, end);
 	damon_free_target(t);
+}
-	t = damon_new_target(42);
+static void damon_test_split_evenly(struct kunit *test)
-	r = damon_new_region(5, 6);
+{
-	damon_add_region(r, t);
+	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(NULL, NULL, 5),
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 2), -EINVAL);
+			-EINVAL);
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1u);
-	damon_for_each_region(r, t) {
+	damon_test_split_evenly_fail(test, 0, 100, 0);
-		KUNIT_EXPECT_EQ(test, r->ar.start, 5ul);
+	damon_test_split_evenly_succ(test, 0, 100, 10);
-		KUNIT_EXPECT_EQ(test, r->ar.end, 6ul);
+	damon_test_split_evenly_succ(test, 5, 59, 5);
-	}
+	damon_test_split_evenly_fail(test, 5, 6, 2);
-	damon_free_target(t);
-	damon_destroy_ctx(c);
 }
 static struct kunit_case damon_test_cases[] = {

mm/damon/vaddr.c+0−1

@@ -627,7 +627,6 @@ int damon_va_apply_scheme(struct damon_ctx ctx, struct damon_target t, · 626 unmodified lines
627	case DAMOS_STAT:	627	case DAMOS_STAT:
628	return 0;	628	return 0;
629	default:	629	default:
630	pr_warn("Wrong action %d\n", scheme->action);
631	return -EINVAL;	630	return -EINVAL;
632	}	631	}
633		632

mm/filemap.c+0−2

 			goto skip;
 		if (!PageUptodate(page) || PageReadahead(page))
 			goto skip;
-		if (PageHWPoison(page))
-			goto skip;
 		if (!trylock_page(page))
 			goto skip;
 		if (page->mapping != mapping)

mm/hugetlb.c+1−1

@@ -2973,7 +2973,7 @@ int __alloc_bootmem_huge_page(struct hstate *h, int nid) · 2972 unmodified lines
2973	struct huge_bootmem_page m = NULL; / initialize for clang */	2973	struct huge_bootmem_page m = NULL; / initialize for clang */
2974	int nr_nodes, node;	2974	int nr_nodes, node;
2975		2975
2976	if (nid >= nr_online_nodes)	2976	if (nid != NUMA_NO_NODE && nid >= nr_online_nodes)
2977	return 0;	2977	return 0;
2978	/* do node specific alloc */	2978	/* do node specific alloc */
2979	if (nid != NUMA_NO_NODE) {	2979	if (nid != NUMA_NO_NODE) {

mm/memcontrol.c+53−53

 	rcu_read_unlock();
 }
-/*
- * mod_objcg_mlstate() may be called with irq enabled, so
- * mod_memcg_lruvec_state() should be used.
- */
-static inline void mod_objcg_mlstate(struct obj_cgroup *objcg,
-				     struct pglist_data *pgdat,
-				     enum node_stat_item idx, int nr)
-{
-	struct mem_cgroup *memcg;
-	struct lruvec *lruvec;
-	rcu_read_lock();
-	memcg = obj_cgroup_memcg(objcg);
-	lruvec = mem_cgroup_lruvec(memcg, pgdat);
-	mod_memcg_lruvec_state(lruvec, idx, nr);
-	rcu_read_unlock();
-}
 /**
  * __count_memcg_events - account VM events in a cgroup
  * @memcg: the memory cgroup
 }
 #endif
-/*
- * Most kmem_cache_alloc() calls are from user context. The irq disable/enable
- * sequence used in this case to access content from object stock is slow.
- * To optimize for user context access, there are now two object stocks for
- * task context and interrupt context access respectively.
- *
- * The task context object stock can be accessed by disabling preemption only
- * which is cheap in non-preempt kernel. The interrupt context object stock
- * can only be accessed after disabling interrupt. User context code can
- * access interrupt object stock, but not vice versa.
- */
-static inline struct obj_stock *get_obj_stock(unsigned long *pflags)
-{
-	struct memcg_stock_pcp *stock;
-	if (likely(in_task())) {
-		*pflags = 0UL;
-		preempt_disable();
-		stock = this_cpu_ptr(&memcg_stock);
-		return &stock->task_obj;
-	}
-	local_irq_save(*pflags);
-	stock = this_cpu_ptr(&memcg_stock);
-	return &stock->irq_obj;
-}
-static inline void put_obj_stock(unsigned long flags)
-{
-	if (likely(in_task()))
-		preempt_enable();
-	else
-		local_irq_restore(flags);
-}
 /**
  * consume_stock: Try to consume stocked charge on this cpu.
  * @memcg: memcg to consume from.
  */
 #define OBJCGS_CLEAR_MASK	(__GFP_DMA | __GFP_RECLAIMABLE | __GFP_ACCOUNT)
+/*
+ * Most kmem_cache_alloc() calls are from user context. The irq disable/enable
+ * sequence used in this case to access content from object stock is slow.
+ * To optimize for user context access, there are now two object stocks for
+ * task context and interrupt context access respectively.
+ *
+ * The task context object stock can be accessed by disabling preemption only
+ * which is cheap in non-preempt kernel. The interrupt context object stock
+ * can only be accessed after disabling interrupt. User context code can
+ * access interrupt object stock, but not vice versa.
+ */
+static inline struct obj_stock *get_obj_stock(unsigned long *pflags)
+{
+	struct memcg_stock_pcp *stock;
+	if (likely(in_task())) {
+		*pflags = 0UL;
+		preempt_disable();
+		stock = this_cpu_ptr(&memcg_stock);
+		return &stock->task_obj;
+	}
+	local_irq_save(*pflags);
+	stock = this_cpu_ptr(&memcg_stock);
+	return &stock->irq_obj;
+}
+static inline void put_obj_stock(unsigned long flags)
+{
+	if (likely(in_task()))
+		preempt_enable();
+	else
+		local_irq_restore(flags);
+}
+/*
+ * mod_objcg_mlstate() may be called with irq enabled, so
+ * mod_memcg_lruvec_state() should be used.
+ */
+static inline void mod_objcg_mlstate(struct obj_cgroup *objcg,
+				     struct pglist_data *pgdat,
+				     enum node_stat_item idx, int nr)
+{
+	struct mem_cgroup *memcg;
+	struct lruvec *lruvec;
+	rcu_read_lock();
+	memcg = obj_cgroup_memcg(objcg);
+	lruvec = mem_cgroup_lruvec(memcg, pgdat);
+	mod_memcg_lruvec_state(lruvec, idx, nr);
+	rcu_read_unlock();
+}
 int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
 				 gfp_t gfp, bool new_page)
 {

mm/slub.c+9−6

 	unsigned long max;
 	unsigned long count;
 	struct location *loc;
+	loff_t idx;
 };
 static struct dentry *slab_debugfs_root;
 #if defined(CONFIG_SLUB_DEBUG) && defined(CONFIG_DEBUG_FS)
 static int slab_debugfs_show(struct seq_file *seq, void *v)
 {
-	struct location *l;
-	unsigned int idx = *(unsigned int *)v;
 	struct loc_track *t = seq->private;
+	struct location *l;
+	unsigned long idx;
+	idx = (unsigned long) t->idx;
 	if (idx < t->count) {
 		l = &t->loc[idx];
 {
 	struct loc_track *t = seq->private;
-	v = ppos;
+	t->idx = ++(*ppos);
-	++*ppos;
 	if (*ppos <= t->count)
-		return v;
+		return ppos;
 	return NULL;
 }
 static void *slab_debugfs_start(struct seq_file *seq, loff_t *ppos)
 {
+	struct loc_track *t = seq->private;
+	t->idx = *ppos;
 	return ppos;
 }

net/core/skbuff.c+1−1

@@ -832,7 +832,7 @@ void skb_dump(const char level, const struct sk_buff skb, bool full_pkt) · 831 unmodified lines
832	ntohs(skb->protocol), skb->pkt_type, skb->skb_iif);	832	ntohs(skb->protocol), skb->pkt_type, skb->skb_iif);
833		833
834	if (dev)	834	if (dev)
835	printk("%sdev name=%s feat=0x%pNF\n",	835	printk("%sdev name=%s feat=%pNF\n",
836	level, dev->name, &dev->features);	836	level, dev->name, &dev->features);
837	if (sk)	837	if (sk)
838	printk("%ssk family=%hu type=%u proto=%u\n",	838	printk("%ssk family=%hu type=%u proto=%u\n",

net/ipv4/inet_diag.c+1−3

 	r->idiag_state = sk->sk_state;
 	r->idiag_timer = 0;
 	r->idiag_retrans = 0;
+	r->idiag_expires = 0;
 	if (inet_diag_msg_attrs_fill(sk, skb, r, ext,
 				     sk_user_ns(NETLINK_CB(cb->skb).sk),
 		r->idiag_retrans = icsk->icsk_probes_out;
 		r->idiag_expires =
 			jiffies_delta_to_msecs(sk->sk_timer.expires - jiffies);
-	} else {
-		r->idiag_timer = 0;
-		r->idiag_expires = 0;
 	}
 	if ((ext & (1 << (INET_DIAG_INFO - 1))) && handler->idiag_info_size) {

net/ipv6/sit.c+0−1

@@ -1933,7 +1933,6 @@ static int __net_init sit_init_net(struct net *net) · 1932 unmodified lines
1933	return 0;	1933	return 0;
1934		1934
1935	err_reg_dev:	1935	err_reg_dev:
1936	ipip6_dev_free(sitn->fb_tunnel_dev);
1937	free_netdev(sitn->fb_tunnel_dev);	1936	free_netdev(sitn->fb_tunnel_dev);
1938	err_alloc_dev:	1937	err_alloc_dev:
1939	return err;	1938	return err;

net/mac80211/agg-rx.c+3−2

  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  * Copyright 2007-2010, Intel Corporation
  * Copyright(c) 2015-2017 Intel Deutschland GmbH
- * Copyright (C) 2018-2020 Intel Corporation
+ * Copyright (C) 2018-2021 Intel Corporation
  */
 /**
 	sband = ieee80211_get_sband(sdata);
 	if (!sband)
 		return;
-	he_cap = ieee80211_get_he_iftype_cap(sband, sdata->vif.type);
+	he_cap = ieee80211_get_he_iftype_cap(sband,
+					     ieee80211_vif_type_p2p(&sdata->vif));
 	if (!he_cap)
 		return;

net/mac80211/agg-tx.c+11−5

  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  * Copyright 2007-2010, Intel Corporation
  * Copyright(c) 2015-2017 Intel Deutschland GmbH
- * Copyright (C) 2018 - 2020 Intel Corporation
+ * Copyright (C) 2018 - 2021 Intel Corporation
  */
 #include <linux/ieee80211.h>
 	mgmt->u.action.u.addba_req.start_seq_num =
 					cpu_to_le16(start_seq_num << 4);
-	ieee80211_tx_skb(sdata, skb);
+	ieee80211_tx_skb_tid(sdata, skb, tid);
 }
 void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
 	struct ieee80211_txq *txq = sta->sta.txq[tid];
 	struct txq_info *txqi;
+	lockdep_assert_held(&sta->ampdu_mlme.mtx);
 	if (!txq)
 		return;
 	ieee80211_assign_tid_tx(sta, tid, NULL);
 	ieee80211_agg_splice_finish(sta->sdata, tid);
-	ieee80211_agg_start_txq(sta, tid, false);
 	kfree_rcu(tid_tx, rcu_head);
 }
 	/* send AddBA request */
 	ieee80211_send_addba_request(sdata, sta->sta.addr, tid,
-				     tid_tx->dialog_token,
+				     tid_tx->dialog_token, tid_tx->ssn,
-				     sta->tid_seq[tid] >> 4,
 				     buf_size, tid_tx->timeout);
 	WARN_ON(test_and_set_bit(HT_AGG_STATE_SENT_ADDBA, &tid_tx->state));
 	params.ssn = sta->tid_seq[tid] >> 4;
 	ret = drv_ampdu_action(local, sdata, &params);
+	tid_tx->ssn = params.ssn;
 	if (ret == IEEE80211_AMPDU_TX_START_DELAY_ADDBA) {
 		return;
 	} else if (ret == IEEE80211_AMPDU_TX_START_IMMEDIATE) {
 {
 	struct ieee80211_sub_if_data *sdata = sta->sdata;
 	bool send_delba = false;
+	bool start_txq = false;
 	ht_dbg(sdata, "Stopping Tx BA session for %pM tid %d\n",
 	       sta->sta.addr, tid);
 		send_delba = true;
 	ieee80211_remove_tid_tx(sta, tid);
+	start_txq = true;
  unlock_sta:
 	spin_unlock_bh(&sta->lock);
+	if (start_txq)
+		ieee80211_agg_start_txq(sta, tid, false);
 	if (send_delba)
 		ieee80211_send_delba(sdata, sta->sta.addr, tid,
 			WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);

net/mac80211/driver-ops.h+4−1

 {
 	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
-	if (local->in_reconfig)
+	/* In reconfig don't transmit now, but mark for waking later */
+	if (local->in_reconfig) {
+		set_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txq->flags);
 		return;
+	}
 	if (!check_sdata_in_driver(sdata))
 		return;

net/mac80211/mlme.c+10−3

 					   u16 tx_time)
 {
 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-	u16 tid = ieee80211_get_tid(hdr);
+	u16 tid;
-	int ac = ieee80211_ac_from_tid(tid);
+	int ac;
-	struct ieee80211_sta_tx_tspec *tx_tspec = &ifmgd->tx_tspec[ac];
+	struct ieee80211_sta_tx_tspec *tx_tspec;
 	unsigned long now = jiffies;
+	if (!ieee80211_is_data_qos(hdr->frame_control))
+		return;
+	tid = ieee80211_get_tid(hdr);
+	ac = ieee80211_ac_from_tid(tid);
+	tx_tspec = &ifmgd->tx_tspec[ac];
 	if (likely(!tx_tspec->admitted_time))
 		return;

net/mac80211/rx.c+1−0

@@ -2944,6 +2944,7 @@ ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx) · 2943 unmodified lines
2944	if (!fwd_skb)	2944	if (!fwd_skb)
2945	goto out;	2945	goto out;
2946		2946
		2947	fwd_skb->dev = sdata->dev;
2947	fwd_hdr = (struct ieee80211_hdr *) fwd_skb->data;	2948	fwd_hdr = (struct ieee80211_hdr *) fwd_skb->data;
2948	fwd_hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_RETRY);	2949	fwd_hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_RETRY);
2949	info = IEEE80211_SKB_CB(fwd_skb);	2950	info = IEEE80211_SKB_CB(fwd_skb);

net/mac80211/sta_info.c+12−9

 	/* check if STA exists already */
 	if (sta_info_get_bss(sdata, sta->sta.addr)) {
 		err = -EEXIST;
-		goto out_err;
+		goto out_cleanup;
 	}
 	sinfo = kzalloc(sizeof(struct station_info), GFP_KERNEL);
 	if (!sinfo) {
 		err = -ENOMEM;
-		goto out_err;
+		goto out_cleanup;
 	}
 	local->num_sta++;
 	list_add_tail_rcu(&sta->list, &local->sta_list);
+	/* update channel context before notifying the driver about state
+	 * change, this enables driver using the updated channel context right away.
+	 */
+	if (sta->sta_state >= IEEE80211_STA_ASSOC) {
+		ieee80211_recalc_min_chandef(sta->sdata);
+		if (!sta->sta.support_p2p_ps)
+			ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
+	}
 	/* notify driver */
 	err = sta_info_insert_drv_state(local, sdata, sta);
 	if (err)
 	set_sta_flag(sta, WLAN_STA_INSERTED);
-	if (sta->sta_state >= IEEE80211_STA_ASSOC) {
-		ieee80211_recalc_min_chandef(sta->sdata);
-		if (!sta->sta.support_p2p_ps)
-			ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
-	}
 	/* accept BA sessions now */
 	clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
  out_drop_sta:
 	local->num_sta--;
 	synchronize_net();
+ out_cleanup:
 	cleanup_single_sta(sta);
- out_err:
 	mutex_unlock(&local->sta_mtx);
 	kfree(sinfo);
 	rcu_read_lock();

net/mac80211/sta_info.h+2−0

  * @failed_bar_ssn: ssn of the last failed BAR tx attempt
  * @bar_pending: BAR needs to be re-sent
  * @amsdu: support A-MSDU withing A-MDPU
+ * @ssn: starting sequence number of the session
  *
  * This structure's lifetime is managed by RCU, assignments to
  * the array holding it must hold the aggregation mutex.
 	u8 stop_initiator;
 	bool tx_stop;
 	u16 buf_size;
+	u16 ssn;
 	u16 failed_bar_ssn;
 	bool bar_pending;

net/mac80211/tx.c+5−5

 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
 	ieee80211_tx_result res = TX_CONTINUE;
+	if (!ieee80211_hw_check(&tx->local->hw, HAS_RATE_CONTROL))
+		CALL_TXH(ieee80211_tx_h_rate_ctrl);
 	if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION)) {
 		__skb_queue_tail(&tx->skbs, tx->skb);
 		tx->skb = NULL;
 		goto txh_done;
 	}
-	if (!ieee80211_hw_check(&tx->local->hw, HAS_RATE_CONTROL))
-		CALL_TXH(ieee80211_tx_h_rate_ctrl);
 	CALL_TXH(ieee80211_tx_h_michael_mic_add);
 	CALL_TXH(ieee80211_tx_h_sequence);
 	CALL_TXH(ieee80211_tx_h_fragment);
 	ieee80211_aggr_check(sdata, sta, skb);
+	sk_pacing_shift_update(skb->sk, sdata->local->hw.tx_sk_pacing_shift);
 	if (sta) {
 		struct ieee80211_fast_tx *fast_tx;
-		sk_pacing_shift_update(skb->sk, sdata->local->hw.tx_sk_pacing_shift);
 		fast_tx = rcu_dereference(sta->fast_tx);
 		if (fast_tx &&

net/mac80211/util.c+14−9

 					      struct ieee802_11_elems *elems)
 {
 	const void *data = elem->data + 1;
-	u8 len = elem->datalen - 1;
+	u8 len;
+	if (!elem->datalen)
+		return;
+	len = elem->datalen - 1;
 	switch (elem->data[0]) {
 	case WLAN_EID_EXT_HE_MU_EDCA:
 		chandef.chan = chan;
 	skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
-				     100 + ie_len);
+				     local->scan_ies_len + ie_len);
 	if (!skb)
 		return NULL;
 		mutex_unlock(&local->sta_mtx);
 	}
+	/*
+	 * If this is for hw restart things are still running.
+	 * We may want to change that later, however.
+	 */
+	if (local->open_count && (!suspended || reconfig_due_to_wowlan))
+		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
 	if (local->in_reconfig) {
 		local->in_reconfig = false;
 		barrier();
 					IEEE80211_QUEUE_STOP_REASON_SUSPEND,
 					false);
-	/*
-	 * If this is for hw restart things are still running.
-	 * We may want to change that later, however.
-	 */
-	if (local->open_count && (!suspended || reconfig_due_to_wowlan))
-		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
 	if (!suspended)
 		return 0;

net/mptcp/pm_netlink.c+3−0

@@ -700,6 +700,9 @@ static void mptcp_pm_nl_rm_addr_or_subflow(struct mptcp_sock *msk, · 699 unmodified lines
700		700
701	msk_owned_by_me(msk);	701	msk_owned_by_me(msk);
702		702
		703	if (sk->sk_state == TCP_LISTEN)
		704	return;
		705
703	if (!rm_list->nr)	706	if (!rm_list->nr)
704	return;	707	return;
705		708

net/mptcp/protocol.c+4−2

 			int ret = 0;
 			prev_ssk = ssk;
-			mptcp_flush_join_list(msk);
+			__mptcp_flush_join_list(msk);
 			ssk = mptcp_subflow_get_send(msk);
 			/* First check. If the ssk has changed since
 		 */
 		if (WARN_ON_ONCE(!new_mptcp_sock)) {
 			tcp_sk(newsk)->is_mptcp = 0;
-			return newsk;
+			goto out;
 		}
 		/* acquire the 2nd reference for the owning socket */
 				MPTCP_MIB_MPCAPABLEPASSIVEFALLBACK);
 	}
+out:
+	newsk->sk_kern_sock = kern;
 	return newsk;
 }

net/mptcp/sockopt.c+0−1

@@ -543,7 +543,6 @@ static bool mptcp_supported_sockopt(int level, int optname) · 542 unmodified lines
543	case TCP_NODELAY:	543	case TCP_NODELAY:
544	case TCP_THIN_LINEAR_TIMEOUTS:	544	case TCP_THIN_LINEAR_TIMEOUTS:
545	case TCP_CONGESTION:	545	case TCP_CONGESTION:
546	case TCP_ULP:
547	case TCP_CORK:	546	case TCP_CORK:
548	case TCP_KEEPIDLE:	547	case TCP_KEEPIDLE:
549	case TCP_KEEPINTVL:	548	case TCP_KEEPINTVL:

net/packet/af_packet.c+3−2

 	}
 out_free_pg_vec:
-	bitmap_free(rx_owner_map);
+	if (pg_vec) {
-	if (pg_vec)
+		bitmap_free(rx_owner_map);
 		free_pg_vec(pg_vec, order, req->tp_block_nr);
+	}
 out:
 	return err;
 }

net/phonet/pep.c+1−0

@@ -868,6 +868,7 @@ static struct sock pep_sock_accept(struct sock sk, int flags, int *errp, · 867 unmodified lines
868		868
869	err = pep_accept_conn(newsk, skb);	869	err = pep_accept_conn(newsk, skb);
870	if (err) {	870	if (err) {
		871	__sock_put(sk);
871	sock_put(newsk);	872	sock_put(newsk);
872	newsk = NULL;	873	newsk = NULL;
873	goto drop;	874	goto drop;

net/rds/connection.c+1−0

@@ -253,6 +253,7 @@ static struct rds_connection __rds_conn_create(struct net net, · 252 unmodified lines
253	* should end up here, but if it	253	* should end up here, but if it
254	* does, reset/destroy the connection.	254	* does, reset/destroy the connection.
255	*/	255	*/
		256	kfree(conn->c_path);
256	kmem_cache_free(rds_conn_slab, conn);	257	kmem_cache_free(rds_conn_slab, conn);
257	conn = ERR_PTR(-EOPNOTSUPP);	258	conn = ERR_PTR(-EOPNOTSUPP);
258	goto out;	259	goto out;

net/sched/cls_api.c+1−0

@@ -3687,6 +3687,7 @@ int tc_setup_flow_action(struct flow_action *flow_action, · 3686 unmodified lines
3687	entry->mpls_mangle.ttl = tcf_mpls_ttl(act);	3687	entry->mpls_mangle.ttl = tcf_mpls_ttl(act);
3688	break;	3688	break;
3689	default:	3689	default:
		3690	err = -EOPNOTSUPP;
3690	goto err_out_locked;	3691	goto err_out_locked;
3691	}	3692	}
3692	} else if (is_tcf_skbedit_ptype(act)) {	3693	} else if (is_tcf_skbedit_ptype(act)) {

net/sched/sch_cake.c+1−5

 	q->tins = kvcalloc(CAKE_MAX_TINS, sizeof(struct cake_tin_data),
 			   GFP_KERNEL);
 	if (!q->tins)
-		goto nomem;
+		return -ENOMEM;
 	for (i = 0; i < CAKE_MAX_TINS; i++) {
 		struct cake_tin_data *b = q->tins + i;
 	q->min_netlen = ~0;
 	q->min_adjlen = ~0;
 	return 0;
-nomem:
-	cake_destroy(sch);
-	return -ENOMEM;
 }
 static int cake_dump(struct Qdisc *sch, struct sk_buff *skb)

net/sched/sch_ets.c+2−2

 		}
 	}
 	for (i = q->nbands; i < oldbands; i++) {
-		qdisc_tree_flush_backlog(q->classes[i].qdisc);
+		if (i >= q->nstrict && q->classes[i].qdisc->q.qlen)
-		if (i >= q->nstrict)
 			list_del(&q->classes[i].alist);
+		qdisc_tree_flush_backlog(q->classes[i].qdisc);
 	}
 	q->nstrict = nstrict;
 	memcpy(q->prio2band, priomap, sizeof(priomap));

net/smc/af_smc.c+3−1

@@ -194,7 +194,9 @@ static int smc_release(struct socket *sock) · 193 unmodified lines
194	/* cleanup for a dangling non-blocking connect */	194	/* cleanup for a dangling non-blocking connect */
195	if (smc->connect_nonblock && sk->sk_state == SMC_INIT)	195	if (smc->connect_nonblock && sk->sk_state == SMC_INIT)
196	tcp_abort(smc->clcsock->sk, ECONNABORTED);	196	tcp_abort(smc->clcsock->sk, ECONNABORTED);
197	flush_work(&smc->connect_work);	197
		198	if (cancel_work_sync(&smc->connect_work))
		199	sock_put(&smc->sk); /* sock_hold in smc_connect for passive closing */
198		200
199	if (sk->sk_state == SMC_LISTEN)	201	if (sk->sk_state == SMC_LISTEN)
200	/* smc_close_non_accepted() is called and acquires	202	/* smc_close_non_accepted() is called and acquires

net/vmw_vsock/virtio_transport_common.c+2−1

@@ -1299,7 +1299,8 @@ void virtio_transport_recv_pkt(struct virtio_transport *t, · 1298 unmodified lines
1299	space_available = virtio_transport_space_update(sk, pkt);	1299	space_available = virtio_transport_space_update(sk, pkt);
1300		1300
1301	/* Update CID in case it has changed after a transport reset event */	1301	/* Update CID in case it has changed after a transport reset event */
1302	vsk->local_addr.svm_cid = dst.svm_cid;	1302	if (vsk->local_addr.svm_cid != VMADDR_CID_ANY)
		1303	vsk->local_addr.svm_cid = dst.svm_cid;
1303		1304
1304	if (space_available)	1305	if (space_available)
1305	sk->sk_write_space(sk);	1306	sk->sk_write_space(sk);

net/wireless/reg.c+28−2

 static void restore_regulatory_settings(bool reset_user, bool cached);
 static void print_regdomain(const struct ieee80211_regdomain *rd);
+static void reg_process_hint(struct regulatory_request *reg_request);
 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
 {
 	const struct firmware *fw;
 	void *db;
 	int err;
+	const struct ieee80211_regdomain *current_regdomain;
+	struct regulatory_request *request;
 	err = request_firmware(&fw, "regulatory.db", &reg_pdev->dev);
 	if (err)
 	if (!IS_ERR_OR_NULL(regdb))
 		kfree(regdb);
 	regdb = db;
-	rtnl_unlock();
+	/* reset regulatory domain */
+	current_regdomain = get_cfg80211_regdom();
+	request = kzalloc(sizeof(*request), GFP_KERNEL);
+	if (!request) {
+		err = -ENOMEM;
+		goto out_unlock;
+	}
+	request->wiphy_idx = WIPHY_IDX_INVALID;
+	request->alpha2[0] = current_regdomain->alpha2[0];
+	request->alpha2[1] = current_regdomain->alpha2[1];
+	request->initiator = NL80211_REGDOM_SET_BY_CORE;
+	request->user_reg_hint_type = NL80211_USER_REG_HINT_USER;
+	reg_process_hint(request);
+out_unlock:
+	rtnl_unlock();
  out:
 	release_firmware(fw);
 	return err;
 	struct cfg80211_chan_def chandef = {};
 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 	enum nl80211_iftype iftype;
+	bool ret;
 	wdev_lock(wdev);
 	iftype = wdev->iftype;
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_P2P_GO:
 	case NL80211_IFTYPE_ADHOC:
-		return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
+		wiphy_lock(wiphy);
+		ret = cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
+		wiphy_unlock(wiphy);
+		return ret;
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_P2P_CLIENT:
 		return cfg80211_chandef_usable(wiphy, &chandef,

net/xdp/xsk.c+2−2

 	struct xdp_sock *xs = xdp_sk(sk);
 	struct xsk_buff_pool *pool;
-	sock_poll_wait(file, sock, wait);
 	if (unlikely(!xsk_is_bound(xs)))
 		return mask;
 		else
 			/* Poll needs to drive Tx also in copy mode */
 			__xsk_sendmsg(sk);
+	} else {
+		sock_poll_wait(file, sock, wait);
 	}
 	if (xs->rx && !xskq_prod_is_empty(xs->rx))

samples/ftrace/Makefile+1−0

@@ -4,6 +4,7 @@ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct.o · 3 unmodified lines
4	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o	4	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o
5	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o	5	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o
6	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi.o	6	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi.o
		7	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi-modify.o
7		8
8	CFLAGS_sample-trace-array.o := -I$(src)	9	CFLAGS_sample-trace-array.o := -I$(src)
9	obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o	10	obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o

samples/ftrace/ftrace-direct-multi-modify.c+152−0

@@ -0,0 +1,152 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	#include <linux/module.h>
	3	#include <linux/kthread.h>
	4	#include <linux/ftrace.h>
	5	#include <asm/asm-offsets.h>
	6
	7	void my_direct_func1(unsigned long ip)
	8	{
	9	trace_printk("my direct func1 ip %lx\n", ip);
	10	}
	11
	12	void my_direct_func2(unsigned long ip)
	13	{
	14	trace_printk("my direct func2 ip %lx\n", ip);
	15	}
	16
	17	extern void my_tramp1(void *);
	18	extern void my_tramp2(void *);
	19
	20	#ifdef CONFIG_X86_64
	21
	22	asm (
	23	" .pushsection .text, \"ax\", @progbits\n"
	24	" .type my_tramp1, @function\n"
	25	" .globl my_tramp1\n"
	26	" my_tramp1:"
	27	" pushq %rbp\n"
	28	" movq %rsp, %rbp\n"
	29	" pushq %rdi\n"
	30	" movq 8(%rbp), %rdi\n"
	31	" call my_direct_func1\n"
	32	" popq %rdi\n"
	33	" leave\n"
	34	" ret\n"
	35	" .size my_tramp1, .-my_tramp1\n"
	36	" .type my_tramp2, @function\n"
	37	"\n"
	38	" .globl my_tramp2\n"
	39	" my_tramp2:"
	40	" pushq %rbp\n"
	41	" movq %rsp, %rbp\n"
	42	" pushq %rdi\n"
	43	" movq 8(%rbp), %rdi\n"
	44	" call my_direct_func2\n"
	45	" popq %rdi\n"
	46	" leave\n"
	47	" ret\n"
	48	" .size my_tramp2, .-my_tramp2\n"
	49	" .popsection\n"
	50	);
	51
	52	#endif /* CONFIG_X86_64 */
	53
	54	#ifdef CONFIG_S390
	55
	56	asm (
	57	" .pushsection .text, \"ax\", @progbits\n"
	58	" .type my_tramp1, @function\n"
	59	" .globl my_tramp1\n"
	60	" my_tramp1:"
	61	" lgr %r1,%r15\n"
	62	" stmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	63	" stg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	64	" aghi %r15,"__stringify(-STACK_FRAME_OVERHEAD)"\n"
	65	" stg %r1,"__stringify(__SF_BACKCHAIN)"(%r15)\n"
	66	" lgr %r2,%r0\n"
	67	" brasl %r14,my_direct_func1\n"
	68	" aghi %r15,"__stringify(STACK_FRAME_OVERHEAD)"\n"
	69	" lmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	70	" lg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	71	" lgr %r1,%r0\n"
	72	" br %r1\n"
	73	" .size my_tramp1, .-my_tramp1\n"
	74	"\n"
	75	" .type my_tramp2, @function\n"
	76	" .globl my_tramp2\n"
	77	" my_tramp2:"
	78	" lgr %r1,%r15\n"
	79	" stmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	80	" stg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	81	" aghi %r15,"__stringify(-STACK_FRAME_OVERHEAD)"\n"
	82	" stg %r1,"__stringify(__SF_BACKCHAIN)"(%r15)\n"
	83	" lgr %r2,%r0\n"
	84	" brasl %r14,my_direct_func2\n"
	85	" aghi %r15,"__stringify(STACK_FRAME_OVERHEAD)"\n"
	86	" lmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	87	" lg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	88	" lgr %r1,%r0\n"
	89	" br %r1\n"
	90	" .size my_tramp2, .-my_tramp2\n"
	91	" .popsection\n"
	92	);
	93
	94	#endif /* CONFIG_S390 */
	95
	96	static unsigned long my_tramp = (unsigned long)my_tramp1;
	97	static unsigned long tramps[2] = {
	98	(unsigned long)my_tramp1,
	99	(unsigned long)my_tramp2,
	100	};
	101
	102	static struct ftrace_ops direct;
	103
	104	static int simple_thread(void *arg)
	105	{
	106	static int t;
	107	int ret = 0;
	108
	109	while (!kthread_should_stop()) {
	110	set_current_state(TASK_INTERRUPTIBLE);
	111	schedule_timeout(2 * HZ);
	112
	113	if (ret)
	114	continue;
	115	t ^= 1;
	116	ret = modify_ftrace_direct_multi(&direct, tramps[t]);
	117	if (!ret)
	118	my_tramp = tramps[t];
	119	WARN_ON_ONCE(ret);
	120	}
	121
	122	return 0;
	123	}
	124
	125	static struct task_struct *simple_tsk;
	126
	127	static int __init ftrace_direct_multi_init(void)
	128	{
	129	int ret;
	130
	131	ftrace_set_filter_ip(&direct, (unsigned long) wake_up_process, 0, 0);
	132	ftrace_set_filter_ip(&direct, (unsigned long) schedule, 0, 0);
	133
	134	ret = register_ftrace_direct_multi(&direct, my_tramp);
	135
	136	if (!ret)
	137	simple_tsk = kthread_run(simple_thread, NULL, "event-sample-fn");
	138	return ret;
	139	}
	140
	141	static void __exit ftrace_direct_multi_exit(void)
	142	{
	143	kthread_stop(simple_tsk);
	144	unregister_ftrace_direct_multi(&direct, my_tramp);
	145	}
	146
	147	module_init(ftrace_direct_multi_init);
	148	module_exit(ftrace_direct_multi_exit);
	149
	150	MODULE_AUTHOR("Jiri Olsa");
	151	MODULE_DESCRIPTION("Example use case of using modify_ftrace_direct_multi()");
	152	MODULE_LICENSE("GPL");

scripts/recordmcount.pl+1−1

@@ -219,7 +219,7 @@ if ($arch eq "x86_64") { · 218 unmodified lines
219		219
220	} elsif ($arch eq "s390" && $bits == 64) {	220	} elsif ($arch eq "s390" && $bits == 64) {
221	if ($cc =~ /-DCC_USING_HOTPATCH/) {	221	if ($cc =~ /-DCC_USING_HOTPATCH/) {
222	$mcount_regex = "^\\s([0-9a-fA-F]+):\\sc0 04 00 00 00 00\\sbrcl\\s0,[0-9a-f]+ <([^\+]*)>\$";	222	$mcount_regex = "^\\s([0-9a-fA-F]+):\\sc0 04 00 00 00 00\\s(bcrl\\s0,\|jgnop\\s)[0-9a-f]+ <([^\+])>\$";
223	$mcount_adjust = 0;	223	$mcount_adjust = 0;
224	}	224	}
225	$alignment = 8;	225	$alignment = 8;

sound/core/control_compat.c+3−0

 				  struct snd_ctl_elem_value *data,
 				  int type, int count)
 {
+	struct snd_ctl_elem_value32 __user *data32 = userdata;
 	int i, size;
 	if (type == SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
 		if (copy_to_user(valuep, data->value.bytes.data, size))
 			return -EFAULT;
 	}
+	if (copy_to_user(&data32->id, &data->id, sizeof(data32->id)))
+		return -EFAULT;
 	return 0;
 }

sound/core/oss/pcm_oss.c+25−12

@@ -147,7 +147,7 @@ snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, · 146 unmodified lines
147	*	147	*
148	* Return the maximum value for field PAR.	148	* Return the maximum value for field PAR.
149	*/	149	*/
150	static unsigned int	150	static int
151	snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,	151	snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
152	snd_pcm_hw_param_t var, int *dir)	152	snd_pcm_hw_param_t var, int *dir)
153	{	153	{
@@ -682,18 +682,24 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 528 unmodified lines
682	struct snd_pcm_hw_params *oss_params,	682	struct snd_pcm_hw_params *oss_params,
683	struct snd_pcm_hw_params *slave_params)	683	struct snd_pcm_hw_params *slave_params)
684	{	684	{
685	size_t s;	685	ssize_t s;
686	size_t oss_buffer_size, oss_period_size, oss_periods;	686	ssize_t oss_buffer_size;
687	size_t min_period_size, max_period_size;	687	ssize_t oss_period_size, oss_periods;
		688	ssize_t min_period_size, max_period_size;
688	struct snd_pcm_runtime *runtime = substream->runtime;	689	struct snd_pcm_runtime *runtime = substream->runtime;
689	size_t oss_frame_size;	690	size_t oss_frame_size;
690		691
691	oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *	692	oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *
692	params_channels(oss_params) / 8;	693	params_channels(oss_params) / 8;
693		694
		695	oss_buffer_size = snd_pcm_hw_param_value_max(slave_params,
		696	SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
		697	NULL);
		698	if (oss_buffer_size <= 0)
		699	return -EINVAL;
694	oss_buffer_size = snd_pcm_plug_client_size(substream,	700	oss_buffer_size = snd_pcm_plug_client_size(substream,
695	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;	701	oss_buffer_size * oss_frame_size);
696	if (!oss_buffer_size)	702	if (oss_buffer_size <= 0)
697	return -EINVAL;	703	return -EINVAL;
698	oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);	704	oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);
699	if (atomic_read(&substream->mmap_count)) {	705	if (atomic_read(&substream->mmap_count)) {
@@ -730,7 +736,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 30 unmodified lines
730		736
731	min_period_size = snd_pcm_plug_client_size(substream,	737	min_period_size = snd_pcm_plug_client_size(substream,
732	snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));	738	snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
733	if (min_period_size) {	739	if (min_period_size > 0) {
734	min_period_size *= oss_frame_size;	740	min_period_size *= oss_frame_size;
735	min_period_size = roundup_pow_of_two(min_period_size);	741	min_period_size = roundup_pow_of_two(min_period_size);
736	if (oss_period_size < min_period_size)	742	if (oss_period_size < min_period_size)
@@ -739,7 +745,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 2 unmodified lines
739		745
740	max_period_size = snd_pcm_plug_client_size(substream,	746	max_period_size = snd_pcm_plug_client_size(substream,
741	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));	747	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
742	if (max_period_size) {	748	if (max_period_size > 0) {
743	max_period_size *= oss_frame_size;	749	max_period_size *= oss_frame_size;
744	max_period_size = rounddown_pow_of_two(max_period_size);	750	max_period_size = rounddown_pow_of_two(max_period_size);
745	if (oss_period_size > max_period_size)	751	if (oss_period_size > max_period_size)
@@ -752,7 +758,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 6 unmodified lines
752	oss_periods = substream->oss.setup.periods;	758	oss_periods = substream->oss.setup.periods;
753		759
754	s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);	760	s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
755	if (runtime->oss.maxfrags && s > runtime->oss.maxfrags)	761	if (s > 0 && runtime->oss.maxfrags && s > runtime->oss.maxfrags)
756	s = runtime->oss.maxfrags;	762	s = runtime->oss.maxfrags;
757	if (oss_periods > s)	763	if (oss_periods > s)
758	oss_periods = s;	764	oss_periods = s;
@@ -878,8 +884,15 @@ static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream *substream) · 119 unmodified lines
878	err = -EINVAL;	884	err = -EINVAL;
879	goto failure;	885	goto failure;
880	}	886	}
881	choose_rate(substream, sparams, runtime->oss.rate);	887
882	snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_CHANNELS, runtime->oss.channels, NULL);	888	err = choose_rate(substream, sparams, runtime->oss.rate);
		889	if (err < 0)
		890	goto failure;
		891	err = snd_pcm_hw_param_near(substream, sparams,
		892	SNDRV_PCM_HW_PARAM_CHANNELS,
		893	runtime->oss.channels, NULL);
		894	if (err < 0)
		895	goto failure;
883		896
884	format = snd_pcm_oss_format_from(runtime->oss.format);	897	format = snd_pcm_oss_format_from(runtime->oss.format);
885		898
@@ -1956,7 +1969,7 @@ static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsign · 1070 unmodified lines
1956	if (runtime->oss.subdivision \|\| runtime->oss.fragshift)	1969	if (runtime->oss.subdivision \|\| runtime->oss.fragshift)
1957	return -EINVAL;	1970	return -EINVAL;
1958	fragshift = val & 0xffff;	1971	fragshift = val & 0xffff;
1959	if (fragshift >= 31)	1972	if (fragshift >= 25) /* should be large enough */
1960	return -EINVAL;	1973	return -EINVAL;
1961	runtime->oss.fragshift = fragshift;	1974	runtime->oss.fragshift = fragshift;
1962	runtime->oss.maxfrags = (val >> 16) & 0xffff;	1975	runtime->oss.maxfrags = (val >> 16) & 0xffff;

sound/pci/hda/patch_realtek.c+62−18

 /* for alc285_fixup_ideapad_s740_coef() */
 #include "ideapad_s740_helper.c"
-static void alc256_fixup_tongfang_reset_persistent_settings(struct hda_codec *codec,
+static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
-							    const struct hda_fixup *fix,
+	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
-							    int action)
+	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
+	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
+	{}
+};
+static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
+					   const struct hda_fixup *fix,
+					   int action)
 {
 	/*
-	* A certain other OS sets these coeffs to different values. On at least one TongFang
+	 * A certain other OS sets these coeffs to different values. On at least
-	* barebone these settings might survive even a cold reboot. So to restore a clean slate the
+	 * one TongFang barebone these settings might survive even a cold
-	* values are explicitly reset to default here. Without this, the external microphone is
+	 * reboot. So to restore a clean slate the values are explicitly reset
-	* always in a plugged-in state, while the internal microphone is always in an unplugged
+	 * to default here. Without this, the external microphone is always in a
-	* state, breaking the ability to use the internal microphone.
+	 * plugged-in state, while the internal microphone is always in an
-	*/
+	 * unplugged state, breaking the ability to use the internal microphone.
-	alc_write_coef_idx(codec, 0x24, 0x0000);
+	 */
-	alc_write_coef_idx(codec, 0x26, 0x0000);
+	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
-	alc_write_coef_idx(codec, 0x29, 0x3000);
-	alc_write_coef_idx(codec, 0x37, 0xfe05);
-	alc_write_coef_idx(codec, 0x45, 0x5089);
 }
 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
-	ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS,
+	ALC256_FIXUP_SET_COEF_DEFAULTS,
 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
 	ALC233_FIXUP_NO_AUDIO_JACK,
 };
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
 	},
-	[ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS] = {
+	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
 		.type = HDA_FIXUP_FUNC,
-		.v.func = alc256_fixup_tongfang_reset_persistent_settings,
+		.v.func = alc256_fixup_set_coef_defaults,
 	},
 	[ALC245_FIXUP_HP_GPIO_LED] = {
 		.type = HDA_FIXUP_FUNC,
 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
-	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS),
+	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
 	}
 }
+static void alc897_hp_automute_hook(struct hda_codec *codec,
+					 struct hda_jack_callback *jack)
+{
+	struct alc_spec *spec = codec->spec;
+	int vref;
+	snd_hda_gen_hp_automute(codec, jack);
+	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
+	snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+			    vref);
+}
+static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
+				     const struct hda_fixup *fix, int action)
+{
+	struct alc_spec *spec = codec->spec;
+	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
+	}
+}
 static const struct coef_fw alc668_coefs[] = {
 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
 	ALC668_FIXUP_HEADSET_MIC,
 	ALC668_FIXUP_MIC_DET_COEF,
+	ALC897_FIXUP_LENOVO_HEADSET_MIC,
+	ALC897_FIXUP_HEADSET_MIC_PIN,
 };
 static const struct hda_fixup alc662_fixups[] = {
 			{}
 		},
 	},
+	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc897_fixup_lenovo_headset_mic,
+	},
+	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
+		.type = HDA_FIXUP_PINS,
+		.v.pins = (const struct hda_pintbl[]) {
+			{ 0x1a, 0x03a11050 },
+			{ }
+		},
+		.chained = true,
+		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
+	},
 };
 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
+	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),

sound/soc/amd/yc/pci-acp6x.c+2−1

 {
 	struct acp6x_dev_data *adata;
 	struct platform_device_info pdevinfo[ACP6x_DEVS];
-	int ret, index;
+	int index = 0;
 	int val = 0x00;
 	u32 addr;
 	unsigned int irqflags;
+	int ret;
 	irqflags = IRQF_SHARED;
 	/* Yellow Carp device check */

sound/soc/codecs/rt5682.c+6−4

 	for (i = 0; i < RT5682_DAI_NUM_CLKS; ++i) {
 		struct clk_init_data init = { };
+		struct clk_parent_data parent_data;
+		const struct clk_hw *parent;
 		dai_clk_hw = &rt5682->dai_clks_hw[i];
 		case RT5682_DAI_WCLK_IDX:
 			/* Make MCLK the parent of WCLK */
 			if (rt5682->mclk) {
-				init.parent_data = &(struct clk_parent_data){
+				parent_data = (struct clk_parent_data){
 					.fw_name = "mclk",
 				};
+				init.parent_data = &parent_data;
 				init.num_parents = 1;
 			}
 			break;
 		case RT5682_DAI_BCLK_IDX:
 			/* Make WCLK the parent of BCLK */
-			init.parent_hws = &(const struct clk_hw *){
+			parent = &rt5682->dai_clks_hw[RT5682_DAI_WCLK_IDX];
-				&rt5682->dai_clks_hw[RT5682_DAI_WCLK_IDX]
+			init.parent_hws = &parent;
-			};
 			init.num_parents = 1;
 			break;
 		default:

sound/soc/codecs/rt5682s.c+6−4

 	for (i = 0; i < RT5682S_DAI_NUM_CLKS; ++i) {
 		struct clk_init_data init = { };
+		struct clk_parent_data parent_data;
+		const struct clk_hw *parent;
 		dai_clk_hw = &rt5682s->dai_clks_hw[i];
 		case RT5682S_DAI_WCLK_IDX:
 			/* Make MCLK the parent of WCLK */
 			if (rt5682s->mclk) {
-				init.parent_data = &(struct clk_parent_data){
+				parent_data = (struct clk_parent_data){
 					.fw_name = "mclk",
 				};
+				init.parent_data = &parent_data;
 				init.num_parents = 1;
 			}
 			break;
 		case RT5682S_DAI_BCLK_IDX:
 			/* Make WCLK the parent of BCLK */
-			init.parent_hws = &(const struct clk_hw *){
+			parent = &rt5682s->dai_clks_hw[RT5682S_DAI_WCLK_IDX];
-				&rt5682s->dai_clks_hw[RT5682S_DAI_WCLK_IDX]
+			init.parent_hws = &parent;
-			};
 			init.num_parents = 1;
 			break;
 		default:

sound/soc/codecs/wcd934x.c+93−33

@@ -3256,6 +3256,9 @@ static int wcd934x_compander_set(struct snd_kcontrol *kc, · 3255 unmodified lines
3256	int value = ucontrol->value.integer.value[0];	3256	int value = ucontrol->value.integer.value[0];
3257	int sel;	3257	int sel;
3258		3258
		3259	if (wcd->comp_enabled[comp] == value)
		3260	return 0;
		3261
3259	wcd->comp_enabled[comp] = value;	3262	wcd->comp_enabled[comp] = value;
3260	sel = value ? WCD934X_HPH_GAIN_SRC_SEL_COMPANDER :	3263	sel = value ? WCD934X_HPH_GAIN_SRC_SEL_COMPANDER :
3261	WCD934X_HPH_GAIN_SRC_SEL_REGISTER;	3264	WCD934X_HPH_GAIN_SRC_SEL_REGISTER;
@@ -3279,10 +3282,10 @@ static int wcd934x_compander_set(struct snd_kcontrol *kc, · 17 unmodified lines
3279	case COMPANDER_8:	3282	case COMPANDER_8:
3280	break;	3283	break;
3281	default:	3284	default:
3282	break;	3285	return 0;
3283	}	3286	}
3284		3287
3285	return 0;	3288	return 1;
3286	}	3289	}
3287		3290
3288	static int wcd934x_rx_hph_mode_get(struct snd_kcontrol *kc,	3291	static int wcd934x_rx_hph_mode_get(struct snd_kcontrol *kc,
@@ -3326,6 +3329,31 @@ static int slim_rx_mux_get(struct snd_kcontrol *kc, · 37 unmodified lines
3326	return 0;	3329	return 0;
3327	}	3330	}
3328		3331
		3332	static int slim_rx_mux_to_dai_id(int mux)
		3333	{
		3334	int aif_id;
		3335
		3336	switch (mux) {
		3337	case 1:
		3338	aif_id = AIF1_PB;
		3339	break;
		3340	case 2:
		3341	aif_id = AIF2_PB;
		3342	break;
		3343	case 3:
		3344	aif_id = AIF3_PB;
		3345	break;
		3346	case 4:
		3347	aif_id = AIF4_PB;
		3348	break;
		3349	default:
		3350	aif_id = -1;
		3351	break;
		3352	}
		3353
		3354	return aif_id;
		3355	}
		3356
3329	static int slim_rx_mux_put(struct snd_kcontrol *kc,	3357	static int slim_rx_mux_put(struct snd_kcontrol *kc,
3330	struct snd_ctl_elem_value *ucontrol)	3358	struct snd_ctl_elem_value *ucontrol)
3331	{	3359	{
@@ -3333,43 +3361,59 @@ static int slim_rx_mux_put(struct snd_kcontrol *kc, · 1 unmodified line
3333	struct wcd934x_codec *wcd = dev_get_drvdata(w->dapm->dev);	3361	struct wcd934x_codec *wcd = dev_get_drvdata(w->dapm->dev);
3334	struct soc_enum e = (struct soc_enum )kc->private_value;	3362	struct soc_enum e = (struct soc_enum )kc->private_value;
3335	struct snd_soc_dapm_update *update = NULL;	3363	struct snd_soc_dapm_update *update = NULL;
		3364	struct wcd934x_slim_ch ch, c;
3336	u32 port_id = w->shift;	3365	u32 port_id = w->shift;
		3366	bool found = false;
		3367	int mux_idx;
		3368	int prev_mux_idx = wcd->rx_port_value[port_id];
		3369	int aif_id;
3337		3370
3338	if (wcd->rx_port_value[port_id] == ucontrol->value.enumerated.item[0])	3371	mux_idx = ucontrol->value.enumerated.item[0];
3339	return 0;
3340		3372
3341	wcd->rx_port_value[port_id] = ucontrol->value.enumerated.item[0];	3373	if (mux_idx == prev_mux_idx)
		3374	return 0;
3342		3375
3343	switch (wcd->rx_port_value[port_id]) {	3376	switch(mux_idx) {
3344	case 0:	3377	case 0:
3345	list_del_init(&wcd->rx_chs[port_id].list);	3378	aif_id = slim_rx_mux_to_dai_id(prev_mux_idx);
3346	break;	3379	if (aif_id < 0)
3347	case 1:	3380	return 0;
3348	list_add_tail(&wcd->rx_chs[port_id].list,	3381
3349	&wcd->dai[AIF1_PB].slim_ch_list);	3382	list_for_each_entry_safe(ch, c, &wcd->dai[aif_id].slim_ch_list, list) {
3350	break;	3383	if (ch->port == port_id + WCD934X_RX_START) {
3351	case 2:	3384	found = true;
3352	list_add_tail(&wcd->rx_chs[port_id].list,	3385	list_del_init(&ch->list);
3353	&wcd->dai[AIF2_PB].slim_ch_list);	3386	break;
3354	break;	3387	}
3355	case 3:	3388	}
3356	list_add_tail(&wcd->rx_chs[port_id].list,	3389	if (!found)
3357	&wcd->dai[AIF3_PB].slim_ch_list);	3390	return 0;
		3391
3358	break;	3392	break;
3359	case 4:	3393	case 1 ... 4:
3360	list_add_tail(&wcd->rx_chs[port_id].list,	3394	aif_id = slim_rx_mux_to_dai_id(mux_idx);
3361	&wcd->dai[AIF4_PB].slim_ch_list);	3395	if (aif_id < 0)
		3396	return 0;
		3397
		3398	if (list_empty(&wcd->rx_chs[port_id].list)) {
		3399	list_add_tail(&wcd->rx_chs[port_id].list,
		3400	&wcd->dai[aif_id].slim_ch_list);
		3401	} else {
		3402	dev_err(wcd->dev ,"SLIM_RX%d PORT is busy\n", port_id);
		3403	return 0;
		3404	}
3362	break;	3405	break;
		3406
3363	default:	3407	default:
3364	dev_err(wcd->dev, "Unknown AIF %d\n",	3408	dev_err(wcd->dev, "Unknown AIF %d\n", mux_idx);
3365	wcd->rx_port_value[port_id]);
3366	goto err;	3409	goto err;
3367	}	3410	}
3368		3411
		3412	wcd->rx_port_value[port_id] = mux_idx;
3369	snd_soc_dapm_mux_update_power(w->dapm, kc, wcd->rx_port_value[port_id],	3413	snd_soc_dapm_mux_update_power(w->dapm, kc, wcd->rx_port_value[port_id],
3370	e, update);	3414	e, update);
3371		3415
3372	return 0;	3416	return 1;
3373	err:	3417	err:
3374	return -EINVAL;	3418	return -EINVAL;
3375	}	3419	}
@@ -3815,6 +3859,7 @@ static int slim_tx_mixer_put(struct snd_kcontrol *kc, · 439 unmodified lines
3815	struct soc_mixer_control *mixer =	3859	struct soc_mixer_control *mixer =
3816	(struct soc_mixer_control *)kc->private_value;	3860	(struct soc_mixer_control *)kc->private_value;
3817	int enable = ucontrol->value.integer.value[0];	3861	int enable = ucontrol->value.integer.value[0];
		3862	struct wcd934x_slim_ch ch, c;
3818	int dai_id = widget->shift;	3863	int dai_id = widget->shift;
3819	int port_id = mixer->shift;	3864	int port_id = mixer->shift;
3820		3865
@@ -3822,17 +3867,32 @@ static int slim_tx_mixer_put(struct snd_kcontrol *kc, · 1 unmodified line
3822	if (enable == wcd->tx_port_value[port_id])	3867	if (enable == wcd->tx_port_value[port_id])
3823	return 0;	3868	return 0;
3824		3869
3825	wcd->tx_port_value[port_id] = enable;	3870	if (enable) {
3826		3871	if (list_empty(&wcd->tx_chs[port_id].list)) {
3827	if (enable)	3872	list_add_tail(&wcd->tx_chs[port_id].list,
3828	list_add_tail(&wcd->tx_chs[port_id].list,	3873	&wcd->dai[dai_id].slim_ch_list);
3829	&wcd->dai[dai_id].slim_ch_list);	3874	} else {
3830	else	3875	dev_err(wcd->dev ,"SLIM_TX%d PORT is busy\n", port_id);
3831	list_del_init(&wcd->tx_chs[port_id].list);	3876	return 0;
		3877	}
		3878	} else {
		3879	bool found = false;
		3880
		3881	list_for_each_entry_safe(ch, c, &wcd->dai[dai_id].slim_ch_list, list) {
		3882	if (ch->port == port_id) {
		3883	found = true;
		3884	list_del_init(&wcd->tx_chs[port_id].list);
		3885	break;
		3886	}
		3887	}
		3888	if (!found)
		3889	return 0;
		3890	}
3832		3891
		3892	wcd->tx_port_value[port_id] = enable;
3833	snd_soc_dapm_mixer_update_power(widget->dapm, kc, enable, update);	3893	snd_soc_dapm_mixer_update_power(widget->dapm, kc, enable, update);
3834		3894
3835	return 0;	3895	return 1;
3836	}	3896	}
3837		3897
3838	static const struct snd_kcontrol_new aif1_slim_cap_mixer[] = {	3898	static const struct snd_kcontrol_new aif1_slim_cap_mixer[] = {

sound/soc/codecs/wsa881x.c+12−4

@@ -772,7 +772,8 @@ static int wsa881x_put_pa_gain(struct snd_kcontrol *kc, · 771 unmodified lines
772		772
773	usleep_range(1000, 1010);	773	usleep_range(1000, 1010);
774	}	774	}
775	return 0;	775
		776	return 1;
776	}	777	}
777		778
778	static int wsa881x_get_port(struct snd_kcontrol *kcontrol,	779	static int wsa881x_get_port(struct snd_kcontrol *kcontrol,
@@ -816,15 +817,22 @@ static int wsa881x_set_port(struct snd_kcontrol *kcontrol, · 37 unmodified lines
816	(struct soc_mixer_control *)kcontrol->private_value;	817	(struct soc_mixer_control *)kcontrol->private_value;
817	int portidx = mixer->reg;	818	int portidx = mixer->reg;
818		819
819	if (ucontrol->value.integer.value[0])	820	if (ucontrol->value.integer.value[0]) {
		821	if (data->port_enable[portidx])
		822	return 0;
		823
820	data->port_enable[portidx] = true;	824	data->port_enable[portidx] = true;
821	else	825	} else {
		826	if (!data->port_enable[portidx])
		827	return 0;
		828
822	data->port_enable[portidx] = false;	829	data->port_enable[portidx] = false;
		830	}
823		831
824	if (portidx == WSA881X_PORT_BOOST) /* Boost Switch */	832	if (portidx == WSA881X_PORT_BOOST) /* Boost Switch */
825	wsa881x_boost_ctrl(comp, data->port_enable[portidx]);	833	wsa881x_boost_ctrl(comp, data->port_enable[portidx]);
826		834
827	return 0;	835	return 1;
828	}	836	}
829		837
830	static const char * const smart_boost_lvl_text[] = {	838	static const char * const smart_boost_lvl_text[] = {

sound/soc/qcom/qdsp6/q6routing.c+5−3

 	struct session_data *session = &data->sessions[session_id];
 	if (ucontrol->value.integer.value[0]) {
+		if (session->port_id == be_id)
+			return 0;
 		session->port_id = be_id;
 		snd_soc_dapm_mixer_update_power(dapm, kcontrol, 1, update);
 	} else {
-		if (session->port_id == be_id) {
+		if (session->port_id == -1 || session->port_id != be_id)
-			session->port_id = -1;
 			return 0;
-		}
+		session->port_id = -1;
 		snd_soc_dapm_mixer_update_power(dapm, kcontrol, 0, update);
 	}

sound/soc/rockchip/rockchip_i2s_tdm.c+31−21

@@ -95,6 +95,7 @@ struct rk_i2s_tdm_dev { · 94 unmodified lines
95	spinlock_t lock; /* xfer lock */	95	spinlock_t lock; /* xfer lock */
96	bool has_playback;	96	bool has_playback;
97	bool has_capture;	97	bool has_capture;
		98	struct snd_soc_dai_driver *dai;
98	};	99	};
99		100
100	static int to_ch_num(unsigned int val)	101	static int to_ch_num(unsigned int val)
@@ -1310,19 +1311,14 @@ static const struct of_device_id rockchip_i2s_tdm_match[] = { · 1209 unmodified lines
1310	{},	1311	{},
1311	};	1312	};
1312		1313
1313	static struct snd_soc_dai_driver i2s_tdm_dai = {	1314	static const struct snd_soc_dai_driver i2s_tdm_dai = {
1314	.probe = rockchip_i2s_tdm_dai_probe,	1315	.probe = rockchip_i2s_tdm_dai_probe,
1315	.playback = {
1316	.stream_name = "Playback",
1317	},
1318	.capture = {
1319	.stream_name = "Capture",
1320	},
1321	.ops = &rockchip_i2s_tdm_dai_ops,	1316	.ops = &rockchip_i2s_tdm_dai_ops,
1322	};	1317	};
1323		1318
1324	static void rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm)	1319	static int rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm)
1325	{	1320	{
		1321	struct snd_soc_dai_driver *dai;
1326	struct property *dma_names;	1322	struct property *dma_names;
1327	const char *dma_name;	1323	const char *dma_name;
1328	u64 formats = (SNDRV_PCM_FMTBIT_S8 \| SNDRV_PCM_FMTBIT_S16_LE \|	1324	u64 formats = (SNDRV_PCM_FMTBIT_S8 \| SNDRV_PCM_FMTBIT_S16_LE \|
@@ -1337,19 +1333,33 @@ static void rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm) · 8 unmodified lines
1337	i2s_tdm->has_capture = true;	1333	i2s_tdm->has_capture = true;
1338	}	1334	}
1339		1335
		1336	dai = devm_kmemdup(i2s_tdm->dev, &i2s_tdm_dai,
		1337	sizeof(*dai), GFP_KERNEL);
		1338	if (!dai)
		1339	return -ENOMEM;
		1340
1340	if (i2s_tdm->has_playback) {	1341	if (i2s_tdm->has_playback) {
1341	i2s_tdm_dai.playback.channels_min = 2;	1342	dai->playback.stream_name = "Playback";
1342	i2s_tdm_dai.playback.channels_max = 8;	1343	dai->playback.channels_min = 2;
1343	i2s_tdm_dai.playback.rates = SNDRV_PCM_RATE_8000_192000;	1344	dai->playback.channels_max = 8;
1344	i2s_tdm_dai.playback.formats = formats;	1345	dai->playback.rates = SNDRV_PCM_RATE_8000_192000;
		1346	dai->playback.formats = formats;
1345	}	1347	}
1346		1348
1347	if (i2s_tdm->has_capture) {	1349	if (i2s_tdm->has_capture) {
1348	i2s_tdm_dai.capture.channels_min = 2;	1350	dai->capture.stream_name = "Capture";
1349	i2s_tdm_dai.capture.channels_max = 8;	1351	dai->capture.channels_min = 2;
1350	i2s_tdm_dai.capture.rates = SNDRV_PCM_RATE_8000_192000;	1352	dai->capture.channels_max = 8;
1351	i2s_tdm_dai.capture.formats = formats;	1353	dai->capture.rates = SNDRV_PCM_RATE_8000_192000;
		1354	dai->capture.formats = formats;
1352	}	1355	}
		1356
		1357	if (i2s_tdm->clk_trcm != TRCM_TXRX)
		1358	dai->symmetric_rate = 1;
		1359
		1360	i2s_tdm->dai = dai;
		1361
		1362	return 0;
1353	}	1363	}
1354		1364
1355	static int rockchip_i2s_tdm_path_check(struct rk_i2s_tdm_dev *i2s_tdm,	1365	static int rockchip_i2s_tdm_path_check(struct rk_i2s_tdm_dev *i2s_tdm,
@@ -1541,8 +1551,6 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 185 unmodified lines
1541	spin_lock_init(&i2s_tdm->lock);	1551	spin_lock_init(&i2s_tdm->lock);
1542	i2s_tdm->soc_data = (struct rk_i2s_soc_data *)of_id->data;	1552	i2s_tdm->soc_data = (struct rk_i2s_soc_data *)of_id->data;
1543		1553
1544	rockchip_i2s_tdm_init_dai(i2s_tdm);
1545
1546	i2s_tdm->frame_width = 64;	1554	i2s_tdm->frame_width = 64;
1547		1555
1548	i2s_tdm->clk_trcm = TRCM_TXRX;	1556	i2s_tdm->clk_trcm = TRCM_TXRX;
@@ -1555,8 +1563,10 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 6 unmodified lines
1555	}	1563	}
1556	i2s_tdm->clk_trcm = TRCM_RX;	1564	i2s_tdm->clk_trcm = TRCM_RX;
1557	}	1565	}
1558	if (i2s_tdm->clk_trcm != TRCM_TXRX)	1566
1559	i2s_tdm_dai.symmetric_rate = 1;	1567	ret = rockchip_i2s_tdm_init_dai(i2s_tdm);
		1568	if (ret)
		1569	return ret;
1560		1570
1561	i2s_tdm->grf = syscon_regmap_lookup_by_phandle(node, "rockchip,grf");	1571	i2s_tdm->grf = syscon_regmap_lookup_by_phandle(node, "rockchip,grf");
1562	if (IS_ERR(i2s_tdm->grf))	1572	if (IS_ERR(i2s_tdm->grf))
@@ -1678,7 +1688,7 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 115 unmodified lines
1678		1688
1679	ret = devm_snd_soc_register_component(&pdev->dev,	1689	ret = devm_snd_soc_register_component(&pdev->dev,
1680	&rockchip_i2s_tdm_component,	1690	&rockchip_i2s_tdm_component,
1681	&i2s_tdm_dai, 1);	1691	i2s_tdm->dai, 1);
1682		1692
1683	if (ret) {	1693	if (ret) {
1684	dev_err(&pdev->dev, "Could not register DAI\n");	1694	dev_err(&pdev->dev, "Could not register DAI\n");

sound/soc/sof/intel/hda-codec.c+9−5

 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
 #define IDISP_VID_INTEL	0x80860000
+#define CODEC_PROBE_RETRIES 3
 /* load the legacy HDA codec driver */
 static int request_codec_module(struct hda_codec *codec)
 	u32 hda_cmd = (address << 28) | (AC_NODE_ROOT << 20) |
 		(AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
 	u32 resp = -1;
-	int ret;
+	int ret, retry = 0;
+	do {
+		mutex_lock(&hbus->core.cmd_mutex);
+		snd_hdac_bus_send_cmd(&hbus->core, hda_cmd);
+		snd_hdac_bus_get_response(&hbus->core, address, &resp);
+		mutex_unlock(&hbus->core.cmd_mutex);
+	} while (resp == -1 && retry++ < CODEC_PROBE_RETRIES);
-	mutex_lock(&hbus->core.cmd_mutex);
-	snd_hdac_bus_send_cmd(&hbus->core, hda_cmd);
-	snd_hdac_bus_get_response(&hbus->core, address, &resp);
-	mutex_unlock(&hbus->core.cmd_mutex);
 	if (resp == -1)
 		return -EIO;
 	dev_dbg(sdev->dev, "HDA codec #%d probed OK: response: %x\n",

sound/soc/tegra/tegra210_adx.c+2−2

@@ -514,8 +514,8 @@ static int tegra210_adx_platform_remove(struct platform_device *pdev) · 513 unmodified lines
514	static const struct dev_pm_ops tegra210_adx_pm_ops = {	514	static const struct dev_pm_ops tegra210_adx_pm_ops = {
515	SET_RUNTIME_PM_OPS(tegra210_adx_runtime_suspend,	515	SET_RUNTIME_PM_OPS(tegra210_adx_runtime_suspend,
516	tegra210_adx_runtime_resume, NULL)	516	tegra210_adx_runtime_resume, NULL)
517	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	517	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
518	pm_runtime_force_resume)	518	pm_runtime_force_resume)
519	};	519	};
520		520
521	static struct platform_driver tegra210_adx_driver = {	521	static struct platform_driver tegra210_adx_driver = {

sound/soc/tegra/tegra210_amx.c+2−2

@@ -583,8 +583,8 @@ static int tegra210_amx_platform_remove(struct platform_device *pdev) · 582 unmodified lines
583	static const struct dev_pm_ops tegra210_amx_pm_ops = {	583	static const struct dev_pm_ops tegra210_amx_pm_ops = {
584	SET_RUNTIME_PM_OPS(tegra210_amx_runtime_suspend,	584	SET_RUNTIME_PM_OPS(tegra210_amx_runtime_suspend,
585	tegra210_amx_runtime_resume, NULL)	585	tegra210_amx_runtime_resume, NULL)
586	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	586	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
587	pm_runtime_force_resume)	587	pm_runtime_force_resume)
588	};	588	};
589		589
590	static struct platform_driver tegra210_amx_driver = {	590	static struct platform_driver tegra210_amx_driver = {

sound/soc/tegra/tegra210_mixer.c+2−2

@@ -666,8 +666,8 @@ static int tegra210_mixer_platform_remove(struct platform_device *pdev) · 665 unmodified lines
666	static const struct dev_pm_ops tegra210_mixer_pm_ops = {	666	static const struct dev_pm_ops tegra210_mixer_pm_ops = {
667	SET_RUNTIME_PM_OPS(tegra210_mixer_runtime_suspend,	667	SET_RUNTIME_PM_OPS(tegra210_mixer_runtime_suspend,
668	tegra210_mixer_runtime_resume, NULL)	668	tegra210_mixer_runtime_resume, NULL)
669	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	669	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
670	pm_runtime_force_resume)	670	pm_runtime_force_resume)
671	};	671	};
672		672
673	static struct platform_driver tegra210_mixer_driver = {	673	static struct platform_driver tegra210_mixer_driver = {

sound/soc/tegra/tegra210_mvc.c+4−4

@@ -164,7 +164,7 @@ static int tegra210_mvc_put_mute(struct snd_kcontrol *kcontrol, · 163 unmodified lines
164	if (err < 0)	164	if (err < 0)
165	goto end;	165	goto end;
166		166
167	return 1;	167	err = 1;
168		168
169	end:	169	end:
170	pm_runtime_put(cmpnt->dev);	170	pm_runtime_put(cmpnt->dev);
@@ -236,7 +236,7 @@ static int tegra210_mvc_put_vol(struct snd_kcontrol *kcontrol, · 65 unmodified lines
236	TEGRA210_MVC_VOLUME_SWITCH_MASK,	236	TEGRA210_MVC_VOLUME_SWITCH_MASK,
237	TEGRA210_MVC_VOLUME_SWITCH_TRIGGER);	237	TEGRA210_MVC_VOLUME_SWITCH_TRIGGER);
238		238
239	return 1;	239	err = 1;
240		240
241	end:	241	end:
242	pm_runtime_put(cmpnt->dev);	242	pm_runtime_put(cmpnt->dev);
@@ -639,8 +639,8 @@ static int tegra210_mvc_platform_remove(struct platform_device *pdev) · 396 unmodified lines
639	static const struct dev_pm_ops tegra210_mvc_pm_ops = {	639	static const struct dev_pm_ops tegra210_mvc_pm_ops = {
640	SET_RUNTIME_PM_OPS(tegra210_mvc_runtime_suspend,	640	SET_RUNTIME_PM_OPS(tegra210_mvc_runtime_suspend,
641	tegra210_mvc_runtime_resume, NULL)	641	tegra210_mvc_runtime_resume, NULL)
642	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	642	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
643	pm_runtime_force_resume)	643	pm_runtime_force_resume)
644	};	644	};
645		645
646	static struct platform_driver tegra210_mvc_driver = {	646	static struct platform_driver tegra210_mvc_driver = {

sound/soc/tegra/tegra210_sfc.c+2−2

@@ -3594,8 +3594,8 @@ static int tegra210_sfc_platform_remove(struct platform_device *pdev) · 3593 unmodified lines
3594	static const struct dev_pm_ops tegra210_sfc_pm_ops = {	3594	static const struct dev_pm_ops tegra210_sfc_pm_ops = {
3595	SET_RUNTIME_PM_OPS(tegra210_sfc_runtime_suspend,	3595	SET_RUNTIME_PM_OPS(tegra210_sfc_runtime_suspend,
3596	tegra210_sfc_runtime_resume, NULL)	3596	tegra210_sfc_runtime_resume, NULL)
3597	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	3597	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3598	pm_runtime_force_resume)	3598	pm_runtime_force_resume)
3599	};	3599	};
3600		3600
3601	static struct platform_driver tegra210_sfc_driver = {	3601	static struct platform_driver tegra210_sfc_driver = {

sound/usb/mixer_quirks.c+5−5

@@ -3016,11 +3016,11 @@ static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = { · 3015 unmodified lines
3016		3016
3017		3017
3018	static const struct snd_djm_device snd_djm_devices[] = {	3018	static const struct snd_djm_device snd_djm_devices[] = {
3019	SND_DJM_DEVICE(250mk2),	3019	[SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2),
3020	SND_DJM_DEVICE(750),	3020	[SND_DJM_750_IDX] = SND_DJM_DEVICE(750),
3021	SND_DJM_DEVICE(750mk2),	3021	[SND_DJM_850_IDX] = SND_DJM_DEVICE(850),
3022	SND_DJM_DEVICE(850),	3022	[SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2),
3023	SND_DJM_DEVICE(900nxs2)	3023	[SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2),
3024	};	3024	};
3025		3025
3026		3026

tools/perf/util/event.h+4−1

 /* perf sample has 16 bits size limit */
 #define PERF_SAMPLE_MAX_SIZE (1 << 16)
+/* number of register is bound by the number of bits in regs_dump::mask (64) */
+#define PERF_SAMPLE_REGS_CACHE_SIZE (8 * sizeof(u64))
 struct regs_dump {
 	u64 abi;
 	u64 mask;
 	u64 *regs;
 	/* Cached values/mask filled by first register access. */
-	u64 cache_regs[PERF_REGS_MAX];
+	u64 cache_regs[PERF_SAMPLE_REGS_CACHE_SIZE];
 	u64 cache_mask;
 };

tools/perf/util/intel-pt-decoder/intel-pt-decoder.c+55−30

 static bool intel_pt_fup_event(struct intel_pt_decoder *decoder)
 {
+	enum intel_pt_sample_type type = decoder->state.type;
 	bool ret = false;
+	decoder->state.type &= ~INTEL_PT_BRANCH;
 	if (decoder->set_fup_tx_flags) {
 		decoder->set_fup_tx_flags = false;
 		decoder->tx_flags = decoder->fup_tx_flags;
-		decoder->state.type = INTEL_PT_TRANSACTION;
+		decoder->state.type |= INTEL_PT_TRANSACTION;
 		if (decoder->fup_tx_flags & INTEL_PT_ABORT_TX)
 			decoder->state.type |= INTEL_PT_BRANCH;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.flags = decoder->fup_tx_flags;
-		return true;
+		ret = true;
 	}
 	if (decoder->set_fup_ptw) {
 		decoder->set_fup_ptw = false;
-		decoder->state.type = INTEL_PT_PTW;
+		decoder->state.type |= INTEL_PT_PTW;
 		decoder->state.flags |= INTEL_PT_FUP_IP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.ptw_payload = decoder->fup_ptw_payload;
-		return true;
+		ret = true;
 	}
 	if (decoder->set_fup_mwait) {
 		decoder->set_fup_mwait = false;
-		decoder->state.type = INTEL_PT_MWAIT_OP;
+		decoder->state.type |= INTEL_PT_MWAIT_OP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.mwait_payload = decoder->fup_mwait_payload;
 		ret = true;
 	}
 	if (decoder->set_fup_pwre) {
 		decoder->set_fup_pwre = false;
 		decoder->state.type |= INTEL_PT_PWR_ENTRY;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.pwre_payload = decoder->fup_pwre_payload;
 		ret = true;
 	}
 	if (decoder->set_fup_exstop) {
 		decoder->set_fup_exstop = false;
 		decoder->state.type |= INTEL_PT_EX_STOP;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
 		decoder->state.flags |= INTEL_PT_FUP_IP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		ret = true;
 	}
 	if (decoder->set_fup_bep) {
 		decoder->set_fup_bep = false;
 		decoder->state.type |= INTEL_PT_BLK_ITEMS;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
+		ret = true;
+	}
+	if (decoder->overflow) {
+		decoder->overflow = false;
+		if (!ret && !decoder->pge) {
+			if (decoder->hop) {
+				decoder->state.type = 0;
+				decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
+			}
+			decoder->pge = true;
+			decoder->state.type |= INTEL_PT_BRANCH | INTEL_PT_TRACE_BEGIN;
+			decoder->state.from_ip = 0;
+			decoder->state.to_ip = decoder->ip;
+			return true;
+		}
+	}
+	if (ret) {
 		decoder->state.from_ip = decoder->ip;
 		decoder->state.to_ip = 0;
-		ret = true;
+	} else {
+		decoder->state.type = type;
 	}
 	return ret;
 }
 	intel_pt_clear_tx_flags(decoder);
 	intel_pt_set_nr(decoder);
 	decoder->timestamp_insn_cnt = 0;
-	decoder->pkt_state = INTEL_PT_STATE_ERR_RESYNC;
+	decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
+	decoder->state.from_ip = decoder->ip;
+	decoder->ip = 0;
+	decoder->pge = false;
+	decoder->set_fup_tx_flags = false;
+	decoder->set_fup_ptw = false;
+	decoder->set_fup_mwait = false;
+	decoder->set_fup_pwre = false;
+	decoder->set_fup_exstop = false;
+	decoder->set_fup_bep = false;
 	decoder->overflow = true;
 	return -EOVERFLOW;
 }
 /* Hop mode: Ignore TNT, do not walk code, but get ip from FUPs and TIPs */
 static int intel_pt_hop_trace(struct intel_pt_decoder *decoder, bool *no_tip, int *err)
 {
+	*err = 0;
 	/* Leap from PSB to PSB, getting ip from FUP within PSB+ */
 	if (decoder->leap && !decoder->in_psb && decoder->packet.type != INTEL_PT_PSB) {
 		*err = intel_pt_scan_for_psb(decoder);
 		return HOP_IGNORE;
 	case INTEL_PT_TIP_PGD:
+		decoder->pge = false;
 		if (!decoder->packet.count) {
 			intel_pt_set_nr(decoder);
 			return HOP_IGNORE;
 		if (!decoder->packet.count)
 			return HOP_IGNORE;
 		intel_pt_set_ip(decoder);
-		if (intel_pt_fup_event(decoder))
+		if (decoder->set_fup_mwait || decoder->set_fup_pwre)
-			return HOP_RETURN;
+			*no_tip = true;
-		if (!decoder->branch_enable)
+		if (!decoder->branch_enable || !decoder->pge)
 			*no_tip = true;
 		if (*no_tip) {
 			decoder->state.type = INTEL_PT_INSTRUCTION;
 			decoder->state.from_ip = decoder->ip;
 			decoder->state.to_ip = 0;
+			intel_pt_fup_event(decoder);
 			return HOP_RETURN;
 		}
+		intel_pt_fup_event(decoder);
+		decoder->state.type |= INTEL_PT_INSTRUCTION | INTEL_PT_BRANCH;
 		*err = intel_pt_walk_fup_tip(decoder);
-		if (!*err)
+		if (!*err && decoder->state.to_ip)
 			decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
 		return HOP_RETURN;
 {
 	struct intel_pt_psb_info data = { .fup = false };
-	if (!decoder->branch_enable || !decoder->pge)
+	if (!decoder->branch_enable)
 		return false;
 	intel_pt_pkt_lookahead(decoder, intel_pt_psb_lookahead_cb, &data);
 		if (err)
 			return err;
 next:
+		err = 0;
 		if (decoder->cyc_threshold) {
 			if (decoder->sample_cyc && last_packet_type != INTEL_PT_CYC)
 				decoder->sample_cyc = false;
 		case INTEL_PT_TIP_PGE: {
 			decoder->pge = true;
+			decoder->overflow = false;
 			intel_pt_mtc_cyc_cnt_pge(decoder);
 			intel_pt_set_nr(decoder);
 			if (decoder->packet.count == 0) {
 				break;
 			}
 			intel_pt_set_last_ip(decoder);
-			if (!decoder->branch_enable) {
+			if (!decoder->branch_enable || !decoder->pge) {
 				decoder->ip = decoder->last_ip;
 				if (intel_pt_fup_event(decoder))
 					return 0;
 	decoder->set_fup_pwre = false;
 	decoder->set_fup_exstop = false;
 	decoder->set_fup_bep = false;
+	decoder->overflow = false;
 	if (!decoder->branch_enable) {
 		decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-		decoder->overflow = false;
 		decoder->state.type = 0; /* Do not have a sample */
 		return 0;
 	}
 		decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
 	else
 		decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-	decoder->overflow = false;
 	decoder->state.from_ip = 0;
 	decoder->state.to_ip = decoder->ip;
 	}
 	decoder->have_last_ip = true;
-	decoder->pkt_state = INTEL_PT_STATE_NO_IP;
+	decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
 	err = intel_pt_walk_psb(decoder);
 	if (err)
 	if (err) {
 		decoder->state.err = intel_pt_ext_err(err);
-		decoder->state.from_ip = decoder->ip;
+		if (err != -EOVERFLOW)
+			decoder->state.from_ip = decoder->ip;
 		intel_pt_update_sample_time(decoder);
 		decoder->sample_tot_cyc_cnt = decoder->tot_cyc_cnt;
 		intel_pt_set_nr(decoder);

tools/perf/util/intel-pt.c+1−0

@@ -2565,6 +2565,7 @@ static int intel_pt_run_decoder(struct intel_pt_queue ptq, u64 timestamp) · 2564 unmodified lines
2565	ptq->sync_switch = false;	2565	ptq->sync_switch = false;
2566	intel_pt_next_tid(pt, ptq);	2566	intel_pt_next_tid(pt, ptq);
2567	}	2567	}
		2568	ptq->timestamp = state->est_timestamp;
2568	if (pt->synth_opts.errors) {	2569	if (pt->synth_opts.errors) {
2569	err = intel_ptq_synth_error(ptq, state);	2570	err = intel_ptq_synth_error(ptq, state);
2570	if (err)	2571	if (err)

tools/perf/util/perf_regs.c+3−0

@@ -25,6 +25,9 @@ int perf_reg_value(u64 valp, struct regs_dump regs, int id) · 24 unmodified lines
25	int i, idx = 0;	25	int i, idx = 0;
26	u64 mask = regs->mask;	26	u64 mask = regs->mask;
27		27
		28	if ((u64)id >= PERF_SAMPLE_REGS_CACHE_SIZE)
		29	return -EINVAL;
		30
28	if (regs->cache_mask & (1ULL << id))	31	if (regs->cache_mask & (1ULL << id))
29	goto out;	32	goto out;
30		33

tools/perf/util/python.c+1−1

@@ -461,7 +461,7 @@ get_tracepoint_field(struct pyrf_event pevent, PyObject attr_name) · 460 unmodified lines
461	struct tep_event *tp_format;	461	struct tep_event *tp_format;
462		462
463	tp_format = trace_event__tp_format_id(evsel->core.attr.config);	463	tp_format = trace_event__tp_format_id(evsel->core.attr.config);
464	if (!tp_format)	464	if (IS_ERR_OR_NULL(tp_format))
465	return NULL;	465	return NULL;
466		466
467	evsel->tp_format = tp_format;	467	evsel->tp_format = tp_format;

tools/power/acpi/Makefile.config+1−0

@@ -69,6 +69,7 @@ KERNEL_INCLUDE := $(OUTPUT)include · 68 unmodified lines
69	ACPICA_INCLUDE := $(srctree)/../../../drivers/acpi/acpica	69	ACPICA_INCLUDE := $(srctree)/../../../drivers/acpi/acpica
70	CFLAGS += -D_LINUX -I$(KERNEL_INCLUDE) -I$(ACPICA_INCLUDE)	70	CFLAGS += -D_LINUX -I$(KERNEL_INCLUDE) -I$(ACPICA_INCLUDE)
71	CFLAGS += $(WARNINGS)	71	CFLAGS += $(WARNINGS)
		72	MKDIR = mkdir
72		73
73	ifeq ($(strip $(V)),false)	74	ifeq ($(strip $(V)),false)
74	QUIET=@	75	QUIET=@

tools/power/acpi/Makefile.rules+1−0

@@ -21,6 +21,7 @@ $(KERNEL_INCLUDE): · 20 unmodified lines
21		21
22	$(objdir)%.o: %.c $(KERNEL_INCLUDE)	22	$(objdir)%.o: %.c $(KERNEL_INCLUDE)
23	$(ECHO) " CC " $(subst $(OUTPUT),,$@)	23	$(ECHO) " CC " $(subst $(OUTPUT),,$@)
		24	$(QUIET) $(MKDIR) -p $(objdir) 2>/dev/null
24	$(QUIET) $(CC) -c $(CFLAGS) -o $@ $<	25	$(QUIET) $(CC) -c $(CFLAGS) -o $@ $<
25		26
26	all: $(OUTPUT)$(TOOL)	27	all: $(OUTPUT)$(TOOL)

tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c+20−0

@@ -33,6 +33,22 @@ noinline int bpf_testmod_loop_test(int n) · 32 unmodified lines
33	return sum;	33	return sum;
34	}	34	}
35		35
		36	__weak noinline struct file *bpf_testmod_return_ptr(int arg)
		37	{
		38	static struct file f = {};
		39
		40	switch (arg) {
		41	case 1: return (void )EINVAL; / user addr */
		42	case 2: return (void )0xcafe4a11; / user addr */
		43	case 3: return (void )-EINVAL; / canonical, but invalid */
		44	case 4: return (void )(1ull << 60); / non-canonical and invalid */
		45	case 5: return (void )~(1ull << 30); / trigger extable */
		46	case 6: return &f; /* valid addr */
		47	case 7: return (void )((long)&f \| 1); / kernel tricks */
		48	default: return NULL;
		49	}
		50	}
		51
36	noinline ssize_t	52	noinline ssize_t
37	bpf_testmod_test_read(struct file file, struct kobject kobj,	53	bpf_testmod_test_read(struct file file, struct kobject kobj,
38	struct bin_attribute *bin_attr,	54	struct bin_attribute *bin_attr,
@@ -43,6 +59,10 @@ bpf_testmod_test_read(struct file file, struct kobject kobj, · 4 unmodified lines
43	.off = off,	59	.off = off,
44	.len = len,	60	.len = len,
45	};	61	};
		62	int i = 1;
		63
		64	while (bpf_testmod_return_ptr(i))
		65	i++;
46		66
47	/* This is always true. Use the check to make sure the compiler	67	/* This is always true. Use the check to make sure the compiler
48	* doesn't remove bpf_testmod_loop_test.	68	* doesn't remove bpf_testmod_loop_test.

tools/testing/selftests/bpf/prog_tests/btf_skc_cls_ingress.c+14−2

 static void test_conn(void)
 {
-	int listen_fd = -1, cli_fd = -1, err;
+	int listen_fd = -1, cli_fd = -1, srv_fd = -1, err;
 	socklen_t addrlen = sizeof(srv_sa6);
 	int srv_port;
 	if (CHECK_FAIL(cli_fd == -1))
 		goto done;
+	srv_fd = accept(listen_fd, NULL, NULL);
+	if (CHECK_FAIL(srv_fd == -1))
+		goto done;
 	if (CHECK(skel->bss->listen_tp_sport != srv_port ||
 		  skel->bss->req_sk_sport != srv_port,
 		  "Unexpected sk src port",
 		close(listen_fd);
 	if (cli_fd != -1)
 		close(cli_fd);
+	if (srv_fd != -1)
+		close(srv_fd);
 }
 static void test_syncookie(void)
 {
-	int listen_fd = -1, cli_fd = -1, err;
+	int listen_fd = -1, cli_fd = -1, srv_fd = -1, err;
 	socklen_t addrlen = sizeof(srv_sa6);
 	int srv_port;
 	if (CHECK_FAIL(cli_fd == -1))
 		goto done;
+	srv_fd = accept(listen_fd, NULL, NULL);
+	if (CHECK_FAIL(srv_fd == -1))
+		goto done;
 	if (CHECK(skel->bss->listen_tp_sport != srv_port,
 		  "Unexpected tp src port",
 		  "listen_tp_sport:%u expected:%u\n",
 		close(listen_fd);
 	if (cli_fd != -1)
 		close(cli_fd);
+	if (srv_fd != -1)
+		close(srv_fd);
 }
 struct test {

tools/testing/selftests/bpf/progs/test_module_attach.c+12−0

@@ -87,6 +87,18 @@ int BPF_PROG(handle_fexit, · 86 unmodified lines
87	return 0;	87	return 0;
88	}	88	}
89		89
		90	SEC("fexit/bpf_testmod_return_ptr")
		91	int BPF_PROG(handle_fexit_ret, int arg, struct file *ret)
		92	{
		93	long buf = 0;
		94
		95	bpf_probe_read_kernel(&buf, 8, ret);
		96	bpf_probe_read_kernel(&buf, 8, (char *)ret + 256);
		97	(volatile long long )ret;
		98	(volatile int )&ret->f_mode;
		99	return 0;
		100	}
		101
90	__u32 fmod_ret_read_sz = 0;	102	__u32 fmod_ret_read_sz = 0;
91		103
92	SEC("fmod_ret/bpf_testmod_test_read")	104	SEC("fmod_ret/bpf_testmod_test_read")

tools/testing/selftests/bpf/test_verifier.c+1−1

@@ -54,7 +54,7 @@ · 53 unmodified lines
54	#define MAX_INSNS BPF_MAXINSNS	54	#define MAX_INSNS BPF_MAXINSNS
55	#define MAX_TEST_INSNS 1000000	55	#define MAX_TEST_INSNS 1000000
56	#define MAX_FIXUPS 8	56	#define MAX_FIXUPS 8
57	#define MAX_NR_MAPS 21	57	#define MAX_NR_MAPS 22
58	#define MAX_TEST_RUNS 8	58	#define MAX_TEST_RUNS 8
59	#define POINTER_VALUE 0xcafe4all	59	#define POINTER_VALUE 0xcafe4all
60	#define TEST_DATA_LEN 64	60	#define TEST_DATA_LEN 64

tools/testing/selftests/bpf/verifier/atomic_cmpxchg.c+86−0

@@ -138,6 +138,8 @@ · 137 unmodified lines
138	BPF_EXIT_INSN(),	138	BPF_EXIT_INSN(),
139	},	139	},
140	.result = ACCEPT,	140	.result = ACCEPT,
		141	.result_unpriv = REJECT,
		142	.errstr_unpriv = "R0 leaks addr into mem",
141	},	143	},
142	{	144	{
143	"Dest pointer in r0 - succeed",	145	"Dest pointer in r0 - succeed",
@@ -156,4 +158,88 @@ · 12 unmodified lines
156	BPF_EXIT_INSN(),	158	BPF_EXIT_INSN(),
157	},	159	},
158	.result = ACCEPT,	160	.result = ACCEPT,
		161	.result_unpriv = REJECT,
		162	.errstr_unpriv = "R0 leaks addr into mem",
		163	},
		164	{
		165	"Dest pointer in r0 - succeed, check 2",
		166	.insns = {
		167	/* r0 = &val */
		168	BPF_MOV64_REG(BPF_REG_0, BPF_REG_10),
		169	/* val = r0; */
		170	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -8),
		171	/* r5 = &val */
		172	BPF_MOV64_REG(BPF_REG_5, BPF_REG_10),
		173	/* r0 = atomic_cmpxchg(&val, r0, r5); */
		174	BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, BPF_REG_10, BPF_REG_5, -8),
		175	/* r1 = r0 /
		176	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
		177	/* exit(0); */
		178	BPF_MOV64_IMM(BPF_REG_0, 0),
		179	BPF_EXIT_INSN(),
		180	},
		181	.result = ACCEPT,
		182	.result_unpriv = REJECT,
		183	.errstr_unpriv = "R0 leaks addr into mem",
		184	},
		185	{
		186	"Dest pointer in r0 - succeed, check 3",
		187	.insns = {
		188	/* r0 = &val */
		189	BPF_MOV64_REG(BPF_REG_0, BPF_REG_10),
		190	/* val = r0; */
		191	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -8),
		192	/* r5 = &val */
		193	BPF_MOV64_REG(BPF_REG_5, BPF_REG_10),
		194	/* r0 = atomic_cmpxchg(&val, r0, r5); */
		195	BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, BPF_REG_10, BPF_REG_5, -8),
		196	/* exit(0); */
		197	BPF_MOV64_IMM(BPF_REG_0, 0),
		198	BPF_EXIT_INSN(),
		199	},
		200	.result = REJECT,
		201	.errstr = "invalid size of register fill",
		202	.errstr_unpriv = "R0 leaks addr into mem",
		203	},
		204	{
		205	"Dest pointer in r0 - succeed, check 4",
		206	.insns = {
		207	/* r0 = &val */
		208	BPF_MOV32_REG(BPF_REG_0, BPF_REG_10),
		209	/* val = r0; */
		210	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -8),
		211	/* r5 = &val */
		212	BPF_MOV32_REG(BPF_REG_5, BPF_REG_10),
		213	/* r0 = atomic_cmpxchg(&val, r0, r5); */
		214	BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, BPF_REG_10, BPF_REG_5, -8),
		215	/* r1 = r10 /
		216	BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_10, -8),
		217	/* exit(0); */
		218	BPF_MOV64_IMM(BPF_REG_0, 0),
		219	BPF_EXIT_INSN(),
		220	},
		221	.result = ACCEPT,
		222	.result_unpriv = REJECT,
		223	.errstr_unpriv = "R10 partial copy of pointer",
		224	},
		225	{
		226	"Dest pointer in r0 - succeed, check 5",
		227	.insns = {
		228	/* r0 = &val */
		229	BPF_MOV32_REG(BPF_REG_0, BPF_REG_10),
		230	/* val = r0; */
		231	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -8),
		232	/* r5 = &val */
		233	BPF_MOV32_REG(BPF_REG_5, BPF_REG_10),
		234	/* r0 = atomic_cmpxchg(&val, r0, r5); */
		235	BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, BPF_REG_10, BPF_REG_5, -8),
		236	/* r1 = r0 /
		237	BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, -8),
		238	/* exit(0); */
		239	BPF_MOV64_IMM(BPF_REG_0, 0),
		240	BPF_EXIT_INSN(),
		241	},
		242	.result = REJECT,
		243	.errstr = "R0 invalid mem access",
		244	.errstr_unpriv = "R10 partial copy of pointer",
159	},	245	},

tools/testing/selftests/bpf/verifier/atomic_fetch.c+94−0

@@ -1,3 +1,97 @@
		1	{
		2	"atomic dw/fetch and address leakage of (map ptr & -1) via stack slot",
		3	.insns = {
		4	BPF_LD_IMM64(BPF_REG_1, -1),
		5	BPF_LD_MAP_FD(BPF_REG_8, 0),
		6	BPF_LD_MAP_FD(BPF_REG_9, 0),
		7	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		8	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		9	BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
		10	BPF_ATOMIC_OP(BPF_DW, BPF_AND \| BPF_FETCH, BPF_REG_2, BPF_REG_1, 0),
		11	BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_2, 0),
		12	BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
		13	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
		14	BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
		15	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		16	BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_9, 0),
		17	BPF_MOV64_IMM(BPF_REG_0, 0),
		18	BPF_EXIT_INSN(),
		19	},
		20	.fixup_map_array_48b = { 2, 4 },
		21	.result = ACCEPT,
		22	.result_unpriv = REJECT,
		23	.errstr_unpriv = "leaking pointer from stack off -8",
		24	},
		25	{
		26	"atomic dw/fetch and address leakage of (map ptr & -1) via returned value",
		27	.insns = {
		28	BPF_LD_IMM64(BPF_REG_1, -1),
		29	BPF_LD_MAP_FD(BPF_REG_8, 0),
		30	BPF_LD_MAP_FD(BPF_REG_9, 0),
		31	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		32	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		33	BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
		34	BPF_ATOMIC_OP(BPF_DW, BPF_AND \| BPF_FETCH, BPF_REG_2, BPF_REG_1, 0),
		35	BPF_MOV64_REG(BPF_REG_9, BPF_REG_1),
		36	BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
		37	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
		38	BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
		39	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		40	BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_9, 0),
		41	BPF_MOV64_IMM(BPF_REG_0, 0),
		42	BPF_EXIT_INSN(),
		43	},
		44	.fixup_map_array_48b = { 2, 4 },
		45	.result = ACCEPT,
		46	.result_unpriv = REJECT,
		47	.errstr_unpriv = "leaking pointer from stack off -8",
		48	},
		49	{
		50	"atomic w/fetch and address leakage of (map ptr & -1) via stack slot",
		51	.insns = {
		52	BPF_LD_IMM64(BPF_REG_1, -1),
		53	BPF_LD_MAP_FD(BPF_REG_8, 0),
		54	BPF_LD_MAP_FD(BPF_REG_9, 0),
		55	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		56	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		57	BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
		58	BPF_ATOMIC_OP(BPF_W, BPF_AND \| BPF_FETCH, BPF_REG_2, BPF_REG_1, 0),
		59	BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_2, 0),
		60	BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
		61	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
		62	BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
		63	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		64	BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_9, 0),
		65	BPF_MOV64_IMM(BPF_REG_0, 0),
		66	BPF_EXIT_INSN(),
		67	},
		68	.fixup_map_array_48b = { 2, 4 },
		69	.result = REJECT,
		70	.errstr = "invalid size of register fill",
		71	},
		72	{
		73	"atomic w/fetch and address leakage of (map ptr & -1) via returned value",
		74	.insns = {
		75	BPF_LD_IMM64(BPF_REG_1, -1),
		76	BPF_LD_MAP_FD(BPF_REG_8, 0),
		77	BPF_LD_MAP_FD(BPF_REG_9, 0),
		78	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		79	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		80	BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_9, 0),
		81	BPF_ATOMIC_OP(BPF_W, BPF_AND \| BPF_FETCH, BPF_REG_2, BPF_REG_1, 0),
		82	BPF_MOV64_REG(BPF_REG_9, BPF_REG_1),
		83	BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
		84	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
		85	BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
		86	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		87	BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_9, 0),
		88	BPF_MOV64_IMM(BPF_REG_0, 0),
		89	BPF_EXIT_INSN(),
		90	},
		91	.fixup_map_array_48b = { 2, 4 },
		92	.result = REJECT,
		93	.errstr = "invalid size of register fill",
		94	},
1	#define __ATOMIC_FETCH_OP_TEST(src_reg, dst_reg, operand1, op, operand2, expect) \	95	#define __ATOMIC_FETCH_OP_TEST(src_reg, dst_reg, operand1, op, operand2, expect) \
2	{ \	96	{ \
3	"atomic fetch " #op ", src=" #dst_reg " dst=" #dst_reg, \	97	"atomic fetch " #op ", src=" #dst_reg " dst=" #dst_reg, \

tools/testing/selftests/bpf/verifier/search_pruning.c+71−0

@@ -132,6 +132,77 @@ · 131 unmodified lines
132	.result = REJECT,	132	.result = REJECT,
133	.prog_type = BPF_PROG_TYPE_TRACEPOINT,	133	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
134	},	134	},
		135	{
		136	"precision tracking for u32 spill/fill",
		137	.insns = {
		138	BPF_MOV64_REG(BPF_REG_7, BPF_REG_1),
		139	BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32),
		140	BPF_MOV32_IMM(BPF_REG_6, 32),
		141	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		142	BPF_MOV32_IMM(BPF_REG_6, 4),
		143	/* Additional insns to introduce a pruning point. */
		144	BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32),
		145	BPF_MOV64_IMM(BPF_REG_3, 0),
		146	BPF_MOV64_IMM(BPF_REG_3, 0),
		147	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		148	BPF_MOV64_IMM(BPF_REG_3, 0),
		149	/* u32 spill/fill */
		150	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_6, -8),
		151	BPF_LDX_MEM(BPF_W, BPF_REG_8, BPF_REG_10, -8),
		152	/* out-of-bound map value access for r6=32 */
		153	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, 0),
		154	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		155	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16),
		156	BPF_LD_MAP_FD(BPF_REG_1, 0),
		157	BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
		158	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
		159	BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_8),
		160	BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
		161	BPF_MOV64_IMM(BPF_REG_0, 0),
		162	BPF_EXIT_INSN(),
		163	},
		164	.fixup_map_hash_8b = { 15 },
		165	.result = REJECT,
		166	.errstr = "R0 min value is outside of the allowed memory range",
		167	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
		168	},
		169	{
		170	"precision tracking for u32 spills, u64 fill",
		171	.insns = {
		172	BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32),
		173	BPF_MOV64_REG(BPF_REG_6, BPF_REG_0),
		174	BPF_MOV32_IMM(BPF_REG_7, 0xffffffff),
		175	/* Additional insns to introduce a pruning point. */
		176	BPF_MOV64_IMM(BPF_REG_3, 1),
		177	BPF_MOV64_IMM(BPF_REG_3, 1),
		178	BPF_MOV64_IMM(BPF_REG_3, 1),
		179	BPF_MOV64_IMM(BPF_REG_3, 1),
		180	BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32),
		181	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
		182	BPF_MOV64_IMM(BPF_REG_3, 1),
		183	BPF_ALU32_IMM(BPF_DIV, BPF_REG_3, 0),
		184	/* u32 spills, u64 fill */
		185	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_6, -4),
		186	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_7, -8),
		187	BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_10, -8),
		188	/* if r8 != X goto pc+1 r8 known in fallthrough branch */
		189	BPF_JMP_IMM(BPF_JNE, BPF_REG_8, 0xffffffff, 1),
		190	BPF_MOV64_IMM(BPF_REG_3, 1),
		191	/* if r8 == X goto pc+1 condition always true on first
		192	* traversal, so starts backtracking to mark r8 as requiring
		193	* precision. r7 marked as needing precision. r6 not marked
		194	* since it's not tracked.
		195	*/
		196	BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 0xffffffff, 1),
		197	/* fails if r8 correctly marked unknown after fill. */
		198	BPF_ALU32_IMM(BPF_DIV, BPF_REG_3, 0),
		199	BPF_MOV64_IMM(BPF_REG_0, 0),
		200	BPF_EXIT_INSN(),
		201	},
		202	.result = REJECT,
		203	.errstr = "div by zero",
		204	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
		205	},
135	{	206	{
136	"allocated_stack",	207	"allocated_stack",
137	.insns = {	208	.insns = {

tools/testing/selftests/bpf/verifier/spill_fill.c+32−0

@@ -175,6 +175,38 @@ · 174 unmodified lines
175	.errstr = "invalid access to packet",	175	.errstr = "invalid access to packet",
176	.prog_type = BPF_PROG_TYPE_SCHED_CLS,	176	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
177	},	177	},
		178	{
		179	"Spill u32 const scalars. Refill as u64. Offset to skb->data",
		180	.insns = {
		181	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		182	offsetof(struct __sk_buff, data)),
		183	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		184	offsetof(struct __sk_buff, data_end)),
		185	/* r6 = 0 */
		186	BPF_MOV32_IMM(BPF_REG_6, 0),
		187	/* r7 = 20 */
		188	BPF_MOV32_IMM(BPF_REG_7, 20),
		189	/* (u32 )(r10 -4) = r6 */
		190	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_6, -4),
		191	/* (u32 )(r10 -8) = r7 */
		192	BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_7, -8),
		193	/* r4 = (u64 )(r10 -8) */
		194	BPF_LDX_MEM(BPF_H, BPF_REG_4, BPF_REG_10, -8),
		195	/* r0 = r2 */
		196	BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
		197	/* r0 += r4 R0=pkt R2=pkt R3=pkt_end R4=inv,umax=65535 */
		198	BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_4),
		199	/* if (r0 > r3) R0=pkt,umax=65535 R2=pkt R3=pkt_end R4=inv,umax=65535 */
		200	BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 1),
		201	/* r0 = (u32 )r2 R0=pkt,umax=65535 R2=pkt R3=pkt_end R4=inv20 */
		202	BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_2, 0),
		203	BPF_MOV64_IMM(BPF_REG_0, 0),
		204	BPF_EXIT_INSN(),
		205	},
		206	.result = REJECT,
		207	.errstr = "invalid access to packet",
		208	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
		209	},
178	{	210	{
179	"Spill a u32 const scalar. Refill as u16 from fp-6. Offset to skb->data",	211	"Spill a u32 const scalar. Refill as u16 from fp-6. Offset to skb->data",
180	.insns = {	212	.insns = {

tools/testing/selftests/bpf/verifier/value_ptr_arith.c+23−0

@@ -1077,6 +1077,29 @@ · 1076 unmodified lines
1077	.errstr = "R0 invalid mem access 'inv'",	1077	.errstr = "R0 invalid mem access 'inv'",
1078	.errstr_unpriv = "R0 pointer -= pointer prohibited",	1078	.errstr_unpriv = "R0 pointer -= pointer prohibited",
1079	},	1079	},
		1080	{
		1081	"map access: trying to leak tained dst reg",
		1082	.insns = {
		1083	BPF_MOV64_IMM(BPF_REG_0, 0),
		1084	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
		1085	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		1086	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
		1087	BPF_LD_MAP_FD(BPF_REG_1, 0),
		1088	BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
		1089	BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
		1090	BPF_EXIT_INSN(),
		1091	BPF_MOV64_REG(BPF_REG_2, BPF_REG_0),
		1092	BPF_MOV32_IMM(BPF_REG_1, 0xFFFFFFFF),
		1093	BPF_MOV32_REG(BPF_REG_1, BPF_REG_1),
		1094	BPF_ALU64_REG(BPF_SUB, BPF_REG_2, BPF_REG_1),
		1095	BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, 0),
		1096	BPF_MOV64_IMM(BPF_REG_0, 0),
		1097	BPF_EXIT_INSN(),
		1098	},
		1099	.fixup_map_array_48b = { 4 },
		1100	.result = REJECT,
		1101	.errstr = "math between map_value pointer and 4294967295 is not allowed",
		1102	},
1080	{	1103	{
1081	"32bit pkt_ptr -= scalar",	1104	"32bit pkt_ptr -= scalar",
1082	.insns = {	1105	.insns = {

tools/testing/selftests/damon/.gitignore+2−0

@@ -0,0 +1,2 @@
	1	# SPDX-License-Identifier: GPL-2.0-only
	2	huge_count_read_write

tools/testing/selftests/damon/Makefile+5−2

@@ -1,7 +1,10 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	# Makefile for damon selftests	2	# Makefile for damon selftests
3		3
4	TEST_FILES = _chk_dependency.sh	4	TEST_GEN_FILES += huge_count_read_write
5	TEST_PROGS = debugfs_attrs.sh	5
		6	TEST_FILES = _chk_dependency.sh _debugfs_common.sh
		7	TEST_PROGS = debugfs_attrs.sh debugfs_schemes.sh debugfs_target_ids.sh
		8	TEST_PROGS += debugfs_empty_targets.sh debugfs_huge_count_read_write.sh
6		9
7	include ../lib.mk	10	include ../lib.mk

tools/testing/selftests/damon/_debugfs_common.sh+52−0

@@ -0,0 +1,52 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	test_write_result() {
	5	file=$1
	6	content=$2
	7	orig_content=$3
	8	expect_reason=$4
	9	expected=$5
	10
	11	echo "$content" > "$file"
	12	if [ $? -ne "$expected" ]
	13	then
	14	echo "writing $content to $file doesn't return $expected"
	15	echo "expected because: $expect_reason"
	16	echo "$orig_content" > "$file"
	17	exit 1
	18	fi
	19	}
	20
	21	test_write_succ() {
	22	test_write_result "$1" "$2" "$3" "$4" 0
	23	}
	24
	25	test_write_fail() {
	26	test_write_result "$1" "$2" "$3" "$4" 1
	27	}
	28
	29	test_content() {
	30	file=$1
	31	orig_content=$2
	32	expected=$3
	33	expect_reason=$4
	34
	35	content=$(cat "$file")
	36	if [ "$content" != "$expected" ]
	37	then
	38	echo "reading $file expected $expected but $content"
	39	echo "expected because: $expect_reason"
	40	echo "$orig_content" > "$file"
	41	exit 1
	42	fi
	43	}
	44
	45	source ./_chk_dependency.sh
	46
	47	damon_onoff="$DBGFS/monitor_on"
	48	if [ $(cat "$damon_onoff") = "on" ]
	49	then
	50	echo "monitoring is on"
	51	exit $ksft_skip
	52	fi

tools/testing/selftests/damon/debugfs_attrs.sh+1−72

@@ -1,48 +1,7 @@
1	#!/bin/bash	1	#!/bin/bash
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
4	test_write_result() {	4	source _debugfs_common.sh
5	file=$1
6	content=$2
7	orig_content=$3
8	expect_reason=$4
9	expected=$5
10
11	echo "$content" > "$file"
12	if [ $? -ne "$expected" ]
13	then
14	echo "writing $content to $file doesn't return $expected"
15	echo "expected because: $expect_reason"
16	echo "$orig_content" > "$file"
17	exit 1
18	fi
19	}
20
21	test_write_succ() {
22	test_write_result "$1" "$2" "$3" "$4" 0
23	}
24
25	test_write_fail() {
26	test_write_result "$1" "$2" "$3" "$4" 1
27	}
28
29	test_content() {
30	file=$1
31	orig_content=$2
32	expected=$3
33	expect_reason=$4
34
35	content=$(cat "$file")
36	if [ "$content" != "$expected" ]
37	then
38	echo "reading $file expected $expected but $content"
39	echo "expected because: $expect_reason"
40	echo "$orig_content" > "$file"
41	exit 1
42	fi
43	}
44
45	source ./_chk_dependency.sh
46		5
47	# Test attrs file	6	# Test attrs file
48	# ===============	7	# ===============
@@ -56,33 +15,3 @@ test_write_fail "$file" "1 2 3 5 4" "$orig_content" \ · 7 unmodified lines
56	"min_nr_regions > max_nr_regions"	15	"min_nr_regions > max_nr_regions"
57	test_content "$file" "$orig_content" "1 2 3 4 5" "successfully written"	16	test_content "$file" "$orig_content" "1 2 3 4 5" "successfully written"
58	echo "$orig_content" > "$file"	17	echo "$orig_content" > "$file"
59
60	# Test schemes file
61	# =================
62
63	file="$DBGFS/schemes"
64	orig_content=$(cat "$file")
65
66	test_write_succ "$file" "1 2 3 4 5 6 4 0 0 0 1 2 3 1 100 3 2 1" \
67	"$orig_content" "valid input"
68	test_write_fail "$file" "1 2
69	3 4 5 6 3 0 0 0 1 2 3 1 100 3 2 1" "$orig_content" "multi lines"
70	test_write_succ "$file" "" "$orig_content" "disabling"
71	echo "$orig_content" > "$file"
72
73	# Test target_ids file
74	# ====================
75
76	file="$DBGFS/target_ids"
77	orig_content=$(cat "$file")
78
79	test_write_succ "$file" "1 2 3 4" "$orig_content" "valid input"
80	test_write_succ "$file" "1 2 abc 4" "$orig_content" "still valid input"
81	test_content "$file" "$orig_content" "1 2" "non-integer was there"
82	test_write_succ "$file" "abc 2 3" "$orig_content" "the file allows wrong input"
83	test_content "$file" "$orig_content" "" "wrong input written"
84	test_write_succ "$file" "" "$orig_content" "empty input"
85	test_content "$file" "$orig_content" "" "empty input written"
86	echo "$orig_content" > "$file"
87
88	echo "PASS"

tools/testing/selftests/damon/debugfs_empty_targets.sh+13−0

@@ -0,0 +1,13 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	source _debugfs_common.sh
	5
	6	# Test empty targets case
	7	# =======================
	8
	9	orig_target_ids=$(cat "$DBGFS/target_ids")
	10	echo "" > "$DBGFS/target_ids"
	11	orig_monitor_on=$(cat "$DBGFS/monitor_on")
	12	test_write_fail "$DBGFS/monitor_on" "on" "orig_monitor_on" "empty target ids"
	13	echo "$orig_target_ids" > "$DBGFS/target_ids"

tools/testing/selftests/damon/debugfs_huge_count_read_write.sh+22−0

@@ -0,0 +1,22 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	source _debugfs_common.sh
	5
	6	# Test huge count read write
	7	# ==========================
	8
	9	dmesg -C
	10
	11	for file in "$DBGFS/"*
	12	do
	13	./huge_count_read_write "$file"
	14	done
	15
	16	if dmesg \| grep -q WARNING
	17	then
	18	dmesg
	19	exit 1
	20	else
	21	exit 0
	22	fi

tools/testing/selftests/damon/debugfs_schemes.sh+19−0

@@ -0,0 +1,19 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	source _debugfs_common.sh
	5
	6	# Test schemes file
	7	# =================
	8
	9	file="$DBGFS/schemes"
	10	orig_content=$(cat "$file")
	11
	12	test_write_succ "$file" "1 2 3 4 5 6 4 0 0 0 1 2 3 1 100 3 2 1" \
	13	"$orig_content" "valid input"
	14	test_write_fail "$file" "1 2
	15	3 4 5 6 3 0 0 0 1 2 3 1 100 3 2 1" "$orig_content" "multi lines"
	16	test_write_succ "$file" "" "$orig_content" "disabling"
	17	test_write_fail "$file" "2 1 2 1 10 1 3 10 1 1 1 1 1 1 1 1 2 3" \
	18	"$orig_content" "wrong condition ranges"
	19	echo "$orig_content" > "$file"

tools/testing/selftests/damon/debugfs_target_ids.sh+19−0

@@ -0,0 +1,19 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	source _debugfs_common.sh
	5
	6	# Test target_ids file
	7	# ====================
	8
	9	file="$DBGFS/target_ids"
	10	orig_content=$(cat "$file")
	11
	12	test_write_succ "$file" "1 2 3 4" "$orig_content" "valid input"
	13	test_write_succ "$file" "1 2 abc 4" "$orig_content" "still valid input"
	14	test_content "$file" "$orig_content" "1 2" "non-integer was there"
	15	test_write_succ "$file" "abc 2 3" "$orig_content" "the file allows wrong input"
	16	test_content "$file" "$orig_content" "" "wrong input written"
	17	test_write_succ "$file" "" "$orig_content" "empty input"
	18	test_content "$file" "$orig_content" "" "empty input written"
	19	echo "$orig_content" > "$file"

tools/testing/selftests/damon/huge_count_read_write.c+39−0

@@ -0,0 +1,39 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Author: SeongJae Park <sj@kernel.org>
	4	*/
	5
	6	#include <fcntl.h>
	7	#include <stdlib.h>
	8	#include <unistd.h>
	9	#include <stdio.h>
	10
	11	void write_read_with_huge_count(char *file)
	12	{
	13	int filedesc = open(file, O_RDWR);
	14	char buf[25];
	15	int ret;
	16
	17	printf("%s %s\n", __func__, file);
	18	if (filedesc < 0) {
	19	fprintf(stderr, "failed opening %s\n", file);
	20	exit(1);
	21	}
	22
	23	write(filedesc, "", 0xfffffffful);
	24	perror("after write: ");
	25	ret = read(filedesc, buf, 0xfffffffful);
	26	perror("after read: ");
	27	close(filedesc);
	28	}
	29
	30	int main(int argc, char *argv[])
	31	{
	32	if (argc != 2) {
	33	fprintf(stderr, "Usage: %s <file>\n", argv[0]);
	34	exit(1);
	35	}
	36	write_read_with_huge_count(argv[1]);
	37
	38	return 0;
	39	}

tools/testing/selftests/drivers/net/mlxsw/rif_mac_profiles_occ.sh+30−0

@@ -72,6 +72,35 @@ rif_mac_profile_replacement_test() · 71 unmodified lines
72	ip link set $h1.10 address $h1_10_mac	72	ip link set $h1.10 address $h1_10_mac
73	}	73	}
74		74
		75	rif_mac_profile_consolidation_test()
		76	{
		77	local count=$1; shift
		78	local h1_20_mac
		79
		80	RET=0
		81
		82	if [[ $count -eq 1 ]]; then
		83	return
		84	fi
		85
		86	h1_20_mac=$(mac_get $h1.20)
		87
		88	# Set the MAC of $h1.20 to that of $h1.10 and confirm that they are
		89	# using the same MAC profile.
		90	ip link set $h1.20 address 00:11:11:11:11:11
		91	check_err $?
		92
		93	occ=$(devlink -j resource show $DEVLINK_DEV \
		94	\| jq '.[][][] \| select(.name=="rif_mac_profiles") \|.["occ"]')
		95
		96	[[ $occ -eq $((count - 1)) ]]
		97	check_err $? "MAC profile occupancy did not decrease"
		98
		99	log_test "RIF MAC profile consolidation"
		100
		101	ip link set $h1.20 address $h1_20_mac
		102	}
		103
75	rif_mac_profile_shared_replacement_test()	104	rif_mac_profile_shared_replacement_test()
76	{	105	{
77	local count=$1; shift	106	local count=$1; shift
@@ -104,6 +133,7 @@ rif_mac_profile_edit_test() · 26 unmodified lines
104	create_max_rif_mac_profiles $count	133	create_max_rif_mac_profiles $count
105		134
106	rif_mac_profile_replacement_test	135	rif_mac_profile_replacement_test
		136	rif_mac_profile_consolidation_test $count
107	rif_mac_profile_shared_replacement_test $count	137	rif_mac_profile_shared_replacement_test $count
108	}	138	}
109		139

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

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	/x86_64/svm_int_ctl_test	30	/x86_64/svm_int_ctl_test
31	/x86_64/sync_regs_test	31	/x86_64/sync_regs_test
32	/x86_64/tsc_msrs_test	32	/x86_64/tsc_msrs_test
		33	/x86_64/userspace_io_test
33	/x86_64/userspace_msr_exit_test	34	/x86_64/userspace_msr_exit_test
34	/x86_64/vmx_apic_access_test	35	/x86_64/vmx_apic_access_test
35	/x86_64/vmx_close_while_nested_test	36	/x86_64/vmx_close_while_nested_test

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

@@ -59,6 +59,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/vmx_preemption_timer_test · 58 unmodified lines
59	TEST_GEN_PROGS_x86_64 += x86_64/svm_vmcall_test	59	TEST_GEN_PROGS_x86_64 += x86_64/svm_vmcall_test
60	TEST_GEN_PROGS_x86_64 += x86_64/svm_int_ctl_test	60	TEST_GEN_PROGS_x86_64 += x86_64/svm_int_ctl_test
61	TEST_GEN_PROGS_x86_64 += x86_64/sync_regs_test	61	TEST_GEN_PROGS_x86_64 += x86_64/sync_regs_test
		62	TEST_GEN_PROGS_x86_64 += x86_64/userspace_io_test
62	TEST_GEN_PROGS_x86_64 += x86_64/userspace_msr_exit_test	63	TEST_GEN_PROGS_x86_64 += x86_64/userspace_msr_exit_test
63	TEST_GEN_PROGS_x86_64 += x86_64/vmx_apic_access_test	64	TEST_GEN_PROGS_x86_64 += x86_64/vmx_apic_access_test
64	TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test	65	TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test

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

@@ -71,6 +71,15 @@ enum vm_guest_mode { · 70 unmodified lines
71		71
72	#endif	72	#endif
73		73
		74	#if defined(__x86_64__)
		75	unsigned long vm_compute_max_gfn(struct kvm_vm *vm);
		76	#else
		77	static inline unsigned long vm_compute_max_gfn(struct kvm_vm *vm)
		78	{
		79	return ((1ULL << vm->pa_bits) >> vm->page_shift) - 1;
		80	}
		81	#endif
		82
74	#define MIN_PAGE_SIZE (1U << MIN_PAGE_SHIFT)	83	#define MIN_PAGE_SIZE (1U << MIN_PAGE_SHIFT)
75	#define PTES_PER_MIN_PAGE ptes_per_page(MIN_PAGE_SIZE)	84	#define PTES_PER_MIN_PAGE ptes_per_page(MIN_PAGE_SIZE)
76		85

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

@@ -302,7 +302,7 @@ struct kvm_vm *vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm) · 301 unmodified lines
302	(1ULL << (vm->va_bits - 1)) >> vm->page_shift);	302	(1ULL << (vm->va_bits - 1)) >> vm->page_shift);
303		303
304	/* Limit physical addresses to PA-bits. */	304	/* Limit physical addresses to PA-bits. */
305	vm->max_gfn = ((1ULL << vm->pa_bits) >> vm->page_shift) - 1;	305	vm->max_gfn = vm_compute_max_gfn(vm);
306		306
307	/* Allocate and setup memory for guest. */	307	/* Allocate and setup memory for guest. */
308	vm->vpages_mapped = sparsebit_alloc();	308	vm->vpages_mapped = sparsebit_alloc();

tools/testing/selftests/kvm/lib/x86_64/processor.c+68−0

@@ -1431,3 +1431,71 @@ struct kvm_cpuid2 vcpu_get_supported_hv_cpuid(struct kvm_vm vm, uint32_t vcpui · 1430 unmodified lines
1431		1431
1432	return cpuid;	1432	return cpuid;
1433	}	1433	}
		1434
		1435	#define X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx 0x68747541
		1436	#define X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx 0x444d4163
		1437	#define X86EMUL_CPUID_VENDOR_AuthenticAMD_edx 0x69746e65
		1438
		1439	static inline unsigned x86_family(unsigned int eax)
		1440	{
		1441	unsigned int x86;
		1442
		1443	x86 = (eax >> 8) & 0xf;
		1444
		1445	if (x86 == 0xf)
		1446	x86 += (eax >> 20) & 0xff;
		1447
		1448	return x86;
		1449	}
		1450
		1451	unsigned long vm_compute_max_gfn(struct kvm_vm *vm)
		1452	{
		1453	const unsigned long num_ht_pages = 12 << (30 - vm->page_shift); /* 12 GiB */
		1454	unsigned long ht_gfn, max_gfn, max_pfn;
		1455	uint32_t eax, ebx, ecx, edx, max_ext_leaf;
		1456
		1457	max_gfn = (1ULL << (vm->pa_bits - vm->page_shift)) - 1;
		1458
		1459	/* Avoid reserved HyperTransport region on AMD processors. */
		1460	eax = ecx = 0;
		1461	cpuid(&eax, &ebx, &ecx, &edx);
		1462	if (ebx != X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx \|\|
		1463	ecx != X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx \|\|
		1464	edx != X86EMUL_CPUID_VENDOR_AuthenticAMD_edx)
		1465	return max_gfn;
		1466
		1467	/* On parts with <40 physical address bits, the area is fully hidden */
		1468	if (vm->pa_bits < 40)
		1469	return max_gfn;
		1470
		1471	/* Before family 17h, the HyperTransport area is just below 1T. */
		1472	ht_gfn = (1 << 28) - num_ht_pages;
		1473	eax = 1;
		1474	cpuid(&eax, &ebx, &ecx, &edx);
		1475	if (x86_family(eax) < 0x17)
		1476	goto done;
		1477
		1478	/*
		1479	* Otherwise it's at the top of the physical address space, possibly
		1480	* reduced due to SME by bits 11:6 of CPUID[0x8000001f].EBX. Use
		1481	* the old conservative value if MAXPHYADDR is not enumerated.
		1482	*/
		1483	eax = 0x80000000;
		1484	cpuid(&eax, &ebx, &ecx, &edx);
		1485	max_ext_leaf = eax;
		1486	if (max_ext_leaf < 0x80000008)
		1487	goto done;
		1488
		1489	eax = 0x80000008;
		1490	cpuid(&eax, &ebx, &ecx, &edx);
		1491	max_pfn = (1ULL << ((eax & 0xff) - vm->page_shift)) - 1;
		1492	if (max_ext_leaf >= 0x8000001f) {
		1493	eax = 0x8000001f;
		1494	cpuid(&eax, &ebx, &ecx, &edx);
		1495	max_pfn >>= (ebx >> 6) & 0x3f;
		1496	}
		1497
		1498	ht_gfn = max_pfn - num_ht_pages;
		1499	done:
		1500	return min(max_gfn, ht_gfn - 1);
		1501	}

tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c+1−1

@@ -75,7 +75,7 @@ static void l1_guest_code(struct svm_test_data *svm) · 74 unmodified lines
75	vmcb->control.int_ctl &= ~V_INTR_MASKING_MASK;	75	vmcb->control.int_ctl &= ~V_INTR_MASKING_MASK;
76		76
77	/* No intercepts for real and virtual interrupts */	77	/* No intercepts for real and virtual interrupts */
78	vmcb->control.intercept &= ~(1ULL << INTERCEPT_INTR \| INTERCEPT_VINTR);	78	vmcb->control.intercept &= ~(BIT(INTERCEPT_INTR) \| BIT(INTERCEPT_VINTR));
79		79
80	/* Make a virtual interrupt VINTR_IRQ_NUMBER pending */	80	/* Make a virtual interrupt VINTR_IRQ_NUMBER pending */
81	vmcb->control.int_ctl \|= V_IRQ_MASK \| (0x1 << V_INTR_PRIO_SHIFT);	81	vmcb->control.int_ctl \|= V_IRQ_MASK \| (0x1 << V_INTR_PRIO_SHIFT);

tools/testing/selftests/kvm/x86_64/userspace_io_test.c+114−0

@@ -0,0 +1,114 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <fcntl.h>
	3	#include <stdio.h>
	4	#include <stdlib.h>
	5	#include <string.h>
	6	#include <sys/ioctl.h>
	7
	8	#include "test_util.h"
	9
	10	#include "kvm_util.h"
	11	#include "processor.h"
	12
	13	#define VCPU_ID 1
	14
	15	static void guest_ins_port80(uint8_t *buffer, unsigned int count)
	16	{
	17	unsigned long end;
	18
	19	if (count == 2)
	20	end = (unsigned long)buffer + 1;
	21	else
	22	end = (unsigned long)buffer + 8192;
	23
	24	asm volatile("cld; rep; insb" : "+D"(buffer), "+c"(count) : "d"(0x80) : "memory");
	25	GUEST_ASSERT_1(count == 0, count);
	26	GUEST_ASSERT_2((unsigned long)buffer == end, buffer, end);
	27	}
	28
	29	static void guest_code(void)
	30	{
	31	uint8_t buffer[8192];
	32	int i;
	33
	34	/*
	35	* Special case tests. main() will adjust RCX 2 => 1 and 3 => 8192 to
	36	* test that KVM doesn't explode when userspace modifies the "count" on
	37	* a userspace I/O exit. KVM isn't required to play nice with the I/O
	38	* itself as KVM doesn't support manipulating the count, it just needs
	39	* to not explode or overflow a buffer.
	40	*/
	41	guest_ins_port80(buffer, 2);
	42	guest_ins_port80(buffer, 3);
	43
	44	/* Verify KVM fills the buffer correctly when not stuffing RCX. */
	45	memset(buffer, 0, sizeof(buffer));
	46	guest_ins_port80(buffer, 8192);
	47	for (i = 0; i < 8192; i++)
	48	GUEST_ASSERT_2(buffer[i] == 0xaa, i, buffer[i]);
	49
	50	GUEST_DONE();
	51	}
	52
	53	int main(int argc, char *argv[])
	54	{
	55	struct kvm_regs regs;
	56	struct kvm_run *run;
	57	struct kvm_vm *vm;
	58	struct ucall uc;
	59	int rc;
	60
	61	/* Tell stdout not to buffer its content */
	62	setbuf(stdout, NULL);
	63
	64	/* Create VM */
	65	vm = vm_create_default(VCPU_ID, 0, guest_code);
	66	run = vcpu_state(vm, VCPU_ID);
	67
	68	memset(&regs, 0, sizeof(regs));
	69
	70	while (1) {
	71	rc = _vcpu_run(vm, VCPU_ID);
	72
	73	TEST_ASSERT(rc == 0, "vcpu_run failed: %d\n", rc);
	74	TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
	75	"Unexpected exit reason: %u (%s),\n",
	76	run->exit_reason,
	77	exit_reason_str(run->exit_reason));
	78
	79	if (get_ucall(vm, VCPU_ID, &uc))
	80	break;
	81
	82	TEST_ASSERT(run->io.port == 0x80,
	83	"Expected I/O at port 0x80, got port 0x%x\n", run->io.port);
	84
	85	/*
	86	* Modify the rep string count in RCX: 2 => 1 and 3 => 8192.
	87	* Note, this abuses KVM's batching of rep string I/O to avoid
	88	* getting stuck in an infinite loop. That behavior isn't in
	89	* scope from a testing perspective as it's not ABI in any way,
	90	* i.e. it really is abusing internal KVM knowledge.
	91	*/
	92	vcpu_regs_get(vm, VCPU_ID, &regs);
	93	if (regs.rcx == 2)
	94	regs.rcx = 1;
	95	if (regs.rcx == 3)
	96	regs.rcx = 8192;
	97	memset((void *)run + run->io.data_offset, 0xaa, 4096);
	98	vcpu_regs_set(vm, VCPU_ID, &regs);
	99	}
	100
	101	switch (uc.cmd) {
	102	case UCALL_DONE:
	103	break;
	104	case UCALL_ABORT:
	105	TEST_FAIL("%s at %s:%ld : argN+1 = 0x%lx, argN+2 = 0x%lx",
	106	(const char *)uc.args[0], __FILE__, uc.args[1],
	107	uc.args[2], uc.args[3]);
	108	default:
	109	TEST_FAIL("Unknown ucall %lu", uc.cmd);
	110	}
	111
	112	kvm_vm_free(vm);
	113	return 0;
	114	}

tools/testing/selftests/net/fcnal-test.sh+34−11

 	ip netns del ${NSC} >/dev/null 2>&1
 }
+cleanup_vrf_dup()
+{
+	ip link del ${NSA_DEV2} >/dev/null 2>&1
+	ip netns pids ${NSC} | xargs kill 2>/dev/null
+	ip netns del ${NSC} >/dev/null 2>&1
+}
+setup_vrf_dup()
+{
+	# some VRF tests use ns-C which has the same config as
+	# ns-B but for a device NOT in the VRF
+	create_ns ${NSC} "-" "-"
+	connect_ns ${NSA} ${NSA_DEV2} ${NSA_IP}/24 ${NSA_IP6}/64 \
+		   ${NSC} ${NSC_DEV} ${NSB_IP}/24 ${NSB_IP6}/64
+}
 setup()
 {
 	local with_vrf=${1}
 		ip -netns ${NSB} ro add ${VRF_IP}/32 via ${NSA_IP} dev ${NSB_DEV}
 		ip -netns ${NSB} -6 ro add ${VRF_IP6}/128 via ${NSA_IP6} dev ${NSB_DEV}
-		# some VRF tests use ns-C which has the same config as
-		# ns-B but for a device NOT in the VRF
-		create_ns ${NSC} "-" "-"
-		connect_ns ${NSA} ${NSA_DEV2} ${NSA_IP}/24 ${NSA_IP6}/64 \
-			   ${NSC} ${NSC_DEV} ${NSB_IP}/24 ${NSB_IP6}/64
 	else
 		ip -netns ${NSA} ro add ${NSB_LO_IP}/32 via ${NSB_IP} dev ${NSA_DEV}
 		ip -netns ${NSA} ro add ${NSB_LO_IP6}/128 via ${NSB_IP6} dev ${NSA_DEV}
 	log_test_addr ${a} $? 1 "Global server, local connection"
 	# run MD5 tests
+	setup_vrf_dup
 	ipv4_tcp_md5
+	cleanup_vrf_dup
 	#
 	# enable VRF global server
 	for a in ${NSA_IP} ${VRF_IP}
 	do
 		log_start
+		show_hint "Socket not bound to VRF, but address is in VRF"
 		run_cmd nettest -s -R -P icmp -l ${a} -b
-		log_test_addr ${a} $? 0 "Raw socket bind to local address"
+		log_test_addr ${a} $? 1 "Raw socket bind to local address"
 		log_start
 		run_cmd nettest -s -R -P icmp -l ${a} -I ${NSA_DEV} -b
 		log_start
 		show_hint "Fails since VRF device does not support linklocal or multicast"
 		run_cmd ${ping6} -c1 -w1 ${a}
-		log_test_addr ${a} $? 2 "ping out, VRF bind"
+		log_test_addr ${a} $? 1 "ping out, VRF bind"
 	done
 	for a in ${NSB_IP6} ${NSB_LO_IP6} ${NSB_LINKIP6}%${NSA_DEV} ${MCAST}%${NSA_DEV}
 	log_test_addr ${a} $? 1 "Global server, local connection"
 	# run MD5 tests
+	setup_vrf_dup
 	ipv6_tcp_md5
+	cleanup_vrf_dup
 	#
 	# enable VRF global server
 	run_cmd nettest -6 -s -l ${a} -I ${NSA_DEV} -t1 -b
 	log_test_addr ${a} $? 0 "TCP socket bind to local address after device bind"
+	# Sadly, the kernel allows binding a socket to a device and then
+	# binding to an address not on the device. So this test passes
+	# when it really should not
 	a=${NSA_LO_IP6}
 	log_start
-	show_hint "Should fail with 'Cannot assign requested address'"
+	show_hint "Tecnically should fail since address is not on device but kernel allows"
 	run_cmd nettest -6 -s -l ${a} -I ${NSA_DEV} -t1 -b
-	log_test_addr ${a} $? 1 "TCP socket bind to out of scope local address"
+	log_test_addr ${a} $? 0 "TCP socket bind to out of scope local address"
 }
 ipv6_addr_bind_vrf()
 	run_cmd nettest -6 -s -l ${a} -I ${NSA_DEV} -t1 -b
 	log_test_addr ${a} $? 0 "TCP socket bind to local address with device bind"
+	# Sadly, the kernel allows binding a socket to a device and then
+	# binding to an address not on the device. The only restriction
+	# is that the address is valid in the L3 domain. So this test
+	# passes when it really should not
 	a=${VRF_IP6}
 	log_start
+	show_hint "Tecnically should fail since address is not on device but kernel allows"
 	run_cmd nettest -6 -s -l ${a} -I ${NSA_DEV} -t1 -b
-	log_test_addr ${a} $? 1 "TCP socket bind to VRF address with device bind"
+	log_test_addr ${a} $? 0 "TCP socket bind to VRF address with device bind"
 	a=${NSA_LO_IP6}
 	log_start

tools/testing/selftests/net/forwarding/forwarding.config.sample+2−0

@@ -13,6 +13,8 @@ NETIFS[p5]=veth4 · 12 unmodified lines
13	NETIFS[p6]=veth5	13	NETIFS[p6]=veth5
14	NETIFS[p7]=veth6	14	NETIFS[p7]=veth6
15	NETIFS[p8]=veth7	15	NETIFS[p8]=veth7
		16	NETIFS[p9]=veth8
		17	NETIFS[p10]=veth9
16		18
17	# Port that does not have a cable connected.	19	# Port that does not have a cable connected.
18	NETIF_NO_CABLE=eth8	20	NETIF_NO_CABLE=eth8

tools/testing/selftests/net/icmp_redirect.sh+1−1

@@ -311,7 +311,7 @@ check_exception() · 310 unmodified lines
311	ip -netns h1 ro get ${H1_VRF_ARG} ${H2_N2_IP} \| \	311	ip -netns h1 ro get ${H1_VRF_ARG} ${H2_N2_IP} \| \
312	grep -E -v 'mtu\|redirected' \| grep -q "cache"	312	grep -E -v 'mtu\|redirected' \| grep -q "cache"
313	fi	313	fi
314	log_test $? 0 "IPv4: ${desc}"	314	log_test $? 0 "IPv4: ${desc}" 0
315		315
316	# No PMTU info for test "redirect" and "mtu exception plus redirect"	316	# No PMTU info for test "redirect" and "mtu exception plus redirect"
317	if [ "$with_redirect" = "yes" ] && [ "$desc" != "redirect exception plus mtu" ]; then	317	if [ "$with_redirect" = "yes" ] && [ "$desc" != "redirect exception plus mtu" ]; then

tools/testing/selftests/net/toeplitz.c+1−1

@@ -498,7 +498,7 @@ static void parse_opts(int argc, char **argv) · 497 unmodified lines
498	bool have_toeplitz = false;	498	bool have_toeplitz = false;
499	int index, c;	499	int index, c;
500		500
501	while ((c = getopt_long(argc, argv, "46C:d:i:k:r:stT:u:v", long_options, &index)) != -1) {	501	while ((c = getopt_long(argc, argv, "46C:d:i:k:r:stT:uv", long_options, &index)) != -1) {
502	switch (c) {	502	switch (c) {
503	case '4':	503	case '4':
504	cfg_family = AF_INET;	504	cfg_family = AF_INET;

@@ -134,23 +134,23 @@ · 133 unmodified lines
134	type = "critical";	134	type = "critical";
135	};	135	};
136	};	136	};
137	};
138		137
139	cpu_cooling_maps: cooling-maps {	138	cpu_cooling_maps: cooling-maps {
140	map0 {	139	map0 {
141	trip = <&cpu_passive>;	140	trip = <&cpu_passive>;
142	cooling-device = <&cpu0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	141	cooling-device = <&cpu0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
143	<&cpu1 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	142	<&cpu1 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
144	<&cpu2 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	143	<&cpu2 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
145	<&cpu3 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;	144	<&cpu3 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;
146	};	145	};
147		146
148	map1 {	147	map1 {
149	trip = <&cpu_hot>;	148	trip = <&cpu_hot>;
150	cooling-device = <&cpu0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	149	cooling-device = <&cpu0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
151	<&cpu1 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	150	<&cpu1 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
152	<&cpu2 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,	151	<&cpu2 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,
153	<&cpu3 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;	152	<&cpu3 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;
		153	};
154	};	154	};
155	};	155	};
156	};	156	};