lael-labs/linux

.mailmap+1−0

@@ -102,6 +102,7 @@ Ard Biesheuvel <ardb@kernel.org> <ard.biesheuvel@linaro.org> · 101 unmodified lines
102	Arnaud Patard <arnaud.patard@rtp-net.org>	102	Arnaud Patard <arnaud.patard@rtp-net.org>
103	Arnd Bergmann <arnd@arndb.de>	103	Arnd Bergmann <arnd@arndb.de>
104	Arun Kumar Neelakantam <quic_aneela@quicinc.com> <aneela@codeaurora.org>	104	Arun Kumar Neelakantam <quic_aneela@quicinc.com> <aneela@codeaurora.org>
		105	Asahi Lina <lina+kernel@asahilina.net> <lina@asahilina.net>
105	Ashok Raj Nagarajan <quic_arnagara@quicinc.com> <arnagara@codeaurora.org>	106	Ashok Raj Nagarajan <quic_arnagara@quicinc.com> <arnagara@codeaurora.org>
106	Ashwin Chaugule <quic_ashwinc@quicinc.com> <ashwinc@codeaurora.org>	107	Ashwin Chaugule <quic_ashwinc@quicinc.com> <ashwinc@codeaurora.org>
107	Asutosh Das <quic_asutoshd@quicinc.com> <asutoshd@codeaurora.org>	108	Asutosh Das <quic_asutoshd@quicinc.com> <asutoshd@codeaurora.org>

Documentation/ABI/testing/sysfs-driver-hid-appletb-kbd+2−2

@@ -1,6 +1,6 @@
1	What: /sys/bus/hid/drivers/hid-appletb-kbd/<dev>/mode	1	What: /sys/bus/hid/drivers/hid-appletb-kbd/<dev>/mode
2	Date: September, 2023	2	Date: March, 2025
3	KernelVersion: 6.5	3	KernelVersion: 6.15
4	Contact: linux-input@vger.kernel.org	4	Contact: linux-input@vger.kernel.org
5	Description:	5	Description:
6	The set of keys displayed on the Touch Bar.	6	The set of keys displayed on the Touch Bar.

Documentation/kbuild/reproducible-builds.rst+17−0

@@ -46,6 +46,21 @@ The kernel embeds the building user and host names in · 45 unmodified lines
46	`KBUILD_BUILD_USER and KBUILD_BUILD_HOST`_ variables. If you are	46	`KBUILD_BUILD_USER and KBUILD_BUILD_HOST`_ variables. If you are
47	building from a git commit, you could use its committer address.	47	building from a git commit, you could use its committer address.
48		48
		49	Absolute filenames
		50	------------------
		51
		52	When the kernel is built out-of-tree, debug information may include
		53	absolute filenames for the source files. This must be overridden by
		54	including the ``-fdebug-prefix-map`` option in the `KCFLAGS`_ variable.
		55
		56	Depending on the compiler used, the ``__FILE__`` macro may also expand
		57	to an absolute filename in an out-of-tree build. Kbuild automatically
		58	uses the ``-fmacro-prefix-map`` option to prevent this, if it is
		59	supported.
		60
		61	The Reproducible Builds web site has more information about these
		62	`prefix-map options`_.
		63
49	Generated files in source packages	64	Generated files in source packages
50	----------------------------------	65	----------------------------------
51		66
@@ -116,5 +131,7 @@ See ``scripts/setlocalversion`` for details. · 64 unmodified lines
116		131
117	.. _KBUILD_BUILD_TIMESTAMP: kbuild.html#kbuild-build-timestamp	132	.. _KBUILD_BUILD_TIMESTAMP: kbuild.html#kbuild-build-timestamp
118	.. _KBUILD_BUILD_USER and KBUILD_BUILD_HOST: kbuild.html#kbuild-build-user-kbuild-build-host	133	.. _KBUILD_BUILD_USER and KBUILD_BUILD_HOST: kbuild.html#kbuild-build-user-kbuild-build-host
		134	.. _KCFLAGS: kbuild.html#kcflags
		135	.. _prefix-map options: https://reproducible-builds.org/docs/build-path/
119	.. _Reproducible Builds project: https://reproducible-builds.org/	136	.. _Reproducible Builds project: https://reproducible-builds.org/
120	.. _SOURCE_DATE_EPOCH: https://reproducible-builds.org/docs/source-date-epoch/	137	.. _SOURCE_DATE_EPOCH: https://reproducible-builds.org/docs/source-date-epoch/

Documentation/netlink/specs/tc.yaml+6−4

     attributes:
       -
         name: act
-        type: nest
+        type: indexed-array
+        sub-type: nest
         nested-attributes: tc-act-attrs
       -
         name: police
     attributes:
       -
         name: act
-        type: nest
+        type: indexed-array
+        sub-type: nest
         nested-attributes: tc-act-attrs
       -
         name: police
         type: u16
         byte-order: big-endian
       -
-        name: key-l2-tpv3-sid
+        name: key-l2tpv3-sid
         type: u32
         byte-order: big-endian
       -
         name: rate64
         type: u64
       -
-        name: prate4
+        name: prate64
         type: u64
       -
         name: burst

Documentation/networking/timestamping.rst+3−5

@@ -811,11 +811,9 @@ Documentation/devicetree/bindings/ptp/timestamper.txt for more details. · 810 unmodified lines
811	3.2.4 Other caveats for MAC drivers	811	3.2.4 Other caveats for MAC drivers
812	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^	812	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
813		813
814	Stacked PHCs, especially DSA (but not only) - since that doesn't require any	814	The use of stacked PHCs may uncover MAC driver bugs which were impossible to
815	modification to MAC drivers, so it is more difficult to ensure correctness of	815	trigger without them. One example has to do with this line of code, already
816	all possible code paths - is that they uncover bugs which were impossible to	816	presented earlier::
817	trigger before the existence of stacked PTP clocks. One example has to do with
818	this line of code, already presented earlier::
819		817
820	skb_shinfo(skb)->tx_flags \|= SKBTX_IN_PROGRESS;	818	skb_shinfo(skb)->tx_flags \|= SKBTX_IN_PROGRESS;
821		819

MAINTAINERS+22−4

 F:	include/linux/gpio/regmap.h
 K:	(devm_)?gpio_regmap_(un)?register
+GPIO SLOPPY LOGIC ANALYZER
+M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
+S:	Supported
+F:	Documentation/dev-tools/gpio-sloppy-logic-analyzer.rst
+F:	drivers/gpio/gpio-sloppy-logic-analyzer.c
+F:	tools/gpio/gpio-sloppy-logic-analyzer.sh
 GPIO SUBSYSTEM
 M:	Linus Walleij <linus.walleij@linaro.org>
 M:	Bartosz Golaszewski <brgl@bgdev.pl>
 F:	include/linux/execmem.h
 F:	mm/execmem.c
+MEMORY MANAGEMENT - GUP (GET USER PAGES)
+M:	Andrew Morton <akpm@linux-foundation.org>
+M:	David Hildenbrand <david@redhat.com>
+R:	Jason Gunthorpe <jgg@nvidia.com>
+R:	John Hubbard <jhubbard@nvidia.com>
+R:	Peter Xu <peterx@redhat.com>
+L:	linux-mm@kvack.org
+S:	Maintained
+W:	http://www.linux-mm.org
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
+F:	mm/gup.c
 MEMORY MANAGEMENT - NUMA MEMBLOCKS AND NUMA EMULATION
 M:	Andrew Morton <akpm@linux-foundation.org>
 M:	Mike Rapoport <rppt@kernel.org>
 PARAVIRT_OPS INTERFACE
 M:	Juergen Gross <jgross@suse.com>
 R:	Ajay Kaher <ajay.kaher@broadcom.com>
-R:	Alexey Makhalov <alexey.amakhalov@broadcom.com>
+R:	Alexey Makhalov <alexey.makhalov@broadcom.com>
 R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
 L:	virtualization@lists.linux.dev
 L:	x86@kernel.org
 SPEAR PLATFORM/CLOCK/PINCTRL SUPPORT
 M:	Viresh Kumar <vireshk@kernel.org>
-M:	Shiraz Hashim <shiraz.linux.kernel@gmail.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	soc@lists.linux.dev
 S:	Maintained
 VMWARE HYPERVISOR INTERFACE
 M:	Ajay Kaher <ajay.kaher@broadcom.com>
-M:	Alexey Makhalov <alexey.amakhalov@broadcom.com>
+M:	Alexey Makhalov <alexey.makhalov@broadcom.com>
 R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
 L:	virtualization@lists.linux.dev
 L:	x86@kernel.org
 VMWARE VIRTUAL PTP CLOCK DRIVER
 M:	Nick Shi <nick.shi@broadcom.com>
 R:	Ajay Kaher <ajay.kaher@broadcom.com>
-R:	Alexey Makhalov <alexey.amakhalov@broadcom.com>
+R:	Alexey Makhalov <alexey.makhalov@broadcom.com>
 R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
 L:	netdev@vger.kernel.org
 S:	Supported

Makefile+2−3

 VERSION = 6
 PATCHLEVEL = 15
 SUBLEVEL = 0
-EXTRAVERSION = -rc6
+EXTRAVERSION = -rc7
 NAME = Baby Opossum Posse
 # *DOCUMENTATION*
 # change __FILE__ to the relative path to the source directory
 ifdef building_out_of_srctree
-KBUILD_CPPFLAGS += $(call cc-option,-ffile-prefix-map=$(srcroot)/=)
+KBUILD_CPPFLAGS += $(call cc-option,-fmacro-prefix-map=$(srcroot)/=)
-KBUILD_RUSTFLAGS += --remap-path-prefix=$(srcroot)/=
 endif
 # include additional Makefiles when needed

arch/arm/boot/dts/amlogic/meson8.dtsi+3−3

@@ -451,7 +451,7 @@ · 450 unmodified lines
451	pwm_ef: pwm@86c0 {	451	pwm_ef: pwm@86c0 {
452	compatible = "amlogic,meson8-pwm-v2";	452	compatible = "amlogic,meson8-pwm-v2";
453	clocks = <&xtal>,	453	clocks = <&xtal>,
454	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	454	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
455	<&clkc CLKID_FCLK_DIV4>,	455	<&clkc CLKID_FCLK_DIV4>,
456	<&clkc CLKID_FCLK_DIV3>;	456	<&clkc CLKID_FCLK_DIV3>;
457	reg = <0x86c0 0x10>;	457	reg = <0x86c0 0x10>;
@@ -705,7 +705,7 @@ · 247 unmodified lines
705	&pwm_ab {	705	&pwm_ab {
706	compatible = "amlogic,meson8-pwm-v2";	706	compatible = "amlogic,meson8-pwm-v2";
707	clocks = <&xtal>,	707	clocks = <&xtal>,
708	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	708	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
709	<&clkc CLKID_FCLK_DIV4>,	709	<&clkc CLKID_FCLK_DIV4>,
710	<&clkc CLKID_FCLK_DIV3>;	710	<&clkc CLKID_FCLK_DIV3>;
711	};	711	};
@@ -713,7 +713,7 @@ · 1 unmodified line
713	&pwm_cd {	713	&pwm_cd {
714	compatible = "amlogic,meson8-pwm-v2";	714	compatible = "amlogic,meson8-pwm-v2";
715	clocks = <&xtal>,	715	clocks = <&xtal>,
716	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	716	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
717	<&clkc CLKID_FCLK_DIV4>,	717	<&clkc CLKID_FCLK_DIV4>,
718	<&clkc CLKID_FCLK_DIV3>;	718	<&clkc CLKID_FCLK_DIV3>;
719	};	719	};

arch/arm/boot/dts/amlogic/meson8b.dtsi+3−3

@@ -406,7 +406,7 @@ · 405 unmodified lines
406	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";	406	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";
407	reg = <0x86c0 0x10>;	407	reg = <0x86c0 0x10>;
408	clocks = <&xtal>,	408	clocks = <&xtal>,
409	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	409	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
410	<&clkc CLKID_FCLK_DIV4>,	410	<&clkc CLKID_FCLK_DIV4>,
411	<&clkc CLKID_FCLK_DIV3>;	411	<&clkc CLKID_FCLK_DIV3>;
412	#pwm-cells = <3>;	412	#pwm-cells = <3>;
@@ -680,7 +680,7 @@ · 267 unmodified lines
680	&pwm_ab {	680	&pwm_ab {
681	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";	681	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";
682	clocks = <&xtal>,	682	clocks = <&xtal>,
683	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	683	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
684	<&clkc CLKID_FCLK_DIV4>,	684	<&clkc CLKID_FCLK_DIV4>,
685	<&clkc CLKID_FCLK_DIV3>;	685	<&clkc CLKID_FCLK_DIV3>;
686	};	686	};
@@ -688,7 +688,7 @@ · 1 unmodified line
688	&pwm_cd {	688	&pwm_cd {
689	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";	689	compatible = "amlogic,meson8b-pwm-v2", "amlogic,meson8-pwm-v2";
690	clocks = <&xtal>,	690	clocks = <&xtal>,
691	<>, /* unknown/untested, the datasheet calls it "Video PLL" */	691	<0>, /* unknown/untested, the datasheet calls it "Video PLL" */
692	<&clkc CLKID_FCLK_DIV4>,	692	<&clkc CLKID_FCLK_DIV4>,
693	<&clkc CLKID_FCLK_DIV3>;	693	<&clkc CLKID_FCLK_DIV3>;
694	};	694	};

arch/arm64/boot/dts/amazon/alpine-v2.dtsi+1−1

@@ -151,7 +151,7 @@ · 150 unmodified lines
151	al,msi-num-spis = <160>;	151	al,msi-num-spis = <160>;
152	};	152	};
153		153
154	io-fabric@fc000000 {	154	io-bus@fc000000 {
155	compatible = "simple-bus";	155	compatible = "simple-bus";
156	#address-cells = <1>;	156	#address-cells = <1>;
157	#size-cells = <1>;	157	#size-cells = <1>;

arch/arm64/boot/dts/amazon/alpine-v3.dtsi+1−1

@@ -361,7 +361,7 @@ · 360 unmodified lines
361	interrupt-parent = <&gic>;	361	interrupt-parent = <&gic>;
362	};	362	};
363		363
364	io-fabric@fc000000 {	364	io-bus@fc000000 {
365	compatible = "simple-bus";	365	compatible = "simple-bus";
366	#address-cells = <1>;	366	#address-cells = <1>;
367	#size-cells = <1>;	367	#size-cells = <1>;

arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi+3−3

@@ -2313,7 +2313,7 @@ · 2312 unmodified lines
2313	"amlogic,meson8-pwm-v2";	2313	"amlogic,meson8-pwm-v2";
2314	reg = <0x0 0x19000 0x0 0x20>;	2314	reg = <0x0 0x19000 0x0 0x20>;
2315	clocks = <&xtal>,	2315	clocks = <&xtal>,
2316	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	2316	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
2317	<&clkc CLKID_FCLK_DIV4>,	2317	<&clkc CLKID_FCLK_DIV4>,
2318	<&clkc CLKID_FCLK_DIV3>;	2318	<&clkc CLKID_FCLK_DIV3>;
2319	#pwm-cells = <3>;	2319	#pwm-cells = <3>;
@@ -2325,7 +2325,7 @@ · 5 unmodified lines
2325	"amlogic,meson8-pwm-v2";	2325	"amlogic,meson8-pwm-v2";
2326	reg = <0x0 0x1a000 0x0 0x20>;	2326	reg = <0x0 0x1a000 0x0 0x20>;
2327	clocks = <&xtal>,	2327	clocks = <&xtal>,
2328	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	2328	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
2329	<&clkc CLKID_FCLK_DIV4>,	2329	<&clkc CLKID_FCLK_DIV4>,
2330	<&clkc CLKID_FCLK_DIV3>;	2330	<&clkc CLKID_FCLK_DIV3>;
2331	#pwm-cells = <3>;	2331	#pwm-cells = <3>;
@@ -2337,7 +2337,7 @@ · 5 unmodified lines
2337	"amlogic,meson8-pwm-v2";	2337	"amlogic,meson8-pwm-v2";
2338	reg = <0x0 0x1b000 0x0 0x20>;	2338	reg = <0x0 0x1b000 0x0 0x20>;
2339	clocks = <&xtal>,	2339	clocks = <&xtal>,
2340	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	2340	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
2341	<&clkc CLKID_FCLK_DIV4>,	2341	<&clkc CLKID_FCLK_DIV4>,
2342	<&clkc CLKID_FCLK_DIV3>;	2342	<&clkc CLKID_FCLK_DIV3>;
2343	#pwm-cells = <3>;	2343	#pwm-cells = <3>;

arch/arm64/boot/dts/amlogic/meson-g12b-dreambox.dtsi+4−0

 	status = "okay";
 };
+&clkc_audio {
+	status = "okay";
+};
 &frddr_a {
 	status = "okay";
 };

arch/arm64/boot/dts/amlogic/meson-gxbb.dtsi+3−3

@@ -741,7 +741,7 @@ · 740 unmodified lines
741		741
742	&pwm_ab {	742	&pwm_ab {
743	clocks = <&xtal>,	743	clocks = <&xtal>,
744	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	744	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
745	<&clkc CLKID_FCLK_DIV4>,	745	<&clkc CLKID_FCLK_DIV4>,
746	<&clkc CLKID_FCLK_DIV3>;	746	<&clkc CLKID_FCLK_DIV3>;
747	};	747	};
@@ -752,14 +752,14 @@ · 4 unmodified lines
752		752
753	&pwm_cd {	753	&pwm_cd {
754	clocks = <&xtal>,	754	clocks = <&xtal>,
755	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	755	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
756	<&clkc CLKID_FCLK_DIV4>,	756	<&clkc CLKID_FCLK_DIV4>,
757	<&clkc CLKID_FCLK_DIV3>;	757	<&clkc CLKID_FCLK_DIV3>;
758	};	758	};
759		759
760	&pwm_ef {	760	&pwm_ef {
761	clocks = <&xtal>,	761	clocks = <&xtal>,
762	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	762	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
763	<&clkc CLKID_FCLK_DIV4>,	763	<&clkc CLKID_FCLK_DIV4>,
764	<&clkc CLKID_FCLK_DIV3>;	764	<&clkc CLKID_FCLK_DIV3>;
765	};	765	};

arch/arm64/boot/dts/amlogic/meson-gxl.dtsi+3−3

@@ -811,7 +811,7 @@ · 810 unmodified lines
811		811
812	&pwm_ab {	812	&pwm_ab {
813	clocks = <&xtal>,	813	clocks = <&xtal>,
814	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	814	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
815	<&clkc CLKID_FCLK_DIV4>,	815	<&clkc CLKID_FCLK_DIV4>,
816	<&clkc CLKID_FCLK_DIV3>;	816	<&clkc CLKID_FCLK_DIV3>;
817	};	817	};
@@ -822,14 +822,14 @@ · 4 unmodified lines
822		822
823	&pwm_cd {	823	&pwm_cd {
824	clocks = <&xtal>,	824	clocks = <&xtal>,
825	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	825	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
826	<&clkc CLKID_FCLK_DIV4>,	826	<&clkc CLKID_FCLK_DIV4>,
827	<&clkc CLKID_FCLK_DIV3>;	827	<&clkc CLKID_FCLK_DIV3>;
828	};	828	};
829		829
830	&pwm_ef {	830	&pwm_ef {
831	clocks = <&xtal>,	831	clocks = <&xtal>,
832	<>, /* unknown/untested, the datasheet calls it "vid_pll" */	832	<0>, /* unknown/untested, the datasheet calls it "vid_pll" */
833	<&clkc CLKID_FCLK_DIV4>,	833	<&clkc CLKID_FCLK_DIV4>,
834	<&clkc CLKID_FCLK_DIV3>;	834	<&clkc CLKID_FCLK_DIV3>;
835	};	835	};

arch/arm64/boot/dts/apple/t8103-j293.dts+10−0

@@ -77,6 +77,16 @@ · 76 unmodified lines
77	};	77	};
78	};	78	};
79		79
		80	/*
		81	* The driver depends on boot loader initialized state which resets when this
		82	* power-domain is powered off. This happens on suspend or when the driver is
		83	* missing during boot. Mark the domain as always on until the driver can
		84	* handle this.
		85	*/
		86	&ps_dispdfr_be {
		87	apple,always-on;
		88	};
		89
80	&display_dfr {	90	&display_dfr {
81	status = "okay";	91	status = "okay";
82	};	92	};

arch/arm64/boot/dts/apple/t8112-j493.dts+10−0

@@ -40,6 +40,16 @@ · 39 unmodified lines
40	};	40	};
41	};	41	};
42		42
		43	/*
		44	* The driver depends on boot loader initialized state which resets when this
		45	* power-domain is powered off. This happens on suspend or when the driver is
		46	* missing during boot. Mark the domain as always on until the driver can
		47	* handle this.
		48	*/
		49	&ps_dispdfr_be {
		50	apple,always-on;
		51	};
		52
43	&display_dfr {	53	&display_dfr {
44	status = "okay";	54	status = "okay";
45	};	55	};

arch/arm64/boot/dts/freescale/imx8mp-nominal.dtsi+2−0

@@ -88,3 +88,5 @@ · 87 unmodified lines
88	<0>, <0>, <400000000>,	88	<0>, <0>, <400000000>,
89	<1039500000>;	89	<1039500000>;
90	};	90	};
		91
		92	/delete-node/ &{noc_opp_table/opp-1000000000};

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

 		      <0x1 0x00000000 0 0xc0000000>;
 	};
 	reg_usdhc2_vmmc: regulator-usdhc2-vmmc {
 	        compatible = "regulator-fixed";
 	        regulator-name = "VSD_3V3";
 	        startup-delay-us = <100>;
 	        off-on-delay-us = <12000>;
 	};
+	reg_usdhc2_vqmmc: regulator-usdhc2-vqmmc {
+		compatible = "regulator-gpio";
+		regulator-name = "VSD_VSEL";
+		regulator-min-microvolt = <1800000>;
+		regulator-max-microvolt = <3300000>;
+		gpios = <&gpio2 12 GPIO_ACTIVE_HIGH>;
+		states = <3300000 0x0 1800000 0x1>;
+		vin-supply = <&ldo5>;
+	};
 };
 &A53_0 {
         pinctrl-2 = <&pinctrl_usdhc2_200mhz>, <&pinctrl_usdhc2_gpio>;
         cd-gpios = <&gpio1 14 GPIO_ACTIVE_LOW>;
         vmmc-supply = <&reg_usdhc2_vmmc>;
+	vqmmc-supply = <&reg_usdhc2_vqmmc>;
         bus-width = <4>;
         status = "okay";
 };

arch/arm64/boot/dts/freescale/imx8mp.dtsi+6−0

 					opp-hz = /bits/ 64 <200000000>;
 				};
+				/* Nominal drive mode maximum */
+				opp-800000000 {
+					opp-hz = /bits/ 64 <800000000>;
+				};
+				/* Overdrive mode maximum */
 				opp-1000000000 {
 					opp-hz = /bits/ 64 <1000000000>;
 				};

arch/arm64/boot/dts/rockchip/px30-engicam-common.dtsi+1−2

 	};
 	vcc3v3_btreg: vcc3v3-btreg {
-		compatible = "regulator-gpio";
+		compatible = "regulator-fixed";
 		enable-active-high;
 		pinctrl-names = "default";
 		pinctrl-0 = <&bt_enable_h>;
 		regulator-min-microvolt = <3300000>;
 		regulator-max-microvolt = <3300000>;
 		regulator-always-on;
-		states = <3300000 0x0>;
 	};
 	vcc3v3_rf_aux_mod: regulator-vcc3v3-rf-aux-mod {

arch/arm64/boot/dts/rockchip/px30-engicam-ctouch2.dtsi+1−1

@@ -26,5 +26,5 @@ · 25 unmodified lines
26	};	26	};
27		27
28	&vcc3v3_btreg {	28	&vcc3v3_btreg {
29	enable-gpios = <&gpio1 RK_PC3 GPIO_ACTIVE_HIGH>;	29	gpios = <&gpio1 RK_PC3 GPIO_ACTIVE_HIGH>;
30	};	30	};

arch/arm64/boot/dts/rockchip/px30-engicam-px30-core-edimm2.2.dts+1−1

@@ -39,5 +39,5 @@ · 38 unmodified lines
39	};	39	};
40		40
41	&vcc3v3_btreg {	41	&vcc3v3_btreg {
42	enable-gpios = <&gpio1 RK_PC2 GPIO_ACTIVE_HIGH>;	42	gpios = <&gpio1 RK_PC2 GPIO_ACTIVE_HIGH>;
43	};	43	};

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

@@ -43,7 +43,7 @@ · 42 unmodified lines
43	sdio_pwrseq: sdio-pwrseq {	43	sdio_pwrseq: sdio-pwrseq {
44	compatible = "mmc-pwrseq-simple";	44	compatible = "mmc-pwrseq-simple";
45	clocks = <&rk808 1>;	45	clocks = <&rk808 1>;
46	clock-names = "lpo";	46	clock-names = "ext_clock";
47	pinctrl-names = "default";	47	pinctrl-names = "default";
48	pinctrl-0 = <&wifi_enable_h>;	48	pinctrl-0 = <&wifi_enable_h>;
49	reset-gpios = <&gpio0 RK_PB2 GPIO_ACTIVE_LOW>;	49	reset-gpios = <&gpio0 RK_PB2 GPIO_ACTIVE_LOW>;

arch/arm64/boot/dts/rockchip/rk3566-bigtreetech-cb2.dtsi+1−1

@@ -775,7 +775,7 @@ · 774 unmodified lines
775	rockchip,default-sample-phase = <90>;	775	rockchip,default-sample-phase = <90>;
776	status = "okay";	776	status = "okay";
777		777
778	sdio-wifi@1 {	778	wifi@1 {
779	compatible = "brcm,bcm4329-fmac";	779	compatible = "brcm,bcm4329-fmac";
780	reg = <1>;	780	reg = <1>;
781	interrupt-parent = <&gpio2>;	781	interrupt-parent = <&gpio2>;

arch/arm64/boot/dts/rockchip/rk3568-qnap-ts433.dts+2−0

@@ -619,6 +619,8 @@ · 618 unmodified lines
619	bus-width = <8>;	619	bus-width = <8>;
620	max-frequency = <200000000>;	620	max-frequency = <200000000>;
621	non-removable;	621	non-removable;
		622	pinctrl-names = "default";
		623	pinctrl-0 = <&emmc_bus8 &emmc_clk &emmc_cmd &emmc_datastrobe>;
622	status = "okay";	624	status = "okay";
623	};	625	};
624		626

arch/arm64/boot/dts/rockchip/rk3576-armsom-sige5.dts+1−1

@@ -610,7 +610,7 @@ · 609 unmodified lines
610	reg = <0x51>;	610	reg = <0x51>;
611	clock-output-names = "hym8563";	611	clock-output-names = "hym8563";
612	interrupt-parent = <&gpio0>;	612	interrupt-parent = <&gpio0>;
613	interrupts = <RK_PB0 IRQ_TYPE_LEVEL_LOW>;	613	interrupts = <RK_PA0 IRQ_TYPE_LEVEL_LOW>;
614	pinctrl-names = "default";	614	pinctrl-names = "default";
615	pinctrl-0 = <&hym8563_int>;	615	pinctrl-0 = <&hym8563_int>;
616	wakeup-source;	616	wakeup-source;

arch/arm64/boot/dts/rockchip/rk3588-friendlyelec-cm3588.dtsi+4−0

 		compatible = "realtek,rt5616";
 		reg = <0x1b>;
 		#sound-dai-cells = <0>;
+		assigned-clocks = <&cru I2S0_8CH_MCLKOUT>;
+		assigned-clock-rates = <12288000>;
+		clocks = <&cru I2S0_8CH_MCLKOUT>;
+		clock-names = "mclk";
 	};
 };

arch/arm64/boot/dts/rockchip/rk3588-turing-rk1.dtsi+2−0

@@ -214,6 +214,8 @@ · 213 unmodified lines
214	};	214	};
215		215
216	&package_thermal {	216	&package_thermal {
		217	polling-delay = <1000>;
		218
217	trips {	219	trips {
218	package_active1: trip-active1 {	220	package_active1: trip-active1 {
219	temperature = <45000>;	221	temperature = <45000>;

arch/arm64/boot/dts/rockchip/rk3588j.dtsi+17−36

 		compatible = "operating-points-v2";
 		opp-shared;
-		opp-1416000000 {
+		opp-1200000000 {
-			opp-hz = /bits/ 64 <1416000000>;
+			opp-hz = /bits/ 64 <1200000000>;
 			opp-microvolt = <750000 750000 950000>;
 			clock-latency-ns = <40000>;
 			opp-suspend;
 		};
-		opp-1608000000 {
+		opp-1296000000 {
-			opp-hz = /bits/ 64 <1608000000>;
+			opp-hz = /bits/ 64 <1296000000>;
-			opp-microvolt = <887500 887500 950000>;
+			opp-microvolt = <775000 775000 950000>;
-			clock-latency-ns = <40000>;
-		};
-		opp-1704000000 {
-			opp-hz = /bits/ 64 <1704000000>;
-			opp-microvolt = <937500 937500 950000>;
 			clock-latency-ns = <40000>;
 		};
 	};
 		compatible = "operating-points-v2";
 		opp-shared;
+		opp-1200000000{
+			opp-hz = /bits/ 64 <1200000000>;
+			opp-microvolt = <750000 750000 950000>;
+			clock-latency-ns = <40000>;
+		};
 		opp-1416000000 {
 			opp-hz = /bits/ 64 <1416000000>;
-			opp-microvolt = <750000 750000 950000>;
+			opp-microvolt = <762500 762500 950000>;
 			clock-latency-ns = <40000>;
 		};
 		opp-1608000000 {
 			opp-microvolt = <787500 787500 950000>;
 			clock-latency-ns = <40000>;
 		};
-		opp-1800000000 {
-			opp-hz = /bits/ 64 <1800000000>;
-			opp-microvolt = <875000 875000 950000>;
-			clock-latency-ns = <40000>;
-		};
-		opp-2016000000 {
-			opp-hz = /bits/ 64 <2016000000>;
-			opp-microvolt = <950000 950000 950000>;
-			clock-latency-ns = <40000>;
-		};
 	};
 	cluster2_opp_table: opp-table-cluster2 {
 		compatible = "operating-points-v2";
 		opp-shared;
+		opp-1200000000{
+			opp-hz = /bits/ 64 <1200000000>;
+			opp-microvolt = <750000 750000 950000>;
+			clock-latency-ns = <40000>;
+		};
 		opp-1416000000 {
 			opp-hz = /bits/ 64 <1416000000>;
-			opp-microvolt = <750000 750000 950000>;
+			opp-microvolt = <762500 762500 950000>;
 			clock-latency-ns = <40000>;
 		};
 		opp-1608000000 {
 			opp-microvolt = <787500 787500 950000>;
 			clock-latency-ns = <40000>;
 		};
-		opp-1800000000 {
-			opp-hz = /bits/ 64 <1800000000>;
-			opp-microvolt = <875000 875000 950000>;
-			clock-latency-ns = <40000>;
-		};
-		opp-2016000000 {
-			opp-hz = /bits/ 64 <2016000000>;
-			opp-microvolt = <950000 950000 950000>;
-			clock-latency-ns = <40000>;
-		};
 	};
 	gpu_opp_table: opp-table {
 			opp-hz = /bits/ 64 <700000000>;
 			opp-microvolt = <750000 750000 850000>;
 		};
-		opp-850000000 {
-			opp-hz = /bits/ 64 <800000000>;
-			opp-microvolt = <787500 787500 850000>;
-		};
 	};
 };

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

 #define ARM_CPU_PART_CORTEX_A78AE	0xD42
 #define ARM_CPU_PART_CORTEX_X1		0xD44
 #define ARM_CPU_PART_CORTEX_A510	0xD46
+#define ARM_CPU_PART_CORTEX_X1C		0xD4C
 #define ARM_CPU_PART_CORTEX_A520	0xD80
 #define ARM_CPU_PART_CORTEX_A710	0xD47
 #define ARM_CPU_PART_CORTEX_A715	0xD4D
 #define MIDR_CORTEX_A78AE	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A78AE)
 #define MIDR_CORTEX_X1	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_X1)
 #define MIDR_CORTEX_A510 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A510)
+#define MIDR_CORTEX_X1C MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_X1C)
 #define MIDR_CORTEX_A520 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A520)
 #define MIDR_CORTEX_A710 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A710)
 #define MIDR_CORTEX_A715 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A715)

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

@@ -706,6 +706,7 @@ u32 aarch64_insn_gen_cas(enum aarch64_insn_register result, · 705 unmodified lines
706	}	706	}
707	#endif	707	#endif
708	u32 aarch64_insn_gen_dmb(enum aarch64_insn_mb_type type);	708	u32 aarch64_insn_gen_dmb(enum aarch64_insn_mb_type type);
		709	u32 aarch64_insn_gen_dsb(enum aarch64_insn_mb_type type);
709	u32 aarch64_insn_gen_mrs(enum aarch64_insn_register result,	710	u32 aarch64_insn_gen_mrs(enum aarch64_insn_register result,
710	enum aarch64_insn_system_register sysreg);	711	enum aarch64_insn_system_register sysreg);
711		712

arch/arm64/include/asm/spectre.h+3−0

@@ -97,6 +97,9 @@ enum mitigation_state arm64_get_meltdown_state(void); · 96 unmodified lines
97		97
98	enum mitigation_state arm64_get_spectre_bhb_state(void);	98	enum mitigation_state arm64_get_spectre_bhb_state(void);
99	bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, int scope);	99	bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, int scope);
		100	extern bool __nospectre_bhb;
		101	u8 get_spectre_bhb_loop_value(void);
		102	bool is_spectre_bhb_fw_mitigated(void);
100	void spectre_bhb_enable_mitigation(const struct arm64_cpu_capabilities *__unused);	103	void spectre_bhb_enable_mitigation(const struct arm64_cpu_capabilities *__unused);
101	bool try_emulate_el1_ssbs(struct pt_regs *regs, u32 instr);	104	bool try_emulate_el1_ssbs(struct pt_regs *regs, u32 instr);
102		105

arch/arm64/kernel/proton-pack.c+12−1

 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78C),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_X1),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_X1C),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A710),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_X2),
 		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N2),
 	return true;
 }
+u8 get_spectre_bhb_loop_value(void)
+{
+	return max_bhb_k;
+}
 static void this_cpu_set_vectors(enum arm64_bp_harden_el1_vectors slot)
 {
 	const char *v = arm64_get_bp_hardening_vector(slot);
 	isb();
 }
-static bool __read_mostly __nospectre_bhb;
+bool __read_mostly __nospectre_bhb;
 static int __init parse_spectre_bhb_param(char *str)
 {
 	__nospectre_bhb = true;
 	update_mitigation_state(&spectre_bhb_state, state);
 }
+bool is_spectre_bhb_fw_mitigated(void)
+{
+	return test_bit(BHB_FW, &system_bhb_mitigations);
+}
 /* Patched to NOP when enabled */
 void noinstr spectre_bhb_patch_loop_mitigation_enable(struct alt_instr *alt,
 						     __le32 *origptr,

arch/arm64/lib/insn.c+37−23

  *
  * Copyright (C) 2014-2016 Zi Shen Lim <zlim.lnx@gmail.com>
  */
+#include <linux/bitfield.h>
 #include <linux/bitops.h>
 #include <linux/bug.h>
 #include <linux/printk.h>
 	return aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RM, insn, Rm);
 }
-u32 aarch64_insn_gen_dmb(enum aarch64_insn_mb_type type)
+static u32 __get_barrier_crm_val(enum aarch64_insn_mb_type type)
 {
-	u32 opt;
-	u32 insn;
 	switch (type) {
 	case AARCH64_INSN_MB_SY:
-		opt = 0xf;
+		return 0xf;
-		break;
 	case AARCH64_INSN_MB_ST:
-		opt = 0xe;
+		return 0xe;
-		break;
 	case AARCH64_INSN_MB_LD:
-		opt = 0xd;
+		return 0xd;
-		break;
 	case AARCH64_INSN_MB_ISH:
-		opt = 0xb;
+		return 0xb;
-		break;
 	case AARCH64_INSN_MB_ISHST:
-		opt = 0xa;
+		return 0xa;
-		break;
 	case AARCH64_INSN_MB_ISHLD:
-		opt = 0x9;
+		return 0x9;
-		break;
 	case AARCH64_INSN_MB_NSH:
-		opt = 0x7;
+		return 0x7;
-		break;
 	case AARCH64_INSN_MB_NSHST:
-		opt = 0x6;
+		return 0x6;
-		break;
 	case AARCH64_INSN_MB_NSHLD:
-		opt = 0x5;
+		return 0x5;
-		break;
 	default:
-		pr_err("%s: unknown dmb type %d\n", __func__, type);
+		pr_err("%s: unknown barrier type %d\n", __func__, type);
 		return AARCH64_BREAK_FAULT;
 	}
+}
+u32 aarch64_insn_gen_dmb(enum aarch64_insn_mb_type type)
+{
+	u32 opt;
+	u32 insn;
+	opt = __get_barrier_crm_val(type);
+	if (opt == AARCH64_BREAK_FAULT)
+		return AARCH64_BREAK_FAULT;
 	insn = aarch64_insn_get_dmb_value();
 	insn &= ~GENMASK(11, 8);
 	return insn;
 }
+u32 aarch64_insn_gen_dsb(enum aarch64_insn_mb_type type)
+{
+	u32 opt, insn;
+	opt = __get_barrier_crm_val(type);
+	if (opt == AARCH64_BREAK_FAULT)
+		return AARCH64_BREAK_FAULT;
+	insn = aarch64_insn_get_dsb_base_value();
+	insn &= ~GENMASK(11, 8);
+	insn |= (opt << 8);
+	return insn;
+}
 u32 aarch64_insn_gen_mrs(enum aarch64_insn_register result,
 			 enum aarch64_insn_system_register sysreg)
 {

arch/arm64/net/bpf_jit_comp.c+53−4

@@ -7,6 +7,7 @@ · 6 unmodified lines
7		7
8	#define pr_fmt(fmt) "bpf_jit: " fmt	8	#define pr_fmt(fmt) "bpf_jit: " fmt
9		9
		10	#include <linux/arm-smccc.h>
10	#include <linux/bitfield.h>	11	#include <linux/bitfield.h>
11	#include <linux/bpf.h>	12	#include <linux/bpf.h>
12	#include <linux/filter.h>	13	#include <linux/filter.h>
@@ -17,6 +18,7 @@ · 4 unmodified lines
17	#include <asm/asm-extable.h>	18	#include <asm/asm-extable.h>
18	#include <asm/byteorder.h>	19	#include <asm/byteorder.h>
19	#include <asm/cacheflush.h>	20	#include <asm/cacheflush.h>
		21	#include <asm/cpufeature.h>
20	#include <asm/debug-monitors.h>	22	#include <asm/debug-monitors.h>
21	#include <asm/insn.h>	23	#include <asm/insn.h>
22	#include <asm/text-patching.h>	24	#include <asm/text-patching.h>
@@ -939,7 +941,51 @@ static void build_plt(struct jit_ctx *ctx) · 916 unmodified lines
939	plt->target = (u64)&dummy_tramp;	941	plt->target = (u64)&dummy_tramp;
940	}	942	}
941		943
942	static void build_epilogue(struct jit_ctx *ctx)	944	/* Clobbers BPF registers 1-4, aka x0-x3 */
		945	static void __maybe_unused build_bhb_mitigation(struct jit_ctx *ctx)
		946	{
		947	const u8 r1 = bpf2a64[BPF_REG_1]; /* aka x0 */
		948	u8 k = get_spectre_bhb_loop_value();
		949
		950	if (!IS_ENABLED(CONFIG_MITIGATE_SPECTRE_BRANCH_HISTORY) \|\|
		951	cpu_mitigations_off() \|\| __nospectre_bhb \|\|
		952	arm64_get_spectre_v2_state() == SPECTRE_VULNERABLE)
		953	return;
		954
		955	if (capable(CAP_SYS_ADMIN))
		956	return;
		957
		958	if (supports_clearbhb(SCOPE_SYSTEM)) {
		959	emit(aarch64_insn_gen_hint(AARCH64_INSN_HINT_CLEARBHB), ctx);
		960	return;
		961	}
		962
		963	if (k) {
		964	emit_a64_mov_i64(r1, k, ctx);
		965	emit(A64_B(1), ctx);
		966	emit(A64_SUBS_I(true, r1, r1, 1), ctx);
		967	emit(A64_B_(A64_COND_NE, -2), ctx);
		968	emit(aarch64_insn_gen_dsb(AARCH64_INSN_MB_ISH), ctx);
		969	emit(aarch64_insn_get_isb_value(), ctx);
		970	}
		971
		972	if (is_spectre_bhb_fw_mitigated()) {
		973	emit(A64_ORR_I(false, r1, AARCH64_INSN_REG_ZR,
		974	ARM_SMCCC_ARCH_WORKAROUND_3), ctx);
		975	switch (arm_smccc_1_1_get_conduit()) {
		976	case SMCCC_CONDUIT_HVC:
		977	emit(aarch64_insn_get_hvc_value(), ctx);
		978	break;
		979	case SMCCC_CONDUIT_SMC:
		980	emit(aarch64_insn_get_smc_value(), ctx);
		981	break;
		982	default:
		983	pr_err_once("Firmware mitigation enabled with unknown conduit\n");
		984	}
		985	}
		986	}
		987
		988	static void build_epilogue(struct jit_ctx *ctx, bool was_classic)
943	{	989	{
944	const u8 r0 = bpf2a64[BPF_REG_0];	990	const u8 r0 = bpf2a64[BPF_REG_0];
945	const u8 ptr = bpf2a64[TCCNT_PTR];	991	const u8 ptr = bpf2a64[TCCNT_PTR];
@@ -952,10 +998,13 @@ static void build_epilogue(struct jit_ctx *ctx) · 6 unmodified lines
952		998
953	emit(A64_POP(A64_ZR, ptr, A64_SP), ctx);	999	emit(A64_POP(A64_ZR, ptr, A64_SP), ctx);
954		1000
		1001	if (was_classic)
		1002	build_bhb_mitigation(ctx);
		1003
955	/* Restore FP/LR registers */	1004	/* Restore FP/LR registers */
956	emit(A64_POP(A64_FP, A64_LR, A64_SP), ctx);	1005	emit(A64_POP(A64_FP, A64_LR, A64_SP), ctx);
957		1006
958	/* Set return value */	1007	/* Move the return value from bpf:r0 (aka x7) to x0 */
959	emit(A64_MOV(1, A64_R(0), r0), ctx);	1008	emit(A64_MOV(1, A64_R(0), r0), ctx);
960		1009
961	/* Authenticate lr */	1010	/* Authenticate lr */
@@ -1898,7 +1947,7 @@ struct bpf_prog bpf_int_jit_compile(struct bpf_prog prog) · 936 unmodified lines
1898	}	1947	}
1899		1948
1900	ctx.epilogue_offset = ctx.idx;	1949	ctx.epilogue_offset = ctx.idx;
1901	build_epilogue(&ctx);	1950	build_epilogue(&ctx, was_classic);
1902	build_plt(&ctx);	1951	build_plt(&ctx);
1903		1952
1904	extable_align = __alignof__(struct exception_table_entry);	1953	extable_align = __alignof__(struct exception_table_entry);
@@ -1961,7 +2010,7 @@ skip_init_ctx: · 56 unmodified lines
1961	goto out_free_hdr;	2010	goto out_free_hdr;
1962	}	2011	}
1963		2012
1964	build_epilogue(&ctx);	2013	build_epilogue(&ctx, was_classic);
1965	build_plt(&ctx);	2014	build_plt(&ctx);
1966		2015
1967	/* Extra pass to validate JITed code. */	2016	/* Extra pass to validate JITed code. */

arch/loongarch/include/asm/ptrace.h+1−1

@@ -55,7 +55,7 @@ static inline void instruction_pointer_set(struct pt_regs *regs, unsigned long v · 54 unmodified lines
55		55
56	/* Query offset/name of register from its name/offset */	56	/* Query offset/name of register from its name/offset */
57	extern int regs_query_register_offset(const char *name);	57	extern int regs_query_register_offset(const char *name);
58	#define MAX_REG_OFFSET (offsetof(struct pt_regs, __last))	58	#define MAX_REG_OFFSET (offsetof(struct pt_regs, __last) - sizeof(unsigned long))
59		59
60	/**	60	/**
61	* regs_get_register() - get register value from its offset	61	* regs_get_register() - get register value from its offset

arch/loongarch/include/asm/uprobes.h+0−1

@@ -15,7 +15,6 @@ typedef u32 uprobe_opcode_t; · 14 unmodified lines
15	#define UPROBE_XOLBP_INSN __emit_break(BRK_UPROBE_XOLBP)	15	#define UPROBE_XOLBP_INSN __emit_break(BRK_UPROBE_XOLBP)
16		16
17	struct arch_uprobe {	17	struct arch_uprobe {
18	unsigned long resume_era;
19	u32 insn[2];	18	u32 insn[2];
20	u32 ixol[2];	19	u32 ixol[2];
21	bool simulate;	20	bool simulate;

arch/loongarch/kernel/genex.S+5−2

 #include <asm/stackframe.h>
 #include <asm/thread_info.h>
+	.section .cpuidle.text, "ax"
 	.align	5
 SYM_FUNC_START(__arch_cpu_idle)
 	/* start of idle interrupt region */
 	 */
 	idle	0
 	/* end of idle interrupt region */
-1:	jr	ra
+idle_exit:
+	jr	ra
 SYM_FUNC_END(__arch_cpu_idle)
+	.previous
 SYM_CODE_START(handle_vint)
 	UNWIND_HINT_UNDEFINED
 	BACKUP_T0T1
 	SAVE_ALL
-	la_abs	t1, 1b
+	la_abs	t1, idle_exit
 	LONG_L	t0, sp, PT_ERA
 	/* 3 instructions idle interrupt region */
 	ori	t0, t0, 0b1100

arch/loongarch/kernel/kfpu.c+20−2

 static DEFINE_PER_CPU(bool, in_kernel_fpu);
 static DEFINE_PER_CPU(unsigned int, euen_current);
+static inline void fpregs_lock(void)
+{
+	if (IS_ENABLED(CONFIG_PREEMPT_RT))
+		preempt_disable();
+	else
+		local_bh_disable();
+}
+static inline void fpregs_unlock(void)
+{
+	if (IS_ENABLED(CONFIG_PREEMPT_RT))
+		preempt_enable();
+	else
+		local_bh_enable();
+}
 void kernel_fpu_begin(void)
 {
 	unsigned int *euen_curr;
-	preempt_disable();
+	if (!irqs_disabled())
+		fpregs_lock();
 	WARN_ON(this_cpu_read(in_kernel_fpu));
 	this_cpu_write(in_kernel_fpu, false);
-	preempt_enable();
+	if (!irqs_disabled())
+		fpregs_unlock();
 }
 EXPORT_SYMBOL_GPL(kernel_fpu_end);

arch/loongarch/kernel/time.c+1−1

@@ -111,7 +111,7 @@ static unsigned long __init get_loops_per_jiffy(void) · 110 unmodified lines
111	return lpj;	111	return lpj;
112	}	112	}
113		113
114	static long init_offset __nosavedata;	114	static long init_offset;
115		115
116	void save_counter(void)	116	void save_counter(void)
117	{	117	{

arch/loongarch/kernel/uprobes.c+1−10

@@ -42,7 +42,6 @@ int arch_uprobe_pre_xol(struct arch_uprobe auprobe, struct pt_regs regs) · 41 unmodified lines
42	utask->autask.saved_trap_nr = current->thread.trap_nr;	42	utask->autask.saved_trap_nr = current->thread.trap_nr;
43	current->thread.trap_nr = UPROBE_TRAP_NR;	43	current->thread.trap_nr = UPROBE_TRAP_NR;
44	instruction_pointer_set(regs, utask->xol_vaddr);	44	instruction_pointer_set(regs, utask->xol_vaddr);
45	user_enable_single_step(current);
46		45
47	return 0;	46	return 0;
48	}	47	}
@@ -53,13 +52,7 @@ int arch_uprobe_post_xol(struct arch_uprobe auprobe, struct pt_regs regs) · 4 unmodified lines
53		52
54	WARN_ON_ONCE(current->thread.trap_nr != UPROBE_TRAP_NR);	53	WARN_ON_ONCE(current->thread.trap_nr != UPROBE_TRAP_NR);
55	current->thread.trap_nr = utask->autask.saved_trap_nr;	54	current->thread.trap_nr = utask->autask.saved_trap_nr;
56		55	instruction_pointer_set(regs, utask->vaddr + LOONGARCH_INSN_SIZE);
57	if (auprobe->simulate)
58	instruction_pointer_set(regs, auprobe->resume_era);
59	else
60	instruction_pointer_set(regs, utask->vaddr + LOONGARCH_INSN_SIZE);
61
62	user_disable_single_step(current);
63		56
64	return 0;	57	return 0;
65	}	58	}
@@ -70,7 +63,6 @@ void arch_uprobe_abort_xol(struct arch_uprobe auprobe, struct pt_regs regs) · 4 unmodified lines
70		63
71	current->thread.trap_nr = utask->autask.saved_trap_nr;	64	current->thread.trap_nr = utask->autask.saved_trap_nr;
72	instruction_pointer_set(regs, utask->vaddr);	65	instruction_pointer_set(regs, utask->vaddr);
73	user_disable_single_step(current);
74	}	66	}
75		67
76	bool arch_uprobe_xol_was_trapped(struct task_struct *t)	68	bool arch_uprobe_xol_was_trapped(struct task_struct *t)
@@ -90,7 +82,6 @@ bool arch_uprobe_skip_sstep(struct arch_uprobe auprobe, struct pt_regs regs) · 13 unmodified lines
90		82
91	insn.word = auprobe->insn[0];	83	insn.word = auprobe->insn[0];
92	arch_simulate_insn(insn, regs);	84	arch_simulate_insn(insn, regs);
93	auprobe->resume_era = regs->csr_era;
94		85
95	return true;	86	return true;
96	}	87	}

arch/loongarch/power/hibernate.c+3−0

 #include <asm/fpu.h>
 #include <asm/loongson.h>
 #include <asm/sections.h>
+#include <asm/time.h>
 #include <asm/tlbflush.h>
 #include <linux/suspend.h>
 void save_processor_state(void)
 {
+	save_counter();
 	saved_crmd = csr_read32(LOONGARCH_CSR_CRMD);
 	saved_prmd = csr_read32(LOONGARCH_CSR_PRMD);
 	saved_euen = csr_read32(LOONGARCH_CSR_EUEN);
 void restore_processor_state(void)
 {
+	sync_counter();
 	csr_write32(saved_crmd, LOONGARCH_CSR_CRMD);
 	csr_write32(saved_prmd, LOONGARCH_CSR_PRMD);
 	csr_write32(saved_euen, LOONGARCH_CSR_EUEN);

arch/riscv/boot/dts/sophgo/cv18xx.dtsi+1−1

@@ -341,7 +341,7 @@ · 340 unmodified lines
341	1024 1024 1024 1024>;	341	1024 1024 1024 1024>;
342	snps,priority = <0 1 2 3 4 5 6 7>;	342	snps,priority = <0 1 2 3 4 5 6 7>;
343	snps,dma-masters = <2>;	343	snps,dma-masters = <2>;
344	snps,data-width = <4>;	344	snps,data-width = <2>;
345	status = "disabled";	345	status = "disabled";
346	};	346	};
347		347

arch/um/Makefile+1−0

@@ -154,5 +154,6 @@ MRPROPER_FILES += $(HOST_DIR)/include/generated · 153 unmodified lines
154	archclean:	154	archclean:
155	@find . \( -name '.bb' -o -name '.bbg' -o -name '*.da' \	155	@find . \( -name '.bb' -o -name '.bbg' -o -name '*.da' \
156	-o -name '*.gcov' \) -type f -print \| xargs rm -f	156	-o -name '*.gcov' \) -type f -print \| xargs rm -f
		157	$(Q)$(MAKE) -f $(srctree)/Makefile ARCH=$(HEADER_ARCH) clean
157		158
158	export HEADER_ARCH SUBARCH USER_CFLAGS CFLAGS_NO_HARDENING DEV_NULL_PATH	159	export HEADER_ARCH SUBARCH USER_CFLAGS CFLAGS_NO_HARDENING DEV_NULL_PATH

arch/x86/coco/sev/core.c+165−90

@@ -547,6 +547,102 @@ void snp_accept_memory(phys_addr_t start, phys_addr_t end) · 546 unmodified lines
547	set_pages_state(vaddr, npages, SNP_PAGE_STATE_PRIVATE);	547	set_pages_state(vaddr, npages, SNP_PAGE_STATE_PRIVATE);
548	}	548	}
549		549
		550	static int vmgexit_ap_control(u64 event, struct sev_es_save_area *vmsa, u32 apic_id)
		551	{
		552	bool create = event != SVM_VMGEXIT_AP_DESTROY;
		553	struct ghcb_state state;
		554	unsigned long flags;
		555	struct ghcb *ghcb;
		556	int ret = 0;
		557
		558	local_irq_save(flags);
		559
		560	ghcb = __sev_get_ghcb(&state);
		561
		562	vc_ghcb_invalidate(ghcb);
		563
		564	if (create)
		565	ghcb_set_rax(ghcb, vmsa->sev_features);
		566
		567	ghcb_set_sw_exit_code(ghcb, SVM_VMGEXIT_AP_CREATION);
		568	ghcb_set_sw_exit_info_1(ghcb,
		569	((u64)apic_id << 32) \|
		570	((u64)snp_vmpl << 16) \|
		571	event);
		572	ghcb_set_sw_exit_info_2(ghcb, __pa(vmsa));
		573
		574	sev_es_wr_ghcb_msr(__pa(ghcb));
		575	VMGEXIT();
		576
		577	if (!ghcb_sw_exit_info_1_is_valid(ghcb) \|\|
		578	lower_32_bits(ghcb->save.sw_exit_info_1)) {
		579	pr_err("SNP AP %s error\n", (create ? "CREATE" : "DESTROY"));
		580	ret = -EINVAL;
		581	}
		582
		583	__sev_put_ghcb(&state);
		584
		585	local_irq_restore(flags);
		586
		587	return ret;
		588	}
		589
		590	static int snp_set_vmsa(void va, void caa, int apic_id, bool make_vmsa)
		591	{
		592	int ret;
		593
		594	if (snp_vmpl) {
		595	struct svsm_call call = {};
		596	unsigned long flags;
		597
		598	local_irq_save(flags);
		599
		600	call.caa = this_cpu_read(svsm_caa);
		601	call.rcx = __pa(va);
		602
		603	if (make_vmsa) {
		604	/* Protocol 0, Call ID 2 */
		605	call.rax = SVSM_CORE_CALL(SVSM_CORE_CREATE_VCPU);
		606	call.rdx = __pa(caa);
		607	call.r8 = apic_id;
		608	} else {
		609	/* Protocol 0, Call ID 3 */
		610	call.rax = SVSM_CORE_CALL(SVSM_CORE_DELETE_VCPU);
		611	}
		612
		613	ret = svsm_perform_call_protocol(&call);
		614
		615	local_irq_restore(flags);
		616	} else {
		617	/*
		618	* If the kernel runs at VMPL0, it can change the VMSA
		619	* bit for a page using the RMPADJUST instruction.
		620	* However, for the instruction to succeed it must
		621	* target the permissions of a lesser privileged (higher
		622	* numbered) VMPL level, so use VMPL1.
		623	*/
		624	u64 attrs = 1;
		625
		626	if (make_vmsa)
		627	attrs \|= RMPADJUST_VMSA_PAGE_BIT;
		628
		629	ret = rmpadjust((unsigned long)va, RMP_PG_SIZE_4K, attrs);
		630	}
		631
		632	return ret;
		633	}
		634
		635	static void snp_cleanup_vmsa(struct sev_es_save_area *vmsa, int apic_id)
		636	{
		637	int err;
		638
		639	err = snp_set_vmsa(vmsa, NULL, apic_id, false);
		640	if (err)
		641	pr_err("clear VMSA page failed (%u), leaking page\n", err);
		642	else
		643	free_page((unsigned long)vmsa);
		644	}
		645
550	static void set_pte_enc(pte_t kpte, int level, void va)	646	static void set_pte_enc(pte_t kpte, int level, void va)
551	{	647	{
552	struct pte_enc_desc d = {	648	struct pte_enc_desc d = {
@@ -593,7 +689,8 @@ static void unshare_all_memory(void) · 40 unmodified lines
593	data = per_cpu(runtime_data, cpu);	689	data = per_cpu(runtime_data, cpu);
594	ghcb = (unsigned long)&data->ghcb_page;	690	ghcb = (unsigned long)&data->ghcb_page;
595		691
596	if (addr <= ghcb && ghcb <= addr + size) {	692	/* Handle the case of a huge page containing the GHCB page */
		693	if (addr <= ghcb && ghcb < addr + size) {
597	skipped_addr = true;	694	skipped_addr = true;
598	break;	695	break;
599	}	696	}
@@ -643,11 +740,70 @@ void snp_kexec_begin(void) · 43 unmodified lines
643	pr_warn("Failed to stop shared<->private conversions\n");	740	pr_warn("Failed to stop shared<->private conversions\n");
644	}	741	}
645		742
		743	/*
		744	* Shutdown all APs except the one handling kexec/kdump and clearing
		745	* the VMSA tag on AP's VMSA pages as they are not being used as
		746	* VMSA page anymore.
		747	*/
		748	static void shutdown_all_aps(void)
		749	{
		750	struct sev_es_save_area *vmsa;
		751	int apic_id, this_cpu, cpu;
		752
		753	this_cpu = get_cpu();
		754
		755	/*
		756	* APs are already in HLT loop when enc_kexec_finish() callback
		757	* is invoked.
		758	*/
		759	for_each_present_cpu(cpu) {
		760	vmsa = per_cpu(sev_vmsa, cpu);
		761
		762	/*
		763	* The BSP or offlined APs do not have guest allocated VMSA
		764	* and there is no need to clear the VMSA tag for this page.
		765	*/
		766	if (!vmsa)
		767	continue;
		768
		769	/*
		770	* Cannot clear the VMSA tag for the currently running vCPU.
		771	*/
		772	if (this_cpu == cpu) {
		773	unsigned long pa;
		774	struct page *p;
		775
		776	pa = __pa(vmsa);
		777	/*
		778	* Mark the VMSA page of the running vCPU as offline
		779	* so that is excluded and not touched by makedumpfile
		780	* while generating vmcore during kdump.
		781	*/
		782	p = pfn_to_online_page(pa >> PAGE_SHIFT);
		783	if (p)
		784	__SetPageOffline(p);
		785	continue;
		786	}
		787
		788	apic_id = cpuid_to_apicid[cpu];
		789
		790	/*
		791	* Issue AP destroy to ensure AP gets kicked out of guest mode
		792	* to allow using RMPADJUST to remove the VMSA tag on it's
		793	* VMSA page.
		794	*/
		795	vmgexit_ap_control(SVM_VMGEXIT_AP_DESTROY, vmsa, apic_id);
		796	snp_cleanup_vmsa(vmsa, apic_id);
		797	}
		798
		799	put_cpu();
		800	}
		801
646	void snp_kexec_finish(void)	802	void snp_kexec_finish(void)
647	{	803	{
648	struct sev_es_runtime_data *data;	804	struct sev_es_runtime_data *data;
		805	unsigned long size, addr;
649	unsigned int level, cpu;	806	unsigned int level, cpu;
650	unsigned long size;
651	struct ghcb *ghcb;	807	struct ghcb *ghcb;
652	pte_t *pte;	808	pte_t *pte;
653		809
@@ -657,6 +813,8 @@ void snp_kexec_finish(void) · 3 unmodified lines
657	if (!IS_ENABLED(CONFIG_KEXEC_CORE))	813	if (!IS_ENABLED(CONFIG_KEXEC_CORE))
658	return;	814	return;
659		815
		816	shutdown_all_aps();
		817
660	unshare_all_memory();	818	unshare_all_memory();
661		819
662	/*	820	/*
@@ -673,54 +831,11 @@ void snp_kexec_finish(void) · 10 unmodified lines
673	ghcb = &data->ghcb_page;	831	ghcb = &data->ghcb_page;
674	pte = lookup_address((unsigned long)ghcb, &level);	832	pte = lookup_address((unsigned long)ghcb, &level);
675	size = page_level_size(level);	833	size = page_level_size(level);
676	set_pte_enc(pte, level, (void *)ghcb);	834	/* Handle the case of a huge page containing the GHCB page */
677	snp_set_memory_private((unsigned long)ghcb, (size / PAGE_SIZE));	835	addr = (unsigned long)ghcb & page_level_mask(level);
678	}	836	set_pte_enc(pte, level, (void *)addr);
679	}	837	snp_set_memory_private(addr, (size / PAGE_SIZE));
680
681	static int snp_set_vmsa(void va, void caa, int apic_id, bool make_vmsa)
682	{
683	int ret;
684
685	if (snp_vmpl) {
686	struct svsm_call call = {};
687	unsigned long flags;
688
689	local_irq_save(flags);
690
691	call.caa = this_cpu_read(svsm_caa);
692	call.rcx = __pa(va);
693
694	if (make_vmsa) {
695	/* Protocol 0, Call ID 2 */
696	call.rax = SVSM_CORE_CALL(SVSM_CORE_CREATE_VCPU);
697	call.rdx = __pa(caa);
698	call.r8 = apic_id;
699	} else {
700	/* Protocol 0, Call ID 3 */
701	call.rax = SVSM_CORE_CALL(SVSM_CORE_DELETE_VCPU);
702	}
703
704	ret = svsm_perform_call_protocol(&call);
705
706	local_irq_restore(flags);
707	} else {
708	/*
709	* If the kernel runs at VMPL0, it can change the VMSA
710	* bit for a page using the RMPADJUST instruction.
711	* However, for the instruction to succeed it must
712	* target the permissions of a lesser privileged (higher
713	* numbered) VMPL level, so use VMPL1.
714	*/
715	u64 attrs = 1;
716
717	if (make_vmsa)
718	attrs \|= RMPADJUST_VMSA_PAGE_BIT;
719
720	ret = rmpadjust((unsigned long)va, RMP_PG_SIZE_4K, attrs);
721	}	838	}
722
723	return ret;
724	}	839	}
725		840
726	#define __ATTR_BASE (SVM_SELECTOR_P_MASK \| SVM_SELECTOR_S_MASK)	841	#define __ATTR_BASE (SVM_SELECTOR_P_MASK \| SVM_SELECTOR_S_MASK)
@@ -754,24 +869,10 @@ static void *snp_alloc_vmsa_page(int cpu) · 27 unmodified lines
754	return page_address(p + 1);	869	return page_address(p + 1);
755	}	870	}
756		871
757	static void snp_cleanup_vmsa(struct sev_es_save_area *vmsa, int apic_id)
758	{
759	int err;
760
761	err = snp_set_vmsa(vmsa, NULL, apic_id, false);
762	if (err)
763	pr_err("clear VMSA page failed (%u), leaking page\n", err);
764	else
765	free_page((unsigned long)vmsa);
766	}
767
768	static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip)	872	static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip)
769	{	873	{
770	struct sev_es_save_area cur_vmsa, vmsa;	874	struct sev_es_save_area cur_vmsa, vmsa;
771	struct ghcb_state state;
772	struct svsm_ca *caa;	875	struct svsm_ca *caa;
773	unsigned long flags;
774	struct ghcb *ghcb;
775	u8 sipi_vector;	876	u8 sipi_vector;
776	int cpu, ret;	877	int cpu, ret;
777	u64 cr4;	878	u64 cr4;
@@ -885,33 +986,7 @@ static int wakeup_cpu_via_vmgexit(u32 apic_id, unsigned long start_ip) · 107 unmodified lines
885	}	986	}
886		987
887	/* Issue VMGEXIT AP Creation NAE event */	988	/* Issue VMGEXIT AP Creation NAE event */
888	local_irq_save(flags);	989	ret = vmgexit_ap_control(SVM_VMGEXIT_AP_CREATE, vmsa, apic_id);
889
890	ghcb = __sev_get_ghcb(&state);
891
892	vc_ghcb_invalidate(ghcb);
893	ghcb_set_rax(ghcb, vmsa->sev_features);
894	ghcb_set_sw_exit_code(ghcb, SVM_VMGEXIT_AP_CREATION);
895	ghcb_set_sw_exit_info_1(ghcb,
896	((u64)apic_id << 32) \|
897	((u64)snp_vmpl << 16) \|
898	SVM_VMGEXIT_AP_CREATE);
899	ghcb_set_sw_exit_info_2(ghcb, __pa(vmsa));
900
901	sev_es_wr_ghcb_msr(__pa(ghcb));
902	VMGEXIT();
903
904	if (!ghcb_sw_exit_info_1_is_valid(ghcb) \|\|
905	lower_32_bits(ghcb->save.sw_exit_info_1)) {
906	pr_err("SNP AP Creation error\n");
907	ret = -EINVAL;
908	}
909
910	__sev_put_ghcb(&state);
911
912	local_irq_restore(flags);
913
914	/* Perform cleanup if there was an error */
915	if (ret) {	990	if (ret) {
916	snp_cleanup_vmsa(vmsa, apic_id);	991	snp_cleanup_vmsa(vmsa, apic_id);
917	vmsa = NULL;	992	vmsa = NULL;

arch/x86/events/intel/ds.c+5−4

 				setup_pebs_fixed_sample_data);
 }
-static void intel_pmu_pebs_event_update_no_drain(struct cpu_hw_events *cpuc, int size)
+static void intel_pmu_pebs_event_update_no_drain(struct cpu_hw_events *cpuc, u64 mask)
 {
+	u64 pebs_enabled = cpuc->pebs_enabled & mask;
 	struct perf_event *event;
 	int bit;
 	 * It needs to call intel_pmu_save_and_restart_reload() to
 	 * update the event->count for this case.
 	 */
-	for_each_set_bit(bit, (unsigned long *)&cpuc->pebs_enabled, size) {
+	for_each_set_bit(bit, (unsigned long *)&pebs_enabled, X86_PMC_IDX_MAX) {
 		event = cpuc->events[bit];
 		if (event->hw.flags & PERF_X86_EVENT_AUTO_RELOAD)
 			intel_pmu_save_and_restart_reload(event, 0);
 	}
 	if (unlikely(base >= top)) {
-		intel_pmu_pebs_event_update_no_drain(cpuc, size);
+		intel_pmu_pebs_event_update_no_drain(cpuc, mask);
 		return;
 	}
 	       (hybrid(cpuc->pmu, fixed_cntr_mask64) << INTEL_PMC_IDX_FIXED);
 	if (unlikely(base >= top)) {
-		intel_pmu_pebs_event_update_no_drain(cpuc, X86_PMC_IDX_MAX);
+		intel_pmu_pebs_event_update_no_drain(cpuc, mask);
 		return;
 	}

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

@@ -75,7 +75,7 @@ · 74 unmodified lines
75	#define X86_FEATURE_CENTAUR_MCR ( 332+ 3) / "centaur_mcr" Centaur MCRs (= MTRRs) */	75	#define X86_FEATURE_CENTAUR_MCR ( 332+ 3) / "centaur_mcr" Centaur MCRs (= MTRRs) */
76	#define X86_FEATURE_K8 ( 332+ 4) / Opteron, Athlon64 */	76	#define X86_FEATURE_K8 ( 332+ 4) / Opteron, Athlon64 */
77	#define X86_FEATURE_ZEN5 ( 332+ 5) / CPU based on Zen5 microarchitecture */	77	#define X86_FEATURE_ZEN5 ( 332+ 5) / CPU based on Zen5 microarchitecture */
78	/* Free ( 332+ 6) /	78	#define X86_FEATURE_ZEN6 ( 332+ 6) / CPU based on Zen6 microarchitecture */
79	/* Free ( 332+ 7) /	79	/* Free ( 332+ 7) /
80	#define X86_FEATURE_CONSTANT_TSC ( 332+ 8) / "constant_tsc" TSC ticks at a constant rate */	80	#define X86_FEATURE_CONSTANT_TSC ( 332+ 8) / "constant_tsc" TSC ticks at a constant rate */
81	#define X86_FEATURE_UP ( 332+ 9) / "up" SMP kernel running on UP */	81	#define X86_FEATURE_UP ( 332+ 9) / "up" SMP kernel running on UP */

arch/x86/include/asm/sev-common.h+1−1

@@ -116,7 +116,7 @@ enum psc_op { · 115 unmodified lines
116	#define GHCB_MSR_VMPL_REQ 0x016	116	#define GHCB_MSR_VMPL_REQ 0x016
117	#define GHCB_MSR_VMPL_REQ_LEVEL(v) \	117	#define GHCB_MSR_VMPL_REQ_LEVEL(v) \
118	/* GHCBData[39:32] */ \	118	/* GHCBData[39:32] */ \
119	(((u64)(v) & GENMASK_ULL(7, 0) << 32) \| \	119	((((u64)(v) & GENMASK_ULL(7, 0)) << 32) \| \
120	/* GHCBDdata[11:0] */ \	120	/* GHCBDdata[11:0] */ \
121	GHCB_MSR_VMPL_REQ)	121	GHCB_MSR_VMPL_REQ)
122		122

arch/x86/kernel/alternative.c+6−0

 #ifdef CONFIG_MITIGATION_ITS
+#ifdef CONFIG_MODULES
 static struct module *its_mod;
+#endif
 static void *its_page;
 static unsigned int its_offset;
 	return thunk + offset;
 }
+#ifdef CONFIG_MODULES
 void its_init_mod(struct module *mod)
 {
 	if (!cpu_feature_enabled(X86_FEATURE_INDIRECT_THUNK_ITS))
 	}
 	kfree(mod->its_page_array);
 }
+#endif /* CONFIG_MODULES */
 static void *its_alloc(void)
 {
 	if (!page)
 		return NULL;
+#ifdef CONFIG_MODULES
 	if (its_mod) {
 		void *tmp = krealloc(its_mod->its_page_array,
 				     (its_mod->its_num_pages+1) * sizeof(void *),
 		execmem_make_temp_rw(page, PAGE_SIZE);
 	}
+#endif /* CONFIG_MODULES */
 	return no_free_ptr(page);
 }

arch/x86/kernel/cpu/amd.c+5−0

 		case 0x60 ... 0x7f:
 			setup_force_cpu_cap(X86_FEATURE_ZEN5);
 			break;
+		case 0x50 ... 0x5f:
+		case 0x90 ... 0xaf:
+		case 0xc0 ... 0xcf:
+			setup_force_cpu_cap(X86_FEATURE_ZEN6);
+			break;
 		default:
 			goto warn;
 		}

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

@@ -566,7 +566,7 @@ static void __init lowmem_pfn_init(void) · 565 unmodified lines
566	"only %luMB highmem pages available, ignoring highmem size of %luMB!\n"	566	"only %luMB highmem pages available, ignoring highmem size of %luMB!\n"
567		567
568	#define MSG_HIGHMEM_TRIMMED \	568	#define MSG_HIGHMEM_TRIMMED \
569	"Warning: only 4GB will be used. Support for for CONFIG_HIGHMEM64G was removed!\n"	569	"Warning: only 4GB will be used. Support for CONFIG_HIGHMEM64G was removed!\n"
570	/*	570	/*
571	* We have more RAM than fits into lowmem - we try to put it into	571	* We have more RAM than fits into lowmem - we try to put it into
572	* highmem, also taking the highmem=x boot parameter into account:	572	* highmem, also taking the highmem=x boot parameter into account:

block/bio-integrity-auto.c+47−15

  * not aware of PI.
  */
 #include <linux/blk-integrity.h>
+#include <linux/t10-pi.h>
 #include <linux/workqueue.h>
 #include "blk.h"
 	bio_endio(bio);
 }
+#define BIP_CHECK_FLAGS (BIP_CHECK_GUARD | BIP_CHECK_REFTAG | BIP_CHECK_APPTAG)
+static bool bip_should_check(struct bio_integrity_payload *bip)
+{
+	return bip->bip_flags & BIP_CHECK_FLAGS;
+}
+static bool bi_offload_capable(struct blk_integrity *bi)
+{
+	switch (bi->csum_type) {
+	case BLK_INTEGRITY_CSUM_CRC64:
+		return bi->tuple_size == sizeof(struct crc64_pi_tuple);
+	case BLK_INTEGRITY_CSUM_CRC:
+	case BLK_INTEGRITY_CSUM_IP:
+		return bi->tuple_size == sizeof(struct t10_pi_tuple);
+	default:
+		pr_warn_once("%s: unknown integrity checksum type:%d\n",
+			__func__, bi->csum_type);
+		fallthrough;
+	case BLK_INTEGRITY_CSUM_NONE:
+		return false;
+	}
+}
 /**
  * __bio_integrity_endio - Integrity I/O completion function
  * @bio:	Protected bio
  */
 bool __bio_integrity_endio(struct bio *bio)
 {
-	struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 	struct bio_integrity_payload *bip = bio_integrity(bio);
 	struct bio_integrity_data *bid =
 		container_of(bip, struct bio_integrity_data, bip);
-	if (bio_op(bio) == REQ_OP_READ && !bio->bi_status && bi->csum_type) {
+	if (bio_op(bio) == REQ_OP_READ && !bio->bi_status &&
+	    bip_should_check(bip)) {
 		INIT_WORK(&bid->work, bio_integrity_verify_fn);
 		queue_work(kintegrityd_wq, &bid->work);
 		return false;
 {
 	struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 	struct bio_integrity_data *bid;
+	bool set_flags = true;
 	gfp_t gfp = GFP_NOIO;
 	unsigned int len;
 	void *buf;
 	switch (bio_op(bio)) {
 	case REQ_OP_READ:
-		if (bi->flags & BLK_INTEGRITY_NOVERIFY)
+		if (bi->flags & BLK_INTEGRITY_NOVERIFY) {
-			return true;
+			if (bi_offload_capable(bi))
+				return true;
+			set_flags = false;
+		}
 		break;
 	case REQ_OP_WRITE:
-		if (bi->flags & BLK_INTEGRITY_NOGENERATE)
-			return true;
 		/*
 		 * Zero the memory allocated to not leak uninitialized kernel
 		 * memory to disk for non-integrity metadata where nothing else
 		 * initializes the memory.
 		 */
-		if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE)
+		if (bi->flags & BLK_INTEGRITY_NOGENERATE) {
+			if (bi_offload_capable(bi))
+				return true;
+			set_flags = false;
+			gfp |= __GFP_ZERO;
+		} else if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE)
 			gfp |= __GFP_ZERO;
 		break;
 	default:
 	bid->bip.bip_flags |= BIP_BLOCK_INTEGRITY;
 	bip_set_seed(&bid->bip, bio->bi_iter.bi_sector);
-	if (bi->csum_type == BLK_INTEGRITY_CSUM_IP)
+	if (set_flags) {
-		bid->bip.bip_flags |= BIP_IP_CHECKSUM;
+		if (bi->csum_type == BLK_INTEGRITY_CSUM_IP)
-	if (bi->csum_type)
+			bid->bip.bip_flags |= BIP_IP_CHECKSUM;
-		bid->bip.bip_flags |= BIP_CHECK_GUARD;
+		if (bi->csum_type)
-	if (bi->flags & BLK_INTEGRITY_REF_TAG)
+			bid->bip.bip_flags |= BIP_CHECK_GUARD;
-		bid->bip.bip_flags |= BIP_CHECK_REFTAG;
+		if (bi->flags & BLK_INTEGRITY_REF_TAG)
+			bid->bip.bip_flags |= BIP_CHECK_REFTAG;
+	}
 	if (bio_integrity_add_page(bio, virt_to_page(buf), len,
 			offset_in_page(buf)) < len)
 		goto err_end_io;
 	/* Auto-generate integrity metadata if this is a write */
-	if (bio_data_dir(bio) == WRITE)
+	if (bio_data_dir(bio) == WRITE && bip_should_check(&bid->bip))
 		blk_integrity_generate(bio);
 	else
 		bid->saved_bio_iter = bio->bi_iter;

block/bio.c+1−1

@@ -611,7 +611,7 @@ struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask) · 610 unmodified lines
611	{	611	{
612	struct bio *bio;	612	struct bio *bio;
613		613
614	if (nr_vecs > UIO_MAXIOV)	614	if (nr_vecs > BIO_MAX_INLINE_VECS)
615	return NULL;	615	return NULL;
616	return kmalloc(struct_size(bio, bi_inline_vecs, nr_vecs), gfp_mask);	616	return kmalloc(struct_size(bio, bi_inline_vecs, nr_vecs), gfp_mask);
617	}	617	}

drivers/accel/ivpu/ivpu_debugfs.c+1−1

@@ -455,7 +455,7 @@ priority_bands_fops_write(struct file file, const char __user user_buf, size_t · 454 unmodified lines
455	if (ret < 0)	455	if (ret < 0)
456	return ret;	456	return ret;
457		457
458	buf[size] = '\0';	458	buf[ret] = '\0';
459	ret = sscanf(buf, "%u %u %u %u", &band, &grace_period, &process_grace_period,	459	ret = sscanf(buf, "%u %u %u %u", &band, &grace_period, &process_grace_period,
460	&process_quantum);	460	&process_quantum);
461	if (ret != 4)	461	if (ret != 4)

drivers/acpi/pptt.c+8−3

 			     sizeof(struct acpi_table_pptt));
 	proc_sz = sizeof(struct acpi_pptt_processor);
-	while ((unsigned long)entry + proc_sz < table_end) {
+	/* ignore subtable types that are smaller than a processor node */
+	while ((unsigned long)entry + proc_sz <= table_end) {
 		cpu_node = (struct acpi_pptt_processor *)entry;
 		if (entry->type == ACPI_PPTT_TYPE_PROCESSOR &&
 		    cpu_node->parent == node_entry)
 			return 0;
 		if (entry->length == 0)
 			return 0;
 		entry = ACPI_ADD_PTR(struct acpi_subtable_header, entry,
 				     entry->length);
 	}
 	return 1;
 }
 	proc_sz = sizeof(struct acpi_pptt_processor);
 	/* find the processor structure associated with this cpuid */
-	while ((unsigned long)entry + proc_sz < table_end) {
+	while ((unsigned long)entry + proc_sz <= table_end) {
 		cpu_node = (struct acpi_pptt_processor *)entry;
 		if (entry->length == 0) {
 			pr_warn("Invalid zero length subtable\n");
 			break;
 		}
+		/* entry->length may not equal proc_sz, revalidate the processor structure length */
 		if (entry->type == ACPI_PPTT_TYPE_PROCESSOR &&
 		    acpi_cpu_id == cpu_node->acpi_processor_id &&
+		    (unsigned long)entry + entry->length <= table_end &&
+		    entry->length == proc_sz + cpu_node->number_of_priv_resources * sizeof(u32) &&
 		     acpi_pptt_leaf_node(table_hdr, cpu_node)) {
 			return (struct acpi_pptt_processor *)entry;
 		}

drivers/block/ublk_drv.c+1−1

@@ -1708,7 +1708,7 @@ static void ublk_cancel_cmd(struct ublk_queue *ubq, unsigned tag, · 1707 unmodified lines
1708	* that ublk_dispatch_req() is always called	1708	* that ublk_dispatch_req() is always called
1709	*/	1709	*/
1710	req = blk_mq_tag_to_rq(ub->tag_set.tags[ubq->q_id], tag);	1710	req = blk_mq_tag_to_rq(ub->tag_set.tags[ubq->q_id], tag);
1711	if (req && blk_mq_request_started(req))	1711	if (req && blk_mq_request_started(req) && req->tag == tag)
1712	return;	1712	return;
1713		1713
1714	spin_lock(&ubq->cancel_lock);	1714	spin_lock(&ubq->cancel_lock);

drivers/char/tpm/tpm-buf.c+3−3

@@ -201,7 +201,7 @@ static void tpm_buf_read(struct tpm_buf buf, off_t offset, size_t count, void · 200 unmodified lines
201	*/	201	*/
202	u8 tpm_buf_read_u8(struct tpm_buf buf, off_t offset)	202	u8 tpm_buf_read_u8(struct tpm_buf buf, off_t offset)
203	{	203	{
204	u8 value;	204	u8 value = 0;
205		205
206	tpm_buf_read(buf, offset, sizeof(value), &value);	206	tpm_buf_read(buf, offset, sizeof(value), &value);
207		207
@@ -218,7 +218,7 @@ EXPORT_SYMBOL_GPL(tpm_buf_read_u8); · 10 unmodified lines
218	*/	218	*/
219	u16 tpm_buf_read_u16(struct tpm_buf buf, off_t offset)	219	u16 tpm_buf_read_u16(struct tpm_buf buf, off_t offset)
220	{	220	{
221	u16 value;	221	u16 value = 0;
222		222
223	tpm_buf_read(buf, offset, sizeof(value), &value);	223	tpm_buf_read(buf, offset, sizeof(value), &value);
224		224
@@ -235,7 +235,7 @@ EXPORT_SYMBOL_GPL(tpm_buf_read_u16); · 10 unmodified lines
235	*/	235	*/
236	u32 tpm_buf_read_u32(struct tpm_buf buf, off_t offset)	236	u32 tpm_buf_read_u32(struct tpm_buf buf, off_t offset)
237	{	237	{
238	u32 value;	238	u32 value = 0;
239		239
240	tpm_buf_read(buf, offset, sizeof(value), &value);	240	tpm_buf_read(buf, offset, sizeof(value), &value);
241		241

drivers/char/tpm/tpm2-sessions.c+6−14

  *
  * These are the usage functions:
  *
- * tpm2_start_auth_session() which allocates the opaque auth structure
- *	and gets a session from the TPM.  This must be called before
- *	any of the following functions.  The session is protected by a
- *	session_key which is derived from a random salt value
- *	encrypted to the NULL seed.
  * tpm2_end_auth_session() kills the session and frees the resources.
  *	Under normal operation this function is done by
  *	tpm_buf_check_hmac_response(), so this is only to be used on
 }
 /**
- * tpm2_start_auth_session() - create a HMAC authentication session with the TPM
+ * tpm2_start_auth_session() - Create an a HMAC authentication session
- * @chip: the TPM chip structure to create the session with
+ * @chip:	A TPM chip
  *
- * This function loads the NULL seed from its saved context and starts
+ * Loads the ephemeral key (null seed), and starts an HMAC authenticated
- * an authentication session on the null seed, fills in the
+ * session. The null seed is flushed before the return.
- * @chip->auth structure to contain all the session details necessary
- * for performing the HMAC, encrypt and decrypt operations and
- * returns.  The NULL seed is flushed before this function returns.
  *
- * Return: zero on success or actual error encountered.
+ * Returns zero on success, or a POSIX error code.
  */
 int tpm2_start_auth_session(struct tpm_chip *chip)
 {
 	/* hash algorithm for session */
 	tpm_buf_append_u16(&buf, TPM_ALG_SHA256);
-	rc = tpm_transmit_cmd(chip, &buf, 0, "start auth session");
+	rc = tpm_ret_to_err(tpm_transmit_cmd(chip, &buf, 0, "StartAuthSession"));
 	tpm2_flush_context(chip, null_key);
 	if (rc == TPM2_RC_SUCCESS)

drivers/char/tpm/tpm_tis_core.h+1−1

@@ -54,7 +54,7 @@ enum tis_int_flags { · 53 unmodified lines
54	enum tis_defaults {	54	enum tis_defaults {
55	TIS_MEM_LEN = 0x5000,	55	TIS_MEM_LEN = 0x5000,
56	TIS_SHORT_TIMEOUT = 750, /* ms */	56	TIS_SHORT_TIMEOUT = 750, /* ms */
57	TIS_LONG_TIMEOUT = 2000, /* 2 sec */	57	TIS_LONG_TIMEOUT = 4000, /* 4 secs */
58	TIS_TIMEOUT_MIN_ATML = 14700, /* usecs */	58	TIS_TIMEOUT_MIN_ATML = 14700, /* usecs */
59	TIS_TIMEOUT_MAX_ATML = 15000, /* usecs */	59	TIS_TIMEOUT_MAX_ATML = 15000, /* usecs */
60	};	60	};

drivers/dma-buf/dma-resv.c+3−2

@@ -320,8 +320,9 @@ void dma_resv_add_fence(struct dma_resv obj, struct dma_fence fence, · 319 unmodified lines
320	count++;	320	count++;
321		321
322	dma_resv_list_set(fobj, i, fence, usage);	322	dma_resv_list_set(fobj, i, fence, usage);
323	/* pointer update must be visible before we extend the num_fences */	323	/* fence update must be visible before we extend the num_fences */
324	smp_store_mb(fobj->num_fences, count);	324	smp_wmb();
		325	fobj->num_fences = count;
325	}	326	}
326	EXPORT_SYMBOL(dma_resv_add_fence);	327	EXPORT_SYMBOL(dma_resv_add_fence);
327		328

drivers/dma/amd/ptdma/ptdma-dmaengine.c+10−9

 	struct pt_dma_chan *chan;
 	unsigned long flags;
+	if (!desc)
+		return;
 	dma_chan = desc->vd.tx.chan;
 	chan = to_pt_chan(dma_chan);
 		desc->status = DMA_ERROR;
 	spin_lock_irqsave(&chan->vc.lock, flags);
-	if (desc) {
+	if (desc->status != DMA_COMPLETE) {
-		if (desc->status != DMA_COMPLETE) {
+		if (desc->status != DMA_ERROR)
-			if (desc->status != DMA_ERROR)
+			desc->status = DMA_COMPLETE;
-				desc->status = DMA_COMPLETE;
-			dma_cookie_complete(tx_desc);
+		dma_cookie_complete(tx_desc);
-			dma_descriptor_unmap(tx_desc);
+		dma_descriptor_unmap(tx_desc);
-		} else {
+	} else {
-			tx_desc = NULL;
+		tx_desc = NULL;
-		}
 	}
 	spin_unlock_irqrestore(&chan->vc.lock, flags);

drivers/dma/dmatest.c+3−3

@@ -841,9 +841,9 @@ static int dmatest_func(void *data) · 840 unmodified lines
841	} else {	841	} else {
842	dma_async_issue_pending(chan);	842	dma_async_issue_pending(chan);
843		843
844	wait_event_timeout(thread->done_wait,	844	wait_event_freezable_timeout(thread->done_wait,
845	done->done,	845	done->done,
846	msecs_to_jiffies(params->timeout));	846	msecs_to_jiffies(params->timeout));
847		847
848	status = dma_async_is_tx_complete(chan, cookie, NULL,	848	status = dma_async_is_tx_complete(chan, cookie, NULL,
849	NULL);	849	NULL);

drivers/dma/fsl-edma-main.c+1−1

@@ -57,7 +57,7 @@ static irqreturn_t fsl_edma3_tx_handler(int irq, void *dev_id) · 56 unmodified lines
57		57
58	intr = edma_readl_chreg(fsl_chan, ch_int);	58	intr = edma_readl_chreg(fsl_chan, ch_int);
59	if (!intr)	59	if (!intr)
60	return IRQ_HANDLED;	60	return IRQ_NONE;
61		61
62	edma_writel_chreg(fsl_chan, 1, ch_int);	62	edma_writel_chreg(fsl_chan, 1, ch_int);
63		63

drivers/dma/idxd/cdev.c+11−2

 	struct idxd_wq *wq;
 	struct device *dev, *fdev;
 	int rc = 0;
-	struct iommu_sva *sva;
+	struct iommu_sva *sva = NULL;
 	unsigned int pasid;
 	struct idxd_cdev *idxd_cdev;
 	if (device_user_pasid_enabled(idxd))
 		idxd_xa_pasid_remove(ctx);
 failed_get_pasid:
-	if (device_user_pasid_enabled(idxd))
+	if (device_user_pasid_enabled(idxd) && !IS_ERR_OR_NULL(sva))
 		iommu_sva_unbind_device(sva);
 failed:
 	mutex_unlock(&wq->wq_lock);
 	if (!idxd->user_submission_safe && !capable(CAP_SYS_RAWIO))
 		return -EPERM;
+	if (current->mm != ctx->mm)
+		return -EPERM;
 	rc = check_vma(wq, vma, __func__);
 	if (rc < 0)
 		return rc;
 	ssize_t written = 0;
 	int i;
+	if (current->mm != ctx->mm)
+		return -EPERM;
 	for (i = 0; i < len/sizeof(struct dsa_hw_desc); i++) {
 		int rc = idxd_submit_user_descriptor(ctx, udesc + i);
 	struct idxd_device *idxd = wq->idxd;
 	__poll_t out = 0;
+	if (current->mm != ctx->mm)
+		return POLLNVAL;
 	poll_wait(filp, &wq->err_queue, wait);
 	spin_lock(&idxd->dev_lock);
 	if (idxd->sw_err.valid)

drivers/dma/idxd/init.c+113−46

@@ -155,6 +155,25 @@ static void idxd_cleanup_interrupts(struct idxd_device *idxd) · 154 unmodified lines
155	pci_free_irq_vectors(pdev);	155	pci_free_irq_vectors(pdev);
156	}	156	}
157		157
		158	static void idxd_clean_wqs(struct idxd_device *idxd)
		159	{
		160	struct idxd_wq *wq;
		161	struct device *conf_dev;
		162	int i;
		163
		164	for (i = 0; i < idxd->max_wqs; i++) {
		165	wq = idxd->wqs[i];
		166	if (idxd->hw.wq_cap.op_config)
		167	bitmap_free(wq->opcap_bmap);
		168	kfree(wq->wqcfg);
		169	conf_dev = wq_confdev(wq);
		170	put_device(conf_dev);
		171	kfree(wq);
		172	}
		173	bitmap_free(idxd->wq_enable_map);
		174	kfree(idxd->wqs);
		175	}
		176
158	static int idxd_setup_wqs(struct idxd_device *idxd)	177	static int idxd_setup_wqs(struct idxd_device *idxd)
159	{	178	{
160	struct device *dev = &idxd->pdev->dev;	179	struct device *dev = &idxd->pdev->dev;
@@ -169,8 +188,8 @@ static int idxd_setup_wqs(struct idxd_device *idxd) · 8 unmodified lines
169		188
170	idxd->wq_enable_map = bitmap_zalloc_node(idxd->max_wqs, GFP_KERNEL, dev_to_node(dev));	189	idxd->wq_enable_map = bitmap_zalloc_node(idxd->max_wqs, GFP_KERNEL, dev_to_node(dev));
171	if (!idxd->wq_enable_map) {	190	if (!idxd->wq_enable_map) {
172	kfree(idxd->wqs);	191	rc = -ENOMEM;
173	return -ENOMEM;	192	goto err_bitmap;
174	}	193	}
175		194
176	for (i = 0; i < idxd->max_wqs; i++) {	195	for (i = 0; i < idxd->max_wqs; i++) {
@@ -189,10 +208,8 @@ static int idxd_setup_wqs(struct idxd_device *idxd) · 12 unmodified lines
189	conf_dev->bus = &dsa_bus_type;	208	conf_dev->bus = &dsa_bus_type;
190	conf_dev->type = &idxd_wq_device_type;	209	conf_dev->type = &idxd_wq_device_type;
191	rc = dev_set_name(conf_dev, "wq%d.%d", idxd->id, wq->id);	210	rc = dev_set_name(conf_dev, "wq%d.%d", idxd->id, wq->id);
192	if (rc < 0) {	211	if (rc < 0)
193	put_device(conf_dev);
194	goto err;	212	goto err;
195	}
196		213
197	mutex_init(&wq->wq_lock);	214	mutex_init(&wq->wq_lock);
198	init_waitqueue_head(&wq->err_queue);	215	init_waitqueue_head(&wq->err_queue);
@@ -203,7 +220,6 @@ static int idxd_setup_wqs(struct idxd_device *idxd) · 4 unmodified lines
203	wq->enqcmds_retries = IDXD_ENQCMDS_RETRIES;	220	wq->enqcmds_retries = IDXD_ENQCMDS_RETRIES;
204	wq->wqcfg = kzalloc_node(idxd->wqcfg_size, GFP_KERNEL, dev_to_node(dev));	221	wq->wqcfg = kzalloc_node(idxd->wqcfg_size, GFP_KERNEL, dev_to_node(dev));
205	if (!wq->wqcfg) {	222	if (!wq->wqcfg) {
206	put_device(conf_dev);
207	rc = -ENOMEM;	223	rc = -ENOMEM;
208	goto err;	224	goto err;
209	}	225	}
@@ -211,9 +227,8 @@ static int idxd_setup_wqs(struct idxd_device *idxd) · 1 unmodified line
211	if (idxd->hw.wq_cap.op_config) {	227	if (idxd->hw.wq_cap.op_config) {
212	wq->opcap_bmap = bitmap_zalloc(IDXD_MAX_OPCAP_BITS, GFP_KERNEL);	228	wq->opcap_bmap = bitmap_zalloc(IDXD_MAX_OPCAP_BITS, GFP_KERNEL);
213	if (!wq->opcap_bmap) {	229	if (!wq->opcap_bmap) {
214	put_device(conf_dev);
215	rc = -ENOMEM;	230	rc = -ENOMEM;
216	goto err;	231	goto err_opcap_bmap;
217	}	232	}
218	bitmap_copy(wq->opcap_bmap, idxd->opcap_bmap, IDXD_MAX_OPCAP_BITS);	233	bitmap_copy(wq->opcap_bmap, idxd->opcap_bmap, IDXD_MAX_OPCAP_BITS);
219	}	234	}
@@ -224,15 +239,46 @@ static int idxd_setup_wqs(struct idxd_device *idxd) · 4 unmodified lines
224		239
225	return 0;	240	return 0;
226		241
227	err:	242	err_opcap_bmap:
		243	kfree(wq->wqcfg);
		244
		245	err:
		246	put_device(conf_dev);
		247	kfree(wq);
		248
228	while (--i >= 0) {	249	while (--i >= 0) {
229	wq = idxd->wqs[i];	250	wq = idxd->wqs[i];
		251	if (idxd->hw.wq_cap.op_config)
		252	bitmap_free(wq->opcap_bmap);
		253	kfree(wq->wqcfg);
230	conf_dev = wq_confdev(wq);	254	conf_dev = wq_confdev(wq);
231	put_device(conf_dev);	255	put_device(conf_dev);
		256	kfree(wq);
		257
232	}	258	}
		259	bitmap_free(idxd->wq_enable_map);
		260
		261	err_bitmap:
		262	kfree(idxd->wqs);
		263
233	return rc;	264	return rc;
234	}	265	}
235		266
		267	static void idxd_clean_engines(struct idxd_device *idxd)
		268	{
		269	struct idxd_engine *engine;
		270	struct device *conf_dev;
		271	int i;
		272
		273	for (i = 0; i < idxd->max_engines; i++) {
		274	engine = idxd->engines[i];
		275	conf_dev = engine_confdev(engine);
		276	put_device(conf_dev);
		277	kfree(engine);
		278	}
		279	kfree(idxd->engines);
		280	}
		281
236	static int idxd_setup_engines(struct idxd_device *idxd)	282	static int idxd_setup_engines(struct idxd_device *idxd)
237	{	283	{
238	struct idxd_engine *engine;	284	struct idxd_engine *engine;
@@ -263,6 +309,7 @@ static int idxd_setup_engines(struct idxd_device *idxd) · 24 unmodified lines
263	rc = dev_set_name(conf_dev, "engine%d.%d", idxd->id, engine->id);	309	rc = dev_set_name(conf_dev, "engine%d.%d", idxd->id, engine->id);
264	if (rc < 0) {	310	if (rc < 0) {
265	put_device(conf_dev);	311	put_device(conf_dev);
		312	kfree(engine);
266	goto err;	313	goto err;
267	}	314	}
268		315
@@ -276,10 +323,26 @@ static int idxd_setup_engines(struct idxd_device *idxd) · 7 unmodified lines
276	engine = idxd->engines[i];	323	engine = idxd->engines[i];
277	conf_dev = engine_confdev(engine);	324	conf_dev = engine_confdev(engine);
278	put_device(conf_dev);	325	put_device(conf_dev);
		326	kfree(engine);
279	}	327	}
		328	kfree(idxd->engines);
		329
280	return rc;	330	return rc;
281	}	331	}
282		332
		333	static void idxd_clean_groups(struct idxd_device *idxd)
		334	{
		335	struct idxd_group *group;
		336	int i;
		337
		338	for (i = 0; i < idxd->max_groups; i++) {
		339	group = idxd->groups[i];
		340	put_device(group_confdev(group));
		341	kfree(group);
		342	}
		343	kfree(idxd->groups);
		344	}
		345
283	static int idxd_setup_groups(struct idxd_device *idxd)	346	static int idxd_setup_groups(struct idxd_device *idxd)
284	{	347	{
285	struct device *dev = &idxd->pdev->dev;	348	struct device *dev = &idxd->pdev->dev;
@@ -310,6 +373,7 @@ static int idxd_setup_groups(struct idxd_device *idxd) · 24 unmodified lines
310	rc = dev_set_name(conf_dev, "group%d.%d", idxd->id, group->id);	373	rc = dev_set_name(conf_dev, "group%d.%d", idxd->id, group->id);
311	if (rc < 0) {	374	if (rc < 0) {
312	put_device(conf_dev);	375	put_device(conf_dev);
		376	kfree(group);
313	goto err;	377	goto err;
314	}	378	}
315		379
@@ -334,20 +398,18 @@ static int idxd_setup_groups(struct idxd_device *idxd) · 18 unmodified lines
334	while (--i >= 0) {	398	while (--i >= 0) {
335	group = idxd->groups[i];	399	group = idxd->groups[i];
336	put_device(group_confdev(group));	400	put_device(group_confdev(group));
		401	kfree(group);
337	}	402	}
		403	kfree(idxd->groups);
		404
338	return rc;	405	return rc;
339	}	406	}
340		407
341	static void idxd_cleanup_internals(struct idxd_device *idxd)	408	static void idxd_cleanup_internals(struct idxd_device *idxd)
342	{	409	{
343	int i;	410	idxd_clean_groups(idxd);
344		411	idxd_clean_engines(idxd);
345	for (i = 0; i < idxd->max_groups; i++)	412	idxd_clean_wqs(idxd);
346	put_device(group_confdev(idxd->groups[i]));
347	for (i = 0; i < idxd->max_engines; i++)
348	put_device(engine_confdev(idxd->engines[i]));
349	for (i = 0; i < idxd->max_wqs; i++)
350	put_device(wq_confdev(idxd->wqs[i]));
351	destroy_workqueue(idxd->wq);	413	destroy_workqueue(idxd->wq);
352	}	414	}
353		415
@@ -390,7 +452,7 @@ static int idxd_init_evl(struct idxd_device *idxd) · 36 unmodified lines
390	static int idxd_setup_internals(struct idxd_device *idxd)	452	static int idxd_setup_internals(struct idxd_device *idxd)
391	{	453	{
392	struct device *dev = &idxd->pdev->dev;	454	struct device *dev = &idxd->pdev->dev;
393	int rc, i;	455	int rc;
394		456
395	init_waitqueue_head(&idxd->cmd_waitq);	457	init_waitqueue_head(&idxd->cmd_waitq);
396		458
@@ -421,14 +483,11 @@ static int idxd_setup_internals(struct idxd_device *idxd) · 24 unmodified lines
421	err_evl:	483	err_evl:
422	destroy_workqueue(idxd->wq);	484	destroy_workqueue(idxd->wq);
423	err_wkq_create:	485	err_wkq_create:
424	for (i = 0; i < idxd->max_groups; i++)	486	idxd_clean_groups(idxd);
425	put_device(group_confdev(idxd->groups[i]));
426	err_group:	487	err_group:
427	for (i = 0; i < idxd->max_engines; i++)	488	idxd_clean_engines(idxd);
428	put_device(engine_confdev(idxd->engines[i]));
429	err_engine:	489	err_engine:
430	for (i = 0; i < idxd->max_wqs; i++)	490	idxd_clean_wqs(idxd);
431	put_device(wq_confdev(idxd->wqs[i]));
432	err_wqs:	491	err_wqs:
433	return rc;	492	return rc;
434	}	493	}
@@ -528,6 +587,17 @@ static void idxd_read_caps(struct idxd_device *idxd) · 93 unmodified lines
528	idxd->hw.iaa_cap.bits = ioread64(idxd->reg_base + IDXD_IAACAP_OFFSET);	587	idxd->hw.iaa_cap.bits = ioread64(idxd->reg_base + IDXD_IAACAP_OFFSET);
529	}	588	}
530		589
		590	static void idxd_free(struct idxd_device *idxd)
		591	{
		592	if (!idxd)
		593	return;
		594
		595	put_device(idxd_confdev(idxd));
		596	bitmap_free(idxd->opcap_bmap);
		597	ida_free(&idxd_ida, idxd->id);
		598	kfree(idxd);
		599	}
		600
531	static struct idxd_device idxd_alloc(struct pci_dev pdev, struct idxd_driver_data *data)	601	static struct idxd_device idxd_alloc(struct pci_dev pdev, struct idxd_driver_data *data)
532	{	602	{
533	struct device *dev = &pdev->dev;	603	struct device *dev = &pdev->dev;
@@ -545,28 +615,34 @@ static struct idxd_device idxd_alloc(struct pci_dev pdev, struct idxd_driver_d · 11 unmodified lines
545	idxd_dev_set_type(&idxd->idxd_dev, idxd->data->type);	615	idxd_dev_set_type(&idxd->idxd_dev, idxd->data->type);
546	idxd->id = ida_alloc(&idxd_ida, GFP_KERNEL);	616	idxd->id = ida_alloc(&idxd_ida, GFP_KERNEL);
547	if (idxd->id < 0)	617	if (idxd->id < 0)
548	return NULL;	618	goto err_ida;
549		619
550	idxd->opcap_bmap = bitmap_zalloc_node(IDXD_MAX_OPCAP_BITS, GFP_KERNEL, dev_to_node(dev));	620	idxd->opcap_bmap = bitmap_zalloc_node(IDXD_MAX_OPCAP_BITS, GFP_KERNEL, dev_to_node(dev));
551	if (!idxd->opcap_bmap) {	621	if (!idxd->opcap_bmap)
552	ida_free(&idxd_ida, idxd->id);	622	goto err_opcap;
553	return NULL;
554	}
555		623
556	device_initialize(conf_dev);	624	device_initialize(conf_dev);
557	conf_dev->parent = dev;	625	conf_dev->parent = dev;
558	conf_dev->bus = &dsa_bus_type;	626	conf_dev->bus = &dsa_bus_type;
559	conf_dev->type = idxd->data->dev_type;	627	conf_dev->type = idxd->data->dev_type;
560	rc = dev_set_name(conf_dev, "%s%d", idxd->data->name_prefix, idxd->id);	628	rc = dev_set_name(conf_dev, "%s%d", idxd->data->name_prefix, idxd->id);
561	if (rc < 0) {	629	if (rc < 0)
562	put_device(conf_dev);	630	goto err_name;
563	return NULL;
564	}
565		631
566	spin_lock_init(&idxd->dev_lock);	632	spin_lock_init(&idxd->dev_lock);
567	spin_lock_init(&idxd->cmd_lock);	633	spin_lock_init(&idxd->cmd_lock);
568		634
569	return idxd;	635	return idxd;
		636
		637	err_name:
		638	put_device(conf_dev);
		639	bitmap_free(idxd->opcap_bmap);
		640	err_opcap:
		641	ida_free(&idxd_ida, idxd->id);
		642	err_ida:
		643	kfree(idxd);
		644
		645	return NULL;
570	}	646	}
571		647
572	static int idxd_enable_system_pasid(struct idxd_device *idxd)	648	static int idxd_enable_system_pasid(struct idxd_device *idxd)
@@ -1190,7 +1266,7 @@ int idxd_pci_probe_alloc(struct idxd_device idxd, struct pci_dev pdev, · 617 unmodified lines
1190	err:	1266	err:
1191	pci_iounmap(pdev, idxd->reg_base);	1267	pci_iounmap(pdev, idxd->reg_base);
1192	err_iomap:	1268	err_iomap:
1193	put_device(idxd_confdev(idxd));	1269	idxd_free(idxd);
1194	err_idxd_alloc:	1270	err_idxd_alloc:
1195	pci_disable_device(pdev);	1271	pci_disable_device(pdev);
1196	return rc;	1272	return rc;
@@ -1232,7 +1308,6 @@ static void idxd_shutdown(struct pci_dev *pdev) · 35 unmodified lines
1232	static void idxd_remove(struct pci_dev *pdev)	1308	static void idxd_remove(struct pci_dev *pdev)
1233	{	1309	{
1234	struct idxd_device *idxd = pci_get_drvdata(pdev);	1310	struct idxd_device *idxd = pci_get_drvdata(pdev);
1235	struct idxd_irq_entry *irq_entry;
1236		1311
1237	idxd_unregister_devices(idxd);	1312	idxd_unregister_devices(idxd);
1238	/*	1313	/*
@@ -1245,20 +1320,12 @@ static void idxd_remove(struct pci_dev *pdev) · 6 unmodified lines
1245	get_device(idxd_confdev(idxd));	1320	get_device(idxd_confdev(idxd));
1246	device_unregister(idxd_confdev(idxd));	1321	device_unregister(idxd_confdev(idxd));
1247	idxd_shutdown(pdev);	1322	idxd_shutdown(pdev);
1248	if (device_pasid_enabled(idxd))
1249	idxd_disable_system_pasid(idxd);
1250	idxd_device_remove_debugfs(idxd);	1323	idxd_device_remove_debugfs(idxd);
1251		1324	idxd_cleanup(idxd);
1252	irq_entry = idxd_get_ie(idxd, 0);
1253	free_irq(irq_entry->vector, irq_entry);
1254	pci_free_irq_vectors(pdev);
1255	pci_iounmap(pdev, idxd->reg_base);	1325	pci_iounmap(pdev, idxd->reg_base);
1256	if (device_user_pasid_enabled(idxd))
1257	idxd_disable_sva(pdev);
1258	pci_disable_device(pdev);
1259	destroy_workqueue(idxd->wq);
1260	perfmon_pmu_remove(idxd);
1261	put_device(idxd_confdev(idxd));	1326	put_device(idxd_confdev(idxd));
		1327	idxd_free(idxd);
		1328	pci_disable_device(pdev);
1262	}	1329	}
1263		1330
1264	static struct pci_driver idxd_pci_driver = {	1331	static struct pci_driver idxd_pci_driver = {

drivers/dma/mediatek/mtk-cqdma.c+2−4

 {
 	struct mtk_cqdma_vchan *cvc = to_cqdma_vchan(c);
 	struct virt_dma_desc *vd;
-	unsigned long flags;
-	spin_lock_irqsave(&cvc->pc->lock, flags);
 	list_for_each_entry(vd, &cvc->pc->queue, node)
 		if (vd->tx.cookie == cookie) {
-			spin_unlock_irqrestore(&cvc->pc->lock, flags);
 			return vd;
 		}
-	spin_unlock_irqrestore(&cvc->pc->lock, flags);
 	list_for_each_entry(vd, &cvc->vc.desc_issued, node)
 		if (vd->tx.cookie == cookie)
 	if (ret == DMA_COMPLETE || !txstate)
 		return ret;
+	spin_lock_irqsave(&cvc->pc->lock, flags);
 	spin_lock_irqsave(&cvc->vc.lock, flags);
 	vd = mtk_cqdma_find_active_desc(c, cookie);
 	spin_unlock_irqrestore(&cvc->vc.lock, flags);
+	spin_unlock_irqrestore(&cvc->pc->lock, flags);
 	if (vd) {
 		cvd = to_cqdma_vdesc(vd);

drivers/dma/ti/k3-udma.c+8−2

 	u32 residue_diff;
 	ktime_t time_diff;
 	unsigned long delay;
+	unsigned long flags;
 	while (1) {
+		spin_lock_irqsave(&uc->vc.lock, flags);
 		if (uc->desc) {
 			/* Get previous residue and time stamp */
 			residue_diff = uc->tx_drain.residue;
 				break;
 			}
+			spin_unlock_irqrestore(&uc->vc.lock, flags);
 			usleep_range(ktime_to_us(delay),
 				     ktime_to_us(delay) + 10);
 			continue;
 		break;
 	}
+	spin_unlock_irqrestore(&uc->vc.lock, flags);
 }
 static irqreturn_t udma_ring_irq_handler(int irq, void *data)
 				      struct of_dma *ofdma)
 {
 	struct udma_dev *ud = ofdma->of_dma_data;
-	dma_cap_mask_t mask = ud->ddev.cap_mask;
 	struct udma_filter_param filter_param;
 	struct dma_chan *chan;
 		}
 	}
-	chan = __dma_request_channel(&mask, udma_dma_filter_fn, &filter_param,
+	chan = __dma_request_channel(&ud->ddev.cap_mask, udma_dma_filter_fn, &filter_param,
 				     ofdma->of_node);
 	if (!chan) {
 		dev_err(ud->dev, "get channel fail in %s.\n", __func__);

drivers/gpio/gpio-pca953x.c+6−0

 	guard(mutex)(&chip->i2c_lock);
+	if (chip->client->irq > 0)
+		enable_irq(chip->client->irq);
 	regcache_cache_only(chip->regmap, false);
 	regcache_mark_dirty(chip->regmap);
 	ret = pca953x_regcache_sync(chip);
 static void pca953x_save_context(struct pca953x_chip *chip)
 {
 	guard(mutex)(&chip->i2c_lock);
+	/* Disable IRQ to prevent early triggering while regmap "cache only" is on */
+	if (chip->client->irq > 0)
+		disable_irq(chip->client->irq);
 	regcache_cache_only(chip->regmap, true);
 }

drivers/gpio/gpio-virtuser.c+10−2

 	char buf[32], *trimmed;
 	int ret, dir, val = 0;
-	ret = simple_write_to_buffer(buf, sizeof(buf), ppos, user_buf, count);
+	if (count >= sizeof(buf))
+		return -EINVAL;
+	ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 	if (ret < 0)
 		return ret;
+	buf[ret] = '\0';
 	trimmed = strim(buf);
 	if (strcmp(trimmed, "input") == 0) {
 	char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 2];
 	int ret;
+	if (count >= sizeof(buf))
+		return -EINVAL;
 	ret = simple_write_to_buffer(buf, GPIO_VIRTUSER_NAME_BUF_LEN, ppos,
 				     user_buf, count);
 	if (ret < 0)
 		return ret;
-	buf[strlen(buf) - 1] = '\0';
+	buf[ret] = '\0';
 	ret = gpiod_set_consumer_name(data->ad.desc, buf);
 	if (ret)

drivers/gpu/drm/amd/amdgpu/amdgpu_csa.c+1−1

@@ -109,7 +109,7 @@ int amdgpu_unmap_static_csa(struct amdgpu_device adev, struct amdgpu_vm vm, · 108 unmodified lines
109	struct drm_exec exec;	109	struct drm_exec exec;
110	int r;	110	int r;
111		111
112	drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT, 0);	112	drm_exec_init(&exec, 0, 0);
113	drm_exec_until_all_locked(&exec) {	113	drm_exec_until_all_locked(&exec) {
114	r = amdgpu_vm_lock_pd(vm, &exec, 0);	114	r = amdgpu_vm_lock_pd(vm, &exec, 0);
115	if (likely(!r))	115	if (likely(!r))

drivers/gpu/drm/amd/amdgpu/gmc_v11_0.c+12−0

@@ -752,6 +752,18 @@ static int gmc_v11_0_sw_init(struct amdgpu_ip_block *ip_block) · 751 unmodified lines
752	adev->gmc.vram_type = vram_type;	752	adev->gmc.vram_type = vram_type;
753	adev->gmc.vram_vendor = vram_vendor;	753	adev->gmc.vram_vendor = vram_vendor;
754		754
		755	/* The mall_size is already calculated as mall_size_per_umc * num_umc.
		756	* However, for gfx1151, which features a 2-to-1 UMC mapping,
		757	* the result must be multiplied by 2 to determine the actual mall size.
		758	*/
		759	switch (amdgpu_ip_version(adev, GC_HWIP, 0)) {
		760	case IP_VERSION(11, 5, 1):
		761	adev->gmc.mall_size *= 2;
		762	break;
		763	default:
		764	break;
		765	}
		766
755	switch (amdgpu_ip_version(adev, GC_HWIP, 0)) {	767	switch (amdgpu_ip_version(adev, GC_HWIP, 0)) {
756	case IP_VERSION(11, 0, 0):	768	case IP_VERSION(11, 0, 0):
757	case IP_VERSION(11, 0, 1):	769	case IP_VERSION(11, 0, 1):

drivers/gpu/drm/amd/amdgpu/vcn_v4_0_5.c+8−0

 			ring->doorbell_index << VCN_RB1_DB_CTRL__OFFSET__SHIFT |
 			VCN_RB1_DB_CTRL__EN_MASK);
+	/* Keeping one read-back to ensure all register writes are done, otherwise
+	 * it may introduce race conditions */
+	RREG32_SOC15(VCN, inst_idx, regVCN_RB1_DB_CTRL);
 	return 0;
 }
 	WREG32_SOC15(VCN, i, regVCN_RB_ENABLE, tmp);
 	fw_shared->sq.queue_mode &= ~(FW_QUEUE_RING_RESET | FW_QUEUE_DPG_HOLD_OFF);
+	/* Keeping one read-back to ensure all register writes are done, otherwise
+	 * it may introduce race conditions */
+	RREG32_SOC15(VCN, i, regVCN_RB_ENABLE);
 	return 0;
 }

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

 static inline bool is_dc_timing_adjust_needed(struct dm_crtc_state *old_state,
 					      struct dm_crtc_state *new_state)
 {
+	if (new_state->stream->adjust.timing_adjust_pending)
+		return true;
 	if (new_state->freesync_config.state ==  VRR_STATE_ACTIVE_FIXED)
 		return true;
 	else if (amdgpu_dm_crtc_vrr_active(old_state) != amdgpu_dm_crtc_vrr_active(new_state))
 		/* The reply is stored in the top nibble of the command. */
 		payload->reply[0] = (adev->dm.dmub_notify->aux_reply.command >> 4) & 0xF;
-	if (!payload->write && p_notify->aux_reply.length)
+	/*write req may receive a byte indicating partially written number as well*/
+	if (p_notify->aux_reply.length)
 		memcpy(payload->data, p_notify->aux_reply.data,
 				p_notify->aux_reply.length);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c+11−5

 	enum aux_return_code_type operation_result;
 	struct amdgpu_device *adev;
 	struct ddc_service *ddc;
+	uint8_t copy[16];
 	if (WARN_ON(msg->size > 16))
 		return -E2BIG;
 			(msg->request & DP_AUX_I2C_WRITE_STATUS_UPDATE) != 0;
 	payload.defer_delay = 0;
+	if (payload.write) {
+		memcpy(copy, msg->buffer, msg->size);
+		payload.data = copy;
+	}
 	result = dc_link_aux_transfer_raw(TO_DM_AUX(aux)->ddc_service, &payload,
 				      &operation_result);
 	 */
 	if (payload.write && result >= 0) {
 		if (result) {
-			/*one byte indicating partially written bytes. Force 0 to retry*/
+			/*one byte indicating partially written bytes*/
-			drm_info(adev_to_drm(adev), "amdgpu: AUX partially written\n");
+			drm_dbg_dp(adev_to_drm(adev), "amdgpu: AUX partially written\n");
-			result = 0;
+			result = payload.data[0];
 		} else if (!payload.reply[0])
 			/*I2C_ACK|AUX_ACK*/
 			result = msg->size;
 			break;
 		}
-		drm_info(adev_to_drm(adev), "amdgpu: DP AUX transfer fail:%d\n", operation_result);
+		drm_dbg_dp(adev_to_drm(adev), "amdgpu: DP AUX transfer fail:%d\n", operation_result);
 	}
 	if (payload.reply[0])
-		drm_info(adev_to_drm(adev), "amdgpu: AUX reply command not ACK: 0x%02x.",
+		drm_dbg_dp(adev_to_drm(adev), "amdgpu: AUX reply command not ACK: 0x%02x.",
 			payload.reply[0]);
 	return result;

drivers/gpu/drm/amd/display/dc/core/dc.c+7−3

 	 * Don't adjust DRR while there's bandwidth optimizations pending to
 	 * avoid conflicting with firmware updates.
 	 */
-	if (dc->ctx->dce_version > DCE_VERSION_MAX)
+	if (dc->ctx->dce_version > DCE_VERSION_MAX) {
-		if (dc->optimized_required || dc->wm_optimized_required)
+		if (dc->optimized_required || dc->wm_optimized_required) {
+			stream->adjust.timing_adjust_pending = true;
 			return false;
+		}
+	}
 	dc_exit_ips_for_hw_access(dc);
 	if (update->crtc_timing_adjust) {
 		if (stream->adjust.v_total_min != update->crtc_timing_adjust->v_total_min ||
-			stream->adjust.v_total_max != update->crtc_timing_adjust->v_total_max)
+			stream->adjust.v_total_max != update->crtc_timing_adjust->v_total_max ||
+			stream->adjust.timing_adjust_pending)
 			update->crtc_timing_adjust->timing_adjust_pending = true;
 		stream->adjust = *update->crtc_timing_adjust;
 		update->crtc_timing_adjust->timing_adjust_pending = false;

drivers/gpu/drm/amd/display/dc/dml/dcn35/dcn35_fpu.c+2−2

@@ -195,9 +195,9 @@ struct _vcs_dpi_soc_bounding_box_st dcn3_5_soc = { · 194 unmodified lines
195	.dcn_downspread_percent = 0.5,	195	.dcn_downspread_percent = 0.5,
196	.gpuvm_min_page_size_bytes = 4096,	196	.gpuvm_min_page_size_bytes = 4096,
197	.hostvm_min_page_size_bytes = 4096,	197	.hostvm_min_page_size_bytes = 4096,
198	.do_urgent_latency_adjustment = 1,	198	.do_urgent_latency_adjustment = 0,
199	.urgent_latency_adjustment_fabric_clock_component_us = 0,	199	.urgent_latency_adjustment_fabric_clock_component_us = 0,
200	.urgent_latency_adjustment_fabric_clock_reference_mhz = 3000,	200	.urgent_latency_adjustment_fabric_clock_reference_mhz = 0,
201	};	201	};
202		202
203	void dcn35_build_wm_range_table_fpu(struct clk_mgr *clk_mgr)	203	void dcn35_build_wm_range_table_fpu(struct clk_mgr *clk_mgr)

drivers/gpu/drm/amd/display/dc/dml2/dml21/dml21_translation_helper.c+11−9

 }
 //TODO : Could be possibly moved to a common helper layer.
-static bool dml21_wrapper_get_plane_id(const struct dc_state *context, const struct dc_plane_state *plane, unsigned int *plane_id)
+static bool dml21_wrapper_get_plane_id(const struct dc_state *context, unsigned int stream_id, const struct dc_plane_state *plane, unsigned int *plane_id)
 {
 	int i, j;
 		return false;
 	for (i = 0; i < context->stream_count; i++) {
-		for (j = 0; j < context->stream_status[i].plane_count; j++) {
+		if (context->streams[i]->stream_id == stream_id) {
-			if (context->stream_status[i].plane_states[j] == plane) {
+			for (j = 0; j < context->stream_status[i].plane_count; j++) {
-				*plane_id = (i << 16) | j;
+				if (context->stream_status[i].plane_states[j] == plane) {
-				return true;
+					*plane_id = (i << 16) | j;
+					return true;
+				}
 			}
 		}
 	}
 	return location;
 }
-static unsigned int map_plane_to_dml21_display_cfg(const struct dml2_context *dml_ctx,
+static unsigned int map_plane_to_dml21_display_cfg(const struct dml2_context *dml_ctx, unsigned int stream_id,
 		const struct dc_plane_state *plane, const struct dc_state *context)
 {
 	unsigned int plane_id;
 	int i = 0;
 	int location = -1;
-	if (!dml21_wrapper_get_plane_id(context, plane, &plane_id)) {
+	if (!dml21_wrapper_get_plane_id(context, stream_id, plane, &plane_id)) {
 		ASSERT(false);
 		return -1;
 	}
 			dml_dispcfg->plane_descriptors[disp_cfg_plane_location].stream_index = disp_cfg_stream_location;
 		} else {
 			for (plane_index = 0; plane_index < context->stream_status[stream_index].plane_count; plane_index++) {
-				disp_cfg_plane_location = map_plane_to_dml21_display_cfg(dml_ctx, context->stream_status[stream_index].plane_states[plane_index], context);
+				disp_cfg_plane_location = map_plane_to_dml21_display_cfg(dml_ctx, context->streams[stream_index]->stream_id, context->stream_status[stream_index].plane_states[plane_index], context);
 				if (disp_cfg_plane_location < 0)
 					disp_cfg_plane_location = dml_dispcfg->num_planes++;
 				populate_dml21_plane_config_from_plane_state(dml_ctx, &dml_dispcfg->plane_descriptors[disp_cfg_plane_location], context->stream_status[stream_index].plane_states[plane_index], context, stream_index);
 				dml_dispcfg->plane_descriptors[disp_cfg_plane_location].stream_index = disp_cfg_stream_location;
-				if (dml21_wrapper_get_plane_id(context, context->stream_status[stream_index].plane_states[plane_index], &dml_ctx->v21.dml_to_dc_pipe_mapping.disp_cfg_to_plane_id[disp_cfg_plane_location]))
+				if (dml21_wrapper_get_plane_id(context, context->streams[stream_index]->stream_id, context->stream_status[stream_index].plane_states[plane_index], &dml_ctx->v21.dml_to_dc_pipe_mapping.disp_cfg_to_plane_id[disp_cfg_plane_location]))
 					dml_ctx->v21.dml_to_dc_pipe_mapping.disp_cfg_to_plane_id_valid[disp_cfg_plane_location] = true;
 				/* apply forced pstate policy */

drivers/gpu/drm/amd/display/dc/dpp/dcn401/dcn401_dpp_cm.c+3−2

 	enum dc_cursor_color_format color_format = cursor_attributes->color_format;
 	int cur_rom_en = 0;
-	// DCN4 should always do Cursor degamma for Cursor Color modes
 	if (color_format == CURSOR_MODE_COLOR_PRE_MULTIPLIED_ALPHA ||
 		color_format == CURSOR_MODE_COLOR_UN_PRE_MULTIPLIED_ALPHA) {
-		cur_rom_en = 1;
+		if (cursor_attributes->attribute_flags.bits.ENABLE_CURSOR_DEGAMMA) {
+			cur_rom_en = 1;
+		}
 	}
 	REG_UPDATE_3(CURSOR0_CONTROL,

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

@@ -1980,9 +1980,9 @@ void dcn401_program_pipe( · 1979 unmodified lines
1980	dc->res_pool->hubbub, pipe_ctx->plane_res.hubp->inst, pipe_ctx->hubp_regs.det_size);	1980	dc->res_pool->hubbub, pipe_ctx->plane_res.hubp->inst, pipe_ctx->hubp_regs.det_size);
1981	}	1981	}
1982		1982
1983	if (pipe_ctx->update_flags.raw \|\|	1983	if (pipe_ctx->plane_state && (pipe_ctx->update_flags.raw \|\|
1984	(pipe_ctx->plane_state && pipe_ctx->plane_state->update_flags.raw) \|\|	1984	pipe_ctx->plane_state->update_flags.raw \|\|
1985	pipe_ctx->stream->update_flags.raw)	1985	pipe_ctx->stream->update_flags.raw))
1986	dc->hwss.update_dchubp_dpp(dc, pipe_ctx, context);	1986	dc->hwss.update_dchubp_dpp(dc, pipe_ctx, context);
1987		1987
1988	if (pipe_ctx->plane_state && (pipe_ctx->update_flags.bits.enable \|\|	1988	if (pipe_ctx->plane_state && (pipe_ctx->update_flags.bits.enable \|\|

drivers/gpu/drm/amd/display/dc/link/link_dpms.c+11−2

 void link_set_all_streams_dpms_off_for_link(struct dc_link *link)
 {
 	struct pipe_ctx *pipes[MAX_PIPES];
+	struct dc_stream_state *streams[MAX_PIPES];
 	struct dc_state *state = link->dc->current_state;
 	uint8_t count;
 	int i;
 	link_get_master_pipes_with_dpms_on(link, state, &count, pipes);
+	/* The subsequent call to dc_commit_updates_for_stream for a full update
+	 * will release the current state and swap to a new state. Releasing the
+	 * current state results in the stream pointers in the pipe_ctx structs
+	 * to be zero'd. Hence, cache all streams prior to dc_commit_updates_for_stream.
+	 */
+	for (i = 0; i < count; i++)
+		streams[i] = pipes[i]->stream;
 	for (i = 0; i < count; i++) {
-		stream_update.stream = pipes[i]->stream;
+		stream_update.stream = streams[i];
 		dc_commit_updates_for_stream(link->ctx->dc, NULL, 0,
-				pipes[i]->stream, &stream_update,
+				streams[i], &stream_update,
 				state);
 	}

drivers/gpu/drm/drm_gpusvm.c+32−5

@@ -1118,6 +1118,10 @@ static void __drm_gpusvm_range_unmap_pages(struct drm_gpusvm *gpusvm, · 1117 unmodified lines
1118	lockdep_assert_held(&gpusvm->notifier_lock);	1118	lockdep_assert_held(&gpusvm->notifier_lock);
1119		1119
1120	if (range->flags.has_dma_mapping) {	1120	if (range->flags.has_dma_mapping) {
		1121	struct drm_gpusvm_range_flags flags = {
		1122	.__flags = range->flags.__flags,
		1123	};
		1124
1121	for (i = 0, j = 0; i < npages; j++) {	1125	for (i = 0, j = 0; i < npages; j++) {
1122	struct drm_pagemap_device_addr *addr = &range->dma_addr[j];	1126	struct drm_pagemap_device_addr *addr = &range->dma_addr[j];
1123		1127
@@ -1131,8 +1135,12 @@ static void __drm_gpusvm_range_unmap_pages(struct drm_gpusvm *gpusvm, · 7 unmodified lines
1131	dev, *addr);	1135	dev, *addr);
1132	i += 1 << addr->order;	1136	i += 1 << addr->order;
1133	}	1137	}
1134	range->flags.has_devmem_pages = false;	1138
1135	range->flags.has_dma_mapping = false;	1139	/* WRITE_ONCE pairs with READ_ONCE for opportunistic checks */
		1140	flags.has_devmem_pages = false;
		1141	flags.has_dma_mapping = false;
		1142	WRITE_ONCE(range->flags.__flags, flags.__flags);
		1143
1136	range->dpagemap = NULL;	1144	range->dpagemap = NULL;
1137	}	1145	}
1138	}	1146	}
@@ -1334,6 +1342,7 @@ int drm_gpusvm_range_get_pages(struct drm_gpusvm *gpusvm, · 195 unmodified lines
1334	int err = 0;	1342	int err = 0;
1335	struct dev_pagemap *pagemap;	1343	struct dev_pagemap *pagemap;
1336	struct drm_pagemap *dpagemap;	1344	struct drm_pagemap *dpagemap;
		1345	struct drm_gpusvm_range_flags flags;
1337		1346
1338	retry:	1347	retry:
1339	hmm_range.notifier_seq = mmu_interval_read_begin(notifier);	1348	hmm_range.notifier_seq = mmu_interval_read_begin(notifier);
@@ -1378,7 +1387,8 @@ map_pages: · 38 unmodified lines
1378	*/	1387	*/
1379	drm_gpusvm_notifier_lock(gpusvm);	1388	drm_gpusvm_notifier_lock(gpusvm);
1380		1389
1381	if (range->flags.unmapped) {	1390	flags.__flags = range->flags.__flags;
		1391	if (flags.unmapped) {
1382	drm_gpusvm_notifier_unlock(gpusvm);	1392	drm_gpusvm_notifier_unlock(gpusvm);
1383	err = -EFAULT;	1393	err = -EFAULT;
1384	goto err_free;	1394	goto err_free;
@@ -1454,6 +1464,11 @@ map_pages: · 69 unmodified lines
1454	goto err_unmap;	1464	goto err_unmap;
1455	}	1465	}
1456		1466
		1467	if (ctx->devmem_only) {
		1468	err = -EFAULT;
		1469	goto err_unmap;
		1470	}
		1471
1457	addr = dma_map_page(gpusvm->drm->dev,	1472	addr = dma_map_page(gpusvm->drm->dev,
1458	page, 0,	1473	page, 0,
1459	PAGE_SIZE << order,	1474	PAGE_SIZE << order,
@@ -1469,14 +1484,17 @@ map_pages: · 9 unmodified lines
1469	}	1484	}
1470	i += 1 << order;	1485	i += 1 << order;
1471	num_dma_mapped = i;	1486	num_dma_mapped = i;
1472	range->flags.has_dma_mapping = true;	1487	flags.has_dma_mapping = true;
1473	}	1488	}
1474		1489
1475	if (zdd) {	1490	if (zdd) {
1476	range->flags.has_devmem_pages = true;	1491	flags.has_devmem_pages = true;
1477	range->dpagemap = dpagemap;	1492	range->dpagemap = dpagemap;
1478	}	1493	}
1479		1494
		1495	/* WRITE_ONCE pairs with READ_ONCE for opportunistic checks */
		1496	WRITE_ONCE(range->flags.__flags, flags.__flags);
		1497
1480	drm_gpusvm_notifier_unlock(gpusvm);	1498	drm_gpusvm_notifier_unlock(gpusvm);
1481	kvfree(pfns);	1499	kvfree(pfns);
1482	set_seqno:	1500	set_seqno:
@@ -1765,6 +1783,8 @@ int drm_gpusvm_migrate_to_devmem(struct drm_gpusvm *gpusvm, · 282 unmodified lines
1765	goto err_finalize;	1783	goto err_finalize;
1766		1784
1767	/* Upon success bind devmem allocation to range and zdd */	1785	/* Upon success bind devmem allocation to range and zdd */
		1786	devmem_allocation->timeslice_expiration = get_jiffies_64() +
		1787	msecs_to_jiffies(ctx->timeslice_ms);
1768	zdd->devmem_allocation = devmem_allocation; /* Owns ref */	1788	zdd->devmem_allocation = devmem_allocation; /* Owns ref */
1769		1789
1770	err_finalize:	1790	err_finalize:
@@ -1985,6 +2005,13 @@ static int __drm_gpusvm_migrate_to_ram(struct vm_area_struct *vas, · 214 unmodified lines
1985	void *buf;	2005	void *buf;
1986	int i, err = 0;	2006	int i, err = 0;
1987		2007
		2008	if (page) {
		2009	zdd = page->zone_device_data;
		2010	if (time_before64(get_jiffies_64(),
		2011	zdd->devmem_allocation->timeslice_expiration))
		2012	return 0;
		2013	}
		2014
1988	start = ALIGN_DOWN(fault_addr, size);	2015	start = ALIGN_DOWN(fault_addr, size);
1989	end = ALIGN(fault_addr + 1, size);	2016	end = ALIGN(fault_addr + 1, size);
1990		2017

drivers/gpu/drm/meson/meson_encoder_hdmi.c+2−2

@@ -75,7 +75,7 @@ static void meson_encoder_hdmi_set_vclk(struct meson_encoder_hdmi *encoder_hdmi, · 74 unmodified lines
75	unsigned long long venc_freq;	75	unsigned long long venc_freq;
76	unsigned long long hdmi_freq;	76	unsigned long long hdmi_freq;
77		77
78	vclk_freq = mode->clock * 1000;	78	vclk_freq = mode->clock * 1000ULL;
79		79
80	/* For 420, pixel clock is half unlike venc clock */	80	/* For 420, pixel clock is half unlike venc clock */
81	if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)	81	if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
@@ -123,7 +123,7 @@ static enum drm_mode_status meson_encoder_hdmi_mode_valid(struct drm_bridge *bri · 41 unmodified lines
123	struct meson_encoder_hdmi *encoder_hdmi = bridge_to_meson_encoder_hdmi(bridge);	123	struct meson_encoder_hdmi *encoder_hdmi = bridge_to_meson_encoder_hdmi(bridge);
124	struct meson_drm *priv = encoder_hdmi->priv;	124	struct meson_drm *priv = encoder_hdmi->priv;
125	bool is_hdmi2_sink = display_info->hdmi.scdc.supported;	125	bool is_hdmi2_sink = display_info->hdmi.scdc.supported;
126	unsigned long long clock = mode->clock * 1000;	126	unsigned long long clock = mode->clock * 1000ULL;
127	unsigned long long phy_freq;	127	unsigned long long phy_freq;
128	unsigned long long vclk_freq;	128	unsigned long long vclk_freq;
129	unsigned long long venc_freq;	129	unsigned long long venc_freq;

drivers/gpu/drm/tiny/panel-mipi-dbi.c+4−1

@@ -390,7 +390,10 @@ static int panel_mipi_dbi_spi_probe(struct spi_device *spi) · 389 unmodified lines
390		390
391	spi_set_drvdata(spi, drm);	391	spi_set_drvdata(spi, drm);
392		392
393	drm_client_setup(drm, NULL);	393	if (bpp == 16)
		394	drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB565);
		395	else
		396	drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB888);
394		397
395	return 0;	398	return 0;
396	}	399	}

drivers/gpu/drm/xe/instructions/xe_mi_commands.h+4−0

 #define   MI_LRI_FORCE_POSTED		REG_BIT(12)
 #define   MI_LRI_LEN(x)			(((x) & 0xff) + 1)
+#define MI_STORE_REGISTER_MEM		(__MI_INSTR(0x24) | XE_INSTR_NUM_DW(4))
+#define   MI_SRM_USE_GGTT		REG_BIT(22)
+#define   MI_SRM_ADD_CS_OFFSET		REG_BIT(19)
 #define MI_FLUSH_DW			__MI_INSTR(0x26)
 #define   MI_FLUSH_DW_PROTECTED_MEM_EN	REG_BIT(22)
 #define   MI_FLUSH_DW_STORE_INDEX	REG_BIT(21)

drivers/gpu/drm/xe/regs/xe_engine_regs.h+5−0

 #define XEHPC_BCS8_RING_BASE			0x3ee000
 #define GSCCS_RING_BASE				0x11a000
+#define ENGINE_ID(base)				XE_REG((base) + 0x8c)
+#define   ENGINE_INSTANCE_ID			REG_GENMASK(9, 4)
+#define   ENGINE_CLASS_ID			REG_GENMASK(2, 0)
 #define RING_TAIL(base)				XE_REG((base) + 0x30)
 #define   TAIL_ADDR				REG_GENMASK(20, 3)
 #define   STOP_RING				REG_BIT(8)
 #define RING_CTX_TIMESTAMP(base)		XE_REG((base) + 0x3a8)
+#define RING_CTX_TIMESTAMP_UDW(base)		XE_REG((base) + 0x3ac)
 #define CSBE_DEBUG_STATUS(base)			XE_REG((base) + 0x3fc)
 #define RING_FORCE_TO_NONPRIV(base, i)		XE_REG(((base) + 0x4d0) + (i) * 4)

drivers/gpu/drm/xe/regs/xe_gt_regs.h+1−0

@@ -157,6 +157,7 @@ · 156 unmodified lines
157	#define XEHPG_SC_INSTDONE_EXTRA2 XE_REG_MCR(0x7108)	157	#define XEHPG_SC_INSTDONE_EXTRA2 XE_REG_MCR(0x7108)
158		158
159	#define COMMON_SLICE_CHICKEN4 XE_REG(0x7300, XE_REG_OPTION_MASKED)	159	#define COMMON_SLICE_CHICKEN4 XE_REG(0x7300, XE_REG_OPTION_MASKED)
		160	#define SBE_PUSH_CONSTANT_BEHIND_FIX_ENABLE REG_BIT(12)
160	#define DISABLE_TDC_LOAD_BALANCING_CALC REG_BIT(6)	161	#define DISABLE_TDC_LOAD_BALANCING_CALC REG_BIT(6)
161		162
162	#define COMMON_SLICE_CHICKEN3 XE_REG(0x7304, XE_REG_OPTION_MASKED)	163	#define COMMON_SLICE_CHICKEN3 XE_REG(0x7304, XE_REG_OPTION_MASKED)

drivers/gpu/drm/xe/regs/xe_lrc_layout.h+2−0

 #define CTX_RING_TAIL			(0x06 + 1)
 #define CTX_RING_START			(0x08 + 1)
 #define CTX_RING_CTL			(0x0a + 1)
+#define CTX_BB_PER_CTX_PTR		(0x12 + 1)
 #define CTX_TIMESTAMP			(0x22 + 1)
+#define CTX_TIMESTAMP_UDW		(0x24 + 1)
 #define CTX_INDIRECT_RING_STATE		(0x26 + 1)
 #define CTX_PDP0_UDW			(0x30 + 1)
 #define CTX_PDP0_LDW			(0x32 + 1)

drivers/gpu/drm/xe/xe_device_types.h+2−0

 		u8 has_sriov:1;
 		/** @info.has_usm: Device has unified shared memory support */
 		u8 has_usm:1;
+		/** @info.has_64bit_timestamp: Device supports 64-bit timestamps */
+		u8 has_64bit_timestamp:1;
 		/** @info.is_dgfx: is discrete device */
 		u8 is_dgfx:1;
 		/**

drivers/gpu/drm/xe/xe_exec_queue.c+1−1

@@ -830,7 +830,7 @@ void xe_exec_queue_update_run_ticks(struct xe_exec_queue *q) · 829 unmodified lines
830	{	830	{
831	struct xe_device *xe = gt_to_xe(q->gt);	831	struct xe_device *xe = gt_to_xe(q->gt);
832	struct xe_lrc *lrc;	832	struct xe_lrc *lrc;
833	u32 old_ts, new_ts;	833	u64 old_ts, new_ts;
834	int idx;	834	int idx;
835		835
836	/*	836	/*

drivers/gpu/drm/xe/xe_guc_submit.c+1−1

@@ -941,7 +941,7 @@ static bool check_timeout(struct xe_exec_queue q, struct xe_sched_job job) · 940 unmodified lines
941	return xe_sched_invalidate_job(job, 2);	941	return xe_sched_invalidate_job(job, 2);
942	}	942	}
943		943
944	ctx_timestamp = xe_lrc_ctx_timestamp(q->lrc[0]);	944	ctx_timestamp = lower_32_bits(xe_lrc_ctx_timestamp(q->lrc[0]));
945	ctx_job_timestamp = xe_lrc_ctx_job_timestamp(q->lrc[0]);	945	ctx_job_timestamp = xe_lrc_ctx_job_timestamp(q->lrc[0]);
946		946
947	/*	947	/*

drivers/gpu/drm/xe/xe_lrc.c+186−13

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	#include "xe_hw_fence.h"	24	#include "xe_hw_fence.h"
25	#include "xe_map.h"	25	#include "xe_map.h"
26	#include "xe_memirq.h"	26	#include "xe_memirq.h"
		27	#include "xe_mmio.h"
27	#include "xe_sriov.h"	28	#include "xe_sriov.h"
28	#include "xe_trace_lrc.h"	29	#include "xe_trace_lrc.h"
29	#include "xe_vm.h"	30	#include "xe_vm.h"
@@ -650,6 +651,7 @@ u32 xe_lrc_pphwsp_offset(struct xe_lrc *lrc) · 620 unmodified lines
650	#define LRC_START_SEQNO_PPHWSP_OFFSET (LRC_SEQNO_PPHWSP_OFFSET + 8)	651	#define LRC_START_SEQNO_PPHWSP_OFFSET (LRC_SEQNO_PPHWSP_OFFSET + 8)
651	#define LRC_CTX_JOB_TIMESTAMP_OFFSET (LRC_START_SEQNO_PPHWSP_OFFSET + 8)	652	#define LRC_CTX_JOB_TIMESTAMP_OFFSET (LRC_START_SEQNO_PPHWSP_OFFSET + 8)
652	#define LRC_PARALLEL_PPHWSP_OFFSET 2048	653	#define LRC_PARALLEL_PPHWSP_OFFSET 2048
		654	#define LRC_ENGINE_ID_PPHWSP_OFFSET 2096
653	#define LRC_PPHWSP_SIZE SZ_4K	655	#define LRC_PPHWSP_SIZE SZ_4K
654		656
655	u32 xe_lrc_regs_offset(struct xe_lrc *lrc)	657	u32 xe_lrc_regs_offset(struct xe_lrc *lrc)
@@ -684,7 +686,7 @@ static inline u32 __xe_lrc_start_seqno_offset(struct xe_lrc *lrc) · 28 unmodified lines
684		686
685	static u32 __xe_lrc_ctx_job_timestamp_offset(struct xe_lrc *lrc)	687	static u32 __xe_lrc_ctx_job_timestamp_offset(struct xe_lrc *lrc)
686	{	688	{
687	/* The start seqno is stored in the driver-defined portion of PPHWSP */	689	/* This is stored in the driver-defined portion of PPHWSP */
688	return xe_lrc_pphwsp_offset(lrc) + LRC_CTX_JOB_TIMESTAMP_OFFSET;	690	return xe_lrc_pphwsp_offset(lrc) + LRC_CTX_JOB_TIMESTAMP_OFFSET;
689	}	691	}
690		692
@@ -694,11 +696,21 @@ static inline u32 __xe_lrc_parallel_offset(struct xe_lrc *lrc) · 3 unmodified lines
694	return xe_lrc_pphwsp_offset(lrc) + LRC_PARALLEL_PPHWSP_OFFSET;	696	return xe_lrc_pphwsp_offset(lrc) + LRC_PARALLEL_PPHWSP_OFFSET;
695	}	697	}
696		698
		699	static inline u32 __xe_lrc_engine_id_offset(struct xe_lrc *lrc)
		700	{
		701	return xe_lrc_pphwsp_offset(lrc) + LRC_ENGINE_ID_PPHWSP_OFFSET;
		702	}
		703
697	static u32 __xe_lrc_ctx_timestamp_offset(struct xe_lrc *lrc)	704	static u32 __xe_lrc_ctx_timestamp_offset(struct xe_lrc *lrc)
698	{	705	{
699	return __xe_lrc_regs_offset(lrc) + CTX_TIMESTAMP * sizeof(u32);	706	return __xe_lrc_regs_offset(lrc) + CTX_TIMESTAMP * sizeof(u32);
700	}	707	}
701		708
		709	static u32 __xe_lrc_ctx_timestamp_udw_offset(struct xe_lrc *lrc)
		710	{
		711	return __xe_lrc_regs_offset(lrc) + CTX_TIMESTAMP_UDW * sizeof(u32);
		712	}
		713
702	static inline u32 __xe_lrc_indirect_ring_offset(struct xe_lrc *lrc)	714	static inline u32 __xe_lrc_indirect_ring_offset(struct xe_lrc *lrc)
703	{	715	{
704	/* Indirect ring state page is at the very end of LRC */	716	/* Indirect ring state page is at the very end of LRC */
@@ -726,8 +738,10 @@ DECL_MAP_ADDR_HELPERS(regs) · 21 unmodified lines
726	DECL_MAP_ADDR_HELPERS(start_seqno)	738	DECL_MAP_ADDR_HELPERS(start_seqno)
727	DECL_MAP_ADDR_HELPERS(ctx_job_timestamp)	739	DECL_MAP_ADDR_HELPERS(ctx_job_timestamp)
728	DECL_MAP_ADDR_HELPERS(ctx_timestamp)	740	DECL_MAP_ADDR_HELPERS(ctx_timestamp)
		741	DECL_MAP_ADDR_HELPERS(ctx_timestamp_udw)
729	DECL_MAP_ADDR_HELPERS(parallel)	742	DECL_MAP_ADDR_HELPERS(parallel)
730	DECL_MAP_ADDR_HELPERS(indirect_ring)	743	DECL_MAP_ADDR_HELPERS(indirect_ring)
		744	DECL_MAP_ADDR_HELPERS(engine_id)
731		745
732	#undef DECL_MAP_ADDR_HELPERS	746	#undef DECL_MAP_ADDR_HELPERS
733		747
@@ -742,19 +756,38 @@ u32 xe_lrc_ctx_timestamp_ggtt_addr(struct xe_lrc *lrc) · 8 unmodified lines
742	return __xe_lrc_ctx_timestamp_ggtt_addr(lrc);	756	return __xe_lrc_ctx_timestamp_ggtt_addr(lrc);
743	}	757	}
744		758
		759	/**
		760	* xe_lrc_ctx_timestamp_udw_ggtt_addr() - Get ctx timestamp udw GGTT address
		761	* @lrc: Pointer to the lrc.
		762	*
		763	* Returns: ctx timestamp udw GGTT address
		764	*/
		765	u32 xe_lrc_ctx_timestamp_udw_ggtt_addr(struct xe_lrc *lrc)
		766	{
		767	return __xe_lrc_ctx_timestamp_udw_ggtt_addr(lrc);
		768	}
		769
745	/**	770	/**
746	* xe_lrc_ctx_timestamp() - Read ctx timestamp value	771	* xe_lrc_ctx_timestamp() - Read ctx timestamp value
747	* @lrc: Pointer to the lrc.	772	* @lrc: Pointer to the lrc.
748	*	773	*
749	* Returns: ctx timestamp value	774	* Returns: ctx timestamp value
750	*/	775	*/
751	u32 xe_lrc_ctx_timestamp(struct xe_lrc *lrc)	776	u64 xe_lrc_ctx_timestamp(struct xe_lrc *lrc)
752	{	777	{
753	struct xe_device *xe = lrc_to_xe(lrc);	778	struct xe_device *xe = lrc_to_xe(lrc);
754	struct iosys_map map;	779	struct iosys_map map;
		780	u32 ldw, udw = 0;
755		781
756	map = __xe_lrc_ctx_timestamp_map(lrc);	782	map = __xe_lrc_ctx_timestamp_map(lrc);
757	return xe_map_read32(xe, &map);	783	ldw = xe_map_read32(xe, &map);
		784
		785	if (xe->info.has_64bit_timestamp) {
		786	map = __xe_lrc_ctx_timestamp_udw_map(lrc);
		787	udw = xe_map_read32(xe, &map);
		788	}
		789
		790	return (u64)udw << 32 \| ldw;
758	}	791	}
759		792
760	/**	793	/**
@@ -864,7 +897,7 @@ static void empty_lrc_data(struct xe_hw_engine hwe) · 103 unmodified lines
864		897
865	static void xe_lrc_set_ppgtt(struct xe_lrc lrc, struct xe_vm vm)	898	static void xe_lrc_set_ppgtt(struct xe_lrc lrc, struct xe_vm vm)
866	{	899	{
867	u64 desc = xe_vm_pdp4_descriptor(vm, lrc->tile);	900	u64 desc = xe_vm_pdp4_descriptor(vm, gt_to_tile(lrc->gt));
868		901
869	xe_lrc_write_ctx_reg(lrc, CTX_PDP0_UDW, upper_32_bits(desc));	902	xe_lrc_write_ctx_reg(lrc, CTX_PDP0_UDW, upper_32_bits(desc));
870	xe_lrc_write_ctx_reg(lrc, CTX_PDP0_LDW, lower_32_bits(desc));	903	xe_lrc_write_ctx_reg(lrc, CTX_PDP0_LDW, lower_32_bits(desc));
@@ -877,6 +910,65 @@ static void xe_lrc_finish(struct xe_lrc *lrc) · 6 unmodified lines
877	xe_bo_unpin(lrc->bo);	910	xe_bo_unpin(lrc->bo);
878	xe_bo_unlock(lrc->bo);	911	xe_bo_unlock(lrc->bo);
879	xe_bo_put(lrc->bo);	912	xe_bo_put(lrc->bo);
		913	xe_bo_unpin_map_no_vm(lrc->bb_per_ctx_bo);
		914	}
		915
		916	/*
		917	* xe_lrc_setup_utilization() - Setup wa bb to assist in calculating active
		918	* context run ticks.
		919	* @lrc: Pointer to the lrc.
		920	*
		921	* Context Timestamp (CTX_TIMESTAMP) in the LRC accumulates the run ticks of the
		922	* context, but only gets updated when the context switches out. In order to
		923	* check how long a context has been active before it switches out, two things
		924	* are required:
		925	*
		926	* (1) Determine if the context is running:
		927	* To do so, we program the WA BB to set an initial value for CTX_TIMESTAMP in
		928	* the LRC. The value chosen is 1 since 0 is the initial value when the LRC is
		929	* initialized. During a query, we just check for this value to determine if the
		930	* context is active. If the context switched out, it would overwrite this
		931	* location with the actual CTX_TIMESTAMP MMIO value. Note that WA BB runs as
		932	* the last part of context restore, so reusing this LRC location will not
		933	* clobber anything.
		934	*
		935	* (2) Calculate the time that the context has been active for:
		936	* The CTX_TIMESTAMP ticks only when the context is active. If a context is
		937	* active, we just use the CTX_TIMESTAMP MMIO as the new value of utilization.
		938	* While doing so, we need to read the CTX_TIMESTAMP MMIO for the specific
		939	* engine instance. Since we do not know which instance the context is running
		940	* on until it is scheduled, we also read the ENGINE_ID MMIO in the WA BB and
		941	* store it in the PPHSWP.
		942	*/
		943	#define CONTEXT_ACTIVE 1ULL
		944	static void xe_lrc_setup_utilization(struct xe_lrc *lrc)
		945	{
		946	u32 *cmd;
		947
		948	cmd = lrc->bb_per_ctx_bo->vmap.vaddr;
		949
		950	*cmd++ = MI_STORE_REGISTER_MEM \| MI_SRM_USE_GGTT \| MI_SRM_ADD_CS_OFFSET;
		951	*cmd++ = ENGINE_ID(0).addr;
		952	*cmd++ = __xe_lrc_engine_id_ggtt_addr(lrc);
		953	*cmd++ = 0;
		954
		955	*cmd++ = MI_STORE_DATA_IMM \| MI_SDI_GGTT \| MI_SDI_NUM_DW(1);
		956	*cmd++ = __xe_lrc_ctx_timestamp_ggtt_addr(lrc);
		957	*cmd++ = 0;
		958	*cmd++ = lower_32_bits(CONTEXT_ACTIVE);
		959
		960	if (lrc_to_xe(lrc)->info.has_64bit_timestamp) {
		961	*cmd++ = MI_STORE_DATA_IMM \| MI_SDI_GGTT \| MI_SDI_NUM_DW(1);
		962	*cmd++ = __xe_lrc_ctx_timestamp_udw_ggtt_addr(lrc);
		963	*cmd++ = 0;
		964	*cmd++ = upper_32_bits(CONTEXT_ACTIVE);
		965	}
		966
		967	*cmd++ = MI_BATCH_BUFFER_END;
		968
		969	xe_lrc_write_ctx_reg(lrc, CTX_BB_PER_CTX_PTR,
		970	xe_bo_ggtt_addr(lrc->bb_per_ctx_bo) \| 1);
		971
880	}	972	}
881		973
882	#define PVC_CTX_ASID (0x2e + 1)	974	#define PVC_CTX_ASID (0x2e + 1)
@@ -893,31 +985,40 @@ static int xe_lrc_init(struct xe_lrc lrc, struct xe_hw_engine hwe, · 10 unmodified lines
893	void *init_data = NULL;	985	void *init_data = NULL;
894	u32 arb_enable;	986	u32 arb_enable;
895	u32 lrc_size;	987	u32 lrc_size;
		988	u32 bo_flags;
896	int err;	989	int err;
897		990
898	kref_init(&lrc->refcount);	991	kref_init(&lrc->refcount);
		992	lrc->gt = gt;
899	lrc->flags = 0;	993	lrc->flags = 0;
900	lrc_size = ring_size + xe_gt_lrc_size(gt, hwe->class);	994	lrc_size = ring_size + xe_gt_lrc_size(gt, hwe->class);
901	if (xe_gt_has_indirect_ring_state(gt))	995	if (xe_gt_has_indirect_ring_state(gt))
902	lrc->flags \|= XE_LRC_FLAG_INDIRECT_RING_STATE;	996	lrc->flags \|= XE_LRC_FLAG_INDIRECT_RING_STATE;
903		997
		998	bo_flags = XE_BO_FLAG_VRAM_IF_DGFX(tile) \| XE_BO_FLAG_GGTT \|
		999	XE_BO_FLAG_GGTT_INVALIDATE;
		1000
904	/*	1001	/*
905	* FIXME: Perma-pinning LRC as we don't yet support moving GGTT address	1002	* FIXME: Perma-pinning LRC as we don't yet support moving GGTT address
906	* via VM bind calls.	1003	* via VM bind calls.
907	*/	1004	*/
908	lrc->bo = xe_bo_create_pin_map(xe, tile, vm, lrc_size,	1005	lrc->bo = xe_bo_create_pin_map(xe, tile, vm, lrc_size,
909	ttm_bo_type_kernel,	1006	ttm_bo_type_kernel,
910	XE_BO_FLAG_VRAM_IF_DGFX(tile) \|	1007	bo_flags);
911	XE_BO_FLAG_GGTT \|
912	XE_BO_FLAG_GGTT_INVALIDATE);
913	if (IS_ERR(lrc->bo))	1008	if (IS_ERR(lrc->bo))
914	return PTR_ERR(lrc->bo);	1009	return PTR_ERR(lrc->bo);
915		1010
		1011	lrc->bb_per_ctx_bo = xe_bo_create_pin_map(xe, tile, NULL, SZ_4K,
		1012	ttm_bo_type_kernel,
		1013	bo_flags);
		1014	if (IS_ERR(lrc->bb_per_ctx_bo)) {
		1015	err = PTR_ERR(lrc->bb_per_ctx_bo);
		1016	goto err_lrc_finish;
		1017	}
		1018
916	lrc->size = lrc_size;	1019	lrc->size = lrc_size;
917	lrc->tile = gt_to_tile(hwe->gt);
918	lrc->ring.size = ring_size;	1020	lrc->ring.size = ring_size;
919	lrc->ring.tail = 0;	1021	lrc->ring.tail = 0;
920	lrc->ctx_timestamp = 0;
921		1022
922	xe_hw_fence_ctx_init(&lrc->fence_ctx, hwe->gt,	1023	xe_hw_fence_ctx_init(&lrc->fence_ctx, hwe->gt,
923	hwe->fence_irq, hwe->name);	1024	hwe->fence_irq, hwe->name);
@@ -990,7 +1091,10 @@ static int xe_lrc_init(struct xe_lrc lrc, struct xe_hw_engine hwe, · 66 unmodified lines
990	xe_lrc_read_ctx_reg(lrc, CTX_CONTEXT_CONTROL) \|	1091	xe_lrc_read_ctx_reg(lrc, CTX_CONTEXT_CONTROL) \|
991	_MASKED_BIT_ENABLE(CTX_CTRL_PXP_ENABLE));	1092	_MASKED_BIT_ENABLE(CTX_CTRL_PXP_ENABLE));
992		1093
		1094	lrc->ctx_timestamp = 0;
993	xe_lrc_write_ctx_reg(lrc, CTX_TIMESTAMP, 0);	1095	xe_lrc_write_ctx_reg(lrc, CTX_TIMESTAMP, 0);
		1096	if (lrc_to_xe(lrc)->info.has_64bit_timestamp)
		1097	xe_lrc_write_ctx_reg(lrc, CTX_TIMESTAMP_UDW, 0);
994		1098
995	if (xe->info.has_asid && vm)	1099	if (xe->info.has_asid && vm)
996	xe_lrc_write_ctx_reg(lrc, PVC_CTX_ASID, vm->usm.asid);	1100	xe_lrc_write_ctx_reg(lrc, PVC_CTX_ASID, vm->usm.asid);
@@ -1019,6 +1123,8 @@ static int xe_lrc_init(struct xe_lrc lrc, struct xe_hw_engine hwe, · 22 unmodified lines
1019	map = __xe_lrc_start_seqno_map(lrc);	1123	map = __xe_lrc_start_seqno_map(lrc);
1020	xe_map_write32(lrc_to_xe(lrc), &map, lrc->fence_ctx.next_seqno - 1);	1124	xe_map_write32(lrc_to_xe(lrc), &map, lrc->fence_ctx.next_seqno - 1);
1021		1125
		1126	xe_lrc_setup_utilization(lrc);
		1127
1022	return 0;	1128	return 0;
1023		1129
1024	err_lrc_finish:	1130	err_lrc_finish:
@@ -1238,6 +1344,21 @@ struct iosys_map xe_lrc_parallel_map(struct xe_lrc *lrc) · 213 unmodified lines
1238	return __xe_lrc_parallel_map(lrc);	1344	return __xe_lrc_parallel_map(lrc);
1239	}	1345	}
1240		1346
		1347	/**
		1348	* xe_lrc_engine_id() - Read engine id value
		1349	* @lrc: Pointer to the lrc.
		1350	*
		1351	* Returns: context id value
		1352	*/
		1353	static u32 xe_lrc_engine_id(struct xe_lrc *lrc)
		1354	{
		1355	struct xe_device *xe = lrc_to_xe(lrc);
		1356	struct iosys_map map;
		1357
		1358	map = __xe_lrc_engine_id_map(lrc);
		1359	return xe_map_read32(xe, &map);
		1360	}
		1361
1241	static int instr_dw(u32 cmd_header)	1362	static int instr_dw(u32 cmd_header)
1242	{	1363	{
1243	/* GFXPIPE "SINGLE_DW" opcodes are a single dword */	1364	/* GFXPIPE "SINGLE_DW" opcodes are a single dword */
@@ -1684,7 +1805,7 @@ struct xe_lrc_snapshot xe_lrc_snapshot_capture(struct xe_lrc lrc) · 440 unmodified lines
1684	snapshot->lrc_offset = xe_lrc_pphwsp_offset(lrc);	1805	snapshot->lrc_offset = xe_lrc_pphwsp_offset(lrc);
1685	snapshot->lrc_size = lrc->bo->size - snapshot->lrc_offset;	1806	snapshot->lrc_size = lrc->bo->size - snapshot->lrc_offset;
1686	snapshot->lrc_snapshot = NULL;	1807	snapshot->lrc_snapshot = NULL;
1687	snapshot->ctx_timestamp = xe_lrc_ctx_timestamp(lrc);	1808	snapshot->ctx_timestamp = lower_32_bits(xe_lrc_ctx_timestamp(lrc));
1688	snapshot->ctx_job_timestamp = xe_lrc_ctx_job_timestamp(lrc);	1809	snapshot->ctx_job_timestamp = xe_lrc_ctx_job_timestamp(lrc);
1689	return snapshot;	1810	return snapshot;
1690	}	1811	}
@@ -1784,22 +1905,74 @@ void xe_lrc_snapshot_free(struct xe_lrc_snapshot *snapshot) · 93 unmodified lines
1784	kfree(snapshot);	1905	kfree(snapshot);
1785	}	1906	}
1786		1907
		1908	static int get_ctx_timestamp(struct xe_lrc lrc, u32 engine_id, u64 reg_ctx_ts)
		1909	{
		1910	u16 class = REG_FIELD_GET(ENGINE_CLASS_ID, engine_id);
		1911	u16 instance = REG_FIELD_GET(ENGINE_INSTANCE_ID, engine_id);
		1912	struct xe_hw_engine *hwe;
		1913	u64 val;
		1914
		1915	hwe = xe_gt_hw_engine(lrc->gt, class, instance, false);
		1916	if (xe_gt_WARN_ONCE(lrc->gt, !hwe \|\| xe_hw_engine_is_reserved(hwe),
		1917	"Unexpected engine class:instance %d:%d for context utilization\n",
		1918	class, instance))
		1919	return -1;
		1920
		1921	if (lrc_to_xe(lrc)->info.has_64bit_timestamp)
		1922	val = xe_mmio_read64_2x32(&hwe->gt->mmio,
		1923	RING_CTX_TIMESTAMP(hwe->mmio_base));
		1924	else
		1925	val = xe_mmio_read32(&hwe->gt->mmio,
		1926	RING_CTX_TIMESTAMP(hwe->mmio_base));
		1927
		1928	*reg_ctx_ts = val;
		1929
		1930	return 0;
		1931	}
		1932
1787	/**	1933	/**
1788	* xe_lrc_update_timestamp() - Update ctx timestamp	1934	* xe_lrc_update_timestamp() - Update ctx timestamp
1789	* @lrc: Pointer to the lrc.	1935	* @lrc: Pointer to the lrc.
1790	* @old_ts: Old timestamp value	1936	* @old_ts: Old timestamp value
1791	*	1937	*
1792	* Populate @old_ts current saved ctx timestamp, read new ctx timestamp and	1938	* Populate @old_ts current saved ctx timestamp, read new ctx timestamp and
1793	* update saved value.	1939	* update saved value. With support for active contexts, the calculation may be
		1940	* slightly racy, so follow a read-again logic to ensure that the context is
		1941	* still active before returning the right timestamp.
1794	*	1942	*
1795	* Returns: New ctx timestamp value	1943	* Returns: New ctx timestamp value
1796	*/	1944	*/
1797	u32 xe_lrc_update_timestamp(struct xe_lrc lrc, u32 old_ts)	1945	u64 xe_lrc_update_timestamp(struct xe_lrc lrc, u64 old_ts)
1798	{	1946	{
		1947	u64 lrc_ts, reg_ts;
		1948	u32 engine_id;
		1949
1799	*old_ts = lrc->ctx_timestamp;	1950	*old_ts = lrc->ctx_timestamp;
1800		1951
1801	lrc->ctx_timestamp = xe_lrc_ctx_timestamp(lrc);	1952	lrc_ts = xe_lrc_ctx_timestamp(lrc);
		1953	/* CTX_TIMESTAMP mmio read is invalid on VF, so return the LRC value */
		1954	if (IS_SRIOV_VF(lrc_to_xe(lrc))) {
		1955	lrc->ctx_timestamp = lrc_ts;
		1956	goto done;
		1957	}
		1958
		1959	if (lrc_ts == CONTEXT_ACTIVE) {
		1960	engine_id = xe_lrc_engine_id(lrc);
		1961	if (!get_ctx_timestamp(lrc, engine_id, &reg_ts))
		1962	lrc->ctx_timestamp = reg_ts;
		1963
		1964	/* read lrc again to ensure context is still active */
		1965	lrc_ts = xe_lrc_ctx_timestamp(lrc);
		1966	}
		1967
		1968	/*
		1969	* If context switched out, just use the lrc_ts. Note that this needs to
		1970	* be a separate if condition.
		1971	*/
		1972	if (lrc_ts != CONTEXT_ACTIVE)
		1973	lrc->ctx_timestamp = lrc_ts;
1802		1974
		1975	done:
1803	trace_xe_lrc_update_timestamp(lrc, *old_ts);	1976	trace_xe_lrc_update_timestamp(lrc, *old_ts);
1804		1977
1805	return lrc->ctx_timestamp;	1978	return lrc->ctx_timestamp;

drivers/gpu/drm/xe/xe_lrc.h+3−2

 void xe_lrc_snapshot_free(struct xe_lrc_snapshot *snapshot);
 u32 xe_lrc_ctx_timestamp_ggtt_addr(struct xe_lrc *lrc);
-u32 xe_lrc_ctx_timestamp(struct xe_lrc *lrc);
+u32 xe_lrc_ctx_timestamp_udw_ggtt_addr(struct xe_lrc *lrc);
+u64 xe_lrc_ctx_timestamp(struct xe_lrc *lrc);
 u32 xe_lrc_ctx_job_timestamp_ggtt_addr(struct xe_lrc *lrc);
 u32 xe_lrc_ctx_job_timestamp(struct xe_lrc *lrc);
  *
  * Returns the current LRC timestamp
  */
-u32 xe_lrc_update_timestamp(struct xe_lrc *lrc, u32 *old_ts);
+u64 xe_lrc_update_timestamp(struct xe_lrc *lrc, u64 *old_ts);
 #endif

drivers/gpu/drm/xe/xe_lrc_types.h+6−3

 	/** @size: size of lrc including any indirect ring state page */
 	u32 size;
-	/** @tile: tile which this LRC belongs to */
+	/** @gt: gt which this LRC belongs to */
-	struct xe_tile *tile;
+	struct xe_gt *gt;
 	/** @flags: LRC flags */
 #define XE_LRC_FLAG_INDIRECT_RING_STATE		0x1
 	struct xe_hw_fence_ctx fence_ctx;
 	/** @ctx_timestamp: readout value of CTX_TIMESTAMP on last update */
-	u32 ctx_timestamp;
+	u64 ctx_timestamp;
+	/** @bb_per_ctx_bo: buffer object for per context batch wa buffer */
+	struct xe_bo *bb_per_ctx_bo;
 };
 struct xe_lrc_snapshot;

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

@@ -29,9 +29,6 @@ struct xe_modparam xe_modparam = { · 28 unmodified lines
29	module_param_named(svm_notifier_size, xe_modparam.svm_notifier_size, uint, 0600);	29	module_param_named(svm_notifier_size, xe_modparam.svm_notifier_size, uint, 0600);
30	MODULE_PARM_DESC(svm_notifier_size, "Set the svm notifier size(in MiB), must be power of 2");	30	MODULE_PARM_DESC(svm_notifier_size, "Set the svm notifier size(in MiB), must be power of 2");
31		31
32	module_param_named(always_migrate_to_vram, xe_modparam.always_migrate_to_vram, bool, 0444);
33	MODULE_PARM_DESC(always_migrate_to_vram, "Always migrate to VRAM on GPU fault");
34
35	module_param_named_unsafe(force_execlist, xe_modparam.force_execlist, bool, 0444);	32	module_param_named_unsafe(force_execlist, xe_modparam.force_execlist, bool, 0444);
36	MODULE_PARM_DESC(force_execlist, "Force Execlist submission");	33	MODULE_PARM_DESC(force_execlist, "Force Execlist submission");
37		34

drivers/gpu/drm/xe/xe_module.h+0−1

@@ -12,7 +12,6 @@ · 11 unmodified lines
12	struct xe_modparam {	12	struct xe_modparam {
13	bool force_execlist;	13	bool force_execlist;
14	bool probe_display;	14	bool probe_display;
15	bool always_migrate_to_vram;
16	u32 force_vram_bar_size;	15	u32 force_vram_bar_size;
17	int guc_log_level;	16	int guc_log_level;
18	char *guc_firmware_path;	17	char *guc_firmware_path;

drivers/gpu/drm/xe/xe_pci.c+2−0

 	.has_indirect_ring_state = 1, \
 	.has_range_tlb_invalidation = 1, \
 	.has_usm = 1, \
+	.has_64bit_timestamp = 1, \
 	.va_bits = 48, \
 	.vm_max_level = 4, \
 	.hw_engine_mask = \
 	xe->info.has_range_tlb_invalidation = graphics_desc->has_range_tlb_invalidation;
 	xe->info.has_usm = graphics_desc->has_usm;
+	xe->info.has_64bit_timestamp = graphics_desc->has_64bit_timestamp;
 	for_each_remote_tile(tile, xe, id) {
 		int err;

drivers/gpu/drm/xe/xe_pci_types.h+1−0

@@ -21,6 +21,7 @@ struct xe_graphics_desc { · 20 unmodified lines
21	u8 has_indirect_ring_state:1;	21	u8 has_indirect_ring_state:1;
22	u8 has_range_tlb_invalidation:1;	22	u8 has_range_tlb_invalidation:1;
23	u8 has_usm:1;	23	u8 has_usm:1;
		24	u8 has_64bit_timestamp:1;
24	};	25	};
25		26
26	struct xe_media_desc {	27	struct xe_media_desc {

drivers/gpu/drm/xe/xe_pt.c+11−3

 	}
 	case DRM_GPUVA_OP_DRIVER:
 	{
+		/* WRITE_ONCE pairs with READ_ONCE in xe_svm.c */
 		if (op->subop == XE_VMA_SUBOP_MAP_RANGE) {
-			op->map_range.range->tile_present |= BIT(tile->id);
+			WRITE_ONCE(op->map_range.range->tile_present,
-			op->map_range.range->tile_invalidated &= ~BIT(tile->id);
+				   op->map_range.range->tile_present |
+				   BIT(tile->id));
+			WRITE_ONCE(op->map_range.range->tile_invalidated,
+				   op->map_range.range->tile_invalidated &
+				   ~BIT(tile->id));
 		} else if (op->subop == XE_VMA_SUBOP_UNMAP_RANGE) {
-			op->unmap_range.range->tile_present &= ~BIT(tile->id);
+			WRITE_ONCE(op->unmap_range.range->tile_present,
+				   op->unmap_range.range->tile_present &
+				   ~BIT(tile->id));
 		}
 		break;
 	}

drivers/gpu/drm/xe/xe_ring_ops.c+2−5

 static int emit_copy_timestamp(struct xe_lrc *lrc, u32 *dw, int i)
 {
-	dw[i++] = MI_COPY_MEM_MEM | MI_COPY_MEM_MEM_SRC_GGTT |
+	dw[i++] = MI_STORE_REGISTER_MEM | MI_SRM_USE_GGTT | MI_SRM_ADD_CS_OFFSET;
-		MI_COPY_MEM_MEM_DST_GGTT;
+	dw[i++] = RING_CTX_TIMESTAMP(0).addr;
 	dw[i++] = xe_lrc_ctx_job_timestamp_ggtt_addr(lrc);
 	dw[i++] = 0;
-	dw[i++] = xe_lrc_ctx_timestamp_ggtt_addr(lrc);
-	dw[i++] = 0;
-	dw[i++] = MI_NOOP;
 	return i;
 }

drivers/gpu/drm/xe/xe_shrinker.c+1−1

@@ -227,7 +227,7 @@ struct xe_shrinker xe_shrinker_create(struct xe_device xe) · 226 unmodified lines
227	if (!shrinker)	227	if (!shrinker)
228	return ERR_PTR(-ENOMEM);	228	return ERR_PTR(-ENOMEM);
229		229
230	shrinker->shrink = shrinker_alloc(0, "xe system shrinker");	230	shrinker->shrink = shrinker_alloc(0, "drm-xe_gem:%s", xe->drm.unique);
231	if (!shrinker->shrink) {	231	if (!shrinker->shrink) {
232	kfree(shrinker);	232	kfree(shrinker);
233	return ERR_PTR(-ENOMEM);	233	return ERR_PTR(-ENOMEM);

drivers/gpu/drm/xe/xe_svm.c+90−26

 static bool xe_svm_range_in_vram(struct xe_svm_range *range)
 {
-	/* Not reliable without notifier lock */
+	/*
-	return range->base.flags.has_devmem_pages;
+	 * Advisory only check whether the range is currently backed by VRAM
+	 * memory.
+	 */
+	struct drm_gpusvm_range_flags flags = {
+		/* Pairs with WRITE_ONCE in drm_gpusvm.c */
+		.__flags = READ_ONCE(range->base.flags.__flags),
+	};
+	return flags.has_devmem_pages;
 }
 static bool xe_svm_range_has_vram_binding(struct xe_svm_range *range)
 }
 static bool xe_svm_range_is_valid(struct xe_svm_range *range,
-				  struct xe_tile *tile)
+				  struct xe_tile *tile,
+				  bool devmem_only)
 {
-	return (range->tile_present & ~range->tile_invalidated) & BIT(tile->id);
+	/*
+	 * Advisory only check whether the range currently has a valid mapping,
+	 * READ_ONCE pairs with WRITE_ONCE in xe_pt.c
+	 */
+	return ((READ_ONCE(range->tile_present) &
+		 ~READ_ONCE(range->tile_invalidated)) & BIT(tile->id)) &&
+		(!devmem_only || xe_svm_range_in_vram(range));
 }
 static struct xe_vram_region *tile_to_vr(struct xe_tile *tile)
 	return err;
 }
+static bool supports_4K_migration(struct xe_device *xe)
+{
+	if (xe->info.vram_flags & XE_VRAM_FLAGS_NEED64K)
+		return false;
+	return true;
+}
+static bool xe_svm_range_needs_migrate_to_vram(struct xe_svm_range *range,
+					       struct xe_vma *vma)
+{
+	struct xe_vm *vm = range_to_vm(&range->base);
+	u64 range_size = xe_svm_range_size(range);
+	if (!range->base.flags.migrate_devmem)
+		return false;
+	if (xe_svm_range_in_vram(range)) {
+		drm_dbg(&vm->xe->drm, "Range is already in VRAM\n");
+		return false;
+	}
+	if (range_size <= SZ_64K && !supports_4K_migration(vm->xe)) {
+		drm_dbg(&vm->xe->drm, "Platform doesn't support SZ_4K range migration\n");
+		return false;
+	}
+	return true;
+}
 /**
  * xe_svm_handle_pagefault() - SVM handle page fault
  * @vm: The VM.
 			IS_ENABLED(CONFIG_DRM_XE_DEVMEM_MIRROR),
 		.check_pages_threshold = IS_DGFX(vm->xe) &&
 			IS_ENABLED(CONFIG_DRM_XE_DEVMEM_MIRROR) ? SZ_64K : 0,
+		.devmem_only = atomic && IS_DGFX(vm->xe) &&
+			IS_ENABLED(CONFIG_DRM_XE_DEVMEM_MIRROR),
+		.timeslice_ms = atomic && IS_DGFX(vm->xe) &&
+			IS_ENABLED(CONFIG_DRM_XE_DEVMEM_MIRROR) ? 5 : 0,
 	};
 	struct xe_svm_range *range;
 	struct drm_gpusvm_range *r;
 	struct drm_exec exec;
 	struct dma_fence *fence;
+	int migrate_try_count = ctx.devmem_only ? 3 : 1;
 	ktime_t end = 0;
 	int err;
 	if (IS_ERR(r))
 		return PTR_ERR(r);
+	if (ctx.devmem_only && !r->flags.migrate_devmem)
+		return -EACCES;
 	range = to_xe_range(r);
-	if (xe_svm_range_is_valid(range, tile))
+	if (xe_svm_range_is_valid(range, tile, ctx.devmem_only))
 		return 0;
 	range_debug(range, "PAGE FAULT");
-	/* XXX: Add migration policy, for now migrate range once */
+	if (--migrate_try_count >= 0 &&
-	if (!range->skip_migrate && range->base.flags.migrate_devmem &&
+	    xe_svm_range_needs_migrate_to_vram(range, vma)) {
-	    xe_svm_range_size(range) >= SZ_64K) {
-		range->skip_migrate = true;
 		err = xe_svm_alloc_vram(vm, tile, range, &ctx);
+		ctx.timeslice_ms <<= 1;	/* Double timeslice if we have to retry */
 		if (err) {
-			drm_dbg(&vm->xe->drm,
+			if (migrate_try_count || !ctx.devmem_only) {
-				"VRAM allocation failed, falling back to "
+				drm_dbg(&vm->xe->drm,
-				"retrying fault, asid=%u, errno=%pe\n",
+					"VRAM allocation failed, falling back to retrying fault, asid=%u, errno=%pe\n",
-				vm->usm.asid, ERR_PTR(err));
+					vm->usm.asid, ERR_PTR(err));
-			goto retry;
+				goto retry;
+			} else {
+				drm_err(&vm->xe->drm,
+					"VRAM allocation failed, retry count exceeded, asid=%u, errno=%pe\n",
+					vm->usm.asid, ERR_PTR(err));
+				return err;
+			}
 		}
 	}
 	err = drm_gpusvm_range_get_pages(&vm->svm.gpusvm, r, &ctx);
 	/* Corner where CPU mappings have changed */
 	if (err == -EOPNOTSUPP || err == -EFAULT || err == -EPERM) {
-		if (err == -EOPNOTSUPP) {
+		ctx.timeslice_ms <<= 1;	/* Double timeslice if we have to retry */
-			range_debug(range, "PAGE FAULT - EVICT PAGES");
+		if (migrate_try_count > 0 || !ctx.devmem_only) {
-			drm_gpusvm_range_evict(&vm->svm.gpusvm, &range->base);
+			if (err == -EOPNOTSUPP) {
+				range_debug(range, "PAGE FAULT - EVICT PAGES");
+				drm_gpusvm_range_evict(&vm->svm.gpusvm,
+						       &range->base);
+			}
+			drm_dbg(&vm->xe->drm,
+				"Get pages failed, falling back to retrying, asid=%u, gpusvm=%p, errno=%pe\n",
+				vm->usm.asid, &vm->svm.gpusvm, ERR_PTR(err));
+			range_debug(range, "PAGE FAULT - RETRY PAGES");
+			goto retry;
+		} else {
+			drm_err(&vm->xe->drm,
+				"Get pages failed, retry count exceeded, asid=%u, gpusvm=%p, errno=%pe\n",
+				vm->usm.asid, &vm->svm.gpusvm, ERR_PTR(err));
 		}
-		drm_dbg(&vm->xe->drm,
-			"Get pages failed, falling back to retrying, asid=%u, gpusvm=%p, errno=%pe\n",
-			vm->usm.asid, &vm->svm.gpusvm, ERR_PTR(err));
-		range_debug(range, "PAGE FAULT - RETRY PAGES");
-		goto retry;
 	}
 	if (err) {
 		range_debug(range, "PAGE FAULT - FAIL PAGE COLLECT");
 			drm_exec_fini(&exec);
 			err = PTR_ERR(fence);
 			if (err == -EAGAIN) {
+				ctx.timeslice_ms <<= 1;	/* Double timeslice if we have to retry */
 				range_debug(range, "PAGE FAULT - RETRY BIND");
 				goto retry;
 			}
 	}
 	drm_exec_fini(&exec);
-	if (xe_modparam.always_migrate_to_vram)
-		range->skip_migrate = false;
 	dma_fence_wait(fence, false);
 	dma_fence_put(fence);

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

 	 * range. Protected by GPU SVM notifier lock.
 	 */
 	u8 tile_invalidated;
-	/**
-	 * @skip_migrate: Skip migration to VRAM, protected by GPU fault handler
-	 * locking.
-	 */
-	u8 skip_migrate	:1;
 };
 #if IS_ENABLED(CONFIG_DRM_GPUSVM)

drivers/gpu/drm/xe/xe_trace_lrc.h+4−4

@@ -19,12 +19,12 @@ · 18 unmodified lines
19	#define __dev_name_lrc(lrc) dev_name(gt_to_xe((lrc)->fence_ctx.gt)->drm.dev)	19	#define __dev_name_lrc(lrc) dev_name(gt_to_xe((lrc)->fence_ctx.gt)->drm.dev)
20		20
21	TRACE_EVENT(xe_lrc_update_timestamp,	21	TRACE_EVENT(xe_lrc_update_timestamp,
22	TP_PROTO(struct xe_lrc *lrc, uint32_t old),	22	TP_PROTO(struct xe_lrc *lrc, uint64_t old),
23	TP_ARGS(lrc, old),	23	TP_ARGS(lrc, old),
24	TP_STRUCT__entry(	24	TP_STRUCT__entry(
25	__field(struct xe_lrc *, lrc)	25	__field(struct xe_lrc *, lrc)
26	__field(u32, old)	26	__field(u64, old)
27	__field(u32, new)	27	__field(u64, new)
28	__string(name, lrc->fence_ctx.name)	28	__string(name, lrc->fence_ctx.name)
29	__string(device_id, __dev_name_lrc(lrc))	29	__string(device_id, __dev_name_lrc(lrc))
30	),	30	),
@@ -36,7 +36,7 @@ TRACE_EVENT(xe_lrc_update_timestamp, · 5 unmodified lines
36	__assign_str(name);	36	__assign_str(name);
37	__assign_str(device_id);	37	__assign_str(device_id);
38	),	38	),
39	TP_printk("lrc=:%p lrc->name=%s old=%u new=%u device_id:%s",	39	TP_printk("lrc=:%p lrc->name=%s old=%llu new=%llu device_id:%s",
40	__entry->lrc, __get_str(name),	40	__entry->lrc, __get_str(name),
41	__entry->old, __entry->new,	41	__entry->old, __entry->new,
42	__get_str(device_id))	42	__get_str(device_id))

drivers/gpu/drm/xe/xe_wa.c+4−0

 	  XE_RTP_RULES(GRAPHICS_VERSION(2001), ENGINE_CLASS(RENDER)),
 	  XE_RTP_ACTIONS(SET(CHICKEN_RASTER_1, DIS_CLIP_NEGATIVE_BOUNDING_BOX))
 	},
+	{ XE_RTP_NAME("22021007897"),
+	  XE_RTP_RULES(GRAPHICS_VERSION(2001), ENGINE_CLASS(RENDER)),
+	  XE_RTP_ACTIONS(SET(COMMON_SLICE_CHICKEN4, SBE_PUSH_CONSTANT_BEHIND_FIX_ENABLE))
+	},
 	/* Xe3_LPG */
 	{ XE_RTP_NAME("14021490052"),

drivers/hid/amd-sfh-hid/sfh1_1/amd_sfh_init.c+8−4

 		case ALS_IDX:
 			privdata->dev_en.is_als_present = false;
 			break;
+		case SRA_IDX:
+			privdata->dev_en.is_sra_present = false;
+			break;
 		}
 		if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
 	for (i = 0; i < cl_data->num_hid_devices; i++) {
 		cl_data->sensor_sts[i] = SENSOR_DISABLED;
-		if (cl_data->num_hid_devices == 1 && cl_data->sensor_idx[0] == SRA_IDX)
-			break;
 		if (cl_data->sensor_idx[i] == SRA_IDX) {
 			info.sensor_idx = cl_data->sensor_idx[i];
 			writel(0, privdata->mmio + amd_get_p2c_val(privdata, 0));
 				(privdata, cl_data->sensor_idx[i], ENABLE_SENSOR);
 			cl_data->sensor_sts[i] = (status == 0) ? SENSOR_ENABLED : SENSOR_DISABLED;
-			if (cl_data->sensor_sts[i] == SENSOR_ENABLED)
+			if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
+				cl_data->is_any_sensor_enabled = true;
 				privdata->dev_en.is_sra_present = true;
+			}
 			continue;
 		}
 cleanup:
 	amd_sfh_hid_client_deinit(privdata);
 	for (i = 0; i < cl_data->num_hid_devices; i++) {
+		if (cl_data->sensor_idx[i] == SRA_IDX)
+			continue;
 		devm_kfree(dev, cl_data->feature_report[i]);
 		devm_kfree(dev, in_data->input_report[i]);
 		devm_kfree(dev, cl_data->report_descr[i]);

drivers/hid/bpf/hid_bpf_dispatch.c+9−0

 	struct hid_bpf_ops *e;
 	int ret;
+	if (unlikely(hdev->bpf.destroyed))
+		return ERR_PTR(-ENODEV);
 	if (type >= HID_REPORT_TYPES)
 		return ERR_PTR(-EINVAL);
 	struct hid_bpf_ops *e;
 	int ret, idx;
+	if (unlikely(hdev->bpf.destroyed))
+		return -ENODEV;
 	if (rtype >= HID_REPORT_TYPES)
 		return -EINVAL;
 	struct hid_bpf_ops *e;
 	int ret, idx;
+	if (unlikely(hdev->bpf.destroyed))
+		return -ENODEV;
 	idx = srcu_read_lock(&hdev->bpf.srcu);
 	list_for_each_entry_srcu(e, &hdev->bpf.prog_list, list,
 				 srcu_read_lock_held(&hdev->bpf.srcu)) {

drivers/hid/bpf/progs/XPPen__ACK05.bpf.c+1−0

@@ -157,6 +157,7 @@ static const __u8 fixed_rdesc_vendor[] = { · 156 unmodified lines
157	ReportCount(5) // padding	157	ReportCount(5) // padding
158	Input(Const)	158	Input(Const)
159	// Byte 4 in report - just exists so we get to be a tablet pad	159	// Byte 4 in report - just exists so we get to be a tablet pad
		160	UsagePage_Digitizers
160	Usage_Dig_BarrelSwitch // BTN_STYLUS	161	Usage_Dig_BarrelSwitch // BTN_STYLUS
161	ReportCount(1)	162	ReportCount(1)
162	ReportSize(1)	163	ReportSize(1)

drivers/hid/hid-ids.h+4−0

@@ -41,6 +41,10 @@ · 40 unmodified lines
41	#define USB_VENDOR_ID_ACTIONSTAR 0x2101	41	#define USB_VENDOR_ID_ACTIONSTAR 0x2101
42	#define USB_DEVICE_ID_ACTIONSTAR_1011 0x1011	42	#define USB_DEVICE_ID_ACTIONSTAR_1011 0x1011
43		43
		44	#define USB_VENDOR_ID_ADATA_XPG 0x125f
		45	#define USB_VENDOR_ID_ADATA_XPG_WL_GAMING_MOUSE 0x7505
		46	#define USB_VENDOR_ID_ADATA_XPG_WL_GAMING_MOUSE_DONGLE 0x7506
		47
44	#define USB_VENDOR_ID_ADS_TECH 0x06e1	48	#define USB_VENDOR_ID_ADS_TECH 0x06e1
45	#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X 0xa155	49	#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X 0xa155
46		50

drivers/hid/hid-quirks.c+2−0

 static const struct hid_device_id hid_quirks[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD), HID_QUIRK_BADPAD },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR), HID_QUIRK_BADPAD },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_ADATA_XPG, USB_VENDOR_ID_ADATA_XPG_WL_GAMING_MOUSE), HID_QUIRK_ALWAYS_POLL },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_ADATA_XPG, USB_VENDOR_ID_ADATA_XPG_WL_GAMING_MOUSE_DONGLE), HID_QUIRK_ALWAYS_POLL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016), HID_QUIRK_FULLSPEED_INTERVAL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS), HID_QUIRK_NOGET },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AKAI_09E8, USB_DEVICE_ID_AKAI_09E8_MIDIMIX), HID_QUIRK_NO_INIT_REPORTS },

drivers/hid/hid-steam.c+0−2

 	struct steam_device *steam = hdev->driver_data;
 	unsigned long flags;
-	bool connected;
 	spin_lock_irqsave(&steam->lock, flags);
 	steam->client_opened--;
-	connected = steam->connected && !steam->client_opened;
 	spin_unlock_irqrestore(&steam->lock, flags);
 	schedule_work(&steam->unregister_work);

drivers/hid/hid-thrustmaster.c+1−0

@@ -174,6 +174,7 @@ static void thrustmaster_interrupts(struct hid_device *hdev) · 173 unmodified lines
174	u8 ep_addr[2] = {b_ep, 0};	174	u8 ep_addr[2] = {b_ep, 0};
175		175
176	if (!usb_check_int_endpoints(usbif, ep_addr)) {	176	if (!usb_check_int_endpoints(usbif, ep_addr)) {
		177	kfree(send_buf);
177	hid_err(hdev, "Unexpected non-int endpoint\n");	178	hid_err(hdev, "Unexpected non-int endpoint\n");
178	return;	179	return;
179	}	180	}

drivers/hid/hid-uclogic-core.c+4−3

 			suffix = "System Control";
 			break;
 		}
-	}
+	} else {
-	if (suffix)
 		hi->input->name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
 						 "%s %s", hdev->name, suffix);
+		if (!hi->input->name)
+			return -ENOMEM;
+	}
 	return 0;
 }

drivers/hid/wacom_sys.c+10−1

 {
 	while (!kfifo_is_empty(fifo)) {
 		int size = kfifo_peek_len(fifo);
-		u8 *buf = kzalloc(size, GFP_KERNEL);
+		u8 *buf;
 		unsigned int count;
 		int err;
+		buf = kzalloc(size, GFP_KERNEL);
+		if (!buf) {
+			kfifo_skip(fifo);
+			continue;
+		}
 		count = kfifo_out(fifo, buf, size);
 		if (count != size) {
 			// Hard to say what is the "right" action in this
 			// to flush seems reasonable enough, however.
 			hid_warn(hdev, "%s: removed fifo entry with unexpected size\n",
 				 __func__);
+			kfree(buf);
 			continue;
 		}
 		err = hid_report_raw_event(hdev, HID_INPUT_REPORT, buf, size, false);
 	unsigned int connect_mask = HID_CONNECT_HIDRAW;
 	features->pktlen = wacom_compute_pktlen(hdev);
+	if (!features->pktlen)
+		return -ENODEV;
 	if (!devres_open_group(&hdev->dev, wacom, GFP_KERNEL))
 		return -ENOMEM;

drivers/hv/channel.c+3−62

@@ -1077,68 +1077,10 @@ int vmbus_sendpacket(struct vmbus_channel channel, void buffer, · 1076 unmodified lines
1077	EXPORT_SYMBOL(vmbus_sendpacket);	1077	EXPORT_SYMBOL(vmbus_sendpacket);
1078		1078
1079	/*	1079	/*
1080	* vmbus_sendpacket_pagebuffer - Send a range of single-page buffer	1080	* vmbus_sendpacket_mpb_desc - Send one or more multi-page buffer packets
1081	* packets using a GPADL Direct packet type. This interface allows you
1082	* to control notifying the host. This will be useful for sending
1083	* batched data. Also the sender can control the send flags
1084	* explicitly.
1085	*/
1086	int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
1087	struct hv_page_buffer pagebuffers[],
1088	u32 pagecount, void *buffer, u32 bufferlen,
1089	u64 requestid)
1090	{
1091	int i;
1092	struct vmbus_channel_packet_page_buffer desc;
1093	u32 descsize;
1094	u32 packetlen;
1095	u32 packetlen_aligned;
1096	struct kvec bufferlist[3];
1097	u64 aligned_data = 0;
1098
1099	if (pagecount > MAX_PAGE_BUFFER_COUNT)
1100	return -EINVAL;
1101
1102	/*
1103	* Adjust the size down since vmbus_channel_packet_page_buffer is the
1104	* largest size we support
1105	*/
1106	descsize = sizeof(struct vmbus_channel_packet_page_buffer) -
1107	((MAX_PAGE_BUFFER_COUNT - pagecount) *
1108	sizeof(struct hv_page_buffer));
1109	packetlen = descsize + bufferlen;
1110	packetlen_aligned = ALIGN(packetlen, sizeof(u64));
1111
1112	/* Setup the descriptor */
1113	desc.type = VM_PKT_DATA_USING_GPA_DIRECT;
1114	desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
1115	desc.dataoffset8 = descsize >> 3; /* in 8-bytes granularity */
1116	desc.length8 = (u16)(packetlen_aligned >> 3);
1117	desc.transactionid = VMBUS_RQST_ERROR; /* will be updated in hv_ringbuffer_write() */
1118	desc.reserved = 0;
1119	desc.rangecount = pagecount;
1120
1121	for (i = 0; i < pagecount; i++) {
1122	desc.range[i].len = pagebuffers[i].len;
1123	desc.range[i].offset = pagebuffers[i].offset;
1124	desc.range[i].pfn = pagebuffers[i].pfn;
1125	}
1126
1127	bufferlist[0].iov_base = &desc;
1128	bufferlist[0].iov_len = descsize;
1129	bufferlist[1].iov_base = buffer;
1130	bufferlist[1].iov_len = bufferlen;
1131	bufferlist[2].iov_base = &aligned_data;
1132	bufferlist[2].iov_len = (packetlen_aligned - packetlen);
1133
1134	return hv_ringbuffer_write(channel, bufferlist, 3, requestid, NULL);
1135	}
1136	EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer);
1137
1138	/*
1139	* vmbus_sendpacket_multipagebuffer - Send a multi-page buffer packet
1140	* using a GPADL Direct packet type.	1081	* using a GPADL Direct packet type.
1141	* The buffer includes the vmbus descriptor.	1082	* The desc argument must include space for the VMBus descriptor. The
		1083	* rangecount field must already be set.
1142	*/	1084	*/
1143	int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,	1085	int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,
1144	struct vmbus_packet_mpb_array *desc,	1086	struct vmbus_packet_mpb_array *desc,
@@ -1160,7 +1102,6 @@ int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel, · 15 unmodified lines
1160	desc->length8 = (u16)(packetlen_aligned >> 3);	1102	desc->length8 = (u16)(packetlen_aligned >> 3);
1161	desc->transactionid = VMBUS_RQST_ERROR; /* will be updated in hv_ringbuffer_write() */	1103	desc->transactionid = VMBUS_RQST_ERROR; /* will be updated in hv_ringbuffer_write() */
1162	desc->reserved = 0;	1104	desc->reserved = 0;
1163	desc->rangecount = 1;
1164		1105
1165	bufferlist[0].iov_base = desc;	1106	bufferlist[0].iov_base = desc;
1166	bufferlist[0].iov_len = desc_size;	1107	bufferlist[0].iov_len = desc_size;

drivers/i2c/busses/i2c-designware-pcidrv.c+3−1

 	if ((dev->flags & MODEL_MASK) == MODEL_AMD_NAVI_GPU) {
 		dev->slave = i2c_new_ccgx_ucsi(&dev->adapter, dev->irq, &dgpu_node);
-		if (IS_ERR(dev->slave))
+		if (IS_ERR(dev->slave)) {
+			i2c_del_adapter(&dev->adapter);
 			return dev_err_probe(device, PTR_ERR(dev->slave),
 					     "register UCSI failed\n");
+		}
 	}
 	pm_runtime_set_autosuspend_delay(device, 1000);

drivers/infiniband/core/device.c+4−2

 	down_read(&devices_rwsem);
+	/* Mark for userspace that device is ready */
+	kobject_uevent(&device->dev.kobj, KOBJ_ADD);
 	ret = rdma_nl_notify_event(device, 0, RDMA_REGISTER_EVENT);
 	if (ret)
 		goto out;
 		return ret;
 	}
 	dev_set_uevent_suppress(&device->dev, false);
-	/* Mark for userspace that device is ready */
-	kobject_uevent(&device->dev.kobj, KOBJ_ADD);
 	ib_device_notify_register(device);
 	ib_device_put(device);
 	return 0;

drivers/infiniband/hw/irdma/main.c+3−1

 			break;
 	if (i < IRDMA_MIN_MSIX) {
-		for (; i > 0; i--)
+		while (--i >= 0)
 			ice_free_rdma_qvector(pf, &rf->msix_entries[i]);
 		kfree(rf->msix_entries);
 	ice_rdma_update_vsi_filter(pf, iwdev->vsi_num, false);
 	irdma_deinit_interrupts(iwdev->rf, pf);
+	kfree(iwdev->rf);
 	pr_debug("INIT: Gen2 PF[%d] device remove success\n", PCI_FUNC(pf->pdev->devfn));
 }

drivers/infiniband/hw/irdma/verbs.c+0−1

@@ -4871,5 +4871,4 @@ void irdma_ib_dealloc_device(struct ib_device *ibdev) · 4870 unmodified lines
4871		4871
4872	irdma_rt_deinit_hw(iwdev);	4872	irdma_rt_deinit_hw(iwdev);
4873	irdma_ctrl_deinit_hw(iwdev->rf);	4873	irdma_ctrl_deinit_hw(iwdev->rf);
4874	kfree(iwdev->rf);
4875	}	4874	}

drivers/infiniband/sw/rxe/rxe_cq.c+1−4

 	err = do_mmap_info(rxe, uresp ? &uresp->mi : NULL, udata,
 			   cq->queue->buf, cq->queue->buf_size, &cq->queue->ip);
-	if (err) {
+	if (err)
-		vfree(cq->queue->buf);
-		kfree(cq->queue);
 		return err;
-	}
 	cq->is_user = uresp;

drivers/irqchip/irq-gic-v2m.c+1−1

@@ -252,7 +252,7 @@ static void __init gicv2m_teardown(void) · 251 unmodified lines
252	static struct msi_parent_ops gicv2m_msi_parent_ops = {	252	static struct msi_parent_ops gicv2m_msi_parent_ops = {
253	.supported_flags = GICV2M_MSI_FLAGS_SUPPORTED,	253	.supported_flags = GICV2M_MSI_FLAGS_SUPPORTED,
254	.required_flags = GICV2M_MSI_FLAGS_REQUIRED,	254	.required_flags = GICV2M_MSI_FLAGS_REQUIRED,
255	.chip_flags = MSI_CHIP_FLAG_SET_EOI \| MSI_CHIP_FLAG_SET_ACK,	255	.chip_flags = MSI_CHIP_FLAG_SET_EOI,
256	.bus_select_token = DOMAIN_BUS_NEXUS,	256	.bus_select_token = DOMAIN_BUS_NEXUS,
257	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,	257	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,
258	.prefix = "GICv2m-",	258	.prefix = "GICv2m-",

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

@@ -203,7 +203,7 @@ static bool its_init_dev_msi_info(struct device dev, struct irq_domain domain, · 202 unmodified lines
203	const struct msi_parent_ops gic_v3_its_msi_parent_ops = {	203	const struct msi_parent_ops gic_v3_its_msi_parent_ops = {
204	.supported_flags = ITS_MSI_FLAGS_SUPPORTED,	204	.supported_flags = ITS_MSI_FLAGS_SUPPORTED,
205	.required_flags = ITS_MSI_FLAGS_REQUIRED,	205	.required_flags = ITS_MSI_FLAGS_REQUIRED,
206	.chip_flags = MSI_CHIP_FLAG_SET_EOI \| MSI_CHIP_FLAG_SET_ACK,	206	.chip_flags = MSI_CHIP_FLAG_SET_EOI,
207	.bus_select_token = DOMAIN_BUS_NEXUS,	207	.bus_select_token = DOMAIN_BUS_NEXUS,
208	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,	208	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,
209	.prefix = "ITS-",	209	.prefix = "ITS-",

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

@@ -197,7 +197,7 @@ static bool mbi_init_dev_msi_info(struct device dev, struct irq_domain domain, · 196 unmodified lines
197	static const struct msi_parent_ops gic_v3_mbi_msi_parent_ops = {	197	static const struct msi_parent_ops gic_v3_mbi_msi_parent_ops = {
198	.supported_flags = MBI_MSI_FLAGS_SUPPORTED,	198	.supported_flags = MBI_MSI_FLAGS_SUPPORTED,
199	.required_flags = MBI_MSI_FLAGS_REQUIRED,	199	.required_flags = MBI_MSI_FLAGS_REQUIRED,
200	.chip_flags = MSI_CHIP_FLAG_SET_EOI \| MSI_CHIP_FLAG_SET_ACK,	200	.chip_flags = MSI_CHIP_FLAG_SET_EOI,
201	.bus_select_token = DOMAIN_BUS_NEXUS,	201	.bus_select_token = DOMAIN_BUS_NEXUS,
202	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,	202	.bus_select_mask = MATCH_PCI_MSI \| MATCH_PLATFORM_MSI,
203	.prefix = "MBI-",	203	.prefix = "MBI-",

drivers/irqchip/irq-mvebu-gicp.c+1−1

@@ -161,7 +161,7 @@ static const struct irq_domain_ops gicp_domain_ops = { · 160 unmodified lines
161	static const struct msi_parent_ops gicp_msi_parent_ops = {	161	static const struct msi_parent_ops gicp_msi_parent_ops = {
162	.supported_flags = GICP_MSI_FLAGS_SUPPORTED,	162	.supported_flags = GICP_MSI_FLAGS_SUPPORTED,
163	.required_flags = GICP_MSI_FLAGS_REQUIRED,	163	.required_flags = GICP_MSI_FLAGS_REQUIRED,
164	.chip_flags = MSI_CHIP_FLAG_SET_EOI \| MSI_CHIP_FLAG_SET_ACK,	164	.chip_flags = MSI_CHIP_FLAG_SET_EOI,
165	.bus_select_token = DOMAIN_BUS_GENERIC_MSI,	165	.bus_select_token = DOMAIN_BUS_GENERIC_MSI,
166	.bus_select_mask = MATCH_PLATFORM_MSI,	166	.bus_select_mask = MATCH_PLATFORM_MSI,
167	.prefix = "GICP-",	167	.prefix = "GICP-",

drivers/irqchip/irq-mvebu-odmi.c+1−1

@@ -157,7 +157,7 @@ static const struct irq_domain_ops odmi_domain_ops = { · 156 unmodified lines
157	static const struct msi_parent_ops odmi_msi_parent_ops = {	157	static const struct msi_parent_ops odmi_msi_parent_ops = {
158	.supported_flags = ODMI_MSI_FLAGS_SUPPORTED,	158	.supported_flags = ODMI_MSI_FLAGS_SUPPORTED,
159	.required_flags = ODMI_MSI_FLAGS_REQUIRED,	159	.required_flags = ODMI_MSI_FLAGS_REQUIRED,
160	.chip_flags = MSI_CHIP_FLAG_SET_EOI \| MSI_CHIP_FLAG_SET_ACK,	160	.chip_flags = MSI_CHIP_FLAG_SET_EOI,
161	.bus_select_token = DOMAIN_BUS_GENERIC_MSI,	161	.bus_select_token = DOMAIN_BUS_GENERIC_MSI,
162	.bus_select_mask = MATCH_PLATFORM_MSI,	162	.bus_select_mask = MATCH_PLATFORM_MSI,
163	.prefix = "ODMI-",	163	.prefix = "ODMI-",

drivers/irqchip/irq-riscv-imsic-state.c+5−5

@@ -208,17 +208,17 @@ skip: · 207 unmodified lines
208	}	208	}
209		209
210	#ifdef CONFIG_SMP	210	#ifdef CONFIG_SMP
211	static void __imsic_local_timer_start(struct imsic_local_priv *lpriv)	211	static void __imsic_local_timer_start(struct imsic_local_priv *lpriv, unsigned int cpu)
212	{	212	{
213	lockdep_assert_held(&lpriv->lock);	213	lockdep_assert_held(&lpriv->lock);
214		214
215	if (!timer_pending(&lpriv->timer)) {	215	if (!timer_pending(&lpriv->timer)) {
216	lpriv->timer.expires = jiffies + 1;	216	lpriv->timer.expires = jiffies + 1;
217	add_timer_on(&lpriv->timer, smp_processor_id());	217	add_timer_on(&lpriv->timer, cpu);
218	}	218	}
219	}	219	}
220	#else	220	#else
221	static inline void __imsic_local_timer_start(struct imsic_local_priv *lpriv)	221	static inline void __imsic_local_timer_start(struct imsic_local_priv *lpriv, unsigned int cpu)
222	{	222	{
223	}	223	}
224	#endif	224	#endif
@@ -233,7 +233,7 @@ void imsic_local_sync_all(bool force_all) · 8 unmodified lines
233	if (force_all)	233	if (force_all)
234	bitmap_fill(lpriv->dirty_bitmap, imsic->global.nr_ids + 1);	234	bitmap_fill(lpriv->dirty_bitmap, imsic->global.nr_ids + 1);
235	if (!__imsic_local_sync(lpriv))	235	if (!__imsic_local_sync(lpriv))
236	__imsic_local_timer_start(lpriv);	236	__imsic_local_timer_start(lpriv, smp_processor_id());
237		237
238	raw_spin_unlock_irqrestore(&lpriv->lock, flags);	238	raw_spin_unlock_irqrestore(&lpriv->lock, flags);
239	}	239	}
@@ -278,7 +278,7 @@ static void __imsic_remote_sync(struct imsic_local_priv *lpriv, unsigned int cpu · 38 unmodified lines
278	return;	278	return;
279	}	279	}
280		280
281	__imsic_local_timer_start(lpriv);	281	__imsic_local_timer_start(lpriv, cpu);
282	}	282	}
283	}	283	}
284	#else	284	#else

drivers/net/dsa/b53/b53_common.c+33−0

@@ -326,6 +326,26 @@ static void b53_get_vlan_entry(struct b53_device *dev, u16 vid, · 325 unmodified lines
326	}	326	}
327	}	327	}
328		328
		329	static void b53_set_eap_mode(struct b53_device *dev, int port, int mode)
		330	{
		331	u64 eap_conf;
		332
		333	if (is5325(dev) \|\| is5365(dev) \|\| dev->chip_id == BCM5389_DEVICE_ID)
		334	return;
		335
		336	b53_read64(dev, B53_EAP_PAGE, B53_PORT_EAP_CONF(port), &eap_conf);
		337
		338	if (is63xx(dev)) {
		339	eap_conf &= ~EAP_MODE_MASK_63XX;
		340	eap_conf \|= (u64)mode << EAP_MODE_SHIFT_63XX;
		341	} else {
		342	eap_conf &= ~EAP_MODE_MASK;
		343	eap_conf \|= (u64)mode << EAP_MODE_SHIFT;
		344	}
		345
		346	b53_write64(dev, B53_EAP_PAGE, B53_PORT_EAP_CONF(port), eap_conf);
		347	}
		348
329	static void b53_set_forwarding(struct b53_device *dev, int enable)	349	static void b53_set_forwarding(struct b53_device *dev, int enable)
330	{	350	{
331	u8 mgmt;	351	u8 mgmt;
@@ -586,6 +606,13 @@ int b53_setup_port(struct dsa_switch *ds, int port) · 254 unmodified lines
586	b53_port_set_mcast_flood(dev, port, true);	606	b53_port_set_mcast_flood(dev, port, true);
587	b53_port_set_learning(dev, port, false);	607	b53_port_set_learning(dev, port, false);
588		608
		609	/* Force all traffic to go to the CPU port to prevent the ASIC from
		610	* trying to forward to bridged ports on matching FDB entries, then
		611	* dropping frames because it isn't allowed to forward there.
		612	*/
		613	if (dsa_is_user_port(ds, port))
		614	b53_set_eap_mode(dev, port, EAP_MODE_SIMPLIFIED);
		615
589	return 0;	616	return 0;
590	}	617	}
591	EXPORT_SYMBOL(b53_setup_port);	618	EXPORT_SYMBOL(b53_setup_port);
@@ -2042,6 +2069,9 @@ int b53_br_join(struct dsa_switch *ds, int port, struct dsa_bridge bridge, · 1450 unmodified lines
2042	pvlan \|= BIT(i);	2069	pvlan \|= BIT(i);
2043	}	2070	}
2044		2071
		2072	/* Disable redirection of unknown SA to the CPU port */
		2073	b53_set_eap_mode(dev, port, EAP_MODE_BASIC);
		2074
2045	/* Configure the local port VLAN control membership to include	2075	/* Configure the local port VLAN control membership to include
2046	* remote ports and update the local port bitmask	2076	* remote ports and update the local port bitmask
2047	*/	2077	*/
@@ -2077,6 +2107,9 @@ void b53_br_leave(struct dsa_switch *ds, int port, struct dsa_bridge bridge) · 29 unmodified lines
2077	pvlan &= ~BIT(i);	2107	pvlan &= ~BIT(i);
2078	}	2108	}
2079		2109
		2110	/* Enable redirection of unknown SA to the CPU port */
		2111	b53_set_eap_mode(dev, port, EAP_MODE_SIMPLIFIED);
		2112
2080	b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), pvlan);	2113	b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), pvlan);
2081	dev->ports[port].vlan_ctl_mask = pvlan;	2114	dev->ports[port].vlan_ctl_mask = pvlan;
2082		2115

drivers/net/dsa/b53/b53_regs.h+14−0

@@ -50,6 +50,9 @@ · 49 unmodified lines
50	/* Jumbo Frame Registers */	50	/* Jumbo Frame Registers */
51	#define B53_JUMBO_PAGE 0x40	51	#define B53_JUMBO_PAGE 0x40
52		52
		53	/* EAP Registers */
		54	#define B53_EAP_PAGE 0x42
		55
53	/* EEE Control Registers Page */	56	/* EEE Control Registers Page */
54	#define B53_EEE_PAGE 0x92	57	#define B53_EEE_PAGE 0x92
55		58
@@ -480,6 +483,17 @@ · 424 unmodified lines
480	#define JMS_MIN_SIZE 1518	483	#define JMS_MIN_SIZE 1518
481	#define JMS_MAX_SIZE 9724	484	#define JMS_MAX_SIZE 9724
482		485
		486	/*************************************************************************
		487	* EAP Page Registers
		488	*************************************************************************/
		489	#define B53_PORT_EAP_CONF(i) (0x20 + 8 * (i))
		490	#define EAP_MODE_SHIFT 51
		491	#define EAP_MODE_SHIFT_63XX 50
		492	#define EAP_MODE_MASK (0x3ull << EAP_MODE_SHIFT)
		493	#define EAP_MODE_MASK_63XX (0x3ull << EAP_MODE_SHIFT_63XX)
		494	#define EAP_MODE_BASIC 0
		495	#define EAP_MODE_SIMPLIFIED 3
		496
483	/*************************************************************************	497	/*************************************************************************
484	* EEE Configuration Page Registers	498	* EEE Configuration Page Registers
485	*************************************************************************/	499	*************************************************************************/

drivers/net/dsa/microchip/ksz_common.c+107−28

@@ -265,16 +265,70 @@ static void ksz_phylink_mac_link_down(struct phylink_config *config, · 264 unmodified lines
265	unsigned int mode,	265	unsigned int mode,
266	phy_interface_t interface);	266	phy_interface_t interface);
267		267
		268	/**
		269	* ksz_phylink_mac_disable_tx_lpi() - Callback to signal LPI support (Dummy)
		270	* @config: phylink config structure
		271	*
		272	* This function is a dummy handler. See ksz_phylink_mac_enable_tx_lpi() for
		273	* a detailed explanation of EEE/LPI handling in KSZ switches.
		274	*/
		275	static void ksz_phylink_mac_disable_tx_lpi(struct phylink_config *config)
		276	{
		277	}
		278
		279	/**
		280	* ksz_phylink_mac_enable_tx_lpi() - Callback to signal LPI support (Dummy)
		281	* @config: phylink config structure
		282	* @timer: timer value before entering LPI (unused)
		283	* @tx_clock_stop: whether to stop the TX clock in LPI mode (unused)
		284	*
		285	* This function signals to phylink that the driver architecture supports
		286	* LPI management, enabling phylink to control EEE advertisement during
		287	* negotiation according to IEEE Std 802.3 (Clause 78).
		288	*
		289	* Hardware Management of EEE/LPI State:
		290	* For KSZ switch ports with integrated PHYs (e.g., KSZ9893R ports 1-2),
		291	* observation and testing suggest that the actual EEE / Low Power Idle (LPI)
		292	* state transitions are managed autonomously by the hardware based on
		293	* the auto-negotiation results. (Note: While the datasheet describes EEE
		294	* operation based on negotiation, it doesn't explicitly detail the internal
		295	* MAC/PHY interaction, so autonomous hardware management of the MAC state
		296	* for LPI is inferred from observed behavior).
		297	* This hardware control, consistent with the switch's ability to operate
		298	* autonomously via strapping, means MAC-level software intervention is not
		299	* required or exposed for managing the LPI state once EEE is negotiated.
		300	* (Ref: KSZ9893R Data Sheet DS00002420D, primarily Section 4.7.5 explaining
		301	* EEE, also Sections 4.1.7 on Auto-Negotiation and 3.2.1 on Configuration
		302	* Straps).
		303	*
		304	* Additionally, ports configured as MAC interfaces (e.g., KSZ9893R port 3)
		305	* lack documented MAC-level LPI control.
		306	*
		307	* Therefore, this callback performs no action and serves primarily to inform
		308	* phylink of LPI awareness and to document the inferred hardware behavior.
		309	*
		310	* Returns: 0 (Always success)
		311	*/
		312	static int ksz_phylink_mac_enable_tx_lpi(struct phylink_config *config,
		313	u32 timer, bool tx_clock_stop)
		314	{
		315	return 0;
		316	}
		317
268	static const struct phylink_mac_ops ksz88x3_phylink_mac_ops = {	318	static const struct phylink_mac_ops ksz88x3_phylink_mac_ops = {
269	.mac_config = ksz88x3_phylink_mac_config,	319	.mac_config = ksz88x3_phylink_mac_config,
270	.mac_link_down = ksz_phylink_mac_link_down,	320	.mac_link_down = ksz_phylink_mac_link_down,
271	.mac_link_up = ksz8_phylink_mac_link_up,	321	.mac_link_up = ksz8_phylink_mac_link_up,
		322	.mac_disable_tx_lpi = ksz_phylink_mac_disable_tx_lpi,
		323	.mac_enable_tx_lpi = ksz_phylink_mac_enable_tx_lpi,
272	};	324	};
273		325
274	static const struct phylink_mac_ops ksz8_phylink_mac_ops = {	326	static const struct phylink_mac_ops ksz8_phylink_mac_ops = {
275	.mac_config = ksz_phylink_mac_config,	327	.mac_config = ksz_phylink_mac_config,
276	.mac_link_down = ksz_phylink_mac_link_down,	328	.mac_link_down = ksz_phylink_mac_link_down,
277	.mac_link_up = ksz8_phylink_mac_link_up,	329	.mac_link_up = ksz8_phylink_mac_link_up,
		330	.mac_disable_tx_lpi = ksz_phylink_mac_disable_tx_lpi,
		331	.mac_enable_tx_lpi = ksz_phylink_mac_enable_tx_lpi,
278	};	332	};
279		333
280	static const struct ksz_dev_ops ksz88xx_dev_ops = {	334	static const struct ksz_dev_ops ksz88xx_dev_ops = {
@@ -358,6 +412,8 @@ static const struct phylink_mac_ops ksz9477_phylink_mac_ops = { · 77 unmodified lines
358	.mac_config = ksz_phylink_mac_config,	412	.mac_config = ksz_phylink_mac_config,
359	.mac_link_down = ksz_phylink_mac_link_down,	413	.mac_link_down = ksz_phylink_mac_link_down,
360	.mac_link_up = ksz9477_phylink_mac_link_up,	414	.mac_link_up = ksz9477_phylink_mac_link_up,
		415	.mac_disable_tx_lpi = ksz_phylink_mac_disable_tx_lpi,
		416	.mac_enable_tx_lpi = ksz_phylink_mac_enable_tx_lpi,
361	};	417	};
362		418
363	static const struct ksz_dev_ops ksz9477_dev_ops = {	419	static const struct ksz_dev_ops ksz9477_dev_ops = {
@@ -401,6 +457,8 @@ static const struct phylink_mac_ops lan937x_phylink_mac_ops = { · 37 unmodified lines
401	.mac_config = ksz_phylink_mac_config,	457	.mac_config = ksz_phylink_mac_config,
402	.mac_link_down = ksz_phylink_mac_link_down,	458	.mac_link_down = ksz_phylink_mac_link_down,
403	.mac_link_up = ksz9477_phylink_mac_link_up,	459	.mac_link_up = ksz9477_phylink_mac_link_up,
		460	.mac_disable_tx_lpi = ksz_phylink_mac_disable_tx_lpi,
		461	.mac_enable_tx_lpi = ksz_phylink_mac_enable_tx_lpi,
404	};	462	};
405		463
406	static const struct ksz_dev_ops lan937x_dev_ops = {	464	static const struct ksz_dev_ops lan937x_dev_ops = {
@@ -2016,6 +2074,18 @@ static void ksz_phylink_get_caps(struct dsa_switch *ds, int port, · 1609 unmodified lines
2016		2074
2017	if (dev->dev_ops->get_caps)	2075	if (dev->dev_ops->get_caps)
2018	dev->dev_ops->get_caps(dev, port, config);	2076	dev->dev_ops->get_caps(dev, port, config);
		2077
		2078	if (ds->ops->support_eee && ds->ops->support_eee(ds, port)) {
		2079	memcpy(config->lpi_interfaces, config->supported_interfaces,
		2080	sizeof(config->lpi_interfaces));
		2081
		2082	config->lpi_capabilities = MAC_100FD;
		2083	if (dev->info->gbit_capable[port])
		2084	config->lpi_capabilities \|= MAC_1000FD;
		2085
		2086	/* EEE is fully operational */
		2087	config->eee_enabled_default = true;
		2088	}
2019	}	2089	}
2020		2090
2021	void ksz_r_mib_stats64(struct ksz_device *dev, int port)	2091	void ksz_r_mib_stats64(struct ksz_device *dev, int port)
@@ -3008,31 +3078,6 @@ static u32 ksz_get_phy_flags(struct dsa_switch *ds, int port) · 986 unmodified lines
3008	if (!port)	3078	if (!port)
3009	return MICREL_KSZ8_P1_ERRATA;	3079	return MICREL_KSZ8_P1_ERRATA;
3010	break;	3080	break;
3011	case KSZ8567_CHIP_ID:
3012	/* KSZ8567R Errata DS80000752C Module 4 */
3013	case KSZ8765_CHIP_ID:
3014	case KSZ8794_CHIP_ID:
3015	case KSZ8795_CHIP_ID:
3016	/* KSZ879x/KSZ877x/KSZ876x Errata DS80000687C Module 2 */
3017	case KSZ9477_CHIP_ID:
3018	/* KSZ9477S Errata DS80000754A Module 4 */
3019	case KSZ9567_CHIP_ID:
3020	/* KSZ9567S Errata DS80000756A Module 4 */
3021	case KSZ9896_CHIP_ID:
3022	/* KSZ9896C Errata DS80000757A Module 3 */
3023	case KSZ9897_CHIP_ID:
3024	case LAN9646_CHIP_ID:
3025	/* KSZ9897R Errata DS80000758C Module 4 */
3026	/* Energy Efficient Ethernet (EEE) feature select must be manually disabled
3027	* The EEE feature is enabled by default, but it is not fully
3028	* operational. It must be manually disabled through register
3029	* controls. If not disabled, the PHY ports can auto-negotiate
3030	* to enable EEE, and this feature can cause link drops when
3031	* linked to another device supporting EEE.
3032	*
3033	* The same item appears in the errata for all switches above.
3034	*/
3035	return MICREL_NO_EEE;
3036	}	3081	}
3037		3082
3038	return 0;	3083	return 0;
@@ -3466,6 +3511,20 @@ static int ksz_max_mtu(struct dsa_switch *ds, int port) · 427 unmodified lines
3466	return -EOPNOTSUPP;	3511	return -EOPNOTSUPP;
3467	}	3512	}
3468		3513
		3514	/**
		3515	* ksz_support_eee - Determine Energy Efficient Ethernet (EEE) support for a
		3516	* port
		3517	* @ds: Pointer to the DSA switch structure
		3518	* @port: Port number to check
		3519	*
		3520	* This function also documents devices where EEE was initially advertised but
		3521	* later withdrawn due to reliability issues, as described in official errata
		3522	* documents. These devices are explicitly listed to record known limitations,
		3523	* even if there is no technical necessity for runtime checks.
		3524	*
		3525	* Returns: true if the internal PHY on the given port supports fully
		3526	* operational EEE, false otherwise.
		3527	*/
3469	static bool ksz_support_eee(struct dsa_switch *ds, int port)	3528	static bool ksz_support_eee(struct dsa_switch *ds, int port)
3470	{	3529	{
3471	struct ksz_device *dev = ds->priv;	3530	struct ksz_device *dev = ds->priv;
@@ -3475,15 +3534,35 @@ static bool ksz_support_eee(struct dsa_switch *ds, int port) · 3 unmodified lines
3475		3534
3476	switch (dev->chip_id) {	3535	switch (dev->chip_id) {
3477	case KSZ8563_CHIP_ID:	3536	case KSZ8563_CHIP_ID:
		3537	case KSZ9563_CHIP_ID:
		3538	case KSZ9893_CHIP_ID:
		3539	return true;
3478	case KSZ8567_CHIP_ID:	3540	case KSZ8567_CHIP_ID:
		3541	/* KSZ8567R Errata DS80000752C Module 4 */
		3542	case KSZ8765_CHIP_ID:
		3543	case KSZ8794_CHIP_ID:
		3544	case KSZ8795_CHIP_ID:
		3545	/* KSZ879x/KSZ877x/KSZ876x Errata DS80000687C Module 2 */
3479	case KSZ9477_CHIP_ID:	3546	case KSZ9477_CHIP_ID:
3480	case KSZ9563_CHIP_ID:	3547	/* KSZ9477S Errata DS80000754A Module 4 */
3481	case KSZ9567_CHIP_ID:	3548	case KSZ9567_CHIP_ID:
3482	case KSZ9893_CHIP_ID:	3549	/* KSZ9567S Errata DS80000756A Module 4 */
3483	case KSZ9896_CHIP_ID:	3550	case KSZ9896_CHIP_ID:
		3551	/* KSZ9896C Errata DS80000757A Module 3 */
3484	case KSZ9897_CHIP_ID:	3552	case KSZ9897_CHIP_ID:
3485	case LAN9646_CHIP_ID:	3553	case LAN9646_CHIP_ID:
3486	return true;	3554	/* KSZ9897R Errata DS80000758C Module 4 */
		3555	/* Energy Efficient Ethernet (EEE) feature select must be
		3556	* manually disabled
		3557	* The EEE feature is enabled by default, but it is not fully
		3558	* operational. It must be manually disabled through register
		3559	* controls. If not disabled, the PHY ports can auto-negotiate
		3560	* to enable EEE, and this feature can cause link drops when
		3561	* linked to another device supporting EEE.
		3562	*
		3563	* The same item appears in the errata for all switches above.
		3564	*/
		3565	break;
3487	}	3566	}
3488		3567
3489	return false;	3568	return false;

drivers/net/dsa/sja1105/sja1105_main.c+1−5

 	switch (state) {
 	case BR_STATE_DISABLED:
 	case BR_STATE_BLOCKING:
+	case BR_STATE_LISTENING:
 		/* From UM10944 description of DRPDTAG (why put this there?):
 		 * "Management traffic flows to the port regardless of the state
 		 * of the INGRESS flag". So BPDUs are still be allowed to pass.
 		mac[port].egress    = false;
 		mac[port].dyn_learn = false;
 		break;
-	case BR_STATE_LISTENING:
-		mac[port].ingress   = true;
-		mac[port].egress    = false;
-		mac[port].dyn_learn = false;
-		break;
 	case BR_STATE_LEARNING:
 		mac[port].ingress   = true;
 		mac[port].egress    = false;

drivers/net/ethernet/broadcom/bnxt/bnxt.c+29−7

 	netdev_unlock(bp->dev);
 }
+/* Same as bnxt_lock_sp() with additional rtnl_lock */
+static void bnxt_rtnl_lock_sp(struct bnxt *bp)
+{
+	clear_bit(BNXT_STATE_IN_SP_TASK, &bp->state);
+	rtnl_lock();
+	netdev_lock(bp->dev);
+}
+static void bnxt_rtnl_unlock_sp(struct bnxt *bp)
+{
+	set_bit(BNXT_STATE_IN_SP_TASK, &bp->state);
+	netdev_unlock(bp->dev);
+	rtnl_unlock();
+}
 /* Only called from bnxt_sp_task() */
 static void bnxt_reset(struct bnxt *bp, bool silent)
 {
-	bnxt_lock_sp(bp);
+	bnxt_rtnl_lock_sp(bp);
 	if (test_bit(BNXT_STATE_OPEN, &bp->state))
 		bnxt_reset_task(bp, silent);
-	bnxt_unlock_sp(bp);
+	bnxt_rtnl_unlock_sp(bp);
 }
 /* Only called from bnxt_sp_task() */
 {
 	int i;
-	bnxt_lock_sp(bp);
+	bnxt_rtnl_lock_sp(bp);
 	if (!test_bit(BNXT_STATE_OPEN, &bp->state)) {
-		bnxt_unlock_sp(bp);
+		bnxt_rtnl_unlock_sp(bp);
 		return;
 	}
 	/* Disable and flush TPA before resetting the RX ring */
 	}
 	if (bp->flags & BNXT_FLAG_TPA)
 		bnxt_set_tpa(bp, true);
-	bnxt_unlock_sp(bp);
+	bnxt_rtnl_unlock_sp(bp);
 }
 static void bnxt_fw_fatal_close(struct bnxt *bp)
 		bp->fw_reset_state = BNXT_FW_RESET_STATE_OPENING;
 		fallthrough;
 	case BNXT_FW_RESET_STATE_OPENING:
-		while (!netdev_trylock(bp->dev)) {
+		while (!rtnl_trylock()) {
 			bnxt_queue_fw_reset_work(bp, HZ / 10);
 			return;
 		}
+		netdev_lock(bp->dev);
 		rc = bnxt_open(bp->dev);
 		if (rc) {
 			netdev_err(bp->dev, "bnxt_open() failed during FW reset\n");
 			bnxt_fw_reset_abort(bp, rc);
 			netdev_unlock(bp->dev);
+			rtnl_unlock();
 			goto ulp_start;
 		}
 			bnxt_dl_health_fw_status_update(bp, true);
 		}
 		netdev_unlock(bp->dev);
+		rtnl_unlock();
 		bnxt_ulp_start(bp, 0);
 		bnxt_reenable_sriov(bp);
 		netdev_lock(bp->dev);
 		   rc);
 	napi_enable_locked(&bnapi->napi);
 	bnxt_db_nq_arm(bp, &cpr->cp_db, cpr->cp_raw_cons);
-	bnxt_reset_task(bp, true);
+	netif_close(dev);
 	return rc;
 }
 	struct bnxt *bp = netdev_priv(dev);
 	int rc = 0;
+	rtnl_lock();
 	netdev_lock(dev);
 	rc = pci_enable_device(bp->pdev);
 	if (rc) {
 resume_exit:
 	netdev_unlock(bp->dev);
+	rtnl_unlock();
 	bnxt_ulp_start(bp, rc);
 	if (!rc)
 		bnxt_reenable_sriov(bp);
 	int err;
 	netdev_info(bp->dev, "PCI Slot Resume\n");
+	rtnl_lock();
 	netdev_lock(netdev);
 	err = bnxt_hwrm_func_qcaps(bp);
 		netif_device_attach(netdev);
 	netdev_unlock(netdev);
+	rtnl_unlock();
 	bnxt_ulp_start(bp, err);
 	if (!err)
 		bnxt_reenable_sriov(bp);

drivers/net/ethernet/cadence/macb_main.c+6−13

 static int macb_halt_tx(struct macb *bp)
 {
-	unsigned long	halt_time, timeout;
+	u32 status;
-	u32		status;
 	macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(THALT));
-	timeout = jiffies + usecs_to_jiffies(MACB_HALT_TIMEOUT);
+	/* Poll TSR until TGO is cleared or timeout. */
-	do {
+	return read_poll_timeout_atomic(macb_readl, status,
-		halt_time = jiffies;
+					!(status & MACB_BIT(TGO)),
-		status = macb_readl(bp, TSR);
+					250, MACB_HALT_TIMEOUT, false,
-		if (!(status & MACB_BIT(TGO)))
+					bp, TSR);
-			return 0;
-		udelay(250);
-	} while (time_before(halt_time, timeout));
-	return -ETIMEDOUT;
 }
 static void macb_tx_unmap(struct macb *bp, struct macb_tx_skb *tx_skb, int budget)

drivers/net/ethernet/engleder/tsnep_main.c+19−11

 #define TSNEP_TX_TYPE_XDP_NDO_MAP_PAGE	(TSNEP_TX_TYPE_XDP_NDO | TSNEP_TX_TYPE_MAP_PAGE)
 #define TSNEP_TX_TYPE_XDP		(TSNEP_TX_TYPE_XDP_TX | TSNEP_TX_TYPE_XDP_NDO)
 #define TSNEP_TX_TYPE_XSK		BIT(12)
+#define TSNEP_TX_TYPE_TSTAMP		BIT(13)
+#define TSNEP_TX_TYPE_SKB_TSTAMP	(TSNEP_TX_TYPE_SKB | TSNEP_TX_TYPE_TSTAMP)
 #define TSNEP_XDP_TX		BIT(0)
 #define TSNEP_XDP_REDIRECT	BIT(1)
 	if (entry->skb) {
 		entry->properties = length & TSNEP_DESC_LENGTH_MASK;
 		entry->properties |= TSNEP_DESC_INTERRUPT_FLAG;
-		if ((entry->type & TSNEP_TX_TYPE_SKB) &&
+		if ((entry->type & TSNEP_TX_TYPE_SKB_TSTAMP) == TSNEP_TX_TYPE_SKB_TSTAMP)
-		    (skb_shinfo(entry->skb)->tx_flags & SKBTX_IN_PROGRESS))
 			entry->properties |= TSNEP_DESC_EXTENDED_WRITEBACK_FLAG;
 		/* toggle user flag to prevent false acknowledge
 	return mapped;
 }
-static int tsnep_tx_map(struct sk_buff *skb, struct tsnep_tx *tx, int count)
+static int tsnep_tx_map(struct sk_buff *skb, struct tsnep_tx *tx, int count,
+			bool do_tstamp)
 {
 	struct device *dmadev = tx->adapter->dmadev;
 	struct tsnep_tx_entry *entry;
 				entry->type = TSNEP_TX_TYPE_SKB_INLINE;
 				mapped = 0;
 			}
+			if (do_tstamp)
+				entry->type |= TSNEP_TX_TYPE_TSTAMP;
 		} else {
 			skb_frag_t *frag = &skb_shinfo(skb)->frags[i - 1];
 static netdev_tx_t tsnep_xmit_frame_ring(struct sk_buff *skb,
 					 struct tsnep_tx *tx)
 {
-	int count = 1;
 	struct tsnep_tx_entry *entry;
+	bool do_tstamp = false;
+	int count = 1;
 	int length;
-	int i;
 	int retval;
+	int i;
 	if (skb_shinfo(skb)->nr_frags > 0)
 		count += skb_shinfo(skb)->nr_frags;
 	entry = &tx->entry[tx->write];
 	entry->skb = skb;
-	retval = tsnep_tx_map(skb, tx, count);
+	if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+	    tx->adapter->hwtstamp_config.tx_type == HWTSTAMP_TX_ON) {
+		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+		do_tstamp = true;
+	}
+	retval = tsnep_tx_map(skb, tx, count, do_tstamp);
 	if (retval < 0) {
 		tsnep_tx_unmap(tx, tx->write, count);
 		dev_kfree_skb_any(entry->skb);
 	}
 	length = retval;
-	if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)
-		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
 	for (i = 0; i < count; i++)
 		tsnep_tx_activate(tx, (tx->write + i) & TSNEP_RING_MASK, length,
 				  i == count - 1);
 		length = tsnep_tx_unmap(tx, tx->read, count);
-		if ((entry->type & TSNEP_TX_TYPE_SKB) &&
+		if (((entry->type & TSNEP_TX_TYPE_SKB_TSTAMP) == TSNEP_TX_TYPE_SKB_TSTAMP) &&
-		    (skb_shinfo(entry->skb)->tx_flags & SKBTX_IN_PROGRESS) &&
 		    (__le32_to_cpu(entry->desc_wb->properties) &
 		     TSNEP_DESC_EXTENDED_WRITEBACK_FLAG)) {
 			struct skb_shared_hwtstamps hwtstamps;

drivers/net/ethernet/marvell/octeontx2/af/cgx.c+5−0

 	if (!is_lmac_valid(cgx, lmac_id))
 		return -ENODEV;
+	/* pass lmac as 0 for CGX_CMR_RX_STAT9-12 */
+	if (idx >= CGX_RX_STAT_GLOBAL_INDEX)
+		lmac_id = 0;
 	*rx_stat =  cgx_read(cgx, lmac_id, CGXX_CMRX_RX_STAT0 + (idx * 8));
 	return 0;
 }

drivers/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c+2−1

@@ -531,7 +531,8 @@ static int cn10k_mcs_write_tx_secy(struct otx2_nic *pfvf, · 530 unmodified lines
531	if (sw_tx_sc->encrypt)	531	if (sw_tx_sc->encrypt)
532	sectag_tci \|= (MCS_TCI_E \| MCS_TCI_C);	532	sectag_tci \|= (MCS_TCI_E \| MCS_TCI_C);
533		533
534	policy = FIELD_PREP(MCS_TX_SECY_PLCY_MTU, secy->netdev->mtu);	534	policy = FIELD_PREP(MCS_TX_SECY_PLCY_MTU,
		535	pfvf->netdev->mtu + OTX2_ETH_HLEN);
535	/* Write SecTag excluding AN bits(1..0) */	536	/* Write SecTag excluding AN bits(1..0) */
536	policy \|= FIELD_PREP(MCS_TX_SECY_PLCY_ST_TCI, sectag_tci >> 2);	537	policy \|= FIELD_PREP(MCS_TX_SECY_PLCY_ST_TCI, sectag_tci >> 2);
537	policy \|= FIELD_PREP(MCS_TX_SECY_PLCY_ST_OFFSET, tag_offset);	538	policy \|= FIELD_PREP(MCS_TX_SECY_PLCY_ST_OFFSET, tag_offset);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h+1−0

@@ -356,6 +356,7 @@ struct otx2_flow_config { · 355 unmodified lines
356	struct list_head flow_list_tc;	356	struct list_head flow_list_tc;
357	u8 ucast_flt_cnt;	357	u8 ucast_flt_cnt;
358	bool ntuple;	358	bool ntuple;
		359	u16 ntuple_cnt;
359	};	360	};
360		361
361	struct dev_hw_ops {	362	struct dev_hw_ops {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_devlink.c+1−0

@@ -41,6 +41,7 @@ static int otx2_dl_mcam_count_set(struct devlink *devlink, u32 id, · 40 unmodified lines
41	if (!pfvf->flow_cfg)	41	if (!pfvf->flow_cfg)
42	return 0;	42	return 0;
43		43
		44	pfvf->flow_cfg->ntuple_cnt = ctx->val.vu16;
44	otx2_alloc_mcam_entries(pfvf, ctx->val.vu16);	45	otx2_alloc_mcam_entries(pfvf, ctx->val.vu16);
45		46
46	return 0;	47	return 0;

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

@@ -315,7 +315,7 @@ static void otx2_get_pauseparam(struct net_device *netdev, · 314 unmodified lines
315	struct otx2_nic *pfvf = netdev_priv(netdev);	315	struct otx2_nic *pfvf = netdev_priv(netdev);
316	struct cgx_pause_frm_cfg req, rsp;	316	struct cgx_pause_frm_cfg req, rsp;
317		317
318	if (is_otx2_lbkvf(pfvf->pdev))	318	if (is_otx2_lbkvf(pfvf->pdev) \|\| is_otx2_sdp_rep(pfvf->pdev))
319	return;	319	return;
320		320
321	mutex_lock(&pfvf->mbox.lock);	321	mutex_lock(&pfvf->mbox.lock);
@@ -347,7 +347,7 @@ static int otx2_set_pauseparam(struct net_device *netdev, · 25 unmodified lines
347	if (pause->autoneg)	347	if (pause->autoneg)
348	return -EOPNOTSUPP;	348	return -EOPNOTSUPP;
349		349
350	if (is_otx2_lbkvf(pfvf->pdev))	350	if (is_otx2_lbkvf(pfvf->pdev) \|\| is_otx2_sdp_rep(pfvf->pdev))
351	return -EOPNOTSUPP;	351	return -EOPNOTSUPP;
352		352
353	if (pause->rx_pause)	353	if (pause->rx_pause)
@@ -941,8 +941,8 @@ static u32 otx2_get_link(struct net_device *netdev) · 587 unmodified lines
941	{	941	{
942	struct otx2_nic *pfvf = netdev_priv(netdev);	942	struct otx2_nic *pfvf = netdev_priv(netdev);
943		943
944	/* LBK link is internal and always UP */	944	/* LBK and SDP links are internal and always UP */
945	if (is_otx2_lbkvf(pfvf->pdev))	945	if (is_otx2_lbkvf(pfvf->pdev) \|\| is_otx2_sdp_rep(pfvf->pdev))
946	return 1;	946	return 1;
947	return pfvf->linfo.link_up;	947	return pfvf->linfo.link_up;
948	}	948	}
@@ -1413,7 +1413,7 @@ static int otx2vf_get_link_ksettings(struct net_device *netdev, · 464 unmodified lines
1413	{	1413	{
1414	struct otx2_nic *pfvf = netdev_priv(netdev);	1414	struct otx2_nic *pfvf = netdev_priv(netdev);
1415		1415
1416	if (is_otx2_lbkvf(pfvf->pdev)) {	1416	if (is_otx2_lbkvf(pfvf->pdev) \|\| is_otx2_sdp_rep(pfvf->pdev)) {
1417	cmd->base.duplex = DUPLEX_FULL;	1417	cmd->base.duplex = DUPLEX_FULL;
1418	cmd->base.speed = SPEED_100000;	1418	cmd->base.speed = SPEED_100000;
1419	} else {	1419	} else {

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

 	mutex_unlock(&pfvf->mbox.lock);
 	/* Allocate entries for Ntuple filters */
-	count = otx2_alloc_mcam_entries(pfvf, OTX2_DEFAULT_FLOWCOUNT);
+	count = otx2_alloc_mcam_entries(pfvf, flow_cfg->ntuple_cnt);
 	if (count <= 0) {
 		otx2_clear_ntuple_flow_info(pfvf, flow_cfg);
 		return 0;
 	INIT_LIST_HEAD(&pf->flow_cfg->flow_list_tc);
 	pf->flow_cfg->ucast_flt_cnt = OTX2_DEFAULT_UNICAST_FLOWS;
+	pf->flow_cfg->ntuple_cnt = OTX2_DEFAULT_FLOWCOUNT;
 	/* Allocate bare minimum number of MCAM entries needed for
 	 * unicast and ntuple filters.

drivers/net/ethernet/mediatek/mtk_eth_soc.c+1−1

@@ -4748,7 +4748,7 @@ static int mtk_add_mac(struct mtk_eth eth, struct device_node np) · 4747 unmodified lines
4748	}	4748	}
4749		4749
4750	if (mtk_is_netsys_v3_or_greater(mac->hw) &&	4750	if (mtk_is_netsys_v3_or_greater(mac->hw) &&
4751	MTK_HAS_CAPS(mac->hw->soc->caps, MTK_ESW_BIT) &&	4751	MTK_HAS_CAPS(mac->hw->soc->caps, MTK_ESW) &&
4752	id == MTK_GMAC1_ID) {	4752	id == MTK_GMAC1_ID) {
4753	mac->phylink_config.mac_capabilities = MAC_ASYM_PAUSE \|	4753	mac->phylink_config.mac_capabilities = MAC_ASYM_PAUSE \|
4754	MAC_SYM_PAUSE \|	4754	MAC_SYM_PAUSE \|

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

@@ -4349,6 +4349,10 @@ static netdev_features_t mlx5e_fix_uplink_rep_features(struct net_device *netdev · 4348 unmodified lines
4349	if (netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)	4349	if (netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
4350	netdev_warn(netdev, "Disabling HW_VLAN CTAG FILTERING, not supported in switchdev mode\n");	4350	netdev_warn(netdev, "Disabling HW_VLAN CTAG FILTERING, not supported in switchdev mode\n");
4351		4351
		4352	features &= ~NETIF_F_HW_MACSEC;
		4353	if (netdev->features & NETIF_F_HW_MACSEC)
		4354	netdev_warn(netdev, "Disabling HW MACsec offload, not supported in switchdev mode\n");
		4355
4352	return features;	4356	return features;
4353	}	4357	}
4354		4358

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+3−0

@@ -3014,6 +3014,9 @@ static int mlxsw_sp_neigh_rif_made_sync(struct mlxsw_sp *mlxsw_sp, · 3013 unmodified lines
3014	.rif = rif,	3014	.rif = rif,
3015	};	3015	};
3016		3016
		3017	if (!mlxsw_sp_dev_lower_is_port(mlxsw_sp_rif_dev(rif)))
		3018	return 0;
		3019
3017	neigh_for_each(&arp_tbl, mlxsw_sp_neigh_rif_made_sync_each, &rms);	3020	neigh_for_each(&arp_tbl, mlxsw_sp_neigh_rif_made_sync_each, &rms);
3018	if (rms.err)	3021	if (rms.err)
3019	goto err_arp;	3022	goto err_arp;

drivers/net/ethernet/qlogic/qede/qede_main.c+1−1

@@ -203,7 +203,7 @@ static struct pci_driver qede_pci_driver = { · 202 unmodified lines
203	};	203	};
204		204
205	static struct qed_eth_cb_ops qede_ll_ops = {	205	static struct qed_eth_cb_ops qede_ll_ops = {
206	{	206	.common = {
207	#ifdef CONFIG_RFS_ACCEL	207	#ifdef CONFIG_RFS_ACCEL
208	.arfs_filter_op = qede_arfs_filter_op,	208	.arfs_filter_op = qede_arfs_filter_op,
209	#endif	209	#endif

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c+5−2

 	}
 	cmd_op = (cmd.rsp.arg[0] & 0xff);
-	if (cmd.rsp.arg[0] >> 25 == 2)
+	if (cmd.rsp.arg[0] >> 25 == 2) {
-		return 2;
+		ret = 2;
+		goto out;
+	}
 	if (cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
 		set_bit(QLC_BC_VF_STATE, &vf->state);
 	else

drivers/net/ethernet/wangxun/libwx/wx_hw.c+8−2

 	wr32m(wx, WX_SW2FW_MBOX_CMD, WX_SW2FW_MBOX_CMD_VLD, WX_SW2FW_MBOX_CMD_VLD);
 	/* polling reply from FW */
-	err = read_poll_timeout(wx_poll_fw_reply, reply, reply, 1000, 50000,
+	err = read_poll_timeout(wx_poll_fw_reply, reply, reply, 2000,
-				true, wx, buffer, send_cmd);
+				timeout * 1000, true, wx, buffer, send_cmd);
 	if (err) {
 		wx_err(wx, "Polling from FW messages timeout, cmd: 0x%x, index: %d\n",
 		       send_cmd, wx->swfw_index);
 		goto rel_out;
 	}
+	if (hdr->cmd_or_resp.ret_status == 0x80) {
+		wx_err(wx, "Unknown FW command: 0x%x\n", send_cmd);
+		err = -EINVAL;
+		goto rel_out;
+	}
 	/* expect no reply from FW then return */
 	if (!return_data)
 		goto rel_out;

drivers/net/ethernet/wangxun/txgbe/txgbe_hw.c+7−1

 	}
 	local_buffer = eeprom_ptrs;
-	for (i = 0; i < TXGBE_EEPROM_LAST_WORD; i++)
+	for (i = 0; i < TXGBE_EEPROM_LAST_WORD; i++) {
+		if (wx->mac.type == wx_mac_aml) {
+			if (i >= TXGBE_EEPROM_I2C_SRART_PTR &&
+			    i < TXGBE_EEPROM_I2C_END_PTR)
+				local_buffer[i] = 0xffff;
+		}
 		if (i != wx->eeprom.sw_region_offset + TXGBE_EEPROM_CHECKSUM)
 			*checksum += local_buffer[i];
+	}
 	kvfree(eeprom_ptrs);

drivers/net/ethernet/wangxun/txgbe/txgbe_type.h+2−0

@@ -158,6 +158,8 @@ · 157 unmodified lines
158	#define TXGBE_EEPROM_VERSION_L 0x1D	158	#define TXGBE_EEPROM_VERSION_L 0x1D
159	#define TXGBE_EEPROM_VERSION_H 0x1E	159	#define TXGBE_EEPROM_VERSION_H 0x1E
160	#define TXGBE_ISCSI_BOOT_CONFIG 0x07	160	#define TXGBE_ISCSI_BOOT_CONFIG 0x07
		161	#define TXGBE_EEPROM_I2C_SRART_PTR 0x580
		162	#define TXGBE_EEPROM_I2C_END_PTR 0x800
161		163
162	#define TXGBE_MAX_MSIX_VECTORS 64	164	#define TXGBE_MAX_MSIX_VECTORS 64
163	#define TXGBE_MAX_FDIR_INDICES 63	165	#define TXGBE_MAX_FDIR_INDICES 63

drivers/net/hyperv/hyperv_net.h+12−1

 	u8 cp_partial; /* partial copy into send buffer */
 	u8 rmsg_size; /* RNDIS header and PPI size */
-	u8 rmsg_pgcnt; /* page count of RNDIS header and PPI */
 	u8 page_buf_cnt;
 	u16 q_idx;
 				 sizeof(struct nvsp_message))
 #define NETVSC_MIN_IN_MSG_SIZE sizeof(struct vmpacket_descriptor)
+/* Maximum # of contiguous data ranges that can make up a trasmitted packet.
+ * Typically it's the max SKB fragments plus 2 for the rndis packet and the
+ * linear portion of the SKB. But if MAX_SKB_FRAGS is large, the value may
+ * need to be limited to MAX_PAGE_BUFFER_COUNT, which is the max # of entries
+ * in a GPA direct packet sent to netvsp over VMBus.
+ */
+#if MAX_SKB_FRAGS + 2 < MAX_PAGE_BUFFER_COUNT
+#define MAX_DATA_RANGES (MAX_SKB_FRAGS + 2)
+#else
+#define MAX_DATA_RANGES MAX_PAGE_BUFFER_COUNT
+#endif
 /* Estimated requestor size:
  * out_ring_size/min_out_msg_size + in_ring_size/min_in_msg_size
  */

drivers/net/hyperv/netvsc.c+48−9

@@ -953,8 +953,7 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · 952 unmodified lines
953	+ pend_size;	953	+ pend_size;
954	int i;	954	int i;
955	u32 padding = 0;	955	u32 padding = 0;
956	u32 page_count = packet->cp_partial ? packet->rmsg_pgcnt :	956	u32 page_count = packet->cp_partial ? 1 : packet->page_buf_cnt;
957	packet->page_buf_cnt;
958	u32 remain;	957	u32 remain;
959		958
960	/* Add padding */	959	/* Add padding */
@@ -1055,6 +1054,42 @@ static int netvsc_dma_map(struct hv_device *hv_dev, · 94 unmodified lines
1055	return 0;	1054	return 0;
1056	}	1055	}
1057		1056
		1057	/* Build an "array" of mpb entries describing the data to be transferred
		1058	* over VMBus. After the desc header fields, each "array" entry is variable
		1059	* size, and each entry starts after the end of the previous entry. The
		1060	* "offset" and "len" fields for each entry imply the size of the entry.
		1061	*
		1062	* The pfns are in HV_HYP_PAGE_SIZE, because all communication with Hyper-V
		1063	* uses that granularity, even if the system page size of the guest is larger.
		1064	* Each entry in the input "pb" array must describe a contiguous range of
		1065	* guest physical memory so that the pfns are sequential if the range crosses
		1066	* a page boundary. The offset field must be < HV_HYP_PAGE_SIZE.
		1067	*/
		1068	static inline void netvsc_build_mpb_array(struct hv_page_buffer *pb,
		1069	u32 page_buffer_count,
		1070	struct vmbus_packet_mpb_array *desc,
		1071	u32 *desc_size)
		1072	{
		1073	struct hv_mpb_array *mpb_entry = &desc->range;
		1074	int i, j;
		1075
		1076	for (i = 0; i < page_buffer_count; i++) {
		1077	u32 offset = pb[i].offset;
		1078	u32 len = pb[i].len;
		1079
		1080	mpb_entry->offset = offset;
		1081	mpb_entry->len = len;
		1082
		1083	for (j = 0; j < HVPFN_UP(offset + len); j++)
		1084	mpb_entry->pfn_array[j] = pb[i].pfn + j;
		1085
		1086	mpb_entry = (struct hv_mpb_array *)&mpb_entry->pfn_array[j];
		1087	}
		1088
		1089	desc->rangecount = page_buffer_count;
		1090	desc_size = (char )mpb_entry - (char *)desc;
		1091	}
		1092
1058	static inline int netvsc_send_pkt(	1093	static inline int netvsc_send_pkt(
1059	struct hv_device *device,	1094	struct hv_device *device,
1060	struct hv_netvsc_packet *packet,	1095	struct hv_netvsc_packet *packet,
@@ -1097,8 +1132,11 @@ static inline int netvsc_send_pkt( · 36 unmodified lines
1097		1132
1098	packet->dma_range = NULL;	1133	packet->dma_range = NULL;
1099	if (packet->page_buf_cnt) {	1134	if (packet->page_buf_cnt) {
		1135	struct vmbus_channel_packet_page_buffer desc;
		1136	u32 desc_size;
		1137
1100	if (packet->cp_partial)	1138	if (packet->cp_partial)
1101	pb += packet->rmsg_pgcnt;	1139	pb++;
1102		1140
1103	ret = netvsc_dma_map(ndev_ctx->device_ctx, packet, pb);	1141	ret = netvsc_dma_map(ndev_ctx->device_ctx, packet, pb);
1104	if (ret) {	1142	if (ret) {
@@ -1106,11 +1144,12 @@ static inline int netvsc_send_pkt( · 1 unmodified line
1106	goto exit;	1144	goto exit;
1107	}	1145	}
1108		1146
1109	ret = vmbus_sendpacket_pagebuffer(out_channel,	1147	netvsc_build_mpb_array(pb, packet->page_buf_cnt,
1110	pb, packet->page_buf_cnt,	1148	(struct vmbus_packet_mpb_array *)&desc,
1111	&nvmsg, sizeof(nvmsg),	1149	&desc_size);
1112	req_id);	1150	ret = vmbus_sendpacket_mpb_desc(out_channel,
1113		1151	(struct vmbus_packet_mpb_array *)&desc,
		1152	desc_size, &nvmsg, sizeof(nvmsg), req_id);
1114	if (ret)	1153	if (ret)
1115	netvsc_dma_unmap(ndev_ctx->device_ctx, packet);	1154	netvsc_dma_unmap(ndev_ctx->device_ctx, packet);
1116	} else {	1155	} else {
@@ -1259,7 +1298,7 @@ int netvsc_send(struct net_device *ndev, · 142 unmodified lines
1259	packet->send_buf_index = section_index;	1298	packet->send_buf_index = section_index;
1260		1299
1261	if (packet->cp_partial) {	1300	if (packet->cp_partial) {
1262	packet->page_buf_cnt -= packet->rmsg_pgcnt;	1301	packet->page_buf_cnt--;
1263	packet->total_data_buflen = msd_len + packet->rmsg_size;	1302	packet->total_data_buflen = msd_len + packet->rmsg_size;
1264	} else {	1303	} else {
1265	packet->page_buf_cnt = 0;	1304	packet->page_buf_cnt = 0;

drivers/net/hyperv/netvsc_drv.c+14−48

 	return txq;
 }
-static u32 fill_pg_buf(unsigned long hvpfn, u32 offset, u32 len,
-		       struct hv_page_buffer *pb)
-{
-	int j = 0;
-	hvpfn += offset >> HV_HYP_PAGE_SHIFT;
-	offset = offset & ~HV_HYP_PAGE_MASK;
-	while (len > 0) {
-		unsigned long bytes;
-		bytes = HV_HYP_PAGE_SIZE - offset;
-		if (bytes > len)
-			bytes = len;
-		pb[j].pfn = hvpfn;
-		pb[j].offset = offset;
-		pb[j].len = bytes;
-		offset += bytes;
-		len -= bytes;
-		if (offset == HV_HYP_PAGE_SIZE && len) {
-			hvpfn++;
-			offset = 0;
-			j++;
-		}
-	}
-	return j + 1;
-}
 static u32 init_page_array(void *hdr, u32 len, struct sk_buff *skb,
 			   struct hv_netvsc_packet *packet,
 			   struct hv_page_buffer *pb)
 {
-	u32 slots_used = 0;
-	char *data = skb->data;
 	int frags = skb_shinfo(skb)->nr_frags;
 	int i;
 	 * 2. skb linear data
 	 * 3. skb fragment data
 	 */
-	slots_used += fill_pg_buf(virt_to_hvpfn(hdr),
-				  offset_in_hvpage(hdr),
-				  len,
-				  &pb[slots_used]);
+	pb[0].offset = offset_in_hvpage(hdr);
+	pb[0].len = len;
+	pb[0].pfn = virt_to_hvpfn(hdr);
 	packet->rmsg_size = len;
-	packet->rmsg_pgcnt = slots_used;
-	slots_used += fill_pg_buf(virt_to_hvpfn(data),
+	pb[1].offset = offset_in_hvpage(skb->data);
-				  offset_in_hvpage(data),
+	pb[1].len = skb_headlen(skb);
-				  skb_headlen(skb),
+	pb[1].pfn = virt_to_hvpfn(skb->data);
-				  &pb[slots_used]);
 	for (i = 0; i < frags; i++) {
 		skb_frag_t *frag = skb_shinfo(skb)->frags + i;
+		struct hv_page_buffer *cur_pb = &pb[i + 2];
+		u64 pfn = page_to_hvpfn(skb_frag_page(frag));
+		u32 offset = skb_frag_off(frag);
-		slots_used += fill_pg_buf(page_to_hvpfn(skb_frag_page(frag)),
+		cur_pb->offset = offset_in_hvpage(offset);
-					  skb_frag_off(frag),
+		cur_pb->len = skb_frag_size(frag);
-					  skb_frag_size(frag),
+		cur_pb->pfn = pfn + (offset >> HV_HYP_PAGE_SHIFT);
-					  &pb[slots_used]);
 	}
-	return slots_used;
+	return frags + 2;
 }
 static int count_skb_frag_slots(struct sk_buff *skb)
 	struct net_device *vf_netdev;
 	u32 rndis_msg_size;
 	u32 hash;
-	struct hv_page_buffer pb[MAX_PAGE_BUFFER_COUNT];
+	struct hv_page_buffer pb[MAX_DATA_RANGES];
 	/* If VF is present and up then redirect packets to it.
 	 * Skip the VF if it is marked down or has no carrier.

drivers/net/hyperv/rndis_filter.c+5−19

 				  struct rndis_request *req)
 {
 	struct hv_netvsc_packet *packet;
-	struct hv_page_buffer page_buf[2];
+	struct hv_page_buffer pb;
-	struct hv_page_buffer *pb = page_buf;
 	int ret;
 	/* Setup the packet to send it */
 	packet->total_data_buflen = req->request_msg.msg_len;
 	packet->page_buf_cnt = 1;
-	pb[0].pfn = virt_to_phys(&req->request_msg) >>
+	pb.pfn = virt_to_phys(&req->request_msg) >> HV_HYP_PAGE_SHIFT;
-					HV_HYP_PAGE_SHIFT;
+	pb.len = req->request_msg.msg_len;
-	pb[0].len = req->request_msg.msg_len;
+	pb.offset = offset_in_hvpage(&req->request_msg);
-	pb[0].offset = offset_in_hvpage(&req->request_msg);
-	/* Add one page_buf when request_msg crossing page boundary */
-	if (pb[0].offset + pb[0].len > HV_HYP_PAGE_SIZE) {
-		packet->page_buf_cnt++;
-		pb[0].len = HV_HYP_PAGE_SIZE -
-			pb[0].offset;
-		pb[1].pfn = virt_to_phys((void *)&req->request_msg
-			+ pb[0].len) >> HV_HYP_PAGE_SHIFT;
-		pb[1].offset = 0;
-		pb[1].len = req->request_msg.msg_len -
-			pb[0].len;
-	}
 	trace_rndis_send(dev->ndev, 0, &req->request_msg);
 	rcu_read_lock_bh();
-	ret = netvsc_send(dev->ndev, packet, NULL, pb, NULL, false);
+	ret = netvsc_send(dev->ndev, packet, NULL, &pb, NULL, false);
 	rcu_read_unlock_bh();
 	return ret;

drivers/net/phy/micrel.c+0−7

 			return err;
 	}
-	/* According to KSZ9477 Errata DS80000754C (Module 4) all EEE modes
-	 * in this switch shall be regarded as broken.
-	 */
-	if (phydev->dev_flags & MICREL_NO_EEE)
-		phy_disable_eee(phydev);
 	return kszphy_config_init(phydev);
 }
 	.handle_interrupt = kszphy_handle_interrupt,
 	.suspend	= genphy_suspend,
 	.resume		= ksz9477_resume,
-	.get_features	= ksz9477_get_features,
 } };
 module_phy_driver(ksphy_driver);

drivers/net/wireless/mediatek/mt76/dma.c+1−0

@@ -1011,6 +1011,7 @@ void mt76_dma_cleanup(struct mt76_dev *dev) · 1010 unmodified lines
1011	int i;	1011	int i;
1012		1012
1013	mt76_worker_disable(&dev->tx_worker);	1013	mt76_worker_disable(&dev->tx_worker);
		1014	napi_disable(&dev->tx_napi);
1014	netif_napi_del(&dev->tx_napi);	1015	netif_napi_del(&dev->tx_napi);
1015		1016
1016	for (i = 0; i < ARRAY_SIZE(dev->phys); i++) {	1017	for (i = 0; i < ARRAY_SIZE(dev->phys); i++) {

drivers/net/wireless/mediatek/mt76/mt7925/mcu.c+2−2

 			mt7925_mcu_sta_mld_tlv(skb, info->vif, info->link_sta->sta);
 			mt7925_mcu_sta_eht_mld_tlv(skb, info->vif, info->link_sta->sta);
 		}
-		mt7925_mcu_sta_hdr_trans_tlv(skb, info->vif, info->link_sta);
 	}
 	if (!info->enable) {
 		mt7925_mcu_sta_remove_tlv(skb);
 		mt76_connac_mcu_add_tlv(skb, STA_REC_MLD_OFF,
 					sizeof(struct tlv));
+	} else {
+		mt7925_mcu_sta_hdr_trans_tlv(skb, info->vif, info->link_sta);
 	}
 	return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true);

drivers/nvme/host/core.c+27−3

@@ -2059,7 +2059,21 @@ static bool nvme_update_disk_info(struct nvme_ns ns, struct nvme_id_ns id, · 2058 unmodified lines
2059	if (id->nsfeat & NVME_NS_FEAT_ATOMICS && id->nawupf)	2059	if (id->nsfeat & NVME_NS_FEAT_ATOMICS && id->nawupf)
2060	atomic_bs = (1 + le16_to_cpu(id->nawupf)) * bs;	2060	atomic_bs = (1 + le16_to_cpu(id->nawupf)) * bs;
2061	else	2061	else
2062	atomic_bs = (1 + ns->ctrl->subsys->awupf) * bs;	2062	atomic_bs = (1 + ns->ctrl->awupf) * bs;
		2063
		2064	/*
		2065	* Set subsystem atomic bs.
		2066	*/
		2067	if (ns->ctrl->subsys->atomic_bs) {
		2068	if (atomic_bs != ns->ctrl->subsys->atomic_bs) {
		2069	dev_err_ratelimited(ns->ctrl->device,
		2070	"%s: Inconsistent Atomic Write Size, Namespace will not be added: Subsystem=%d bytes, Controller/Namespace=%d bytes\n",
		2071	ns->disk ? ns->disk->disk_name : "?",
		2072	ns->ctrl->subsys->atomic_bs,
		2073	atomic_bs);
		2074	}
		2075	} else
		2076	ns->ctrl->subsys->atomic_bs = atomic_bs;
2063		2077
2064	nvme_update_atomic_write_disk_info(ns, id, lim, bs, atomic_bs);	2078	nvme_update_atomic_write_disk_info(ns, id, lim, bs, atomic_bs);
2065	}	2079	}
@@ -2201,6 +2215,17 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns, · 135 unmodified lines
2201	nvme_set_chunk_sectors(ns, id, &lim);	2215	nvme_set_chunk_sectors(ns, id, &lim);
2202	if (!nvme_update_disk_info(ns, id, &lim))	2216	if (!nvme_update_disk_info(ns, id, &lim))
2203	capacity = 0;	2217	capacity = 0;
		2218
		2219	/*
		2220	* Validate the max atomic write size fits within the subsystem's
		2221	* atomic write capabilities.
		2222	*/
		2223	if (lim.atomic_write_hw_max > ns->ctrl->subsys->atomic_bs) {
		2224	blk_mq_unfreeze_queue(ns->disk->queue, memflags);
		2225	ret = -ENXIO;
		2226	goto out;
		2227	}
		2228
2204	nvme_config_discard(ns, &lim);	2229	nvme_config_discard(ns, &lim);
2205	if (IS_ENABLED(CONFIG_BLK_DEV_ZONED) &&	2230	if (IS_ENABLED(CONFIG_BLK_DEV_ZONED) &&
2206	ns->head->ids.csi == NVME_CSI_ZNS)	2231	ns->head->ids.csi == NVME_CSI_ZNS)
@@ -3031,7 +3056,6 @@ static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id) · 824 unmodified lines
3031	kfree(subsys);	3056	kfree(subsys);
3032	return -EINVAL;	3057	return -EINVAL;
3033	}	3058	}
3034	subsys->awupf = le16_to_cpu(id->awupf);
3035	nvme_mpath_default_iopolicy(subsys);	3059	nvme_mpath_default_iopolicy(subsys);
3036		3060
3037	subsys->dev.class = &nvme_subsys_class;	3061	subsys->dev.class = &nvme_subsys_class;
@@ -3441,7 +3465,7 @@ static int nvme_init_identify(struct nvme_ctrl *ctrl) · 403 unmodified lines
3441	dev_pm_qos_expose_latency_tolerance(ctrl->device);	3465	dev_pm_qos_expose_latency_tolerance(ctrl->device);
3442	else if (!ctrl->apst_enabled && prev_apst_enabled)	3466	else if (!ctrl->apst_enabled && prev_apst_enabled)
3443	dev_pm_qos_hide_latency_tolerance(ctrl->device);	3467	dev_pm_qos_hide_latency_tolerance(ctrl->device);
3444		3468	ctrl->awupf = le16_to_cpu(id->awupf);
3445	out_free:	3469	out_free:
3446	kfree(id);	3470	kfree(id);
3447	return ret;	3471	return ret;

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

@@ -638,7 +638,8 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl ctrl, struct nvme_ns_head head) · 637 unmodified lines
638		638
639	blk_set_stacking_limits(&lim);	639	blk_set_stacking_limits(&lim);
640	lim.dma_alignment = 3;	640	lim.dma_alignment = 3;
641	lim.features \|= BLK_FEAT_IO_STAT \| BLK_FEAT_NOWAIT \| BLK_FEAT_POLL;	641	lim.features \|= BLK_FEAT_IO_STAT \| BLK_FEAT_NOWAIT \|
		642	BLK_FEAT_POLL \| BLK_FEAT_ATOMIC_WRITES;
642	if (head->ids.csi == NVME_CSI_ZNS)	643	if (head->ids.csi == NVME_CSI_ZNS)
643	lim.features \|= BLK_FEAT_ZONED;	644	lim.features \|= BLK_FEAT_ZONED;
644		645

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

 	enum nvme_ctrl_type cntrltype;
 	enum nvme_dctype dctype;
+	u16 awupf; /* 0's based value. */
 };
 static inline enum nvme_ctrl_state nvme_ctrl_state(struct nvme_ctrl *ctrl)
 	u8			cmic;
 	enum nvme_subsys_type	subtype;
 	u16			vendor_id;
-	u16			awupf;	/* 0's based awupf value. */
 	struct ida		ns_ida;
 #ifdef CONFIG_NVME_MULTIPATH
 	enum nvme_iopolicy	iopolicy;
 #endif
+	u32			atomic_bs;
 };
 /*

drivers/nvme/host/pci.c+5−1

  * as it only leads to a small amount of wasted memory for the lifetime of
  * the I/O.
  */
-static int nvme_pci_npages_prp(void)
+static __always_inline int nvme_pci_npages_prp(void)
 {
 	unsigned max_bytes = (NVME_MAX_KB_SZ * 1024) + NVME_CTRL_PAGE_SIZE;
 	unsigned nprps = DIV_ROUND_UP(max_bytes, NVME_CTRL_PAGE_SIZE);
 	WARN_ON_ONCE(test_bit(NVMEQ_POLLED, &nvmeq->flags));
 	disable_irq(pci_irq_vector(pdev, nvmeq->cq_vector));
+	spin_lock(&nvmeq->cq_poll_lock);
 	nvme_poll_cq(nvmeq, NULL);
+	spin_unlock(&nvmeq->cq_poll_lock);
 	enable_irq(pci_irq_vector(pdev, nvmeq->cq_vector));
 }
 		.driver_data = NVME_QUIRK_NO_DEEPEST_PS, },
 	{ PCI_DEVICE(0x1e49, 0x0041),   /* ZHITAI TiPro7000 NVMe SSD */
 		.driver_data = NVME_QUIRK_NO_DEEPEST_PS, },
+	{ PCI_DEVICE(0x025e, 0xf1ac),   /* SOLIDIGM  P44 pro SSDPFKKW020X7  */
+		.driver_data = NVME_QUIRK_NO_DEEPEST_PS, },
 	{ PCI_DEVICE(0xc0a9, 0x540a),   /* Crucial P2 */
 		.driver_data = NVME_QUIRK_BOGUS_NID, },
 	{ PCI_DEVICE(0x1d97, 0x2263), /* Lexar NM610 */

drivers/nvme/target/pci-epf.c+23−16

 #define NVMET_PCI_EPF_CQ_RETRY_INTERVAL	msecs_to_jiffies(1)
 enum nvmet_pci_epf_queue_flags {
-	NVMET_PCI_EPF_Q_IS_SQ = 0,	/* The queue is a submission queue */
+	NVMET_PCI_EPF_Q_LIVE = 0,	/* The queue is live */
-	NVMET_PCI_EPF_Q_LIVE,		/* The queue is live */
 	NVMET_PCI_EPF_Q_IRQ_ENABLED,	/* IRQ is enabled for this queue */
 };
 	struct nvmet_pci_epf_irq_vector *iv = cq->iv;
 	bool ret;
-	if (!test_bit(NVMET_PCI_EPF_Q_IRQ_ENABLED, &cq->flags))
-		return false;
 	/* IRQ coalescing for the admin queue is not allowed. */
 	if (!cq->qid)
 		return true;
 	struct pci_epf *epf = nvme_epf->epf;
 	int ret = 0;
-	if (!test_bit(NVMET_PCI_EPF_Q_LIVE, &cq->flags))
+	if (!test_bit(NVMET_PCI_EPF_Q_LIVE, &cq->flags) ||
+	    !test_bit(NVMET_PCI_EPF_Q_IRQ_ENABLED, &cq->flags))
 		return;
 	mutex_lock(&ctrl->irq_lock);
 	switch (nvme_epf->irq_type) {
 	case PCI_IRQ_MSIX:
 	case PCI_IRQ_MSI:
+		/*
+		 * If we fail to raise an MSI or MSI-X interrupt, it is likely
+		 * because the host is using legacy INTX IRQs (e.g. BIOS,
+		 * grub), but we can fallback to the INTX type only if the
+		 * endpoint controller supports this type.
+		 */
 		ret = pci_epc_raise_irq(epf->epc, epf->func_no, epf->vfunc_no,
 					nvme_epf->irq_type, cq->vector + 1);
-		if (!ret)
+		if (!ret || !nvme_epf->epc_features->intx_capable)
 			break;
-		/*
-		 * If we got an error, it is likely because the host is using
-		 * legacy IRQs (e.g. BIOS, grub).
-		 */
 		fallthrough;
 	case PCI_IRQ_INTX:
 		ret = pci_epc_raise_irq(epf->epc, epf->func_no, epf->vfunc_no,
 	}
 	if (ret)
-		dev_err(ctrl->dev, "Failed to raise IRQ (err=%d)\n", ret);
+		dev_err_ratelimited(ctrl->dev,
+				    "CQ[%u]: Failed to raise IRQ (err=%d)\n",
+				    cq->qid, ret);
 unlock:
 	mutex_unlock(&ctrl->irq_lock);
 	set_bit(NVMET_PCI_EPF_Q_LIVE, &cq->flags);
-	dev_dbg(ctrl->dev, "CQ[%u]: %u entries of %zu B, IRQ vector %u\n",
+	if (test_bit(NVMET_PCI_EPF_Q_IRQ_ENABLED, &cq->flags))
-		cqid, qsize, cq->qes, cq->vector);
+		dev_dbg(ctrl->dev,
+			"CQ[%u]: %u entries of %zu B, IRQ vector %u\n",
+			cqid, qsize, cq->qes, cq->vector);
+	else
+		dev_dbg(ctrl->dev,
+			"CQ[%u]: %u entries of %zu B, IRQ disabled\n",
+			cqid, qsize, cq->qes);
 	return NVME_SC_SUCCESS;
 	cancel_delayed_work_sync(&cq->work);
 	nvmet_pci_epf_drain_queue(cq);
-	nvmet_pci_epf_remove_irq_vector(ctrl, cq->vector);
+	if (test_and_clear_bit(NVMET_PCI_EPF_Q_IRQ_ENABLED, &cq->flags))
+		nvmet_pci_epf_remove_irq_vector(ctrl, cq->vector);
 	nvmet_pci_epf_mem_unmap(ctrl->nvme_epf, &cq->pci_map);
 	return NVME_SC_SUCCESS;
 	if (sq) {
 		queue = &ctrl->sq[qid];
-		set_bit(NVMET_PCI_EPF_Q_IS_SQ, &queue->flags);
 	} else {
 		queue = &ctrl->cq[qid];
 		INIT_DELAYED_WORK(&queue->work, nvmet_pci_epf_cq_work);

drivers/phy/phy-can-transceiver.c+15−7

@@ -93,6 +93,16 @@ static const struct of_device_id can_transceiver_phy_ids[] = { · 92 unmodified lines
93	};	93	};
94	MODULE_DEVICE_TABLE(of, can_transceiver_phy_ids);	94	MODULE_DEVICE_TABLE(of, can_transceiver_phy_ids);
95		95
		96	/* Temporary wrapper until the multiplexer subsystem supports optional muxes */
		97	static inline struct mux_state *
		98	devm_mux_state_get_optional(struct device dev, const char mux_name)
		99	{
		100	if (!of_property_present(dev->of_node, "mux-states"))
		101	return NULL;
		102
		103	return devm_mux_state_get(dev, mux_name);
		104	}
		105
96	static int can_transceiver_phy_probe(struct platform_device *pdev)	106	static int can_transceiver_phy_probe(struct platform_device *pdev)
97	{	107	{
98	struct phy_provider *phy_provider;	108	struct phy_provider *phy_provider;
@@ -114,13 +124,11 @@ static int can_transceiver_phy_probe(struct platform_device *pdev) · 15 unmodified lines
114	match = of_match_node(can_transceiver_phy_ids, pdev->dev.of_node);	124	match = of_match_node(can_transceiver_phy_ids, pdev->dev.of_node);
115	drvdata = match->data;	125	drvdata = match->data;
116		126
117	mux_state = devm_mux_state_get(dev, NULL);	127	mux_state = devm_mux_state_get_optional(dev, NULL);
118	if (IS_ERR(mux_state)) {	128	if (IS_ERR(mux_state))
119	if (PTR_ERR(mux_state) == -EPROBE_DEFER)	129	return PTR_ERR(mux_state);
120	return PTR_ERR(mux_state);	130
121	} else {	131	can_transceiver_phy->mux_state = mux_state;
122	can_transceiver_phy->mux_state = mux_state;
123	}
124		132
125	phy = devm_phy_create(dev, dev->of_node,	133	phy = devm_phy_create(dev, dev->of_node,
126	&can_transceiver_phy_ops);	134	&can_transceiver_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c+2−1

@@ -1754,7 +1754,8 @@ static void qmp_ufs_init_registers(struct qmp_ufs *qmp, const struct qmp_phy_cfg · 1753 unmodified lines
1754	qmp_ufs_init_all(qmp, &cfg->tbls_hs_overlay[i]);	1754	qmp_ufs_init_all(qmp, &cfg->tbls_hs_overlay[i]);
1755	}	1755	}
1756		1756
1757	qmp_ufs_init_all(qmp, &cfg->tbls_hs_b);	1757	if (qmp->mode == PHY_MODE_UFS_HS_B)
		1758	qmp_ufs_init_all(qmp, &cfg->tbls_hs_b);
1758	}	1759	}
1759		1760
1760	static int qmp_ufs_com_init(struct qmp_ufs *qmp)	1761	static int qmp_ufs_com_init(struct qmp_ufs *qmp)

drivers/phy/renesas/phy-rcar-gen3-usb2.c+75−60

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	* Copyright (C) 2014 Cogent Embedded, Inc.	9	* Copyright (C) 2014 Cogent Embedded, Inc.
10	*/	10	*/
11		11
		12	#include <linux/cleanup.h>
12	#include <linux/extcon-provider.h>	13	#include <linux/extcon-provider.h>
13	#include <linux/interrupt.h>	14	#include <linux/interrupt.h>
14	#include <linux/io.h>	15	#include <linux/io.h>
@@ -107,7 +108,6 @@ struct rcar_gen3_phy { · 92 unmodified lines
107	struct rcar_gen3_chan *ch;	108	struct rcar_gen3_chan *ch;
108	u32 int_enable_bits;	109	u32 int_enable_bits;
109	bool initialized;	110	bool initialized;
110	bool otg_initialized;
111	bool powered;	111	bool powered;
112	};	112	};
113		113
@@ -119,9 +119,8 @@ struct rcar_gen3_chan { · 5 unmodified lines
119	struct regulator *vbus;	119	struct regulator *vbus;
120	struct reset_control *rstc;	120	struct reset_control *rstc;
121	struct work_struct work;	121	struct work_struct work;
122	struct mutex lock; /* protects rphys[...].powered */	122	spinlock_t lock; /* protects access to hardware and driver data structure. */
123	enum usb_dr_mode dr_mode;	123	enum usb_dr_mode dr_mode;
124	int irq;
125	u32 obint_enable_bits;	124	u32 obint_enable_bits;
126	bool extcon_host;	125	bool extcon_host;
127	bool is_otg_channel;	126	bool is_otg_channel;
@@ -320,16 +319,15 @@ static bool rcar_gen3_is_any_rphy_initialized(struct rcar_gen3_chan *ch) · 192 unmodified lines
320	return false;	319	return false;
321	}	320	}
322		321
323	static bool rcar_gen3_needs_init_otg(struct rcar_gen3_chan *ch)	322	static bool rcar_gen3_is_any_otg_rphy_initialized(struct rcar_gen3_chan *ch)
324	{	323	{
325	int i;	324	for (enum rcar_gen3_phy_index i = PHY_INDEX_BOTH_HC; i <= PHY_INDEX_EHCI;
326		325	i++) {
327	for (i = 0; i < NUM_OF_PHYS; i++) {	326	if (ch->rphys[i].initialized)
328	if (ch->rphys[i].otg_initialized)	327	return true;
329	return false;
330	}	328	}
331		329
332	return true;	330	return false;
333	}	331	}
334		332
335	static bool rcar_gen3_are_all_rphys_power_off(struct rcar_gen3_chan *ch)	333	static bool rcar_gen3_are_all_rphys_power_off(struct rcar_gen3_chan *ch)
@@ -351,7 +349,9 @@ static ssize_t role_store(struct device dev, struct device_attribute attr, · 15 unmodified lines
351	bool is_b_device;	349	bool is_b_device;
352	enum phy_mode cur_mode, new_mode;	350	enum phy_mode cur_mode, new_mode;
353		351
354	if (!ch->is_otg_channel \|\| !rcar_gen3_is_any_rphy_initialized(ch))	352	guard(spinlock_irqsave)(&ch->lock);
		353
		354	if (!ch->is_otg_channel \|\| !rcar_gen3_is_any_otg_rphy_initialized(ch))
355	return -EIO;	355	return -EIO;
356		356
357	if (sysfs_streq(buf, "host"))	357	if (sysfs_streq(buf, "host"))
@@ -389,7 +389,7 @@ static ssize_t role_show(struct device dev, struct device_attribute attr, · 31 unmodified lines
389	{	389	{
390	struct rcar_gen3_chan *ch = dev_get_drvdata(dev);	390	struct rcar_gen3_chan *ch = dev_get_drvdata(dev);
391		391
392	if (!ch->is_otg_channel \|\| !rcar_gen3_is_any_rphy_initialized(ch))	392	if (!ch->is_otg_channel \|\| !rcar_gen3_is_any_otg_rphy_initialized(ch))
393	return -EIO;	393	return -EIO;
394		394
395	return sprintf(buf, "%s\n", rcar_gen3_is_host(ch) ? "host" :	395	return sprintf(buf, "%s\n", rcar_gen3_is_host(ch) ? "host" :
@@ -402,6 +402,9 @@ static void rcar_gen3_init_otg(struct rcar_gen3_chan *ch) · 6 unmodified lines
402	void __iomem *usb2_base = ch->base;	402	void __iomem *usb2_base = ch->base;
403	u32 val;	403	u32 val;
404		404
		405	if (!ch->is_otg_channel \|\| rcar_gen3_is_any_otg_rphy_initialized(ch))
		406	return;
		407
405	/* Should not use functions of read-modify-write a register */	408	/* Should not use functions of read-modify-write a register */
406	val = readl(usb2_base + USB2_LINECTRL1);	409	val = readl(usb2_base + USB2_LINECTRL1);
407	val = (val & ~USB2_LINECTRL1_DP_RPD) \| USB2_LINECTRL1_DPRPD_EN \|	410	val = (val & ~USB2_LINECTRL1_DP_RPD) \| USB2_LINECTRL1_DPRPD_EN \|
@@ -415,7 +418,7 @@ static void rcar_gen3_init_otg(struct rcar_gen3_chan *ch) · 7 unmodified lines
415	val = readl(usb2_base + USB2_ADPCTRL);	418	val = readl(usb2_base + USB2_ADPCTRL);
416	writel(val \| USB2_ADPCTRL_IDPULLUP, usb2_base + USB2_ADPCTRL);	419	writel(val \| USB2_ADPCTRL_IDPULLUP, usb2_base + USB2_ADPCTRL);
417	}	420	}
418	msleep(20);	421	mdelay(20);
419		422
420	writel(0xffffffff, usb2_base + USB2_OBINTSTA);	423	writel(0xffffffff, usb2_base + USB2_OBINTSTA);
421	writel(ch->obint_enable_bits, usb2_base + USB2_OBINTEN);	424	writel(ch->obint_enable_bits, usb2_base + USB2_OBINTEN);
@@ -427,16 +430,27 @@ static irqreturn_t rcar_gen3_phy_usb2_irq(int irq, void *_ch) · 5 unmodified lines
427	{	430	{
428	struct rcar_gen3_chan *ch = _ch;	431	struct rcar_gen3_chan *ch = _ch;
429	void __iomem *usb2_base = ch->base;	432	void __iomem *usb2_base = ch->base;
430	u32 status = readl(usb2_base + USB2_OBINTSTA);	433	struct device *dev = ch->dev;
431	irqreturn_t ret = IRQ_NONE;	434	irqreturn_t ret = IRQ_NONE;
		435	u32 status;
		436
		437	pm_runtime_get_noresume(dev);
		438
		439	if (pm_runtime_suspended(dev))
		440	goto rpm_put;
432		441
433	if (status & ch->obint_enable_bits) {	442	scoped_guard(spinlock, &ch->lock) {
434	dev_vdbg(ch->dev, "%s: %08x\n", __func__, status);	443	status = readl(usb2_base + USB2_OBINTSTA);
435	writel(ch->obint_enable_bits, usb2_base + USB2_OBINTSTA);	444	if (status & ch->obint_enable_bits) {
436	rcar_gen3_device_recognition(ch);	445	dev_vdbg(dev, "%s: %08x\n", __func__, status);
437	ret = IRQ_HANDLED;	446	writel(ch->obint_enable_bits, usb2_base + USB2_OBINTSTA);
		447	rcar_gen3_device_recognition(ch);
		448	ret = IRQ_HANDLED;
		449	}
438	}	450	}
439		451
		452	rpm_put:
		453	pm_runtime_put_noidle(dev);
440	return ret;	454	return ret;
441	}	455	}
442		456
@@ -446,32 +460,23 @@ static int rcar_gen3_phy_usb2_init(struct phy *p) · 3 unmodified lines
446	struct rcar_gen3_chan *channel = rphy->ch;	460	struct rcar_gen3_chan *channel = rphy->ch;
447	void __iomem *usb2_base = channel->base;	461	void __iomem *usb2_base = channel->base;
448	u32 val;	462	u32 val;
449	int ret;
450		463
451	if (!rcar_gen3_is_any_rphy_initialized(channel) && channel->irq >= 0) {	464	guard(spinlock_irqsave)(&channel->lock);
452	INIT_WORK(&channel->work, rcar_gen3_phy_usb2_work);
453	ret = request_irq(channel->irq, rcar_gen3_phy_usb2_irq,
454	IRQF_SHARED, dev_name(channel->dev), channel);
455	if (ret < 0) {
456	dev_err(channel->dev, "No irq handler (%d)\n", channel->irq);
457	return ret;
458	}
459	}
460		465
461	/* Initialize USB2 part */	466	/* Initialize USB2 part */
462	val = readl(usb2_base + USB2_INT_ENABLE);	467	val = readl(usb2_base + USB2_INT_ENABLE);
463	val \|= USB2_INT_ENABLE_UCOM_INTEN \| rphy->int_enable_bits;	468	val \|= USB2_INT_ENABLE_UCOM_INTEN \| rphy->int_enable_bits;
464	writel(val, usb2_base + USB2_INT_ENABLE);	469	writel(val, usb2_base + USB2_INT_ENABLE);
465	writel(USB2_SPD_RSM_TIMSET_INIT, usb2_base + USB2_SPD_RSM_TIMSET);	470
466	writel(USB2_OC_TIMSET_INIT, usb2_base + USB2_OC_TIMSET);	471	if (!rcar_gen3_is_any_rphy_initialized(channel)) {
467		472	writel(USB2_SPD_RSM_TIMSET_INIT, usb2_base + USB2_SPD_RSM_TIMSET);
468	/* Initialize otg part */	473	writel(USB2_OC_TIMSET_INIT, usb2_base + USB2_OC_TIMSET);
469	if (channel->is_otg_channel) {
470	if (rcar_gen3_needs_init_otg(channel))
471	rcar_gen3_init_otg(channel);
472	rphy->otg_initialized = true;
473	}	474	}
474		475
		476	/* Initialize otg part (only if we initialize a PHY with IRQs). */
		477	if (rphy->int_enable_bits)
		478	rcar_gen3_init_otg(channel);
		479
475	rphy->initialized = true;	480	rphy->initialized = true;
476		481
477	return 0;	482	return 0;
@@ -484,10 +489,9 @@ static int rcar_gen3_phy_usb2_exit(struct phy *p) · 6 unmodified lines
484	void __iomem *usb2_base = channel->base;	489	void __iomem *usb2_base = channel->base;
485	u32 val;	490	u32 val;
486		491
487	rphy->initialized = false;	492	guard(spinlock_irqsave)(&channel->lock);
488		493
489	if (channel->is_otg_channel)	494	rphy->initialized = false;
490	rphy->otg_initialized = false;
491		495
492	val = readl(usb2_base + USB2_INT_ENABLE);	496	val = readl(usb2_base + USB2_INT_ENABLE);
493	val &= ~rphy->int_enable_bits;	497	val &= ~rphy->int_enable_bits;
@@ -495,9 +499,6 @@ static int rcar_gen3_phy_usb2_exit(struct phy *p) · 1 unmodified line
495	val &= ~USB2_INT_ENABLE_UCOM_INTEN;	499	val &= ~USB2_INT_ENABLE_UCOM_INTEN;
496	writel(val, usb2_base + USB2_INT_ENABLE);	500	writel(val, usb2_base + USB2_INT_ENABLE);
497		501
498	if (channel->irq >= 0 && !rcar_gen3_is_any_rphy_initialized(channel))
499	free_irq(channel->irq, channel);
500
501	return 0;	502	return 0;
502	}	503	}
503		504
@@ -509,16 +510,17 @@ static int rcar_gen3_phy_usb2_power_on(struct phy *p) · 5 unmodified lines
509	u32 val;	510	u32 val;
510	int ret = 0;	511	int ret = 0;
511		512
512	mutex_lock(&channel->lock);
513	if (!rcar_gen3_are_all_rphys_power_off(channel))
514	goto out;
515
516	if (channel->vbus) {	513	if (channel->vbus) {
517	ret = regulator_enable(channel->vbus);	514	ret = regulator_enable(channel->vbus);
518	if (ret)	515	if (ret)
519	goto out;	516	return ret;
520	}	517	}
521		518
		519	guard(spinlock_irqsave)(&channel->lock);
		520
		521	if (!rcar_gen3_are_all_rphys_power_off(channel))
		522	goto out;
		523
522	val = readl(usb2_base + USB2_USBCTR);	524	val = readl(usb2_base + USB2_USBCTR);
523	val \|= USB2_USBCTR_PLL_RST;	525	val \|= USB2_USBCTR_PLL_RST;
524	writel(val, usb2_base + USB2_USBCTR);	526	writel(val, usb2_base + USB2_USBCTR);
@@ -528,7 +530,6 @@ static int rcar_gen3_phy_usb2_power_on(struct phy *p) · 3 unmodified lines
528	out:	530	out:
529	/* The powered flag should be set for any other phys anyway */	531	/* The powered flag should be set for any other phys anyway */
530	rphy->powered = true;	532	rphy->powered = true;
531	mutex_unlock(&channel->lock);
532		533
533	return 0;	534	return 0;
534	}	535	}
@@ -539,18 +540,20 @@ static int rcar_gen3_phy_usb2_power_off(struct phy *p) · 4 unmodified lines
539	struct rcar_gen3_chan *channel = rphy->ch;	540	struct rcar_gen3_chan *channel = rphy->ch;
540	int ret = 0;	541	int ret = 0;
541		542
542	mutex_lock(&channel->lock);	543	scoped_guard(spinlock_irqsave, &channel->lock) {
543	rphy->powered = false;	544	rphy->powered = false;
544		545
545	if (!rcar_gen3_are_all_rphys_power_off(channel))	546	if (rcar_gen3_are_all_rphys_power_off(channel)) {
546	goto out;	547	u32 val = readl(channel->base + USB2_USBCTR);
		548
		549	val \|= USB2_USBCTR_PLL_RST;
		550	writel(val, channel->base + USB2_USBCTR);
		551	}
		552	}
547		553
548	if (channel->vbus)	554	if (channel->vbus)
549	ret = regulator_disable(channel->vbus);	555	ret = regulator_disable(channel->vbus);
550		556
551	out:
552	mutex_unlock(&channel->lock);
553
554	return ret;	557	return ret;
555	}	558	}
556		559
@@ -703,7 +706,7 @@ static int rcar_gen3_phy_usb2_probe(struct platform_device *pdev) · 146 unmodified lines
703	struct device *dev = &pdev->dev;	706	struct device *dev = &pdev->dev;
704	struct rcar_gen3_chan *channel;	707	struct rcar_gen3_chan *channel;
705	struct phy_provider *provider;	708	struct phy_provider *provider;
706	int ret = 0, i;	709	int ret = 0, i, irq;
707		710
708	if (!dev->of_node) {	711	if (!dev->of_node) {
709	dev_err(dev, "This driver needs device tree\n");	712	dev_err(dev, "This driver needs device tree\n");
@@ -719,8 +722,6 @@ static int rcar_gen3_phy_usb2_probe(struct platform_device *pdev) · 9 unmodified lines
719	return PTR_ERR(channel->base);	722	return PTR_ERR(channel->base);
720		723
721	channel->obint_enable_bits = USB2_OBINT_BITS;	724	channel->obint_enable_bits = USB2_OBINT_BITS;
722	/* get irq number here and request_irq for OTG in phy_init */
723	channel->irq = platform_get_irq_optional(pdev, 0);
724	channel->dr_mode = rcar_gen3_get_dr_mode(dev->of_node);	725	channel->dr_mode = rcar_gen3_get_dr_mode(dev->of_node);
725	if (channel->dr_mode != USB_DR_MODE_UNKNOWN) {	726	if (channel->dr_mode != USB_DR_MODE_UNKNOWN) {
726	channel->is_otg_channel = true;	727	channel->is_otg_channel = true;
@@ -763,7 +764,7 @@ static int rcar_gen3_phy_usb2_probe(struct platform_device *pdev) · 36 unmodified lines
763	if (phy_data->no_adp_ctrl)	764	if (phy_data->no_adp_ctrl)
764	channel->obint_enable_bits = USB2_OBINT_IDCHG_EN;	765	channel->obint_enable_bits = USB2_OBINT_IDCHG_EN;
765		766
766	mutex_init(&channel->lock);	767	spin_lock_init(&channel->lock);
767	for (i = 0; i < NUM_OF_PHYS; i++) {	768	for (i = 0; i < NUM_OF_PHYS; i++) {
768	channel->rphys[i].phy = devm_phy_create(dev, NULL,	769	channel->rphys[i].phy = devm_phy_create(dev, NULL,
769	phy_data->phy_usb2_ops);	770	phy_data->phy_usb2_ops);
@@ -789,6 +790,20 @@ static int rcar_gen3_phy_usb2_probe(struct platform_device *pdev) · 19 unmodified lines
789	channel->vbus = NULL;	790	channel->vbus = NULL;
790	}	791	}
791		792
		793	irq = platform_get_irq_optional(pdev, 0);
		794	if (irq < 0 && irq != -ENXIO) {
		795	ret = irq;
		796	goto error;
		797	} else if (irq > 0) {
		798	INIT_WORK(&channel->work, rcar_gen3_phy_usb2_work);
		799	ret = devm_request_irq(dev, irq, rcar_gen3_phy_usb2_irq,
		800	IRQF_SHARED, dev_name(dev), channel);
		801	if (ret < 0) {
		802	dev_err(dev, "Failed to request irq (%d)\n", irq);
		803	goto error;
		804	}
		805	}
		806
792	provider = devm_of_phy_provider_register(dev, rcar_gen3_phy_usb2_xlate);	807	provider = devm_of_phy_provider_register(dev, rcar_gen3_phy_usb2_xlate);
793	if (IS_ERR(provider)) {	808	if (IS_ERR(provider)) {
794	dev_err(dev, "Failed to register PHY provider\n");	809	dev_err(dev, "Failed to register PHY provider\n");

drivers/phy/rockchip/phy-rockchip-samsung-dcphy.c+1−1

@@ -1653,7 +1653,7 @@ static __maybe_unused int samsung_mipi_dcphy_runtime_resume(struct device *dev) · 1652 unmodified lines
1653	return ret;	1653	return ret;
1654	}	1654	}
1655		1655
1656	clk_prepare_enable(samsung->ref_clk);	1656	ret = clk_prepare_enable(samsung->ref_clk);
1657	if (ret) {	1657	if (ret) {
1658	dev_err(samsung->dev, "Failed to enable reference clock, %d\n", ret);	1658	dev_err(samsung->dev, "Failed to enable reference clock, %d\n", ret);
1659	clk_disable_unprepare(samsung->pclk);	1659	clk_disable_unprepare(samsung->pclk);

drivers/phy/rockchip/phy-rockchip-samsung-hdptx.c+2−0

 	  1, 1, 0, 0x20, 0x0c, 1, 0x0e, 0, 0, },
 	{ 650000, 162, 162, 1, 1, 11, 1, 1, 1, 1, 1, 1, 1, 54, 0, 16, 4, 1,
 	  1, 1, 0, 0x20, 0x0c, 1, 0x0e, 0, 0, },
+	{ 502500, 84, 84, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1, 11, 1, 4, 5,
+	  4, 11, 1, 0, 0x20, 0x0c, 1, 0x0e, 0, 0, },
 	{ 337500, 0x70, 0x70, 1, 1, 0xf, 1, 1, 1, 1, 1, 1, 1, 0x2, 0, 0x01, 5,
 	  1, 1, 1, 0, 0x20, 0x0c, 1, 0x0e, 0, 0, },
 	{ 400000, 100, 100, 1, 1, 11, 1, 1, 0, 1, 0, 1, 1, 0x9, 0, 0x05, 0,

drivers/phy/starfive/phy-jh7110-usb.c+7−0

 #include <linux/usb/of.h>
 #define USB_125M_CLK_RATE		125000000
+#define USB_CLK_MODE_OFF		0x0
+#define USB_CLK_MODE_RX_NORMAL_PWR	BIT(1)
 #define USB_LS_KEEPALIVE_OFF		0x4
 #define USB_LS_KEEPALIVE_ENABLE		BIT(4)
 {
 	struct jh7110_usb2_phy *phy = phy_get_drvdata(_phy);
 	int ret;
+	unsigned int val;
 	ret = clk_set_rate(phy->usb_125m_clk, USB_125M_CLK_RATE);
 	if (ret)
 	if (ret)
 		return ret;
+	val = readl(phy->regs + USB_CLK_MODE_OFF);
+	val |= USB_CLK_MODE_RX_NORMAL_PWR;
+	writel(val, phy->regs + USB_CLK_MODE_OFF);
 	return 0;
 }

drivers/phy/tegra/xusb-tegra186.c+27−19

 #define   DATA0_VAL_PD				BIT(1)
 #define   USE_XUSB_AO				BIT(4)
+#define TEGRA_UTMI_PAD_MAX 4
 #define TEGRA186_LANE(_name, _offset, _shift, _mask, _type)		\
 	{								\
 		.name = _name,						\
 	/* UTMI bias and tracking */
 	struct clk *usb2_trk_clk;
-	unsigned int bias_pad_enable;
+	DECLARE_BITMAP(utmi_pad_enabled, TEGRA_UTMI_PAD_MAX);
 	/* padctl context */
 	struct tegra186_xusb_padctl_context context;
 	u32 value;
 	int err;
-	mutex_lock(&padctl->lock);
+	if (!bitmap_empty(priv->utmi_pad_enabled, TEGRA_UTMI_PAD_MAX))
-	if (priv->bias_pad_enable++ > 0) {
-		mutex_unlock(&padctl->lock);
 		return;
-	}
 	err = clk_prepare_enable(priv->usb2_trk_clk);
 	if (err < 0)
 	} else {
 		clk_disable_unprepare(priv->usb2_trk_clk);
 	}
-	mutex_unlock(&padctl->lock);
 }
 static void tegra186_utmi_bias_pad_power_off(struct tegra_xusb_padctl *padctl)
 	struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 	u32 value;
-	mutex_lock(&padctl->lock);
+	if (!bitmap_empty(priv->utmi_pad_enabled, TEGRA_UTMI_PAD_MAX))
-	if (WARN_ON(priv->bias_pad_enable == 0)) {
-		mutex_unlock(&padctl->lock);
-		return;
-	}
-	if (--priv->bias_pad_enable > 0) {
-		mutex_unlock(&padctl->lock);
 		return;
-	}
 	value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 	value |= USB2_PD_TRK;
 		clk_disable_unprepare(priv->usb2_trk_clk);
 	}
-	mutex_unlock(&padctl->lock);
 }
 static void tegra186_utmi_pad_power_on(struct phy *phy)
 {
 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 	struct tegra_xusb_padctl *padctl = lane->pad->padctl;
+	struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 	struct tegra_xusb_usb2_port *port;
 	struct device *dev = padctl->dev;
 	unsigned int index = lane->index;
 	if (!phy)
 		return;
+	mutex_lock(&padctl->lock);
+	if (test_bit(index, priv->utmi_pad_enabled)) {
+		mutex_unlock(&padctl->lock);
+		return;
+	}
 	port = tegra_xusb_find_usb2_port(padctl, index);
 	if (!port) {
 		dev_err(dev, "no port found for USB2 lane %u\n", index);
+		mutex_unlock(&padctl->lock);
 		return;
 	}
 	value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 	value &= ~USB2_OTG_PD_DR;
 	padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
+	set_bit(index, priv->utmi_pad_enabled);
+	mutex_unlock(&padctl->lock);
 }
 static void tegra186_utmi_pad_power_down(struct phy *phy)
 {
 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 	struct tegra_xusb_padctl *padctl = lane->pad->padctl;
+	struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 	unsigned int index = lane->index;
 	u32 value;
 	if (!phy)
 		return;
+	mutex_lock(&padctl->lock);
+	if (!test_bit(index, priv->utmi_pad_enabled)) {
+		mutex_unlock(&padctl->lock);
+		return;
+	}
 	dev_dbg(padctl->dev, "power down UTMI pad %u\n", index);
 	value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 	udelay(2);
+	clear_bit(index, priv->utmi_pad_enabled);
 	tegra186_utmi_bias_pad_power_off(padctl);
+	mutex_unlock(&padctl->lock);
 }
 static int tegra186_xusb_padctl_vbus_override(struct tegra_xusb_padctl *padctl,

drivers/phy/tegra/xusb.c+4−4

@@ -548,16 +548,16 @@ static int tegra_xusb_port_init(struct tegra_xusb_port *port, · 547 unmodified lines
548		548
549	err = dev_set_name(&port->dev, "%s-%u", name, index);	549	err = dev_set_name(&port->dev, "%s-%u", name, index);
550	if (err < 0)	550	if (err < 0)
551	goto unregister;	551	goto put_device;
552		552
553	err = device_add(&port->dev);	553	err = device_add(&port->dev);
554	if (err < 0)	554	if (err < 0)
555	goto unregister;	555	goto put_device;
556		556
557	return 0;	557	return 0;
558		558
559	unregister:	559	put_device:
560	device_unregister(&port->dev);	560	put_device(&port->dev);
561	return err;	561	return err;
562	}	562	}
563		563

drivers/platform/x86/amd/hsmp/acpi.c+1−2

@@ -27,9 +27,8 @@ · 26 unmodified lines
27		27
28	#include "hsmp.h"	28	#include "hsmp.h"
29		29
30	#define DRIVER_NAME "amd_hsmp"	30	#define DRIVER_NAME "hsmp_acpi"
31	#define DRIVER_VERSION "2.3"	31	#define DRIVER_VERSION "2.3"
32	#define ACPI_HSMP_DEVICE_HID "AMDI0097"
33		32
34	/* These are the strings specified in ACPI table */	33	/* These are the strings specified in ACPI table */
35	#define MSG_IDOFF_STR "MsgIdOffset"	34	#define MSG_IDOFF_STR "MsgIdOffset"

drivers/platform/x86/amd/hsmp/hsmp.h+1−0

@@ -23,6 +23,7 @@ · 22 unmodified lines
23		23
24	#define HSMP_CDEV_NAME "hsmp_cdev"	24	#define HSMP_CDEV_NAME "hsmp_cdev"
25	#define HSMP_DEVNODE_NAME "hsmp"	25	#define HSMP_DEVNODE_NAME "hsmp"
		26	#define ACPI_HSMP_DEVICE_HID "AMDI0097"
26		27
27	struct hsmp_mbaddr_info {	28	struct hsmp_mbaddr_info {
28	u32 base_addr;	29	u32 base_addr;

drivers/platform/x86/amd/hsmp/plat.c+5−1

 #include <asm/amd/hsmp.h>
+#include <linux/acpi.h>
 #include <linux/build_bug.h>
 #include <linux/device.h>
 #include <linux/module.h>
 		}
 	case 0x1A:
 		switch (boot_cpu_data.x86_model) {
-		case 0x00 ... 0x1F:
+		case 0x00 ... 0x0F:
 			return true;
 		default:
 			return false;
 		return ret;
 	}
+	if (acpi_dev_present(ACPI_HSMP_DEVICE_HID, NULL, -1))
+		return -ENODEV;
 	hsmp_pdev = get_hsmp_pdev();
 	if (!hsmp_pdev)
 		return -ENOMEM;

drivers/platform/x86/amd/pmc/pmc-quirks.c+7−0

@@ -218,6 +218,13 @@ static const struct dmi_system_id fwbug_list[] = { · 217 unmodified lines
218	DMI_MATCH(DMI_BIOS_VERSION, "03.05"),	218	DMI_MATCH(DMI_BIOS_VERSION, "03.05"),
219	}	219	}
220	},	220	},
		221	{
		222	.ident = "MECHREVO Wujie 14X (GX4HRXL)",
		223	.driver_data = &quirk_spurious_8042,
		224	.matches = {
		225	DMI_MATCH(DMI_BOARD_NAME, "WUJIE14-GX4HRXL"),
		226	}
		227	},
221	{}	228	{}
222	};	229	};
223		230

drivers/platform/x86/amd/pmf/tee-if.c+22−1

 	return 0;
 }
+static inline bool amd_pmf_pb_valid(struct amd_pmf_dev *dev)
+{
+	return memchr_inv(dev->policy_buf, 0xff, dev->policy_sz);
+}
 #ifdef CONFIG_AMD_PMF_DEBUG
 static void amd_pmf_hex_dump_pb(struct amd_pmf_dev *dev)
 {
 	dev->policy_buf = new_policy_buf;
 	dev->policy_sz = length;
+	if (!amd_pmf_pb_valid(dev)) {
+		ret = -EINVAL;
+		goto cleanup;
+	}
 	amd_pmf_hex_dump_pb(dev);
 	ret = amd_pmf_start_policy_engine(dev);
 	if (ret < 0)
-		return ret;
+		goto cleanup;
 	return length;
+cleanup:
+	kfree(dev->policy_buf);
+	dev->policy_buf = NULL;
+	return ret;
 }
 static const struct file_operations pb_fops = {
 	memcpy_fromio(dev->policy_buf, dev->policy_base, dev->policy_sz);
+	if (!amd_pmf_pb_valid(dev)) {
+		dev_info(dev->dev, "No Smart PC policy present\n");
+		ret = -EINVAL;
+		goto err_free_policy;
+	}
 	amd_pmf_hex_dump_pb(dev);
 	dev->prev_data = kzalloc(sizeof(*dev->prev_data), GFP_KERNEL);

drivers/platform/x86/asus-wmi.c+2−1

@@ -4779,7 +4779,8 @@ static int asus_wmi_add(struct platform_device *pdev) · 4778 unmodified lines
4779	goto fail_leds;	4779	goto fail_leds;
4780		4780
4781	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);	4781	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
4782	if (result & (ASUS_WMI_DSTS_PRESENCE_BIT \| ASUS_WMI_DSTS_USER_BIT))	4782	if ((result & (ASUS_WMI_DSTS_PRESENCE_BIT \| ASUS_WMI_DSTS_USER_BIT)) ==
		4783	(ASUS_WMI_DSTS_PRESENCE_BIT \| ASUS_WMI_DSTS_USER_BIT))
4783	asus->driver->wlan_ctrl_by_user = 1;	4784	asus->driver->wlan_ctrl_by_user = 1;
4784		4785
4785	if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {	4786	if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {

drivers/platform/x86/thinkpad_acpi.c+2−0

@@ -11478,6 +11478,8 @@ static int __must_check __init get_thinkpad_model_data( · 11477 unmodified lines
11478	tp->vendor = PCI_VENDOR_ID_IBM;	11478	tp->vendor = PCI_VENDOR_ID_IBM;
11479	else if (dmi_name_in_vendors("LENOVO"))	11479	else if (dmi_name_in_vendors("LENOVO"))
11480	tp->vendor = PCI_VENDOR_ID_LENOVO;	11480	tp->vendor = PCI_VENDOR_ID_LENOVO;
		11481	else if (dmi_name_in_vendors("NEC"))
		11482	tp->vendor = PCI_VENDOR_ID_LENOVO;
11481	else	11483	else
11482	return 0;	11484	return 0;
11483		11485

drivers/regulator/max20086-regulator.c+6−1

 static int max20086_parse_regulators_dt(struct max20086 *chip, bool *boot_on)
 {
-	struct of_regulator_match matches[MAX20086_MAX_REGULATORS] = { };
+	struct of_regulator_match *matches;
 	struct device_node *node;
 	unsigned int i;
 	int ret;
 		return -ENODEV;
 	}
+	matches = devm_kcalloc(chip->dev, chip->info->num_outputs,
+			       sizeof(*matches), GFP_KERNEL);
+	if (!matches)
+		return -ENOMEM;
 	for (i = 0; i < chip->info->num_outputs; ++i)
 		matches[i].name = max20086_output_names[i];

drivers/scsi/sd_zbc.c+5−1

 					unsigned int nr_zones, size_t *buflen)
 {
 	struct request_queue *q = sdkp->disk->queue;
+	unsigned int max_segments;
 	size_t bufsize;
 	void *buf;
 	 * Furthermore, since the report zone command cannot be split, make
 	 * sure that the allocated buffer can always be mapped by limiting the
 	 * number of pages allocated to the HBA max segments limit.
+	 * Since max segments can be larger than the max inline bio vectors,
+	 * further limit the allocated buffer to BIO_MAX_INLINE_VECS.
 	 */
 	nr_zones = min(nr_zones, sdkp->zone_info.nr_zones);
 	bufsize = roundup((nr_zones + 1) * 64, SECTOR_SIZE);
 	bufsize = min_t(size_t, bufsize,
 			queue_max_hw_sectors(q) << SECTOR_SHIFT);
-	bufsize = min_t(size_t, bufsize, queue_max_segments(q) << PAGE_SHIFT);
+	max_segments = min(BIO_MAX_INLINE_VECS, queue_max_segments(q));
+	bufsize = min_t(size_t, bufsize, max_segments << PAGE_SHIFT);
 	while (bufsize >= SECTOR_SIZE) {
 		buf = kvzalloc(bufsize, GFP_KERNEL | __GFP_NORETRY);

drivers/scsi/storvsc_drv.c+1−0

@@ -1819,6 +1819,7 @@ static int storvsc_queuecommand(struct Scsi_Host host, struct scsi_cmnd scmnd) · 1818 unmodified lines
1819	return SCSI_MLQUEUE_DEVICE_BUSY;	1819	return SCSI_MLQUEUE_DEVICE_BUSY;
1820	}	1820	}
1821		1821
		1822	payload->rangecount = 1;
1822	payload->range.len = length;	1823	payload->range.len = length;
1823	payload->range.offset = offset_in_hvpg;	1824	payload->range.offset = offset_in_hvpg;
1824		1825

drivers/soundwire/bus.c+5−4

 	set_bit(SDW_GROUP13_DEV_NUM, bus->assigned);
 	set_bit(SDW_MASTER_DEV_NUM, bus->assigned);
+	ret = sdw_irq_create(bus, fwnode);
+	if (ret)
+		return ret;
 	/*
 	 * SDW is an enumerable bus, but devices can be powered off. So,
 	 * they won't be able to report as present.
 	if (ret < 0) {
 		dev_err(bus->dev, "Finding slaves failed:%d\n", ret);
+		sdw_irq_delete(bus);
 		return ret;
 	}
 	bus->params.curr_bank = SDW_BANK0;
 	bus->params.next_bank = SDW_BANK1;
-	ret = sdw_irq_create(bus, fwnode);
-	if (ret)
-		return ret;
 	return 0;
 }
 EXPORT_SYMBOL(sdw_bus_master_add);

drivers/spi/spi-loopback-test.c+1−1

@@ -420,7 +420,7 @@ MODULE_LICENSE("GPL"); · 419 unmodified lines
420	static void spi_test_print_hex_dump(char pre, const void ptr, size_t len)	420	static void spi_test_print_hex_dump(char pre, const void ptr, size_t len)
421	{	421	{
422	/* limit the hex_dump */	422	/* limit the hex_dump */
423	if (len < 1024) {	423	if (len <= 1024) {
424	print_hex_dump(KERN_INFO, pre,	424	print_hex_dump(KERN_INFO, pre,
425	DUMP_PREFIX_OFFSET, 16, 1,	425	DUMP_PREFIX_OFFSET, 16, 1,
426	ptr, len, 0);	426	ptr, len, 0);

drivers/spi/spi-sun4i.c+4−1

 	else
 		reg |= SUN4I_CTL_DHB;
+	/* Now that the settings are correct, enable the interface */
+	reg |= SUN4I_CTL_ENABLE;
 	sun4i_spi_write(sspi, SUN4I_CTL_REG, reg);
 	/* Ensure that we have a parent clock fast enough */
 	}
 	sun4i_spi_write(sspi, SUN4I_CTL_REG,
-			SUN4I_CTL_ENABLE | SUN4I_CTL_MASTER | SUN4I_CTL_TP);
+			SUN4I_CTL_MASTER | SUN4I_CTL_TP);
 	return 0;

drivers/spi/spi-tegra114.c+3−3

@@ -728,9 +728,9 @@ static int tegra_spi_set_hw_cs_timing(struct spi_device *spi) · 727 unmodified lines
728	u32 inactive_cycles;	728	u32 inactive_cycles;
729	u8 cs_state;	729	u8 cs_state;
730		730
731	if ((setup->unit && setup->unit != SPI_DELAY_UNIT_SCK) \|\|	731	if ((setup->value && setup->unit != SPI_DELAY_UNIT_SCK) \|\|
732	(hold->unit && hold->unit != SPI_DELAY_UNIT_SCK) \|\|	732	(hold->value && hold->unit != SPI_DELAY_UNIT_SCK) \|\|
733	(inactive->unit && inactive->unit != SPI_DELAY_UNIT_SCK)) {	733	(inactive->value && inactive->unit != SPI_DELAY_UNIT_SCK)) {
734	dev_err(&spi->dev,	734	dev_err(&spi->dev,
735	"Invalid delay unit %d, should be SPI_DELAY_UNIT_SCK\n",	735	"Invalid delay unit %d, should be SPI_DELAY_UNIT_SCK\n",
736	SPI_DELAY_UNIT_SCK);	736	SPI_DELAY_UNIT_SCK);

drivers/usb/gadget/function/f_midi2.c+1−1

@@ -475,7 +475,7 @@ static void reply_ump_stream_ep_info(struct f_midi2_ep *ep) · 474 unmodified lines
475	/* reply a UMP EP device info */	475	/* reply a UMP EP device info */
476	static void reply_ump_stream_ep_device(struct f_midi2_ep *ep)	476	static void reply_ump_stream_ep_device(struct f_midi2_ep *ep)
477	{	477	{
478	struct snd_ump_stream_msg_devince_info rep = {	478	struct snd_ump_stream_msg_device_info rep = {
479	.type = UMP_MSG_TYPE_STREAM,	479	.type = UMP_MSG_TYPE_STREAM,
480	.status = UMP_STREAM_MSG_STATUS_DEVICE_INFO,	480	.status = UMP_STREAM_MSG_STATUS_DEVICE_INFO,
481	.manufacture_id = ep->info.manufacturer,	481	.manufacture_id = ep->info.manufacturer,

fs/bcachefs/backpointers.c+79−38

@@ -192,7 +192,8 @@ static inline int bch2_backpointers_maybe_flush(struct btree_trans *trans, · 191 unmodified lines
192	static int backpointer_target_not_found(struct btree_trans *trans,	192	static int backpointer_target_not_found(struct btree_trans *trans,
193	struct bkey_s_c_backpointer bp,	193	struct bkey_s_c_backpointer bp,
194	struct bkey_s_c target_k,	194	struct bkey_s_c target_k,
195	struct bkey_buf *last_flushed)	195	struct bkey_buf *last_flushed,
		196	bool commit)
196	{	197	{
197	struct bch_fs *c = trans->c;	198	struct bch_fs *c = trans->c;
198	struct printbuf buf = PRINTBUF;	199	struct printbuf buf = PRINTBUF;
@@ -228,18 +229,77 @@ static int backpointer_target_not_found(struct btree_trans *trans, · 29 unmodified lines
228	}	229	}
229		230
230	if (fsck_err(trans, backpointer_to_missing_ptr,	231	if (fsck_err(trans, backpointer_to_missing_ptr,
231	"%s", buf.buf))	232	"%s", buf.buf)) {
232	ret = bch2_backpointer_del(trans, bp.k->p);	233	ret = bch2_backpointer_del(trans, bp.k->p);
		234	if (ret \|\| !commit)
		235	goto out;
		236
		237	/*
		238	* Normally, on transaction commit from inside a transaction,
		239	* we'll return -BCH_ERR_transaction_restart_nested, since a
		240	* transaction commit invalidates pointers given out by peek().
		241	*
		242	* However, since we're updating a write buffer btree, if we
		243	* return a transaction restart and loop we won't see that the
		244	* backpointer has been deleted without an additional write
		245	* buffer flush - and those are expensive.
		246	*
		247	* So we're relying on the caller immediately advancing to the
		248	* next backpointer and starting a new transaction immediately
		249	* after backpointer_get_key() returns NULL:
		250	*/
		251	ret = bch2_trans_commit(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc);
		252	}
		253	out:
233	fsck_err:	254	fsck_err:
234	printbuf_exit(&buf);	255	printbuf_exit(&buf);
235	return ret;	256	return ret;
236	}	257	}
237		258
238	struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,	259	static struct btree __bch2_backpointer_get_node(struct btree_trans trans,
239	struct bkey_s_c_backpointer bp,	260	struct bkey_s_c_backpointer bp,
240	struct btree_iter *iter,	261	struct btree_iter *iter,
241	unsigned iter_flags,	262	struct bkey_buf *last_flushed,
242	struct bkey_buf *last_flushed)	263	bool commit)
		264	{
		265	struct bch_fs *c = trans->c;
		266
		267	BUG_ON(!bp.v->level);
		268
		269	bch2_trans_node_iter_init(trans, iter,
		270	bp.v->btree_id,
		271	bp.v->pos,
		272	0,
		273	bp.v->level - 1,
		274	0);
		275	struct btree *b = bch2_btree_iter_peek_node(trans, iter);
		276	if (IS_ERR_OR_NULL(b))
		277	goto err;
		278
		279	BUG_ON(b->c.level != bp.v->level - 1);
		280
		281	if (extent_matches_bp(c, bp.v->btree_id, bp.v->level,
		282	bkey_i_to_s_c(&b->key), bp))
		283	return b;
		284
		285	if (btree_node_will_make_reachable(b)) {
		286	b = ERR_PTR(-BCH_ERR_backpointer_to_overwritten_btree_node);
		287	} else {
		288	int ret = backpointer_target_not_found(trans, bp, bkey_i_to_s_c(&b->key),
		289	last_flushed, commit);
		290	b = ret ? ERR_PTR(ret) : NULL;
		291	}
		292	err:
		293	bch2_trans_iter_exit(trans, iter);
		294	return b;
		295	}
		296
		297	static struct bkey_s_c __bch2_backpointer_get_key(struct btree_trans *trans,
		298	struct bkey_s_c_backpointer bp,
		299	struct btree_iter *iter,
		300	unsigned iter_flags,
		301	struct bkey_buf *last_flushed,
		302	bool commit)
243	{	303	{
244	struct bch_fs *c = trans->c;	304	struct bch_fs *c = trans->c;
245		305
@@ -277,10 +337,10 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans, · 31 unmodified lines
277	bch2_trans_iter_exit(trans, iter);	337	bch2_trans_iter_exit(trans, iter);
278		338
279	if (!bp.v->level) {	339	if (!bp.v->level) {
280	int ret = backpointer_target_not_found(trans, bp, k, last_flushed);	340	int ret = backpointer_target_not_found(trans, bp, k, last_flushed, commit);
281	return ret ? bkey_s_c_err(ret) : bkey_s_c_null;	341	return ret ? bkey_s_c_err(ret) : bkey_s_c_null;
282	} else {	342	} else {
283	struct btree *b = bch2_backpointer_get_node(trans, bp, iter, last_flushed);	343	struct btree *b = __bch2_backpointer_get_node(trans, bp, iter, last_flushed, commit);
284	if (b == ERR_PTR(-BCH_ERR_backpointer_to_overwritten_btree_node))	344	if (b == ERR_PTR(-BCH_ERR_backpointer_to_overwritten_btree_node))
285	return bkey_s_c_null;	345	return bkey_s_c_null;
286	if (IS_ERR_OR_NULL(b))	346	if (IS_ERR_OR_NULL(b))
@@ -295,35 +355,16 @@ struct btree bch2_backpointer_get_node(struct btree_trans trans, · 8 unmodified lines
295	struct btree_iter *iter,	355	struct btree_iter *iter,
296	struct bkey_buf *last_flushed)	356	struct bkey_buf *last_flushed)
297	{	357	{
298	struct bch_fs *c = trans->c;	358	return __bch2_backpointer_get_node(trans, bp, iter, last_flushed, true);
299		359	}
300	BUG_ON(!bp.v->level);
301
302	bch2_trans_node_iter_init(trans, iter,
303	bp.v->btree_id,
304	bp.v->pos,
305	0,
306	bp.v->level - 1,
307	0);
308	struct btree *b = bch2_btree_iter_peek_node(trans, iter);
309	if (IS_ERR_OR_NULL(b))
310	goto err;
311
312	BUG_ON(b->c.level != bp.v->level - 1);
313
314	if (extent_matches_bp(c, bp.v->btree_id, bp.v->level,
315	bkey_i_to_s_c(&b->key), bp))
316	return b;
317		360
318	if (btree_node_will_make_reachable(b)) {	361	struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,
319	b = ERR_PTR(-BCH_ERR_backpointer_to_overwritten_btree_node);	362	struct bkey_s_c_backpointer bp,
320	} else {	363	struct btree_iter *iter,
321	int ret = backpointer_target_not_found(trans, bp, bkey_i_to_s_c(&b->key), last_flushed);	364	unsigned iter_flags,
322	b = ret ? ERR_PTR(ret) : NULL;	365	struct bkey_buf *last_flushed)
323	}	366	{
324	err:	367	return __bch2_backpointer_get_key(trans, bp, iter, iter_flags, last_flushed, true);
325	bch2_trans_iter_exit(trans, iter);
326	return b;
327	}	368	}
328		369
329	static int bch2_check_backpointer_has_valid_bucket(struct btree_trans *trans, struct bkey_s_c k,	370	static int bch2_check_backpointer_has_valid_bucket(struct btree_trans *trans, struct bkey_s_c k,
@@ -521,7 +562,7 @@ check_existing_bp: · 191 unmodified lines
521	struct bkey_s_c_backpointer other_bp = bkey_s_c_to_backpointer(bp_k);	562	struct bkey_s_c_backpointer other_bp = bkey_s_c_to_backpointer(bp_k);
522		563
523	struct bkey_s_c other_extent =	564	struct bkey_s_c other_extent =
524	bch2_backpointer_get_key(trans, other_bp, &other_extent_iter, 0, NULL);	565	__bch2_backpointer_get_key(trans, other_bp, &other_extent_iter, 0, NULL, false);
525	ret = bkey_err(other_extent);	566	ret = bkey_err(other_extent);
526	if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node)	567	if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node)
527	ret = 0;	568	ret = 0;

fs/bcachefs/btree_cache.c+4−5

 	b->sib_u64s[1]		= 0;
 	b->whiteout_u64s	= 0;
 	bch2_btree_keys_init(b);
-	set_btree_node_accessed(b);
 	bch2_time_stats_update(&c->times[BCH_TIME_btree_node_mem_alloc],
 			       start_time);
 			six_unlock_read(&b->c.lock);
 			goto retry;
 		}
+		/* avoid atomic set bit if it's not needed: */
+		if (!btree_node_accessed(b))
+			set_btree_node_accessed(b);
 	}
 	/* XXX: waiting on IO with btree locks held: */
 		prefetch(p + L1_CACHE_BYTES * 2);
 	}
-	/* avoid atomic set bit if it's not needed: */
-	if (!btree_node_accessed(b))
-		set_btree_node_accessed(b);
 	if (unlikely(btree_node_read_error(b))) {
 		six_unlock_read(&b->c.lock);
 		b = ERR_PTR(-BCH_ERR_btree_node_read_err_cached);

fs/bcachefs/btree_iter.c+14−8

 		return NULL;
 	}
+	/*
+	 * We don't correctly handle nodes with extra intent locks here:
+	 * downgrade so we don't violate locking invariants
+	 */
+	bch2_btree_path_downgrade(trans, path);
 	if (!bch2_btree_node_relock(trans, path, path->level + 1)) {
 		__bch2_btree_path_unlock(trans, path);
 		path->l[path->level].b		= ERR_PTR(-BCH_ERR_no_btree_node_relock);
 	ret = trans_maybe_inject_restart(trans, _RET_IP_);
 	if (unlikely(ret)) {
 		k = bkey_s_c_err(ret);
-		goto out_no_locked;
+		goto out;
 	}
 	/* extents can't span inode numbers: */
 	ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);
 	if (unlikely(ret)) {
 		k = bkey_s_c_err(ret);
-		goto out_no_locked;
+		goto out;
 	}
 	struct btree_path *path = btree_iter_path(trans, iter);
 	if (unlikely(!btree_path_node(path, path->level)))
 		return bkey_s_c_null;
+	btree_path_set_should_be_locked(trans, path);
 	if ((iter->flags & BTREE_ITER_cached) ||
 	    !(iter->flags & (BTREE_ITER_is_extents|BTREE_ITER_filter_snapshots))) {
 		k = bkey_s_c_null;
 			if (!bkey_err(k))
 				iter->k = *k.k;
 			/* We're not returning a key from iter->path: */
-			goto out_no_locked;
+			goto out;
 		}
-		k = bch2_btree_path_peek_slot(trans->paths + iter->path, &iter->k);
+		k = bch2_btree_path_peek_slot(btree_iter_path(trans, iter), &iter->k);
 		if (unlikely(!k.k))
-			goto out_no_locked;
+			goto out;
 		if (unlikely(k.k->type == KEY_TYPE_whiteout &&
 			     (iter->flags & BTREE_ITER_filter_snapshots) &&
 		}
 		if (unlikely(bkey_err(k)))
-			goto out_no_locked;
+			goto out;
 		next = k.k ? bkey_start_pos(k.k) : POS_MAX;
 		}
 	}
 out:
-	btree_path_set_should_be_locked(trans, btree_iter_path(trans, iter));
-out_no_locked:
 	bch2_btree_iter_verify_entry_exit(iter);
 	bch2_btree_iter_verify(trans, iter);
 	ret = bch2_btree_iter_verify_ret(trans, iter, k);

fs/bcachefs/disk_accounting.c+15−2

 	return ret;
 }
+int bch2_accounting_mem_insert_locked(struct bch_fs *c, struct bkey_s_c_accounting a,
+			       enum bch_accounting_mode mode)
+{
+	struct bch_replicas_padded r;
+	if (mode != BCH_ACCOUNTING_read &&
+	    accounting_to_replicas(&r.e, a.k->p) &&
+	    !bch2_replicas_marked_locked(c, &r.e))
+		return -BCH_ERR_btree_insert_need_mark_replicas;
+	return __bch2_accounting_mem_insert(c, a);
+}
 static bool accounting_mem_entry_is_zero(struct accounting_mem_entry *e)
 {
 	for (unsigned i = 0; i < e->nr_counters; i++)
 					accounting_key_init(&k_i.k, &acc_k, src_v, nr);
 					bch2_accounting_mem_mod_locked(trans,
 								bkey_i_to_s_c_accounting(&k_i.k),
-								BCH_ACCOUNTING_normal);
+								BCH_ACCOUNTING_normal, true);
 					preempt_disable();
 					struct bch_fs_usage_base *dst = this_cpu_ptr(c->usage);
 	percpu_down_read(&c->mark_lock);
 	int ret = bch2_accounting_mem_mod_locked(trans, bkey_s_c_to_accounting(k),
-						 BCH_ACCOUNTING_read);
+						 BCH_ACCOUNTING_read, false);
 	percpu_up_read(&c->mark_lock);
 	return ret;
 }

fs/bcachefs/disk_accounting.h+11−5

 };
 int bch2_accounting_mem_insert(struct bch_fs *, struct bkey_s_c_accounting, enum bch_accounting_mode);
+int bch2_accounting_mem_insert_locked(struct bch_fs *, struct bkey_s_c_accounting, enum bch_accounting_mode);
 void bch2_accounting_mem_gc(struct bch_fs *);
 static inline bool bch2_accounting_is_mem(struct disk_accounting_pos acc)
  */
 static inline int bch2_accounting_mem_mod_locked(struct btree_trans *trans,
 						 struct bkey_s_c_accounting a,
-						 enum bch_accounting_mode mode)
+						 enum bch_accounting_mode mode,
+						 bool write_locked)
 {
 	struct bch_fs *c = trans->c;
 	struct bch_accounting_mem *acc = &c->accounting;
 	while ((idx = eytzinger0_find(acc->k.data, acc->k.nr, sizeof(acc->k.data[0]),
 				      accounting_pos_cmp, &a.k->p)) >= acc->k.nr) {
-		int ret = bch2_accounting_mem_insert(c, a, mode);
+		int ret = 0;
+		if (unlikely(write_locked))
+			ret = bch2_accounting_mem_insert_locked(c, a, mode);
+		else
+			ret = bch2_accounting_mem_insert(c, a, mode);
 		if (ret)
 			return ret;
 	}
 static inline int bch2_accounting_mem_add(struct btree_trans *trans, struct bkey_s_c_accounting a, bool gc)
 {
 	percpu_down_read(&trans->c->mark_lock);
-	int ret = bch2_accounting_mem_mod_locked(trans, a, gc ? BCH_ACCOUNTING_gc : BCH_ACCOUNTING_normal);
+	int ret = bch2_accounting_mem_mod_locked(trans, a, gc ? BCH_ACCOUNTING_gc : BCH_ACCOUNTING_normal, false);
 	percpu_up_read(&trans->c->mark_lock);
 	return ret;
 }
 	EBUG_ON(bversion_zero(a->k.bversion));
 	return likely(!(commit_flags & BCH_TRANS_COMMIT_skip_accounting_apply))
-		? bch2_accounting_mem_mod_locked(trans, accounting_i_to_s_c(a), BCH_ACCOUNTING_normal)
+		? bch2_accounting_mem_mod_locked(trans, accounting_i_to_s_c(a), BCH_ACCOUNTING_normal, false)
 		: 0;
 }
 		struct bkey_s_accounting a = accounting_i_to_s(a_i);
 		bch2_accounting_neg(a);
-		bch2_accounting_mem_mod_locked(trans, a.c, BCH_ACCOUNTING_normal);
+		bch2_accounting_mem_mod_locked(trans, a.c, BCH_ACCOUNTING_normal, false);
 		bch2_accounting_neg(a);
 	}
 }

fs/bcachefs/fs.c+3−1

@@ -1429,7 +1429,9 @@ static int bch2_next_fiemap_extent(struct btree_trans *trans, · 1428 unmodified lines
1429	if (ret)	1429	if (ret)
1430	goto err;	1430	goto err;
1431		1431
1432	ret = bch2_next_fiemap_pagecache_extent(trans, inode, start, end, cur);	1432	u64 pagecache_end = k.k ? max(start, bkey_start_offset(k.k)) : end;
		1433
		1434	ret = bch2_next_fiemap_pagecache_extent(trans, inode, start, pagecache_end, cur);
1433	if (ret)	1435	if (ret)
1434	goto err;	1436	goto err;
1435		1437

fs/bcachefs/fsck.c+1−1

@@ -2446,7 +2446,7 @@ static int check_subvol_path(struct btree_trans trans, struct btree_iter iter, · 2445 unmodified lines
2446	u32 parent = le32_to_cpu(s.v->fs_path_parent);	2446	u32 parent = le32_to_cpu(s.v->fs_path_parent);
2447		2447
2448	if (darray_u32_has(&subvol_path, parent)) {	2448	if (darray_u32_has(&subvol_path, parent)) {
2449	if (fsck_err(c, subvol_loop, "subvolume loop"))	2449	if (fsck_err(trans, subvol_loop, "subvolume loop"))
2450	ret = reattach_subvol(trans, s);	2450	ret = reattach_subvol(trans, s);
2451	break;	2451	break;
2452	}	2452	}

fs/bcachefs/journal_reclaim.c+12−5

 #include <linux/kthread.h>
 #include <linux/sched/mm.h>
+static bool __should_discard_bucket(struct journal *, struct journal_device *);
 /* Free space calculations: */
 static unsigned journal_space_from(struct journal_device *ja,
 		       ja->bucket_seq[ja->dirty_idx_ondisk] < j->last_seq_ondisk)
 			ja->dirty_idx_ondisk = (ja->dirty_idx_ondisk + 1) % ja->nr;
-		if (ja->discard_idx != ja->dirty_idx_ondisk)
+		can_discard |= __should_discard_bucket(j, ja);
-			can_discard = true;
 		max_entry_size = min_t(unsigned, max_entry_size, ca->mi.bucket_size);
 		nr_online++;
 /* Discards - last part of journal reclaim: */
-static bool should_discard_bucket(struct journal *j, struct journal_device *ja)
+static bool __should_discard_bucket(struct journal *j, struct journal_device *ja)
 {
-	spin_lock(&j->lock);
 	unsigned min_free = max(4, ja->nr / 8);
-	bool ret = bch2_journal_dev_buckets_available(j, ja, journal_space_discarded) < min_free &&
+	return bch2_journal_dev_buckets_available(j, ja, journal_space_discarded) <
+		min_free &&
 		ja->discard_idx != ja->dirty_idx_ondisk;
+}
+static bool should_discard_bucket(struct journal *j, struct journal_device *ja)
+{
+	spin_lock(&j->lock);
+	bool ret = __should_discard_bucket(j, ja);
 	spin_unlock(&j->lock);
 	return ret;

fs/bcachefs/rebalance.c+1−1

@@ -309,7 +309,7 @@ static int bch2_bkey_clear_needs_rebalance(struct btree_trans *trans, · 308 unmodified lines
309	struct btree_iter *iter,	309	struct btree_iter *iter,
310	struct bkey_s_c k)	310	struct bkey_s_c k)
311	{	311	{
312	if (!bch2_bkey_rebalance_opts(k))	312	if (k.k->type == KEY_TYPE_reflink_v \|\| !bch2_bkey_rebalance_opts(k))
313	return 0;	313	return 0;
314		314
315	struct bkey_i *n = bch2_bkey_make_mut(trans, iter, &k, 0);	315	struct bkey_i *n = bch2_bkey_make_mut(trans, iter, &k, 0);

fs/binfmt_elf.c+47−24

 	struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
 	struct elf_phdr *elf_property_phdata = NULL;
 	unsigned long elf_brk;
+	bool brk_moved = false;
 	int retval, i;
 	unsigned long elf_entry;
 	unsigned long e_entry;
 			/* Calculate any requested alignment. */
 			alignment = maximum_alignment(elf_phdata, elf_ex->e_phnum);
-			/*
+			/**
-			 * There are effectively two types of ET_DYN
+			 * DOC: PIE handling
-			 * binaries: programs (i.e. PIE: ET_DYN with PT_INTERP)
+			 *
-			 * and loaders (ET_DYN without PT_INTERP, since they
+			 * There are effectively two types of ET_DYN ELF
-			 * _are_ the ELF interpreter). The loaders must
+			 * binaries: programs (i.e. PIE: ET_DYN with
-			 * be loaded away from programs since the program
+			 * PT_INTERP) and loaders (i.e. static PIE: ET_DYN
-			 * may otherwise collide with the loader (especially
+			 * without PT_INTERP, usually the ELF interpreter
-			 * for ET_EXEC which does not have a randomized
+			 * itself). Loaders must be loaded away from programs
-			 * position). For example to handle invocations of
+			 * since the program may otherwise collide with the
+			 * loader (especially for ET_EXEC which does not have
+			 * a randomized position).
+			 *
+			 * For example, to handle invocations of
 			 * "./ld.so someprog" to test out a new version of
 			 * the loader, the subsequent program that the
 			 * loader loads must avoid the loader itself, so
 			 * ELF_ET_DYN_BASE and loaders are loaded into the
 			 * independently randomized mmap region (0 load_bias
 			 * without MAP_FIXED nor MAP_FIXED_NOREPLACE).
+			 *
+			 * See below for "brk" handling details, which is
+			 * also affected by program vs loader and ASLR.
 			 */
 			if (interpreter) {
 				/* On ET_DYN with PT_INTERP, we do the ASLR. */
 	start_data += load_bias;
 	end_data += load_bias;
-	current->mm->start_brk = current->mm->brk = ELF_PAGEALIGN(elf_brk);
 	if (interpreter) {
 		elf_entry = load_elf_interp(interp_elf_ex,
 					    interpreter,
 	mm->end_data = end_data;
 	mm->start_stack = bprm->p;
-	if ((current->flags & PF_RANDOMIZE) && (snapshot_randomize_va_space > 1)) {
+	/**
+	 * DOC: "brk" handling
+	 *
+	 * For architectures with ELF randomization, when executing a
+	 * loader directly (i.e. static PIE: ET_DYN without PT_INTERP),
+	 * move the brk area out of the mmap region and into the unused
+	 * ELF_ET_DYN_BASE region. Since "brk" grows up it may collide
+	 * early with the stack growing down or other regions being put
+	 * into the mmap region by the kernel (e.g. vdso).
+	 *
+	 * In the CONFIG_COMPAT_BRK case, though, everything is turned
+	 * off because we're not allowed to move the brk at all.
+	 */
+	if (!IS_ENABLED(CONFIG_COMPAT_BRK) &&
+	    IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
+	    elf_ex->e_type == ET_DYN && !interpreter) {
+		elf_brk = ELF_ET_DYN_BASE;
+		/* This counts as moving the brk, so let brk(2) know. */
+		brk_moved = true;
+	}
+	mm->start_brk = mm->brk = ELF_PAGEALIGN(elf_brk);
+	if ((current->flags & PF_RANDOMIZE) && snapshot_randomize_va_space > 1) {
 		/*
-		 * For architectures with ELF randomization, when executing
+		 * If we didn't move the brk to ELF_ET_DYN_BASE (above),
-		 * a loader directly (i.e. no interpreter listed in ELF
+		 * leave a gap between .bss and brk.
-		 * headers), move the brk area out of the mmap region
-		 * (since it grows up, and may collide early with the stack
-		 * growing down), and into the unused ELF_ET_DYN_BASE region.
 		 */
-		if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
+		if (!brk_moved)
-		    elf_ex->e_type == ET_DYN && !interpreter) {
-			mm->brk = mm->start_brk = ELF_ET_DYN_BASE;
-		} else {
-			/* Otherwise leave a gap between .bss and brk. */
 			mm->brk = mm->start_brk = mm->brk + PAGE_SIZE;
-		}
 		mm->brk = mm->start_brk = arch_randomize_brk(mm);
+		brk_moved = true;
+	}
 #ifdef compat_brk_randomized
+	if (brk_moved)
 		current->brk_randomized = 1;
 #endif
-	}
 	if (current->personality & MMAP_PAGE_ZERO) {
 		/* Why this, you ask???  Well SVr4 maps page 0 as read-only,

fs/btrfs/discard.c+15−2

 				  struct btrfs_block_group *block_group)
 {
 	lockdep_assert_held(&discard_ctl->lock);
-	if (!btrfs_run_discard_work(discard_ctl))
-		return;
 	if (list_empty(&block_group->discard_list) ||
 	    block_group->discard_index == BTRFS_DISCARD_INDEX_UNUSED) {
 	if (!btrfs_is_block_group_data_only(block_group))
 		return;
+	if (!btrfs_run_discard_work(discard_ctl))
+		return;
 	spin_lock(&discard_ctl->lock);
 	__add_to_discard_list(discard_ctl, block_group);
 	spin_unlock(&discard_ctl->lock);
 		    block_group->used != 0) {
 			if (btrfs_is_block_group_data_only(block_group)) {
 				__add_to_discard_list(discard_ctl, block_group);
+				/*
+				 * The block group must have been moved to other
+				 * discard list even if discard was disabled in
+				 * the meantime or a transaction abort happened,
+				 * otherwise we can end up in an infinite loop,
+				 * always jumping into the 'again' label and
+				 * keep getting this block group over and over
+				 * in case there are no other block groups in
+				 * the discard lists.
+				 */
+				ASSERT(block_group->discard_index !=
+				       BTRFS_DISCARD_INDEX_UNUSED);
 			} else {
 				list_del_init(&block_group->discard_list);
 				btrfs_put_block_group(block_group);

fs/btrfs/fs.h+1−0

@@ -300,6 +300,7 @@ enum { · 299 unmodified lines
300	#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL	300	#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL
301		301
302	#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)	302	#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
		303	#define BTRFS_WARNING_COMMIT_INTERVAL (300)
303	#define BTRFS_DEFAULT_MAX_INLINE (2048)	304	#define BTRFS_DEFAULT_MAX_INLINE (2048)
304		305
305	struct btrfs_dev_replace {	306	struct btrfs_dev_replace {

fs/btrfs/inode.c+7−0

 	struct extent_state *cached = NULL;
 	struct extent_map *em;
 	int ret = 0;
+	bool free_pages = false;
 	u64 start = async_extent->start;
 	u64 end = async_extent->start + async_extent->ram_size - 1;
 	}
 	if (async_extent->compress_type == BTRFS_COMPRESS_NONE) {
+		ASSERT(!async_extent->folios);
+		ASSERT(async_extent->nr_folios == 0);
 		submit_uncompressed_range(inode, async_extent, locked_folio);
+		free_pages = true;
 		goto done;
 	}
 		 * fall back to uncompressed.
 		 */
 		submit_uncompressed_range(inode, async_extent, locked_folio);
+		free_pages = true;
 		goto done;
 	}
 done:
 	if (async_chunk->blkcg_css)
 		kthread_associate_blkcg(NULL);
+	if (free_pages)
+		free_async_extent_pages(async_extent);
 	kfree(async_extent);
 	return;

fs/btrfs/super.c+4−0

 		break;
 	case Opt_commit_interval:
 		ctx->commit_interval = result.uint_32;
+		if (ctx->commit_interval > BTRFS_WARNING_COMMIT_INTERVAL) {
+			btrfs_warn(NULL, "excessive commit interval %u, use with care",
+				   ctx->commit_interval);
+		}
 		if (ctx->commit_interval == 0)
 			ctx->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
 		break;

fs/buffer.c+1−3

 	/* FIXME: do we need to set this in both places? */
 	if (bh->b_folio && bh->b_folio->mapping)
 		mapping_set_error(bh->b_folio->mapping, -EIO);
-	if (bh->b_assoc_map) {
+	if (bh->b_assoc_map)
 		mapping_set_error(bh->b_assoc_map, -EIO);
-		errseq_set(&bh->b_assoc_map->host->i_sb->s_wb_err, -EIO);
-	}
 }
 EXPORT_SYMBOL(mark_buffer_write_io_error);

fs/eventpoll.c+4−3

@@ -2111,9 +2111,10 @@ static int ep_poll(struct eventpoll ep, struct epoll_event __user events, · 2110 unmodified lines
2111		2111
2112	write_unlock_irq(&ep->lock);	2112	write_unlock_irq(&ep->lock);
2113		2113
2114	if (!eavail && ep_schedule_timeout(to))	2114	if (!eavail)
2115	timed_out = !schedule_hrtimeout_range(to, slack,	2115	timed_out = !ep_schedule_timeout(to) \|\|
2116	HRTIMER_MODE_ABS);	2116	!schedule_hrtimeout_range(to, slack,
		2117	HRTIMER_MODE_ABS);
2117	__set_current_state(TASK_RUNNING);	2118	__set_current_state(TASK_RUNNING);
2118		2119
2119	/*	2120	/*

fs/nfs/client.c+9−0

 		if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
 			server->namelen = NFS2_MAXNAMLEN;
 	}
+	/* Linux 'subtree_check' borkenness mandates this setting */
+	server->fh_expire_type = NFS_FH_VOL_RENAME;
 	if (!(fattr->valid & NFS_ATTR_FATTR)) {
 		error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
 	INIT_LIST_HEAD(&nn->nfs_volume_list);
 #if IS_ENABLED(CONFIG_NFS_V4)
 	idr_init(&nn->cb_ident_idr);
+#endif
+#if IS_ENABLED(CONFIG_NFS_V4_1)
+	INIT_LIST_HEAD(&nn->nfs4_data_server_cache);
+	spin_lock_init(&nn->nfs4_data_server_lock);
 #endif
 	spin_lock_init(&nn->nfs_client_lock);
 	nn->boot_time = ktime_get_real();
 	nfs_cleanup_cb_ident_idr(net);
 	WARN_ON_ONCE(!list_empty(&nn->nfs_client_list));
 	WARN_ON_ONCE(!list_empty(&nn->nfs_volume_list));
+#if IS_ENABLED(CONFIG_NFS_V4_1)
+	WARN_ON_ONCE(!list_empty(&nn->nfs4_data_server_cache));
+#endif
 }
 #ifdef CONFIG_PROC_FS

fs/nfs/dir.c+14−1

 	unblock_revalidate(new_dentry);
 }
+static bool nfs_rename_is_unsafe_cross_dir(struct dentry *old_dentry,
+					   struct dentry *new_dentry)
+{
+	struct nfs_server *server = NFS_SB(old_dentry->d_sb);
+	if (old_dentry->d_parent != new_dentry->d_parent)
+		return false;
+	if (server->fh_expire_type & NFS_FH_RENAME_UNSAFE)
+		return !(server->fh_expire_type & NFS_FH_NOEXPIRE_WITH_OPEN);
+	return true;
+}
 /*
  * RENAME
  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
 	}
-	if (S_ISREG(old_inode->i_mode))
+	if (S_ISREG(old_inode->i_mode) &&
+	    nfs_rename_is_unsafe_cross_dir(old_dentry, new_dentry))
 		nfs_sync_inode(old_inode);
 	task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry,
 				must_unblock ? nfs_unblock_rename : NULL);

fs/nfs/direct.c+1−1

 {
 	struct nfs_direct_req *dreq = hdr->dreq;
 	struct nfs_commit_info cinfo;
-	struct nfs_page *req = nfs_list_entry(hdr->pages.next);
 	struct inode *inode = dreq->inode;
 	int flags = NFS_ODIRECT_DONE;
 	spin_unlock(&inode->i_lock);
 	while (!list_empty(&hdr->pages)) {
+		struct nfs_page *req;
 		req = nfs_list_entry(hdr->pages.next);
 		nfs_list_remove_request(req);

fs/nfs/filelayout/filelayoutdev.c+3−3

 	struct page *scratch;
 	struct list_head dsaddrs;
 	struct nfs4_pnfs_ds_addr *da;
+	struct net *net = server->nfs_client->cl_net;
 	/* set up xdr stream */
 	scratch = alloc_page(gfp_flags);
 		mp_count = be32_to_cpup(p); /* multipath count */
 		for (j = 0; j < mp_count; j++) {
-			da = nfs4_decode_mp_ds_addr(server->nfs_client->cl_net,
+			da = nfs4_decode_mp_ds_addr(net, &stream, gfp_flags);
-						    &stream, gfp_flags);
 			if (da)
 				list_add_tail(&da->da_node, &dsaddrs);
 		}
 			goto out_err_free_deviceid;
 		}
-		dsaddr->ds_list[i] = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
+		dsaddr->ds_list[i] = nfs4_pnfs_ds_add(net, &dsaddrs, gfp_flags);
 		if (!dsaddr->ds_list[i])
 			goto out_err_drain_dsaddrs;
 		trace_fl_getdevinfo(server, &pdev->dev_id, dsaddr->ds_list[i]->ds_remotestr);

fs/nfs/flexfilelayout/flexfilelayout.c+3−3

@@ -1329,7 +1329,7 @@ static int ff_layout_read_done_cb(struct rpc_task *task, · 1328 unmodified lines
1329	hdr->args.offset, hdr->args.count,	1329	hdr->args.offset, hdr->args.count,
1330	&hdr->res.op_status, OP_READ,	1330	&hdr->res.op_status, OP_READ,
1331	task->tk_status);	1331	task->tk_status);
1332	trace_ff_layout_read_error(hdr);	1332	trace_ff_layout_read_error(hdr, task->tk_status);
1333	}	1333	}
1334		1334
1335	err = ff_layout_async_handle_error(task, hdr->args.context->state,	1335	err = ff_layout_async_handle_error(task, hdr->args.context->state,
@@ -1502,7 +1502,7 @@ static int ff_layout_write_done_cb(struct rpc_task *task, · 166 unmodified lines
1502	hdr->args.offset, hdr->args.count,	1502	hdr->args.offset, hdr->args.count,
1503	&hdr->res.op_status, OP_WRITE,	1503	&hdr->res.op_status, OP_WRITE,
1504	task->tk_status);	1504	task->tk_status);
1505	trace_ff_layout_write_error(hdr);	1505	trace_ff_layout_write_error(hdr, task->tk_status);
1506	}	1506	}
1507		1507
1508	err = ff_layout_async_handle_error(task, hdr->args.context->state,	1508	err = ff_layout_async_handle_error(task, hdr->args.context->state,
@@ -1551,7 +1551,7 @@ static int ff_layout_commit_done_cb(struct rpc_task *task, · 42 unmodified lines
1551	data->args.offset, data->args.count,	1551	data->args.offset, data->args.count,
1552	&data->res.op_status, OP_COMMIT,	1552	&data->res.op_status, OP_COMMIT,
1553	task->tk_status);	1553	task->tk_status);
1554	trace_ff_layout_commit_error(data);	1554	trace_ff_layout_commit_error(data, task->tk_status);
1555	}	1555	}
1556		1556
1557	err = ff_layout_async_handle_error(task, NULL, data->ds_clp,	1557	err = ff_layout_async_handle_error(task, NULL, data->ds_clp,

fs/nfs/flexfilelayout/flexfilelayoutdev.c+3−3

 	struct nfs4_pnfs_ds_addr *da;
 	struct nfs4_ff_layout_ds *new_ds = NULL;
 	struct nfs4_ff_ds_version *ds_versions = NULL;
+	struct net *net = server->nfs_client->cl_net;
 	u32 mp_count;
 	u32 version_count;
 	__be32 *p;
 	for (i = 0; i < mp_count; i++) {
 		/* multipath ds */
-		da = nfs4_decode_mp_ds_addr(server->nfs_client->cl_net,
+		da = nfs4_decode_mp_ds_addr(net, &stream, gfp_flags);
-					    &stream, gfp_flags);
 		if (da)
 			list_add_tail(&da->da_node, &dsaddrs);
 	}
 	new_ds->ds_versions = ds_versions;
 	new_ds->ds_versions_cnt = version_count;
-	new_ds->ds = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
+	new_ds->ds = nfs4_pnfs_ds_add(net, &dsaddrs, gfp_flags);
 	if (!new_ds->ds)
 		goto out_err_drain_dsaddrs;

fs/nfs/localio.c+1−1

 		new = __nfs_local_open_fh(clp, cred, fh, nfl, mode);
 		if (IS_ERR(new))
 			return NULL;
+		rcu_read_lock();
 		/* try to swap in the pointer */
 		spin_lock(&clp->cl_uuid.lock);
 		nf = rcu_dereference_protected(*pnf, 1);
 			rcu_assign_pointer(*pnf, nf);
 		}
 		spin_unlock(&clp->cl_uuid.lock);
-		rcu_read_lock();
 	}
 	nf = nfs_local_file_get(nf);
 	rcu_read_unlock();

fs/nfs/netns.h+5−1

 	unsigned short nfs_callback_tcpport;
 	unsigned short nfs_callback_tcpport6;
 	int cb_users[NFS4_MAX_MINOR_VERSION + 1];
-#endif
+#endif /* CONFIG_NFS_V4 */
+#if IS_ENABLED(CONFIG_NFS_V4_1)
+	struct list_head nfs4_data_server_cache;
+	spinlock_t nfs4_data_server_lock;
+#endif /* CONFIG_NFS_V4_1 */
 	struct nfs_netns_client *nfs_client;
 	spinlock_t nfs_client_lock;
 	ktime_t boot_time;

fs/nfs/nfs3acl.c+1−1

@@ -104,7 +104,7 @@ struct posix_acl nfs3_get_acl(struct inode inode, int type, bool rcu) · 103 unmodified lines
104		104
105	switch (status) {	105	switch (status) {
106	case 0:	106	case 0:
107	status = nfs_refresh_inode(inode, res.fattr);	107	nfs_refresh_inode(inode, res.fattr);
108	break;	108	break;
109	case -EPFNOSUPPORT:	109	case -EPFNOSUPPORT:
110	case -EPROTONOSUPPORT:	110	case -EPROTONOSUPPORT:

fs/nfs/nfs4proc.c+17−1

 	struct nfs_client *clp = server->nfs_client;
 	int ret;
+	if ((task->tk_rpc_status == -ENETDOWN ||
+	     task->tk_rpc_status == -ENETUNREACH) &&
+	    task->tk_flags & RPC_TASK_NETUNREACH_FATAL) {
+		exception->delay = 0;
+		exception->recovering = 0;
+		exception->retry = 0;
+		return -EIO;
+	}
 	ret = nfs4_do_handle_exception(server, errorcode, exception);
 	if (exception->delay) {
 		int ret2 = nfs4_exception_should_retrans(server, exception);
 	struct nfs4_unlockdata *p;
 	struct nfs4_state *state = lsp->ls_state;
 	struct inode *inode = state->inode;
+	struct nfs_lock_context *l_ctx;
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (p == NULL)
 		return NULL;
+	l_ctx = nfs_get_lock_context(ctx);
+	if (!IS_ERR(l_ctx)) {
+		p->l_ctx = l_ctx;
+	} else {
+		kfree(p);
+		return NULL;
+	}
 	p->arg.fh = NFS_FH(inode);
 	p->arg.fl = &p->fl;
 	p->arg.seqid = seqid;
 	p->lsp = lsp;
 	/* Ensure we don't close file until we're done freeing locks! */
 	p->ctx = get_nfs_open_context(ctx);
-	p->l_ctx = nfs_get_lock_context(ctx);
 	locks_init_lock(&p->fl);
 	locks_copy_lock(&p->fl, fl);
 	p->server = NFS_SERVER(inode);

fs/nfs/nfs4trace.h+22−12

 DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,
 		TP_PROTO(
-			const struct nfs_pgio_header *hdr
+			const struct nfs_pgio_header *hdr,
+			int error
 		),
-		TP_ARGS(hdr),
+		TP_ARGS(hdr, error),
 		TP_STRUCT__entry(
 			__field(unsigned long, error)
+			__field(unsigned long, nfs_error)
 			__field(dev_t, dev)
 			__field(u32, fhandle)
 			__field(u64, fileid)
 		TP_fast_assign(
 			const struct inode *inode = hdr->inode;
-			__entry->error = hdr->res.op_status;
+			__entry->error = -error;
+			__entry->nfs_error = hdr->res.op_status;
 			__entry->fhandle = nfs_fhandle_hash(hdr->args.fh);
 			__entry->fileid = NFS_FILEID(inode);
 			__entry->dev = inode->i_sb->s_dev;
 		TP_printk(
 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
-			"offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s",
+			"offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s "
+			"nfs_error=%lu (%s)",
 			-__entry->error,
 			show_nfs4_status(__entry->error),
 			MAJOR(__entry->dev), MINOR(__entry->dev),
 			__entry->fhandle,
 			__entry->offset, __entry->count,
 			__entry->stateid_seq, __entry->stateid_hash,
-			__get_str(dstaddr)
+			__get_str(dstaddr), __entry->nfs_error,
+			show_nfs4_status(__entry->nfs_error)
 		)
 );
 #define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \
 	DEFINE_EVENT(nfs4_flexfiles_io_event, name, \
 			TP_PROTO( \
-				const struct nfs_pgio_header *hdr \
+				const struct nfs_pgio_header *hdr, \
+				int error \
 			), \
-			TP_ARGS(hdr))
+			TP_ARGS(hdr, error))
 DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error);
 DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error);
 TRACE_EVENT(ff_layout_commit_error,
 		TP_PROTO(
-			const struct nfs_commit_data *data
+			const struct nfs_commit_data *data,
+			int error
 		),
-		TP_ARGS(data),
+		TP_ARGS(data, error),
 		TP_STRUCT__entry(
 			__field(unsigned long, error)
+			__field(unsigned long, nfs_error)
 			__field(dev_t, dev)
 			__field(u32, fhandle)
 			__field(u64, fileid)
 		TP_fast_assign(
 			const struct inode *inode = data->inode;
-			__entry->error = data->res.op_status;
+			__entry->error = -error;
+			__entry->nfs_error = data->res.op_status;
 			__entry->fhandle = nfs_fhandle_hash(data->args.fh);
 			__entry->fileid = NFS_FILEID(inode);
 			__entry->dev = inode->i_sb->s_dev;
 		TP_printk(
 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
-			"offset=%llu count=%u dstaddr=%s",
+			"offset=%llu count=%u dstaddr=%s nfs_error=%lu (%s)",
 			-__entry->error,
 			show_nfs4_status(__entry->error),
 			MAJOR(__entry->dev), MINOR(__entry->dev),
 			(unsigned long long)__entry->fileid,
 			__entry->fhandle,
 			__entry->offset, __entry->count,
-			__get_str(dstaddr)
+			__get_str(dstaddr), __entry->nfs_error,
+			show_nfs4_status(__entry->nfs_error)
 		)
 );

fs/nfs/pnfs.c+34−17

 	return remaining;
 }
+static void pnfs_reset_return_info(struct pnfs_layout_hdr *lo)
+{
+	struct pnfs_layout_segment *lseg;
+	list_for_each_entry(lseg, &lo->plh_return_segs, pls_list)
+		pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0);
+}
 static void
 pnfs_free_returned_lsegs(struct pnfs_layout_hdr *lo,
 		struct list_head *free_me,
 static void
 pnfs_layoutreturn_retry_later_locked(struct pnfs_layout_hdr *lo,
 				     const nfs4_stateid *arg_stateid,
-				     const struct pnfs_layout_range *range)
+				     const struct pnfs_layout_range *range,
+				     struct list_head *freeme)
 {
-	const struct pnfs_layout_segment *lseg;
-	u32 seq = be32_to_cpu(arg_stateid->seqid);
 	if (pnfs_layout_is_valid(lo) &&
-	    nfs4_stateid_match_other(&lo->plh_stateid, arg_stateid)) {
+	    nfs4_stateid_match_other(&lo->plh_stateid, arg_stateid))
-		list_for_each_entry(lseg, &lo->plh_return_segs, pls_list) {
+		pnfs_reset_return_info(lo);
-			if (pnfs_seqid_is_newer(lseg->pls_seq, seq) ||
+	else
-			    !pnfs_should_free_range(&lseg->pls_range, range))
+		pnfs_mark_layout_stateid_invalid(lo, freeme);
-				continue;
+	pnfs_clear_layoutreturn_waitbit(lo);
-			pnfs_set_plh_return_info(lo, range->iomode, seq);
-			break;
-		}
-	}
 }
 void pnfs_layoutreturn_retry_later(struct pnfs_layout_hdr *lo,
 				   const struct pnfs_layout_range *range)
 {
 	struct inode *inode = lo->plh_inode;
+	LIST_HEAD(freeme);
 	spin_lock(&inode->i_lock);
-	pnfs_layoutreturn_retry_later_locked(lo, arg_stateid, range);
+	pnfs_layoutreturn_retry_later_locked(lo, arg_stateid, range, &freeme);
-	pnfs_clear_layoutreturn_waitbit(lo);
 	spin_unlock(&inode->i_lock);
+	pnfs_free_lseg_list(&freeme);
 }
 void pnfs_layoutreturn_free_lsegs(struct pnfs_layout_hdr *lo,
 		pnfs_mark_matching_lsegs_invalid(lo, &freeme, range, seq);
 		pnfs_free_returned_lsegs(lo, &freeme, range, seq);
 		pnfs_set_layout_stateid(lo, stateid, NULL, true);
+		pnfs_reset_return_info(lo);
 	} else
 		pnfs_mark_layout_stateid_invalid(lo, &freeme);
 out_unlock:
 		/* Was there an RPC level error? If not, retry */
 		if (task->tk_rpc_status == 0)
 			break;
+		/*
+		 * Is there a fatal network level error?
+		 * If so release the layout, but flag the error.
+		 */
+		if ((task->tk_rpc_status == -ENETDOWN ||
+		     task->tk_rpc_status == -ENETUNREACH) &&
+		    task->tk_flags & RPC_TASK_NETUNREACH_FATAL) {
+			*ret = 0;
+			(*respp)->lrs_present = 0;
+			retval = -EIO;
+			break;
+		}
 		/* If the call was not sent, let caller handle it */
 		if (!RPC_WAS_SENT(task))
 			return 0;
 	struct inode *inode = args->inode;
 	const nfs4_stateid *res_stateid = NULL;
 	struct nfs4_xdr_opaque_data *ld_private = args->ld_private;
+	LIST_HEAD(freeme);
 	switch (ret) {
 	case -NFS4ERR_BADSESSION:
 	case -NFS4ERR_NOMATCHING_LAYOUT:
 		spin_lock(&inode->i_lock);
 		pnfs_layoutreturn_retry_later_locked(lo, &args->stateid,
-						     &args->range);
+						     &args->range, &freeme);
-		pnfs_clear_layoutreturn_waitbit(lo);
 		spin_unlock(&inode->i_lock);
+		pnfs_free_lseg_list(&freeme);
 		break;
 	case 0:
 		if (res->lrs_present)

fs/nfs/pnfs.h+3−1

 	struct list_head	ds_node;  /* nfs4_pnfs_dev_hlist dev_dslist */
 	char			*ds_remotestr;	/* comma sep list of addrs */
 	struct list_head	ds_addrs;
+	const struct net	*ds_net;
 	struct nfs_client	*ds_clp;
 	refcount_t		ds_count;
 	unsigned long		ds_state;
 int pnfs_generic_scan_commit_lists(struct nfs_commit_info *cinfo, int max);
 void pnfs_generic_write_commit_done(struct rpc_task *task, void *data);
 void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds);
-struct nfs4_pnfs_ds *nfs4_pnfs_ds_add(struct list_head *dsaddrs,
+struct nfs4_pnfs_ds *nfs4_pnfs_ds_add(const struct net *net,
+				      struct list_head *dsaddrs,
 				      gfp_t gfp_flags);
 void nfs4_pnfs_v3_ds_connect_unload(void);
 int nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds,

fs/nfs/pnfs_nfs.c+18−14

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include "nfs4session.h"	16	#include "nfs4session.h"
17	#include "internal.h"	17	#include "internal.h"
18	#include "pnfs.h"	18	#include "pnfs.h"
		19	#include "netns.h"
19		20
20	#define NFSDBG_FACILITY NFSDBG_PNFS	21	#define NFSDBG_FACILITY NFSDBG_PNFS
21		22
@@ -504,14 +505,14 @@ EXPORT_SYMBOL_GPL(pnfs_generic_commit_pagelist); · 482 unmodified lines
504	/*	505	/*
505	* Data server cache	506	* Data server cache
506	*	507	*
507	* Data servers can be mapped to different device ids.	508	* Data servers can be mapped to different device ids, but should
508	* nfs4_pnfs_ds reference counting	509	* never be shared between net namespaces.
		510	*
		511	* nfs4_pnfs_ds reference counting:
509	* - set to 1 on allocation	512	* - set to 1 on allocation
510	* - incremented when a device id maps a data server already in the cache.	513	* - incremented when a device id maps a data server already in the cache.
511	* - decremented when deviceid is removed from the cache.	514	* - decremented when deviceid is removed from the cache.
512	*/	515	*/
513	static DEFINE_SPINLOCK(nfs4_ds_cache_lock);
514	static LIST_HEAD(nfs4_data_server_cache);
515		516
516	/* Debug routines */	517	/* Debug routines */
517	static void	518	static void
@@ -604,11 +605,11 @@ _same_data_server_addrs_locked(const struct list_head *dsaddrs1, · 86 unmodified lines
604	* Lookup DS by addresses. nfs4_ds_cache_lock is held	605	* Lookup DS by addresses. nfs4_ds_cache_lock is held
605	*/	606	*/
606	static struct nfs4_pnfs_ds *	607	static struct nfs4_pnfs_ds *
607	_data_server_lookup_locked(const struct list_head *dsaddrs)	608	_data_server_lookup_locked(const struct nfs_net nn, const struct list_head dsaddrs)
608	{	609	{
609	struct nfs4_pnfs_ds *ds;	610	struct nfs4_pnfs_ds *ds;
610		611
611	list_for_each_entry(ds, &nfs4_data_server_cache, ds_node)	612	list_for_each_entry(ds, &nn->nfs4_data_server_cache, ds_node)
612	if (_same_data_server_addrs_locked(&ds->ds_addrs, dsaddrs))	613	if (_same_data_server_addrs_locked(&ds->ds_addrs, dsaddrs))
613	return ds;	614	return ds;
614	return NULL;	615	return NULL;
@@ -653,10 +654,11 @@ static void destroy_ds(struct nfs4_pnfs_ds *ds) · 38 unmodified lines
653		654
654	void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds)	655	void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds)
655	{	656	{
656	if (refcount_dec_and_lock(&ds->ds_count,	657	struct nfs_net *nn = net_generic(ds->ds_net, nfs_net_id);
657	&nfs4_ds_cache_lock)) {	658
		659	if (refcount_dec_and_lock(&ds->ds_count, &nn->nfs4_data_server_lock)) {
658	list_del_init(&ds->ds_node);	660	list_del_init(&ds->ds_node);
659	spin_unlock(&nfs4_ds_cache_lock);	661	spin_unlock(&nn->nfs4_data_server_lock);
660	destroy_ds(ds);	662	destroy_ds(ds);
661	}	663	}
662	}	664	}
@@ -716,8 +718,9 @@ out_err: · 53 unmodified lines
716	* uncached and return cached struct nfs4_pnfs_ds.	718	* uncached and return cached struct nfs4_pnfs_ds.
717	*/	719	*/
718	struct nfs4_pnfs_ds *	720	struct nfs4_pnfs_ds *
719	nfs4_pnfs_ds_add(struct list_head *dsaddrs, gfp_t gfp_flags)	721	nfs4_pnfs_ds_add(const struct net net, struct list_head dsaddrs, gfp_t gfp_flags)
720	{	722	{
		723	struct nfs_net *nn = net_generic(net, nfs_net_id);
721	struct nfs4_pnfs_ds tmp_ds, ds = NULL;	724	struct nfs4_pnfs_ds tmp_ds, ds = NULL;
722	char *remotestr;	725	char *remotestr;
723		726
@@ -733,16 +736,17 @@ nfs4_pnfs_ds_add(struct list_head *dsaddrs, gfp_t gfp_flags) · 9 unmodified lines
733	/* this is only used for debugging, so it's ok if its NULL */	736	/* this is only used for debugging, so it's ok if its NULL */
734	remotestr = nfs4_pnfs_remotestr(dsaddrs, gfp_flags);	737	remotestr = nfs4_pnfs_remotestr(dsaddrs, gfp_flags);
735		738
736	spin_lock(&nfs4_ds_cache_lock);	739	spin_lock(&nn->nfs4_data_server_lock);
737	tmp_ds = _data_server_lookup_locked(dsaddrs);	740	tmp_ds = _data_server_lookup_locked(nn, dsaddrs);
738	if (tmp_ds == NULL) {	741	if (tmp_ds == NULL) {
739	INIT_LIST_HEAD(&ds->ds_addrs);	742	INIT_LIST_HEAD(&ds->ds_addrs);
740	list_splice_init(dsaddrs, &ds->ds_addrs);	743	list_splice_init(dsaddrs, &ds->ds_addrs);
741	ds->ds_remotestr = remotestr;	744	ds->ds_remotestr = remotestr;
742	refcount_set(&ds->ds_count, 1);	745	refcount_set(&ds->ds_count, 1);
743	INIT_LIST_HEAD(&ds->ds_node);	746	INIT_LIST_HEAD(&ds->ds_node);
		747	ds->ds_net = net;
744	ds->ds_clp = NULL;	748	ds->ds_clp = NULL;
745	list_add(&ds->ds_node, &nfs4_data_server_cache);	749	list_add(&ds->ds_node, &nn->nfs4_data_server_cache);
746	dprintk("%s add new data server %s\n", __func__,	750	dprintk("%s add new data server %s\n", __func__,
747	ds->ds_remotestr);	751	ds->ds_remotestr);
748	} else {	752	} else {
@@ -754,7 +758,7 @@ nfs4_pnfs_ds_add(struct list_head *dsaddrs, gfp_t gfp_flags) · 5 unmodified lines
754	refcount_read(&tmp_ds->ds_count));	758	refcount_read(&tmp_ds->ds_count));
755	ds = tmp_ds;	759	ds = tmp_ds;
756	}	760	}
757	spin_unlock(&nfs4_ds_cache_lock);	761	spin_unlock(&nn->nfs4_data_server_lock);
758	out:	762	out:
759	return ds;	763	return ds;
760	}	764	}

fs/smb/client/file.c+4−2

 	server = cifs_pick_channel(tlink_tcon(req->cfile->tlink)->ses);
 	rdata->server = server;
-	cifs_negotiate_rsize(server, cifs_sb->ctx,
+	if (cifs_sb->ctx->rsize == 0) {
-			     tlink_tcon(req->cfile->tlink));
+		cifs_negotiate_rsize(server, cifs_sb->ctx,
+				     tlink_tcon(req->cfile->tlink));
+	}
 	rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
 					   &size, &rdata->credits);

fs/smb/client/smb2pdu.c+1−1

@@ -2968,7 +2968,7 @@ replay_again: · 2967 unmodified lines
2968	/* Eventually save off posix specific response info and timestamps */	2968	/* Eventually save off posix specific response info and timestamps */
2969		2969
2970	err_free_rsp_buf:	2970	err_free_rsp_buf:
2971	free_rsp_buf(resp_buftype, rsp);	2971	free_rsp_buf(resp_buftype, rsp_iov.iov_base);
2972	kfree(pc_buf);	2972	kfree(pc_buf);
2973	err_free_req:	2973	err_free_req:
2974	cifs_small_buf_release(req);	2974	cifs_small_buf_release(req);

fs/udf/truncate.c+1−1

@@ -115,7 +115,7 @@ void udf_truncate_tail_extent(struct inode *inode) · 114 unmodified lines
115	}	115	}
116	/* This inode entry is in-memory only and thus we don't have to mark	116	/* This inode entry is in-memory only and thus we don't have to mark
117	* the inode dirty */	117	* the inode dirty */
118	if (ret == 0)	118	if (ret >= 0)
119	iinfo->i_lenExtents = inode->i_size;	119	iinfo->i_lenExtents = inode->i_size;
120	brelse(epos.bh);	120	brelse(epos.bh);
121	}	121	}

fs/xattr.c+24−0

@@ -1428,6 +1428,15 @@ static bool xattr_is_trusted(const char *name) · 1427 unmodified lines
1428	return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);	1428	return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
1429	}	1429	}
1430		1430
		1431	static bool xattr_is_maclabel(const char *name)
		1432	{
		1433	const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
		1434
		1435	return !strncmp(name, XATTR_SECURITY_PREFIX,
		1436	XATTR_SECURITY_PREFIX_LEN) &&
		1437	security_ismaclabel(suffix);
		1438	}
		1439
1431	/**	1440	/**
1432	* simple_xattr_list - list all xattr objects	1441	* simple_xattr_list - list all xattr objects
1433	* @inode: inode from which to get the xattrs	1442	* @inode: inode from which to get the xattrs
@@ -1460,6 +1469,17 @@ ssize_t simple_xattr_list(struct inode inode, struct simple_xattrs xattrs, · 26 unmodified lines
1460	if (err)	1469	if (err)
1461	return err;	1470	return err;
1462		1471
		1472	err = security_inode_listsecurity(inode, buffer, remaining_size);
		1473	if (err < 0)
		1474	return err;
		1475
		1476	if (buffer) {
		1477	if (remaining_size < err)
		1478	return -ERANGE;
		1479	buffer += err;
		1480	}
		1481	remaining_size -= err;
		1482
1463	read_lock(&xattrs->lock);	1483	read_lock(&xattrs->lock);
1464	for (rbp = rb_first(&xattrs->rb_root); rbp; rbp = rb_next(rbp)) {	1484	for (rbp = rb_first(&xattrs->rb_root); rbp; rbp = rb_next(rbp)) {
1465	xattr = rb_entry(rbp, struct simple_xattr, rb_node);	1485	xattr = rb_entry(rbp, struct simple_xattr, rb_node);
@@ -1468,6 +1488,10 @@ ssize_t simple_xattr_list(struct inode inode, struct simple_xattrs xattrs, · 2 unmodified lines
1468	if (!trusted && xattr_is_trusted(xattr->name))	1488	if (!trusted && xattr_is_trusted(xattr->name))
1469	continue;	1489	continue;
1470		1490
		1491	/* skip MAC labels; these are provided by LSM above */
		1492	if (xattr_is_maclabel(xattr->name))
		1493	continue;
		1494
1471	err = xattr_list_one(&buffer, &remaining_size, xattr->name);	1495	err = xattr_list_one(&buffer, &remaining_size, xattr->name);
1472	if (err)	1496	if (err)
1473	break;	1497	break;

fs/xfs/xfs_super.c+27−1

@@ -1149,7 +1149,7 @@ xfs_init_percpu_counters( · 1148 unmodified lines
1149	return 0;	1149	return 0;
1150		1150
1151	free_freecounters:	1151	free_freecounters:
1152	while (--i > 0)	1152	while (--i >= 0)
1153	percpu_counter_destroy(&mp->m_free[i].count);	1153	percpu_counter_destroy(&mp->m_free[i].count);
1154	percpu_counter_destroy(&mp->m_delalloc_rtextents);	1154	percpu_counter_destroy(&mp->m_delalloc_rtextents);
1155	free_delalloc:	1155	free_delalloc:
@@ -2114,6 +2114,21 @@ xfs_fs_reconfigure( · 958 unmodified lines
2114	if (error)	2114	if (error)
2115	return error;	2115	return error;
2116		2116
		2117	/* attr2 -> noattr2 */
		2118	if (xfs_has_noattr2(new_mp)) {
		2119	if (xfs_has_crc(mp)) {
		2120	xfs_warn(mp,
		2121	"attr2 is always enabled for a V5 filesystem - can't be changed.");
		2122	return -EINVAL;
		2123	}
		2124	mp->m_features &= ~XFS_FEAT_ATTR2;
		2125	mp->m_features \|= XFS_FEAT_NOATTR2;
		2126	} else if (xfs_has_attr2(new_mp)) {
		2127	/* noattr2 -> attr2 */
		2128	mp->m_features &= ~XFS_FEAT_NOATTR2;
		2129	mp->m_features \|= XFS_FEAT_ATTR2;
		2130	}
		2131
2117	/* inode32 -> inode64 */	2132	/* inode32 -> inode64 */
2118	if (xfs_has_small_inums(mp) && !xfs_has_small_inums(new_mp)) {	2133	if (xfs_has_small_inums(mp) && !xfs_has_small_inums(new_mp)) {
2119	mp->m_features &= ~XFS_FEAT_SMALL_INUMS;	2134	mp->m_features &= ~XFS_FEAT_SMALL_INUMS;
@@ -2126,6 +2141,17 @@ xfs_fs_reconfigure( · 6 unmodified lines
2126	mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount);	2141	mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount);
2127	}	2142	}
2128		2143
		2144	/*
		2145	* Now that mp has been modified according to the remount options, we
		2146	* do a final option validation with xfs_finish_flags() just like it is
		2147	* just like it is done during mount. We cannot use
		2148	* done during mount. We cannot use xfs_finish_flags() on new_mp as it
		2149	* contains only the user given options.
		2150	*/
		2151	error = xfs_finish_flags(mp);
		2152	if (error)
		2153	return error;
		2154
2129	/* ro -> rw */	2155	/* ro -> rw */
2130	if (xfs_is_readonly(mp) && !(flags & SB_RDONLY)) {	2156	if (xfs_is_readonly(mp) && !(flags & SB_RDONLY)) {
2131	error = xfs_remount_rw(mp);	2157	error = xfs_remount_rw(mp);

fs/xfs/xfs_trans_ail.c+18−16

 }
 /*
- * Delete the given item from the AIL.  Return a pointer to the item.
+ * Delete the given item from the AIL.
  */
 static void
 xfs_ail_delete(
 }
 /*
- * xfs_trans_ail_update - bulk AIL insertion operation.
+ * xfs_trans_ail_update_bulk - bulk AIL insertion operation.
  *
- * @xfs_trans_ail_update takes an array of log items that all need to be
+ * @xfs_trans_ail_update_bulk takes an array of log items that all need to be
  * positioned at the same LSN in the AIL. If an item is not in the AIL, it will
- * be added.  Otherwise, it will be repositioned  by removing it and re-adding
+ * be added. Otherwise, it will be repositioned by removing it and re-adding
- * it to the AIL. If we move the first item in the AIL, update the log tail to
+ * it to the AIL.
- * match the new minimum LSN in the AIL.
  *
- * This function takes the AIL lock once to execute the update operations on
+ * If we move the first item in the AIL, update the log tail to match the new
- * all the items in the array, and as such should not be called with the AIL
+ * minimum LSN in the AIL.
- * lock held. As a result, once we have the AIL lock, we need to check each log
- * item LSN to confirm it needs to be moved forward in the AIL.
  *
- * To optimise the insert operation, we delete all the items from the AIL in
+ * This function should be called with the AIL lock held.
- * the first pass, moving them into a temporary list, then splice the temporary
- * list into the correct position in the AIL. This avoids needing to do an
- * insert operation on every item.
  *
- * This function must be called with the AIL lock held.  The lock is dropped
+ * To optimise the insert operation, we add all items to a temporary list, then
- * before returning.
+ * splice this list into the correct position in the AIL.
+ *
+ * Items that are already in the AIL are first deleted from their current
+ * location before being added to the temporary list.
+ *
+ * This avoids needing to do an insert operation on every item.
+ *
+ * The AIL lock is dropped by xfs_ail_update_finish() before returning to
+ * the caller.
  */
 void
 xfs_trans_ail_update_bulk(

fs/xfs/xfs_zone_gc.c+3−2

 {
 	struct xfs_zone_gc_data	*data = chunk->data;
 	struct xfs_mount	*mp = chunk->ip->i_mount;
-	unsigned int		folio_offset = chunk->bio.bi_io_vec->bv_offset;
+	phys_addr_t		bvec_paddr =
+		bvec_phys(bio_first_bvec_all(&chunk->bio));
 	struct xfs_gc_bio	*split_chunk;
 	if (chunk->bio.bi_status)
 	bio_reset(&chunk->bio, mp->m_rtdev_targp->bt_bdev, REQ_OP_WRITE);
 	bio_add_folio_nofail(&chunk->bio, chunk->scratch->folio, chunk->len,
-			folio_offset);
+			offset_in_folio(chunk->scratch->folio, bvec_paddr));
 	while ((split_chunk = xfs_zone_gc_split_write(data, chunk)))
 		xfs_zone_gc_submit_write(data, split_chunk);

include/drm/drm_gpusvm.h+33−14

  * @ops: Pointer to the operations structure for GPU SVM device memory
  * @dpagemap: The struct drm_pagemap of the pages this allocation belongs to.
  * @size: Size of device memory allocation
+ * @timeslice_expiration: Timeslice expiration in jiffies
  */
 struct drm_gpusvm_devmem {
 	struct device *dev;
 	const struct drm_gpusvm_devmem_ops *ops;
 	struct drm_pagemap *dpagemap;
 	size_t size;
+	u64 timeslice_expiration;
 };
 /**
 	} flags;
 };
+/**
+ * struct drm_gpusvm_range_flags - Structure representing a GPU SVM range flags
+ *
+ * @migrate_devmem: Flag indicating whether the range can be migrated to device memory
+ * @unmapped: Flag indicating if the range has been unmapped
+ * @partial_unmap: Flag indicating if the range has been partially unmapped
+ * @has_devmem_pages: Flag indicating if the range has devmem pages
+ * @has_dma_mapping: Flag indicating if the range has a DMA mapping
+ * @__flags: Flags for range in u16 form (used for READ_ONCE)
+ */
+struct drm_gpusvm_range_flags {
+	union {
+		struct {
+			/* All flags below must be set upon creation */
+			u16 migrate_devmem : 1;
+			/* All flags below must be set / cleared under notifier lock */
+			u16 unmapped : 1;
+			u16 partial_unmap : 1;
+			u16 has_devmem_pages : 1;
+			u16 has_dma_mapping : 1;
+		};
+		u16 __flags;
+	};
+};
 /**
  * struct drm_gpusvm_range - Structure representing a GPU SVM range
  *
  * @dpagemap: The struct drm_pagemap of the device pages we're dma-mapping.
  *            Note this is assuming only one drm_pagemap per range is allowed.
  * @flags: Flags for range
- * @flags.migrate_devmem: Flag indicating whether the range can be migrated to device memory
- * @flags.unmapped: Flag indicating if the range has been unmapped
- * @flags.partial_unmap: Flag indicating if the range has been partially unmapped
- * @flags.has_devmem_pages: Flag indicating if the range has devmem pages
- * @flags.has_dma_mapping: Flag indicating if the range has a DMA mapping
  *
  * This structure represents a GPU SVM range used for tracking memory ranges
  * mapped in a DRM device.
 	unsigned long notifier_seq;
 	struct drm_pagemap_device_addr *dma_addr;
 	struct drm_pagemap *dpagemap;
-	struct {
+	struct drm_gpusvm_range_flags flags;
-		/* All flags below must be set upon creation */
-		u16 migrate_devmem : 1;
-		/* All flags below must be set / cleared under notifier lock */
-		u16 unmapped : 1;
-		u16 partial_unmap : 1;
-		u16 has_devmem_pages : 1;
-		u16 has_dma_mapping : 1;
-	} flags;
 };
 /**
  * @check_pages_threshold: Check CPU pages for present if chunk is less than or
  *                         equal to threshold. If not present, reduce chunk
  *                         size.
+ * @timeslice_ms: The timeslice MS which in minimum time a piece of memory
+ *		  remains with either exclusive GPU or CPU access.
  * @in_notifier: entering from a MMU notifier
  * @read_only: operating on read-only memory
  * @devmem_possible: possible to use device memory
+ * @devmem_only: use only device memory
  *
  * Context that is DRM GPUSVM is operating in (i.e. user arguments).
  */
 struct drm_gpusvm_ctx {
 	unsigned long check_pages_threshold;
+	unsigned long timeslice_ms;
 	unsigned int in_notifier :1;
 	unsigned int read_only :1;
 	unsigned int devmem_possible :1;
+	unsigned int devmem_only :1;
 };
 int drm_gpusvm_init(struct drm_gpusvm *gpusvm,

include/linux/bio.h+1−0

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include <linux/uio.h>	11	#include <linux/uio.h>
12		12
13	#define BIO_MAX_VECS 256U	13	#define BIO_MAX_VECS 256U
		14	#define BIO_MAX_INLINE_VECS UIO_MAXIOV
14		15
15	struct queue_limits;	16	struct queue_limits;
16		17

include/linux/hyperv.h+0−7

@@ -1167,13 +1167,6 @@ extern int vmbus_sendpacket(struct vmbus_channel *channel, · 1166 unmodified lines
1167	enum vmbus_packet_type type,	1167	enum vmbus_packet_type type,
1168	u32 flags);	1168	u32 flags);
1169		1169
1170	extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
1171	struct hv_page_buffer pagebuffers[],
1172	u32 pagecount,
1173	void *buffer,
1174	u32 bufferlen,
1175	u64 requestid);
1176
1177	extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,	1170	extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,
1178	struct vmbus_packet_mpb_array *mpb,	1171	struct vmbus_packet_mpb_array *mpb,
1179	u32 desc_size,	1172	u32 desc_size,

include/linux/micrel_phy.h+0−1

@@ -44,7 +44,6 @@ · 43 unmodified lines
44	#define MICREL_PHY_50MHZ_CLK BIT(0)	44	#define MICREL_PHY_50MHZ_CLK BIT(0)
45	#define MICREL_PHY_FXEN BIT(1)	45	#define MICREL_PHY_FXEN BIT(1)
46	#define MICREL_KSZ8_P1_ERRATA BIT(2)	46	#define MICREL_KSZ8_P1_ERRATA BIT(2)
47	#define MICREL_NO_EEE BIT(3)
48		47
49	#define MICREL_KSZ9021_EXTREG_CTRL 0xB	48	#define MICREL_KSZ9021_EXTREG_CTRL 0xB
50	#define MICREL_KSZ9021_EXTREG_DATA_WRITE 0xC	49	#define MICREL_KSZ9021_EXTREG_DATA_WRITE 0xC

include/linux/nfs_fs_sb.h+9−3

 	char			*fscache_uniq;	/* Uniquifier (or NULL) */
 #endif
+	/* The following #defines numerically match the NFSv4 equivalents */
+#define NFS_FH_NOEXPIRE_WITH_OPEN (0x1)
+#define NFS_FH_VOLATILE_ANY (0x2)
+#define NFS_FH_VOL_MIGRATION (0x4)
+#define NFS_FH_VOL_RENAME (0x8)
+#define NFS_FH_RENAME_UNSAFE (NFS_FH_VOLATILE_ANY | NFS_FH_VOL_RENAME)
+	u32			fh_expire_type;	/* V4 bitmask representing file
+						   handle volatility type for
+						   this filesystem */
 	u32			pnfs_blksize;	/* layout_blksize attr */
 #if IS_ENABLED(CONFIG_NFS_V4)
 	u32			attr_bitmask[3];/* V4 bitmask representing the set
 	u32			acl_bitmask;	/* V4 bitmask representing the ACEs
 						   that are supported on this
 						   filesystem */
-	u32			fh_expire_type;	/* V4 bitmask representing file
-						   handle volatility type for
-						   this filesystem */
 	struct pnfs_layoutdriver_type  *pnfs_curr_ld; /* Active layout driver */
 	struct rpc_wait_queue	roc_rpcwaitq;
 	void			*pnfs_ld_data;	/* per mount point data */

include/linux/pgalloc_tag.h+8−0

 	return tag;
 }
+static inline struct alloc_tag *pgalloc_tag_get(struct page *page)
+{
+	if (mem_alloc_profiling_enabled())
+		return __pgalloc_tag_get(page);
+	return NULL;
+}
 void pgalloc_tag_split(struct folio *folio, int old_order, int new_order);
 void pgalloc_tag_swap(struct folio *new, struct folio *old);
 static inline void alloc_tag_sec_init(void) {}
 static inline void pgalloc_tag_split(struct folio *folio, int old_order, int new_order) {}
 static inline void pgalloc_tag_swap(struct folio *new, struct folio *old) {}
+static inline struct alloc_tag *pgalloc_tag_get(struct page *page) { return NULL; }
 #endif /* CONFIG_MEM_ALLOC_PROFILING */

include/linux/soundwire/sdw_intel.h+1−1

@@ -365,7 +365,7 @@ struct sdw_intel_res { · 364 unmodified lines
365	* on e.g. which machine driver to select (I2S mode, HDaudio or	365	* on e.g. which machine driver to select (I2S mode, HDaudio or
366	* SoundWire).	366	* SoundWire).
367	*/	367	*/
368	int sdw_intel_acpi_scan(acpi_handle *parent_handle,	368	int sdw_intel_acpi_scan(acpi_handle parent_handle,
369	struct sdw_intel_acpi_info *info);	369	struct sdw_intel_acpi_info *info);
370		370
371	void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx);	371	void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx);

include/linux/tpm.h+20−1

 enum tpm2_timeouts {
 	TPM2_TIMEOUT_A          =    750,
-	TPM2_TIMEOUT_B          =   2000,
+	TPM2_TIMEOUT_B          =   4000,
 	TPM2_TIMEOUT_C          =    200,
 	TPM2_TIMEOUT_D          =     30,
 	TPM2_DURATION_SHORT     =     20,
 	TPM2_RC_TESTING		= 0x090A, /* RC_WARN */
 	TPM2_RC_REFERENCE_H0	= 0x0910,
 	TPM2_RC_RETRY		= 0x0922,
+	TPM2_RC_SESSION_MEMORY	= 0x0903,
 };
 enum tpm2_command_codes {
 	return (rc & BIT(7)) ? rc & 0xbf : rc;
 }
+/*
+ * Convert a return value from tpm_transmit_cmd() to POSIX error code.
+ */
+static inline ssize_t tpm_ret_to_err(ssize_t ret)
+{
+	if (ret < 0)
+		return ret;
+	switch (tpm2_rc_value(ret)) {
+	case TPM2_RC_SUCCESS:
+		return 0;
+	case TPM2_RC_SESSION_MEMORY:
+		return -ENOMEM;
+	default:
+		return -EFAULT;
+	}
+}
 #if defined(CONFIG_TCG_TPM) || defined(CONFIG_TCG_TPM_MODULE)
 extern int tpm_is_tpm2(struct tpm_chip *chip);

include/net/bluetooth/hci_core.h+1−0

@@ -1798,6 +1798,7 @@ struct hci_conn_params hci_pend_le_action_lookup(struct list_head list, · 1797 unmodified lines
1798	void hci_uuids_clear(struct hci_dev *hdev);	1798	void hci_uuids_clear(struct hci_dev *hdev);
1799		1799
1800	void hci_link_keys_clear(struct hci_dev *hdev);	1800	void hci_link_keys_clear(struct hci_dev *hdev);
		1801	u8 hci_conn_key_enc_size(struct hci_conn conn);
1801	struct link_key hci_find_link_key(struct hci_dev hdev, bdaddr_t *bdaddr);	1802	struct link_key hci_find_link_key(struct hci_dev hdev, bdaddr_t *bdaddr);
1802	struct link_key hci_add_link_key(struct hci_dev hdev, struct hci_conn *conn,	1803	struct link_key hci_add_link_key(struct hci_dev hdev, struct hci_conn *conn,
1803	bdaddr_t bdaddr, u8 val, u8 type,	1804	bdaddr_t bdaddr, u8 val, u8 type,

include/net/sch_generic.h+15−0

@@ -1031,6 +1031,21 @@ static inline struct sk_buff __qdisc_dequeue_head(struct qdisc_skb_head qh) · 1030 unmodified lines
1031	return skb;	1031	return skb;
1032	}	1032	}
1033		1033
		1034	static inline struct sk_buff qdisc_dequeue_internal(struct Qdisc sch, bool direct)
		1035	{
		1036	struct sk_buff *skb;
		1037
		1038	skb = __skb_dequeue(&sch->gso_skb);
		1039	if (skb) {
		1040	sch->q.qlen--;
		1041	return skb;
		1042	}
		1043	if (direct)
		1044	return __qdisc_dequeue_head(&sch->q);
		1045	else
		1046	return sch->dequeue(sch);
		1047	}
		1048
1034	static inline struct sk_buff qdisc_dequeue_head(struct Qdisc sch)	1049	static inline struct sk_buff qdisc_dequeue_head(struct Qdisc sch)
1035	{	1050	{
1036	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);	1051	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);

include/sound/ump_msg.h+2−2

@@ -604,7 +604,7 @@ struct snd_ump_stream_msg_ep_info { · 603 unmodified lines
604	} __packed;	604	} __packed;
605		605
606	/* UMP Stream Message: Device Info Notification (128bit) */	606	/* UMP Stream Message: Device Info Notification (128bit) */
607	struct snd_ump_stream_msg_devince_info {	607	struct snd_ump_stream_msg_device_info {
608	#ifdef __BIG_ENDIAN_BITFIELD	608	#ifdef __BIG_ENDIAN_BITFIELD
609	/* 0 */	609	/* 0 */
610	u32 type:4;	610	u32 type:4;
@@ -754,7 +754,7 @@ struct snd_ump_stream_msg_fb_name { · 143 unmodified lines
754	union snd_ump_stream_msg {	754	union snd_ump_stream_msg {
755	struct snd_ump_stream_msg_ep_discovery ep_discovery;	755	struct snd_ump_stream_msg_ep_discovery ep_discovery;
756	struct snd_ump_stream_msg_ep_info ep_info;	756	struct snd_ump_stream_msg_ep_info ep_info;
757	struct snd_ump_stream_msg_devince_info device_info;	757	struct snd_ump_stream_msg_device_info device_info;
758	struct snd_ump_stream_msg_stream_cfg stream_cfg;	758	struct snd_ump_stream_msg_stream_cfg stream_cfg;
759	struct snd_ump_stream_msg_fb_discovery fb_discovery;	759	struct snd_ump_stream_msg_fb_discovery fb_discovery;
760	struct snd_ump_stream_msg_fb_info fb_info;	760	struct snd_ump_stream_msg_fb_info fb_info;

init/Kconfig+0−5

 	default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m64-flag)) if 64BIT
 	default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m32-flag))
-config CC_CAN_LINK_STATIC
-	bool
-	default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m64-flag) -static) if 64BIT
-	default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m32-flag) -static)
 # Fixed in GCC 14, 13.3, 12.4 and 11.5
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113921
 config GCC_ASM_GOTO_OUTPUT_BROKEN

io_uring/fdinfo.c+25−23

 }
 #endif
-/*
+static void __io_uring_show_fdinfo(struct io_ring_ctx *ctx, struct seq_file *m)
- * Caller holds a reference to the file already, we don't need to do
- * anything else to get an extra reference.
- */
-__cold void io_uring_show_fdinfo(struct seq_file *m, struct file *file)
 {
-	struct io_ring_ctx *ctx = file->private_data;
 	struct io_overflow_cqe *ocqe;
 	struct io_rings *r = ctx->rings;
 	struct rusage sq_usage;
 	unsigned int sq_entries, cq_entries;
 	int sq_pid = -1, sq_cpu = -1;
 	u64 sq_total_time = 0, sq_work_time = 0;
-	bool has_lock;
 	unsigned int i;
 	if (ctx->flags & IORING_SETUP_CQE32)
 		seq_printf(m, "\n");
 	}
-	/*
+	if (ctx->flags & IORING_SETUP_SQPOLL) {
-	 * Avoid ABBA deadlock between the seq lock and the io_uring mutex,
-	 * since fdinfo case grabs it in the opposite direction of normal use
-	 * cases. If we fail to get the lock, we just don't iterate any
-	 * structures that could be going away outside the io_uring mutex.
-	 */
-	has_lock = mutex_trylock(&ctx->uring_lock);
-	if (has_lock && (ctx->flags & IORING_SETUP_SQPOLL)) {
 		struct io_sq_data *sq = ctx->sq_data;
 		/*
 	seq_printf(m, "SqTotalTime:\t%llu\n", sq_total_time);
 	seq_printf(m, "SqWorkTime:\t%llu\n", sq_work_time);
 	seq_printf(m, "UserFiles:\t%u\n", ctx->file_table.data.nr);
-	for (i = 0; has_lock && i < ctx->file_table.data.nr; i++) {
+	for (i = 0; i < ctx->file_table.data.nr; i++) {
 		struct file *f = NULL;
 		if (ctx->file_table.data.nodes[i])
 		}
 	}
 	seq_printf(m, "UserBufs:\t%u\n", ctx->buf_table.nr);
-	for (i = 0; has_lock && i < ctx->buf_table.nr; i++) {
+	for (i = 0; i < ctx->buf_table.nr; i++) {
 		struct io_mapped_ubuf *buf = NULL;
 		if (ctx->buf_table.nodes[i])
 		else
 			seq_printf(m, "%5u: <none>\n", i);
 	}
-	if (has_lock && !xa_empty(&ctx->personalities)) {
+	if (!xa_empty(&ctx->personalities)) {
 		unsigned long index;
 		const struct cred *cred;
 	}
 	seq_puts(m, "PollList:\n");
-	for (i = 0; has_lock && i < (1U << ctx->cancel_table.hash_bits); i++) {
+	for (i = 0; i < (1U << ctx->cancel_table.hash_bits); i++) {
 		struct io_hash_bucket *hb = &ctx->cancel_table.hbs[i];
 		struct io_kiocb *req;
 					task_work_pending(req->tctx->task));
 	}
-	if (has_lock)
-		mutex_unlock(&ctx->uring_lock);
 	seq_puts(m, "CqOverflowList:\n");
 	spin_lock(&ctx->completion_lock);
 	list_for_each_entry(ocqe, &ctx->cq_overflow_list, list) {
 	spin_unlock(&ctx->completion_lock);
 	napi_show_fdinfo(ctx, m);
 }
+/*
+ * Caller holds a reference to the file already, we don't need to do
+ * anything else to get an extra reference.
+ */
+__cold void io_uring_show_fdinfo(struct seq_file *m, struct file *file)
+{
+	struct io_ring_ctx *ctx = file->private_data;
+	/*
+	 * Avoid ABBA deadlock between the seq lock and the io_uring mutex,
+	 * since fdinfo case grabs it in the opposite direction of normal use
+	 * cases.
+	 */
+	if (mutex_trylock(&ctx->uring_lock)) {
+		__io_uring_show_fdinfo(ctx, m);
+		mutex_unlock(&ctx->uring_lock);
+	}
+}
 #endif

io_uring/memmap.c+1−1

@@ -116,7 +116,7 @@ static int io_region_init_ptr(struct io_mapped_region *mr) · 115 unmodified lines
116	void *ptr;	116	void *ptr;
117		117
118	if (io_check_coalesce_buffer(mr->pages, mr->nr_pages, &ifd)) {	118	if (io_check_coalesce_buffer(mr->pages, mr->nr_pages, &ifd)) {
119	if (ifd.nr_folios == 1) {	119	if (ifd.nr_folios == 1 && !PageHighMem(mr->pages[0])) {
120	mr->ptr = page_address(mr->pages[0]);	120	mr->ptr = page_address(mr->pages[0]);
121	return 0;	121	return 0;
122	}	122	}

io_uring/uring_cmd.c+5−0

 			return -EOPNOTSUPP;
 		issue_flags |= IO_URING_F_IOPOLL;
 		req->iopoll_completed = 0;
+		if (ctx->flags & IORING_SETUP_HYBRID_IOPOLL) {
+			/* make sure every req only blocks once */
+			req->flags &= ~REQ_F_IOPOLL_STATE;
+			req->iopoll_start = ktime_get_ns();
+		}
 	}
 	ret = file->f_op->uring_cmd(ioucmd, issue_flags);

kernel/cgroup/cpuset.c+4−2

 		if (top_cs) {
 			/*
-			 * Percpu kthreads in top_cpuset are ignored
+			 * PF_NO_SETAFFINITY tasks are ignored.
+			 * All per cpu kthreads should have PF_NO_SETAFFINITY
+			 * flag set, see kthread_set_per_cpu().
 			 */
-			if (kthread_is_per_cpu(task))
+			if (task->flags & PF_NO_SETAFFINITY)
 				continue;
 			cpumask_andnot(new_cpus, possible_mask, subpartitions_cpus);
 		} else {

kernel/fork.c+5−4

 	vma_numab_state_init(new);
 	dup_anon_vma_name(orig, new);
-	/* track_pfn_copy() will later take care of copying internal state. */
-	if (unlikely(new->vm_flags & VM_PFNMAP))
-		untrack_pfn_clear(new);
 	return new;
 }
 		tmp = vm_area_dup(mpnt);
 		if (!tmp)
 			goto fail_nomem;
+		/* track_pfn_copy() will later take care of copying internal state. */
+		if (unlikely(tmp->vm_flags & VM_PFNMAP))
+			untrack_pfn_clear(tmp);
 		retval = vma_dup_policy(mpnt, tmp);
 		if (retval)
 			goto fail_nomem_policy;

kernel/module/Kconfig+5−0

 	depends on !DEBUG_INFO_REDUCED && !DEBUG_INFO_SPLIT
 	# Requires ELF object files.
 	depends on !LTO
+	# To avoid conflicts with the discarded __gendwarfksyms_ptr symbols on
+	# X86, requires pahole before commit 47dcb534e253 ("btf_encoder: Stop
+	# indexing symbols for VARs") or after commit 9810758003ce ("btf_encoder:
+	# Verify 0 address DWARF variables are in ELF section").
+	depends on !X86 || !DEBUG_INFO_BTF || PAHOLE_VERSION < 128 || PAHOLE_VERSION > 129
 	help
 	  Calculate symbol versions from DWARF debugging information using
 	  gendwarfksyms. Requires DEBUG_INFO to be enabled.

kernel/sched/ext.c+123−68

 	current->scx.kf_mask &= ~mask;
 }
-#define SCX_CALL_OP(mask, op, args...)						\
+/*
+ * Track the rq currently locked.
+ *
+ * This allows kfuncs to safely operate on rq from any scx ops callback,
+ * knowing which rq is already locked.
+ */
+static DEFINE_PER_CPU(struct rq *, locked_rq);
+static inline void update_locked_rq(struct rq *rq)
+{
+	/*
+	 * Check whether @rq is actually locked. This can help expose bugs
+	 * or incorrect assumptions about the context in which a kfunc or
+	 * callback is executed.
+	 */
+	if (rq)
+		lockdep_assert_rq_held(rq);
+	__this_cpu_write(locked_rq, rq);
+}
+/*
+ * Return the rq currently locked from an scx callback, or NULL if no rq is
+ * locked.
+ */
+static inline struct rq *scx_locked_rq(void)
+{
+	return __this_cpu_read(locked_rq);
+}
+#define SCX_CALL_OP(mask, op, rq, args...)					\
 do {										\
+	update_locked_rq(rq);							\
 	if (mask) {								\
 		scx_kf_allow(mask);						\
 		scx_ops.op(args);						\
 	} else {								\
 		scx_ops.op(args);						\
 	}									\
+	update_locked_rq(NULL);							\
 } while (0)
-#define SCX_CALL_OP_RET(mask, op, args...)					\
+#define SCX_CALL_OP_RET(mask, op, rq, args...)					\
 ({										\
 	__typeof__(scx_ops.op(args)) __ret;					\
+										\
+	update_locked_rq(rq);							\
 	if (mask) {								\
 		scx_kf_allow(mask);						\
 		__ret = scx_ops.op(args);					\
 	} else {								\
 		__ret = scx_ops.op(args);					\
 	}									\
+	update_locked_rq(NULL);							\
 	__ret;									\
 })
  * scx_kf_allowed_on_arg_tasks() to test whether the invocation is allowed on
  * the specific task.
  */
-#define SCX_CALL_OP_TASK(mask, op, task, args...)				\
+#define SCX_CALL_OP_TASK(mask, op, rq, task, args...)				\
 do {										\
 	BUILD_BUG_ON((mask) & ~__SCX_KF_TERMINAL);				\
 	current->scx.kf_tasks[0] = task;					\
-	SCX_CALL_OP(mask, op, task, ##args);					\
+	SCX_CALL_OP(mask, op, rq, task, ##args);				\
 	current->scx.kf_tasks[0] = NULL;					\
 } while (0)
-#define SCX_CALL_OP_TASK_RET(mask, op, task, args...)				\
+#define SCX_CALL_OP_TASK_RET(mask, op, rq, task, args...)			\
 ({										\
 	__typeof__(scx_ops.op(task, ##args)) __ret;				\
 	BUILD_BUG_ON((mask) & ~__SCX_KF_TERMINAL);				\
 	current->scx.kf_tasks[0] = task;					\
-	__ret = SCX_CALL_OP_RET(mask, op, task, ##args);			\
+	__ret = SCX_CALL_OP_RET(mask, op, rq, task, ##args);			\
 	current->scx.kf_tasks[0] = NULL;					\
 	__ret;									\
 })
-#define SCX_CALL_OP_2TASKS_RET(mask, op, task0, task1, args...)			\
+#define SCX_CALL_OP_2TASKS_RET(mask, op, rq, task0, task1, args...)		\
 ({										\
 	__typeof__(scx_ops.op(task0, task1, ##args)) __ret;			\
 	BUILD_BUG_ON((mask) & ~__SCX_KF_TERMINAL);				\
 	current->scx.kf_tasks[0] = task0;					\
 	current->scx.kf_tasks[1] = task1;					\
-	__ret = SCX_CALL_OP_RET(mask, op, task0, task1, ##args);		\
+	__ret = SCX_CALL_OP_RET(mask, op, rq, task0, task1, ##args);		\
 	current->scx.kf_tasks[0] = NULL;					\
 	current->scx.kf_tasks[1] = NULL;					\
 	__ret;									\
 	WARN_ON_ONCE(*ddsp_taskp);
 	*ddsp_taskp = p;
-	SCX_CALL_OP_TASK(SCX_KF_ENQUEUE, enqueue, p, enq_flags);
+	SCX_CALL_OP_TASK(SCX_KF_ENQUEUE, enqueue, rq, p, enq_flags);
 	*ddsp_taskp = NULL;
 	if (p->scx.ddsp_dsq_id != SCX_DSQ_INVALID)
 	add_nr_running(rq, 1);
 	if (SCX_HAS_OP(runnable) && !task_on_rq_migrating(p))
-		SCX_CALL_OP_TASK(SCX_KF_REST, runnable, p, enq_flags);
+		SCX_CALL_OP_TASK(SCX_KF_REST, runnable, rq, p, enq_flags);
 	if (enq_flags & SCX_ENQ_WAKEUP)
 		touch_core_sched(rq, p);
 		__scx_add_event(SCX_EV_SELECT_CPU_FALLBACK, 1);
 }
-static void ops_dequeue(struct task_struct *p, u64 deq_flags)
+static void ops_dequeue(struct rq *rq, struct task_struct *p, u64 deq_flags)
 {
 	unsigned long opss;
 		BUG();
 	case SCX_OPSS_QUEUED:
 		if (SCX_HAS_OP(dequeue))
-			SCX_CALL_OP_TASK(SCX_KF_REST, dequeue, p, deq_flags);
+			SCX_CALL_OP_TASK(SCX_KF_REST, dequeue, rq, p, deq_flags);
 		if (atomic_long_try_cmpxchg(&p->scx.ops_state, &opss,
 					    SCX_OPSS_NONE))
 		return true;
 	}
-	ops_dequeue(p, deq_flags);
+	ops_dequeue(rq, p, deq_flags);
 	/*
 	 * A currently running task which is going off @rq first gets dequeued
 	 */
 	if (SCX_HAS_OP(stopping) && task_current(rq, p)) {
 		update_curr_scx(rq);
-		SCX_CALL_OP_TASK(SCX_KF_REST, stopping, p, false);
+		SCX_CALL_OP_TASK(SCX_KF_REST, stopping, rq, p, false);
 	}
 	if (SCX_HAS_OP(quiescent) && !task_on_rq_migrating(p))
-		SCX_CALL_OP_TASK(SCX_KF_REST, quiescent, p, deq_flags);
+		SCX_CALL_OP_TASK(SCX_KF_REST, quiescent, rq, p, deq_flags);
 	if (deq_flags & SCX_DEQ_SLEEP)
 		p->scx.flags |= SCX_TASK_DEQD_FOR_SLEEP;
 	struct task_struct *p = rq->curr;
 	if (SCX_HAS_OP(yield))
-		SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, yield, p, NULL);
+		SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, yield, rq, p, NULL);
 	else
 		p->scx.slice = 0;
 }
 	struct task_struct *from = rq->curr;
 	if (SCX_HAS_OP(yield))
-		return SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, yield, from, to);
+		return SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, yield, rq, from, to);
 	else
 		return false;
 }
 		 * emitted in switch_class().
 		 */
 		if (SCX_HAS_OP(cpu_acquire))
-			SCX_CALL_OP(SCX_KF_REST, cpu_acquire, cpu_of(rq), NULL);
+			SCX_CALL_OP(SCX_KF_REST, cpu_acquire, rq, cpu_of(rq), NULL);
 		rq->scx.cpu_released = false;
 	}
 	do {
 		dspc->nr_tasks = 0;
-		SCX_CALL_OP(SCX_KF_DISPATCH, dispatch, cpu_of(rq),
+		SCX_CALL_OP(SCX_KF_DISPATCH, dispatch, rq, cpu_of(rq),
 			    prev_on_scx ? prev : NULL);
 		flush_dispatch_buf(rq);
 		 * Core-sched might decide to execute @p before it is
 		 * dispatched. Call ops_dequeue() to notify the BPF scheduler.
 		 */
-		ops_dequeue(p, SCX_DEQ_CORE_SCHED_EXEC);
+		ops_dequeue(rq, p, SCX_DEQ_CORE_SCHED_EXEC);
 		dispatch_dequeue(rq, p);
 	}
 	/* see dequeue_task_scx() on why we skip when !QUEUED */
 	if (SCX_HAS_OP(running) && (p->scx.flags & SCX_TASK_QUEUED))
-		SCX_CALL_OP_TASK(SCX_KF_REST, running, p);
+		SCX_CALL_OP_TASK(SCX_KF_REST, running, rq, p);
 	clr_task_runnable(p, true);
 				.task = next,
 			};
-			SCX_CALL_OP(SCX_KF_CPU_RELEASE,
+			SCX_CALL_OP(SCX_KF_CPU_RELEASE, cpu_release, rq, cpu_of(rq), &args);
-				    cpu_release, cpu_of(rq), &args);
 		}
 		rq->scx.cpu_released = true;
 	}
 	/* see dequeue_task_scx() on why we skip when !QUEUED */
 	if (SCX_HAS_OP(stopping) && (p->scx.flags & SCX_TASK_QUEUED))
-		SCX_CALL_OP_TASK(SCX_KF_REST, stopping, p, true);
+		SCX_CALL_OP_TASK(SCX_KF_REST, stopping, rq, p, true);
 	if (p->scx.flags & SCX_TASK_QUEUED) {
 		set_task_runnable(rq, p);
 	 * verifier.
 	 */
 	if (SCX_HAS_OP(core_sched_before) && !scx_rq_bypassing(task_rq(a)))
-		return SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, core_sched_before,
+		return SCX_CALL_OP_2TASKS_RET(SCX_KF_REST, core_sched_before, NULL,
 					      (struct task_struct *)a,
 					      (struct task_struct *)b);
 	else
 		*ddsp_taskp = p;
 		cpu = SCX_CALL_OP_TASK_RET(SCX_KF_ENQUEUE | SCX_KF_SELECT_CPU,
-					   select_cpu, p, prev_cpu, wake_flags);
+					   select_cpu, NULL, p, prev_cpu, wake_flags);
 		p->scx.selected_cpu = cpu;
 		*ddsp_taskp = NULL;
 		if (ops_cpu_valid(cpu, "from ops.select_cpu()"))
 	 * designation pointless. Cast it away when calling the operation.
 	 */
 	if (SCX_HAS_OP(set_cpumask))
-		SCX_CALL_OP_TASK(SCX_KF_REST, set_cpumask, p,
+		SCX_CALL_OP_TASK(SCX_KF_REST, set_cpumask, NULL,
-				 (struct cpumask *)p->cpus_ptr);
+				 p, (struct cpumask *)p->cpus_ptr);
 }
 static void handle_hotplug(struct rq *rq, bool online)
 		scx_idle_update_selcpu_topology(&scx_ops);
 	if (online && SCX_HAS_OP(cpu_online))
-		SCX_CALL_OP(SCX_KF_UNLOCKED, cpu_online, cpu);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, cpu_online, NULL, cpu);
 	else if (!online && SCX_HAS_OP(cpu_offline))
-		SCX_CALL_OP(SCX_KF_UNLOCKED, cpu_offline, cpu);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, cpu_offline, NULL, cpu);
 	else
 		scx_ops_exit(SCX_ECODE_ACT_RESTART | SCX_ECODE_RSN_HOTPLUG,
 			     "cpu %d going %s, exiting scheduler", cpu,
 		curr->scx.slice = 0;
 		touch_core_sched(rq, curr);
 	} else if (SCX_HAS_OP(tick)) {
-		SCX_CALL_OP_TASK(SCX_KF_REST, tick, curr);
+		SCX_CALL_OP_TASK(SCX_KF_REST, tick, rq, curr);
 	}
 	if (!curr->scx.slice)
 			.fork = fork,
 		};
-		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, init_task, p, &args);
+		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, init_task, NULL, p, &args);
 		if (unlikely(ret)) {
 			ret = ops_sanitize_err("init_task", ret);
 			return ret;
 static void scx_ops_enable_task(struct task_struct *p)
 {
+	struct rq *rq = task_rq(p);
 	u32 weight;
-	lockdep_assert_rq_held(task_rq(p));
+	lockdep_assert_rq_held(rq);
 	/*
 	 * Set the weight before calling ops.enable() so that the scheduler
 	p->scx.weight = sched_weight_to_cgroup(weight);
 	if (SCX_HAS_OP(enable))
-		SCX_CALL_OP_TASK(SCX_KF_REST, enable, p);
+		SCX_CALL_OP_TASK(SCX_KF_REST, enable, rq, p);
 	scx_set_task_state(p, SCX_TASK_ENABLED);
 	if (SCX_HAS_OP(set_weight))
-		SCX_CALL_OP_TASK(SCX_KF_REST, set_weight, p, p->scx.weight);
+		SCX_CALL_OP_TASK(SCX_KF_REST, set_weight, rq, p, p->scx.weight);
 }
 static void scx_ops_disable_task(struct task_struct *p)
 {
-	lockdep_assert_rq_held(task_rq(p));
+	struct rq *rq = task_rq(p);
+	lockdep_assert_rq_held(rq);
 	WARN_ON_ONCE(scx_get_task_state(p) != SCX_TASK_ENABLED);
 	if (SCX_HAS_OP(disable))
-		SCX_CALL_OP_TASK(SCX_KF_REST, disable, p);
+		SCX_CALL_OP_TASK(SCX_KF_REST, disable, rq, p);
 	scx_set_task_state(p, SCX_TASK_READY);
 }
 	}
 	if (SCX_HAS_OP(exit_task))
-		SCX_CALL_OP_TASK(SCX_KF_REST, exit_task, p, &args);
+		SCX_CALL_OP_TASK(SCX_KF_REST, exit_task, task_rq(p), p, &args);
 	scx_set_task_state(p, SCX_TASK_NONE);
 }
 	p->scx.weight = sched_weight_to_cgroup(scale_load_down(lw->weight));
 	if (SCX_HAS_OP(set_weight))
-		SCX_CALL_OP_TASK(SCX_KF_REST, set_weight, p, p->scx.weight);
+		SCX_CALL_OP_TASK(SCX_KF_REST, set_weight, rq, p, p->scx.weight);
 }
 static void prio_changed_scx(struct rq *rq, struct task_struct *p, int oldprio)
 	 * different scheduler class. Keep the BPF scheduler up-to-date.
 	 */
 	if (SCX_HAS_OP(set_cpumask))
-		SCX_CALL_OP_TASK(SCX_KF_REST, set_cpumask, p,
+		SCX_CALL_OP_TASK(SCX_KF_REST, set_cpumask, rq,
-				 (struct cpumask *)p->cpus_ptr);
+				 p, (struct cpumask *)p->cpus_ptr);
 }
 static void switched_from_scx(struct rq *rq, struct task_struct *p)
 			struct scx_cgroup_init_args args =
 				{ .weight = tg->scx_weight };
-			ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_init,
+			ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_init, NULL,
 					      tg->css.cgroup, &args);
 			if (ret)
 				ret = ops_sanitize_err("cgroup_init", ret);
 	percpu_down_read(&scx_cgroup_rwsem);
 	if (SCX_HAS_OP(cgroup_exit) && (tg->scx_flags & SCX_TG_INITED))
-		SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_exit, tg->css.cgroup);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_exit, NULL, tg->css.cgroup);
 	tg->scx_flags &= ~(SCX_TG_ONLINE | SCX_TG_INITED);
 	percpu_up_read(&scx_cgroup_rwsem);
 			continue;
 		if (SCX_HAS_OP(cgroup_prep_move)) {
-			ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_prep_move,
+			ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_prep_move, NULL,
 					      p, from, css->cgroup);
 			if (ret)
 				goto err;
 err:
 	cgroup_taskset_for_each(p, css, tset) {
 		if (SCX_HAS_OP(cgroup_cancel_move) && p->scx.cgrp_moving_from)
-			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_cancel_move, p,
+			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_cancel_move, NULL,
-				    p->scx.cgrp_moving_from, css->cgroup);
+				    p, p->scx.cgrp_moving_from, css->cgroup);
 		p->scx.cgrp_moving_from = NULL;
 	}
 	 * cgrp_moving_from set.
 	 */
 	if (SCX_HAS_OP(cgroup_move) && !WARN_ON_ONCE(!p->scx.cgrp_moving_from))
-		SCX_CALL_OP_TASK(SCX_KF_UNLOCKED, cgroup_move, p,
+		SCX_CALL_OP_TASK(SCX_KF_UNLOCKED, cgroup_move, NULL,
-			p->scx.cgrp_moving_from, tg_cgrp(task_group(p)));
+				 p, p->scx.cgrp_moving_from, tg_cgrp(task_group(p)));
 	p->scx.cgrp_moving_from = NULL;
 }
 	cgroup_taskset_for_each(p, css, tset) {
 		if (SCX_HAS_OP(cgroup_cancel_move) && p->scx.cgrp_moving_from)
-			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_cancel_move, p,
+			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_cancel_move, NULL,
-				    p->scx.cgrp_moving_from, css->cgroup);
+				    p, p->scx.cgrp_moving_from, css->cgroup);
 		p->scx.cgrp_moving_from = NULL;
 	}
 out_unlock:
 	if (scx_cgroup_enabled && tg->scx_weight != weight) {
 		if (SCX_HAS_OP(cgroup_set_weight))
-			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_set_weight,
+			SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_set_weight, NULL,
 				    tg_cgrp(tg), weight);
 		tg->scx_weight = weight;
 	}
 			continue;
 		rcu_read_unlock();
-		SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_exit, css->cgroup);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, cgroup_exit, NULL, css->cgroup);
 		rcu_read_lock();
 		css_put(css);
 			continue;
 		rcu_read_unlock();
-		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_init,
+		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, cgroup_init, NULL,
 				      css->cgroup, &args);
 		if (ret) {
 			css_put(css);
 	}
 	if (scx_ops.exit)
-		SCX_CALL_OP(SCX_KF_UNLOCKED, exit, ei);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, exit, NULL, ei);
 	cancel_delayed_work_sync(&scx_watchdog_work);
 	if (SCX_HAS_OP(dump_task)) {
 		ops_dump_init(s, "    ");
-		SCX_CALL_OP(SCX_KF_REST, dump_task, dctx, p);
+		SCX_CALL_OP(SCX_KF_REST, dump_task, NULL, dctx, p);
 		ops_dump_exit();
 	}
 	if (SCX_HAS_OP(dump)) {
 		ops_dump_init(&s, "");
-		SCX_CALL_OP(SCX_KF_UNLOCKED, dump, &dctx);
+		SCX_CALL_OP(SCX_KF_UNLOCKED, dump, NULL, &dctx);
 		ops_dump_exit();
 	}
 		used = seq_buf_used(&ns);
 		if (SCX_HAS_OP(dump_cpu)) {
 			ops_dump_init(&ns, "  ");
-			SCX_CALL_OP(SCX_KF_REST, dump_cpu, &dctx, cpu, idle);
+			SCX_CALL_OP(SCX_KF_REST, dump_cpu, NULL, &dctx, cpu, idle);
 			ops_dump_exit();
 		}
 	scx_idle_enable(ops);
 	if (scx_ops.init) {
-		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, init);
+		ret = SCX_CALL_OP_RET(SCX_KF_UNLOCKED, init, NULL);
 		if (ret) {
 			ret = ops_sanitize_err("init", ret);
 			cpus_read_unlock();
 	BUILD_BUG_ON(__alignof__(struct bpf_iter_scx_dsq_kern) !=
 		     __alignof__(struct bpf_iter_scx_dsq));
+	/*
+	 * next() and destroy() will be called regardless of the return value.
+	 * Always clear $kit->dsq.
+	 */
+	kit->dsq = NULL;
 	if (flags & ~__SCX_DSQ_ITER_USER_FLAGS)
 		return -EINVAL;
 	}
 	if (ops_cpu_valid(cpu, NULL)) {
-		struct rq *rq = cpu_rq(cpu);
+		struct rq *rq = cpu_rq(cpu), *locked_rq = scx_locked_rq();
+		struct rq_flags rf;
+		/*
+		 * When called with an rq lock held, restrict the operation
+		 * to the corresponding CPU to prevent ABBA deadlocks.
+		 */
+		if (locked_rq && rq != locked_rq) {
+			scx_ops_error("Invalid target CPU %d", cpu);
+			return;
+		}
+		/*
+		 * If no rq lock is held, allow to operate on any CPU by
+		 * acquiring the corresponding rq lock.
+		 */
+		if (!locked_rq) {
+			rq_lock_irqsave(rq, &rf);
+			update_rq_clock(rq);
+		}
 		rq->scx.cpuperf_target = perf;
+		cpufreq_update_util(rq, 0);
-		rcu_read_lock_sched_notrace();
+		if (!locked_rq)
-		cpufreq_update_util(cpu_rq(cpu), 0);
+			rq_unlock_irqrestore(rq, &rf);
-		rcu_read_unlock_sched_notrace();
 	}
 }
 BTF_ID_FLAGS(func, scx_bpf_get_possible_cpumask, KF_ACQUIRE)
 BTF_ID_FLAGS(func, scx_bpf_get_online_cpumask, KF_ACQUIRE)
 BTF_ID_FLAGS(func, scx_bpf_put_cpumask, KF_RELEASE)
-BTF_ID_FLAGS(func, scx_bpf_get_idle_cpumask, KF_ACQUIRE)
-BTF_ID_FLAGS(func, scx_bpf_get_idle_smtmask, KF_ACQUIRE)
-BTF_ID_FLAGS(func, scx_bpf_put_idle_cpumask, KF_RELEASE)
-BTF_ID_FLAGS(func, scx_bpf_test_and_clear_cpu_idle)
-BTF_ID_FLAGS(func, scx_bpf_pick_idle_cpu, KF_RCU)
-BTF_ID_FLAGS(func, scx_bpf_pick_any_cpu, KF_RCU)
 BTF_ID_FLAGS(func, scx_bpf_task_running, KF_RCU)
 BTF_ID_FLAGS(func, scx_bpf_task_cpu, KF_RCU)
 BTF_ID_FLAGS(func, scx_bpf_cpu_rq)

kernel/sched/ext_idle.c+1−1

@@ -674,7 +674,7 @@ void __scx_update_idle(struct rq *rq, bool idle, bool do_notify) · 673 unmodified lines
674	* managed by put_prev_task_idle()/set_next_task_idle().	674	* managed by put_prev_task_idle()/set_next_task_idle().
675	*/	675	*/
676	if (SCX_HAS_OP(update_idle) && do_notify && !scx_rq_bypassing(rq))	676	if (SCX_HAS_OP(update_idle) && do_notify && !scx_rq_bypassing(rq))
677	SCX_CALL_OP(SCX_KF_REST, update_idle, cpu_of(rq), idle);	677	SCX_CALL_OP(SCX_KF_REST, update_idle, rq, cpu_of(rq), idle);
678		678
679	/*	679	/*
680	* Update the idle masks:	680	* Update the idle masks:

kernel/trace/fprobe.c+2−1

@@ -454,7 +454,8 @@ static void fprobe_remove_node_in_module(struct module mod, struct hlist_head · 453 unmodified lines
454	struct fprobe_hlist_node *node;	454	struct fprobe_hlist_node *node;
455	int ret = 0;	455	int ret = 0;
456		456
457	hlist_for_each_entry_rcu(node, head, hlist) {	457	hlist_for_each_entry_rcu(node, head, hlist,
		458	lockdep_is_held(&fprobe_mutex)) {
458	if (!within_module(node->addr, mod))	459	if (!within_module(node->addr, mod))
459	continue;	460	continue;
460	if (delete_fprobe_node(node))	461	if (delete_fprobe_node(node))

kernel/trace/ring_buffer.c+5−3

 	head_page = cpu_buffer->head_page;
-	/* If both the head and commit are on the reader_page then we are done. */
+	/* If the commit_buffer is the reader page, update the commit page */
-	if (head_page == cpu_buffer->reader_page &&
+	if (meta->commit_buffer == (unsigned long)cpu_buffer->reader_page->page) {
-	    head_page == cpu_buffer->commit_page)
+		cpu_buffer->commit_page = cpu_buffer->reader_page;
+		/* Nothing more to do, the only page is the reader page */
 		goto done;
+	}
 	/* Iterate until finding the commit page */
 	for (i = 0; i < meta->nr_subbufs + 1; i++, rb_inc_page(&head_page)) {

kernel/trace/trace_dynevent.c+15−1

@@ -16,7 +16,7 @@ · 15 unmodified lines
16	#include "trace_output.h" /* for trace_event_sem */	16	#include "trace_output.h" /* for trace_event_sem */
17	#include "trace_dynevent.h"	17	#include "trace_dynevent.h"
18		18
19	static DEFINE_MUTEX(dyn_event_ops_mutex);	19	DEFINE_MUTEX(dyn_event_ops_mutex);
20	static LIST_HEAD(dyn_event_ops_list);	20	static LIST_HEAD(dyn_event_ops_list);
21		21
22	bool trace_event_dyn_try_get_ref(struct trace_event_call *dyn_call)	22	bool trace_event_dyn_try_get_ref(struct trace_event_call *dyn_call)
@@ -116,6 +116,20 @@ int dyn_event_release(const char raw_command, struct dyn_event_operations type · 93 unmodified lines
116	return ret;	116	return ret;
117	}	117	}
118		118
		119	/*
		120	* Locked version of event creation. The event creation must be protected by
		121	* dyn_event_ops_mutex because of protecting trace_probe_log.
		122	*/
		123	int dyn_event_create(const char raw_command, struct dyn_event_operations type)
		124	{
		125	int ret;
		126
		127	mutex_lock(&dyn_event_ops_mutex);
		128	ret = type->create(raw_command);
		129	mutex_unlock(&dyn_event_ops_mutex);
		130	return ret;
		131	}
		132
119	static int create_dyn_event(const char *raw_command)	133	static int create_dyn_event(const char *raw_command)
120	{	134	{
121	struct dyn_event_operations *ops;	135	struct dyn_event_operations *ops;

kernel/trace/trace_dynevent.h+1−0

@@ -100,6 +100,7 @@ void dyn_event_seq_next(struct seq_file m, void v, loff_t pos); · 99 unmodified lines
100	void dyn_event_seq_stop(struct seq_file m, void v);	100	void dyn_event_seq_stop(struct seq_file m, void v);
101	int dyn_events_release_all(struct dyn_event_operations *type);	101	int dyn_events_release_all(struct dyn_event_operations *type);
102	int dyn_event_release(const char raw_command, struct dyn_event_operations type);	102	int dyn_event_release(const char raw_command, struct dyn_event_operations type);
		103	int dyn_event_create(const char raw_command, struct dyn_event_operations type);
103		104
104	/*	105	/*
105	* for_each_dyn_event - iterate over the dyn_event list	106	* for_each_dyn_event - iterate over the dyn_event list

kernel/trace/trace_eprobe.c+3−0

 			goto error;
 		}
 	}
+	trace_probe_log_clear();
 	return ret;
 parse_error:
 	ret = -EINVAL;
 error:
+	trace_probe_log_clear();
 	trace_event_probe_cleanup(ep);
 	return ret;
 }

kernel/trace/trace_events_trigger.c+1−1

@@ -1560,7 +1560,7 @@ stacktrace_trigger(struct event_trigger_data *data, · 1559 unmodified lines
1560	struct trace_event_file *file = data->private_data;	1560	struct trace_event_file *file = data->private_data;
1561		1561
1562	if (file)	1562	if (file)
1563	__trace_stack(file->tr, tracing_gen_ctx(), STACK_SKIP);	1563	__trace_stack(file->tr, tracing_gen_ctx_dec(), STACK_SKIP);
1564	else	1564	else
1565	trace_dump_stack(STACK_SKIP);	1565	trace_dump_stack(STACK_SKIP);
1566	}	1566	}

kernel/trace/trace_functions.c+1−5

@@ -633,11 +633,7 @@ ftrace_traceoff(unsigned long ip, unsigned long parent_ip, · 632 unmodified lines
633		633
634	static __always_inline void trace_stack(struct trace_array *tr)	634	static __always_inline void trace_stack(struct trace_array *tr)
635	{	635	{
636	unsigned int trace_ctx;	636	__trace_stack(tr, tracing_gen_ctx_dec(), FTRACE_STACK_SKIP);
637
638	trace_ctx = tracing_gen_ctx();
639
640	__trace_stack(tr, trace_ctx, FTRACE_STACK_SKIP);
641	}	637	}
642		638
643	static void	639	static void

kernel/trace/trace_kprobe.c+1−1

@@ -1089,7 +1089,7 @@ static int create_or_delete_trace_kprobe(const char *raw_command) · 1088 unmodified lines
1089	if (raw_command[0] == '-')	1089	if (raw_command[0] == '-')
1090	return dyn_event_release(raw_command, &trace_kprobe_ops);	1090	return dyn_event_release(raw_command, &trace_kprobe_ops);
1091		1091
1092	ret = trace_kprobe_create(raw_command);	1092	ret = dyn_event_create(raw_command, &trace_kprobe_ops);
1093	return ret == -ECANCELED ? -EINVAL : ret;	1093	return ret == -ECANCELED ? -EINVAL : ret;
1094	}	1094	}
1095		1095

kernel/trace/trace_probe.c+9−0

 }
 static struct trace_probe_log trace_probe_log;
+extern struct mutex dyn_event_ops_mutex;
 void trace_probe_log_init(const char *subsystem, int argc, const char **argv)
 {
+	lockdep_assert_held(&dyn_event_ops_mutex);
 	trace_probe_log.subsystem = subsystem;
 	trace_probe_log.argc = argc;
 	trace_probe_log.argv = argv;
 void trace_probe_log_clear(void)
 {
+	lockdep_assert_held(&dyn_event_ops_mutex);
 	memset(&trace_probe_log, 0, sizeof(trace_probe_log));
 }
 void trace_probe_log_set_index(int index)
 {
+	lockdep_assert_held(&dyn_event_ops_mutex);
 	trace_probe_log.index = index;
 }
 	char *command, *p;
 	int i, len = 0, pos = 0;
+	lockdep_assert_held(&dyn_event_ops_mutex);
 	if (!trace_probe_log.argv)
 		return;

kernel/trace/trace_uprobe.c+1−1

@@ -741,7 +741,7 @@ static int create_or_delete_trace_uprobe(const char *raw_command) · 740 unmodified lines
741	if (raw_command[0] == '-')	741	if (raw_command[0] == '-')
742	return dyn_event_release(raw_command, &trace_uprobe_ops);	742	return dyn_event_release(raw_command, &trace_uprobe_ops);
743		743
744	ret = trace_uprobe_create(raw_command);	744	ret = dyn_event_create(raw_command, &trace_uprobe_ops);
745	return ret == -ECANCELED ? -EINVAL : ret;	745	return ret == -ECANCELED ? -EINVAL : ret;
746	}	746	}
747		747

mm/hugetlb.c+22−6

 	struct hugepage_subpool *spool = subpool_vma(vma);
 	struct hstate *h = hstate_vma(vma);
 	struct folio *folio;
-	long retval, gbl_chg;
+	long retval, gbl_chg, gbl_reserve;
 	map_chg_state map_chg;
 	int ret, idx;
 	struct hugetlb_cgroup *h_cg = NULL;
 		hugetlb_cgroup_uncharge_cgroup_rsvd(idx, pages_per_huge_page(h),
 						    h_cg);
 out_subpool_put:
-	if (map_chg)
+	/*
-		hugepage_subpool_put_pages(spool, 1);
+	 * put page to subpool iff the quota of subpool's rsv_hpages is used
+	 * during hugepage_subpool_get_pages.
+	 */
+	if (map_chg && !gbl_chg) {
+		gbl_reserve = hugepage_subpool_put_pages(spool, 1);
+		hugetlb_acct_memory(h, -gbl_reserve);
+	}
 out_end_reservation:
 	if (map_chg != MAP_CHG_ENFORCED)
 		vma_end_reservation(h, vma, addr);
 					struct vm_area_struct *vma,
 					vm_flags_t vm_flags)
 {
-	long chg = -1, add = -1;
+	long chg = -1, add = -1, spool_resv, gbl_resv;
 	struct hstate *h = hstate_inode(inode);
 	struct hugepage_subpool *spool = subpool_inode(inode);
 	struct resv_map *resv_map;
 	return true;
 out_put_pages:
-	/* put back original number of pages, chg */
+	spool_resv = chg - gbl_reserve;
-	(void)hugepage_subpool_put_pages(spool, chg);
+	if (spool_resv) {
+		/* put sub pool's reservation back, chg - gbl_reserve */
+		gbl_resv = hugepage_subpool_put_pages(spool, spool_resv);
+		/*
+		 * subpool's reserved pages can not be put back due to race,
+		 * return to hstate.
+		 */
+		hugetlb_acct_memory(h, -gbl_resv);
+	}
 out_uncharge_cgroup:
 	hugetlb_cgroup_uncharge_cgroup_rsvd(hstate_index(h),
 					    chg * pages_per_huge_page(h), h_cg);

mm/internal.h+0−1

@@ -1590,7 +1590,6 @@ unsigned long move_page_tables(struct pagetable_move_control *pmc); · 1589 unmodified lines
1590		1590
1591	#ifdef CONFIG_UNACCEPTED_MEMORY	1591	#ifdef CONFIG_UNACCEPTED_MEMORY
1592	void accept_page(struct page *page);	1592	void accept_page(struct page *page);
1593	void unaccepted_cleanup_work(struct work_struct *work);
1594	#else /* CONFIG_UNACCEPTED_MEMORY */	1593	#else /* CONFIG_UNACCEPTED_MEMORY */
1595	static inline void accept_page(struct page *page)	1594	static inline void accept_page(struct page *page)
1596	{	1595	{

mm/memory.c+1−1

@@ -3751,7 +3751,7 @@ static bool __wp_can_reuse_large_anon_folio(struct folio *folio, · 3750 unmodified lines
3751		3751
3752	/* Stabilize the mapcount vs. refcount and recheck. */	3752	/* Stabilize the mapcount vs. refcount and recheck. */
3753	folio_lock_large_mapcount(folio);	3753	folio_lock_large_mapcount(folio);
3754	VM_WARN_ON_ONCE(folio_large_mapcount(folio) < folio_ref_count(folio));	3754	VM_WARN_ON_ONCE_FOLIO(folio_large_mapcount(folio) > folio_ref_count(folio), folio);
3755		3755
3756	if (folio_test_large_maybe_mapped_shared(folio))	3756	if (folio_test_large_maybe_mapped_shared(folio))
3757	goto unlock;	3757	goto unlock;

mm/mm_init.c+0−1

@@ -1441,7 +1441,6 @@ static void __meminit zone_init_free_lists(struct zone *zone) · 1440 unmodified lines
1441		1441
1442	#ifdef CONFIG_UNACCEPTED_MEMORY	1442	#ifdef CONFIG_UNACCEPTED_MEMORY
1443	INIT_LIST_HEAD(&zone->unaccepted_pages);	1443	INIT_LIST_HEAD(&zone->unaccepted_pages);
1444	INIT_WORK(&zone->unaccepted_cleanup, unaccepted_cleanup_work);
1445	#endif	1444	#endif
1446	}	1445	}
1447		1446

mm/page_alloc.c+20−68

 #endif
 static bool page_contains_unaccepted(struct page *page, unsigned int order);
-static bool cond_accept_memory(struct zone *zone, unsigned int order);
+static bool cond_accept_memory(struct zone *zone, unsigned int order,
+			       int alloc_flags);
 static bool __free_unaccepted(struct page *page);
 int page_group_by_mobility_disabled __read_mostly;
 		__pgalloc_tag_sub(page, nr);
 }
-static inline void pgalloc_tag_sub_pages(struct page *page, unsigned int nr)
+/* When tag is not NULL, assuming mem_alloc_profiling_enabled */
+static inline void pgalloc_tag_sub_pages(struct alloc_tag *tag, unsigned int nr)
 {
-	struct alloc_tag *tag;
-	if (!mem_alloc_profiling_enabled())
-		return;
-	tag = __pgalloc_tag_get(page);
 	if (tag)
 		this_cpu_sub(tag->counters->bytes, PAGE_SIZE * nr);
 }
 static inline void pgalloc_tag_add(struct page *page, struct task_struct *task,
 				   unsigned int nr) {}
 static inline void pgalloc_tag_sub(struct page *page, unsigned int nr) {}
-static inline void pgalloc_tag_sub_pages(struct page *page, unsigned int nr) {}
+static inline void pgalloc_tag_sub_pages(struct alloc_tag *tag, unsigned int nr) {}
 #endif /* CONFIG_MEM_ALLOC_PROFILING */
 			}
 		}
-		cond_accept_memory(zone, order);
+		cond_accept_memory(zone, order, alloc_flags);
 		/*
 		 * Detect whether the number of free pages is below high
 				       gfp_mask)) {
 			int ret;
-			if (cond_accept_memory(zone, order))
+			if (cond_accept_memory(zone, order, alloc_flags))
 				goto try_this_zone;
 			/*
 			return page;
 		} else {
-			if (cond_accept_memory(zone, order))
+			if (cond_accept_memory(zone, order, alloc_flags))
 				goto try_this_zone;
 			/* Try again if zone has deferred pages */
 			goto failed;
 		}
-		cond_accept_memory(zone, 0);
+		cond_accept_memory(zone, 0, alloc_flags);
 retry_this_zone:
 		mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK) + nr_pages;
 		if (zone_watermark_fast(zone, 0,  mark,
 			break;
 		}
-		if (cond_accept_memory(zone, 0))
+		if (cond_accept_memory(zone, 0, alloc_flags))
 			goto retry_this_zone;
 		/* Try again if zone has deferred pages */
 {
 	/* get PageHead before we drop reference */
 	int head = PageHead(page);
+	/* get alloc tag in case the page is released by others */
+	struct alloc_tag *tag = pgalloc_tag_get(page);
 	if (put_page_testzero(page))
 		__free_frozen_pages(page, order, fpi_flags);
 	else if (!head) {
-		pgalloc_tag_sub_pages(page, (1 << order) - 1);
+		pgalloc_tag_sub_pages(tag, (1 << order) - 1);
 		while (order-- > 0)
 			__free_frozen_pages(page + (1 << order), order,
 					    fpi_flags);
 #ifdef CONFIG_UNACCEPTED_MEMORY
-/* Counts number of zones with unaccepted pages. */
-static DEFINE_STATIC_KEY_FALSE(zones_with_unaccepted_pages);
 static bool lazy_accept = true;
-void unaccepted_cleanup_work(struct work_struct *work)
-{
-	static_branch_dec(&zones_with_unaccepted_pages);
-}
 static int __init accept_memory_parse(char *p)
 {
 	if (!strcmp(p, "lazy")) {
 static void __accept_page(struct zone *zone, unsigned long *flags,
 			  struct page *page)
 {
-	bool last;
 	list_del(&page->lru);
-	last = list_empty(&zone->unaccepted_pages);
 	account_freepages(zone, -MAX_ORDER_NR_PAGES, MIGRATE_MOVABLE);
 	__mod_zone_page_state(zone, NR_UNACCEPTED, -MAX_ORDER_NR_PAGES);
 	__ClearPageUnaccepted(page);
 	accept_memory(page_to_phys(page), PAGE_SIZE << MAX_PAGE_ORDER);
 	__free_pages_ok(page, MAX_PAGE_ORDER, FPI_TO_TAIL);
-	if (last) {
-		/*
-		 * There are two corner cases:
-		 *
-		 * - If allocation occurs during the CPU bring up,
-		 *   static_branch_dec() cannot be used directly as
-		 *   it causes a deadlock on cpu_hotplug_lock.
-		 *
-		 *   Instead, use schedule_work() to prevent deadlock.
-		 *
-		 * - If allocation occurs before workqueues are initialized,
-		 *   static_branch_dec() should be called directly.
-		 *
-		 *   Workqueues are initialized before CPU bring up, so this
-		 *   will not conflict with the first scenario.
-		 */
-		if (system_wq)
-			schedule_work(&zone->unaccepted_cleanup);
-		else
-			unaccepted_cleanup_work(&zone->unaccepted_cleanup);
-	}
 }
 void accept_page(struct page *page)
 	return true;
 }
-static inline bool has_unaccepted_memory(void)
+static bool cond_accept_memory(struct zone *zone, unsigned int order,
-{
+			       int alloc_flags)
-	return static_branch_unlikely(&zones_with_unaccepted_pages);
-}
-static bool cond_accept_memory(struct zone *zone, unsigned int order)
 {
 	long to_accept, wmark;
 	bool ret = false;
-	if (!has_unaccepted_memory())
+	if (list_empty(&zone->unaccepted_pages))
 		return false;
-	if (list_empty(&zone->unaccepted_pages))
+	/* Bailout, since try_to_accept_memory_one() needs to take a lock */
+	if (alloc_flags & ALLOC_TRYLOCK)
 		return false;
 	wmark = promo_wmark_pages(zone);
 {
 	struct zone *zone = page_zone(page);
 	unsigned long flags;
-	bool first = false;
 	if (!lazy_accept)
 		return false;
 	spin_lock_irqsave(&zone->lock, flags);
-	first = list_empty(&zone->unaccepted_pages);
 	list_add_tail(&page->lru, &zone->unaccepted_pages);
 	account_freepages(zone, MAX_ORDER_NR_PAGES, MIGRATE_MOVABLE);
 	__mod_zone_page_state(zone, NR_UNACCEPTED, MAX_ORDER_NR_PAGES);
 	__SetPageUnaccepted(page);
 	spin_unlock_irqrestore(&zone->lock, flags);
-	if (first)
-		static_branch_inc(&zones_with_unaccepted_pages);
 	return true;
 }
 	return false;
 }
-static bool cond_accept_memory(struct zone *zone, unsigned int order)
+static bool cond_accept_memory(struct zone *zone, unsigned int order,
+			       int alloc_flags)
 {
 	return false;
 }
 	if (!pcp_allowed_order(order))
 		return NULL;
-#ifdef CONFIG_UNACCEPTED_MEMORY
-	/* Bailout, since try_to_accept_memory_one() needs to take a lock */
-	if (has_unaccepted_memory())
-		return NULL;
-#endif
 	/* Bailout, since _deferred_grow_zone() needs to take a lock */
 	if (deferred_pages_enabled())
 		return NULL;

mm/swapfile.c+9−0

@@ -3331,6 +3331,15 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) · 3330 unmodified lines
3331	goto bad_swap_unlock_inode;	3331	goto bad_swap_unlock_inode;
3332	}	3332	}
3333		3333
		3334	/*
		3335	* The swap subsystem needs a major overhaul to support this.
		3336	* It doesn't work yet so just disable it for now.
		3337	*/
		3338	if (mapping_min_folio_order(mapping) > 0) {
		3339	error = -EINVAL;
		3340	goto bad_swap_unlock_inode;
		3341	}
		3342
3334	/*	3343	/*
3335	* Read the swap header.	3344	* Read the swap header.
3336	*/	3345	*/

mm/userfaultfd.c+10−2

 	src_folio->index = linear_page_index(dst_vma, dst_addr);
 	orig_dst_pte = mk_pte(&src_folio->page, dst_vma->vm_page_prot);
-	/* Follow mremap() behavior and treat the entry dirty after the move */
+	/* Set soft dirty bit so userspace can notice the pte was moved */
-	orig_dst_pte = pte_mkwrite(pte_mkdirty(orig_dst_pte), dst_vma);
+#ifdef CONFIG_MEM_SOFT_DIRTY
+	orig_dst_pte = pte_mksoft_dirty(orig_dst_pte);
+#endif
+	if (pte_dirty(orig_src_pte))
+		orig_dst_pte = pte_mkdirty(orig_dst_pte);
+	orig_dst_pte = pte_mkwrite(orig_dst_pte, dst_vma);
 	set_pte_at(mm, dst_addr, dst_pte, orig_dst_pte);
 out:
 	}
 	orig_src_pte = ptep_get_and_clear(mm, src_addr, src_pte);
+#ifdef CONFIG_MEM_SOFT_DIRTY
+	orig_src_pte = pte_swp_mksoft_dirty(orig_src_pte);
+#endif
 	set_pte_at(mm, dst_addr, dst_pte, orig_src_pte);
 	double_pt_unlock(dst_ptl, src_ptl);

mm/zsmalloc.c+4−4

 	class = zspage_class(pool, zspage);
 	off = offset_in_page(class->size * obj_idx);
-	if (off + class->size <= PAGE_SIZE) {
+	if (!ZsHugePage(zspage))
+		off += ZS_HANDLE_SIZE;
+	if (off + mem_len <= PAGE_SIZE) {
 		/* this object is contained entirely within a page */
 		void *dst = kmap_local_zpdesc(zpdesc);
-		if (!ZsHugePage(zspage))
-			off += ZS_HANDLE_SIZE;
 		memcpy(dst + off, handle_mem, mem_len);
 		kunmap_local(dst);
 	} else {
 		/* this object spans two pages */
 		size_t sizes[2];
-		off += ZS_HANDLE_SIZE;
 		sizes[0] = PAGE_SIZE - off;
 		sizes[1] = mem_len - sizes[0];

net/batman-adv/hard-interface.c+18−13

@@ -506,28 +506,32 @@ batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) · 505 unmodified lines
506	return false;	506	return false;
507	}	507	}
508		508
509	static void batadv_check_known_mac_addr(const struct net_device *net_dev)	509	static void batadv_check_known_mac_addr(const struct batadv_hard_iface *hard_iface)
510	{	510	{
511	const struct batadv_hard_iface *hard_iface;	511	const struct net_device *mesh_iface = hard_iface->mesh_iface;
		512	const struct batadv_hard_iface *tmp_hard_iface;
512		513
513	rcu_read_lock();	514	if (!mesh_iface)
514	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {	515	return;
515	if (hard_iface->if_status != BATADV_IF_ACTIVE &&	516
516	hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)	517	list_for_each_entry(tmp_hard_iface, &batadv_hardif_list, list) {
		518	if (tmp_hard_iface == hard_iface)
		519	continue;
		520
		521	if (tmp_hard_iface->mesh_iface != mesh_iface)
517	continue;	522	continue;
518		523
519	if (hard_iface->net_dev == net_dev)	524	if (tmp_hard_iface->if_status == BATADV_IF_NOT_IN_USE)
520	continue;	525	continue;
521		526
522	if (!batadv_compare_eth(hard_iface->net_dev->dev_addr,	527	if (!batadv_compare_eth(tmp_hard_iface->net_dev->dev_addr,
523	net_dev->dev_addr))	528	hard_iface->net_dev->dev_addr))
524	continue;	529	continue;
525		530
526	pr_warn("The newly added mac address (%pM) already exists on: %s\n",	531	pr_warn("The newly added mac address (%pM) already exists on: %s\n",
527	net_dev->dev_addr, hard_iface->net_dev->name);	532	hard_iface->net_dev->dev_addr, tmp_hard_iface->net_dev->name);
528	pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n");	533	pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n");
529	}	534	}
530	rcu_read_unlock();
531	}	535	}
532		536
533	/**	537	/**
@@ -763,6 +767,8 @@ int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, · 229 unmodified lines
763	hard_iface->net_dev->name, hardif_mtu,	767	hard_iface->net_dev->name, hardif_mtu,
764	required_mtu);	768	required_mtu);
765		769
		770	batadv_check_known_mac_addr(hard_iface);
		771
766	if (batadv_hardif_is_iface_up(hard_iface))	772	if (batadv_hardif_is_iface_up(hard_iface))
767	batadv_hardif_activate_interface(hard_iface);	773	batadv_hardif_activate_interface(hard_iface);
768	else	774	else
@@ -901,7 +907,6 @@ batadv_hardif_add_interface(struct net_device *net_dev) · 132 unmodified lines
901		907
902	batadv_v_hardif_init(hard_iface);	908	batadv_v_hardif_init(hard_iface);
903		909
904	batadv_check_known_mac_addr(hard_iface->net_dev);
905	kref_get(&hard_iface->refcount);	910	kref_get(&hard_iface->refcount);
906	list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list);	911	list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list);
907	batadv_hardif_generation++;	912	batadv_hardif_generation++;
@@ -988,7 +993,7 @@ static int batadv_hard_if_event(struct notifier_block *this, · 80 unmodified lines
988	if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)	993	if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
989	goto hardif_put;	994	goto hardif_put;
990		995
991	batadv_check_known_mac_addr(hard_iface->net_dev);	996	batadv_check_known_mac_addr(hard_iface);
992		997
993	bat_priv = netdev_priv(hard_iface->mesh_iface);	998	bat_priv = netdev_priv(hard_iface->mesh_iface);
994	bat_priv->algo_ops->iface.update_mac(hard_iface);	999	bat_priv->algo_ops->iface.update_mac(hard_iface);

net/bluetooth/hci_conn.c+24−0

@@ -3023,3 +3023,27 @@ void hci_conn_tx_dequeue(struct hci_conn *conn) · 3022 unmodified lines
3023		3023
3024	kfree_skb(skb);	3024	kfree_skb(skb);
3025	}	3025	}
		3026
		3027	u8 hci_conn_key_enc_size(struct hci_conn conn)
		3028	{
		3029	if (conn->type == ACL_LINK) {
		3030	struct link_key *key;
		3031
		3032	key = hci_find_link_key(conn->hdev, &conn->dst);
		3033	if (!key)
		3034	return NULL;
		3035
		3036	return &key->pin_len;
		3037	} else if (conn->type == LE_LINK) {
		3038	struct smp_ltk *ltk;
		3039
		3040	ltk = hci_find_ltk(conn->hdev, &conn->dst, conn->dst_type,
		3041	conn->role);
		3042	if (!ltk)
		3043	return NULL;
		3044
		3045	return &ltk->enc_size;
		3046	}
		3047
		3048	return NULL;
		3049	}

net/bluetooth/hci_event.c+42−31

@@ -739,10 +739,17 @@ static u8 hci_cc_read_enc_key_size(struct hci_dev hdev, void data, · 738 unmodified lines
739	handle);	739	handle);
740	conn->enc_key_size = 0;	740	conn->enc_key_size = 0;
741	} else {	741	} else {
		742	u8 *key_enc_size = hci_conn_key_enc_size(conn);
		743
742	conn->enc_key_size = rp->key_size;	744	conn->enc_key_size = rp->key_size;
743	status = 0;	745	status = 0;
744		746
745	if (conn->enc_key_size < hdev->min_enc_key_size) {	747	/* Attempt to check if the key size is too small or if it has
		748	* been downgraded from the last time it was stored as part of
		749	* the link_key.
		750	*/
		751	if (conn->enc_key_size < hdev->min_enc_key_size \|\|
		752	(key_enc_size && conn->enc_key_size < *key_enc_size)) {
746	/* As slave role, the conn->state has been set to	753	/* As slave role, the conn->state has been set to
747	* BT_CONNECTED and l2cap conn req might not be received	754	* BT_CONNECTED and l2cap conn req might not be received
748	* yet, at this moment the l2cap layer almost does	755	* yet, at this moment the l2cap layer almost does
@@ -755,6 +762,10 @@ static u8 hci_cc_read_enc_key_size(struct hci_dev hdev, void data, · 6 unmodified lines
755	clear_bit(HCI_CONN_ENCRYPT, &conn->flags);	762	clear_bit(HCI_CONN_ENCRYPT, &conn->flags);
756	clear_bit(HCI_CONN_AES_CCM, &conn->flags);	763	clear_bit(HCI_CONN_AES_CCM, &conn->flags);
757	}	764	}
		765
		766	/* Update the key encryption size with the connection one */
		767	if (key_enc_size && *key_enc_size != conn->enc_key_size)
		768	*key_enc_size = conn->enc_key_size;
758	}	769	}
759		770
760	hci_encrypt_cfm(conn, status);	771	hci_encrypt_cfm(conn, status);
@@ -3065,6 +3076,34 @@ static void hci_inquiry_result_evt(struct hci_dev hdev, void edata, · 2304 unmodified lines
3065	hci_dev_unlock(hdev);	3076	hci_dev_unlock(hdev);
3066	}	3077	}
3067		3078
		3079	static int hci_read_enc_key_size(struct hci_dev hdev, struct hci_conn conn)
		3080	{
		3081	struct hci_cp_read_enc_key_size cp;
		3082	u8 *key_enc_size = hci_conn_key_enc_size(conn);
		3083
		3084	if (!read_key_size_capable(hdev)) {
		3085	conn->enc_key_size = HCI_LINK_KEY_SIZE;
		3086	return -EOPNOTSUPP;
		3087	}
		3088
		3089	bt_dev_dbg(hdev, "hcon %p", conn);
		3090
		3091	memset(&cp, 0, sizeof(cp));
		3092	cp.handle = cpu_to_le16(conn->handle);
		3093
		3094	/* If the key enc_size is already known, use it as conn->enc_key_size,
		3095	* otherwise use hdev->min_enc_key_size so the likes of
		3096	* l2cap_check_enc_key_size don't fail while waiting for
		3097	* HCI_OP_READ_ENC_KEY_SIZE response.
		3098	*/
		3099	if (key_enc_size && *key_enc_size)
		3100	conn->enc_key_size = *key_enc_size;
		3101	else
		3102	conn->enc_key_size = hdev->min_enc_key_size;
		3103
		3104	return hci_send_cmd(hdev, HCI_OP_READ_ENC_KEY_SIZE, sizeof(cp), &cp);
		3105	}
		3106
3068	static void hci_conn_complete_evt(struct hci_dev hdev, void data,	3107	static void hci_conn_complete_evt(struct hci_dev hdev, void data,
3069	struct sk_buff *skb)	3108	struct sk_buff *skb)
3070	{	3109	{
@@ -3157,23 +3196,11 @@ static void hci_conn_complete_evt(struct hci_dev hdev, void data, · 86 unmodified lines
3157	if (ev->encr_mode == 1 && !test_bit(HCI_CONN_ENCRYPT, &conn->flags) &&	3196	if (ev->encr_mode == 1 && !test_bit(HCI_CONN_ENCRYPT, &conn->flags) &&
3158	ev->link_type == ACL_LINK) {	3197	ev->link_type == ACL_LINK) {
3159	struct link_key *key;	3198	struct link_key *key;
3160	struct hci_cp_read_enc_key_size cp;
3161		3199
3162	key = hci_find_link_key(hdev, &ev->bdaddr);	3200	key = hci_find_link_key(hdev, &ev->bdaddr);
3163	if (key) {	3201	if (key) {
3164	set_bit(HCI_CONN_ENCRYPT, &conn->flags);	3202	set_bit(HCI_CONN_ENCRYPT, &conn->flags);
3165		3203	hci_read_enc_key_size(hdev, conn);
3166	if (!read_key_size_capable(hdev)) {
3167	conn->enc_key_size = HCI_LINK_KEY_SIZE;
3168	} else {
3169	cp.handle = cpu_to_le16(conn->handle);
3170	if (hci_send_cmd(hdev, HCI_OP_READ_ENC_KEY_SIZE,
3171	sizeof(cp), &cp)) {
3172	bt_dev_err(hdev, "sending read key size failed");
3173	conn->enc_key_size = HCI_LINK_KEY_SIZE;
3174	}
3175	}
3176
3177	hci_encrypt_cfm(conn, ev->status);	3204	hci_encrypt_cfm(conn, ev->status);
3178	}	3205	}
3179	}	3206	}
@@ -3612,24 +3639,8 @@ static void hci_encrypt_change_evt(struct hci_dev hdev, void data, · 432 unmodified lines
3612		3639
3613	/* Try reading the encryption key size for encrypted ACL links */	3640	/* Try reading the encryption key size for encrypted ACL links */
3614	if (!ev->status && ev->encrypt && conn->type == ACL_LINK) {	3641	if (!ev->status && ev->encrypt && conn->type == ACL_LINK) {
3615	struct hci_cp_read_enc_key_size cp;	3642	if (hci_read_enc_key_size(hdev, conn))
3616
3617	/* Only send HCI_Read_Encryption_Key_Size if the
3618	* controller really supports it. If it doesn't, assume
3619	* the default size (16).
3620	*/
3621	if (!read_key_size_capable(hdev)) {
3622	conn->enc_key_size = HCI_LINK_KEY_SIZE;
3623	goto notify;
3624	}
3625
3626	cp.handle = cpu_to_le16(conn->handle);
3627	if (hci_send_cmd(hdev, HCI_OP_READ_ENC_KEY_SIZE,
3628	sizeof(cp), &cp)) {
3629	bt_dev_err(hdev, "sending read key size failed");
3630	conn->enc_key_size = HCI_LINK_KEY_SIZE;
3631	goto notify;	3643	goto notify;
3632	}
3633		3644
3634	goto unlock;	3645	goto unlock;
3635	}	3646	}

net/bluetooth/mgmt.c+6−3

 	struct mgmt_cp_add_device *cp = cmd->param;
 	if (!err) {
+		struct hci_conn_params *params;
+		params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
+						le_addr_type(cp->addr.type));
 		device_added(cmd->sk, hdev, &cp->addr.bdaddr, cp->addr.type,
 			     cp->action);
 		device_flags_changed(NULL, hdev, &cp->addr.bdaddr,
 				     cp->addr.type, hdev->conn_flags,
-				     PTR_UINT(cmd->user_data));
+				     params ? params->flags : 0);
 	}
 	mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_ADD_DEVICE,
 		goto unlock;
 	}
-	cmd->user_data = UINT_PTR(current_flags);
 	err = hci_cmd_sync_queue(hdev, add_device_sync, cmd,
 				 add_device_complete);
 	if (err < 0) {

net/core/dev.c+2−0

 		if (!(features & feature) && (lower->features & feature)) {
 			netdev_dbg(upper, "Disabling feature %pNF on lower dev %s.\n",
 				   &feature, lower->name);
+			netdev_lock_ops(lower);
 			lower->wanted_features &= ~feature;
 			__netdev_update_features(lower);
 					    &feature, lower->name);
 			else
 				netdev_features_change(lower);
+			netdev_unlock_ops(lower);
 		}
 	}
 }

net/core/devmem.c+7−0

 	refcount_set(&binding->ref, 1);
+	mutex_init(&binding->lock);
 	binding->dmabuf = dmabuf;
 	binding->attachment = dma_buf_attach(binding->dmabuf, dev->dev.parent);
 	xa_for_each(&binding->bound_rxqs, xa_idx, bound_rxq) {
 		if (bound_rxq == rxq) {
 			xa_erase(&binding->bound_rxqs, xa_idx);
+			if (xa_empty(&binding->bound_rxqs)) {
+				mutex_lock(&binding->lock);
+				binding->dev = NULL;
+				mutex_unlock(&binding->lock);
+			}
 			break;
 		}
 	}

net/core/devmem.h+2−0

@@ -20,6 +20,8 @@ struct net_devmem_dmabuf_binding { · 19 unmodified lines
20	struct sg_table *sgt;	20	struct sg_table *sgt;
21	struct net_device *dev;	21	struct net_device *dev;
22	struct gen_pool *chunk_pool;	22	struct gen_pool *chunk_pool;
		23	/* Protect dev */
		24	struct mutex lock;
23		25
24	/* The user holds a ref (via the netlink API) for as long as they want	26	/* The user holds a ref (via the netlink API) for as long as they want
25	* the binding to remain alive. Each page pool using this binding holds	27	* the binding to remain alive. Each page pool using this binding holds

net/core/netdev-genl.c+11−0

 {
 	struct net_devmem_dmabuf_binding *binding;
 	struct net_devmem_dmabuf_binding *temp;
+	netdevice_tracker dev_tracker;
 	struct net_device *dev;
 	mutex_lock(&priv->lock);
 	list_for_each_entry_safe(binding, temp, &priv->bindings, list) {
+		mutex_lock(&binding->lock);
 		dev = binding->dev;
+		if (!dev) {
+			mutex_unlock(&binding->lock);
+			net_devmem_unbind_dmabuf(binding);
+			continue;
+		}
+		netdev_hold(dev, &dev_tracker, GFP_KERNEL);
+		mutex_unlock(&binding->lock);
 		netdev_lock(dev);
 		net_devmem_unbind_dmabuf(binding);
 		netdev_unlock(dev);
+		netdev_put(dev, &dev_tracker);
 	}
 	mutex_unlock(&priv->lock);
 }

net/mac80211/main.c+4−2

 	hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
-	local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
+	local->int_scan_req = kzalloc(struct_size(local->int_scan_req,
-				      sizeof(void *) * channels, GFP_KERNEL);
+						  channels, channels),
+				      GFP_KERNEL);
 	if (!local->int_scan_req)
 		return -ENOMEM;
+	local->int_scan_req->n_channels = channels;
 	eth_broadcast_addr(local->int_scan_req->bssid);

net/mctp/device.c+12−5

 	struct net_device *dev;
 	struct ifaddrmsg *hdr;
 	struct mctp_dev *mdev;
-	int ifindex, rc;
+	int ifindex = 0, rc;
-	hdr = nlmsg_data(cb->nlh);
+	/* Filter by ifindex if a header is provided */
-	// filter by ifindex if requested
+	if (cb->nlh->nlmsg_len >= nlmsg_msg_size(sizeof(*hdr))) {
-	ifindex = hdr->ifa_index;
+		hdr = nlmsg_data(cb->nlh);
+		ifindex = hdr->ifa_index;
+	} else {
+		if (cb->strict_check) {
+			NL_SET_ERR_MSG(cb->extack, "mctp: Invalid header for addr dump request");
+			return -EINVAL;
+		}
+	}
 	rcu_read_lock();
 	for_each_netdev_dump(net, dev, mcb->ifindex) {

net/mctp/route.c+3−1

@@ -313,8 +313,10 @@ static void mctp_flow_prepare_output(struct sk_buff skb, struct mctp_dev dev) · 312 unmodified lines
313		313
314	key = flow->key;	314	key = flow->key;
315		315
316	if (WARN_ON(key->dev && key->dev != dev))	316	if (key->dev) {
		317	WARN_ON(key->dev != dev);
317	return;	318	return;
		319	}
318		320
319	mctp_dev_set_key(dev, key);	321	mctp_dev_set_key(dev, key);
320	}	322	}

net/sched/sch_codel.c+1−1

@@ -144,7 +144,7 @@ static int codel_change(struct Qdisc sch, struct nlattr opt, · 143 unmodified lines
144		144
145	qlen = sch->q.qlen;	145	qlen = sch->q.qlen;
146	while (sch->q.qlen > sch->limit) {	146	while (sch->q.qlen > sch->limit) {
147	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);	147	struct sk_buff *skb = qdisc_dequeue_internal(sch, true);
148		148
149	dropped += qdisc_pkt_len(skb);	149	dropped += qdisc_pkt_len(skb);
150	qdisc_qstats_backlog_dec(sch, skb);	150	qdisc_qstats_backlog_dec(sch, skb);

net/sched/sch_fq.c+1−1

@@ -1136,7 +1136,7 @@ static int fq_change(struct Qdisc sch, struct nlattr opt, · 1135 unmodified lines
1136	sch_tree_lock(sch);	1136	sch_tree_lock(sch);
1137	}	1137	}
1138	while (sch->q.qlen > sch->limit) {	1138	while (sch->q.qlen > sch->limit) {
1139	struct sk_buff *skb = fq_dequeue(sch);	1139	struct sk_buff *skb = qdisc_dequeue_internal(sch, false);
1140		1140
1141	if (!skb)	1141	if (!skb)
1142	break;	1142	break;

net/sched/sch_fq_codel.c+1−1

@@ -441,7 +441,7 @@ static int fq_codel_change(struct Qdisc sch, struct nlattr opt, · 440 unmodified lines
441		441
442	while (sch->q.qlen > sch->limit \|\|	442	while (sch->q.qlen > sch->limit \|\|
443	q->memory_usage > q->memory_limit) {	443	q->memory_usage > q->memory_limit) {
444	struct sk_buff *skb = fq_codel_dequeue(sch);	444	struct sk_buff *skb = qdisc_dequeue_internal(sch, false);
445		445
446	q->cstats.drop_len += qdisc_pkt_len(skb);	446	q->cstats.drop_len += qdisc_pkt_len(skb);
447	rtnl_kfree_skbs(skb, skb);	447	rtnl_kfree_skbs(skb, skb);

net/sched/sch_fq_pie.c+1−1

@@ -366,7 +366,7 @@ static int fq_pie_change(struct Qdisc sch, struct nlattr opt, · 365 unmodified lines
366		366
367	/* Drop excess packets if new limit is lower */	367	/* Drop excess packets if new limit is lower */
368	while (sch->q.qlen > sch->limit) {	368	while (sch->q.qlen > sch->limit) {
369	struct sk_buff *skb = fq_pie_qdisc_dequeue(sch);	369	struct sk_buff *skb = qdisc_dequeue_internal(sch, false);
370		370
371	len_dropped += qdisc_pkt_len(skb);	371	len_dropped += qdisc_pkt_len(skb);
372	num_dropped += 1;	372	num_dropped += 1;

net/sched/sch_hhf.c+1−1

@@ -564,7 +564,7 @@ static int hhf_change(struct Qdisc sch, struct nlattr opt, · 563 unmodified lines
564	qlen = sch->q.qlen;	564	qlen = sch->q.qlen;
565	prev_backlog = sch->qstats.backlog;	565	prev_backlog = sch->qstats.backlog;
566	while (sch->q.qlen > sch->limit) {	566	while (sch->q.qlen > sch->limit) {
567	struct sk_buff *skb = hhf_dequeue(sch);	567	struct sk_buff *skb = qdisc_dequeue_internal(sch, false);
568		568
569	rtnl_kfree_skbs(skb, skb);	569	rtnl_kfree_skbs(skb, skb);
570	}	570	}

net/sched/sch_pie.c+1−1

@@ -195,7 +195,7 @@ static int pie_change(struct Qdisc sch, struct nlattr opt, · 194 unmodified lines
195	/* Drop excess packets if new limit is lower */	195	/* Drop excess packets if new limit is lower */
196	qlen = sch->q.qlen;	196	qlen = sch->q.qlen;
197	while (sch->q.qlen > sch->limit) {	197	while (sch->q.qlen > sch->limit) {
198	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);	198	struct sk_buff *skb = qdisc_dequeue_internal(sch, true);
199		199
200	dropped += qdisc_pkt_len(skb);	200	dropped += qdisc_pkt_len(skb);
201	qdisc_qstats_backlog_dec(sch, skb);	201	qdisc_qstats_backlog_dec(sch, skb);

net/tls/tls_strp.c+2−1

 		return 0;
 	shinfo = skb_shinfo(strp->anchor);
-	shinfo->frag_list = NULL;
 	/* If we don't know the length go max plus page for cipher overhead */
 	need_spc = strp->stm.full_len ?: TLS_MAX_PAYLOAD_SIZE + PAGE_SIZE;
 				   page, 0, 0);
 	}
+	shinfo->frag_list = NULL;
 	strp->copy_mode = 1;
 	strp->stm.offset = 0;

samples/ftrace/sample-trace-array.c+1−1

@@ -112,7 +112,7 @@ static int __init sample_trace_array_init(void) · 111 unmodified lines
112	/*	112	/*
113	* If context specific per-cpu buffers havent already been allocated.	113	* If context specific per-cpu buffers havent already been allocated.
114	*/	114	*/
115	trace_printk_init_buffers();	115	trace_array_init_printk(tr);
116		116
117	simple_tsk = kthread_run(simple_thread, NULL, "sample-instance");	117	simple_tsk = kthread_run(simple_thread, NULL, "sample-instance");
118	if (IS_ERR(simple_tsk)) {	118	if (IS_ERR(simple_tsk)) {

scripts/Makefile.extrawarn+12−0

@@ -37,6 +37,18 @@ KBUILD_CFLAGS += -Wno-gnu · 36 unmodified lines
37	# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111219	37	# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111219
38	KBUILD_CFLAGS += $(call cc-disable-warning, format-overflow-non-kprintf)	38	KBUILD_CFLAGS += $(call cc-disable-warning, format-overflow-non-kprintf)
39	KBUILD_CFLAGS += $(call cc-disable-warning, format-truncation-non-kprintf)	39	KBUILD_CFLAGS += $(call cc-disable-warning, format-truncation-non-kprintf)
		40
		41	# Clang may emit a warning when a const variable, such as the dummy variables
		42	# in typecheck(), or const member of an aggregate type are not initialized,
		43	# which can result in unexpected behavior. However, in many audited cases of
		44	# the "field" variant of the warning, this is intentional because the field is
		45	# never used within a particular call path, the field is within a union with
		46	# other non-const members, or the containing object is not const so the field
		47	# can be modified via memcpy() / memset(). While the variable warning also gets
		48	# disabled with this same switch, there should not be too much coverage lost
		49	# because -Wuninitialized will still flag when an uninitialized const variable
		50	# is used.
		51	KBUILD_CFLAGS += $(call cc-disable-warning, default-const-init-unsafe)
40	else	52	else
41		53
42	# gcc inanely warns about local variables called 'main'	54	# gcc inanely warns about local variables called 'main'

scripts/Makefile.vmlinux+2−2

@@ -94,10 +94,10 @@ $(vmlinux-final): $(RESOLVE_BTFIDS) · 93 unmodified lines
94	endif	94	endif
95		95
96	ifdef CONFIG_BUILDTIME_TABLE_SORT	96	ifdef CONFIG_BUILDTIME_TABLE_SORT
97	vmlinux: scripts/sorttable	97	$(vmlinux-final): scripts/sorttable
98	endif	98	endif
99		99
100	# module.builtin.ranges	100	# modules.builtin.ranges
101	# ---------------------------------------------------------------------------	101	# ---------------------------------------------------------------------------
102	ifdef CONFIG_BUILTIN_MODULE_RANGES	102	ifdef CONFIG_BUILTIN_MODULE_RANGES
103	__default: modules.builtin.ranges	103	__default: modules.builtin.ranges

scripts/Makefile.vmlinux_o+2−2

@@ -73,7 +73,7 @@ vmlinux.o: $(initcalls-lds) vmlinux.a $(KBUILD_VMLINUX_LIBS) FORCE · 72 unmodified lines
73		73
74	targets += vmlinux.o	74	targets += vmlinux.o
75		75
76	# module.builtin.modinfo	76	# modules.builtin.modinfo
77	# ---------------------------------------------------------------------------	77	# ---------------------------------------------------------------------------
78		78
79	OBJCOPYFLAGS_modules.builtin.modinfo := -j .modinfo -O binary	79	OBJCOPYFLAGS_modules.builtin.modinfo := -j .modinfo -O binary
@@ -82,7 +82,7 @@ targets += modules.builtin.modinfo · 2 unmodified lines
82	modules.builtin.modinfo: vmlinux.o FORCE	82	modules.builtin.modinfo: vmlinux.o FORCE
83	$(call if_changed,objcopy)	83	$(call if_changed,objcopy)
84		84
85	# module.builtin	85	# modules.builtin
86	# ---------------------------------------------------------------------------	86	# ---------------------------------------------------------------------------
87		87
88	# The second line aids cases where multiple modules share the same object.	88	# The second line aids cases where multiple modules share the same object.

scripts/package/kernel.spec+1−0

@@ -16,6 +16,7 @@ Source1: config · 15 unmodified lines
16	Source2: diff.patch	16	Source2: diff.patch
17	Provides: kernel-%{KERNELRELEASE}	17	Provides: kernel-%{KERNELRELEASE}
18	BuildRequires: bc binutils bison dwarves	18	BuildRequires: bc binutils bison dwarves
		19	BuildRequires: (elfutils-devel or libdw-devel)
19	BuildRequires: (elfutils-libelf-devel or libelf-devel) flex	20	BuildRequires: (elfutils-libelf-devel or libelf-devel) flex
20	BuildRequires: gcc make openssl openssl-devel perl python3 rsync	21	BuildRequires: gcc make openssl openssl-devel perl python3 rsync
21		22

scripts/package/mkdebian+1−1

@@ -210,7 +210,7 @@ Rules-Requires-Root: no · 209 unmodified lines
210	Build-Depends: debhelper-compat (= 12)	210	Build-Depends: debhelper-compat (= 12)
211	Build-Depends-Arch: bc, bison, flex,	211	Build-Depends-Arch: bc, bison, flex,
212	gcc-${host_gnu} <!pkg.${sourcename}.nokernelheaders>,	212	gcc-${host_gnu} <!pkg.${sourcename}.nokernelheaders>,
213	kmod, libelf-dev:native,	213	kmod, libdw-dev:native, libelf-dev:native,
214	libssl-dev:native, libssl-dev <!pkg.${sourcename}.nokernelheaders>,	214	libssl-dev:native, libssl-dev <!pkg.${sourcename}.nokernelheaders>,
215	python3:native, rsync	215	python3:native, rsync
216	Homepage: https://www.kernel.org/	216	Homepage: https://www.kernel.org/

security/landlock/audit.c+2−2

@@ -175,7 +175,7 @@ static void test_get_hierarchy(struct kunit *const test) · 174 unmodified lines
175	KUNIT_EXPECT_EQ(test, 10, get_hierarchy(&dom2, 0)->id);	175	KUNIT_EXPECT_EQ(test, 10, get_hierarchy(&dom2, 0)->id);
176	KUNIT_EXPECT_EQ(test, 20, get_hierarchy(&dom2, 1)->id);	176	KUNIT_EXPECT_EQ(test, 20, get_hierarchy(&dom2, 1)->id);
177	KUNIT_EXPECT_EQ(test, 30, get_hierarchy(&dom2, 2)->id);	177	KUNIT_EXPECT_EQ(test, 30, get_hierarchy(&dom2, 2)->id);
178	KUNIT_EXPECT_EQ(test, 30, get_hierarchy(&dom2, -1)->id);	178	/* KUNIT_EXPECT_EQ(test, 30, get_hierarchy(&dom2, -1)->id); */
179	}	179	}
180		180
181	#endif /* CONFIG_SECURITY_LANDLOCK_KUNIT_TEST */	181	#endif /* CONFIG_SECURITY_LANDLOCK_KUNIT_TEST */
@@ -437,7 +437,7 @@ void landlock_log_denial(const struct landlock_cred_security *const subject, · 255 unmodified lines
437	return;	437	return;
438		438
439	/* Checks if the current exec was restricting itself. */	439	/* Checks if the current exec was restricting itself. */
440	if (subject->domain_exec & (1 << youngest_layer)) {	440	if (subject->domain_exec & BIT(youngest_layer)) {
441	/* Ignores denials for the same execution. */	441	/* Ignores denials for the same execution. */
442	if (!youngest_denied->log_same_exec)	442	if (!youngest_denied->log_same_exec)
443	return;	443	return;

security/landlock/id.c+31−2

 #include <kunit/test.h>
 #include <linux/atomic.h>
+#include <linux/bitops.h>
 #include <linux/random.h>
 #include <linux/spinlock.h>
 	 * Ensures sure 64-bit values are always used by user space (or may
 	 * fail with -EOVERFLOW), and makes this testable.
 	 */
-	init = 1ULL << 32;
+	init = BIT_ULL(32);
 	/*
 	 * Makes a large (2^32) boot-time value to limit ID collision in logs
 	 * to get a new ID (e.g. a full landlock_restrict_self() call), and the
 	 * cost of draining all available IDs during the system's uptime.
 	 */
-	random_4bits = random_4bits % (1 << 4);
+	random_4bits &= 0b1111;
 	step = number_of_ids + random_4bits;
 	/* It is safe to cast a signed atomic to an unsigned value. */
 		init + 2);
 }
+static void test_range1_rand15(struct kunit *const test)
+{
+	atomic64_t counter;
+	u64 init;
+	init = get_random_u32();
+	atomic64_set(&counter, init);
+	KUNIT_EXPECT_EQ(test, get_id_range(1, &counter, 15), init);
+	KUNIT_EXPECT_EQ(
+		test, get_id_range(get_random_u8(), &counter, get_random_u8()),
+		init + 16);
+}
 static void test_range1_rand16(struct kunit *const test)
 {
 	atomic64_t counter;
 		init + 4);
 }
+static void test_range2_rand15(struct kunit *const test)
+{
+	atomic64_t counter;
+	u64 init;
+	init = get_random_u32();
+	atomic64_set(&counter, init);
+	KUNIT_EXPECT_EQ(test, get_id_range(2, &counter, 15), init);
+	KUNIT_EXPECT_EQ(
+		test, get_id_range(get_random_u8(), &counter, get_random_u8()),
+		init + 17);
+}
 static void test_range2_rand16(struct kunit *const test)
 {
 	atomic64_t counter;
 	KUNIT_CASE(test_init_once),
 	KUNIT_CASE(test_range1_rand0),
 	KUNIT_CASE(test_range1_rand1),
+	KUNIT_CASE(test_range1_rand15),
 	KUNIT_CASE(test_range1_rand16),
 	KUNIT_CASE(test_range2_rand0),
 	KUNIT_CASE(test_range2_rand1),
 	KUNIT_CASE(test_range2_rand2),
+	KUNIT_CASE(test_range2_rand15),
 	KUNIT_CASE(test_range2_rand16),
 	{}
 	/* clang-format on */

security/landlock/syscalls.c+2−1

 #include <asm/current.h>
 #include <linux/anon_inodes.h>
+#include <linux/bitops.h>
 #include <linux/build_bug.h>
 #include <linux/capability.h>
 #include <linux/cleanup.h>
 	new_llcred->domain = new_dom;
 #ifdef CONFIG_AUDIT
-	new_llcred->domain_exec |= 1 << (new_dom->num_layers - 1);
+	new_llcred->domain_exec |= BIT(new_dom->num_layers - 1);
 #endif /* CONFIG_AUDIT */
 	return commit_creds(new_cred);

sound/core/seq/seq_clientmgr.c+33−19

@@ -732,15 +732,21 @@ static int snd_seq_deliver_single_event(struct snd_seq_client *client, · 731 unmodified lines
732	*/	732	*/
733	static int __deliver_to_subscribers(struct snd_seq_client *client,	733	static int __deliver_to_subscribers(struct snd_seq_client *client,
734	struct snd_seq_event *event,	734	struct snd_seq_event *event,
735	struct snd_seq_client_port *src_port,	735	int port, int atomic, int hop)
736	int atomic, int hop)
737	{	736	{
		737	struct snd_seq_client_port *src_port;
738	struct snd_seq_subscribers *subs;	738	struct snd_seq_subscribers *subs;
739	int err, result = 0, num_ev = 0;	739	int err, result = 0, num_ev = 0;
740	union __snd_seq_event event_saved;	740	union __snd_seq_event event_saved;
741	size_t saved_size;	741	size_t saved_size;
742	struct snd_seq_port_subs_info *grp;	742	struct snd_seq_port_subs_info *grp;
743		743
		744	if (port < 0)
		745	return 0;
		746	src_port = snd_seq_port_use_ptr(client, port);
		747	if (!src_port)
		748	return 0;
		749
744	/* save original event record */	750	/* save original event record */
745	saved_size = snd_seq_event_packet_size(event);	751	saved_size = snd_seq_event_packet_size(event);
746	memcpy(&event_saved, event, saved_size);	752	memcpy(&event_saved, event, saved_size);
@@ -775,6 +781,7 @@ static int __deliver_to_subscribers(struct snd_seq_client *client, · 28 unmodified lines
775	read_unlock(&grp->list_lock);	781	read_unlock(&grp->list_lock);
776	else	782	else
777	up_read(&grp->list_mutex);	783	up_read(&grp->list_mutex);
		784	snd_seq_port_unlock(src_port);
778	memcpy(event, &event_saved, saved_size);	785	memcpy(event, &event_saved, saved_size);
779	return (result < 0) ? result : num_ev;	786	return (result < 0) ? result : num_ev;
780	}	787	}
@@ -783,25 +790,32 @@ static int deliver_to_subscribers(struct snd_seq_client *client, · 2 unmodified lines
783	struct snd_seq_event *event,	790	struct snd_seq_event *event,
784	int atomic, int hop)	791	int atomic, int hop)
785	{	792	{
786	struct snd_seq_client_port *src_port;	793	int ret;
787	int ret = 0, ret2;	794	#if IS_ENABLED(CONFIG_SND_SEQ_UMP)
788		795	int ret2;
789	src_port = snd_seq_port_use_ptr(client, event->source.port);	796	#endif
790	if (src_port) {
791	ret = __deliver_to_subscribers(client, event, src_port, atomic, hop);
792	snd_seq_port_unlock(src_port);
793	}
794
795	if (client->ump_endpoint_port < 0 \|\|
796	event->source.port == client->ump_endpoint_port)
797	return ret;
798		797
799	src_port = snd_seq_port_use_ptr(client, client->ump_endpoint_port);	798	ret = __deliver_to_subscribers(client, event,
800	if (!src_port)	799	event->source.port, atomic, hop);
		800	#if IS_ENABLED(CONFIG_SND_SEQ_UMP)
		801	if (!snd_seq_client_is_ump(client) \|\| client->ump_endpoint_port < 0)
801	return ret;	802	return ret;
802	ret2 = __deliver_to_subscribers(client, event, src_port, atomic, hop);	803	/* If it's an event from EP port (and with a UMP group),
803	snd_seq_port_unlock(src_port);	804	* deliver to subscribers of the corresponding UMP group port, too.
804	return ret2 < 0 ? ret2 : ret;	805	* Or, if it's from non-EP port, deliver to subscribers of EP port, too.
		806	*/
		807	if (event->source.port == client->ump_endpoint_port)
		808	ret2 = __deliver_to_subscribers(client, event,
		809	snd_seq_ump_group_port(event),
		810	atomic, hop);
		811	else
		812	ret2 = __deliver_to_subscribers(client, event,
		813	client->ump_endpoint_port,
		814	atomic, hop);
		815	if (ret2 < 0)
		816	return ret2;
		817	#endif
		818	return ret;
805	}	819	}
806		820
807	/* deliver an event to the destination port(s).	821	/* deliver an event to the destination port(s).

sound/core/seq/seq_ump_convert.c+18−0

@@ -1285,3 +1285,21 @@ int snd_seq_deliver_to_ump(struct snd_seq_client *source, · 1284 unmodified lines
1285	else	1285	else
1286	return cvt_to_ump_midi1(dest, dest_port, event, atomic, hop);	1286	return cvt_to_ump_midi1(dest, dest_port, event, atomic, hop);
1287	}	1287	}
		1288
		1289	/* return the UMP group-port number of the event;
		1290	* return -1 if groupless or non-UMP event
		1291	*/
		1292	int snd_seq_ump_group_port(const struct snd_seq_event *event)
		1293	{
		1294	const struct snd_seq_ump_event *ump_ev =
		1295	(const struct snd_seq_ump_event *)event;
		1296	unsigned char type;
		1297
		1298	if (!snd_seq_ev_is_ump(event))
		1299	return -1;
		1300	type = ump_message_type(ump_ev->ump[0]);
		1301	if (ump_is_groupless_msg(type))
		1302	return -1;
		1303	/* group-port number starts from 1 */
		1304	return ump_message_group(ump_ev->ump[0]) + 1;
		1305	}

sound/core/seq/seq_ump_convert.h+1−0

@@ -18,5 +18,6 @@ int snd_seq_deliver_to_ump(struct snd_seq_client *source, · 17 unmodified lines
18	struct snd_seq_client_port *dest_port,	18	struct snd_seq_client_port *dest_port,
19	struct snd_seq_event *event,	19	struct snd_seq_event *event,
20	int atomic, int hop);	20	int atomic, int hop);
		21	int snd_seq_ump_group_port(const struct snd_seq_event *event);
21		22
22	#endif /* __SEQ_UMP_CONVERT_H */	23	#endif /* __SEQ_UMP_CONVERT_H */

sound/hda/intel-sdw-acpi.c+1−1

@@ -177,7 +177,7 @@ static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level, · 176 unmodified lines
177	* sdw_intel_startup() is required for creation of devices and bus	177	* sdw_intel_startup() is required for creation of devices and bus
178	* startup	178	* startup
179	*/	179	*/
180	int sdw_intel_acpi_scan(acpi_handle *parent_handle,	180	int sdw_intel_acpi_scan(acpi_handle parent_handle,
181	struct sdw_intel_acpi_info *info)	181	struct sdw_intel_acpi_info *info)
182	{	182	{
183	acpi_status status;	183	acpi_status status;

sound/pci/es1968.c+4−2

 	struct snd_pcm_runtime *runtime = substream->runtime;
 	struct es1968 *chip = snd_pcm_substream_chip(substream);
 	struct esschan *es;
-	int apu1, apu2;
+	int err, apu1, apu2;
 	apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
 	if (apu1 < 0)
 	runtime->hw = snd_es1968_capture;
 	runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
 		calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
-	snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
+	err = snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
+	if (err < 0)
+		return err;
 	spin_lock_irq(&chip->substream_lock);
 	list_add(&es->list, &chip->substream_list);

sound/sh/Kconfig+1−1

@@ -14,7 +14,7 @@ if SND_SUPERH · 13 unmodified lines
14		14
15	config SND_AICA	15	config SND_AICA
16	tristate "Dreamcast Yamaha AICA sound"	16	tristate "Dreamcast Yamaha AICA sound"
17	depends on SH_DREAMCAST	17	depends on SH_DREAMCAST && SH_DMA_API
18	select SND_PCM	18	select SND_PCM
19	select G2_DMA	19	select G2_DMA
20	help	20	help

sound/usb/quirks.c+4−0

 		   QUIRK_FLAG_CTL_MSG_DELAY_1M),
 	DEVICE_FLG(0x0c45, 0x6340, /* Sonix HD USB Camera */
 		   QUIRK_FLAG_GET_SAMPLE_RATE),
+	DEVICE_FLG(0x0c45, 0x636b, /* Microdia JP001 USB Camera */
+		   QUIRK_FLAG_GET_SAMPLE_RATE),
 	DEVICE_FLG(0x0d8c, 0x0014, /* USB Audio Device */
 		   QUIRK_FLAG_CTL_MSG_DELAY_1M),
 	DEVICE_FLG(0x0ecb, 0x205c, /* JBL Quantum610 Wireless */
 		   QUIRK_FLAG_FIXED_RATE),
 	DEVICE_FLG(0x0fd9, 0x0008, /* Hauppauge HVR-950Q */
 		   QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
+	DEVICE_FLG(0x1101, 0x0003, /* Audioengine D1 */
+		   QUIRK_FLAG_GET_SAMPLE_RATE),
 	DEVICE_FLG(0x1224, 0x2a25, /* Jieli Technology USB PHY 2.0 */
 		   QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_MIC_RES_16),
 	DEVICE_FLG(0x1395, 0x740a, /* Sennheiser DECT */

tools/net/ynl/pyynl/ethtool.py+15−7

         print('Capabilities:')
         [print(f'\t{v}') for v in bits_to_dict(tsinfo['timestamping'])]
-        print(f'PTP Hardware Clock: {tsinfo["phc-index"]}')
+        print(f'PTP Hardware Clock: {tsinfo.get("phc-index", "none")}')
-        print('Hardware Transmit Timestamp Modes:')
+        if 'tx-types' in tsinfo:
-        [print(f'\t{v}') for v in bits_to_dict(tsinfo['tx-types'])]
+            print('Hardware Transmit Timestamp Modes:')
+            [print(f'\t{v}') for v in bits_to_dict(tsinfo['tx-types'])]
+        else:
+            print('Hardware Transmit Timestamp Modes: none')
+        if 'rx-filters' in tsinfo:
+            print('Hardware Receive Filter Modes:')
+            [print(f'\t{v}') for v in bits_to_dict(tsinfo['rx-filters'])]
+        else:
+            print('Hardware Receive Filter Modes: none')
-        print('Hardware Receive Filter Modes:')
+        if 'stats' in tsinfo and tsinfo['stats']:
-        [print(f'\t{v}') for v in bits_to_dict(tsinfo['rx-filters'])]
+            print('Statistics:')
+            [print(f'\t{k}: {v}') for k, v in tsinfo['stats'].items()]
-        print('Statistics:')
-        [print(f'\t{k}: {v}') for k, v in tsinfo['stats'].items()]
         return
     print(f'Settings for {args.device}:')

tools/net/ynl/pyynl/ynl_gen_c.py+3−4

@@ -1143,10 +1143,9 @@ class Family(SpecFamily): · 1142 unmodified lines
1143	self.pure_nested_structs[nested].request = True	1143	self.pure_nested_structs[nested].request = True
1144	if attr in rs_members['reply']:	1144	if attr in rs_members['reply']:
1145	self.pure_nested_structs[nested].reply = True	1145	self.pure_nested_structs[nested].reply = True
1146		1146	if spec.is_multi_val():
1147	if spec.is_multi_val():	1147	child = self.pure_nested_structs.get(nested)
1148	child = self.pure_nested_structs.get(nested)	1148	child.in_multi_val = True
1149	child.in_multi_val = True
1150		1149
1151	self._sort_pure_types()	1150	self._sort_pure_types()
1152		1151

tools/testing/selftests/drivers/net/hw/ncdevmem.c+22−33

 	return 0;
 }
+static struct netdev_queue_id *create_queues(void)
+{
+	struct netdev_queue_id *queues;
+	size_t i = 0;
+	queues = calloc(num_queues, sizeof(*queues));
+	for (i = 0; i < num_queues; i++) {
+		queues[i]._present.type = 1;
+		queues[i]._present.id = 1;
+		queues[i].type = NETDEV_QUEUE_TYPE_RX;
+		queues[i].id = start_queue + i;
+	}
+	return queues;
+}
 int do_server(struct memory_buffer *mem)
 {
 	char ctrl_data[sizeof(int) * 20000];
 	char buffer[256];
 	int socket_fd;
 	int client_fd;
-	size_t i = 0;
 	int ret;
 	ret = parse_address(server_ip, atoi(port), &server_sin);
 	sleep(1);
-	queues = malloc(sizeof(*queues) * num_queues);
+	if (bind_rx_queue(ifindex, mem->fd, create_queues(), num_queues, &ys))
-	for (i = 0; i < num_queues; i++) {
-		queues[i]._present.type = 1;
-		queues[i]._present.id = 1;
-		queues[i].type = NETDEV_QUEUE_TYPE_RX;
-		queues[i].id = start_queue + i;
-	}
-	if (bind_rx_queue(ifindex, mem->fd, queues, num_queues, &ys))
 		error(1, 0, "Failed to bind\n");
 	tmp_mem = malloc(mem->size);
 			goto cleanup;
 		}
-		i++;
 		for (cm = CMSG_FIRSTHDR(&msg); cm; cm = CMSG_NXTHDR(&msg, cm)) {
 			if (cm->cmsg_level != SOL_SOCKET ||
 			    (cm->cmsg_type != SCM_DEVMEM_DMABUF &&
 void run_devmem_tests(void)
 {
-	struct netdev_queue_id *queues;
 	struct memory_buffer *mem;
 	struct ynl_sock *ys;
-	size_t i = 0;
 	mem = provider->alloc(getpagesize() * NUM_PAGES);
 	if (configure_rss())
 		error(1, 0, "rss error\n");
-	queues = calloc(num_queues, sizeof(*queues));
 	if (configure_headersplit(1))
 		error(1, 0, "Failed to configure header split\n");
-	if (!bind_rx_queue(ifindex, mem->fd, queues, num_queues, &ys))
+	if (!bind_rx_queue(ifindex, mem->fd,
+			   calloc(num_queues, sizeof(struct netdev_queue_id)),
+			   num_queues, &ys))
 		error(1, 0, "Binding empty queues array should have failed\n");
-	for (i = 0; i < num_queues; i++) {
-		queues[i]._present.type = 1;
-		queues[i]._present.id = 1;
-		queues[i].type = NETDEV_QUEUE_TYPE_RX;
-		queues[i].id = start_queue + i;
-	}
 	if (configure_headersplit(0))
 		error(1, 0, "Failed to configure header split\n");
-	if (!bind_rx_queue(ifindex, mem->fd, queues, num_queues, &ys))
+	if (!bind_rx_queue(ifindex, mem->fd, create_queues(), num_queues, &ys))
 		error(1, 0, "Configure dmabuf with header split off should have failed\n");
 	if (configure_headersplit(1))
 		error(1, 0, "Failed to configure header split\n");
-	for (i = 0; i < num_queues; i++) {
+	if (bind_rx_queue(ifindex, mem->fd, create_queues(), num_queues, &ys))
-		queues[i]._present.type = 1;
-		queues[i]._present.id = 1;
-		queues[i].type = NETDEV_QUEUE_TYPE_RX;
-		queues[i].id = start_queue + i;
-	}
-	if (bind_rx_queue(ifindex, mem->fd, queues, num_queues, &ys))
 		error(1, 0, "Failed to bind\n");
 	/* Deactivating a bound queue should not be legal */

tools/testing/selftests/tc-testing/tc-tests/qdiscs/codel.json+24−0

@@ -189,5 +189,29 @@ · 188 unmodified lines
189	"teardown": [	189	"teardown": [
190	"$TC qdisc del dev $DUMMY handle 1: root"	190	"$TC qdisc del dev $DUMMY handle 1: root"
191	]	191	]
		192	},
		193	{
		194	"id": "deb1",
		195	"name": "CODEL test qdisc limit trimming",
		196	"category": ["qdisc", "codel"],
		197	"plugins": {
		198	"requires": ["nsPlugin", "scapyPlugin"]
		199	},
		200	"setup": [
		201	"$TC qdisc add dev $DEV1 handle 1: root codel limit 10"
		202	],
		203	"scapy": [
		204	{
		205	"iface": "$DEV0",
		206	"count": 10,
		207	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
		208	}
		209	],
		210	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root codel limit 1",
		211	"expExitCode": "0",
		212	"verifyCmd": "$TC qdisc show dev $DEV1",
		213	"matchPattern": "qdisc codel 1: root refcnt [0-9]+ limit 1p target 5ms interval 100ms",
		214	"matchCount": "1",
		215	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
192	}	216	}
193	]	217	]

tools/testing/selftests/tc-testing/tc-tests/qdiscs/fq.json+22−0

@@ -377,5 +377,27 @@ · 376 unmodified lines
377	"teardown": [	377	"teardown": [
378	"$TC qdisc del dev $DUMMY handle 1: root"	378	"$TC qdisc del dev $DUMMY handle 1: root"
379	]	379	]
		380	},
		381	{
		382	"id": "9479",
		383	"name": "FQ test qdisc limit trimming",
		384	"category": ["qdisc", "fq"],
		385	"plugins": {"requires": ["nsPlugin", "scapyPlugin"]},
		386	"setup": [
		387	"$TC qdisc add dev $DEV1 handle 1: root fq limit 10"
		388	],
		389	"scapy": [
		390	{
		391	"iface": "$DEV0",
		392	"count": 10,
		393	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
		394	}
		395	],
		396	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root fq limit 1",
		397	"expExitCode": "0",
		398	"verifyCmd": "$TC qdisc show dev $DEV1",
		399	"matchPattern": "qdisc fq 1: root refcnt [0-9]+ limit 1p",
		400	"matchCount": "1",
		401	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
380	}	402	}
381	]	403	]

tools/testing/selftests/tc-testing/tc-tests/qdiscs/fq_codel.json+22−0

@@ -294,5 +294,27 @@ · 293 unmodified lines
294	"teardown": [	294	"teardown": [
295	"$TC qdisc del dev $DUMMY handle 1: root"	295	"$TC qdisc del dev $DUMMY handle 1: root"
296	]	296	]
		297	},
		298	{
		299	"id": "0436",
		300	"name": "FQ_CODEL test qdisc limit trimming",
		301	"category": ["qdisc", "fq_codel"],
		302	"plugins": {"requires": ["nsPlugin", "scapyPlugin"]},
		303	"setup": [
		304	"$TC qdisc add dev $DEV1 handle 1: root fq_codel limit 10"
		305	],
		306	"scapy": [
		307	{
		308	"iface": "$DEV0",
		309	"count": 10,
		310	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
		311	}
		312	],
		313	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root fq_codel limit 1",
		314	"expExitCode": "0",
		315	"verifyCmd": "$TC qdisc show dev $DEV1",
		316	"matchPattern": "qdisc fq_codel 1: root refcnt [0-9]+ limit 1p flows 1024 quantum.*target 5ms interval 100ms memory_limit 32Mb ecn drop_batch 64",
		317	"matchCount": "1",
		318	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
297	}	319	}
298	]	320	]

tools/testing/selftests/tc-testing/tc-tests/qdiscs/fq_pie.json+22−0

@@ -18,5 +18,27 @@ · 17 unmodified lines
18	"matchCount": "1",	18	"matchCount": "1",
19	"teardown": [	19	"teardown": [
20	]	20	]
		21	},
		22	{
		23	"id": "83bf",
		24	"name": "FQ_PIE test qdisc limit trimming",
		25	"category": ["qdisc", "fq_pie"],
		26	"plugins": {"requires": ["nsPlugin", "scapyPlugin"]},
		27	"setup": [
		28	"$TC qdisc add dev $DEV1 handle 1: root fq_pie limit 10"
		29	],
		30	"scapy": [
		31	{
		32	"iface": "$DEV0",
		33	"count": 10,
		34	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
		35	}
		36	],
		37	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root fq_pie limit 1",
		38	"expExitCode": "0",
		39	"verifyCmd": "$TC qdisc show dev $DEV1",
		40	"matchPattern": "qdisc fq_pie 1: root refcnt [0-9]+ limit 1p",
		41	"matchCount": "1",
		42	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
21	}	43	}
22	]	44	]

tools/testing/selftests/tc-testing/tc-tests/qdiscs/hhf.json+22−0

@@ -188,5 +188,27 @@ · 187 unmodified lines
188	"teardown": [	188	"teardown": [
189	"$TC qdisc del dev $DUMMY handle 1: root"	189	"$TC qdisc del dev $DUMMY handle 1: root"
190	]	190	]
		191	},
		192	{
		193	"id": "385f",
		194	"name": "HHF test qdisc limit trimming",
		195	"category": ["qdisc", "hhf"],
		196	"plugins": {"requires": ["nsPlugin", "scapyPlugin"]},
		197	"setup": [
		198	"$TC qdisc add dev $DEV1 handle 1: root hhf limit 10"
		199	],
		200	"scapy": [
		201	{
		202	"iface": "$DEV0",
		203	"count": 10,
		204	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
		205	}
		206	],
		207	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root hhf limit 1",
		208	"expExitCode": "0",
		209	"verifyCmd": "$TC qdisc show dev $DEV1",
		210	"matchPattern": "qdisc hhf 1: root refcnt [0-9]+ limit 1p.*hh_limit 2048 reset_timeout 40ms admit_bytes 128Kb evict_timeout 1s non_hh_weight 2",
		211	"matchCount": "1",
		212	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
191	}	213	}
192	]	214	]

tools/testing/selftests/tc-testing/tc-tests/qdiscs/pie.json+24−0

@@ -0,0 +1,24 @@
	1	[
	2	{
	3	"id": "6158",
	4	"name": "PIE test qdisc limit trimming",
	5	"category": ["qdisc", "pie"],
	6	"plugins": {"requires": ["nsPlugin", "scapyPlugin"]},
	7	"setup": [
	8	"$TC qdisc add dev $DEV1 handle 1: root pie limit 10"
	9	],
	10	"scapy": [
	11	{
	12	"iface": "$DEV0",
	13	"count": 10,
	14	"packet": "Ether(type=0x800)/IP(src='10.0.0.10',dst='10.0.0.20')/TCP(sport=5000,dport=10)"
	15	}
	16	],
	17	"cmdUnderTest": "$TC qdisc change dev $DEV1 handle 1: root pie limit 1",
	18	"expExitCode": "0",
	19	"verifyCmd": "$TC qdisc show dev $DEV1",
	20	"matchPattern": "qdisc pie 1: root refcnt [0-9]+ limit 1p",
	21	"matchCount": "1",
	22	"teardown": ["$TC qdisc del dev $DEV1 handle 1: root"]
	23	}
	24	]

tools/testing/vsock/vsock_test.c+16−12

 	send_buf(fd, buf, sizeof(buf), 0, sizeof(buf));
 	control_expectln("RECEIVED");
-	ret = ioctl(fd, SIOCOUTQ, &sock_bytes_unsent);
+	/* SIOCOUTQ isn't guaranteed to instantly track sent data. Even though
-	if (ret < 0) {
+	 * the "RECEIVED" message means that the other side has received the
-		if (errno == EOPNOTSUPP) {
+	 * data, there can be a delay in our kernel before updating the "unsent
-			fprintf(stderr, "Test skipped, SIOCOUTQ not supported.\n");
+	 * bytes" counter. Repeat SIOCOUTQ until it returns 0.
-		} else {
+	 */
+	timeout_begin(TIMEOUT);
+	do {
+		ret = ioctl(fd, SIOCOUTQ, &sock_bytes_unsent);
+		if (ret < 0) {
+			if (errno == EOPNOTSUPP) {
+				fprintf(stderr, "Test skipped, SIOCOUTQ not supported.\n");
+				break;
+			}
 			perror("ioctl");
 			exit(EXIT_FAILURE);
 		}
-	} else if (ret == 0 && sock_bytes_unsent != 0) {
+		timeout_check("SIOCOUTQ");
-		fprintf(stderr,
+	} while (sock_bytes_unsent != 0);
-			"Unexpected 'SIOCOUTQ' value, expected 0, got %i\n",
+	timeout_end();
-			sock_bytes_unsent);
-		exit(EXIT_FAILURE);
-	}
 	close(fd);
 }

usr/include/Makefile+4−0

 no-header-test += linux/bpf_perf_event.h
 endif
+ifeq ($(SRCARCH),openrisc)
+no-header-test += linux/bpf_perf_event.h
+endif
 ifeq ($(SRCARCH),powerpc)
 no-header-test += linux/bpf_perf_event.h
 endif