lael-labs/linux

.mailmap+1−0

@@ -27,6 +27,7 @@ Alan Cox <alan@lxorguk.ukuu.org.uk> · 26 unmodified lines
27	Alan Cox <root@hraefn.swansea.linux.org.uk>	27	Alan Cox <root@hraefn.swansea.linux.org.uk>
28	Aleksandar Markovic <aleksandar.markovic@mips.com> <aleksandar.markovic@imgtec.com>	28	Aleksandar Markovic <aleksandar.markovic@mips.com> <aleksandar.markovic@imgtec.com>
29	Aleksey Gorelov <aleksey_gorelov@phoenix.com>	29	Aleksey Gorelov <aleksey_gorelov@phoenix.com>
		30	Alex Williamson <alex@shazbot.org> <alex.williamson@redhat.com>
30	Alexander Lobakin <alobakin@pm.me> <alobakin@dlink.ru>	31	Alexander Lobakin <alobakin@pm.me> <alobakin@dlink.ru>
31	Alexander Lobakin <alobakin@pm.me> <alobakin@marvell.com>	32	Alexander Lobakin <alobakin@pm.me> <alobakin@marvell.com>
32	Alexander Lobakin <alobakin@pm.me> <bloodyreaper@yandex.ru>	33	Alexander Lobakin <alobakin@pm.me> <bloodyreaper@yandex.ru>

Documentation/devicetree/bindings/phy/fsl,imx8mq-usb-phy.yaml+3−1

@@ -142,7 +142,9 @@ allOf: · 141 unmodified lines
142	required:	142	required:
143	- orientation-switch	143	- orientation-switch
144	then:	144	then:
145	$ref: /schemas/usb/usb-switch.yaml#	145	allOf:
		146	- $ref: /schemas/usb/usb-switch.yaml#
		147	- $ref: /schemas/usb/usb-switch-ports.yaml#
146		148
147	unevaluatedProperties: false	149	unevaluatedProperties: false
148		150

Documentation/devicetree/bindings/phy/qcom,sc8280xp-qmp-ufs-phy.yaml+4−0

           - enum:
               - qcom,qcs8300-qmp-ufs-phy
           - const: qcom,sa8775p-qmp-ufs-phy
+      - items:
+          - enum:
+              - qcom,kaanapali-qmp-ufs-phy
+          - const: qcom,sm8750-qmp-ufs-phy
       - enum:
           - qcom,msm8996-qmp-ufs-phy
           - qcom,msm8998-qmp-ufs-phy

Documentation/devicetree/bindings/phy/samsung,usb3-drd-phy.yaml+3−1

           contains:
             const: google,gs101-usb31drd-phy
     then:
-      $ref: /schemas/usb/usb-switch.yaml#
+      allOf:
+        - $ref: /schemas/usb/usb-switch.yaml#
+        - $ref: /schemas/usb/usb-switch-ports.yaml#
       properties:
         clocks:

Documentation/devicetree/bindings/serial/renesas,scif.yaml+1−0

@@ -197,6 +197,7 @@ allOf: · 196 unmodified lines
197	- renesas,rcar-gen2-scif	197	- renesas,rcar-gen2-scif
198	- renesas,rcar-gen3-scif	198	- renesas,rcar-gen3-scif
199	- renesas,rcar-gen4-scif	199	- renesas,rcar-gen4-scif
		200	- renesas,rcar-gen5-scif
200	then:	201	then:
201	properties:	202	properties:
202	interrupts:	203	interrupts:

Documentation/devicetree/bindings/spi/spi-cadence.yaml+8−3

 properties:
   compatible:
-    enum:
+    oneOf:
-      - cdns,spi-r1p6
+      - enum:
-      - xlnx,zynq-spi-r1p6
+          - xlnx,zynq-spi-r1p6
+      - items:
+          - enum:
+              - xlnx,zynqmp-spi-r1p6
+              - xlnx,versal-net-spi-r1p6
+          - const: cdns,spi-r1p6
   reg:
     maxItems: 1

Documentation/devicetree/bindings/spi/spi-rockchip.yaml+1−0

@@ -34,6 +34,7 @@ properties: · 33 unmodified lines
34	- rockchip,rk3328-spi	34	- rockchip,rk3328-spi
35	- rockchip,rk3368-spi	35	- rockchip,rk3368-spi
36	- rockchip,rk3399-spi	36	- rockchip,rk3399-spi
		37	- rockchip,rk3506-spi
37	- rockchip,rk3528-spi	38	- rockchip,rk3528-spi
38	- rockchip,rk3562-spi	39	- rockchip,rk3562-spi
39	- rockchip,rk3568-spi	40	- rockchip,rk3568-spi

Documentation/devicetree/bindings/ufs/qcom,sm8650-ufshc.yaml+2−0

     compatible:
       contains:
         enum:
+          - qcom,kaanapali-ufshc
           - qcom,sm8650-ufshc
           - qcom,sm8750-ufshc
   required:
   compatible:
     items:
       - enum:
+          - qcom,kaanapali-ufshc
           - qcom,sm8650-ufshc
           - qcom,sm8750-ufshc
       - const: qcom,ufshc

Documentation/devicetree/bindings/usb/fcs,fsa4480.yaml+1−0

@@ -76,6 +76,7 @@ required: · 75 unmodified lines
76		76
77	allOf:	77	allOf:
78	- $ref: usb-switch.yaml#	78	- $ref: usb-switch.yaml#
		79	- $ref: usb-switch-ports.yaml#
79		80
80	additionalProperties: false	81	additionalProperties: false
81		82

Documentation/devicetree/bindings/usb/fsl,imx8mp-dwc3.yaml+9−1

   - reg
   - "#address-cells"
   - "#size-cells"
-  - dma-ranges
   - ranges
   - clocks
   - clock-names
   - interrupts
   - power-domains
+allOf:
+  - if:
+      properties:
+        compatible:
+          const: fsl,imx8mp-dwc3
+    then:
+      required:
+        - dma-ranges
 additionalProperties: false
 examples:

Documentation/devicetree/bindings/usb/gpio-sbu-mux.yaml+1−0

@@ -52,6 +52,7 @@ required: · 51 unmodified lines
52		52
53	allOf:	53	allOf:
54	- $ref: usb-switch.yaml#	54	- $ref: usb-switch.yaml#
		55	- $ref: usb-switch-ports.yaml#
55	- if:	56	- if:
56	required:	57	required:
57	- mode-switch	58	- mode-switch

Documentation/devicetree/bindings/usb/nxp,ptn36502.yaml+1−0

@@ -46,6 +46,7 @@ required: · 45 unmodified lines
46		46
47	allOf:	47	allOf:
48	- $ref: usb-switch.yaml#	48	- $ref: usb-switch.yaml#
		49	- $ref: usb-switch-ports.yaml#
49		50
50	additionalProperties: false	51	additionalProperties: false
51		52

Documentation/devicetree/bindings/usb/onnn,nb7vpq904m.yaml+1−0

@@ -91,6 +91,7 @@ required: · 90 unmodified lines
91		91
92	allOf:	92	allOf:
93	- $ref: usb-switch.yaml#	93	- $ref: usb-switch.yaml#
		94	- $ref: usb-switch-ports.yaml#
94		95
95	additionalProperties: false	96	additionalProperties: false
96		97

Documentation/devicetree/bindings/usb/parade,ps8830.yaml+1−0

@@ -81,6 +81,7 @@ required: · 80 unmodified lines
81		81
82	allOf:	82	allOf:
83	- $ref: usb-switch.yaml#	83	- $ref: usb-switch.yaml#
		84	- $ref: usb-switch-ports.yaml#
84		85
85	additionalProperties: false	86	additionalProperties: false
86		87

Documentation/devicetree/bindings/usb/qcom,snps-dwc3.yaml+3−0

           - qcom,sm8550-dwc3
           - qcom,sm8650-dwc3
           - qcom,x1e80100-dwc3
+          - qcom,x1e80100-dwc3-mp
       - const: qcom,snps-dwc3
   reg:
     then:
       properties:
         interrupts:
+          minItems: 4
           maxItems: 5
         interrupt-names:
+          minItems: 4
           items:
             - const: dwc_usb3
             - const: pwr_event

Documentation/devicetree/bindings/usb/qcom,wcd939x-usbss.yaml+1−0

@@ -60,6 +60,7 @@ required: · 59 unmodified lines
60		60
61	allOf:	61	allOf:
62	- $ref: usb-switch.yaml#	62	- $ref: usb-switch.yaml#
		63	- $ref: usb-switch-ports.yaml#
63		64
64	additionalProperties: false	65	additionalProperties: false
65		66

Documentation/devicetree/bindings/usb/ti,tusb1046.yaml+1−0

@@ -11,6 +11,7 @@ maintainers: · 10 unmodified lines
11		11
12	allOf:	12	allOf:
13	- $ref: usb-switch.yaml#	13	- $ref: usb-switch.yaml#
		14	- $ref: usb-switch-ports.yaml#
14		15
15	properties:	16	properties:
16	compatible:	17	compatible:

Documentation/devicetree/bindings/usb/usb-switch-ports.yaml+68−0

@@ -0,0 +1,68 @@
	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/usb/usb-switch-ports.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: USB Orientation and Mode Switches Ports Graph Properties
	8
	9	maintainers:
	10	- Greg Kroah-Hartman <gregkh@linuxfoundation.org>
	11
	12	description:
	13	Ports Graph properties for devices handling USB mode and orientation switching.
	14
	15	properties:
	16	port:
	17	$ref: /schemas/graph.yaml#/$defs/port-base
	18	description:
	19	A port node to link the device to a TypeC controller for the purpose of
	20	handling altmode muxing and orientation switching.
	21
	22	properties:
	23	endpoint:
	24	$ref: /schemas/graph.yaml#/$defs/endpoint-base
	25	unevaluatedProperties: false
	26	properties:
	27	data-lanes:
	28	$ref: /schemas/types.yaml#/definitions/uint32-array
	29	minItems: 1
	30	maxItems: 8
	31	uniqueItems: true
	32	items:
	33	maximum: 8
	34
	35	ports:
	36	$ref: /schemas/graph.yaml#/properties/ports
	37	properties:
	38	port@0:
	39	$ref: /schemas/graph.yaml#/properties/port
	40	description:
	41	Super Speed (SS) Output endpoint to the Type-C connector
	42
	43	port@1:
	44	$ref: /schemas/graph.yaml#/$defs/port-base
	45	description:
	46	Super Speed (SS) Input endpoint from the Super-Speed PHY
	47	unevaluatedProperties: false
	48
	49	properties:
	50	endpoint:
	51	$ref: /schemas/graph.yaml#/$defs/endpoint-base
	52	unevaluatedProperties: false
	53	properties:
	54	data-lanes:
	55	$ref: /schemas/types.yaml#/definitions/uint32-array
	56	minItems: 1
	57	maxItems: 8
	58	uniqueItems: true
	59	items:
	60	maximum: 8
	61
	62	oneOf:
	63	- required:
	64	- port
	65	- required:
	66	- ports
	67
	68	additionalProperties: true

Documentation/devicetree/bindings/usb/usb-switch.yaml+0−52

@@ -25,56 +25,4 @@ properties: · 24 unmodified lines
25	description: Possible handler of SuperSpeed signals retiming	25	description: Possible handler of SuperSpeed signals retiming
26	type: boolean	26	type: boolean
27		27
28	port:
29	$ref: /schemas/graph.yaml#/$defs/port-base
30	description:
31	A port node to link the device to a TypeC controller for the purpose of
32	handling altmode muxing and orientation switching.
33
34	properties:
35	endpoint:
36	$ref: /schemas/graph.yaml#/$defs/endpoint-base
37	unevaluatedProperties: false
38	properties:
39	data-lanes:
40	$ref: /schemas/types.yaml#/definitions/uint32-array
41	minItems: 1
42	maxItems: 8
43	uniqueItems: true
44	items:
45	maximum: 8
46
47	ports:
48	$ref: /schemas/graph.yaml#/properties/ports
49	properties:
50	port@0:
51	$ref: /schemas/graph.yaml#/properties/port
52	description:
53	Super Speed (SS) Output endpoint to the Type-C connector
54
55	port@1:
56	$ref: /schemas/graph.yaml#/$defs/port-base
57	description:
58	Super Speed (SS) Input endpoint from the Super-Speed PHY
59	unevaluatedProperties: false
60
61	properties:
62	endpoint:
63	$ref: /schemas/graph.yaml#/$defs/endpoint-base
64	unevaluatedProperties: false
65	properties:
66	data-lanes:
67	$ref: /schemas/types.yaml#/definitions/uint32-array
68	minItems: 1
69	maxItems: 8
70	uniqueItems: true
71	items:
72	maximum: 8
73
74	oneOf:
75	- required:
76	- port
77	- required:
78	- ports
79
80	additionalProperties: true	28	additionalProperties: true

Documentation/networking/ax25.rst+4−3

@@ -11,6 +11,7 @@ found on https://linux-ax25.in-berlin.de. · 10 unmodified lines
11		11
12	There is a mailing list for discussing Linux amateur radio matters	12	There is a mailing list for discussing Linux amateur radio matters
13	called linux-hams@vger.kernel.org. To subscribe to it, send a message to	13	called linux-hams@vger.kernel.org. To subscribe to it, send a message to
14	majordomo@vger.kernel.org with the words "subscribe linux-hams" in the body	14	linux-hams+subscribe@vger.kernel.org or use the web interface at
15	of the message, the subject field is ignored. You don't need to be	15	https://vger.kernel.org. The subject and body of the message are
16	subscribed to post but of course that means you might miss an answer.	16	ignored. You don't need to be subscribed to post but of course that
		17	means you might miss an answer.

Documentation/networking/device_drivers/cellular/qualcomm/rmnet.rst+9−3

@@ -137,16 +137,20 @@ d. Checksum offload header v5 · 136 unmodified lines
137		137
138	Checksum offload header fields are in big endian format.	138	Checksum offload header fields are in big endian format.
139		139
		140	Packet format::
		141
140	Bit 0 - 6 7 8-15 16-31	142	Bit 0 - 6 7 8-15 16-31
141	Function Header Type Next Header Checksum Valid Reserved	143	Function Header Type Next Header Checksum Valid Reserved
142		144
143	Header Type is to indicate the type of header, this usually is set to CHECKSUM	145	Header Type is to indicate the type of header, this usually is set to CHECKSUM
144		146
145	Header types	147	Header types
146	= ==========================================	148
		149	= ===============
147	0 Reserved	150	0 Reserved
148	1 Reserved	151	1 Reserved
149	2 checksum header	152	2 checksum header
		153	= ===============
150		154
151	Checksum Valid is to indicate whether the header checksum is valid. Value of 1	155	Checksum Valid is to indicate whether the header checksum is valid. Value of 1
152	implies that checksum is calculated on this packet and is valid, value of 0	156	implies that checksum is calculated on this packet and is valid, value of 0
@@ -183,9 +187,11 @@ rmnet in a single linear skb. rmnet will process the individual · 30 unmodified lines
183	packets and either ACK the MAP command or deliver the IP packet to the	187	packets and either ACK the MAP command or deliver the IP packet to the
184	network stack as needed	188	network stack as needed
185		189
186	MAP header\|IP Packet\|Optional padding\|MAP header\|IP Packet\|Optional padding....	190	Packet format::
		191
		192	MAP header\|IP Packet\|Optional padding\|MAP header\|IP Packet\|Optional padding....
187		193
188	MAP header\|IP Packet\|Optional padding\|MAP header\|Command Packet\|Optional pad...	194	MAP header\|IP Packet\|Optional padding\|MAP header\|Command Packet\|Optional pad...
189		195
190	3. Userspace configuration	196	3. Userspace configuration
191	==========================	197	==========================

Documentation/networking/net_failover.rst+2−4

 received only on the 'failover' device.
 Below is the patch snippet used with 'cloud-ifupdown-helper' script found on
-Debian cloud images:
+Debian cloud images::
-::
   @@ -27,6 +27,8 @@ do_setup() {
        local working="$cfgdir/.$INTERFACE"
        local final="$cfgdir/$INTERFACE"
 The following script is executed on the destination hypervisor once migration
 completes, and it reattaches the VF to the VM and brings down the virtio-net
-interface.
+interface::
-::
   # reattach-vf.sh
   #!/bin/bash

MAINTAINERS+17−2

 ARM AND ARM64 SoC SUB-ARCHITECTURES (COMMON PARTS)
 M:	Arnd Bergmann <arnd@arndb.de>
+M:	Krzysztof Kozlowski <krzk@kernel.org>
+M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
+M:	Linus Walleij <linus.walleij@linaro.org>
+R:	Drew Fustini <fustini@kernel.org>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	soc@lists.linux.dev
 S:	Maintained
 ASUS NOTEBOOKS AND EEEPC ACPI/WMI EXTRAS DRIVERS
 M:	Corentin Chary <corentin.chary@gmail.com>
 M:	Luke D. Jones <luke@ljones.dev>
+M:	Denis Benato <benato.denis96@gmail.com>
 L:	platform-driver-x86@vger.kernel.org
 S:	Maintained
 W:	https://asus-linux.org/
 F:	include/uapi/linux/io_uring/
 F:	io_uring/
+IO_URING ZCRX
+M:	Pavel Begunkov <asml.silence@gmail.com>
+L:	io-uring@vger.kernel.org
+L:	netdev@vger.kernel.org
+T:	git https://github.com/isilence/linux.git zcrx/for-next
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux.git
+S:	Maintained
+F:	io_uring/zcrx.*
 IPMI SUBSYSTEM
 M:	Corey Minyard <corey@minyard.net>
 L:	openipmi-developer@lists.sourceforge.net (moderated for non-subscribers)
 LINUX-NEXT TREE
 M:	Stephen Rothwell <sfr@canb.auug.org.au>
+M:	Mark Brown <broonie@kernel.org>
 L:	linux-next@vger.kernel.org
 S:	Supported
 B:	mailto:linux-next@vger.kernel.org and the appropriate development tree
 F:	drivers/vfio/cdx/*
 VFIO DRIVER
-M:	Alex Williamson <alex.williamson@redhat.com>
+M:	Alex Williamson <alex@shazbot.org>
 L:	kvm@vger.kernel.org
 S:	Maintained
 T:	git https://github.com/awilliam/linux-vfio.git
 F:	drivers/media/test-drivers/vimc/*
 VIRT LIB
-M:	Alex Williamson <alex.williamson@redhat.com>
+M:	Alex Williamson <alex@shazbot.org>
 M:	Paolo Bonzini <pbonzini@redhat.com>
 L:	kvm@vger.kernel.org
 S:	Supported

Makefile+4−1

 VERSION = 6
 PATCHLEVEL = 18
 SUBLEVEL = 0
-EXTRAVERSION = -rc2
+EXTRAVERSION = -rc3
 NAME = Baby Opossum Posse
 # *DOCUMENTATION*
 # perform bounds checking.
 KBUILD_CFLAGS += $(call cc-option, -fstrict-flex-arrays=3)
+# Allow including a tagged struct or union anonymously in another struct/union.
+KBUILD_CFLAGS += -fms-extensions
 # disable invalid "can't wrap" optimizations for signed / pointers
 KBUILD_CFLAGS	+= -fno-strict-overflow

arch/arm/boot/dts/broadcom/bcm2711-rpi.dtsi+8−0

@@ -77,6 +77,14 @@ · 76 unmodified lines
77	/delete-property/ pinctrl-0;	77	/delete-property/ pinctrl-0;
78	};	78	};
79		79
		80	&pm {
		81	clocks = <&firmware_clocks 5>,
		82	<&clocks BCM2835_CLOCK_PERI_IMAGE>,
		83	<&clocks BCM2835_CLOCK_H264>,
		84	<&clocks BCM2835_CLOCK_ISP>;
		85	clock-names = "v3d", "peri_image", "h264", "isp";
		86	};
		87
80	&rmem {	88	&rmem {
81	/*	89	/*
82	* RPi4's co-processor will copy the board's bootloader configuration	90	* RPi4's co-processor will copy the board's bootloader configuration

arch/arm/boot/dts/broadcom/bcm2835-rpi-common.dtsi+9−0

@@ -13,7 +13,16 @@ · 12 unmodified lines
13	clock-names = "pixel", "hdmi";	13	clock-names = "pixel", "hdmi";
14	};	14	};
15		15
		16	&pm {
		17	clocks = <&firmware_clocks 5>,
		18	<&clocks BCM2835_CLOCK_PERI_IMAGE>,
		19	<&clocks BCM2835_CLOCK_H264>,
		20	<&clocks BCM2835_CLOCK_ISP>;
		21	clock-names = "v3d", "peri_image", "h264", "isp";
		22	};
		23
16	&v3d {	24	&v3d {
		25	clocks = <&firmware_clocks 5>;
17	power-domains = <&power RPI_POWER_DOMAIN_V3D>;	26	power-domains = <&power RPI_POWER_DOMAIN_V3D>;
18	};	27	};
19		28

arch/arm64/boot/dts/broadcom/bcm2712.dtsi+2−0

@@ -326,6 +326,8 @@ · 325 unmodified lines
326	<0x7fffe000 0x2000>;	326	<0x7fffe000 0x2000>;
327	interrupt-controller;	327	interrupt-controller;
328	#address-cells = <0>;	328	#address-cells = <0>;
		329	interrupts = <GIC_PPI 9 (GIC_CPU_MASK_SIMPLE(4) \|
		330	IRQ_TYPE_LEVEL_HIGH)>;
329	#interrupt-cells = <3>;	331	#interrupt-cells = <3>;
330	};	332	};
331		333

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

@@ -293,7 +293,8 @@ static inline pmd_t set_pmd_bit(pmd_t pmd, pgprot_t prot) · 292 unmodified lines
293	static inline pte_t pte_mkwrite_novma(pte_t pte)	293	static inline pte_t pte_mkwrite_novma(pte_t pte)
294	{	294	{
295	pte = set_pte_bit(pte, __pgprot(PTE_WRITE));	295	pte = set_pte_bit(pte, __pgprot(PTE_WRITE));
296	pte = clear_pte_bit(pte, __pgprot(PTE_RDONLY));	296	if (pte_sw_dirty(pte))
		297	pte = clear_pte_bit(pte, __pgprot(PTE_RDONLY));
297	return pte;	298	return pte;
298	}	299	}
299		300

arch/arm64/kernel/vdso32/Makefile+2−1

                $(filter -Werror,$(KBUILD_CPPFLAGS)) \
                -Werror-implicit-function-declaration \
                -Wno-format-security \
-               -std=gnu11
+               -std=gnu11 -fms-extensions
 VDSO_CFLAGS  += -O2
 # Some useful compiler-dependent flags from top-level Makefile
 VDSO_CFLAGS += $(call cc32-option,-Wno-pointer-sign)
 VDSO_CFLAGS += $(call cc32-option,-Werror=strict-prototypes)
 VDSO_CFLAGS += -Werror=date-time
 VDSO_CFLAGS += $(call cc32-option,-Werror=incompatible-pointer-types)
+VDSO_CFLAGS += $(if $(CONFIG_CC_IS_CLANG),-Wno-microsoft-anon-tag)
 # Compile as THUMB2 or ARM. Unwinding via frame-pointers in THUMB2 is
 # unreliable.

arch/arm64/mm/copypage.c+8−3

 		    from != folio_page(src, 0))
 			return;
-		WARN_ON_ONCE(!folio_try_hugetlb_mte_tagging(dst));
+		folio_try_hugetlb_mte_tagging(dst);
 		/*
 		 * Populate tags for all subpages.
 		}
 		folio_set_hugetlb_mte_tagged(dst);
 	} else if (page_mte_tagged(from)) {
-		/* It's a new page, shouldn't have been tagged yet */
+		/*
-		WARN_ON_ONCE(!try_page_mte_tagging(to));
+		 * Most of the time it's a new page that shouldn't have been
+		 * tagged yet. However, folio migration can end up reusing the
+		 * same page without untagging it. Ignore the warning if the
+		 * page is already tagged.
+		 */
+		try_page_mte_tagging(to);
 		mte_copy_page_tags(kto, kfrom);
 		set_page_mte_tagged(to);

arch/csky/abiv2/cacheflush.c+1−1

@@ -21,7 +21,7 @@ void update_mmu_cache_range(struct vm_fault vmf, struct vm_area_struct vma, · 20 unmodified lines
21		21
22	folio = page_folio(pfn_to_page(pfn));	22	folio = page_folio(pfn_to_page(pfn));
23		23
24	if (test_and_set_bit(PG_dcache_clean, &folio->flags))	24	if (test_and_set_bit(PG_dcache_clean, &folio->flags.f))
25	return;	25	return;
26		26
27	icache_inv_range(address, address + nr*PAGE_SIZE);	27	icache_inv_range(address, address + nr*PAGE_SIZE);

arch/csky/abiv2/inc/abi/cacheflush.h+2−2

@@ -20,8 +20,8 @@ · 19 unmodified lines
20		20
21	static inline void flush_dcache_folio(struct folio *folio)	21	static inline void flush_dcache_folio(struct folio *folio)
22	{	22	{
23	if (test_bit(PG_dcache_clean, &folio->flags))	23	if (test_bit(PG_dcache_clean, &folio->flags.f))
24	clear_bit(PG_dcache_clean, &folio->flags);	24	clear_bit(PG_dcache_clean, &folio->flags.f);
25	}	25	}
26	#define flush_dcache_folio flush_dcache_folio	26	#define flush_dcache_folio flush_dcache_folio
27		27

arch/loongarch/vdso/Makefile+1−1

@@ -19,7 +19,7 @@ ccflags-vdso := \ · 18 unmodified lines
19	cflags-vdso := $(ccflags-vdso) \	19	cflags-vdso := $(ccflags-vdso) \
20	-isystem $(shell $(CC) -print-file-name=include) \	20	-isystem $(shell $(CC) -print-file-name=include) \
21	$(filter -W%,$(filter-out -Wa$(comma)%,$(KBUILD_CFLAGS))) \	21	$(filter -W%,$(filter-out -Wa$(comma)%,$(KBUILD_CFLAGS))) \
22	-std=gnu11 -O2 -g -fno-strict-aliasing -fno-common -fno-builtin \	22	-std=gnu11 -fms-extensions -O2 -g -fno-strict-aliasing -fno-common -fno-builtin \
23	-fno-stack-protector -fno-jump-tables -DDISABLE_BRANCH_PROFILING \	23	-fno-stack-protector -fno-jump-tables -DDISABLE_BRANCH_PROFILING \
24	$(call cc-option, -fno-asynchronous-unwind-tables) \	24	$(call cc-option, -fno-asynchronous-unwind-tables) \
25	$(call cc-option, -fno-stack-protector)	25	$(call cc-option, -fno-stack-protector)

arch/mips/mti-malta/malta-setup.c+2−2

@@ -47,7 +47,7 @@ static struct resource standard_io_resources[] = { · 46 unmodified lines
47	.name = "keyboard",	47	.name = "keyboard",
48	.start = 0x60,	48	.start = 0x60,
49	.end = 0x6f,	49	.end = 0x6f,
50	.flags = IORESOURCE_IO \| IORESOURCE_BUSY	50	.flags = IORESOURCE_IO
51	},	51	},
52	{	52	{
53	.name = "dma page reg",	53	.name = "dma page reg",
@@ -213,7 +213,7 @@ void __init plat_mem_setup(void) · 159 unmodified lines
213		213
214	/* Request I/O space for devices used on the Malta board. */	214	/* Request I/O space for devices used on the Malta board. */
215	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)	215	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
216	request_resource(&ioport_resource, standard_io_resources+i);	216	insert_resource(&ioport_resource, standard_io_resources + i);
217		217
218	/*	218	/*
219	* Enable DMA channel 4 (cascade channel) in the PIIX4 south bridge.	219	* Enable DMA channel 4 (cascade channel) in the PIIX4 south bridge.

arch/mips/pci/pci-malta.c+1−2

@@ -230,8 +230,7 @@ void __init mips_pcibios_init(void) · 229 unmodified lines
230	}	230	}
231		231
232	/* PIIX4 ACPI starts at 0x1000 */	232	/* PIIX4 ACPI starts at 0x1000 */
233	if (controller->io_resource->start < 0x00001000UL)	233	PCIBIOS_MIN_IO = 0x1000;
234	controller->io_resource->start = 0x00001000UL;
235		234
236	iomem_resource.end &= 0xfffffffffULL; /* 64 GB */	235	iomem_resource.end &= 0xfffffffffULL; /* 64 GB */
237	ioport_resource.end = controller->io_resource->end;	236	ioport_resource.end = controller->io_resource->end;

arch/parisc/boot/compressed/Makefile+1−1

@@ -18,7 +18,7 @@ KBUILD_CFLAGS += -fno-PIE -mno-space-regs -mdisable-fpregs -Os · 17 unmodified lines
18	ifndef CONFIG_64BIT	18	ifndef CONFIG_64BIT
19	KBUILD_CFLAGS += -mfast-indirect-calls	19	KBUILD_CFLAGS += -mfast-indirect-calls
20	endif	20	endif
21	KBUILD_CFLAGS += -std=gnu11	21	KBUILD_CFLAGS += -std=gnu11 -fms-extensions
22		22
23	LDFLAGS_vmlinux := -X -e startup --as-needed -T	23	LDFLAGS_vmlinux := -X -e startup --as-needed -T
24	$(obj)/vmlinux: $(obj)/vmlinux.lds $(addprefix $(obj)/, $(OBJECTS)) $(LIBGCC) FORCE	24	$(obj)/vmlinux: $(obj)/vmlinux.lds $(addprefix $(obj)/, $(OBJECTS)) $(LIBGCC) FORCE

arch/powerpc/boot/Makefile+2−1

 BOOTCPPFLAGS	+= -isystem $(shell $(BOOTCC) -print-file-name=include)
 BOOTCFLAGS	:= $(BOOTTARGETFLAGS) \
-		   -std=gnu11 \
+		   -std=gnu11 -fms-extensions \
 		   -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \
 		   -fno-strict-aliasing -O2 \
 		   -msoft-float -mno-altivec -mno-vsx \
 ifdef CONFIG_CC_IS_CLANG
 BOOTCFLAGS += $(CLANG_FLAGS)
+BOOTCFLAGS += -Wno-microsoft-anon-tag
 BOOTAFLAGS += $(CLANG_FLAGS)
 endif

arch/riscv/include/asm/asm.h+1−7

 .endm
 #ifdef CONFIG_SMP
-#ifdef CONFIG_32BIT
-#define PER_CPU_OFFSET_SHIFT 2
-#else
-#define PER_CPU_OFFSET_SHIFT 3
-#endif
 .macro asm_per_cpu dst sym tmp
 	lw    \tmp, TASK_TI_CPU_NUM(tp)
-	slli  \tmp, \tmp, PER_CPU_OFFSET_SHIFT
+	slli  \tmp, \tmp, RISCV_LGPTR
 	la    \dst, __per_cpu_offset
 	add   \dst, \dst, \tmp
 	REG_L \tmp, 0(\dst)

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

@@ -31,6 +31,8 @@ struct riscv_isainfo { · 30 unmodified lines
31		31
32	DECLARE_PER_CPU(struct riscv_cpuinfo, riscv_cpuinfo);	32	DECLARE_PER_CPU(struct riscv_cpuinfo, riscv_cpuinfo);
33		33
		34	extern const struct seq_operations cpuinfo_op;
		35
34	/* Per-cpu ISA extensions. */	36	/* Per-cpu ISA extensions. */
35	extern struct riscv_isainfo hart_isa[NR_CPUS];	37	extern struct riscv_isainfo hart_isa[NR_CPUS];
36		38

arch/riscv/include/asm/hwprobe.h+7−0

@@ -42,4 +42,11 @@ static inline bool riscv_hwprobe_pair_cmp(struct riscv_hwprobe *pair, · 41 unmodified lines
42	return pair->value == other_pair->value;	42	return pair->value == other_pair->value;
43	}	43	}
44		44
		45	#ifdef CONFIG_MMU
		46	void riscv_hwprobe_register_async_probe(void);
		47	void riscv_hwprobe_complete_async_probe(void);
		48	#else
		49	static inline void riscv_hwprobe_register_async_probe(void) {}
		50	static inline void riscv_hwprobe_complete_async_probe(void) {}
		51	#endif
45	#endif	52	#endif

arch/riscv/include/asm/pgtable-64.h+2−0

@@ -69,6 +69,8 @@ typedef struct { · 68 unmodified lines
69		69
70	#define PTRS_PER_PMD (PAGE_SIZE / sizeof(pmd_t))	70	#define PTRS_PER_PMD (PAGE_SIZE / sizeof(pmd_t))
71		71
		72	#define MAX_POSSIBLE_PHYSMEM_BITS 56
		73
72	/*	74	/*
73	* rv64 PTE format:	75	* rv64 PTE format:
74	* \| 63 \| 62 61 \| 60 54 \| 53 10 \| 9 8 \| 7 \| 6 \| 5 \| 4 \| 3 \| 2 \| 1 \| 0	76	* \| 63 \| 62 61 \| 60 54 \| 53 10 \| 9 8 \| 7 \| 6 \| 5 \| 4 \| 3 \| 2 \| 1 \| 0

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

@@ -654,6 +654,8 @@ static inline pgprot_t pgprot_writecombine(pgprot_t _prot) · 653 unmodified lines
654	return __pgprot(prot);	654	return __pgprot(prot);
655	}	655	}
656		656
		657	#define pgprot_dmacoherent pgprot_writecombine
		658
657	/*	659	/*
658	* Both Svade and Svadu control the hardware behavior when the PTE A/D bits need to be set. By	660	* Both Svade and Svadu control the hardware behavior when the PTE A/D bits need to be set. By
659	* default the M-mode firmware enables the hardware updating scheme when only Svadu is present in	661	* default the M-mode firmware enables the hardware updating scheme when only Svadu is present in

arch/riscv/include/asm/vdso/arch_data.h+6−0

 	/* Boolean indicating all CPUs have the same static hwprobe values. */
 	__u8 homogeneous_cpus;
+	/*
+	 * A gate to check and see if the hwprobe data is actually ready, as
+	 * probing is deferred to avoid boot slowdowns.
+	 */
+	__u8 ready;
 };
 #endif /* __RISCV_ASM_VDSO_ARCH_DATA_H */

arch/riscv/kernel/cpu.c+1−3

 		return -ENODEV;
 	}
-	if (!of_device_is_available(node)) {
+	if (!of_device_is_available(node))
-		pr_info("CPU with hartid=%lu is not available\n", *hart);
 		return -ENODEV;
-	}
 	if (of_property_read_string(node, "riscv,isa-base", &isa))
 		goto old_interface;

arch/riscv/kernel/cpufeature.c+2−2

@@ -932,9 +932,9 @@ static int has_thead_homogeneous_vlenb(void) · 931 unmodified lines
932	{	932	{
933	int cpu;	933	int cpu;
934	u32 prev_vlenb = 0;	934	u32 prev_vlenb = 0;
935	u32 vlenb;	935	u32 vlenb = 0;
936		936
937	/* Ignore thead,vlenb property if xtheavector is not enabled in the kernel */	937	/* Ignore thead,vlenb property if xtheadvector is not enabled in the kernel */
938	if (!IS_ENABLED(CONFIG_RISCV_ISA_XTHEADVECTOR))	938	if (!IS_ENABLED(CONFIG_RISCV_ISA_XTHEADVECTOR))
939	return 0;	939	return 0;
940		940

arch/riscv/kernel/smp.c+12−12

 	IPI_MAX
 };
+static const char * const ipi_names[] = {
+	[IPI_RESCHEDULE]	= "Rescheduling interrupts",
+	[IPI_CALL_FUNC]		= "Function call interrupts",
+	[IPI_CPU_STOP]		= "CPU stop interrupts",
+	[IPI_CPU_CRASH_STOP]	= "CPU stop (for crash dump) interrupts",
+	[IPI_IRQ_WORK]		= "IRQ work interrupts",
+	[IPI_TIMER]		= "Timer broadcast interrupts",
+	[IPI_CPU_BACKTRACE]     = "CPU backtrace interrupts",
+	[IPI_KGDB_ROUNDUP]	= "KGDB roundup interrupts",
+};
 unsigned long __cpuid_to_hartid_map[NR_CPUS] __ro_after_init = {
 	[0 ... NR_CPUS-1] = INVALID_HARTID
 };
 	/* Request IPIs */
 	for (i = 0; i < nr_ipi; i++) {
 		err = request_percpu_irq(ipi_virq_base + i, handle_IPI,
-					 "IPI", &ipi_dummy_dev);
+					 ipi_names[i], &ipi_dummy_dev);
 		WARN_ON(err);
 		ipi_desc[i] = irq_to_desc(ipi_virq_base + i);
 	riscv_ipi_enable();
 }
-static const char * const ipi_names[] = {
-	[IPI_RESCHEDULE]	= "Rescheduling interrupts",
-	[IPI_CALL_FUNC]		= "Function call interrupts",
-	[IPI_CPU_STOP]		= "CPU stop interrupts",
-	[IPI_CPU_CRASH_STOP]	= "CPU stop (for crash dump) interrupts",
-	[IPI_IRQ_WORK]		= "IRQ work interrupts",
-	[IPI_TIMER]		= "Timer broadcast interrupts",
-	[IPI_CPU_BACKTRACE]     = "CPU backtrace interrupts",
-	[IPI_KGDB_ROUNDUP]	= "KGDB roundup interrupts",
-};
 void show_ipi_stats(struct seq_file *p, int prec)
 {
 	unsigned int cpu, i;

arch/riscv/kernel/sys_hwprobe.c+64−12

  * more details.
  */
 #include <linux/syscalls.h>
+#include <linux/completion.h>
+#include <linux/atomic.h>
+#include <linux/once.h>
 #include <asm/cacheflush.h>
 #include <asm/cpufeature.h>
 #include <asm/hwprobe.h>
 	bool first = true;
 	int cpu;
+	if (pair->key != RISCV_HWPROBE_KEY_MVENDORID &&
+	    pair->key != RISCV_HWPROBE_KEY_MIMPID &&
+	    pair->key != RISCV_HWPROBE_KEY_MARCHID)
+		goto out;
 	for_each_cpu(cpu, cpus) {
 		u64 cpu_id;
 		}
 	}
+out:
 	pair->value = id;
 }
 	return 0;
 }
-static int do_riscv_hwprobe(struct riscv_hwprobe __user *pairs,
+#ifdef CONFIG_MMU
-			    size_t pair_count, size_t cpusetsize,
-			    unsigned long __user *cpus_user,
-			    unsigned int flags)
-{
-	if (flags & RISCV_HWPROBE_WHICH_CPUS)
-		return hwprobe_get_cpus(pairs, pair_count, cpusetsize,
-					cpus_user, flags);
-	return hwprobe_get_values(pairs, pair_count, cpusetsize,
+static DECLARE_COMPLETION(boot_probes_done);
-				  cpus_user, flags);
+static atomic_t pending_boot_probes = ATOMIC_INIT(1);
+void riscv_hwprobe_register_async_probe(void)
+{
+	atomic_inc(&pending_boot_probes);
 }
-#ifdef CONFIG_MMU
+void riscv_hwprobe_complete_async_probe(void)
+{
+	if (atomic_dec_and_test(&pending_boot_probes))
+		complete(&boot_probes_done);
+}
-static int __init init_hwprobe_vdso_data(void)
+static int complete_hwprobe_vdso_data(void)
 {
 	struct vdso_arch_data *avd = vdso_k_arch_data;
 	u64 id_bitsmash = 0;
 	struct riscv_hwprobe pair;
 	int key;
+	if (unlikely(!atomic_dec_and_test(&pending_boot_probes)))
+		wait_for_completion(&boot_probes_done);
 	/*
 	 * Initialize vDSO data with the answers for the "all CPUs" case, to
 	 * save a syscall in the common case.
 	 * vDSO should defer to the kernel for exotic cpu masks.
 	 */
 	avd->homogeneous_cpus = id_bitsmash != 0 && id_bitsmash != -1;
+	/*
+	 * Make sure all the VDSO values are visible before we look at them.
+	 * This pairs with the implicit "no speculativly visible accesses"
+	 * barrier in the VDSO hwprobe code.
+	 */
+	smp_wmb();
+	avd->ready = true;
+	return 0;
+}
+static int __init init_hwprobe_vdso_data(void)
+{
+	struct vdso_arch_data *avd = vdso_k_arch_data;
+	/*
+	 * Prevent the vDSO cached values from being used, as they're not ready
+	 * yet.
+	 */
+	avd->ready = false;
 	return 0;
 }
 arch_initcall_sync(init_hwprobe_vdso_data);
+#else
+static int complete_hwprobe_vdso_data(void) { return 0; }
 #endif /* CONFIG_MMU */
+static int do_riscv_hwprobe(struct riscv_hwprobe __user *pairs,
+			    size_t pair_count, size_t cpusetsize,
+			    unsigned long __user *cpus_user,
+			    unsigned int flags)
+{
+	DO_ONCE_SLEEPABLE(complete_hwprobe_vdso_data);
+	if (flags & RISCV_HWPROBE_WHICH_CPUS)
+		return hwprobe_get_cpus(pairs, pair_count, cpusetsize,
+					cpus_user, flags);
+	return hwprobe_get_values(pairs, pair_count, cpusetsize,
+				cpus_user, flags);
+}
 SYSCALL_DEFINE5(riscv_hwprobe, struct riscv_hwprobe __user *, pairs,
 		size_t, pair_count, size_t, cpusetsize, unsigned long __user *,
 		cpus, unsigned int, flags)

arch/riscv/kernel/unaligned_access_speed.c+7−2

 static int __init vec_check_unaligned_access_speed_all_cpus(void *unused __always_unused)
 {
 	schedule_on_each_cpu(check_vector_unaligned_access);
+	riscv_hwprobe_complete_async_probe();
 	return 0;
 }
 			per_cpu(vector_misaligned_access, cpu) = unaligned_vector_speed_param;
 	} else if (!check_vector_unaligned_access_emulated_all_cpus() &&
 		   IS_ENABLED(CONFIG_RISCV_PROBE_VECTOR_UNALIGNED_ACCESS)) {
-		kthread_run(vec_check_unaligned_access_speed_all_cpus,
+		riscv_hwprobe_register_async_probe();
-			    NULL, "vec_check_unaligned_access_speed_all_cpus");
+		if (IS_ERR(kthread_run(vec_check_unaligned_access_speed_all_cpus,
+				       NULL, "vec_check_unaligned_access_speed_all_cpus"))) {
+			pr_warn("Failed to create vec_unalign_check kthread\n");
+			riscv_hwprobe_complete_async_probe();
+		}
 	}
 	/*

arch/riscv/kernel/vdso/hwprobe.c+1−1

@@ -27,7 +27,7 @@ static int riscv_vdso_get_values(struct riscv_hwprobe *pairs, size_t pair_count, · 26 unmodified lines
27	* homogeneous, then this function can handle requests for arbitrary	27	* homogeneous, then this function can handle requests for arbitrary
28	* masks.	28	* masks.
29	*/	29	*/
30	if ((flags != 0) \|\| (!all_cpus && !avd->homogeneous_cpus))	30	if (flags != 0 \|\| (!all_cpus && !avd->homogeneous_cpus) \|\| unlikely(!avd->ready))
31	return riscv_hwprobe(pairs, pair_count, cpusetsize, cpus, flags);	31	return riscv_hwprobe(pairs, pair_count, cpusetsize, cpus, flags);
32		32
33	/* This is something we can handle, fill out the pairs. */	33	/* This is something we can handle, fill out the pairs. */

arch/s390/Makefile+2−1

 ifndef CONFIG_AS_IS_LLVM
 KBUILD_AFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO),$(aflags_dwarf))
 endif
-KBUILD_CFLAGS_DECOMPRESSOR := $(CLANG_FLAGS) -m64 -O2 -mpacked-stack -std=gnu11
+KBUILD_CFLAGS_DECOMPRESSOR := $(CLANG_FLAGS) -m64 -O2 -mpacked-stack -std=gnu11 -fms-extensions
 KBUILD_CFLAGS_DECOMPRESSOR += -DDISABLE_BRANCH_PROFILING -D__NO_FORTIFY
 KBUILD_CFLAGS_DECOMPRESSOR += -D__DECOMPRESSOR
 KBUILD_CFLAGS_DECOMPRESSOR += -Wno-pointer-sign
 KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO),-g)
 KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO_DWARF4), $(call cc-option, -gdwarf-4,))
 KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_CC_NO_ARRAY_BOUNDS),-Wno-array-bounds)
+KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_CC_IS_CLANG),-Wno-microsoft-anon-tag)
 UTS_MACHINE	:= s390x
 STACK_SIZE	:= $(if $(CONFIG_KASAN),65536,$(if $(CONFIG_KMSAN),65536,16384))

arch/s390/purgatory/Makefile+2−1

 $(obj)/mem.o: $(srctree)/arch/s390/lib/mem.S FORCE
 	$(call if_changed_rule,as_o_S)
-KBUILD_CFLAGS := -std=gnu11 -fno-strict-aliasing -Wall -Wstrict-prototypes
+KBUILD_CFLAGS := -std=gnu11 -fms-extensions -fno-strict-aliasing -Wall -Wstrict-prototypes
 KBUILD_CFLAGS += -Wno-pointer-sign -Wno-sign-compare
 KBUILD_CFLAGS += -fno-zero-initialized-in-bss -fno-builtin -ffreestanding
 KBUILD_CFLAGS += -Os -m64 -msoft-float -fno-common
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
 KBUILD_CFLAGS += -D__DISABLE_EXPORTS
 KBUILD_CFLAGS += $(CLANG_FLAGS)
+KBUILD_CFLAGS += $(if $(CONFIG_CC_IS_CLANG),-Wno-microsoft-anon-tag)
 KBUILD_CFLAGS += $(call cc-option,-fno-PIE)
 KBUILD_AFLAGS := $(filter-out -DCC_USING_EXPOLINE,$(KBUILD_AFLAGS))
 KBUILD_AFLAGS += -D__DISABLE_EXPORTS

arch/x86/Makefile+3−1

 # How to compile the 16-bit code.  Note we always compile for -march=i386;
 # that way we can complain to the user if the CPU is insufficient.
-REALMODE_CFLAGS	:= -std=gnu11 -m16 -g -Os -DDISABLE_BRANCH_PROFILING -D__DISABLE_EXPORTS \
+REALMODE_CFLAGS	:= -std=gnu11 -fms-extensions -m16 -g -Os \
+		   -DDISABLE_BRANCH_PROFILING -D__DISABLE_EXPORTS \
 		   -Wall -Wstrict-prototypes -march=i386 -mregparm=3 \
 		   -fno-strict-aliasing -fomit-frame-pointer -fno-pic \
 		   -mno-mmx -mno-sse $(call cc-option,-fcf-protection=none)
 REALMODE_CFLAGS += $(CLANG_FLAGS)
 ifdef CONFIG_CC_IS_CLANG
 REALMODE_CFLAGS += -Wno-gnu
+REALMODE_CFLAGS += -Wno-microsoft-anon-tag
 endif
 export REALMODE_CFLAGS

arch/x86/boot/compressed/Makefile+5−2

 # avoid errors with '-march=i386', and future flags may depend on the target to
 # be valid.
 KBUILD_CFLAGS := -m$(BITS) -O2 $(CLANG_FLAGS)
-KBUILD_CFLAGS += -std=gnu11
+KBUILD_CFLAGS += -std=gnu11 -fms-extensions
 KBUILD_CFLAGS += -fno-strict-aliasing -fPIE
 KBUILD_CFLAGS += -Wundef
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
 KBUILD_CFLAGS += -ffreestanding -fshort-wchar
 KBUILD_CFLAGS += -fno-stack-protector
 KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)
-KBUILD_CFLAGS += $(call cc-disable-warning, gnu)
+ifdef CONFIG_CC_IS_CLANG
+KBUILD_CFLAGS += -Wno-gnu
+KBUILD_CFLAGS += -Wno-microsoft-anon-tag
+endif
 KBUILD_CFLAGS += -Wno-pointer-sign
 KBUILD_CFLAGS += -fno-asynchronous-unwind-tables
 KBUILD_CFLAGS += -D__DISABLE_EXPORTS

arch/x86/kernel/cpu/bugs.c+3−8

 			break;
 		default:
 			if (retbleed_mitigation != RETBLEED_MITIGATION_STUFF) {
-				pr_err(RETBLEED_INTEL_MSG);
+				if (retbleed_mitigation != RETBLEED_MITIGATION_NONE)
+					pr_err(RETBLEED_INTEL_MSG);
 				retbleed_mitigation = RETBLEED_MITIGATION_NONE;
 			}
 		}
 }
 #endif
-static inline bool match_option(const char *arg, int arglen, const char *opt)
-{
-	int len = strlen(opt);
-	return len == arglen && !strncmp(arg, opt, len);
-}
 /* The kernel command line selection for spectre v2 */
 enum spectre_v2_mitigation_cmd {
 	SPECTRE_V2_CMD_NONE,

arch/x86/kernel/cpu/microcode/amd.c+1−1

@@ -194,7 +194,7 @@ static bool need_sha_check(u32 cur_rev) · 193 unmodified lines
194	}	194	}
195		195
196	switch (cur_rev >> 8) {	196	switch (cur_rev >> 8) {
197	case 0x80012: return cur_rev <= 0x800126f; break;	197	case 0x80012: return cur_rev <= 0x8001277; break;
198	case 0x80082: return cur_rev <= 0x800820f; break;	198	case 0x80082: return cur_rev <= 0x800820f; break;
199	case 0x83010: return cur_rev <= 0x830107c; break;	199	case 0x83010: return cur_rev <= 0x830107c; break;
200	case 0x86001: return cur_rev <= 0x860010e; break;	200	case 0x86001: return cur_rev <= 0x860010e; break;

arch/x86/kernel/cpu/resctrl/monitor.c+10−1

@@ -458,7 +458,16 @@ int __init rdt_get_mon_l3_config(struct rdt_resource *r) · 457 unmodified lines
458	r->mon.mbm_cfg_mask = ecx & MAX_EVT_CONFIG_BITS;	458	r->mon.mbm_cfg_mask = ecx & MAX_EVT_CONFIG_BITS;
459	}	459	}
460		460
461	if (rdt_cpu_has(X86_FEATURE_ABMC)) {	461	/*
		462	* resctrl assumes a system that supports assignable counters can
		463	* switch to "default" mode. Ensure that there is a "default" mode
		464	* to switch to. This enforces a dependency between the independent
		465	* X86_FEATURE_ABMC and X86_FEATURE_CQM_MBM_TOTAL/X86_FEATURE_CQM_MBM_LOCAL
		466	* hardware features.
		467	*/
		468	if (rdt_cpu_has(X86_FEATURE_ABMC) &&
		469	(rdt_cpu_has(X86_FEATURE_CQM_MBM_TOTAL) \|\|
		470	rdt_cpu_has(X86_FEATURE_CQM_MBM_LOCAL))) {
462	r->mon.mbm_cntr_assignable = true;	471	r->mon.mbm_cntr_assignable = true;
463	cpuid_count(0x80000020, 5, &eax, &ebx, &ecx, &edx);	472	cpuid_count(0x80000020, 5, &eax, &ebx, &ecx, &edx);
464	r->mon.num_mbm_cntrs = (ebx & GENMASK(15, 0)) + 1;	473	r->mon.num_mbm_cntrs = (ebx & GENMASK(15, 0)) + 1;

block/blk-settings.c+10−0

@@ -184,6 +184,16 @@ static int blk_validate_integrity_limits(struct queue_limits *lim) · 183 unmodified lines
184	if (!bi->interval_exp)	184	if (!bi->interval_exp)
185	bi->interval_exp = ilog2(lim->logical_block_size);	185	bi->interval_exp = ilog2(lim->logical_block_size);
186		186
		187	/*
		188	* The PI generation / validation helpers do not expect intervals to
		189	* straddle multiple bio_vecs. Enforce alignment so that those are
		190	* never generated, and that each buffer is aligned as expected.
		191	*/
		192	if (bi->csum_type) {
		193	lim->dma_alignment = max(lim->dma_alignment,
		194	(1U << bi->interval_exp) - 1);
		195	}
		196
187	return 0;	197	return 0;
188	}	198	}
189		199

drivers/acpi/acpica/tbprint.c+6−0

 {
 	struct acpi_table_header local_header;
+#pragma GCC diagnostic push
+#if defined(__GNUC__) && __GNUC__ >= 11
+#pragma GCC diagnostic ignored "-Wstringop-overread"
+#endif
 	if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_FACS)) {
 		/* FACS only has signature and length fields */
 			   local_header.asl_compiler_id,
 			   local_header.asl_compiler_revision));
 	}
+#pragma GCC diagnostic pop
 }

drivers/acpi/property.c+1−1

@@ -1107,7 +1107,7 @@ int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode, · 1106 unmodified lines
1107	size_t num_args,	1107	size_t num_args,
1108	struct fwnode_reference_args *args)	1108	struct fwnode_reference_args *args)
1109	{	1109	{
1110	return acpi_fwnode_get_reference_args(fwnode, propname, NULL, index, num_args, args);	1110	return acpi_fwnode_get_reference_args(fwnode, propname, NULL, num_args, index, args);
1111	}	1111	}
1112	EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);	1112	EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
1113		1113

drivers/acpi/riscv/rimt.c+61−61

 	return 0;
 }
-/**
- * rimt_get_fwnode() - Retrieve fwnode associated with an RIMT node
- *
- * @node: RIMT table node to be looked-up
- *
- * Returns: fwnode_handle pointer on success, NULL on failure
- */
-static struct fwnode_handle *rimt_get_fwnode(struct acpi_rimt_node *node)
-{
-	struct fwnode_handle *fwnode = NULL;
-	struct rimt_fwnode *curr;
-	spin_lock(&rimt_fwnode_lock);
-	list_for_each_entry(curr, &rimt_fwnode_list, list) {
-		if (curr->rimt_node == node) {
-			fwnode = curr->fwnode;
-			break;
-		}
-	}
-	spin_unlock(&rimt_fwnode_lock);
-	return fwnode;
-}
 static acpi_status rimt_match_node_callback(struct acpi_rimt_node *node,
 					    void *context)
 {
 	return NULL;
 }
+/*
+ * RISC-V supports IOMMU as a PCI device or a platform device.
+ * When it is a platform device, there should be a namespace device as
+ * well along with RIMT. To create the link between RIMT information and
+ * the platform device, the IOMMU driver should register itself with the
+ * RIMT module. This is true for PCI based IOMMU as well.
+ */
+int rimt_iommu_register(struct device *dev)
+{
+	struct fwnode_handle *rimt_fwnode;
+	struct acpi_rimt_node *node;
+	node = rimt_scan_node(ACPI_RIMT_NODE_TYPE_IOMMU, dev);
+	if (!node) {
+		pr_err("Could not find IOMMU node in RIMT\n");
+		return -ENODEV;
+	}
+	if (dev_is_pci(dev)) {
+		rimt_fwnode = acpi_alloc_fwnode_static();
+		if (!rimt_fwnode)
+			return -ENOMEM;
+		rimt_fwnode->dev = dev;
+		if (!dev->fwnode)
+			dev->fwnode = rimt_fwnode;
+		rimt_set_fwnode(node, rimt_fwnode);
+	} else {
+		rimt_set_fwnode(node, dev->fwnode);
+	}
+	return 0;
+}
+#ifdef CONFIG_IOMMU_API
+/**
+ * rimt_get_fwnode() - Retrieve fwnode associated with an RIMT node
+ *
+ * @node: RIMT table node to be looked-up
+ *
+ * Returns: fwnode_handle pointer on success, NULL on failure
+ */
+static struct fwnode_handle *rimt_get_fwnode(struct acpi_rimt_node *node)
+{
+	struct fwnode_handle *fwnode = NULL;
+	struct rimt_fwnode *curr;
+	spin_lock(&rimt_fwnode_lock);
+	list_for_each_entry(curr, &rimt_fwnode_list, list) {
+		if (curr->rimt_node == node) {
+			fwnode = curr->fwnode;
+			break;
+		}
+	}
+	spin_unlock(&rimt_fwnode_lock);
+	return fwnode;
+}
 static bool rimt_pcie_rc_supports_ats(struct acpi_rimt_node *node)
 {
 	struct acpi_rimt_pcie_rc *pci_rc;
 	return NULL;
 }
-/*
- * RISC-V supports IOMMU as a PCI device or a platform device.
- * When it is a platform device, there should be a namespace device as
- * well along with RIMT. To create the link between RIMT information and
- * the platform device, the IOMMU driver should register itself with the
- * RIMT module. This is true for PCI based IOMMU as well.
- */
-int rimt_iommu_register(struct device *dev)
-{
-	struct fwnode_handle *rimt_fwnode;
-	struct acpi_rimt_node *node;
-	node = rimt_scan_node(ACPI_RIMT_NODE_TYPE_IOMMU, dev);
-	if (!node) {
-		pr_err("Could not find IOMMU node in RIMT\n");
-		return -ENODEV;
-	}
-	if (dev_is_pci(dev)) {
-		rimt_fwnode = acpi_alloc_fwnode_static();
-		if (!rimt_fwnode)
-			return -ENOMEM;
-		rimt_fwnode->dev = dev;
-		if (!dev->fwnode)
-			dev->fwnode = rimt_fwnode;
-		rimt_set_fwnode(node, rimt_fwnode);
-	} else {
-		rimt_set_fwnode(node, dev->fwnode);
-	}
-	return 0;
-}
-#ifdef CONFIG_IOMMU_API
 static struct acpi_rimt_node *rimt_node_map_id(struct acpi_rimt_node *node,
 					       u32 id_in, u32 *id_out,
 					       u8 type_mask)

drivers/android/binder.c+15−23

 	} else {
 		if (!internal)
 			node->local_weak_refs++;
-		if (!node->has_weak_ref && list_empty(&node->work.entry)) {
+		if (!node->has_weak_ref && target_list && list_empty(&node->work.entry))
-			if (target_list == NULL) {
-				pr_err("invalid inc weak node for %d\n",
-					node->debug_id);
-				return -EINVAL;
-			}
-			/*
-			 * See comment above
-			 */
 			binder_enqueue_work_ilocked(&node->work, target_list);
-		}
 	}
 	return 0;
 }
 /**
  * struct binder_ptr_fixup - data to be fixed-up in target buffer
- * @offset	offset in target buffer to fixup
+ * @offset:      offset in target buffer to fixup
- * @skip_size	bytes to skip in copy (fixup will be written later)
+ * @skip_size:   bytes to skip in copy (fixup will be written later)
- * @fixup_data	data to write at fixup offset
+ * @fixup_data:  data to write at fixup offset
- * @node	list node
+ * @node:        list node
  *
  * This is used for the pointer fixup list (pf) which is created and consumed
  * during binder_transaction() and is only accessed locally. No
 /**
  * struct binder_sg_copy - scatter-gather data to be copied
- * @offset		offset in target buffer
+ * @offset:        offset in target buffer
- * @sender_uaddr	user address in source buffer
+ * @sender_uaddr:  user address in source buffer
- * @length		bytes to copy
+ * @length:        bytes to copy
- * @node		list node
+ * @node:          list node
  *
  * This is used for the sg copy list (sgc) which is created and consumed
  * during binder_transaction() and is only accessed locally. No
 /**
  * binder_free_buf() - free the specified buffer
- * @proc:	binder proc that owns buffer
+ * @proc:       binder proc that owns buffer
- * @buffer:	buffer to be freed
+ * @thread:     binder thread performing the buffer release
- * @is_failure:	failed to send transaction
+ * @buffer:     buffer to be freed
+ * @is_failure: failed to send transaction
  *
- * If buffer for an async transaction, enqueue the next async
+ * If the buffer is for an async transaction, enqueue the next async
  * transaction from the node.
  *
- * Cleanup buffer and free it.
+ * Cleanup the buffer and free it.
  */
 static void
 binder_free_buf(struct binder_proc *proc,

drivers/android/binder/freeze.rs+14−4

             return Ok(true);
         }
         if freeze.is_clearing {
-            _removed_listener = freeze_entry.remove_node();
+            kernel::warn_on!(freeze.num_cleared_duplicates != 0);
+            if freeze.num_pending_duplicates > 0 {
+                // The primary freeze listener was deleted, so convert a pending duplicate back
+                // into the primary one.
+                freeze.num_pending_duplicates -= 1;
+                freeze.is_pending = true;
+                freeze.is_clearing = true;
+            } else {
+                _removed_listener = freeze_entry.remove_node();
+            }
             drop(node_refs);
             writer.write_code(BR_CLEAR_FREEZE_NOTIFICATION_DONE)?;
             writer.write_payload(&self.cookie.0)?;
             Ok(true)
         } else {
-            let is_frozen = freeze.node.owner.inner.lock().is_frozen;
+            let is_frozen = freeze.node.owner.inner.lock().is_frozen.is_fully_frozen();
             if freeze.last_is_frozen == Some(is_frozen) {
                 return Ok(true);
             }
                 );
                 return Err(EINVAL);
             }
-            if freeze.is_clearing {
+            let is_frozen = freeze.node.owner.inner.lock().is_frozen.is_fully_frozen();
-                // Immediately send another FreezeMessage for BR_CLEAR_FREEZE_NOTIFICATION_DONE.
+            if freeze.is_clearing || freeze.last_is_frozen != Some(is_frozen) {
+                // Immediately send another FreezeMessage.
                 clear_msg = Some(FreezeMessage::init(alloc, cookie));
             }
             freeze.is_pending = false;

drivers/android/binder/node.rs+1−1

@@ -687,7 +687,7 @@ impl Node { · 686 unmodified lines
687	);	687	);
688	}	688	}
689	if inner.freeze_list.is_empty() {	689	if inner.freeze_list.is_empty() {
690	_unused_capacity = mem::replace(&mut inner.freeze_list, KVVec::new());	690	_unused_capacity = mem::take(&mut inner.freeze_list);
691	}	691	}
692	}	692	}
693		693

drivers/android/binder/process.rs+37−13

 const PROC_DEFER_FLUSH: u8 = 1;
 const PROC_DEFER_RELEASE: u8 = 2;
+#[derive(Copy, Clone)]
+pub(crate) enum IsFrozen {
+    Yes,
+    No,
+    InProgress,
+}
+impl IsFrozen {
+    /// Whether incoming transactions should be rejected due to freeze.
+    pub(crate) fn is_frozen(self) -> bool {
+        match self {
+            IsFrozen::Yes => true,
+            IsFrozen::No => false,
+            IsFrozen::InProgress => true,
+        }
+    }
+    /// Whether freeze notifications consider this process frozen.
+    pub(crate) fn is_fully_frozen(self) -> bool {
+        match self {
+            IsFrozen::Yes => true,
+            IsFrozen::No => false,
+            IsFrozen::InProgress => false,
+        }
+    }
+}
 /// The fields of `Process` protected by the spinlock.
 pub(crate) struct ProcessInner {
     is_manager: bool,
     /// are woken up.
     outstanding_txns: u32,
     /// Process is frozen and unable to service binder transactions.
-    pub(crate) is_frozen: bool,
+    pub(crate) is_frozen: IsFrozen,
     /// Process received sync transactions since last frozen.
     pub(crate) sync_recv: bool,
     /// Process received async transactions since last frozen.
             started_thread_count: 0,
             defer_work: 0,
             outstanding_txns: 0,
-            is_frozen: false,
+            is_frozen: IsFrozen::No,
             sync_recv: false,
             async_recv: false,
             binderfs_file: None,
         let is_manager = {
             let mut inner = self.inner.lock();
             inner.is_dead = true;
-            inner.is_frozen = false;
+            inner.is_frozen = IsFrozen::No;
             inner.sync_recv = false;
             inner.async_recv = false;
             inner.is_manager
                 .alloc
                 .take_for_each(|offset, size, debug_id, odata| {
                     let ptr = offset + address;
-                    pr_warn!(
-                        "{}: removing orphan mapping {offset}:{size}\n",
-                        self.pid_in_current_ns()
-                    );
                     let mut alloc =
                         Allocation::new(self.clone(), debug_id, offset, size, ptr, false);
                     if let Some(data) = odata {
                 return;
             }
             inner.outstanding_txns -= 1;
-            inner.is_frozen && inner.outstanding_txns == 0
+            inner.is_frozen.is_frozen() && inner.outstanding_txns == 0
         };
         if wake {
             let mut inner = self.inner.lock();
             inner.sync_recv = false;
             inner.async_recv = false;
-            inner.is_frozen = false;
+            inner.is_frozen = IsFrozen::No;
             drop(inner);
             msgs.send_messages();
             return Ok(());
         let mut inner = self.inner.lock();
         inner.sync_recv = false;
         inner.async_recv = false;
-        inner.is_frozen = true;
+        inner.is_frozen = IsFrozen::InProgress;
         if info.timeout_ms > 0 {
             let mut jiffies = kernel::time::msecs_to_jiffies(info.timeout_ms);
                     .wait_interruptible_timeout(&mut inner, jiffies)
                 {
                     CondVarTimeoutResult::Signal { .. } => {
-                        inner.is_frozen = false;
+                        inner.is_frozen = IsFrozen::No;
                         return Err(ERESTARTSYS);
                     }
                     CondVarTimeoutResult::Woken { jiffies: remaining } => {
         }
         if inner.txns_pending_locked() {
-            inner.is_frozen = false;
+            inner.is_frozen = IsFrozen::No;
             Err(EAGAIN)
         } else {
             drop(inner);
             match self.prepare_freeze_messages() {
                 Ok(batch) => {
+                    self.inner.lock().is_frozen = IsFrozen::Yes;
                     batch.send_messages();
                     Ok(())
                 }
                 Err(kernel::alloc::AllocError) => {
-                    self.inner.lock().is_frozen = false;
+                    self.inner.lock().is_frozen = IsFrozen::No;
                     Err(ENOMEM)
                 }
             }

drivers/android/binder/transaction.rs+3−3

@@ -249,7 +249,7 @@ impl Transaction { · 248 unmodified lines
249		249
250	if oneway {	250	if oneway {
251	if let Some(target_node) = self.target_node.clone() {	251	if let Some(target_node) = self.target_node.clone() {
252	if process_inner.is_frozen {	252	if process_inner.is_frozen.is_frozen() {
253	process_inner.async_recv = true;	253	process_inner.async_recv = true;
254	if self.flags & TF_UPDATE_TXN != 0 {	254	if self.flags & TF_UPDATE_TXN != 0 {
255	if let Some(t_outdated) =	255	if let Some(t_outdated) =
@@ -270,7 +270,7 @@ impl Transaction { · 14 unmodified lines
270	}	270	}
271	}	271	}
272		272
273	if process_inner.is_frozen {	273	if process_inner.is_frozen.is_frozen() {
274	return Err(BinderError::new_frozen_oneway());	274	return Err(BinderError::new_frozen_oneway());
275	} else {	275	} else {
276	return Ok(());	276	return Ok(());
@@ -280,7 +280,7 @@ impl Transaction { · 3 unmodified lines
280	}	280	}
281	}	281	}
282		282
283	if process_inner.is_frozen {	283	if process_inner.is_frozen.is_frozen() {
284	process_inner.sync_recv = true;	284	process_inner.sync_recv = true;
285	return Err(BinderError::new_frozen());	285	return Err(BinderError::new_frozen());
286	}	286	}

drivers/base/arch_topology.c+1−1

@@ -292,7 +292,7 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu) · 291 unmodified lines
292	* frequency (by keeping the initial capacity_freq_ref value).	292	* frequency (by keeping the initial capacity_freq_ref value).
293	*/	293	*/
294	cpu_clk = of_clk_get(cpu_node, 0);	294	cpu_clk = of_clk_get(cpu_node, 0);
295	if (!PTR_ERR_OR_ZERO(cpu_clk)) {	295	if (!IS_ERR_OR_NULL(cpu_clk)) {
296	per_cpu(capacity_freq_ref, cpu) =	296	per_cpu(capacity_freq_ref, cpu) =
297	clk_get_rate(cpu_clk) / HZ_PER_KHZ;	297	clk_get_rate(cpu_clk) / HZ_PER_KHZ;
298	clk_put(cpu_clk);	298	clk_put(cpu_clk);

drivers/base/core.c+1−1

@@ -1784,7 +1784,7 @@ static int fw_devlink_dev_sync_state(struct device dev, void data) · 1783 unmodified lines
1784	return 0;	1784	return 0;
1785		1785
1786	if (fw_devlink_sync_state == FW_DEVLINK_SYNC_STATE_STRICT) {	1786	if (fw_devlink_sync_state == FW_DEVLINK_SYNC_STATE_STRICT) {
1787	dev_warn(sup, "sync_state() pending due to %s\n",	1787	dev_info(sup, "sync_state() pending due to %s\n",
1788	dev_name(link->consumer));	1788	dev_name(link->consumer));
1789	return 0;	1789	return 0;
1790	}	1790	}

drivers/base/devcoredump.c+83−53

@@ -23,50 +23,46 @@ struct devcd_entry { · 22 unmodified lines
23	void *data;	23	void *data;
24	size_t datalen;	24	size_t datalen;
25	/*	25	/*
26	* Here, mutex is required to serialize the calls to del_wk work between	26	* There are 2 races for which mutex is required.
27	* user/kernel space which happens when devcd is added with device_add()
28	* and that sends uevent to user space. User space reads the uevents,
29	* and calls to devcd_data_write() which try to modify the work which is
30	* not even initialized/queued from devcoredump.
31	*	27	*
		28	* The first race is between device creation and userspace writing to
		29	* schedule immediately destruction.
32	*	30	*
		31	* This race is handled by arming the timer before device creation, but
		32	* when device creation fails the timer still exists.
33	*	33	*
34	* cpu0(X) cpu1(Y)	34	* To solve this, hold the mutex during device_add(), and set
		35	* init_completed on success before releasing the mutex.
35	*	36	*
36	* dev_coredump() uevent sent to user space	37	* That way the timer will never fire until device_add() is called,
37	* device_add() ======================> user space process Y reads the	38	* it will do nothing if init_completed is not set. The timer is also
38	* uevents writes to devcd fd	39	* cancelled in that case.
39	* which results into writes to
40	*	40	*
41	* devcd_data_write()	41	* The second race involves multiple parallel invocations of devcd_free(),
42	* mod_delayed_work()	42	* add a deleted flag so only 1 can call the destructor.
43	* try_to_grab_pending()
44	* timer_delete()
45	* debug_assert_init()
46	* INIT_DELAYED_WORK()
47	* schedule_delayed_work()
48	*
49	*
50	* Also, mutex alone would not be enough to avoid scheduling of
51	* del_wk work after it get flush from a call to devcd_free()
52	* mentioned as below.
53	*
54	* disabled_store()
55	* devcd_free()
56	* mutex_lock() devcd_data_write()
57	* flush_delayed_work()
58	* mutex_unlock()
59	* mutex_lock()
60	* mod_delayed_work()
61	* mutex_unlock()
62	* So, delete_work flag is required.
63	*/	43	*/
64	struct mutex mutex;	44	struct mutex mutex;
65	bool delete_work;	45	bool init_completed, deleted;
66	struct module *owner;	46	struct module *owner;
67	ssize_t (read)(char buffer, loff_t offset, size_t count,	47	ssize_t (read)(char buffer, loff_t offset, size_t count,
68	void *data, size_t datalen);	48	void *data, size_t datalen);
69	void (free)(void data);	49	void (free)(void data);
		50	/*
		51	* If nothing interferes and device_add() was returns success,
		52	* del_wk will destroy the device after the timer fires.
		53	*
		54	* Multiple userspace processes can interfere in the working of the timer:
		55	* - Writing to the coredump will reschedule the timer to run immediately,
		56	* if still armed.
		57	*
		58	* This is handled by using "if (cancel_delayed_work()) {
		59	* schedule_delayed_work() }", to prevent re-arming after having
		60	* been previously fired.
		61	* - Writing to /sys/class/devcoredump/disabled will destroy the
		62	* coredump synchronously.
		63	* This is handled by using disable_delayed_work_sync(), and then
		64	* checking if deleted flag is set with &devcd->mutex held.
		65	*/
70	struct delayed_work del_wk;	66	struct delayed_work del_wk;
71	struct device *failing_dev;	67	struct device *failing_dev;
72	};	68	};
@@ -95,14 +91,27 @@ static void devcd_dev_release(struct device *dev) · 22 unmodified lines
95	kfree(devcd);	91	kfree(devcd);
96	}	92	}
97		93
		94	static void __devcd_del(struct devcd_entry *devcd)
		95	{
		96	devcd->deleted = true;
		97	device_del(&devcd->devcd_dev);
		98	put_device(&devcd->devcd_dev);
		99	}
		100
98	static void devcd_del(struct work_struct *wk)	101	static void devcd_del(struct work_struct *wk)
99	{	102	{
100	struct devcd_entry *devcd;	103	struct devcd_entry *devcd;
		104	bool init_completed;
101		105
102	devcd = container_of(wk, struct devcd_entry, del_wk.work);	106	devcd = container_of(wk, struct devcd_entry, del_wk.work);
103		107
104	device_del(&devcd->devcd_dev);	108	/* devcd->mutex serializes against dev_coredumpm_timeout */
105	put_device(&devcd->devcd_dev);	109	mutex_lock(&devcd->mutex);
		110	init_completed = devcd->init_completed;
		111	mutex_unlock(&devcd->mutex);
		112
		113	if (init_completed)
		114	__devcd_del(devcd);
106	}	115	}
107		116
108	static ssize_t devcd_data_read(struct file filp, struct kobject kobj,	117	static ssize_t devcd_data_read(struct file filp, struct kobject kobj,
@@ -122,12 +131,12 @@ static ssize_t devcd_data_write(struct file filp, struct kobject kobj, · 13 unmodified lines
122	struct device *dev = kobj_to_dev(kobj);	131	struct device *dev = kobj_to_dev(kobj);
123	struct devcd_entry *devcd = dev_to_devcd(dev);	132	struct devcd_entry *devcd = dev_to_devcd(dev);
124		133
125	mutex_lock(&devcd->mutex);	134	/*
126	if (!devcd->delete_work) {	135	* Although it's tempting to use mod_delayed work here,
127	devcd->delete_work = true;	136	* that will cause a reschedule if the timer already fired.
128	mod_delayed_work(system_wq, &devcd->del_wk, 0);	137	*/
129	}	138	if (cancel_delayed_work(&devcd->del_wk))
130	mutex_unlock(&devcd->mutex);	139	schedule_delayed_work(&devcd->del_wk, 0);
131		140
132	return count;	141	return count;
133	}	142	}
@@ -151,11 +160,21 @@ static int devcd_free(struct device dev, void data) · 17 unmodified lines
151	{	160	{
152	struct devcd_entry *devcd = dev_to_devcd(dev);	161	struct devcd_entry *devcd = dev_to_devcd(dev);
153		162
		163	/*
		164	* To prevent a race with devcd_data_write(), disable work and
		165	* complete manually instead.
		166	*
		167	* We cannot rely on the return value of
		168	* disable_delayed_work_sync() here, because it might be in the
		169	* middle of a cancel_delayed_work + schedule_delayed_work pair.
		170	*
		171	* devcd->mutex here guards against multiple parallel invocations
		172	* of devcd_free().
		173	*/
		174	disable_delayed_work_sync(&devcd->del_wk);
154	mutex_lock(&devcd->mutex);	175	mutex_lock(&devcd->mutex);
155	if (!devcd->delete_work)	176	if (!devcd->deleted)
156	devcd->delete_work = true;	177	__devcd_del(devcd);
157
158	flush_delayed_work(&devcd->del_wk);
159	mutex_unlock(&devcd->mutex);	178	mutex_unlock(&devcd->mutex);
160	return 0;	179	return 0;
161	}	180	}
@@ -179,12 +198,10 @@ static ssize_t disabled_show(const struct class *class, const struct class_attri · 17 unmodified lines
179	* put_device() <- last reference	198	* put_device() <- last reference
180	* error = fn(dev, data) devcd_dev_release()	199	* error = fn(dev, data) devcd_dev_release()
181	* devcd_free(dev, data) kfree(devcd)	200	* devcd_free(dev, data) kfree(devcd)
182	* mutex_lock(&devcd->mutex);
183	*	201	*
184	*	202	*
185	* In the above diagram, it looks like disabled_store() would be racing with parallelly	203	* In the above diagram, it looks like disabled_store() would be racing with parallelly
186	* running devcd_del() and result in memory abort while acquiring devcd->mutex which	204	* running devcd_del() and result in memory abort after dropping its last reference with
187	* is called after kfree of devcd memory after dropping its last reference with
188	* put_device(). However, this will not happens as fn(dev, data) runs	205	* put_device(). However, this will not happens as fn(dev, data) runs
189	* with its own reference to device via klist_node so it is not its last reference.	206	* with its own reference to device via klist_node so it is not its last reference.
190	* so, above situation would not occur.	207	* so, above situation would not occur.
@@ -374,7 +391,7 @@ void dev_coredumpm_timeout(struct device dev, struct module owner, · 183 unmodified lines
374	devcd->read = read;	391	devcd->read = read;
375	devcd->free = free;	392	devcd->free = free;
376	devcd->failing_dev = get_device(dev);	393	devcd->failing_dev = get_device(dev);
377	devcd->delete_work = false;	394	devcd->deleted = false;
378		395
379	mutex_init(&devcd->mutex);	396	mutex_init(&devcd->mutex);
380	device_initialize(&devcd->devcd_dev);	397	device_initialize(&devcd->devcd_dev);
@@ -383,8 +400,14 @@ void dev_coredumpm_timeout(struct device dev, struct module owner, · 2 unmodified lines
383	atomic_inc_return(&devcd_count));	400	atomic_inc_return(&devcd_count));
384	devcd->devcd_dev.class = &devcd_class;	401	devcd->devcd_dev.class = &devcd_class;
385		402
386	mutex_lock(&devcd->mutex);
387	dev_set_uevent_suppress(&devcd->devcd_dev, true);	403	dev_set_uevent_suppress(&devcd->devcd_dev, true);
		404
		405	/* devcd->mutex prevents devcd_del() completing until init finishes */
		406	mutex_lock(&devcd->mutex);
		407	devcd->init_completed = false;
		408	INIT_DELAYED_WORK(&devcd->del_wk, devcd_del);
		409	schedule_delayed_work(&devcd->del_wk, timeout);
		410
388	if (device_add(&devcd->devcd_dev))	411	if (device_add(&devcd->devcd_dev))
389	goto put_device;	412	goto put_device;
390		413
@@ -401,13 +424,20 @@ void dev_coredumpm_timeout(struct device dev, struct module owner, · 10 unmodified lines
401		424
402	dev_set_uevent_suppress(&devcd->devcd_dev, false);	425	dev_set_uevent_suppress(&devcd->devcd_dev, false);
403	kobject_uevent(&devcd->devcd_dev.kobj, KOBJ_ADD);	426	kobject_uevent(&devcd->devcd_dev.kobj, KOBJ_ADD);
404	INIT_DELAYED_WORK(&devcd->del_wk, devcd_del);	427
405	schedule_delayed_work(&devcd->del_wk, timeout);	428	/*
		429	* Safe to run devcd_del() now that we are done with devcd_dev.
		430	* Alternatively we could have taken a ref on devcd_dev before
		431	* dropping the lock.
		432	*/
		433	devcd->init_completed = true;
406	mutex_unlock(&devcd->mutex);	434	mutex_unlock(&devcd->mutex);
407	return;	435	return;
408	put_device:	436	put_device:
409	put_device(&devcd->devcd_dev);
410	mutex_unlock(&devcd->mutex);	437	mutex_unlock(&devcd->mutex);
		438	cancel_delayed_work_sync(&devcd->del_wk);
		439	put_device(&devcd->devcd_dev);
		440
411	put_module:	441	put_module:
412	module_put(owner);	442	module_put(owner);
413	free:	443	free:

drivers/block/nbd.c+15−0

 static DEFINE_IDR(nbd_index_idr);
 static DEFINE_MUTEX(nbd_index_mutex);
 static struct workqueue_struct *nbd_del_wq;
+static struct cred *nbd_cred;
 static int nbd_total_devices = 0;
 struct nbd_sock {
 	int result;
 	struct msghdr msg = {} ;
 	unsigned int noreclaim_flag;
+	const struct cred *old_cred;
 	if (unlikely(!sock)) {
 		dev_err_ratelimited(disk_to_dev(nbd->disk),
 		return -EINVAL;
 	}
+	old_cred = override_creds(nbd_cred);
 	msg.msg_iter = *iter;
 	noreclaim_flag = memalloc_noreclaim_save();
 	memalloc_noreclaim_restore(noreclaim_flag);
+	revert_creds(old_cred);
 	return result;
 }
 		return -ENOMEM;
 	}
+	nbd_cred = prepare_kernel_cred(&init_task);
+	if (!nbd_cred) {
+		destroy_workqueue(nbd_del_wq);
+		unregister_blkdev(NBD_MAJOR, "nbd");
+		return -ENOMEM;
+	}
 	if (genl_register_family(&nbd_genl_family)) {
+		put_cred(nbd_cred);
 		destroy_workqueue(nbd_del_wq);
 		unregister_blkdev(NBD_MAJOR, "nbd");
 		return -EINVAL;
 	/* Also wait for nbd_dev_remove_work() completes */
 	destroy_workqueue(nbd_del_wq);
+	put_cred(nbd_cred);
 	idr_destroy(&nbd_index_idr);
 	unregister_blkdev(NBD_MAJOR, "nbd");
 }

drivers/comedi/comedi_buf.c+1−1

@@ -317,7 +317,7 @@ static unsigned int comedi_buf_munge(struct comedi_subdevice *s, · 316 unmodified lines
317	unsigned int count = 0;	317	unsigned int count = 0;
318	const unsigned int num_sample_bytes = comedi_bytes_per_sample(s);	318	const unsigned int num_sample_bytes = comedi_bytes_per_sample(s);
319		319
320	if (!s->munge \|\| (async->cmd.flags & CMDF_RAWDATA)) {	320	if (!s->munge \|\| (async->cmd.flags & CMDF_RAWDATA) \|\| async->cmd.chanlist_len == 0) {
321	async->munge_count += num_bytes;	321	async->munge_count += num_bytes;
322	return num_bytes;	322	return num_bytes;
323	}	323	}

drivers/cpufreq/amd-pstate.c+5−1

 	 * min_perf value across kexec reboots. If this CPU is just onlined normally after this, the
 	 * limits, epp and desired perf will get reset to the cached values in cpudata struct
 	 */
-	return amd_pstate_update_perf(policy, perf.bios_min_perf, 0U, 0U, 0U, false);
+	return amd_pstate_update_perf(policy, perf.bios_min_perf,
+				     FIELD_GET(AMD_CPPC_DES_PERF_MASK, cpudata->cppc_req_cached),
+				     FIELD_GET(AMD_CPPC_MAX_PERF_MASK, cpudata->cppc_req_cached),
+				     FIELD_GET(AMD_CPPC_EPP_PERF_MASK, cpudata->cppc_req_cached),
+				     false);
 }
 static int amd_pstate_suspend(struct cpufreq_policy *policy)

drivers/cpuidle/governors/menu.c+9−12

 	 *
 	 * This can deal with workloads that have long pauses interspersed
 	 * with sporadic activity with a bunch of short pauses.
+	 *
+	 * However, if the number of remaining samples is too small to exclude
+	 * any more outliers, allow the deepest available idle state to be
+	 * selected because there are systems where the time spent by CPUs in
+	 * deep idle states is correlated to the maximum frequency the CPUs
+	 * can get to.  On those systems, shallow idle states should be avoided
+	 * unless there is a clear indication that the given CPU is most likley
+	 * going to be woken up shortly.
 	 */
-	if (divisor * 4 <= INTERVALS * 3) {
+	if (divisor * 4 <= INTERVALS * 3)
-		/*
-		 * If there are sufficiently many data points still under
-		 * consideration after the outliers have been eliminated,
-		 * returning without a prediction would be a mistake because it
-		 * is likely that the next interval will not exceed the current
-		 * maximum, so return the latter in that case.
-		 */
-		if (divisor >= INTERVALS / 2)
-			return max;
 		return UINT_MAX;
-	}
 	/* Update the thresholds for the next round. */
 	if (avg - min > max - avg)

drivers/firewire/core-transaction.c+1−1

@@ -269,7 +269,7 @@ static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel, · 268 unmodified lines
269	}	269	}
270		270
271	static int allocate_tlabel(struct fw_card *card)	271	static int allocate_tlabel(struct fw_card *card)
272	__must_hold(&card->transactions_lock)	272	__must_hold(&card->transactions.lock)
273	{	273	{
274	int tlabel;	274	int tlabel;
275		275

drivers/firewire/init_ohci1394_dma.c+10−0

 /**
  * init_ohci1394_wait_for_busresets - wait until bus resets are completed
+ * @ohci: Pointer to the OHCI-1394 controller structure
  *
  * OHCI1394 initialization itself and any device going on- or offline
  * and any cable issue cause a IEEE1394 bus reset. The OHCI1394 spec
 /**
  * init_ohci1394_enable_physical_dma - Enable physical DMA for remote debugging
+ * @ohci: Pointer to the OHCI-1394 controller structure
+ *
  * This enables remote DMA access over IEEE1394 from every host for the low
  * 4GB of address space. DMA accesses above 4GB are not available currently.
  */
 /**
  * init_ohci1394_reset_and_init_dma - init controller and enable DMA
+ * @ohci: Pointer to the OHCI-1394 controller structure
+ *
  * This initializes the given controller and enables physical DMA engine in it.
  */
 static inline void __init init_ohci1394_reset_and_init_dma(struct ohci *ohci)
 /**
  * init_ohci1394_controller - Map the registers of the controller and init DMA
+ * @num: PCI bus number
+ * @slot: PCI device number
+ * @func: PCI function number
+ *
  * This maps the registers of the specified controller and initializes it
  */
 static inline void __init init_ohci1394_controller(int num, int slot, int func)
 /**
  * setup_ohci1394_dma - enables early OHCI1394 DMA initialization
+ * @opt: Kernel command line parameter string
  */
 static int __init setup_ohci1394_dma(char *opt)
 {

drivers/firmware/arm_ffa/driver.c+27−10

 	return FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK | FFA_MEM_INNER_SHAREABLE;
 }
+static void ffa_emad_impdef_value_init(u32 version, void *dst, void *src)
+{
+	struct ffa_mem_region_attributes *ep_mem_access;
+	if (FFA_EMAD_HAS_IMPDEF_FIELD(version))
+		memcpy(dst, src, sizeof(ep_mem_access->impdef_val));
+}
+static void
+ffa_mem_region_additional_setup(u32 version, struct ffa_mem_region *mem_region)
+{
+	if (!FFA_MEM_REGION_HAS_EP_MEM_OFFSET(version)) {
+		mem_region->ep_mem_size = 0;
+	} else {
+		mem_region->ep_mem_size = ffa_emad_size_get(version);
+		mem_region->ep_mem_offset = sizeof(*mem_region);
+		memset(mem_region->reserved, 0, 12);
+	}
+}
 static int
 ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
 		       struct ffa_mem_ops_args *args)
 	mem_region->flags = args->flags;
 	mem_region->sender_id = drv_info->vm_id;
 	mem_region->attributes = ffa_memory_attributes_get(func_id);
-	ep_mem_access = buffer +
-			ffa_mem_desc_offset(buffer, 0, drv_info->version);
 	composite_offset = ffa_mem_desc_offset(buffer, args->nattrs,
 					       drv_info->version);
-	for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {
+	for (idx = 0; idx < args->nattrs; idx++) {
+		ep_mem_access = buffer +
+			ffa_mem_desc_offset(buffer, idx, drv_info->version);
 		ep_mem_access->receiver = args->attrs[idx].receiver;
 		ep_mem_access->attrs = args->attrs[idx].attrs;
 		ep_mem_access->composite_off = composite_offset;
 		ep_mem_access->flag = 0;
 		ep_mem_access->reserved = 0;
+		ffa_emad_impdef_value_init(drv_info->version,
+					   ep_mem_access->impdef_val,
+					   args->attrs[idx].impdef_val);
 	}
 	mem_region->handle = 0;
 	mem_region->ep_count = args->nattrs;
-	if (drv_info->version <= FFA_VERSION_1_0) {
+	ffa_mem_region_additional_setup(drv_info->version, mem_region);
-		mem_region->ep_mem_size = 0;
-	} else {
-		mem_region->ep_mem_size = sizeof(*ep_mem_access);
-		mem_region->ep_mem_offset = sizeof(*mem_region);
-		memset(mem_region->reserved, 0, 12);
-	}
 	composite = buffer + composite_offset;
 	composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg);

drivers/firmware/arm_scmi/common.h+26−6

@@ -309,16 +309,36 @@ enum debug_counters { · 308 unmodified lines
309	SCMI_DEBUG_COUNTERS_LAST	309	SCMI_DEBUG_COUNTERS_LAST
310	};	310	};
311		311
312	static inline void scmi_inc_count(atomic_t *arr, int stat)	312	/**
		313	* struct scmi_debug_info - Debug common info
		314	* @top_dentry: A reference to the top debugfs dentry
		315	* @name: Name of this SCMI instance
		316	* @type: Type of this SCMI instance
		317	* @is_atomic: Flag to state if the transport of this instance is atomic
		318	* @counters: An array of atomic_c's used for tracking statistics (if enabled)
		319	*/
		320	struct scmi_debug_info {
		321	struct dentry *top_dentry;
		322	const char *name;
		323	const char *type;
		324	bool is_atomic;
		325	atomic_t counters[SCMI_DEBUG_COUNTERS_LAST];
		326	};
		327
		328	static inline void scmi_inc_count(struct scmi_debug_info *dbg, int stat)
313	{	329	{
314	if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS))	330	if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS)) {
315	atomic_inc(&arr[stat]);	331	if (dbg)
		332	atomic_inc(&dbg->counters[stat]);
		333	}
316	}	334	}
317		335
318	static inline void scmi_dec_count(atomic_t *arr, int stat)	336	static inline void scmi_dec_count(struct scmi_debug_info *dbg, int stat)
319	{	337	{
320	if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS))	338	if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS)) {
321	atomic_dec(&arr[stat]);	339	if (dbg)
		340	atomic_dec(&dbg->counters[stat]);
		341	}
322	}	342	}
323		343
324	enum scmi_bad_msg {	344	enum scmi_bad_msg {

drivers/firmware/arm_scmi/driver.c+21−38

 #define ph_to_pi(h)	container_of(h, struct scmi_protocol_instance, ph)
-/**
- * struct scmi_debug_info  - Debug common info
- * @top_dentry: A reference to the top debugfs dentry
- * @name: Name of this SCMI instance
- * @type: Type of this SCMI instance
- * @is_atomic: Flag to state if the transport of this instance is atomic
- * @counters: An array of atomic_c's used for tracking statistics (if enabled)
- */
-struct scmi_debug_info {
-	struct dentry *top_dentry;
-	const char *name;
-	const char *type;
-	bool is_atomic;
-	atomic_t counters[SCMI_DEBUG_COUNTERS_LAST];
-};
 /**
  * struct scmi_info - Structure representing a SCMI instance
  *
 	/* Set in-flight */
 	set_bit(xfer->hdr.seq, minfo->xfer_alloc_table);
 	hash_add(minfo->pending_xfers, &xfer->node, xfer->hdr.seq);
-	scmi_inc_count(info->dbg->counters, XFERS_INFLIGHT);
+	scmi_inc_count(info->dbg, XFERS_INFLIGHT);
 	xfer->pending = true;
 }
 			hash_del(&xfer->node);
 			xfer->pending = false;
-			scmi_dec_count(info->dbg->counters, XFERS_INFLIGHT);
+			scmi_dec_count(info->dbg, XFERS_INFLIGHT);
 		}
+		xfer->flags = 0;
 		hlist_add_head(&xfer->node, &minfo->free_xfers);
 	}
 	spin_unlock_irqrestore(&minfo->xfer_lock, flags);
 {
 	struct scmi_info *info = handle_to_scmi_info(handle);
-	xfer->flags &= ~SCMI_XFER_FLAG_IS_RAW;
-	xfer->flags &= ~SCMI_XFER_FLAG_CHAN_SET;
 	return __scmi_xfer_put(&info->tx_minfo, xfer);
 }
 		spin_unlock_irqrestore(&minfo->xfer_lock, flags);
 		scmi_bad_message_trace(cinfo, msg_hdr, MSG_UNEXPECTED);
-		scmi_inc_count(info->dbg->counters, ERR_MSG_UNEXPECTED);
+		scmi_inc_count(info->dbg, ERR_MSG_UNEXPECTED);
 		return xfer;
 	}
 			msg_type, xfer_id, msg_hdr, xfer->state);
 		scmi_bad_message_trace(cinfo, msg_hdr, MSG_INVALID);
-		scmi_inc_count(info->dbg->counters, ERR_MSG_INVALID);
+		scmi_inc_count(info->dbg, ERR_MSG_INVALID);
 		/* On error the refcount incremented above has to be dropped */
 		__scmi_xfer_put(minfo, xfer);
 			PTR_ERR(xfer));
 		scmi_bad_message_trace(cinfo, msg_hdr, MSG_NOMEM);
-		scmi_inc_count(info->dbg->counters, ERR_MSG_NOMEM);
+		scmi_inc_count(info->dbg, ERR_MSG_NOMEM);
 		scmi_clear_channel(info, cinfo);
 		return;
 	trace_scmi_msg_dump(info->id, cinfo->id, xfer->hdr.protocol_id,
 			    xfer->hdr.id, "NOTI", xfer->hdr.seq,
 			    xfer->hdr.status, xfer->rx.buf, xfer->rx.len);
-	scmi_inc_count(info->dbg->counters, NOTIFICATION_OK);
+	scmi_inc_count(info->dbg, NOTIFICATION_OK);
 	scmi_notify(cinfo->handle, xfer->hdr.protocol_id,
 		    xfer->hdr.id, xfer->rx.buf, xfer->rx.len, ts);
 	if (xfer->hdr.type == MSG_TYPE_DELAYED_RESP) {
 		scmi_clear_channel(info, cinfo);
 		complete(xfer->async_done);
-		scmi_inc_count(info->dbg->counters, DELAYED_RESPONSE_OK);
+		scmi_inc_count(info->dbg, DELAYED_RESPONSE_OK);
 	} else {
 		complete(&xfer->done);
-		scmi_inc_count(info->dbg->counters, RESPONSE_OK);
+		scmi_inc_count(info->dbg, RESPONSE_OK);
 	}
 	if (IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT)) {
 					"timed out in resp(caller: %pS) - polling\n",
 					(void *)_RET_IP_);
 				ret = -ETIMEDOUT;
-				scmi_inc_count(info->dbg->counters, XFERS_RESPONSE_POLLED_TIMEOUT);
+				scmi_inc_count(info->dbg, XFERS_RESPONSE_POLLED_TIMEOUT);
 			}
 		}
 					    "RESP" : "resp",
 					    xfer->hdr.seq, xfer->hdr.status,
 					    xfer->rx.buf, xfer->rx.len);
-			scmi_inc_count(info->dbg->counters, RESPONSE_POLLED_OK);
+			scmi_inc_count(info->dbg, RESPONSE_POLLED_OK);
 			if (IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT)) {
 				scmi_raw_message_report(info->raw, xfer,
 			dev_err(dev, "timed out in resp(caller: %pS)\n",
 				(void *)_RET_IP_);
 			ret = -ETIMEDOUT;
-			scmi_inc_count(info->dbg->counters, XFERS_RESPONSE_TIMEOUT);
+			scmi_inc_count(info->dbg, XFERS_RESPONSE_TIMEOUT);
 		}
 	}
 	    !is_transport_polling_capable(info->desc)) {
 		dev_warn_once(dev,
 			      "Polling mode is not supported by transport.\n");
-		scmi_inc_count(info->dbg->counters, SENT_FAIL_POLLING_UNSUPPORTED);
+		scmi_inc_count(info->dbg, SENT_FAIL_POLLING_UNSUPPORTED);
 		return -EINVAL;
 	}
 	cinfo = idr_find(&info->tx_idr, pi->proto->id);
 	if (unlikely(!cinfo)) {
-		scmi_inc_count(info->dbg->counters, SENT_FAIL_CHANNEL_NOT_FOUND);
+		scmi_inc_count(info->dbg, SENT_FAIL_CHANNEL_NOT_FOUND);
 		return -EINVAL;
 	}
 	/* True ONLY if also supported by transport. */
 	ret = info->desc->ops->send_message(cinfo, xfer);
 	if (ret < 0) {
 		dev_dbg(dev, "Failed to send message %d\n", ret);
-		scmi_inc_count(info->dbg->counters, SENT_FAIL);
+		scmi_inc_count(info->dbg, SENT_FAIL);
 		return ret;
 	}
 	trace_scmi_msg_dump(info->id, cinfo->id, xfer->hdr.protocol_id,
 			    xfer->hdr.id, "CMND", xfer->hdr.seq,
 			    xfer->hdr.status, xfer->tx.buf, xfer->tx.len);
-	scmi_inc_count(info->dbg->counters, SENT_OK);
+	scmi_inc_count(info->dbg, SENT_OK);
 	ret = scmi_wait_for_message_response(cinfo, xfer);
 	if (!ret && xfer->hdr.status) {
 		ret = scmi_to_linux_errno(xfer->hdr.status);
-		scmi_inc_count(info->dbg->counters, ERR_PROTOCOL);
+		scmi_inc_count(info->dbg, ERR_PROTOCOL);
 	}
 	if (info->desc->ops->mark_txdone)
 	u8 channels[SCMI_MAX_CHANNELS] = {};
 	DECLARE_BITMAP(protos, SCMI_MAX_CHANNELS) = {};
-	if (!info->dbg)
-		return -EINVAL;
 	/* Enumerate all channels to collect their ids */
 	idr_for_each_entry(&info->tx_idr, cinfo, id) {
 		/*
 		if (!info->dbg)
 			dev_warn(dev, "Failed to setup SCMI debugfs.\n");
-		if (IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT)) {
+		if (info->dbg && IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT)) {
 			ret = scmi_debugfs_raw_mode_setup(info);
 			if (!coex) {
 				if (ret)
 	if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS)) {
 		struct scmi_info *info = handle_to_scmi_info(handle);
+		if (!info->dbg)
+			return 0;
 		return atomic_read(&info->dbg->counters[XFERS_INFLIGHT]);
 	} else {
 		return 0;

drivers/firmware/efi/libstub/Makefile+2−2

@@ -11,12 +11,12 @@ cflags-y := $(KBUILD_CFLAGS) · 10 unmodified lines
11		11
12	cflags-$(CONFIG_X86_32) := -march=i386	12	cflags-$(CONFIG_X86_32) := -march=i386
13	cflags-$(CONFIG_X86_64) := -mcmodel=small	13	cflags-$(CONFIG_X86_64) := -mcmodel=small
14	cflags-$(CONFIG_X86) += -m$(BITS) -D__KERNEL__ -std=gnu11 \	14	cflags-$(CONFIG_X86) += -m$(BITS) -D__KERNEL__ -std=gnu11 -fms-extensions \
15	-fPIC -fno-strict-aliasing -mno-red-zone \	15	-fPIC -fno-strict-aliasing -mno-red-zone \
16	-mno-mmx -mno-sse -fshort-wchar \	16	-mno-mmx -mno-sse -fshort-wchar \
17	-Wno-pointer-sign \	17	-Wno-pointer-sign \
18	$(call cc-disable-warning, address-of-packed-member) \	18	$(call cc-disable-warning, address-of-packed-member) \
19	$(call cc-disable-warning, gnu) \	19	$(if $(CONFIG_CC_IS_CLANG),-Wno-gnu -Wno-microsoft-anon-tag) \
20	-fno-asynchronous-unwind-tables \	20	-fno-asynchronous-unwind-tables \
21	$(CLANG_FLAGS)	21	$(CLANG_FLAGS)
22		22

drivers/gpio/gpio-104-idio-16.c+1−0

@@ -59,6 +59,7 @@ static const struct regmap_config idio_16_regmap_config = { · 58 unmodified lines
59	.reg_stride = 1,	59	.reg_stride = 1,
60	.val_bits = 8,	60	.val_bits = 8,
61	.io_port = true,	61	.io_port = true,
		62	.max_register = 0x5,
62	.wr_table = &idio_16_wr_table,	63	.wr_table = &idio_16_wr_table,
63	.rd_table = &idio_16_rd_table,	64	.rd_table = &idio_16_rd_table,
64	.volatile_table = &idio_16_rd_table,	65	.volatile_table = &idio_16_rd_table,

drivers/gpio/gpio-idio-16.c+5−0

 #define DEFAULT_SYMBOL_NAMESPACE "GPIO_IDIO_16"
+#include <linux/bitmap.h>
 #include <linux/bits.h>
 #include <linux/device.h>
 #include <linux/err.h>
 	struct idio_16_data *data;
 	struct regmap_irq_chip *chip;
 	struct regmap_irq_chip_data *chip_data;
+	DECLARE_BITMAP(fixed_direction_output, IDIO_16_NGPIO);
 	if (!config->parent)
 		return -EINVAL;
 	gpio_config.irq_domain = regmap_irq_get_domain(chip_data);
 	gpio_config.reg_mask_xlate = idio_16_reg_mask_xlate;
+	bitmap_from_u64(fixed_direction_output, GENMASK_U64(15, 0));
+	gpio_config.fixed_direction_output = fixed_direction_output;
 	return PTR_ERR_OR_ZERO(devm_gpio_regmap_register(dev, &gpio_config));
 }
 EXPORT_SYMBOL_GPL(devm_idio_16_regmap_register);

drivers/gpio/gpio-ljca.c+3−11

 {
 	const struct ljca_gpio_packet *packet = evt_data;
 	struct ljca_gpio_dev *ljca_gpio = context;
-	int i, irq;
+	int i;
 	if (cmd != LJCA_GPIO_INT_EVENT)
 		return;
 	for (i = 0; i < packet->num; i++) {
-		irq = irq_find_mapping(ljca_gpio->gc.irq.domain,
+		generic_handle_domain_irq(ljca_gpio->gc.irq.domain,
-				       packet->item[i].index);
+					packet->item[i].index);
-		if (!irq) {
-			dev_err(ljca_gpio->gc.parent,
-				"gpio_id %u does not mapped to IRQ yet\n",
-				packet->item[i].index);
-			return;
-		}
-		generic_handle_domain_irq(ljca_gpio->gc.irq.domain, irq);
 		set_bit(packet->item[i].index, ljca_gpio->reenable_irqs);
 	}

drivers/gpio/gpio-pci-idio-16.c+1−0

@@ -41,6 +41,7 @@ static const struct regmap_config idio_16_regmap_config = { · 40 unmodified lines
41	.reg_stride = 1,	41	.reg_stride = 1,
42	.val_bits = 8,	42	.val_bits = 8,
43	.io_port = true,	43	.io_port = true,
		44	.max_register = 0x7,
44	.wr_table = &idio_16_wr_table,	45	.wr_table = &idio_16_wr_table,
45	.rd_table = &idio_16_rd_table,	46	.rd_table = &idio_16_rd_table,
46	.volatile_table = &idio_16_rd_table,	47	.volatile_table = &idio_16_rd_table,

drivers/gpio/gpio-regmap.c+24−2

 	unsigned int reg_clr_base;
 	unsigned int reg_dir_in_base;
 	unsigned int reg_dir_out_base;
+	unsigned long *fixed_direction_output;
 #ifdef CONFIG_REGMAP_IRQ
 	int regmap_irq_line;
 	unsigned int base, val, reg, mask;
 	int invert, ret;
+	if (gpio->fixed_direction_output) {
+		if (test_bit(offset, gpio->fixed_direction_output))
+			return GPIO_LINE_DIRECTION_OUT;
+		else
+			return GPIO_LINE_DIRECTION_IN;
+	}
 	if (gpio->reg_dat_base && !gpio->reg_set_base)
 		return GPIO_LINE_DIRECTION_IN;
 	if (gpio->reg_set_base && !gpio->reg_dat_base)
 			goto err_free_gpio;
 	}
+	if (config->fixed_direction_output) {
+		gpio->fixed_direction_output = bitmap_alloc(chip->ngpio,
+							    GFP_KERNEL);
+		if (!gpio->fixed_direction_output) {
+			ret = -ENOMEM;
+			goto err_free_gpio;
+		}
+		bitmap_copy(gpio->fixed_direction_output,
+			    config->fixed_direction_output, chip->ngpio);
+	}
 	/* if not set, assume there is only one register */
 	gpio->ngpio_per_reg = config->ngpio_per_reg;
 	if (!gpio->ngpio_per_reg)
 	ret = gpiochip_add_data(chip, gpio);
 	if (ret < 0)
-		goto err_free_gpio;
+		goto err_free_bitmap;
 #ifdef CONFIG_REGMAP_IRQ
 	if (config->regmap_irq_chip) {
 						 config->regmap_irq_line, config->regmap_irq_flags,
 						 0, config->regmap_irq_chip, &gpio->irq_chip_data);
 		if (ret)
-			goto err_free_gpio;
+			goto err_free_bitmap;
 		irq_domain = regmap_irq_get_domain(gpio->irq_chip_data);
 	} else
 err_remove_gpiochip:
 	gpiochip_remove(chip);
+err_free_bitmap:
+	bitmap_free(gpio->fixed_direction_output);
 err_free_gpio:
 	kfree(gpio);
 	return ERR_PTR(ret);
 #endif
 	gpiochip_remove(&gpio->gpio_chip);
+	bitmap_free(gpio->fixed_direction_output);
 	kfree(gpio);
 }
 EXPORT_SYMBOL_GPL(gpio_regmap_unregister);

drivers/gpio/gpiolib-acpi-core.c+17−14

 	return GPIOD_ASIS;
 }
+static void acpi_gpio_set_debounce_timeout(struct gpio_desc *desc,
+					   unsigned int acpi_debounce)
+{
+	int ret;
+	/* ACPI uses hundredths of milliseconds units */
+	acpi_debounce *= 10;
+	ret = gpio_set_debounce_timeout(desc, acpi_debounce);
+	if (ret)
+		gpiod_warn(desc, "Failed to set debounce-timeout %u: %d\n",
+			   acpi_debounce, ret);
+}
 static struct gpio_desc *acpi_request_own_gpiod(struct gpio_chip *chip,
 						struct acpi_resource_gpio *agpio,
 						unsigned int index,
 	enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio, polarity);
 	unsigned int pin = agpio->pin_table[index];
 	struct gpio_desc *desc;
-	int ret;
 	desc = gpiochip_request_own_desc(chip, pin, label, polarity, flags);
 	if (IS_ERR(desc))
 		return desc;
-	/* ACPI uses hundredths of milliseconds units */
+	acpi_gpio_set_debounce_timeout(desc, agpio->debounce_timeout);
-	ret = gpio_set_debounce_timeout(desc, agpio->debounce_timeout * 10);
-	if (ret)
-		dev_warn(chip->parent,
-			 "Failed to set debounce-timeout for pin 0x%04X, err %d\n",
-			 pin, ret);
 	return desc;
 }
 	desc = acpi_request_own_gpiod(chip, agpio, 0, "ACPI:Event");
 	if (IS_ERR(desc)) {
 		dev_err(chip->parent,
-			"Failed to request GPIO for pin 0x%04X, err %ld\n",
+			"Failed to request GPIO for pin 0x%04X, err %pe\n",
-			pin, PTR_ERR(desc));
+			pin, desc);
 		return AE_OK;
 	}
 	bool can_fallback = acpi_can_fallback_to_crs(adev, con_id);
 	struct acpi_gpio_info info = {};
 	struct gpio_desc *desc;
-	int ret;
 	desc = __acpi_find_gpio(fwnode, con_id, idx, can_fallback, &info);
 	if (IS_ERR(desc))
 	acpi_gpio_update_gpiod_flags(dflags, &info);
 	acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info);
-	/* ACPI uses hundredths of milliseconds units */
+	acpi_gpio_set_debounce_timeout(desc, info.debounce);
-	ret = gpio_set_debounce_timeout(desc, info.debounce * 10);
-	if (ret)
-		return ERR_PTR(ret);
 	return desc;
 }

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+2−2

@@ -551,13 +551,13 @@ static void schedule_dc_vmin_vmax(struct amdgpu_device *adev, · 550 unmodified lines
551	struct dc_stream_state *stream,	551	struct dc_stream_state *stream,
552	struct dc_crtc_timing_adjust *adjust)	552	struct dc_crtc_timing_adjust *adjust)
553	{	553	{
554	struct vupdate_offload_work offload_work = kzalloc(sizeof(offload_work), GFP_KERNEL);	554	struct vupdate_offload_work offload_work = kzalloc(sizeof(offload_work), GFP_NOWAIT);
555	if (!offload_work) {	555	if (!offload_work) {
556	drm_dbg_driver(adev_to_drm(adev), "Failed to allocate vupdate_offload_work\n");	556	drm_dbg_driver(adev_to_drm(adev), "Failed to allocate vupdate_offload_work\n");
557	return;	557	return;
558	}	558	}
559		559
560	struct dc_crtc_timing_adjust adjust_copy = kzalloc(sizeof(adjust_copy), GFP_KERNEL);	560	struct dc_crtc_timing_adjust adjust_copy = kzalloc(sizeof(adjust_copy), GFP_NOWAIT);
561	if (!adjust_copy) {	561	if (!adjust_copy) {
562	drm_dbg_driver(adev_to_drm(adev), "Failed to allocate adjust_copy\n");	562	drm_dbg_driver(adev_to_drm(adev), "Failed to allocate adjust_copy\n");
563	kfree(offload_work);	563	kfree(offload_work);

drivers/gpu/drm/amd/display/dc/hwss/dcn401/dcn401_hwseq.c+3−0

@@ -200,6 +200,9 @@ void dcn401_init_hw(struct dc *dc) · 199 unmodified lines
200	*/	200	*/
201	struct dc_link *link = dc->links[i];	201	struct dc_link *link = dc->links[i];
202		202
		203	if (link->ep_type != DISPLAY_ENDPOINT_PHY)
		204	continue;
		205
203	link->link_enc->funcs->hw_init(link->link_enc);	206	link->link_enc->funcs->hw_init(link->link_enc);
204		207
205	/* Check for enabled DIG to identify enabled display */	208	/* Check for enabled DIG to identify enabled display */

drivers/gpu/drm/amd/display/dc/inc/hw/hw_shared.h+7−1

@@ -44,7 +44,13 @@ · 43 unmodified lines
44	*/	44	*/
45	#define MAX_PIPES 6	45	#define MAX_PIPES 6
46	#define MAX_PHANTOM_PIPES (MAX_PIPES / 2)	46	#define MAX_PHANTOM_PIPES (MAX_PIPES / 2)
47	#define MAX_LINKS (MAX_PIPES * 2 +2)	47
		48	#define MAX_DPIA 6
		49	#define MAX_CONNECTOR 6
		50	#define MAX_VIRTUAL_LINKS 4
		51
		52	#define MAX_LINKS (MAX_DPIA + MAX_CONNECTOR + MAX_VIRTUAL_LINKS)
		53
48	#define MAX_DIG_LINK_ENCODERS 7	54	#define MAX_DIG_LINK_ENCODERS 7
49	#define MAX_DWB_PIPES 1	55	#define MAX_DWB_PIPES 1
50	#define MAX_HPO_DP2_ENCODERS 4	56	#define MAX_HPO_DP2_ENCODERS 4

drivers/gpu/drm/amd/display/dc/link/accessories/link_dp_cts.c+2−1

 	struct audio_output audio_output[MAX_PIPES];
 	struct dc_stream_state *streams_on_link[MAX_PIPES];
 	int num_streams_on_link = 0;
+	struct dc *dc = (struct dc *)link->dc;
 	needs_divider_update = (link->dc->link_srv->dp_get_encoding_format(link_setting) !=
 	link->dc->link_srv->dp_get_encoding_format((const struct dc_link_settings *) &link->cur_link_settings));
 		if (streams_on_link[i] && streams_on_link[i]->link && streams_on_link[i]->link == link) {
 			stream_update.stream = streams_on_link[i];
 			stream_update.dpms_off = &dpms_off;
-			dc_update_planes_and_stream(state->clk_mgr->ctx->dc, NULL, 0, streams_on_link[i], &stream_update);
+			dc_update_planes_and_stream(dc, NULL, 0, streams_on_link[i], &stream_update);
 		}
 	}
 }

drivers/gpu/drm/drm_panic.c+54−6

 	*p = color & 0xff;
 }
+/*
+ * Special case if the pixel crosses page boundaries
+ */
+static void drm_panic_write_pixel24_xpage(void *vaddr, struct page *next_page,
+					  unsigned int offset, u32 color)
+{
+	u8 *vaddr2;
+	u8 *p = vaddr + offset;
+	vaddr2 = kmap_local_page_try_from_panic(next_page);
+	*p++ = color & 0xff;
+	color >>= 8;
+	if (offset == PAGE_SIZE - 1)
+		p = vaddr2;
+	*p++ = color & 0xff;
+	color >>= 8;
+	if (offset == PAGE_SIZE - 2)
+		p = vaddr2;
+	*p = color & 0xff;
+	kunmap_local(vaddr2);
+}
 static void drm_panic_write_pixel32(void *vaddr, unsigned int offset, u32 color)
 {
 	u32 *p = vaddr + offset;
 					page = new_page;
 					vaddr = kmap_local_page_try_from_panic(pages[page]);
 				}
-				if (vaddr)
+				if (!vaddr)
+					continue;
+				// Special case for 24bit, as a pixel might cross page boundaries
+				if (cpp == 3 && offset + 3 > PAGE_SIZE)
+					drm_panic_write_pixel24_xpage(vaddr, pages[page + 1],
+								      offset, fg32);
+				else
 					drm_panic_write_pixel(vaddr, offset, fg32, cpp);
 			}
 		}
 				page = new_page;
 				vaddr = kmap_local_page_try_from_panic(pages[page]);
 			}
-			drm_panic_write_pixel(vaddr, offset, color, cpp);
+			if (!vaddr)
+				continue;
+			// Special case for 24bit, as a pixel might cross page boundaries
+			if (cpp == 3 && offset + 3 > PAGE_SIZE)
+				drm_panic_write_pixel24_xpage(vaddr, pages[page + 1],
+							      offset, color);
+			else
+				drm_panic_write_pixel(vaddr, offset, color, cpp);
 		}
 	}
 	if (vaddr)
 static void drm_panic_logo_draw(struct drm_scanout_buffer *sb, struct drm_rect *rect,
 				const struct font_desc *font, u32 fg_color)
 {
+	if (rect->x2 > sb->width || rect->y2 > sb->height)
+		return;
 	if (logo_mono)
 		drm_panic_blit(sb, rect, logo_mono->data,
 			       DIV_ROUND_UP(drm_rect_width(rect), 8), 1, fg_color);
 			       struct drm_panic_line *line, int yoffset, u32 fg_color)
 {
 	int chars_per_row = sb->width / font->width;
-	struct drm_rect r_txt = DRM_RECT_INIT(0, yoffset, sb->width, sb->height);
+	struct drm_rect r_txt = DRM_RECT_INIT(0, yoffset, sb->width, font->height);
 	struct drm_panic_line line_wrap;
 	if (line->len > chars_per_row) {
 	struct drm_panic_line line;
 	int yoffset;
-	if (!font)
+	if (!font || font->width > sb->width)
 		return;
 	yoffset = sb->height - font->height - (sb->height % font->height) / 2;
 	pr_debug("QR width %d and scale %d\n", qr_width, scale);
 	r_qr_canvas = DRM_RECT_INIT(0, 0, qr_canvas_width * scale, qr_canvas_width * scale);
-	v_margin = (sb->height - drm_rect_height(&r_qr_canvas) - drm_rect_height(&r_msg)) / 5;
+	v_margin = sb->height - drm_rect_height(&r_qr_canvas) - drm_rect_height(&r_msg);
+	if (v_margin < 0)
+		return -ENOSPC;
+	v_margin /= 5;
 	drm_rect_translate(&r_qr_canvas, (sb->width - r_qr_canvas.x2) / 2, 2 * v_margin);
 	r_qr = DRM_RECT_INIT(r_qr_canvas.x1 + QR_MARGIN * scale, r_qr_canvas.y1 + QR_MARGIN * scale,
 	/* Fill with the background color, and draw text on top */
 	drm_panic_fill(sb, &r_screen, bg_color);
-	if (!drm_rect_overlap(&r_logo, &r_msg) && !drm_rect_overlap(&r_logo, &r_qr))
+	if (!drm_rect_overlap(&r_logo, &r_msg) && !drm_rect_overlap(&r_logo, &r_qr_canvas))
 		drm_panic_logo_draw(sb, &r_logo, font, fg_color);
 	draw_txt_rectangle(sb, font, panic_msg, panic_msg_lines, true, &r_msg, fg_color);

drivers/gpu/drm/i915/display/intel_fb.c+13−12

 	intel_frontbuffer_put(intel_fb->frontbuffer);
+	kfree(intel_fb->panic);
 	kfree(intel_fb);
 }
 	struct intel_display *display = to_intel_display(obj->dev);
 	struct drm_framebuffer *fb = &intel_fb->base;
 	u32 max_stride;
-	int ret = -EINVAL;
+	int ret;
 	int i;
+	intel_fb->panic = intel_panic_alloc();
+	if (!intel_fb->panic)
+		return -ENOMEM;
 	/*
 	 * intel_frontbuffer_get() must be done before
 	 * intel_fb_bo_framebuffer_init() to avoid set_tiling vs. addfb race.
 	 */
 	intel_fb->frontbuffer = intel_frontbuffer_get(obj);
-	if (!intel_fb->frontbuffer)
+	if (!intel_fb->frontbuffer) {
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto err_free_panic;
+	}
 	ret = intel_fb_bo_framebuffer_init(fb, obj, mode_cmd);
 	if (ret)
 	intel_fb_bo_framebuffer_fini(obj);
 err_frontbuffer_put:
 	intel_frontbuffer_put(intel_fb->frontbuffer);
+err_free_panic:
+	kfree(intel_fb->panic);
 	return ret;
 }
 struct intel_framebuffer *intel_framebuffer_alloc(void)
 {
 	struct intel_framebuffer *intel_fb;
-	struct intel_panic *panic;
 	intel_fb = kzalloc(sizeof(*intel_fb), GFP_KERNEL);
 	if (!intel_fb)
 		return NULL;
-	panic = intel_panic_alloc();
-	if (!panic) {
-		kfree(intel_fb);
-		return NULL;
-	}
-	intel_fb->panic = panic;
 	return intel_fb;
 }

drivers/gpu/drm/panthor/panthor_mmu.c+7−3

 		break;
 	case DRM_PANTHOR_VM_BIND_OP_TYPE_UNMAP:
-		/* Partial unmaps might trigger a remap with either a prev or a next VA,
+		/* Two VMAs can be needed for an unmap, as an unmap can happen
-		 * but not both.
+		 * in the middle of a drm_gpuva, requiring a remap with both
+		 * prev & next VA. Or an unmap can span more than one drm_gpuva
+		 * where the first and last ones are covered partially, requring
+		 * a remap for the first with a prev VA and remap for the last
+		 * with a next VA.
 		 */
-		vma_count = 1;
+		vma_count = 2;
 		break;
 	default:

drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c+1−1

@@ -361,7 +361,7 @@ static void dw_hdmi_rk3228_setup_hpd(struct dw_hdmi dw_hdmi, void data) · 360 unmodified lines
361		361
362	regmap_write(hdmi->regmap, RK3228_GRF_SOC_CON2,	362	regmap_write(hdmi->regmap, RK3228_GRF_SOC_CON2,
363	FIELD_PREP_WM16(RK3228_HDMI_SDAIN_MSK, 1) \|	363	FIELD_PREP_WM16(RK3228_HDMI_SDAIN_MSK, 1) \|
364	FIELD_PREP_WM16(RK3328_HDMI_SCLIN_MSK, 1));	364	FIELD_PREP_WM16(RK3228_HDMI_SCLIN_MSK, 1));
365	}	365	}
366		366
367	static enum drm_connector_status	367	static enum drm_connector_status

drivers/gpu/drm/xe/xe_ggtt.c+3−0

@@ -292,6 +292,9 @@ int xe_ggtt_init_early(struct xe_ggtt *ggtt) · 291 unmodified lines
292	ggtt->pt_ops = &xelp_pt_ops;	292	ggtt->pt_ops = &xelp_pt_ops;
293		293
294	ggtt->wq = alloc_workqueue("xe-ggtt-wq", 0, WQ_MEM_RECLAIM);	294	ggtt->wq = alloc_workqueue("xe-ggtt-wq", 0, WQ_MEM_RECLAIM);
		295	if (!ggtt->wq)
		296	return -ENOMEM;
		297
295	__xe_ggtt_init_early(ggtt, xe_wopcm_size(xe));	298	__xe_ggtt_init_early(ggtt, xe_wopcm_size(xe));
296		299
297	err = drmm_add_action_or_reset(&xe->drm, ggtt_fini_early, ggtt);	300	err = drmm_add_action_or_reset(&xe->drm, ggtt_fini_early, ggtt);

drivers/gpu/drm/xe/xe_pt.c+2−2

@@ -2022,7 +2022,7 @@ static int op_prepare(struct xe_vm *vm, · 2021 unmodified lines
2022	case DRM_GPUVA_OP_MAP:	2022	case DRM_GPUVA_OP_MAP:
2023	if ((!op->map.immediate && xe_vm_in_fault_mode(vm) &&	2023	if ((!op->map.immediate && xe_vm_in_fault_mode(vm) &&
2024	!op->map.invalidate_on_bind) \|\|	2024	!op->map.invalidate_on_bind) \|\|
2025	op->map.is_cpu_addr_mirror)	2025	(op->map.vma_flags & XE_VMA_SYSTEM_ALLOCATOR))
2026	break;	2026	break;
2027		2027
2028	err = bind_op_prepare(vm, tile, pt_update_ops, op->map.vma,	2028	err = bind_op_prepare(vm, tile, pt_update_ops, op->map.vma,
@@ -2252,7 +2252,7 @@ static void op_commit(struct xe_vm *vm, · 223 unmodified lines
2252	switch (op->base.op) {	2252	switch (op->base.op) {
2253	case DRM_GPUVA_OP_MAP:	2253	case DRM_GPUVA_OP_MAP:
2254	if ((!op->map.immediate && xe_vm_in_fault_mode(vm)) \|\|	2254	if ((!op->map.immediate && xe_vm_in_fault_mode(vm)) \|\|
2255	op->map.is_cpu_addr_mirror)	2255	(op->map.vma_flags & XE_VMA_SYSTEM_ALLOCATOR))
2256	break;	2256	break;
2257		2257
2258	bind_op_commit(vm, tile, pt_update_ops, op->map.vma, fence,	2258	bind_op_commit(vm, tile, pt_update_ops, op->map.vma, fence,

drivers/gpu/drm/xe/xe_svm.c+5−0

 	if (!vma)
 		return -EINVAL;
+	if (!(vma->gpuva.flags & XE_VMA_MADV_AUTORESET)) {
+		drm_dbg(&vm->xe->drm, "Skipping madvise reset for vma.\n");
+		return 0;
+	}
 	if (xe_vma_has_default_mem_attrs(vma))
 		return 0;

drivers/gpu/drm/xe/xe_vm.c+37−59

@@ -616,6 +616,13 @@ static void xe_vma_ops_incr_pt_update_ops(struct xe_vma_ops *vops, u8 tile_mask, · 615 unmodified lines
616	vops->pt_update_ops[i].num_ops += inc_val;	616	vops->pt_update_ops[i].num_ops += inc_val;
617	}	617	}
618		618
		619	#define XE_VMA_CREATE_MASK ( \
		620	XE_VMA_READ_ONLY \| \
		621	XE_VMA_DUMPABLE \| \
		622	XE_VMA_SYSTEM_ALLOCATOR \| \
		623	DRM_GPUVA_SPARSE \| \
		624	XE_VMA_MADV_AUTORESET)
		625
619	static void xe_vm_populate_rebind(struct xe_vma_op op, struct xe_vma vma,	626	static void xe_vm_populate_rebind(struct xe_vma_op op, struct xe_vma vma,
620	u8 tile_mask)	627	u8 tile_mask)
621	{	628	{
@@ -628,8 +635,7 @@ static void xe_vm_populate_rebind(struct xe_vma_op op, struct xe_vma vma, · 6 unmodified lines
628	op->base.map.gem.offset = vma->gpuva.gem.offset;	635	op->base.map.gem.offset = vma->gpuva.gem.offset;
629	op->map.vma = vma;	636	op->map.vma = vma;
630	op->map.immediate = true;	637	op->map.immediate = true;
631	op->map.dumpable = vma->gpuva.flags & XE_VMA_DUMPABLE;	638	op->map.vma_flags = vma->gpuva.flags & XE_VMA_CREATE_MASK;
632	op->map.is_null = xe_vma_is_null(vma);
633	}	639	}
634		640
635	static int xe_vm_ops_add_rebind(struct xe_vma_ops vops, struct xe_vma vma,	641	static int xe_vm_ops_add_rebind(struct xe_vma_ops vops, struct xe_vma vma,
@@ -932,11 +938,6 @@ static void xe_vma_free(struct xe_vma *vma) · 296 unmodified lines
932	kfree(vma);	938	kfree(vma);
933	}	939	}
934		940
935	#define VMA_CREATE_FLAG_READ_ONLY BIT(0)
936	#define VMA_CREATE_FLAG_IS_NULL BIT(1)
937	#define VMA_CREATE_FLAG_DUMPABLE BIT(2)
938	#define VMA_CREATE_FLAG_IS_SYSTEM_ALLOCATOR BIT(3)
939
940	static struct xe_vma xe_vma_create(struct xe_vm vm,	941	static struct xe_vma xe_vma_create(struct xe_vm vm,
941	struct xe_bo *bo,	942	struct xe_bo *bo,
942	u64 bo_offset_or_userptr,	943	u64 bo_offset_or_userptr,
@@ -947,11 +948,8 @@ static struct xe_vma xe_vma_create(struct xe_vm vm, · 4 unmodified lines
947	struct xe_vma *vma;	948	struct xe_vma *vma;
948	struct xe_tile *tile;	949	struct xe_tile *tile;
949	u8 id;	950	u8 id;
950	bool read_only = (flags & VMA_CREATE_FLAG_READ_ONLY);	951	bool is_null = (flags & DRM_GPUVA_SPARSE);
951	bool is_null = (flags & VMA_CREATE_FLAG_IS_NULL);	952	bool is_cpu_addr_mirror = (flags & XE_VMA_SYSTEM_ALLOCATOR);
952	bool dumpable = (flags & VMA_CREATE_FLAG_DUMPABLE);
953	bool is_cpu_addr_mirror =
954	(flags & VMA_CREATE_FLAG_IS_SYSTEM_ALLOCATOR);
955		953
956	xe_assert(vm->xe, start < end);	954	xe_assert(vm->xe, start < end);
957	xe_assert(vm->xe, end < vm->size);	955	xe_assert(vm->xe, end < vm->size);
@@ -972,10 +970,6 @@ static struct xe_vma xe_vma_create(struct xe_vm vm, · 14 unmodified lines
972	if (!vma)	970	if (!vma)
973	return ERR_PTR(-ENOMEM);	971	return ERR_PTR(-ENOMEM);
974		972
975	if (is_cpu_addr_mirror)
976	vma->gpuva.flags \|= XE_VMA_SYSTEM_ALLOCATOR;
977	if (is_null)
978	vma->gpuva.flags \|= DRM_GPUVA_SPARSE;
979	if (bo)	973	if (bo)
980	vma->gpuva.gem.obj = &bo->ttm.base;	974	vma->gpuva.gem.obj = &bo->ttm.base;
981	}	975	}
@@ -986,10 +980,7 @@ static struct xe_vma xe_vma_create(struct xe_vm vm, · 4 unmodified lines
986	vma->gpuva.vm = &vm->gpuvm;	980	vma->gpuva.vm = &vm->gpuvm;
987	vma->gpuva.va.addr = start;	981	vma->gpuva.va.addr = start;
988	vma->gpuva.va.range = end - start + 1;	982	vma->gpuva.va.range = end - start + 1;
989	if (read_only)	983	vma->gpuva.flags = flags;
990	vma->gpuva.flags \|= XE_VMA_READ_ONLY;
991	if (dumpable)
992	vma->gpuva.flags \|= XE_VMA_DUMPABLE;
993		984
994	for_each_tile(tile, vm->xe, id)	985	for_each_tile(tile, vm->xe, id)
995	vma->tile_mask \|= 0x1 << id;	986	vma->tile_mask \|= 0x1 << id;
@@ -2272,12 +2263,16 @@ vm_bind_ioctl_ops_create(struct xe_vm vm, struct xe_vma_ops vops, · 1276 unmodified lines
2272	if (__op->op == DRM_GPUVA_OP_MAP) {	2263	if (__op->op == DRM_GPUVA_OP_MAP) {
2273	op->map.immediate =	2264	op->map.immediate =
2274	flags & DRM_XE_VM_BIND_FLAG_IMMEDIATE;	2265	flags & DRM_XE_VM_BIND_FLAG_IMMEDIATE;
2275	op->map.read_only =	2266	if (flags & DRM_XE_VM_BIND_FLAG_READONLY)
2276	flags & DRM_XE_VM_BIND_FLAG_READONLY;	2267	op->map.vma_flags \|= XE_VMA_READ_ONLY;
2277	op->map.is_null = flags & DRM_XE_VM_BIND_FLAG_NULL;	2268	if (flags & DRM_XE_VM_BIND_FLAG_NULL)
2278	op->map.is_cpu_addr_mirror = flags &	2269	op->map.vma_flags \|= DRM_GPUVA_SPARSE;
2279	DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR;	2270	if (flags & DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR)
2280	op->map.dumpable = flags & DRM_XE_VM_BIND_FLAG_DUMPABLE;	2271	op->map.vma_flags \|= XE_VMA_SYSTEM_ALLOCATOR;
		2272	if (flags & DRM_XE_VM_BIND_FLAG_DUMPABLE)
		2273	op->map.vma_flags \|= XE_VMA_DUMPABLE;
		2274	if (flags & DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET)
		2275	op->map.vma_flags \|= XE_VMA_MADV_AUTORESET;
2281	op->map.pat_index = pat_index;	2276	op->map.pat_index = pat_index;
2282	op->map.invalidate_on_bind =	2277	op->map.invalidate_on_bind =
2283	__xe_vm_needs_clear_scratch_pages(vm, flags);	2278	__xe_vm_needs_clear_scratch_pages(vm, flags);
@@ -2590,14 +2585,7 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm vm, struct drm_gpuva_ops ops, · 306 unmodified lines
2590	.pat_index = op->map.pat_index,	2585	.pat_index = op->map.pat_index,
2591	};	2586	};
2592		2587
2593	flags \|= op->map.read_only ?	2588	flags \|= op->map.vma_flags & XE_VMA_CREATE_MASK;
2594	VMA_CREATE_FLAG_READ_ONLY : 0;
2595	flags \|= op->map.is_null ?
2596	VMA_CREATE_FLAG_IS_NULL : 0;
2597	flags \|= op->map.dumpable ?
2598	VMA_CREATE_FLAG_DUMPABLE : 0;
2599	flags \|= op->map.is_cpu_addr_mirror ?
2600	VMA_CREATE_FLAG_IS_SYSTEM_ALLOCATOR : 0;
2601		2589
2602	vma = new_vma(vm, &op->base.map, &default_attr,	2590	vma = new_vma(vm, &op->base.map, &default_attr,
2603	flags);	2591	flags);
@@ -2606,7 +2594,7 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm vm, struct drm_gpuva_ops ops, · 2 unmodified lines
2606		2594
2607	op->map.vma = vma;	2595	op->map.vma = vma;
2608	if (((op->map.immediate \|\| !xe_vm_in_fault_mode(vm)) &&	2596	if (((op->map.immediate \|\| !xe_vm_in_fault_mode(vm)) &&
2609	!op->map.is_cpu_addr_mirror) \|\|	2597	!(op->map.vma_flags & XE_VMA_SYSTEM_ALLOCATOR)) \|\|
2610	op->map.invalidate_on_bind)	2598	op->map.invalidate_on_bind)
2611	xe_vma_ops_incr_pt_update_ops(vops,	2599	xe_vma_ops_incr_pt_update_ops(vops,
2612	op->tile_mask, 1);	2600	op->tile_mask, 1);
@@ -2637,18 +2625,7 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm vm, struct drm_gpuva_ops ops, · 24 unmodified lines
2637	op->remap.start = xe_vma_start(old);	2625	op->remap.start = xe_vma_start(old);
2638	op->remap.range = xe_vma_size(old);	2626	op->remap.range = xe_vma_size(old);
2639		2627
2640	flags \|= op->base.remap.unmap->va->flags &	2628	flags \|= op->base.remap.unmap->va->flags & XE_VMA_CREATE_MASK;
2641	XE_VMA_READ_ONLY ?
2642	VMA_CREATE_FLAG_READ_ONLY : 0;
2643	flags \|= op->base.remap.unmap->va->flags &
2644	DRM_GPUVA_SPARSE ?
2645	VMA_CREATE_FLAG_IS_NULL : 0;
2646	flags \|= op->base.remap.unmap->va->flags &
2647	XE_VMA_DUMPABLE ?
2648	VMA_CREATE_FLAG_DUMPABLE : 0;
2649	flags \|= xe_vma_is_cpu_addr_mirror(old) ?
2650	VMA_CREATE_FLAG_IS_SYSTEM_ALLOCATOR : 0;
2651
2652	if (op->base.remap.prev) {	2629	if (op->base.remap.prev) {
2653	vma = new_vma(vm, op->base.remap.prev,	2630	vma = new_vma(vm, op->base.remap.prev,
2654	&old->attr, flags);	2631	&old->attr, flags);
@@ -3279,7 +3256,8 @@ ALLOW_ERROR_INJECTION(vm_bind_ioctl_ops_execute, ERRNO); · 624 unmodified lines
3279	DRM_XE_VM_BIND_FLAG_NULL \| \	3256	DRM_XE_VM_BIND_FLAG_NULL \| \
3280	DRM_XE_VM_BIND_FLAG_DUMPABLE \| \	3257	DRM_XE_VM_BIND_FLAG_DUMPABLE \| \
3281	DRM_XE_VM_BIND_FLAG_CHECK_PXP \| \	3258	DRM_XE_VM_BIND_FLAG_CHECK_PXP \| \
3282	DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR)	3259	DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR \| \
		3260	DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET)
3283		3261
3284	#ifdef TEST_VM_OPS_ERROR	3262	#ifdef TEST_VM_OPS_ERROR
3285	#define SUPPORTED_FLAGS (SUPPORTED_FLAGS_STUB \| FORCE_OP_ERROR)	3263	#define SUPPORTED_FLAGS (SUPPORTED_FLAGS_STUB \| FORCE_OP_ERROR)
@@ -3394,7 +3372,9 @@ static int vm_bind_ioctl_check_args(struct xe_device xe, struct xe_vm vm, · 108 unmodified lines
3394	XE_IOCTL_DBG(xe, (prefetch_region != DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC &&	3372	XE_IOCTL_DBG(xe, (prefetch_region != DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC &&
3395	!(BIT(prefetch_region) & xe->info.mem_region_mask))) \|\|	3373	!(BIT(prefetch_region) & xe->info.mem_region_mask))) \|\|
3396	XE_IOCTL_DBG(xe, obj &&	3374	XE_IOCTL_DBG(xe, obj &&
3397	op == DRM_XE_VM_BIND_OP_UNMAP)) {	3375	op == DRM_XE_VM_BIND_OP_UNMAP) \|\|
		3376	XE_IOCTL_DBG(xe, (flags & DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET) &&
		3377	(!is_cpu_addr_mirror \|\| op != DRM_XE_VM_BIND_OP_MAP))) {
3398	err = -EINVAL;	3378	err = -EINVAL;
3399	goto free_bind_ops;	3379	goto free_bind_ops;
3400	}	3380	}
@@ -4212,7 +4192,7 @@ static int xe_vm_alloc_vma(struct xe_vm *vm, · 811 unmodified lines
4212	struct xe_vma_ops vops;	4192	struct xe_vma_ops vops;
4213	struct drm_gpuva_ops *ops = NULL;	4193	struct drm_gpuva_ops *ops = NULL;
4214	struct drm_gpuva_op *__op;	4194	struct drm_gpuva_op *__op;
4215	bool is_cpu_addr_mirror = false;	4195	unsigned int vma_flags = 0;
4216	bool remap_op = false;	4196	bool remap_op = false;
4217	struct xe_vma_mem_attr tmp_attr;	4197	struct xe_vma_mem_attr tmp_attr;
4218	u16 default_pat;	4198	u16 default_pat;
@@ -4242,15 +4222,17 @@ static int xe_vm_alloc_vma(struct xe_vm *vm, · 23 unmodified lines
4242	vma = gpuva_to_vma(op->base.unmap.va);	4222	vma = gpuva_to_vma(op->base.unmap.va);
4243	XE_WARN_ON(!xe_vma_has_default_mem_attrs(vma));	4223	XE_WARN_ON(!xe_vma_has_default_mem_attrs(vma));
4244	default_pat = vma->attr.default_pat_index;	4224	default_pat = vma->attr.default_pat_index;
		4225	vma_flags = vma->gpuva.flags;
4245	}	4226	}
4246		4227
4247	if (__op->op == DRM_GPUVA_OP_REMAP) {	4228	if (__op->op == DRM_GPUVA_OP_REMAP) {
4248	vma = gpuva_to_vma(op->base.remap.unmap->va);	4229	vma = gpuva_to_vma(op->base.remap.unmap->va);
4249	default_pat = vma->attr.default_pat_index;	4230	default_pat = vma->attr.default_pat_index;
		4231	vma_flags = vma->gpuva.flags;
4250	}	4232	}
4251		4233
4252	if (__op->op == DRM_GPUVA_OP_MAP) {	4234	if (__op->op == DRM_GPUVA_OP_MAP) {
4253	op->map.is_cpu_addr_mirror = true;	4235	op->map.vma_flags \|= vma_flags & XE_VMA_CREATE_MASK;
4254	op->map.pat_index = default_pat;	4236	op->map.pat_index = default_pat;
4255	}	4237	}
4256	} else {	4238	} else {
@@ -4259,11 +4241,7 @@ static int xe_vm_alloc_vma(struct xe_vm *vm, · 2 unmodified lines
4259	xe_assert(vm->xe, !remap_op);	4241	xe_assert(vm->xe, !remap_op);
4260	xe_assert(vm->xe, xe_vma_has_no_bo(vma));	4242	xe_assert(vm->xe, xe_vma_has_no_bo(vma));
4261	remap_op = true;	4243	remap_op = true;
4262		4244	vma_flags = vma->gpuva.flags;
4263	if (xe_vma_is_cpu_addr_mirror(vma))
4264	is_cpu_addr_mirror = true;
4265	else
4266	is_cpu_addr_mirror = false;
4267	}	4245	}
4268		4246
4269	if (__op->op == DRM_GPUVA_OP_MAP) {	4247	if (__op->op == DRM_GPUVA_OP_MAP) {
@@ -4272,10 +4250,10 @@ static int xe_vm_alloc_vma(struct xe_vm *vm, · 2 unmodified lines
4272	/*	4250	/*
4273	* In case of madvise ops DRM_GPUVA_OP_MAP is	4251	* In case of madvise ops DRM_GPUVA_OP_MAP is
4274	* always after DRM_GPUVA_OP_REMAP, so ensure	4252	* always after DRM_GPUVA_OP_REMAP, so ensure
4275	* we assign op->map.is_cpu_addr_mirror true	4253	* to propagate the flags from the vma we're
4276	* if REMAP is for xe_vma_is_cpu_addr_mirror vma	4254	* unmapping.
4277	*/	4255	*/
4278	op->map.is_cpu_addr_mirror = is_cpu_addr_mirror;	4256	op->map.vma_flags \|= vma_flags & XE_VMA_CREATE_MASK;
4279	}	4257	}
4280	}	4258	}
4281	print_op(vm->xe, __op);	4259	print_op(vm->xe, __op);

drivers/gpu/drm/xe/xe_vm_types.h+2−8

 #define XE_VMA_PTE_COMPACT	(DRM_GPUVA_USERBITS << 7)
 #define XE_VMA_DUMPABLE		(DRM_GPUVA_USERBITS << 8)
 #define XE_VMA_SYSTEM_ALLOCATOR	(DRM_GPUVA_USERBITS << 9)
+#define XE_VMA_MADV_AUTORESET	(DRM_GPUVA_USERBITS << 10)
 /**
  * struct xe_vma_mem_attr - memory attributes associated with vma
 struct xe_vma_op_map {
 	/** @vma: VMA to map */
 	struct xe_vma *vma;
+	unsigned int vma_flags;
 	/** @immediate: Immediate bind */
 	bool immediate;
 	/** @read_only: Read only */
-	bool read_only;
-	/** @is_null: is NULL binding */
-	bool is_null;
-	/** @is_cpu_addr_mirror: is CPU address mirror binding */
-	bool is_cpu_addr_mirror;
-	/** @dumpable: whether BO is dumped on GPU hang */
-	bool dumpable;
-	/** @invalidate: invalidate the VMA before bind */
 	bool invalidate_on_bind;
 	/** @pat_index: The pat index to use for this operation. */
 	u16 pat_index;

drivers/hwmon/cgbc-hwmon.c+3−0

@@ -107,6 +107,9 @@ static int cgbc_hwmon_probe_sensors(struct device dev, struct cgbc_hwmon_data · 106 unmodified lines
107	nb_sensors = data[0];	107	nb_sensors = data[0];
108		108
109	hwmon->sensors = devm_kzalloc(dev, sizeof(hwmon->sensors) nb_sensors, GFP_KERNEL);	109	hwmon->sensors = devm_kzalloc(dev, sizeof(hwmon->sensors) nb_sensors, GFP_KERNEL);
		110	if (!hwmon->sensors)
		111	return -ENOMEM;
		112
110	sensor = hwmon->sensors;	113	sensor = hwmon->sensors;
111		114
112	for (i = 0; i < nb_sensors; i++) {	115	for (i = 0; i < nb_sensors; i++) {

drivers/hwmon/gpd-fan.c+5−5

@@ -615,14 +615,14 @@ static int gpd_fan_probe(struct platform_device *pdev) · 614 unmodified lines
615	const struct device *hwdev;	615	const struct device *hwdev;
616		616
617	res = platform_get_resource(pdev, IORESOURCE_IO, 0);	617	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
618	if (IS_ERR(res))	618	if (!res)
619	return dev_err_probe(dev, PTR_ERR(res),	619	return dev_err_probe(dev, -EINVAL,
620	"Failed to get platform resource\n");	620	"Failed to get platform resource\n");
621		621
622	region = devm_request_region(dev, res->start,	622	region = devm_request_region(dev, res->start,
623	resource_size(res), DRIVER_NAME);	623	resource_size(res), DRIVER_NAME);
624	if (IS_ERR(region))	624	if (!region)
625	return dev_err_probe(dev, PTR_ERR(region),	625	return dev_err_probe(dev, -EBUSY,
626	"Failed to request region\n");	626	"Failed to request region\n");
627		627
628	hwdev = devm_hwmon_device_register_with_info(dev,	628	hwdev = devm_hwmon_device_register_with_info(dev,
@@ -631,7 +631,7 @@ static int gpd_fan_probe(struct platform_device *pdev) · 2 unmodified lines
631	&gpd_fan_chip_info,	631	&gpd_fan_chip_info,
632	NULL);	632	NULL);
633	if (IS_ERR(hwdev))	633	if (IS_ERR(hwdev))
634	return dev_err_probe(dev, PTR_ERR(region),	634	return dev_err_probe(dev, PTR_ERR(hwdev),
635	"Failed to register hwmon device\n");	635	"Failed to register hwmon device\n");
636		636
637	return 0;	637	return 0;

drivers/hwmon/pmbus/isl68137.c+1−2

 				  struct isl68137_data *data)
 {
 	const struct device_node *np = dev->of_node;
-	struct device_node *child;
 	int err;
-	for_each_child_of_node(np, child) {
+	for_each_child_of_node_scoped(np, child) {
 		if (strcmp(child->name, "channel"))
 			continue;

drivers/hwmon/pmbus/max34440.c+6−6

@@ -336,18 +336,18 @@ static struct pmbus_driver_info max34440_info[] = { · 335 unmodified lines
336	.format[PSC_CURRENT_IN] = direct,	336	.format[PSC_CURRENT_IN] = direct,
337	.format[PSC_CURRENT_OUT] = direct,	337	.format[PSC_CURRENT_OUT] = direct,
338	.format[PSC_TEMPERATURE] = direct,	338	.format[PSC_TEMPERATURE] = direct,
339	.m[PSC_VOLTAGE_IN] = 1,	339	.m[PSC_VOLTAGE_IN] = 125,
340	.b[PSC_VOLTAGE_IN] = 0,	340	.b[PSC_VOLTAGE_IN] = 0,
341	.R[PSC_VOLTAGE_IN] = 0,	341	.R[PSC_VOLTAGE_IN] = 0,
342	.m[PSC_VOLTAGE_OUT] = 1,	342	.m[PSC_VOLTAGE_OUT] = 125,
343	.b[PSC_VOLTAGE_OUT] = 0,	343	.b[PSC_VOLTAGE_OUT] = 0,
344	.R[PSC_VOLTAGE_OUT] = 0,	344	.R[PSC_VOLTAGE_OUT] = 0,
345	.m[PSC_CURRENT_IN] = 1,	345	.m[PSC_CURRENT_IN] = 250,
346	.b[PSC_CURRENT_IN] = 0,	346	.b[PSC_CURRENT_IN] = 0,
347	.R[PSC_CURRENT_IN] = 2,	347	.R[PSC_CURRENT_IN] = -1,
348	.m[PSC_CURRENT_OUT] = 1,	348	.m[PSC_CURRENT_OUT] = 250,
349	.b[PSC_CURRENT_OUT] = 0,	349	.b[PSC_CURRENT_OUT] = 0,
350	.R[PSC_CURRENT_OUT] = 2,	350	.R[PSC_CURRENT_OUT] = -1,
351	.m[PSC_TEMPERATURE] = 1,	351	.m[PSC_TEMPERATURE] = 1,
352	.b[PSC_TEMPERATURE] = 0,	352	.b[PSC_TEMPERATURE] = 0,
353	.R[PSC_TEMPERATURE] = 2,	353	.R[PSC_TEMPERATURE] = 2,

drivers/hwmon/sht3x.c+17−10

 	return data;
 }
-static int temp1_input_read(struct device *dev)
+static int temp1_input_read(struct device *dev, long *temp)
 {
 	struct sht3x_data *data = sht3x_update_client(dev);
 	if (IS_ERR(data))
 		return PTR_ERR(data);
-	return data->temperature;
+	*temp = data->temperature;
+	return 0;
 }
-static int humidity1_input_read(struct device *dev)
+static int humidity1_input_read(struct device *dev, long *humidity)
 {
 	struct sht3x_data *data = sht3x_update_client(dev);
 	if (IS_ERR(data))
 		return PTR_ERR(data);
-	return data->humidity;
+	*humidity = data->humidity;
+	return 0;
 }
 /*
 		      u32 attr, int channel, long *val)
 {
 	enum sht3x_limits index;
+	int ret;
 	switch (type) {
 	case hwmon_chip:
 	case hwmon_temp:
 		switch (attr) {
 		case hwmon_temp_input:
-			*val = temp1_input_read(dev);
+			return temp1_input_read(dev, val);
-			break;
 		case hwmon_temp_alarm:
-			*val = temp1_alarm_read(dev);
+			ret = temp1_alarm_read(dev);
+			if (ret < 0)
+				return ret;
+			*val = ret;
 			break;
 		case hwmon_temp_max:
 			index = limit_max;
 	case hwmon_humidity:
 		switch (attr) {
 		case hwmon_humidity_input:
-			*val = humidity1_input_read(dev);
+			return humidity1_input_read(dev, val);
-			break;
 		case hwmon_humidity_alarm:
-			*val = humidity1_alarm_read(dev);
+			ret = humidity1_alarm_read(dev);
+			if (ret < 0)
+				return ret;
+			*val = ret;
 			break;
 		case hwmon_humidity_max:
 			index = limit_max;

drivers/misc/amd-sbi/Kconfig+2−0

 config AMD_SBRMI_I2C
 	tristate "AMD side band RMI support"
 	depends on I2C
+	depends on ARM || ARM64 || COMPILE_TEST
 	select REGMAP_I2C
 	help
 	  Side band RMI over I2C support for AMD out of band management.
+	  This driver is intended to run on the BMC, not the managed node.
 	  This driver can also be built as a module. If so, the module will
 	  be called sbrmi-i2c.

drivers/misc/fastrpc.c+2−0

@@ -381,6 +381,8 @@ static int fastrpc_map_lookup(struct fastrpc_user *fl, int fd, · 380 unmodified lines
381	}	381	}
382	spin_unlock(&fl->lock);	382	spin_unlock(&fl->lock);
383		383
		384	dma_buf_put(buf);
		385
384	return ret;	386	return ret;
385	}	387	}
386		388

drivers/misc/mei/hw-me-regs.h+2−0

@@ -120,6 +120,8 @@ · 119 unmodified lines
120	#define MEI_DEV_ID_PTL_H 0xE370 /* Panther Lake H */	120	#define MEI_DEV_ID_PTL_H 0xE370 /* Panther Lake H */
121	#define MEI_DEV_ID_PTL_P 0xE470 /* Panther Lake P */	121	#define MEI_DEV_ID_PTL_P 0xE470 /* Panther Lake P */
122		122
		123	#define MEI_DEV_ID_WCL_P 0x4D70 /* Wildcat Lake P */
		124
123	/*	125	/*
124	* MEI HW Section	126	* MEI HW Section
125	*/	127	*/

drivers/misc/mei/mei_lb.c+1−2

@@ -134,8 +134,7 @@ static bool mei_lb_check_response(const struct device *dev, ssize_t bytes, · 133 unmodified lines
134	return true;	134	return true;
135	}	135	}
136		136
137	static int mei_lb_push_payload(struct device *dev,	137	static int mei_lb_push_payload(struct device *dev, u32 type, u32 flags,
138	enum intel_lb_type type, u32 flags,
139	const void *payload, size_t payload_size)	138	const void *payload, size_t payload_size)
140	{	139	{
141	struct mei_cl_device *cldev;	140	struct mei_cl_device *cldev;

drivers/misc/mei/pci-me.c+2−0

@@ -127,6 +127,8 @@ static const struct pci_device_id mei_me_pci_tbl[] = { · 126 unmodified lines
127	{MEI_PCI_DEVICE(MEI_DEV_ID_PTL_H, MEI_ME_PCH15_CFG)},	127	{MEI_PCI_DEVICE(MEI_DEV_ID_PTL_H, MEI_ME_PCH15_CFG)},
128	{MEI_PCI_DEVICE(MEI_DEV_ID_PTL_P, MEI_ME_PCH15_CFG)},	128	{MEI_PCI_DEVICE(MEI_DEV_ID_PTL_P, MEI_ME_PCH15_CFG)},
129		129
		130	{MEI_PCI_DEVICE(MEI_DEV_ID_WCL_P, MEI_ME_PCH15_CFG)},
		131
130	/* required last entry */	132	/* required last entry */
131	{0, }	133	{0, }
132	};	134	};

drivers/misc/mei/pci-txe.c+7−7

 		goto end;
 	}
+	err = mei_register(dev, &pdev->dev);
+	if (err)
+		goto release_irq;
 	if (mei_start(dev)) {
 		dev_err(&pdev->dev, "init hw failure.\n");
 		err = -ENODEV;
-		goto release_irq;
+		goto deregister;
 	}
 	pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_TXI_RPM_TIMEOUT);
 	pm_runtime_use_autosuspend(&pdev->dev);
-	err = mei_register(dev, &pdev->dev);
-	if (err)
-		goto stop;
 	pci_set_drvdata(pdev, dev);
 	/*
 	return 0;
-stop:
+deregister:
-	mei_stop(dev);
+	mei_deregister(dev);
 release_irq:
 	mei_cancel_work(dev);
 	mei_disable_interrupts(dev);

drivers/misc/vmw_balloon.c+3−5

 {
 	unsigned long status, flags;
 	struct vmballoon *b;
-	int ret;
+	int ret = 0;
 	b = container_of(b_dev_info, struct vmballoon, b_dev_info);
 		 * A failure happened. While we can deflate the page we just
 		 * inflated, this deflation can also encounter an error. Instead
 		 * we will decrease the size of the balloon to reflect the
-		 * change and report failure.
+		 * change.
 		 */
 		atomic64_dec(&b->size);
-		ret = -EBUSY;
 	} else {
 		/*
 		 * Success. Take a reference for the page, and we will add it to
 		 * the list after acquiring the lock.
 		 */
 		get_page(newpage);
-		ret = 0;
 	}
 	/* Update the balloon list under the @pages_lock */
 	 * If we succeed just insert it to the list and update the statistics
 	 * under the lock.
 	 */
-	if (!ret) {
+	if (status == VMW_BALLOON_SUCCESS) {
 		balloon_page_insert(&b->b_dev_info, newpage);
 		__count_vm_event(BALLOON_MIGRATE);
 	}

drivers/most/most_usb.c+5−8

 {
 	struct most_dev *mdev = to_mdev_from_dev(dev);
+	kfree(mdev->busy_urbs);
+	kfree(mdev->cap);
+	kfree(mdev->conf);
+	kfree(mdev->ep_address);
 	kfree(mdev);
 }
 /**
 err_free_conf:
 	kfree(mdev->conf);
 err_free_mdev:
-	put_device(&mdev->dev);
+	kfree(mdev);
 	return ret;
 }
 	if (mdev->dci)
 		device_unregister(&mdev->dci->dev);
 	most_deregister_interface(&mdev->iface);
-	kfree(mdev->busy_urbs);
-	kfree(mdev->cap);
-	kfree(mdev->conf);
-	kfree(mdev->ep_address);
-	put_device(&mdev->dci->dev);
-	put_device(&mdev->dev);
 }
 static int hdm_suspend(struct usb_interface *interface, pm_message_t message)

drivers/net/bonding/bond_main.c+23−24

 		unblock_netpoll_tx();
 	}
-	if (bond_mode_can_use_xmit_hash(bond))
+	/* broadcast mode uses the all_slaves to loop through slaves. */
+	if (bond_mode_can_use_xmit_hash(bond) ||
+	    BOND_MODE(bond) == BOND_MODE_BROADCAST)
 		bond_update_slave_arr(bond, NULL);
 	if (!slave_dev->netdev_ops->ndo_bpf ||
 	bond_upper_dev_unlink(bond, slave);
-	if (bond_mode_can_use_xmit_hash(bond))
+	if (bond_mode_can_use_xmit_hash(bond) ||
+	    BOND_MODE(bond) == BOND_MODE_BROADCAST)
 		bond_update_slave_arr(bond, slave);
 	slave_info(bond_dev, slave_dev, "Releasing %s interface\n",
 {
 	struct bonding *bond = container_of(work, struct bonding,
 					    mii_work.work);
-	bool should_notify_peers = false;
+	bool should_notify_peers;
 	bool commit;
 	unsigned long delay;
 	struct slave *slave;
 		goto re_arm;
 	rcu_read_lock();
 	should_notify_peers = bond_should_notify_peers(bond);
 	commit = !!bond_miimon_inspect(bond);
-	if (bond->send_peer_notif) {
-		rcu_read_unlock();
-		if (rtnl_trylock()) {
-			bond->send_peer_notif--;
-			rtnl_unlock();
-		}
-	} else {
-		rcu_read_unlock();
-	}
-	if (commit) {
+	rcu_read_unlock();
+	if (commit || bond->send_peer_notif) {
 		/* Race avoidance with bond_close cancel of workqueue */
 		if (!rtnl_trylock()) {
 			delay = 1;
-			should_notify_peers = false;
 			goto re_arm;
 		}
-		bond_for_each_slave(bond, slave, iter) {
+		if (commit) {
-			bond_commit_link_state(slave, BOND_SLAVE_NOTIFY_LATER);
+			bond_for_each_slave(bond, slave, iter) {
+				bond_commit_link_state(slave,
+						       BOND_SLAVE_NOTIFY_LATER);
+			}
+			bond_miimon_commit(bond);
+		}
+		if (bond->send_peer_notif) {
+			bond->send_peer_notif--;
+			if (should_notify_peers)
+				call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
+							 bond->dev);
 		}
-		bond_miimon_commit(bond);
 		rtnl_unlock();	/* might sleep, hold no other locks */
 	}
 re_arm:
 	if (bond->params.miimon)
 		queue_delayed_work(bond->wq, &bond->mii_work, delay);
-	if (should_notify_peers) {
-		if (!rtnl_trylock())
-			return;
-		call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
-		rtnl_unlock();
-	}
 }
 static int bond_upper_dev_walk(struct net_device *upper,

drivers/net/can/bxcan.c+1−1

@@ -842,7 +842,7 @@ static netdev_tx_t bxcan_start_xmit(struct sk_buff *skb, · 841 unmodified lines
842	u32 id;	842	u32 id;
843	int i, j;	843	int i, j;
844		844
845	if (can_dropped_invalid_skb(ndev, skb))	845	if (can_dev_dropped_skb(ndev, skb))
846	return NETDEV_TX_OK;	846	return NETDEV_TX_OK;
847		847
848	if (bxcan_tx_busy(priv))	848	if (bxcan_tx_busy(priv))

drivers/net/can/dev/netlink.c+4−2

 	}
 	if (data[IFLA_CAN_RESTART_MS]) {
-		if (!priv->do_set_mode) {
+		unsigned int restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
+		if (restart_ms != 0 && !priv->do_set_mode) {
 			NL_SET_ERR_MSG(extack,
 				       "Device doesn't support restart from Bus Off");
 			return -EOPNOTSUPP;
 		/* Do not allow changing restart delay while running */
 		if (dev->flags & IFF_UP)
 			return -EBUSY;
-		priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
+		priv->restart_ms = restart_ms;
 	}
 	if (data[IFLA_CAN_RESTART]) {

drivers/net/can/esd/esdacc.c+1−1

@@ -254,7 +254,7 @@ netdev_tx_t acc_start_xmit(struct sk_buff skb, struct net_device netdev) · 253 unmodified lines
254	u32 acc_id;	254	u32 acc_id;
255	u32 acc_dlc;	255	u32 acc_dlc;
256		256
257	if (can_dropped_invalid_skb(netdev, skb))	257	if (can_dev_dropped_skb(netdev, skb))
258	return NETDEV_TX_OK;	258	return NETDEV_TX_OK;
259		259
260	/* Access core->tx_fifo_tail only once because it may be changed	260	/* Access core->tx_fifo_tail only once because it may be changed

drivers/net/can/rockchip/rockchip_canfd-tx.c+1−1

@@ -72,7 +72,7 @@ netdev_tx_t rkcanfd_start_xmit(struct sk_buff skb, struct net_device ndev) · 71 unmodified lines
72	int err;	72	int err;
73	u8 i;	73	u8 i;
74		74
75	if (can_dropped_invalid_skb(ndev, skb))	75	if (can_dev_dropped_skb(ndev, skb))
76	return NETDEV_TX_OK;	76	return NETDEV_TX_OK;
77		77
78	if (!netif_subqueue_maybe_stop(priv->ndev, 0,	78	if (!netif_subqueue_maybe_stop(priv->ndev, 0,

drivers/net/ethernet/dlink/dl2k.c+1−1

@@ -733,7 +733,7 @@ start_xmit (struct sk_buff skb, struct net_device dev) · 732 unmodified lines
733	u64 tfc_vlan_tag = 0;	733	u64 tfc_vlan_tag = 0;
734		734
735	if (np->link_status == 0) { /* Link Down */	735	if (np->link_status == 0) { /* Link Down */
736	dev_kfree_skb(skb);	736	dev_kfree_skb_any(skb);
737	return NETDEV_TX_OK;	737	return NETDEV_TX_OK;
738	}	738	}
739	entry = np->cur_tx % TX_RING_SIZE;	739	entry = np->cur_tx % TX_RING_SIZE;

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

@@ -1077,8 +1077,7 @@ static int dpaa2_eth_build_single_fd(struct dpaa2_eth_priv *priv, · 1076 unmodified lines
1077	dma_addr_t addr;	1077	dma_addr_t addr;
1078		1078
1079	buffer_start = skb->data - dpaa2_eth_needed_headroom(skb);	1079	buffer_start = skb->data - dpaa2_eth_needed_headroom(skb);
1080	aligned_start = PTR_ALIGN(buffer_start - DPAA2_ETH_TX_BUF_ALIGN,	1080	aligned_start = PTR_ALIGN(buffer_start, DPAA2_ETH_TX_BUF_ALIGN);
1081	DPAA2_ETH_TX_BUF_ALIGN);
1082	if (aligned_start >= skb->head)	1081	if (aligned_start >= skb->head)
1083	buffer_start = aligned_start;	1082	buffer_start = aligned_start;
1084	else	1083	else

drivers/net/ethernet/freescale/enetc/enetc.c+21−4

 	/* next descriptor to process */
 	i = rx_ring->next_to_clean;
+	enetc_lock_mdio();
 	while (likely(rx_frm_cnt < work_limit)) {
 		union enetc_rx_bd *rxbd;
 		struct sk_buff *skb;
 		rx_byte_cnt += skb->len + ETH_HLEN;
 		rx_frm_cnt++;
+		enetc_unlock_mdio();
 		napi_gro_receive(napi, skb);
+		enetc_lock_mdio();
 	}
 	rx_ring->next_to_clean = i;
 	rx_ring->stats.packets += rx_frm_cnt;
 	rx_ring->stats.bytes += rx_byte_cnt;
+	enetc_unlock_mdio();
 	return rx_frm_cnt;
 }
 	/* next descriptor to process */
 	i = rx_ring->next_to_clean;
+	enetc_lock_mdio();
 	while (likely(rx_frm_cnt < work_limit)) {
 		union enetc_rx_bd *rxbd, *orig_rxbd;
 		struct xdp_buff xdp_buff;
 			 */
 			enetc_bulk_flip_buff(rx_ring, orig_i, i);
+			enetc_unlock_mdio();
 			napi_gro_receive(napi, skb);
+			enetc_lock_mdio();
 			break;
 		case XDP_TX:
 			tx_ring = priv->xdp_tx_ring[rx_ring->index];
 			}
 			break;
 		case XDP_REDIRECT:
+			enetc_unlock_mdio();
 			err = xdp_do_redirect(rx_ring->ndev, &xdp_buff, prog);
+			enetc_lock_mdio();
 			if (unlikely(err)) {
 				enetc_xdp_drop(rx_ring, orig_i, i);
 				rx_ring->stats.xdp_redirect_failures++;
 	rx_ring->stats.packets += rx_frm_cnt;
 	rx_ring->stats.bytes += rx_byte_cnt;
-	if (xdp_redirect_frm_cnt)
+	if (xdp_redirect_frm_cnt) {
+		enetc_unlock_mdio();
 		xdp_do_flush();
+		enetc_lock_mdio();
+	}
 	if (xdp_tx_frm_cnt)
 		enetc_update_tx_ring_tail(tx_ring);
 		enetc_refill_rx_ring(rx_ring, enetc_bd_unused(rx_ring) -
 				     rx_ring->xdp.xdp_tx_in_flight);
+	enetc_unlock_mdio();
 	return rx_frm_cnt;
 }
 	for (i = 0; i < v->count_tx_rings; i++)
 		if (!enetc_clean_tx_ring(&v->tx_ring[i], budget))
 			complete = false;
+	enetc_unlock_mdio();
 	prog = rx_ring->xdp.prog;
 	if (prog)
 	if (work_done)
 		v->rx_napi_work = true;
-	if (!complete) {
+	if (!complete)
-		enetc_unlock_mdio();
 		return budget;
-	}
 	napi_complete_done(napi, work_done);
 	v->rx_napi_work = false;
+	enetc_lock_mdio();
 	/* enable interrupts */
 	enetc_wr_reg_hot(v->rbier, ENETC_RBIER_RXTIE);

drivers/net/ethernet/freescale/enetc/enetc.h+1−1

@@ -76,7 +76,7 @@ struct enetc_lso_t { · 75 unmodified lines
76	#define ENETC_LSO_MAX_DATA_LEN SZ_256K	76	#define ENETC_LSO_MAX_DATA_LEN SZ_256K
77		77
78	#define ENETC_RX_MAXFRM_SIZE ENETC_MAC_MAXFRM_SIZE	78	#define ENETC_RX_MAXFRM_SIZE ENETC_MAC_MAXFRM_SIZE
79	#define ENETC_RXB_TRUESIZE 2048 /* PAGE_SIZE >> 1 */	79	#define ENETC_RXB_TRUESIZE (PAGE_SIZE >> 1)
80	#define ENETC_RXB_PAD NET_SKB_PAD /* add extra space if needed */	80	#define ENETC_RXB_PAD NET_SKB_PAD /* add extra space if needed */
81	#define ENETC_RXB_DMA_SIZE \	81	#define ENETC_RXB_DMA_SIZE \
82	(SKB_WITH_OVERHEAD(ENETC_RXB_TRUESIZE) - ENETC_RXB_PAD)	82	(SKB_WITH_OVERHEAD(ENETC_RXB_TRUESIZE) - ENETC_RXB_PAD)

drivers/net/ethernet/hisilicon/Kconfig+1−0

@@ -148,6 +148,7 @@ config HIBMCGE · 147 unmodified lines
148	tristate "Hisilicon BMC Gigabit Ethernet Device Support"	148	tristate "Hisilicon BMC Gigabit Ethernet Device Support"
149	depends on PCI && PCI_MSI	149	depends on PCI && PCI_MSI
150	select PHYLIB	150	select PHYLIB
		151	select FIXED_PHY
151	select MOTORCOMM_PHY	152	select MOTORCOMM_PHY
152	select REALTEK_PHY	153	select REALTEK_PHY
153	help	154	help

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

@@ -100,7 +100,7 @@ u8 mlx5e_mpwrq_umr_entry_size(enum mlx5e_mpwrq_umr_mode mode) · 99 unmodified lines
100	return sizeof(struct mlx5_ksm) * 4;	100	return sizeof(struct mlx5_ksm) * 4;
101	}	101	}
102	WARN_ONCE(1, "MPWRQ UMR mode %d is not known\n", mode);	102	WARN_ONCE(1, "MPWRQ UMR mode %d is not known\n", mode);
103	return 0;	103	return 1;
104	}	104	}
105		105
106	u8 mlx5e_mpwrq_log_wqe_sz(struct mlx5_core_dev *mdev, u8 page_shift,	106	u8 mlx5e_mpwrq_log_wqe_sz(struct mlx5_core_dev *mdev, u8 page_shift,

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.h+5−0

 void mlx5e_ipsec_handle_mpv_event(int event, struct mlx5e_priv *slave_priv,
 				  struct mlx5e_priv *master_priv);
 void mlx5e_ipsec_send_event(struct mlx5e_priv *priv, int event);
+void mlx5e_ipsec_disable_events(struct mlx5e_priv *priv);
 static inline struct mlx5_core_dev *
 mlx5e_ipsec_sa2dev(struct mlx5e_ipsec_sa_entry *sa_entry)
 static inline void mlx5e_ipsec_send_event(struct mlx5e_priv *priv, int event)
 {
 }
+static inline void mlx5e_ipsec_disable_events(struct mlx5e_priv *priv)
+{
+}
 #endif
 #endif	/* __MLX5E_IPSEC_H__ */

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_fs.c+23−2

@@ -2893,9 +2893,30 @@ void mlx5e_ipsec_handle_mpv_event(int event, struct mlx5e_priv *slave_priv, · 2892 unmodified lines
2893		2893
2894	void mlx5e_ipsec_send_event(struct mlx5e_priv *priv, int event)	2894	void mlx5e_ipsec_send_event(struct mlx5e_priv *priv, int event)
2895	{	2895	{
2896	if (!priv->ipsec)	2896	if (!priv->ipsec \|\| mlx5_devcom_comp_get_size(priv->devcom) < 2)
2897	return; /* IPsec not supported */	2897	return; /* IPsec not supported or no peers */
2898		2898
2899	mlx5_devcom_send_event(priv->devcom, event, event, priv);	2899	mlx5_devcom_send_event(priv->devcom, event, event, priv);
2900	wait_for_completion(&priv->ipsec->comp);	2900	wait_for_completion(&priv->ipsec->comp);
2901	}	2901	}
		2902
		2903	void mlx5e_ipsec_disable_events(struct mlx5e_priv *priv)
		2904	{
		2905	struct mlx5_devcom_comp_dev *tmp = NULL;
		2906	struct mlx5e_priv *peer_priv;
		2907
		2908	if (!priv->devcom)
		2909	return;
		2910
		2911	if (!mlx5_devcom_for_each_peer_begin(priv->devcom))
		2912	goto out;
		2913
		2914	peer_priv = mlx5_devcom_get_next_peer_data(priv->devcom, &tmp);
		2915	if (peer_priv)
		2916	complete_all(&peer_priv->ipsec->comp);
		2917
		2918	mlx5_devcom_for_each_peer_end(priv->devcom);
		2919	out:
		2920	mlx5_devcom_unregister_component(priv->devcom);
		2921	priv->devcom = NULL;
		2922	}

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+5−3

 						      &attr,
 						      mlx5e_devcom_event_mpv,
 						      priv);
-	if (IS_ERR(priv->devcom))
+	if (!priv->devcom)
-		return PTR_ERR(priv->devcom);
+		return -EINVAL;
 	if (mlx5_core_is_mp_master(priv->mdev)) {
 		mlx5_devcom_send_event(priv->devcom, MPV_DEVCOM_MASTER_UP,
 static void mlx5e_devcom_cleanup_mpv(struct mlx5e_priv *priv)
 {
-	if (IS_ERR_OR_NULL(priv->devcom))
+	if (!priv->devcom)
 		return;
 	if (mlx5_core_is_mp_master(priv->mdev)) {
 	}
 	mlx5_devcom_unregister_component(priv->devcom);
+	priv->devcom = NULL;
 }
 static int blocking_event(struct notifier_block *nb, unsigned long event, void *data)
 	if (mlx5e_monitor_counter_supported(priv))
 		mlx5e_monitor_counter_cleanup(priv);
+	mlx5e_ipsec_disable_events(priv);
 	mlx5e_disable_blocking_events(priv);
 	mlx5e_disable_async_events(priv);
 	mlx5_lag_remove_netdev(mdev, priv->netdev);

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

@@ -1794,14 +1794,27 @@ mlx5e_skb_from_cqe_nonlinear(struct mlx5e_rq rq, struct mlx5e_wqe_frag_info wi · 1793 unmodified lines
1794	}	1794	}
1795		1795
1796	prog = rcu_dereference(rq->xdp_prog);	1796	prog = rcu_dereference(rq->xdp_prog);
1797	if (prog && mlx5e_xdp_handle(rq, prog, mxbuf)) {	1797	if (prog) {
1798	if (__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT, rq->flags)) {	1798	u8 nr_frags_free, old_nr_frags = sinfo->nr_frags;
1799	struct mlx5e_wqe_frag_info *pwi;	1799
		1800	if (mlx5e_xdp_handle(rq, prog, mxbuf)) {
		1801	if (__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT,
		1802	rq->flags)) {
		1803	struct mlx5e_wqe_frag_info *pwi;
		1804
		1805	wi -= old_nr_frags - sinfo->nr_frags;
		1806
		1807	for (pwi = head_wi; pwi < wi; pwi++)
		1808	pwi->frag_page->frags++;
		1809	}
		1810	return NULL; /* page/packet was consumed by XDP */
		1811	}
1800		1812
1801	for (pwi = head_wi; pwi < wi; pwi++)	1813	nr_frags_free = old_nr_frags - sinfo->nr_frags;
1802	pwi->frag_page->frags++;	1814	if (unlikely(nr_frags_free)) {
		1815	wi -= nr_frags_free;
		1816	truesize -= nr_frags_free * frag_info->frag_stride;
1803	}	1817	}
1804	return NULL; /* page/packet was consumed by XDP */
1805	}	1818	}
1806		1819
1807	skb = mlx5e_build_linear_skb(	1820	skb = mlx5e_build_linear_skb(
@@ -2027,6 +2040,7 @@ mlx5e_skb_from_cqe_mpwrq_nonlinear(struct mlx5e_rq rq, struct mlx5e_mpw_info w · 219 unmodified lines
2027	u32 byte_cnt = cqe_bcnt;	2040	u32 byte_cnt = cqe_bcnt;
2028	struct skb_shared_info *sinfo;	2041	struct skb_shared_info *sinfo;
2029	unsigned int truesize = 0;	2042	unsigned int truesize = 0;
		2043	u32 pg_consumed_bytes;
2030	struct bpf_prog *prog;	2044	struct bpf_prog *prog;
2031	struct sk_buff *skb;	2045	struct sk_buff *skb;
2032	u32 linear_frame_sz;	2046	u32 linear_frame_sz;
@@ -2080,7 +2094,8 @@ mlx5e_skb_from_cqe_mpwrq_nonlinear(struct mlx5e_rq rq, struct mlx5e_mpw_info w · 47 unmodified lines
2080		2094
2081	while (byte_cnt) {	2095	while (byte_cnt) {
2082	/* Non-linear mode, hence non-XSK, which always uses PAGE_SIZE. */	2096	/* Non-linear mode, hence non-XSK, which always uses PAGE_SIZE. */
2083	u32 pg_consumed_bytes = min_t(u32, PAGE_SIZE - frag_offset, byte_cnt);	2097	pg_consumed_bytes =
		2098	min_t(u32, PAGE_SIZE - frag_offset, byte_cnt);
2084		2099
2085	if (test_bit(MLX5E_RQ_STATE_SHAMPO, &rq->state))	2100	if (test_bit(MLX5E_RQ_STATE_SHAMPO, &rq->state))
2086	truesize += pg_consumed_bytes;	2101	truesize += pg_consumed_bytes;
@@ -2096,10 +2111,15 @@ mlx5e_skb_from_cqe_mpwrq_nonlinear(struct mlx5e_rq rq, struct mlx5e_mpw_info w · 9 unmodified lines
2096	}	2111	}
2097		2112
2098	if (prog) {	2113	if (prog) {
		2114	u8 nr_frags_free, old_nr_frags = sinfo->nr_frags;
		2115	u32 len;
		2116
2099	if (mlx5e_xdp_handle(rq, prog, mxbuf)) {	2117	if (mlx5e_xdp_handle(rq, prog, mxbuf)) {
2100	if (__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT, rq->flags)) {	2118	if (__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT, rq->flags)) {
2101	struct mlx5e_frag_page *pfp;	2119	struct mlx5e_frag_page *pfp;
2102		2120
		2121	frag_page -= old_nr_frags - sinfo->nr_frags;
		2122
2103	for (pfp = head_page; pfp < frag_page; pfp++)	2123	for (pfp = head_page; pfp < frag_page; pfp++)
2104	pfp->frags++;	2124	pfp->frags++;
2105		2125
@@ -2110,9 +2130,19 @@ mlx5e_skb_from_cqe_mpwrq_nonlinear(struct mlx5e_rq rq, struct mlx5e_mpw_info w · 4 unmodified lines
2110	return NULL; /* page/packet was consumed by XDP */	2130	return NULL; /* page/packet was consumed by XDP */
2111	}	2131	}
2112		2132
		2133	nr_frags_free = old_nr_frags - sinfo->nr_frags;
		2134	if (unlikely(nr_frags_free)) {
		2135	frag_page -= nr_frags_free;
		2136	truesize -= (nr_frags_free - 1) * PAGE_SIZE +
		2137	ALIGN(pg_consumed_bytes,
		2138	BIT(rq->mpwqe.log_stride_sz));
		2139	}
		2140
		2141	len = mxbuf->xdp.data_end - mxbuf->xdp.data;
		2142
2113	skb = mlx5e_build_linear_skb(	2143	skb = mlx5e_build_linear_skb(
2114	rq, mxbuf->xdp.data_hard_start, linear_frame_sz,	2144	rq, mxbuf->xdp.data_hard_start, linear_frame_sz,
2115	mxbuf->xdp.data - mxbuf->xdp.data_hard_start, 0,	2145	mxbuf->xdp.data - mxbuf->xdp.data_hard_start, len,
2116	mxbuf->xdp.data - mxbuf->xdp.data_meta);	2146	mxbuf->xdp.data - mxbuf->xdp.data_meta);
2117	if (unlikely(!skb)) {	2147	if (unlikely(!skb)) {
2118	mlx5e_page_release_fragmented(rq->page_pool,	2148	mlx5e_page_release_fragmented(rq->page_pool,
@@ -2137,8 +2167,11 @@ mlx5e_skb_from_cqe_mpwrq_nonlinear(struct mlx5e_rq rq, struct mlx5e_mpw_info w · 18 unmodified lines
2137	do	2167	do
2138	pagep->frags++;	2168	pagep->frags++;
2139	while (++pagep < frag_page);	2169	while (++pagep < frag_page);
		2170
		2171	headlen = min_t(u16, MLX5E_RX_MAX_HEAD - len,
		2172	skb->data_len);
		2173	__pskb_pull_tail(skb, headlen);
2140	}	2174	}
2141	__pskb_pull_tail(skb, headlen);
2142	} else {	2175	} else {
2143	dma_addr_t addr;	2176	dma_addr_t addr;
2144		2177

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

@@ -1614,7 +1614,9 @@ void mlx5e_stats_fec_get(struct mlx5e_priv *priv, · 1613 unmodified lines
1614		1614
1615	fec_set_corrected_bits_total(priv, fec_stats);	1615	fec_set_corrected_bits_total(priv, fec_stats);
1616	fec_set_block_stats(priv, mode, fec_stats);	1616	fec_set_block_stats(priv, mode, fec_stats);
1617	fec_set_histograms_stats(priv, mode, hist);	1617
		1618	if (MLX5_CAP_PCAM_REG(priv->mdev, pphcr))
		1619	fec_set_histograms_stats(priv, mode, hist);
1618	}	1620	}
1619		1621
1620	#define PPORT_ETH_EXT_OFF(c) \	1622	#define PPORT_ETH_EXT_OFF(c) \

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c+4−3

 	u8 mode;
 #ifdef CONFIG_MLX5_EN_TLS
-	if (accel && accel->tls.tls_tisn)
+	if (accel->tls.tls_tisn)
 		return MLX5_INLINE_MODE_TCP_UDP;
 #endif
 	struct mlx5e_tx_attr attr;
 	struct mlx5i_tx_wqe *wqe;
+	struct mlx5e_accel_tx_state accel = {};
 	struct mlx5_wqe_datagram_seg *datagram;
 	struct mlx5_wqe_ctrl_seg *cseg;
 	struct mlx5_wqe_eth_seg  *eseg;
 	int num_dma;
 	u16 pi;
-	mlx5e_sq_xmit_prepare(sq, skb, NULL, &attr);
+	mlx5e_sq_xmit_prepare(sq, skb, &accel, &attr);
 	mlx5i_sq_calc_wqe_attr(skb, &attr, &wqe_attr);
 	pi = mlx5e_txqsq_get_next_pi(sq, wqe_attr.num_wqebbs);
 	mlx5i_txwqe_build_datagram(av, dqpn, dqkey, datagram);
-	mlx5e_txwqe_build_eseg_csum(sq, skb, NULL, eseg);
+	mlx5e_txwqe_build_eseg_csum(sq, skb, &accel, eseg);
 	eseg->mss = attr.mss;

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

@@ -3129,7 +3129,7 @@ void mlx5_esw_offloads_devcom_init(struct mlx5_eswitch *esw, · 3128 unmodified lines
3129	attr,	3129	attr,
3130	mlx5_esw_offloads_devcom_event,	3130	mlx5_esw_offloads_devcom_event,
3131	esw);	3131	esw);
3132	if (IS_ERR(esw->devcom))	3132	if (!esw->devcom)
3133	return;	3133	return;
3134		3134
3135	mlx5_devcom_send_event(esw->devcom,	3135	mlx5_devcom_send_event(esw->devcom,
@@ -3140,7 +3140,7 @@ void mlx5_esw_offloads_devcom_init(struct mlx5_eswitch *esw, · 4 unmodified lines
3140		3140
3141	void mlx5_esw_offloads_devcom_cleanup(struct mlx5_eswitch *esw)	3141	void mlx5_esw_offloads_devcom_cleanup(struct mlx5_eswitch *esw)
3142	{	3142	{
3143	if (IS_ERR_OR_NULL(esw->devcom))	3143	if (!esw->devcom)
3144	return;	3144	return;
3145		3145
3146	mlx5_devcom_send_event(esw->devcom,	3146	mlx5_devcom_send_event(esw->devcom,

drivers/net/ethernet/mellanox/mlx5/core/lag/lag.c+3−4

 		mlx5_devcom_register_component(dev->priv.devc,
 					       MLX5_DEVCOM_HCA_PORTS,
 					       &attr, NULL, dev);
-	if (IS_ERR(dev->priv.hca_devcom_comp)) {
+	if (!dev->priv.hca_devcom_comp) {
 		mlx5_core_err(dev,
-			      "Failed to register devcom HCA component, err: %ld\n",
+			      "Failed to register devcom HCA component.");
-			      PTR_ERR(dev->priv.hca_devcom_comp));
+		return -EINVAL;
-		return PTR_ERR(dev->priv.hca_devcom_comp);
 	}
 	return 0;

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

@@ -1444,7 +1444,7 @@ static void mlx5_shared_clock_register(struct mlx5_core_dev *mdev, u64 key) · 1443 unmodified lines
1444	compd = mlx5_devcom_register_component(mdev->priv.devc,	1444	compd = mlx5_devcom_register_component(mdev->priv.devc,
1445	MLX5_DEVCOM_SHARED_CLOCK,	1445	MLX5_DEVCOM_SHARED_CLOCK,
1446	&attr, NULL, mdev);	1446	&attr, NULL, mdev);
1447	if (IS_ERR(compd))	1447	if (!compd)
1448	return;	1448	return;
1449		1449
1450	mdev->clock_state->compdev = compd;	1450	mdev->clock_state->compdev = compd;

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c+26−27

@@ -76,20 +76,18 @@ mlx5_devcom_dev_alloc(struct mlx5_core_dev *dev) · 75 unmodified lines
76	struct mlx5_devcom_dev *	76	struct mlx5_devcom_dev *
77	mlx5_devcom_register_device(struct mlx5_core_dev *dev)	77	mlx5_devcom_register_device(struct mlx5_core_dev *dev)
78	{	78	{
79	struct mlx5_devcom_dev *devc;	79	struct mlx5_devcom_dev *devc = NULL;
80		80
81	mutex_lock(&dev_list_lock);	81	mutex_lock(&dev_list_lock);
82		82
83	if (devcom_dev_exists(dev)) {	83	if (devcom_dev_exists(dev)) {
84	devc = ERR_PTR(-EEXIST);	84	mlx5_core_err(dev, "devcom device already exists");
85	goto out;	85	goto out;
86	}	86	}
87		87
88	devc = mlx5_devcom_dev_alloc(dev);	88	devc = mlx5_devcom_dev_alloc(dev);
89	if (!devc) {	89	if (!devc)
90	devc = ERR_PTR(-ENOMEM);
91	goto out;	90	goto out;
92	}
93		91
94	list_add_tail(&devc->list, &devcom_dev_list);	92	list_add_tail(&devc->list, &devcom_dev_list);
95	out:	93	out:
@@ -110,8 +108,10 @@ mlx5_devcom_dev_release(struct kref *ref) · 14 unmodified lines
110		108
111	void mlx5_devcom_unregister_device(struct mlx5_devcom_dev *devc)	109	void mlx5_devcom_unregister_device(struct mlx5_devcom_dev *devc)
112	{	110	{
113	if (!IS_ERR_OR_NULL(devc))	111	if (!devc)
114	kref_put(&devc->ref, mlx5_devcom_dev_release);	112	return;
		113
		114	kref_put(&devc->ref, mlx5_devcom_dev_release);
115	}	115	}
116		116
117	static struct mlx5_devcom_comp *	117	static struct mlx5_devcom_comp *
@@ -122,7 +122,7 @@ mlx5_devcom_comp_alloc(u64 id, const struct mlx5_devcom_match_attr *attr, · 4 unmodified lines
122		122
123	comp = kzalloc(sizeof(*comp), GFP_KERNEL);	123	comp = kzalloc(sizeof(*comp), GFP_KERNEL);
124	if (!comp)	124	if (!comp)
125	return ERR_PTR(-ENOMEM);	125	return NULL;
126		126
127	comp->id = id;	127	comp->id = id;
128	comp->key.key = attr->key;	128	comp->key.key = attr->key;
@@ -160,7 +160,7 @@ devcom_alloc_comp_dev(struct mlx5_devcom_dev *devc, · 31 unmodified lines
160		160
161	devcom = kzalloc(sizeof(*devcom), GFP_KERNEL);	161	devcom = kzalloc(sizeof(*devcom), GFP_KERNEL);
162	if (!devcom)	162	if (!devcom)
163	return ERR_PTR(-ENOMEM);	163	return NULL;
164		164
165	kref_get(&devc->ref);	165	kref_get(&devc->ref);
166	devcom->devc = devc;	166	devcom->devc = devc;
@@ -240,31 +240,28 @@ mlx5_devcom_register_component(struct mlx5_devcom_dev *devc, · 73 unmodified lines
240	mlx5_devcom_event_handler_t handler,	240	mlx5_devcom_event_handler_t handler,
241	void *data)	241	void *data)
242	{	242	{
243	struct mlx5_devcom_comp_dev *devcom;	243	struct mlx5_devcom_comp_dev *devcom = NULL;
244	struct mlx5_devcom_comp *comp;	244	struct mlx5_devcom_comp *comp;
245		245
246	if (IS_ERR_OR_NULL(devc))	246	if (!devc)
247	return ERR_PTR(-EINVAL);	247	return NULL;
248		248
249	mutex_lock(&comp_list_lock);	249	mutex_lock(&comp_list_lock);
250	comp = devcom_component_get(devc, id, attr, handler);	250	comp = devcom_component_get(devc, id, attr, handler);
251	if (IS_ERR(comp)) {	251	if (IS_ERR(comp))
252	devcom = ERR_PTR(-EINVAL);
253	goto out_unlock;	252	goto out_unlock;
254	}
255		253
256	if (!comp) {	254	if (!comp) {
257	comp = mlx5_devcom_comp_alloc(id, attr, handler);	255	comp = mlx5_devcom_comp_alloc(id, attr, handler);
258	if (IS_ERR(comp)) {	256	if (!comp)
259	devcom = ERR_CAST(comp);
260	goto out_unlock;	257	goto out_unlock;
261	}	258
262	list_add_tail(&comp->comp_list, &devcom_comp_list);	259	list_add_tail(&comp->comp_list, &devcom_comp_list);
263	}	260	}
264	mutex_unlock(&comp_list_lock);	261	mutex_unlock(&comp_list_lock);
265		262
266	devcom = devcom_alloc_comp_dev(devc, comp, data);	263	devcom = devcom_alloc_comp_dev(devc, comp, data);
267	if (IS_ERR(devcom))	264	if (!devcom)
268	kref_put(&comp->ref, mlx5_devcom_comp_release);	265	kref_put(&comp->ref, mlx5_devcom_comp_release);
269		266
270	return devcom;	267	return devcom;
@@ -276,8 +273,10 @@ out_unlock: · 5 unmodified lines
276		273
277	void mlx5_devcom_unregister_component(struct mlx5_devcom_comp_dev *devcom)	274	void mlx5_devcom_unregister_component(struct mlx5_devcom_comp_dev *devcom)
278	{	275	{
279	if (!IS_ERR_OR_NULL(devcom))	276	if (!devcom)
280	devcom_free_comp_dev(devcom);	277	return;
		278
		279	devcom_free_comp_dev(devcom);
281	}	280	}
282		281
283	int mlx5_devcom_comp_get_size(struct mlx5_devcom_comp_dev *devcom)	282	int mlx5_devcom_comp_get_size(struct mlx5_devcom_comp_dev *devcom)
@@ -296,7 +295,7 @@ int mlx5_devcom_send_event(struct mlx5_devcom_comp_dev *devcom, · 12 unmodified lines
296	int err = 0;	295	int err = 0;
297	void *data;	296	void *data;
298		297
299	if (IS_ERR_OR_NULL(devcom))	298	if (!devcom)
300	return -ENODEV;	299	return -ENODEV;
301		300
302	comp = devcom->comp;	301	comp = devcom->comp;
@@ -338,7 +337,7 @@ void mlx5_devcom_comp_set_ready(struct mlx5_devcom_comp_dev *devcom, bool ready) · 35 unmodified lines
338		337
339	bool mlx5_devcom_comp_is_ready(struct mlx5_devcom_comp_dev *devcom)	338	bool mlx5_devcom_comp_is_ready(struct mlx5_devcom_comp_dev *devcom)
340	{	339	{
341	if (IS_ERR_OR_NULL(devcom))	340	if (!devcom)
342	return false;	341	return false;
343		342
344	return READ_ONCE(devcom->comp->ready);	343	return READ_ONCE(devcom->comp->ready);
@@ -348,7 +347,7 @@ bool mlx5_devcom_for_each_peer_begin(struct mlx5_devcom_comp_dev *devcom) · 3 unmodified lines
348	{	347	{
349	struct mlx5_devcom_comp *comp;	348	struct mlx5_devcom_comp *comp;
350		349
351	if (IS_ERR_OR_NULL(devcom))	350	if (!devcom)
352	return false;	351	return false;
353		352
354	comp = devcom->comp;	353	comp = devcom->comp;
@@ -421,21 +420,21 @@ void mlx5_devcom_get_next_peer_data_rcu(struct mlx5_devcom_comp_dev devcom, · 66 unmodified lines
421		420
422	void mlx5_devcom_comp_lock(struct mlx5_devcom_comp_dev *devcom)	421	void mlx5_devcom_comp_lock(struct mlx5_devcom_comp_dev *devcom)
423	{	422	{
424	if (IS_ERR_OR_NULL(devcom))	423	if (!devcom)
425	return;	424	return;
426	down_write(&devcom->comp->sem);	425	down_write(&devcom->comp->sem);
427	}	426	}
428		427
429	void mlx5_devcom_comp_unlock(struct mlx5_devcom_comp_dev *devcom)	428	void mlx5_devcom_comp_unlock(struct mlx5_devcom_comp_dev *devcom)
430	{	429	{
431	if (IS_ERR_OR_NULL(devcom))	430	if (!devcom)
432	return;	431	return;
433	up_write(&devcom->comp->sem);	432	up_write(&devcom->comp->sem);
434	}	433	}
435		434
436	int mlx5_devcom_comp_trylock(struct mlx5_devcom_comp_dev *devcom)	435	int mlx5_devcom_comp_trylock(struct mlx5_devcom_comp_dev *devcom)
437	{	436	{
438	if (IS_ERR_OR_NULL(devcom))	437	if (!devcom)
439	return 0;	438	return 0;
440	return down_write_trylock(&devcom->comp->sem);	439	return down_write_trylock(&devcom->comp->sem);
441	}	440	}

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

@@ -221,8 +221,8 @@ static int sd_register(struct mlx5_core_dev *dev) · 220 unmodified lines
221	attr.net = mlx5_core_net(dev);	221	attr.net = mlx5_core_net(dev);
222	devcom = mlx5_devcom_register_component(dev->priv.devc, MLX5_DEVCOM_SD_GROUP,	222	devcom = mlx5_devcom_register_component(dev->priv.devc, MLX5_DEVCOM_SD_GROUP,
223	&attr, NULL, dev);	223	&attr, NULL, dev);
224	if (IS_ERR(devcom))	224	if (!devcom)
225	return PTR_ERR(devcom);	225	return -EINVAL;
226		226
227	sd->devcom = devcom;	227	sd->devcom = devcom;
228		228

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

@@ -978,9 +978,8 @@ static int mlx5_init_once(struct mlx5_core_dev *dev) · 977 unmodified lines
978	int err;	978	int err;
979		979
980	dev->priv.devc = mlx5_devcom_register_device(dev);	980	dev->priv.devc = mlx5_devcom_register_device(dev);
981	if (IS_ERR(dev->priv.devc))	981	if (!dev->priv.devc)
982	mlx5_core_warn(dev, "failed to register devcom device %pe\n",	982	mlx5_core_warn(dev, "failed to register devcom device\n");
983	dev->priv.devc);
984		983
985	err = mlx5_query_board_id(dev);	984	err = mlx5_query_board_id(dev);
986	if (err) {	985	if (err) {

drivers/net/ethernet/renesas/ravb_main.c+22−2

@@ -2211,15 +2211,35 @@ static netdev_tx_t ravb_start_xmit(struct sk_buff skb, struct net_device ndev) · 2210 unmodified lines
2211		2211
2212	skb_tx_timestamp(skb);	2212	skb_tx_timestamp(skb);
2213	}	2213	}
2214	/* Descriptor type must be set after all the above writes */	2214
2215	dma_wmb();
2216	if (num_tx_desc > 1) {	2215	if (num_tx_desc > 1) {
2217	desc->die_dt = DT_FEND;	2216	desc->die_dt = DT_FEND;
2218	desc--;	2217	desc--;
		2218	/* When using multi-descriptors, DT_FEND needs to get written
		2219	* before DT_FSTART, but the compiler may reorder the memory
		2220	* writes in an attempt to optimize the code.
		2221	* Use a dma_wmb() barrier to make sure DT_FEND and DT_FSTART
		2222	* are written exactly in the order shown in the code.
		2223	* This is particularly important for cases where the DMA engine
		2224	* is already running when we are running this code. If the DMA
		2225	* sees DT_FSTART without the corresponding DT_FEND it will enter
		2226	* an error condition.
		2227	*/
		2228	dma_wmb();
2219	desc->die_dt = DT_FSTART;	2229	desc->die_dt = DT_FSTART;
2220	} else {	2230	} else {
		2231	/* Descriptor type must be set after all the above writes */
		2232	dma_wmb();
2221	desc->die_dt = DT_FSINGLE;	2233	desc->die_dt = DT_FSINGLE;
2222	}	2234	}
		2235
		2236	/* Before ringing the doorbell we need to make sure that the latest
		2237	* writes have been committed to memory, otherwise it could delay
		2238	* things until the doorbell is rang again.
		2239	* This is in replacement of the read operation mentioned in the HW
		2240	* manuals.
		2241	*/
		2242	dma_wmb();
2223	ravb_modify(ndev, TCCR, TCCR_TSRQ0 << q, TCCR_TSRQ0 << q);	2243	ravb_modify(ndev, TCCR, TCCR_TSRQ0 << q, TCCR_TSRQ0 << q);
2224		2244
2225	priv->cur_tx[q] += num_tx_desc;	2245	priv->cur_tx[q] += num_tx_desc;

drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c+5−4

 		}
 	} else {
 		if (bsp_priv->clk_enabled) {
+			if (bsp_priv->ops && bsp_priv->ops->set_clock_selection) {
+				bsp_priv->ops->set_clock_selection(bsp_priv,
+					      bsp_priv->clock_input, false);
+			}
 			clk_bulk_disable_unprepare(bsp_priv->num_clks,
 						   bsp_priv->clks);
 			clk_disable_unprepare(bsp_priv->clk_phy);
-			if (bsp_priv->ops && bsp_priv->ops->set_clock_selection)
-				bsp_priv->ops->set_clock_selection(bsp_priv,
-					      bsp_priv->clock_input, false);
 			bsp_priv->clk_enabled = false;
 		}
 	}

drivers/net/ethernet/ti/am65-cpts.c+43−20

 	struct device_node *clk_mux_np;
 	struct clk *refclk;
 	u32 refclk_freq;
-	struct list_head events;
+	/* separate lists to handle TX and RX timestamp independently */
+	struct list_head events_tx;
+	struct list_head events_rx;
 	struct list_head pool;
 	struct am65_cpts_event pool_data[AM65_CPTS_MAX_EVENTS];
 	spinlock_t lock; /* protects events lists*/
 	am65_cpts_write32(cpts, 0, int_enable);
 }
+static int am65_cpts_purge_event_list(struct am65_cpts *cpts,
+				      struct list_head *events)
+{
+	struct list_head *this, *next;
+	struct am65_cpts_event *event;
+	int removed = 0;
+	list_for_each_safe(this, next, events) {
+		event = list_entry(this, struct am65_cpts_event, list);
+		if (time_after(jiffies, event->tmo)) {
+			list_del_init(&event->list);
+			list_add(&event->list, &cpts->pool);
+			++removed;
+		}
+	}
+	return removed;
+}
 static int am65_cpts_event_get_port(struct am65_cpts_event *event)
 {
 	return (event->event1 & AM65_CPTS_EVENT_1_PORT_NUMBER_MASK) >>
 		AM65_CPTS_EVENT_1_EVENT_TYPE_SHIFT;
 }
-static int am65_cpts_cpts_purge_events(struct am65_cpts *cpts)
+static int am65_cpts_purge_events(struct am65_cpts *cpts)
 {
-	struct list_head *this, *next;
-	struct am65_cpts_event *event;
 	int removed = 0;
-	list_for_each_safe(this, next, &cpts->events) {
+	removed += am65_cpts_purge_event_list(cpts, &cpts->events_tx);
-		event = list_entry(this, struct am65_cpts_event, list);
+	removed += am65_cpts_purge_event_list(cpts, &cpts->events_rx);
-		if (time_after(jiffies, event->tmo)) {
-			list_del_init(&event->list);
-			list_add(&event->list, &cpts->pool);
-			++removed;
-		}
-	}
 	if (removed)
 		dev_dbg(cpts->dev, "event pool cleaned up %d\n", removed);
 						 struct am65_cpts_event, list);
 		if (!event) {
-			if (am65_cpts_cpts_purge_events(cpts)) {
+			if (am65_cpts_purge_events(cpts)) {
 				dev_err(cpts->dev, "cpts: event pool empty\n");
 				ret = -1;
 				goto out;
 				cpts->timestamp);
 			break;
 		case AM65_CPTS_EV_RX:
+			event->tmo = jiffies +
+				msecs_to_jiffies(AM65_CPTS_EVENT_RX_TX_TIMEOUT);
+			list_move_tail(&event->list, &cpts->events_rx);
+			dev_dbg(cpts->dev,
+				"AM65_CPTS_EV_RX e1:%08x e2:%08x t:%lld\n",
+				event->event1, event->event2,
+				event->timestamp);
+			break;
 		case AM65_CPTS_EV_TX:
 			event->tmo = jiffies +
 				msecs_to_jiffies(AM65_CPTS_EVENT_RX_TX_TIMEOUT);
-			list_move_tail(&event->list, &cpts->events);
+			list_move_tail(&event->list, &cpts->events_tx);
 			dev_dbg(cpts->dev,
 				"AM65_CPTS_EV_TX e1:%08x e2:%08x t:%lld\n",
 	return found;
 }
-static void am65_cpts_find_ts(struct am65_cpts *cpts)
+static void am65_cpts_find_tx_ts(struct am65_cpts *cpts)
 {
 	struct am65_cpts_event *event;
 	struct list_head *this, *next;
 	LIST_HEAD(events);
 	spin_lock_irqsave(&cpts->lock, flags);
-	list_splice_init(&cpts->events, &events);
+	list_splice_init(&cpts->events_tx, &events);
 	spin_unlock_irqrestore(&cpts->lock, flags);
 	list_for_each_safe(this, next, &events) {
 	}
 	spin_lock_irqsave(&cpts->lock, flags);
-	list_splice_tail(&events, &cpts->events);
+	list_splice_tail(&events, &cpts->events_tx);
 	list_splice_tail(&events_free, &cpts->pool);
 	spin_unlock_irqrestore(&cpts->lock, flags);
 }
 	unsigned long flags;
 	long delay = -1;
-	am65_cpts_find_ts(cpts);
+	am65_cpts_find_tx_ts(cpts);
 	spin_lock_irqsave(&cpts->txq.lock, flags);
 	if (!skb_queue_empty(&cpts->txq))
 	spin_lock_irqsave(&cpts->lock, flags);
 	__am65_cpts_fifo_read(cpts);
-	list_for_each_safe(this, next, &cpts->events) {
+	list_for_each_safe(this, next, &cpts->events_rx) {
 		event = list_entry(this, struct am65_cpts_event, list);
 		if (time_after(jiffies, event->tmo)) {
 			list_move(&event->list, &cpts->pool);
 		return ERR_PTR(ret);
 	mutex_init(&cpts->ptp_clk_lock);
-	INIT_LIST_HEAD(&cpts->events);
+	INIT_LIST_HEAD(&cpts->events_tx);
+	INIT_LIST_HEAD(&cpts->events_rx);
 	INIT_LIST_HEAD(&cpts->pool);
 	spin_lock_init(&cpts->lock);
 	skb_queue_head_init(&cpts->txq);

drivers/net/ovpn/tcp.c+22−4

@@ -560,16 +560,34 @@ static void ovpn_tcp_close(struct sock *sk, long timeout) · 559 unmodified lines
560	static __poll_t ovpn_tcp_poll(struct file file, struct socket sock,	560	static __poll_t ovpn_tcp_poll(struct file file, struct socket sock,
561	poll_table *wait)	561	poll_table *wait)
562	{	562	{
563	__poll_t mask = datagram_poll(file, sock, wait);	563	struct sk_buff_head *queue = &sock->sk->sk_receive_queue;
564	struct ovpn_socket *ovpn_sock;	564	struct ovpn_socket *ovpn_sock;
		565	struct ovpn_peer *peer = NULL;
		566	__poll_t mask;
565		567
566	rcu_read_lock();	568	rcu_read_lock();
567	ovpn_sock = rcu_dereference_sk_user_data(sock->sk);	569	ovpn_sock = rcu_dereference_sk_user_data(sock->sk);
568	if (ovpn_sock && ovpn_sock->peer &&	570	/* if we landed in this callback, we expect to have a
569	!skb_queue_empty(&ovpn_sock->peer->tcp.user_queue))	571	* meaningful state. The ovpn_socket lifecycle would
570	mask \|= EPOLLIN \| EPOLLRDNORM;	572	* prevent it otherwise.
		573	*/
		574	if (WARN(!ovpn_sock \|\| !ovpn_sock->peer,
		575	"ovpn: null state in ovpn_tcp_poll!")) {
		576	rcu_read_unlock();
		577	return 0;
		578	}
		579
		580	if (ovpn_peer_hold(ovpn_sock->peer)) {
		581	peer = ovpn_sock->peer;
		582	queue = &peer->tcp.user_queue;
		583	}
571	rcu_read_unlock();	584	rcu_read_unlock();
572		585
		586	mask = datagram_poll_queue(file, sock, wait, queue);
		587
		588	if (peer)
		589	ovpn_peer_put(peer);
		590
573	return mask;	591	return mask;
574	}	592	}
575		593

drivers/net/phy/micrel.c+2−2

 {
 	struct lan8814_shared_priv *shared = phy_package_get_priv(phydev);
+	shared->phydev = phydev;
 	/* Initialise shared lock for clock*/
 	mutex_init(&shared->shared_lock);
 	phydev_dbg(phydev, "successfully registered ptp clock\n");
-	shared->phydev = phydev;
 	/* The EP.4 is shared between all the PHYs in the package and also it
 	 * can be accessed by any of the PHYs
 	 */

drivers/net/phy/realtek/realtek_main.c+8−8

@@ -154,7 +154,7 @@ · 153 unmodified lines
154	#define RTL_8211FVD_PHYID 0x001cc878	154	#define RTL_8211FVD_PHYID 0x001cc878
155	#define RTL_8221B 0x001cc840	155	#define RTL_8221B 0x001cc840
156	#define RTL_8221B_VB_CG 0x001cc849	156	#define RTL_8221B_VB_CG 0x001cc849
157	#define RTL_8221B_VN_CG 0x001cc84a	157	#define RTL_8221B_VM_CG 0x001cc84a
158	#define RTL_8251B 0x001cc862	158	#define RTL_8251B 0x001cc862
159	#define RTL_8261C 0x001cc890	159	#define RTL_8261C 0x001cc890
160		160
@@ -1523,16 +1523,16 @@ static int rtl8221b_vb_cg_c45_match_phy_device(struct phy_device *phydev, · 1362 unmodified lines
1523	return rtlgen_is_c45_match(phydev, RTL_8221B_VB_CG, true);	1523	return rtlgen_is_c45_match(phydev, RTL_8221B_VB_CG, true);
1524	}	1524	}
1525		1525
1526	static int rtl8221b_vn_cg_c22_match_phy_device(struct phy_device *phydev,	1526	static int rtl8221b_vm_cg_c22_match_phy_device(struct phy_device *phydev,
1527	const struct phy_driver *phydrv)	1527	const struct phy_driver *phydrv)
1528	{	1528	{
1529	return rtlgen_is_c45_match(phydev, RTL_8221B_VN_CG, false);	1529	return rtlgen_is_c45_match(phydev, RTL_8221B_VM_CG, false);
1530	}	1530	}
1531		1531
1532	static int rtl8221b_vn_cg_c45_match_phy_device(struct phy_device *phydev,	1532	static int rtl8221b_vm_cg_c45_match_phy_device(struct phy_device *phydev,
1533	const struct phy_driver *phydrv)	1533	const struct phy_driver *phydrv)
1534	{	1534	{
1535	return rtlgen_is_c45_match(phydev, RTL_8221B_VN_CG, true);	1535	return rtlgen_is_c45_match(phydev, RTL_8221B_VM_CG, true);
1536	}	1536	}
1537		1537
1538	static int rtl_internal_nbaset_match_phy_device(struct phy_device *phydev,	1538	static int rtl_internal_nbaset_match_phy_device(struct phy_device *phydev,
@@ -1879,7 +1879,7 @@ static struct phy_driver realtek_drvs[] = { · 340 unmodified lines
1879	.suspend = genphy_c45_pma_suspend,	1879	.suspend = genphy_c45_pma_suspend,
1880	.resume = rtlgen_c45_resume,	1880	.resume = rtlgen_c45_resume,
1881	}, {	1881	}, {
1882	.match_phy_device = rtl8221b_vn_cg_c22_match_phy_device,	1882	.match_phy_device = rtl8221b_vm_cg_c22_match_phy_device,
1883	.name = "RTL8221B-VM-CG 2.5Gbps PHY (C22)",	1883	.name = "RTL8221B-VM-CG 2.5Gbps PHY (C22)",
1884	.probe = rtl822x_probe,	1884	.probe = rtl822x_probe,
1885	.get_features = rtl822x_get_features,	1885	.get_features = rtl822x_get_features,
@@ -1892,8 +1892,8 @@ static struct phy_driver realtek_drvs[] = { · 6 unmodified lines
1892	.read_page = rtl821x_read_page,	1892	.read_page = rtl821x_read_page,
1893	.write_page = rtl821x_write_page,	1893	.write_page = rtl821x_write_page,
1894	}, {	1894	}, {
1895	.match_phy_device = rtl8221b_vn_cg_c45_match_phy_device,	1895	.match_phy_device = rtl8221b_vm_cg_c45_match_phy_device,
1896	.name = "RTL8221B-VN-CG 2.5Gbps PHY (C45)",	1896	.name = "RTL8221B-VM-CG 2.5Gbps PHY (C45)",
1897	.probe = rtl822x_probe,	1897	.probe = rtl822x_probe,
1898	.config_init = rtl822xb_config_init,	1898	.config_init = rtl822xb_config_init,
1899	.get_rate_matching = rtl822xb_get_rate_matching,	1899	.get_rate_matching = rtl822xb_get_rate_matching,

drivers/net/usb/rtl8150.c+9−2

 	rtl8150_t *dev = netdev_priv(netdev);
 	int count, res;
+	/* pad the frame and ensure terminating USB packet, datasheet 9.2.3 */
+	count = max(skb->len, ETH_ZLEN);
+	if (count % 64 == 0)
+		count++;
+	if (skb_padto(skb, count)) {
+		netdev->stats.tx_dropped++;
+		return NETDEV_TX_OK;
+	}
 	netif_stop_queue(netdev);
-	count = (skb->len < 60) ? 60 : skb->len;
-	count = (count & 0x3f) ? count : count + 1;
 	dev->tx_skb = skb;
 	usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
 		      skb->data, count, write_bulk_callback, dev);

drivers/nvmem/rcar-efuse.c+1−0

@@ -127,6 +127,7 @@ static const struct of_device_id rcar_fuse_match[] = { · 126 unmodified lines
127	{ .compatible = "renesas,r8a779h0-otp", .data = &rcar_fuse_v4m },	127	{ .compatible = "renesas,r8a779h0-otp", .data = &rcar_fuse_v4m },
128	{ /* sentinel */ }	128	{ /* sentinel */ }
129	};	129	};
		130	MODULE_DEVICE_TABLE(of, rcar_fuse_match);
130		131
131	static struct platform_driver rcar_fuse_driver = {	132	static struct platform_driver rcar_fuse_driver = {
132	.probe = rcar_fuse_probe,	133	.probe = rcar_fuse_probe,

drivers/of/irq.c+40−4

@@ -671,6 +671,36 @@ err: · 670 unmodified lines
671	}	671	}
672	}	672	}
673		673
		674	static int of_check_msi_parent(struct device_node dev_node, struct device_node *msi_node)
		675	{
		676	struct of_phandle_args msi_spec;
		677	int ret;
		678
		679	/*
		680	* An msi-parent phandle with a missing or == 0 #msi-cells
		681	* property identifies a 1:1 ID translation mapping.
		682	*
		683	* Set the msi controller node if the firmware matches this
		684	* condition.
		685	*/
		686	ret = of_parse_phandle_with_optional_args(dev_node, "msi-parent", "#msi-cells",
		687	0, &msi_spec);
		688	if (ret)
		689	return ret;
		690
		691	if ((msi_node && msi_node != msi_spec.np) \|\| msi_spec.args_count != 0)
		692	ret = -EINVAL;
		693
		694	if (!ret) {
		695	/* Return with a node reference held */
		696	*msi_node = msi_spec.np;
		697	return 0;
		698	}
		699	of_node_put(msi_spec.np);
		700
		701	return ret;
		702	}
		703
674	/**	704	/**
675	* of_msi_xlate - map a MSI ID and find relevant MSI controller node	705	* of_msi_xlate - map a MSI ID and find relevant MSI controller node
676	* @dev: device for which the mapping is to be done.	706	* @dev: device for which the mapping is to be done.
@@ -678,7 +708,7 @@ err: · 1 unmodified line
678	* @id_in: Device ID.	708	* @id_in: Device ID.
679	*	709	*
680	* Walk up the device hierarchy looking for devices with a "msi-map"	710	* Walk up the device hierarchy looking for devices with a "msi-map"
681	* property. If found, apply the mapping to @id_in.	711	* or "msi-parent" property. If found, apply the mapping to @id_in.
682	* If @msi_np points to a non-NULL device node pointer, only entries targeting	712	* If @msi_np points to a non-NULL device node pointer, only entries targeting
683	* that node will be matched; if it points to a NULL value, it will receive the	713	* that node will be matched; if it points to a NULL value, it will receive the
684	* device node of the first matching target phandle, with a reference held.	714	* device node of the first matching target phandle, with a reference held.
@@ -692,14 +722,18 @@ u32 of_msi_xlate(struct device dev, struct device_node *msi_np, u32 id_in) · 7 unmodified lines
692		722
693	/*	723	/*
694	* Walk up the device parent links looking for one with a	724	* Walk up the device parent links looking for one with a
695	* "msi-map" property.	725	* "msi-map" or an "msi-parent" property.
696	*/	726	*/
697	for (parent_dev = dev; parent_dev; parent_dev = parent_dev->parent)	727	for (parent_dev = dev; parent_dev; parent_dev = parent_dev->parent) {
698	if (!of_map_id(parent_dev->of_node, id_in, "msi-map",	728	if (!of_map_id(parent_dev->of_node, id_in, "msi-map",
699	"msi-map-mask", msi_np, &id_out))	729	"msi-map-mask", msi_np, &id_out))
700	break;	730	break;
		731	if (!of_check_msi_parent(parent_dev->of_node, msi_np))
		732	break;
		733	}
701	return id_out;	734	return id_out;
702	}	735	}
		736	EXPORT_SYMBOL_GPL(of_msi_xlate);
703		737
704	/**	738	/**
705	* of_msi_map_get_device_domain - Use msi-map to find the relevant MSI domain	739	* of_msi_map_get_device_domain - Use msi-map to find the relevant MSI domain
@@ -741,8 +775,10 @@ struct irq_domain of_msi_get_domain(struct device dev, · 35 unmodified lines
741		775
742	of_for_each_phandle(&it, err, np, "msi-parent", "#msi-cells", 0) {	776	of_for_each_phandle(&it, err, np, "msi-parent", "#msi-cells", 0) {
743	d = irq_find_matching_host(it.node, token);	777	d = irq_find_matching_host(it.node, token);
744	if (d)	778	if (d) {
		779	of_node_put(it.node);
745	return d;	780	return d;
		781	}
746	}	782	}
747		783
748	return NULL;	784	return NULL;

drivers/pci/controller/dwc/pcie-designware-host.c+24−4

 #include "pcie-designware.h"
 static struct pci_ops dw_pcie_ops;
+static struct pci_ops dw_pcie_ecam_ops;
 static struct pci_ops dw_child_pcie_ops;
 #define DW_PCIE_MSI_FLAGS_REQUIRED (MSI_FLAG_USE_DEF_DOM_OPS		| \
 	if (IS_ERR(pp->cfg))
 		return PTR_ERR(pp->cfg);
-	pci->dbi_base = pp->cfg->win;
-	pci->dbi_phys_addr = res->start;
 	return 0;
 }
 		if (ret)
 			return ret;
-		pp->bridge->ops = (struct pci_ops *)&pci_generic_ecam_ops.pci_ops;
+		pp->bridge->ops = &dw_pcie_ecam_ops;
 		pp->bridge->sysdata = pp->cfg;
 		pp->cfg->priv = pp;
 	} else {
 }
 EXPORT_SYMBOL_GPL(dw_pcie_own_conf_map_bus);
+static void __iomem *dw_pcie_ecam_conf_map_bus(struct pci_bus *bus, unsigned int devfn, int where)
+{
+	struct pci_config_window *cfg = bus->sysdata;
+	struct dw_pcie_rp *pp = cfg->priv;
+	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
+	unsigned int busn = bus->number;
+	if (busn > 0)
+		return pci_ecam_map_bus(bus, devfn, where);
+	if (PCI_SLOT(devfn) > 0)
+		return NULL;
+	return pci->dbi_base + where;
+}
 static struct pci_ops dw_pcie_ops = {
 	.map_bus = dw_pcie_own_conf_map_bus,
 	.read = pci_generic_config_read,
 	.write = pci_generic_config_write,
 };
+static struct pci_ops dw_pcie_ecam_ops = {
+	.map_bus = dw_pcie_ecam_conf_map_bus,
+	.read = pci_generic_config_read,
+	.write = pci_generic_config_write,
+};
 static int dw_pcie_iatu_setup(struct dw_pcie_rp *pp)
 {
 	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);

drivers/pci/controller/dwc/pcie-qcom.c+0−68

@@ -55,7 +55,6 @@ · 54 unmodified lines
55	#define PARF_AXI_MSTR_WR_ADDR_HALT_V2 0x1a8	55	#define PARF_AXI_MSTR_WR_ADDR_HALT_V2 0x1a8
56	#define PARF_Q2A_FLUSH 0x1ac	56	#define PARF_Q2A_FLUSH 0x1ac
57	#define PARF_LTSSM 0x1b0	57	#define PARF_LTSSM 0x1b0
58	#define PARF_SLV_DBI_ELBI 0x1b4
59	#define PARF_INT_ALL_STATUS 0x224	58	#define PARF_INT_ALL_STATUS 0x224
60	#define PARF_INT_ALL_CLEAR 0x228	59	#define PARF_INT_ALL_CLEAR 0x228
61	#define PARF_INT_ALL_MASK 0x22c	60	#define PARF_INT_ALL_MASK 0x22c
@@ -65,16 +64,6 @@ · 3 unmodified lines
65	#define PARF_DBI_BASE_ADDR_V2_HI 0x354	64	#define PARF_DBI_BASE_ADDR_V2_HI 0x354
66	#define PARF_SLV_ADDR_SPACE_SIZE_V2 0x358	65	#define PARF_SLV_ADDR_SPACE_SIZE_V2 0x358
67	#define PARF_SLV_ADDR_SPACE_SIZE_V2_HI 0x35c	66	#define PARF_SLV_ADDR_SPACE_SIZE_V2_HI 0x35c
68	#define PARF_BLOCK_SLV_AXI_WR_BASE 0x360
69	#define PARF_BLOCK_SLV_AXI_WR_BASE_HI 0x364
70	#define PARF_BLOCK_SLV_AXI_WR_LIMIT 0x368
71	#define PARF_BLOCK_SLV_AXI_WR_LIMIT_HI 0x36c
72	#define PARF_BLOCK_SLV_AXI_RD_BASE 0x370
73	#define PARF_BLOCK_SLV_AXI_RD_BASE_HI 0x374
74	#define PARF_BLOCK_SLV_AXI_RD_LIMIT 0x378
75	#define PARF_BLOCK_SLV_AXI_RD_LIMIT_HI 0x37c
76	#define PARF_ECAM_BASE 0x380
77	#define PARF_ECAM_BASE_HI 0x384
78	#define PARF_NO_SNOOP_OVERRIDE 0x3d4	67	#define PARF_NO_SNOOP_OVERRIDE 0x3d4
79	#define PARF_ATU_BASE_ADDR 0x634	68	#define PARF_ATU_BASE_ADDR 0x634
80	#define PARF_ATU_BASE_ADDR_HI 0x638	69	#define PARF_ATU_BASE_ADDR_HI 0x638
@@ -98,7 +87,6 @@ · 17 unmodified lines
98		87
99	/* PARF_SYS_CTRL register fields */	88	/* PARF_SYS_CTRL register fields */
100	#define MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN BIT(29)	89	#define MAC_PHY_POWERDOWN_IN_P2_D_MUX_EN BIT(29)
101	#define PCIE_ECAM_BLOCKER_EN BIT(26)
102	#define MST_WAKEUP_EN BIT(13)	90	#define MST_WAKEUP_EN BIT(13)
103	#define SLV_WAKEUP_EN BIT(12)	91	#define SLV_WAKEUP_EN BIT(12)
104	#define MSTR_ACLK_CGC_DIS BIT(10)	92	#define MSTR_ACLK_CGC_DIS BIT(10)
@@ -146,9 +134,6 @@ · 41 unmodified lines
146	/* PARF_LTSSM register fields */	134	/* PARF_LTSSM register fields */
147	#define LTSSM_EN BIT(8)	135	#define LTSSM_EN BIT(8)
148		136
149	/* PARF_SLV_DBI_ELBI */
150	#define SLV_DBI_ELBI_ADDR_BASE GENMASK(11, 0)
151
152	/* PARF_INT_ALL_{STATUS/CLEAR/MASK} register fields */	137	/* PARF_INT_ALL_{STATUS/CLEAR/MASK} register fields */
153	#define PARF_INT_ALL_LINK_UP BIT(13)	138	#define PARF_INT_ALL_LINK_UP BIT(13)
154	#define PARF_INT_MSI_DEV_0_7 GENMASK(30, 23)	139	#define PARF_INT_MSI_DEV_0_7 GENMASK(30, 23)
@@ -326,47 +311,6 @@ static void qcom_ep_reset_deassert(struct qcom_pcie *pcie) · 171 unmodified lines
326	qcom_perst_assert(pcie, false);	311	qcom_perst_assert(pcie, false);
327	}	312	}
328		313
329	static void qcom_pci_config_ecam(struct dw_pcie_rp *pp)
330	{
331	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
332	struct qcom_pcie *pcie = to_qcom_pcie(pci);
333	u64 addr, addr_end;
334	u32 val;
335
336	writel_relaxed(lower_32_bits(pci->dbi_phys_addr), pcie->parf + PARF_ECAM_BASE);
337	writel_relaxed(upper_32_bits(pci->dbi_phys_addr), pcie->parf + PARF_ECAM_BASE_HI);
338
339	/*
340	* The only device on the root bus is a single Root Port. If we try to
341	* access any devices other than Device/Function 00.0 on Bus 0, the TLP
342	* will go outside of the controller to the PCI bus. But with CFG Shift
343	* Feature (ECAM) enabled in iATU, there is no guarantee that the
344	* response is going to be all F's. Hence, to make sure that the
345	* requester gets all F's response for accesses other than the Root
346	* Port, configure iATU to block the transactions starting from
347	* function 1 of the root bus to the end of the root bus (i.e., from
348	* dbi_base + 4KB to dbi_base + 1MB).
349	*/
350	addr = pci->dbi_phys_addr + SZ_4K;
351	writel_relaxed(lower_32_bits(addr), pcie->parf + PARF_BLOCK_SLV_AXI_WR_BASE);
352	writel_relaxed(upper_32_bits(addr), pcie->parf + PARF_BLOCK_SLV_AXI_WR_BASE_HI);
353
354	writel_relaxed(lower_32_bits(addr), pcie->parf + PARF_BLOCK_SLV_AXI_RD_BASE);
355	writel_relaxed(upper_32_bits(addr), pcie->parf + PARF_BLOCK_SLV_AXI_RD_BASE_HI);
356
357	addr_end = pci->dbi_phys_addr + SZ_1M - 1;
358
359	writel_relaxed(lower_32_bits(addr_end), pcie->parf + PARF_BLOCK_SLV_AXI_WR_LIMIT);
360	writel_relaxed(upper_32_bits(addr_end), pcie->parf + PARF_BLOCK_SLV_AXI_WR_LIMIT_HI);
361
362	writel_relaxed(lower_32_bits(addr_end), pcie->parf + PARF_BLOCK_SLV_AXI_RD_LIMIT);
363	writel_relaxed(upper_32_bits(addr_end), pcie->parf + PARF_BLOCK_SLV_AXI_RD_LIMIT_HI);
364
365	val = readl_relaxed(pcie->parf + PARF_SYS_CTRL);
366	val \|= PCIE_ECAM_BLOCKER_EN;
367	writel_relaxed(val, pcie->parf + PARF_SYS_CTRL);
368	}
369
370	static int qcom_pcie_start_link(struct dw_pcie *pci)	314	static int qcom_pcie_start_link(struct dw_pcie *pci)
371	{	315	{
372	struct qcom_pcie *pcie = to_qcom_pcie(pci);	316	struct qcom_pcie *pcie = to_qcom_pcie(pci);
@@ -1320,7 +1264,6 @@ static int qcom_pcie_host_init(struct dw_pcie_rp *pp) · 947 unmodified lines
1320	{	1264	{
1321	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);	1265	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
1322	struct qcom_pcie *pcie = to_qcom_pcie(pci);	1266	struct qcom_pcie *pcie = to_qcom_pcie(pci);
1323	u16 offset;
1324	int ret;	1267	int ret;
1325		1268
1326	qcom_ep_reset_assert(pcie);	1269	qcom_ep_reset_assert(pcie);
@@ -1329,17 +1272,6 @@ static int qcom_pcie_host_init(struct dw_pcie_rp *pp) · 2 unmodified lines
1329	if (ret)	1272	if (ret)
1330	return ret;	1273	return ret;
1331		1274
1332	if (pp->ecam_enabled) {
1333	/*
1334	* Override ELBI when ECAM is enabled, as when ECAM is enabled,
1335	* ELBI moves under the 'config' space.
1336	*/
1337	offset = FIELD_GET(SLV_DBI_ELBI_ADDR_BASE, readl(pcie->parf + PARF_SLV_DBI_ELBI));
1338	pci->elbi_base = pci->dbi_base + offset;
1339
1340	qcom_pci_config_ecam(pp);
1341	}
1342
1343	ret = qcom_pcie_phy_power_on(pcie);	1275	ret = qcom_pcie_phy_power_on(pcie);
1344	if (ret)	1276	if (ret)
1345	goto err_deinit;	1277	goto err_deinit;

drivers/pci/pcie/aspm.c+9−25

 	/* Clock PM state */
 	u32 clkpm_capable:1;		/* Clock PM capable? */
 	u32 clkpm_enabled:1;		/* Current Clock PM state */
-	u32 clkpm_default:1;		/* Default Clock PM state by BIOS or
+	u32 clkpm_default:1;		/* Default Clock PM state by BIOS */
-					   override */
 	u32 clkpm_disable:1;		/* Clock PM disabled */
 };
 	pcie_set_clkpm_nocheck(link, enable);
 }
-static void pcie_clkpm_override_default_link_state(struct pcie_link_state *link,
-						   int enabled)
-{
-	struct pci_dev *pdev = link->downstream;
-	/* For devicetree platforms, enable ClockPM by default */
-	if (of_have_populated_dt() && !enabled) {
-		link->clkpm_default = 1;
-		pci_info(pdev, "ASPM: DT platform, enabling ClockPM\n");
-	}
-}
 static void pcie_clkpm_cap_init(struct pcie_link_state *link, int blacklist)
 {
 	int capable = 1, enabled = 1;
 	}
 	link->clkpm_enabled = enabled;
 	link->clkpm_default = enabled;
-	pcie_clkpm_override_default_link_state(link, enabled);
 	link->clkpm_capable = capable;
 	link->clkpm_disable = blacklist ? 1 : 0;
 }
 	struct pci_dev *pdev = link->downstream;
 	u32 override;
-	/* For devicetree platforms, enable all ASPM states by default */
+	/* For devicetree platforms, enable L0s and L1 by default */
 	if (of_have_populated_dt()) {
-		link->aspm_default = PCIE_LINK_STATE_ASPM_ALL;
+		if (link->aspm_support & PCIE_LINK_STATE_L0S)
+			link->aspm_default |= PCIE_LINK_STATE_L0S;
+		if (link->aspm_support & PCIE_LINK_STATE_L1)
+			link->aspm_default |= PCIE_LINK_STATE_L1;
 		override = link->aspm_default & ~link->aspm_enabled;
 		if (override)
-			pci_info(pdev, "ASPM: DT platform, enabling%s%s%s%s%s%s%s\n",
+			pci_info(pdev, "ASPM: default states%s%s\n",
-				 FLAG(override, L0S_UP, " L0s-up"),
+				 FLAG(override, L0S, " L0s"),
-				 FLAG(override, L0S_DW, " L0s-dw"),
+				 FLAG(override, L1, " L1"));
-				 FLAG(override, L1, " L1"),
-				 FLAG(override, L1_1, " ASPM-L1.1"),
-				 FLAG(override, L1_2, " ASPM-L1.2"),
-				 FLAG(override, L1_1_PCIPM, " PCI-PM-L1.1"),
-				 FLAG(override, L1_2_PCIPM, " PCI-PM-L1.2"));
 	}
 }

drivers/platform/mellanox/mlxbf-pmc.c+1−0

@@ -2015,6 +2015,7 @@ static int mlxbf_pmc_init_perftype_counter(struct device *dev, unsigned int blk_ · 2014 unmodified lines
2015	if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {	2015	if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {
2016	/* Program crspace counters to count clock cycles using "count_clock" sysfs */	2016	/* Program crspace counters to count clock cycles using "count_clock" sysfs */
2017	attr = &pmc->block[blk_num].attr_count_clock;	2017	attr = &pmc->block[blk_num].attr_count_clock;
		2018	sysfs_attr_init(&attr->dev_attr.attr);
2018	attr->dev_attr.attr.mode = 0644;	2019	attr->dev_attr.attr.mode = 0644;
2019	attr->dev_attr.show = mlxbf_pmc_count_clock_show;	2020	attr->dev_attr.show = mlxbf_pmc_count_clock_show;
2020	attr->dev_attr.store = mlxbf_pmc_count_clock_store;	2021	attr->dev_attr.store = mlxbf_pmc_count_clock_store;

drivers/platform/x86/dell/alienware-wmi-wmax.c+10−2

 		},
 		.driver_data = &g_series_quirks,
 	},
+	{
+		.ident = "Dell Inc. G15 5530",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Dell G15 5530"),
+		},
+		.driver_data = &g_series_quirks,
+	},
 	{
 		.ident = "Dell Inc. G16 7630",
 		.matches = {
 static int wmax_wmi_suspend(struct device *dev)
 {
-	if (awcc->hwmon)
+	if (awcc && awcc->hwmon)
 		awcc_hwmon_suspend(dev);
 	return 0;
 static int wmax_wmi_resume(struct device *dev)
 {
-	if (awcc->hwmon)
+	if (awcc && awcc->hwmon)
 		awcc_hwmon_resume(dev);
 	return 0;

drivers/ptp/ptp_ocp.c+1−1

@@ -2548,7 +2548,7 @@ ptp_ocp_sma_fb_init(struct ptp_ocp *bp) · 2547 unmodified lines
2548	for (i = 0; i < OCP_SMA_NUM; i++) {	2548	for (i = 0; i < OCP_SMA_NUM; i++) {
2549	bp->sma[i].fixed_fcn = true;	2549	bp->sma[i].fixed_fcn = true;
2550	bp->sma[i].fixed_dir = true;	2550	bp->sma[i].fixed_dir = true;
2551	bp->sma[1].dpll_prop.capabilities &=	2551	bp->sma[i].dpll_prop.capabilities &=
2552	~DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE;	2552	~DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE;
2553	}	2553	}
2554	return;	2554	return;

drivers/scsi/libfc/fc_fcp.c+1−1

@@ -503,7 +503,7 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt fsp, struct fc_frame fp) · 502 unmodified lines
503	host_bcode = FC_ERROR;	503	host_bcode = FC_ERROR;
504	goto err;	504	goto err;
505	}	505	}
506	if (offset + len > fsp->data_len) {	506	if (size_add(offset, len) > fsp->data_len) {
507	/* this should never happen */	507	/* this should never happen */
508	if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&	508	if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
509	fc_frame_crc_check(fp))	509	fc_frame_crc_check(fp))

drivers/scsi/qla4xxx/ql4_os.c+4−4

drivers/scsi/storvsc_drv.c+45−51

 	}
 	/*
-	 * Our channel array is sparsley populated and we
+	 * Our channel array could be sparsley populated and we
 	 * initiated I/O on a processor/hw-q that does not
 	 * currently have a designated channel. Fix this.
 	 * The strategy is simple:
-	 * I. Ensure NUMA locality
+	 * I. Prefer the channel associated with the current CPU
-	 * II. Distribute evenly (best effort)
+	 * II. Ensure NUMA locality
+	 * III. Distribute evenly (best effort)
 	 */
+	/* Prefer the channel on the I/O issuing processor/hw-q */
+	if (cpumask_test_cpu(q_num, &stor_device->alloced_cpus))
+		return stor_device->stor_chns[q_num];
 	node_mask = cpumask_of_node(cpu_to_node(q_num));
 	num_channels = 0;
 	/* See storvsc_change_target_cpu(). */
 	outgoing_channel = READ_ONCE(stor_device->stor_chns[q_num]);
 	if (outgoing_channel != NULL) {
-		if (outgoing_channel->target_cpu == q_num) {
+		if (hv_get_avail_to_write_percent(&outgoing_channel->outbound)
-			/*
+				> ring_avail_percent_lowater)
-			 * Ideally, we want to pick a different channel if
+			goto found_channel;
-			 * available on the same NUMA node.
-			 */
-			node_mask = cpumask_of_node(cpu_to_node(q_num));
-			for_each_cpu_wrap(tgt_cpu,
-				 &stor_device->alloced_cpus, q_num + 1) {
-				if (!cpumask_test_cpu(tgt_cpu, node_mask))
-					continue;
-				if (tgt_cpu == q_num)
-					continue;
-				channel = READ_ONCE(
-					stor_device->stor_chns[tgt_cpu]);
-				if (channel == NULL)
-					continue;
-				if (hv_get_avail_to_write_percent(
-							&channel->outbound)
-						> ring_avail_percent_lowater) {
-					outgoing_channel = channel;
-					goto found_channel;
-				}
-			}
-			/*
+		/*
-			 * All the other channels on the same NUMA node are
+		 * Channel is busy, try to find a channel on the same NUMA node
-			 * busy. Try to use the channel on the current CPU
+		 */
-			 */
+		node_mask = cpumask_of_node(cpu_to_node(q_num));
-			if (hv_get_avail_to_write_percent(
+		for_each_cpu_wrap(tgt_cpu, &stor_device->alloced_cpus,
-						&outgoing_channel->outbound)
+				  q_num + 1) {
-					> ring_avail_percent_lowater)
+			if (!cpumask_test_cpu(tgt_cpu, node_mask))
+				continue;
+			channel = READ_ONCE(stor_device->stor_chns[tgt_cpu]);
+			if (!channel)
+				continue;
+			if (hv_get_avail_to_write_percent(&channel->outbound)
+					> ring_avail_percent_lowater) {
+				outgoing_channel = channel;
 				goto found_channel;
+			}
+		}
-			/*
+		/*
-			 * If we reach here, all the channels on the current
+		 * If we reach here, all the channels on the current
-			 * NUMA node are busy. Try to find a channel in
+		 * NUMA node are busy. Try to find a channel in
-			 * other NUMA nodes
+		 * all NUMA nodes
-			 */
+		 */
-			for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
+		for_each_cpu_wrap(tgt_cpu, &stor_device->alloced_cpus,
-				if (cpumask_test_cpu(tgt_cpu, node_mask))
+				  q_num + 1) {
-					continue;
+			channel = READ_ONCE(stor_device->stor_chns[tgt_cpu]);
-				channel = READ_ONCE(
+			if (!channel)
-					stor_device->stor_chns[tgt_cpu]);
+				continue;
-				if (channel == NULL)
+			if (hv_get_avail_to_write_percent(&channel->outbound)
-					continue;
+					> ring_avail_percent_lowater) {
-				if (hv_get_avail_to_write_percent(
+				outgoing_channel = channel;
-							&channel->outbound)
+				goto found_channel;
-						> ring_avail_percent_lowater) {
-					outgoing_channel = channel;
-					goto found_channel;
-				}
 			}
 		}
+		/*
+		 * If we reach here, all the channels are busy. Use the
+		 * original channel found.
+		 */
 	} else {
 		spin_lock_irqsave(&stor_device->lock, flags);
 		outgoing_channel = stor_device->stor_chns[q_num];

drivers/spi/spi-airoha-snfi.c+97−31

@@ -192,6 +192,14 @@ · 191 unmodified lines
192	#define SPI_NAND_OP_RESET 0xff	192	#define SPI_NAND_OP_RESET 0xff
193	#define SPI_NAND_OP_DIE_SELECT 0xc2	193	#define SPI_NAND_OP_DIE_SELECT 0xc2
194		194
		195	/* SNAND FIFO commands */
		196	#define SNAND_FIFO_TX_BUSWIDTH_SINGLE 0x08
		197	#define SNAND_FIFO_TX_BUSWIDTH_DUAL 0x09
		198	#define SNAND_FIFO_TX_BUSWIDTH_QUAD 0x0a
		199	#define SNAND_FIFO_RX_BUSWIDTH_SINGLE 0x0c
		200	#define SNAND_FIFO_RX_BUSWIDTH_DUAL 0x0e
		201	#define SNAND_FIFO_RX_BUSWIDTH_QUAD 0x0f
		202
195	#define SPI_NAND_CACHE_SIZE (SZ_4K + SZ_256)	203	#define SPI_NAND_CACHE_SIZE (SZ_4K + SZ_256)
196	#define SPI_MAX_TRANSFER_SIZE 511	204	#define SPI_MAX_TRANSFER_SIZE 511
197		205
@@ -387,10 +395,26 @@ static int airoha_snand_set_mode(struct airoha_snand_ctrl *as_ctrl, · 189 unmodified lines
387	return regmap_write(as_ctrl->regmap_ctrl, REG_SPI_CTRL_DUMMY, 0);	395	return regmap_write(as_ctrl->regmap_ctrl, REG_SPI_CTRL_DUMMY, 0);
388	}	396	}
389		397
390	static int airoha_snand_write_data(struct airoha_snand_ctrl *as_ctrl, u8 cmd,	398	static int airoha_snand_write_data(struct airoha_snand_ctrl *as_ctrl,
391	const u8 *data, int len)	399	const u8 *data, int len, int buswidth)
392	{	400	{
393	int i, data_len;	401	int i, data_len;
		402	u8 cmd;
		403
		404	switch (buswidth) {
		405	case 0:
		406	case 1:
		407	cmd = SNAND_FIFO_TX_BUSWIDTH_SINGLE;
		408	break;
		409	case 2:
		410	cmd = SNAND_FIFO_TX_BUSWIDTH_DUAL;
		411	break;
		412	case 4:
		413	cmd = SNAND_FIFO_TX_BUSWIDTH_QUAD;
		414	break;
		415	default:
		416	return -EINVAL;
		417	}
394		418
395	for (i = 0; i < len; i += data_len) {	419	for (i = 0; i < len; i += data_len) {
396	int err;	420	int err;
@@ -409,16 +433,32 @@ static int airoha_snand_write_data(struct airoha_snand_ctrl *as_ctrl, u8 cmd, · 12 unmodified lines
409	return 0;	433	return 0;
410	}	434	}
411		435
412	static int airoha_snand_read_data(struct airoha_snand_ctrl as_ctrl, u8 data,	436	static int airoha_snand_read_data(struct airoha_snand_ctrl *as_ctrl,
413	int len)	437	u8 *data, int len, int buswidth)
414	{	438	{
415	int i, data_len;	439	int i, data_len;
		440	u8 cmd;
		441
		442	switch (buswidth) {
		443	case 0:
		444	case 1:
		445	cmd = SNAND_FIFO_RX_BUSWIDTH_SINGLE;
		446	break;
		447	case 2:
		448	cmd = SNAND_FIFO_RX_BUSWIDTH_DUAL;
		449	break;
		450	case 4:
		451	cmd = SNAND_FIFO_RX_BUSWIDTH_QUAD;
		452	break;
		453	default:
		454	return -EINVAL;
		455	}
416		456
417	for (i = 0; i < len; i += data_len) {	457	for (i = 0; i < len; i += data_len) {
418	int err;	458	int err;
419		459
420	data_len = min(len - i, SPI_MAX_TRANSFER_SIZE);	460	data_len = min(len - i, SPI_MAX_TRANSFER_SIZE);
421	err = airoha_snand_set_fifo_op(as_ctrl, 0xc, data_len);	461	err = airoha_snand_set_fifo_op(as_ctrl, cmd, data_len);
422	if (err)	462	if (err)
423	return err;	463	return err;
424		464
@@ -618,6 +658,10 @@ static int airoha_snand_dirmap_create(struct spi_mem_dirmap_desc *desc) · 193 unmodified lines
618	if (desc->info.offset + desc->info.length > U32_MAX)	658	if (desc->info.offset + desc->info.length > U32_MAX)
619	return -EINVAL;	659	return -EINVAL;
620		660
		661	/* continuous reading is not supported */
		662	if (desc->info.length > SPI_NAND_CACHE_SIZE)
		663	return -E2BIG;
		664
621	if (!airoha_snand_supports_op(desc->mem, &desc->info.op_tmpl))	665	if (!airoha_snand_supports_op(desc->mem, &desc->info.op_tmpl))
622	return -EOPNOTSUPP;	666	return -EOPNOTSUPP;
623		667
@@ -654,13 +698,13 @@ static ssize_t airoha_snand_dirmap_read(struct spi_mem_dirmap_desc *desc, · 30 unmodified lines
654		698
655	err = airoha_snand_nfi_config(as_ctrl);	699	err = airoha_snand_nfi_config(as_ctrl);
656	if (err)	700	if (err)
657	return err;	701	goto error_dma_mode_off;
658		702
659	dma_addr = dma_map_single(as_ctrl->dev, txrx_buf, SPI_NAND_CACHE_SIZE,	703	dma_addr = dma_map_single(as_ctrl->dev, txrx_buf, SPI_NAND_CACHE_SIZE,
660	DMA_FROM_DEVICE);	704	DMA_FROM_DEVICE);
661	err = dma_mapping_error(as_ctrl->dev, dma_addr);	705	err = dma_mapping_error(as_ctrl->dev, dma_addr);
662	if (err)	706	if (err)
663	return err;	707	goto error_dma_mode_off;
664		708
665	/* set dma addr */	709	/* set dma addr */
666	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_STRADDR,	710	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_STRADDR,
@@ -689,8 +733,9 @@ static ssize_t airoha_snand_dirmap_read(struct spi_mem_dirmap_desc *desc, · 22 unmodified lines
689	if (err)	733	if (err)
690	goto error_dma_unmap;	734	goto error_dma_unmap;
691		735
692	/* set read addr */	736	/* set read addr: zero page offset + descriptor read offset */
693	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_RD_CTL3, 0x0);	737	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_RD_CTL3,
		738	desc->info.offset);
694	if (err)	739	if (err)
695	goto error_dma_unmap;	740	goto error_dma_unmap;
696		741
@@ -760,6 +805,8 @@ static ssize_t airoha_snand_dirmap_read(struct spi_mem_dirmap_desc *desc, · 63 unmodified lines
760	error_dma_unmap:	805	error_dma_unmap:
761	dma_unmap_single(as_ctrl->dev, dma_addr, SPI_NAND_CACHE_SIZE,	806	dma_unmap_single(as_ctrl->dev, dma_addr, SPI_NAND_CACHE_SIZE,
762	DMA_FROM_DEVICE);	807	DMA_FROM_DEVICE);
		808	error_dma_mode_off:
		809	airoha_snand_set_mode(as_ctrl, SPI_MODE_MANUAL);
763	return err;	810	return err;
764	}	811	}
765		812
@@ -824,7 +871,9 @@ static ssize_t airoha_snand_dirmap_write(struct spi_mem_dirmap_desc *desc, · 58 unmodified lines
824	if (err)	871	if (err)
825	goto error_dma_unmap;	872	goto error_dma_unmap;
826		873
827	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_PG_CTL2, 0x0);	874	/* set write addr: zero page offset + descriptor write offset */
		875	err = regmap_write(as_ctrl->regmap_nfi, REG_SPI_NFI_PG_CTL2,
		876	desc->info.offset);
828	if (err)	877	if (err)
829	goto error_dma_unmap;	878	goto error_dma_unmap;
830		879
@@ -892,18 +941,35 @@ static ssize_t airoha_snand_dirmap_write(struct spi_mem_dirmap_desc *desc, · 61 unmodified lines
892	error_dma_unmap:	941	error_dma_unmap:
893	dma_unmap_single(as_ctrl->dev, dma_addr, SPI_NAND_CACHE_SIZE,	942	dma_unmap_single(as_ctrl->dev, dma_addr, SPI_NAND_CACHE_SIZE,
894	DMA_TO_DEVICE);	943	DMA_TO_DEVICE);
		944	airoha_snand_set_mode(as_ctrl, SPI_MODE_MANUAL);
895	return err;	945	return err;
896	}	946	}
897		947
898	static int airoha_snand_exec_op(struct spi_mem *mem,	948	static int airoha_snand_exec_op(struct spi_mem *mem,
899	const struct spi_mem_op *op)	949	const struct spi_mem_op *op)
900	{	950	{
901	u8 data[8], cmd, opcode = op->cmd.opcode;
902	struct airoha_snand_ctrl *as_ctrl;	951	struct airoha_snand_ctrl *as_ctrl;
		952	int op_len, addr_len, dummy_len;
		953	u8 buf[20], *data;
903	int i, err;	954	int i, err;
904		955
905	as_ctrl = spi_controller_get_devdata(mem->spi->controller);	956	as_ctrl = spi_controller_get_devdata(mem->spi->controller);
906		957
		958	op_len = op->cmd.nbytes;
		959	addr_len = op->addr.nbytes;
		960	dummy_len = op->dummy.nbytes;
		961
		962	if (op_len + dummy_len + addr_len > sizeof(buf))
		963	return -EIO;
		964
		965	data = buf;
		966	for (i = 0; i < op_len; i++)
		967	data++ = op->cmd.opcode >> (8 (op_len - i - 1));
		968	for (i = 0; i < addr_len; i++)
		969	data++ = op->addr.val >> (8 (addr_len - i - 1));
		970	for (i = 0; i < dummy_len; i++)
		971	*data++ = 0xff;
		972
907	/* switch to manual mode */	973	/* switch to manual mode */
908	err = airoha_snand_set_mode(as_ctrl, SPI_MODE_MANUAL);	974	err = airoha_snand_set_mode(as_ctrl, SPI_MODE_MANUAL);
909	if (err < 0)	975	if (err < 0)
@@ -914,40 +980,40 @@ static int airoha_snand_exec_op(struct spi_mem *mem, · 4 unmodified lines
914	return err;	980	return err;
915		981
916	/* opcode */	982	/* opcode */
917	err = airoha_snand_write_data(as_ctrl, 0x8, &opcode, sizeof(opcode));	983	data = buf;
		984	err = airoha_snand_write_data(as_ctrl, data, op_len,
		985	op->cmd.buswidth);
918	if (err)	986	if (err)
919	return err;	987	return err;
920		988
921	/* addr part */	989	/* addr part */
922	cmd = opcode == SPI_NAND_OP_GET_FEATURE ? 0x11 : 0x8;	990	data += op_len;
923	put_unaligned_be64(op->addr.val, data);	991	if (addr_len) {
924		992	err = airoha_snand_write_data(as_ctrl, data, addr_len,
925	for (i = ARRAY_SIZE(data) - op->addr.nbytes;	993	op->addr.buswidth);
926	i < ARRAY_SIZE(data); i++) {
927	err = airoha_snand_write_data(as_ctrl, cmd, &data[i],
928	sizeof(data[0]));
929	if (err)	994	if (err)
930	return err;	995	return err;
931	}	996	}
932		997
933	/* dummy */	998	/* dummy */
934	data[0] = 0xff;	999	data += addr_len;
935	for (i = 0; i < op->dummy.nbytes; i++) {	1000	if (dummy_len) {
936	err = airoha_snand_write_data(as_ctrl, 0x8, &data[0],	1001	err = airoha_snand_write_data(as_ctrl, data, dummy_len,
937	sizeof(data[0]));	1002	op->dummy.buswidth);
938	if (err)	1003	if (err)
939	return err;	1004	return err;
940	}	1005	}
941		1006
942	/* data */	1007	/* data */
943	if (op->data.dir == SPI_MEM_DATA_IN) {	1008	if (op->data.nbytes) {
944	err = airoha_snand_read_data(as_ctrl, op->data.buf.in,	1009	if (op->data.dir == SPI_MEM_DATA_IN)
945	op->data.nbytes);	1010	err = airoha_snand_read_data(as_ctrl, op->data.buf.in,
946	if (err)	1011	op->data.nbytes,
947	return err;	1012	op->data.buswidth);
948	} else {	1013	else
949	err = airoha_snand_write_data(as_ctrl, 0x8, op->data.buf.out,	1014	err = airoha_snand_write_data(as_ctrl, op->data.buf.out,
950	op->data.nbytes);	1015	op->data.nbytes,
		1016	op->data.buswidth);
951	if (err)	1017	if (err)
952	return err;	1018	return err;
953	}	1019	}

drivers/spi/spi-amlogic-spifc-a4.c+2−2

@@ -286,7 +286,7 @@ static int aml_sfc_set_bus_width(struct aml_sfc *sfc, u8 buswidth, u32 mask) · 285 unmodified lines
286		286
287	for (i = 0; i <= LANE_MAX; i++) {	287	for (i = 0; i <= LANE_MAX; i++) {
288	if (buswidth == 1 << i) {	288	if (buswidth == 1 << i) {
289	conf = i << __bf_shf(mask);	289	conf = i << __ffs(mask);
290	return regmap_update_bits(sfc->regmap_base, SFC_SPI_CFG,	290	return regmap_update_bits(sfc->regmap_base, SFC_SPI_CFG,
291	mask, conf);	291	mask, conf);
292	}	292	}
@@ -566,7 +566,7 @@ static int aml_sfc_raw_io_op(struct aml_sfc sfc, const struct spi_mem_op op) · 273 unmodified lines
566	if (!op->data.nbytes)	566	if (!op->data.nbytes)
567	goto end_xfer;	567	goto end_xfer;
568		568
569	conf = (op->data.nbytes >> RAW_SIZE_BW) << __bf_shf(RAW_EXT_SIZE);	569	conf = (op->data.nbytes >> RAW_SIZE_BW) << __ffs(RAW_EXT_SIZE);
570	ret = regmap_update_bits(sfc->regmap_base, SFC_SPI_CFG, RAW_EXT_SIZE, conf);	570	ret = regmap_update_bits(sfc->regmap_base, SFC_SPI_CFG, RAW_EXT_SIZE, conf);
571	if (ret)	571	if (ret)
572	goto err_out;	572	goto err_out;

drivers/spi/spi-cadence-quadspi.c+3−2

 	if (cqspi->use_direct_mode) {
 		ret = cqspi_request_mmap_dma(cqspi);
 		if (ret == -EPROBE_DEFER)
-			goto probe_setup_failed;
+			goto probe_dma_failed;
 	}
 	if (!(ddata && (ddata->quirks & CQSPI_DISABLE_RUNTIME_PM))) {
 	return 0;
 probe_setup_failed:
-	cqspi_controller_enable(cqspi, 0);
 	if (!(ddata && (ddata->quirks & CQSPI_DISABLE_RUNTIME_PM)))
 		pm_runtime_disable(dev);
+probe_dma_failed:
+	cqspi_controller_enable(cqspi, 0);
 probe_reset_failed:
 	if (cqspi->is_jh7110)
 		cqspi_jh7110_disable_clk(pdev, cqspi);

drivers/spi/spi-dw-mmio.c+3−1

@@ -358,7 +358,9 @@ static int dw_spi_mmio_probe(struct platform_device *pdev) · 357 unmodified lines
358	if (IS_ERR(dwsmmio->rstc))	358	if (IS_ERR(dwsmmio->rstc))
359	return PTR_ERR(dwsmmio->rstc);	359	return PTR_ERR(dwsmmio->rstc);
360		360
361	reset_control_deassert(dwsmmio->rstc);	361	ret = reset_control_deassert(dwsmmio->rstc);
		362	if (ret)
		363	return dev_err_probe(&pdev->dev, ret, "Failed to deassert resets\n");
362		364
363	dws->bus_num = pdev->id;	365	dws->bus_num = pdev->id;
364		366

drivers/spi/spi-intel-pci.c+2−0

 	{ PCI_VDEVICE(INTEL, 0x38a4), (unsigned long)&bxt_info },
 	{ PCI_VDEVICE(INTEL, 0x43a4), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x4b24), (unsigned long)&bxt_info },
+	{ PCI_VDEVICE(INTEL, 0x4d23), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x4da4), (unsigned long)&bxt_info },
 	{ PCI_VDEVICE(INTEL, 0x51a4), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x54a4), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x5794), (unsigned long)&cnl_info },
+	{ PCI_VDEVICE(INTEL, 0x7723), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x7a24), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x7aa4), (unsigned long)&cnl_info },
 	{ PCI_VDEVICE(INTEL, 0x7e23), (unsigned long)&cnl_info },

drivers/spi/spi-intel.c+6−0

 #define FLCOMP_C0DEN_16M		0x05
 #define FLCOMP_C0DEN_32M		0x06
 #define FLCOMP_C0DEN_64M		0x07
+#define FLCOMP_C0DEN_128M		0x08
 #define INTEL_SPI_TIMEOUT		5000 /* ms */
 #define INTEL_SPI_FIFO_SZ		64
 	case FLCOMP_C0DEN_64M:
 		ispi->chip0_size = SZ_64M;
 		break;
+	case FLCOMP_C0DEN_128M:
+		ispi->chip0_size = SZ_128M;
+		break;
 	default:
+		dev_warn(ispi->dev, "unsupported C0DEN: %#lx\n",
+			 flcomp & FLCOMP_C0DEN_MASK);
 		return -EINVAL;
 	}

drivers/spi/spi-nxp-fspi.c+27−5

 #define FSPI_NEED_INIT		BIT(0)
 #define FSPI_DTR_MODE		BIT(1)
 	int flags;
+	/* save the previous operation clock rate */
+	unsigned long pre_op_rate;
+	/* the max clock rate fspi output to device */
+	unsigned long max_rate;
 };
 static inline int needs_ip_only(struct nxp_fspi *f)
 	 * change the mode back to mode 0.
 	 */
 	reg = fspi_readl(f, f->iobase + FSPI_MCR0);
-	if (op_is_dtr)
+	if (op_is_dtr) {
 		reg |= FSPI_MCR0_RXCLKSRC(3);
-	else	/*select mode 0 */
+		f->max_rate = 166000000;
+	} else {	/*select mode 0 */
 		reg &= ~FSPI_MCR0_RXCLKSRC(3);
+		f->max_rate = 66000000;
+	}
 	fspi_writel(f, reg, f->iobase + FSPI_MCR0);
 }
 				   0, POLL_TOUT, true);
 	if (ret)
 		dev_warn(f->dev, "DLL lock failed, please fix it!\n");
+	/*
+	 * For ERR050272, DLL lock status bit is not accurate,
+	 * wait for 4us more as a workaround.
+	 */
+	udelay(4);
 }
 /*
 	uint64_t size_kb;
 	/*
-	 * Return, if previously selected target device is same as current
+	 * Return when following condition all meet,
-	 * requested target device. Also the DTR or STR mode do not change.
+	 * 1, if previously selected target device is same as current
+	 *    requested target device.
+	 * 2, the DTR or STR mode do not change.
+	 * 3, previous operation max rate equals current one.
+	 *
+	 * For other case, need to re-config.
 	 */
 	if ((f->selected == spi_get_chipselect(spi, 0)) &&
-	    (!!(f->flags & FSPI_DTR_MODE) == op_is_dtr))
+	    (!!(f->flags & FSPI_DTR_MODE) == op_is_dtr) &&
+	    (f->pre_op_rate == op->max_freq))
 		return;
 	/* Reset FLSHxxCR0 registers */
 	dev_dbg(f->dev, "Target device [CS:%x] selected\n", spi_get_chipselect(spi, 0));
 	nxp_fspi_select_rx_sample_clk_source(f, op_is_dtr);
+	rate = min(f->max_rate, op->max_freq);
 	if (op_is_dtr) {
 		f->flags |= FSPI_DTR_MODE;
 	else
 		nxp_fspi_dll_override(f);
+	f->pre_op_rate = op->max_freq;
 	f->selected = spi_get_chipselect(spi, 0);
 }

drivers/spi/spi-rockchip-sfc.c+11−1

 			ret = -ENOMEM;
 			goto err_dma;
 		}
-		sfc->dma_buffer = virt_to_phys(sfc->buffer);
+		sfc->dma_buffer = dma_map_single(dev, sfc->buffer,
+					    sfc->max_iosize, DMA_BIDIRECTIONAL);
+		if (dma_mapping_error(dev, sfc->dma_buffer)) {
+			ret = -ENOMEM;
+			goto err_dma_map;
+		}
 	}
 	ret = devm_spi_register_controller(dev, host);
 	return 0;
 err_register:
+	dma_unmap_single(dev, sfc->dma_buffer, sfc->max_iosize,
+			 DMA_BIDIRECTIONAL);
+err_dma_map:
 	free_pages((unsigned long)sfc->buffer, get_order(sfc->max_iosize));
 err_dma:
 	pm_runtime_get_sync(dev);
 	struct spi_controller *host = sfc->host;
 	spi_unregister_controller(host);
+	dma_unmap_single(&pdev->dev, sfc->dma_buffer, sfc->max_iosize,
+			 DMA_BIDIRECTIONAL);
 	free_pages((unsigned long)sfc->buffer, get_order(sfc->max_iosize));
 	clk_disable_unprepare(sfc->clk);

drivers/staging/gpib/agilent_82350b/agilent_82350b.c+7−5

 		return retval;
 #endif
-	retval = agilent_82350b_write(board, buffer, 1, 0, &num_bytes);
+	if (fifotransferlength > 0) {
-	*bytes_written += num_bytes;
+		retval = agilent_82350b_write(board, buffer, 1, 0, &num_bytes);
-	if (retval < 0)
+		*bytes_written += num_bytes;
-		return retval;
+		if (retval < 0)
+			return retval;
+	}
 	write_byte(tms_priv, tms_priv->imr0_bits & ~HR_BOIE, IMR0);
 	for (i = 1; i < fifotransferlength;) {
 			break;
 	}
 	write_byte(tms_priv, tms_priv->imr0_bits, IMR0);
-	if (retval)
+	if (retval < 0)
 		return retval;
 	if (send_eoi) {

drivers/staging/gpib/fmh_gpib/fmh_gpib.c+5−0

 					   resource_size(e_priv->gpib_iomem_res));
 	}
 	fmh_gpib_generic_detach(board);
+	if (board->dev) {
+		put_device(board->dev);
+		board->dev = NULL;
+	}
 }
 static int fmh_gpib_pci_attach_impl(struct gpib_board *board,

drivers/staging/gpib/ni_usb/ni_usb_gpib.c+10−3

 	board->status &= ~clear_mask;
 	board->status &= ~ni_usb_ibsta_mask;
 	board->status |= ni_usb_ibsta & ni_usb_ibsta_mask;
-	// FIXME should generate events on DTAS and DCAS
+	if (ni_usb_ibsta & DCAS)
+		push_gpib_event(board, EVENT_DEV_CLR);
+	if (ni_usb_ibsta & DTAS)
+		push_gpib_event(board, EVENT_DEV_TRG);
 	spin_lock_irqsave(&board->spinlock, flags);
 /* remove set status bits from monitored set why ?***/
 		 */
 		break;
 	case NIUSB_ATN_STATE_ERROR:
-		retval = -EIO;
+		if (status.ibsta & DCAS) {
-		dev_err(&usb_dev->dev, "read when ATN set\n");
+			retval = -EINTR;
+		} else {
+			retval = -EIO;
+			dev_dbg(&usb_dev->dev, "read when ATN set stat: 0x%06x\n", status.ibsta);
+		}
 		break;
 	case NIUSB_ADDRESSING_ERROR:
 		retval = -EIO;

drivers/tee/qcomtee/Kconfig+1−0

@@ -2,6 +2,7 @@ · 1 unmodified line
2	# Qualcomm Trusted Execution Environment Configuration	2	# Qualcomm Trusted Execution Environment Configuration
3	config QCOMTEE	3	config QCOMTEE
4	tristate "Qualcomm TEE Support"	4	tristate "Qualcomm TEE Support"
		5	depends on ARCH_QCOM \|\| COMPILE_TEST
5	depends on !CPU_BIG_ENDIAN	6	depends on !CPU_BIG_ENDIAN
6	select QCOM_SCM	7	select QCOM_SCM
7	select QCOM_TZMEM_MODE_SHMBRIDGE	8	select QCOM_TZMEM_MODE_SHMBRIDGE

drivers/tee/qcomtee/call.c+1−1

@@ -308,7 +308,7 @@ out_failed: · 307 unmodified lines
308	}	308	}
309		309
310	/* Release any IO and OO objects not processed. */	310	/* Release any IO and OO objects not processed. */
311	for (; u[i].type && i < num_params; i++) {	311	for (; i < num_params && u[i].type; i++) {
312	if (u[i].type == QCOMTEE_ARG_TYPE_OO \|\|	312	if (u[i].type == QCOMTEE_ARG_TYPE_OO \|\|
313	u[i].type == QCOMTEE_ARG_TYPE_IO)	313	u[i].type == QCOMTEE_ARG_TYPE_IO)
314	qcomtee_object_put(u[i].o);	314	qcomtee_object_put(u[i].o);

drivers/tee/qcomtee/core.c+1−1

@@ -424,7 +424,7 @@ static int qcomtee_prepare_msg(struct qcomtee_object_invoke_ctx *oic, · 423 unmodified lines
424	if (!(u[i].flags & QCOMTEE_ARG_FLAGS_UADDR))	424	if (!(u[i].flags & QCOMTEE_ARG_FLAGS_UADDR))
425	memcpy(msgptr, u[i].b.addr, u[i].b.size);	425	memcpy(msgptr, u[i].b.addr, u[i].b.size);
426	else if (copy_from_user(msgptr, u[i].b.uaddr, u[i].b.size))	426	else if (copy_from_user(msgptr, u[i].b.uaddr, u[i].b.size))
427	return -EINVAL;	427	return -EFAULT;
428		428
429	offset += qcomtee_msg_offset_align(u[i].b.size);	429	offset += qcomtee_msg_offset_align(u[i].b.size);
430	ib++;	430	ib++;

drivers/tty/serial/8250/8250_dw.c+3−1

@@ -635,7 +635,9 @@ static int dw8250_probe(struct platform_device *pdev) · 634 unmodified lines
635	if (IS_ERR(data->rst))	635	if (IS_ERR(data->rst))
636	return PTR_ERR(data->rst);	636	return PTR_ERR(data->rst);
637		637
638	reset_control_deassert(data->rst);	638	err = reset_control_deassert(data->rst);
		639	if (err)
		640	return dev_err_probe(dev, err, "failed to deassert resets\n");
639		641
640	err = devm_add_action_or_reset(dev, dw8250_reset_control_assert, data->rst);	642	err = devm_add_action_or_reset(dev, dw8250_reset_control_assert, data->rst);
641	if (err)	643	if (err)

drivers/tty/serial/8250/8250_exar.c+11−0

 #define PCI_DEVICE_ID_ACCESSIO_COM_4SM		0x10db
 #define PCI_DEVICE_ID_ACCESSIO_COM_8SM		0x10ea
+#define PCI_DEVICE_ID_ADVANTECH_XR17V352	0x0018
 #define PCI_DEVICE_ID_COMMTECH_4224PCI335	0x0002
 #define PCI_DEVICE_ID_COMMTECH_4222PCI335	0x0004
 #define PCI_DEVICE_ID_COMMTECH_2324PCI335	0x000a
 	.exit		= pci_xr17v35x_exit,
 };
+static const struct exar8250_board pbn_adv_XR17V352 = {
+	.num_ports	= 2,
+	.setup		= pci_xr17v35x_setup,
+	.exit		= pci_xr17v35x_exit,
+};
 static const struct exar8250_board pbn_exar_XR17V4358 = {
 	.num_ports	= 12,
 	.setup		= pci_xr17v35x_setup,
 	USR_DEVICE(XR17C152, 2980, pbn_exar_XR17C15x),
 	USR_DEVICE(XR17C152, 2981, pbn_exar_XR17C15x),
+	/* ADVANTECH devices */
+	EXAR_DEVICE(ADVANTECH, XR17V352, pbn_adv_XR17V352),
 	/* Exar Corp. XR17C15[248] Dual/Quad/Octal UART */
 	EXAR_DEVICE(EXAR, XR17C152, pbn_exar_XR17C15x),
 	EXAR_DEVICE(EXAR, XR17C154, pbn_exar_XR17C15x),

drivers/tty/serial/8250/8250_mtk.c+4−2

 	while
 		(serial_in(up, MTK_UART_DEBUG0));
+	clk_disable_unprepare(data->uart_clk);
 	clk_disable_unprepare(data->bus_clk);
 	return 0;
 	struct mtk8250_data *data = dev_get_drvdata(dev);
 	clk_prepare_enable(data->bus_clk);
+	clk_prepare_enable(data->uart_clk);
 	return 0;
 }
 	int dmacnt;
 #endif
-	data->uart_clk = devm_clk_get(&pdev->dev, "baud");
+	data->uart_clk = devm_clk_get_enabled(&pdev->dev, "baud");
 	if (IS_ERR(data->uart_clk)) {
 		/*
 		 * For compatibility with older device trees try unnamed
 		 * clk when no baud clk can be found.
 		 */
-		data->uart_clk = devm_clk_get(&pdev->dev, NULL);
+		data->uart_clk = devm_clk_get_enabled(&pdev->dev, NULL);
 		if (IS_ERR(data->uart_clk)) {
 			dev_warn(&pdev->dev, "Can't get uart clock\n");
 			return PTR_ERR(data->uart_clk);

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

@@ -588,13 +588,6 @@ static int sc16is7xx_set_baud(struct uart_port *port, int baud) · 587 unmodified lines
588	div /= prescaler;	588	div /= prescaler;
589	}	589	}
590		590
591	/* Enable enhanced features */
592	sc16is7xx_efr_lock(port);
593	sc16is7xx_port_update(port, SC16IS7XX_EFR_REG,
594	SC16IS7XX_EFR_ENABLE_BIT,
595	SC16IS7XX_EFR_ENABLE_BIT);
596	sc16is7xx_efr_unlock(port);
597
598	/* If bit MCR_CLKSEL is set, the divide by 4 prescaler is activated. */	591	/* If bit MCR_CLKSEL is set, the divide by 4 prescaler is activated. */
599	sc16is7xx_port_update(port, SC16IS7XX_MCR_REG,	592	sc16is7xx_port_update(port, SC16IS7XX_MCR_REG,
600	SC16IS7XX_MCR_CLKSEL_BIT,	593	SC16IS7XX_MCR_CLKSEL_BIT,

drivers/tty/serial/sh-sci.c+8−6

@@ -1014,16 +1014,18 @@ static int sci_handle_fifo_overrun(struct uart_port *port) · 1013 unmodified lines
1014	struct sci_port *s = to_sci_port(port);	1014	struct sci_port *s = to_sci_port(port);
1015	const struct plat_sci_reg *reg;	1015	const struct plat_sci_reg *reg;
1016	int copied = 0;	1016	int copied = 0;
1017	u16 status;	1017	u32 status;
1018		1018
1019	reg = sci_getreg(port, s->params->overrun_reg);	1019	if (s->type != SCI_PORT_RSCI) {
1020	if (!reg->size)	1020	reg = sci_getreg(port, s->params->overrun_reg);
1021	return 0;	1021	if (!reg->size)
		1022	return 0;
		1023	}
1022		1024
1023	status = sci_serial_in(port, s->params->overrun_reg);	1025	status = s->ops->read_reg(port, s->params->overrun_reg);
1024	if (status & s->params->overrun_mask) {	1026	if (status & s->params->overrun_mask) {
1025	status &= ~s->params->overrun_mask;	1027	status &= ~s->params->overrun_mask;
1026	sci_serial_out(port, s->params->overrun_reg, status);	1028	s->ops->write_reg(port, s->params->overrun_reg, status);
1027		1029
1028	port->icount.overrun++;	1030	port->icount.overrun++;
1029		1031

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

@@ -467,6 +467,8 @@ static const struct usb_device_id usb_quirk_list[] = { · 466 unmodified lines
467	/* Huawei 4G LTE module */	467	/* Huawei 4G LTE module */
468	{ USB_DEVICE(0x12d1, 0x15bb), .driver_info =	468	{ USB_DEVICE(0x12d1, 0x15bb), .driver_info =
469	USB_QUIRK_DISCONNECT_SUSPEND },	469	USB_QUIRK_DISCONNECT_SUSPEND },
		470	{ USB_DEVICE(0x12d1, 0x15c1), .driver_info =
		471	USB_QUIRK_DISCONNECT_SUSPEND },
470	{ USB_DEVICE(0x12d1, 0x15c3), .driver_info =	472	{ USB_DEVICE(0x12d1, 0x15c3), .driver_info =
471	USB_QUIRK_DISCONNECT_SUSPEND },	473	USB_QUIRK_DISCONNECT_SUSPEND },
472		474

drivers/usb/dwc3/dwc3-generic-plat.c+0−3

 static void dwc3_generic_remove(struct platform_device *pdev)
 {
 	struct dwc3 *dwc = platform_get_drvdata(pdev);
-	struct dwc3_generic *dwc3g = to_dwc3_generic(dwc);
 	dwc3_core_remove(dwc);
-	clk_bulk_disable_unprepare(dwc3g->num_clocks, dwc3g->clks);
 }
 static int dwc3_generic_suspend(struct device *dev)

drivers/usb/gadget/legacy/raw_gadget.c+0−2

 		return ERR_PTR(-EINVAL);
 	if (!usb_raw_io_flags_valid(io->flags))
 		return ERR_PTR(-EINVAL);
-	if (io->length > PAGE_SIZE)
-		return ERR_PTR(-EINVAL);
 	if (get_from_user)
 		data = memdup_user(ptr + sizeof(*io), io->length);
 	else {

drivers/usb/host/xhci-dbgcap.c+12−3

 			dev_info(dbc->dev, "DbC configured\n");
 			portsc = readl(&dbc->regs->portsc);
 			writel(portsc, &dbc->regs->portsc);
-			return EVT_GSER;
+			ret = EVT_GSER;
+			break;
 		}
 		return EVT_DONE;
 			break;
 		case TRB_TYPE(TRB_TRANSFER):
 			dbc_handle_xfer_event(dbc, evt);
-			ret = EVT_XFER_DONE;
+			if (ret != EVT_GSER)
+				ret = EVT_XFER_DONE;
 			break;
 		default:
 			break;
 	if (!dbc)
 		return 0;
-	if (dbc->state == DS_CONFIGURED)
+	switch (dbc->state) {
+	case DS_ENABLED:
+	case DS_CONNECTED:
+	case DS_CONFIGURED:
 		dbc->resume_required = 1;
+		break;
+	default:
+		break;
+	}
 	xhci_dbc_stop(dbc);

drivers/usb/host/xhci-pci.c+2−1

 	if (!usb_hcd_is_primary_hcd(hcd))
 		return 0;
+	xhci->allow_single_roothub = 1;
 	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
 		xhci_pme_acpi_rtd3_enable(pdev);
 	xhci = hcd_to_xhci(hcd);
 	xhci->reset = reset;
-	xhci->allow_single_roothub = 1;
 	if (!xhci_has_one_roothub(xhci)) {
 		xhci->shared_hcd = usb_create_shared_hcd(&xhci_pci_hc_driver, &dev->dev,
 							 pci_name(dev), hcd);

drivers/usb/misc/Kconfig+1−0

@@ -182,6 +182,7 @@ config USB_LJCA · 181 unmodified lines
182	config USB_USBIO	182	config USB_USBIO
183	tristate "Intel USBIO Bridge support"	183	tristate "Intel USBIO Bridge support"
184	depends on USB && ACPI	184	depends on USB && ACPI
		185	depends on X86 \|\| COMPILE_TEST
185	select AUXILIARY_BUS	186	select AUXILIARY_BUS
186	help	187	help
187	This adds support for Intel USBIO drivers.	188	This adds support for Intel USBIO drivers.

drivers/usb/serial/option.c+10−0

 #define QUECTEL_PRODUCT_EM05CN			0x0312
 #define QUECTEL_PRODUCT_EM05G_GR		0x0313
 #define QUECTEL_PRODUCT_EM05G_RS		0x0314
+#define QUECTEL_PRODUCT_RG255C			0x0316
 #define QUECTEL_PRODUCT_EM12			0x0512
 #define QUECTEL_PRODUCT_RM500Q			0x0800
 #define QUECTEL_PRODUCT_RM520N			0x0801
 #define UNISOC_VENDOR_ID			0x1782
 /* TOZED LT70-C based on UNISOC SL8563 uses UNISOC's vendor ID */
 #define TOZED_PRODUCT_LT70C			0x4055
+#define UNISOC_PRODUCT_UIS7720			0x4064
 /* Luat Air72*U series based on UNISOC UIS8910 uses UNISOC's vendor ID */
 #define LUAT_PRODUCT_AIR720U			0x4e00
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500K, 0xff, 0x00, 0x00) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RG650V, 0xff, 0xff, 0x30) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RG650V, 0xff, 0, 0) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RG255C, 0xff, 0xff, 0x30) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RG255C, 0xff, 0, 0) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RG255C, 0xff, 0xff, 0x40) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) },
 	  .driver_info = RSVD(0) | NCTRL(3) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a2, 0xff),	/* Telit FN920C04 (MBIM) */
 	  .driver_info = NCTRL(4) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a3, 0xff),	/* Telit FN920C04 (ECM) */
+	  .driver_info = NCTRL(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a4, 0xff),	/* Telit FN20C04 (rmnet) */
 	  .driver_info = RSVD(0) | NCTRL(3) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a7, 0xff),	/* Telit FN920C04 (MBIM) */
 	  .driver_info = NCTRL(4) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a8, 0xff),	/* Telit FN920C04 (ECM) */
+	  .driver_info = NCTRL(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a9, 0xff),	/* Telit FN20C04 (rmnet) */
 	  .driver_info = RSVD(0) | NCTRL(2) | RSVD(3) | RSVD(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10aa, 0xff),	/* Telit FN920C04 (MBIM) */
 	{ USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9291, 0xff, 0xff, 0x30) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9291, 0xff, 0xff, 0x40) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(UNISOC_VENDOR_ID, TOZED_PRODUCT_LT70C, 0xff, 0, 0) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(UNISOC_VENDOR_ID, UNISOC_PRODUCT_UIS7720, 0xff, 0, 0) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(UNISOC_VENDOR_ID, LUAT_PRODUCT_AIR720U, 0xff, 0, 0) },
 	{ USB_DEVICE_INTERFACE_CLASS(0x1bbb, 0x0530, 0xff),			/* TCL IK512 MBIM */
 	  .driver_info = NCTRL(1) },

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

@@ -7876,9 +7876,9 @@ struct tcpm_port tcpm_register_port(struct device dev, struct tcpc_dev *tcpc) · 7875 unmodified lines
7876		7876
7877	port->partner_desc.identity = &port->partner_ident;	7877	port->partner_desc.identity = &port->partner_ident;
7878		7878
7879	port->role_sw = usb_role_switch_get(port->dev);	7879	port->role_sw = fwnode_usb_role_switch_get(tcpc->fwnode);
7880	if (!port->role_sw)	7880	if (!port->role_sw)
7881	port->role_sw = fwnode_usb_role_switch_get(tcpc->fwnode);	7881	port->role_sw = usb_role_switch_get(port->dev);
7882	if (IS_ERR(port->role_sw)) {	7882	if (IS_ERR(port->role_sw)) {
7883	err = PTR_ERR(port->role_sw);	7883	err = PTR_ERR(port->role_sw);
7884	goto out_destroy_wq;	7884	goto out_destroy_wq;

fs/9p/vfs_dentry.c+2−8

 	struct p9_fid *fid;
 	struct inode *inode;
 	struct v9fs_inode *v9inode;
-	unsigned int cached;
 	if (flags & LOOKUP_RCU)
 		return -ECHILD;
 		goto out_valid;
 	v9inode = V9FS_I(inode);
-	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+	if (v9inode->cache_validity & V9FS_INO_INVALID_ATTR) {
-	cached = v9ses->cache & (CACHE_META | CACHE_LOOSE);
-	if (!cached || v9inode->cache_validity & V9FS_INO_INVALID_ATTR) {
 		int retval;
 		struct v9fs_session_info *v9ses;
 			p9_debug(P9_DEBUG_VFS,
 				"refresh inode: dentry = %pd (%p), got error %pe\n",
 				dentry, dentry, ERR_PTR(retval));
+		if (retval < 0)
 			return retval;
 		}
 	}
 };
 const struct dentry_operations v9fs_dentry_operations = {
-	.d_revalidate = v9fs_lookup_revalidate,
-	.d_weak_revalidate = __v9fs_lookup_revalidate,
 	.d_release = v9fs_dentry_release,
 	.d_unalias_trylock = v9fs_dentry_unalias_trylock,
 	.d_unalias_unlock = v9fs_dentry_unalias_unlock,

fs/9p/vfs_inode.c+1−7

 	 * Don't update inode if the file type is different
 	 */
 	umode = p9mode2unixmode(v9ses, st, &rdev);
-	if (inode_wrong_type(inode, umode)) {
+	if (inode_wrong_type(inode, umode))
-		/*
-		 * Do this as a way of letting the caller know the inode should not
-		 * be reused
-		 */
-		v9fs_invalidate_inode_attr(inode);
 		goto out;
-	}
 	/*
 	 * We don't want to refresh inode->i_size,

fs/9p/vfs_inode_dotl.c+1−7

 	/*
 	 * Don't update inode if the file type is different
 	 */
-	if (inode_wrong_type(inode, st->st_mode)) {
+	if (inode_wrong_type(inode, st->st_mode))
-		/*
-		 * Do this as a way of letting the caller know the inode should not
-		 * be reused
-		 */
-		v9fs_invalidate_inode_attr(inode);
 		goto out;
-	}
 	/*
 	 * We don't want to refresh inode->i_size,

fs/btrfs/delayed-inode.c+1−1

 		for (int i = 0; i < count; i++) {
 			__btrfs_kill_delayed_node(delayed_nodes[i]);
+			btrfs_delayed_node_ref_tracker_dir_print(delayed_nodes[i]);
 			btrfs_release_delayed_node(delayed_nodes[i],
 						   &delayed_node_trackers[i]);
-			btrfs_delayed_node_ref_tracker_dir_print(delayed_nodes[i]);
 		}
 	}
 }

fs/btrfs/delayed-inode.h+7−0

@@ -219,6 +219,13 @@ static inline void btrfs_delayed_node_ref_tracker_dir_print(struct btrfs_delayed · 218 unmodified lines
219	if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))	219	if (!btrfs_test_opt(node->root->fs_info, REF_TRACKER))
220	return;	220	return;
221		221
		222	/*
		223	* Only print if there are leaked references. The caller is
		224	* holding one reference, so if refs == 1 there is no leak.
		225	*/
		226	if (refcount_read(&node->refs) == 1)
		227	return;
		228
222	ref_tracker_dir_print(&node->ref_dir.dir,	229	ref_tracker_dir_print(&node->ref_dir.dir,
223	BTRFS_DELAYED_NODE_REF_TRACKER_DISPLAY_LIMIT);	230	BTRFS_DELAYED_NODE_REF_TRACKER_DISPLAY_LIMIT);
224	}	231	}

fs/btrfs/ref-verify.c+1−1

@@ -982,7 +982,7 @@ int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info) · 981 unmodified lines
982		982
983	extent_root = btrfs_extent_root(fs_info, 0);	983	extent_root = btrfs_extent_root(fs_info, 0);
984	/* If the extent tree is damaged we cannot ignore it (IGNOREBADROOTS). */	984	/* If the extent tree is damaged we cannot ignore it (IGNOREBADROOTS). */
985	if (IS_ERR(extent_root)) {	985	if (!extent_root) {
986	btrfs_warn(fs_info, "ref-verify: extent tree not available, disabling");	986	btrfs_warn(fs_info, "ref-verify: extent tree not available, disabling");
987	btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);	987	btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);
988	return 0;	988	return 0;

fs/btrfs/send.c+48−8

 	return ret;
 }
+static int rbtree_check_dir_ref_comp(const void *k, const struct rb_node *node)
+{
+	const struct recorded_ref *data = k;
+	const struct recorded_ref *ref = rb_entry(node, struct recorded_ref, node);
+	if (data->dir > ref->dir)
+		return 1;
+	if (data->dir < ref->dir)
+		return -1;
+	if (data->dir_gen > ref->dir_gen)
+		return 1;
+	if (data->dir_gen < ref->dir_gen)
+		return -1;
+	return 0;
+}
+static bool rbtree_check_dir_ref_less(struct rb_node *node, const struct rb_node *parent)
+{
+	const struct recorded_ref *entry = rb_entry(node, struct recorded_ref, node);
+	return rbtree_check_dir_ref_comp(entry, parent) < 0;
+}
+static int record_check_dir_ref_in_tree(struct rb_root *root,
+			struct recorded_ref *ref, struct list_head *list)
+{
+	struct recorded_ref *tmp_ref;
+	int ret;
+	if (rb_find(ref, root, rbtree_check_dir_ref_comp))
+		return 0;
+	ret = dup_ref(ref, list);
+	if (ret < 0)
+		return ret;
+	tmp_ref = list_last_entry(list, struct recorded_ref, list);
+	rb_add(&tmp_ref->node, root, rbtree_check_dir_ref_less);
+	tmp_ref->root = root;
+	return 0;
+}
 static int rename_current_inode(struct send_ctx *sctx,
 				struct fs_path *current_path,
 				struct fs_path *new_path)
 	struct recorded_ref *cur;
 	struct recorded_ref *cur2;
 	LIST_HEAD(check_dirs);
+	struct rb_root rbtree_check_dirs = RB_ROOT;
 	struct fs_path *valid_path = NULL;
 	u64 ow_inode = 0;
 	u64 ow_gen;
 	u64 ow_mode;
-	u64 last_dir_ino_rm = 0;
 	bool did_overwrite = false;
 	bool is_orphan = false;
 	bool can_rename = true;
 					goto out;
 			}
 		}
-		ret = dup_ref(cur, &check_dirs);
+		ret = record_check_dir_ref_in_tree(&rbtree_check_dirs, cur, &check_dirs);
 		if (ret < 0)
 			goto out;
 	}
 		}
 		list_for_each_entry(cur, &sctx->deleted_refs, list) {
-			ret = dup_ref(cur, &check_dirs);
+			ret = record_check_dir_ref_in_tree(&rbtree_check_dirs, cur, &check_dirs);
 			if (ret < 0)
 				goto out;
 		}
 		 * We have a moved dir. Add the old parent to check_dirs
 		 */
 		cur = list_first_entry(&sctx->deleted_refs, struct recorded_ref, list);
-		ret = dup_ref(cur, &check_dirs);
+		ret = record_check_dir_ref_in_tree(&rbtree_check_dirs, cur, &check_dirs);
 		if (ret < 0)
 			goto out;
 	} else if (!S_ISDIR(sctx->cur_inode_mode)) {
 				if (is_current_inode_path(sctx, cur->full_path))
 					fs_path_reset(&sctx->cur_inode_path);
 			}
-			ret = dup_ref(cur, &check_dirs);
+			ret = record_check_dir_ref_in_tree(&rbtree_check_dirs, cur, &check_dirs);
 			if (ret < 0)
 				goto out;
 		}
 			ret = cache_dir_utimes(sctx, cur->dir, cur->dir_gen);
 			if (ret < 0)
 				goto out;
-		} else if (ret == inode_state_did_delete &&
+		} else if (ret == inode_state_did_delete) {
-			   cur->dir != last_dir_ino_rm) {
 			ret = can_rmdir(sctx, cur->dir, cur->dir_gen);
 			if (ret < 0)
 				goto out;
 				ret = send_rmdir(sctx, valid_path);
 				if (ret < 0)
 					goto out;
-				last_dir_ino_rm = cur->dir;
 			}
 		}
 	}

fs/btrfs/super.c+7−1

 	fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
 	fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
 	if (!fs_info->super_copy || !fs_info->super_for_commit) {
-		btrfs_free_fs_info(fs_info);
+		/*
+		 * Dont call btrfs_free_fs_info() to free it as it's still
+		 * initialized partially.
+		 */
+		kfree(fs_info->super_copy);
+		kfree(fs_info->super_for_commit);
+		kvfree(fs_info);
 		return -ENOMEM;
 	}
 	btrfs_init_fs_info(fs_info);

fs/erofs/zmap.c+30−29

@@ -55,10 +55,6 @@ static int z_erofs_load_full_lcluster(struct z_erofs_maprecorder *m, · 54 unmodified lines
55	} else {	55	} else {
56	m->partialref = !!(advise & Z_EROFS_LI_PARTIAL_REF);	56	m->partialref = !!(advise & Z_EROFS_LI_PARTIAL_REF);
57	m->clusterofs = le16_to_cpu(di->di_clusterofs);	57	m->clusterofs = le16_to_cpu(di->di_clusterofs);
58	if (m->clusterofs >= 1 << vi->z_lclusterbits) {
59	DBG_BUGON(1);
60	return -EFSCORRUPTED;
61	}
62	m->pblk = le32_to_cpu(di->di_u.blkaddr);	58	m->pblk = le32_to_cpu(di->di_u.blkaddr);
63	}	59	}
64	return 0;	60	return 0;
@@ -240,21 +236,29 @@ static int z_erofs_load_compact_lcluster(struct z_erofs_maprecorder *m, · 175 unmodified lines
240	static int z_erofs_load_lcluster_from_disk(struct z_erofs_maprecorder *m,	236	static int z_erofs_load_lcluster_from_disk(struct z_erofs_maprecorder *m,
241	unsigned int lcn, bool lookahead)	237	unsigned int lcn, bool lookahead)
242	{	238	{
		239	struct erofs_inode *vi = EROFS_I(m->inode);
		240	int err;
		241
		242	if (vi->datalayout == EROFS_INODE_COMPRESSED_COMPACT) {
		243	err = z_erofs_load_compact_lcluster(m, lcn, lookahead);
		244	} else {
		245	DBG_BUGON(vi->datalayout != EROFS_INODE_COMPRESSED_FULL);
		246	err = z_erofs_load_full_lcluster(m, lcn);
		247	}
		248	if (err)
		249	return err;
		250
243	if (m->type >= Z_EROFS_LCLUSTER_TYPE_MAX) {	251	if (m->type >= Z_EROFS_LCLUSTER_TYPE_MAX) {
244	erofs_err(m->inode->i_sb, "unknown type %u @ lcn %u of nid %llu",	252	erofs_err(m->inode->i_sb, "unknown type %u @ lcn %u of nid %llu",
245	m->type, lcn, EROFS_I(m->inode)->nid);	253	m->type, lcn, EROFS_I(m->inode)->nid);
246	DBG_BUGON(1);	254	DBG_BUGON(1);
247	return -EOPNOTSUPP;	255	return -EOPNOTSUPP;
		256	} else if (m->type != Z_EROFS_LCLUSTER_TYPE_NONHEAD &&
		257	m->clusterofs >= (1 << vi->z_lclusterbits)) {
		258	DBG_BUGON(1);
		259	return -EFSCORRUPTED;
248	}	260	}
249		261	return 0;
250	switch (EROFS_I(m->inode)->datalayout) {
251	case EROFS_INODE_COMPRESSED_FULL:
252	return z_erofs_load_full_lcluster(m, lcn);
253	case EROFS_INODE_COMPRESSED_COMPACT:
254	return z_erofs_load_compact_lcluster(m, lcn, lookahead);
255	default:
256	return -EINVAL;
257	}
258	}	262	}
259		263
260	static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m,	264	static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m,
@@ -268,20 +272,19 @@ static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m, · 7 unmodified lines
268	unsigned long lcn = m->lcn - lookback_distance;	272	unsigned long lcn = m->lcn - lookback_distance;
269	int err;	273	int err;
270		274
		275	if (!lookback_distance)
		276	break;
		277
271	err = z_erofs_load_lcluster_from_disk(m, lcn, false);	278	err = z_erofs_load_lcluster_from_disk(m, lcn, false);
272	if (err)	279	if (err)
273	return err;	280	return err;
274
275	if (m->type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {	281	if (m->type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
276	lookback_distance = m->delta[0];	282	lookback_distance = m->delta[0];
277	if (!lookback_distance)
278	break;
279	continue;	283	continue;
280	} else {
281	m->headtype = m->type;
282	m->map->m_la = (lcn << lclusterbits) \| m->clusterofs;
283	return 0;
284	}	284	}
		285	m->headtype = m->type;
		286	m->map->m_la = (lcn << lclusterbits) \| m->clusterofs;
		287	return 0;
285	}	288	}
286	erofs_err(sb, "bogus lookback distance %u @ lcn %lu of nid %llu",	289	erofs_err(sb, "bogus lookback distance %u @ lcn %lu of nid %llu",
287	lookback_distance, m->lcn, vi->nid);	290	lookback_distance, m->lcn, vi->nid);
@@ -431,13 +434,6 @@ static int z_erofs_map_blocks_fo(struct inode *inode, · 143 unmodified lines
431	end = inode->i_size;	434	end = inode->i_size;
432	} else {	435	} else {
433	if (m.type != Z_EROFS_LCLUSTER_TYPE_NONHEAD) {	436	if (m.type != Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
434	/* m.lcn should be >= 1 if endoff < m.clusterofs */
435	if (!m.lcn) {
436	erofs_err(sb, "invalid logical cluster 0 at nid %llu",
437	vi->nid);
438	err = -EFSCORRUPTED;
439	goto unmap_out;
440	}
441	end = (m.lcn << lclusterbits) \| m.clusterofs;	437	end = (m.lcn << lclusterbits) \| m.clusterofs;
442	map->m_flags \|= EROFS_MAP_FULL_MAPPED;	438	map->m_flags \|= EROFS_MAP_FULL_MAPPED;
443	m.delta[0] = 1;	439	m.delta[0] = 1;
@@ -596,7 +592,7 @@ static int z_erofs_map_blocks_ext(struct inode *inode, · 152 unmodified lines
596	vi->z_fragmentoff = map->m_plen;	592	vi->z_fragmentoff = map->m_plen;
597	if (recsz > offsetof(struct z_erofs_extent, pstart_lo))	593	if (recsz > offsetof(struct z_erofs_extent, pstart_lo))
598	vi->z_fragmentoff \|= map->m_pa << 32;	594	vi->z_fragmentoff \|= map->m_pa << 32;
599	} else if (map->m_plen) {	595	} else if (map->m_plen & Z_EROFS_EXTENT_PLEN_MASK) {
600	map->m_flags \|= EROFS_MAP_MAPPED \|	596	map->m_flags \|= EROFS_MAP_MAPPED \|
601	EROFS_MAP_FULL_MAPPED \| EROFS_MAP_ENCODED;	597	EROFS_MAP_FULL_MAPPED \| EROFS_MAP_ENCODED;
602	fmt = map->m_plen >> Z_EROFS_EXTENT_PLEN_FMT_BIT;	598	fmt = map->m_plen >> Z_EROFS_EXTENT_PLEN_FMT_BIT;
@@ -715,6 +711,7 @@ static int z_erofs_map_sanity_check(struct inode *inode, · 112 unmodified lines
715	struct erofs_map_blocks *map)	711	struct erofs_map_blocks *map)
716	{	712	{
717	struct erofs_sb_info *sbi = EROFS_I_SB(inode);	713	struct erofs_sb_info *sbi = EROFS_I_SB(inode);
		714	u64 pend;
718		715
719	if (!(map->m_flags & EROFS_MAP_ENCODED))	716	if (!(map->m_flags & EROFS_MAP_ENCODED))
720	return 0;	717	return 0;
@@ -732,6 +729,10 @@ static int z_erofs_map_sanity_check(struct inode *inode, · 11 unmodified lines
732	if (unlikely(map->m_plen > Z_EROFS_PCLUSTER_MAX_SIZE \|\|	729	if (unlikely(map->m_plen > Z_EROFS_PCLUSTER_MAX_SIZE \|\|
733	map->m_llen > Z_EROFS_PCLUSTER_MAX_DSIZE))	730	map->m_llen > Z_EROFS_PCLUSTER_MAX_DSIZE))
734	return -EOPNOTSUPP;	731	return -EOPNOTSUPP;
		732	/* Filesystems beyond 48-bit physical block addresses are invalid */
		733	if (unlikely(check_add_overflow(map->m_pa, map->m_plen, &pend) \|\|
		734	(pend >> sbi->blkszbits) >= BIT_ULL(48)))
		735	return -EFSCORRUPTED;
735	return 0;	736	return 0;
736	}	737	}
737		738

fs/hugetlbfs/inode.c+0−9

 		if (!hugetlb_vma_trylock_write(vma))
 			continue;
-		/*
-		 * Skip VMAs without shareable locks. Per the design in commit
-		 * 40549ba8f8e0, these will be handled by remove_inode_hugepages()
-		 * called after this function with proper locking.
-		 */
-		if (!__vma_shareable_lock(vma))
-			goto skip;
 		v_start = vma_offset_start(vma, start);
 		v_end = vma_offset_end(vma, end);
 		 * vmas.  Therefore, lock is not held when calling
 		 * unmap_hugepage_range for private vmas.
 		 */
-skip:
 		hugetlb_vma_unlock_write(vma);
 	}
 }

fs/jfs/jfs_incore.h+3−3

@@ -76,14 +76,14 @@ struct jfs_inode_info { · 75 unmodified lines
76	struct {	76	struct {
77	unchar _unused[16]; /* 16: */	77	unchar _unused[16]; /* 16: */
78	dxd_t _dxd; /* 16: */	78	dxd_t _dxd; /* 16: */
79	/* _inline may overflow into _inline_ea when needed */	79	/* _inline_sym may overflow into _inline_ea when needed */
80	/* _inline_ea may overlay the last part of	80	/* _inline_ea may overlay the last part of
81	* file._xtroot if maxentry = XTROOTINITSLOT	81	* file._xtroot if maxentry = XTROOTINITSLOT
82	*/	82	*/
83	union {	83	union {
84	struct {	84	struct {
85	/* 128: inline symlink */	85	/* 128: inline symlink */
86	unchar _inline[128];	86	unchar _inline_sym[128];
87	/* 128: inline extended attr */	87	/* 128: inline extended attr */
88	unchar _inline_ea[128];	88	unchar _inline_ea[128];
89	};	89	};
@@ -101,7 +101,7 @@ struct jfs_inode_info { · 11 unmodified lines
101	#define i_imap u.file._imap	101	#define i_imap u.file._imap
102	#define i_dirtable u.dir._table	102	#define i_dirtable u.dir._table
103	#define i_dtroot u.dir._dtroot	103	#define i_dtroot u.dir._dtroot
104	#define i_inline u.link._inline	104	#define i_inline u.link._inline_sym
105	#define i_inline_ea u.link._inline_ea	105	#define i_inline_ea u.link._inline_ea
106	#define i_inline_all u.link._inline_all	106	#define i_inline_all u.link._inline_all
107		107

fs/notify/fdinfo.c+6−0

 #include "fanotify/fanotify.h"
 #include "fdinfo.h"
 #include "fsnotify.h"
+#include "../internal.h"
 #if defined(CONFIG_PROC_FS)
 	size = f->handle_bytes >> 2;
+	if (!super_trylock_shared(inode->i_sb))
+		return;
 	ret = exportfs_encode_fid(inode, (struct fid *)f->f_handle, &size);
+	up_read(&inode->i_sb->s_umount);
 	if ((ret == FILEID_INVALID) || (ret < 0))
 		return;

fs/ocfs2/move_extents.c+5−0

 			mlog_errno(ret);
 			goto out;
 		}
+		/*
+		 * Invalidate extent cache after moving/defragging to prevent
+		 * stale cached data with outdated extent flags.
+		 */
+		ocfs2_extent_map_trunc(inode, cpos);
 		context->clusters_moved += alloc_size;
 next:

fs/resctrl/monitor.c+7−9

@@ -1782,15 +1782,13 @@ int resctrl_mon_resource_init(void) · 1781 unmodified lines
1782	mba_mbps_default_event = QOS_L3_MBM_TOTAL_EVENT_ID;	1782	mba_mbps_default_event = QOS_L3_MBM_TOTAL_EVENT_ID;
1783		1783
1784	if (r->mon.mbm_cntr_assignable) {	1784	if (r->mon.mbm_cntr_assignable) {
1785	if (!resctrl_is_mon_event_enabled(QOS_L3_MBM_TOTAL_EVENT_ID))	1785	if (resctrl_is_mon_event_enabled(QOS_L3_MBM_TOTAL_EVENT_ID))
1786	resctrl_enable_mon_event(QOS_L3_MBM_TOTAL_EVENT_ID);	1786	mon_event_all[QOS_L3_MBM_TOTAL_EVENT_ID].evt_cfg = r->mon.mbm_cfg_mask;
1787	if (!resctrl_is_mon_event_enabled(QOS_L3_MBM_LOCAL_EVENT_ID))	1787	if (resctrl_is_mon_event_enabled(QOS_L3_MBM_LOCAL_EVENT_ID))
1788	resctrl_enable_mon_event(QOS_L3_MBM_LOCAL_EVENT_ID);	1788	mon_event_all[QOS_L3_MBM_LOCAL_EVENT_ID].evt_cfg = r->mon.mbm_cfg_mask &
1789	mon_event_all[QOS_L3_MBM_TOTAL_EVENT_ID].evt_cfg = r->mon.mbm_cfg_mask;	1789	(READS_TO_LOCAL_MEM \|
1790	mon_event_all[QOS_L3_MBM_LOCAL_EVENT_ID].evt_cfg = r->mon.mbm_cfg_mask &	1790	READS_TO_LOCAL_S_MEM \|
1791	(READS_TO_LOCAL_MEM \|	1791	NON_TEMP_WRITE_TO_LOCAL_MEM);
1792	READS_TO_LOCAL_S_MEM \|
1793	NON_TEMP_WRITE_TO_LOCAL_MEM);
1794	r->mon.mbm_assign_on_mkdir = true;	1792	r->mon.mbm_assign_on_mkdir = true;
1795	resctrl_file_fflags_init("num_mbm_cntrs",	1793	resctrl_file_fflags_init("num_mbm_cntrs",
1796	RFTYPE_MON_INFO \| RFTYPE_RES_CACHE);	1794	RFTYPE_MON_INFO \| RFTYPE_RES_CACHE);

fs/smb/client/cifsglob.h+1−3

 	void (*new_lease_key)(struct cifs_fid *);
 	int (*generate_signingkey)(struct cifs_ses *ses,
 				   struct TCP_Server_Info *server);
-	int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *,
-				bool allocate_crypto);
 	int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon,
 			     struct cifsFileInfo *src_file);
 	int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon,
 	bool nosharesock;
 	bool tcp_nodelay;
 	bool terminate;
-	unsigned int credits;  /* send no more requests at once */
+	int credits;  /* send no more requests at once */
 	unsigned int max_credits; /* can override large 32000 default at mnt */
 	unsigned int in_flight;  /* number of requests on the wire to server */
 	unsigned int max_in_flight; /* max number of requests that were on wire */

fs/smb/client/cifsproto.h+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#define _CIFSPROTO_H	9	#define _CIFSPROTO_H
10	#include <linux/nls.h>	10	#include <linux/nls.h>
11	#include <linux/ctype.h>	11	#include <linux/ctype.h>
		12	#include "cifsglob.h"
12	#include "trace.h"	13	#include "trace.h"
13	#ifdef CONFIG_CIFS_DFS_UPCALL	14	#ifdef CONFIG_CIFS_DFS_UPCALL
14	#include "dfs_cache.h"	15	#include "dfs_cache.h"

fs/smb/client/cifssmb.c+8−0

 		.rreq_debug_id = rdata->rreq->debug_id,
 		.rreq_debug_index = rdata->subreq.debug_index,
 	};
+	unsigned int rreq_debug_id = rdata->rreq->debug_id;
+	unsigned int subreq_debug_index = rdata->subreq.debug_index;
 	cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%zu\n",
 		 __func__, mid->mid, mid->mid_state, rdata->result,
 			__set_bit(NETFS_SREQ_MADE_PROGRESS, &rdata->subreq.flags);
 	}
+	trace_smb3_rw_credits(rreq_debug_id, subreq_debug_index, rdata->credits.value,
+			      server->credits, server->in_flight,
+			      0, cifs_trace_rw_credits_read_response_clear);
 	rdata->credits.value = 0;
 	rdata->subreq.error = rdata->result;
 	rdata->subreq.transferred += rdata->got_bytes;
 	netfs_read_subreq_terminated(&rdata->subreq);
 	release_mid(mid);
 	add_credits(server, &credits, 0);
+	trace_smb3_rw_credits(rreq_debug_id, subreq_debug_index, 0,
+			      server->credits, server->in_flight,
+			      credits.value, cifs_trace_rw_credits_read_response_add);
 }
 /* cifs_async_readv - send an async write, and set up mid to handle result */

fs/smb/client/inode.c+1−4

 	}
 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 do_rename_exit:
-	if (rc == 0) {
+	if (rc == 0)
 		d_move(from_dentry, to_dentry);
-		/* Force a new lookup */
-		d_drop(from_dentry);
-	}
 	cifs_put_tlink(tlink);
 	return rc;
 }

fs/smb/client/smb2ops.c+0−4

 	.get_lease_key = smb2_get_lease_key,
 	.set_lease_key = smb2_set_lease_key,
 	.new_lease_key = smb2_new_lease_key,
-	.calc_signature = smb2_calc_signature,
 	.is_read_op = smb2_is_read_op,
 	.set_oplock_level = smb2_set_oplock_level,
 	.create_lease_buf = smb2_create_lease_buf,
 	.get_lease_key = smb2_get_lease_key,
 	.set_lease_key = smb2_set_lease_key,
 	.new_lease_key = smb2_new_lease_key,
-	.calc_signature = smb2_calc_signature,
 	.is_read_op = smb21_is_read_op,
 	.set_oplock_level = smb21_set_oplock_level,
 	.create_lease_buf = smb2_create_lease_buf,
 	.set_lease_key = smb2_set_lease_key,
 	.new_lease_key = smb2_new_lease_key,
 	.generate_signingkey = generate_smb30signingkey,
-	.calc_signature = smb3_calc_signature,
 	.set_integrity  = smb3_set_integrity,
 	.is_read_op = smb21_is_read_op,
 	.set_oplock_level = smb3_set_oplock_level,
 	.set_lease_key = smb2_set_lease_key,
 	.new_lease_key = smb2_new_lease_key,
 	.generate_signingkey = generate_smb311signingkey,
-	.calc_signature = smb3_calc_signature,
 	.set_integrity  = smb3_set_integrity,
 	.is_read_op = smb21_is_read_op,
 	.set_oplock_level = smb3_set_oplock_level,

fs/smb/client/smb2proto.h+0−6

 			struct TCP_Server_Info *server, struct smb_rqst *rqst);
 extern struct cifs_tcon *smb2_find_smb_tcon(struct TCP_Server_Info *server,
 						__u64 ses_id, __u32  tid);
-extern int smb2_calc_signature(struct smb_rqst *rqst,
-				struct TCP_Server_Info *server,
-				bool allocate_crypto);
-extern int smb3_calc_signature(struct smb_rqst *rqst,
-				struct TCP_Server_Info *server,
-				bool allocate_crypto);
 extern void smb2_echo_request(struct work_struct *work);
 extern __le32 smb2_get_lease_state(struct cifsInodeInfo *cinode);
 extern bool smb2_is_valid_oplock_break(char *buffer,

fs/smb/client/smb2transport.c+9−9

 	return tcon;
 }
-int
+static int
 smb2_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
-			bool allocate_crypto)
+		    bool allocate_crypto)
 {
 	int rc;
 	unsigned char smb2_signature[SMB2_HMACSHA256_SIZE];
 	return generate_smb3signingkey(ses, server, &triplet);
 }
-int
+static int
 smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
-			bool allocate_crypto)
+		    bool allocate_crypto)
 {
 	int rc;
 	unsigned char smb3_signature[SMB2_CMACAES_SIZE];
 	struct smb_rqst drqst;
 	u8 key[SMB3_SIGN_KEY_SIZE];
+	if (server->vals->protocol_id <= SMB21_PROT_ID)
+		return smb2_calc_signature(rqst, server, allocate_crypto);
 	rc = smb3_get_sign_key(le64_to_cpu(shdr->SessionId), server, key);
 	if (unlikely(rc)) {
 		cifs_server_dbg(FYI, "%s: Could not get signing key\n", __func__);
 static int
 smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)
 {
-	int rc = 0;
 	struct smb2_hdr *shdr;
 	struct smb2_sess_setup_req *ssr;
 	bool is_binding;
 		return 0;
 	}
-	rc = server->ops->calc_signature(rqst, server, false);
+	return smb3_calc_signature(rqst, server, false);
-	return rc;
 }
 int
 	memset(shdr->Signature, 0, SMB2_SIGNATURE_SIZE);
-	rc = server->ops->calc_signature(rqst, server, true);
+	rc = smb3_calc_signature(rqst, server, true);
 	if (rc)
 		return rc;

fs/smb/client/smbdirect.c+65−38

 	 * in order to notice the broken connection.
 	 */
 	wake_up_all(&sc->status_wait);
+	wake_up_all(&sc->send_io.lcredits.wait_queue);
 	wake_up_all(&sc->send_io.credits.wait_queue);
 	wake_up_all(&sc->send_io.pending.dec_wait_queue);
 	wake_up_all(&sc->send_io.pending.zero_wait_queue);
 	struct smbdirect_send_io *request =
 		container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);
 	struct smbdirect_socket *sc = request->socket;
+	int lcredits = 0;
 	log_rdma_send(INFO, "smbdirect_send_io 0x%p completed wc->status=%s\n",
 		request, ib_wc_status_msg(wc->status));
 			request->sge[i].addr,
 			request->sge[i].length,
 			DMA_TO_DEVICE);
+	mempool_free(request, sc->send_io.mem.pool);
+	lcredits += 1;
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_SEND) {
 		if (wc->status != IB_WC_WR_FLUSH_ERR)
 			log_rdma_send(ERR, "wc->status=%s wc->opcode=%d\n",
 				ib_wc_status_msg(wc->status), wc->opcode);
-		mempool_free(request, sc->send_io.mem.pool);
 		smbd_disconnect_rdma_connection(sc);
 		return;
 	}
+	atomic_add(lcredits, &sc->send_io.lcredits.count);
+	wake_up(&sc->send_io.lcredits.wait_queue);
 	if (atomic_dec_and_test(&sc->send_io.pending.count))
 		wake_up(&sc->send_io.pending.zero_wait_queue);
 	wake_up(&sc->send_io.pending.dec_wait_queue);
-	mempool_free(request, sc->send_io.mem.pool);
 }
 static void dump_smbdirect_negotiate_resp(struct smbdirect_negotiate_resp *resp)
 		log_rdma_event(ERR, "error: credits_granted==0\n");
 		return false;
 	}
+	atomic_set(&sc->send_io.lcredits.count, sp->send_credit_target);
 	atomic_set(&sc->send_io.credits.count, le16_to_cpu(packet->credits_granted));
 	if (le32_to_cpu(packet->preferred_send_size) > sp->max_recv_size) {
 	struct smbdirect_data_transfer *packet;
 	int new_credits = 0;
+wait_lcredit:
+	/* Wait for local send credits */
+	rc = wait_event_interruptible(sc->send_io.lcredits.wait_queue,
+		atomic_read(&sc->send_io.lcredits.count) > 0 ||
+		sc->status != SMBDIRECT_SOCKET_CONNECTED);
+	if (rc)
+		goto err_wait_lcredit;
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
+		log_outgoing(ERR, "disconnected not sending on wait_credit\n");
+		rc = -EAGAIN;
+		goto err_wait_lcredit;
+	}
+	if (unlikely(atomic_dec_return(&sc->send_io.lcredits.count) < 0)) {
+		atomic_inc(&sc->send_io.lcredits.count);
+		goto wait_lcredit;
+	}
 wait_credit:
 	/* Wait for send credits. A SMBD packet needs one credit */
 	rc = wait_event_interruptible(sc->send_io.credits.wait_queue,
 		goto wait_credit;
 	}
-wait_send_queue:
-	wait_event(sc->send_io.pending.dec_wait_queue,
-		atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
-		sc->status != SMBDIRECT_SOCKET_CONNECTED);
-	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
-		log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
-		rc = -EAGAIN;
-		goto err_wait_send_queue;
-	}
-	if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
-				sp->send_credit_target)) {
-		atomic_dec(&sc->send_io.pending.count);
-		goto wait_send_queue;
-	}
 	request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL);
 	if (!request) {
 		rc = -ENOMEM;
 		     le32_to_cpu(packet->data_length),
 		     le32_to_cpu(packet->remaining_data_length));
+	/*
+	 * Now that we got a local and a remote credit
+	 * we add us as pending
+	 */
+	atomic_inc(&sc->send_io.pending.count);
 	rc = smbd_post_send(sc, request);
 	if (!rc)
 		return 0;
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.zero_wait_queue);
+	wake_up(&sc->send_io.pending.dec_wait_queue);
 err_dma:
 	for (i = 0; i < request->num_sge; i++)
 		if (request->sge[i].addr)
 	atomic_sub(new_credits, &sc->recv_io.credits.count);
 err_alloc:
-	if (atomic_dec_and_test(&sc->send_io.pending.count))
-		wake_up(&sc->send_io.pending.zero_wait_queue);
-err_wait_send_queue:
-	/* roll back send credits and pending */
 	atomic_inc(&sc->send_io.credits.count);
+	wake_up(&sc->send_io.credits.wait_queue);
 err_wait_credit:
+	atomic_inc(&sc->send_io.lcredits.count);
+	wake_up(&sc->send_io.lcredits.wait_queue);
+err_wait_lcredit:
 	return rc;
 }
 	struct smbdirect_socket *sc;
 	struct smbdirect_socket_parameters *sp;
 	struct rdma_conn_param conn_param;
+	struct ib_qp_cap qp_cap;
 	struct ib_qp_init_attr qp_attr;
 	struct sockaddr_in *addr_in = (struct sockaddr_in *) dstaddr;
 	struct ib_port_immutable port_immutable;
 		goto config_failed;
 	}
+	sp->responder_resources =
+		min_t(u8, sp->responder_resources,
+		      sc->ib.dev->attrs.max_qp_rd_atom);
+	log_rdma_mr(INFO, "responder_resources=%d\n",
+		sp->responder_resources);
+	/*
+	 * We use allocate sp->responder_resources * 2 MRs
+	 * and each MR needs WRs for REG and INV, so
+	 * we use '* 4'.
+	 *
+	 * +1 for ib_drain_qp()
+	 */
+	memset(&qp_cap, 0, sizeof(qp_cap));
+	qp_cap.max_send_wr = sp->send_credit_target + sp->responder_resources * 4 + 1;
+	qp_cap.max_recv_wr = sp->recv_credit_max + 1;
+	qp_cap.max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
+	qp_cap.max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
 	sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0);
 	if (IS_ERR(sc->ib.pd)) {
 		rc = PTR_ERR(sc->ib.pd);
 	sc->ib.send_cq =
 		ib_alloc_cq_any(sc->ib.dev, sc,
-				sp->send_credit_target, IB_POLL_SOFTIRQ);
+				qp_cap.max_send_wr, IB_POLL_SOFTIRQ);
 	if (IS_ERR(sc->ib.send_cq)) {
 		sc->ib.send_cq = NULL;
 		goto alloc_cq_failed;
 	sc->ib.recv_cq =
 		ib_alloc_cq_any(sc->ib.dev, sc,
-				sp->recv_credit_max, IB_POLL_SOFTIRQ);
+				qp_cap.max_recv_wr, IB_POLL_SOFTIRQ);
 	if (IS_ERR(sc->ib.recv_cq)) {
 		sc->ib.recv_cq = NULL;
 		goto alloc_cq_failed;
 	memset(&qp_attr, 0, sizeof(qp_attr));
 	qp_attr.event_handler = smbd_qp_async_error_upcall;
 	qp_attr.qp_context = sc;
-	qp_attr.cap.max_send_wr = sp->send_credit_target;
+	qp_attr.cap = qp_cap;
-	qp_attr.cap.max_recv_wr = sp->recv_credit_max;
-	qp_attr.cap.max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
-	qp_attr.cap.max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
-	qp_attr.cap.max_inline_data = 0;
 	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
 	qp_attr.qp_type = IB_QPT_RC;
 	qp_attr.send_cq = sc->ib.send_cq;
 	}
 	sc->ib.qp = sc->rdma.cm_id->qp;
-	sp->responder_resources =
-		min_t(u8, sp->responder_resources,
-		      sc->ib.dev->attrs.max_qp_rd_atom);
-	log_rdma_mr(INFO, "responder_resources=%d\n",
-		sp->responder_resources);
 	memset(&conn_param, 0, sizeof(conn_param));
 	conn_param.initiator_depth = sp->initiator_depth;
 	conn_param.responder_resources = sp->responder_resources;

fs/smb/client/trace.c+1−0

@@ -4,5 +4,6 @@ · 3 unmodified lines
4	*	4	*
5	* Author(s): Steve French <stfrench@microsoft.com>	5	* Author(s): Steve French <stfrench@microsoft.com>
6	*/	6	*/
		7	#include "cifsglob.h"
7	#define CREATE_TRACE_POINTS	8	#define CREATE_TRACE_POINTS
8	#include "trace.h"	9	#include "trace.h"

fs/smb/common/smbdirect/smbdirect_socket.h+12−1

 		} mem;
 		/*
-		 * The credit state for the send side
+		 * The local credit state for ib_post_send()
+		 */
+		struct {
+			atomic_t count;
+			wait_queue_head_t wait_queue;
+		} lcredits;
+		/*
+		 * The remote credit state for the send side
 		 */
 		struct {
 			atomic_t count;
 	INIT_DELAYED_WORK(&sc->idle.timer_work, __smbdirect_socket_disabled_work);
 	disable_delayed_work_sync(&sc->idle.timer_work);
+	atomic_set(&sc->send_io.lcredits.count, 0);
+	init_waitqueue_head(&sc->send_io.lcredits.wait_queue);
 	atomic_set(&sc->send_io.credits.count, 0);
 	init_waitqueue_head(&sc->send_io.credits.wait_queue);

fs/smb/server/transport_rdma.c+219−125

@@ -219,6 +219,7 @@ static void smb_direct_disconnect_wake_up_all(struct smbdirect_socket *sc) · 218 unmodified lines
219	* in order to notice the broken connection.	219	* in order to notice the broken connection.
220	*/	220	*/
221	wake_up_all(&sc->status_wait);	221	wake_up_all(&sc->status_wait);
		222	wake_up_all(&sc->send_io.lcredits.wait_queue);
222	wake_up_all(&sc->send_io.credits.wait_queue);	223	wake_up_all(&sc->send_io.credits.wait_queue);
223	wake_up_all(&sc->send_io.pending.zero_wait_queue);	224	wake_up_all(&sc->send_io.pending.zero_wait_queue);
224	wake_up_all(&sc->recv_io.reassembly.wait_queue);	225	wake_up_all(&sc->recv_io.reassembly.wait_queue);
@@ -450,11 +451,10 @@ static void free_transport(struct smb_direct_transport *t) · 225 unmodified lines
450	struct smbdirect_recv_io *recvmsg;	451	struct smbdirect_recv_io *recvmsg;
451		452
452	disable_work_sync(&sc->disconnect_work);	453	disable_work_sync(&sc->disconnect_work);
453	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) {	454	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING)
454	smb_direct_disconnect_rdma_work(&sc->disconnect_work);	455	smb_direct_disconnect_rdma_work(&sc->disconnect_work);
455	wait_event_interruptible(sc->status_wait,	456	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTED)
456	sc->status == SMBDIRECT_SOCKET_DISCONNECTED);	457	wait_event(sc->status_wait, sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
457	}
458		458
459	/*	459	/*
460	* Wake up all waiters in all wait queues	460	* Wake up all waiters in all wait queues
@@ -471,7 +471,6 @@ static void free_transport(struct smb_direct_transport *t) · 10 unmodified lines
471		471
472	if (sc->ib.qp) {	472	if (sc->ib.qp) {
473	ib_drain_qp(sc->ib.qp);	473	ib_drain_qp(sc->ib.qp);
474	ib_mr_pool_destroy(sc->ib.qp, &sc->ib.qp->rdma_mrs);
475	sc->ib.qp = NULL;	474	sc->ib.qp = NULL;
476	rdma_destroy_qp(sc->rdma.cm_id);	475	rdma_destroy_qp(sc->rdma.cm_id);
477	}	476	}
@@ -524,6 +523,12 @@ static void smb_direct_free_sendmsg(struct smbdirect_socket *sc, · 46 unmodified lines
524	{	523	{
525	int i;	524	int i;
526		525
		526	/*
		527	* The list needs to be empty!
		528	* The caller should take care of it.
		529	*/
		530	WARN_ON_ONCE(!list_empty(&msg->sibling_list));
		531
527	if (msg->num_sge > 0) {	532	if (msg->num_sge > 0) {
528	ib_dma_unmap_single(sc->ib.dev,	533	ib_dma_unmap_single(sc->ib.dev,
529	msg->sge[0].addr, msg->sge[0].length,	534	msg->sge[0].addr, msg->sge[0].length,
@@ -909,9 +914,9 @@ static void smb_direct_post_recv_credits(struct work_struct *work) · 379 unmodified lines
909		914
910	static void send_done(struct ib_cq cq, struct ib_wc wc)	915	static void send_done(struct ib_cq cq, struct ib_wc wc)
911	{	916	{
912	struct smbdirect_send_io sendmsg, sibling;	917	struct smbdirect_send_io sendmsg, sibling, *next;
913	struct smbdirect_socket *sc;	918	struct smbdirect_socket *sc;
914	struct list_head pos, prev, *end;	919	int lcredits = 0;
915		920
916	sendmsg = container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);	921	sendmsg = container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);
917	sc = sendmsg->socket;	922	sc = sendmsg->socket;
@@ -920,27 +925,31 @@ static void send_done(struct ib_cq cq, struct ib_wc wc) · 2 unmodified lines
920	ib_wc_status_msg(wc->status), wc->status,	925	ib_wc_status_msg(wc->status), wc->status,
921	wc->opcode);	926	wc->opcode);
922		927
		928	/*
		929	* Free possible siblings and then the main send_io
		930	*/
		931	list_for_each_entry_safe(sibling, next, &sendmsg->sibling_list, sibling_list) {
		932	list_del_init(&sibling->sibling_list);
		933	smb_direct_free_sendmsg(sc, sibling);
		934	lcredits += 1;
		935	}
		936	/* Note this frees wc->wr_cqe, but not wc */
		937	smb_direct_free_sendmsg(sc, sendmsg);
		938	lcredits += 1;
		939
923	if (wc->status != IB_WC_SUCCESS \|\| wc->opcode != IB_WC_SEND) {	940	if (wc->status != IB_WC_SUCCESS \|\| wc->opcode != IB_WC_SEND) {
924	pr_err("Send error. status='%s (%d)', opcode=%d\n",	941	pr_err("Send error. status='%s (%d)', opcode=%d\n",
925	ib_wc_status_msg(wc->status), wc->status,	942	ib_wc_status_msg(wc->status), wc->status,
926	wc->opcode);	943	wc->opcode);
927	smb_direct_disconnect_rdma_connection(sc);	944	smb_direct_disconnect_rdma_connection(sc);
		945	return;
928	}	946	}
929		947
		948	atomic_add(lcredits, &sc->send_io.lcredits.count);
		949	wake_up(&sc->send_io.lcredits.wait_queue);
		950
930	if (atomic_dec_and_test(&sc->send_io.pending.count))	951	if (atomic_dec_and_test(&sc->send_io.pending.count))
931	wake_up(&sc->send_io.pending.zero_wait_queue);	952	wake_up(&sc->send_io.pending.zero_wait_queue);
932
933	/* iterate and free the list of messages in reverse. the list's head
934	* is invalid.
935	*/
936	for (pos = &sendmsg->sibling_list, prev = pos->prev, end = sendmsg->sibling_list.next;
937	prev != end; pos = prev, prev = prev->prev) {
938	sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
939	smb_direct_free_sendmsg(sc, sibling);
940	}
941
942	sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
943	smb_direct_free_sendmsg(sc, sibling);
944	}	953	}
945		954
946	static int manage_credits_prior_sending(struct smbdirect_socket *sc)	955	static int manage_credits_prior_sending(struct smbdirect_socket *sc)
@@ -988,8 +997,6 @@ static int smb_direct_post_send(struct smbdirect_socket *sc, · 41 unmodified lines
988	ret = ib_post_send(sc->ib.qp, wr, NULL);	997	ret = ib_post_send(sc->ib.qp, wr, NULL);
989	if (ret) {	998	if (ret) {
990	pr_err("failed to post send: %d\n", ret);	999	pr_err("failed to post send: %d\n", ret);
991	if (atomic_dec_and_test(&sc->send_io.pending.count))
992	wake_up(&sc->send_io.pending.zero_wait_queue);
993	smb_direct_disconnect_rdma_connection(sc);	1000	smb_direct_disconnect_rdma_connection(sc);
994	}	1001	}
995	return ret;	1002	return ret;
@@ -1032,19 +1039,29 @@ static int smb_direct_flush_send_list(struct smbdirect_socket *sc, · 36 unmodified lines
1032	last->wr.send_flags = IB_SEND_SIGNALED;	1039	last->wr.send_flags = IB_SEND_SIGNALED;
1033	last->wr.wr_cqe = &last->cqe;	1040	last->wr.wr_cqe = &last->cqe;
1034		1041
		1042	/*
		1043	* Remove last from send_ctx->msg_list
		1044	* and splice the rest of send_ctx->msg_list
		1045	* to last->sibling_list.
		1046	*
		1047	* send_ctx->msg_list is a valid empty list
		1048	* at the end.
		1049	*/
		1050	list_del_init(&last->sibling_list);
		1051	list_splice_tail_init(&send_ctx->msg_list, &last->sibling_list);
		1052	send_ctx->wr_cnt = 0;
		1053
1035	ret = smb_direct_post_send(sc, &first->wr);	1054	ret = smb_direct_post_send(sc, &first->wr);
1036	if (!ret) {	1055	if (ret) {
1037	smb_direct_send_ctx_init(send_ctx,	1056	struct smbdirect_send_io sibling, next;
1038	send_ctx->need_invalidate_rkey,	1057
1039	send_ctx->remote_key);	1058	list_for_each_entry_safe(sibling, next, &last->sibling_list, sibling_list) {
1040	} else {	1059	list_del_init(&sibling->sibling_list);
1041	atomic_add(send_ctx->wr_cnt, &sc->send_io.credits.count);	1060	smb_direct_free_sendmsg(sc, sibling);
1042	wake_up(&sc->send_io.credits.wait_queue);
1043	list_for_each_entry_safe(first, last, &send_ctx->msg_list,
1044	sibling_list) {
1045	smb_direct_free_sendmsg(sc, first);
1046	}	1061	}
		1062	smb_direct_free_sendmsg(sc, last);
1047	}	1063	}
		1064
1048	return ret;	1065	return ret;
1049	}	1066	}
1050		1067
@@ -1070,6 +1087,23 @@ static int wait_for_credits(struct smbdirect_socket *sc, · 19 unmodified lines
1070	} while (true);	1087	} while (true);
1071	}	1088	}
1072		1089
		1090	static int wait_for_send_lcredit(struct smbdirect_socket *sc,
		1091	struct smbdirect_send_batch *send_ctx)
		1092	{
		1093	if (send_ctx && (atomic_read(&sc->send_io.lcredits.count) <= 1)) {
		1094	int ret;
		1095
		1096	ret = smb_direct_flush_send_list(sc, send_ctx, false);
		1097	if (ret)
		1098	return ret;
		1099	}
		1100
		1101	return wait_for_credits(sc,
		1102	&sc->send_io.lcredits.wait_queue,
		1103	&sc->send_io.lcredits.count,
		1104	1);
		1105	}
		1106
1073	static int wait_for_send_credits(struct smbdirect_socket *sc,	1107	static int wait_for_send_credits(struct smbdirect_socket *sc,
1074	struct smbdirect_send_batch *send_ctx)	1108	struct smbdirect_send_batch *send_ctx)
1075	{	1109	{
@@ -1257,9 +1291,13 @@ static int smb_direct_post_send_data(struct smbdirect_socket *sc, · 181 unmodified lines
1257	int data_length;	1291	int data_length;
1258	struct scatterlist sg[SMBDIRECT_SEND_IO_MAX_SGE - 1];	1292	struct scatterlist sg[SMBDIRECT_SEND_IO_MAX_SGE - 1];
1259		1293
		1294	ret = wait_for_send_lcredit(sc, send_ctx);
		1295	if (ret)
		1296	goto lcredit_failed;
		1297
1260	ret = wait_for_send_credits(sc, send_ctx);	1298	ret = wait_for_send_credits(sc, send_ctx);
1261	if (ret)	1299	if (ret)
1262	return ret;	1300	goto credit_failed;
1263		1301
1264	data_length = 0;	1302	data_length = 0;
1265	for (i = 0; i < niov; i++)	1303	for (i = 0; i < niov; i++)
@@ -1267,10 +1305,8 @@ static int smb_direct_post_send_data(struct smbdirect_socket *sc, · 1 unmodified line
1267		1305
1268	ret = smb_direct_create_header(sc, data_length, remaining_data_length,	1306	ret = smb_direct_create_header(sc, data_length, remaining_data_length,
1269	&msg);	1307	&msg);
1270	if (ret) {	1308	if (ret)
1271	atomic_inc(&sc->send_io.credits.count);	1309	goto header_failed;
1272	return ret;
1273	}
1274		1310
1275	for (i = 0; i < niov; i++) {	1311	for (i = 0; i < niov; i++) {
1276	struct ib_sge *sge;	1312	struct ib_sge *sge;
@@ -1308,7 +1344,11 @@ static int smb_direct_post_send_data(struct smbdirect_socket *sc, · 31 unmodified lines
1308	return 0;	1344	return 0;
1309	err:	1345	err:
1310	smb_direct_free_sendmsg(sc, msg);	1346	smb_direct_free_sendmsg(sc, msg);
		1347	header_failed:
1311	atomic_inc(&sc->send_io.credits.count);	1348	atomic_inc(&sc->send_io.credits.count);
		1349	credit_failed:
		1350	atomic_inc(&sc->send_io.lcredits.count);
		1351	lcredit_failed:
1312	return ret;	1352	return ret;
1313	}	1353	}
1314		1354
@@ -1871,20 +1911,11 @@ out_err: · 556 unmodified lines
1871	return ret;	1911	return ret;
1872	}	1912	}
1873		1913
1874	static unsigned int smb_direct_get_max_fr_pages(struct smbdirect_socket *sc)	1914	static int smb_direct_init_params(struct smbdirect_socket *sc)
1875	{
1876	return min_t(unsigned int,
1877	sc->ib.dev->attrs.max_fast_reg_page_list_len,
1878	256);
1879	}
1880
1881	static int smb_direct_init_params(struct smbdirect_socket *sc,
1882	struct ib_qp_cap *cap)
1883	{	1915	{
1884	struct smbdirect_socket_parameters *sp = &sc->parameters;	1916	struct smbdirect_socket_parameters *sp = &sc->parameters;
1885	struct ib_device *device = sc->ib.dev;	1917	int max_send_sges;
1886	int max_send_sges, max_rw_wrs, max_send_wrs;	1918	unsigned int maxpages;
1887	unsigned int max_sge_per_wr, wrs_per_credit;
1888		1919
1889	/* need 3 more sge. because a SMB_DIRECT header, SMB2 header,	1920	/* need 3 more sge. because a SMB_DIRECT header, SMB2 header,
1890	* SMB2 response could be mapped.	1921	* SMB2 response could be mapped.
@@ -1895,67 +1926,20 @@ static int smb_direct_init_params(struct smbdirect_socket *sc, · 4 unmodified lines
1895	return -EINVAL;	1926	return -EINVAL;
1896	}	1927	}
1897		1928
1898	/* Calculate the number of work requests for RDMA R/W.	1929	atomic_set(&sc->send_io.lcredits.count, sp->send_credit_target);
1899	* The maximum number of pages which can be registered
1900	* with one Memory region can be transferred with one
1901	* R/W credit. And at least 4 work requests for each credit
1902	* are needed for MR registration, RDMA R/W, local & remote
1903	* MR invalidation.
1904	*/
1905	sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(sc);
1906	sc->rw_io.credits.max = DIV_ROUND_UP(sp->max_read_write_size,
1907	(sc->rw_io.credits.num_pages - 1) *
1908	PAGE_SIZE);
1909
1910	max_sge_per_wr = min_t(unsigned int, device->attrs.max_send_sge,
1911	device->attrs.max_sge_rd);
1912	max_sge_per_wr = max_t(unsigned int, max_sge_per_wr,
1913	max_send_sges);
1914	wrs_per_credit = max_t(unsigned int, 4,
1915	DIV_ROUND_UP(sc->rw_io.credits.num_pages,
1916	max_sge_per_wr) + 1);
1917	max_rw_wrs = sc->rw_io.credits.max * wrs_per_credit;
1918
1919	max_send_wrs = sp->send_credit_target + max_rw_wrs;
1920	if (max_send_wrs > device->attrs.max_cqe \|\|
1921	max_send_wrs > device->attrs.max_qp_wr) {
1922	pr_err("consider lowering send_credit_target = %d\n",
1923	sp->send_credit_target);
1924	pr_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
1925	device->attrs.max_cqe, device->attrs.max_qp_wr);
1926	return -EINVAL;
1927	}
1928		1930
1929	if (sp->recv_credit_max > device->attrs.max_cqe \|\|	1931	maxpages = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE);
1930	sp->recv_credit_max > device->attrs.max_qp_wr) {	1932	sc->rw_io.credits.max = rdma_rw_mr_factor(sc->ib.dev,
1931	pr_err("consider lowering receive_credit_max = %d\n",	1933	sc->rdma.cm_id->port_num,
1932	sp->recv_credit_max);	1934	maxpages);
1933	pr_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n",	1935	sc->rw_io.credits.num_pages = DIV_ROUND_UP(maxpages, sc->rw_io.credits.max);
1934	device->attrs.max_cqe, device->attrs.max_qp_wr);	1936	/* add one extra in order to handle unaligned pages */
1935	return -EINVAL;	1937	sc->rw_io.credits.max += 1;
1936	}
1937
1938	if (device->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE) {
1939	pr_err("warning: device max_send_sge = %d too small\n",
1940	device->attrs.max_send_sge);
1941	return -EINVAL;
1942	}
1943	if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
1944	pr_err("warning: device max_recv_sge = %d too small\n",
1945	device->attrs.max_recv_sge);
1946	return -EINVAL;
1947	}
1948		1938
1949	sc->recv_io.credits.target = 1;	1939	sc->recv_io.credits.target = 1;
1950		1940
1951	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);	1941	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);
1952		1942
1953	cap->max_send_wr = max_send_wrs;
1954	cap->max_recv_wr = sp->recv_credit_max;
1955	cap->max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
1956	cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
1957	cap->max_inline_data = 0;
1958	cap->max_rdma_ctxs = sc->rw_io.credits.max;
1959	return 0;	1943	return 0;
1960	}	1944	}
1961		1945
@@ -2029,13 +2013,129 @@ err: · 67 unmodified lines
2029	return -ENOMEM;	2013	return -ENOMEM;
2030	}	2014	}
2031		2015
2032	static int smb_direct_create_qpair(struct smbdirect_socket *sc,	2016	static u32 smb_direct_rdma_rw_send_wrs(struct ib_device dev, const struct ib_qp_init_attr attr)
2033	struct ib_qp_cap *cap)	2017	{
		2018	/*
		2019	* This could be split out of rdma_rw_init_qp()
		2020	* and be a helper function next to rdma_rw_mr_factor()
		2021	*
		2022	* We can't check unlikely(rdma_rw_force_mr) here,
		2023	* but that is most likely 0 anyway.
		2024	*/
		2025	u32 factor;
		2026
		2027	WARN_ON_ONCE(attr->port_num == 0);
		2028
		2029	/*
		2030	* Each context needs at least one RDMA READ or WRITE WR.
		2031	*
		2032	* For some hardware we might need more, eventually we should ask the
		2033	* HCA driver for a multiplier here.
		2034	*/
		2035	factor = 1;
		2036
		2037	/*
		2038	* If the device needs MRs to perform RDMA READ or WRITE operations,
		2039	* we'll need two additional MRs for the registrations and the
		2040	* invalidation.
		2041	*/
		2042	if (rdma_protocol_iwarp(dev, attr->port_num) \|\| dev->attrs.max_sgl_rd)
		2043	factor += 2; /* inv + reg */
		2044
		2045	return factor * attr->cap.max_rdma_ctxs;
		2046	}
		2047
		2048	static int smb_direct_create_qpair(struct smbdirect_socket *sc)
2034	{	2049	{
2035	struct smbdirect_socket_parameters *sp = &sc->parameters;	2050	struct smbdirect_socket_parameters *sp = &sc->parameters;
2036	int ret;	2051	int ret;
		2052	struct ib_qp_cap qp_cap;
2037	struct ib_qp_init_attr qp_attr;	2053	struct ib_qp_init_attr qp_attr;
2038	int pages_per_rw;	2054	u32 max_send_wr;
		2055	u32 rdma_send_wr;
		2056
		2057	/*
		2058	* Note that {rdma,ib}_create_qp() will call
		2059	* rdma_rw_init_qp() if cap->max_rdma_ctxs is not 0.
		2060	* It will adjust cap->max_send_wr to the required
		2061	* number of additional WRs for the RDMA RW operations.
		2062	* It will cap cap->max_send_wr to the device limit.
		2063	*
		2064	* +1 for ib_drain_qp
		2065	*/
		2066	qp_cap.max_send_wr = sp->send_credit_target + 1;
		2067	qp_cap.max_recv_wr = sp->recv_credit_max + 1;
		2068	qp_cap.max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
		2069	qp_cap.max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
		2070	qp_cap.max_inline_data = 0;
		2071	qp_cap.max_rdma_ctxs = sc->rw_io.credits.max;
		2072
		2073	/*
		2074	* Find out the number of max_send_wr
		2075	* after rdma_rw_init_qp() adjusted it.
		2076	*
		2077	* We only do it on a temporary variable,
		2078	* as rdma_create_qp() will trigger
		2079	* rdma_rw_init_qp() again.
		2080	*/
		2081	memset(&qp_attr, 0, sizeof(qp_attr));
		2082	qp_attr.cap = qp_cap;
		2083	qp_attr.port_num = sc->rdma.cm_id->port_num;
		2084	rdma_send_wr = smb_direct_rdma_rw_send_wrs(sc->ib.dev, &qp_attr);
		2085	max_send_wr = qp_cap.max_send_wr + rdma_send_wr;
		2086
		2087	if (qp_cap.max_send_wr > sc->ib.dev->attrs.max_cqe \|\|
		2088	qp_cap.max_send_wr > sc->ib.dev->attrs.max_qp_wr) {
		2089	pr_err("Possible CQE overrun: max_send_wr %d\n",
		2090	qp_cap.max_send_wr);
		2091	pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n",
		2092	IB_DEVICE_NAME_MAX,
		2093	sc->ib.dev->name,
		2094	sc->ib.dev->attrs.max_cqe,
		2095	sc->ib.dev->attrs.max_qp_wr);
		2096	pr_err("consider lowering send_credit_target = %d\n",
		2097	sp->send_credit_target);
		2098	return -EINVAL;
		2099	}
		2100
		2101	if (qp_cap.max_rdma_ctxs &&
		2102	(max_send_wr >= sc->ib.dev->attrs.max_cqe \|\|
		2103	max_send_wr >= sc->ib.dev->attrs.max_qp_wr)) {
		2104	pr_err("Possible CQE overrun: rdma_send_wr %d + max_send_wr %d = %d\n",
		2105	rdma_send_wr, qp_cap.max_send_wr, max_send_wr);
		2106	pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n",
		2107	IB_DEVICE_NAME_MAX,
		2108	sc->ib.dev->name,
		2109	sc->ib.dev->attrs.max_cqe,
		2110	sc->ib.dev->attrs.max_qp_wr);
		2111	pr_err("consider lowering send_credit_target = %d, max_rdma_ctxs = %d\n",
		2112	sp->send_credit_target, qp_cap.max_rdma_ctxs);
		2113	return -EINVAL;
		2114	}
		2115
		2116	if (qp_cap.max_recv_wr > sc->ib.dev->attrs.max_cqe \|\|
		2117	qp_cap.max_recv_wr > sc->ib.dev->attrs.max_qp_wr) {
		2118	pr_err("Possible CQE overrun: max_recv_wr %d\n",
		2119	qp_cap.max_recv_wr);
		2120	pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n",
		2121	IB_DEVICE_NAME_MAX,
		2122	sc->ib.dev->name,
		2123	sc->ib.dev->attrs.max_cqe,
		2124	sc->ib.dev->attrs.max_qp_wr);
		2125	pr_err("consider lowering receive_credit_max = %d\n",
		2126	sp->recv_credit_max);
		2127	return -EINVAL;
		2128	}
		2129
		2130	if (qp_cap.max_send_sge > sc->ib.dev->attrs.max_send_sge \|\|
		2131	qp_cap.max_recv_sge > sc->ib.dev->attrs.max_recv_sge) {
		2132	pr_err("device %.*s max_send_sge/max_recv_sge = %d/%d too small\n",
		2133	IB_DEVICE_NAME_MAX,
		2134	sc->ib.dev->name,
		2135	sc->ib.dev->attrs.max_send_sge,
		2136	sc->ib.dev->attrs.max_recv_sge);
		2137	return -EINVAL;
		2138	}
2039		2139
2040	sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0);	2140	sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0);
2041	if (IS_ERR(sc->ib.pd)) {	2141	if (IS_ERR(sc->ib.pd)) {
@@ -2046,8 +2146,7 @@ static int smb_direct_create_qpair(struct smbdirect_socket *sc, · 4 unmodified lines
2046	}	2146	}
2047		2147
2048	sc->ib.send_cq = ib_alloc_cq_any(sc->ib.dev, sc,	2148	sc->ib.send_cq = ib_alloc_cq_any(sc->ib.dev, sc,
2049	sp->send_credit_target +	2149	max_send_wr,
2050	cap->max_rdma_ctxs,
2051	IB_POLL_WORKQUEUE);	2150	IB_POLL_WORKQUEUE);
2052	if (IS_ERR(sc->ib.send_cq)) {	2151	if (IS_ERR(sc->ib.send_cq)) {
2053	pr_err("Can't create RDMA send CQ\n");	2152	pr_err("Can't create RDMA send CQ\n");
@@ -2057,7 +2156,7 @@ static int smb_direct_create_qpair(struct smbdirect_socket *sc, · 3 unmodified lines
2057	}	2156	}
2058		2157
2059	sc->ib.recv_cq = ib_alloc_cq_any(sc->ib.dev, sc,	2158	sc->ib.recv_cq = ib_alloc_cq_any(sc->ib.dev, sc,
2060	sp->recv_credit_max,	2159	qp_cap.max_recv_wr,
2061	IB_POLL_WORKQUEUE);	2160	IB_POLL_WORKQUEUE);
2062	if (IS_ERR(sc->ib.recv_cq)) {	2161	if (IS_ERR(sc->ib.recv_cq)) {
2063	pr_err("Can't create RDMA recv CQ\n");	2162	pr_err("Can't create RDMA recv CQ\n");
@@ -2066,10 +2165,18 @@ static int smb_direct_create_qpair(struct smbdirect_socket *sc, · 2 unmodified lines
2066	goto err;	2165	goto err;
2067	}	2166	}
2068		2167
		2168	/*
		2169	* We reset completely here!
		2170	* As the above use was just temporary
		2171	* to calc max_send_wr and rdma_send_wr.
		2172	*
		2173	* rdma_create_qp() will trigger rdma_rw_init_qp()
		2174	* again if max_rdma_ctxs is not 0.
		2175	*/
2069	memset(&qp_attr, 0, sizeof(qp_attr));	2176	memset(&qp_attr, 0, sizeof(qp_attr));
2070	qp_attr.event_handler = smb_direct_qpair_handler;	2177	qp_attr.event_handler = smb_direct_qpair_handler;
2071	qp_attr.qp_context = sc;	2178	qp_attr.qp_context = sc;
2072	qp_attr.cap = *cap;	2179	qp_attr.cap = qp_cap;
2073	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;	2180	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
2074	qp_attr.qp_type = IB_QPT_RC;	2181	qp_attr.qp_type = IB_QPT_RC;
2075	qp_attr.send_cq = sc->ib.send_cq;	2182	qp_attr.send_cq = sc->ib.send_cq;
@@ -2085,18 +2192,6 @@ static int smb_direct_create_qpair(struct smbdirect_socket *sc, · 9 unmodified lines
2085	sc->ib.qp = sc->rdma.cm_id->qp;	2192	sc->ib.qp = sc->rdma.cm_id->qp;
2086	sc->rdma.cm_id->event_handler = smb_direct_cm_handler;	2193	sc->rdma.cm_id->event_handler = smb_direct_cm_handler;
2087		2194
2088	pages_per_rw = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE) + 1;
2089	if (pages_per_rw > sc->ib.dev->attrs.max_sgl_rd) {
2090	ret = ib_mr_pool_init(sc->ib.qp, &sc->ib.qp->rdma_mrs,
2091	sc->rw_io.credits.max, IB_MR_TYPE_MEM_REG,
2092	sc->rw_io.credits.num_pages, 0);
2093	if (ret) {
2094	pr_err("failed to init mr pool count %zu pages %zu\n",
2095	sc->rw_io.credits.max, sc->rw_io.credits.num_pages);
2096	goto err;
2097	}
2098	}
2099
2100	return 0;	2195	return 0;
2101	err:	2196	err:
2102	if (sc->ib.qp) {	2197	if (sc->ib.qp) {
@@ -2183,10 +2278,9 @@ out: · 80 unmodified lines
2183		2278
2184	static int smb_direct_connect(struct smbdirect_socket *sc)	2279	static int smb_direct_connect(struct smbdirect_socket *sc)
2185	{	2280	{
2186	struct ib_qp_cap qp_cap;
2187	int ret;	2281	int ret;
2188		2282
2189	ret = smb_direct_init_params(sc, &qp_cap);	2283	ret = smb_direct_init_params(sc);
2190	if (ret) {	2284	if (ret) {
2191	pr_err("Can't configure RDMA parameters\n");	2285	pr_err("Can't configure RDMA parameters\n");
2192	return ret;	2286	return ret;
@@ -2198,7 +2292,7 @@ static int smb_direct_connect(struct smbdirect_socket *sc) · 5 unmodified lines
2198	return ret;	2292	return ret;
2199	}	2293	}
2200		2294
2201	ret = smb_direct_create_qpair(sc, &qp_cap);	2295	ret = smb_direct_create_qpair(sc);
2202	if (ret) {	2296	if (ret) {
2203	pr_err("Can't accept RDMA client: %d\n", ret);	2297	pr_err("Can't accept RDMA client: %d\n", ret);
2204	return ret;	2298	return ret;

fs/sysfs/group.c+21−5

 }
 EXPORT_SYMBOL_GPL(compat_only_sysfs_link_entry_to_kobj);
-static int sysfs_group_attrs_change_owner(struct kernfs_node *grp_kn,
+static int sysfs_group_attrs_change_owner(struct kobject *kobj,
+					  struct kernfs_node *grp_kn,
 					  const struct attribute_group *grp,
 					  struct iattr *newattrs)
 {
 	struct kernfs_node *kn;
-	int error;
+	int error, i;
+	umode_t mode;
 	if (grp->attrs) {
 		struct attribute *const *attr;
-		for (attr = grp->attrs; *attr; attr++) {
+		for (i = 0, attr = grp->attrs; *attr; i++, attr++) {
+			if (grp->is_visible) {
+				mode = grp->is_visible(kobj, *attr, i);
+				if (mode & SYSFS_GROUP_INVISIBLE)
+					break;
+				if (!mode)
+					continue;
+			}
 			kn = kernfs_find_and_get(grp_kn, (*attr)->name);
 			if (!kn)
 				return -ENOENT;
 	if (grp->bin_attrs) {
 		const struct bin_attribute *const *bin_attr;
-		for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) {
+		for (i = 0, bin_attr = grp->bin_attrs; *bin_attr; i++, bin_attr++) {
+			if (grp->is_bin_visible) {
+				mode = grp->is_bin_visible(kobj, *bin_attr, i);
+				if (mode & SYSFS_GROUP_INVISIBLE)
+					break;
+				if (!mode)
+					continue;
+			}
 			kn = kernfs_find_and_get(grp_kn, (*bin_attr)->attr.name);
 			if (!kn)
 				return -ENOENT;
 	error = kernfs_setattr(grp_kn, &newattrs);
 	if (!error)
-		error = sysfs_group_attrs_change_owner(grp_kn, grp, &newattrs);
+		error = sysfs_group_attrs_change_owner(kobj, grp_kn, grp, &newattrs);
 	kernfs_put(grp_kn);

fs/xfs/Kconfig+10−1

 	  See the xfs man page in section 5 for additional information.
+	  This option is mandatory to support zoned block devices. For these
+	  devices, the realtime subvolume must be backed by a zoned block
+	  device and a regular block device used as the main device (for
+	  metadata). If the zoned block device is a host-managed SMR hard-disk
+	  containing conventional zones at the beginning of its address space,
+	  XFS will use the disk conventional zones as the main device and the
+	  remaining sequential write required zones as the backing storage for
+	  the realtime subvolume.
 	  If unsure, say N.
 config XFS_DRAIN_INTENTS
 	bool "XFS online metadata check usage data collection"
 	default y
 	depends on XFS_ONLINE_SCRUB
-	select DEBUG_FS
+	depends on DEBUG_FS
 	help
 	  If you say Y here, the kernel will gather usage data about
 	  the online metadata check subsystem.  This includes the number

fs/xfs/scrub/nlinks.c+31−3

@@ -376,6 +376,36 @@ out_incomplete: · 375 unmodified lines
376	return error;	376	return error;
377	}	377	}
378		378
		379	static uint
		380	xchk_nlinks_ilock_dir(
		381	struct xfs_inode *ip)
		382	{
		383	uint lock_mode = XFS_ILOCK_SHARED;
		384
		385	/*
		386	* We're going to scan the directory entries, so we must be ready to
		387	* pull the data fork mappings into memory if they aren't already.
		388	*/
		389	if (xfs_need_iread_extents(&ip->i_df))
		390	lock_mode = XFS_ILOCK_EXCL;
		391
		392	/*
		393	* We're going to scan the parent pointers, so we must be ready to
		394	* pull the attr fork mappings into memory if they aren't already.
		395	*/
		396	if (xfs_has_parent(ip->i_mount) && xfs_inode_has_attr_fork(ip) &&
		397	xfs_need_iread_extents(&ip->i_af))
		398	lock_mode = XFS_ILOCK_EXCL;
		399
		400	/*
		401	* Take the IOLOCK so that other threads cannot start a directory
		402	* update while we're scanning.
		403	*/
		404	lock_mode \|= XFS_IOLOCK_SHARED;
		405	xfs_ilock(ip, lock_mode);
		406	return lock_mode;
		407	}
		408
379	/* Walk a directory to bump the observed link counts of the children. */	409	/* Walk a directory to bump the observed link counts of the children. */
380	STATIC int	410	STATIC int
381	xchk_nlinks_collect_dir(	411	xchk_nlinks_collect_dir(
@@ -394,8 +424,7 @@ xchk_nlinks_collect_dir( · 12 unmodified lines
394	return 0;	424	return 0;
395		425
396	/* Prevent anyone from changing this directory while we walk it. */	426	/* Prevent anyone from changing this directory while we walk it. */
397	xfs_ilock(dp, XFS_IOLOCK_SHARED);	427	lock_mode = xchk_nlinks_ilock_dir(dp);
398	lock_mode = xfs_ilock_data_map_shared(dp);
399		428
400	/*	429	/*
401	* The dotdot entry of an unlinked directory still points to the last	430	* The dotdot entry of an unlinked directory still points to the last
@@ -452,7 +481,6 @@ out_abort: · 50 unmodified lines
452	xchk_iscan_abort(&xnc->collect_iscan);	481	xchk_iscan_abort(&xnc->collect_iscan);
453	out_unlock:	482	out_unlock:
454	xfs_iunlock(dp, lock_mode);	483	xfs_iunlock(dp, lock_mode);
455	xfs_iunlock(dp, XFS_IOLOCK_SHARED);
456	return error;	484	return error;
457	}	485	}
458		486

fs/xfs/xfs_buf.c+1−1

@@ -1751,7 +1751,7 @@ xfs_init_buftarg( · 1750 unmodified lines
1751	const char *descr)	1751	const char *descr)
1752	{	1752	{
1753	/* The maximum size of the buftarg is only known once the sb is read. */	1753	/* The maximum size of the buftarg is only known once the sb is read. */
1754	btp->bt_nr_sectors = (xfs_daddr_t)-1;	1754	btp->bt_nr_sectors = XFS_BUF_DADDR_MAX;
1755		1755
1756	/* Set up device logical sector size mask */	1756	/* Set up device logical sector size mask */
1757	btp->bt_logical_sectorsize = logical_sectorsize;	1757	btp->bt_logical_sectorsize = logical_sectorsize;

fs/xfs/xfs_buf.h+1−0

@@ -22,6 +22,7 @@ extern struct kmem_cache *xfs_buf_cache; · 21 unmodified lines
22	*/	22	*/
23	struct xfs_buf;	23	struct xfs_buf;
24		24
		25	#define XFS_BUF_DADDR_MAX ((xfs_daddr_t) S64_MAX)
25	#define XFS_BUF_DADDR_NULL ((xfs_daddr_t) (-1LL))	26	#define XFS_BUF_DADDR_NULL ((xfs_daddr_t) (-1LL))
26		27
27	#define XBF_READ (1u << 0) /* buffer intended for reading from device */	28	#define XBF_READ (1u << 0) /* buffer intended for reading from device */

fs/xfs/xfs_mount.h+0−1

@@ -236,7 +236,6 @@ typedef struct xfs_mount { · 235 unmodified lines
236	bool m_update_sb; /* sb needs update in mount */	236	bool m_update_sb; /* sb needs update in mount */
237	unsigned int m_max_open_zones;	237	unsigned int m_max_open_zones;
238	unsigned int m_zonegc_low_space;	238	unsigned int m_zonegc_low_space;
239	struct xfs_mru_cache m_zone_cache; / Inode to open zone cache */
240		239
241	/* max_atomic_write mount option value */	240	/* max_atomic_write mount option value */
242	unsigned long long m_awu_max_bytes;	241	unsigned long long m_awu_max_bytes;

fs/xfs/xfs_super.c+42−11

  * Table driven mount option parser.
  */
 enum {
-	Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev,
+	Op_deprecated, Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev,
 	Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid,
 	Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups,
 	Opt_allocsize, Opt_norecovery, Opt_inode64, Opt_inode32,
 	Opt_lifetime, Opt_nolifetime, Opt_max_atomic_write,
 };
+#define fsparam_dead(NAME) \
+	__fsparam(NULL, (NAME), Op_deprecated, fs_param_deprecated, NULL)
 static const struct fs_parameter_spec xfs_fs_parameters[] = {
+	/*
+	 * These mount options were supposed to be deprecated in September 2025
+	 * but the deprecation warning was buggy, so not all users were
+	 * notified.  The deprecation is now obnoxiously loud and postponed to
+	 * September 2030.
+	 */
+	fsparam_dead("attr2"),
+	fsparam_dead("noattr2"),
+	fsparam_dead("ikeep"),
+	fsparam_dead("noikeep"),
 	fsparam_u32("logbufs",		Opt_logbufs),
 	fsparam_string("logbsize",	Opt_logbsize),
 	fsparam_string("logdev",	Opt_logdev),
 	truncate_inode_pages_final(&inode->i_data);
 	clear_inode(inode);
+	if (IS_ENABLED(CONFIG_XFS_RT) &&
+	    S_ISREG(inode->i_mode) && inode->i_private) {
+		xfs_open_zone_put(inode->i_private);
+		inode->i_private = NULL;
+	}
 }
 static void
 static inline void
 xfs_fs_warn_deprecated(
 	struct fs_context	*fc,
-	struct fs_parameter	*param,
+	struct fs_parameter	*param)
-	uint64_t		flag,
-	bool			value)
 {
-	/* Don't print the warning if reconfiguring and current mount point
+	/*
-	 * already had the flag set
+	 * Always warn about someone passing in a deprecated mount option.
+	 * Previously we wouldn't print the warning if we were reconfiguring
+	 * and current mount point already had the flag set, but that was not
+	 * the right thing to do.
+	 *
+	 * Many distributions mount the root filesystem with no options in the
+	 * initramfs and rely on mount -a to remount the root fs with the
+	 * options in fstab.  However, the old behavior meant that there would
+	 * never be a warning about deprecated mount options for the root fs in
+	 * /etc/fstab.  On a single-fs system, that means no warning at all.
+	 *
+	 * Compounding this problem are distribution scripts that copy
+	 * /proc/mounts to fstab, which means that we can't remove mount
+	 * options unless we're 100% sure they have only ever been advertised
+	 * in /proc/mounts in response to explicitly provided mount options.
 	 */
-	if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) &&
-            !!(XFS_M(fc->root->d_sb)->m_features & flag) == value)
-		return;
 	xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key);
 }
 		return opt;
 	switch (opt) {
+	case Op_deprecated:
+		xfs_fs_warn_deprecated(fc, param);
+		return 0;
 	case Opt_logbufs:
 		parsing_mp->m_logbufs = result.uint_32;
 		return 0;
 		xfs_mount_set_dax_mode(parsing_mp, result.uint_32);
 		return 0;
 #endif
-	/* Following mount options will be removed in September 2025 */
 	case Opt_max_open_zones:
 		parsing_mp->m_max_open_zones = result.uint_32;
 		return 0;
 	struct xfs_mount	*mp;
 	int			i;
-	mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL | __GFP_NOFAIL);
+	mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
 	if (!mp)
 		return -ENOMEM;

fs/xfs/xfs_zone_alloc.c+60−88

@@ -26,14 +26,22 @@ · 25 unmodified lines
26	#include "xfs_trace.h"	26	#include "xfs_trace.h"
27	#include "xfs_mru_cache.h"	27	#include "xfs_mru_cache.h"
28		28
		29	static void
		30	xfs_open_zone_free_rcu(
		31	struct callback_head *cb)
		32	{
		33	struct xfs_open_zone oz = container_of(cb, typeof(oz), oz_rcu);
		34
		35	xfs_rtgroup_rele(oz->oz_rtg);
		36	kfree(oz);
		37	}
		38
29	void	39	void
30	xfs_open_zone_put(	40	xfs_open_zone_put(
31	struct xfs_open_zone *oz)	41	struct xfs_open_zone *oz)
32	{	42	{
33	if (atomic_dec_and_test(&oz->oz_ref)) {	43	if (atomic_dec_and_test(&oz->oz_ref))
34	xfs_rtgroup_rele(oz->oz_rtg);	44	call_rcu(&oz->oz_rcu, xfs_open_zone_free_rcu);
35	kfree(oz);
36	}
37	}	45	}
38		46
39	static inline uint32_t	47	static inline uint32_t
@@ -614,14 +622,25 @@ static inline enum rw_hint xfs_inode_write_hint(struct xfs_inode *ip) · 574 unmodified lines
614	}	622	}
615		623
616	/*	624	/*
617	* Try to pack inodes that are written back after they were closed tight instead	625	* Try to tightly pack small files that are written back after they were closed
618	* of trying to open new zones for them or spread them to the least recently	626	* instead of trying to open new zones for them or spread them to the least
619	* used zone. This optimizes the data layout for workloads that untar or copy	627	* recently used zone. This optimizes the data layout for workloads that untar
620	* a lot of small files. Right now this does not separate multiple such	628	* or copy a lot of small files. Right now this does not separate multiple such
621	* streams.	629	* streams.
622	*/	630	*/
623	static inline bool xfs_zoned_pack_tight(struct xfs_inode *ip)	631	static inline bool xfs_zoned_pack_tight(struct xfs_inode *ip)
624	{	632	{
		633	struct xfs_mount *mp = ip->i_mount;
		634	size_t zone_capacity =
		635	XFS_FSB_TO_B(mp, mp->m_groups[XG_TYPE_RTG].blocks);
		636
		637	/*
		638	* Do not pack write files that are already using a full zone to avoid
		639	* fragmentation.
		640	*/
		641	if (i_size_read(VFS_I(ip)) >= zone_capacity)
		642	return false;
		643
625	return !inode_is_open_for_write(VFS_I(ip)) &&	644	return !inode_is_open_for_write(VFS_I(ip)) &&
626	!(ip->i_diflags & XFS_DIFLAG_APPEND);	645	!(ip->i_diflags & XFS_DIFLAG_APPEND);
627	}	646	}
@@ -745,98 +764,55 @@ xfs_mark_rtg_boundary( · 117 unmodified lines
745	ioend->io_flags \|= IOMAP_IOEND_BOUNDARY;	764	ioend->io_flags \|= IOMAP_IOEND_BOUNDARY;
746	}	765	}
747		766
748	/*
749	* Cache the last zone written to for an inode so that it is considered first
750	* for subsequent writes.
751	*/
752	struct xfs_zone_cache_item {
753	struct xfs_mru_cache_elem mru;
754	struct xfs_open_zone *oz;
755	};
756
757	static inline struct xfs_zone_cache_item *
758	xfs_zone_cache_item(struct xfs_mru_cache_elem *mru)
759	{
760	return container_of(mru, struct xfs_zone_cache_item, mru);
761	}
762
763	static void
764	xfs_zone_cache_free_func(
765	void *data,
766	struct xfs_mru_cache_elem *mru)
767	{
768	struct xfs_zone_cache_item *item = xfs_zone_cache_item(mru);
769
770	xfs_open_zone_put(item->oz);
771	kfree(item);
772	}
773
774	/*	767	/*
775	* Check if we have a cached last open zone available for the inode and	768	* Check if we have a cached last open zone available for the inode and
776	* if yes return a reference to it.	769	* if yes return a reference to it.
777	*/	770	*/
778	static struct xfs_open_zone *	771	static struct xfs_open_zone *
779	xfs_cached_zone(	772	xfs_get_cached_zone(
780	struct xfs_mount *mp,	773	struct xfs_inode *ip)
781	struct xfs_inode *ip)
782	{	774	{
783	struct xfs_mru_cache_elem *mru;	775	struct xfs_open_zone *oz;
784	struct xfs_open_zone *oz;
785		776
786	mru = xfs_mru_cache_lookup(mp->m_zone_cache, ip->i_ino);	777	rcu_read_lock();
787	if (!mru)	778	oz = VFS_I(ip)->i_private;
788	return NULL;
789	oz = xfs_zone_cache_item(mru)->oz;
790	if (oz) {	779	if (oz) {
791	/*	780	/*
792	* GC only steals open zones at mount time, so no GC zones	781	* GC only steals open zones at mount time, so no GC zones
793	* should end up in the cache.	782	* should end up in the cache.
794	*/	783	*/
795	ASSERT(!oz->oz_is_gc);	784	ASSERT(!oz->oz_is_gc);
796	ASSERT(atomic_read(&oz->oz_ref) > 0);	785	if (!atomic_inc_not_zero(&oz->oz_ref))
797	atomic_inc(&oz->oz_ref);	786	oz = NULL;
798	}	787	}
799	xfs_mru_cache_done(mp->m_zone_cache);	788	rcu_read_unlock();
		789
800	return oz;	790	return oz;
801	}	791	}
802		792
803	/*	793	/*
804	* Update the last used zone cache for a given inode.	794	* Stash our zone in the inode so that is is reused for future allocations.
805	*	795	*
806	* The caller must have a reference on the open zone.	796	* The open_zone structure will be pinned until either the inode is freed or
		797	* until the cached open zone is replaced with a different one because the
		798	* current one was full when we tried to use it. This means we keep any
		799	* open zone around forever as long as any inode that used it for the last
		800	* write is cached, which slightly increases the memory use of cached inodes
		801	* that were every written to, but significantly simplifies the cached zone
		802	* lookup. Because the open_zone is clearly marked as full when all data
		803	* in the underlying RTG was written, the caching is always safe.
807	*/	804	*/
808	static void	805	static void
809	xfs_zone_cache_create_association(	806	xfs_set_cached_zone(
810	struct xfs_inode *ip,	807	struct xfs_inode *ip,
811	struct xfs_open_zone *oz)	808	struct xfs_open_zone *oz)
812	{	809	{
813	struct xfs_mount *mp = ip->i_mount;	810	struct xfs_open_zone *old_oz;
814	struct xfs_zone_cache_item *item = NULL;
815	struct xfs_mru_cache_elem *mru;
816		811
817	ASSERT(atomic_read(&oz->oz_ref) > 0);
818	atomic_inc(&oz->oz_ref);	812	atomic_inc(&oz->oz_ref);
819		813	old_oz = xchg(&VFS_I(ip)->i_private, oz);
820	mru = xfs_mru_cache_lookup(mp->m_zone_cache, ip->i_ino);	814	if (old_oz)
821	if (mru) {	815	xfs_open_zone_put(old_oz);
822	/*
823	* If we have an association already, update it to point to the
824	* new zone.
825	*/
826	item = xfs_zone_cache_item(mru);
827	xfs_open_zone_put(item->oz);
828	item->oz = oz;
829	xfs_mru_cache_done(mp->m_zone_cache);
830	return;
831	}
832
833	item = kmalloc(sizeof(*item), GFP_KERNEL);
834	if (!item) {
835	xfs_open_zone_put(oz);
836	return;
837	}
838	item->oz = oz;
839	xfs_mru_cache_insert(mp->m_zone_cache, ip->i_ino, &item->mru);
840	}	816	}
841		817
842	static void	818	static void
@@ -880,15 +856,14 @@ xfs_zone_alloc_and_submit( · 37 unmodified lines
880	* the inode is still associated with a zone and use that if so.	856	* the inode is still associated with a zone and use that if so.
881	*/	857	*/
882	if (!*oz)	858	if (!*oz)
883	*oz = xfs_cached_zone(mp, ip);	859	*oz = xfs_get_cached_zone(ip);
884		860
885	if (!*oz) {	861	if (!*oz) {
886	select_zone:	862	select_zone:
887	*oz = xfs_select_zone(mp, write_hint, pack_tight);	863	*oz = xfs_select_zone(mp, write_hint, pack_tight);
888	if (!*oz)	864	if (!*oz)
889	goto out_error;	865	goto out_error;
890		866	xfs_set_cached_zone(ip, *oz);
891	xfs_zone_cache_create_association(ip, *oz);
892	}	867	}
893		868
894	alloc_len = xfs_zone_alloc_blocks(*oz, XFS_B_TO_FSB(mp, ioend->io_size),	869	alloc_len = xfs_zone_alloc_blocks(*oz, XFS_B_TO_FSB(mp, ioend->io_size),
@@ -966,6 +941,12 @@ xfs_free_open_zones( · 71 unmodified lines
966	xfs_open_zone_put(oz);	941	xfs_open_zone_put(oz);
967	}	942	}
968	spin_unlock(&zi->zi_open_zones_lock);	943	spin_unlock(&zi->zi_open_zones_lock);
		944
		945	/*
		946	* Wait for all open zones to be freed so that they drop the group
		947	* references:
		948	*/
		949	rcu_barrier();
969	}	950	}
970		951
971	struct xfs_init_zones {	952	struct xfs_init_zones {
@@ -1279,14 +1260,6 @@ xfs_mount_zones( · 307 unmodified lines
1279	error = xfs_zone_gc_mount(mp);	1260	error = xfs_zone_gc_mount(mp);
1280	if (error)	1261	if (error)
1281	goto out_free_zone_info;	1262	goto out_free_zone_info;
1282
1283	/*
1284	* Set up a mru cache to track inode to open zone for data placement
1285	* purposes. The magic values for group count and life time is the
1286	* same as the defaults for file streams, which seems sane enough.
1287	*/
1288	xfs_mru_cache_create(&mp->m_zone_cache, mp,
1289	5000, 10, xfs_zone_cache_free_func);
1290	return 0;	1263	return 0;
1291		1264
1292	out_free_zone_info:	1265	out_free_zone_info:
@@ -1300,5 +1273,4 @@ xfs_unmount_zones( · 7 unmodified lines
1300	{	1273	{
1301	xfs_zone_gc_unmount(mp);	1274	xfs_zone_gc_unmount(mp);
1302	xfs_free_zone_info(mp->m_zone_info);	1275	xfs_free_zone_info(mp->m_zone_info);
1303	xfs_mru_cache_destroy(mp->m_zone_cache);
1304	}	1276	}

fs/xfs/xfs_zone_gc.c+46−35

@@ -491,21 +491,6 @@ xfs_zone_gc_select_victim( · 490 unmodified lines
491	struct xfs_rtgroup *victim_rtg = NULL;	491	struct xfs_rtgroup *victim_rtg = NULL;
492	unsigned int bucket;	492	unsigned int bucket;
493		493
494	if (xfs_is_shutdown(mp))
495	return false;
496
497	if (iter->victim_rtg)
498	return true;
499
500	/*
501	* Don't start new work if we are asked to stop or park.
502	*/
503	if (kthread_should_stop() \|\| kthread_should_park())
504	return false;
505
506	if (!xfs_zoned_need_gc(mp))
507	return false;
508
509	spin_lock(&zi->zi_used_buckets_lock);	494	spin_lock(&zi->zi_used_buckets_lock);
510	for (bucket = 0; bucket < XFS_ZONE_USED_BUCKETS; bucket++) {	495	for (bucket = 0; bucket < XFS_ZONE_USED_BUCKETS; bucket++) {
511	victim_rtg = xfs_zone_gc_pick_victim_from(mp, bucket);	496	victim_rtg = xfs_zone_gc_pick_victim_from(mp, bucket);
@@ -975,6 +960,27 @@ xfs_zone_gc_reset_zones( · 463 unmodified lines
975	} while (next);	960	} while (next);
976	}	961	}
977		962
		963	static bool
		964	xfs_zone_gc_should_start_new_work(
		965	struct xfs_zone_gc_data *data)
		966	{
		967	if (xfs_is_shutdown(data->mp))
		968	return false;
		969	if (!xfs_zone_gc_space_available(data))
		970	return false;
		971
		972	if (!data->iter.victim_rtg) {
		973	if (kthread_should_stop() \|\| kthread_should_park())
		974	return false;
		975	if (!xfs_zoned_need_gc(data->mp))
		976	return false;
		977	if (!xfs_zone_gc_select_victim(data))
		978	return false;
		979	}
		980
		981	return true;
		982	}
		983
978	/*	984	/*
979	* Handle the work to read and write data for GC and to reset the zones,	985	* Handle the work to read and write data for GC and to reset the zones,
980	* including handling all completions.	986	* including handling all completions.
@@ -982,7 +988,7 @@ xfs_zone_gc_reset_zones( · 1 unmodified line
982	* Note that the order of the chunks is preserved so that we don't undo the	988	* Note that the order of the chunks is preserved so that we don't undo the
983	* optimal order established by xfs_zone_gc_query().	989	* optimal order established by xfs_zone_gc_query().
984	*/	990	*/
985	static bool	991	static void
986	xfs_zone_gc_handle_work(	992	xfs_zone_gc_handle_work(
987	struct xfs_zone_gc_data *data)	993	struct xfs_zone_gc_data *data)
988	{	994	{
@@ -996,30 +1002,22 @@ xfs_zone_gc_handle_work( · 7 unmodified lines
996	zi->zi_reset_list = NULL;	1002	zi->zi_reset_list = NULL;
997	spin_unlock(&zi->zi_reset_list_lock);	1003	spin_unlock(&zi->zi_reset_list_lock);
998		1004
999	if (!xfs_zone_gc_select_victim(data) \|\|	1005	if (reset_list) {
1000	!xfs_zone_gc_space_available(data)) {	1006	set_current_state(TASK_RUNNING);
1001	if (list_empty(&data->reading) &&
1002	list_empty(&data->writing) &&
1003	list_empty(&data->resetting) &&
1004	!reset_list)
1005	return false;
1006	}
1007
1008	__set_current_state(TASK_RUNNING);
1009	try_to_freeze();
1010
1011	if (reset_list)
1012	xfs_zone_gc_reset_zones(data, reset_list);	1007	xfs_zone_gc_reset_zones(data, reset_list);
		1008	}
1013		1009
1014	list_for_each_entry_safe(chunk, next, &data->resetting, entry) {	1010	list_for_each_entry_safe(chunk, next, &data->resetting, entry) {
1015	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)	1011	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)
1016	break;	1012	break;
		1013	set_current_state(TASK_RUNNING);
1017	xfs_zone_gc_finish_reset(chunk);	1014	xfs_zone_gc_finish_reset(chunk);
1018	}	1015	}
1019		1016
1020	list_for_each_entry_safe(chunk, next, &data->writing, entry) {	1017	list_for_each_entry_safe(chunk, next, &data->writing, entry) {
1021	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)	1018	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)
1022	break;	1019	break;
		1020	set_current_state(TASK_RUNNING);
1023	xfs_zone_gc_finish_chunk(chunk);	1021	xfs_zone_gc_finish_chunk(chunk);
1024	}	1022	}
1025		1023
@@ -1027,15 +1025,18 @@ xfs_zone_gc_handle_work( · 1 unmodified line
1027	list_for_each_entry_safe(chunk, next, &data->reading, entry) {	1025	list_for_each_entry_safe(chunk, next, &data->reading, entry) {
1028	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)	1026	if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)
1029	break;	1027	break;
		1028	set_current_state(TASK_RUNNING);
1030	xfs_zone_gc_write_chunk(chunk);	1029	xfs_zone_gc_write_chunk(chunk);
1031	}	1030	}
1032	blk_finish_plug(&plug);	1031	blk_finish_plug(&plug);
1033		1032
1034	blk_start_plug(&plug);	1033	if (xfs_zone_gc_should_start_new_work(data)) {
1035	while (xfs_zone_gc_start_chunk(data))	1034	set_current_state(TASK_RUNNING);
1036	;	1035	blk_start_plug(&plug);
1037	blk_finish_plug(&plug);	1036	while (xfs_zone_gc_start_chunk(data))
1038	return true;	1037	;
		1038	blk_finish_plug(&plug);
		1039	}
1039	}	1040	}
1040		1041
1041	/*	1042	/*
@@ -1059,8 +1060,18 @@ xfs_zoned_gcd( · 17 unmodified lines
1059	for (;;) {	1060	for (;;) {
1060	set_current_state(TASK_INTERRUPTIBLE \| TASK_FREEZABLE);	1061	set_current_state(TASK_INTERRUPTIBLE \| TASK_FREEZABLE);
1061	xfs_set_zonegc_running(mp);	1062	xfs_set_zonegc_running(mp);
1062	if (xfs_zone_gc_handle_work(data))	1063
		1064	xfs_zone_gc_handle_work(data);
		1065
		1066	/*
		1067	* Only sleep if nothing set the state to running. Else check for
		1068	* work again as someone might have queued up more work and woken
		1069	* us in the meantime.
		1070	*/
		1071	if (get_current_state() == TASK_RUNNING) {
		1072	try_to_freeze();
1063	continue;	1073	continue;
		1074	}
1064		1075
1065	if (list_empty(&data->reading) &&	1076	if (list_empty(&data->reading) &&
1066	list_empty(&data->writing) &&	1077	list_empty(&data->writing) &&

fs/xfs/xfs_zone_priv.h+2−0

@@ -44,6 +44,8 @@ struct xfs_open_zone { · 43 unmodified lines
44	* the life time of an open zone.	44	* the life time of an open zone.
45	*/	45	*/
46	struct xfs_rtgroup *oz_rtg;	46	struct xfs_rtgroup *oz_rtg;
		47
		48	struct rcu_head oz_rcu;
47	};	49	};
48		50
49	/*	51	/*

include/linux/arm_ffa.h+19−2

 	 * an `struct ffa_mem_region_addr_range`.
 	 */
 	u32 composite_off;
+	u8 impdef_val[16];
 	u64 reserved;
 };
 #define CONSTITUENTS_OFFSET(x)	\
 	(offsetof(struct ffa_composite_mem_region, constituents[x]))
+#define FFA_EMAD_HAS_IMPDEF_FIELD(version)	((version) >= FFA_VERSION_1_2)
+#define FFA_MEM_REGION_HAS_EP_MEM_OFFSET(version) ((version) > FFA_VERSION_1_0)
+static inline u32 ffa_emad_size_get(u32 ffa_version)
+{
+	u32 sz;
+	struct ffa_mem_region_attributes *ep_mem_access;
+	if (FFA_EMAD_HAS_IMPDEF_FIELD(ffa_version))
+		sz = sizeof(*ep_mem_access);
+	else
+		sz = sizeof(*ep_mem_access) - sizeof(ep_mem_access->impdef_val);
+	return sz;
+}
 static inline u32
 ffa_mem_desc_offset(struct ffa_mem_region *buf, int count, u32 ffa_version)
 {
-	u32 offset = count * sizeof(struct ffa_mem_region_attributes);
+	u32 offset = count * ffa_emad_size_get(ffa_version);
 	/*
 	 * Earlier to v1.1, the endpoint memory descriptor array started at
 	 * offset 32(i.e. offset of ep_mem_offset in the current structure)
 	 */
-	if (ffa_version <= FFA_VERSION_1_0)
+	if (!FFA_MEM_REGION_HAS_EP_MEM_OFFSET(ffa_version))
 		offset += offsetof(struct ffa_mem_region, ep_mem_offset);
 	else
 		offset += sizeof(struct ffa_mem_region);

include/linux/cgroup-defs.h+1−1

@@ -452,7 +452,7 @@ struct cgroup_freezer_state { · 451 unmodified lines
452	int nr_frozen_tasks;	452	int nr_frozen_tasks;
453		453
454	/* Freeze time data consistency protection */	454	/* Freeze time data consistency protection */
455	seqcount_t freeze_seq;	455	seqcount_spinlock_t freeze_seq;
456		456
457	/*	457	/*
458	* Most recent time the cgroup was requested to freeze.	458	* Most recent time the cgroup was requested to freeze.

include/linux/exportfs.h+4−3

 static inline bool exportfs_can_encode_fh(const struct export_operations *nop,
 					  int fh_flags)
 {
-	if (!nop)
-		return false;
 	/*
 	 * If a non-decodeable file handle was requested, we only need to make
 	 * sure that filesystem did not opt-out of encoding fid.
 	if (fh_flags & EXPORT_FH_FID)
 		return exportfs_can_encode_fid(nop);
+	/* Normal file handles cannot be created without export ops */
+	if (!nop)
+		return false;
 	/*
 	 * If a connectable file handle was requested, we need to make sure that
 	 * filesystem can also decode connected file handles.

include/linux/gpio/regmap.h+5−0

  *			offset to a register/bitmask pair. If not
  *			given the default gpio_regmap_simple_xlate()
  *			is used.
+ * @fixed_direction_output:
+ *			(Optional) Bitmap representing the fixed direction of
+ *			the GPIO lines. Useful when there are GPIO lines with a
+ *			fixed direction mixed together in the same register.
  * @drvdata:		(Optional) Pointer to driver specific data which is
  *			not used by gpio-remap but is provided "as is" to the
  *			driver callback(s).
 	int reg_stride;
 	int ngpio_per_reg;
 	struct irq_domain *irq_domain;
+	unsigned long *fixed_direction_output;
 #ifdef CONFIG_REGMAP_IRQ
 	struct regmap_irq_chip *regmap_irq_chip;

include/linux/hung_task.h+5−3

  * always zero. So we can use these bits to encode the specific blocking
  * type.
  *
+ * Note that on architectures where this is not guaranteed, or for any
+ * unaligned lock, this tracking mechanism is silently skipped for that
+ * lock.
+ *
  * Type encoding:
  * 00 - Blocked on mutex			(BLOCKER_TYPE_MUTEX)
  * 01 - Blocked on semaphore			(BLOCKER_TYPE_SEM)
 	 * If the lock pointer matches the BLOCKER_TYPE_MASK, return
 	 * without writing anything.
 	 */
-	if (WARN_ON_ONCE(lock_ptr & BLOCKER_TYPE_MASK))
+	if (lock_ptr & BLOCKER_TYPE_MASK)
 		return;
 	WRITE_ONCE(current->blocker, lock_ptr | type);
 static inline void hung_task_clear_blocker(void)
 {
-	WARN_ON_ONCE(!READ_ONCE(current->blocker));
 	WRITE_ONCE(current->blocker, 0UL);
 }

include/linux/misc_cgroup.h+1−1

@@ -19,7 +19,7 @@ enum misc_res_type { · 18 unmodified lines
19	MISC_CG_RES_SEV_ES,	19	MISC_CG_RES_SEV_ES,
20	#endif	20	#endif
21	#ifdef CONFIG_INTEL_TDX_HOST	21	#ifdef CONFIG_INTEL_TDX_HOST
22	/* Intel TDX HKIDs resource */	22	/** @MISC_CG_RES_TDX: Intel TDX HKIDs resource */
23	MISC_CG_RES_TDX,	23	MISC_CG_RES_TDX,
24	#endif	24	#endif
25	/** @MISC_CG_RES_TYPES: count of enum misc_res_type constants */	25	/** @MISC_CG_RES_TYPES: count of enum misc_res_type constants */

include/linux/mlx5/mlx5_ifc.h+3−1

@@ -10833,7 +10833,9 @@ struct mlx5_ifc_pcam_regs_5000_to_507f_bits { · 10832 unmodified lines
10833	u8 port_access_reg_cap_mask_127_to_96[0x20];	10833	u8 port_access_reg_cap_mask_127_to_96[0x20];
10834	u8 port_access_reg_cap_mask_95_to_64[0x20];	10834	u8 port_access_reg_cap_mask_95_to_64[0x20];
10835		10835
10836	u8 port_access_reg_cap_mask_63_to_36[0x1c];	10836	u8 port_access_reg_cap_mask_63[0x1];
		10837	u8 pphcr[0x1];
		10838	u8 port_access_reg_cap_mask_61_to_36[0x1a];
10837	u8 pplm[0x1];	10839	u8 pplm[0x1];
10838	u8 port_access_reg_cap_mask_34_to_32[0x3];	10840	u8 port_access_reg_cap_mask_34_to_32[0x3];
10839		10841

include/linux/pm_runtime.h+4−4

@@ -629,13 +629,13 @@ DEFINE_GUARD(pm_runtime_active_auto, struct device *, · 628 unmodified lines
629	* device.	629	* device.
630	*/	630	*/
631	DEFINE_GUARD_COND(pm_runtime_active, _try,	631	DEFINE_GUARD_COND(pm_runtime_active, _try,
632	pm_runtime_get_active(_T, RPM_TRANSPARENT))	632	pm_runtime_get_active(_T, RPM_TRANSPARENT), _RET == 0)
633	DEFINE_GUARD_COND(pm_runtime_active, _try_enabled,	633	DEFINE_GUARD_COND(pm_runtime_active, _try_enabled,
634	pm_runtime_resume_and_get(_T))	634	pm_runtime_resume_and_get(_T), _RET == 0)
635	DEFINE_GUARD_COND(pm_runtime_active_auto, _try,	635	DEFINE_GUARD_COND(pm_runtime_active_auto, _try,
636	pm_runtime_get_active(_T, RPM_TRANSPARENT))	636	pm_runtime_get_active(_T, RPM_TRANSPARENT), _RET == 0)
637	DEFINE_GUARD_COND(pm_runtime_active_auto, _try_enabled,	637	DEFINE_GUARD_COND(pm_runtime_active_auto, _try_enabled,
638	pm_runtime_resume_and_get(_T))	638	pm_runtime_resume_and_get(_T), _RET == 0)
639		639
640	/**	640	/**
641	* pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0.	641	* pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0.

include/linux/skbuff.h+3−0

 				    struct sk_buff_head *sk_queue,
 				    unsigned int flags, int *off, int *err);
 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned int flags, int *err);
+__poll_t datagram_poll_queue(struct file *file, struct socket *sock,
+			     struct poll_table_struct *wait,
+			     struct sk_buff_head *rcv_queue);
 __poll_t datagram_poll(struct file *file, struct socket *sock,
 			   struct poll_table_struct *wait);
 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,

include/linux/virtio_net.h+4−0

 	if (!tnl_hdr_negotiated)
 		return -EINVAL;
+        vhdr->hash_hdr.hash_value = 0;
+        vhdr->hash_hdr.hash_report = 0;
+        vhdr->hash_hdr.padding = 0;
 	/* Let the basic parsing deal with plain GSO features. */
 	skb_shinfo(skb)->gso_type &= ~tnl_gso_type;
 	ret = virtio_net_hdr_from_skb(skb, hdr, true, false, vlan_hlen);

include/uapi/drm/xe_drm.h+15−0

@@ -1013,6 +1013,20 @@ struct drm_xe_vm_destroy { · 1012 unmodified lines
1013	* valid on VMs with DRM_XE_VM_CREATE_FLAG_FAULT_MODE set. The CPU address	1013	* valid on VMs with DRM_XE_VM_CREATE_FLAG_FAULT_MODE set. The CPU address
1014	* mirror flag are only valid for DRM_XE_VM_BIND_OP_MAP operations, the BO	1014	* mirror flag are only valid for DRM_XE_VM_BIND_OP_MAP operations, the BO
1015	* handle MBZ, and the BO offset MBZ.	1015	* handle MBZ, and the BO offset MBZ.
		1016	* - %DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET - Can be used in combination with
		1017	* %DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR to reset madvises when the underlying
		1018	* CPU address space range is unmapped (typically with munmap(2) or brk(2)).
		1019	* The madvise values set with &DRM_IOCTL_XE_MADVISE are reset to the values
		1020	* that were present immediately after the &DRM_IOCTL_XE_VM_BIND.
		1021	* The reset GPU virtual address range is the intersection of the range bound
		1022	* using &DRM_IOCTL_XE_VM_BIND and the virtual CPU address space range
		1023	* unmapped.
		1024	* This functionality is present to mimic the behaviour of CPU address space
		1025	* madvises set using madvise(2), which are typically reset on unmap.
		1026	* Note: free(3) may or may not call munmap(2) and/or brk(2), and may thus
		1027	* not invoke autoreset. Neither will stack variables going out of scope.
		1028	* Therefore it's recommended to always explicitly reset the madvises when
		1029	* freeing the memory backing a region used in a &DRM_IOCTL_XE_MADVISE call.
1016	*	1030	*
1017	* The @prefetch_mem_region_instance for %DRM_XE_VM_BIND_OP_PREFETCH can also be:	1031	* The @prefetch_mem_region_instance for %DRM_XE_VM_BIND_OP_PREFETCH can also be:
1018	* - %DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC, which ensures prefetching occurs in	1032	* - %DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC, which ensures prefetching occurs in
@@ -1119,6 +1133,7 @@ struct drm_xe_vm_bind_op { · 100 unmodified lines
1119	#define DRM_XE_VM_BIND_FLAG_DUMPABLE (1 << 3)	1133	#define DRM_XE_VM_BIND_FLAG_DUMPABLE (1 << 3)
1120	#define DRM_XE_VM_BIND_FLAG_CHECK_PXP (1 << 4)	1134	#define DRM_XE_VM_BIND_FLAG_CHECK_PXP (1 << 4)
1121	#define DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR (1 << 5)	1135	#define DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR (1 << 5)
		1136	#define DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET (1 << 6)
1122	/** @flags: Bind flags */	1137	/** @flags: Bind flags */
1123	__u32 flags;	1138	__u32 flags;
1124		1139

io_uring/fdinfo.c+4−4

 {
 	struct io_overflow_cqe *ocqe;
 	struct io_rings *r = ctx->rings;
-	struct rusage sq_usage;
 	unsigned int sq_mask = ctx->sq_entries - 1, cq_mask = ctx->cq_entries - 1;
 	unsigned int sq_head = READ_ONCE(r->sq.head);
 	unsigned int sq_tail = READ_ONCE(r->sq.tail);
 		 * thread termination.
 		 */
 		if (tsk) {
+			u64 usec;
 			get_task_struct(tsk);
 			rcu_read_unlock();
-			getrusage(tsk, RUSAGE_SELF, &sq_usage);
+			usec = io_sq_cpu_usec(tsk);
 			put_task_struct(tsk);
 			sq_pid = sq->task_pid;
 			sq_cpu = sq->sq_cpu;
-			sq_total_time = (sq_usage.ru_stime.tv_sec * 1000000
+			sq_total_time = usec;
-					 + sq_usage.ru_stime.tv_usec);
 			sq_work_time = sq->work_time;
 		} else {
 			rcu_read_unlock();

io_uring/filetable.c+1−1

@@ -57,7 +57,7 @@ void io_free_file_tables(struct io_ring_ctx ctx, struct io_file_table table) · 56 unmodified lines
57		57
58	static int io_install_fixed_file(struct io_ring_ctx ctx, struct file file,	58	static int io_install_fixed_file(struct io_ring_ctx ctx, struct file file,
59	u32 slot_index)	59	u32 slot_index)
60	__must_hold(&req->ctx->uring_lock)	60	__must_hold(&ctx->uring_lock)
61	{	61	{
62	struct io_rsrc_node *node;	62	struct io_rsrc_node *node;
63		63

io_uring/io_uring.c+1−1

@@ -879,7 +879,7 @@ static inline struct io_cqe io_init_cqe(u64 user_data, s32 res, u32 cflags) · 878 unmodified lines
879	}	879	}
880		880
881	static __cold void io_cqe_overflow(struct io_ring_ctx ctx, struct io_cqe cqe,	881	static __cold void io_cqe_overflow(struct io_ring_ctx ctx, struct io_cqe cqe,
882	struct io_big_cqe *big_cqe)	882	struct io_big_cqe *big_cqe)
883	{	883	{
884	struct io_overflow_cqe *ocqe;	884	struct io_overflow_cqe *ocqe;
885		885

io_uring/kbuf.c+22−11

 	return 1;
 }
+static bool io_should_commit(struct io_kiocb *req, unsigned int issue_flags)
+{
+	/*
+	* If we came in unlocked, we have no choice but to consume the
+	* buffer here, otherwise nothing ensures that the buffer won't
+	* get used by others. This does mean it'll be pinned until the
+	* IO completes, coming in unlocked means we're being called from
+	* io-wq context and there may be further retries in async hybrid
+	* mode. For the locked case, the caller must call commit when
+	* the transfer completes (or if we get -EAGAIN and must poll of
+	* retry).
+	*/
+	if (issue_flags & IO_URING_F_UNLOCKED)
+		return true;
+	/* uring_cmd commits kbuf upfront, no need to auto-commit */
+	if (!io_file_can_poll(req) && req->opcode != IORING_OP_URING_CMD)
+		return true;
+	return false;
+}
 static struct io_br_sel io_ring_buffer_select(struct io_kiocb *req, size_t *len,
 					      struct io_buffer_list *bl,
 					      unsigned int issue_flags)
 	sel.buf_list = bl;
 	sel.addr = u64_to_user_ptr(buf->addr);
-	if (issue_flags & IO_URING_F_UNLOCKED || !io_file_can_poll(req)) {
+	if (io_should_commit(req, issue_flags)) {
-		/*
-		 * If we came in unlocked, we have no choice but to consume the
-		 * buffer here, otherwise nothing ensures that the buffer won't
-		 * get used by others. This does mean it'll be pinned until the
-		 * IO completes, coming in unlocked means we're being called from
-		 * io-wq context and there may be further retries in async hybrid
-		 * mode. For the locked case, the caller must call commit when
-		 * the transfer completes (or if we get -EAGAIN and must poll of
-		 * retry).
-		 */
 		io_kbuf_commit(req, sel.buf_list, *len, 1);
 		sel.buf_list = NULL;
 	}

io_uring/net.c+1−1

@@ -383,7 +383,7 @@ static int io_send_setup(struct io_kiocb req, const struct io_uring_sqe sqe) · 382 unmodified lines
383	return 0;	383	return 0;
384		384
385	if (sr->flags & IORING_SEND_VECTORIZED)	385	if (sr->flags & IORING_SEND_VECTORIZED)
386	return io_net_import_vec(req, kmsg, sr->buf, sr->len, ITER_SOURCE);	386	return io_net_import_vec(req, kmsg, sr->buf, sr->len, ITER_SOURCE);
387		387
388	return import_ubuf(ITER_SOURCE, sr->buf, sr->len, &kmsg->msg.msg_iter);	388	return import_ubuf(ITER_SOURCE, sr->buf, sr->len, &kmsg->msg.msg_iter);
389	}	389	}

io_uring/sqpoll.c+45−20

 #include <linux/audit.h>
 #include <linux/security.h>
 #include <linux/cpuset.h>
+#include <linux/sched/cputime.h>
 #include <linux/io_uring.h>
 #include <uapi/linux/io_uring.h>
 	return READ_ONCE(sqd->state);
 }
-static int __io_sq_thread(struct io_ring_ctx *ctx, bool cap_entries)
+struct io_sq_time {
+	bool started;
+	u64 usec;
+};
+u64 io_sq_cpu_usec(struct task_struct *tsk)
+{
+	u64 utime, stime;
+	task_cputime_adjusted(tsk, &utime, &stime);
+	do_div(stime, 1000);
+	return stime;
+}
+static void io_sq_update_worktime(struct io_sq_data *sqd, struct io_sq_time *ist)
+{
+	if (!ist->started)
+		return;
+	ist->started = false;
+	sqd->work_time += io_sq_cpu_usec(current) - ist->usec;
+}
+static void io_sq_start_worktime(struct io_sq_time *ist)
+{
+	if (ist->started)
+		return;
+	ist->started = true;
+	ist->usec = io_sq_cpu_usec(current);
+}
+static int __io_sq_thread(struct io_ring_ctx *ctx, struct io_sq_data *sqd,
+			  bool cap_entries, struct io_sq_time *ist)
 {
 	unsigned int to_submit;
 	int ret = 0;
 	if (to_submit || !wq_list_empty(&ctx->iopoll_list)) {
 		const struct cred *creds = NULL;
+		io_sq_start_worktime(ist);
 		if (ctx->sq_creds != current_cred())
 			creds = override_creds(ctx->sq_creds);
 	return retry_list || !llist_empty(&tctx->task_list);
 }
-static void io_sq_update_worktime(struct io_sq_data *sqd, struct rusage *start)
-{
-	struct rusage end;
-	getrusage(current, RUSAGE_SELF, &end);
-	end.ru_stime.tv_sec -= start->ru_stime.tv_sec;
-	end.ru_stime.tv_usec -= start->ru_stime.tv_usec;
-	sqd->work_time += end.ru_stime.tv_usec + end.ru_stime.tv_sec * 1000000;
-}
 static int io_sq_thread(void *data)
 {
 	struct llist_node *retry_list = NULL;
 	struct io_sq_data *sqd = data;
 	struct io_ring_ctx *ctx;
-	struct rusage start;
 	unsigned long timeout = 0;
 	char buf[TASK_COMM_LEN] = {};
 	DEFINE_WAIT(wait);
 	mutex_lock(&sqd->lock);
 	while (1) {
 		bool cap_entries, sqt_spin = false;
+		struct io_sq_time ist = { };
 		if (io_sqd_events_pending(sqd) || signal_pending(current)) {
 			if (io_sqd_handle_event(sqd))
 		}
 		cap_entries = !list_is_singular(&sqd->ctx_list);
-		getrusage(current, RUSAGE_SELF, &start);
 		list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {
-			int ret = __io_sq_thread(ctx, cap_entries);
+			int ret = __io_sq_thread(ctx, sqd, cap_entries, &ist);
 			if (!sqt_spin && (ret > 0 || !wq_list_empty(&ctx->iopoll_list)))
 				sqt_spin = true;
 		if (io_sq_tw(&retry_list, IORING_TW_CAP_ENTRIES_VALUE))
 			sqt_spin = true;
-		list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
+		list_for_each_entry(ctx, &sqd->ctx_list, sqd_list) {
-			if (io_napi(ctx))
+			if (io_napi(ctx)) {
+				io_sq_start_worktime(&ist);
 				io_napi_sqpoll_busy_poll(ctx);
+			}
+		}
+		io_sq_update_worktime(sqd, &ist);
 		if (sqt_spin || !time_after(jiffies, timeout)) {
-			if (sqt_spin) {
+			if (sqt_spin)
-				io_sq_update_worktime(sqd, &start);
 				timeout = jiffies + sqd->sq_thread_idle;
-			}
 			if (unlikely(need_resched())) {
 				mutex_unlock(&sqd->lock);
 				cond_resched();

io_uring/sqpoll.h+1−0

@@ -29,6 +29,7 @@ void io_sq_thread_unpark(struct io_sq_data *sqd); · 28 unmodified lines
29	void io_put_sq_data(struct io_sq_data *sqd);	29	void io_put_sq_data(struct io_sq_data *sqd);
30	void io_sqpoll_wait_sq(struct io_ring_ctx *ctx);	30	void io_sqpoll_wait_sq(struct io_ring_ctx *ctx);
31	int io_sqpoll_wq_cpu_affinity(struct io_ring_ctx *ctx, cpumask_var_t mask);	31	int io_sqpoll_wq_cpu_affinity(struct io_ring_ctx *ctx, cpumask_var_t mask);
		32	u64 io_sq_cpu_usec(struct task_struct *tsk);
32		33
33	static inline struct task_struct sqpoll_task_locked(struct io_sq_data sqd)	34	static inline struct task_struct sqpoll_task_locked(struct io_sq_data sqd)
34	{	35	{

io_uring/waitid.c+1−1

@@ -250,7 +250,7 @@ int io_waitid_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 249 unmodified lines
250	return -EINVAL;	250	return -EINVAL;
251		251
252	iwa = io_uring_alloc_async_data(NULL, req);	252	iwa = io_uring_alloc_async_data(NULL, req);
253	if (!unlikely(iwa))	253	if (unlikely(!iwa))
254	return -ENOMEM;	254	return -ENOMEM;
255	iwa->req = req;	255	iwa->req = req;
256		256

kernel/cgroup/cgroup.c+1−1

@@ -5889,7 +5889,7 @@ static struct cgroup cgroup_create(struct cgroup parent, const char *name, · 5888 unmodified lines
5889	* if the parent has to be frozen, the child has too.	5889	* if the parent has to be frozen, the child has too.
5890	*/	5890	*/
5891	cgrp->freezer.e_freeze = parent->freezer.e_freeze;	5891	cgrp->freezer.e_freeze = parent->freezer.e_freeze;
5892	seqcount_init(&cgrp->freezer.freeze_seq);	5892	seqcount_spinlock_init(&cgrp->freezer.freeze_seq, &css_set_lock);
5893	if (cgrp->freezer.e_freeze) {	5893	if (cgrp->freezer.e_freeze) {
5894	/*	5894	/*
5895	* Set the CGRP_FREEZE flag, so when a process will be	5895	* Set the CGRP_FREEZE flag, so when a process will be

kernel/dma/debug.c+4−1

 #include <linux/ctype.h>
 #include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/swiotlb.h>
 #include <asm/sections.h>
 #include "debug.h"
 	if (rc == -ENOMEM) {
 		pr_err_once("cacheline tracking ENOMEM, dma-debug disabled\n");
 		global_disable = true;
-	} else if (rc == -EEXIST && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) {
+	} else if (rc == -EEXIST && !(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
+		   !(IS_ENABLED(CONFIG_DMA_BOUNCE_UNALIGNED_KMALLOC) &&
+		     is_swiotlb_active(entry->dev))) {
 		err_printk(entry->dev, entry,
 			"cacheline tracking EEXIST, overlapping mappings aren't supported\n");
 	}

kernel/irq/chip.c+1−1

@@ -1030,7 +1030,7 @@ __irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle, · 1029 unmodified lines
1030	void __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,	1030	void __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
1031	const char *name)	1031	const char *name)
1032	{	1032	{
1033	scoped_irqdesc_get_and_lock(irq, 0)	1033	scoped_irqdesc_get_and_buslock(irq, 0)
1034	__irq_do_set_handler(scoped_irqdesc, handle, is_chained, name);	1034	__irq_do_set_handler(scoped_irqdesc, handle, is_chained, name);
1035	}	1035	}
1036	EXPORT_SYMBOL_GPL(__irq_set_handler);	1036	EXPORT_SYMBOL_GPL(__irq_set_handler);

kernel/irq/manage.c+2−2

@@ -659,7 +659,7 @@ void __disable_irq(struct irq_desc *desc) · 658 unmodified lines
659		659
660	static int __disable_irq_nosync(unsigned int irq)	660	static int __disable_irq_nosync(unsigned int irq)
661	{	661	{
662	scoped_irqdesc_get_and_lock(irq, IRQ_GET_DESC_CHECK_GLOBAL) {	662	scoped_irqdesc_get_and_buslock(irq, IRQ_GET_DESC_CHECK_GLOBAL) {
663	__disable_irq(scoped_irqdesc);	663	__disable_irq(scoped_irqdesc);
664	return 0;	664	return 0;
665	}	665	}
@@ -789,7 +789,7 @@ void __enable_irq(struct irq_desc *desc) · 123 unmodified lines
789	*/	789	*/
790	void enable_irq(unsigned int irq)	790	void enable_irq(unsigned int irq)
791	{	791	{
792	scoped_irqdesc_get_and_lock(irq, IRQ_GET_DESC_CHECK_GLOBAL) {	792	scoped_irqdesc_get_and_buslock(irq, IRQ_GET_DESC_CHECK_GLOBAL) {
793	struct irq_desc *desc = scoped_irqdesc;	793	struct irq_desc *desc = scoped_irqdesc;
794		794
795	if (WARN(!desc->irq_data.chip, "enable_irq before setup/request_irq: irq %u\n", irq))	795	if (WARN(!desc->irq_data.chip, "enable_irq before setup/request_irq: irq %u\n", irq))

kernel/sched/fair.c+12−0

 	cfs_rq->throttle_count = pcfs_rq->throttle_count;
 	cfs_rq->throttled_clock_pelt = rq_clock_pelt(cpu_rq(cpu));
+	/*
+	 * It is not enough to sync the "pelt_clock_throttled" indicator
+	 * with the parent cfs_rq when the hierarchy is not queued.
+	 * Always join a throttled hierarchy with PELT clock throttled
+	 * and leaf it to the first enqueue, or distribution to
+	 * unthrottle the PELT clock.
+	 */
+	if (cfs_rq->throttle_count)
+		cfs_rq->pelt_clock_throttled = 1;
 }
 /* conditionally throttle active cfs_rq's from put_prev_entity() */
 		if (!cfs_rq_pelt_clock_throttled(cfs_rq))
 			list_add_leaf_cfs_rq(cfs_rq);
 	}
+	assert_list_leaf_cfs_rq(rq_of(cfs_rq));
 }
 #else /* !CONFIG_FAIR_GROUP_SCHED: */
 static void propagate_entity_cfs_rq(struct sched_entity *se) { }

kernel/sched/sched.h+0−2

 			     struct mm_struct *mm)
 {
 	struct mm_cid __percpu *pcpu_cid = mm->pcpu_cid;
-	struct cpumask *cpumask;
 	int cid;
 	lockdep_assert_rq_held(rq);
-	cpumask = mm_cidmask(mm);
 	cid = __this_cpu_read(pcpu_cid->cid);
 	if (mm_cid_is_valid(cid)) {
 		mm_cid_snapshot_time(rq, mm);

kernel/time/timekeeping.c+1−1

@@ -3070,7 +3070,7 @@ static int __init tk_aux_sysfs_init(void) · 3069 unmodified lines
3070	return -ENOMEM;	3070	return -ENOMEM;
3071	}	3071	}
3072		3072
3073	for (int i = 0; i <= MAX_AUX_CLOCKS; i++) {	3073	for (int i = 0; i < MAX_AUX_CLOCKS; i++) {
3074	char id[2] = { [0] = '0' + i, };	3074	char id[2] = { [0] = '0' + i, };
3075	struct kobject *clk = kobject_create_and_add(id, auxo);	3075	struct kobject *clk = kobject_create_and_add(id, auxo);
3076		3076

kernel/trace/rv/monitors/pagefault/Kconfig+1−0

@@ -5,6 +5,7 @@ config RV_MON_PAGEFAULT · 4 unmodified lines
5	select RV_LTL_MONITOR	5	select RV_LTL_MONITOR
6	depends on RV_MON_RTAPP	6	depends on RV_MON_RTAPP
7	depends on X86 \|\| RISCV	7	depends on X86 \|\| RISCV
		8	depends on MMU
8	default y	9	default y
9	select LTL_MON_EVENTS_ID	10	select LTL_MON_EVENTS_ID
10	bool "pagefault monitor"	11	bool "pagefault monitor"

kernel/trace/rv/rv.c+6−6

@@ -501,7 +501,7 @@ static void enabled_monitors_next(struct seq_file m, void p, loff_t pos) · 500 unmodified lines
501		501
502	list_for_each_entry_continue(mon, &rv_monitors_list, list) {	502	list_for_each_entry_continue(mon, &rv_monitors_list, list) {
503	if (mon->enabled)	503	if (mon->enabled)
504	return mon;	504	return &mon->list;
505	}	505	}
506		506
507	return NULL;	507	return NULL;
@@ -509,7 +509,7 @@ static void enabled_monitors_next(struct seq_file m, void p, loff_t pos) · 1 unmodified line
509		509
510	static void enabled_monitors_start(struct seq_file m, loff_t *pos)	510	static void enabled_monitors_start(struct seq_file m, loff_t *pos)
511	{	511	{
512	struct rv_monitor *mon;	512	struct list_head *head;
513	loff_t l;	513	loff_t l;
514		514
515	mutex_lock(&rv_interface_lock);	515	mutex_lock(&rv_interface_lock);
@@ -517,15 +517,15 @@ static void enabled_monitors_start(struct seq_file m, loff_t *pos) · 1 unmodified line
517	if (list_empty(&rv_monitors_list))	517	if (list_empty(&rv_monitors_list))
518	return NULL;	518	return NULL;
519		519
520	mon = list_entry(&rv_monitors_list, struct rv_monitor, list);	520	head = &rv_monitors_list;
521		521
522	for (l = 0; l <= *pos; ) {	522	for (l = 0; l <= *pos; ) {
523	mon = enabled_monitors_next(m, mon, &l);	523	head = enabled_monitors_next(m, head, &l);
524	if (!mon)	524	if (!head)
525	break;	525	break;
526	}	526	}
527		527
528	return mon;	528	return head;
529	}	529	}
530		530
531	/*	531	/*

lib/crypto/Kconfig+1−1

@@ -97,7 +97,7 @@ config CRYPTO_LIB_POLY1305 · 96 unmodified lines
97		97
98	config CRYPTO_LIB_POLY1305_ARCH	98	config CRYPTO_LIB_POLY1305_ARCH
99	bool	99	bool
100	depends on CRYPTO_LIB_POLY1305 && !UML	100	depends on CRYPTO_LIB_POLY1305 && !UML && !KMSAN
101	default y if ARM	101	default y if ARM
102	default y if ARM64 && KERNEL_MODE_NEON	102	default y if ARM64 && KERNEL_MODE_NEON
103	default y if MIPS	103	default y if MIPS

mm/damon/core.c+5−2

 	damos_for_each_filter_safe(f, next, s)
 		damos_destroy_filter(f);
+	damos_for_each_ops_filter_safe(f, next, s)
+		damos_destroy_filter(f);
 	kfree(s->migrate_dests.node_id_arr);
 	kfree(s->migrate_dests.weight_arr);
 	damon_del_scheme(s);
 				src_goal->metric, src_goal->target_value);
 		if (!new_goal)
 			return -ENOMEM;
-		damos_commit_quota_goal_union(new_goal, src_goal);
+		damos_commit_quota_goal(new_goal, src_goal);
 		damos_add_quota_goal(dst, new_goal);
 	}
 	return 0;
 	INIT_LIST_HEAD(&control->list);
 	mutex_lock(&ctx->call_controls_lock);
-	list_add_tail(&ctx->call_controls, &control->list);
+	list_add_tail(&control->list, &ctx->call_controls);
 	mutex_unlock(&ctx->call_controls_lock);
 	if (!damon_is_running(ctx))
 		return -EINVAL;

mm/damon/sysfs.c+4−3

 	if (IS_ERR(param_ctx))
 		return PTR_ERR(param_ctx);
 	test_ctx = damon_new_ctx();
+	if (!test_ctx)
+		return -ENOMEM;
 	err = damon_commit_ctx(test_ctx, param_ctx);
-	if (err) {
+	if (err)
-		damon_destroy_ctx(test_ctx);
 		goto out;
-	}
 	err = damon_commit_ctx(kdamond->damon_ctx, param_ctx);
 out:
+	damon_destroy_ctx(test_ctx);
 	damon_destroy_ctx(param_ctx);
 	return err;
 }

mm/huge_memory.c+3−0

@@ -4109,6 +4109,9 @@ static bool thp_underused(struct folio *folio) · 4108 unmodified lines
4109	if (khugepaged_max_ptes_none == HPAGE_PMD_NR - 1)	4109	if (khugepaged_max_ptes_none == HPAGE_PMD_NR - 1)
4110	return false;	4110	return false;
4111		4111
		4112	if (folio_contain_hwpoisoned_page(folio))
		4113	return false;
		4114
4112	for (i = 0; i < folio_nr_pages(folio); i++) {	4115	for (i = 0; i < folio_nr_pages(folio); i++) {
4113	if (pages_identical(folio_page(folio, i), ZERO_PAGE(0))) {	4116	if (pages_identical(folio_page(folio, i), ZERO_PAGE(0))) {
4114	if (++num_zero_pages > khugepaged_max_ptes_none)	4117	if (++num_zero_pages > khugepaged_max_ptes_none)

mm/hugetlb.c+2−3

@@ -7614,13 +7614,12 @@ int huge_pmd_unshare(struct mm_struct mm, struct vm_area_struct vma, · 7613 unmodified lines
7614	p4d_t *p4d = p4d_offset(pgd, addr);	7614	p4d_t *p4d = p4d_offset(pgd, addr);
7615	pud_t *pud = pud_offset(p4d, addr);	7615	pud_t *pud = pud_offset(p4d, addr);
7616		7616
7617	i_mmap_assert_write_locked(vma->vm_file->f_mapping);
7618	hugetlb_vma_assert_locked(vma);
7619	if (sz != PMD_SIZE)	7617	if (sz != PMD_SIZE)
7620	return 0;	7618	return 0;
7621	if (!ptdesc_pmd_is_shared(virt_to_ptdesc(ptep)))	7619	if (!ptdesc_pmd_is_shared(virt_to_ptdesc(ptep)))
7622	return 0;	7620	return 0;
7623		7621	i_mmap_assert_write_locked(vma->vm_file->f_mapping);
		7622	hugetlb_vma_assert_locked(vma);
7624	pud_clear(pud);	7623	pud_clear(pud);
7625	/*	7624	/*
7626	* Once our caller drops the rmap lock, some other process might be	7625	* Once our caller drops the rmap lock, some other process might be

mm/migrate.c+2−1

@@ -301,8 +301,9 @@ static bool try_to_map_unused_to_zeropage(struct page_vma_mapped_walk *pvmw, · 300 unmodified lines
301	struct page *page = folio_page(folio, idx);	301	struct page *page = folio_page(folio, idx);
302	pte_t newpte;	302	pte_t newpte;
303		303
304	if (PageCompound(page))	304	if (PageCompound(page) \|\| PageHWPoison(page))
305	return false;	305	return false;
		306
306	VM_BUG_ON_PAGE(!PageAnon(page), page);	307	VM_BUG_ON_PAGE(!PageAnon(page), page);
307	VM_BUG_ON_PAGE(!PageLocked(page), page);	308	VM_BUG_ON_PAGE(!PageLocked(page), page);
308	VM_BUG_ON_PAGE(pte_present(old_pte), page);	309	VM_BUG_ON_PAGE(pte_present(old_pte), page);

mm/mremap.c+6−9

 }
 /*
- * Perform final tasks for MADV_DONTUNMAP operation, clearing mlock() and
+ * Perform final tasks for MADV_DONTUNMAP operation, clearing mlock() flag on
- * account flags on remaining VMA by convention (it cannot be mlock()'d any
+ * remaining VMA by convention (it cannot be mlock()'d any longer, as pages in
- * longer, as pages in range are no longer mapped), and removing anon_vma_chain
+ * range are no longer mapped), and removing anon_vma_chain links from it if the
- * links from it (if the entire VMA was copied over).
+ * entire VMA was copied over.
  */
 static void dontunmap_complete(struct vma_remap_struct *vrm,
 			       struct vm_area_struct *new_vma)
 	unsigned long old_start = vrm->vma->vm_start;
 	unsigned long old_end = vrm->vma->vm_end;
-	/*
+	/* We always clear VM_LOCKED[ONFAULT] on the old VMA. */
-	 * We always clear VM_LOCKED[ONFAULT] | VM_ACCOUNT on the old
+	vm_flags_clear(vrm->vma, VM_LOCKED_MASK);
-	 * vma.
-	 */
-	vm_flags_clear(vrm->vma, VM_LOCKED_MASK | VM_ACCOUNT);
 	/*
 	 * anon_vma links of the old vma is no longer needed after its page

mm/page_owner.c+3−0

@@ -168,6 +168,9 @@ static void add_stack_record_to_list(struct stack_record *stack_record, · 167 unmodified lines
168	unsigned long flags;	168	unsigned long flags;
169	struct stack *stack;	169	struct stack *stack;
170		170
		171	if (!gfpflags_allow_spinning(gfp_mask))
		172	return;
		173
171	set_current_in_page_owner();	174	set_current_in_page_owner();
172	stack = kmalloc(sizeof(*stack), gfp_nested_mask(gfp_mask));	175	stack = kmalloc(sizeof(*stack), gfp_nested_mask(gfp_mask));
173	if (!stack) {	176	if (!stack) {

mm/slub.c+21−10

 	}
 }
-static inline void mark_failed_objexts_alloc(struct slab *slab)
+static inline bool mark_failed_objexts_alloc(struct slab *slab)
 {
-	slab->obj_exts = OBJEXTS_ALLOC_FAIL;
+	return cmpxchg(&slab->obj_exts, 0, OBJEXTS_ALLOC_FAIL) == 0;
 }
 static inline void handle_failed_objexts_alloc(unsigned long obj_exts,
 #else /* CONFIG_MEM_ALLOC_PROFILING_DEBUG */
 static inline void mark_objexts_empty(struct slabobj_ext *obj_exts) {}
-static inline void mark_failed_objexts_alloc(struct slab *slab) {}
+static inline bool mark_failed_objexts_alloc(struct slab *slab) { return false; }
 static inline void handle_failed_objexts_alloc(unsigned long obj_exts,
 			struct slabobj_ext *vec, unsigned int objects) {}
 				   slab_nid(slab));
 	}
 	if (!vec) {
-		/* Mark vectors which failed to allocate */
+		/*
-		mark_failed_objexts_alloc(slab);
+		 * Try to mark vectors which failed to allocate.
+		 * If this operation fails, there may be a racing process
+		 * that has already completed the allocation.
+		 */
+		if (!mark_failed_objexts_alloc(slab) &&
+		    slab_obj_exts(slab))
+			return 0;
 		return -ENOMEM;
 	}
 #ifdef CONFIG_MEMCG
 	new_exts |= MEMCG_DATA_OBJEXTS;
 #endif
+retry:
 	old_exts = READ_ONCE(slab->obj_exts);
 	handle_failed_objexts_alloc(old_exts, vec, objects);
 	if (new_slab) {
 		 * be simply assigned.
 		 */
 		slab->obj_exts = new_exts;
-	} else if ((old_exts & ~OBJEXTS_FLAGS_MASK) ||
+	} else if (old_exts & ~OBJEXTS_FLAGS_MASK) {
-		   cmpxchg(&slab->obj_exts, old_exts, new_exts) != old_exts) {
 		/*
 		 * If the slab is already in use, somebody can allocate and
 		 * assign slabobj_exts in parallel. In this case the existing
 		else
 			kfree(vec);
 		return 0;
+	} else if (cmpxchg(&slab->obj_exts, old_exts, new_exts) != old_exts) {
+		/* Retry if a racing thread changed slab->obj_exts from under us. */
+		goto retry;
 	}
 	if (allow_spin)
 	if (!allow_spin && !spin_trylock_irqsave(&n->list_lock, flags)) {
 		/* Unlucky, discard newly allocated slab */
-		slab->frozen = 1;
 		defer_deactivate_slab(slab, NULL);
 		return NULL;
 	}
 		struct slab *slab = container_of(pos, struct slab, llnode);
 #ifdef CONFIG_SLUB_TINY
-		discard_slab(slab->slab_cache, slab);
+		free_slab(slab->slab_cache, slab);
 #else
-		deactivate_slab(slab->slab_cache, slab, slab->flush_freelist);
+		if (slab->frozen)
+			deactivate_slab(slab->slab_cache, slab, slab->flush_freelist);
+		else
+			free_slab(slab->slab_cache, slab);
 #endif
 	}
 }

net/core/datagram.c+34−10

 EXPORT_SYMBOL(skb_copy_and_csum_datagram_msg);
 /**
- * 	datagram_poll - generic datagram poll
+ *	datagram_poll_queue - same as datagram_poll, but on a specific receive
+ *		queue
  *	@file: file struct
  *	@sock: socket
  *	@wait: poll table
+ *	@rcv_queue: receive queue to poll
  *
- *	Datagram poll: Again totally generic. This also handles
+ *	Performs polling on the given receive queue, handling shutdown, error,
- *	sequenced packet sockets providing the socket receive queue
+ *	and connection state. This is useful for protocols that deliver
- *	is only ever holding data ready to receive.
+ *	userspace-bound packets through a custom queue instead of
+ *	sk->sk_receive_queue.
  *
- *	Note: when you *don't* use this routine for this protocol,
+ *	Return: poll bitmask indicating the socket's current state
- *	and you use a different write policy from sock_writeable()
- *	then please supply your own write_space callback.
  */
-__poll_t datagram_poll(struct file *file, struct socket *sock,
+__poll_t datagram_poll_queue(struct file *file, struct socket *sock,
-			   poll_table *wait)
+			     poll_table *wait, struct sk_buff_head *rcv_queue)
 {
 	struct sock *sk = sock->sk;
 	__poll_t mask;
 		mask |= EPOLLHUP;
 	/* readable? */
-	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
+	if (!skb_queue_empty_lockless(rcv_queue))
 		mask |= EPOLLIN | EPOLLRDNORM;
 	/* Connection-based need to check for termination and startup */
 	return mask;
 }
+EXPORT_SYMBOL(datagram_poll_queue);
+/**
+ *	datagram_poll - generic datagram poll
+ *	@file: file struct
+ *	@sock: socket
+ *	@wait: poll table
+ *
+ *	Datagram poll: Again totally generic. This also handles
+ *	sequenced packet sockets providing the socket receive queue
+ *	is only ever holding data ready to receive.
+ *
+ *	Note: when you *don't* use this routine for this protocol,
+ *	and you use a different write policy from sock_writeable()
+ *	then please supply your own write_space callback.
+ *
+ *	Return: poll bitmask indicating the socket's current state
+ */
+__poll_t datagram_poll(struct file *file, struct socket *sock, poll_table *wait)
+{
+	return datagram_poll_queue(file, sock, wait,
+				   &sock->sk->sk_receive_queue);
+}
 EXPORT_SYMBOL(datagram_poll);

net/core/gro.c+8−2

@@ -639,6 +639,8 @@ EXPORT_SYMBOL(gro_receive_skb); · 638 unmodified lines
639		639
640	static void napi_reuse_skb(struct napi_struct napi, struct sk_buff skb)	640	static void napi_reuse_skb(struct napi_struct napi, struct sk_buff skb)
641	{	641	{
		642	struct skb_shared_info *shinfo;
		643
642	if (unlikely(skb->pfmemalloc)) {	644	if (unlikely(skb->pfmemalloc)) {
643	consume_skb(skb);	645	consume_skb(skb);
644	return;	646	return;
@@ -655,8 +657,12 @@ static void napi_reuse_skb(struct napi_struct napi, struct sk_buff skb) · 10 unmodified lines
655		657
656	skb->encapsulation = 0;	658	skb->encapsulation = 0;
657	skb->ip_summed = CHECKSUM_NONE;	659	skb->ip_summed = CHECKSUM_NONE;
658	skb_shinfo(skb)->gso_type = 0;	660
659	skb_shinfo(skb)->gso_size = 0;	661	shinfo = skb_shinfo(skb);
		662	shinfo->gso_type = 0;
		663	shinfo->gso_size = 0;
		664	shinfo->hwtstamps.hwtstamp = 0;
		665
660	if (unlikely(skb->slow_gro)) {	666	if (unlikely(skb->slow_gro)) {
661	skb_orphan(skb);	667	skb_orphan(skb);
662	skb_ext_reset(skb);	668	skb_ext_reset(skb);

net/core/gro_cells.c+2−3

 	if (skb_queue_len(&cell->napi_skbs) == 1)
 		napi_schedule(&cell->napi);
-	if (have_bh_lock)
-		local_unlock_nested_bh(&gcells->cells->bh_lock);
 	res = NET_RX_SUCCESS;
 unlock:
+	if (have_bh_lock)
+		local_unlock_nested_bh(&gcells->cells->bh_lock);
 	rcu_read_unlock();
 	return res;
 }

net/core/rtnetlink.c+0−3

@@ -4715,9 +4715,6 @@ static int rtnl_fdb_del(struct sk_buff skb, struct nlmsghdr nlh, · 4714 unmodified lines
4715	int err;	4715	int err;
4716	u16 vid;	4716	u16 vid;
4717		4717
4718	if (!netlink_capable(skb, CAP_NET_ADMIN))
4719	return -EPERM;
4720
4721	if (!del_bulk) {	4718	if (!del_bulk) {
4722	err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,	4719	err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,
4723	NULL, extack);	4720	NULL, extack);

net/hsr/hsr_netlink.c+7−1

 		       struct netlink_ext_ack *extack)
 {
 	struct net *link_net = rtnl_newlink_link_net(params);
+	struct net_device *link[2], *interlink = NULL;
 	struct nlattr **data = params->data;
 	enum hsr_version proto_version;
 	unsigned char multicast_spec;
 	u8 proto = HSR_PROTOCOL_HSR;
-	struct net_device *link[2], *interlink = NULL;
+	if (!net_eq(link_net, dev_net(dev))) {
+		NL_SET_ERR_MSG_MOD(extack,
+				   "HSR slaves/interlink must be on the same net namespace than HSR link");
+		return -EINVAL;
+	}
 	if (!data) {
 		NL_SET_ERR_MSG_MOD(extack, "No slave devices specified");
 		return -EINVAL;

net/mptcp/pm_kernel.c+6−0

 	}
 subflow:
+	/* No need to try establishing subflows to remote id0 if not allowed */
+	if (mptcp_pm_add_addr_c_flag_case(msk))
+		goto exit;
 	/* check if should create a new subflow */
 	while (msk->pm.local_addr_used < endp_subflow_max &&
 	       msk->pm.extra_subflows < limit_extra_subflows) {
 			__mptcp_subflow_connect(sk, &local, &addrs[i]);
 		spin_lock_bh(&msk->pm.lock);
 	}
+exit:
 	mptcp_pm_nl_check_work_pending(msk);
 }

net/sctp/inqueue.c+7−6

 				chunk->head_skb = chunk->skb;
 			/* skbs with "cover letter" */
-			if (chunk->head_skb && chunk->skb->data_len == chunk->skb->len)
+			if (chunk->head_skb && chunk->skb->data_len == chunk->skb->len) {
+				if (WARN_ON(!skb_shinfo(chunk->skb)->frag_list)) {
+					__SCTP_INC_STATS(dev_net(chunk->skb->dev),
+							 SCTP_MIB_IN_PKT_DISCARDS);
+					sctp_chunk_free(chunk);
+					goto next_chunk;
+				}
 				chunk->skb = skb_shinfo(chunk->skb)->frag_list;
-			if (WARN_ON(!chunk->skb)) {
-				__SCTP_INC_STATS(dev_net(chunk->skb->dev), SCTP_MIB_IN_PKT_DISCARDS);
-				sctp_chunk_free(chunk);
-				goto next_chunk;
 			}
 		}

net/smc/smc_inet.c+0−13

 	.protocol	= IPPROTO_SMC,
 	.prot		= &smc_inet_prot,
 	.ops		= &smc_inet_stream_ops,
-	.flags		= INET_PROTOSW_ICSK,
 };
 #if IS_ENABLED(CONFIG_IPV6)
 	.protocol	= IPPROTO_SMC,
 	.prot		= &smc_inet6_prot,
 	.ops		= &smc_inet6_stream_ops,
-	.flags		= INET_PROTOSW_ICSK,
 };
 #endif /* CONFIG_IPV6 */
-static unsigned int smc_sync_mss(struct sock *sk, u32 pmtu)
-{
-	/* No need pass it through to clcsock, mss can always be set by
-	 * sock_create_kern or smc_setsockopt.
-	 */
-	return 0;
-}
 static int smc_inet_init_sock(struct sock *sk)
 {
 	struct net *net = sock_net(sk);
 	/* init common smc sock */
 	smc_sk_init(net, sk, IPPROTO_SMC);
-	inet_csk(sk)->icsk_sync_mss = smc_sync_mss;
 	/* create clcsock */
 	return smc_create_clcsk(net, sk, sk->sk_family);
 }

net/vmw_vsock/af_vsock.c+19−19

 		goto err;
 	}
-	if (vsk->transport) {
+	if (vsk->transport && vsk->transport == new_transport) {
-		if (vsk->transport == new_transport) {
+		ret = 0;
-			ret = 0;
+		goto err;
-			goto err;
+	}
-		}
+	/* We increase the module refcnt to prevent the transport unloading
+	 * while there are open sockets assigned to it.
+	 */
+	if (!new_transport || !try_module_get(new_transport->module)) {
+		ret = -ENODEV;
+		goto err;
+	}
+	/* It's safe to release the mutex after a successful try_module_get().
+	 * Whichever transport `new_transport` points at, it won't go away until
+	 * the last module_put() below or in vsock_deassign_transport().
+	 */
+	mutex_unlock(&vsock_register_mutex);
+	if (vsk->transport) {
 		/* transport->release() must be called with sock lock acquired.
 		 * This path can only be taken during vsock_connect(), where we
 		 * have already held the sock lock. In the other cases, this
 		vsk->peer_shutdown = 0;
 	}
-	/* We increase the module refcnt to prevent the transport unloading
-	 * while there are open sockets assigned to it.
-	 */
-	if (!new_transport || !try_module_get(new_transport->module)) {
-		ret = -ENODEV;
-		goto err;
-	}
-	/* It's safe to release the mutex after a successful try_module_get().
-	 * Whichever transport `new_transport` points at, it won't go away until
-	 * the last module_put() below or in vsock_deassign_transport().
-	 */
-	mutex_unlock(&vsock_register_mutex);
 	if (sk->sk_type == SOCK_SEQPACKET) {
 		if (!new_transport->seqpacket_allow ||
 		    !new_transport->seqpacket_allow(remote_cid)) {

net/xfrm/espintcp.c+1−5

 static __poll_t espintcp_poll(struct file *file, struct socket *sock,
 			      poll_table *wait)
 {
-	__poll_t mask = datagram_poll(file, sock, wait);
 	struct sock *sk = sock->sk;
 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
-	if (!skb_queue_empty(&ctx->ike_queue))
+	return datagram_poll_queue(file, sock, wait, &ctx->ike_queue);
-		mask |= EPOLLIN | EPOLLRDNORM;
-	return mask;
 }
 static void build_protos(struct proto *espintcp_prot,

rust/kernel/auxiliary.rs+1−7

     /// Returns a reference to the parent [`device::Device`], if any.
     pub fn parent(&self) -> Option<&device::Device> {
-        let ptr: *const Self = self;
+        self.as_ref().parent()
-        // CAST: `Device<Ctx: DeviceContext>` types are transparent to each other.
-        let ptr: *const Device = ptr.cast();
-        // SAFETY: `ptr` was derived from `&self`.
-        let this = unsafe { &*ptr };
-        this.as_ref().parent()
     }
 }

rust/kernel/device.rs+2−2

@@ -251,7 +251,7 @@ impl<Ctx: DeviceContext> Device<Ctx> { · 250 unmodified lines
251		251
252	/// Returns a reference to the parent device, if any.	252	/// Returns a reference to the parent device, if any.
253	#[cfg_attr(not(CONFIG_AUXILIARY_BUS), expect(dead_code))]	253	#[cfg_attr(not(CONFIG_AUXILIARY_BUS), expect(dead_code))]
254	pub(crate) fn parent(&self) -> Option<&Self> {	254	pub(crate) fn parent(&self) -> Option<&Device> {
255	// SAFETY:	255	// SAFETY:
256	// - By the type invariant `self.as_raw()` is always valid.	256	// - By the type invariant `self.as_raw()` is always valid.
257	// - The parent device is only ever set at device creation.	257	// - The parent device is only ever set at device creation.
@@ -264,7 +264,7 @@ impl<Ctx: DeviceContext> Device<Ctx> { · 6 unmodified lines
264	// - Since `parent` is not NULL, it must be a valid pointer to a `struct device`.	264	// - Since `parent` is not NULL, it must be a valid pointer to a `struct device`.
265	// - `parent` is valid for the lifetime of `self`, since a `struct device` holds a	265	// - `parent` is valid for the lifetime of `self`, since a `struct device` holds a
266	// reference count of its parent.	266	// reference count of its parent.
267	Some(unsafe { Self::from_raw(parent) })	267	Some(unsafe { Device::from_raw(parent) })
268	}	268	}
269	}	269	}
270		270

scripts/Makefile.extrawarn+3−1

 KBUILD_CFLAGS-$(CONFIG_CC_NO_ARRAY_BOUNDS) += -Wno-array-bounds
 ifdef CONFIG_CC_IS_CLANG
-# The kernel builds with '-std=gnu11' so use of GNU extensions is acceptable.
+# The kernel builds with '-std=gnu11' and '-fms-extensions' so use of GNU and
+# Microsoft extensions is acceptable.
 KBUILD_CFLAGS += -Wno-gnu
+KBUILD_CFLAGS += -Wno-microsoft-anon-tag
 # Clang checks for overflow/truncation with '%p', while GCC does not:
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111219

tools/objtool/check.c+3−2

 	 * these come from the Rust standard library).
 	 */
 	return str_ends_with(func->name, "_4core5sliceSp15copy_from_slice17len_mismatch_fail")		||
+	       str_ends_with(func->name, "_4core6option13expect_failed")				||
 	       str_ends_with(func->name, "_4core6option13unwrap_failed")				||
 	       str_ends_with(func->name, "_4core6result13unwrap_failed")				||
 	       str_ends_with(func->name, "_4core9panicking5panic")					||
 		for_each_reloc(sec->rsec, reloc) {
 			if (arch_absolute_reloc(file->elf, reloc)) {
-				WARN("section %s has absolute relocation at offset 0x%lx",
+				WARN("section %s has absolute relocation at offset 0x%llx",
-				     sec->name, reloc_offset(reloc));
+				     sec->name, (unsigned long long)reloc_offset(reloc));
 				ret++;
 			}
 		}

tools/testing/selftests/cgroup/lib/include/cgroup_util.h+20−0

@@ -25,6 +25,26 @@ static inline int values_close(long a, long b, int err) · 24 unmodified lines
25	return labs(a - b) <= (a + b) / 100 * err;	25	return labs(a - b) <= (a + b) / 100 * err;
26	}	26	}
27		27
		28	/*
		29	* Checks if two given values differ by less than err% of their sum and assert
		30	* with detailed debug info if not.
		31	*/
		32	static inline int values_close_report(long a, long b, int err)
		33	{
		34	long diff = labs(a - b);
		35	long limit = (a + b) / 100 * err;
		36	double actual_err = (a + b) ? (100.0 * diff / (a + b)) : 0.0;
		37	int close = diff <= limit;
		38
		39	if (!close)
		40	fprintf(stderr,
		41	"[FAIL] actual=%ld expected=%ld \| diff=%ld \| limit=%ld \| "
		42	"tolerance=%d%% \| actual_error=%.2f%%\n",
		43	a, b, diff, limit, err, actual_err);
		44
		45	return close;
		46	}
		47
28	extern ssize_t read_text(const char path, char buf, size_t max_len);	48	extern ssize_t read_text(const char path, char buf, size_t max_len);
29	extern ssize_t write_text(const char path, char buf, ssize_t len);	49	extern ssize_t write_text(const char path, char buf, ssize_t len);
30		50

tools/testing/selftests/cgroup/test_cpu.c+9−9

@@ -219,7 +219,7 @@ static int test_cpucg_stats(const char *root) · 218 unmodified lines
219	if (user_usec <= 0)	219	if (user_usec <= 0)
220	goto cleanup;	220	goto cleanup;
221		221
222	if (!values_close(usage_usec, expected_usage_usec, 1))	222	if (!values_close_report(usage_usec, expected_usage_usec, 1))
223	goto cleanup;	223	goto cleanup;
224		224
225	ret = KSFT_PASS;	225	ret = KSFT_PASS;
@@ -291,7 +291,7 @@ static int test_cpucg_nice(const char *root) · 65 unmodified lines
291		291
292	user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");	292	user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
293	nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");	293	nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");
294	if (!values_close(nice_usec, expected_nice_usec, 1))	294	if (!values_close_report(nice_usec, expected_nice_usec, 1))
295	goto cleanup;	295	goto cleanup;
296		296
297	ret = KSFT_PASS;	297	ret = KSFT_PASS;
@@ -404,7 +404,7 @@ overprovision_validate(const struct cpu_hogger *children, int num_children) · 106 unmodified lines
404	goto cleanup;	404	goto cleanup;
405		405
406	delta = children[i + 1].usage - children[i].usage;	406	delta = children[i + 1].usage - children[i].usage;
407	if (!values_close(delta, children[0].usage, 35))	407	if (!values_close_report(delta, children[0].usage, 35))
408	goto cleanup;	408	goto cleanup;
409	}	409	}
410		410
@@ -444,7 +444,7 @@ underprovision_validate(const struct cpu_hogger *children, int num_children) · 33 unmodified lines
444	int ret = KSFT_FAIL, i;	444	int ret = KSFT_FAIL, i;
445		445
446	for (i = 0; i < num_children - 1; i++) {	446	for (i = 0; i < num_children - 1; i++) {
447	if (!values_close(children[i + 1].usage, children[0].usage, 15))	447	if (!values_close_report(children[i + 1].usage, children[0].usage, 15))
448	goto cleanup;	448	goto cleanup;
449	}	449	}
450		450
@@ -573,16 +573,16 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned) · 122 unmodified lines
573		573
574	nested_leaf_usage = leaf[1].usage + leaf[2].usage;	574	nested_leaf_usage = leaf[1].usage + leaf[2].usage;
575	if (overprovisioned) {	575	if (overprovisioned) {
576	if (!values_close(leaf[0].usage, nested_leaf_usage, 15))	576	if (!values_close_report(leaf[0].usage, nested_leaf_usage, 15))
577	goto cleanup;	577	goto cleanup;
578	} else if (!values_close(leaf[0].usage * 2, nested_leaf_usage, 15))	578	} else if (!values_close_report(leaf[0].usage * 2, nested_leaf_usage, 15))
579	goto cleanup;	579	goto cleanup;
580		580
581		581
582	child_usage = cg_read_key_long(child, "cpu.stat", "usage_usec");	582	child_usage = cg_read_key_long(child, "cpu.stat", "usage_usec");
583	if (child_usage <= 0)	583	if (child_usage <= 0)
584	goto cleanup;	584	goto cleanup;
585	if (!values_close(child_usage, nested_leaf_usage, 1))	585	if (!values_close_report(child_usage, nested_leaf_usage, 1))
586	goto cleanup;	586	goto cleanup;
587		587
588	ret = KSFT_PASS;	588	ret = KSFT_PASS;
@@ -691,7 +691,7 @@ static int test_cpucg_max(const char *root) · 102 unmodified lines
691	expected_usage_usec	691	expected_usage_usec
692	= n_periods * quota_usec + MIN(remainder_usec, quota_usec);	692	= n_periods * quota_usec + MIN(remainder_usec, quota_usec);
693		693
694	if (!values_close(usage_usec, expected_usage_usec, 10))	694	if (!values_close_report(usage_usec, expected_usage_usec, 10))
695	goto cleanup;	695	goto cleanup;
696		696
697	ret = KSFT_PASS;	697	ret = KSFT_PASS;
@@ -762,7 +762,7 @@ static int test_cpucg_max_nested(const char *root) · 64 unmodified lines
762	expected_usage_usec	762	expected_usage_usec
763	= n_periods * quota_usec + MIN(remainder_usec, quota_usec);	763	= n_periods * quota_usec + MIN(remainder_usec, quota_usec);
764		764
765	if (!values_close(usage_usec, expected_usage_usec, 10))	765	if (!values_close_report(usage_usec, expected_usage_usec, 10))
766	goto cleanup;	766	goto cleanup;
767		767
768	ret = KSFT_PASS;	768	ret = KSFT_PASS;

tools/testing/selftests/net/mptcp/mptcp_join.sh+9−9

@@ -2324,7 +2324,7 @@ laminar_endp_tests() · 2323 unmodified lines
2324	{	2324	{
2325	# no laminar endpoints: routing rules are used	2325	# no laminar endpoints: routing rules are used
2326	if reset_with_tcp_filter "without a laminar endpoint" ns1 10.0.2.2 REJECT &&	2326	if reset_with_tcp_filter "without a laminar endpoint" ns1 10.0.2.2 REJECT &&
2327	mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then	2327	continue_if mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then
2328	pm_nl_set_limits $ns1 0 2	2328	pm_nl_set_limits $ns1 0 2
2329	pm_nl_set_limits $ns2 2 2	2329	pm_nl_set_limits $ns2 2 2
2330	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	2330	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -2336,7 +2336,7 @@ laminar_endp_tests() · 5 unmodified lines
2336		2336
2337	# laminar endpoints: this endpoint is used	2337	# laminar endpoints: this endpoint is used
2338	if reset_with_tcp_filter "with a laminar endpoint" ns1 10.0.2.2 REJECT &&	2338	if reset_with_tcp_filter "with a laminar endpoint" ns1 10.0.2.2 REJECT &&
2339	mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then	2339	continue_if mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then
2340	pm_nl_set_limits $ns1 0 2	2340	pm_nl_set_limits $ns1 0 2
2341	pm_nl_set_limits $ns2 2 2	2341	pm_nl_set_limits $ns2 2 2
2342	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	2342	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -2348,7 +2348,7 @@ laminar_endp_tests() · 5 unmodified lines
2348		2348
2349	# laminar endpoints: these endpoints are used	2349	# laminar endpoints: these endpoints are used
2350	if reset_with_tcp_filter "with multiple laminar endpoints" ns1 10.0.2.2 REJECT &&	2350	if reset_with_tcp_filter "with multiple laminar endpoints" ns1 10.0.2.2 REJECT &&
2351	mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then	2351	continue_if mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then
2352	pm_nl_set_limits $ns1 0 2	2352	pm_nl_set_limits $ns1 0 2
2353	pm_nl_set_limits $ns2 2 2	2353	pm_nl_set_limits $ns2 2 2
2354	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	2354	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -2363,7 +2363,7 @@ laminar_endp_tests() · 8 unmodified lines
2363		2363
2364	# laminar endpoints: only one endpoint is used	2364	# laminar endpoints: only one endpoint is used
2365	if reset_with_tcp_filter "single laminar endpoint" ns1 10.0.2.2 REJECT &&	2365	if reset_with_tcp_filter "single laminar endpoint" ns1 10.0.2.2 REJECT &&
2366	mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then	2366	continue_if mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then
2367	pm_nl_set_limits $ns1 0 2	2367	pm_nl_set_limits $ns1 0 2
2368	pm_nl_set_limits $ns2 2 2	2368	pm_nl_set_limits $ns2 2 2
2369	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	2369	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -2376,7 +2376,7 @@ laminar_endp_tests() · 6 unmodified lines
2376		2376
2377	# laminar endpoints: subflow and laminar flags	2377	# laminar endpoints: subflow and laminar flags
2378	if reset_with_tcp_filter "sublow + laminar endpoints" ns1 10.0.2.2 REJECT &&	2378	if reset_with_tcp_filter "sublow + laminar endpoints" ns1 10.0.2.2 REJECT &&
2379	mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then	2379	continue_if mptcp_lib_kallsyms_has "mptcp_pm_get_endp_laminar_max$"; then
2380	pm_nl_set_limits $ns1 0 4	2380	pm_nl_set_limits $ns1 0 4
2381	pm_nl_set_limits $ns2 2 4	2381	pm_nl_set_limits $ns2 2 4
2382	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	2382	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -3939,7 +3939,7 @@ endpoint_tests() · 1556 unmodified lines
3939	# subflow_rebuild_header is needed to support the implicit flag	3939	# subflow_rebuild_header is needed to support the implicit flag
3940	# userspace pm type prevents add_addr	3940	# userspace pm type prevents add_addr
3941	if reset "implicit EP" &&	3941	if reset "implicit EP" &&
3942	mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then	3942	continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then
3943	pm_nl_set_limits $ns1 2 2	3943	pm_nl_set_limits $ns1 2 2
3944	pm_nl_set_limits $ns2 2 2	3944	pm_nl_set_limits $ns2 2 2
3945	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal	3945	pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
@@ -3964,7 +3964,7 @@ endpoint_tests() · 18 unmodified lines
3964	fi	3964	fi
3965		3965
3966	if reset_with_tcp_filter "delete and re-add" ns2 10.0.3.2 REJECT OUTPUT &&	3966	if reset_with_tcp_filter "delete and re-add" ns2 10.0.3.2 REJECT OUTPUT &&
3967	mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then	3967	continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then
3968	start_events	3968	start_events
3969	pm_nl_set_limits $ns1 0 3	3969	pm_nl_set_limits $ns1 0 3
3970	pm_nl_set_limits $ns2 0 3	3970	pm_nl_set_limits $ns2 0 3
@@ -4040,7 +4040,7 @@ endpoint_tests() · 69 unmodified lines
4040		4040
4041	# remove and re-add	4041	# remove and re-add
4042	if reset_with_events "delete re-add signal" &&	4042	if reset_with_events "delete re-add signal" &&
4043	mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then	4043	continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then
4044	ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=0	4044	ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=0
4045	pm_nl_set_limits $ns1 0 3	4045	pm_nl_set_limits $ns1 0 3
4046	pm_nl_set_limits $ns2 3 3	4046	pm_nl_set_limits $ns2 3 3
@@ -4115,7 +4115,7 @@ endpoint_tests() · 68 unmodified lines
4115		4115
4116	# flush and re-add	4116	# flush and re-add
4117	if reset_with_tcp_filter "flush re-add" ns2 10.0.3.2 REJECT OUTPUT &&	4117	if reset_with_tcp_filter "flush re-add" ns2 10.0.3.2 REJECT OUTPUT &&
4118	mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then	4118	continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then
4119	pm_nl_set_limits $ns1 0 2	4119	pm_nl_set_limits $ns1 0 2
4120	pm_nl_set_limits $ns2 1 2	4120	pm_nl_set_limits $ns2 1 2
4121	# broadcast IP: no packet for this address will be received on ns1	4121	# broadcast IP: no packet for this address will be received on ns1

tools/testing/selftests/net/sctp_hello.c+2−15

 static int do_client(int argc, char *argv[])
 {
 	struct sockaddr_storage ss;
-	char buf[] = "hello";
 	int csk, ret, len;
 	if (argc < 5) {
 	set_addr(&ss, argv[3], argv[4], &len);
 	ret = connect(csk, (struct sockaddr *)&ss, len);
-	if (ret < 0) {
+	if (ret < 0)
-		printf("failed to connect to peer\n");
 		return -1;
-	}
-	ret = send(csk, buf, strlen(buf) + 1, 0);
+	recv(csk, NULL, 0, 0);
-	if (ret < 0) {
-		printf("failed to send msg %d\n", ret);
-		return -1;
-	}
 	close(csk);
 	return 0;
 {
 	struct sockaddr_storage ss;
 	int lsk, csk, ret, len;
-	char buf[20];
 	if (argc < 2 || (strcmp(argv[1], "server") && strcmp(argv[1], "client"))) {
 		printf("%s server|client ...\n", argv[0]);
 		return -1;
 	}
-	ret = recv(csk, buf, sizeof(buf), 0);
-	if (ret <= 0) {
-		printf("failed to recv msg %d\n", ret);
-		return -1;
-	}
 	close(csk);
 	close(lsk);

tools/testing/selftests/net/sctp_vrf.sh+45−28

 	modprobe sctp_diag
 	setup_ns CLIENT_NS1 CLIENT_NS2 SERVER_NS
-	ip net exec $CLIENT_NS1 sysctl -w net.ipv6.conf.default.accept_dad=0 2>&1 >/dev/null
+	ip net exec $CLIENT_NS1 sysctl -wq net.ipv6.conf.default.accept_dad=0
-	ip net exec $CLIENT_NS2 sysctl -w net.ipv6.conf.default.accept_dad=0 2>&1 >/dev/null
+	ip net exec $CLIENT_NS2 sysctl -wq net.ipv6.conf.default.accept_dad=0
-	ip net exec $SERVER_NS sysctl -w net.ipv6.conf.default.accept_dad=0 2>&1 >/dev/null
+	ip net exec $SERVER_NS sysctl -wq net.ipv6.conf.default.accept_dad=0
 	ip -n $SERVER_NS link add veth1 type veth peer name veth1 netns $CLIENT_NS1
 	ip -n $SERVER_NS link add veth2 type veth peer name veth1 netns $CLIENT_NS2
 }
 cleanup() {
-	ip netns exec $SERVER_NS pkill sctp_hello 2>&1 >/dev/null
+	wait_client $CLIENT_NS1
+	wait_client $CLIENT_NS2
+	stop_server
 	cleanup_ns $CLIENT_NS1 $CLIENT_NS2 $SERVER_NS
 }
-wait_server() {
+start_server() {
 	local IFACE=$1
 	local CNT=0
-	until ip netns exec $SERVER_NS ss -lS src $SERVER_IP:$SERVER_PORT | \
+	ip netns exec $SERVER_NS ./sctp_hello server $AF $SERVER_IP $SERVER_PORT $IFACE &
-		grep LISTEN | grep "$IFACE" 2>&1 >/dev/null; do
+	disown
-		[ $((CNT++)) = "20" ] && { RET=3; return $RET; }
+	until ip netns exec $SERVER_NS ss -SlH | grep -q "$IFACE"; do
+		[ $((CNT++)) -eq 30 ] && { RET=3; return $RET; }
+		sleep 0.1
+	done
+}
+stop_server() {
+	local CNT=0
+	ip netns exec $SERVER_NS pkill sctp_hello
+	while ip netns exec $SERVER_NS ss -SaH | grep -q .; do
+		[ $((CNT++)) -eq 30 ] && break
+		sleep 0.1
+	done
+}
+wait_client() {
+	local CLIENT_NS=$1
+	local CNT=0
+	while ip netns exec $CLIENT_NS ss -SaH | grep -q .; do
+		[ $((CNT++)) -eq 30 ] && break
 		sleep 0.1
 	done
 }
 	local CLIENT_NS=$1
 	local IFACE=$2
-	ip netns exec $SERVER_NS pkill sctp_hello 2>&1 >/dev/null
+	start_server $IFACE || return $RET
-	ip netns exec $SERVER_NS ./sctp_hello server $AF $SERVER_IP \
-		$SERVER_PORT $IFACE 2>&1 >/dev/null &
-	disown
-	wait_server $IFACE || return $RET
 	timeout 3 ip netns exec $CLIENT_NS ./sctp_hello client $AF \
-		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT 2>&1 >/dev/null
+		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT
 	RET=$?
+	wait_client $CLIENT_NS
+	stop_server
 	return $RET
 }
 	local IFACE1=$1
 	local IFACE2=$2
-	ip netns exec $SERVER_NS pkill sctp_hello 2>&1 >/dev/null
+	start_server $IFACE1 || return $RET
-	ip netns exec $SERVER_NS ./sctp_hello server $AF $SERVER_IP \
+	start_server $IFACE2 || return $RET
-		$SERVER_PORT $IFACE1 2>&1 >/dev/null &
-	disown
-	wait_server $IFACE1 || return $RET
-	ip netns exec $SERVER_NS ./sctp_hello server $AF $SERVER_IP \
-		$SERVER_PORT $IFACE2 2>&1 >/dev/null &
-	disown
-	wait_server $IFACE2 || return $RET
 	timeout 3 ip netns exec $CLIENT_NS1 ./sctp_hello client $AF \
-		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT 2>&1 >/dev/null && \
+		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT && \
 	timeout 3 ip netns exec $CLIENT_NS2 ./sctp_hello client $AF \
-		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT 2>&1 >/dev/null
+		$SERVER_IP $SERVER_PORT $CLIENT_IP $CLIENT_PORT
 	RET=$?
+	wait_client $CLIENT_NS1
+	wait_client $CLIENT_NS2
+	stop_server
 	return $RET
 }
 testup() {
-	ip netns exec $SERVER_NS sysctl -w net.sctp.l3mdev_accept=1 2>&1 >/dev/null
+	ip netns exec $SERVER_NS sysctl -wq net.sctp.l3mdev_accept=1
 	echo -n "TEST 01: nobind, connect from client 1, l3mdev_accept=1, Y "
 	do_test $CLIENT_NS1 || { echo "[FAIL]"; return $RET; }
 	echo "[PASS]"
 	do_test $CLIENT_NS2 && { echo "[FAIL]"; return $RET; }
 	echo "[PASS]"
-	ip netns exec $SERVER_NS sysctl -w net.sctp.l3mdev_accept=0 2>&1 >/dev/null
+	ip netns exec $SERVER_NS sysctl -wq net.sctp.l3mdev_accept=0
 	echo -n "TEST 03: nobind, connect from client 1, l3mdev_accept=0, N "
 	do_test $CLIENT_NS1 && { echo "[FAIL]"; return $RET; }
 	echo "[PASS]"
 	do_testx vrf-1 vrf-2 || { echo "[FAIL]"; return $RET; }
 	echo "[PASS]"
-	echo -n "TEST 12: bind vrf-2 & 1 in server, connect from client 1 & 2, N "
+	echo -n "TEST 12: bind vrf-2 & 1 in server, connect from client 1 & 2, Y "
 	do_testx vrf-2 vrf-1 || { echo "[FAIL]"; return $RET; }
 	echo "[PASS]"
 }

@@ -4104,7 +4104,7 @@ void qla4xxx_srb_compl(struct kref *ref) · 4103 unmodified lines
4104	* The mid-level driver tries to ensure that queuecommand never gets	4104	* The mid-level driver tries to ensure that queuecommand never gets
4105	* invoked concurrently with itself or the interrupt handler (although	4105	* invoked concurrently with itself or the interrupt handler (although
4106	* the interrupt handler may call this routine as part of request-	4106	* the interrupt handler may call this routine as part of request-
4107	* completion handling). Unfortunely, it sometimes calls the scheduler	4107	* completion handling). Unfortunately, it sometimes calls the scheduler
4108	* in interrupt context which is a big NO! NO!.	4108	* in interrupt context which is a big NO! NO!.
4109	**/	4109	**/
4110	static int qla4xxx_queuecommand(struct Scsi_Host host, struct scsi_cmnd cmd)	4110	static int qla4xxx_queuecommand(struct Scsi_Host host, struct scsi_cmnd cmd)
@@ -4647,7 +4647,7 @@ static int qla4xxx_cmd_wait(struct scsi_qla_host *ha) · 536 unmodified lines
4647	cmd = scsi_host_find_tag(ha->host, index);	4647	cmd = scsi_host_find_tag(ha->host, index);
4648	/*	4648	/*
4649	* We cannot just check if the index is valid,	4649	* We cannot just check if the index is valid,
4650	* becase if we are run from the scsi eh, then	4650	* because if we are run from the scsi eh, then
4651	* the scsi/block layer is going to prevent	4651	* the scsi/block layer is going to prevent
4652	* the tag from being released.	4652	* the tag from being released.
4653	*/	4653	*/
@@ -4952,7 +4952,7 @@ recover_ha_init_adapter: · 298 unmodified lines
4952	/* Upon successful firmware/chip reset, re-initialize the adapter */	4952	/* Upon successful firmware/chip reset, re-initialize the adapter */
4953	if (status == QLA_SUCCESS) {	4953	if (status == QLA_SUCCESS) {
4954	/* For ISP-4xxx, force function 1 to always initialize	4954	/* For ISP-4xxx, force function 1 to always initialize
4955	* before function 3 to prevent both funcions from	4955	* before function 3 to prevent both functions from
4956	* stepping on top of the other */	4956	* stepping on top of the other */
4957	if (is_qla40XX(ha) && (ha->mac_index == 3))	4957	if (is_qla40XX(ha) && (ha->mac_index == 3))
4958	ssleep(6);	4958	ssleep(6);
@@ -6914,7 +6914,7 @@ static int qla4xxx_sess_conn_setup(struct scsi_qla_host *ha, · 1955 unmodified lines
6914	struct ddb_entry *ddb_entry = NULL;	6914	struct ddb_entry *ddb_entry = NULL;
6915		6915
6916	/* Create session object, with INVALID_ENTRY,	6916	/* Create session object, with INVALID_ENTRY,
6917	* the targer_id would get set when we issue the login	6917	* the target_id would get set when we issue the login
6918	*/	6918	*/
6919	cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, ha->host,	6919	cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, ha->host,
6920	cmds_max, sizeof(struct ddb_entry),	6920	cmds_max, sizeof(struct ddb_entry),