lael-labs/linux

Documentation/admin-guide/kernel-parameters.txt+0−19

@@ -788,25 +788,6 @@ · 787 unmodified lines
788	Documentation/networking/netconsole.rst for an	788	Documentation/networking/netconsole.rst for an
789	alternative.	789	alternative.
790		790
791	<DEVNAME>:<n>.<n>[,options]
792	Use the specified serial port on the serial core bus.
793	The addressing uses DEVNAME of the physical serial port
794	device, followed by the serial core controller instance,
795	and the serial port instance. The options are the same
796	as documented for the ttyS addressing above.
797
798	The mapping of the serial ports to the tty instances
799	can be viewed with:
800
801	$ ls -d /sys/bus/serial-base/devices/:./tty/
802	/sys/bus/serial-base/devices/00:04:0.0/tty/ttyS0
803
804	In the above example, the console can be addressed with
805	console=00:04:0.0. Note that a console addressed this
806	way will only get added when the related device driver
807	is ready. The use of an earlycon parameter in addition to
808	the console may be desired for console output early on.
809
810	uart[8250],io,<addr>[,options]	791	uart[8250],io,<addr>[,options]
811	uart[8250],mmio,<addr>[,options]	792	uart[8250],mmio,<addr>[,options]
812	uart[8250],mmio16,<addr>[,options]	793	uart[8250],mmio16,<addr>[,options]

Documentation/driver-api/cxl/memory-devices.rst+15−0

@@ -328,6 +328,12 @@ CXL Memory Device · 327 unmodified lines
328	.. kernel-doc:: drivers/cxl/mem.c	328	.. kernel-doc:: drivers/cxl/mem.c
329	:doc: cxl mem	329	:doc: cxl mem
330		330
		331	.. kernel-doc:: drivers/cxl/cxlmem.h
		332	:internal:
		333
		334	.. kernel-doc:: drivers/cxl/core/memdev.c
		335	:identifiers:
		336
331	CXL Port	337	CXL Port
332	--------	338	--------
333	.. kernel-doc:: drivers/cxl/port.c	339	.. kernel-doc:: drivers/cxl/port.c
@@ -341,6 +347,15 @@ CXL Core · 7 unmodified lines
341	.. kernel-doc:: drivers/cxl/cxl.h	347	.. kernel-doc:: drivers/cxl/cxl.h
342	:internal:	348	:internal:
343		349
		350	.. kernel-doc:: drivers/cxl/core/hdm.c
		351	:doc: cxl core hdm
		352
		353	.. kernel-doc:: drivers/cxl/core/hdm.c
		354	:identifiers:
		355
		356	.. kernel-doc:: drivers/cxl/core/cdat.c
		357	:identifiers:
		358
344	.. kernel-doc:: drivers/cxl/core/port.c	359	.. kernel-doc:: drivers/cxl/core/port.c
345	:doc: cxl core	360	:doc: cxl core
346		361

Documentation/kbuild/modules.rst+4−4

@@ -128,7 +128,7 @@ executed to make module versioning work. · 127 unmodified lines
128		128
129	modules_install	129	modules_install
130	Install the external module(s). The default location is	130	Install the external module(s). The default location is
131	/lib/modules/<kernel_release>/extra/, but a prefix may	131	/lib/modules/<kernel_release>/updates/, but a prefix may
132	be added with INSTALL_MOD_PATH (discussed in section 5).	132	be added with INSTALL_MOD_PATH (discussed in section 5).
133		133
134	clean	134	clean
@@ -417,7 +417,7 @@ directory: · 282 unmodified lines
417		417
418	And external modules are installed in:	418	And external modules are installed in:
419		419
420	/lib/modules/$(KERNELRELEASE)/extra/	420	/lib/modules/$(KERNELRELEASE)/updates/
421		421
422	5.1 INSTALL_MOD_PATH	422	5.1 INSTALL_MOD_PATH
423	--------------------	423	--------------------
@@ -438,10 +438,10 @@ And external modules are installed in: · 14 unmodified lines
438	-------------------	438	-------------------
439		439
440	External modules are by default installed to a directory under	440	External modules are by default installed to a directory under
441	/lib/modules/$(KERNELRELEASE)/extra/, but you may wish to	441	/lib/modules/$(KERNELRELEASE)/updates/, but you may wish to
442	locate modules for a specific functionality in a separate	442	locate modules for a specific functionality in a separate
443	directory. For this purpose, use INSTALL_MOD_DIR to specify an	443	directory. For this purpose, use INSTALL_MOD_DIR to specify an
444	alternative name to "extra."::	444	alternative name to "updates."::
445		445
446	$ make INSTALL_MOD_DIR=gandalf -C $KDIR \	446	$ make INSTALL_MOD_DIR=gandalf -C $KDIR \
447	M=$PWD modules_install	447	M=$PWD modules_install

Documentation/userspace-api/ioctl/ioctl-number.rst+1−0

@@ -186,6 +186,7 @@ Code Seq# Include File Comments · 185 unmodified lines
186	'Q' all linux/soundcard.h	186	'Q' all linux/soundcard.h
187	'R' 00-1F linux/random.h conflict!	187	'R' 00-1F linux/random.h conflict!
188	'R' 01 linux/rfkill.h conflict!	188	'R' 01 linux/rfkill.h conflict!
		189	'R' 20-2F linux/trace_mmap.h
189	'R' C0-DF net/bluetooth/rfcomm.h	190	'R' C0-DF net/bluetooth/rfcomm.h
190	'R' E0 uapi/linux/fsl_mc.h	191	'R' E0 uapi/linux/fsl_mc.h
191	'S' all linux/cdrom.h conflict!	192	'S' all linux/cdrom.h conflict!

MAINTAINERS+5−5

@@ -1044,7 +1044,7 @@ M: Joerg Roedel <joro@8bytes.org> · 1043 unmodified lines
1044	R: Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>	1044	R: Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
1045	L: iommu@lists.linux.dev	1045	L: iommu@lists.linux.dev
1046	S: Maintained	1046	S: Maintained
1047	T: git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git	1047	T: git git://git.kernel.org/pub/scm/linux/kernel/git/iommu/linux.git
1048	F: drivers/iommu/amd/	1048	F: drivers/iommu/amd/
1049	F: include/linux/amd-iommu.h	1049	F: include/linux/amd-iommu.h
1050		1050
@@ -11157,7 +11157,7 @@ M: David Woodhouse <dwmw2@infradead.org> · 10106 unmodified lines
11157	M: Lu Baolu <baolu.lu@linux.intel.com>	11157	M: Lu Baolu <baolu.lu@linux.intel.com>
11158	L: iommu@lists.linux.dev	11158	L: iommu@lists.linux.dev
11159	S: Supported	11159	S: Supported
11160	T: git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git	11160	T: git git://git.kernel.org/pub/scm/linux/kernel/git/iommu/linux.git
11161	F: drivers/iommu/intel/	11161	F: drivers/iommu/intel/
11162		11162
11163	INTEL IPU3 CSI-2 CIO2 DRIVER	11163	INTEL IPU3 CSI-2 CIO2 DRIVER
@@ -11530,7 +11530,7 @@ IOMMU DMA-API LAYER · 366 unmodified lines
11530	M: Robin Murphy <robin.murphy@arm.com>	11530	M: Robin Murphy <robin.murphy@arm.com>
11531	L: iommu@lists.linux.dev	11531	L: iommu@lists.linux.dev
11532	S: Maintained	11532	S: Maintained
11533	T: git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git	11533	T: git git://git.kernel.org/pub/scm/linux/kernel/git/iommu/linux.git
11534	F: drivers/iommu/dma-iommu.c	11534	F: drivers/iommu/dma-iommu.c
11535	F: drivers/iommu/dma-iommu.h	11535	F: drivers/iommu/dma-iommu.h
11536	F: drivers/iommu/iova.c	11536	F: drivers/iommu/iova.c
@@ -11542,7 +11542,7 @@ M: Will Deacon <will@kernel.org> · 5 unmodified lines
11542	R: Robin Murphy <robin.murphy@arm.com>	11542	R: Robin Murphy <robin.murphy@arm.com>
11543	L: iommu@lists.linux.dev	11543	L: iommu@lists.linux.dev
11544	S: Maintained	11544	S: Maintained
11545	T: git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git	11545	T: git git://git.kernel.org/pub/scm/linux/kernel/git/iommu/linux.git
11546	F: Documentation/devicetree/bindings/iommu/	11546	F: Documentation/devicetree/bindings/iommu/
11547	F: Documentation/userspace-api/iommu.rst	11547	F: Documentation/userspace-api/iommu.rst
11548	F: drivers/iommu/	11548	F: drivers/iommu/
@@ -19324,7 +19324,7 @@ F: drivers/perf/riscv_pmu_legacy.c · 7775 unmodified lines
19324	F: drivers/perf/riscv_pmu_sbi.c	19324	F: drivers/perf/riscv_pmu_sbi.c
19325		19325
19326	RISC-V THEAD SoC SUPPORT	19326	RISC-V THEAD SoC SUPPORT
19327	M: Jisheng Zhang <jszhang@kernel.org>	19327	M: Drew Fustini <drew@pdp7.com>
19328	M: Guo Ren <guoren@kernel.org>	19328	M: Guo Ren <guoren@kernel.org>
19329	M: Fu Wei <wefu@redhat.com>	19329	M: Fu Wei <wefu@redhat.com>
19330	L: linux-riscv@lists.infradead.org	19330	L: linux-riscv@lists.infradead.org

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 6	2	VERSION = 6
3	PATCHLEVEL = 10	3	PATCHLEVEL = 10
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc5	5	EXTRAVERSION = -rc6
6	NAME = Baby Opossum Posse	6	NAME = Baby Opossum Posse
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/rockchip/rk3066a.dtsi+1−0

@@ -128,6 +128,7 @@ · 127 unmodified lines
128	pinctrl-0 = <&hdmii2c_xfer>, <&hdmi_hpd>;	128	pinctrl-0 = <&hdmii2c_xfer>, <&hdmi_hpd>;
129	power-domains = <&power RK3066_PD_VIO>;	129	power-domains = <&power RK3066_PD_VIO>;
130	rockchip,grf = <&grf>;	130	rockchip,grf = <&grf>;
		131	#sound-dai-cells = <0>;
131	status = "disabled";	132	status = "disabled";
132		133
133	ports {	134	ports {

arch/arm64/boot/dts/rockchip/rk3308-rock-pi-s.dts+13−5

  */
 /dts-v1/;
+#include <dt-bindings/leds/common.h>
 #include "rk3308.dtsi"
 / {
 	leds {
 		compatible = "gpio-leds";
 		pinctrl-names = "default";
-		pinctrl-0 = <&green_led_gio>, <&heartbeat_led_gpio>;
+		pinctrl-0 = <&green_led>, <&heartbeat_led>;
 		green-led {
+			color = <LED_COLOR_ID_GREEN>;
 			default-state = "on";
+			function = LED_FUNCTION_POWER;
 			gpios = <&gpio0 RK_PA6 GPIO_ACTIVE_HIGH>;
 			label = "rockpis:green:power";
 			linux,default-trigger = "default-on";
 		};
 		blue-led {
+			color = <LED_COLOR_ID_BLUE>;
 			default-state = "on";
+			function = LED_FUNCTION_HEARTBEAT;
 			gpios = <&gpio0 RK_PA5 GPIO_ACTIVE_HIGH>;
 			label = "rockpis:blue:user";
 			linux,default-trigger = "heartbeat";
 };
 &emmc {
-	bus-width = <4>;
 	cap-mmc-highspeed;
-	mmc-hs200-1_8v;
+	cap-sd-highspeed;
+	no-sdio;
 	non-removable;
+	pinctrl-names = "default";
+	pinctrl-0 = <&emmc_bus8 &emmc_clk &emmc_cmd>;
 	vmmc-supply = <&vcc_io>;
 	status = "okay";
 };
 	pinctrl-0 = <&rtc_32k>;
 	leds {
-		green_led_gio: green-led-gpio {
+		green_led: green-led {
 			rockchip,pins = <0 RK_PA6 RK_FUNC_GPIO &pcfg_pull_none>;
 		};
-		heartbeat_led_gpio: heartbeat-led-gpio {
+		heartbeat_led: heartbeat-led {
 			rockchip,pins = <0 RK_PA5 RK_FUNC_GPIO &pcfg_pull_none>;
 		};
 	};

arch/arm64/boot/dts/rockchip/rk3308.dtsi+1−1

@@ -811,7 +811,7 @@ · 810 unmodified lines
811	clocks = <&cru SCLK_I2S2_8CH_TX_OUT>,	811	clocks = <&cru SCLK_I2S2_8CH_TX_OUT>,
812	<&cru SCLK_I2S2_8CH_RX_OUT>,	812	<&cru SCLK_I2S2_8CH_RX_OUT>,
813	<&cru PCLK_ACODEC>;	813	<&cru PCLK_ACODEC>;
814	reset-names = "codec-reset";	814	reset-names = "codec";
815	resets = <&cru SRST_ACODEC_P>;	815	resets = <&cru SRST_ACODEC_P>;
816	#sound-dai-cells = <0>;	816	#sound-dai-cells = <0>;
817	status = "disabled";	817	status = "disabled";

arch/arm64/boot/dts/rockchip/rk3328-rock-pi-e.dts+2−2

@@ -241,8 +241,8 @@ · 240 unmodified lines
241	rk805: pmic@18 {	241	rk805: pmic@18 {
242	compatible = "rockchip,rk805";	242	compatible = "rockchip,rk805";
243	reg = <0x18>;	243	reg = <0x18>;
244	interrupt-parent = <&gpio2>;	244	interrupt-parent = <&gpio0>;
245	interrupts = <6 IRQ_TYPE_LEVEL_LOW>;	245	interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
246	#clock-cells = <1>;	246	#clock-cells = <1>;
247	clock-output-names = "xin32k", "rk805-clkout2";	247	clock-output-names = "xin32k", "rk805-clkout2";
248	gpio-controller;	248	gpio-controller;

arch/arm64/boot/dts/rockchip/rk3368.dtsi+3−0

 		dma-names = "tx";
 		pinctrl-names = "default";
 		pinctrl-0 = <&spdif_tx>;
+		#sound-dai-cells = <0>;
 		status = "disabled";
 	};
 		clocks = <&cru SCLK_I2S_2CH>, <&cru HCLK_I2S_2CH>;
 		dmas = <&dmac_bus 6>, <&dmac_bus 7>;
 		dma-names = "tx", "rx";
+		#sound-dai-cells = <0>;
 		status = "disabled";
 	};
 		dma-names = "tx", "rx";
 		pinctrl-names = "default";
 		pinctrl-0 = <&i2s_8ch_bus>;
+		#sound-dai-cells = <0>;
 		status = "disabled";
 	};

arch/arm64/boot/dts/rockchip/rk3399-gru.dtsi+1−1

@@ -450,7 +450,7 @@ ap_i2c_audio: &i2c8 { · 449 unmodified lines
450	dlg,btn-cfg = <50>;	450	dlg,btn-cfg = <50>;
451	dlg,mic-det-thr = <500>;	451	dlg,mic-det-thr = <500>;
452	dlg,jack-ins-deb = <20>;	452	dlg,jack-ins-deb = <20>;
453	dlg,jack-det-rate = "32ms_64ms";	453	dlg,jack-det-rate = "32_64";
454	dlg,jack-rem-deb = <1>;	454	dlg,jack-rem-deb = <1>;
455		455
456	dlg,a-d-btn-thr = <0xa>;	456	dlg,a-d-btn-thr = <0xa>;

arch/arm64/boot/dts/rockchip/rk3566-quartz64-b.dts+1−1

@@ -289,7 +289,7 @@ · 288 unmodified lines
289	regulator-name = "vdd_gpu";	289	regulator-name = "vdd_gpu";
290	regulator-always-on;	290	regulator-always-on;
291	regulator-boot-on;	291	regulator-boot-on;
292	regulator-min-microvolt = <900000>;	292	regulator-min-microvolt = <500000>;
293	regulator-max-microvolt = <1350000>;	293	regulator-max-microvolt = <1350000>;
294	regulator-ramp-delay = <6001>;	294	regulator-ramp-delay = <6001>;
295		295

arch/arm64/boot/dts/rockchip/rk3588-orangepi-5-plus.dts+1−0

@@ -444,6 +444,7 @@ · 443 unmodified lines
444	&sdmmc {	444	&sdmmc {
445	bus-width = <4>;	445	bus-width = <4>;
446	cap-sd-highspeed;	446	cap-sd-highspeed;
		447	cd-gpios = <&gpio0 RK_PA4 GPIO_ACTIVE_LOW>;
447	disable-wp;	448	disable-wp;
448	max-frequency = <150000000>;	449	max-frequency = <150000000>;
449	no-sdio;	450	no-sdio;

arch/arm64/boot/dts/rockchip/rk3588-quartzpro64.dts+1−0

@@ -435,6 +435,7 @@ · 434 unmodified lines
435	&sdmmc {	435	&sdmmc {
436	bus-width = <4>;	436	bus-width = <4>;
437	cap-sd-highspeed;	437	cap-sd-highspeed;
		438	cd-gpios = <&gpio0 RK_PA4 GPIO_ACTIVE_LOW>;
438	disable-wp;	439	disable-wp;
439	max-frequency = <150000000>;	440	max-frequency = <150000000>;
440	no-sdio;	441	no-sdio;

arch/arm64/boot/dts/rockchip/rk3588-rock-5b.dts+1−0

@@ -383,6 +383,7 @@ · 382 unmodified lines
383	bus-width = <4>;	383	bus-width = <4>;
384	cap-mmc-highspeed;	384	cap-mmc-highspeed;
385	cap-sd-highspeed;	385	cap-sd-highspeed;
		386	cd-gpios = <&gpio0 RK_PA4 GPIO_ACTIVE_LOW>;
386	disable-wp;	387	disable-wp;
387	sd-uhs-sdr104;	388	sd-uhs-sdr104;
388	vmmc-supply = <&vcc_3v3_s3>;	389	vmmc-supply = <&vcc_3v3_s3>;

arch/arm64/boot/dts/rockchip/rk3588-tiger.dtsi+5−0

 	};
 };
+&pwm0 {
+	pinctrl-0 = <&pwm0m1_pins>;
+	pinctrl-names = "default";
+};
 &saradc {
 	vref-supply = <&vcc_1v8_s0>;
 	status = "okay";

arch/arm64/boot/dts/rockchip/rk3588s-coolpi-4b.dts+2−2

@@ -288,9 +288,9 @@ · 287 unmodified lines
288	pinctrl-0 = <&i2c7m0_xfer>;	288	pinctrl-0 = <&i2c7m0_xfer>;
289	status = "okay";	289	status = "okay";
290		290
291	es8316: audio-codec@11 {	291	es8316: audio-codec@10 {
292	compatible = "everest,es8316";	292	compatible = "everest,es8316";
293	reg = <0x11>;	293	reg = <0x10>;
294	assigned-clocks = <&cru I2S0_8CH_MCLKOUT>;	294	assigned-clocks = <&cru I2S0_8CH_MCLKOUT>;
295	assigned-clock-rates = <12288000>;	295	assigned-clock-rates = <12288000>;
296	clocks = <&cru I2S0_8CH_MCLKOUT>;	296	clocks = <&cru I2S0_8CH_MCLKOUT>;

arch/arm64/boot/dts/rockchip/rk3588s-rock-5a.dts+2−0

 	bus-width = <4>;
 	cap-mmc-highspeed;
 	cap-sd-highspeed;
+	cd-gpios = <&gpio0 RK_PA4 GPIO_ACTIVE_LOW>;
 	disable-wp;
 	max-frequency = <150000000>;
 	no-sdio;
 		pinctrl-0 = <&pmic_pins>, <&rk806_dvs1_null>,
 			    <&rk806_dvs2_null>, <&rk806_dvs3_null>;
 		spi-max-frequency = <1000000>;
+		system-power-controller;
 		vcc1-supply = <&vcc5v0_sys>;
 		vcc2-supply = <&vcc5v0_sys>;

arch/arm64/include/asm/pgtable-hwdef.h+1−0

@@ -170,6 +170,7 @@ · 169 unmodified lines
170	#define PTE_CONT (_AT(pteval_t, 1) << 52) /* Contiguous range */	170	#define PTE_CONT (_AT(pteval_t, 1) << 52) /* Contiguous range */
171	#define PTE_PXN (_AT(pteval_t, 1) << 53) /* Privileged XN */	171	#define PTE_PXN (_AT(pteval_t, 1) << 53) /* Privileged XN */
172	#define PTE_UXN (_AT(pteval_t, 1) << 54) /* User XN */	172	#define PTE_UXN (_AT(pteval_t, 1) << 54) /* User XN */
		173	#define PTE_SWBITS_MASK _AT(pteval_t, (BIT(63) \| GENMASK(58, 55)))
173		174
174	#define PTE_ADDR_LOW (((_AT(pteval_t, 1) << (50 - PAGE_SHIFT)) - 1) << PAGE_SHIFT)	175	#define PTE_ADDR_LOW (((_AT(pteval_t, 1) << (50 - PAGE_SHIFT)) - 1) << PAGE_SHIFT)
175	#ifdef CONFIG_ARM64_PA_BITS_52	176	#ifdef CONFIG_ARM64_PA_BITS_52

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

@@ -840,7 +840,7 @@ __SYSCALL(__NR_pselect6_time64, compat_sys_pselect6_time64) · 839 unmodified lines
840	#define __NR_ppoll_time64 414	840	#define __NR_ppoll_time64 414
841	__SYSCALL(__NR_ppoll_time64, compat_sys_ppoll_time64)	841	__SYSCALL(__NR_ppoll_time64, compat_sys_ppoll_time64)
842	#define __NR_io_pgetevents_time64 416	842	#define __NR_io_pgetevents_time64 416
843	__SYSCALL(__NR_io_pgetevents_time64, sys_io_pgetevents)	843	__SYSCALL(__NR_io_pgetevents_time64, compat_sys_io_pgetevents_time64)
844	#define __NR_recvmmsg_time64 417	844	#define __NR_recvmmsg_time64 417
845	__SYSCALL(__NR_recvmmsg_time64, compat_sys_recvmmsg_time64)	845	__SYSCALL(__NR_recvmmsg_time64, compat_sys_recvmmsg_time64)
846	#define __NR_mq_timedsend_time64 418	846	#define __NR_mq_timedsend_time64 418

arch/arm64/kernel/pi/map_kernel.c+1−1

@@ -173,7 +173,7 @@ static void __init remap_idmap_for_lpa2(void) · 172 unmodified lines
173	* Don't bother with the FDT, we no longer need it after this.	173	* Don't bother with the FDT, we no longer need it after this.
174	*/	174	*/
175	memset(init_idmap_pg_dir, 0,	175	memset(init_idmap_pg_dir, 0,
176	(u64)init_idmap_pg_dir - (u64)init_idmap_pg_end);	176	(u64)init_idmap_pg_end - (u64)init_idmap_pg_dir);
177		177
178	create_init_idmap(init_idmap_pg_dir, mask);	178	create_init_idmap(init_idmap_pg_dir, mask);
179	dsb(ishst);	179	dsb(ishst);

arch/arm64/kernel/syscall.c+7−9

 	syscall_set_return_value(current, regs, 0, ret);
 	/*
-	 * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
+	 * This value will get limited by KSTACK_OFFSET_MAX(), which is 10
-	 * but not enough for arm64 stack utilization comfort. To keep
+	 * bits. The actual entropy will be further reduced by the compiler
-	 * reasonable stack head room, reduce the maximum offset to 9 bits.
+	 * when applying stack alignment constraints: the AAPCS mandates a
+	 * 16-byte aligned SP at function boundaries, which will remove the
+	 * 4 low bits from any entropy chosen here.
 	 *
-	 * The actual entropy will be further reduced by the compiler when
+	 * The resulting 6 bits of entropy is seen in SP[9:4].
-	 * applying stack alignment constraints: the AAPCS mandates a
-	 * 16-byte (i.e. 4-bit) aligned SP at function boundaries.
-	 *
-	 * The resulting 5 bits of entropy is seen in SP[8:4].
 	 */
-	choose_random_kstack_offset(get_random_u16() & 0x1FF);
+	choose_random_kstack_offset(get_random_u16());
 }
 static inline bool has_syscall_work(unsigned long flags)

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

@@ -124,7 +124,8 @@ bool pgattr_change_is_safe(u64 old, u64 new) · 123 unmodified lines
124	* The following mapping attributes may be updated in live	124	* The following mapping attributes may be updated in live
125	* kernel mappings without the need for break-before-make.	125	* kernel mappings without the need for break-before-make.
126	*/	126	*/
127	pteval_t mask = PTE_PXN \| PTE_RDONLY \| PTE_WRITE \| PTE_NG;	127	pteval_t mask = PTE_PXN \| PTE_RDONLY \| PTE_WRITE \| PTE_NG \|
		128	PTE_SWBITS_MASK;
128		129
129	/* creating or taking down mappings is always safe */	130	/* creating or taking down mappings is always safe */
130	if (!pte_valid(__pte(old)) \|\| !pte_valid(__pte(new)))	131	if (!pte_valid(__pte(old)) \|\| !pte_valid(__pte(new)))

arch/csky/include/uapi/asm/unistd.h+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#define __ARCH_WANT_SYS_CLONE3	6	#define __ARCH_WANT_SYS_CLONE3
7	#define __ARCH_WANT_SET_GET_RLIMIT	7	#define __ARCH_WANT_SET_GET_RLIMIT
8	#define __ARCH_WANT_TIME32_SYSCALLS	8	#define __ARCH_WANT_TIME32_SYSCALLS
		9	#define __ARCH_WANT_SYNC_FILE_RANGE2
9	#include <asm-generic/unistd.h>	10	#include <asm-generic/unistd.h>
10		11
11	#define __NR_set_thread_area (__NR_arch_specific_syscall + 0)	12	#define __NR_set_thread_area (__NR_arch_specific_syscall + 0)

arch/csky/kernel/syscall.c+1−1

@@ -20,7 +20,7 @@ SYSCALL_DEFINE6(mmap2, · 19 unmodified lines
20	unsigned long, prot,	20	unsigned long, prot,
21	unsigned long, flags,	21	unsigned long, flags,
22	unsigned long, fd,	22	unsigned long, fd,
23	off_t, offset)	23	unsigned long, offset)
24	{	24	{
25	if (unlikely(offset & (~PAGE_MASK >> 12)))	25	if (unlikely(offset & (~PAGE_MASK >> 12)))
26	return -EINVAL;	26	return -EINVAL;

arch/hexagon/include/asm/syscalls.h+6−0

@@ -0,0 +1,6 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2
	3	#include <asm-generic/syscalls.h>
	4
	5	asmlinkage long sys_hexagon_fadvise64_64(int fd, int advice,
	6	u32 a2, u32 a3, u32 a4, u32 a5);

arch/hexagon/include/uapi/asm/unistd.h+1−0

@@ -36,5 +36,6 @@ · 35 unmodified lines
36	#define __ARCH_WANT_SYS_VFORK	36	#define __ARCH_WANT_SYS_VFORK
37	#define __ARCH_WANT_SYS_FORK	37	#define __ARCH_WANT_SYS_FORK
38	#define __ARCH_WANT_TIME32_SYSCALLS	38	#define __ARCH_WANT_TIME32_SYSCALLS
		39	#define __ARCH_WANT_SYNC_FILE_RANGE2
39		40
40	#include <asm-generic/unistd.h>	41	#include <asm-generic/unistd.h>

arch/hexagon/kernel/syscalltab.c+7−0

@@ -14,6 +14,13 @@ · 13 unmodified lines
14	#undef __SYSCALL	14	#undef __SYSCALL
15	#define __SYSCALL(nr, call) [nr] = (call),	15	#define __SYSCALL(nr, call) [nr] = (call),
16		16
		17	SYSCALL_DEFINE6(hexagon_fadvise64_64, int, fd, int, advice,
		18	SC_ARG64(offset), SC_ARG64(len))
		19	{
		20	return ksys_fadvise64_64(fd, SC_VAL64(loff_t, offset), SC_VAL64(loff_t, len), advice);
		21	}
		22	#define sys_fadvise64_64 sys_hexagon_fadvise64_64
		23
17	void *sys_call_table[__NR_syscalls] = {	24	void *sys_call_table[__NR_syscalls] = {
18	#include <asm/unistd.h>	25	#include <asm/unistd.h>
19	};	26	};

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

@@ -22,7 +22,7 @@ · 21 unmodified lines
22	#define __SYSCALL(nr, call) [nr] = (call),	22	#define __SYSCALL(nr, call) [nr] = (call),
23		23
24	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len, unsigned long,	24	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len, unsigned long,
25	prot, unsigned long, flags, unsigned long, fd, off_t, offset)	25	prot, unsigned long, flags, unsigned long, fd, unsigned long, offset)
26	{	26	{
27	if (offset & ~PAGE_MASK)	27	if (offset & ~PAGE_MASK)
28	return -EINVAL;	28	return -EINVAL;

arch/microblaze/kernel/sys_microblaze.c+1−1

@@ -35,7 +35,7 @@ · 34 unmodified lines
35		35
36	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,	36	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
37	unsigned long, prot, unsigned long, flags, unsigned long, fd,	37	unsigned long, prot, unsigned long, flags, unsigned long, fd,
38	off_t, pgoff)	38	unsigned long, pgoff)
39	{	39	{
40	if (pgoff & ~PAGE_MASK)	40	if (pgoff & ~PAGE_MASK)
41	return -EINVAL;	41	return -EINVAL;

arch/mips/kernel/syscalls/syscall_n32.tbl+1−1

@@ -354,7 +354,7 @@ · 353 unmodified lines
354	412 n32 utimensat_time64 sys_utimensat	354	412 n32 utimensat_time64 sys_utimensat
355	413 n32 pselect6_time64 compat_sys_pselect6_time64	355	413 n32 pselect6_time64 compat_sys_pselect6_time64
356	414 n32 ppoll_time64 compat_sys_ppoll_time64	356	414 n32 ppoll_time64 compat_sys_ppoll_time64
357	416 n32 io_pgetevents_time64 sys_io_pgetevents	357	416 n32 io_pgetevents_time64 compat_sys_io_pgetevents_time64
358	417 n32 recvmmsg_time64 compat_sys_recvmmsg_time64	358	417 n32 recvmmsg_time64 compat_sys_recvmmsg_time64
359	418 n32 mq_timedsend_time64 sys_mq_timedsend	359	418 n32 mq_timedsend_time64 sys_mq_timedsend
360	419 n32 mq_timedreceive_time64 sys_mq_timedreceive	360	419 n32 mq_timedreceive_time64 sys_mq_timedreceive

arch/mips/kernel/syscalls/syscall_o32.tbl+1−1

@@ -403,7 +403,7 @@ · 402 unmodified lines
403	412 o32 utimensat_time64 sys_utimensat sys_utimensat	403	412 o32 utimensat_time64 sys_utimensat sys_utimensat
404	413 o32 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64	404	413 o32 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64
405	414 o32 ppoll_time64 sys_ppoll compat_sys_ppoll_time64	405	414 o32 ppoll_time64 sys_ppoll compat_sys_ppoll_time64
406	416 o32 io_pgetevents_time64 sys_io_pgetevents sys_io_pgetevents	406	416 o32 io_pgetevents_time64 sys_io_pgetevents compat_sys_io_pgetevents_time64
407	417 o32 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64	407	417 o32 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64
408	418 o32 mq_timedsend_time64 sys_mq_timedsend sys_mq_timedsend	408	418 o32 mq_timedsend_time64 sys_mq_timedsend sys_mq_timedsend
409	419 o32 mq_timedreceive_time64 sys_mq_timedreceive sys_mq_timedreceive	409	419 o32 mq_timedreceive_time64 sys_mq_timedreceive sys_mq_timedreceive

arch/parisc/Kconfig+1−0

@@ -16,6 +16,7 @@ config PARISC · 15 unmodified lines
16	select ARCH_HAS_UBSAN	16	select ARCH_HAS_UBSAN
17	select ARCH_HAS_PTE_SPECIAL	17	select ARCH_HAS_PTE_SPECIAL
18	select ARCH_NO_SG_CHAIN	18	select ARCH_NO_SG_CHAIN
		19	select ARCH_SPLIT_ARG64 if !64BIT
19	select ARCH_SUPPORTS_HUGETLBFS if PA20	20	select ARCH_SUPPORTS_HUGETLBFS if PA20
20	select ARCH_SUPPORTS_MEMORY_FAILURE	21	select ARCH_SUPPORTS_MEMORY_FAILURE
21	select ARCH_STACKWALK	22	select ARCH_STACKWALK

arch/parisc/kernel/sys_parisc32.c+0−9

@@ -23,12 +23,3 @@ asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23, · 22 unmodified lines
23	current->comm, current->pid, r20);	23	current->comm, current->pid, r20);
24	return -ENOSYS;	24	return -ENOSYS;
25	}	25	}
26
27	asmlinkage long sys32_fanotify_mark(compat_int_t fanotify_fd, compat_uint_t flags,
28	compat_uint_t mask0, compat_uint_t mask1, compat_int_t dfd,
29	const char __user * pathname)
30	{
31	return sys_fanotify_mark(fanotify_fd, flags,
32	((__u64)mask1 << 32) \| mask0,
33	dfd, pathname);
34	}

arch/parisc/kernel/syscalls/syscall.tbl+3−3

arch/powerpc/kernel/syscalls/syscall.tbl+5−1

 178	nospu 	rt_sigsuspend			sys_rt_sigsuspend		compat_sys_rt_sigsuspend
 179	32	pread64				sys_ppc_pread64			compat_sys_ppc_pread64
 179	64	pread64				sys_pread64
+179	spu	pread64				sys_pread64
 180	32	pwrite64			sys_ppc_pwrite64		compat_sys_ppc_pwrite64
 180	64	pwrite64			sys_pwrite64
+180	spu	pwrite64			sys_pwrite64
 181	common	chown				sys_chown
 182	common	getcwd				sys_getcwd
 183	common	capget				sys_capget
 190	common	ugetrlimit			sys_getrlimit			compat_sys_getrlimit
 191	32	readahead			sys_ppc_readahead		compat_sys_ppc_readahead
 191	64	readahead			sys_readahead
+191	spu	readahead			sys_readahead
 192	32	mmap2				sys_mmap2			compat_sys_mmap2
 193	32	truncate64			sys_ppc_truncate64		compat_sys_ppc_truncate64
 194	32	ftruncate64			sys_ppc_ftruncate64		compat_sys_ppc_ftruncate64
 232	nospu	set_tid_address			sys_set_tid_address
 233	32	fadvise64			sys_ppc32_fadvise64		compat_sys_ppc32_fadvise64
 233	64	fadvise64			sys_fadvise64
+233	spu	fadvise64			sys_fadvise64
 234	nospu	exit_group			sys_exit_group
 235	nospu	lookup_dcookie			sys_ni_syscall
 236	common	epoll_create			sys_epoll_create
 412	32	utimensat_time64		sys_utimensat			sys_utimensat
 413	32	pselect6_time64			sys_pselect6			compat_sys_pselect6_time64
 414	32	ppoll_time64			sys_ppoll			compat_sys_ppoll_time64
-416	32	io_pgetevents_time64		sys_io_pgetevents		sys_io_pgetevents
+416	32	io_pgetevents_time64		sys_io_pgetevents		compat_sys_io_pgetevents_time64
 417	32	recvmmsg_time64			sys_recvmmsg			compat_sys_recvmmsg_time64
 418	32	mq_timedsend_time64		sys_mq_timedsend		sys_mq_timedsend
 419	32	mq_timedreceive_time64		sys_mq_timedreceive		sys_mq_timedreceive

arch/riscv/boot/dts/canaan/canaan_kd233.dts+6−1

 	model = "Kendryte KD233";
 	compatible = "canaan,kendryte-kd233", "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 &fpioa {
 	pinctrl-0 = <&jtag_pinctrl>;
 	pinctrl-names = "default";
-	status = "okay";
 	jtag_pinctrl: jtag-pinmux {
 		pinmux = <K210_FPIOA(0, K210_PCF_JTAG_TCLK)>,
 	#sound-dai-cells = <1>;
 	pinctrl-0 = <&i2s0_pinctrl>;
 	pinctrl-names = "default";
+	status = "okay";
 };
 &spi0 {
 	pinctrl-names = "default";
 	num-cs = <1>;
 	cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>;
+	status = "okay";
 	panel@0 {
 		compatible = "canaan,kd233-tft", "ilitek,ili9341";

arch/riscv/boot/dts/canaan/k210.dtsi+16−7

 	#size-cells = <1>;
 	compatible = "canaan,kendryte-k210";
-	aliases {
-		serial0 = &uarths0;
-		serial1 = &uart1;
-		serial2 = &uart2;
-		serial3 = &uart3;
-	};
 	/*
 	 * The K210 has an sv39 MMU following the privileged specification v1.9.
 	 * Since this is a non-ratified draft specification, the kernel does not
 			reg = <0x38000000 0x1000>;
 			interrupts = <33>;
 			clocks = <&sysclk K210_CLK_CPU>;
+			status = "disabled";
 		};
 		gpio0: gpio-controller@38001000 {
 				     <62>, <63>, <64>, <65>;
 			gpio-controller;
 			ngpios = <32>;
+			status = "disabled";
 		};
 		dmac0: dma-controller@50000000 {
 					 <&sysclk K210_CLK_GPIO>;
 				clock-names = "bus", "db";
 				resets = <&sysrst K210_RST_GPIO>;
+				status = "disabled";
 				gpio1_0: gpio-port@0 {
 					#gpio-cells = <2>;
 				dsr-override;
 				cts-override;
 				ri-override;
+				status = "disabled";
 			};
 			uart2: serial@50220000 {
 				dsr-override;
 				cts-override;
 				ri-override;
+				status = "disabled";
 			};
 			uart3: serial@50230000 {
 				dsr-override;
 				cts-override;
 				ri-override;
+				status = "disabled";
 			};
 			spi2: spi@50240000 {
 					 <&sysclk K210_CLK_APB0>;
 				clock-names = "ssi_clk", "pclk";
 				resets = <&sysrst K210_RST_SPI2>;
+				status = "disabled";
 			};
 			i2s0: i2s@50250000 {
 				clocks = <&sysclk K210_CLK_I2S0>;
 				clock-names = "i2sclk";
 				resets = <&sysrst K210_RST_I2S0>;
+				status = "disabled";
 			};
 			i2s1: i2s@50260000 {
 				clocks = <&sysclk K210_CLK_I2S1>;
 				clock-names = "i2sclk";
 				resets = <&sysrst K210_RST_I2S1>;
+				status = "disabled";
 			};
 			i2s2: i2s@50270000 {
 				clocks = <&sysclk K210_CLK_I2S2>;
 				clock-names = "i2sclk";
 				resets = <&sysrst K210_RST_I2S2>;
+				status = "disabled";
 			};
 			i2c0: i2c@50280000 {
 					 <&sysclk K210_CLK_APB0>;
 				clock-names = "ref", "pclk";
 				resets = <&sysrst K210_RST_I2C0>;
+				status = "disabled";
 			};
 			i2c1: i2c@50290000 {
 					 <&sysclk K210_CLK_APB0>;
 				clock-names = "ref", "pclk";
 				resets = <&sysrst K210_RST_I2C1>;
+				status = "disabled";
 			};
 			i2c2: i2c@502a0000 {
 					 <&sysclk K210_CLK_APB0>;
 				clock-names = "ref", "pclk";
 				resets = <&sysrst K210_RST_I2C2>;
+				status = "disabled";
 			};
 			fpioa: pinmux@502b0000 {
 				reset-names = "spi";
 				num-cs = <4>;
 				reg-io-width = <4>;
+				status = "disabled";
 			};
 			spi1: spi@53000000 {
 				reset-names = "spi";
 				num-cs = <4>;
 				reg-io-width = <4>;
+				status = "disabled";
 			};
 			spi3: spi@54000000 {
 				num-cs = <4>;
 				reg-io-width = <4>;
+				status = "disabled";
 			};
 		};
 	};

arch/riscv/boot/dts/canaan/k210_generic.dts+4−1

 	model = "Kendryte K210 generic";
 	compatible = "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 &fpioa {
 	pinctrl-0 = <&jtag_pins>;
 	pinctrl-names = "default";
-	status = "okay";
 	jtag_pins: jtag-pinmux {
 		pinmux = <K210_FPIOA(0, K210_PCF_JTAG_TCLK)>,

arch/riscv/boot/dts/canaan/sipeed_maix_bit.dts+8−1

 	compatible = "sipeed,maix-bit", "sipeed,maix-bitm",
 		     "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 &fpioa {
 	pinctrl-names = "default";
 	pinctrl-0 = <&jtag_pinctrl>;
-	status = "okay";
 	jtag_pinctrl: jtag-pinmux {
 		pinmux = <K210_FPIOA(0, K210_PCF_JTAG_TCLK)>,
 	#sound-dai-cells = <1>;
 	pinctrl-0 = <&i2s0_pinctrl>;
 	pinctrl-names = "default";
+	status = "okay";
 };
 &i2c1 {
 	pinctrl-names = "default";
 	num-cs = <1>;
 	cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>;
+	status = "okay";
 	panel@0 {
 		compatible = "sitronix,st7789v";
 };
 &spi3 {
+	status = "okay";
 	flash@0 {
 		compatible = "jedec,spi-nor";
 		reg = <0>;

arch/riscv/boot/dts/canaan/sipeed_maix_dock.dts+6−1

 	compatible = "sipeed,maix-dock-m1", "sipeed,maix-dock-m1w",
 		     "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 &fpioa {
 	pinctrl-0 = <&jtag_pinctrl>;
 	pinctrl-names = "default";
-	status = "okay";
 	jtag_pinctrl: jtag-pinmux {
 		pinmux = <K210_FPIOA(0, K210_PCF_JTAG_TCLK)>,
 	#sound-dai-cells = <1>;
 	pinctrl-0 = <&i2s0_pinctrl>;
 	pinctrl-names = "default";
+	status = "okay";
 };
 &i2c1 {
 	pinctrl-names = "default";
 	num-cs = <1>;
 	cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>;
+	status = "okay";
 	panel@0 {
 		compatible = "sitronix,st7789v";

arch/riscv/boot/dts/canaan/sipeed_maix_go.dts+8−1

 	model = "SiPeed MAIX GO";
 	compatible = "sipeed,maix-go", "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 &fpioa {
 	pinctrl-0 = <&jtag_pinctrl>;
 	pinctrl-names = "default";
-	status = "okay";
 	jtag_pinctrl: jtag-pinmux {
 		pinmux = <K210_FPIOA(0, K210_PCF_JTAG_TCLK)>,
 	#sound-dai-cells = <1>;
 	pinctrl-0 = <&i2s0_pinctrl>;
 	pinctrl-names = "default";
+	status = "okay";
 };
 &i2c1 {
 	pinctrl-names = "default";
 	num-cs = <1>;
 	cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>;
+	status = "okay";
 	panel@0 {
 		compatible = "sitronix,st7789v";
 };
 &spi3 {
+	status = "okay";
 	flash@0 {
 		compatible = "jedec,spi-nor";
 		reg = <0>;

arch/riscv/boot/dts/canaan/sipeed_maixduino.dts+8−2

 	model = "SiPeed MAIXDUINO";
 	compatible = "sipeed,maixduino", "canaan,kendryte-k210";
+	aliases {
+		serial0 = &uarths0;
+	};
 	chosen {
 		bootargs = "earlycon console=ttySIF0";
 		stdout-path = "serial0:115200n8";
 };
 &fpioa {
-	status = "okay";
 	uarths_pinctrl: uarths-pinmux {
 		pinmux = <K210_FPIOA(4, K210_PCF_UARTHS_RX)>, /* Header "0" */
 			 <K210_FPIOA(5, K210_PCF_UARTHS_TX)>; /* Header "1" */
 	#sound-dai-cells = <1>;
 	pinctrl-0 = <&i2s0_pinctrl>;
 	pinctrl-names = "default";
+	status = "okay";
 };
 &i2c1 {
 	pinctrl-names = "default";
 	num-cs = <1>;
 	cs-gpios = <&gpio0 20 GPIO_ACTIVE_HIGH>;
+	status = "okay";
 	panel@0 {
 		compatible = "sitronix,st7789v";
 };
 &spi3 {
+	status = "okay";
 	flash@0 {
 		compatible = "jedec,spi-nor";
 		reg = <0>;

arch/riscv/boot/dts/starfive/jh7110-common.dtsi+1−1

@@ -244,7 +244,7 @@ · 243 unmodified lines
244	regulator-boot-on;	244	regulator-boot-on;
245	regulator-always-on;	245	regulator-always-on;
246	regulator-min-microvolt = <1800000>;	246	regulator-min-microvolt = <1800000>;
247	regulator-max-microvolt = <1800000>;	247	regulator-max-microvolt = <3300000>;
248	regulator-name = "emmc_vdd";	248	regulator-name = "emmc_vdd";
249	};	249	};
250	};	250	};

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

@@ -145,7 +145,7 @@ · 144 unmodified lines
145		145
146	/* parts of opcode for RVF, RVD and RVQ */	146	/* parts of opcode for RVF, RVD and RVQ */
147	#define RVFDQ_FL_FS_WIDTH_OFF 12	147	#define RVFDQ_FL_FS_WIDTH_OFF 12
148	#define RVFDQ_FL_FS_WIDTH_MASK GENMASK(3, 0)	148	#define RVFDQ_FL_FS_WIDTH_MASK GENMASK(2, 0)
149	#define RVFDQ_FL_FS_WIDTH_W 2	149	#define RVFDQ_FL_FS_WIDTH_W 2
150	#define RVFDQ_FL_FS_WIDTH_D 3	150	#define RVFDQ_FL_FS_WIDTH_D 3
151	#define RVFDQ_LS_FS_WIDTH_Q 4	151	#define RVFDQ_LS_FS_WIDTH_Q 4

arch/riscv/kernel/ftrace.c+2−5

 	out = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
 	mutex_unlock(&text_mutex);
-	if (!mod)
-		local_flush_icache_range(rec->ip, rec->ip + MCOUNT_INSN_SIZE);
 	return out;
 }
 	} else {
 		while (atomic_read(&param->cpu_count) <= num_online_cpus())
 			cpu_relax();
-	}
-	local_flush_icache_all();
+		local_flush_icache_all();
+	}
 	return 0;
 }

arch/riscv/kernel/patch.c+18−8

 	memset(waddr, c, len);
+	/*
+	 * We could have just patched a function that is about to be
+	 * called so make sure we don't execute partially patched
+	 * instructions by flushing the icache as soon as possible.
+	 */
+	local_flush_icache_range((unsigned long)waddr,
+				 (unsigned long)waddr + len);
 	patch_unmap(FIX_TEXT_POKE0);
 	if (across_pages)
 	ret = copy_to_kernel_nofault(waddr, insn, len);
+	/*
+	 * We could have just patched a function that is about to be
+	 * called so make sure we don't execute partially patched
+	 * instructions by flushing the icache as soon as possible.
+	 */
+	local_flush_icache_range((unsigned long)waddr,
+				 (unsigned long)waddr + len);
 	patch_unmap(FIX_TEXT_POKE0);
 	if (across_pages)
 	ret = patch_insn_set(tp, c, len);
-	if (!ret)
-		flush_icache_range((uintptr_t)tp, (uintptr_t)tp + len);
 	return ret;
 }
 NOKPROBE_SYMBOL(patch_text_set_nosync);
 	ret = patch_insn_write(tp, insns, len);
-	if (!ret)
-		flush_icache_range((uintptr_t) tp, (uintptr_t) tp + len);
 	return ret;
 }
 NOKPROBE_SYMBOL(patch_text_nosync);
 	} else {
 		while (atomic_read(&patch->cpu_count) <= num_online_cpus())
 			cpu_relax();
-	}
-	local_flush_icache_all();
+		local_flush_icache_all();
+	}
 	return ret;
 }

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

@@ -156,7 +156,7 @@ unsigned long __get_wchan(struct task_struct *task) · 155 unmodified lines
156	return pc;	156	return pc;
157	}	157	}
158		158
159	noinline void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,	159	noinline noinstr void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
160	struct task_struct task, struct pt_regs regs)	160	struct task_struct task, struct pt_regs regs)
161	{	161	{
162	walk_stackframe(task, regs, consume_entry, cookie);	162	walk_stackframe(task, regs, consume_entry, cookie);

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

@@ -23,7 +23,7 @@ static long riscv_sys_mmap(unsigned long addr, unsigned long len, · 22 unmodified lines
23	#ifdef CONFIG_64BIT	23	#ifdef CONFIG_64BIT
24	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,	24	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
25	unsigned long, prot, unsigned long, flags,	25	unsigned long, prot, unsigned long, flags,
26	unsigned long, fd, off_t, offset)	26	unsigned long, fd, unsigned long, offset)
27	{	27	{
28	return riscv_sys_mmap(addr, len, prot, flags, fd, offset, 0);	28	return riscv_sys_mmap(addr, len, prot, flags, fd, offset, 0);
29	}	29	}
@@ -32,7 +32,7 @@ SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len, · 2 unmodified lines
32	#if defined(CONFIG_32BIT) \|\| defined(CONFIG_COMPAT)	32	#if defined(CONFIG_32BIT) \|\| defined(CONFIG_COMPAT)
33	SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len,	33	SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len,
34	unsigned long, prot, unsigned long, flags,	34	unsigned long, prot, unsigned long, flags,
35	unsigned long, fd, off_t, offset)	35	unsigned long, fd, unsigned long, offset)
36	{	36	{
37	/*	37	/*
38	* Note that the shift for mmap2 is constant (12),	38	* Note that the shift for mmap2 is constant (12),

arch/s390/boot/startup.c+7−4

 	u64 *entry;
 	/*
-	 * Even without -fPIE, Clang still uses a global offset table for some
+	 * Adjust GOT entries, except for ones for undefined weak symbols
-	 * reason. Adjust the GOT entries.
+	 * that resolved to zero. This also skips the first three reserved
+	 * entries on s390x that are zero.
 	 */
-	for (entry = (u64 *)vmlinux.got_start; entry < (u64 *)vmlinux.got_end; entry++)
+	for (entry = (u64 *)vmlinux.got_start; entry < (u64 *)vmlinux.got_end; entry++) {
-		*entry += offset - __START_KERNEL;
+		if (*entry)
+			*entry += offset - __START_KERNEL;
+	}
 }
 /*

arch/s390/configs/debug_defconfig+2−3

 CONFIG_WATCHDOG_NOWAYOUT=y
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
+CONFIG_DRM=m
+CONFIG_DRM_VIRTIO_GPU=m
 CONFIG_FB=y
 # CONFIG_FB_DEVICE is not set
-CONFIG_FRAMEBUFFER_CONSOLE=y
-CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID_SUPPORT is not set
 # CONFIG_USB_SUPPORT is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
 CONFIG_MLX5_INFINIBAND=m
-CONFIG_SYNC_FILE=y
 CONFIG_VFIO=m
 CONFIG_VFIO_PCI=m
 CONFIG_MLX5_VFIO_PCI=m

arch/s390/configs/defconfig+2−3

 CONFIG_WATCHDOG_NOWAYOUT=y
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
+CONFIG_DRM=m
+CONFIG_DRM_VIRTIO_GPU=m
 CONFIG_FB=y
 # CONFIG_FB_DEVICE is not set
-CONFIG_FRAMEBUFFER_CONSOLE=y
-CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_HID_SUPPORT is not set
 # CONFIG_USB_SUPPORT is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
 CONFIG_MLX5_INFINIBAND=m
-CONFIG_SYNC_FILE=y
 CONFIG_VFIO=m
 CONFIG_VFIO_PCI=m
 CONFIG_MLX5_VFIO_PCI=m

arch/s390/include/asm/entry-common.h+1−1

@@ -54,7 +54,7 @@ static __always_inline void arch_exit_to_user_mode(void) · 53 unmodified lines
54	static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,	54	static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,
55	unsigned long ti_work)	55	unsigned long ti_work)
56	{	56	{
57	choose_random_kstack_offset(get_tod_clock_fast() & 0xff);	57	choose_random_kstack_offset(get_tod_clock_fast());
58	}	58	}
59		59
60	#define arch_exit_to_user_mode_prepare arch_exit_to_user_mode_prepare	60	#define arch_exit_to_user_mode_prepare arch_exit_to_user_mode_prepare

arch/s390/kernel/syscall.c+0−27

@@ -38,33 +38,6 @@ · 37 unmodified lines
38		38
39	#include "entry.h"	39	#include "entry.h"
40		40
41	/*
42	* Perform the mmap() system call. Linux for S/390 isn't able to handle more
43	* than 5 system call parameters, so this system call uses a memory block
44	* for parameter passing.
45	*/
46
47	struct s390_mmap_arg_struct {
48	unsigned long addr;
49	unsigned long len;
50	unsigned long prot;
51	unsigned long flags;
52	unsigned long fd;
53	unsigned long offset;
54	};
55
56	SYSCALL_DEFINE1(mmap2, struct s390_mmap_arg_struct __user *, arg)
57	{
58	struct s390_mmap_arg_struct a;
59	int error = -EFAULT;
60
61	if (copy_from_user(&a, arg, sizeof(a)))
62	goto out;
63	error = ksys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);
64	out:
65	return error;
66	}
67
68	#ifdef CONFIG_SYSVIPC	41	#ifdef CONFIG_SYSVIPC
69	/*	42	/*
70	* sys_ipc() is the de-multiplexer for the SysV IPC calls.	43	* sys_ipc() is the de-multiplexer for the SysV IPC calls.

arch/s390/kernel/syscalls/syscall.tbl+1−1

@@ -418,7 +418,7 @@ · 417 unmodified lines
418	412 32 utimensat_time64 - sys_utimensat	418	412 32 utimensat_time64 - sys_utimensat
419	413 32 pselect6_time64 - compat_sys_pselect6_time64	419	413 32 pselect6_time64 - compat_sys_pselect6_time64
420	414 32 ppoll_time64 - compat_sys_ppoll_time64	420	414 32 ppoll_time64 - compat_sys_ppoll_time64
421	416 32 io_pgetevents_time64 - sys_io_pgetevents	421	416 32 io_pgetevents_time64 - compat_sys_io_pgetevents_time64
422	417 32 recvmmsg_time64 - compat_sys_recvmmsg_time64	422	417 32 recvmmsg_time64 - compat_sys_recvmmsg_time64
423	418 32 mq_timedsend_time64 - sys_mq_timedsend	423	418 32 mq_timedsend_time64 - sys_mq_timedsend
424	419 32 mq_timedreceive_time64 - sys_mq_timedreceive	424	419 32 mq_timedreceive_time64 - sys_mq_timedreceive

arch/s390/pci/pci_irq.c+1−1

@@ -410,7 +410,7 @@ static void __init cpu_enable_directed_irq(void *unused) · 409 unmodified lines
410	union zpci_sic_iib iib = {{0}};	410	union zpci_sic_iib iib = {{0}};
411	union zpci_sic_iib ziib = {{0}};	411	union zpci_sic_iib ziib = {{0}};
412		412
413	iib.cdiib.dibv_addr = (u64) zpci_ibv[smp_processor_id()]->vector;	413	iib.cdiib.dibv_addr = virt_to_phys(zpci_ibv[smp_processor_id()]->vector);
414		414
415	zpci_set_irq_ctrl(SIC_IRQ_MODE_SET_CPU, 0, &iib);	415	zpci_set_irq_ctrl(SIC_IRQ_MODE_SET_CPU, 0, &iib);
416	zpci_set_irq_ctrl(SIC_IRQ_MODE_D_SINGLE, PCI_ISC, &ziib);	416	zpci_set_irq_ctrl(SIC_IRQ_MODE_D_SINGLE, PCI_ISC, &ziib);

arch/sh/kernel/sys_sh32.c+11−0

@@ -59,3 +59,14 @@ asmlinkage int sys_fadvise64_64_wrapper(int fd, u32 offset0, u32 offset1, · 58 unmodified lines
59	(u64)len0 << 32 \| len1, advice);	59	(u64)len0 << 32 \| len1, advice);
60	#endif	60	#endif
61	}	61	}
		62
		63	/*
		64	* swap the arguments the way that libc wants them instead of
		65	* moving flags ahead of the 64-bit nbytes argument
		66	*/
		67	SYSCALL_DEFINE6(sh_sync_file_range6, int, fd, SC_ARG64(offset),
		68	SC_ARG64(nbytes), unsigned int, flags)
		69	{
		70	return ksys_sync_file_range(fd, SC_VAL64(loff_t, offset),
		71	SC_VAL64(loff_t, nbytes), flags);
		72	}

arch/sh/kernel/syscalls/syscall.tbl+2−1

 311	common	set_robust_list			sys_set_robust_list
 312	common	get_robust_list			sys_get_robust_list
 313	common	splice				sys_splice
-314	common	sync_file_range			sys_sync_file_range
+314	common	sync_file_range			sys_sh_sync_file_range6
 315	common	tee				sys_tee
 316	common	vmsplice			sys_vmsplice
 317	common	move_pages			sys_move_pages
 385	common	pkey_alloc			sys_pkey_alloc
 386	common	pkey_free			sys_pkey_free
 387	common	rseq				sys_rseq
+388	common	sync_file_range2		sys_sync_file_range2
 # room for arch specific syscalls
 393	common	semget				sys_semget
 394	common	semctl				sys_semctl

arch/sparc/kernel/sys32.S+0−221

@@ -18,224 +18,3 @@ sys32_mmap2: · 17 unmodified lines
18	sethi %hi(sys_mmap), %g1	18	sethi %hi(sys_mmap), %g1
19	jmpl %g1 + %lo(sys_mmap), %g0	19	jmpl %g1 + %lo(sys_mmap), %g0
20	sllx %o5, 12, %o5	20	sllx %o5, 12, %o5
21
22	.align 32
23	.globl sys32_socketcall
24	sys32_socketcall: /* %o0=call, %o1=args */
25	cmp %o0, 1
26	bl,pn %xcc, do_einval
27	cmp %o0, 18
28	bg,pn %xcc, do_einval
29	sub %o0, 1, %o0
30	sllx %o0, 5, %o0
31	sethi %hi(__socketcall_table_begin), %g2
32	or %g2, %lo(__socketcall_table_begin), %g2
33	jmpl %g2 + %o0, %g0
34	nop
35	do_einval:
36	retl
37	mov -EINVAL, %o0
38
39	.align 32
40	__socketcall_table_begin:
41
42	/* Each entry is exactly 32 bytes. */
43	do_sys_socket: /* sys_socket(int, int, int) */
44	1: ldswa [%o1 + 0x0] %asi, %o0
45	sethi %hi(sys_socket), %g1
46	2: ldswa [%o1 + 0x8] %asi, %o2
47	jmpl %g1 + %lo(sys_socket), %g0
48	3: ldswa [%o1 + 0x4] %asi, %o1
49	nop
50	nop
51	nop
52	do_sys_bind: /* sys_bind(int fd, struct sockaddr , int) /
53	4: ldswa [%o1 + 0x0] %asi, %o0
54	sethi %hi(sys_bind), %g1
55	5: ldswa [%o1 + 0x8] %asi, %o2
56	jmpl %g1 + %lo(sys_bind), %g0
57	6: lduwa [%o1 + 0x4] %asi, %o1
58	nop
59	nop
60	nop
61	do_sys_connect: /* sys_connect(int, struct sockaddr , int) /
62	7: ldswa [%o1 + 0x0] %asi, %o0
63	sethi %hi(sys_connect), %g1
64	8: ldswa [%o1 + 0x8] %asi, %o2
65	jmpl %g1 + %lo(sys_connect), %g0
66	9: lduwa [%o1 + 0x4] %asi, %o1
67	nop
68	nop
69	nop
70	do_sys_listen: /* sys_listen(int, int) */
71	10: ldswa [%o1 + 0x0] %asi, %o0
72	sethi %hi(sys_listen), %g1
73	jmpl %g1 + %lo(sys_listen), %g0
74	11: ldswa [%o1 + 0x4] %asi, %o1
75	nop
76	nop
77	nop
78	nop
79	do_sys_accept: /* sys_accept(int, struct sockaddr , int ) */
80	12: ldswa [%o1 + 0x0] %asi, %o0
81	sethi %hi(sys_accept), %g1
82	13: lduwa [%o1 + 0x8] %asi, %o2
83	jmpl %g1 + %lo(sys_accept), %g0
84	14: lduwa [%o1 + 0x4] %asi, %o1
85	nop
86	nop
87	nop
88	do_sys_getsockname: /* sys_getsockname(int, struct sockaddr , int ) */
89	15: ldswa [%o1 + 0x0] %asi, %o0
90	sethi %hi(sys_getsockname), %g1
91	16: lduwa [%o1 + 0x8] %asi, %o2
92	jmpl %g1 + %lo(sys_getsockname), %g0
93	17: lduwa [%o1 + 0x4] %asi, %o1
94	nop
95	nop
96	nop
97	do_sys_getpeername: /* sys_getpeername(int, struct sockaddr , int ) */
98	18: ldswa [%o1 + 0x0] %asi, %o0
99	sethi %hi(sys_getpeername), %g1
100	19: lduwa [%o1 + 0x8] %asi, %o2
101	jmpl %g1 + %lo(sys_getpeername), %g0
102	20: lduwa [%o1 + 0x4] %asi, %o1
103	nop
104	nop
105	nop
106	do_sys_socketpair: /* sys_socketpair(int, int, int, int ) /
107	21: ldswa [%o1 + 0x0] %asi, %o0
108	sethi %hi(sys_socketpair), %g1
109	22: ldswa [%o1 + 0x8] %asi, %o2
110	23: lduwa [%o1 + 0xc] %asi, %o3
111	jmpl %g1 + %lo(sys_socketpair), %g0
112	24: ldswa [%o1 + 0x4] %asi, %o1
113	nop
114	nop
115	do_sys_send: /* sys_send(int, void , size_t, unsigned int) /
116	25: ldswa [%o1 + 0x0] %asi, %o0
117	sethi %hi(sys_send), %g1
118	26: lduwa [%o1 + 0x8] %asi, %o2
119	27: lduwa [%o1 + 0xc] %asi, %o3
120	jmpl %g1 + %lo(sys_send), %g0
121	28: lduwa [%o1 + 0x4] %asi, %o1
122	nop
123	nop
124	do_sys_recv: /* sys_recv(int, void , size_t, unsigned int) /
125	29: ldswa [%o1 + 0x0] %asi, %o0
126	sethi %hi(sys_recv), %g1
127	30: lduwa [%o1 + 0x8] %asi, %o2
128	31: lduwa [%o1 + 0xc] %asi, %o3
129	jmpl %g1 + %lo(sys_recv), %g0
130	32: lduwa [%o1 + 0x4] %asi, %o1
131	nop
132	nop
133	do_sys_sendto: /* sys_sendto(int, u32, compat_size_t, unsigned int, u32, int) */
134	33: ldswa [%o1 + 0x0] %asi, %o0
135	sethi %hi(sys_sendto), %g1
136	34: lduwa [%o1 + 0x8] %asi, %o2
137	35: lduwa [%o1 + 0xc] %asi, %o3
138	36: lduwa [%o1 + 0x10] %asi, %o4
139	37: ldswa [%o1 + 0x14] %asi, %o5
140	jmpl %g1 + %lo(sys_sendto), %g0
141	38: lduwa [%o1 + 0x4] %asi, %o1
142	do_sys_recvfrom: /* sys_recvfrom(int, u32, compat_size_t, unsigned int, u32, u32) */
143	39: ldswa [%o1 + 0x0] %asi, %o0
144	sethi %hi(sys_recvfrom), %g1
145	40: lduwa [%o1 + 0x8] %asi, %o2
146	41: lduwa [%o1 + 0xc] %asi, %o3
147	42: lduwa [%o1 + 0x10] %asi, %o4
148	43: lduwa [%o1 + 0x14] %asi, %o5
149	jmpl %g1 + %lo(sys_recvfrom), %g0
150	44: lduwa [%o1 + 0x4] %asi, %o1
151	do_sys_shutdown: /* sys_shutdown(int, int) */
152	45: ldswa [%o1 + 0x0] %asi, %o0
153	sethi %hi(sys_shutdown), %g1
154	jmpl %g1 + %lo(sys_shutdown), %g0
155	46: ldswa [%o1 + 0x4] %asi, %o1
156	nop
157	nop
158	nop
159	nop
160	do_sys_setsockopt: /* sys_setsockopt(int, int, int, char , int) /
161	47: ldswa [%o1 + 0x0] %asi, %o0
162	sethi %hi(sys_setsockopt), %g1
163	48: ldswa [%o1 + 0x8] %asi, %o2
164	49: lduwa [%o1 + 0xc] %asi, %o3
165	50: ldswa [%o1 + 0x10] %asi, %o4
166	jmpl %g1 + %lo(sys_setsockopt), %g0
167	51: ldswa [%o1 + 0x4] %asi, %o1
168	nop
169	do_sys_getsockopt: /* sys_getsockopt(int, int, int, u32, u32) */
170	52: ldswa [%o1 + 0x0] %asi, %o0
171	sethi %hi(sys_getsockopt), %g1
172	53: ldswa [%o1 + 0x8] %asi, %o2
173	54: lduwa [%o1 + 0xc] %asi, %o3
174	55: lduwa [%o1 + 0x10] %asi, %o4
175	jmpl %g1 + %lo(sys_getsockopt), %g0
176	56: ldswa [%o1 + 0x4] %asi, %o1
177	nop
178	do_sys_sendmsg: /* compat_sys_sendmsg(int, struct compat_msghdr , unsigned int) /
179	57: ldswa [%o1 + 0x0] %asi, %o0
180	sethi %hi(compat_sys_sendmsg), %g1
181	58: lduwa [%o1 + 0x8] %asi, %o2
182	jmpl %g1 + %lo(compat_sys_sendmsg), %g0
183	59: lduwa [%o1 + 0x4] %asi, %o1
184	nop
185	nop
186	nop
187	do_sys_recvmsg: /* compat_sys_recvmsg(int, struct compat_msghdr , unsigned int) /
188	60: ldswa [%o1 + 0x0] %asi, %o0
189	sethi %hi(compat_sys_recvmsg), %g1
190	61: lduwa [%o1 + 0x8] %asi, %o2
191	jmpl %g1 + %lo(compat_sys_recvmsg), %g0
192	62: lduwa [%o1 + 0x4] %asi, %o1
193	nop
194	nop
195	nop
196	do_sys_accept4: /* sys_accept4(int, struct sockaddr , int , int) */
197	63: ldswa [%o1 + 0x0] %asi, %o0
198	sethi %hi(sys_accept4), %g1
199	64: lduwa [%o1 + 0x8] %asi, %o2
200	65: ldswa [%o1 + 0xc] %asi, %o3
201	jmpl %g1 + %lo(sys_accept4), %g0
202	66: lduwa [%o1 + 0x4] %asi, %o1
203	nop
204	nop
205
206	.section __ex_table,"a"
207	.align 4
208	.word 1b, __retl_efault, 2b, __retl_efault
209	.word 3b, __retl_efault, 4b, __retl_efault
210	.word 5b, __retl_efault, 6b, __retl_efault
211	.word 7b, __retl_efault, 8b, __retl_efault
212	.word 9b, __retl_efault, 10b, __retl_efault
213	.word 11b, __retl_efault, 12b, __retl_efault
214	.word 13b, __retl_efault, 14b, __retl_efault
215	.word 15b, __retl_efault, 16b, __retl_efault
216	.word 17b, __retl_efault, 18b, __retl_efault
217	.word 19b, __retl_efault, 20b, __retl_efault
218	.word 21b, __retl_efault, 22b, __retl_efault
219	.word 23b, __retl_efault, 24b, __retl_efault
220	.word 25b, __retl_efault, 26b, __retl_efault
221	.word 27b, __retl_efault, 28b, __retl_efault
222	.word 29b, __retl_efault, 30b, __retl_efault
223	.word 31b, __retl_efault, 32b, __retl_efault
224	.word 33b, __retl_efault, 34b, __retl_efault
225	.word 35b, __retl_efault, 36b, __retl_efault
226	.word 37b, __retl_efault, 38b, __retl_efault
227	.word 39b, __retl_efault, 40b, __retl_efault
228	.word 41b, __retl_efault, 42b, __retl_efault
229	.word 43b, __retl_efault, 44b, __retl_efault
230	.word 45b, __retl_efault, 46b, __retl_efault
231	.word 47b, __retl_efault, 48b, __retl_efault
232	.word 49b, __retl_efault, 50b, __retl_efault
233	.word 51b, __retl_efault, 52b, __retl_efault
234	.word 53b, __retl_efault, 54b, __retl_efault
235	.word 55b, __retl_efault, 56b, __retl_efault
236	.word 57b, __retl_efault, 58b, __retl_efault
237	.word 59b, __retl_efault, 60b, __retl_efault
238	.word 61b, __retl_efault, 62b, __retl_efault
239	.word 63b, __retl_efault, 64b, __retl_efault
240	.word 65b, __retl_efault, 66b, __retl_efault
241	.previous

arch/sparc/kernel/syscalls/syscall.tbl+4−4

@@ -117,7 +117,7 @@ · 116 unmodified lines
117	90 common dup2 sys_dup2	117	90 common dup2 sys_dup2
118	91 32 setfsuid32 sys_setfsuid	118	91 32 setfsuid32 sys_setfsuid
119	92 common fcntl sys_fcntl compat_sys_fcntl	119	92 common fcntl sys_fcntl compat_sys_fcntl
120	93 common select sys_select	120	93 common select sys_select compat_sys_select
121	94 32 setfsgid32 sys_setfsgid	121	94 32 setfsgid32 sys_setfsgid
122	95 common fsync sys_fsync	122	95 common fsync sys_fsync
123	96 common setpriority sys_setpriority	123	96 common setpriority sys_setpriority
@@ -155,7 +155,7 @@ · 31 unmodified lines
155	123 32 fchown sys_fchown16	155	123 32 fchown sys_fchown16
156	123 64 fchown sys_fchown	156	123 64 fchown sys_fchown
157	124 common fchmod sys_fchmod	157	124 common fchmod sys_fchmod
158	125 common recvfrom sys_recvfrom	158	125 common recvfrom sys_recvfrom compat_sys_recvfrom
159	126 32 setreuid sys_setreuid16	159	126 32 setreuid sys_setreuid16
160	126 64 setreuid sys_setreuid	160	126 64 setreuid sys_setreuid
161	127 32 setregid sys_setregid16	161	127 32 setregid sys_setregid16
@@ -247,7 +247,7 @@ · 85 unmodified lines
247	204 32 readdir sys_old_readdir compat_sys_old_readdir	247	204 32 readdir sys_old_readdir compat_sys_old_readdir
248	204 64 readdir sys_nis_syscall	248	204 64 readdir sys_nis_syscall
249	205 common readahead sys_readahead compat_sys_readahead	249	205 common readahead sys_readahead compat_sys_readahead
250	206 common socketcall sys_socketcall sys32_socketcall	250	206 common socketcall sys_socketcall compat_sys_socketcall
251	207 common syslog sys_syslog	251	207 common syslog sys_syslog
252	208 common lookup_dcookie sys_ni_syscall	252	208 common lookup_dcookie sys_ni_syscall
253	209 common fadvise64 sys_fadvise64 compat_sys_fadvise64	253	209 common fadvise64 sys_fadvise64 compat_sys_fadvise64
@@ -461,7 +461,7 @@ · 207 unmodified lines
461	412 32 utimensat_time64 sys_utimensat sys_utimensat	461	412 32 utimensat_time64 sys_utimensat sys_utimensat
462	413 32 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64	462	413 32 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64
463	414 32 ppoll_time64 sys_ppoll compat_sys_ppoll_time64	463	414 32 ppoll_time64 sys_ppoll compat_sys_ppoll_time64
464	416 32 io_pgetevents_time64 sys_io_pgetevents sys_io_pgetevents	464	416 32 io_pgetevents_time64 sys_io_pgetevents compat_sys_io_pgetevents_time64
465	417 32 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64	465	417 32 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64
466	418 32 mq_timedsend_time64 sys_mq_timedsend sys_mq_timedsend	466	418 32 mq_timedsend_time64 sys_mq_timedsend sys_mq_timedsend
467	419 32 mq_timedreceive_time64 sys_mq_timedreceive sys_mq_timedreceive	467	419 32 mq_timedreceive_time64 sys_mq_timedreceive sys_mq_timedreceive

arch/x86/entry/syscalls/syscall_32.tbl+1−1

@@ -420,7 +420,7 @@ · 419 unmodified lines
420	412 i386 utimensat_time64 sys_utimensat	420	412 i386 utimensat_time64 sys_utimensat
421	413 i386 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64	421	413 i386 pselect6_time64 sys_pselect6 compat_sys_pselect6_time64
422	414 i386 ppoll_time64 sys_ppoll compat_sys_ppoll_time64	422	414 i386 ppoll_time64 sys_ppoll compat_sys_ppoll_time64
423	416 i386 io_pgetevents_time64 sys_io_pgetevents	423	416 i386 io_pgetevents_time64 sys_io_pgetevents compat_sys_io_pgetevents_time64
424	417 i386 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64	424	417 i386 recvmmsg_time64 sys_recvmmsg compat_sys_recvmmsg_time64
425	418 i386 mq_timedsend_time64 sys_mq_timedsend	425	418 i386 mq_timedsend_time64 sys_mq_timedsend
426	419 i386 mq_timedreceive_time64 sys_mq_timedreceive	426	419 i386 mq_timedreceive_time64 sys_mq_timedreceive

arch/x86/include/asm/cmpxchg_32.h+5−7

 									\
 	asm volatile(ALTERNATIVE(_lock_loc				\
 				 "call cmpxchg8b_emu",			\
-				 _lock "cmpxchg8b %[ptr]", X86_FEATURE_CX8) \
+				 _lock "cmpxchg8b %a[ptr]", X86_FEATURE_CX8) \
-		     : [ptr] "+m" (*(_ptr)),				\
+		     : "+a" (o.low), "+d" (o.high)			\
-		       "+a" (o.low), "+d" (o.high)			\
+		     : "b" (n.low), "c" (n.high), [ptr] "S" (_ptr)	\
-		     : "b" (n.low), "c" (n.high), "S" (_ptr)		\
 		     : "memory");					\
 									\
 	o.full;								\
 									\
 	asm volatile(ALTERNATIVE(_lock_loc				\
 				 "call cmpxchg8b_emu",			\
-				 _lock "cmpxchg8b %[ptr]", X86_FEATURE_CX8) \
+				 _lock "cmpxchg8b %a[ptr]", X86_FEATURE_CX8) \
 		     CC_SET(e)						\
 		     : CC_OUT(e) (ret),					\
-		       [ptr] "+m" (*(_ptr)),				\
 		       "+a" (o.low), "+d" (o.high)			\
-		     : "b" (n.low), "c" (n.high), "S" (_ptr)		\
+		     : "b" (n.low), "c" (n.high), [ptr] "S" (_ptr)	\
 		     : "memory");					\
 									\
 	if (unlikely(!ret))						\

arch/x86/include/asm/entry-common.h+6−9

 #endif
 	/*
-	 * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
+	 * This value will get limited by KSTACK_OFFSET_MAX(), which is 10
-	 * but not enough for x86 stack utilization comfort. To keep
+	 * bits. The actual entropy will be further reduced by the compiler
-	 * reasonable stack head room, reduce the maximum offset to 8 bits.
+	 * when applying stack alignment constraints (see cc_stack_align4/8 in
-	 *
-	 * The actual entropy will be further reduced by the compiler when
-	 * applying stack alignment constraints (see cc_stack_align4/8 in
 	 * arch/x86/Makefile), which will remove the 3 (x86_64) or 2 (ia32)
 	 * low bits from any entropy chosen here.
 	 *
-	 * Therefore, final stack offset entropy will be 5 (x86_64) or
+	 * Therefore, final stack offset entropy will be 7 (x86_64) or
-	 * 6 (ia32) bits.
+	 * 8 (ia32) bits.
 	 */
-	choose_random_kstack_offset(rdtsc() & 0xFF);
+	choose_random_kstack_offset(rdtsc());
 }
 #define arch_exit_to_user_mode_prepare arch_exit_to_user_mode_prepare

arch/x86/kernel/time.c+1−19

@@ -27,25 +27,7 @@ · 26 unmodified lines
27		27
28	unsigned long profile_pc(struct pt_regs *regs)	28	unsigned long profile_pc(struct pt_regs *regs)
29	{	29	{
30	unsigned long pc = instruction_pointer(regs);	30	return instruction_pointer(regs);
31
32	if (!user_mode(regs) && in_lock_functions(pc)) {
33	#ifdef CONFIG_FRAME_POINTER
34	return (unsigned long )(regs->bp + sizeof(long));
35	#else
36	unsigned long sp = (unsigned long )regs->sp;
37	/*
38	* Return address is either directly at stack pointer
39	* or above a saved flags. Eflags has bits 22-31 zero,
40	* kernel addresses don't.
41	*/
42	if (sp[0] >> 22)
43	return sp[0];
44	if (sp[1] >> 22)
45	return sp[1];
46	#endif
47	}
48	return pc;
49	}	31	}
50	EXPORT_SYMBOL(profile_pc);	32	EXPORT_SYMBOL(profile_pc);
51		33

drivers/ata/ahci.c+12−5

 	n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
 	host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
-	if (!host)
+	if (!host) {
-		return -ENOMEM;
+		rc = -ENOMEM;
+		goto err_rm_sysfs_file;
+	}
 	host->private_data = hpriv;
 	if (ahci_init_msi(pdev, n_ports, hpriv) < 0) {
 	/* initialize adapter */
 	rc = ahci_configure_dma_masks(pdev, hpriv);
 	if (rc)
-		return rc;
+		goto err_rm_sysfs_file;
 	rc = ahci_pci_reset_controller(host);
 	if (rc)
-		return rc;
+		goto err_rm_sysfs_file;
 	ahci_pci_init_controller(host);
 	ahci_pci_print_info(host);
 	rc = ahci_host_activate(host, &ahci_sht);
 	if (rc)
-		return rc;
+		goto err_rm_sysfs_file;
 	pm_runtime_put_noidle(&pdev->dev);
 	return 0;
+err_rm_sysfs_file:
+	sysfs_remove_file_from_group(&pdev->dev.kobj,
+				     &dev_attr_remapped_nvme.attr, NULL);
+	return rc;
 }
 static void ahci_shutdown_one(struct pci_dev *pdev)

drivers/ata/libata-core.c+19−13

 	{ "PIONEER BD-RW   BDR-205",	NULL,	ATA_HORKAGE_NOLPM },
 	/* Crucial devices with broken LPM support */
-	{ "CT500BX100SSD1",		NULL,	ATA_HORKAGE_NOLPM },
+	{ "CT*0BX*00SSD1",		NULL,	ATA_HORKAGE_NOLPM },
-	{ "CT240BX500SSD1",		NULL,	ATA_HORKAGE_NOLPM },
 	/* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */
 	{ "Crucial_CT512MX100*",	"MU01",	ATA_HORKAGE_NO_NCQ_TRIM |
 	return ap;
 }
+void ata_port_free(struct ata_port *ap)
+{
+	if (!ap)
+		return;
+	kfree(ap->pmp_link);
+	kfree(ap->slave_link);
+	kfree(ap->ncq_sense_buf);
+	kfree(ap);
+}
+EXPORT_SYMBOL_GPL(ata_port_free);
 static void ata_devres_release(struct device *gendev, void *res)
 {
 	struct ata_host *host = dev_get_drvdata(gendev);
 	int i;
 	for (i = 0; i < host->n_ports; i++) {
-		struct ata_port *ap = host->ports[i];
+		ata_port_free(host->ports[i]);
-		kfree(ap->pmp_link);
-		kfree(ap->slave_link);
-		kfree(ap->ncq_sense_buf);
-		kfree(ap);
 		host->ports[i] = NULL;
 	}
 	kfree(host);
 	if (!host)
 		return NULL;
-	if (!devres_open_group(dev, NULL, GFP_KERNEL))
+	if (!devres_open_group(dev, NULL, GFP_KERNEL)) {
-		goto err_free;
+		kfree(host);
+		return NULL;
+	}
 	dr = devres_alloc(ata_devres_release, 0, GFP_KERNEL);
 	if (!dr)
  err_out:
 	devres_release_group(dev, NULL);
- err_free:
-	kfree(host);
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(ata_host_alloc);
 	 * allocation time.
 	 */
 	for (i = host->n_ports; host->ports[i]; i++)
-		kfree(host->ports[i]);
+		ata_port_free(host->ports[i]);
 	/* give ports names and add SCSI hosts */
 	for (i = 0; i < host->n_ports; i++) {

drivers/bluetooth/btintel_pcie.c+1−1

@@ -382,7 +382,7 @@ static int btintel_pcie_recv_frame(struct btintel_pcie_data *data, · 381 unmodified lines
382		382
383	/* The first 4 bytes indicates the Intel PCIe specific packet type */	383	/* The first 4 bytes indicates the Intel PCIe specific packet type */
384	pdata = skb_pull_data(skb, BTINTEL_PCIE_HCI_TYPE_LEN);	384	pdata = skb_pull_data(skb, BTINTEL_PCIE_HCI_TYPE_LEN);
385	if (!data) {	385	if (!pdata) {
386	bt_dev_err(hdev, "Corrupted packet received");	386	bt_dev_err(hdev, "Corrupted packet received");
387	ret = -EILSEQ;	387	ret = -EILSEQ;
388	goto exit_error;	388	goto exit_error;

drivers/bluetooth/btnxpuart.c+1−1

@@ -281,7 +281,7 @@ static u8 crc8_table[CRC8_TABLE_SIZE]; · 280 unmodified lines
281		281
282	/* Default configurations */	282	/* Default configurations */
283	#define DEFAULT_H2C_WAKEUP_MODE WAKEUP_METHOD_BREAK	283	#define DEFAULT_H2C_WAKEUP_MODE WAKEUP_METHOD_BREAK
284	#define DEFAULT_PS_MODE PS_MODE_DISABLE	284	#define DEFAULT_PS_MODE PS_MODE_ENABLE
285	#define FW_INIT_BAUDRATE HCI_NXP_PRI_BAUDRATE	285	#define FW_INIT_BAUDRATE HCI_NXP_PRI_BAUDRATE
286		286
287	static struct sk_buff nxp_drv_send_cmd(struct hci_dev hdev, u16 opcode,	287	static struct sk_buff nxp_drv_send_cmd(struct hci_dev hdev, u16 opcode,

drivers/bluetooth/hci_bcm4377.c+9−1

  *                  extended scanning
  * broken_mws_transport_config: Set to true if the chip erroneously claims to
  *                              support MWS Transport Configuration
+ * broken_le_ext_adv_report_phy: Set to true if this chip stuffs flags inside
+ *                               reserved bits of Primary/Secondary_PHY inside
+ *                               LE Extended Advertising Report events which
+ *                               have to be ignored
  * send_calibration: Optional callback to send calibration data
  * send_ptb: Callback to send "PTB" regulatory/calibration data
  */
 	unsigned long broken_ext_scan : 1;
 	unsigned long broken_mws_transport_config : 1;
 	unsigned long broken_le_coded : 1;
+	unsigned long broken_le_ext_adv_report_phy : 1;
 	int (*send_calibration)(struct bcm4377_data *bcm4377);
 	int (*send_ptb)(struct bcm4377_data *bcm4377,
 		ring->events[msgid] = NULL;
 	}
-	bitmap_release_region(ring->msgids, msgid, ring->n_entries);
+	bitmap_release_region(ring->msgids, msgid, 0);
 unlock:
 	spin_unlock_irqrestore(&ring->lock, flags);
 		set_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &hdev->quirks);
 	if (bcm4377->hw->broken_le_coded)
 		set_bit(HCI_QUIRK_BROKEN_LE_CODED, &hdev->quirks);
+	if (bcm4377->hw->broken_le_ext_adv_report_phy)
+		set_bit(HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY, &hdev->quirks);
 	pci_set_drvdata(pdev, bcm4377);
 	hci_set_drvdata(hdev, bcm4377);
 		.clear_pciecfg_subsystem_ctrl_bit19 = true,
 		.broken_mws_transport_config = true,
 		.broken_le_coded = true,
+		.broken_le_ext_adv_report_phy = true,
 		.send_calibration = bcm4387_send_calibration,
 		.send_ptb = bcm4378_send_ptb,
 	},

drivers/bluetooth/hci_qca.c+15−3

 	struct qca_serdev *qcadev = serdev_device_get_drvdata(serdev);
 	struct hci_uart *hu = &qcadev->serdev_hu;
 	struct hci_dev *hdev = hu->hdev;
-	struct qca_data *qca = hu->priv;
 	const u8 ibs_wake_cmd[] = { 0xFD };
 	const u8 edl_reset_soc_cmd[] = { 0x01, 0x00, 0xFC, 0x01, 0x05 };
 	if (qcadev->btsoc_type == QCA_QCA6390) {
-		if (test_bit(QCA_BT_OFF, &qca->flags) ||
+		/* The purpose of sending the VSC is to reset SOC into a initial
-		    !test_bit(HCI_RUNNING, &hdev->flags))
+		 * state and the state will ensure next hdev->setup() success.
+		 * if HCI_QUIRK_NON_PERSISTENT_SETUP is set, it means that
+		 * hdev->setup() can do its job regardless of SoC state, so
+		 * don't need to send the VSC.
+		 * if HCI_SETUP is set, it means that hdev->setup() was never
+		 * invoked and the SOC is already in the initial state, so
+		 * don't also need to send the VSC.
+		 */
+		if (test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks) ||
+		    hci_dev_test_flag(hdev, HCI_SETUP))
 			return;
+		/* The serdev must be in open state when conrol logic arrives
+		 * here, so also fix the use-after-free issue caused by that
+		 * the serdev is flushed or wrote after it is closed.
+		 */
 		serdev_device_write_flush(serdev);
 		ret = serdev_device_write_buf(serdev, ibs_wake_cmd,
 					      sizeof(ibs_wake_cmd));

drivers/counter/ti-eqep.c+6−0

  */
 #include <linux/bitops.h>
+#include <linux/clk.h>
 #include <linux/counter.h>
 #include <linux/kernel.h>
 #include <linux/mod_devicetable.h>
 	struct counter_device *counter;
 	struct ti_eqep_cnt *priv;
 	void __iomem *base;
+	struct clk *clk;
 	int err;
 	counter = devm_counter_alloc(dev, sizeof(*priv));
 	pm_runtime_enable(dev);
 	pm_runtime_get_sync(dev);
+	clk = devm_clk_get_enabled(dev, NULL);
+	if (IS_ERR(clk))
+		return dev_err_probe(dev, PTR_ERR(clk), "failed to enable clock\n");
 	err = counter_add(counter);
 	if (err < 0) {
 		pm_runtime_put_sync(dev);

drivers/cpufreq/intel_pstate.c+6−7

 	int ret;
 	ret = cppc_get_perf_caps(cpu, &cppc_perf);
-	if (ret)
-		return;
 	/*
-	 * On some systems with overclocking enabled, CPPC.highest_perf is hardcoded to 0xff.
+	 * If CPPC is not available, fall back to MSR_HWP_CAPABILITIES bits [8:0].
-	 * In this case we can't use CPPC.highest_perf to enable ITMT.
+	 *
-	 * In this case we can look at MSR_HWP_CAPABILITIES bits [8:0] to decide.
+	 * Also, on some systems with overclocking enabled, CPPC.highest_perf is
+	 * hardcoded to 0xff, so CPPC.highest_perf cannot be used to enable ITMT.
+	 * Fall back to MSR_HWP_CAPABILITIES then too.
 	 */
-	if (cppc_perf.highest_perf == CPPC_MAX_PERF)
+	if (ret || cppc_perf.highest_perf == CPPC_MAX_PERF)
 		cppc_perf.highest_perf = HWP_HIGHEST_PERF(READ_ONCE(all_cpu_data[cpu]->hwp_cap_cached));
 	/*

drivers/crypto/intel/qat/qat_common/Makefile+3−2

 	adf_sysfs_rl.o \
 	qat_uclo.o \
 	qat_hal.o \
-	qat_bl.o
+	qat_bl.o \
+	qat_mig_dev.o
 intel_qat-$(CONFIG_DEBUG_FS) += adf_transport_debug.o \
 				adf_fw_counters.o \
 intel_qat-$(CONFIG_PCI_IOV) += adf_sriov.o adf_vf_isr.o adf_pfvf_utils.o \
 			       adf_pfvf_pf_msg.o adf_pfvf_pf_proto.o \
 			       adf_pfvf_vf_msg.o adf_pfvf_vf_proto.o \
-			       adf_gen2_pfvf.o adf_gen4_pfvf.o qat_mig_dev.o
+			       adf_gen2_pfvf.o adf_gen4_pfvf.o
 intel_qat-$(CONFIG_CRYPTO_DEV_QAT_ERROR_INJECTION) += adf_heartbeat_inject.o

drivers/cxl/core/hdm.c+13−0

@@ -52,6 +52,14 @@ int devm_cxl_add_passthrough_decoder(struct cxl_port *port) · 51 unmodified lines
52	struct cxl_dport *dport = NULL;	52	struct cxl_dport *dport = NULL;
53	int single_port_map[1];	53	int single_port_map[1];
54	unsigned long index;	54	unsigned long index;
		55	struct cxl_hdm *cxlhdm = dev_get_drvdata(&port->dev);
		56
		57	/*
		58	* Capability checks are moot for passthrough decoders, support
		59	* any and all possibilities.
		60	*/
		61	cxlhdm->interleave_mask = ~0U;
		62	cxlhdm->iw_cap_mask = ~0UL;
55		63
56	cxlsd = cxl_switch_decoder_alloc(port, 1);	64	cxlsd = cxl_switch_decoder_alloc(port, 1);
57	if (IS_ERR(cxlsd))	65	if (IS_ERR(cxlsd))
@@ -79,6 +87,11 @@ static void parse_hdm_decoder_caps(struct cxl_hdm *cxlhdm) · 21 unmodified lines
79	cxlhdm->interleave_mask \|= GENMASK(11, 8);	87	cxlhdm->interleave_mask \|= GENMASK(11, 8);
80	if (FIELD_GET(CXL_HDM_DECODER_INTERLEAVE_14_12, hdm_cap))	88	if (FIELD_GET(CXL_HDM_DECODER_INTERLEAVE_14_12, hdm_cap))
81	cxlhdm->interleave_mask \|= GENMASK(14, 12);	89	cxlhdm->interleave_mask \|= GENMASK(14, 12);
		90	cxlhdm->iw_cap_mask = BIT(1) \| BIT(2) \| BIT(4) \| BIT(8);
		91	if (FIELD_GET(CXL_HDM_DECODER_INTERLEAVE_3_6_12_WAY, hdm_cap))
		92	cxlhdm->iw_cap_mask \|= BIT(3) \| BIT(6) \| BIT(12);
		93	if (FIELD_GET(CXL_HDM_DECODER_INTERLEAVE_16_WAY, hdm_cap))
		94	cxlhdm->iw_cap_mask \|= BIT(16);
82	}	95	}
83		96
84	static bool should_emulate_decoders(struct cxl_endpoint_dvsec_info *info)	97	static bool should_emulate_decoders(struct cxl_endpoint_dvsec_info *info)

drivers/cxl/core/pmem.c+11−5

 	return is_cxl_nvdimm_bridge(dev);
 }
-struct cxl_nvdimm_bridge *cxl_find_nvdimm_bridge(struct cxl_memdev *cxlmd)
+/**
+ * cxl_find_nvdimm_bridge() - find a bridge device relative to a port
+ * @port: any descendant port of an nvdimm-bridge associated
+ *        root-cxl-port
+ */
+struct cxl_nvdimm_bridge *cxl_find_nvdimm_bridge(struct cxl_port *port)
 {
-	struct cxl_root *cxl_root __free(put_cxl_root) =
+	struct cxl_root *cxl_root __free(put_cxl_root) = find_cxl_root(port);
-		find_cxl_root(cxlmd->endpoint);
 	struct device *dev;
 	if (!cxl_root)
 /**
  * devm_cxl_add_nvdimm() - add a bridge between a cxl_memdev and an nvdimm
+ * @parent_port: parent port for the (to be added) @cxlmd endpoint port
  * @cxlmd: cxl_memdev instance that will perform LIBNVDIMM operations
  *
  * Return: 0 on success negative error code on failure.
  */
-int devm_cxl_add_nvdimm(struct cxl_memdev *cxlmd)
+int devm_cxl_add_nvdimm(struct cxl_port *parent_port,
+			struct cxl_memdev *cxlmd)
 {
 	struct cxl_nvdimm_bridge *cxl_nvb;
 	struct cxl_nvdimm *cxl_nvd;
 	struct device *dev;
 	int rc;
-	cxl_nvb = cxl_find_nvdimm_bridge(cxlmd);
+	cxl_nvb = cxl_find_nvdimm_bridge(parent_port);
 	if (!cxl_nvb)
 		return -ENODEV;

drivers/cxl/core/region.c+98−5

@@ -1101,6 +1101,26 @@ static int cxl_port_attach_region(struct cxl_port *port, · 1100 unmodified lines
1101	}	1101	}
1102	cxld = cxl_rr->decoder;	1102	cxld = cxl_rr->decoder;
1103		1103
		1104	/*
		1105	* the number of targets should not exceed the target_count
		1106	* of the decoder
		1107	*/
		1108	if (is_switch_decoder(&cxld->dev)) {
		1109	struct cxl_switch_decoder *cxlsd;
		1110
		1111	cxlsd = to_cxl_switch_decoder(&cxld->dev);
		1112	if (cxl_rr->nr_targets > cxlsd->nr_targets) {
		1113	dev_dbg(&cxlr->dev,
		1114	"%s:%s %s add: %s:%s @ %d overflows targets: %d\n",
		1115	dev_name(port->uport_dev), dev_name(&port->dev),
		1116	dev_name(&cxld->dev), dev_name(&cxlmd->dev),
		1117	dev_name(&cxled->cxld.dev), pos,
		1118	cxlsd->nr_targets);
		1119	rc = -ENXIO;
		1120	goto out_erase;
		1121	}
		1122	}
		1123
1104	rc = cxl_rr_ep_add(cxl_rr, cxled);	1124	rc = cxl_rr_ep_add(cxl_rr, cxled);
1105	if (rc) {	1125	if (rc) {
1106	dev_dbg(&cxlr->dev,	1126	dev_dbg(&cxlr->dev,
@@ -1210,6 +1230,50 @@ static int check_last_peer(struct cxl_endpoint_decoder *cxled, · 103 unmodified lines
1210	return 0;	1230	return 0;
1211	}	1231	}
1212		1232
		1233	static int check_interleave_cap(struct cxl_decoder *cxld, int iw, int ig)
		1234	{
		1235	struct cxl_port *port = to_cxl_port(cxld->dev.parent);
		1236	struct cxl_hdm *cxlhdm = dev_get_drvdata(&port->dev);
		1237	unsigned int interleave_mask;
		1238	u8 eiw;
		1239	u16 eig;
		1240	int high_pos, low_pos;
		1241
		1242	if (!test_bit(iw, &cxlhdm->iw_cap_mask))
		1243	return -ENXIO;
		1244	/*
		1245	* Per CXL specification r3.1(8.2.4.20.13 Decoder Protection),
		1246	* if eiw < 8:
		1247	* DPAOFFSET[51: eig + 8] = HPAOFFSET[51: eig + 8 + eiw]
		1248	* DPAOFFSET[eig + 7: 0] = HPAOFFSET[eig + 7: 0]
		1249	*
		1250	* when the eiw is 0, all the bits of HPAOFFSET[51: 0] are used, the
		1251	* interleave bits are none.
		1252	*
		1253	* if eiw >= 8:
		1254	* DPAOFFSET[51: eig + 8] = HPAOFFSET[51: eig + eiw] / 3
		1255	* DPAOFFSET[eig + 7: 0] = HPAOFFSET[eig + 7: 0]
		1256	*
		1257	* when the eiw is 8, all the bits of HPAOFFSET[51: 0] are used, the
		1258	* interleave bits are none.
		1259	*/
		1260	ways_to_eiw(iw, &eiw);
		1261	if (eiw == 0 \|\| eiw == 8)
		1262	return 0;
		1263
		1264	granularity_to_eig(ig, &eig);
		1265	if (eiw > 8)
		1266	high_pos = eiw + eig - 1;
		1267	else
		1268	high_pos = eiw + eig + 7;
		1269	low_pos = eig + 8;
		1270	interleave_mask = GENMASK(high_pos, low_pos);
		1271	if (interleave_mask & ~cxlhdm->interleave_mask)
		1272	return -ENXIO;
		1273
		1274	return 0;
		1275	}
		1276
1213	static int cxl_port_setup_targets(struct cxl_port *port,	1277	static int cxl_port_setup_targets(struct cxl_port *port,
1214	struct cxl_region *cxlr,	1278	struct cxl_region *cxlr,
1215	struct cxl_endpoint_decoder *cxled)	1279	struct cxl_endpoint_decoder *cxled)
@@ -1360,6 +1424,15 @@ static int cxl_port_setup_targets(struct cxl_port *port, · 144 unmodified lines
1360	return -ENXIO;	1424	return -ENXIO;
1361	}	1425	}
1362	} else {	1426	} else {
		1427	rc = check_interleave_cap(cxld, iw, ig);
		1428	if (rc) {
		1429	dev_dbg(&cxlr->dev,
		1430	"%s:%s iw: %d ig: %d is not supported\n",
		1431	dev_name(port->uport_dev),
		1432	dev_name(&port->dev), iw, ig);
		1433	return rc;
		1434	}
		1435
1363	cxld->interleave_ways = iw;	1436	cxld->interleave_ways = iw;
1364	cxld->interleave_granularity = ig;	1437	cxld->interleave_granularity = ig;
1365	cxld->hpa_range = (struct range) {	1438	cxld->hpa_range = (struct range) {
@@ -1796,6 +1869,15 @@ static int cxl_region_attach(struct cxl_region *cxlr, · 430 unmodified lines
1796	struct cxl_dport *dport;	1869	struct cxl_dport *dport;
1797	int rc = -ENXIO;	1870	int rc = -ENXIO;
1798		1871
		1872	rc = check_interleave_cap(&cxled->cxld, p->interleave_ways,
		1873	p->interleave_granularity);
		1874	if (rc) {
		1875	dev_dbg(&cxlr->dev, "%s iw: %d ig: %d is not supported\n",
		1876	dev_name(&cxled->cxld.dev), p->interleave_ways,
		1877	p->interleave_granularity);
		1878	return rc;
		1879	}
		1880
1799	if (cxled->mode != cxlr->mode) {	1881	if (cxled->mode != cxlr->mode) {
1800	dev_dbg(&cxlr->dev, "%s region mode: %d mismatch: %d\n",	1882	dev_dbg(&cxlr->dev, "%s region mode: %d mismatch: %d\n",
1801	dev_name(&cxled->cxld.dev), cxlr->mode, cxled->mode);	1883	dev_name(&cxled->cxld.dev), cxlr->mode, cxled->mode);
@@ -2688,22 +2770,33 @@ static int __cxl_dpa_to_region(struct device dev, void arg) · 886 unmodified lines
2688	{	2770	{
2689	struct cxl_dpa_to_region_context *ctx = arg;	2771	struct cxl_dpa_to_region_context *ctx = arg;
2690	struct cxl_endpoint_decoder *cxled;	2772	struct cxl_endpoint_decoder *cxled;
		2773	struct cxl_region *cxlr;
2691	u64 dpa = ctx->dpa;	2774	u64 dpa = ctx->dpa;
2692		2775
2693	if (!is_endpoint_decoder(dev))	2776	if (!is_endpoint_decoder(dev))
2694	return 0;	2777	return 0;
2695		2778
2696	cxled = to_cxl_endpoint_decoder(dev);	2779	cxled = to_cxl_endpoint_decoder(dev);
2697	if (!cxled->dpa_res \|\| !resource_size(cxled->dpa_res))	2780	if (!cxled \|\| !cxled->dpa_res \|\| !resource_size(cxled->dpa_res))
2698	return 0;	2781	return 0;
2699		2782
2700	if (dpa > cxled->dpa_res->end \|\| dpa < cxled->dpa_res->start)	2783	if (dpa > cxled->dpa_res->end \|\| dpa < cxled->dpa_res->start)
2701	return 0;	2784	return 0;
2702		2785
2703	dev_dbg(dev, "dpa:0x%llx mapped in region:%s\n", dpa,	2786	/*
2704	dev_name(&cxled->cxld.region->dev));	2787	* Stop the region search (return 1) when an endpoint mapping is
		2788	* found. The region may not be fully constructed so offering
		2789	* the cxlr in the context structure is not guaranteed.
		2790	*/
		2791	cxlr = cxled->cxld.region;
		2792	if (cxlr)
		2793	dev_dbg(dev, "dpa:0x%llx mapped in region:%s\n", dpa,
		2794	dev_name(&cxlr->dev));
		2795	else
		2796	dev_dbg(dev, "dpa:0x%llx mapped in endpoint:%s\n", dpa,
		2797	dev_name(dev));
2705		2798
2706	ctx->cxlr = cxled->cxld.region;	2799	ctx->cxlr = cxlr;
2707		2800
2708	return 1;	2801	return 1;
2709	}	2802	}
@@ -2847,7 +2940,7 @@ static int cxl_pmem_region_alloc(struct cxl_region *cxlr) · 137 unmodified lines
2847	* bridge for one device is the same for all.	2940	* bridge for one device is the same for all.
2848	*/	2941	*/
2849	if (i == 0) {	2942	if (i == 0) {
2850	cxl_nvb = cxl_find_nvdimm_bridge(cxlmd);	2943	cxl_nvb = cxl_find_nvdimm_bridge(cxlmd->endpoint);
2851	if (!cxl_nvb)	2944	if (!cxl_nvb)
2852	return -ENODEV;	2945	return -ENODEV;
2853	cxlr->cxl_nvb = cxl_nvb;	2946	cxlr->cxl_nvb = cxl_nvb;

drivers/cxl/cxl.h+4−2

 #define   CXL_HDM_DECODER_TARGET_COUNT_MASK GENMASK(7, 4)
 #define   CXL_HDM_DECODER_INTERLEAVE_11_8 BIT(8)
 #define   CXL_HDM_DECODER_INTERLEAVE_14_12 BIT(9)
+#define   CXL_HDM_DECODER_INTERLEAVE_3_6_12_WAY BIT(11)
+#define   CXL_HDM_DECODER_INTERLEAVE_16_WAY BIT(12)
 #define CXL_HDM_DECODER_CTRL_OFFSET 0x4
 #define   CXL_HDM_DECODER_ENABLE BIT(1)
 #define CXL_HDM_DECODER0_BASE_LOW_OFFSET(i) (0x20 * (i) + 0x10)
 struct cxl_nvdimm *to_cxl_nvdimm(struct device *dev);
 bool is_cxl_nvdimm(struct device *dev);
 bool is_cxl_nvdimm_bridge(struct device *dev);
-int devm_cxl_add_nvdimm(struct cxl_memdev *cxlmd);
+int devm_cxl_add_nvdimm(struct cxl_port *parent_port, struct cxl_memdev *cxlmd);
-struct cxl_nvdimm_bridge *cxl_find_nvdimm_bridge(struct cxl_memdev *cxlmd);
+struct cxl_nvdimm_bridge *cxl_find_nvdimm_bridge(struct cxl_port *port);
 #ifdef CONFIG_CXL_REGION
 bool is_cxl_pmem_region(struct device *dev);

drivers/cxl/cxlmem.h+16−5

 /**
  * struct cxl_dpa_perf - DPA performance property entry
- * @dpa_range - range for DPA address
+ * @dpa_range: range for DPA address
- * @coord - QoS performance data (i.e. latency, bandwidth)
+ * @coord: QoS performance data (i.e. latency, bandwidth)
- * @qos_class - QoS Class cookies
+ * @qos_class: QoS Class cookies
  */
 struct cxl_dpa_perf {
 	struct range dpa_range;
  * @active_persistent_bytes: sum of hard + soft persistent
  * @next_volatile_bytes: volatile capacity change pending device reset
  * @next_persistent_bytes: persistent capacity change pending device reset
+ * @ram_perf: performance data entry matched to RAM partition
+ * @pmem_perf: performance data entry matched to PMEM partition
  * @event: event log driver state
  * @poison: poison driver state info
  * @security: security driver state info
  * @fw: firmware upload / activation state
+ * @mbox_wait: RCU wait for mbox send completely
  * @mbox_send: @dev specific transport for transmitting mailbox commands
- * @ram_perf: performance data entry matched to RAM partition
- * @pmem_perf: performance data entry matched to PMEM partition
  *
  * See CXL 3.0 8.2.9.8.2 Capacity Configuration and Label Storage for
  * details on capacity parameters.
 int cxl_mem_sanitize(struct cxl_memdev *cxlmd, u16 cmd);
+/**
+ * struct cxl_hdm - HDM Decoder registers and cached / decoded capabilities
+ * @regs: mapped registers, see devm_cxl_setup_hdm()
+ * @decoder_count: number of decoders for this port
+ * @target_count: for switch decoders, max downstream port targets
+ * @interleave_mask: interleave granularity capability, see check_interleave_cap()
+ * @iw_cap_mask: bitmask of supported interleave ways, see check_interleave_cap()
+ * @port: mapped cxl_port, see devm_cxl_setup_hdm()
+ */
 struct cxl_hdm {
 	struct cxl_component_regs regs;
 	unsigned int decoder_count;
 	unsigned int target_count;
 	unsigned int interleave_mask;
+	unsigned long iw_cap_mask;
 	struct cxl_port *port;
 };

drivers/cxl/mem.c+9−8

 		return -ENXIO;
 	}
+	if (resource_size(&cxlds->pmem_res) && IS_ENABLED(CONFIG_CXL_PMEM)) {
+		rc = devm_cxl_add_nvdimm(parent_port, cxlmd);
+		if (rc) {
+			if (rc == -ENODEV)
+				dev_info(dev, "PMEM disabled by platform\n");
+			return rc;
+		}
+	}
 	if (dport->rch)
 		endpoint_parent = parent_port->uport_dev;
 	else
 	if (rc)
 		return rc;
-	if (resource_size(&cxlds->pmem_res) && IS_ENABLED(CONFIG_CXL_PMEM)) {
-		rc = devm_cxl_add_nvdimm(cxlmd);
-		if (rc == -ENODEV)
-			dev_info(dev, "PMEM disabled by platform\n");
-		else
-			return rc;
-	}
 	/*
 	 * The kernel may be operating out of CXL memory on this device,
 	 * there is no spec defined way to determine whether this device

drivers/gpio/gpio-davinci.c+5−0

 	else
 		nirq = DIV_ROUND_UP(ngpio, 16);
+	if (nirq > MAX_INT_PER_BANK) {
+		dev_err(dev, "Too many IRQs!\n");
+		return -EINVAL;
+	}
 	chips = devm_kzalloc(dev, sizeof(*chips), GFP_KERNEL);
 	if (!chips)
 		return -ENOMEM;

drivers/gpio/gpio-graniterapids.c+2−0

@@ -296,6 +296,8 @@ static int gnr_gpio_probe(struct platform_device *pdev) · 295 unmodified lines
296	if (!priv)	296	if (!priv)
297	return -ENOMEM;	297	return -ENOMEM;
298		298
		299	raw_spin_lock_init(&priv->lock);
		300
299	regs = devm_platform_ioremap_resource(pdev, 0);	301	regs = devm_platform_ioremap_resource(pdev, 0);
300	if (IS_ERR(regs))	302	if (IS_ERR(regs))
301	return PTR_ERR(regs);	303	return PTR_ERR(regs);

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

@@ -758,6 +758,8 @@ static void pca953x_irq_bus_sync_unlock(struct irq_data *d) · 757 unmodified lines
758	int level;	758	int level;
759		759
760	if (chip->driver_data & PCA_PCAL) {	760	if (chip->driver_data & PCA_PCAL) {
		761	guard(mutex)(&chip->i2c_lock);
		762
761	/* Enable latch on interrupt-enabled inputs */	763	/* Enable latch on interrupt-enabled inputs */
762	pca953x_write_regs(chip, PCAL953X_IN_LATCH, chip->irq_mask);	764	pca953x_write_regs(chip, PCAL953X_IN_LATCH, chip->irq_mask);
763		765

drivers/gpio/gpiolib-cdev.c+17−11

 	GPIOHANDLE_REQUEST_OPEN_DRAIN | \
 	GPIOHANDLE_REQUEST_OPEN_SOURCE)
+#define GPIOHANDLE_REQUEST_DIRECTION_FLAGS \
+	(GPIOHANDLE_REQUEST_INPUT | \
+	 GPIOHANDLE_REQUEST_OUTPUT)
 static int linehandle_validate_flags(u32 flags)
 {
 	/* Return an error if an unknown flag is set */
 	if (ret)
 		return ret;
+	/* Lines must be reconfigured explicitly as input or output. */
+	if (!(lflags & GPIOHANDLE_REQUEST_DIRECTION_FLAGS))
+		return -EINVAL;
 	for (i = 0; i < lh->num_descs; i++) {
 		desc = lh->descs[i];
-		linehandle_flags_to_desc_flags(gcnf.flags, &desc->flags);
+		linehandle_flags_to_desc_flags(lflags, &desc->flags);
-		/*
-		 * Lines have to be requested explicitly for input
-		 * or output, else the line will be treated "as is".
-		 */
 		if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
 			int val = !!gcnf.default_values[i];
 			ret = gpiod_direction_output(desc, val);
 			if (ret)
 				return ret;
-		} else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
+		} else {
 			ret = gpiod_direction_input(desc);
 			if (ret)
 				return ret;
 		line = &lr->lines[i];
 		desc = lr->lines[i].desc;
 		flags = gpio_v2_line_config_flags(&lc, i);
-		gpio_v2_line_config_flags_to_desc_flags(flags, &desc->flags);
-		edflags = flags & GPIO_V2_LINE_EDGE_DETECTOR_FLAGS;
 		/*
-		 * Lines have to be requested explicitly for input
+		 * Lines not explicitly reconfigured as input or output
-		 * or output, else the line will be treated "as is".
+		 * are left unchanged.
 		 */
+		if (!(flags & GPIO_V2_LINE_DIRECTION_FLAGS))
+			continue;
+		gpio_v2_line_config_flags_to_desc_flags(flags, &desc->flags);
+		edflags = flags & GPIO_V2_LINE_EDGE_DETECTOR_FLAGS;
 		if (flags & GPIO_V2_LINE_FLAG_OUTPUT) {
 			int val = gpio_v2_line_config_output_value(&lc, i);
 			ret = gpiod_direction_output(desc, val);
 			if (ret)
 				return ret;
-		} else if (flags & GPIO_V2_LINE_FLAG_INPUT) {
+		} else {
 			ret = gpiod_direction_input(desc);
 			if (ret)
 				return ret;

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

@@ -400,7 +400,7 @@ amdgpu_atomfirmware_get_vram_info(struct amdgpu_device *adev, · 399 unmodified lines
400	mem_channel_number = vram_info->v30.channel_num;	400	mem_channel_number = vram_info->v30.channel_num;
401	mem_channel_width = vram_info->v30.channel_width;	401	mem_channel_width = vram_info->v30.channel_width;
402	if (vram_width)	402	if (vram_width)
403	vram_width = mem_channel_number (1 << mem_channel_width);	403	vram_width = mem_channel_number 16;
404	break;	404	break;
405	default:	405	default:
406	return -EINVAL;	406	return -EINVAL;

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

 	dev_info(adev->dev, "GPU mode1 reset\n");
+	/* Cache the state before bus master disable. The saved config space
+	 * values are used in other cases like restore after mode-2 reset.
+	 */
+	amdgpu_device_cache_pci_state(adev->pdev);
 	/* disable BM */
 	pci_clear_master(adev->pdev);
-	amdgpu_device_cache_pci_state(adev->pdev);
 	if (amdgpu_dpm_is_mode1_reset_supported(adev)) {
 		dev_info(adev->dev, "GPU smu mode1 reset\n");
 		ret = amdgpu_dpm_mode1_reset(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c+21−4

@@ -640,6 +640,20 @@ static const char *psp_gfx_cmd_name(enum psp_gfx_cmd_id cmd_id) · 639 unmodified lines
640	}	640	}
641	}	641	}
642		642
		643	static bool psp_err_warn(struct psp_context *psp)
		644	{
		645	struct psp_gfx_cmd_resp *cmd = psp->cmd_buf_mem;
		646
		647	/* This response indicates reg list is already loaded */
		648	if (amdgpu_ip_version(psp->adev, MP0_HWIP, 0) == IP_VERSION(13, 0, 2) &&
		649	cmd->cmd_id == GFX_CMD_ID_LOAD_IP_FW &&
		650	cmd->cmd.cmd_load_ip_fw.fw_type == GFX_FW_TYPE_REG_LIST &&
		651	cmd->resp.status == TEE_ERROR_CANCEL)
		652	return false;
		653
		654	return true;
		655	}
		656
643	static int	657	static int
644	psp_cmd_submit_buf(struct psp_context *psp,	658	psp_cmd_submit_buf(struct psp_context *psp,
645	struct amdgpu_firmware_info *ucode,	659	struct amdgpu_firmware_info *ucode,
@@ -699,10 +713,13 @@ psp_cmd_submit_buf(struct psp_context *psp, · 53 unmodified lines
699	dev_warn(psp->adev->dev,	713	dev_warn(psp->adev->dev,
700	"failed to load ucode %s(0x%X) ",	714	"failed to load ucode %s(0x%X) ",
701	amdgpu_ucode_name(ucode->ucode_id), ucode->ucode_id);	715	amdgpu_ucode_name(ucode->ucode_id), ucode->ucode_id);
702	dev_warn(psp->adev->dev,	716	if (psp_err_warn(psp))
703	"psp gfx command %s(0x%X) failed and response status is (0x%X)\n",	717	dev_warn(
704	psp_gfx_cmd_name(psp->cmd_buf_mem->cmd_id), psp->cmd_buf_mem->cmd_id,	718	psp->adev->dev,
705	psp->cmd_buf_mem->resp.status);	719	"psp gfx command %s(0x%X) failed and response status is (0x%X)\n",
		720	psp_gfx_cmd_name(psp->cmd_buf_mem->cmd_id),
		721	psp->cmd_buf_mem->cmd_id,
		722	psp->cmd_buf_mem->resp.status);
706	/* If any firmware (including CAP) load fails under SRIOV, it should	723	/* If any firmware (including CAP) load fails under SRIOV, it should
707	* return failure to stop the VF from initializing.	724	* return failure to stop the VF from initializing.
708	* Also return failure in case of timeout	725	* Also return failure in case of timeout

drivers/gpu/drm/amd/amdgpu/amdgpu_vkms.c+16−2

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	#include <drm/drm_atomic_helper.h>	3	#include <drm/drm_atomic_helper.h>
4	#include <drm/drm_edid.h>	4	#include <drm/drm_edid.h>
5	#include <drm/drm_simple_kms_helper.h>	5	#include <drm/drm_simple_kms_helper.h>
		6	#include <drm/drm_gem_framebuffer_helper.h>
6	#include <drm/drm_vblank.h>	7	#include <drm/drm_vblank.h>
7		8
8	#include "amdgpu.h"	9	#include "amdgpu.h"
@@ -314,7 +315,13 @@ static int amdgpu_vkms_prepare_fb(struct drm_plane *plane, · 305 unmodified lines
314	return 0;	315	return 0;
315	}	316	}
316	afb = to_amdgpu_framebuffer(new_state->fb);	317	afb = to_amdgpu_framebuffer(new_state->fb);
317	obj = new_state->fb->obj[0];	318
		319	obj = drm_gem_fb_get_obj(new_state->fb, 0);
		320	if (!obj) {
		321	DRM_ERROR("Failed to get obj from framebuffer\n");
		322	return -EINVAL;
		323	}
		324
318	rbo = gem_to_amdgpu_bo(obj);	325	rbo = gem_to_amdgpu_bo(obj);
319	adev = amdgpu_ttm_adev(rbo->tbo.bdev);	326	adev = amdgpu_ttm_adev(rbo->tbo.bdev);
320		327
@@ -368,12 +375,19 @@ static void amdgpu_vkms_cleanup_fb(struct drm_plane *plane, · 47 unmodified lines
368	struct drm_plane_state *old_state)	375	struct drm_plane_state *old_state)
369	{	376	{
370	struct amdgpu_bo *rbo;	377	struct amdgpu_bo *rbo;
		378	struct drm_gem_object *obj;
371	int r;	379	int r;
372		380
373	if (!old_state->fb)	381	if (!old_state->fb)
374	return;	382	return;
375		383
376	rbo = gem_to_amdgpu_bo(old_state->fb->obj[0]);	384	obj = drm_gem_fb_get_obj(old_state->fb, 0);
		385	if (!obj) {
		386	DRM_ERROR("Failed to get obj from framebuffer\n");
		387	return;
		388	}
		389
		390	rbo = gem_to_amdgpu_bo(obj);
377	r = amdgpu_bo_reserve(rbo, false);	391	r = amdgpu_bo_reserve(rbo, false);
378	if (unlikely(r)) {	392	if (unlikely(r)) {
379	DRM_ERROR("failed to reserve rbo before unpin\n");	393	DRM_ERROR("failed to reserve rbo before unpin\n");

drivers/gpu/drm/amd/amdgpu/psp_gfx_if.h+3−2

@@ -464,8 +464,9 @@ struct psp_gfx_rb_frame · 463 unmodified lines
464	#define PSP_ERR_UNKNOWN_COMMAND 0x00000100	464	#define PSP_ERR_UNKNOWN_COMMAND 0x00000100
465		465
466	enum tee_error_code {	466	enum tee_error_code {
467	TEE_SUCCESS = 0x00000000,	467	TEE_SUCCESS = 0x00000000,
468	TEE_ERROR_NOT_SUPPORTED = 0xFFFF000A,	468	TEE_ERROR_CANCEL = 0xFFFF0002,
		469	TEE_ERROR_NOT_SUPPORTED = 0xFFFF000A,
469	};	470	};
470		471
471	#endif /* _PSP_TEE_GFX_IF_H_ */	472	#endif /* _PSP_TEE_GFX_IF_H_ */

drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c+9−1

 			return false;
 	}
-	if (dp_is_lttpr_present(link))
+	if (dp_is_lttpr_present(link)) {
 		configure_lttpr_mode_transparent(link);
+		// Echo TOTAL_LTTPR_CNT back downstream
+		core_link_write_dpcd(
+				link,
+				DP_TOTAL_LTTPR_CNT,
+				&link->dpcd_caps.lttpr_caps.phy_repeater_cnt,
+				sizeof(link->dpcd_caps.lttpr_caps.phy_repeater_cnt));
+	}
 	/* Read DP tunneling information. */
 	status = dpcd_get_tunneling_device_data(link);

drivers/gpu/drm/amd/display/include/dpcd_defs.h+5−0

@@ -177,4 +177,9 @@ enum dpcd_psr_sink_states { · 176 unmodified lines
177	#define DP_SINK_PR_PIXEL_DEVIATION_PER_LINE 0x379	177	#define DP_SINK_PR_PIXEL_DEVIATION_PER_LINE 0x379
178	#define DP_SINK_PR_MAX_NUMBER_OF_DEVIATION_LINE 0x37A	178	#define DP_SINK_PR_MAX_NUMBER_OF_DEVIATION_LINE 0x37A
179		179
		180	/* Remove once drm_dp_helper.h is updated upstream */
		181	#ifndef DP_TOTAL_LTTPR_CNT
		182	#define DP_TOTAL_LTTPR_CNT 0xF000A /* 2.1 */
		183	#endif
		184
180	#endif /* __DAL_DPCD_DEFS_H__ */	185	#endif /* __DAL_DPCD_DEFS_H__ */

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c+13−0

@@ -324,6 +324,18 @@ static int smu_dpm_set_umsch_mm_enable(struct smu_context *smu, · 323 unmodified lines
324	return ret;	324	return ret;
325	}	325	}
326		326
		327	static int smu_set_mall_enable(struct smu_context *smu)
		328	{
		329	int ret = 0;
		330
		331	if (!smu->ppt_funcs->set_mall_enable)
		332	return 0;
		333
		334	ret = smu->ppt_funcs->set_mall_enable(smu);
		335
		336	return ret;
		337	}
		338
327	/**	339	/**
328	* smu_dpm_set_power_gate - power gate/ungate the specific IP block	340	* smu_dpm_set_power_gate - power gate/ungate the specific IP block
329	*	341	*
@@ -1791,6 +1803,7 @@ static int smu_hw_init(void *handle) · 1461 unmodified lines
1791	smu_dpm_set_jpeg_enable(smu, true);	1803	smu_dpm_set_jpeg_enable(smu, true);
1792	smu_dpm_set_vpe_enable(smu, true);	1804	smu_dpm_set_vpe_enable(smu, true);
1793	smu_dpm_set_umsch_mm_enable(smu, true);	1805	smu_dpm_set_umsch_mm_enable(smu, true);
		1806	smu_set_mall_enable(smu);
1794	smu_set_gfx_cgpg(smu, true);	1807	smu_set_gfx_cgpg(smu, true);
1795	}	1808	}
1796		1809

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h+5−0

 	 */
 	int (*dpm_set_umsch_mm_enable)(struct smu_context *smu, bool enable);
+	/**
+	 * @set_mall_enable: Init MALL power gating control.
+	 */
+	int (*set_mall_enable)(struct smu_context *smu);
 	/**
 	 * @notify_rlc_state: Notify RLC power state to SMU.
 	 */

drivers/gpu/drm/amd/pm/swsmu/inc/pmfw_if/smu_v14_0_0_ppsmc.h+2−2

@@ -106,8 +106,8 @@ · 105 unmodified lines
106	#define PPSMC_MSG_DisableLSdma 0x35 ///< Disable LSDMA	106	#define PPSMC_MSG_DisableLSdma 0x35 ///< Disable LSDMA
107	#define PPSMC_MSG_SetSoftMaxVpe 0x36 ///<	107	#define PPSMC_MSG_SetSoftMaxVpe 0x36 ///<
108	#define PPSMC_MSG_SetSoftMinVpe 0x37 ///<	108	#define PPSMC_MSG_SetSoftMinVpe 0x37 ///<
109	#define PPSMC_MSG_AllocMALLCache 0x38 ///< Allocating MALL Cache	109	#define PPSMC_MSG_MALLPowerController 0x38 ///< Set MALL control
110	#define PPSMC_MSG_ReleaseMALLCache 0x39 ///< Releasing MALL Cache	110	#define PPSMC_MSG_MALLPowerState 0x39 ///< Enter/Exit MALL PG
111	#define PPSMC_Message_Count 0x3A ///< Total number of PPSMC messages	111	#define PPSMC_Message_Count 0x3A ///< Total number of PPSMC messages
112	/** @}*/	112	/** @}*/
113		113

drivers/gpu/drm/amd/pm/swsmu/inc/smu_types.h+3−1

 	__SMU_DUMMY_MAP(SetSoftMinVpe), \
 	__SMU_DUMMY_MAP(GetMetricsVersion), \
 	__SMU_DUMMY_MAP(EnableUCLKShadow), \
-	__SMU_DUMMY_MAP(RmaDueToBadPageThreshold),
+	__SMU_DUMMY_MAP(RmaDueToBadPageThreshold), \
+	__SMU_DUMMY_MAP(MALLPowerController), \
+	__SMU_DUMMY_MAP(MALLPowerState),
 #undef __SMU_DUMMY_MAP
 #define __SMU_DUMMY_MAP(type)	SMU_MSG_##type

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_0_ppt.c+73−0

@@ -52,6 +52,19 @@ · 51 unmodified lines
52	#define mmMP1_SMN_C2PMSG_90 0x029a	52	#define mmMP1_SMN_C2PMSG_90 0x029a
53	#define mmMP1_SMN_C2PMSG_90_BASE_IDX 0	53	#define mmMP1_SMN_C2PMSG_90_BASE_IDX 0
54		54
		55	/* MALLPowerController message arguments (Defines for the Cache mode control) */
		56	#define SMU_MALL_PMFW_CONTROL 0
		57	#define SMU_MALL_DRIVER_CONTROL 1
		58
		59	/*
		60	* MALLPowerState message arguments
		61	* (Defines for the Allocate/Release Cache mode if in driver mode)
		62	*/
		63	#define SMU_MALL_EXIT_PG 0
		64	#define SMU_MALL_ENTER_PG 1
		65
		66	#define SMU_MALL_PG_CONFIG_DEFAULT SMU_MALL_PG_CONFIG_DRIVER_CONTROL_ALWAYS_ON
		67
55	#define FEATURE_MASK(feature) (1ULL << feature)	68	#define FEATURE_MASK(feature) (1ULL << feature)
56	#define SMC_DPM_FEATURE ( \	69	#define SMC_DPM_FEATURE ( \
57	FEATURE_MASK(FEATURE_CCLK_DPM_BIT) \| \	70	FEATURE_MASK(FEATURE_CCLK_DPM_BIT) \| \
@@ -66,6 +79,12 @@ · 8 unmodified lines
66	FEATURE_MASK(FEATURE_GFX_DPM_BIT) \| \	79	FEATURE_MASK(FEATURE_GFX_DPM_BIT) \| \
67	FEATURE_MASK(FEATURE_VPE_DPM_BIT))	80	FEATURE_MASK(FEATURE_VPE_DPM_BIT))
68		81
		82	enum smu_mall_pg_config {
		83	SMU_MALL_PG_CONFIG_PMFW_CONTROL = 0,
		84	SMU_MALL_PG_CONFIG_DRIVER_CONTROL_ALWAYS_ON = 1,
		85	SMU_MALL_PG_CONFIG_DRIVER_CONTROL_ALWAYS_OFF = 2,
		86	};
		87
69	static struct cmn2asic_msg_mapping smu_v14_0_0_message_map[SMU_MSG_MAX_COUNT] = {	88	static struct cmn2asic_msg_mapping smu_v14_0_0_message_map[SMU_MSG_MAX_COUNT] = {
70	MSG_MAP(TestMessage, PPSMC_MSG_TestMessage, 1),	89	MSG_MAP(TestMessage, PPSMC_MSG_TestMessage, 1),
71	MSG_MAP(GetSmuVersion, PPSMC_MSG_GetPmfwVersion, 1),	90	MSG_MAP(GetSmuVersion, PPSMC_MSG_GetPmfwVersion, 1),
@@ -113,6 +132,8 @@ static struct cmn2asic_msg_mapping smu_v14_0_0_message_map[SMU_MSG_MAX_COUNT] = · 41 unmodified lines
113	MSG_MAP(PowerDownUmsch, PPSMC_MSG_PowerDownUmsch, 1),	132	MSG_MAP(PowerDownUmsch, PPSMC_MSG_PowerDownUmsch, 1),
114	MSG_MAP(SetSoftMaxVpe, PPSMC_MSG_SetSoftMaxVpe, 1),	133	MSG_MAP(SetSoftMaxVpe, PPSMC_MSG_SetSoftMaxVpe, 1),
115	MSG_MAP(SetSoftMinVpe, PPSMC_MSG_SetSoftMinVpe, 1),	134	MSG_MAP(SetSoftMinVpe, PPSMC_MSG_SetSoftMinVpe, 1),
		135	MSG_MAP(MALLPowerController, PPSMC_MSG_MALLPowerController, 1),
		136	MSG_MAP(MALLPowerState, PPSMC_MSG_MALLPowerState, 1),
116	};	137	};
117		138
118	static struct cmn2asic_mapping smu_v14_0_0_feature_mask_map[SMU_FEATURE_COUNT] = {	139	static struct cmn2asic_mapping smu_v14_0_0_feature_mask_map[SMU_FEATURE_COUNT] = {
@@ -1423,6 +1444,57 @@ static int smu_v14_0_common_get_dpm_table(struct smu_context *smu, struct dpm_cl · 1304 unmodified lines
1423	return 0;	1444	return 0;
1424	}	1445	}
1425		1446
		1447	static int smu_v14_0_1_init_mall_power_gating(struct smu_context *smu, enum smu_mall_pg_config pg_config)
		1448	{
		1449	struct amdgpu_device *adev = smu->adev;
		1450	int ret = 0;
		1451
		1452	if (pg_config == SMU_MALL_PG_CONFIG_PMFW_CONTROL) {
		1453	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_MALLPowerController,
		1454	SMU_MALL_PMFW_CONTROL, NULL);
		1455	if (ret) {
		1456	dev_err(adev->dev, "Init MALL PMFW CONTROL Failure\n");
		1457	return ret;
		1458	}
		1459	} else {
		1460	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_MALLPowerController,
		1461	SMU_MALL_DRIVER_CONTROL, NULL);
		1462	if (ret) {
		1463	dev_err(adev->dev, "Init MALL Driver CONTROL Failure\n");
		1464	return ret;
		1465	}
		1466
		1467	if (pg_config == SMU_MALL_PG_CONFIG_DRIVER_CONTROL_ALWAYS_ON) {
		1468	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_MALLPowerState,
		1469	SMU_MALL_EXIT_PG, NULL);
		1470	if (ret) {
		1471	dev_err(adev->dev, "EXIT MALL PG Failure\n");
		1472	return ret;
		1473	}
		1474	} else if (pg_config == SMU_MALL_PG_CONFIG_DRIVER_CONTROL_ALWAYS_OFF) {
		1475	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_MALLPowerState,
		1476	SMU_MALL_ENTER_PG, NULL);
		1477	if (ret) {
		1478	dev_err(adev->dev, "Enter MALL PG Failure\n");
		1479	return ret;
		1480	}
		1481	}
		1482	}
		1483
		1484	return ret;
		1485	}
		1486
		1487	static int smu_v14_0_common_set_mall_enable(struct smu_context *smu)
		1488	{
		1489	enum smu_mall_pg_config pg_config = SMU_MALL_PG_CONFIG_DEFAULT;
		1490	int ret = 0;
		1491
		1492	if (amdgpu_ip_version(smu->adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 1))
		1493	ret = smu_v14_0_1_init_mall_power_gating(smu, pg_config);
		1494
		1495	return ret;
		1496	}
		1497
1426	static const struct pptable_funcs smu_v14_0_0_ppt_funcs = {	1498	static const struct pptable_funcs smu_v14_0_0_ppt_funcs = {
1427	.check_fw_status = smu_v14_0_check_fw_status,	1499	.check_fw_status = smu_v14_0_check_fw_status,
1428	.check_fw_version = smu_v14_0_check_fw_version,	1500	.check_fw_version = smu_v14_0_check_fw_version,
@@ -1454,6 +1526,7 @@ static const struct pptable_funcs smu_v14_0_0_ppt_funcs = { · 25 unmodified lines
1454	.dpm_set_vpe_enable = smu_v14_0_0_set_vpe_enable,	1526	.dpm_set_vpe_enable = smu_v14_0_0_set_vpe_enable,
1455	.dpm_set_umsch_mm_enable = smu_v14_0_0_set_umsch_mm_enable,	1527	.dpm_set_umsch_mm_enable = smu_v14_0_0_set_umsch_mm_enable,
1456	.get_dpm_clock_table = smu_v14_0_common_get_dpm_table,	1528	.get_dpm_clock_table = smu_v14_0_common_get_dpm_table,
		1529	.set_mall_enable = smu_v14_0_common_set_mall_enable,
1457	};	1530	};
1458		1531
1459	static void smu_v14_0_0_set_smu_mailbox_registers(struct smu_context *smu)	1532	static void smu_v14_0_0_set_smu_mailbox_registers(struct smu_context *smu)

drivers/gpu/drm/drm_fb_helper.c+3−3

 	if (!info)
 		return ERR_PTR(-ENOMEM);
+	if (!drm_leak_fbdev_smem)
+		info->flags |= FBINFO_HIDE_SMEM_START;
 	ret = fb_alloc_cmap(&info->cmap, 256, 0);
 	if (ret)
 		goto err_release;
 	info = fb_helper->info;
 	info->var.pixclock = 0;
-	if (!drm_leak_fbdev_smem)
-		info->flags |= FBINFO_HIDE_SMEM_START;
 	/* Need to drop locks to avoid recursive deadlock in
 	 * register_framebuffer. This is ok because the only thing left to do is
 	 * register the fbdev emulation instance in kernel_fb_helper_list. */

drivers/gpu/drm/drm_fbdev_dma.c+4−1

 		info->flags |= FBINFO_READS_FAST; /* signal caching */
 	info->screen_size = sizes->surface_height * fb->pitches[0];
 	info->screen_buffer = map.vaddr;
-	info->fix.smem_start = page_to_phys(virt_to_page(info->screen_buffer));
+	if (!(info->flags & FBINFO_HIDE_SMEM_START)) {
+		if (!drm_WARN_ON(dev, is_vmalloc_addr(info->screen_buffer)))
+			info->fix.smem_start = page_to_phys(virt_to_page(info->screen_buffer));
+	}
 	info->fix.smem_len = info->screen_size;
 	return 0;

drivers/gpu/drm/drm_file.c+3−5

 	dev = filp->minor->dev;
 	mutex_lock(&dev->filelist_mutex);
+	get_pid(pid);
 	old = rcu_replace_pointer(filp->pid, pid, 1);
 	mutex_unlock(&dev->filelist_mutex);
-	if (pid != old) {
+	synchronize_rcu();
-		get_pid(pid);
+	put_pid(old);
-		synchronize_rcu();
-		put_pid(old);
-	}
 }
 /**

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

@@ -298,6 +298,7 @@ void i915_vma_revoke_fence(struct i915_vma *vma) · 297 unmodified lines
298	return;	298	return;
299		299
300	GEM_BUG_ON(fence->vma != vma);	300	GEM_BUG_ON(fence->vma != vma);
		301	i915_active_wait(&fence->active);
301	GEM_BUG_ON(!i915_active_is_idle(&fence->active));	302	GEM_BUG_ON(!i915_active_is_idle(&fence->active));
302	GEM_BUG_ON(atomic_read(&fence->pin_count));	303	GEM_BUG_ON(atomic_read(&fence->pin_count));
303		304

drivers/gpu/drm/nouveau/dispnv04/tvnv17.c+6−0

 		struct drm_display_mode *mode;
 		mode = drm_mode_duplicate(encoder->dev, tv_mode);
+		if (!mode)
+			continue;
 		mode->clock = tv_norm->tv_enc_mode.vrefresh *
 			mode->htotal / 1000 *
 		if (modes[i].hdisplay == output_mode->hdisplay &&
 		    modes[i].vdisplay == output_mode->vdisplay) {
 			mode = drm_mode_duplicate(encoder->dev, output_mode);
+			if (!mode)
+				continue;
 			mode->type |= DRM_MODE_TYPE_PREFERRED;
 		} else {
 					    modes[i].vdisplay, 60, false,
 					    (output_mode->flags &
 					     DRM_MODE_FLAG_INTERLACE), false);
+			if (!mode)
+				continue;
 		}
 		/* CVT modes are sometimes unsuitable... */

drivers/gpu/drm/panel/panel-simple.c+1−0

@@ -2752,6 +2752,7 @@ static const struct display_timing koe_tx26d202vm0bwa_timing = { · 2751 unmodified lines
2752	.vfront_porch = { 3, 5, 10 },	2752	.vfront_porch = { 3, 5, 10 },
2753	.vback_porch = { 2, 5, 10 },	2753	.vback_porch = { 2, 5, 10 },
2754	.vsync_len = { 5, 5, 5 },	2754	.vsync_len = { 5, 5, 5 },
		2755	.flags = DISPLAY_FLAGS_DE_HIGH,
2755	};	2756	};
2756		2757
2757	static const struct panel_desc koe_tx26d202vm0bwa = {	2758	static const struct panel_desc koe_tx26d202vm0bwa = {

drivers/i2c/busses/Makefile+2−4

 obj-$(CONFIG_I2C_SIS96X)	+= i2c-sis96x.o
 obj-$(CONFIG_I2C_VIA)		+= i2c-via.o
 obj-$(CONFIG_I2C_VIAPRO)	+= i2c-viapro.o
-i2c-zhaoxin-objs := i2c-viai2c-zhaoxin.o i2c-viai2c-common.o
+obj-$(CONFIG_I2C_ZHAOXIN)	+= i2c-viai2c-zhaoxin.o i2c-viai2c-common.o
-obj-$(CONFIG_I2C_ZHAOXIN)	+= i2c-zhaoxin.o
 # Mac SMBus host controller drivers
 obj-$(CONFIG_I2C_HYDRA)		+= i2c-hydra.o
 obj-$(CONFIG_I2C_UNIPHIER)	+= i2c-uniphier.o
 obj-$(CONFIG_I2C_UNIPHIER_F)	+= i2c-uniphier-f.o
 obj-$(CONFIG_I2C_VERSATILE)	+= i2c-versatile.o
-i2c-wmt-objs := i2c-viai2c-wmt.o i2c-viai2c-common.o
+obj-$(CONFIG_I2C_WMT)		+= i2c-viai2c-wmt.o i2c-viai2c-common.o
-obj-$(CONFIG_I2C_WMT)		+= i2c-wmt.o
 i2c-octeon-objs := i2c-octeon-core.o i2c-octeon-platdrv.o
 obj-$(CONFIG_I2C_OCTEON)	+= i2c-octeon.o
 i2c-thunderx-objs := i2c-octeon-core.o i2c-thunderx-pcidrv.o

drivers/i2c/busses/i2c-viai2c-common.c+9−62

@@ -17,6 +17,7 @@ int viai2c_wait_bus_not_busy(struct viai2c *i2c) · 16 unmodified lines
17		17
18	return 0;	18	return 0;
19	}	19	}
		20	EXPORT_SYMBOL_GPL(viai2c_wait_bus_not_busy);
20		21
21	static int viai2c_write(struct viai2c i2c, struct i2c_msg pmsg, int last)	22	static int viai2c_write(struct viai2c i2c, struct i2c_msg pmsg, int last)
22	{	23	{
@@ -121,6 +122,7 @@ int viai2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) · 98 unmodified lines
121		122
122	return (ret < 0) ? ret : i;	123	return (ret < 0) ? ret : i;
123	}	124	}
		125	EXPORT_SYMBOL_GPL(viai2c_xfer);
124		126
125	/*	127	/*
126	* Main process of the byte mode xfer	128	* Main process of the byte mode xfer
@@ -130,7 +132,7 @@ int viai2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) · 3 unmodified lines
130	* 0: there is still data that needs to be transferred	132	* 0: there is still data that needs to be transferred
131	* -EIO: error occurred	133	* -EIO: error occurred
132	*/	134	*/
133	static int viai2c_irq_xfer(struct viai2c *i2c)	135	int viai2c_irq_xfer(struct viai2c *i2c)
134	{	136	{
135	u16 val;	137	u16 val;
136	struct i2c_msg *msg = i2c->msg;	138	struct i2c_msg *msg = i2c->msg;
@@ -171,51 +173,11 @@ static int viai2c_irq_xfer(struct viai2c *i2c) · 34 unmodified lines
171		173
172	return i2c->xfered_len == msg->len;	174	return i2c->xfered_len == msg->len;
173	}	175	}
174		176	EXPORT_SYMBOL_GPL(viai2c_irq_xfer);
175	int __weak viai2c_fifo_irq_xfer(struct viai2c *i2c, bool irq)
176	{
177	return 0;
178	}
179
180	static irqreturn_t viai2c_isr(int irq, void *data)
181	{
182	struct viai2c *i2c = data;
183	u8 status;
184
185	/* save the status and write-clear it */
186	status = readw(i2c->base + VIAI2C_REG_ISR);
187	if (!status && i2c->platform == VIAI2C_PLAT_ZHAOXIN)
188	return IRQ_NONE;
189
190	writew(status, i2c->base + VIAI2C_REG_ISR);
191
192	i2c->ret = 0;
193	if (status & VIAI2C_ISR_NACK_ADDR)
194	i2c->ret = -EIO;
195
196	if (i2c->platform == VIAI2C_PLAT_WMT && (status & VIAI2C_ISR_SCL_TIMEOUT))
197	i2c->ret = -ETIMEDOUT;
198
199	if (!i2c->ret) {
200	if (i2c->mode == VIAI2C_BYTE_MODE)
201	i2c->ret = viai2c_irq_xfer(i2c);
202	else
203	i2c->ret = viai2c_fifo_irq_xfer(i2c, true);
204	}
205
206	/* All the data has been successfully transferred or error occurred */
207	if (i2c->ret)
208	complete(&i2c->complete);
209
210	return IRQ_HANDLED;
211	}
212		177
213	int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat)	178	int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat)
214	{	179	{
215	int err;
216	int irq_flags;
217	struct viai2c *i2c;	180	struct viai2c *i2c;
218	struct device_node *np = pdev->dev.of_node;
219		181
220	i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL);	182	i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL);
221	if (!i2c)	183	if (!i2c)
@@ -225,28 +187,8 @@ int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat) · 3 unmodified lines
225	if (IS_ERR(i2c->base))	187	if (IS_ERR(i2c->base))
226	return PTR_ERR(i2c->base);	188	return PTR_ERR(i2c->base);
227		189
228	if (plat == VIAI2C_PLAT_WMT) {
229	irq_flags = 0;
230	i2c->irq = irq_of_parse_and_map(np, 0);
231	if (!i2c->irq)
232	return -EINVAL;
233	} else if (plat == VIAI2C_PLAT_ZHAOXIN) {
234	irq_flags = IRQF_SHARED;
235	i2c->irq = platform_get_irq(pdev, 0);
236	if (i2c->irq < 0)
237	return i2c->irq;
238	} else {
239	return dev_err_probe(&pdev->dev, -EINVAL, "wrong platform type\n");
240	}
241
242	i2c->platform = plat;	190	i2c->platform = plat;
243		191
244	err = devm_request_irq(&pdev->dev, i2c->irq, viai2c_isr,
245	irq_flags, pdev->name, i2c);
246	if (err)
247	return dev_err_probe(&pdev->dev, err,
248	"failed to request irq %i\n", i2c->irq);
249
250	i2c->dev = &pdev->dev;	192	i2c->dev = &pdev->dev;
251	init_completion(&i2c->complete);	193	init_completion(&i2c->complete);
252	platform_set_drvdata(pdev, i2c);	194	platform_set_drvdata(pdev, i2c);
@@ -254,3 +196,8 @@ int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat) · 1 unmodified line
254	*pi2c = i2c;	196	*pi2c = i2c;
255	return 0;	197	return 0;
256	}	198	}
		199	EXPORT_SYMBOL_GPL(viai2c_init);
		200
		201	MODULE_DESCRIPTION("Via/Wondermedia/Zhaoxin I2C master-mode bus adapter");
		202	MODULE_AUTHOR("Tony Prisk <linux@prisktech.co.nz>");
		203	MODULE_LICENSE("GPL");

drivers/i2c/busses/i2c-viai2c-common.h+1−1

@@ -80,6 +80,6 @@ struct viai2c { · 79 unmodified lines
80	int viai2c_wait_bus_not_busy(struct viai2c *i2c);	80	int viai2c_wait_bus_not_busy(struct viai2c *i2c);
81	int viai2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num);	81	int viai2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num);
82	int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat);	82	int viai2c_init(struct platform_device pdev, struct viai2c *pi2c, int plat);
83	int viai2c_fifo_irq_xfer(struct viai2c *i2c, bool irq);	83	int viai2c_irq_xfer(struct viai2c *i2c);
84		84
85	#endif	85	#endif

drivers/i2c/busses/i2c-viai2c-wmt.c+36−0

@@ -72,6 +72,32 @@ static int wmt_i2c_reset_hardware(struct viai2c *i2c) · 71 unmodified lines
72	return 0;	72	return 0;
73	}	73	}
74		74
		75	static irqreturn_t wmt_i2c_isr(int irq, void *data)
		76	{
		77	struct viai2c *i2c = data;
		78	u8 status;
		79
		80	/* save the status and write-clear it */
		81	status = readw(i2c->base + VIAI2C_REG_ISR);
		82	writew(status, i2c->base + VIAI2C_REG_ISR);
		83
		84	i2c->ret = 0;
		85	if (status & VIAI2C_ISR_NACK_ADDR)
		86	i2c->ret = -EIO;
		87
		88	if (status & VIAI2C_ISR_SCL_TIMEOUT)
		89	i2c->ret = -ETIMEDOUT;
		90
		91	if (!i2c->ret)
		92	i2c->ret = viai2c_irq_xfer(i2c);
		93
		94	/* All the data has been successfully transferred or error occurred */
		95	if (i2c->ret)
		96	complete(&i2c->complete);
		97
		98	return IRQ_HANDLED;
		99	}
		100
75	static int wmt_i2c_probe(struct platform_device *pdev)	101	static int wmt_i2c_probe(struct platform_device *pdev)
76	{	102	{
77	struct device_node *np = pdev->dev.of_node;	103	struct device_node *np = pdev->dev.of_node;
@@ -84,6 +110,16 @@ static int wmt_i2c_probe(struct platform_device *pdev) · 6 unmodified lines
84	if (err)	110	if (err)
85	return err;	111	return err;
86		112
		113	i2c->irq = platform_get_irq(pdev, 0);
		114	if (i2c->irq < 0)
		115	return i2c->irq;
		116
		117	err = devm_request_irq(&pdev->dev, i2c->irq, wmt_i2c_isr,
		118	0, pdev->name, i2c);
		119	if (err)
		120	return dev_err_probe(&pdev->dev, err,
		121	"failed to request irq %i\n", i2c->irq);
		122
87	i2c->clk = of_clk_get(np, 0);	123	i2c->clk = of_clk_get(np, 0);
88	if (IS_ERR(i2c->clk)) {	124	if (IS_ERR(i2c->clk)) {
89	dev_err(&pdev->dev, "unable to request clock\n");	125	dev_err(&pdev->dev, "unable to request clock\n");

drivers/i2c/busses/i2c-viai2c-zhaoxin.c+91−22

@@ -49,8 +49,7 @@ struct viai2c_zhaoxin { · 48 unmodified lines
49	u16 xfer_len;	49	u16 xfer_len;
50	};	50	};
51		51
52	/* 'irq == true' means in interrupt context */	52	static int viai2c_fifo_xfer(struct viai2c *i2c)
53	int viai2c_fifo_irq_xfer(struct viai2c *i2c, bool irq)
54	{	53	{
55	u16 i;	54	u16 i;
56	u8 tmp;	55	u8 tmp;
@@ -59,17 +58,6 @@ int viai2c_fifo_irq_xfer(struct viai2c *i2c, bool irq) · 2 unmodified lines
59	bool read = !!(msg->flags & I2C_M_RD);	58	bool read = !!(msg->flags & I2C_M_RD);
60	struct viai2c_zhaoxin *priv = i2c->pltfm_priv;	59	struct viai2c_zhaoxin *priv = i2c->pltfm_priv;
61		60
62	if (irq) {
63	/* get the received data */
64	if (read)
65	for (i = 0; i < priv->xfer_len; i++)
66	msg->buf[i2c->xfered_len + i] = ioread8(base + ZXI2C_REG_HRDR);
67
68	i2c->xfered_len += priv->xfer_len;
69	if (i2c->xfered_len == msg->len)
70	return 1;
71	}
72
73	/* reset fifo buffer */	61	/* reset fifo buffer */
74	tmp = ioread8(base + ZXI2C_REG_HCR);	62	tmp = ioread8(base + ZXI2C_REG_HCR);
75	iowrite8(tmp \| ZXI2C_HCR_RST_FIFO, base + ZXI2C_REG_HCR);	63	iowrite8(tmp \| ZXI2C_HCR_RST_FIFO, base + ZXI2C_REG_HCR);
@@ -92,18 +80,59 @@ int viai2c_fifo_irq_xfer(struct viai2c *i2c, bool irq) · 16 unmodified lines
92	iowrite8(tmp, base + VIAI2C_REG_CR);	80	iowrite8(tmp, base + VIAI2C_REG_CR);
93	}	81	}
94		82
95	if (irq) {	83	u16 tcr_val = i2c->tcr;
96	/* continue transmission */	84
97	tmp = ioread8(base + VIAI2C_REG_CR);	85	/* start transmission */
98	iowrite8(tmp \|= VIAI2C_CR_CPU_RDY, base + VIAI2C_REG_CR);	86	tcr_val \|= read ? VIAI2C_TCR_READ : 0;
		87	writew(tcr_val \| msg->addr, base + VIAI2C_REG_TCR);
		88
		89	return 0;
		90	}
		91
		92	static int viai2c_fifo_irq_xfer(struct viai2c *i2c)
		93	{
		94	u16 i;
		95	u8 tmp;
		96	struct i2c_msg *msg = i2c->msg;
		97	void __iomem *base = i2c->base;
		98	bool read = !!(msg->flags & I2C_M_RD);
		99	struct viai2c_zhaoxin *priv = i2c->pltfm_priv;
		100
		101	/* get the received data */
		102	if (read)
		103	for (i = 0; i < priv->xfer_len; i++)
		104	msg->buf[i2c->xfered_len + i] = ioread8(base + ZXI2C_REG_HRDR);
		105
		106	i2c->xfered_len += priv->xfer_len;
		107	if (i2c->xfered_len == msg->len)
		108	return 1;
		109
		110	/* reset fifo buffer */
		111	tmp = ioread8(base + ZXI2C_REG_HCR);
		112	iowrite8(tmp \| ZXI2C_HCR_RST_FIFO, base + ZXI2C_REG_HCR);
		113
		114	/* set xfer len */
		115	priv->xfer_len = min_t(u16, msg->len - i2c->xfered_len, ZXI2C_FIFO_SIZE);
		116	if (read) {
		117	iowrite8(priv->xfer_len - 1, base + ZXI2C_REG_HRLR);
99	} else {	118	} else {
100	u16 tcr_val = i2c->tcr;	119	iowrite8(priv->xfer_len - 1, base + ZXI2C_REG_HTLR);
		120	/* set write data */
		121	for (i = 0; i < priv->xfer_len; i++)
		122	iowrite8(msg->buf[i2c->xfered_len + i], base + ZXI2C_REG_HTDR);
		123	}
101		124
102	/* start transmission */	125	/* prepare to stop transmission */
103	tcr_val \|= read ? VIAI2C_TCR_READ : 0;	126	if (priv->hrv && msg->len == (i2c->xfered_len + priv->xfer_len)) {
104	writew(tcr_val \| msg->addr, base + VIAI2C_REG_TCR);	127	tmp = ioread8(base + VIAI2C_REG_CR);
		128	tmp \|= read ? VIAI2C_CR_RX_END : VIAI2C_CR_TX_END;
		129	iowrite8(tmp, base + VIAI2C_REG_CR);
105	}	130	}
106		131
		132	/* continue transmission */
		133	tmp = ioread8(base + VIAI2C_REG_CR);
		134	iowrite8(tmp \|= VIAI2C_CR_CPU_RDY, base + VIAI2C_REG_CR);
		135
107	return 0;	136	return 0;
108	}	137	}
109		138
@@ -135,7 +164,7 @@ static int zxi2c_master_xfer(struct i2c_adapter adap, struct i2c_msg msgs, int · 25 unmodified lines
135	priv->xfer_len = 0;	164	priv->xfer_len = 0;
136	i2c->xfered_len = 0;	165	i2c->xfered_len = 0;
137		166
138	viai2c_fifo_irq_xfer(i2c, 0);	167	viai2c_fifo_xfer(i2c);
139		168
140	if (!wait_for_completion_timeout(&i2c->complete, VIAI2C_TIMEOUT))	169	if (!wait_for_completion_timeout(&i2c->complete, VIAI2C_TIMEOUT))
141	return -ETIMEDOUT;	170	return -ETIMEDOUT;
@@ -228,6 +257,36 @@ static void zxi2c_get_bus_speed(struct viai2c *i2c) · 86 unmodified lines
228	dev_info(i2c->dev, "speed mode is %s\n", i2c_freq_mode_string(params[0]));	257	dev_info(i2c->dev, "speed mode is %s\n", i2c_freq_mode_string(params[0]));
229	}	258	}
230		259
		260	static irqreturn_t zxi2c_isr(int irq, void *data)
		261	{
		262	struct viai2c *i2c = data;
		263	u8 status;
		264
		265	/* save the status and write-clear it */
		266	status = readw(i2c->base + VIAI2C_REG_ISR);
		267	if (!status)
		268	return IRQ_NONE;
		269
		270	writew(status, i2c->base + VIAI2C_REG_ISR);
		271
		272	i2c->ret = 0;
		273	if (status & VIAI2C_ISR_NACK_ADDR)
		274	i2c->ret = -EIO;
		275
		276	if (!i2c->ret) {
		277	if (i2c->mode == VIAI2C_BYTE_MODE)
		278	i2c->ret = viai2c_irq_xfer(i2c);
		279	else
		280	i2c->ret = viai2c_fifo_irq_xfer(i2c);
		281	}
		282
		283	/* All the data has been successfully transferred or error occurred */
		284	if (i2c->ret)
		285	complete(&i2c->complete);
		286
		287	return IRQ_HANDLED;
		288	}
		289
231	static int zxi2c_probe(struct platform_device *pdev)	290	static int zxi2c_probe(struct platform_device *pdev)
232	{	291	{
233	int error;	292	int error;
@@ -239,6 +298,16 @@ static int zxi2c_probe(struct platform_device *pdev) · 5 unmodified lines
239	if (error)	298	if (error)
240	return error;	299	return error;
241		300
		301	i2c->irq = platform_get_irq(pdev, 0);
		302	if (i2c->irq < 0)
		303	return i2c->irq;
		304
		305	error = devm_request_irq(&pdev->dev, i2c->irq, zxi2c_isr,
		306	IRQF_SHARED, pdev->name, i2c);
		307	if (error)
		308	return dev_err_probe(&pdev->dev, error,
		309	"failed to request irq %i\n", i2c->irq);
		310
242	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);	311	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
243	if (!priv)	312	if (!priv)
244	return -ENOMEM;	313	return -ENOMEM;

drivers/i2c/i2c-slave-testunit.c+4−1

 			queue_delayed_work(system_long_wq, &tu->worker,
 					   msecs_to_jiffies(10 * tu->regs[TU_REG_DELAY]));
 		}
-		fallthrough;
+		break;
 	case I2C_SLAVE_WRITE_REQUESTED:
+		if (test_bit(TU_FLAG_IN_PROCESS, &tu->flags))
+			return -EBUSY;
 		memset(tu->regs, 0, TU_NUM_REGS);
 		tu->reg_idx = 0;
 		break;

drivers/iio/accel/Kconfig+2−0

@@ -330,6 +330,8 @@ config DMARD10 · 329 unmodified lines
330	config FXLS8962AF	330	config FXLS8962AF
331	tristate	331	tristate
332	depends on I2C \|\| !I2C # cannot be built-in for modular I2C	332	depends on I2C \|\| !I2C # cannot be built-in for modular I2C
		333	select IIO_BUFFER
		334	select IIO_KFIFO_BUF
333		335
334	config FXLS8962AF_I2C	336	config FXLS8962AF_I2C
335	tristate "NXP FXLS8962AF/FXLS8964AF Accelerometer I2C Driver"	337	tristate "NXP FXLS8962AF/FXLS8964AF Accelerometer I2C Driver"

drivers/iio/adc/ad7266.c+2−0

@@ -157,6 +157,8 @@ static int ad7266_read_raw(struct iio_dev *indio_dev, · 156 unmodified lines
157	ret = ad7266_read_single(st, val, chan->address);	157	ret = ad7266_read_single(st, val, chan->address);
158	iio_device_release_direct_mode(indio_dev);	158	iio_device_release_direct_mode(indio_dev);
159		159
		160	if (ret < 0)
		161	return ret;
160	val = (val >> 2) & 0xfff;	162	val = (val >> 2) & 0xfff;
161	if (chan->scan_type.sign == 's')	163	if (chan->scan_type.sign == 's')
162	val = sign_extend32(val,	164	val = sign_extend32(val,

drivers/iio/adc/xilinx-ams.c+6−2

 	/* Run calibration of PS & PL as part of the sequence */
 	scan_mask = BIT(0) | BIT(AMS_PS_SEQ_MAX);
-	for (i = 0; i < indio_dev->num_channels; i++)
+	for (i = 0; i < indio_dev->num_channels; i++) {
-		scan_mask |= BIT_ULL(indio_dev->channels[i].scan_index);
+		const struct iio_chan_spec *chan = &indio_dev->channels[i];
+		if (chan->scan_index < AMS_CTRL_SEQ_BASE)
+			scan_mask |= BIT_ULL(chan->scan_index);
+	}
 	if (ams->ps_base) {
 		/* put sysmon in a soft reset to change the sequence */

drivers/iio/chemical/bme680.h+2−0

@@ -54,7 +54,9 @@ · 53 unmodified lines
54	#define BME680_NB_CONV_MASK GENMASK(3, 0)	54	#define BME680_NB_CONV_MASK GENMASK(3, 0)
55		55
56	#define BME680_REG_MEAS_STAT_0 0x1D	56	#define BME680_REG_MEAS_STAT_0 0x1D
		57	#define BME680_NEW_DATA_BIT BIT(7)
57	#define BME680_GAS_MEAS_BIT BIT(6)	58	#define BME680_GAS_MEAS_BIT BIT(6)
		59	#define BME680_MEAS_BIT BIT(5)
58		60
59	/* Calibration Parameters */	61	/* Calibration Parameters */
60	#define BME680_T2_LSB_REG 0x8A	62	#define BME680_T2_LSB_REG 0x8A

drivers/iio/chemical/bme680_core.c+54−8

  */
 #include <linux/acpi.h>
 #include <linux/bitfield.h>
+#include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/log2.h>
 	s8  par_h3;
 	s8  par_h4;
 	s8  par_h5;
-	s8  par_h6;
+	u8  par_h6;
 	s8  par_h7;
 	s8  par_gh1;
 	s16 par_gh2;
 	if (!calib->par_t2)
 		bme680_read_calib(data, calib);
-	var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
+	var1 = (adc_temp >> 3) - ((s32)calib->par_t1 << 1);
 	var2 = (var1 * calib->par_t2) >> 11;
 	var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
-	var3 = (var3 * (calib->par_t3 << 4)) >> 14;
+	var3 = (var3 * ((s32)calib->par_t3 << 4)) >> 14;
 	data->t_fine = var2 + var3;
 	calc_temp = (data->t_fine * 5 + 128) >> 8;
 	var1 = (data->t_fine >> 1) - 64000;
 	var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * calib->par_p6) >> 2;
 	var2 = var2 + (var1 * calib->par_p5 << 1);
-	var2 = (var2 >> 2) + (calib->par_p4 << 16);
+	var2 = (var2 >> 2) + ((s32)calib->par_p4 << 16);
 	var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
-			(calib->par_p3 << 5)) >> 3) +
+			((s32)calib->par_p3 << 5)) >> 3) +
 			((calib->par_p2 * var1) >> 1);
 	var1 = var1 >> 18;
 	var1 = ((32768 + var1) * calib->par_p1) >> 15;
 	var3 = ((press_comp >> 8) * (press_comp >> 8) *
 			(press_comp >> 8) * calib->par_p10) >> 17;
-	press_comp += (var1 + var2 + var3 + (calib->par_p7 << 7)) >> 4;
+	press_comp += (var1 + var2 + var3 + ((s32)calib->par_p7 << 7)) >> 4;
 	return press_comp;
 }
 		 (((temp_scaled * ((temp_scaled * calib->par_h5) / 100))
 		   >> 6) / 100) + (1 << 14))) >> 10;
 	var3 = var1 * var2;
-	var4 = calib->par_h6 << 7;
+	var4 = (s32)calib->par_h6 << 7;
 	var4 = (var4 + ((temp_scaled * calib->par_h7) / 100)) >> 4;
 	var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
 	var6 = (var4 * var5) >> 1;
 	return ilog2(val) + 1;
 }
+/*
+ * Taken from Bosch BME680 API:
+ * https://github.com/boschsensortec/BME68x_SensorAPI/blob/v4.4.8/bme68x.c#L490
+ */
+static int bme680_wait_for_eoc(struct bme680_data *data)
+{
+	struct device *dev = regmap_get_device(data->regmap);
+	unsigned int check;
+	int ret;
+	/*
+	 * (Sum of oversampling ratios * time per oversampling) +
+	 * TPH measurement + gas measurement + wait transition from forced mode
+	 * + heater duration
+	 */
+	int wait_eoc_us = ((data->oversampling_temp + data->oversampling_press +
+			   data->oversampling_humid) * 1936) + (477 * 4) +
+			   (477 * 5) + 1000 + (data->heater_dur * 1000);
+	usleep_range(wait_eoc_us, wait_eoc_us + 100);
+	ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check);
+	if (ret) {
+		dev_err(dev, "failed to read measurement status register.\n");
+		return ret;
+	}
+	if (check & BME680_MEAS_BIT) {
+		dev_err(dev, "Device measurement cycle incomplete.\n");
+		return -EBUSY;
+	}
+	if (!(check & BME680_NEW_DATA_BIT)) {
+		dev_err(dev, "No new data available from the device.\n");
+		return -ENODATA;
+	}
+	return 0;
+}
 static int bme680_chip_config(struct bme680_data *data)
 {
 	struct device *dev = regmap_get_device(data->regmap);
 	if (ret < 0)
 		return ret;
+	ret = bme680_wait_for_eoc(data);
+	if (ret)
+		return ret;
 	ret = regmap_bulk_read(data->regmap, BME680_REG_TEMP_MSB,
 			       &tmp, 3);
 	if (ret < 0) {
 	}
 	*val = bme680_compensate_press(data, adc_press);
-	*val2 = 100;
+	*val2 = 1000;
 	return IIO_VAL_FRACTIONAL;
 }
 	if (ret < 0)
 		return ret;
+	ret = bme680_wait_for_eoc(data);
+	if (ret)
+		return ret;
 	ret = regmap_read(data->regmap, BME680_REG_MEAS_STAT_0, &check);
 	if (check & BME680_GAS_MEAS_BIT) {
 		dev_err(dev, "gas measurement incomplete\n");

drivers/iio/dac/Kconfig+1−1

@@ -133,7 +133,7 @@ config AD5624R_SPI · 132 unmodified lines
133		133
134	config AD9739A	134	config AD9739A
135	tristate "Analog Devices AD9739A RF DAC spi driver"	135	tristate "Analog Devices AD9739A RF DAC spi driver"
136	depends on SPI \|\| COMPILE_TEST	136	depends on SPI
137	select REGMAP_SPI	137	select REGMAP_SPI
138	select IIO_BACKEND	138	select IIO_BACKEND
139	help	139	help

drivers/iio/humidity/hdc3020.c+249−76

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <linux/i2c.h>	19	#include <linux/i2c.h>
20	#include <linux/init.h>	20	#include <linux/init.h>
21	#include <linux/interrupt.h>	21	#include <linux/interrupt.h>
		22	#include <linux/math64.h>
22	#include <linux/module.h>	23	#include <linux/module.h>
23	#include <linux/mutex.h>	24	#include <linux/mutex.h>
24	#include <linux/pm.h>	25	#include <linux/pm.h>
@@ -66,8 +67,10 @@ · 41 unmodified lines
66		67
67	#define HDC3020_CRC8_POLYNOMIAL 0x31	68	#define HDC3020_CRC8_POLYNOMIAL 0x31
68		69
69	#define HDC3020_MIN_TEMP -40	70	#define HDC3020_MIN_TEMP_MICRO -39872968
70	#define HDC3020_MAX_TEMP 125	71	#define HDC3020_MAX_TEMP_MICRO 124875639
		72	#define HDC3020_MAX_TEMP_HYST_MICRO 164748607
		73	#define HDC3020_MAX_HUM_MICRO 99220264
71		74
72	struct hdc3020_data {	75	struct hdc3020_data {
73	struct i2c_client *client;	76	struct i2c_client *client;
@@ -368,6 +371,105 @@ static int hdc3020_write_raw(struct iio_dev *indio_dev, · 294 unmodified lines
368	return -EINVAL;	371	return -EINVAL;
369	}	372	}
370		373
		374	static int hdc3020_thresh_get_temp(u16 thresh)
		375	{
		376	int temp;
		377
		378	/*
		379	* Get the temperature threshold from 9 LSBs, shift them to get
		380	* the truncated temperature threshold representation and
		381	* calculate the threshold according to the formula in the
		382	* datasheet. Result is degree celsius scaled by 65535.
		383	*/
		384	temp = FIELD_GET(HDC3020_THRESH_TEMP_MASK, thresh) <<
		385	HDC3020_THRESH_TEMP_TRUNC_SHIFT;
		386
		387	return -2949075 + (175 * temp);
		388	}
		389
		390	static int hdc3020_thresh_get_hum(u16 thresh)
		391	{
		392	int hum;
		393
		394	/*
		395	* Get the humidity threshold from 7 MSBs, shift them to get the
		396	* truncated humidity threshold representation and calculate the
		397	* threshold according to the formula in the datasheet. Result is
		398	* percent scaled by 65535.
		399	*/
		400	hum = FIELD_GET(HDC3020_THRESH_HUM_MASK, thresh) <<
		401	HDC3020_THRESH_HUM_TRUNC_SHIFT;
		402
		403	return hum * 100;
		404	}
		405
		406	static u16 hdc3020_thresh_set_temp(int s_temp, u16 curr_thresh)
		407	{
		408	u64 temp;
		409	u16 thresh;
		410
		411	/*
		412	* Calculate temperature threshold, shift it down to get the
		413	* truncated threshold representation in the 9LSBs while keeping
		414	* the current humidity threshold in the 7 MSBs.
		415	*/
		416	temp = (u64)(s_temp + 45000000) * 65535ULL;
		417	temp = div_u64(temp, 1000000 * 175) >> HDC3020_THRESH_TEMP_TRUNC_SHIFT;
		418	thresh = FIELD_PREP(HDC3020_THRESH_TEMP_MASK, temp);
		419	thresh \|= (FIELD_GET(HDC3020_THRESH_HUM_MASK, curr_thresh) <<
		420	HDC3020_THRESH_HUM_TRUNC_SHIFT);
		421
		422	return thresh;
		423	}
		424
		425	static u16 hdc3020_thresh_set_hum(int s_hum, u16 curr_thresh)
		426	{
		427	u64 hum;
		428	u16 thresh;
		429
		430	/*
		431	* Calculate humidity threshold, shift it down and up to get the
		432	* truncated threshold representation in the 7MSBs while keeping
		433	* the current temperature threshold in the 9 LSBs.
		434	*/
		435	hum = (u64)(s_hum) * 65535ULL;
		436	hum = div_u64(hum, 1000000 * 100) >> HDC3020_THRESH_HUM_TRUNC_SHIFT;
		437	thresh = FIELD_PREP(HDC3020_THRESH_HUM_MASK, hum);
		438	thresh \|= FIELD_GET(HDC3020_THRESH_TEMP_MASK, curr_thresh);
		439
		440	return thresh;
		441	}
		442
		443	static
		444	int hdc3020_thresh_clr(s64 s_thresh, s64 s_hyst, enum iio_event_direction dir)
		445	{
		446	s64 s_clr;
		447
		448	/*
		449	* Include directions when calculation the clear value,
		450	* since hysteresis is unsigned by definition and the
		451	* clear value is an absolute value which is signed.
		452	*/
		453	if (dir == IIO_EV_DIR_RISING)
		454	s_clr = s_thresh - s_hyst;
		455	else
		456	s_clr = s_thresh + s_hyst;
		457
		458	/* Divide by 65535 to get units of micro */
		459	return div_s64(s_clr, 65535);
		460	}
		461
		462	static int _hdc3020_write_thresh(struct hdc3020_data *data, u16 reg, u16 val)
		463	{
		464	u8 buf[5];
		465
		466	put_unaligned_be16(reg, buf);
		467	put_unaligned_be16(val, buf + 2);
		468	buf[4] = crc8(hdc3020_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);
		469
		470	return hdc3020_write_bytes(data, buf, 5);
		471	}
		472
371	static int hdc3020_write_thresh(struct iio_dev *indio_dev,	473	static int hdc3020_write_thresh(struct iio_dev *indio_dev,
372	const struct iio_chan_spec *chan,	474	const struct iio_chan_spec *chan,
373	enum iio_event_type type,	475	enum iio_event_type type,
@@ -376,67 +478,126 @@ static int hdc3020_write_thresh(struct iio_dev *indio_dev, · 2 unmodified lines
376	int val, int val2)	478	int val, int val2)
377	{	479	{
378	struct hdc3020_data *data = iio_priv(indio_dev);	480	struct hdc3020_data *data = iio_priv(indio_dev);
379	u8 buf[5];	481	u16 reg, reg_val, reg_thresh_rd, reg_clr_rd, reg_thresh_wr, reg_clr_wr;
380	u64 tmp;	482	s64 s_thresh, s_hyst, s_clr;
381	u16 reg;	483	int s_val, thresh, clr, ret;
382	int ret;	484
383		485	/* Select threshold registers */
384	/* Supported temperature range is from –40 to 125 degree celsius */	486	if (dir == IIO_EV_DIR_RISING) {
385	if (val < HDC3020_MIN_TEMP \|\| val > HDC3020_MAX_TEMP)	487	reg_thresh_rd = HDC3020_R_T_RH_THRESH_HIGH;
386	return -EINVAL;	488	reg_thresh_wr = HDC3020_S_T_RH_THRESH_HIGH;
387		489	reg_clr_rd = HDC3020_R_T_RH_THRESH_HIGH_CLR;
388	/* Select threshold register */	490	reg_clr_wr = HDC3020_S_T_RH_THRESH_HIGH_CLR;
389	if (info == IIO_EV_INFO_VALUE) {
390	if (dir == IIO_EV_DIR_RISING)
391	reg = HDC3020_S_T_RH_THRESH_HIGH;
392	else
393	reg = HDC3020_S_T_RH_THRESH_LOW;
394	} else {	491	} else {
395	if (dir == IIO_EV_DIR_RISING)	492	reg_thresh_rd = HDC3020_R_T_RH_THRESH_LOW;
396	reg = HDC3020_S_T_RH_THRESH_HIGH_CLR;	493	reg_thresh_wr = HDC3020_S_T_RH_THRESH_LOW;
397	else	494	reg_clr_rd = HDC3020_R_T_RH_THRESH_LOW_CLR;
398	reg = HDC3020_S_T_RH_THRESH_LOW_CLR;	495	reg_clr_wr = HDC3020_S_T_RH_THRESH_LOW_CLR;
399	}	496	}
400		497
401	guard(mutex)(&data->lock);	498	guard(mutex)(&data->lock);
402	ret = hdc3020_read_be16(data, reg);	499	ret = hdc3020_read_be16(data, reg_thresh_rd);
		500	if (ret < 0)
		501	return ret;
		502
		503	thresh = ret;
		504	ret = hdc3020_read_be16(data, reg_clr_rd);
403	if (ret < 0)	505	if (ret < 0)
404	return ret;	506	return ret;
405		507
		508	clr = ret;
		509	/* Scale value to include decimal part into calculations */
		510	s_val = (val < 0) ? (val * 1000000 - val2) : (val * 1000000 + val2);
406	switch (chan->type) {	511	switch (chan->type) {
407	case IIO_TEMP:	512	case IIO_TEMP:
408	/*	513	switch (info) {
409	* Calculate temperature threshold, shift it down to get the	514	case IIO_EV_INFO_VALUE:
410	* truncated threshold representation in the 9LSBs while keeping	515	s_val = max(s_val, HDC3020_MIN_TEMP_MICRO);
411	* the current humidity threshold in the 7 MSBs.	516	s_val = min(s_val, HDC3020_MAX_TEMP_MICRO);
412	*/	517	reg = reg_thresh_wr;
413	tmp = ((u64)(((val + 45) * MICRO) + val2)) * 65535ULL;	518	reg_val = hdc3020_thresh_set_temp(s_val, thresh);
414	tmp = div_u64(tmp, MICRO * 175);	519	ret = _hdc3020_write_thresh(data, reg, reg_val);
415	val = tmp >> HDC3020_THRESH_TEMP_TRUNC_SHIFT;	520	if (ret < 0)
416	val = FIELD_PREP(HDC3020_THRESH_TEMP_MASK, val);	521	return ret;
417	val \|= (FIELD_GET(HDC3020_THRESH_HUM_MASK, ret) <<	522
418	HDC3020_THRESH_HUM_TRUNC_SHIFT);	523	/* Calculate old hysteresis */
		524	s_thresh = (s64)hdc3020_thresh_get_temp(thresh) * 1000000;
		525	s_clr = (s64)hdc3020_thresh_get_temp(clr) * 1000000;
		526	s_hyst = div_s64(abs(s_thresh - s_clr), 65535);
		527	/* Set new threshold */
		528	thresh = reg_val;
		529	/* Set old hysteresis */
		530	s_val = s_hyst;
		531	fallthrough;
		532	case IIO_EV_INFO_HYSTERESIS:
		533	/*
		534	* Function hdc3020_thresh_get_temp returns temperature
		535	* in degree celsius scaled by 65535. Scale by 1000000
		536	* to be able to subtract scaled hysteresis value.
		537	*/
		538	s_thresh = (s64)hdc3020_thresh_get_temp(thresh) * 1000000;
		539	/*
		540	* Units of s_val are in micro degree celsius, scale by
		541	* 65535 to get same units as s_thresh.
		542	*/
		543	s_val = min(abs(s_val), HDC3020_MAX_TEMP_HYST_MICRO);
		544	s_hyst = (s64)s_val * 65535;
		545	s_clr = hdc3020_thresh_clr(s_thresh, s_hyst, dir);
		546	s_clr = max(s_clr, HDC3020_MIN_TEMP_MICRO);
		547	s_clr = min(s_clr, HDC3020_MAX_TEMP_MICRO);
		548	reg = reg_clr_wr;
		549	reg_val = hdc3020_thresh_set_temp(s_clr, clr);
		550	break;
		551	default:
		552	return -EOPNOTSUPP;
		553	}
419	break;	554	break;
420	case IIO_HUMIDITYRELATIVE:	555	case IIO_HUMIDITYRELATIVE:
421	/*	556	s_val = (s_val < 0) ? 0 : min(s_val, HDC3020_MAX_HUM_MICRO);
422	* Calculate humidity threshold, shift it down and up to get the	557	switch (info) {
423	* truncated threshold representation in the 7MSBs while keeping	558	case IIO_EV_INFO_VALUE:
424	* the current temperature threshold in the 9 LSBs.	559	reg = reg_thresh_wr;
425	*/	560	reg_val = hdc3020_thresh_set_hum(s_val, thresh);
426	tmp = ((u64)((val * MICRO) + val2)) * 65535ULL;	561	ret = _hdc3020_write_thresh(data, reg, reg_val);
427	tmp = div_u64(tmp, MICRO * 100);	562	if (ret < 0)
428	val = tmp >> HDC3020_THRESH_HUM_TRUNC_SHIFT;	563	return ret;
429	val = FIELD_PREP(HDC3020_THRESH_HUM_MASK, val);	564
430	val \|= FIELD_GET(HDC3020_THRESH_TEMP_MASK, ret);	565	/* Calculate old hysteresis */
		566	s_thresh = (s64)hdc3020_thresh_get_hum(thresh) * 1000000;
		567	s_clr = (s64)hdc3020_thresh_get_hum(clr) * 1000000;
		568	s_hyst = div_s64(abs(s_thresh - s_clr), 65535);
		569	/* Set new threshold */
		570	thresh = reg_val;
		571	/* Try to set old hysteresis */
		572	s_val = min(abs(s_hyst), HDC3020_MAX_HUM_MICRO);
		573	fallthrough;
		574	case IIO_EV_INFO_HYSTERESIS:
		575	/*
		576	* Function hdc3020_thresh_get_hum returns relative
		577	* humidity in percent scaled by 65535. Scale by 1000000
		578	* to be able to subtract scaled hysteresis value.
		579	*/
		580	s_thresh = (s64)hdc3020_thresh_get_hum(thresh) * 1000000;
		581	/*
		582	* Units of s_val are in micro percent, scale by 65535
		583	* to get same units as s_thresh.
		584	*/
		585	s_hyst = (s64)s_val * 65535;
		586	s_clr = hdc3020_thresh_clr(s_thresh, s_hyst, dir);
		587	s_clr = max(s_clr, 0);
		588	s_clr = min(s_clr, HDC3020_MAX_HUM_MICRO);
		589	reg = reg_clr_wr;
		590	reg_val = hdc3020_thresh_set_hum(s_clr, clr);
		591	break;
		592	default:
		593	return -EOPNOTSUPP;
		594	}
431	break;	595	break;
432	default:	596	default:
433	return -EOPNOTSUPP;	597	return -EOPNOTSUPP;
434	}	598	}
435		599
436	put_unaligned_be16(reg, buf);	600	return _hdc3020_write_thresh(data, reg, reg_val);
437	put_unaligned_be16(val, buf + 2);
438	buf[4] = crc8(hdc3020_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);
439	return hdc3020_write_bytes(data, buf, 5);
440	}	601	}
441		602
442	static int hdc3020_read_thresh(struct iio_dev *indio_dev,	603	static int hdc3020_read_thresh(struct iio_dev *indio_dev,
@@ -447,48 +608,60 @@ static int hdc3020_read_thresh(struct iio_dev *indio_dev, · 4 unmodified lines
447	int val, int val2)	608	int val, int val2)
448	{	609	{
449	struct hdc3020_data *data = iio_priv(indio_dev);	610	struct hdc3020_data *data = iio_priv(indio_dev);
450	u16 reg;	611	u16 reg_thresh, reg_clr;
451	int ret;	612	int thresh, clr, ret;
452		613
453	/* Select threshold register */	614	/* Select threshold registers */
454	if (info == IIO_EV_INFO_VALUE) {	615	if (dir == IIO_EV_DIR_RISING) {
455	if (dir == IIO_EV_DIR_RISING)	616	reg_thresh = HDC3020_R_T_RH_THRESH_HIGH;
456	reg = HDC3020_R_T_RH_THRESH_HIGH;	617	reg_clr = HDC3020_R_T_RH_THRESH_HIGH_CLR;
457	else
458	reg = HDC3020_R_T_RH_THRESH_LOW;
459	} else {	618	} else {
460	if (dir == IIO_EV_DIR_RISING)	619	reg_thresh = HDC3020_R_T_RH_THRESH_LOW;
461	reg = HDC3020_R_T_RH_THRESH_HIGH_CLR;	620	reg_clr = HDC3020_R_T_RH_THRESH_LOW_CLR;
462	else
463	reg = HDC3020_R_T_RH_THRESH_LOW_CLR;
464	}	621	}
465		622
466	guard(mutex)(&data->lock);	623	guard(mutex)(&data->lock);
467	ret = hdc3020_read_be16(data, reg);	624	ret = hdc3020_read_be16(data, reg_thresh);
468	if (ret < 0)	625	if (ret < 0)
469	return ret;	626	return ret;
470		627
471	switch (chan->type) {	628	switch (chan->type) {
472	case IIO_TEMP:	629	case IIO_TEMP:
473	/*	630	thresh = hdc3020_thresh_get_temp(ret);
474	* Get the temperature threshold from 9 LSBs, shift them to get	631	switch (info) {
475	* the truncated temperature threshold representation and	632	case IIO_EV_INFO_VALUE:
476	* calculate the threshold according to the formula in the	633	*val = thresh;
477	* datasheet.	634	break;
478	*/	635	case IIO_EV_INFO_HYSTERESIS:
479	*val = FIELD_GET(HDC3020_THRESH_TEMP_MASK, ret);	636	ret = hdc3020_read_be16(data, reg_clr);
480	val = val << HDC3020_THRESH_TEMP_TRUNC_SHIFT;	637	if (ret < 0)
481	val = -2949075 + (175 (*val));	638	return ret;
		639
		640	clr = hdc3020_thresh_get_temp(ret);
		641	*val = abs(thresh - clr);
		642	break;
		643	default:
		644	return -EOPNOTSUPP;
		645	}
482	*val2 = 65535;	646	*val2 = 65535;
483	return IIO_VAL_FRACTIONAL;	647	return IIO_VAL_FRACTIONAL;
484	case IIO_HUMIDITYRELATIVE:	648	case IIO_HUMIDITYRELATIVE:
485	/*	649	thresh = hdc3020_thresh_get_hum(ret);
486	* Get the humidity threshold from 7 MSBs, shift them to get the	650	switch (info) {
487	* truncated humidity threshold representation and calculate the	651	case IIO_EV_INFO_VALUE:
488	* threshold according to the formula in the datasheet.	652	*val = thresh;
489	*/	653	break;
490	*val = FIELD_GET(HDC3020_THRESH_HUM_MASK, ret);	654	case IIO_EV_INFO_HYSTERESIS:
491	val = (val << HDC3020_THRESH_HUM_TRUNC_SHIFT) * 100;	655	ret = hdc3020_read_be16(data, reg_clr);
		656	if (ret < 0)
		657	return ret;
		658
		659	clr = hdc3020_thresh_get_hum(ret);
		660	*val = abs(thresh - clr);
		661	break;
		662	default:
		663	return -EOPNOTSUPP;
		664	}
492	*val2 = 65535;	665	*val2 = 65535;
493	return IIO_VAL_FRACTIONAL;	666	return IIO_VAL_FRACTIONAL;
494	default:	667	default:

drivers/iommu/amd/init.c+1−0

@@ -2743,6 +2743,7 @@ static void early_enable_iommu(struct amd_iommu *iommu) · 2742 unmodified lines
2743	iommu_enable_command_buffer(iommu);	2743	iommu_enable_command_buffer(iommu);
2744	iommu_enable_event_buffer(iommu);	2744	iommu_enable_event_buffer(iommu);
2745	iommu_set_exclusion_range(iommu);	2745	iommu_set_exclusion_range(iommu);
		2746	iommu_enable_gt(iommu);
2746	iommu_enable_ga(iommu);	2747	iommu_enable_ga(iommu);
2747	iommu_enable_xt(iommu);	2748	iommu_enable_xt(iommu);
2748	iommu_enable_irtcachedis(iommu);	2749	iommu_enable_irtcachedis(iommu);

drivers/iommu/amd/iommu.c+6−6

 	struct protection_domain *domain = dev_data->domain;
 	struct amd_iommu *iommu = get_amd_iommu_from_dev_data(dev_data);
+	/* Clear DTE and flush the entry */
+	amd_iommu_dev_update_dte(dev_data, false);
+	/* Flush IOTLB and wait for the flushes to finish */
+	amd_iommu_domain_flush_all(domain);
 	/* Clear GCR3 table */
 	if (pdom_is_sva_capable(domain))
 		destroy_gcr3_table(dev_data, domain);
 	dev_data->domain = NULL;
 	list_del(&dev_data->list);
-	/* Clear DTE and flush the entry */
-	amd_iommu_dev_update_dte(dev_data, false);
-	/* Flush IOTLB and wait for the flushes to finish */
-	amd_iommu_domain_flush_all(domain);
 	/* decrease reference counters - needs to happen after the flushes */
 	domain->dev_iommu[iommu->index] -= 1;
 	domain->dev_cnt                 -= 1;

drivers/iommu/intel/iommu.c+10−10

 	if (ret)
 		return ret;
-	ret = cache_tag_assign_domain(domain, dev, IOMMU_NO_PASID);
-	if (ret) {
-		domain_detach_iommu(domain, iommu);
-		return ret;
-	}
 	info->domain = domain;
 	spin_lock_irqsave(&domain->lock, flags);
 	list_add(&info->link, &domain->devices);
 	else
 		ret = intel_pasid_setup_second_level(iommu, domain, dev, IOMMU_NO_PASID);
-	if (ret) {
+	if (ret)
-		device_block_translation(dev);
+		goto out_block_translation;
-		return ret;
-	}
 	if (sm_supported(info->iommu) || !domain_type_is_si(info->domain))
 		iommu_enable_pci_caps(info);
+	ret = cache_tag_assign_domain(domain, dev, IOMMU_NO_PASID);
+	if (ret)
+		goto out_block_translation;
 	return 0;
+out_block_translation:
+	device_block_translation(dev);
+	return ret;
 }
 /**

drivers/irqchip/irq-loongson-eiointc.c+3−2

 #include <linux/irqchip/chained_irq.h>
 #include <linux/kernel.h>
 #include <linux/syscore_ops.h>
+#include <asm/numa.h>
 #define EIOINTC_REG_NODEMAP	0x14a0
 #define EIOINTC_REG_IPMAP	0x14c0
 	int node;
 	if (cpu_has_flatmode)
-		node = cpu_to_node(eiointc_priv[nr_pics - 1]->node * CORES_PER_EIO_NODE);
+		node = early_cpu_to_node(eiointc_priv[nr_pics - 1]->node * CORES_PER_EIO_NODE);
 	else
 		node = eiointc_priv[nr_pics - 1]->node;
 		goto out_free_handle;
 	if (cpu_has_flatmode)
-		node = cpu_to_node(acpi_eiointc->node * CORES_PER_EIO_NODE);
+		node = early_cpu_to_node(acpi_eiointc->node * CORES_PER_EIO_NODE);
 	else
 		node = acpi_eiointc->node;
 	acpi_set_vec_parent(node, priv->eiointc_domain, pch_group);

drivers/irqchip/irq-loongson-liointc.c+2−2

@@ -28,7 +28,7 @@ · 27 unmodified lines
28		28
29	#define LIOINTC_INTC_CHIP_START 0x20	29	#define LIOINTC_INTC_CHIP_START 0x20
30		30
31	#define LIOINTC_REG_INTC_STATUS (LIOINTC_INTC_CHIP_START + 0x20)	31	#define LIOINTC_REG_INTC_STATUS(core) (LIOINTC_INTC_CHIP_START + 0x20 + (core) * 8)
32	#define LIOINTC_REG_INTC_EN_STATUS (LIOINTC_INTC_CHIP_START + 0x04)	32	#define LIOINTC_REG_INTC_EN_STATUS (LIOINTC_INTC_CHIP_START + 0x04)
33	#define LIOINTC_REG_INTC_ENABLE (LIOINTC_INTC_CHIP_START + 0x08)	33	#define LIOINTC_REG_INTC_ENABLE (LIOINTC_INTC_CHIP_START + 0x08)
34	#define LIOINTC_REG_INTC_DISABLE (LIOINTC_INTC_CHIP_START + 0x0c)	34	#define LIOINTC_REG_INTC_DISABLE (LIOINTC_INTC_CHIP_START + 0x0c)
@@ -217,7 +217,7 @@ static int liointc_init(phys_addr_t addr, unsigned long size, int revision, · 182 unmodified lines
217	goto out_free_priv;	217	goto out_free_priv;
218		218
219	for (i = 0; i < LIOINTC_NUM_CORES; i++)	219	for (i = 0; i < LIOINTC_NUM_CORES; i++)
220	priv->core_isr[i] = base + LIOINTC_REG_INTC_STATUS;	220	priv->core_isr[i] = base + LIOINTC_REG_INTC_STATUS(i);
221		221
222	for (i = 0; i < LIOINTC_NUM_PARENT; i++)	222	for (i = 0; i < LIOINTC_NUM_PARENT; i++)
223	priv->handler[i].parent_int_map = parent_int_map[i];	223	priv->handler[i].parent_int_map = parent_int_map[i];

drivers/media/pci/intel/ipu6/ipu6-isys-video.c+1−1

@@ -943,7 +943,7 @@ ipu6_isys_query_stream_by_source(struct ipu6_isys *isys, int source, u8 vc) · 942 unmodified lines
943	return NULL;	943	return NULL;
944		944
945	if (source < 0) {	945	if (source < 0) {
946	dev_err(&stream->isys->adev->auxdev.dev,	946	dev_err(&isys->adev->auxdev.dev,
947	"query stream with invalid port number\n");	947	"query stream with invalid port number\n");
948	return NULL;	948	return NULL;
949	}	949	}

drivers/media/pci/intel/ipu6/ipu6-isys.c+1−1

@@ -799,7 +799,7 @@ static int isys_register_devices(struct ipu6_isys *isys) · 798 unmodified lines
799	isys->v4l2_dev.mdev = &isys->media_dev;	799	isys->v4l2_dev.mdev = &isys->media_dev;
800	isys->v4l2_dev.ctrl_handler = NULL;	800	isys->v4l2_dev.ctrl_handler = NULL;
801		801
802	ret = v4l2_device_register(&pdev->dev, &isys->v4l2_dev);	802	ret = v4l2_device_register(dev, &isys->v4l2_dev);
803	if (ret < 0)	803	if (ret < 0)
804	goto out_media_device_unregister;	804	goto out_media_device_unregister;
805		805

drivers/media/pci/intel/ivsc/Kconfig+1−0

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	config INTEL_VSC	4	config INTEL_VSC
5	tristate "Intel Visual Sensing Controller"	5	tristate "Intel Visual Sensing Controller"
6	depends on INTEL_MEI && ACPI && VIDEO_DEV	6	depends on INTEL_MEI && ACPI && VIDEO_DEV
		7	depends on IPU_BRIDGE \|\| !IPU_BRIDGE
7	select MEDIA_CONTROLLER	8	select MEDIA_CONTROLLER
8	select VIDEO_V4L2_SUBDEV_API	9	select VIDEO_V4L2_SUBDEV_API
9	select V4L2_FWNODE	10	select V4L2_FWNODE

drivers/mmc/host/moxart-mmc.c+43−35

 	struct dma_async_tx_descriptor	*tx_desc;
 	struct mmc_host			*mmc;
 	struct mmc_request		*mrq;
+	struct scatterlist		*cur_sg;
 	struct completion		dma_complete;
 	struct completion		pio_complete;
-	struct sg_mapping_iter		sg_miter;
+	u32				num_sg;
+	u32				data_remain;
 	u32				data_len;
 	u32				fifo_width;
 	u32				timeout;
 	bool				is_removed;
 };
+static inline void moxart_init_sg(struct moxart_host *host,
+				  struct mmc_data *data)
+{
+	host->cur_sg = data->sg;
+	host->num_sg = data->sg_len;
+	host->data_remain = host->cur_sg->length;
+	if (host->data_remain > host->data_len)
+		host->data_remain = host->data_len;
+}
+static inline int moxart_next_sg(struct moxart_host *host)
+{
+	int remain;
+	struct mmc_data *data = host->mrq->cmd->data;
+	host->cur_sg++;
+	host->num_sg--;
+	if (host->num_sg > 0) {
+		host->data_remain = host->cur_sg->length;
+		remain = host->data_len - data->bytes_xfered;
+		if (remain > 0 && remain < host->data_remain)
+			host->data_remain = remain;
+	}
+	return host->num_sg;
+}
 static int moxart_wait_for_status(struct moxart_host *host,
 				  u32 mask, u32 *status)
 {
 static void moxart_transfer_pio(struct moxart_host *host)
 {
-	struct sg_mapping_iter *sgm = &host->sg_miter;
 	struct mmc_data *data = host->mrq->cmd->data;
 	u32 *sgp, len = 0, remain, status;
 	if (host->data_len == data->bytes_xfered)
 		return;
-	/*
+	sgp = sg_virt(host->cur_sg);
-	 * By updating sgm->consumes this will get a proper pointer into the
+	remain = host->data_remain;
-	 * buffer at any time.
-	 */
-	if (!sg_miter_next(sgm)) {
-		/* This shold not happen */
-		dev_err(mmc_dev(host->mmc), "ran out of scatterlist prematurely\n");
-		data->error = -EINVAL;
-		complete(&host->pio_complete);
-		return;
-	}
-	sgp = sgm->addr;
-	remain = sgm->length;
-	if (remain > host->data_len)
-		remain = host->data_len;
-	sgm->consumed = 0;
 	if (data->flags & MMC_DATA_WRITE) {
 		while (remain > 0) {
 				sgp++;
 				len += 4;
 			}
-			sgm->consumed += len;
 			remain -= len;
 		}
 				sgp++;
 				len += 4;
 			}
-			sgm->consumed += len;
 			remain -= len;
 		}
 	}
-	data->bytes_xfered += sgm->consumed;
+	data->bytes_xfered += host->data_remain - remain;
-	if (host->data_len == data->bytes_xfered) {
+	host->data_remain = remain;
+	if (host->data_len != data->bytes_xfered)
+		moxart_next_sg(host);
+	else
 		complete(&host->pio_complete);
-		return;
-	}
 }
 static void moxart_prepare_data(struct moxart_host *host)
 {
 	struct mmc_data *data = host->mrq->cmd->data;
-	unsigned int flags = SG_MITER_ATOMIC; /* Used from IRQ */
 	u32 datactrl;
 	int blksz_bits;
 	blksz_bits = ffs(data->blksz) - 1;
 	BUG_ON(1 << blksz_bits != data->blksz);
+	moxart_init_sg(host, data);
 	datactrl = DCR_DATA_EN | (blksz_bits & DCR_BLK_SIZE);
-	if (data->flags & MMC_DATA_WRITE) {
+	if (data->flags & MMC_DATA_WRITE)
-		flags |= SG_MITER_FROM_SG;
 		datactrl |= DCR_DATA_WRITE;
-	} else {
-		flags |= SG_MITER_TO_SG;
-	}
 	if (moxart_use_dma(host))
 		datactrl |= DCR_DMA_EN;
-	else
-		sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
 	writel(DCR_DATA_FIFO_RESET, host->base + REG_DATA_CONTROL);
 	writel(MASK_DATA | FIFO_URUN | FIFO_ORUN, host->base + REG_CLEAR);
 	}
 request_done:
-	if (!moxart_use_dma(host))
-		sg_miter_stop(&host->sg_miter);
 	spin_unlock_irqrestore(&host->lock, flags);
 	mmc_request_done(host->mmc, mrq);
 }

drivers/mmc/host/sdhci-brcmstb.c+4−0

 #define BRCMSTB_MATCH_FLAGS_NO_64BIT		BIT(0)
 #define BRCMSTB_MATCH_FLAGS_BROKEN_TIMEOUT	BIT(1)
 #define BRCMSTB_MATCH_FLAGS_HAS_CLOCK_GATE	BIT(2)
+#define BRCMSTB_MATCH_FLAGS_USE_CARD_BUSY	BIT(4)
 #define BRCMSTB_PRIV_FLAGS_HAS_CQE		BIT(0)
 #define BRCMSTB_PRIV_FLAGS_GATE_CLOCK		BIT(1)
 	if (match_priv->flags & BRCMSTB_MATCH_FLAGS_BROKEN_TIMEOUT)
 		host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
+	if (!(match_priv->flags & BRCMSTB_MATCH_FLAGS_USE_CARD_BUSY))
+		host->mmc_host_ops.card_busy = NULL;
 	/* Change the base clock frequency if the DT property exists */
 	if (device_property_read_u32(&pdev->dev, "clock-frequency",
 				     &priv->base_freq_hz) != 0)

drivers/mmc/host/sdhci-pci-core.c+7−4

 	ret = pci_read_config_byte(chip->pdev, 0xAE, &scratch);
 	if (ret)
-		return ret;
+		goto fail;
 	/*
 	 * Turn PMOS on [bit 0], set over current detection to 2.4 V
 	else
 		scratch &= ~0x47;
-	return pci_write_config_byte(chip->pdev, 0xAE, scratch);
+	ret = pci_write_config_byte(chip->pdev, 0xAE, scratch);
+fail:
+	return pcibios_err_to_errno(ret);
 }
 static int jmicron_probe(struct sdhci_pci_chip *chip)
 	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
 	if (ret)
-		return ret;
+		return pcibios_err_to_errno(ret);
 	slots = PCI_SLOT_INFO_SLOTS(slots) + 1;
 	dev_dbg(&pdev->dev, "found %d slot(s)\n", slots);
 	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &first_bar);
 	if (ret)
-		return ret;
+		return pcibios_err_to_errno(ret);
 	first_bar &= PCI_SLOT_INFO_FIRST_BAR_MASK;

drivers/mmc/host/sdhci-pci-o2micro.c+22−19

 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch &= 0x7f;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_CLKREQ, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x20;
 		pci_write_config_byte(chip->pdev, O2_SD_CLKREQ, scratch);
 		 */
 		ret = pci_read_config_byte(chip->pdev, O2_SD_CAPS, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x01;
 		pci_write_config_byte(chip->pdev, O2_SD_CAPS, scratch);
 		pci_write_config_byte(chip->pdev, O2_SD_CAPS, 0x73);
 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_INF_MOD, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x08;
 		pci_write_config_byte(chip->pdev, O2_SD_INF_MOD, scratch);
 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x80;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		break;
 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch &= 0x7f;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 						    O2_SD_FUNC_REG0,
 						    &scratch_32);
 			if (ret)
-				return ret;
+				goto read_fail;
 			scratch_32 = ((scratch_32 & 0xFF000000) >> 24);
 			/* Check Whether subId is 0x11 or 0x12 */
 							    O2_SD_FUNC_REG4,
 							    &scratch_32);
 				if (ret)
-					return ret;
+					goto read_fail;
 				/* Enable Base Clk setting change */
 				scratch_32 |= O2_SD_FREG4_ENABLE_CLK_SET;
 		ret = pci_read_config_dword(chip->pdev,
 					    O2_SD_CLK_SETTING, &scratch_32);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch_32 &= ~(0xFF00);
 		scratch_32 |= 0x07E0C800;
 		ret = pci_read_config_dword(chip->pdev,
 					    O2_SD_CLKREQ, &scratch_32);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch_32 |= 0x3;
 		pci_write_config_dword(chip->pdev, O2_SD_CLKREQ, scratch_32);
 		ret = pci_read_config_dword(chip->pdev,
 					    O2_SD_PLL_SETTING, &scratch_32);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch_32 &= ~(0x1F3F070E);
 		scratch_32 |= 0x18270106;
 		ret = pci_read_config_dword(chip->pdev,
 					    O2_SD_CAP_REG2, &scratch_32);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch_32 &= ~(0xE0);
 		pci_write_config_dword(chip->pdev,
 				       O2_SD_CAP_REG2, scratch_32);
 		ret = pci_read_config_byte(chip->pdev,
 					   O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x80;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		break;
 		ret = pci_read_config_byte(chip->pdev,
 				O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch &= 0x7f;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		ret = pci_read_config_dword(chip->pdev,
 					    O2_SD_PLL_SETTING, &scratch_32);
 		if (ret)
-			return ret;
+			goto read_fail;
 		if ((scratch_32 & 0xff000000) == 0x01000000) {
 			scratch_32 &= 0x0000FFFF;
 						    O2_SD_FUNC_REG4,
 						    &scratch_32);
 			if (ret)
-				return ret;
+				goto read_fail;
 			scratch_32 |= (1 << 22);
 			pci_write_config_dword(chip->pdev,
 					       O2_SD_FUNC_REG4, scratch_32);
 		ret = pci_read_config_byte(chip->pdev,
 					   O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x80;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		break;
 		/* UnLock WP */
 		ret = pci_read_config_byte(chip->pdev, O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch &= 0x7f;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		/* Lock WP */
 		ret = pci_read_config_byte(chip->pdev, O2_SD_LOCK_WP, &scratch);
 		if (ret)
-			return ret;
+			goto read_fail;
 		scratch |= 0x80;
 		pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
 		break;
 	}
 	return 0;
+read_fail:
+	return pcibios_err_to_errno(ret);
 }
 #ifdef CONFIG_PM_SLEEP

drivers/mmc/host/sdhci.c+14−11

 static int sdhci_check_ro(struct sdhci_host *host)
 {
-	unsigned long flags;
+	bool allow_invert = false;
 	int is_readonly;
-	spin_lock_irqsave(&host->lock, flags);
+	if (host->flags & SDHCI_DEVICE_DEAD) {
-	if (host->flags & SDHCI_DEVICE_DEAD)
 		is_readonly = 0;
-	else if (host->ops->get_ro)
+	} else if (host->ops->get_ro) {
 		is_readonly = host->ops->get_ro(host);
-	else if (mmc_can_gpio_ro(host->mmc))
+	} else if (mmc_can_gpio_ro(host->mmc)) {
 		is_readonly = mmc_gpio_get_ro(host->mmc);
-	else
+		/* Do not invert twice */
+		allow_invert = !(host->mmc->caps2 & MMC_CAP2_RO_ACTIVE_HIGH);
+	} else {
 		is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
 				& SDHCI_WRITE_PROTECT);
+		allow_invert = true;
+	}
-	spin_unlock_irqrestore(&host->lock, flags);
+	if (is_readonly >= 0 &&
+	    allow_invert &&
+	    (host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT))
+		is_readonly = !is_readonly;
-	/* This quirk needs to be replaced by a callback-function later */
+	return is_readonly;
-	return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
-		!is_readonly : is_readonly;
 }
 #define SAMPLE_COUNT	5

drivers/mtd/nand/raw/nand_base.c+40−26

 				   unsigned int offset_in_page)
 {
 	struct mtd_info *mtd = nand_to_mtd(chip);
+	bool ident_stage = !mtd->writesize;
-	/* Make sure the offset is less than the actual page size. */
+	/* Bypass all checks during NAND identification */
-	if (offset_in_page > mtd->writesize + mtd->oobsize)
+	if (likely(!ident_stage)) {
-		return -EINVAL;
+		/* Make sure the offset is less than the actual page size. */
+		if (offset_in_page > mtd->writesize + mtd->oobsize)
+			return -EINVAL;
-	/*
+		/*
-	 * On small page NANDs, there's a dedicated command to access the OOB
+		 * On small page NANDs, there's a dedicated command to access the OOB
-	 * area, and the column address is relative to the start of the OOB
+		 * area, and the column address is relative to the start of the OOB
-	 * area, not the start of the page. Asjust the address accordingly.
+		 * area, not the start of the page. Asjust the address accordingly.
-	 */
+		 */
-	if (mtd->writesize <= 512 && offset_in_page >= mtd->writesize)
+		if (mtd->writesize <= 512 && offset_in_page >= mtd->writesize)
-		offset_in_page -= mtd->writesize;
+			offset_in_page -= mtd->writesize;
-	/*
+		/*
-	 * The offset in page is expressed in bytes, if the NAND bus is 16-bit
+		 * The offset in page is expressed in bytes, if the NAND bus is 16-bit
-	 * wide, then it must be divided by 2.
+		 * wide, then it must be divided by 2.
-	 */
+		 */
-	if (chip->options & NAND_BUSWIDTH_16) {
+		if (chip->options & NAND_BUSWIDTH_16) {
-		if (WARN_ON(offset_in_page % 2))
+			if (WARN_ON(offset_in_page % 2))
-			return -EINVAL;
+				return -EINVAL;
-		offset_in_page /= 2;
+			offset_in_page /= 2;
+		}
 	}
 	addrs[0] = offset_in_page;
 	 * Small page NANDs use 1 cycle for the columns, while large page NANDs
 	 * need 2
 	 */
-	if (mtd->writesize <= 512)
+	if (!ident_stage && mtd->writesize <= 512)
 		return 1;
 	addrs[1] = offset_in_page >> 8;
 			       unsigned int len, bool force_8bit)
 {
 	struct mtd_info *mtd = nand_to_mtd(chip);
+	bool ident_stage = !mtd->writesize;
 	if (len && !buf)
 		return -EINVAL;
-	if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+	if (!ident_stage) {
-		return -EINVAL;
+		if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+			return -EINVAL;
-	/* Small page NANDs do not support column change. */
+		/* Small page NANDs do not support column change. */
-	if (mtd->writesize <= 512)
+		if (mtd->writesize <= 512)
-		return -ENOTSUPP;
+			return -ENOTSUPP;
+	}
 	if (nand_has_exec_op(chip)) {
 		const struct nand_interface_config *conf =
 int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
 		      bool force_8bit, bool check_only)
 {
-	if (!len || !buf)
+	if (!len || (!check_only && !buf))
 		return -EINVAL;
 	if (nand_has_exec_op(chip)) {
 static int nand_scan_tail(struct nand_chip *chip)
 {
 	struct mtd_info *mtd = nand_to_mtd(chip);
+	struct nand_device *base = &chip->base;
 	struct nand_ecc_ctrl *ecc = &chip->ecc;
 	int ret, i;
 	if (!ecc->write_oob_raw)
 		ecc->write_oob_raw = ecc->write_oob;
-	/* propagate ecc info to mtd_info */
+	/* Propagate ECC info to the generic NAND and MTD layers */
 	mtd->ecc_strength = ecc->strength;
+	if (!base->ecc.ctx.conf.strength)
+		base->ecc.ctx.conf.strength = ecc->strength;
 	mtd->ecc_step_size = ecc->size;
+	if (!base->ecc.ctx.conf.step_size)
+		base->ecc.ctx.conf.step_size = ecc->size;
 	/*
 	 * Set the number of read / write steps for one page depending on ECC
 	 */
 	if (!ecc->steps)
 		ecc->steps = mtd->writesize / ecc->size;
+	if (!base->ecc.ctx.nsteps)
+		base->ecc.ctx.nsteps = ecc->steps;
 	if (ecc->steps * ecc->size != mtd->writesize) {
 		WARN(1, "Invalid ECC parameters\n");
 		ret = -EINVAL;

drivers/mtd/nand/raw/rockchip-nand-controller.c+3−3

 	u32 rate, tc2rw, trwpw, trw2c;
 	u32 temp;
-	if (target < 0)
-		return 0;
 	timings = nand_get_sdr_timings(conf);
 	if (IS_ERR(timings))
 		return -EOPNOTSUPP;
+	if (target < 0)
+		return 0;
 	if (IS_ERR(nfc->nfc_clk))
 		rate = clk_get_rate(nfc->ahb_clk);
 	else

drivers/net/bonding/bond_options.c+3−3

@@ -1214,9 +1214,9 @@ static int bond_option_arp_ip_targets_set(struct bonding *bond, · 1213 unmodified lines
1214	__be32 target;	1214	__be32 target;
1215		1215
1216	if (newval->string) {	1216	if (newval->string) {
1217	if (!in4_pton(newval->string+1, -1, (u8 *)&target, -1, NULL)) {	1217	if (strlen(newval->string) < 1 \|\|
1218	netdev_err(bond->dev, "invalid ARP target %pI4 specified\n",	1218	!in4_pton(newval->string + 1, -1, (u8 *)&target, -1, NULL)) {
1219	&target);	1219	netdev_err(bond->dev, "invalid ARP target specified\n");
1220	return ret;	1220	return ret;
1221	}	1221	}
1222	if (newval->string[0] == '+')	1222	if (newval->string[0] == '+')

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

@@ -128,6 +128,7 @@ static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err_liste · 127 unmodified lines
128		128
129	static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leafimx = {	129	static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leafimx = {
130	.quirks = 0,	130	.quirks = 0,
		131	.family = KVASER_LEAF,
131	.ops = &kvaser_usb_leaf_dev_ops,	132	.ops = &kvaser_usb_leaf_dev_ops,
132	};	133	};
133		134

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h+1−1

@@ -1262,7 +1262,7 @@ enum { · 1261 unmodified lines
1262		1262
1263	struct bnx2x_fw_stats_req {	1263	struct bnx2x_fw_stats_req {
1264	struct stats_query_header hdr;	1264	struct stats_query_header hdr;
1265	struct stats_query_entry query[FP_SB_MAX_E1x+	1265	struct stats_query_entry query[FP_SB_MAX_E2 +
1266	BNX2X_FIRST_QUEUE_QUERY_IDX];	1266	BNX2X_FIRST_QUEUE_QUERY_IDX];
1267	};	1267	};
1268		1268

drivers/net/ethernet/broadcom/bnxt/bnxt.c+5−1

 	if (!BNXT_NEW_RM(bp))
 		return true;
-	if (hwr.vnic == bp->hw_resc.resv_vnics &&
+	/* Do not reduce VNIC and RSS ctx reservations.  There is a FW
+	 * issue that will mess up the default VNIC if we reduce the
+	 * reservations.
+	 */
+	if (hwr.vnic <= bp->hw_resc.resv_vnics &&
 	    hwr.rss_ctx <= bp->hw_resc.resv_rsscos_ctxs)
 		return true;

drivers/net/ethernet/intel/e1000e/netdev.c+66−66

 		mac_data |= E1000_EXTCNF_CTRL_GATE_PHY_CFG;
 		ew32(EXTCNF_CTRL, mac_data);
-		/* Enable the Dynamic Power Gating in the MAC */
-		mac_data = er32(FEXTNVM7);
-		mac_data |= BIT(22);
-		ew32(FEXTNVM7, mac_data);
 		/* Disable disconnected cable conditioning for Power Gating */
 		mac_data = er32(DPGFR);
 		mac_data |= BIT(2);
 		ew32(DPGFR, mac_data);
-		/* Don't wake from dynamic Power Gating with clock request */
-		mac_data = er32(FEXTNVM12);
-		mac_data |= BIT(12);
-		ew32(FEXTNVM12, mac_data);
-		/* Ungate PGCB clock */
-		mac_data = er32(FEXTNVM9);
-		mac_data &= ~BIT(28);
-		ew32(FEXTNVM9, mac_data);
-		/* Enable K1 off to enable mPHY Power Gating */
-		mac_data = er32(FEXTNVM6);
-		mac_data |= BIT(31);
-		ew32(FEXTNVM6, mac_data);
-		/* Enable mPHY power gating for any link and speed */
-		mac_data = er32(FEXTNVM8);
-		mac_data |= BIT(9);
-		ew32(FEXTNVM8, mac_data);
 		/* Enable the Dynamic Clock Gating in the DMA and MAC */
 		mac_data = er32(CTRL_EXT);
 		mac_data |= E1000_CTRL_EXT_DMA_DYN_CLK_EN;
 		ew32(CTRL_EXT, mac_data);
-		/* No MAC DPG gating SLP_S0 in modern standby
-		 * Switch the logic of the lanphypc to use PMC counter
-		 */
-		mac_data = er32(FEXTNVM5);
-		mac_data |= BIT(7);
-		ew32(FEXTNVM5, mac_data);
 	}
+	/* Enable the Dynamic Power Gating in the MAC */
+	mac_data = er32(FEXTNVM7);
+	mac_data |= BIT(22);
+	ew32(FEXTNVM7, mac_data);
+	/* Don't wake from dynamic Power Gating with clock request */
+	mac_data = er32(FEXTNVM12);
+	mac_data |= BIT(12);
+	ew32(FEXTNVM12, mac_data);
+	/* Ungate PGCB clock */
+	mac_data = er32(FEXTNVM9);
+	mac_data &= ~BIT(28);
+	ew32(FEXTNVM9, mac_data);
+	/* Enable K1 off to enable mPHY Power Gating */
+	mac_data = er32(FEXTNVM6);
+	mac_data |= BIT(31);
+	ew32(FEXTNVM6, mac_data);
+	/* Enable mPHY power gating for any link and speed */
+	mac_data = er32(FEXTNVM8);
+	mac_data |= BIT(9);
+	ew32(FEXTNVM8, mac_data);
+	/* No MAC DPG gating SLP_S0 in modern standby
+	 * Switch the logic of the lanphypc to use PMC counter
+	 */
+	mac_data = er32(FEXTNVM5);
+	mac_data |= BIT(7);
+	ew32(FEXTNVM5, mac_data);
 	/* Disable the time synchronization clock */
 	mac_data = er32(FEXTNVM7);
 	mac_data |= BIT(31);
 	} else {
 		/* Request driver unconfigure the device from S0ix */
-		/* Disable the Dynamic Power Gating in the MAC */
-		mac_data = er32(FEXTNVM7);
-		mac_data &= 0xFFBFFFFF;
-		ew32(FEXTNVM7, mac_data);
-		/* Disable mPHY power gating for any link and speed */
-		mac_data = er32(FEXTNVM8);
-		mac_data &= ~BIT(9);
-		ew32(FEXTNVM8, mac_data);
-		/* Disable K1 off */
-		mac_data = er32(FEXTNVM6);
-		mac_data &= ~BIT(31);
-		ew32(FEXTNVM6, mac_data);
-		/* Disable Ungate PGCB clock */
-		mac_data = er32(FEXTNVM9);
-		mac_data |= BIT(28);
-		ew32(FEXTNVM9, mac_data);
-		/* Cancel not waking from dynamic
-		 * Power Gating with clock request
-		 */
-		mac_data = er32(FEXTNVM12);
-		mac_data &= ~BIT(12);
-		ew32(FEXTNVM12, mac_data);
 		/* Cancel disable disconnected cable conditioning
 		 * for Power Gating
 		 */
 		mac_data &= 0xFFF7FFFF;
 		ew32(CTRL_EXT, mac_data);
-		/* Revert the lanphypc logic to use the internal Gbe counter
-		 * and not the PMC counter
-		 */
-		mac_data = er32(FEXTNVM5);
-		mac_data &= 0xFFFFFF7F;
-		ew32(FEXTNVM5, mac_data);
 		/* Enable the periodic inband message,
 		 * Request PCIe clock in K1 page770_17[10:9] =01b
 		 */
 	mac_data &= ~BIT(31);
 	mac_data |= BIT(0);
 	ew32(FEXTNVM7, mac_data);
+	/* Disable the Dynamic Power Gating in the MAC */
+	mac_data = er32(FEXTNVM7);
+	mac_data &= 0xFFBFFFFF;
+	ew32(FEXTNVM7, mac_data);
+	/* Disable mPHY power gating for any link and speed */
+	mac_data = er32(FEXTNVM8);
+	mac_data &= ~BIT(9);
+	ew32(FEXTNVM8, mac_data);
+	/* Disable K1 off */
+	mac_data = er32(FEXTNVM6);
+	mac_data &= ~BIT(31);
+	ew32(FEXTNVM6, mac_data);
+	/* Disable Ungate PGCB clock */
+	mac_data = er32(FEXTNVM9);
+	mac_data |= BIT(28);
+	ew32(FEXTNVM9, mac_data);
+	/* Cancel not waking from dynamic
+	 * Power Gating with clock request
+	 */
+	mac_data = er32(FEXTNVM12);
+	mac_data &= ~BIT(12);
+	ew32(FEXTNVM12, mac_data);
+	/* Revert the lanphypc logic to use the internal Gbe counter
+	 * and not the PMC counter
+	 */
+	mac_data = er32(FEXTNVM5);
+	mac_data &= 0xFFFFFF7F;
+	ew32(FEXTNVM5, mac_data);
 }
 static int e1000e_pm_freeze(struct device *dev)

drivers/net/ethernet/intel/ice/ice_hwmon.c+1−1

@@ -96,7 +96,7 @@ static bool ice_is_internal_reading_supported(struct ice_pf *pf) · 95 unmodified lines
96		96
97	unsigned long sensors = pf->hw.dev_caps.supported_sensors;	97	unsigned long sensors = pf->hw.dev_caps.supported_sensors;
98		98
99	return _test_bit(ICE_SENSOR_SUPPORT_E810_INT_TEMP_BIT, &sensors);	99	return test_bit(ICE_SENSOR_SUPPORT_E810_INT_TEMP_BIT, &sensors);
100	};	100	};
101		101
102	void ice_hwmon_init(struct ice_pf *pf)	102	void ice_hwmon_init(struct ice_pf *pf)

drivers/net/ethernet/intel/ice/ice_ptp.c+101−30

@@ -1618,6 +1618,10 @@ void ice_ptp_extts_event(struct ice_pf *pf) · 1617 unmodified lines
1618	u8 chan, tmr_idx;	1618	u8 chan, tmr_idx;
1619	u32 hi, lo;	1619	u32 hi, lo;
1620		1620
		1621	/* Don't process timestamp events if PTP is not ready */
		1622	if (pf->ptp.state != ICE_PTP_READY)
		1623	return;
		1624
1621	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;	1625	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;
1622	/* Event time is captured by one of the two matched registers	1626	/* Event time is captured by one of the two matched registers
1623	* GLTSYN_EVNT_L: 32 LSB of sampled time event	1627	* GLTSYN_EVNT_L: 32 LSB of sampled time event
@@ -1643,27 +1647,33 @@ void ice_ptp_extts_event(struct ice_pf *pf) · 19 unmodified lines
1643	/**	1647	/**
1644	* ice_ptp_cfg_extts - Configure EXTTS pin and channel	1648	* ice_ptp_cfg_extts - Configure EXTTS pin and channel
1645	* @pf: Board private structure	1649	* @pf: Board private structure
1646	* @ena: true to enable; false to disable
1647	* @chan: GPIO channel (0-3)	1650	* @chan: GPIO channel (0-3)
1648	* @gpio_pin: GPIO pin	1651	* @config: desired EXTTS configuration.
1649	* @extts_flags: request flags from the ptp_extts_request.flags	1652	* @store: If set to true, the values will be stored
		1653	*
		1654	* Configure an external timestamp event on the requested channel.
		1655	*
		1656	* Return: 0 on success, -EOPNOTUSPP on unsupported flags
1650	*/	1657	*/
1651	static int	1658	static int ice_ptp_cfg_extts(struct ice_pf *pf, unsigned int chan,
1652	ice_ptp_cfg_extts(struct ice_pf *pf, bool ena, unsigned int chan, u32 gpio_pin,	1659	struct ice_extts_channel *config, bool store)
1653	unsigned int extts_flags)
1654	{	1660	{
1655	u32 func, aux_reg, gpio_reg, irq_reg;	1661	u32 func, aux_reg, gpio_reg, irq_reg;
1656	struct ice_hw *hw = &pf->hw;	1662	struct ice_hw *hw = &pf->hw;
1657	u8 tmr_idx;	1663	u8 tmr_idx;
1658		1664
1659	if (chan > (unsigned int)pf->ptp.info.n_ext_ts)	1665	/* Reject requests with unsupported flags */
1660	return -EINVAL;	1666	if (config->flags & ~(PTP_ENABLE_FEATURE \|
		1667	PTP_RISING_EDGE \|
		1668	PTP_FALLING_EDGE \|
		1669	PTP_STRICT_FLAGS))
		1670	return -EOPNOTSUPP;
1661		1671
1662	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;	1672	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;
1663		1673
1664	irq_reg = rd32(hw, PFINT_OICR_ENA);	1674	irq_reg = rd32(hw, PFINT_OICR_ENA);
1665		1675
1666	if (ena) {	1676	if (config->ena) {
1667	/* Enable the interrupt */	1677	/* Enable the interrupt */
1668	irq_reg \|= PFINT_OICR_TSYN_EVNT_M;	1678	irq_reg \|= PFINT_OICR_TSYN_EVNT_M;
1669	aux_reg = GLTSYN_AUX_IN_0_INT_ENA_M;	1679	aux_reg = GLTSYN_AUX_IN_0_INT_ENA_M;
@@ -1672,9 +1682,9 @@ ice_ptp_cfg_extts(struct ice_pf *pf, bool ena, unsigned int chan, u32 gpio_pin, · 2 unmodified lines
1672	#define GLTSYN_AUX_IN_0_EVNTLVL_FALLING_EDGE BIT(1)	1682	#define GLTSYN_AUX_IN_0_EVNTLVL_FALLING_EDGE BIT(1)
1673		1683
1674	/* set event level to requested edge */	1684	/* set event level to requested edge */
1675	if (extts_flags & PTP_FALLING_EDGE)	1685	if (config->flags & PTP_FALLING_EDGE)
1676	aux_reg \|= GLTSYN_AUX_IN_0_EVNTLVL_FALLING_EDGE;	1686	aux_reg \|= GLTSYN_AUX_IN_0_EVNTLVL_FALLING_EDGE;
1677	if (extts_flags & PTP_RISING_EDGE)	1687	if (config->flags & PTP_RISING_EDGE)
1678	aux_reg \|= GLTSYN_AUX_IN_0_EVNTLVL_RISING_EDGE;	1688	aux_reg \|= GLTSYN_AUX_IN_0_EVNTLVL_RISING_EDGE;
1679		1689
1680	/* Write GPIO CTL reg.	1690	/* Write GPIO CTL reg.
@@ -1695,11 +1705,51 @@ ice_ptp_cfg_extts(struct ice_pf *pf, bool ena, unsigned int chan, u32 gpio_pin, · 14 unmodified lines
1695		1705
1696	wr32(hw, PFINT_OICR_ENA, irq_reg);	1706	wr32(hw, PFINT_OICR_ENA, irq_reg);
1697	wr32(hw, GLTSYN_AUX_IN(chan, tmr_idx), aux_reg);	1707	wr32(hw, GLTSYN_AUX_IN(chan, tmr_idx), aux_reg);
1698	wr32(hw, GLGEN_GPIO_CTL(gpio_pin), gpio_reg);	1708	wr32(hw, GLGEN_GPIO_CTL(config->gpio_pin), gpio_reg);
		1709
		1710	if (store)
		1711	memcpy(&pf->ptp.extts_channels[chan], config, sizeof(*config));
1699		1712
1700	return 0;	1713	return 0;
1701	}	1714	}
1702		1715
		1716	/**
		1717	* ice_ptp_disable_all_extts - Disable all EXTTS channels
		1718	* @pf: Board private structure
		1719	*/
		1720	static void ice_ptp_disable_all_extts(struct ice_pf *pf)
		1721	{
		1722	struct ice_extts_channel extts_cfg = {};
		1723	int i;
		1724
		1725	for (i = 0; i < pf->ptp.info.n_ext_ts; i++) {
		1726	if (pf->ptp.extts_channels[i].ena) {
		1727	extts_cfg.gpio_pin = pf->ptp.extts_channels[i].gpio_pin;
		1728	extts_cfg.ena = false;
		1729	ice_ptp_cfg_extts(pf, i, &extts_cfg, false);
		1730	}
		1731	}
		1732
		1733	synchronize_irq(pf->oicr_irq.virq);
		1734	}
		1735
		1736	/**
		1737	* ice_ptp_enable_all_extts - Enable all EXTTS channels
		1738	* @pf: Board private structure
		1739	*
		1740	* Called during reset to restore user configuration.
		1741	*/
		1742	static void ice_ptp_enable_all_extts(struct ice_pf *pf)
		1743	{
		1744	int i;
		1745
		1746	for (i = 0; i < pf->ptp.info.n_ext_ts; i++) {
		1747	if (pf->ptp.extts_channels[i].ena)
		1748	ice_ptp_cfg_extts(pf, i, &pf->ptp.extts_channels[i],
		1749	false);
		1750	}
		1751	}
		1752
1703	/**	1753	/**
1704	* ice_ptp_cfg_clkout - Configure clock to generate periodic wave	1754	* ice_ptp_cfg_clkout - Configure clock to generate periodic wave
1705	* @pf: Board private structure	1755	* @pf: Board private structure
@@ -1718,6 +1768,9 @@ static int ice_ptp_cfg_clkout(struct ice_pf *pf, unsigned int chan, · 12 unmodified lines
1718	u32 func, val, gpio_pin;	1768	u32 func, val, gpio_pin;
1719	u8 tmr_idx;	1769	u8 tmr_idx;
1720		1770
		1771	if (config && config->flags & ~PTP_PEROUT_PHASE)
		1772	return -EOPNOTSUPP;
		1773
1721	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;	1774	tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned;
1722		1775
1723	/* 0. Reset mode & out_en in AUX_OUT */	1776	/* 0. Reset mode & out_en in AUX_OUT */
@@ -1853,17 +1906,18 @@ ice_ptp_gpio_enable_e810(struct ptp_clock_info *info, · 129 unmodified lines
1853	struct ptp_clock_request *rq, int on)	1906	struct ptp_clock_request *rq, int on)
1854	{	1907	{
1855	struct ice_pf *pf = ptp_info_to_pf(info);	1908	struct ice_pf *pf = ptp_info_to_pf(info);
1856	struct ice_perout_channel clk_cfg = {0};
1857	bool sma_pres = false;	1909	bool sma_pres = false;
1858	unsigned int chan;	1910	unsigned int chan;
1859	u32 gpio_pin;	1911	u32 gpio_pin;
1860	int err;
1861		1912
1862	if (ice_is_feature_supported(pf, ICE_F_SMA_CTRL))	1913	if (ice_is_feature_supported(pf, ICE_F_SMA_CTRL))
1863	sma_pres = true;	1914	sma_pres = true;
1864		1915
1865	switch (rq->type) {	1916	switch (rq->type) {
1866	case PTP_CLK_REQ_PEROUT:	1917	case PTP_CLK_REQ_PEROUT:
		1918	{
		1919	struct ice_perout_channel clk_cfg = {};
		1920
1867	chan = rq->perout.index;	1921	chan = rq->perout.index;
1868	if (sma_pres) {	1922	if (sma_pres) {
1869	if (chan == ice_pin_desc_e810t[SMA1].chan)	1923	if (chan == ice_pin_desc_e810t[SMA1].chan)
@@ -1883,15 +1937,19 @@ ice_ptp_gpio_enable_e810(struct ptp_clock_info *info, · 13 unmodified lines
1883	clk_cfg.gpio_pin = chan;	1937	clk_cfg.gpio_pin = chan;
1884	}	1938	}
1885		1939
		1940	clk_cfg.flags = rq->perout.flags;
1886	clk_cfg.period = ((rq->perout.period.sec * NSEC_PER_SEC) +	1941	clk_cfg.period = ((rq->perout.period.sec * NSEC_PER_SEC) +
1887	rq->perout.period.nsec);	1942	rq->perout.period.nsec);
1888	clk_cfg.start_time = ((rq->perout.start.sec * NSEC_PER_SEC) +	1943	clk_cfg.start_time = ((rq->perout.start.sec * NSEC_PER_SEC) +
1889	rq->perout.start.nsec);	1944	rq->perout.start.nsec);
1890	clk_cfg.ena = !!on;	1945	clk_cfg.ena = !!on;
1891		1946
1892	err = ice_ptp_cfg_clkout(pf, chan, &clk_cfg, true);	1947	return ice_ptp_cfg_clkout(pf, chan, &clk_cfg, true);
1893	break;	1948	}
1894	case PTP_CLK_REQ_EXTTS:	1949	case PTP_CLK_REQ_EXTTS:
		1950	{
		1951	struct ice_extts_channel extts_cfg = {};
		1952
1895	chan = rq->extts.index;	1953	chan = rq->extts.index;
1896	if (sma_pres) {	1954	if (sma_pres) {
1897	if (chan < ice_pin_desc_e810t[SMA2].chan)	1955	if (chan < ice_pin_desc_e810t[SMA2].chan)
@@ -1907,14 +1965,15 @@ ice_ptp_gpio_enable_e810(struct ptp_clock_info *info, · 9 unmodified lines
1907	gpio_pin = chan;	1965	gpio_pin = chan;
1908	}	1966	}
1909		1967
1910	err = ice_ptp_cfg_extts(pf, !!on, chan, gpio_pin,	1968	extts_cfg.flags = rq->extts.flags;
1911	rq->extts.flags);	1969	extts_cfg.gpio_pin = gpio_pin;
1912	break;	1970	extts_cfg.ena = !!on;
		1971
		1972	return ice_ptp_cfg_extts(pf, chan, &extts_cfg, true);
		1973	}
1913	default:	1974	default:
1914	return -EOPNOTSUPP;	1975	return -EOPNOTSUPP;
1915	}	1976	}
1916
1917	return err;
1918	}	1977	}
1919		1978
1920	/**	1979	/**
@@ -1927,26 +1986,32 @@ static int ice_ptp_gpio_enable_e823(struct ptp_clock_info *info, · 6 unmodified lines
1927	struct ptp_clock_request *rq, int on)	1986	struct ptp_clock_request *rq, int on)
1928	{	1987	{
1929	struct ice_pf *pf = ptp_info_to_pf(info);	1988	struct ice_pf *pf = ptp_info_to_pf(info);
1930	struct ice_perout_channel clk_cfg = {0};
1931	int err;
1932		1989
1933	switch (rq->type) {	1990	switch (rq->type) {
1934	case PTP_CLK_REQ_PPS:	1991	case PTP_CLK_REQ_PPS:
		1992	{
		1993	struct ice_perout_channel clk_cfg = {};
		1994
		1995	clk_cfg.flags = rq->perout.flags;
1935	clk_cfg.gpio_pin = PPS_PIN_INDEX;	1996	clk_cfg.gpio_pin = PPS_PIN_INDEX;
1936	clk_cfg.period = NSEC_PER_SEC;	1997	clk_cfg.period = NSEC_PER_SEC;
1937	clk_cfg.ena = !!on;	1998	clk_cfg.ena = !!on;
1938		1999
1939	err = ice_ptp_cfg_clkout(pf, PPS_CLK_GEN_CHAN, &clk_cfg, true);	2000	return ice_ptp_cfg_clkout(pf, PPS_CLK_GEN_CHAN, &clk_cfg, true);
1940	break;	2001	}
1941	case PTP_CLK_REQ_EXTTS:	2002	case PTP_CLK_REQ_EXTTS:
1942	err = ice_ptp_cfg_extts(pf, !!on, rq->extts.index,	2003	{
1943	TIME_SYNC_PIN_INDEX, rq->extts.flags);	2004	struct ice_extts_channel extts_cfg = {};
1944	break;	2005
		2006	extts_cfg.flags = rq->extts.flags;
		2007	extts_cfg.gpio_pin = TIME_SYNC_PIN_INDEX;
		2008	extts_cfg.ena = !!on;
		2009
		2010	return ice_ptp_cfg_extts(pf, rq->extts.index, &extts_cfg, true);
		2011	}
1945	default:	2012	default:
1946	return -EOPNOTSUPP;	2013	return -EOPNOTSUPP;
1947	}	2014	}
1948
1949	return err;
1950	}	2015	}
1951		2016
1952	/**	2017	/**
@@ -2781,6 +2846,10 @@ static int ice_ptp_rebuild_owner(struct ice_pf *pf) · 828 unmodified lines
2781	ice_ptp_restart_all_phy(pf);	2846	ice_ptp_restart_all_phy(pf);
2782	}	2847	}
2783		2848
		2849	/* Re-enable all periodic outputs and external timestamp events */
		2850	ice_ptp_enable_all_clkout(pf);
		2851	ice_ptp_enable_all_extts(pf);
		2852
2784	return 0;	2853	return 0;
2785	}	2854	}
2786		2855
@@ -3340,6 +3409,8 @@ void ice_ptp_release(struct ice_pf *pf) · 553 unmodified lines
3340		3409
3341	ice_ptp_release_tx_tracker(pf, &pf->ptp.port.tx);	3410	ice_ptp_release_tx_tracker(pf, &pf->ptp.port.tx);
3342		3411
		3412	ice_ptp_disable_all_extts(pf);
		3413
3343	kthread_cancel_delayed_work_sync(&pf->ptp.work);	3414	kthread_cancel_delayed_work_sync(&pf->ptp.work);
3344		3415
3345	ice_ptp_port_phy_stop(&pf->ptp.port);	3416	ice_ptp_port_phy_stop(&pf->ptp.port);

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

 struct ice_perout_channel {
 	bool ena;
 	u32 gpio_pin;
+	u32 flags;
 	u64 period;
 	u64 start_time;
 };
+struct ice_extts_channel {
+	bool ena;
+	u32 gpio_pin;
+	u32 flags;
+};
 /* The ice hardware captures Tx hardware timestamps in the PHY. The timestamp
  * is stored in a buffer of registers. Depending on the specific hardware,
  * this buffer might be shared across multiple PHY ports.
  * @ext_ts_irq: the external timestamp IRQ in use
  * @kworker: kwork thread for handling periodic work
  * @perout_channels: periodic output data
+ * @extts_channels: channels for external timestamps
  * @info: structure defining PTP hardware capabilities
  * @clock: pointer to registered PTP clock device
  * @tstamp_config: hardware timestamping configuration
 	u8 ext_ts_irq;
 	struct kthread_worker *kworker;
 	struct ice_perout_channel perout_channels[GLTSYN_TGT_H_IDX_MAX];
+	struct ice_extts_channel extts_channels[GLTSYN_TGT_H_IDX_MAX];
 	struct ptp_clock_info info;
 	struct ptp_clock *clock;
 	struct hwtstamp_config tstamp_config;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c+35−13

@@ -989,7 +989,12 @@ static void mlx5e_xfrm_update_stats(struct xfrm_state *x) · 988 unmodified lines
989	struct mlx5e_ipsec_sa_entry *sa_entry = to_ipsec_sa_entry(x);	989	struct mlx5e_ipsec_sa_entry *sa_entry = to_ipsec_sa_entry(x);
990	struct mlx5e_ipsec_rule *ipsec_rule = &sa_entry->ipsec_rule;	990	struct mlx5e_ipsec_rule *ipsec_rule = &sa_entry->ipsec_rule;
991	struct net *net = dev_net(x->xso.dev);	991	struct net *net = dev_net(x->xso.dev);
		992	u64 trailer_packets = 0, trailer_bytes = 0;
		993	u64 replay_packets = 0, replay_bytes = 0;
		994	u64 auth_packets = 0, auth_bytes = 0;
		995	u64 success_packets, success_bytes;
992	u64 packets, bytes, lastuse;	996	u64 packets, bytes, lastuse;
		997	size_t headers;
993		998
994	lockdep_assert(lockdep_is_held(&x->lock) \|\|	999	lockdep_assert(lockdep_is_held(&x->lock) \|\|
995	lockdep_is_held(&dev_net(x->xso.real_dev)->xfrm.xfrm_cfg_mutex) \|\|	1000	lockdep_is_held(&dev_net(x->xso.real_dev)->xfrm.xfrm_cfg_mutex) \|\|
@@ -999,26 +1004,43 @@ static void mlx5e_xfrm_update_stats(struct xfrm_state *x) · 3 unmodified lines
999	return;	1004	return;
1000		1005
1001	if (sa_entry->attrs.dir == XFRM_DEV_OFFLOAD_IN) {	1006	if (sa_entry->attrs.dir == XFRM_DEV_OFFLOAD_IN) {
1002	mlx5_fc_query_cached(ipsec_rule->auth.fc, &bytes, &packets, &lastuse);	1007	mlx5_fc_query_cached(ipsec_rule->auth.fc, &auth_bytes,
1003	x->stats.integrity_failed += packets;	1008	&auth_packets, &lastuse);
1004	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINSTATEPROTOERROR, packets);	1009	x->stats.integrity_failed += auth_packets;
1005		1010	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINSTATEPROTOERROR, auth_packets);
1006	mlx5_fc_query_cached(ipsec_rule->trailer.fc, &bytes, &packets, &lastuse);	1011
1007	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINHDRERROR, packets);	1012	mlx5_fc_query_cached(ipsec_rule->trailer.fc, &trailer_bytes,
		1013	&trailer_packets, &lastuse);
		1014	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINHDRERROR, trailer_packets);
1008	}	1015	}
1009		1016
1010	if (x->xso.type != XFRM_DEV_OFFLOAD_PACKET)	1017	if (x->xso.type != XFRM_DEV_OFFLOAD_PACKET)
1011	return;	1018	return;
1012		1019
1013	mlx5_fc_query_cached(ipsec_rule->fc, &bytes, &packets, &lastuse);
1014	x->curlft.packets += packets;
1015	x->curlft.bytes += bytes;
1016
1017	if (sa_entry->attrs.dir == XFRM_DEV_OFFLOAD_IN) {	1020	if (sa_entry->attrs.dir == XFRM_DEV_OFFLOAD_IN) {
1018	mlx5_fc_query_cached(ipsec_rule->replay.fc, &bytes, &packets, &lastuse);	1021	mlx5_fc_query_cached(ipsec_rule->replay.fc, &replay_bytes,
1019	x->stats.replay += packets;	1022	&replay_packets, &lastuse);
1020	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR, packets);	1023	x->stats.replay += replay_packets;
		1024	XFRM_ADD_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR, replay_packets);
1021	}	1025	}
		1026
		1027	mlx5_fc_query_cached(ipsec_rule->fc, &bytes, &packets, &lastuse);
		1028	success_packets = packets - auth_packets - trailer_packets - replay_packets;
		1029	x->curlft.packets += success_packets;
		1030	/* NIC counts all bytes passed through flow steering and doesn't have
		1031	* an ability to count payload data size which is needed for SA.
		1032	*
		1033	* To overcome HW limitestion, let's approximate the payload size
		1034	* by removing always available headers.
		1035	*/
		1036	headers = sizeof(struct ethhdr);
		1037	if (sa_entry->attrs.family == AF_INET)
		1038	headers += sizeof(struct iphdr);
		1039	else
		1040	headers += sizeof(struct ipv6hdr);
		1041
		1042	success_bytes = bytes - auth_bytes - trailer_bytes - replay_bytes;
		1043	x->curlft.bytes += success_bytes - headers * success_packets;
1022	}	1044	}
1023		1045
1024	static int mlx5e_xfrm_validate_policy(struct mlx5_core_dev *mdev,	1046	static int mlx5e_xfrm_validate_policy(struct mlx5_core_dev *mdev,

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

 		kfree(priv->htb_qos_sq_stats[i]);
 	kvfree(priv->htb_qos_sq_stats);
+	if (priv->mqprio_rl) {
+		mlx5e_mqprio_rl_cleanup(priv->mqprio_rl);
+		mlx5e_mqprio_rl_free(priv->mqprio_rl);
+	}
 	memset(priv, 0, sizeof(*priv));
 }

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

@@ -1197,9 +1197,7 @@ static int get_num_eqs(struct mlx5_core_dev *dev) · 1196 unmodified lines
1197	if (!mlx5_core_is_eth_enabled(dev) && mlx5_eth_supported(dev))	1197	if (!mlx5_core_is_eth_enabled(dev) && mlx5_eth_supported(dev))
1198	return 1;	1198	return 1;
1199		1199
1200	max_dev_eqs = MLX5_CAP_GEN(dev, max_num_eqs) ?	1200	max_dev_eqs = mlx5_max_eq_cap_get(dev);
1201	MLX5_CAP_GEN(dev, max_num_eqs) :
1202	1 << MLX5_CAP_GEN(dev, log_max_eq);
1203		1201
1204	num_eqs = min_t(int, mlx5_irq_table_get_num_comp(eq_table->irq_table),	1202	num_eqs = min_t(int, mlx5_irq_table_get_num_comp(eq_table->irq_table),
1205	max_dev_eqs - MLX5_MAX_ASYNC_EQS);	1203	max_dev_eqs - MLX5_MAX_ASYNC_EQS);

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/ingress_ofld.c+29−8

@@ -6,6 +6,9 @@ · 5 unmodified lines
6	#include "helper.h"	6	#include "helper.h"
7	#include "ofld.h"	7	#include "ofld.h"
8		8
		9	static int
		10	acl_ingress_ofld_setup(struct mlx5_eswitch esw, struct mlx5_vport vport);
		11
9	static bool	12	static bool
10	esw_acl_ingress_prio_tag_enabled(struct mlx5_eswitch *esw,	13	esw_acl_ingress_prio_tag_enabled(struct mlx5_eswitch *esw,
11	const struct mlx5_vport *vport)	14	const struct mlx5_vport *vport)
@@ -123,18 +126,31 @@ static int esw_acl_ingress_src_port_drop_create(struct mlx5_eswitch *esw, · 111 unmodified lines
123	{	126	{
124	struct mlx5_flow_act flow_act = {};	127	struct mlx5_flow_act flow_act = {};
125	struct mlx5_flow_handle *flow_rule;	128	struct mlx5_flow_handle *flow_rule;
		129	bool created = false;
126	int err = 0;	130	int err = 0;
127		131
		132	if (!vport->ingress.acl) {
		133	err = acl_ingress_ofld_setup(esw, vport);
		134	if (err)
		135	return err;
		136	created = true;
		137	}
		138
128	flow_act.action = MLX5_FLOW_CONTEXT_ACTION_DROP;	139	flow_act.action = MLX5_FLOW_CONTEXT_ACTION_DROP;
129	flow_act.fg = vport->ingress.offloads.drop_grp;	140	flow_act.fg = vport->ingress.offloads.drop_grp;
130	flow_rule = mlx5_add_flow_rules(vport->ingress.acl, NULL, &flow_act, NULL, 0);	141	flow_rule = mlx5_add_flow_rules(vport->ingress.acl, NULL, &flow_act, NULL, 0);
131	if (IS_ERR(flow_rule)) {	142	if (IS_ERR(flow_rule)) {
132	err = PTR_ERR(flow_rule);	143	err = PTR_ERR(flow_rule);
133	goto out;	144	goto err_out;
134	}	145	}
135		146
136	vport->ingress.offloads.drop_rule = flow_rule;	147	vport->ingress.offloads.drop_rule = flow_rule;
137	out:	148
		149	return 0;
		150	err_out:
		151	/* Only destroy ingress acl created in this function. */
		152	if (created)
		153	esw_acl_ingress_ofld_cleanup(esw, vport);
138	return err;	154	return err;
139	}	155	}
140		156
@@ -299,16 +315,12 @@ static void esw_acl_ingress_ofld_groups_destroy(struct mlx5_vport *vport) · 158 unmodified lines
299	}	315	}
300	}	316	}
301		317
302	int esw_acl_ingress_ofld_setup(struct mlx5_eswitch *esw,	318	static int
303	struct mlx5_vport *vport)	319	acl_ingress_ofld_setup(struct mlx5_eswitch esw, struct mlx5_vport vport)
304	{	320	{
305	int num_ftes = 0;	321	int num_ftes = 0;
306	int err;	322	int err;
307		323
308	if (!mlx5_eswitch_vport_match_metadata_enabled(esw) &&
309	!esw_acl_ingress_prio_tag_enabled(esw, vport))
310	return 0;
311
312	esw_acl_ingress_allow_rule_destroy(vport);	324	esw_acl_ingress_allow_rule_destroy(vport);
313		325
314	if (mlx5_eswitch_vport_match_metadata_enabled(esw))	326	if (mlx5_eswitch_vport_match_metadata_enabled(esw))
@@ -347,6 +359,15 @@ group_err: · 32 unmodified lines
347	return err;	359	return err;
348	}	360	}
349		361
		362	int esw_acl_ingress_ofld_setup(struct mlx5_eswitch esw, struct mlx5_vport vport)
		363	{
		364	if (!mlx5_eswitch_vport_match_metadata_enabled(esw) &&
		365	!esw_acl_ingress_prio_tag_enabled(esw, vport))
		366	return 0;
		367
		368	return acl_ingress_ofld_setup(esw, vport);
		369	}
		370
350	void esw_acl_ingress_ofld_cleanup(struct mlx5_eswitch *esw,	371	void esw_acl_ingress_ofld_cleanup(struct mlx5_eswitch *esw,
351	struct mlx5_vport *vport)	372	struct mlx5_vport *vport)
352	{	373	{

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

 		return -EOPNOTSUPP;
 	}
+	if (!MLX5_CAP_GEN_2(esw->dev, max_num_eqs_24b)) {
+		NL_SET_ERR_MSG_MOD(extack,
+				   "Device doesn't support getting the max number of EQs");
+		return -EOPNOTSUPP;
+	}
 	query_ctx = kzalloc(query_out_sz, GFP_KERNEL);
 	if (!query_ctx)
 		return -ENOMEM;
 	mutex_lock(&esw->state_lock);
 	err = mlx5_vport_get_other_func_cap(esw->dev, vport_num, query_ctx,
-					    MLX5_CAP_GENERAL);
+					    MLX5_CAP_GENERAL_2);
 	if (err) {
 		NL_SET_ERR_MSG_MOD(extack, "Failed getting HCA caps");
 		goto out;
 	}
 	hca_caps = MLX5_ADDR_OF(query_hca_cap_out, query_ctx, capability);
-	max_eqs = MLX5_GET(cmd_hca_cap, hca_caps, max_num_eqs);
+	max_eqs = MLX5_GET(cmd_hca_cap_2, hca_caps, max_num_eqs_24b);
 	if (max_eqs < MLX5_ESW_MAX_CTRL_EQS)
 		*max_io_eqs = 0;
 	else
 		return -EOPNOTSUPP;
 	}
+	if (!MLX5_CAP_GEN_2(esw->dev, max_num_eqs_24b)) {
+		NL_SET_ERR_MSG_MOD(extack,
+				   "Device doesn't support changing the max number of EQs");
+		return -EOPNOTSUPP;
+	}
 	if (check_add_overflow(max_io_eqs, MLX5_ESW_MAX_CTRL_EQS, &max_eqs)) {
 		NL_SET_ERR_MSG_MOD(extack, "Supplied value out of range");
 		return -EINVAL;
 	mutex_lock(&esw->state_lock);
 	err = mlx5_vport_get_other_func_cap(esw->dev, vport_num, query_ctx,
-					    MLX5_CAP_GENERAL);
+					    MLX5_CAP_GENERAL_2);
 	if (err) {
 		NL_SET_ERR_MSG_MOD(extack, "Failed getting HCA caps");
 		goto out;
 	}
 	hca_caps = MLX5_ADDR_OF(query_hca_cap_out, query_ctx, capability);
-	MLX5_SET(cmd_hca_cap, hca_caps, max_num_eqs, max_eqs);
+	MLX5_SET(cmd_hca_cap_2, hca_caps, max_num_eqs_24b, max_eqs);
 	err = mlx5_vport_set_other_func_cap(esw->dev, hca_caps, vport_num,
-					    MLX5_SET_HCA_CAP_OP_MOD_GENERAL_DEVICE);
+					    MLX5_SET_HCA_CAP_OP_MOD_GENERAL_DEVICE2);
 	if (err)
 		NL_SET_ERR_MSG_MOD(extack, "Failed setting HCA caps");

drivers/net/ethernet/mellanox/mlx5/core/mlx5_core.h+10−0

@@ -383,4 +383,14 @@ static inline int mlx5_vport_to_func_id(const struct mlx5_core_dev *dev, u16 vpo · 382 unmodified lines
383	: vport;	383	: vport;
384	}	384	}
385		385
		386	static inline int mlx5_max_eq_cap_get(const struct mlx5_core_dev *dev)
		387	{
		388	if (MLX5_CAP_GEN_2(dev, max_num_eqs_24b))
		389	return MLX5_CAP_GEN_2(dev, max_num_eqs_24b);
		390
		391	if (MLX5_CAP_GEN(dev, max_num_eqs))
		392	return MLX5_CAP_GEN(dev, max_num_eqs);
		393
		394	return 1 << MLX5_CAP_GEN(dev, log_max_eq);
		395	}
386	#endif /* __MLX5_CORE_H__ */	396	#endif /* __MLX5_CORE_H__ */

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

 int mlx5_irq_table_create(struct mlx5_core_dev *dev)
 {
-	int num_eqs = MLX5_CAP_GEN(dev, max_num_eqs) ?
+	int num_eqs = mlx5_max_eq_cap_get(dev);
-		      MLX5_CAP_GEN(dev, max_num_eqs) :
-		      1 << MLX5_CAP_GEN(dev, log_max_eq);
 	int total_vec;
 	int pcif_vec;
 	int req_vec;

drivers/net/ethernet/mellanox/mlxsw/core_linecards.c+1−0

@@ -1484,6 +1484,7 @@ err_type_file_file_validate: · 1483 unmodified lines
1484	vfree(types_info->data);	1484	vfree(types_info->data);
1485	err_data_alloc:	1485	err_data_alloc:
1486	kfree(types_info);	1486	kfree(types_info);
		1487	linecards->types_info = NULL;
1487	return err;	1488	return err;
1488	}	1489	}
1489		1490

drivers/net/ethernet/renesas/rswitch.c+2−2

 		dma_rmb();
 		skb = gq->skbs[gq->dirty];
 		if (skb) {
+			rdev->ndev->stats.tx_packets++;
+			rdev->ndev->stats.tx_bytes += skb->len;
 			dma_unmap_single(ndev->dev.parent,
 					 gq->unmap_addrs[gq->dirty],
 					 skb->len, DMA_TO_DEVICE);
 			dev_kfree_skb_any(gq->skbs[gq->dirty]);
 			gq->skbs[gq->dirty] = NULL;
-			rdev->ndev->stats.tx_packets++;
-			rdev->ndev->stats.tx_bytes += skb->len;
 		}
 		desc->desc.die_dt = DT_EEMPTY;
 	}

drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c+1−1

@@ -272,7 +272,7 @@ static const struct ethqos_emac_por emac_v4_0_0_por[] = { · 271 unmodified lines
272		272
273	static const struct ethqos_emac_driver_data emac_v4_0_0_data = {	273	static const struct ethqos_emac_driver_data emac_v4_0_0_data = {
274	.por = emac_v4_0_0_por,	274	.por = emac_v4_0_0_por,
275	.num_por = ARRAY_SIZE(emac_v3_0_0_por),	275	.num_por = ARRAY_SIZE(emac_v4_0_0_por),
276	.rgmii_config_loopback_en = false,	276	.rgmii_config_loopback_en = false,
277	.has_emac_ge_3 = true,	277	.has_emac_ge_3 = true,
278	.link_clk_name = "phyaux",	278	.link_clk_name = "phyaux",

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

@@ -7663,9 +7663,10 @@ int stmmac_dvr_probe(struct device *device, · 7662 unmodified lines
7663	#ifdef STMMAC_VLAN_TAG_USED	7663	#ifdef STMMAC_VLAN_TAG_USED
7664	/* Both mac100 and gmac support receive VLAN tag detection */	7664	/* Both mac100 and gmac support receive VLAN tag detection */
7665	ndev->features \|= NETIF_F_HW_VLAN_CTAG_RX \| NETIF_F_HW_VLAN_STAG_RX;	7665	ndev->features \|= NETIF_F_HW_VLAN_CTAG_RX \| NETIF_F_HW_VLAN_STAG_RX;
7666	ndev->hw_features \|= NETIF_F_HW_VLAN_CTAG_RX;	7666	if (priv->plat->has_gmac4) {
7667	priv->hw->hw_vlan_en = true;	7667	ndev->hw_features \|= NETIF_F_HW_VLAN_CTAG_RX;
7668		7668	priv->hw->hw_vlan_en = true;
		7669	}
7669	if (priv->dma_cap.vlhash) {	7670	if (priv->dma_cap.vlhash) {
7670	ndev->features \|= NETIF_F_HW_VLAN_CTAG_FILTER;	7671	ndev->features \|= NETIF_F_HW_VLAN_CTAG_FILTER;
7671	ndev->features \|= NETIF_F_HW_VLAN_STAG_FILTER;	7672	ndev->features \|= NETIF_F_HW_VLAN_STAG_FILTER;

drivers/net/ethernet/wangxun/libwx/wx_hw.c+1−0

@@ -1978,6 +1978,7 @@ int wx_sw_init(struct wx *wx) · 1977 unmodified lines
1978		1978
1979	bitmap_zero(wx->state, WX_STATE_NBITS);	1979	bitmap_zero(wx->state, WX_STATE_NBITS);
1980	bitmap_zero(wx->flags, WX_PF_FLAGS_NBITS);	1980	bitmap_zero(wx->flags, WX_PF_FLAGS_NBITS);
		1981	wx->misc_irq_domain = false;
1981		1982
1982	return 0;	1983	return 0;
1983	}	1984	}

drivers/net/ethernet/wangxun/libwx/wx_lib.c+7−3

 	}
 	pdev->irq = pci_irq_vector(pdev, 0);
+	wx->num_q_vectors = 1;
 	return 0;
 }
 	int vector;
 	if (!(pdev->msix_enabled)) {
-		free_irq(pdev->irq, wx);
+		if (!wx->misc_irq_domain)
+			free_irq(pdev->irq, wx);
 		return;
 	}
 		free_irq(entry->vector, q_vector);
 	}
-	if (wx->mac.type == wx_mac_em)
+	if (!wx->misc_irq_domain)
 		free_irq(wx->msix_entry->vector, wx);
 }
 EXPORT_SYMBOL(wx_free_irq);
 {
 	struct pci_dev *pdev = wx->pdev;
+	if (wx->isb_mem)
+		return 0;
 	wx->isb_mem = dma_alloc_coherent(&pdev->dev,
 					 sizeof(u32) * 4,
 					 &wx->isb_dma,
 void wx_free_resources(struct wx *wx)
 {
-	wx_free_isb_resources(wx);
 	wx_free_all_rx_resources(wx);
 	wx_free_all_tx_resources(wx);
 }

drivers/net/ethernet/wangxun/libwx/wx_type.h+1−0

@@ -1109,6 +1109,7 @@ struct wx { · 1108 unmodified lines
1109	dma_addr_t isb_dma;	1109	dma_addr_t isb_dma;
1110	u32 *isb_mem;	1110	u32 *isb_mem;
1111	u32 isb_tag[WX_ISB_MAX];	1111	u32 isb_tag[WX_ISB_MAX];
		1112	bool misc_irq_domain;
1112		1113
1113	#define WX_MAX_RETA_ENTRIES 128	1114	#define WX_MAX_RETA_ENTRIES 128
1114	#define WX_RSS_INDIR_TBL_MAX 64	1115	#define WX_RSS_INDIR_TBL_MAX 64

drivers/net/ethernet/wangxun/ngbe/ngbe_main.c+2−0

 err_free_irq:
 	wx_free_irq(wx);
 err_free_resources:
+	wx_free_isb_resources(wx);
 	wx_free_resources(wx);
 	return err;
 }
 	ngbe_down(wx);
 	wx_free_irq(wx);
+	wx_free_isb_resources(wx);
 	wx_free_resources(wx);
 	phylink_disconnect_phy(wx->phylink);
 	wx_control_hw(wx, false);

drivers/net/ethernet/wangxun/txgbe/txgbe_irq.c+47−77

 }
 /**
- * txgbe_intr - msi/legacy mode Interrupt Handler
+ * txgbe_request_queue_irqs - Initialize MSI-X queue interrupts
- * @irq: interrupt number
- * @data: pointer to a network interface device structure
- **/
-static irqreturn_t txgbe_intr(int __always_unused irq, void *data)
-{
-	struct wx_q_vector *q_vector;
-	struct wx *wx  = data;
-	struct pci_dev *pdev;
-	u32 eicr;
-	q_vector = wx->q_vector[0];
-	pdev = wx->pdev;
-	eicr = wx_misc_isb(wx, WX_ISB_VEC0);
-	if (!eicr) {
-		/* shared interrupt alert!
-		 * the interrupt that we masked before the ICR read.
-		 */
-		if (netif_running(wx->netdev))
-			txgbe_irq_enable(wx, true);
-		return IRQ_NONE;        /* Not our interrupt */
-	}
-	wx->isb_mem[WX_ISB_VEC0] = 0;
-	if (!(pdev->msi_enabled))
-		wr32(wx, WX_PX_INTA, 1);
-	wx->isb_mem[WX_ISB_MISC] = 0;
-	/* would disable interrupts here but it is auto disabled */
-	napi_schedule_irqoff(&q_vector->napi);
-	/* re-enable link(maybe) and non-queue interrupts, no flush.
-	 * txgbe_poll will re-enable the queue interrupts
-	 */
-	if (netif_running(wx->netdev))
-		txgbe_irq_enable(wx, false);
-	return IRQ_HANDLED;
-}
-/**
- * txgbe_request_msix_irqs - Initialize MSI-X interrupts
  * @wx: board private structure
  *
- * Allocate MSI-X vectors and request interrupts from the kernel.
+ * Allocate MSI-X queue vectors and request interrupts from the kernel.
  **/
-static int txgbe_request_msix_irqs(struct wx *wx)
+int txgbe_request_queue_irqs(struct wx *wx)
 {
 	struct net_device *netdev = wx->netdev;
 	int vector, err;
+	if (!wx->pdev->msix_enabled)
+		return 0;
 	for (vector = 0; vector < wx->num_q_vectors; vector++) {
 		struct wx_q_vector *q_vector = wx->q_vector[vector];
 		struct msix_entry *entry = &wx->msix_q_entries[vector];
 	return err;
 }
-/**
- * txgbe_request_irq - initialize interrupts
- * @wx: board private structure
- *
- * Attempt to configure interrupts using the best available
- * capabilities of the hardware and kernel.
- **/
-int txgbe_request_irq(struct wx *wx)
-{
-	struct net_device *netdev = wx->netdev;
-	struct pci_dev *pdev = wx->pdev;
-	int err;
-	if (pdev->msix_enabled)
-		err = txgbe_request_msix_irqs(wx);
-	else if (pdev->msi_enabled)
-		err = request_irq(wx->pdev->irq, &txgbe_intr, 0,
-				  netdev->name, wx);
-	else
-		err = request_irq(wx->pdev->irq, &txgbe_intr, IRQF_SHARED,
-				  netdev->name, wx);
-	if (err)
-		wx_err(wx, "request_irq failed, Error %d\n", err);
-	return err;
-}
 static int txgbe_request_gpio_irq(struct txgbe *txgbe)
 {
 	txgbe->gpio_irq = irq_find_mapping(txgbe->misc.domain, TXGBE_IRQ_GPIO);
 };
 static irqreturn_t txgbe_misc_irq_handle(int irq, void *data)
+{
+	struct wx_q_vector *q_vector;
+	struct txgbe *txgbe = data;
+	struct wx *wx = txgbe->wx;
+	u32 eicr;
+	if (wx->pdev->msix_enabled)
+		return IRQ_WAKE_THREAD;
+	eicr = wx_misc_isb(wx, WX_ISB_VEC0);
+	if (!eicr) {
+		/* shared interrupt alert!
+		 * the interrupt that we masked before the ICR read.
+		 */
+		if (netif_running(wx->netdev))
+			txgbe_irq_enable(wx, true);
+		return IRQ_NONE;        /* Not our interrupt */
+	}
+	wx->isb_mem[WX_ISB_VEC0] = 0;
+	if (!(wx->pdev->msi_enabled))
+		wr32(wx, WX_PX_INTA, 1);
+	/* would disable interrupts here but it is auto disabled */
+	q_vector = wx->q_vector[0];
+	napi_schedule_irqoff(&q_vector->napi);
+	return IRQ_WAKE_THREAD;
+}
+static irqreturn_t txgbe_misc_irq_thread_fn(int irq, void *data)
 {
 	struct txgbe *txgbe = data;
 	struct wx *wx = txgbe->wx;
 int txgbe_setup_misc_irq(struct txgbe *txgbe)
 {
+	unsigned long flags = IRQF_ONESHOT;
 	struct wx *wx = txgbe->wx;
 	int hwirq, err;
 		irq_create_mapping(txgbe->misc.domain, hwirq);
 	txgbe->misc.chip = txgbe_irq_chip;
-	if (wx->pdev->msix_enabled)
+	if (wx->pdev->msix_enabled) {
 		txgbe->misc.irq = wx->msix_entry->vector;
-	else
+	} else {
 		txgbe->misc.irq = wx->pdev->irq;
+		if (!wx->pdev->msi_enabled)
+			flags |= IRQF_SHARED;
+	}
-	err = request_threaded_irq(txgbe->misc.irq, NULL,
+	err = request_threaded_irq(txgbe->misc.irq, txgbe_misc_irq_handle,
-				   txgbe_misc_irq_handle,
+				   txgbe_misc_irq_thread_fn,
-				   IRQF_ONESHOT,
+				   flags,
 				   wx->netdev->name, txgbe);
 	if (err)
 		goto del_misc_irq;
 	if (err)
 		goto free_gpio_irq;
+	wx->misc_irq_domain = true;
 	return 0;
 free_gpio_irq:

drivers/net/ethernet/wangxun/txgbe/txgbe_irq.h+1−1

@@ -2,6 +2,6 @@ · 1 unmodified line
2	/* Copyright (c) 2015 - 2024 Beijing WangXun Technology Co., Ltd. */	2	/* Copyright (c) 2015 - 2024 Beijing WangXun Technology Co., Ltd. */
3		3
4	void txgbe_irq_enable(struct wx *wx, bool queues);	4	void txgbe_irq_enable(struct wx *wx, bool queues);
5	int txgbe_request_irq(struct wx *wx);	5	int txgbe_request_queue_irqs(struct wx *wx);
6	void txgbe_free_misc_irq(struct txgbe *txgbe);	6	void txgbe_free_misc_irq(struct txgbe *txgbe);
7	int txgbe_setup_misc_irq(struct txgbe *txgbe);	7	int txgbe_setup_misc_irq(struct txgbe *txgbe);

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c+5−4

 	wx_configure(wx);
-	err = txgbe_request_irq(wx);
+	err = txgbe_request_queue_irqs(wx);
 	if (err)
-		goto err_free_isb;
+		goto err_free_resources;
 	/* Notify the stack of the actual queue counts. */
 	err = netif_set_real_num_tx_queues(netdev, wx->num_tx_queues);
 err_free_irq:
 	wx_free_irq(wx);
-err_free_isb:
+err_free_resources:
-	wx_free_isb_resources(wx);
+	wx_free_resources(wx);
 err_reset:
 	txgbe_reset(wx);
 	txgbe_remove_phy(txgbe);
 	txgbe_free_misc_irq(txgbe);
+	wx_free_isb_resources(wx);
 	pci_release_selected_regions(pdev,
 				     pci_select_bars(pdev, IORESOURCE_MEM));

drivers/net/ntb_netdev.c+1−1

@@ -119,7 +119,7 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp qp, void qp_data, · 118 unmodified lines
119	skb->protocol = eth_type_trans(skb, ndev);	119	skb->protocol = eth_type_trans(skb, ndev);
120	skb->ip_summed = CHECKSUM_NONE;	120	skb->ip_summed = CHECKSUM_NONE;
121		121
122	if (__netif_rx(skb) == NET_RX_DROP) {	122	if (netif_rx(skb) == NET_RX_DROP) {
123	ndev->stats.rx_errors++;	123	ndev->stats.rx_errors++;
124	ndev->stats.rx_dropped++;	124	ndev->stats.rx_dropped++;
125	} else {	125	} else {

drivers/net/phy/aquantia/aquantia.h+4−0

  * Author: Heiner Kallweit <hkallweit1@gmail.com>
  */
+#ifndef AQUANTIA_H
+#define AQUANTIA_H
 #include <linux/device.h>
 #include <linux/phy.h>
 int aqr_phy_led_active_low_set(struct phy_device *phydev, int index, bool enable);
 int aqr_phy_led_polarity_set(struct phy_device *phydev, int index,
 			     unsigned long modes);
+#endif /* AQUANTIA_H */

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c+7−7

 		hw->wiphy->features |= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES;
 	if (iwl_fw_lookup_cmd_ver(mvm->fw, WOWLAN_KEK_KCK_MATERIAL,
-				  IWL_FW_CMD_VER_UNKNOWN) == 3)
+				  IWL_FW_CMD_VER_UNKNOWN) >= 3)
 		hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK;
 	if (fw_has_api(&mvm->fw->ucode_capa,
 	struct iwl_mvm_vif *mvmvif =
 		container_of(wk, struct iwl_mvm_vif, prevent_esr_done_wk.work);
 	struct iwl_mvm *mvm = mvmvif->mvm;
-	struct ieee80211_vif *vif = iwl_mvm_get_bss_vif(mvm);
+	struct ieee80211_vif *vif =
+		container_of((void *)mvmvif, struct ieee80211_vif, drv_priv);
 	guard(mvm)(mvm);
 	iwl_mvm_unblock_esr(mvm, vif, IWL_MVM_ESR_BLOCKED_PREVENTION);
 	struct iwl_mvm_vif *mvmvif =
 		container_of(wk, struct iwl_mvm_vif, unblock_esr_tpt_wk);
 	struct iwl_mvm *mvm = mvmvif->mvm;
-	struct ieee80211_vif *vif = iwl_mvm_get_bss_vif(mvm);
+	struct ieee80211_vif *vif =
+		container_of((void *)mvmvif, struct ieee80211_vif, drv_priv);
 	guard(mvm)(mvm);
 	iwl_mvm_unblock_esr(mvm, vif, IWL_MVM_ESR_BLOCKED_TPT);
 	if (sync) {
 		lockdep_assert_held(&mvm->mutex);
 		ret = wait_event_timeout(mvm->rx_sync_waitq,
-					 READ_ONCE(mvm->queue_sync_state) == 0 ||
+					 READ_ONCE(mvm->queue_sync_state) == 0,
-					 iwl_mvm_is_radio_hw_killed(mvm),
 					 SYNC_RX_QUEUE_TIMEOUT);
-		WARN_ONCE(!ret && !iwl_mvm_is_radio_hw_killed(mvm),
+		WARN_ONCE(!ret, "queue sync: failed to sync, state is 0x%lx, cookie %d\n",
-			  "queue sync: failed to sync, state is 0x%lx, cookie %d\n",
 			  mvm->queue_sync_state,
 			  mvm->queue_sync_cookie);
 	}

drivers/net/wireless/intel/iwlwifi/mvm/ops.c+3−5

 	struct ieee80211_vif *vif = iwl_mvm_get_bss_vif(mvm);
 	/* FW recommendations is only for entering EMLSR */
-	if (!vif || iwl_mvm_vif_from_mac80211(vif)->esr_active)
+	if (IS_ERR_OR_NULL(vif) || iwl_mvm_vif_from_mac80211(vif)->esr_active)
 		return;
 	if (le32_to_cpu(notif->action) == ESR_RECOMMEND_ENTER)
 	bool rfkill_safe_init_done = READ_ONCE(mvm->rfkill_safe_init_done);
 	bool unified = iwl_mvm_has_unified_ucode(mvm);
-	if (state) {
+	if (state)
 		set_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status);
-		wake_up(&mvm->rx_sync_waitq);
+	else
-	} else {
 		clear_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status);
-	}
 	iwl_mvm_set_rfkill_state(mvm);

drivers/net/wireless/intel/iwlwifi/mvm/rx.c+7−8

 };
 static void iwl_mvm_update_link_sig(struct ieee80211_vif *vif, int sig,
-				    struct iwl_mvm_vif_link_info *link_info)
+				    struct iwl_mvm_vif_link_info *link_info,
+				    struct ieee80211_bss_conf *bss_conf)
 {
 	struct iwl_mvm *mvm = iwl_mvm_vif_from_mac80211(vif)->mvm;
-	struct ieee80211_bss_conf *bss_conf =
-		iwl_mvm_rcu_fw_link_id_to_link_conf(mvm, link_info->fw_link_id,
-						    false);
 	int thold = bss_conf->cqm_rssi_thold;
 	int hyst = bss_conf->cqm_rssi_hyst;
 	int last_event;
 			mvmvif->deflink.beacon_stats.num_beacons;
 	/* This is used in pre-MLO API so use deflink */
-	iwl_mvm_update_link_sig(vif, sig, &mvmvif->deflink);
+	iwl_mvm_update_link_sig(vif, sig, &mvmvif->deflink, &vif->bss_conf);
 }
 static void iwl_mvm_stat_iterator_all_macs(void *_data, u8 *mac,
 	sig = -le32_to_cpu(mac_stats->beacon_filter_average_energy);
 	/* This is used in pre-MLO API so use deflink */
-	iwl_mvm_update_link_sig(vif, sig, &mvmvif->deflink);
+	iwl_mvm_update_link_sig(vif, sig, &mvmvif->deflink, &vif->bss_conf);
 }
 static inline void
 				mvmvif->link[link_id]->beacon_stats.num_beacons;
 		sig = -le32_to_cpu(link_stats->beacon_filter_average_energy);
-		iwl_mvm_update_link_sig(bss_conf->vif, sig, link_info);
+		iwl_mvm_update_link_sig(bss_conf->vif, sig, link_info,
+					bss_conf);
 		if (WARN_ONCE(mvmvif->id >= MAC_INDEX_AUX,
 			      "invalid mvmvif id: %d", mvmvif->id))
 	lockdep_assert_held(&mvm->mutex);
-	if (!bss_vif)
+	if (IS_ERR_OR_NULL(bss_vif))
 		return;
 	mvmvif = iwl_mvm_vif_from_mac80211(bss_vif);

drivers/net/wireless/microchip/wilc1000/hif.c+2−1

@@ -382,7 +382,8 @@ wilc_parse_join_bss_param(struct cfg80211_bss *bss, · 381 unmodified lines
382	struct ieee80211_p2p_noa_attr noa_attr;	382	struct ieee80211_p2p_noa_attr noa_attr;
383	const struct cfg80211_bss_ies *ies;	383	const struct cfg80211_bss_ies *ies;
384	struct wilc_join_bss_param *param;	384	struct wilc_join_bss_param *param;
385	u8 rates_len = 0, ies_len;	385	u8 rates_len = 0;
		386	int ies_len;
386	int ret;	387	int ret;
387		388
388	param = kzalloc(sizeof(*param), GFP_KERNEL);	389	param = kzalloc(sizeof(*param), GFP_KERNEL);

drivers/nvme/host/apple.c+1−0

@@ -1602,4 +1602,5 @@ static struct platform_driver apple_nvme_driver = { · 1601 unmodified lines
1602	module_platform_driver(apple_nvme_driver);	1602	module_platform_driver(apple_nvme_driver);
1603		1603
1604	MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>");	1604	MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>");
		1605	MODULE_DESCRIPTION("Apple ANS NVM Express device driver");
1605	MODULE_LICENSE("GPL");	1606	MODULE_LICENSE("GPL");

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

@@ -502,7 +502,7 @@ static inline bool nvme_ns_head_multipath(struct nvme_ns_head *head) · 501 unmodified lines
502	enum nvme_ns_features {	502	enum nvme_ns_features {
503	NVME_NS_EXT_LBAS = 1 << 0, /* support extended LBA format */	503	NVME_NS_EXT_LBAS = 1 << 0, /* support extended LBA format */
504	NVME_NS_METADATA_SUPPORTED = 1 << 1, /* support getting generated md */	504	NVME_NS_METADATA_SUPPORTED = 1 << 1, /* support getting generated md */
505	NVME_NS_DEAC, /* DEAC bit in Write Zeores supported */	505	NVME_NS_DEAC = 1 << 2, /* DEAC bit in Write Zeores supported */
506	};	506	};
507		507
508	struct nvme_ns {	508	struct nvme_ns {

drivers/nvme/target/configfs.c+31−10

@@ -410,7 +410,29 @@ static ssize_t nvmet_addr_tsas_show(struct config_item *item, · 409 unmodified lines
410	return sprintf(page, "%s\n", nvmet_addr_tsas_rdma[i].name);	410	return sprintf(page, "%s\n", nvmet_addr_tsas_rdma[i].name);
411	}	411	}
412	}	412	}
413	return sprintf(page, "reserved\n");	413	return sprintf(page, "\n");
		414	}
		415
		416	static u8 nvmet_addr_tsas_rdma_store(const char *page)
		417	{
		418	int i;
		419
		420	for (i = 0; i < ARRAY_SIZE(nvmet_addr_tsas_rdma); i++) {
		421	if (sysfs_streq(page, nvmet_addr_tsas_rdma[i].name))
		422	return nvmet_addr_tsas_rdma[i].type;
		423	}
		424	return NVMF_RDMA_QPTYPE_INVALID;
		425	}
		426
		427	static u8 nvmet_addr_tsas_tcp_store(const char *page)
		428	{
		429	int i;
		430
		431	for (i = 0; i < ARRAY_SIZE(nvmet_addr_tsas_tcp); i++) {
		432	if (sysfs_streq(page, nvmet_addr_tsas_tcp[i].name))
		433	return nvmet_addr_tsas_tcp[i].type;
		434	}
		435	return NVMF_TCP_SECTYPE_INVALID;
414	}	436	}
415		437
416	static ssize_t nvmet_addr_tsas_store(struct config_item *item,	438	static ssize_t nvmet_addr_tsas_store(struct config_item *item,
@@ -418,20 +440,19 @@ static ssize_t nvmet_addr_tsas_store(struct config_item *item, · 1 unmodified line
418	{	440	{
419	struct nvmet_port *port = to_nvmet_port(item);	441	struct nvmet_port *port = to_nvmet_port(item);
420	u8 treq = nvmet_port_disc_addr_treq_mask(port);	442	u8 treq = nvmet_port_disc_addr_treq_mask(port);
421	u8 sectype;	443	u8 sectype, qptype;
422	int i;
423		444
424	if (nvmet_is_port_enabled(port, __func__))	445	if (nvmet_is_port_enabled(port, __func__))
425	return -EACCES;	446	return -EACCES;
426		447
427	if (port->disc_addr.trtype != NVMF_TRTYPE_TCP)	448	if (port->disc_addr.trtype == NVMF_TRTYPE_RDMA) {
428	return -EINVAL;	449	qptype = nvmet_addr_tsas_rdma_store(page);
429		450	if (qptype == port->disc_addr.tsas.rdma.qptype)
430	for (i = 0; i < ARRAY_SIZE(nvmet_addr_tsas_tcp); i++) {	451	return count;
431	if (sysfs_streq(page, nvmet_addr_tsas_tcp[i].name)) {	452	} else if (port->disc_addr.trtype == NVMF_TRTYPE_TCP) {
432	sectype = nvmet_addr_tsas_tcp[i].type;	453	sectype = nvmet_addr_tsas_tcp_store(page);
		454	if (sectype != NVMF_TCP_SECTYPE_INVALID)
433	goto found;	455	goto found;
434	}
435	}	456	}
436		457
437	pr_err("Invalid value '%s' for tsas\n", page);	458	pr_err("Invalid value '%s' for tsas\n", page);

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

@@ -148,7 +148,7 @@ struct nvmet_fc_tgt_queue { · 147 unmodified lines
148	struct workqueue_struct *work_q;	148	struct workqueue_struct *work_q;
149	struct kref ref;	149	struct kref ref;
150	/* array of fcp_iods */	150	/* array of fcp_iods */
151	struct nvmet_fc_fcp_iod fod[] __counted_by(sqsize);	151	struct nvmet_fc_fcp_iod fod[] /* __counted_by(sqsize) */;
152	} __aligned(sizeof(unsigned long long));	152	} __aligned(sizeof(unsigned long long));
153		153
154	struct nvmet_fc_hostport {	154	struct nvmet_fc_hostport {

drivers/pci/msi/msi.c+8−2

 			       struct irq_affinity *affd)
 {
 	struct irq_affinity_desc *masks = NULL;
-	struct msi_desc *entry;
+	struct msi_desc *entry, desc;
 	int ret;
 	/* Reject multi-MSI early on irq domain enabled architectures */
 	/* All MSIs are unmasked by default; mask them all */
 	entry = msi_first_desc(&dev->dev, MSI_DESC_ALL);
 	pci_msi_mask(entry, msi_multi_mask(entry));
+	/*
+	 * Copy the MSI descriptor for the error path because
+	 * pci_msi_setup_msi_irqs() will free it for the hierarchical
+	 * interrupt domain case.
+	 */
+	memcpy(&desc, entry, sizeof(desc));
 	/* Configure MSI capability structure */
 	ret = pci_msi_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
 	goto unlock;
 err:
-	pci_msi_unmask(entry, msi_multi_mask(entry));
+	pci_msi_unmask(&desc, msi_multi_mask(&desc));
 	pci_free_msi_irqs(dev);
 fail:
 	dev->msi_enabled = 0;

drivers/platform/mellanox/nvsw-sn2201.c+4−1

 static int nvsw_sn2201_probe(struct platform_device *pdev)
 {
 	struct nvsw_sn2201 *nvsw_sn2201;
+	int ret;
 	nvsw_sn2201 = devm_kzalloc(&pdev->dev, sizeof(*nvsw_sn2201), GFP_KERNEL);
 	if (!nvsw_sn2201)
 	nvsw_sn2201->dev = &pdev->dev;
 	platform_set_drvdata(pdev, nvsw_sn2201);
-	platform_device_add_resources(pdev, nvsw_sn2201_lpc_io_resources,
+	ret = platform_device_add_resources(pdev, nvsw_sn2201_lpc_io_resources,
 				      ARRAY_SIZE(nvsw_sn2201_lpc_io_resources));
+	if (ret)
+		return ret;
 	nvsw_sn2201->main_mux_deferred_nr = NVSW_SN2201_MAIN_MUX_DEFER_NR;
 	nvsw_sn2201->main_mux_devs = nvsw_sn2201_main_mux_brdinfo;

drivers/platform/x86/amilo-rfkill.c+1−0

@@ -171,6 +171,7 @@ static void __exit amilo_rfkill_exit(void) · 170 unmodified lines
171	}	171	}
172		172
173	MODULE_AUTHOR("Ben Hutchings <ben@decadent.org.uk>");	173	MODULE_AUTHOR("Ben Hutchings <ben@decadent.org.uk>");
		174	MODULE_DESCRIPTION("Fujitsu-Siemens Amilo rfkill support");
174	MODULE_LICENSE("GPL");	175	MODULE_LICENSE("GPL");
175	MODULE_DEVICE_TABLE(dmi, amilo_rfkill_id_table);	176	MODULE_DEVICE_TABLE(dmi, amilo_rfkill_id_table);
176		177

drivers/platform/x86/firmware_attributes_class.c+1−0

@@ -49,4 +49,5 @@ int fw_attributes_class_put(void) · 48 unmodified lines
49	EXPORT_SYMBOL_GPL(fw_attributes_class_put);	49	EXPORT_SYMBOL_GPL(fw_attributes_class_put);
50		50
51	MODULE_AUTHOR("Mark Pearson <markpearson@lenovo.com>");	51	MODULE_AUTHOR("Mark Pearson <markpearson@lenovo.com>");
		52	MODULE_DESCRIPTION("Firmware attributes class helper module");
52	MODULE_LICENSE("GPL");	53	MODULE_LICENSE("GPL");

drivers/platform/x86/ibm_rtl.c+1−0

@@ -29,6 +29,7 @@ static bool debug; · 28 unmodified lines
29	module_param(debug, bool, 0644);	29	module_param(debug, bool, 0644);
30	MODULE_PARM_DESC(debug, "Show debug output");	30	MODULE_PARM_DESC(debug, "Show debug output");
31		31
		32	MODULE_DESCRIPTION("IBM Premium Real Time Mode (PRTM) driver");
32	MODULE_LICENSE("GPL");	33	MODULE_LICENSE("GPL");
33	MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");	34	MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");
34	MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>");	35	MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>");

drivers/platform/x86/intel/hid.c+1−0

@@ -38,6 +38,7 @@ MODULE_PARM_DESC(enable_sw_tablet_mode, · 37 unmodified lines
38	/* When NOT in tablet mode, VGBS returns with the flag 0x40 */	38	/* When NOT in tablet mode, VGBS returns with the flag 0x40 */
39	#define TABLET_MODE_FLAG BIT(6)	39	#define TABLET_MODE_FLAG BIT(6)
40		40
		41	MODULE_DESCRIPTION("Intel HID Event hotkey driver");
41	MODULE_LICENSE("GPL");	42	MODULE_LICENSE("GPL");
42	MODULE_AUTHOR("Alex Hung");	43	MODULE_AUTHOR("Alex Hung");
43		44

drivers/platform/x86/intel/pmc/pltdrv.c+1−0

@@ -86,4 +86,5 @@ static void __exit pmc_core_platform_exit(void) · 85 unmodified lines
86		86
87	module_init(pmc_core_platform_init);	87	module_init(pmc_core_platform_init);
88	module_exit(pmc_core_platform_exit);	88	module_exit(pmc_core_platform_exit);
		89	MODULE_DESCRIPTION("Intel PMC Core platform driver");
89	MODULE_LICENSE("GPL v2");	90	MODULE_LICENSE("GPL v2");

drivers/platform/x86/intel/rst.c+1−0

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	#include <linux/module.h>	7	#include <linux/module.h>
8	#include <linux/slab.h>	8	#include <linux/slab.h>
9		9
		10	MODULE_DESCRIPTION("Intel Rapid Start Technology Driver");
10	MODULE_LICENSE("GPL");	11	MODULE_LICENSE("GPL");
11		12
12	static ssize_t irst_show_wakeup_events(struct device *dev,	13	static ssize_t irst_show_wakeup_events(struct device *dev,

drivers/platform/x86/intel/smartconnect.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#include <linux/acpi.h>	6	#include <linux/acpi.h>
7	#include <linux/module.h>	7	#include <linux/module.h>
8		8
		9	MODULE_DESCRIPTION("Intel Smart Connect disabling driver");
9	MODULE_LICENSE("GPL");	10	MODULE_LICENSE("GPL");
10		11
11	static int smartconnect_acpi_init(struct acpi_device *acpi)	12	static int smartconnect_acpi_init(struct acpi_device *acpi)

drivers/platform/x86/intel/vbtn.c+1−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24		24
25	#define VGBS_TABLET_MODE_FLAGS (VGBS_TABLET_MODE_FLAG \| VGBS_TABLET_MODE_FLAG_ALT)	25	#define VGBS_TABLET_MODE_FLAGS (VGBS_TABLET_MODE_FLAG \| VGBS_TABLET_MODE_FLAG_ALT)
26		26
		27	MODULE_DESCRIPTION("Intel Virtual Button driver");
27	MODULE_LICENSE("GPL");	28	MODULE_LICENSE("GPL");
28	MODULE_AUTHOR("AceLan Kao");	29	MODULE_AUTHOR("AceLan Kao");
29		30

drivers/platform/x86/lg-laptop.c+34−55

 #define WMI_METHOD_WMBB "2B4F501A-BD3C-4394-8DCF-00A7D2BC8210"
 #define WMI_EVENT_GUID  WMI_EVENT_GUID0
-#define WMAB_METHOD     "\\XINI.WMAB"
-#define WMBB_METHOD     "\\XINI.WMBB"
 #define SB_GGOV_METHOD  "\\_SB.GGOV"
 #define GOV_TLED        0x2020008
 #define WM_GET          1
 static int battery_limit_use_wmbb;
 static struct led_classdev kbd_backlight;
-static enum led_brightness get_kbd_backlight_level(void);
+static enum led_brightness get_kbd_backlight_level(struct device *dev);
 static const struct key_entry wmi_keymap[] = {
 	{KE_KEY, 0x70, {KEY_F15} },	 /* LG control panel (F1) */
 					  * this key both sends an event and
 					  * changes backlight level.
 					  */
-	{KE_KEY, 0x80, {KEY_RFKILL} },
 	{KE_END, 0}
 };
 	return res;
 }
-static union acpi_object *lg_wmab(u32 method, u32 arg1, u32 arg2)
+static union acpi_object *lg_wmab(struct device *dev, u32 method, u32 arg1, u32 arg2)
 {
 	union acpi_object args[3];
 	acpi_status status;
-	acpi_handle handle;
 	struct acpi_object_list arg;
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	args[2].type = ACPI_TYPE_INTEGER;
 	args[2].integer.value = arg2;
-	status = acpi_get_handle(NULL, (acpi_string) WMAB_METHOD, &handle);
-	if (ACPI_FAILURE(status)) {
-		pr_err("Cannot get handle");
-		return NULL;
-	}
 	arg.count = 3;
 	arg.pointer = args;
-	status = acpi_evaluate_object(handle, NULL, &arg, &buffer);
+	status = acpi_evaluate_object(ACPI_HANDLE(dev), "WMAB", &arg, &buffer);
 	if (ACPI_FAILURE(status)) {
-		acpi_handle_err(handle, "WMAB: call failed.\n");
+		dev_err(dev, "WMAB: call failed.\n");
 		return NULL;
 	}
 	return buffer.pointer;
 }
-static union acpi_object *lg_wmbb(u32 method_id, u32 arg1, u32 arg2)
+static union acpi_object *lg_wmbb(struct device *dev, u32 method_id, u32 arg1, u32 arg2)
 {
 	union acpi_object args[3];
 	acpi_status status;
-	acpi_handle handle;
 	struct acpi_object_list arg;
 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 	u8 buf[32];
 	args[2].buffer.length = 32;
 	args[2].buffer.pointer = buf;
-	status = acpi_get_handle(NULL, (acpi_string)WMBB_METHOD, &handle);
-	if (ACPI_FAILURE(status)) {
-		pr_err("Cannot get handle");
-		return NULL;
-	}
 	arg.count = 3;
 	arg.pointer = args;
-	status = acpi_evaluate_object(handle, NULL, &arg, &buffer);
+	status = acpi_evaluate_object(ACPI_HANDLE(dev), "WMBB", &arg, &buffer);
 	if (ACPI_FAILURE(status)) {
-		acpi_handle_err(handle, "WMAB: call failed.\n");
+		dev_err(dev, "WMBB: call failed.\n");
 		return NULL;
 	}
 		if (eventcode == 0x10000000) {
 			led_classdev_notify_brightness_hw_changed(
-				&kbd_backlight, get_kbd_backlight_level());
+				&kbd_backlight, get_kbd_backlight_level(kbd_backlight.dev->parent));
 		} else {
 			key = sparse_keymap_entry_from_scancode(
 				wmi_input_dev, eventcode);
 static void acpi_notify(struct acpi_device *device, u32 event)
 {
-	struct key_entry *key;
 	acpi_handle_debug(device->handle, "notify: %d\n", event);
-	if (inited & INIT_SPARSE_KEYMAP) {
-		key = sparse_keymap_entry_from_scancode(wmi_input_dev, 0x80);
-		if (key && key->type == KE_KEY)
-			sparse_keymap_report_entry(wmi_input_dev, key, 1, true);
-	}
 }
 static ssize_t fan_mode_store(struct device *dev,
 	if (ret)
 		return ret;
-	r = lg_wmab(WM_FAN_MODE, WM_GET, 0);
+	r = lg_wmab(dev, WM_FAN_MODE, WM_GET, 0);
 	if (!r)
 		return -EIO;
 	m = r->integer.value;
 	kfree(r);
-	r = lg_wmab(WM_FAN_MODE, WM_SET, (m & 0xffffff0f) | (value << 4));
+	r = lg_wmab(dev, WM_FAN_MODE, WM_SET, (m & 0xffffff0f) | (value << 4));
 	kfree(r);
-	r = lg_wmab(WM_FAN_MODE, WM_SET, (m & 0xfffffff0) | value);
+	r = lg_wmab(dev, WM_FAN_MODE, WM_SET, (m & 0xfffffff0) | value);
 	kfree(r);
 	return count;
 	unsigned int status;
 	union acpi_object *r;
-	r = lg_wmab(WM_FAN_MODE, WM_GET, 0);
+	r = lg_wmab(dev, WM_FAN_MODE, WM_GET, 0);
 	if (!r)
 		return -EIO;
 	if (ret)
 		return ret;
-	r = lg_wmbb(WMBB_USB_CHARGE, WM_SET, value);
+	r = lg_wmbb(dev, WMBB_USB_CHARGE, WM_SET, value);
 	if (!r)
 		return -EIO;
 	unsigned int status;
 	union acpi_object *r;
-	r = lg_wmbb(WMBB_USB_CHARGE, WM_GET, 0);
+	r = lg_wmbb(dev, WMBB_USB_CHARGE, WM_GET, 0);
 	if (!r)
 		return -EIO;
 	if (ret)
 		return ret;
-	r = lg_wmab(WM_READER_MODE, WM_SET, value);
+	r = lg_wmab(dev, WM_READER_MODE, WM_SET, value);
 	if (!r)
 		return -EIO;
 	unsigned int status;
 	union acpi_object *r;
-	r = lg_wmab(WM_READER_MODE, WM_GET, 0);
+	r = lg_wmab(dev, WM_READER_MODE, WM_GET, 0);
 	if (!r)
 		return -EIO;
 	if (ret)
 		return ret;
-	r = lg_wmab(WM_FN_LOCK, WM_SET, value);
+	r = lg_wmab(dev, WM_FN_LOCK, WM_SET, value);
 	if (!r)
 		return -EIO;
 	unsigned int status;
 	union acpi_object *r;
-	r = lg_wmab(WM_FN_LOCK, WM_GET, 0);
+	r = lg_wmab(dev, WM_FN_LOCK, WM_GET, 0);
 	if (!r)
 		return -EIO;
 		union acpi_object *r;
 		if (battery_limit_use_wmbb)
-			r = lg_wmbb(WMBB_BATT_LIMIT, WM_SET, value);
+			r = lg_wmbb(&pf_device->dev, WMBB_BATT_LIMIT, WM_SET, value);
 		else
-			r = lg_wmab(WM_BATT_LIMIT, WM_SET, value);
+			r = lg_wmab(&pf_device->dev, WM_BATT_LIMIT, WM_SET, value);
 		if (!r)
 			return -EIO;
 	union acpi_object *r;
 	if (battery_limit_use_wmbb) {
-		r = lg_wmbb(WMBB_BATT_LIMIT, WM_GET, 0);
+		r = lg_wmbb(&pf_device->dev, WMBB_BATT_LIMIT, WM_GET, 0);
 		if (!r)
 			return -EIO;
 		status = r->buffer.pointer[0x10];
 	} else {
-		r = lg_wmab(WM_BATT_LIMIT, WM_GET, 0);
+		r = lg_wmab(&pf_device->dev, WM_BATT_LIMIT, WM_GET, 0);
 		if (!r)
 			return -EIO;
 {
 	union acpi_object *r;
-	r = lg_wmab(WM_TLED, WM_SET, brightness > LED_OFF);
+	r = lg_wmab(cdev->dev->parent, WM_TLED, WM_SET, brightness > LED_OFF);
 	kfree(r);
 }
 		val = 0;
 	if (brightness >= LED_FULL)
 		val = 0x24;
-	r = lg_wmab(WM_KEY_LIGHT, WM_SET, val);
+	r = lg_wmab(cdev->dev->parent, WM_KEY_LIGHT, WM_SET, val);
 	kfree(r);
 }
-static enum led_brightness get_kbd_backlight_level(void)
+static enum led_brightness get_kbd_backlight_level(struct device *dev)
 {
 	union acpi_object *r;
 	int val;
-	r = lg_wmab(WM_KEY_LIGHT, WM_GET, 0);
+	r = lg_wmab(dev, WM_KEY_LIGHT, WM_GET, 0);
 	if (!r)
 		return LED_OFF;
 static enum led_brightness kbd_backlight_get(struct led_classdev *cdev)
 {
-	return get_kbd_backlight_level();
+	return get_kbd_backlight_level(cdev->dev->parent);
 }
 static LED_DEVICE(kbd_backlight, 255, LED_BRIGHT_HW_CHANGED);
 static int acpi_add(struct acpi_device *device)
 {
+	struct platform_device_info pdev_info = {
+		.fwnode = acpi_fwnode_handle(device),
+		.name = PLATFORM_NAME,
+		.id = PLATFORM_DEVID_NONE,
+	};
 	int ret;
 	const char *product;
 	int year = 2017;
 	if (ret)
 		return ret;
-	pf_device = platform_device_register_simple(PLATFORM_NAME,
+	pf_device = platform_device_register_full(&pdev_info);
-						    PLATFORM_DEVID_NONE,
-						    NULL, 0);
 	if (IS_ERR(pf_device)) {
 		ret = PTR_ERR(pf_device);
 		pf_device = NULL;
 }
 static const struct acpi_device_id device_ids[] = {
-	{"LGEX0815", 0},
+	{"LGEX0820", 0},
 	{"", 0}
 };
 MODULE_DEVICE_TABLE(acpi, device_ids);

drivers/platform/x86/siemens/simatic-ipc-batt-apollolake.c+1−0

@@ -45,6 +45,7 @@ static struct platform_driver simatic_ipc_batt_driver = { · 44 unmodified lines
45		45
46	module_platform_driver(simatic_ipc_batt_driver);	46	module_platform_driver(simatic_ipc_batt_driver);
47		47
		48	MODULE_DESCRIPTION("CMOS Battery monitoring for Simatic IPCs based on Apollo Lake GPIO");
48	MODULE_LICENSE("GPL");	49	MODULE_LICENSE("GPL");
49	MODULE_ALIAS("platform:" KBUILD_MODNAME);	50	MODULE_ALIAS("platform:" KBUILD_MODNAME);
50	MODULE_SOFTDEP("pre: simatic-ipc-batt platform:apollolake-pinctrl");	51	MODULE_SOFTDEP("pre: simatic-ipc-batt platform:apollolake-pinctrl");

drivers/platform/x86/siemens/simatic-ipc-batt-elkhartlake.c+1−0

@@ -45,6 +45,7 @@ static struct platform_driver simatic_ipc_batt_driver = { · 44 unmodified lines
45		45
46	module_platform_driver(simatic_ipc_batt_driver);	46	module_platform_driver(simatic_ipc_batt_driver);
47		47
		48	MODULE_DESCRIPTION("CMOS Battery monitoring for Simatic IPCs based on Elkhart Lake GPIO");
48	MODULE_LICENSE("GPL");	49	MODULE_LICENSE("GPL");
49	MODULE_ALIAS("platform:" KBUILD_MODNAME);	50	MODULE_ALIAS("platform:" KBUILD_MODNAME);
50	MODULE_SOFTDEP("pre: simatic-ipc-batt platform:elkhartlake-pinctrl");	51	MODULE_SOFTDEP("pre: simatic-ipc-batt platform:elkhartlake-pinctrl");

drivers/platform/x86/siemens/simatic-ipc-batt-f7188x.c+1−0

@@ -81,6 +81,7 @@ static struct platform_driver simatic_ipc_batt_driver = { · 80 unmodified lines
81		81
82	module_platform_driver(simatic_ipc_batt_driver);	82	module_platform_driver(simatic_ipc_batt_driver);
83		83
		84	MODULE_DESCRIPTION("CMOS Battery monitoring for Simatic IPCs based on Nuvoton GPIO");
84	MODULE_LICENSE("GPL");	85	MODULE_LICENSE("GPL");
85	MODULE_ALIAS("platform:" KBUILD_MODNAME);	86	MODULE_ALIAS("platform:" KBUILD_MODNAME);
86	MODULE_SOFTDEP("pre: simatic-ipc-batt gpio_f7188x platform:elkhartlake-pinctrl platform:alderlake-pinctrl");	87	MODULE_SOFTDEP("pre: simatic-ipc-batt gpio_f7188x platform:elkhartlake-pinctrl platform:alderlake-pinctrl");

drivers/platform/x86/siemens/simatic-ipc-batt.c+1−0

@@ -247,6 +247,7 @@ static struct platform_driver simatic_ipc_batt_driver = { · 246 unmodified lines
247		247
248	module_platform_driver(simatic_ipc_batt_driver);	248	module_platform_driver(simatic_ipc_batt_driver);
249		249
		250	MODULE_DESCRIPTION("CMOS core battery driver for Siemens Simatic IPCs");
250	MODULE_LICENSE("GPL");	251	MODULE_LICENSE("GPL");
251	MODULE_ALIAS("platform:" KBUILD_MODNAME);	252	MODULE_ALIAS("platform:" KBUILD_MODNAME);
252	MODULE_AUTHOR("Henning Schild <henning.schild@siemens.com>");	253	MODULE_AUTHOR("Henning Schild <henning.schild@siemens.com>");

drivers/platform/x86/siemens/simatic-ipc.c+1−0

@@ -231,6 +231,7 @@ static void __exit simatic_ipc_exit_module(void) · 230 unmodified lines
231	module_init(simatic_ipc_init_module);	231	module_init(simatic_ipc_init_module);
232	module_exit(simatic_ipc_exit_module);	232	module_exit(simatic_ipc_exit_module);
233		233
		234	MODULE_DESCRIPTION("Siemens SIMATIC IPC platform driver");
234	MODULE_LICENSE("GPL v2");	235	MODULE_LICENSE("GPL v2");
235	MODULE_AUTHOR("Gerd Haeussler <gerd.haeussler.ext@siemens.com>");	236	MODULE_AUTHOR("Gerd Haeussler <gerd.haeussler.ext@siemens.com>");
236	MODULE_ALIAS("dmi::svnSIEMENSAG:");	237	MODULE_ALIAS("dmi::svnSIEMENSAG:");

drivers/platform/x86/toshiba_acpi.c+18−13

  */
 #define QUIRK_HCI_HOTKEY_QUICKSTART		BIT(1)
-static const struct dmi_system_id toshiba_dmi_quirks[] = {
+static const struct dmi_system_id toshiba_dmi_quirks[] __initconst = {
 	{
 	 /* Toshiba Portégé R700 */
 	 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
 	struct toshiba_acpi_dev *dev;
 	const char *hci_method;
 	u32 dummy;
-	const struct dmi_system_id *dmi_id;
-	long quirks = 0;
 	int ret = 0;
 	if (toshiba_acpi)
 	}
 #endif
-	dmi_id = dmi_first_match(toshiba_dmi_quirks);
-	if (dmi_id)
-		quirks = (long)dmi_id->driver_data;
-	if (turn_on_panel_on_resume == -1)
-		turn_on_panel_on_resume = !!(quirks & QUIRK_TURN_ON_PANEL_ON_RESUME);
-	if (hci_hotkey_quickstart == -1)
-		hci_hotkey_quickstart = !!(quirks & QUIRK_HCI_HOTKEY_QUICKSTART);
 	toshiba_wwan_available(dev);
 	if (dev->wwan_supported)
 		toshiba_acpi_setup_wwan_rfkill(dev);
 	.drv.pm	= &toshiba_acpi_pm,
 };
+static void __init toshiba_dmi_init(void)
+{
+	const struct dmi_system_id *dmi_id;
+	long quirks = 0;
+	dmi_id = dmi_first_match(toshiba_dmi_quirks);
+	if (dmi_id)
+		quirks = (long)dmi_id->driver_data;
+	if (turn_on_panel_on_resume == -1)
+		turn_on_panel_on_resume = !!(quirks & QUIRK_TURN_ON_PANEL_ON_RESUME);
+	if (hci_hotkey_quickstart == -1)
+		hci_hotkey_quickstart = !!(quirks & QUIRK_HCI_HOTKEY_QUICKSTART);
+}
 static int __init toshiba_acpi_init(void)
 {
 	int ret;
+	toshiba_dmi_init();
 	toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
 	if (!toshiba_proc_dir) {
 		pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");

drivers/platform/x86/uv_sysfs.c+1−0

@@ -929,4 +929,5 @@ module_init(uv_sysfs_init); · 928 unmodified lines
929	module_exit(uv_sysfs_exit);	929	module_exit(uv_sysfs_exit);
930		930
931	MODULE_AUTHOR("Hewlett Packard Enterprise");	931	MODULE_AUTHOR("Hewlett Packard Enterprise");
		932	MODULE_DESCRIPTION("Sysfs structure for HPE UV systems");
932	MODULE_LICENSE("GPL");	933	MODULE_LICENSE("GPL");

drivers/platform/x86/wireless-hotkey.c+3−0

 #include <linux/acpi.h>
 #include <acpi/acpi_bus.h>
+MODULE_DESCRIPTION("Airplane mode button for AMD, HP & Xiaomi laptops");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alex Hung");
 MODULE_ALIAS("acpi*:HPQ6001:*");
 MODULE_ALIAS("acpi*:WSTADEF:*");
 MODULE_ALIAS("acpi*:AMDI0051:*");
+MODULE_ALIAS("acpi*:LGEX0815:*");
 struct wl_button {
 	struct input_dev *input_dev;
 	{"HPQ6001", 0},
 	{"WSTADEF", 0},
 	{"AMDI0051", 0},
+	{"LGEX0815", 0},
 	{"", 0},
 };

drivers/platform/x86/xo1-rfkill.c+1−0

@@ -74,5 +74,6 @@ static struct platform_driver xo1_rfkill_driver = { · 73 unmodified lines
74	module_platform_driver(xo1_rfkill_driver);	74	module_platform_driver(xo1_rfkill_driver);
75		75
76	MODULE_AUTHOR("Daniel Drake <dsd@laptop.org>");	76	MODULE_AUTHOR("Daniel Drake <dsd@laptop.org>");
		77	MODULE_DESCRIPTION("OLPC XO-1 software RF kill switch");
77	MODULE_LICENSE("GPL");	78	MODULE_LICENSE("GPL");
78	MODULE_ALIAS("platform:xo1-rfkill");	79	MODULE_ALIAS("platform:xo1-rfkill");

drivers/reset/Kconfig+1−0

@@ -68,6 +68,7 @@ config RESET_BRCMSTB_RESCAL · 67 unmodified lines
68		68
69	config RESET_GPIO	69	config RESET_GPIO
70	tristate "GPIO reset controller"	70	tristate "GPIO reset controller"
		71	depends on GPIOLIB
71	help	72	help
72	This enables a generic reset controller for resets attached via	73	This enables a generic reset controller for resets attached via
73	GPIOs. Typically for OF platforms this driver expects "reset-gpios"	74	GPIOs. Typically for OF platforms this driver expects "reset-gpios"

drivers/reset/hisilicon/hi6220_reset.c+1−0

@@ -219,4 +219,5 @@ static int __init hi6220_reset_init(void) · 218 unmodified lines
219		219
220	postcore_initcall(hi6220_reset_init);	220	postcore_initcall(hi6220_reset_init);
221		221
		222	MODULE_DESCRIPTION("Hisilicon Hi6220 reset controller driver");
222	MODULE_LICENSE("GPL v2");	223	MODULE_LICENSE("GPL v2");

drivers/s390/block/dasd_eckd.c+2−2

@@ -4906,7 +4906,7 @@ dasd_eckd_free_cp(struct dasd_ccw_req cqr, struct request req) · 4905 unmodified lines
4906	ccw++;	4906	ccw++;
4907	if (dst) {	4907	if (dst) {
4908	if (ccw->flags & CCW_FLAG_IDA)	4908	if (ccw->flags & CCW_FLAG_IDA)
4909	cda = ((char *)dma32_to_virt(ccw->cda));	4909	cda = dma64_to_virt(((dma64_t )dma32_to_virt(ccw->cda)));
4910	else	4910	else
4911	cda = dma32_to_virt(ccw->cda);	4911	cda = dma32_to_virt(ccw->cda);
4912	if (dst != cda) {	4912	if (dst != cda) {
@@ -5525,7 +5525,7 @@ dasd_eckd_dump_ccw_range(struct dasd_device device, struct ccw1 from, · 612 unmodified lines
5525		5525
5526	/* get pointer to data (consider IDALs) */	5526	/* get pointer to data (consider IDALs) */
5527	if (from->flags & CCW_FLAG_IDA)	5527	if (from->flags & CCW_FLAG_IDA)
5528	datap = (char )((addr_t *)dma32_to_virt(from->cda));	5528	datap = dma64_to_virt(((dma64_t )dma32_to_virt(from->cda)));
5529	else	5529	else
5530	datap = dma32_to_virt(from->cda);	5530	datap = dma32_to_virt(from->cda);
5531		5531

drivers/s390/block/dasd_fba.c+1−1

@@ -585,7 +585,7 @@ dasd_fba_free_cp(struct dasd_ccw_req cqr, struct request req) · 584 unmodified lines
585	ccw++;	585	ccw++;
586	if (dst) {	586	if (dst) {
587	if (ccw->flags & CCW_FLAG_IDA)	587	if (ccw->flags & CCW_FLAG_IDA)
588	cda = ((char *)dma32_to_virt(ccw->cda));	588	cda = dma64_to_virt(((dma64_t )dma32_to_virt(ccw->cda)));
589	else	589	else
590	cda = dma32_to_virt(ccw->cda);	590	cda = dma32_to_virt(ccw->cda);
591	if (dst != cda) {	591	if (dst != cda) {

drivers/s390/char/sclp.c+1−0

@@ -1293,6 +1293,7 @@ sclp_init(void) · 1292 unmodified lines
1293	fail_unregister_reboot_notifier:	1293	fail_unregister_reboot_notifier:
1294	unregister_reboot_notifier(&sclp_reboot_notifier);	1294	unregister_reboot_notifier(&sclp_reboot_notifier);
1295	fail_init_state_uninitialized:	1295	fail_init_state_uninitialized:
		1296	list_del(&sclp_state_change_event.list);
1296	sclp_init_state = sclp_init_state_uninitialized;	1297	sclp_init_state = sclp_init_state_uninitialized;
1297	free_page((unsigned long) sclp_read_sccb);	1298	free_page((unsigned long) sclp_read_sccb);
1298	free_page((unsigned long) sclp_init_sccb);	1299	free_page((unsigned long) sclp_init_sccb);

drivers/s390/cio/vfio_ccw_cp.c+5−4

 			      struct channel_program *cp)
 {
 	struct ccwchain *iter;
-	u32 cda, ccw_head;
+	u32 offset, ccw_head;
 	list_for_each_entry(iter, &cp->ccwchain_list, next) {
 		ccw_head = iter->ch_iova;
 		if (is_cpa_within_range(ccw->cda, ccw_head, iter->ch_len)) {
-			cda = (u64)iter->ch_ccw + dma32_to_u32(ccw->cda) - ccw_head;
+			/* Calculate offset of TIC target */
-			ccw->cda = u32_to_dma32(cda);
+			offset = dma32_to_u32(ccw->cda) - ccw_head;
+			ccw->cda = virt_to_dma32((void *)iter->ch_ccw + offset);
 			return 0;
 		}
 	}
 	 * in the ioctl directly. Path status changes etc.
 	 */
 	list_for_each_entry(chain, &cp->ccwchain_list, next) {
-		ccw_head = (u32)(u64)chain->ch_ccw;
+		ccw_head = dma32_to_u32(virt_to_dma32(chain->ch_ccw));
 		/*
 		 * On successful execution, cpa points just beyond the end
 		 * of the chain.

drivers/s390/virtio/virtio_ccw.c+3−1

 	dma64_t *indicatorp = NULL;
 	int ret, i, queue_idx = 0;
 	struct ccw1 *ccw;
+	dma32_t indicatorp_dma = 0;
 	ccw = ccw_device_dma_zalloc(vcdev->cdev, sizeof(*ccw), NULL);
 	if (!ccw)
 	*/
 	indicatorp = ccw_device_dma_zalloc(vcdev->cdev,
 					   sizeof(*indicatorp),
-					   &ccw->cda);
+					   &indicatorp_dma);
 	if (!indicatorp)
 		goto out;
 	*indicatorp = indicators_dma(vcdev);
 			/* no error, just fall back to legacy interrupts */
 			vcdev->is_thinint = false;
 	}
+	ccw->cda = indicatorp_dma;
 	if (!vcdev->is_thinint) {
 		/* Register queue indicators with host. */
 		*indicators(vcdev) = 0;

drivers/scsi/libsas/sas_ata.c+3−3

@@ -610,15 +610,15 @@ int sas_ata_init(struct domain_device *found_dev) · 609 unmodified lines
610		610
611	rc = ata_sas_tport_add(ata_host->dev, ap);	611	rc = ata_sas_tport_add(ata_host->dev, ap);
612	if (rc)	612	if (rc)
613	goto destroy_port;	613	goto free_port;
614		614
615	found_dev->sata_dev.ata_host = ata_host;	615	found_dev->sata_dev.ata_host = ata_host;
616	found_dev->sata_dev.ap = ap;	616	found_dev->sata_dev.ap = ap;
617		617
618	return 0;	618	return 0;
619		619
620	destroy_port:	620	free_port:
621	kfree(ap);	621	ata_port_free(ap);
622	free_host:	622	free_host:
623	ata_host_put(ata_host);	623	ata_host_put(ata_host);
624	return rc;	624	return rc;

drivers/scsi/libsas/sas_discover.c+1−1

@@ -301,7 +301,7 @@ void sas_free_device(struct kref *kref) · 300 unmodified lines
301		301
302	if (dev_is_sata(dev) && dev->sata_dev.ap) {	302	if (dev_is_sata(dev) && dev->sata_dev.ap) {
303	ata_sas_tport_delete(dev->sata_dev.ap);	303	ata_sas_tport_delete(dev->sata_dev.ap);
304	kfree(dev->sata_dev.ap);	304	ata_port_free(dev->sata_dev.ap);
305	ata_host_put(dev->sata_dev.ata_host);	305	ata_host_put(dev->sata_dev.ata_host);
306	dev->sata_dev.ata_host = NULL;	306	dev->sata_dev.ata_host = NULL;
307	dev->sata_dev.ap = NULL;	307	dev->sata_dev.ap = NULL;

drivers/scsi/libsas/sas_internal.h+14−0

@@ -145,6 +145,20 @@ static inline void sas_fail_probe(struct domain_device dev, const char func, i · 144 unmodified lines
145	func, dev->parent ? "exp-attached" :	145	func, dev->parent ? "exp-attached" :
146	"direct-attached",	146	"direct-attached",
147	SAS_ADDR(dev->sas_addr), err);	147	SAS_ADDR(dev->sas_addr), err);
		148
		149	/*
		150	* If the device probe failed, the expander phy attached address
		151	* needs to be reset so that the phy will not be treated as flutter
		152	* in the next revalidation
		153	*/
		154	if (dev->parent && !dev_is_expander(dev->dev_type)) {
		155	struct sas_phy *phy = dev->phy;
		156	struct domain_device *parent = dev->parent;
		157	struct ex_phy *ex_phy = &parent->ex_dev.ex_phy[phy->number];
		158
		159	memset(ex_phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
		160	}
		161
148	sas_unregister_dev(dev->port, dev);	162	sas_unregister_dev(dev->port, dev);
149	}	163	}
150		164

drivers/scsi/scsi_debug.c+5−1

 static const int condition_met_result = SAM_STAT_CONDITION_MET;
 static struct dentry *sdebug_debugfs_root;
+static ASYNC_DOMAIN_EXCLUSIVE(sdebug_async_domain);
 static void sdebug_err_free(struct rcu_head *head)
 {
 	if (!targetip)
 		return -ENOMEM;
+	async_synchronize_full_domain(&sdebug_async_domain);
 	targetip->debugfs_entry = debugfs_create_dir(dev_name(&starget->dev),
 				sdebug_debugfs_root);
 	targetip = (struct sdebug_target_info *)starget->hostdata;
 	if (targetip) {
 		starget->hostdata = NULL;
-		async_schedule(sdebug_tartget_cleanup_async, targetip);
+		async_schedule_domain(sdebug_tartget_cleanup_async, targetip,
+				&sdebug_async_domain);
 	}
 }

drivers/soc/litex/Kconfig+1−1

@@ -7,7 +7,7 @@ config LITEX · 6 unmodified lines
7		7
8	config LITEX_SOC_CONTROLLER	8	config LITEX_SOC_CONTROLLER
9	tristate "Enable LiteX SoC Controller driver"	9	tristate "Enable LiteX SoC Controller driver"
10	depends on OF \|\| COMPILE_TEST	10	depends on OF
11	depends on HAS_IOMEM	11	depends on HAS_IOMEM
12	select LITEX	12	select LITEX
13	help	13	help

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

 	return NOTIFY_DONE;
 }
-#ifdef CONFIG_OF
 static const struct of_device_id litex_soc_ctrl_of_match[] = {
 	{.compatible = "litex,soc-controller"},
 	{},
 };
 MODULE_DEVICE_TABLE(of, litex_soc_ctrl_of_match);
-#endif /* CONFIG_OF */
 static int litex_soc_ctrl_probe(struct platform_device *pdev)
 {
 static struct platform_driver litex_soc_ctrl_driver = {
 	.driver = {
 		.name = "litex-soc-controller",
-		.of_match_table = of_match_ptr(litex_soc_ctrl_of_match)
+		.of_match_table = litex_soc_ctrl_of_match,
 	},
 	.probe = litex_soc_ctrl_probe,
 	.remove_new = litex_soc_ctrl_remove,

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c+2−2

@@ -707,7 +707,7 @@ int vchiq_initialise(struct vchiq_state state, struct vchiq_instance *instance · 706 unmodified lines
707	* block forever.	707	* block forever.
708	*/	708	*/
709	for (i = 0; i < VCHIQ_INIT_RETRIES; i++) {	709	for (i = 0; i < VCHIQ_INIT_RETRIES; i++) {
710	if (state)	710	if (vchiq_remote_initialised(state))
711	break;	711	break;
712	usleep_range(500, 600);	712	usleep_range(500, 600);
713	}	713	}
@@ -1202,7 +1202,7 @@ void vchiq_dump_platform_instances(struct vchiq_state state, struct seq_file f · 488 unmodified lines
1202	{	1202	{
1203	int i;	1203	int i;
1204		1204
1205	if (!state)	1205	if (!vchiq_remote_initialised(state))
1206	return;	1206	return;
1207		1207
1208	/*	1208	/*

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h+5−0

 	struct opaque_platform_state *platform_state;
 };
+static inline bool vchiq_remote_initialised(const struct vchiq_state *state)
+{
+	return state->remote && state->remote->initialised;
+}
 struct bulk_waiter {
 	struct vchiq_bulk *bulk;
 	struct completion event;

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_debugfs.c+1−1

@@ -138,7 +138,7 @@ void vchiq_debugfs_deinit(void) · 137 unmodified lines
138		138
139	#else /* CONFIG_DEBUG_FS */	139	#else /* CONFIG_DEBUG_FS */
140		140
141	void vchiq_debugfs_init(void)	141	void vchiq_debugfs_init(struct vchiq_state *state)
142	{	142	{
143	}	143	}
144		144

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c+6−1

 	dev_dbg(state->dev, "arm: vchiq open\n");
+	if (!vchiq_remote_initialised(state)) {
+		dev_dbg(state->dev, "arm: vchiq has no connection to VideoCore\n");
+		return -ENOTCONN;
+	}
 	instance = kzalloc(sizeof(*instance), GFP_KERNEL);
 	if (!instance)
 		return -ENOMEM;
 	dev_dbg(state->dev, "arm: instance=%p\n", instance);
-	if (!state) {
+	if (!vchiq_remote_initialised(state)) {
 		ret = -EPERM;
 		goto out;
 	}

drivers/tee/optee/ffa_abi.c+9−3

 					const struct ffa_ops *ops)
 {
 	const struct ffa_msg_ops *msg_ops = ops->msg_ops;
-	struct ffa_send_direct_data data = { OPTEE_FFA_GET_API_VERSION };
+	struct ffa_send_direct_data data = {
+		.data0 = OPTEE_FFA_GET_API_VERSION,
+	};
 	int rc;
 	msg_ops->mode_32bit_set(ffa_dev);
 		return false;
 	}
-	data = (struct ffa_send_direct_data){ OPTEE_FFA_GET_OS_VERSION };
+	data = (struct ffa_send_direct_data){
+		.data0 = OPTEE_FFA_GET_OS_VERSION,
+	};
 	rc = msg_ops->sync_send_receive(ffa_dev, &data);
 	if (rc) {
 		pr_err("Unexpected error %d\n", rc);
 				    unsigned int *rpc_param_count,
 				    unsigned int *max_notif_value)
 {
-	struct ffa_send_direct_data data = { OPTEE_FFA_EXCHANGE_CAPABILITIES };
+	struct ffa_send_direct_data data = {
+		.data0 = OPTEE_FFA_EXCHANGE_CAPABILITIES,
+	};
 	int rc;
 	rc = ops->msg_ops->sync_send_receive(ffa_dev, &data);

drivers/thermal/gov_step_wise.c+5−18

 		if (cur_state <= instance->lower)
 			return THERMAL_NO_TARGET;
-		return clamp(cur_state - 1, instance->lower, instance->upper);
+		/*
+		 * If 'throttle' is false, no mitigation is necessary, so
+		 * request the lower state for this instance.
+		 */
+		return instance->lower;
 	}
 	return instance->target;
 		if (instance->initialized && old_target == instance->target)
 			continue;
-		if (trip->type == THERMAL_TRIP_PASSIVE) {
-			/*
-			 * If the target state for this thermal instance
-			 * changes from THERMAL_NO_TARGET to something else,
-			 * ensure that the zone temperature will be updated
-			 * (assuming enabled passive cooling) until it becomes
-			 * THERMAL_NO_TARGET again, or the cooling device may
-			 * not be reset to its initial state.
-			 */
-			if (old_target == THERMAL_NO_TARGET &&
-			    instance->target != THERMAL_NO_TARGET)
-				tz->passive++;
-			else if (old_target != THERMAL_NO_TARGET &&
-				 instance->target == THERMAL_NO_TARGET)
-				tz->passive--;
-		}
 		instance->initialized = true;
 		mutex_lock(&instance->cdev->lock);

drivers/tty/mxser.c+1−1

@@ -288,7 +288,7 @@ struct mxser_board { · 287 unmodified lines
288	enum mxser_must_hwid must_hwid;	288	enum mxser_must_hwid must_hwid;
289	speed_t max_baud;	289	speed_t max_baud;
290		290
291	struct mxser_port ports[] __counted_by(nports);	291	struct mxser_port ports[] /* __counted_by(nports) */;
292	};	292	};
293		293
294	static DECLARE_BITMAP(mxser_boards, MXSER_BOARDS);	294	static DECLARE_BITMAP(mxser_boards, MXSER_BOARDS);

drivers/tty/serial/8250/8250_core.c+0−5

  */
 #include <linux/acpi.h>
-#include <linux/cleanup.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/ioport.h>
 #include <asm/irq.h>
-#include "../serial_base.h"	/* For serial_base_add_isa_preferred_console() */
 #include "8250.h"
 /*
 		port->irqflags |= irqflag;
 		if (serial8250_isa_config != NULL)
 			serial8250_isa_config(i, &up->port, &up->capabilities);
-		serial_base_add_isa_preferred_console(serial8250_reg.dev_name, i);
 	}
 }

drivers/tty/serial/8250/8250_omap.c+20−5

@@ -115,6 +115,10 @@ · 114 unmodified lines
115	/* RX FIFO occupancy indicator */	115	/* RX FIFO occupancy indicator */
116	#define UART_OMAP_RX_LVL 0x19	116	#define UART_OMAP_RX_LVL 0x19
117		117
		118	/* Timeout low and High */
		119	#define UART_OMAP_TO_L 0x26
		120	#define UART_OMAP_TO_H 0x27
		121
118	/*	122	/*
119	* Copy of the genpd flags for the console.	123	* Copy of the genpd flags for the console.
120	* Only used if console suspend is disabled	124	* Only used if console suspend is disabled
@@ -663,13 +667,24 @@ static irqreturn_t omap8250_irq(int irq, void *dev_id) · 542 unmodified lines
663		667
664	/*	668	/*
665	* On K3 SoCs, it is observed that RX TIMEOUT is signalled after	669	* On K3 SoCs, it is observed that RX TIMEOUT is signalled after
666	* FIFO has been drained, in which case a dummy read of RX FIFO	670	* FIFO has been drained or erroneously.
667	* is required to clear RX TIMEOUT condition.	671	* So apply solution of Errata i2310 as mentioned in
		672	* https://www.ti.com/lit/pdf/sprz536
668	*/	673	*/
669	if (priv->habit & UART_RX_TIMEOUT_QUIRK &&	674	if (priv->habit & UART_RX_TIMEOUT_QUIRK &&
670	(iir & UART_IIR_RX_TIMEOUT) == UART_IIR_RX_TIMEOUT &&	675	(iir & UART_IIR_RX_TIMEOUT) == UART_IIR_RX_TIMEOUT) {
671	serial_port_in(port, UART_OMAP_RX_LVL) == 0) {	676	unsigned char efr2, timeout_h, timeout_l;
672	serial_port_in(port, UART_RX);	677
		678	efr2 = serial_in(up, UART_OMAP_EFR2);
		679	timeout_h = serial_in(up, UART_OMAP_TO_H);
		680	timeout_l = serial_in(up, UART_OMAP_TO_L);
		681	serial_out(up, UART_OMAP_TO_H, 0xFF);
		682	serial_out(up, UART_OMAP_TO_L, 0xFF);
		683	serial_out(up, UART_OMAP_EFR2, UART_OMAP_EFR2_TIMEOUT_BEHAVE);
		684	serial_in(up, UART_IIR);
		685	serial_out(up, UART_OMAP_EFR2, efr2);
		686	serial_out(up, UART_OMAP_TO_H, timeout_h);
		687	serial_out(up, UART_OMAP_TO_L, timeout_l);
673	}	688	}
674		689
675	/* Stop processing interrupts on input overrun */	690	/* Stop processing interrupts on input overrun */

drivers/tty/serial/8250/8250_pci.c+12−1

 	MOXA_SUPP_RS485 = BIT(2),
 };
+static unsigned short moxa_get_nports(unsigned short device)
+{
+	switch (device) {
+	case PCI_DEVICE_ID_MOXA_CP116E_A_A:
+	case PCI_DEVICE_ID_MOXA_CP116E_A_B:
+		return 8;
+	}
+	return FIELD_GET(0x00F0, device);
+}
 static bool pci_moxa_is_mini_pcie(unsigned short device)
 {
 	if (device == PCI_DEVICE_ID_MOXA_CP102N	||
 {
 	unsigned short device = dev->device;
 	resource_size_t iobar_addr = pci_resource_start(dev, 2);
-	unsigned int num_ports = (device & 0x00F0) >> 4, i;
+	unsigned int i, num_ports = moxa_get_nports(device);
 	u8 val, init_mode = MOXA_RS232;
 	if (!(pci_moxa_supported_rs(dev) & MOXA_SUPP_RS232)) {

drivers/tty/serial/bcm63xx_uart.c+5−2

@@ -308,8 +308,8 @@ static void bcm_uart_do_tx(struct uart_port *port) · 307 unmodified lines
308		308
309	val = bcm_uart_readl(port, UART_MCTL_REG);	309	val = bcm_uart_readl(port, UART_MCTL_REG);
310	val = (val & UART_MCTL_TXFIFOFILL_MASK) >> UART_MCTL_TXFIFOFILL_SHIFT;	310	val = (val & UART_MCTL_TXFIFOFILL_MASK) >> UART_MCTL_TXFIFOFILL_SHIFT;
311		311	pending = uart_port_tx_limited_flags(port, ch, UART_TX_NOSTOP,
312	pending = uart_port_tx_limited(port, ch, port->fifosize - val,	312	port->fifosize - val,
313	true,	313	true,
314	bcm_uart_writel(port, ch, UART_FIFO_REG),	314	bcm_uart_writel(port, ch, UART_FIFO_REG),
315	({}));	315	({}));
@@ -320,6 +320,9 @@ static void bcm_uart_do_tx(struct uart_port *port) · 4 unmodified lines
320	val = bcm_uart_readl(port, UART_IR_REG);	320	val = bcm_uart_readl(port, UART_IR_REG);
321	val &= ~UART_TX_INT_MASK;	321	val &= ~UART_TX_INT_MASK;
322	bcm_uart_writel(port, val, UART_IR_REG);	322	bcm_uart_writel(port, val, UART_IR_REG);
		323
		324	if (uart_tx_stopped(port))
		325	bcm_uart_stop_tx(port);
323	}	326	}
324		327
325	/*	328	/*

drivers/tty/serial/imx.c+3−1

 	/* Make sure Rx is enabled in case Tx is active with Rx disabled */
 	if (!(rs485conf->flags & SER_RS485_ENABLED) ||
-	    rs485conf->flags & SER_RS485_RX_DURING_TX)
+	    rs485conf->flags & SER_RS485_RX_DURING_TX) {
+		imx_uart_setup_ufcr(sport, TXTL_DEFAULT, RXTL_DEFAULT);
 		imx_uart_start_rx(port);
+	}
 	return 0;
 }

drivers/tty/serial/mcf.c+1−1

@@ -462,7 +462,7 @@ static const struct uart_ops mcf_uart_ops = { · 461 unmodified lines
462	.verify_port = mcf_verify_port,	462	.verify_port = mcf_verify_port,
463	};	463	};
464		464
465	static struct mcf_uart mcf_ports[4];	465	static struct mcf_uart mcf_ports[10];
466		466
467	#define MCF_MAXPORTS ARRAY_SIZE(mcf_ports)	467	#define MCF_MAXPORTS ARRAY_SIZE(mcf_ports)
468		468

drivers/tty/serial/serial_base.h+0−30

@@ -49,33 +49,3 @@ void serial_ctrl_unregister_port(struct uart_driver drv, struct uart_port port · 48 unmodified lines
49		49
50	int serial_core_register_port(struct uart_driver drv, struct uart_port port);	50	int serial_core_register_port(struct uart_driver drv, struct uart_port port);
51	void serial_core_unregister_port(struct uart_driver drv, struct uart_port port);	51	void serial_core_unregister_port(struct uart_driver drv, struct uart_port port);
52
53	#ifdef CONFIG_SERIAL_CORE_CONSOLE
54
55	int serial_base_add_preferred_console(struct uart_driver *drv,
56	struct uart_port *port);
57
58	#else
59
60	static inline
61	int serial_base_add_preferred_console(struct uart_driver *drv,
62	struct uart_port *port)
63	{
64	return 0;
65	}
66
67	#endif
68
69	#ifdef CONFIG_SERIAL_8250_CONSOLE
70
71	int serial_base_add_isa_preferred_console(const char *name, int idx);
72
73	#else
74
75	static inline
76	int serial_base_add_isa_preferred_console(const char *name, int idx)
77	{
78	return 0;
79	}
80
81	#endif

drivers/tty/serial/serial_base_bus.c+0−129

@@ -8,7 +8,6 @@ · 7 unmodified lines
8	* The serial core bus manages the serial core controller instances.	8	* The serial core bus manages the serial core controller instances.
9	*/	9	*/
10		10
11	#include <linux/cleanup.h>
12	#include <linux/container_of.h>	11	#include <linux/container_of.h>
13	#include <linux/device.h>	12	#include <linux/device.h>
14	#include <linux/idr.h>	13	#include <linux/idr.h>
@@ -205,134 +204,6 @@ void serial_base_port_device_remove(struct serial_port_device *port_dev) · 190 unmodified lines
205	put_device(&port_dev->dev);	204	put_device(&port_dev->dev);
206	}	205	}
207		206
208	#ifdef CONFIG_SERIAL_CORE_CONSOLE
209
210	static int serial_base_add_one_prefcon(const char match, const char dev_name,
211	int port_id)
212	{
213	int ret;
214
215	ret = add_preferred_console_match(match, dev_name, port_id);
216	if (ret == -ENOENT)
217	return 0;
218
219	return ret;
220	}
221
222	#ifdef __sparc__
223
224	/* Handle Sparc ttya and ttyb options as done in console_setup() */
225	static int serial_base_add_sparc_console(const char *dev_name, int idx)
226	{
227	const char *name;
228
229	switch (idx) {
230	case 0:
231	name = "ttya";
232	break;
233	case 1:
234	name = "ttyb";
235	break;
236	default:
237	return 0;
238	}
239
240	return serial_base_add_one_prefcon(name, dev_name, idx);
241	}
242
243	#else
244
245	static inline int serial_base_add_sparc_console(const char *dev_name, int idx)
246	{
247	return 0;
248	}
249
250	#endif
251
252	static int serial_base_add_prefcon(const char *name, int idx)
253	{
254	const char *char_match __free(kfree) = NULL;
255	const char *nmbr_match __free(kfree) = NULL;
256	int ret;
257
258	/* Handle ttyS specific options */
259	if (strstarts(name, "ttyS")) {
260	/* No name, just a number */
261	nmbr_match = kasprintf(GFP_KERNEL, "%i", idx);
262	if (!nmbr_match)
263	return -ENODEV;
264
265	ret = serial_base_add_one_prefcon(nmbr_match, name, idx);
266	if (ret)
267	return ret;
268
269	/* Sparc ttya and ttyb */
270	ret = serial_base_add_sparc_console(name, idx);
271	if (ret)
272	return ret;
273	}
274
275	/* Handle the traditional character device name style console=ttyS0 */
276	char_match = kasprintf(GFP_KERNEL, "%s%i", name, idx);
277	if (!char_match)
278	return -ENOMEM;
279
280	return serial_base_add_one_prefcon(char_match, name, idx);
281	}
282
283	/**
284	* serial_base_add_preferred_console - Adds a preferred console
285	* @drv: Serial port device driver
286	* @port: Serial port instance
287	*
288	* Tries to add a preferred console for a serial port if specified in the
289	* kernel command line. Supports both the traditional character device such
290	* as console=ttyS0, and a hardware addressing based console=DEVNAME:0.0
291	* style name.
292	*
293	* Translates the kernel command line option using a hardware based addressing
294	* console=DEVNAME:0.0 to the serial port character device such as ttyS0.
295	* Cannot be called early for ISA ports, depends on struct device.
296	*
297	* Note that duplicates are ignored by add_preferred_console().
298	*
299	* Return: 0 on success, negative error code on failure.
300	*/
301	int serial_base_add_preferred_console(struct uart_driver *drv,
302	struct uart_port *port)
303	{
304	const char *port_match __free(kfree) = NULL;
305	int ret;
306
307	ret = serial_base_add_prefcon(drv->dev_name, port->line);
308	if (ret)
309	return ret;
310
311	port_match = kasprintf(GFP_KERNEL, "%s:%i.%i", dev_name(port->dev),
312	port->ctrl_id, port->port_id);
313	if (!port_match)
314	return -ENOMEM;
315
316	/* Translate a hardware addressing style console=DEVNAME:0.0 */
317	return serial_base_add_one_prefcon(port_match, drv->dev_name, port->line);
318	}
319
320	#endif
321
322	#ifdef CONFIG_SERIAL_8250_CONSOLE
323
324	/*
325	* Early ISA ports initialize the console before there is no struct device.
326	* This should be only called from serial8250_isa_init_preferred_console(),
327	* other callers are likely wrong and should rely on earlycon instead.
328	*/
329	int serial_base_add_isa_preferred_console(const char *name, int idx)
330	{
331	return serial_base_add_prefcon(name, idx);
332	}
333
334	#endif
335
336	static int serial_base_init(void)	207	static int serial_base_init(void)
337	{	208	{
338	int ret;	209	int ret;

drivers/tty/serial/serial_core.c+0−4

 	if (ret)
 		goto err_unregister_ctrl_dev;
-	ret = serial_base_add_preferred_console(drv, port);
-	if (ret)
-		goto err_unregister_port_dev;
 	ret = serial_core_add_one_port(drv, port);
 	if (ret)
 		goto err_unregister_port_dev;

drivers/usb/atm/cxacru.c+14−0

@@ -1131,6 +1131,7 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance, · 1130 unmodified lines
1131	struct cxacru_data *instance;	1131	struct cxacru_data *instance;
1132	struct usb_device *usb_dev = interface_to_usbdev(intf);	1132	struct usb_device *usb_dev = interface_to_usbdev(intf);
1133	struct usb_host_endpoint *cmd_ep = usb_dev->ep_in[CXACRU_EP_CMD];	1133	struct usb_host_endpoint *cmd_ep = usb_dev->ep_in[CXACRU_EP_CMD];
		1134	struct usb_endpoint_descriptor in, out;
1134	int ret;	1135	int ret;
1135		1136
1136	/* instance init */	1137	/* instance init */
@@ -1177,6 +1178,19 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance, · 40 unmodified lines
1177	goto fail;	1178	goto fail;
1178	}	1179	}
1179		1180
		1181	if (usb_endpoint_xfer_int(&cmd_ep->desc))
		1182	ret = usb_find_common_endpoints(intf->cur_altsetting,
		1183	NULL, NULL, &in, &out);
		1184	else
		1185	ret = usb_find_common_endpoints(intf->cur_altsetting,
		1186	&in, &out, NULL, NULL);
		1187
		1188	if (ret) {
		1189	usb_err(usbatm_instance, "cxacru_bind: interface has incorrect endpoints\n");
		1190	ret = -ENODEV;
		1191	goto fail;
		1192	}
		1193
1180	if ((cmd_ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)	1194	if ((cmd_ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1181	== USB_ENDPOINT_XFER_INT) {	1195	== USB_ENDPOINT_XFER_INT) {
1182	usb_fill_int_urb(instance->rcv_urb,	1196	usb_fill_int_urb(instance->rcv_urb,

drivers/usb/dwc3/core.c+19−7

 static void dwc3_core_setup_global_control(struct dwc3 *dwc)
 {
+	unsigned int power_opt;
+	unsigned int hw_mode;
 	u32 reg;
 	reg = dwc3_readl(dwc->regs, DWC3_GCTL);
 	reg &= ~DWC3_GCTL_SCALEDOWN_MASK;
+	hw_mode = DWC3_GHWPARAMS0_MODE(dwc->hwparams.hwparams0);
+	power_opt = DWC3_GHWPARAMS1_EN_PWROPT(dwc->hwparams.hwparams1);
-	switch (DWC3_GHWPARAMS1_EN_PWROPT(dwc->hwparams.hwparams1)) {
+	switch (power_opt) {
 	case DWC3_GHWPARAMS1_EN_PWROPT_CLK:
 		/**
 		 * WORKAROUND: DWC3 revisions between 2.10a and 2.50a have an
 		break;
 	}
+	/*
+	 * This is a workaround for STAR#4846132, which only affects
+	 * DWC_usb31 version2.00a operating in host mode.
+	 *
+	 * There is a problem in DWC_usb31 version 2.00a operating
+	 * in host mode that would cause a CSR read timeout When CSR
+	 * read coincides with RAM Clock Gating Entry. By disable
+	 * Clock Gating, sacrificing power consumption for normal
+	 * operation.
+	 */
+	if (power_opt != DWC3_GHWPARAMS1_EN_PWROPT_NO &&
+	    hw_mode != DWC3_GHWPARAMS0_MODE_GADGET && DWC3_VER_IS(DWC31, 200A))
+		reg |= DWC3_GCTL_DSBLCLKGTNG;
 	/* check if current dwc3 is on simulation board */
 	if (dwc->hwparams.hwparams6 & DWC3_GHWPARAMS6_EN_FPGA) {
 		dev_info(dwc->dev, "Running with FPGA optimizations\n");
 static int dwc3_suspend_common(struct dwc3 *dwc, pm_message_t msg)
 {
-	unsigned long	flags;
 	u32 reg;
 	int i;
 			break;
 		if (dwc->current_otg_role == DWC3_OTG_ROLE_DEVICE) {
-			spin_lock_irqsave(&dwc->lock, flags);
 			dwc3_gadget_suspend(dwc);
-			spin_unlock_irqrestore(&dwc->lock, flags);
 			synchronize_irq(dwc->irq_gadget);
 		}
 static int dwc3_resume_common(struct dwc3 *dwc, pm_message_t msg)
 {
-	unsigned long	flags;
 	int		ret;
 	u32		reg;
 	int		i;
 		if (dwc->current_otg_role == DWC3_OTG_ROLE_HOST) {
 			dwc3_otg_host_init(dwc);
 		} else if (dwc->current_otg_role == DWC3_OTG_ROLE_DEVICE) {
-			spin_lock_irqsave(&dwc->lock, flags);
 			dwc3_gadget_resume(dwc);
-			spin_unlock_irqrestore(&dwc->lock, flags);
 		}
 		break;

drivers/usb/gadget/function/f_printer.c+30−10

 					struct usb_endpoint_descriptor *ss)
 {
 	switch (gadget->speed) {
+	case USB_SPEED_SUPER_PLUS:
 	case USB_SPEED_SUPER:
 		return ss;
 	case USB_SPEED_HIGH:
 	mutex_lock(&dev->lock_printer_io);
 	spin_lock_irqsave(&dev->lock, flags);
-	if (dev->interface < 0) {
+	if (dev->interface < 0)
-		spin_unlock_irqrestore(&dev->lock, flags);
+		goto out_disabled;
-		mutex_unlock(&dev->lock_printer_io);
-		return -ENODEV;
-	}
 	/* We will use this flag later to check if a printer reset happened
 	 * after we turn interrupts back on.
 	dev->reset_printer = 0;
 	setup_rx_reqs(dev);
+	/* this dropped the lock - need to retest */
+	if (dev->interface < 0)
+		goto out_disabled;
 	bytes_copied = 0;
 	current_rx_req = dev->current_rx_req;
 		wait_event_interruptible(dev->rx_wait,
 				(likely(!list_empty(&dev->rx_buffers))));
 		spin_lock_irqsave(&dev->lock, flags);
+		if (dev->interface < 0)
+			goto out_disabled;
 	}
 	/* We have data to return then copy it to the caller's buffer.*/
 			return -EAGAIN;
 		}
+		if (dev->interface < 0)
+			goto out_disabled;
 		/* If we not returning all the data left in this RX request
 		 * buffer then adjust the amount of data left in the buffer.
 		 * Othewise if we are done with this RX request buffer then
 		return bytes_copied;
 	else
 		return -EAGAIN;
+out_disabled:
+	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock_printer_io);
+	return -ENODEV;
 }
 static ssize_t
 	mutex_lock(&dev->lock_printer_io);
 	spin_lock_irqsave(&dev->lock, flags);
-	if (dev->interface < 0) {
+	if (dev->interface < 0)
-		spin_unlock_irqrestore(&dev->lock, flags);
+		goto out_disabled;
-		mutex_unlock(&dev->lock_printer_io);
-		return -ENODEV;
-	}
 	/* Check if a printer reset happens while we have interrupts on */
 	dev->reset_printer = 0;
 		wait_event_interruptible(dev->tx_wait,
 				(likely(!list_empty(&dev->tx_reqs))));
 		spin_lock_irqsave(&dev->lock, flags);
+		if (dev->interface < 0)
+			goto out_disabled;
 	}
 	while (likely(!list_empty(&dev->tx_reqs)) && len) {
 			return -EAGAIN;
 		}
+		if (dev->interface < 0)
+			goto out_disabled;
 		list_add(&req->list, &dev->tx_reqs_active);
 		/* here, we unlock, and only unlock, to avoid deadlock. */
 			mutex_unlock(&dev->lock_printer_io);
 			return -EAGAIN;
 		}
+		if (dev->interface < 0)
+			goto out_disabled;
 	}
 	spin_unlock_irqrestore(&dev->lock, flags);
 		return bytes_copied;
 	else
 		return -EAGAIN;
+out_disabled:
+	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock_printer_io);
+	return -ENODEV;
 }
 static int

drivers/usb/gadget/function/u_ether.c+1−3

 		if (netif_running(dev->net))
 			eth_start(dev, GFP_ATOMIC);
-		netif_device_attach(dev->net);
 	/* on error, disable any endpoints  */
 	} else {
 		(void) usb_ep_disable(link->out_ep);
 	DBG(dev, "%s\n", __func__);
-	netif_device_detach(dev->net);
+	netif_stop_queue(dev->net);
 	netif_carrier_off(dev->net);
 	/* disable endpoints, forcing (synchronous) completion

drivers/usb/gadget/udc/aspeed_udc.c+2−2

@@ -66,8 +66,8 @@ · 65 unmodified lines
66	#define USB_UPSTREAM_EN BIT(0)	66	#define USB_UPSTREAM_EN BIT(0)
67		67
68	/* Main config reg */	68	/* Main config reg */
69	#define UDC_CFG_SET_ADDR(x) ((x) & 0x3f)	69	#define UDC_CFG_SET_ADDR(x) ((x) & UDC_CFG_ADDR_MASK)
70	#define UDC_CFG_ADDR_MASK (0x3f)	70	#define UDC_CFG_ADDR_MASK GENMASK(6, 0)
71		71
72	/* Interrupt ctrl & status reg */	72	/* Interrupt ctrl & status reg */
73	#define UDC_IRQ_EP_POOL_NAK BIT(17)	73	#define UDC_IRQ_EP_POOL_NAK BIT(17)

drivers/usb/musb/da8xx.c+6−2

 	ret = of_platform_populate(pdev->dev.of_node, NULL,
 				   da8xx_auxdata_lookup, &pdev->dev);
 	if (ret)
-		return ret;
+		goto err_unregister_phy;
 	pinfo = da8xx_dev_info;
 	pinfo.parent = &pdev->dev;
 	ret = PTR_ERR_OR_ZERO(glue->musb);
 	if (ret) {
 		dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
-		usb_phy_generic_unregister(glue->usb_phy);
+		goto err_unregister_phy;
 	}
+	return 0;
+err_unregister_phy:
+	usb_phy_generic_unregister(glue->usb_phy);
 	return ret;
 }

drivers/usb/typec/ucsi/ucsi_acpi.c+61−0

@@ -25,6 +25,7 @@ struct ucsi_acpi { · 24 unmodified lines
25	unsigned long flags;	25	unsigned long flags;
26	#define UCSI_ACPI_COMMAND_PENDING 1	26	#define UCSI_ACPI_COMMAND_PENDING 1
27	#define UCSI_ACPI_ACK_PENDING 2	27	#define UCSI_ACPI_ACK_PENDING 2
		28	#define UCSI_ACPI_CHECK_BOGUS_EVENT 3
28	guid_t guid;	29	guid_t guid;
29	u64 cmd;	30	u64 cmd;
30	};	31	};
@@ -128,6 +129,58 @@ static const struct ucsi_operations ucsi_zenbook_ops = { · 97 unmodified lines
128	.async_write = ucsi_acpi_async_write	129	.async_write = ucsi_acpi_async_write
129	};	130	};
130		131
		132	static int ucsi_gram_read(struct ucsi *ucsi, unsigned int offset,
		133	void *val, size_t val_len)
		134	{
		135	u16 bogus_change = UCSI_CONSTAT_POWER_LEVEL_CHANGE \|
		136	UCSI_CONSTAT_PDOS_CHANGE;
		137	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
		138	struct ucsi_connector_status *status;
		139	int ret;
		140
		141	ret = ucsi_acpi_read(ucsi, offset, val, val_len);
		142	if (ret < 0)
		143	return ret;
		144
		145	if (UCSI_COMMAND(ua->cmd) == UCSI_GET_CONNECTOR_STATUS &&
		146	test_bit(UCSI_ACPI_CHECK_BOGUS_EVENT, &ua->flags) &&
		147	offset == UCSI_MESSAGE_IN) {
		148	status = (struct ucsi_connector_status *)val;
		149
		150	/* Clear the bogus change */
		151	if (status->change == bogus_change)
		152	status->change = 0;
		153
		154	clear_bit(UCSI_ACPI_CHECK_BOGUS_EVENT, &ua->flags);
		155	}
		156
		157	return ret;
		158	}
		159
		160	static int ucsi_gram_sync_write(struct ucsi *ucsi, unsigned int offset,
		161	const void *val, size_t val_len)
		162	{
		163	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
		164	int ret;
		165
		166	ret = ucsi_acpi_sync_write(ucsi, offset, val, val_len);
		167	if (ret < 0)
		168	return ret;
		169
		170	if (UCSI_COMMAND(ua->cmd) == UCSI_GET_PDOS &&
		171	ua->cmd & UCSI_GET_PDOS_PARTNER_PDO(1) &&
		172	ua->cmd & UCSI_GET_PDOS_SRC_PDOS)
		173	set_bit(UCSI_ACPI_CHECK_BOGUS_EVENT, &ua->flags);
		174
		175	return ret;
		176	}
		177
		178	static const struct ucsi_operations ucsi_gram_ops = {
		179	.read = ucsi_gram_read,
		180	.sync_write = ucsi_gram_sync_write,
		181	.async_write = ucsi_acpi_async_write
		182	};
		183
131	static const struct dmi_system_id ucsi_acpi_quirks[] = {	184	static const struct dmi_system_id ucsi_acpi_quirks[] = {
132	{	185	{
133	.matches = {	186	.matches = {
@@ -136,6 +189,14 @@ static const struct dmi_system_id ucsi_acpi_quirks[] = { · 2 unmodified lines
136	},	189	},
137	.driver_data = (void *)&ucsi_zenbook_ops,	190	.driver_data = (void *)&ucsi_zenbook_ops,
138	},	191	},
		192	{
		193	.matches = {
		194	DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
		195	DMI_MATCH(DMI_PRODUCT_FAMILY, "LG gram PC"),
		196	DMI_MATCH(DMI_PRODUCT_NAME, "90Q"),
		197	},
		198	.driver_data = (void *)&ucsi_gram_ops,
		199	},
139	{ }	200	{ }
140	};	201	};
141		202

drivers/usb/typec/ucsi/ucsi_glink.c+4−1

 		ret = fwnode_property_read_u32(fwnode, "reg", &port);
 		if (ret < 0) {
 			dev_err(dev, "missing reg property of %pOFn\n", fwnode);
+			fwnode_handle_put(fwnode);
 			return ret;
 		}
 		if (!desc)
 			continue;
-		if (IS_ERR(desc))
+		if (IS_ERR(desc)) {
+			fwnode_handle_put(fwnode);
 			return dev_err_probe(dev, PTR_ERR(desc),
 					     "unable to acquire orientation gpio\n");
+		}
 		ucsi->port_orientation[port] = desc;
 	}

drivers/usb/typec/ucsi/ucsi_stm32g0.c+15−4

 	struct device *dev;
 	unsigned long flags;
 #define COMMAND_PENDING	1
+#define ACK_PENDING	2
 	const char *fw_name;
 	struct ucsi *ucsi;
 	bool suspended;
 				   size_t len)
 {
 	struct ucsi_stm32g0 *g0 = ucsi_get_drvdata(ucsi);
+	bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI;
 	int ret;
-	set_bit(COMMAND_PENDING, &g0->flags);
+	if (ack)
+		set_bit(ACK_PENDING, &g0->flags);
+	else
+		set_bit(COMMAND_PENDING, &g0->flags);
 	ret = ucsi_stm32g0_async_write(ucsi, offset, val, len);
 	if (ret)
 	if (!wait_for_completion_timeout(&g0->complete, msecs_to_jiffies(5000)))
 		ret = -ETIMEDOUT;
+	else
+		return 0;
 out_clear_bit:
-	clear_bit(COMMAND_PENDING, &g0->flags);
+	if (ack)
+		clear_bit(ACK_PENDING, &g0->flags);
+	else
+		clear_bit(COMMAND_PENDING, &g0->flags);
 	return ret;
 }
 	if (UCSI_CCI_CONNECTOR(cci))
 		ucsi_connector_change(g0->ucsi, UCSI_CCI_CONNECTOR(cci));
-	if (test_bit(COMMAND_PENDING, &g0->flags) &&
+	if (cci & UCSI_CCI_ACK_COMPLETE && test_and_clear_bit(ACK_PENDING, &g0->flags))
-	    cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))
+		complete(&g0->complete);
+	if (cci & UCSI_CCI_COMMAND_COMPLETE && test_and_clear_bit(COMMAND_PENDING, &g0->flags))
 		complete(&g0->complete);
 	return IRQ_HANDLED;

drivers/watchdog/Kconfig+1−0

@@ -257,6 +257,7 @@ config GPIO_WATCHDOG_ARCH_INITCALL · 256 unmodified lines
257	config LENOVO_SE10_WDT	257	config LENOVO_SE10_WDT
258	tristate "Lenovo SE10 Watchdog"	258	tristate "Lenovo SE10 Watchdog"
259	depends on (X86 && DMI) \|\| COMPILE_TEST	259	depends on (X86 && DMI) \|\| COMPILE_TEST
		260	depends on HAS_IOPORT
260	select WATCHDOG_CORE	261	select WATCHDOG_CORE
261	help	262	help
262	If you say yes here you get support for the watchdog	263	If you say yes here you get support for the watchdog

drivers/watchdog/menz69_wdt.c+1−0

@@ -161,6 +161,7 @@ static struct mcb_driver men_z069_driver = { · 160 unmodified lines
161	module_mcb_driver(men_z069_driver);	161	module_mcb_driver(men_z069_driver);
162		162
163	MODULE_AUTHOR("Johannes Thumshirn <jth@kernel.org>");	163	MODULE_AUTHOR("Johannes Thumshirn <jth@kernel.org>");
		164	MODULE_DESCRIPTION("Watchdog driver for the MEN z069 IP-Core");
164	MODULE_LICENSE("GPL v2");	165	MODULE_LICENSE("GPL v2");
165	MODULE_ALIAS("mcb:16z069");	166	MODULE_ALIAS("mcb:16z069");
166	MODULE_IMPORT_NS(MCB);	167	MODULE_IMPORT_NS(MCB);

drivers/watchdog/omap_wdt.c+1−0

@@ -370,5 +370,6 @@ static struct platform_driver omap_wdt_driver = { · 369 unmodified lines
370	module_platform_driver(omap_wdt_driver);	370	module_platform_driver(omap_wdt_driver);
371		371
372	MODULE_AUTHOR("George G. Davis");	372	MODULE_AUTHOR("George G. Davis");
		373	MODULE_DESCRIPTION("Driver for the TI OMAP 16xx/24xx/34xx 32KHz (non-secure) watchdog");
373	MODULE_LICENSE("GPL");	374	MODULE_LICENSE("GPL");
374	MODULE_ALIAS("platform:omap_wdt");	375	MODULE_ALIAS("platform:omap_wdt");

drivers/watchdog/simatic-ipc-wdt.c+1−0

@@ -227,6 +227,7 @@ static struct platform_driver simatic_ipc_wdt_driver = { · 226 unmodified lines
227		227
228	module_platform_driver(simatic_ipc_wdt_driver);	228	module_platform_driver(simatic_ipc_wdt_driver);
229		229
		230	MODULE_DESCRIPTION("Siemens SIMATIC IPC driver for Watchdogs");
230	MODULE_LICENSE("GPL v2");	231	MODULE_LICENSE("GPL v2");
231	MODULE_ALIAS("platform:" KBUILD_MODNAME);	232	MODULE_ALIAS("platform:" KBUILD_MODNAME);
232	MODULE_AUTHOR("Gerd Haeussler <gerd.haeussler.ext@siemens.com>");	233	MODULE_AUTHOR("Gerd Haeussler <gerd.haeussler.ext@siemens.com>");

drivers/watchdog/ts4800_wdt.c+1−0

@@ -200,5 +200,6 @@ static struct platform_driver ts4800_wdt_driver = { · 199 unmodified lines
200	module_platform_driver(ts4800_wdt_driver);	200	module_platform_driver(ts4800_wdt_driver);
201		201
202	MODULE_AUTHOR("Damien Riegel <damien.riegel@savoirfairelinux.com>");	202	MODULE_AUTHOR("Damien Riegel <damien.riegel@savoirfairelinux.com>");
		203	MODULE_DESCRIPTION("Watchdog driver for TS-4800 based boards");
203	MODULE_LICENSE("GPL v2");	204	MODULE_LICENSE("GPL v2");
204	MODULE_ALIAS("platform:ts4800_wdt");	205	MODULE_ALIAS("platform:ts4800_wdt");

drivers/watchdog/twl4030_wdt.c+1−0

@@ -118,6 +118,7 @@ static struct platform_driver twl4030_wdt_driver = { · 117 unmodified lines
118	module_platform_driver(twl4030_wdt_driver);	118	module_platform_driver(twl4030_wdt_driver);
119		119
120	MODULE_AUTHOR("Nokia Corporation");	120	MODULE_AUTHOR("Nokia Corporation");
		121	MODULE_DESCRIPTION("TWL4030 Watchdog");
121	MODULE_LICENSE("GPL");	122	MODULE_LICENSE("GPL");
122	MODULE_ALIAS("platform:twl4030_wdt");	123	MODULE_ALIAS("platform:twl4030_wdt");
123		124

fs/afs/inode.c+2−2

@@ -512,7 +512,7 @@ static int afs_iget5_set_root(struct inode inode, void opaque) · 511 unmodified lines
512	struct afs_vnode *vnode = AFS_FS_I(inode);	512	struct afs_vnode *vnode = AFS_FS_I(inode);
513		513
514	vnode->volume = as->volume;	514	vnode->volume = as->volume;
515	vnode->fid.vid = as->volume->vid,	515	vnode->fid.vid = as->volume->vid;
516	vnode->fid.vnode = 1;	516	vnode->fid.vnode = 1;
517	vnode->fid.unique = 1;	517	vnode->fid.unique = 1;
518	inode->i_ino = 1;	518	inode->i_ino = 1;
@@ -545,7 +545,7 @@ struct inode afs_root_iget(struct super_block sb, struct key *key) · 26 unmodified lines
545	BUG_ON(!(inode->i_state & I_NEW));	545	BUG_ON(!(inode->i_state & I_NEW));
546		546
547	vnode = AFS_FS_I(inode);	547	vnode = AFS_FS_I(inode);
548	vnode->cb_v_check = atomic_read(&as->volume->cb_v_break),	548	vnode->cb_v_check = atomic_read(&as->volume->cb_v_break);
549	afs_set_netfs_context(vnode);	549	afs_set_netfs_context(vnode);
550		550
551	op = afs_alloc_operation(key, as->volume);	551	op = afs_alloc_operation(key, as->volume);

fs/bcachefs/alloc_background.c+139−124

@@ -29,7 +29,7 @@ · 28 unmodified lines
29	#include <linux/sched/task.h>	29	#include <linux/sched/task.h>
30	#include <linux/sort.h>	30	#include <linux/sort.h>
31		31
32	static void bch2_discard_one_bucket_fast(struct bch_fs *c, struct bpos bucket);	32	static void bch2_discard_one_bucket_fast(struct bch_dev *, u64);
33		33
34	/* Persistent alloc info: */	34	/* Persistent alloc info: */
35		35
@@ -893,12 +893,12 @@ int bch2_trigger_alloc(struct btree_trans *trans, · 857 unmodified lines
893	if (statechange(a->data_type == BCH_DATA_need_discard) &&	893	if (statechange(a->data_type == BCH_DATA_need_discard) &&
894	!bch2_bucket_is_open_safe(c, new.k->p.inode, new.k->p.offset) &&	894	!bch2_bucket_is_open_safe(c, new.k->p.inode, new.k->p.offset) &&
895	bucket_flushed(new_a))	895	bucket_flushed(new_a))
896	bch2_discard_one_bucket_fast(c, new.k->p);	896	bch2_discard_one_bucket_fast(ca, new.k->p.offset);
897		897
898	if (statechange(a->data_type == BCH_DATA_cached) &&	898	if (statechange(a->data_type == BCH_DATA_cached) &&
899	!bch2_bucket_is_open(c, new.k->p.inode, new.k->p.offset) &&	899	!bch2_bucket_is_open(c, new.k->p.inode, new.k->p.offset) &&
900	should_invalidate_buckets(ca, bch2_dev_usage_read(ca)))	900	should_invalidate_buckets(ca, bch2_dev_usage_read(ca)))
901	bch2_do_invalidates(c);	901	bch2_dev_do_invalidates(ca);
902		902
903	if (statechange(a->data_type == BCH_DATA_need_gc_gens))	903	if (statechange(a->data_type == BCH_DATA_need_gc_gens))
904	bch2_gc_gens_async(c);	904	bch2_gc_gens_async(c);
@@ -1636,34 +1636,38 @@ int bch2_check_alloc_to_lru_refs(struct bch_fs *c) · 731 unmodified lines
1636	return ret;	1636	return ret;
1637	}	1637	}
1638		1638
1639	static int discard_in_flight_add(struct bch_fs *c, struct bpos bucket)	1639	static int discard_in_flight_add(struct bch_dev *ca, u64 bucket, bool in_progress)
1640	{	1640	{
1641	int ret;	1641	int ret;
1642		1642
1643	mutex_lock(&c->discard_buckets_in_flight_lock);	1643	mutex_lock(&ca->discard_buckets_in_flight_lock);
1644	darray_for_each(c->discard_buckets_in_flight, i)	1644	darray_for_each(ca->discard_buckets_in_flight, i)
1645	if (bkey_eq(*i, bucket)) {	1645	if (i->bucket == bucket) {
1646	ret = -BCH_ERR_EEXIST_discard_in_flight_add;	1646	ret = -BCH_ERR_EEXIST_discard_in_flight_add;
1647	goto out;	1647	goto out;
1648	}	1648	}
1649		1649
1650	ret = darray_push(&c->discard_buckets_in_flight, bucket);	1650	ret = darray_push(&ca->discard_buckets_in_flight, ((struct discard_in_flight) {
		1651	.in_progress = in_progress,
		1652	.bucket = bucket,
		1653	}));
1651	out:	1654	out:
1652	mutex_unlock(&c->discard_buckets_in_flight_lock);	1655	mutex_unlock(&ca->discard_buckets_in_flight_lock);
1653	return ret;	1656	return ret;
1654	}	1657	}
1655		1658
1656	static void discard_in_flight_remove(struct bch_fs *c, struct bpos bucket)	1659	static void discard_in_flight_remove(struct bch_dev *ca, u64 bucket)
1657	{	1660	{
1658	mutex_lock(&c->discard_buckets_in_flight_lock);	1661	mutex_lock(&ca->discard_buckets_in_flight_lock);
1659	darray_for_each(c->discard_buckets_in_flight, i)	1662	darray_for_each(ca->discard_buckets_in_flight, i)
1660	if (bkey_eq(*i, bucket)) {	1663	if (i->bucket == bucket) {
1661	darray_remove_item(&c->discard_buckets_in_flight, i);	1664	BUG_ON(!i->in_progress);
		1665	darray_remove_item(&ca->discard_buckets_in_flight, i);
1662	goto found;	1666	goto found;
1663	}	1667	}
1664	BUG();	1668	BUG();
1665	found:	1669	found:
1666	mutex_unlock(&c->discard_buckets_in_flight_lock);	1670	mutex_unlock(&ca->discard_buckets_in_flight_lock);
1667	}	1671	}
1668		1672
1669	struct discard_buckets_state {	1673	struct discard_buckets_state {
@@ -1671,26 +1675,11 @@ struct discard_buckets_state { · 1 unmodified line
1671	u64 open;	1675	u64 open;
1672	u64 need_journal_commit;	1676	u64 need_journal_commit;
1673	u64 discarded;	1677	u64 discarded;
1674	struct bch_dev *ca;
1675	u64 need_journal_commit_this_dev;	1678	u64 need_journal_commit_this_dev;
1676	};	1679	};
1677		1680
1678	static void discard_buckets_next_dev(struct bch_fs c, struct discard_buckets_state s, struct bch_dev *ca)
1679	{
1680	if (s->ca == ca)
1681	return;
1682
1683	if (s->ca && s->need_journal_commit_this_dev >
1684	bch2_dev_usage_read(s->ca).d[BCH_DATA_free].buckets)
1685	bch2_journal_flush_async(&c->journal, NULL);
1686
1687	if (s->ca)
1688	percpu_ref_put(&s->ca->io_ref);
1689	s->ca = ca;
1690	s->need_journal_commit_this_dev = 0;
1691	}
1692
1693	static int bch2_discard_one_bucket(struct btree_trans *trans,	1681	static int bch2_discard_one_bucket(struct btree_trans *trans,
		1682	struct bch_dev *ca,
1694	struct btree_iter *need_discard_iter,	1683	struct btree_iter *need_discard_iter,
1695	struct bpos *discard_pos_done,	1684	struct bpos *discard_pos_done,
1696	struct discard_buckets_state *s)	1685	struct discard_buckets_state *s)
@@ -1704,16 +1693,6 @@ static int bch2_discard_one_bucket(struct btree_trans *trans, · 7 unmodified lines
1704	bool discard_locked = false;	1693	bool discard_locked = false;
1705	int ret = 0;	1694	int ret = 0;
1706		1695
1707	struct bch_dev *ca = s->ca && s->ca->dev_idx == pos.inode
1708	? s->ca
1709	: bch2_dev_get_ioref(c, pos.inode, WRITE);
1710	if (!ca) {
1711	bch2_btree_iter_set_pos(need_discard_iter, POS(pos.inode + 1, 0));
1712	return 0;
1713	}
1714
1715	discard_buckets_next_dev(c, s, ca);
1716
1717	if (bch2_bucket_is_open_safe(c, pos.inode, pos.offset)) {	1696	if (bch2_bucket_is_open_safe(c, pos.inode, pos.offset)) {
1718	s->open++;	1697	s->open++;
1719	goto out;	1698	goto out;
@@ -1773,7 +1752,7 @@ static int bch2_discard_one_bucket(struct btree_trans *trans, · 53 unmodified lines
1773	goto out;	1752	goto out;
1774	}	1753	}
1775		1754
1776	if (discard_in_flight_add(c, SPOS(iter.pos.inode, iter.pos.offset, true)))	1755	if (discard_in_flight_add(ca, iter.pos.offset, true))
1777	goto out;	1756	goto out;
1778		1757
1779	discard_locked = true;	1758	discard_locked = true;
@@ -1811,7 +1790,7 @@ write: · 31 unmodified lines
1811	s->discarded++;	1790	s->discarded++;
1812	out:	1791	out:
1813	if (discard_locked)	1792	if (discard_locked)
1814	discard_in_flight_remove(c, iter.pos);	1793	discard_in_flight_remove(ca, iter.pos.offset);
1815	s->seen++;	1794	s->seen++;
1816	bch2_trans_iter_exit(trans, &iter);	1795	bch2_trans_iter_exit(trans, &iter);
1817	printbuf_exit(&buf);	1796	printbuf_exit(&buf);
@@ -1820,7 +1799,8 @@ out: · 2 unmodified lines
1820		1799
1821	static void bch2_do_discards_work(struct work_struct *work)	1800	static void bch2_do_discards_work(struct work_struct *work)
1822	{	1801	{
1823	struct bch_fs *c = container_of(work, struct bch_fs, discard_work);	1802	struct bch_dev *ca = container_of(work, struct bch_dev, discard_work);
		1803	struct bch_fs *c = ca->fs;
1824	struct discard_buckets_state s = {};	1804	struct discard_buckets_state s = {};
1825	struct bpos discard_pos_done = POS_MAX;	1805	struct bpos discard_pos_done = POS_MAX;
1826	int ret;	1806	int ret;
@@ -1831,23 +1811,41 @@ static void bch2_do_discards_work(struct work_struct *work) · 4 unmodified lines
1831	* successful commit:	1811	* successful commit:
1832	*/	1812	*/
1833	ret = bch2_trans_run(c,	1813	ret = bch2_trans_run(c,
1834	for_each_btree_key(trans, iter,	1814	for_each_btree_key_upto(trans, iter,
1835	BTREE_ID_need_discard, POS_MIN, 0, k,	1815	BTREE_ID_need_discard,
1836	bch2_discard_one_bucket(trans, &iter, &discard_pos_done, &s)));	1816	POS(ca->dev_idx, 0),
1837		1817	POS(ca->dev_idx, U64_MAX), 0, k,
1838	discard_buckets_next_dev(c, &s, NULL);	1818	bch2_discard_one_bucket(trans, ca, &iter, &discard_pos_done, &s)));
1839		1819
1840	trace_discard_buckets(c, s.seen, s.open, s.need_journal_commit, s.discarded,	1820	trace_discard_buckets(c, s.seen, s.open, s.need_journal_commit, s.discarded,
1841	bch2_err_str(ret));	1821	bch2_err_str(ret));
1842		1822
1843	bch2_write_ref_put(c, BCH_WRITE_REF_discard);	1823	bch2_write_ref_put(c, BCH_WRITE_REF_discard);
		1824	percpu_ref_put(&ca->io_ref);
		1825	}
		1826
		1827	void bch2_dev_do_discards(struct bch_dev *ca)
		1828	{
		1829	struct bch_fs *c = ca->fs;
		1830
		1831	if (!bch2_dev_get_ioref(c, ca->dev_idx, WRITE))
		1832	return;
		1833
		1834	if (!bch2_write_ref_tryget(c, BCH_WRITE_REF_discard))
		1835	goto put_ioref;
		1836
		1837	if (queue_work(c->write_ref_wq, &ca->discard_work))
		1838	return;
		1839
		1840	bch2_write_ref_put(c, BCH_WRITE_REF_discard);
		1841	put_ioref:
		1842	percpu_ref_put(&ca->io_ref);
1844	}	1843	}
1845		1844
1846	void bch2_do_discards(struct bch_fs *c)	1845	void bch2_do_discards(struct bch_fs *c)
1847	{	1846	{
1848	if (bch2_write_ref_tryget(c, BCH_WRITE_REF_discard) &&	1847	for_each_member_device(c, ca)
1849	!queue_work(c->write_ref_wq, &c->discard_work))	1848	bch2_dev_do_discards(ca);
1850	bch2_write_ref_put(c, BCH_WRITE_REF_discard);
1851	}	1849	}
1852		1850
1853	static int bch2_clear_bucket_needs_discard(struct btree_trans *trans, struct bpos bucket)	1851	static int bch2_clear_bucket_needs_discard(struct btree_trans *trans, struct bpos bucket)
@@ -1876,68 +1874,69 @@ err: · 22 unmodified lines
1876		1874
1877	static void bch2_do_discards_fast_work(struct work_struct *work)	1875	static void bch2_do_discards_fast_work(struct work_struct *work)
1878	{	1876	{
1879	struct bch_fs *c = container_of(work, struct bch_fs, discard_fast_work);	1877	struct bch_dev *ca = container_of(work, struct bch_dev, discard_fast_work);
		1878	struct bch_fs *c = ca->fs;
1880		1879
1881	while (1) {	1880	while (1) {
1882	bool got_bucket = false;	1881	bool got_bucket = false;
1883	struct bpos bucket;	1882	u64 bucket;
1884	struct bch_dev *ca;
1885		1883
1886	mutex_lock(&c->discard_buckets_in_flight_lock);	1884	mutex_lock(&ca->discard_buckets_in_flight_lock);
1887	darray_for_each(c->discard_buckets_in_flight, i) {	1885	darray_for_each(ca->discard_buckets_in_flight, i) {
1888	if (i->snapshot)	1886	if (i->in_progress)
1889	continue;	1887	continue;
1890		1888
1891	ca = bch2_dev_get_ioref(c, i->inode, WRITE);
1892	if (!ca) {
1893	darray_remove_item(&c->discard_buckets_in_flight, i);
1894	continue;
1895	}
1896
1897	got_bucket = true;	1889	got_bucket = true;
1898	bucket = *i;	1890	bucket = i->bucket;
1899	i->snapshot = true;	1891	i->in_progress = true;
1900	break;	1892	break;
1901	}	1893	}
1902	mutex_unlock(&c->discard_buckets_in_flight_lock);	1894	mutex_unlock(&ca->discard_buckets_in_flight_lock);
1903		1895
1904	if (!got_bucket)	1896	if (!got_bucket)
1905	break;	1897	break;
1906		1898
1907	if (ca->mi.discard && !c->opts.nochanges)	1899	if (ca->mi.discard && !c->opts.nochanges)
1908	blkdev_issue_discard(ca->disk_sb.bdev,	1900	blkdev_issue_discard(ca->disk_sb.bdev,
1909	bucket.offset * ca->mi.bucket_size,	1901	bucket_to_sector(ca, bucket),
1910	ca->mi.bucket_size,	1902	ca->mi.bucket_size,
1911	GFP_KERNEL);	1903	GFP_KERNEL);
1912		1904
1913	int ret = bch2_trans_do(c, NULL, NULL,	1905	int ret = bch2_trans_do(c, NULL, NULL,
1914	BCH_WATERMARK_btree\|	1906	BCH_WATERMARK_btree\|
1915	BCH_TRANS_COMMIT_no_enospc,	1907	BCH_TRANS_COMMIT_no_enospc,
1916	bch2_clear_bucket_needs_discard(trans, bucket));	1908	bch2_clear_bucket_needs_discard(trans, POS(ca->dev_idx, bucket)));
1917	bch_err_fn(c, ret);	1909	bch_err_fn(c, ret);
1918		1910
1919	percpu_ref_put(&ca->io_ref);	1911	discard_in_flight_remove(ca, bucket);
1920	discard_in_flight_remove(c, bucket);
1921		1912
1922	if (ret)	1913	if (ret)
1923	break;	1914	break;
1924	}	1915	}
1925		1916
1926	bch2_write_ref_put(c, BCH_WRITE_REF_discard_fast);	1917	bch2_write_ref_put(c, BCH_WRITE_REF_discard_fast);
		1918	percpu_ref_put(&ca->io_ref);
1927	}	1919	}
1928		1920
1929	static void bch2_discard_one_bucket_fast(struct bch_fs *c, struct bpos bucket)	1921	static void bch2_discard_one_bucket_fast(struct bch_dev *ca, u64 bucket)
1930	{	1922	{
1931	rcu_read_lock();	1923	struct bch_fs *c = ca->fs;
1932	struct bch_dev *ca = bch2_dev_rcu(c, bucket.inode);	1924
1933	bool dead = !ca \|\| percpu_ref_is_dying(&ca->io_ref);	1925	if (discard_in_flight_add(ca, bucket, false))
1934	rcu_read_unlock();	1926	return;
		1927
		1928	if (!bch2_dev_get_ioref(c, ca->dev_idx, WRITE))
		1929	return;
		1930
		1931	if (!bch2_write_ref_tryget(c, BCH_WRITE_REF_discard_fast))
		1932	goto put_ioref;
		1933
		1934	if (queue_work(c->write_ref_wq, &ca->discard_fast_work))
		1935	return;
1935		1936
1936	if (!dead &&	1937	bch2_write_ref_put(c, BCH_WRITE_REF_discard_fast);
1937	!discard_in_flight_add(c, bucket) &&	1938	put_ioref:
1938	bch2_write_ref_tryget(c, BCH_WRITE_REF_discard_fast) &&	1939	percpu_ref_put(&ca->io_ref);
1939	!queue_work(c->write_ref_wq, &c->discard_fast_work))
1940	bch2_write_ref_put(c, BCH_WRITE_REF_discard_fast);
1941	}	1940	}
1942		1941
1943	static int invalidate_one_bucket(struct btree_trans *trans,	1942	static int invalidate_one_bucket(struct btree_trans *trans,
@@ -2038,7 +2037,8 @@ again: · 94 unmodified lines
2038		2037
2039	static void bch2_do_invalidates_work(struct work_struct *work)	2038	static void bch2_do_invalidates_work(struct work_struct *work)
2040	{	2039	{
2041	struct bch_fs *c = container_of(work, struct bch_fs, invalidate_work);	2040	struct bch_dev *ca = container_of(work, struct bch_dev, invalidate_work);
		2041	struct bch_fs *c = ca->fs;
2042	struct btree_trans *trans = bch2_trans_get(c);	2042	struct btree_trans *trans = bch2_trans_get(c);
2043	int ret = 0;	2043	int ret = 0;
2044		2044
@@ -2046,52 +2046,63 @@ static void bch2_do_invalidates_work(struct work_struct *work) · 1 unmodified line
2046	if (ret)	2046	if (ret)
2047	goto err;	2047	goto err;
2048		2048
2049	for_each_member_device(c, ca) {	2049	s64 nr_to_invalidate =
2050	s64 nr_to_invalidate =	2050	should_invalidate_buckets(ca, bch2_dev_usage_read(ca));
2051	should_invalidate_buckets(ca, bch2_dev_usage_read(ca));	2051	struct btree_iter iter;
2052	struct btree_iter iter;	2052	bool wrapped = false;
2053	bool wrapped = false;
2054
2055	bch2_trans_iter_init(trans, &iter, BTREE_ID_lru,
2056	lru_pos(ca->dev_idx, 0,
2057	((bch2_current_io_time(c, READ) + U32_MAX) &
2058	LRU_TIME_MAX)), 0);
2059
2060	while (true) {
2061	bch2_trans_begin(trans);
2062
2063	struct bkey_s_c k = next_lru_key(trans, &iter, ca, &wrapped);
2064	ret = bkey_err(k);
2065	if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
2066	continue;
2067	if (ret)
2068	break;
2069	if (!k.k)
2070	break;
2071		2053
2072	ret = invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate);	2054	bch2_trans_iter_init(trans, &iter, BTREE_ID_lru,
2073	if (ret)	2055	lru_pos(ca->dev_idx, 0,
2074	break;	2056	((bch2_current_io_time(c, READ) + U32_MAX) &
		2057	LRU_TIME_MAX)), 0);
2075		2058
2076	bch2_btree_iter_advance(&iter);	2059	while (true) {
2077	}	2060	bch2_trans_begin(trans);
2078	bch2_trans_iter_exit(trans, &iter);
2079		2061
2080	if (ret < 0) {	2062	struct bkey_s_c k = next_lru_key(trans, &iter, ca, &wrapped);
2081	bch2_dev_put(ca);	2063	ret = bkey_err(k);
		2064	if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
		2065	continue;
		2066	if (ret)
2082	break;	2067	break;
2083	}	2068	if (!k.k)
		2069	break;
		2070
		2071	ret = invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate);
		2072	if (ret)
		2073	break;
		2074
		2075	bch2_btree_iter_advance(&iter);
2084	}	2076	}
		2077	bch2_trans_iter_exit(trans, &iter);
2085	err:	2078	err:
2086	bch2_trans_put(trans);	2079	bch2_trans_put(trans);
2087	bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);	2080	bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);
		2081	percpu_ref_put(&ca->io_ref);
		2082	}
		2083
		2084	void bch2_dev_do_invalidates(struct bch_dev *ca)
		2085	{
		2086	struct bch_fs *c = ca->fs;
		2087
		2088	if (!bch2_dev_get_ioref(c, ca->dev_idx, WRITE))
		2089	return;
		2090
		2091	if (!bch2_write_ref_tryget(c, BCH_WRITE_REF_invalidate))
		2092	goto put_ioref;
		2093
		2094	if (queue_work(c->write_ref_wq, &ca->invalidate_work))
		2095	return;
		2096
		2097	bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);
		2098	put_ioref:
		2099	percpu_ref_put(&ca->io_ref);
2088	}	2100	}
2089		2101
2090	void bch2_do_invalidates(struct bch_fs *c)	2102	void bch2_do_invalidates(struct bch_fs *c)
2091	{	2103	{
2092	if (bch2_write_ref_tryget(c, BCH_WRITE_REF_invalidate) &&	2104	for_each_member_device(c, ca)
2093	!queue_work(c->write_ref_wq, &c->invalidate_work))	2105	bch2_dev_do_invalidates(ca);
2094	bch2_write_ref_put(c, BCH_WRITE_REF_invalidate);
2095	}	2106	}
2096		2107
2097	int bch2_dev_freespace_init(struct bch_fs c, struct bch_dev ca,	2108	int bch2_dev_freespace_init(struct bch_fs c, struct bch_dev ca,
@@ -2407,16 +2418,20 @@ void bch2_dev_allocator_add(struct bch_fs c, struct bch_dev ca) · 309 unmodified lines
2407	set_bit(ca->dev_idx, c->rw_devs[i].d);	2418	set_bit(ca->dev_idx, c->rw_devs[i].d);
2408	}	2419	}
2409		2420
2410	void bch2_fs_allocator_background_exit(struct bch_fs *c)	2421	void bch2_dev_allocator_background_exit(struct bch_dev *ca)
		2422	{
		2423	darray_exit(&ca->discard_buckets_in_flight);
		2424	}
		2425
		2426	void bch2_dev_allocator_background_init(struct bch_dev *ca)
2411	{	2427	{
2412	darray_exit(&c->discard_buckets_in_flight);	2428	mutex_init(&ca->discard_buckets_in_flight_lock);
		2429	INIT_WORK(&ca->discard_work, bch2_do_discards_work);
		2430	INIT_WORK(&ca->discard_fast_work, bch2_do_discards_fast_work);
		2431	INIT_WORK(&ca->invalidate_work, bch2_do_invalidates_work);
2413	}	2432	}
2414		2433
2415	void bch2_fs_allocator_background_init(struct bch_fs *c)	2434	void bch2_fs_allocator_background_init(struct bch_fs *c)
2416	{	2435	{
2417	spin_lock_init(&c->freelist_lock);	2436	spin_lock_init(&c->freelist_lock);
2418	mutex_init(&c->discard_buckets_in_flight_lock);
2419	INIT_WORK(&c->discard_work, bch2_do_discards_work);
2420	INIT_WORK(&c->discard_fast_work, bch2_do_discards_fast_work);
2421	INIT_WORK(&c->invalidate_work, bch2_do_invalidates_work);
2422	}	2437	}

fs/bcachefs/alloc_background.h+5−1

 		       enum btree_iter_update_trigger_flags);
 int bch2_check_alloc_info(struct bch_fs *);
 int bch2_check_alloc_to_lru_refs(struct bch_fs *);
+void bch2_dev_do_discards(struct bch_dev *);
 void bch2_do_discards(struct bch_fs *);
 static inline u64 should_invalidate_buckets(struct bch_dev *ca,
 	return clamp_t(s64, want_free - free, 0, u.d[BCH_DATA_cached].buckets);
 }
+void bch2_dev_do_invalidates(struct bch_dev *);
 void bch2_do_invalidates(struct bch_fs *);
 static inline struct bch_backpointer *alloc_v4_backpointers(struct bch_alloc_v4 *a)
 void bch2_dev_allocator_remove(struct bch_fs *, struct bch_dev *);
 void bch2_dev_allocator_add(struct bch_fs *, struct bch_dev *);
-void bch2_fs_allocator_background_exit(struct bch_fs *);
+void bch2_dev_allocator_background_exit(struct bch_dev *);
+void bch2_dev_allocator_background_init(struct bch_dev *);
 void bch2_fs_allocator_background_init(struct bch_fs *);
 #endif /* _BCACHEFS_ALLOC_BACKGROUND_H */

fs/bcachefs/alloc_foreground.c+2−2

@@ -621,13 +621,13 @@ again: · 620 unmodified lines
621	avail = dev_buckets_free(ca, *usage, watermark);	621	avail = dev_buckets_free(ca, *usage, watermark);
622		622
623	if (usage->d[BCH_DATA_need_discard].buckets > avail)	623	if (usage->d[BCH_DATA_need_discard].buckets > avail)
624	bch2_do_discards(c);	624	bch2_dev_do_discards(ca);
625		625
626	if (usage->d[BCH_DATA_need_gc_gens].buckets > avail)	626	if (usage->d[BCH_DATA_need_gc_gens].buckets > avail)
627	bch2_gc_gens_async(c);	627	bch2_gc_gens_async(c);
628		628
629	if (should_invalidate_buckets(ca, *usage))	629	if (should_invalidate_buckets(ca, *usage))
630	bch2_do_invalidates(c);	630	bch2_dev_do_invalidates(ca);
631		631
632	if (!avail) {	632	if (!avail) {
633	if (cl && !waiting) {	633	if (cl && !waiting) {

fs/bcachefs/bcachefs.h+11−5

 	u64			sectors[2][BCH_DATA_NR];
 };
+struct discard_in_flight {
+	bool			in_progress:1;
+	u64			bucket:63;
+};
 struct bch_dev {
 	struct kobject		kobj;
 #ifdef CONFIG_BCACHEFS_DEBUG
 	size_t			inc_gen_really_needs_gc;
 	size_t			buckets_waiting_on_journal;
+	struct work_struct	invalidate_work;
+	struct work_struct	discard_work;
+	struct mutex		discard_buckets_in_flight_lock;
+	DARRAY(struct discard_in_flight)	discard_buckets_in_flight;
+	struct work_struct	discard_fast_work;
 	atomic64_t		rebalance_work;
 	struct journal_device	journal;
 	unsigned		write_points_nr;
 	struct buckets_waiting_for_journal buckets_waiting_for_journal;
-	struct work_struct	invalidate_work;
-	struct work_struct	discard_work;
-	struct mutex		discard_buckets_in_flight_lock;
-	DARRAY(struct bpos)	discard_buckets_in_flight;
-	struct work_struct	discard_fast_work;
 	/* GARBAGE COLLECTION */
 	struct work_struct	gc_gens_work;

fs/bcachefs/btree_iter.c+6−13

@@ -3130,7 +3130,6 @@ struct btree_trans __bch2_trans_get(struct bch_fs c, unsigned fn_idx) · 3129 unmodified lines
3130		3130
3131	trans = mempool_alloc(&c->btree_trans_pool, GFP_NOFS);	3131	trans = mempool_alloc(&c->btree_trans_pool, GFP_NOFS);
3132	memset(trans, 0, sizeof(*trans));	3132	memset(trans, 0, sizeof(*trans));
3133	closure_init_stack(&trans->ref);
3134		3133
3135	seqmutex_lock(&c->btree_trans_lock);	3134	seqmutex_lock(&c->btree_trans_lock);
3136	if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG)) {	3135	if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG)) {
@@ -3150,18 +3149,12 @@ struct btree_trans __bch2_trans_get(struct bch_fs c, unsigned fn_idx) · 13 unmodified lines
3150	BUG_ON(pos_task &&	3149	BUG_ON(pos_task &&
3151	pid == pos_task->pid &&	3150	pid == pos_task->pid &&
3152	pos->locked);	3151	pos->locked);
3153
3154	if (pos_task && pid < pos_task->pid) {
3155	list_add_tail(&trans->list, &pos->list);
3156	goto list_add_done;
3157	}
3158	}	3152	}
3159	}	3153	}
3160	list_add_tail(&trans->list, &c->btree_trans_list);	3154
3161	list_add_done:	3155	list_add(&trans->list, &c->btree_trans_list);
3162	seqmutex_unlock(&c->btree_trans_lock);	3156	seqmutex_unlock(&c->btree_trans_lock);
3163	got_trans:	3157	got_trans:
3164	trans->ref.closure_get_happened = false;
3165	trans->c = c;	3158	trans->c = c;
3166	trans->last_begin_time = local_clock();	3159	trans->last_begin_time = local_clock();
3167	trans->fn_idx = fn_idx;	3160	trans->fn_idx = fn_idx;
@@ -3200,6 +3193,8 @@ got_trans: · 32 unmodified lines
3200	trans->srcu_idx = srcu_read_lock(&c->btree_trans_barrier);	3193	trans->srcu_idx = srcu_read_lock(&c->btree_trans_barrier);
3201	trans->srcu_lock_time = jiffies;	3194	trans->srcu_lock_time = jiffies;
3202	trans->srcu_held = true;	3195	trans->srcu_held = true;
		3196
		3197	closure_init_stack_release(&trans->ref);
3203	return trans;	3198	return trans;
3204	}	3199	}
3205		3200
@@ -3257,10 +3252,10 @@ void bch2_trans_put(struct btree_trans *trans) · 51 unmodified lines
3257	bch2_journal_keys_put(c);	3252	bch2_journal_keys_put(c);
3258		3253
3259	/*	3254	/*
3260	* trans->ref protects trans->locking_wait.task, btree_paths arary; used	3255	* trans->ref protects trans->locking_wait.task, btree_paths array; used
3261	* by cycle detector	3256	* by cycle detector
3262	*/	3257	*/
3263	closure_sync(&trans->ref);	3258	closure_return_sync(&trans->ref);
3264	trans->locking_wait.task = NULL;	3259	trans->locking_wait.task = NULL;
3265		3260
3266	unsigned long *paths_allocated = trans->paths_allocated;	3261	unsigned long *paths_allocated = trans->paths_allocated;
@@ -3385,8 +3380,6 @@ void bch2_fs_btree_iter_exit(struct bch_fs *c) · 118 unmodified lines
3385	per_cpu_ptr(c->btree_trans_bufs, cpu)->trans;	3380	per_cpu_ptr(c->btree_trans_bufs, cpu)->trans;
3386		3381
3387	if (trans) {	3382	if (trans) {
3388	closure_sync(&trans->ref);
3389
3390	seqmutex_lock(&c->btree_trans_lock);	3383	seqmutex_lock(&c->btree_trans_lock);
3391	list_del(&trans->list);	3384	list_del(&trans->list);
3392	seqmutex_unlock(&c->btree_trans_lock);	3385	seqmutex_unlock(&c->btree_trans_lock);

fs/bcachefs/chardev.c+6−3

 		ret =   PTR_ERR_OR_ZERO(optstr) ?:
 			bch2_parse_mount_opts(NULL, &thr->opts, optstr);
-		kfree(optstr);
+		if (!IS_ERR(optstr))
+			kfree(optstr);
 		if (ret)
 			goto err;
 		return ret;
 	ret = bch2_dev_add(c, path);
-	kfree(path);
+	if (!IS_ERR(path))
+		kfree(path);
 	return ret;
 }
 		ret =   PTR_ERR_OR_ZERO(optstr) ?:
 			bch2_parse_mount_opts(c, &thr->opts, optstr);
-		kfree(optstr);
+		if (!IS_ERR(optstr))
+			kfree(optstr);
 		if (ret)
 			goto err;

fs/bcachefs/debug.c+69−40

@@ -568,6 +568,32 @@ static const struct file_operations cached_btree_nodes_ops = { · 567 unmodified lines
568	.read = bch2_cached_btree_nodes_read,	568	.read = bch2_cached_btree_nodes_read,
569	};	569	};
570		570
		571	typedef int (list_cmp_fn)(const struct list_head l, const struct list_head *r);
		572
		573	static void list_sort(struct list_head *head, list_cmp_fn cmp)
		574	{
		575	struct list_head *pos;
		576
		577	list_for_each(pos, head)
		578	while (!list_is_last(pos, head) &&
		579	cmp(pos, pos->next) > 0) {
		580	struct list_head pos2, next = pos->next;
		581
		582	list_del(next);
		583	list_for_each(pos2, head)
		584	if (cmp(next, pos2) < 0)
		585	goto pos_found;
		586	BUG();
		587	pos_found:
		588	list_add_tail(next, pos2);
		589	}
		590	}
		591
		592	static int list_ptr_order_cmp(const struct list_head l, const struct list_head r)
		593	{
		594	return cmp_int(l, r);
		595	}
		596
571	static ssize_t bch2_btree_transactions_read(struct file file, char __user buf,	597	static ssize_t bch2_btree_transactions_read(struct file file, char __user buf,
572	size_t size, loff_t *ppos)	598	size_t size, loff_t *ppos)
573	{	599	{
@@ -575,41 +601,39 @@ static ssize_t bch2_btree_transactions_read(struct file file, char __user buf, · 1 unmodified line
575	struct bch_fs *c = i->c;	601	struct bch_fs *c = i->c;
576	struct btree_trans *trans;	602	struct btree_trans *trans;
577	ssize_t ret = 0;	603	ssize_t ret = 0;
578	u32 seq;
579		604
580	i->ubuf = buf;	605	i->ubuf = buf;
581	i->size = size;	606	i->size = size;
582	i->ret = 0;	607	i->ret = 0;
583	restart:	608	restart:
584	seqmutex_lock(&c->btree_trans_lock);	609	seqmutex_lock(&c->btree_trans_lock);
585	list_for_each_entry(trans, &c->btree_trans_list, list) {	610	list_sort(&c->btree_trans_list, list_ptr_order_cmp);
586	struct task_struct *task = READ_ONCE(trans->locking_wait.task);
587		611
588	if (!task \|\| task->pid <= i->iter)	612	list_for_each_entry(trans, &c->btree_trans_list, list) {
		613	if ((ulong) trans < i->iter)
589	continue;	614	continue;
590		615
591	closure_get(&trans->ref);	616	i->iter = (ulong) trans;
592	seq = seqmutex_seq(&c->btree_trans_lock);
593	seqmutex_unlock(&c->btree_trans_lock);
594		617
595	ret = flush_buf(i);	618	if (!closure_get_not_zero(&trans->ref))
596	if (ret) {	619	continue;
597	closure_put(&trans->ref);	620
598	goto unlocked;	621	u32 seq = seqmutex_unlock(&c->btree_trans_lock);
599	}
600		622
601	bch2_btree_trans_to_text(&i->buf, trans);	623	bch2_btree_trans_to_text(&i->buf, trans);
602		624
603	prt_printf(&i->buf, "backtrace:\n");	625	prt_printf(&i->buf, "backtrace:\n");
604	printbuf_indent_add(&i->buf, 2);	626	printbuf_indent_add(&i->buf, 2);
605	bch2_prt_task_backtrace(&i->buf, task, 0, GFP_KERNEL);	627	bch2_prt_task_backtrace(&i->buf, trans->locking_wait.task, 0, GFP_KERNEL);
606	printbuf_indent_sub(&i->buf, 2);	628	printbuf_indent_sub(&i->buf, 2);
607	prt_newline(&i->buf);	629	prt_newline(&i->buf);
608		630
609	i->iter = task->pid;
610
611	closure_put(&trans->ref);	631	closure_put(&trans->ref);
612		632
		633	ret = flush_buf(i);
		634	if (ret)
		635	goto unlocked;
		636
613	if (!seqmutex_relock(&c->btree_trans_lock, seq))	637	if (!seqmutex_relock(&c->btree_trans_lock, seq))
614	goto restart;	638	goto restart;
615	}	639	}
@@ -804,50 +828,55 @@ static const struct file_operations btree_transaction_stats_op = { · 188 unmodified lines
804	.read = btree_transaction_stats_read,	828	.read = btree_transaction_stats_read,
805	};	829	};
806		830
807	static ssize_t bch2_btree_deadlock_read(struct file file, char __user buf,	831	/* walk btree transactions until we find a deadlock and print it */
808	size_t size, loff_t *ppos)	832	static void btree_deadlock_to_text(struct printbuf out, struct bch_fs c)
809	{	833	{
810	struct dump_iter *i = file->private_data;
811	struct bch_fs *c = i->c;
812	struct btree_trans *trans;	834	struct btree_trans *trans;
813	ssize_t ret = 0;	835	pid_t iter = 0;
814	u32 seq;
815
816	i->ubuf = buf;
817	i->size = size;
818	i->ret = 0;
819
820	if (i->iter)
821	goto out;
822	restart:	836	restart:
823	seqmutex_lock(&c->btree_trans_lock);	837	seqmutex_lock(&c->btree_trans_lock);
824	list_for_each_entry(trans, &c->btree_trans_list, list) {	838	list_for_each_entry(trans, &c->btree_trans_list, list) {
825	struct task_struct *task = READ_ONCE(trans->locking_wait.task);	839	struct task_struct *task = READ_ONCE(trans->locking_wait.task);
826		840
827	if (!task \|\| task->pid <= i->iter)	841	if (!task \|\| task->pid <= iter)
828	continue;	842	continue;
829		843
830	closure_get(&trans->ref);	844	iter = task->pid;
831	seq = seqmutex_seq(&c->btree_trans_lock);
832	seqmutex_unlock(&c->btree_trans_lock);
833		845
834	ret = flush_buf(i);	846	if (!closure_get_not_zero(&trans->ref))
835	if (ret) {	847	continue;
836	closure_put(&trans->ref);
837	goto out;
838	}
839		848
840	bch2_check_for_deadlock(trans, &i->buf);	849	u32 seq = seqmutex_unlock(&c->btree_trans_lock);
841		850
842	i->iter = task->pid;	851	bool found = bch2_check_for_deadlock(trans, out) != 0;
843		852
844	closure_put(&trans->ref);	853	closure_put(&trans->ref);
845		854
		855	if (found)
		856	return;
		857
846	if (!seqmutex_relock(&c->btree_trans_lock, seq))	858	if (!seqmutex_relock(&c->btree_trans_lock, seq))
847	goto restart;	859	goto restart;
848	}	860	}
849	seqmutex_unlock(&c->btree_trans_lock);	861	seqmutex_unlock(&c->btree_trans_lock);
850	out:	862	}
		863
		864	static ssize_t bch2_btree_deadlock_read(struct file file, char __user buf,
		865	size_t size, loff_t *ppos)
		866	{
		867	struct dump_iter *i = file->private_data;
		868	struct bch_fs *c = i->c;
		869	ssize_t ret = 0;
		870
		871	i->ubuf = buf;
		872	i->size = size;
		873	i->ret = 0;
		874
		875	if (!i->iter) {
		876	btree_deadlock_to_text(&i->buf, c);
		877	i->iter++;
		878	}
		879
851	if (i->buf.allocation_failure)	880	if (i->buf.allocation_failure)
852	ret = -ENOMEM;	881	ret = -ENOMEM;
853		882

fs/bcachefs/journal.c+5−0

 	struct journal_entry_pin *pin;
 	spin_lock(&j->lock);
+	if (!test_bit(JOURNAL_running, &j->flags)) {
+		spin_unlock(&j->lock);
+		return true;
+	}
 	*seq = max(*seq, j->pin.front);
 	if (*seq >= j->pin.back) {

fs/bcachefs/journal_io.c+7−0

@@ -1677,6 +1677,13 @@ static CLOSURE_CALLBACK(journal_write_done) · 1676 unmodified lines
1677	mod_delayed_work(j->wq, &j->write_work, max(0L, delta));	1677	mod_delayed_work(j->wq, &j->write_work, max(0L, delta));
1678	}	1678	}
1679		1679
		1680	/*
		1681	* We don't typically trigger journal writes from her - the next journal
		1682	* write will be triggered immediately after the previous one is
		1683	* allocated, in bch2_journal_write() - but the journal write error path
		1684	* is special:
		1685	*/
		1686	bch2_journal_do_writes(j);
1680	spin_unlock(&j->lock);	1687	spin_unlock(&j->lock);
1681	}	1688	}
1682		1689

fs/bcachefs/journal_seq_blacklist.c+1−1

@@ -232,7 +232,7 @@ bool bch2_blacklist_entries_gc(struct bch_fs *c) · 231 unmodified lines
232	BUG_ON(nr != t->nr);	232	BUG_ON(nr != t->nr);
233		233
234	unsigned i;	234	unsigned i;
235	for (src = bl->start, i = eytzinger0_first(t->nr);	235	for (src = bl->start, i = t->nr == 0 ? 0 : eytzinger0_first(t->nr);
236	src < bl->start + nr;	236	src < bl->start + nr;
237	src++, i = eytzinger0_next(i, nr)) {	237	src++, i = eytzinger0_next(i, nr)) {
238	BUG_ON(t->entries[i].start != le64_to_cpu(src->start));	238	BUG_ON(t->entries[i].start != le64_to_cpu(src->start));

fs/bcachefs/sb-errors.c+10−4

 void bch2_sb_errors_from_cpu(struct bch_fs *c)
 {
 	bch_sb_errors_cpu *src = &c->fsck_error_counts;
-	struct bch_sb_field_errors *dst =
+	struct bch_sb_field_errors *dst;
-		bch2_sb_field_resize(&c->disk_sb, errors,
-				     bch2_sb_field_errors_u64s(src->nr));
 	unsigned i;
+	mutex_lock(&c->fsck_error_counts_lock);
+	dst = bch2_sb_field_resize(&c->disk_sb, errors,
+				   bch2_sb_field_errors_u64s(src->nr));
 	if (!dst)
-		return;
+		goto err;
 	for (i = 0; i < src->nr; i++) {
 		SET_BCH_SB_ERROR_ENTRY_ID(&dst->entries[i], src->data[i].id);
 		SET_BCH_SB_ERROR_ENTRY_NR(&dst->entries[i], src->data[i].nr);
 		dst->entries[i].last_error_time = cpu_to_le64(src->data[i].last_error_time);
 	}
+err:
+	mutex_unlock(&c->fsck_error_counts_lock);
 }
 static int bch2_sb_errors_to_cpu(struct bch_fs *c)

fs/bcachefs/seqmutex.h+4−7

 static inline void seqmutex_lock(struct seqmutex *lock)
 {
 	mutex_lock(&lock->lock);
-}
-static inline void seqmutex_unlock(struct seqmutex *lock)
-{
 	lock->seq++;
-	mutex_unlock(&lock->lock);
 }
-static inline u32 seqmutex_seq(struct seqmutex *lock)
+static inline u32 seqmutex_unlock(struct seqmutex *lock)
 {
-	return lock->seq;
+	u32 seq = lock->seq;
+	mutex_unlock(&lock->lock);
+	return seq;
 }
 static inline bool seqmutex_relock(struct seqmutex *lock, u32 seq)

fs/bcachefs/snapshot.c+3−0

@@ -168,6 +168,9 @@ static noinline struct snapshot_t __snapshot_t_mut(struct bch_fs c, u32 id) · 167 unmodified lines
168	size_t new_bytes = kmalloc_size_roundup(struct_size(new, s, idx + 1));	168	size_t new_bytes = kmalloc_size_roundup(struct_size(new, s, idx + 1));
169	size_t new_size = (new_bytes - sizeof(*new)) / sizeof(new->s[0]);	169	size_t new_size = (new_bytes - sizeof(*new)) / sizeof(new->s[0]);
170		170
		171	if (unlikely(new_bytes > INT_MAX))
		172	return NULL;
		173
171	new = kvzalloc(new_bytes, GFP_KERNEL);	174	new = kvzalloc(new_bytes, GFP_KERNEL);
172	if (!new)	175	if (!new)
173	return NULL;	176	return NULL;

fs/bcachefs/super.c+5−1

 	bch2_find_btree_nodes_exit(&c->found_btree_nodes);
 	bch2_free_pending_node_rewrites(c);
-	bch2_fs_allocator_background_exit(c);
 	bch2_fs_sb_errors_exit(c);
 	bch2_fs_counters_exit(c);
 	bch2_fs_snapshots_exit(c);
 	kfree(ca->buckets_nouse);
 	bch2_free_super(&ca->disk_sb);
+	bch2_dev_allocator_background_exit(ca);
 	bch2_dev_journal_exit(ca);
 	free_percpu(ca->io_done);
 	atomic_long_set(&ca->ref, 1);
 #endif
+	bch2_dev_allocator_background_init(ca);
 	if (percpu_ref_init(&ca->io_ref, bch2_dev_io_ref_complete,
 			    PERCPU_REF_INIT_DEAD, GFP_KERNEL) ||
 	    !(ca->sb_read_scratch = (void *) __get_free_page(GFP_KERNEL)) ||
 	 * The allocator thread itself allocates btree nodes, so stop it first:
 	 */
 	bch2_dev_allocator_remove(c, ca);
+	bch2_recalc_capacity(c);
 	bch2_dev_journal_stop(&c->journal, ca);
 }
 	bch2_dev_allocator_add(c, ca);
 	bch2_recalc_capacity(c);
+	bch2_dev_do_discards(ca);
 }
 int __bch2_dev_set_state(struct bch_fs *c, struct bch_dev *ca,

fs/btrfs/block-group.c+11−2

@@ -1924,8 +1924,17 @@ void btrfs_reclaim_bgs_work(struct work_struct *work) · 1923 unmodified lines
1924	next:	1924	next:
1925	if (ret) {	1925	if (ret) {
1926	/* Refcount held by the reclaim_bgs list after splice. */	1926	/* Refcount held by the reclaim_bgs list after splice. */
1927	btrfs_get_block_group(bg);	1927	spin_lock(&fs_info->unused_bgs_lock);
1928	list_add_tail(&bg->bg_list, &retry_list);	1928	/*
		1929	* This block group might be added to the unused list
		1930	* during the above process. Move it back to the
		1931	* reclaim list otherwise.
		1932	*/
		1933	if (list_empty(&bg->bg_list)) {
		1934	btrfs_get_block_group(bg);
		1935	list_add_tail(&bg->bg_list, &retry_list);
		1936	}
		1937	spin_unlock(&fs_info->unused_bgs_lock);
1929	}	1938	}
1930	btrfs_put_block_group(bg);	1939	btrfs_put_block_group(bg);
1931		1940

fs/btrfs/free-space-cache.c+1−1

@@ -2697,7 +2697,7 @@ static int __btrfs_add_free_space_zoned(struct btrfs_block_group *block_group, · 2696 unmodified lines
2697	u64 offset = bytenr - block_group->start;	2697	u64 offset = bytenr - block_group->start;
2698	u64 to_free, to_unusable;	2698	u64 to_free, to_unusable;
2699	int bg_reclaim_threshold = 0;	2699	int bg_reclaim_threshold = 0;
2700	bool initial = (size == block_group->length);	2700	bool initial = ((size == block_group->length) && (block_group->alloc_offset == 0));
2701	u64 reclaimable_unusable;	2701	u64 reclaimable_unusable;
2702		2702
2703	WARN_ON(!initial && offset + size > block_group->zone_capacity);	2703	WARN_ON(!initial && offset + size > block_group->zone_capacity);

fs/btrfs/qgroup.c+2−2

 int btrfs_quota_disable(struct btrfs_fs_info *fs_info)
 {
-	struct btrfs_root *quota_root;
+	struct btrfs_root *quota_root = NULL;
 	struct btrfs_trans_handle *trans = NULL;
 	int ret = 0;
 	btrfs_free_tree_block(trans, btrfs_root_id(quota_root),
 			      quota_root->node, 0, 1);
-	btrfs_put_root(quota_root);
 out:
+	btrfs_put_root(quota_root);
 	mutex_unlock(&fs_info->qgroup_ioctl_lock);
 	if (ret && trans)
 		btrfs_end_transaction(trans);

fs/btrfs/scrub.c+14−10

 					    (i << fs_info->sectorsize_bits);
 			int err;
-			bbio = btrfs_bio_alloc(stripe->nr_sectors, REQ_OP_READ,
-					       fs_info, scrub_read_endio, stripe);
-			bbio->bio.bi_iter.bi_sector = logical >> SECTOR_SHIFT;
 			io_stripe.is_scrub = true;
+			stripe_len = (nr_sectors - i) << fs_info->sectorsize_bits;
+			/*
+			 * For RST cases, we need to manually split the bbio to
+			 * follow the RST boundary.
+			 */
 			err = btrfs_map_block(fs_info, BTRFS_MAP_READ, logical,
-					      &stripe_len, &bioc, &io_stripe,
+					      &stripe_len, &bioc, &io_stripe, &mirror);
-					      &mirror);
 			btrfs_put_bioc(bioc);
-			if (err) {
+			if (err < 0) {
-				btrfs_bio_end_io(bbio,
+				set_bit(i, &stripe->io_error_bitmap);
-						 errno_to_blk_status(err));
+				set_bit(i, &stripe->error_bitmap);
-				return;
+				continue;
 			}
+			bbio = btrfs_bio_alloc(stripe->nr_sectors, REQ_OP_READ,
+					       fs_info, scrub_read_endio, stripe);
+			bbio->bio.bi_iter.bi_sector = logical >> SECTOR_SHIFT;
 		}
 		__bio_add_page(&bbio->bio, page, fs_info->sectorsize, pgoff);

fs/btrfs/tree-log.c+28−15

  * and once to do all the other items.
  */
+static struct inode *btrfs_iget_logging(u64 objectid, struct btrfs_root *root)
+{
+	unsigned int nofs_flag;
+	struct inode *inode;
+	/*
+	 * We're holding a transaction handle whether we are logging or
+	 * replaying a log tree, so we must make sure NOFS semantics apply
+	 * because btrfs_alloc_inode() may be triggered and it uses GFP_KERNEL
+	 * to allocate an inode, which can recurse back into the filesystem and
+	 * attempt a transaction commit, resulting in a deadlock.
+	 */
+	nofs_flag = memalloc_nofs_save();
+	inode = btrfs_iget(root->fs_info->sb, objectid, root);
+	memalloc_nofs_restore(nofs_flag);
+	return inode;
+}
 /*
  * start a sub transaction and setup the log tree
  * this increments the log tree writer count to make the people
 {
 	struct inode *inode;
-	inode = btrfs_iget(root->fs_info->sb, objectid, root);
+	inode = btrfs_iget_logging(objectid, root);
 	if (IS_ERR(inode))
 		inode = NULL;
 	return inode;
 				struct btrfs_log_ctx *ctx)
 {
 	struct btrfs_root *root = start_inode->root;
-	struct btrfs_fs_info *fs_info = root->fs_info;
 	struct btrfs_path *path;
 	LIST_HEAD(dir_list);
 	struct btrfs_dir_list *dir_elem;
 				continue;
 			btrfs_release_path(path);
-			di_inode = btrfs_iget(fs_info->sb, di_key.objectid, root);
+			di_inode = btrfs_iget_logging(di_key.objectid, root);
 			if (IS_ERR(di_inode)) {
 				ret = PTR_ERR(di_inode);
 				goto out;
 		btrfs_add_delayed_iput(curr_inode);
 		curr_inode = NULL;
-		vfs_inode = btrfs_iget(fs_info->sb, ino, root);
+		vfs_inode = btrfs_iget_logging(ino, root);
 		if (IS_ERR(vfs_inode)) {
 			ret = PTR_ERR(vfs_inode);
 			break;
 	if (ctx->num_conflict_inodes >= MAX_CONFLICT_INODES)
 		return BTRFS_LOG_FORCE_COMMIT;
-	inode = btrfs_iget(root->fs_info->sb, ino, root);
+	inode = btrfs_iget_logging(ino, root);
 	/*
 	 * If the other inode that had a conflicting dir entry was deleted in
 	 * the current transaction then we either:
 				  struct btrfs_root *root,
 				  struct btrfs_log_ctx *ctx)
 {
-	struct btrfs_fs_info *fs_info = root->fs_info;
 	int ret = 0;
 	/*
 		list_del(&curr->list);
 		kfree(curr);
-		inode = btrfs_iget(fs_info->sb, ino, root);
+		inode = btrfs_iget_logging(ino, root);
 		/*
 		 * If the other inode that had a conflicting dir entry was
 		 * deleted in the current transaction, we need to log its parent
 			if (ret != -ENOENT)
 				break;
-			inode = btrfs_iget(fs_info->sb, parent, root);
+			inode = btrfs_iget_logging(parent, root);
 			if (IS_ERR(inode)) {
 				ret = PTR_ERR(inode);
 				break;
 				    struct btrfs_log_ctx *ctx)
 {
 	const bool orig_log_new_dentries = ctx->log_new_dentries;
-	struct btrfs_fs_info *fs_info = trans->fs_info;
 	struct btrfs_delayed_item *item;
 	int ret = 0;
 		if (key.type == BTRFS_ROOT_ITEM_KEY)
 			continue;
-		di_inode = btrfs_iget(fs_info->sb, key.objectid, inode->root);
+		di_inode = btrfs_iget_logging(key.objectid, inode->root);
 		if (IS_ERR(di_inode)) {
 			ret = PTR_ERR(di_inode);
 			break;
 				 struct btrfs_inode *inode,
 				 struct btrfs_log_ctx *ctx)
 {
-	struct btrfs_fs_info *fs_info = trans->fs_info;
 	int ret;
 	struct btrfs_path *path;
 	struct btrfs_key key;
 				cur_offset = item_size;
 			}
-			dir_inode = btrfs_iget(fs_info->sb, inode_key.objectid,
+			dir_inode = btrfs_iget_logging(inode_key.objectid, root);
-					       root);
 			/*
 			 * If the parent inode was deleted, return an error to
 			 * fallback to a transaction commit. This is to prevent
 	btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
 	while (true) {
-		struct btrfs_fs_info *fs_info = root->fs_info;
 		struct extent_buffer *leaf;
 		int slot;
 		struct btrfs_key search_key;
 		search_key.objectid = found_key.offset;
 		search_key.type = BTRFS_INODE_ITEM_KEY;
 		search_key.offset = 0;
-		inode = btrfs_iget(fs_info->sb, ino, root);
+		inode = btrfs_iget_logging(ino, root);
 		if (IS_ERR(inode))
 			return PTR_ERR(inode);

fs/dcache.c+14−17

@@ -3029,28 +3029,25 @@ EXPORT_SYMBOL(d_splice_alias); · 3028 unmodified lines
3029		3029
3030	bool is_subdir(struct dentry new_dentry, struct dentry old_dentry)	3030	bool is_subdir(struct dentry new_dentry, struct dentry old_dentry)
3031	{	3031	{
3032	bool result;	3032	bool subdir;
3033	unsigned seq;	3033	unsigned seq;
3034		3034
3035	if (new_dentry == old_dentry)	3035	if (new_dentry == old_dentry)
3036	return true;	3036	return true;
3037		3037
3038	do {	3038	/* Access d_parent under rcu as d_move() may change it. */
3039	/* for restarting inner loop in case of seq retry */	3039	rcu_read_lock();
3040	seq = read_seqbegin(&rename_lock);	3040	seq = read_seqbegin(&rename_lock);
3041	/*	3041	subdir = d_ancestor(old_dentry, new_dentry);
3042	* Need rcu_readlock to protect against the d_parent trashing	3042	/* Try lockless once... */
3043	* due to d_move	3043	if (read_seqretry(&rename_lock, seq)) {
3044	*/	3044	/* ...else acquire lock for progress even on deep chains. */
3045	rcu_read_lock();	3045	read_seqlock_excl(&rename_lock);
3046	if (d_ancestor(old_dentry, new_dentry))	3046	subdir = d_ancestor(old_dentry, new_dentry);
3047	result = true;	3047	read_sequnlock_excl(&rename_lock);
3048	else	3048	}
3049	result = false;	3049	rcu_read_unlock();
3050	rcu_read_unlock();	3050	return subdir;
3051	} while (read_seqretry(&rename_lock, seq));
3052
3053	return result;
3054	}	3051	}
3055	EXPORT_SYMBOL(is_subdir);	3052	EXPORT_SYMBOL(is_subdir);
3056		3053

fs/erofs/super.c+1−1

@@ -343,7 +343,7 @@ static int erofs_read_superblock(struct super_block *sb) · 342 unmodified lines
343	sbi->build_time = le64_to_cpu(dsb->build_time);	343	sbi->build_time = le64_to_cpu(dsb->build_time);
344	sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec);	344	sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec);
345		345
346	memcpy(&sb->s_uuid, dsb->uuid, sizeof(dsb->uuid));	346	super_set_uuid(sb, (void *)dsb->uuid, sizeof(dsb->uuid));
347		347
348	ret = strscpy(sbi->volume_name, dsb->volume_name,	348	ret = strscpy(sbi->volume_name, dsb->volume_name,
349	sizeof(dsb->volume_name));	349	sizeof(dsb->volume_name));

fs/erofs/zmap.c+2−0

@@ -711,6 +711,8 @@ int z_erofs_map_blocks_iter(struct inode inode, struct erofs_map_blocks map, · 710 unmodified lines
711		711
712	err = z_erofs_do_map_blocks(inode, map, flags);	712	err = z_erofs_do_map_blocks(inode, map, flags);
713	out:	713	out:
		714	if (err)
		715	map->m_llen = 0;
714	trace_z_erofs_map_blocks_iter_exit(inode, map, flags, err);	716	trace_z_erofs_map_blocks_iter_exit(inode, map, flags, err);
715	return err;	717	return err;
716	}	718	}

fs/erofs/zutil.c+4−4

@@ -148,7 +148,7 @@ int __init z_erofs_gbuf_init(void) · 147 unmodified lines
148		148
149	void z_erofs_gbuf_exit(void)	149	void z_erofs_gbuf_exit(void)
150	{	150	{
151	int i;	151	int i, j;
152		152
153	for (i = 0; i < z_erofs_gbuf_count + (!!z_erofs_rsvbuf); ++i) {	153	for (i = 0; i < z_erofs_gbuf_count + (!!z_erofs_rsvbuf); ++i) {
154	struct z_erofs_gbuf *gbuf = &z_erofs_gbufpool[i];	154	struct z_erofs_gbuf *gbuf = &z_erofs_gbufpool[i];
@@ -161,9 +161,9 @@ void z_erofs_gbuf_exit(void) · 6 unmodified lines
161	if (!gbuf->pages)	161	if (!gbuf->pages)
162	continue;	162	continue;
163		163
164	for (i = 0; i < gbuf->nrpages; ++i)	164	for (j = 0; j < gbuf->nrpages; ++j)
165	if (gbuf->pages[i])	165	if (gbuf->pages[j])
166	put_page(gbuf->pages[i]);	166	put_page(gbuf->pages[j]);
167	kfree(gbuf->pages);	167	kfree(gbuf->pages);
168	gbuf->pages = NULL;	168	gbuf->pages = NULL;
169	}	169	}

fs/locks.c+4−5

 	error = do_lock_file_wait(filp, cmd, file_lock);
 	/*
-	 * Attempt to detect a close/fcntl race and recover by releasing the
+	 * Detect close/fcntl races and recover by zapping all POSIX locks
-	 * lock that was just acquired. There is no need to do that when we're
+	 * associated with this file and our files_struct, just like on
+	 * filp_flush(). There is no need to do that when we're
 	 * unlocking though, or for OFD locks.
 	 */
 	if (!error && file_lock->c.flc_type != F_UNLCK &&
 		f = files_lookup_fd_locked(files, fd);
 		spin_unlock(&files->file_lock);
 		if (f != filp) {
-			file_lock->c.flc_type = F_UNLCK;
+			locks_remove_posix(filp, files);
-			error = do_lock_file_wait(filp, cmd, file_lock);
-			WARN_ON_ONCE(error);
 			error = -EBADF;
 		}
 	}

fs/namei.c+8−2

 	else
 		inode_lock_shared(dir->d_inode);
 	dentry = lookup_open(nd, file, op, got_write);
-	if (!IS_ERR(dentry) && (file->f_mode & FMODE_CREATED))
+	if (!IS_ERR(dentry)) {
-		fsnotify_create(dir->d_inode, dentry);
+		if (file->f_mode & FMODE_CREATED)
+			fsnotify_create(dir->d_inode, dentry);
+		if (file->f_mode & FMODE_OPENED)
+			fsnotify_open(file);
+	}
 	if (open_flag & O_CREAT)
 		inode_unlock(dir->d_inode);
 	else
 	mode = vfs_prepare_mode(idmap, dir, mode, mode, mode);
 	error = dir->i_op->tmpfile(idmap, dir, file, mode);
 	dput(child);
+	if (file->f_mode & FMODE_OPENED)
+		fsnotify_open(file);
 	if (error)
 		return error;
 	/* Don't check for other permissions, the inode was just created */

fs/netfs/buffered_write.c+9−3

 	struct netfs_group *group;
 	struct folio *folio = page_folio(vmf->page);
 	struct file *file = vmf->vma->vm_file;
+	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = file_inode(file);
 	struct netfs_inode *ictx = netfs_inode(inode);
 	vm_fault_t ret = VM_FAULT_RETRY;
 	if (folio_lock_killable(folio) < 0)
 		goto out;
+	if (folio->mapping != mapping) {
+		folio_unlock(folio);
+		ret = VM_FAULT_NOPAGE;
+		goto out;
+	}
 	if (folio_wait_writeback_killable(folio)) {
 		ret = VM_FAULT_LOCKED;
 	group = netfs_folio_group(folio);
 	if (group != netfs_group && group != NETFS_FOLIO_COPY_TO_CACHE) {
 		folio_unlock(folio);
-		err = filemap_fdatawait_range(inode->i_mapping,
+		err = filemap_fdatawrite_range(mapping,
-					      folio_pos(folio),
+					       folio_pos(folio),
-					      folio_pos(folio) + folio_size(folio));
+					       folio_pos(folio) + folio_size(folio));
 		switch (err) {
 		case 0:
 			ret = VM_FAULT_RETRY;

fs/netfs/direct_write.c+2−1

 	__set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
 	if (async)
 		wreq->iocb = iocb;
+	wreq->len = iov_iter_count(&wreq->io_iter);
 	wreq->cleanup = netfs_cleanup_dio_write;
-	ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), iov_iter_count(&wreq->io_iter));
+	ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len);
 	if (ret < 0) {
 		_debug("begin = %zd", ret);
 		goto out;

fs/netfs/internal.h+0−9

@@ -63,15 +63,6 @@ static inline void netfs_proc_del_rreq(struct netfs_io_request *rreq) {} · 62 unmodified lines
63	/*	63	/*
64	* misc.c	64	* misc.c
65	*/	65	*/
66	#define NETFS_FLAG_PUT_MARK BIT(0)
67	#define NETFS_FLAG_PAGECACHE_MARK BIT(1)
68	int netfs_xa_store_and_mark(struct xarray *xa, unsigned long index,
69	struct folio *folio, unsigned int flags,
70	gfp_t gfp_mask);
71	int netfs_add_folios_to_buffer(struct xarray *buffer,
72	struct address_space *mapping,
73	pgoff_t index, pgoff_t to, gfp_t gfp_mask);
74	void netfs_clear_buffer(struct xarray *buffer);
75		66
76	/*	67	/*
77	* objects.c	68	* objects.c

fs/netfs/misc.c+0−81

@@ -8,87 +8,6 @@ · 7 unmodified lines
8	#include <linux/swap.h>	8	#include <linux/swap.h>
9	#include "internal.h"	9	#include "internal.h"
10		10
11	/*
12	* Attach a folio to the buffer and maybe set marks on it to say that we need
13	* to put the folio later and twiddle the pagecache flags.
14	*/
15	int netfs_xa_store_and_mark(struct xarray *xa, unsigned long index,
16	struct folio *folio, unsigned int flags,
17	gfp_t gfp_mask)
18	{
19	XA_STATE_ORDER(xas, xa, index, folio_order(folio));
20
21	retry:
22	xas_lock(&xas);
23	for (;;) {
24	xas_store(&xas, folio);
25	if (!xas_error(&xas))
26	break;
27	xas_unlock(&xas);
28	if (!xas_nomem(&xas, gfp_mask))
29	return xas_error(&xas);
30	goto retry;
31	}
32
33	if (flags & NETFS_FLAG_PUT_MARK)
34	xas_set_mark(&xas, NETFS_BUF_PUT_MARK);
35	if (flags & NETFS_FLAG_PAGECACHE_MARK)
36	xas_set_mark(&xas, NETFS_BUF_PAGECACHE_MARK);
37	xas_unlock(&xas);
38	return xas_error(&xas);
39	}
40
41	/*
42	* Create the specified range of folios in the buffer attached to the read
43	* request. The folios are marked with NETFS_BUF_PUT_MARK so that we know that
44	* these need freeing later.
45	*/
46	int netfs_add_folios_to_buffer(struct xarray *buffer,
47	struct address_space *mapping,
48	pgoff_t index, pgoff_t to, gfp_t gfp_mask)
49	{
50	struct folio *folio;
51	int ret;
52
53	if (to + 1 == index) /* Page range is inclusive */
54	return 0;
55
56	do {
57	/* TODO: Figure out what order folio can be allocated here */
58	folio = filemap_alloc_folio(readahead_gfp_mask(mapping), 0);
59	if (!folio)
60	return -ENOMEM;
61	folio->index = index;
62	ret = netfs_xa_store_and_mark(buffer, index, folio,
63	NETFS_FLAG_PUT_MARK, gfp_mask);
64	if (ret < 0) {
65	folio_put(folio);
66	return ret;
67	}
68
69	index += folio_nr_pages(folio);
70	} while (index <= to && index != 0);
71
72	return 0;
73	}
74
75	/*
76	* Clear an xarray buffer, putting a ref on the folios that have
77	* NETFS_BUF_PUT_MARK set.
78	*/
79	void netfs_clear_buffer(struct xarray *buffer)
80	{
81	struct folio *folio;
82	XA_STATE(xas, buffer, 0);
83
84	rcu_read_lock();
85	xas_for_each_marked(&xas, folio, ULONG_MAX, NETFS_BUF_PUT_MARK) {
86	folio_put(folio);
87	}
88	rcu_read_unlock();
89	xa_destroy(buffer);
90	}
91
92	/**	11	/**
93	* netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback	12	* netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback
94	* @mapping: The mapping the folio belongs to.	13	* @mapping: The mapping the folio belongs to.

fs/netfs/write_issue.c+1−1

@@ -483,7 +483,7 @@ static int netfs_write_folio(struct netfs_io_request *wreq, · 482 unmodified lines
483	if (!debug)	483	if (!debug)
484	kdebug("R=%x: No submit", wreq->debug_id);	484	kdebug("R=%x: No submit", wreq->debug_id);
485		485
486	if (flen < fsize)	486	if (foff + flen < fsize)
487	for (int s = 0; s < NR_IO_STREAMS; s++)	487	for (int s = 0; s < NR_IO_STREAMS; s++)
488	netfs_issue_write(wreq, &wreq->io_streams[s]);	488	netfs_issue_write(wreq, &wreq->io_streams[s]);
489		489

fs/nfsd/nfsctl.c+2−0

 	nn->nfsd_svcstats.program = &nfsd_program;
 	nn->nfsd_versions = NULL;
 	nn->nfsd4_minorversions = NULL;
+	nn->nfsd_info.mutex = &nfsd_mutex;
+	nn->nfsd_serv = NULL;
 	nfsd4_init_leases_net(nn);
 	get_random_bytes(&nn->siphash_key, sizeof(nn->siphash_key));
 	seqlock_init(&nn->writeverf_lock);

fs/nfsd/nfssvc.c+0−1

@@ -672,7 +672,6 @@ int nfsd_create_serv(struct net *net) · 671 unmodified lines
672	return error;	672	return error;
673	}	673	}
674	spin_lock(&nfsd_notifier_lock);	674	spin_lock(&nfsd_notifier_lock);
675	nn->nfsd_info.mutex = &nfsd_mutex;
676	nn->nfsd_serv = serv;	675	nn->nfsd_serv = serv;
677	spin_unlock(&nfsd_notifier_lock);	676	spin_unlock(&nfsd_notifier_lock);
678		677

fs/nilfs2/alloc.c+15−4

  * @target: offset number of an entry in the group (start point)
  * @bsize: size in bits
  * @lock: spin lock protecting @bitmap
+ * @wrap: whether to wrap around
  */
 static int nilfs_palloc_find_available_slot(unsigned char *bitmap,
 					    unsigned long target,
 					    unsigned int bsize,
-					    spinlock_t *lock)
+					    spinlock_t *lock, bool wrap)
 {
 	int pos, end = bsize;
 		end = target;
 	}
+	if (!wrap)
+		return -ENOSPC;
 	/* wrap around */
 	for (pos = 0; pos < end; pos++) {
  * nilfs_palloc_prepare_alloc_entry - prepare to allocate a persistent object
  * @inode: inode of metadata file using this allocator
  * @req: nilfs_palloc_req structure exchanged for the allocation
+ * @wrap: whether to wrap around
  */
 int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
-				     struct nilfs_palloc_req *req)
+				     struct nilfs_palloc_req *req, bool wrap)
 {
 	struct buffer_head *desc_bh, *bitmap_bh;
 	struct nilfs_palloc_group_desc *desc;
 	entries_per_group = nilfs_palloc_entries_per_group(inode);
 	for (i = 0; i < ngroups; i += n) {
-		if (group >= ngroups) {
+		if (group >= ngroups && wrap) {
 			/* wrap around */
 			group = 0;
 			maxgroup = nilfs_palloc_group(inode, req->pr_entry_nr,
 			bitmap_kaddr = kmap_local_page(bitmap_bh->b_page);
 			bitmap = bitmap_kaddr + bh_offset(bitmap_bh);
 			pos = nilfs_palloc_find_available_slot(
-				bitmap, group_offset, entries_per_group, lock);
+				bitmap, group_offset, entries_per_group, lock,
+				wrap);
+			/*
+			 * Since the search for a free slot in the second and
+			 * subsequent bitmap blocks always starts from the
+			 * beginning, the wrap flag only has an effect on the
+			 * first search.
+			 */
 			kunmap_local(bitmap_kaddr);
 			if (pos >= 0)
 				goto found;

fs/nilfs2/alloc.h+2−2

@@ -50,8 +50,8 @@ struct nilfs_palloc_req { · 49 unmodified lines
50	struct buffer_head *pr_entry_bh;	50	struct buffer_head *pr_entry_bh;
51	};	51	};
52		52
53	int nilfs_palloc_prepare_alloc_entry(struct inode *,	53	int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
54	struct nilfs_palloc_req *);	54	struct nilfs_palloc_req *req, bool wrap);
55	void nilfs_palloc_commit_alloc_entry(struct inode *,	55	void nilfs_palloc_commit_alloc_entry(struct inode *,
56	struct nilfs_palloc_req *);	56	struct nilfs_palloc_req *);
57	void nilfs_palloc_abort_alloc_entry(struct inode , struct nilfs_palloc_req );	57	void nilfs_palloc_abort_alloc_entry(struct inode , struct nilfs_palloc_req );

fs/nilfs2/dat.c+1−1

@@ -75,7 +75,7 @@ int nilfs_dat_prepare_alloc(struct inode dat, struct nilfs_palloc_req req) · 74 unmodified lines
75	{	75	{
76	int ret;	76	int ret;
77		77
78	ret = nilfs_palloc_prepare_alloc_entry(dat, req);	78	ret = nilfs_palloc_prepare_alloc_entry(dat, req, true);
79	if (ret < 0)	79	if (ret < 0)
80	return ret;	80	return ret;
81		81

fs/nilfs2/dir.c+6−0

 			goto Enamelen;
 		if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
 			goto Espan;
+		if (unlikely(p->inode &&
+			     NILFS_PRIVATE_INODE(le64_to_cpu(p->inode))))
+			goto Einumber;
 	}
 	if (offs != limit)
 		goto Eend;
 	goto bad_entry;
 Espan:
 	error = "directory entry across blocks";
+	goto bad_entry;
+Einumber:
+	error = "disallowed inode number";
 bad_entry:
 	nilfs_error(sb,
 		    "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%zd, name_len=%d",

fs/nilfs2/ifile.c+2−5

 	struct nilfs_palloc_req req;
 	int ret;
-	req.pr_entry_nr = 0;  /*
+	req.pr_entry_nr = NILFS_FIRST_INO(ifile->i_sb);
-			       * 0 says find free inode from beginning
-			       * of a group. dull code!!
-			       */
 	req.pr_entry_bh = NULL;
-	ret = nilfs_palloc_prepare_alloc_entry(ifile, &req);
+	ret = nilfs_palloc_prepare_alloc_entry(ifile, &req, false);
 	if (!ret) {
 		ret = nilfs_palloc_get_entry_block(ifile, req.pr_entry_nr, 1,
 						   &req.pr_entry_bh);

fs/nilfs2/nilfs.h+8−2

 #define NILFS_FIRST_INO(sb) (((struct the_nilfs *)sb->s_fs_info)->ns_first_ino)
 #define NILFS_MDT_INODE(sb, ino) \
-	((ino) < NILFS_FIRST_INO(sb) && (NILFS_MDT_INO_BITS & BIT(ino)))
+	((ino) < NILFS_USER_INO && (NILFS_MDT_INO_BITS & BIT(ino)))
 #define NILFS_VALID_INODE(sb, ino) \
-	((ino) >= NILFS_FIRST_INO(sb) || (NILFS_SYS_INO_BITS & BIT(ino)))
+	((ino) >= NILFS_FIRST_INO(sb) ||				\
+	 ((ino) < NILFS_USER_INO && (NILFS_SYS_INO_BITS & BIT(ino))))
+#define NILFS_PRIVATE_INODE(ino) ({					\
+	ino_t __ino = (ino);						\
+	((__ino) < NILFS_USER_INO && (__ino) != NILFS_ROOT_INO &&	\
+	 (__ino) != NILFS_SKETCH_INO); })
 /**
  * struct nilfs_transaction_info: context information for synchronization

fs/nilfs2/the_nilfs.c+6−0

 	}
 	nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino);
+	if (nilfs->ns_first_ino < NILFS_USER_INO) {
+		nilfs_err(nilfs->ns_sb,
+			  "too small lower limit for non-reserved inode numbers: %u",
+			  nilfs->ns_first_ino);
+		return -EINVAL;
+	}
 	nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment);
 	if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) {

fs/nilfs2/the_nilfs.h+1−1

@@ -182,7 +182,7 @@ struct the_nilfs { · 181 unmodified lines
182	unsigned long ns_nrsvsegs;	182	unsigned long ns_nrsvsegs;
183	unsigned long ns_first_data_block;	183	unsigned long ns_first_data_block;
184	int ns_inode_size;	184	int ns_inode_size;
185	int ns_first_ino;	185	unsigned int ns_first_ino;
186	u32 ns_crc_seed;	186	u32 ns_crc_seed;
187		187
188	/* /sys/fs/<nilfs>/<device> */	188	/* /sys/fs/<nilfs>/<device> */

fs/open.c+17−9

 	return error;
 }
-SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
+SYSCALL_DEFINE2(ftruncate, unsigned int, fd, off_t, length)
 {
 	return do_sys_ftruncate(fd, length, 1);
 }
 #ifdef CONFIG_COMPAT
-COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
+COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_off_t, length)
 {
 	return do_sys_ftruncate(fd, length, 1);
 }
 		}
 	}
-	/*
-	 * Once we return a file with FMODE_OPENED, __fput() will call
-	 * fsnotify_close(), so we need fsnotify_open() here for symmetry.
-	 */
-	fsnotify_open(f);
 	return 0;
 cleanup_all:
  */
 int vfs_open(const struct path *path, struct file *file)
 {
+	int ret;
 	file->f_path = *path;
-	return do_dentry_open(file, NULL);
+	ret = do_dentry_open(file, NULL);
+	if (!ret) {
+		/*
+		 * Once we return a file with FMODE_OPENED, __fput() will call
+		 * fsnotify_close(), so we need fsnotify_open() here for
+		 * symmetry.
+		 */
+		fsnotify_open(file);
+	}
+	return ret;
 }
 struct file *dentry_open(const struct path *path, int flags,
 	error = do_dentry_open(f, NULL);
 	if (error) {
 		fput(f);
-		f = ERR_PTR(error);
+		return ERR_PTR(error);
 	}
+	fsnotify_open(f);
 	return f;
 }
 EXPORT_SYMBOL_GPL(kernel_file_open);

fs/super.c+10−1

@@ -1502,8 +1502,17 @@ static int fs_bdev_thaw(struct block_device *bdev) · 1501 unmodified lines
1502		1502
1503	lockdep_assert_held(&bdev->bd_fsfreeze_mutex);	1503	lockdep_assert_held(&bdev->bd_fsfreeze_mutex);
1504		1504
		1505	/*
		1506	* The block device may have been frozen before it was claimed by a
		1507	* filesystem. Concurrently another process might try to mount that
		1508	* frozen block device and has temporarily claimed the block device for
		1509	* that purpose causing a concurrent fs_bdev_thaw() to end up here. The
		1510	* mounter is already about to abort mounting because they still saw an
		1511	* elevanted bdev->bd_fsfreeze_count so get_bdev_super() will return
		1512	* NULL in that case.
		1513	*/
1505	sb = get_bdev_super(bdev);	1514	sb = get_bdev_super(bdev);
1506	if (WARN_ON_ONCE(!sb))	1515	if (!sb)
1507	return -EINVAL;	1516	return -EINVAL;
1508		1517
1509	if (sb->s_op->thaw_super)	1518	if (sb->s_op->thaw_super)

fs/xfs/libxfs/xfs_bmap.c+27−4

 	xfs_extlen_t		indlen;
 	uint64_t		fdblocks;
 	int			error;
-	xfs_fileoff_t		aoff = off;
+	xfs_fileoff_t		aoff;
+	bool			use_cowextszhint =
+					whichfork == XFS_COW_FORK && !prealloc;
+retry:
 	/*
 	 * Cap the alloc length. Keep track of prealloc so we know whether to
 	 * tag the inode before we return.
 	 */
+	aoff = off;
 	alen = XFS_FILBLKS_MIN(len + prealloc, XFS_MAX_BMBT_EXTLEN);
 	if (!eof)
 		alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
 	if (prealloc && alen >= len)
 		prealloc = alen - len;
-	/* Figure out the extent size, adjust alen */
+	/*
-	if (whichfork == XFS_COW_FORK) {
+	 * If we're targetting the COW fork but aren't creating a speculative
+	 * posteof preallocation, try to expand the reservation to align with
+	 * the COW extent size hint if there's sufficient free space.
+	 *
+	 * Unlike the data fork, the CoW cancellation functions will free all
+	 * the reservations at inactivation, so we don't require that every
+	 * delalloc reservation have a dirty pagecache.
+	 */
+	if (use_cowextszhint) {
 		struct xfs_bmbt_irec	prev;
 		xfs_extlen_t		extsz = xfs_get_cowextsz_hint(ip);
 	 */
 	error = xfs_quota_reserve_blkres(ip, alen);
 	if (error)
-		return error;
+		goto out;
 	/*
 	 * Split changing sb for alen and indlen since they could be coming
 out_unreserve_quota:
 	if (XFS_IS_QUOTA_ON(mp))
 		xfs_quota_unreserve_blkres(ip, alen);
+out:
+	if (error == -ENOSPC || error == -EDQUOT) {
+		trace_xfs_delalloc_enospc(ip, off, len);
+		if (prealloc || use_cowextszhint) {
+			/* retry without any preallocation */
+			use_cowextszhint = false;
+			prealloc = 0;
+			goto retry;
+		}
+	}
 	return error;
 }

fs/xfs/libxfs/xfs_fs.h+1−1

@@ -996,7 +996,7 @@ struct xfs_getparents_by_handle { · 995 unmodified lines
996	#define XFS_IOC_FSGEOMETRY _IOR ('X', 126, struct xfs_fsop_geom)	996	#define XFS_IOC_FSGEOMETRY _IOR ('X', 126, struct xfs_fsop_geom)
997	#define XFS_IOC_BULKSTAT _IOR ('X', 127, struct xfs_bulkstat_req)	997	#define XFS_IOC_BULKSTAT _IOR ('X', 127, struct xfs_bulkstat_req)
998	#define XFS_IOC_INUMBERS _IOR ('X', 128, struct xfs_inumbers_req)	998	#define XFS_IOC_INUMBERS _IOR ('X', 128, struct xfs_inumbers_req)
999	#define XFS_IOC_EXCHANGE_RANGE _IOWR('X', 129, struct xfs_exchange_range)	999	#define XFS_IOC_EXCHANGE_RANGE _IOW ('X', 129, struct xfs_exchange_range)
1000	/* XFS_IOC_GETFSUUID ---------- deprecated 140 */	1000	/* XFS_IOC_GETFSUUID ---------- deprecated 140 */
1001		1001
1002		1002

fs/xfs/libxfs/xfs_inode_buf.c+18−5

 		/*
 		 * A directory small enough to fit in the inode must be stored
 		 * in local format.  The directory sf <-> extents conversion
-		 * code updates the directory size accordingly.
+		 * code updates the directory size accordingly.  Directories
+		 * being truncated have zero size and are not subject to this
+		 * check.
 		 */
 		if (S_ISDIR(mode)) {
-			if (be64_to_cpu(dip->di_size) <= fork_size &&
+			if (dip->di_size &&
+			    be64_to_cpu(dip->di_size) <= fork_size &&
 			    fork_format != XFS_DINODE_FMT_LOCAL)
 				return __this_address;
 		}
 	if (mode && xfs_mode_to_ftype(mode) == XFS_DIR3_FT_UNKNOWN)
 		return __this_address;
-	/* No zero-length symlinks/dirs. */
+	/*
-	if ((S_ISLNK(mode) || S_ISDIR(mode)) && di_size == 0)
+	 * No zero-length symlinks/dirs unless they're unlinked and hence being
-		return __this_address;
+	 * inactivated.
+	 */
+	if ((S_ISLNK(mode) || S_ISDIR(mode)) && di_size == 0) {
+		if (dip->di_version > 1) {
+			if (dip->di_nlink)
+				return __this_address;
+		} else {
+			if (dip->di_onlink)
+				return __this_address;
+		}
+	}
 	fa = xfs_dinode_verify_nrext64(mp, dip);
 	if (fa)

fs/xfs/xfs_bmap_util.c+22−8

 /*
  * Test whether it is appropriate to check an inode for and free post EOF
- * blocks. The 'force' parameter determines whether we should also consider
+ * blocks.
- * regular files that are marked preallocated or append-only.
  */
 bool
 xfs_can_free_eofblocks(
-	struct xfs_inode	*ip,
+	struct xfs_inode	*ip)
-	bool			force)
 {
 	struct xfs_bmbt_irec	imap;
 	struct xfs_mount	*mp = ip->i_mount;
 		return false;
 	/*
-	 * Do not free real preallocated or append-only files unless the file
+	 * Only free real extents for inodes with persistent preallocations or
-	 * has delalloc blocks and we are forced to remove them.
+	 * the append-only flag.
 	 */
 	if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
-		if (!force || ip->i_delayed_blks == 0)
+		if (ip->i_delayed_blks == 0)
 			return false;
 	/*
 	/* Wait on dio to ensure i_size has settled. */
 	inode_dio_wait(VFS_I(ip));
+	/*
+	 * For preallocated files only free delayed allocations.
+	 *
+	 * Note that this means we also leave speculative preallocations in
+	 * place for preallocated files.
+	 */
+	if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) {
+		if (ip->i_delayed_blks) {
+			xfs_bmap_punch_delalloc_range(ip,
+				round_up(XFS_ISIZE(ip), mp->m_sb.sb_blocksize),
+				LLONG_MAX);
+		}
+		xfs_inode_clear_eofblocks_tag(ip);
+		return 0;
+	}
 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
 	if (error) {
 		ASSERT(xfs_is_shutdown(mp));
 	 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
 	 * into the accessible region of the file.
 	 */
-	if (xfs_can_free_eofblocks(ip, true)) {
+	if (xfs_can_free_eofblocks(ip)) {
 		error = xfs_free_eofblocks(ip);
 		if (error)
 			return error;

fs/xfs/xfs_bmap_util.h+1−1

@@ -63,7 +63,7 @@ int xfs_insert_file_space(struct xfs_inode *, xfs_off_t offset, · 62 unmodified lines
63	xfs_off_t len);	63	xfs_off_t len);
64		64
65	/* EOF block manipulation functions */	65	/* EOF block manipulation functions */
66	bool xfs_can_free_eofblocks(struct xfs_inode *ip, bool force);	66	bool xfs_can_free_eofblocks(struct xfs_inode *ip);
67	int xfs_free_eofblocks(struct xfs_inode *ip);	67	int xfs_free_eofblocks(struct xfs_inode *ip);
68		68
69	int xfs_swap_extents(struct xfs_inode ip, struct xfs_inode tip,	69	int xfs_swap_extents(struct xfs_inode ip, struct xfs_inode tip,

fs/xfs/xfs_icache.c+1−1

@@ -1155,7 +1155,7 @@ xfs_inode_free_eofblocks( · 1154 unmodified lines
1155	}	1155	}
1156	*lockflags \|= XFS_IOLOCK_EXCL;	1156	*lockflags \|= XFS_IOLOCK_EXCL;
1157		1157
1158	if (xfs_can_free_eofblocks(ip, false))	1158	if (xfs_can_free_eofblocks(ip))
1159	return xfs_free_eofblocks(ip);	1159	return xfs_free_eofblocks(ip);
1160		1160
1161	/* inode could be preallocated or append-only */	1161	/* inode could be preallocated or append-only */

fs/xfs/xfs_inode.c+13−11

 #include "xfs_pnfs.h"
 #include "xfs_parent.h"
 #include "xfs_xattr.h"
+#include "xfs_sb.h"
 struct kmem_cache *xfs_inode_cache;
 	 * this saves us from needing to run a separate transaction to set the
 	 * fork offset in the immediate future.
 	 */
-	if (init_xattrs && xfs_has_attr(mp)) {
+	if (init_xattrs) {
 		ip->i_forkoff = xfs_default_attroffset(ip) >> 3;
 		xfs_ifork_init_attr(ip, XFS_DINODE_FMT_EXTENTS, 0);
+		if (!xfs_has_attr(mp)) {
+			spin_lock(&mp->m_sb_lock);
+			xfs_add_attr(mp);
+			spin_unlock(&mp->m_sb_lock);
+			xfs_log_sb(tp);
+		}
 	}
 	/*
 	if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL))
 		return 0;
-	if (xfs_can_free_eofblocks(ip, false)) {
+	if (xfs_can_free_eofblocks(ip)) {
 		/*
 		 * Check if the inode is being opened, written and closed
 		 * frequently and we have delayed allocation blocks outstanding
 	/*
 	 * This file isn't being freed, so check if there are post-eof blocks
-	 * to free.  @force is true because we are evicting an inode from the
+	 * to free.
-	 * cache.  Post-eof blocks must be freed, lest we end up with broken
-	 * free space accounting.
 	 *
 	 * Note: don't bother with iolock here since lockdep complains about
 	 * acquiring it in reclaim context. We have the only reference to the
 	 * inode at this point anyways.
 	 */
-	return xfs_can_free_eofblocks(ip, true);
+	return xfs_can_free_eofblocks(ip);
 }
 /*
 	if (VFS_I(ip)->i_nlink != 0) {
 		/*
-		 * force is true because we are evicting an inode from the
-		 * cache. Post-eof blocks must be freed, lest we end up with
-		 * broken free space accounting.
-		 *
 		 * Note: don't bother with iolock here since lockdep complains
 		 * about acquiring it in reclaim context. We have the only
 		 * reference to the inode at this point anyways.
 		 */
-		if (xfs_can_free_eofblocks(ip, true))
+		if (xfs_can_free_eofblocks(ip))
 			error = xfs_free_eofblocks(ip);
 		goto out;

fs/xfs/xfs_iomap.c+12−22

 		}
 	}
-retry:
-	error = xfs_bmapi_reserve_delalloc(ip, allocfork, offset_fsb,
-			end_fsb - offset_fsb, prealloc_blocks,
-			allocfork == XFS_DATA_FORK ? &imap : &cmap,
-			allocfork == XFS_DATA_FORK ? &icur : &ccur,
-			allocfork == XFS_DATA_FORK ? eof : cow_eof);
-	switch (error) {
-	case 0:
-		break;
-	case -ENOSPC:
-	case -EDQUOT:
-		/* retry without any preallocation */
-		trace_xfs_delalloc_enospc(ip, offset, count);
-		if (prealloc_blocks) {
-			prealloc_blocks = 0;
-			goto retry;
-		}
-		fallthrough;
-	default:
-		goto out_unlock;
-	}
 	if (allocfork == XFS_COW_FORK) {
+		error = xfs_bmapi_reserve_delalloc(ip, allocfork, offset_fsb,
+				end_fsb - offset_fsb, prealloc_blocks, &cmap,
+				&ccur, cow_eof);
+		if (error)
+			goto out_unlock;
 		trace_xfs_iomap_alloc(ip, offset, count, allocfork, &cmap);
 		goto found_cow;
 	}
+	error = xfs_bmapi_reserve_delalloc(ip, allocfork, offset_fsb,
+			end_fsb - offset_fsb, prealloc_blocks, &imap, &icur,
+			eof);
+	if (error)
+		goto out_unlock;
 	/*
 	 * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
 	 * them out if the write happens to fail.

include/asm-generic/syscalls.h+1−1

@@ -19,7 +19,7 @@ asmlinkage long sys_mmap2(unsigned long addr, unsigned long len, · 18 unmodified lines
19	#ifndef sys_mmap	19	#ifndef sys_mmap
20	asmlinkage long sys_mmap(unsigned long addr, unsigned long len,	20	asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
21	unsigned long prot, unsigned long flags,	21	unsigned long prot, unsigned long flags,
22	unsigned long fd, off_t pgoff);	22	unsigned long fd, unsigned long off);
23	#endif	23	#endif
24		24
25	#ifndef sys_rt_sigreturn	25	#ifndef sys_rt_sigreturn

include/linux/closure.h+23−0

@@ -284,6 +284,21 @@ static inline void closure_get(struct closure *cl) · 283 unmodified lines
284	#endif	284	#endif
285	}	285	}
286		286
		287	/**
		288	* closure_get_not_zero
		289	*/
		290	static inline bool closure_get_not_zero(struct closure *cl)
		291	{
		292	unsigned old = atomic_read(&cl->remaining);
		293	do {
		294	if (!(old & CLOSURE_REMAINING_MASK))
		295	return false;
		296
		297	} while (!atomic_try_cmpxchg_acquire(&cl->remaining, &old, old + 1));
		298
		299	return true;
		300	}
		301
287	/**	302	/**
288	* closure_init - Initialize a closure, setting the refcount to 1	303	* closure_init - Initialize a closure, setting the refcount to 1
289	* @cl: closure to initialize	304	* @cl: closure to initialize
@@ -310,6 +325,12 @@ static inline void closure_init_stack(struct closure *cl) · 20 unmodified lines
310	atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);	325	atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);
311	}	326	}
312		327
		328	static inline void closure_init_stack_release(struct closure *cl)
		329	{
		330	memset(cl, 0, sizeof(struct closure));
		331	atomic_set_release(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);
		332	}
		333
313	/**	334	/**
314	* closure_wake_up - wake up all closures on a wait list,	335	* closure_wake_up - wake up all closures on a wait list,
315	* with memory barrier	336	* with memory barrier
@@ -355,6 +376,8 @@ do { \ · 39 unmodified lines
355	*/	376	*/
356	#define closure_return(_cl) continue_at((_cl), NULL, NULL)	377	#define closure_return(_cl) continue_at((_cl), NULL, NULL)
357		378
		379	void closure_return_sync(struct closure *cl);
		380
358	/**	381	/**
359	* continue_at_nobarrier - jump to another function without barrier	382	* continue_at_nobarrier - jump to another function without barrier
360	*	383	*

include/linux/compat.h+1−1

@@ -608,7 +608,7 @@ asmlinkage long compat_sys_fstatfs(unsigned int fd, · 607 unmodified lines
608	asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,	608	asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
609	struct compat_statfs64 __user *buf);	609	struct compat_statfs64 __user *buf);
610	asmlinkage long compat_sys_truncate(const char __user *, compat_off_t);	610	asmlinkage long compat_sys_truncate(const char __user *, compat_off_t);
611	asmlinkage long compat_sys_ftruncate(unsigned int, compat_ulong_t);	611	asmlinkage long compat_sys_ftruncate(unsigned int, compat_off_t);
612	/* No generic prototype for truncate64, ftruncate64, fallocate */	612	/* No generic prototype for truncate64, ftruncate64, fallocate */
613	asmlinkage long compat_sys_openat(int dfd, const char __user *filename,	613	asmlinkage long compat_sys_openat(int dfd, const char __user *filename,
614	int flags, umode_t mode);	614	int flags, umode_t mode);

include/linux/filter.h+7−7

@@ -1313,18 +1313,18 @@ static inline bool bpf_jit_kallsyms_enabled(void) · 1312 unmodified lines
1313	return false;	1313	return false;
1314	}	1314	}
1315		1315
1316	const char __bpf_address_lookup(unsigned long addr, unsigned long size,	1316	int __bpf_address_lookup(unsigned long addr, unsigned long *size,
1317	unsigned long off, char sym);	1317	unsigned long off, char sym);
1318	bool is_bpf_text_address(unsigned long addr);	1318	bool is_bpf_text_address(unsigned long addr);
1319	int bpf_get_kallsym(unsigned int symnum, unsigned long value, char type,	1319	int bpf_get_kallsym(unsigned int symnum, unsigned long value, char type,
1320	char *sym);	1320	char *sym);
1321	struct bpf_prog *bpf_prog_ksym_find(unsigned long addr);	1321	struct bpf_prog *bpf_prog_ksym_find(unsigned long addr);
1322		1322
1323	static inline const char *	1323	static inline int
1324	bpf_address_lookup(unsigned long addr, unsigned long *size,	1324	bpf_address_lookup(unsigned long addr, unsigned long *size,
1325	unsigned long off, char modname, char sym)	1325	unsigned long off, char modname, char sym)
1326	{	1326	{
1327	const char *ret = __bpf_address_lookup(addr, size, off, sym);	1327	int ret = __bpf_address_lookup(addr, size, off, sym);
1328		1328
1329	if (ret && modname)	1329	if (ret && modname)
1330	*modname = NULL;	1330	*modname = NULL;
@@ -1368,11 +1368,11 @@ static inline bool bpf_jit_kallsyms_enabled(void) · 37 unmodified lines
1368	return false;	1368	return false;
1369	}	1369	}
1370		1370
1371	static inline const char *	1371	static inline int
1372	__bpf_address_lookup(unsigned long addr, unsigned long *size,	1372	__bpf_address_lookup(unsigned long addr, unsigned long *size,
1373	unsigned long off, char sym)	1373	unsigned long off, char sym)
1374	{	1374	{
1375	return NULL;	1375	return 0;
1376	}	1376	}
1377		1377
1378	static inline bool is_bpf_text_address(unsigned long addr)	1378	static inline bool is_bpf_text_address(unsigned long addr)
@@ -1391,11 +1391,11 @@ static inline struct bpf_prog *bpf_prog_ksym_find(unsigned long addr) · 12 unmodified lines
1391	return NULL;	1391	return NULL;
1392	}	1392	}
1393		1393
1394	static inline const char *	1394	static inline int
1395	bpf_address_lookup(unsigned long addr, unsigned long *size,	1395	bpf_address_lookup(unsigned long addr, unsigned long *size,
1396	unsigned long off, char modname, char sym)	1396	unsigned long off, char modname, char sym)
1397	{	1397	{
1398	return NULL;	1398	return 0;
1399	}	1399	}
1400		1400
1401	static inline void bpf_prog_kallsyms_add(struct bpf_prog *fp)	1401	static inline void bpf_prog_kallsyms_add(struct bpf_prog *fp)

include/linux/fsnotify.h+7−1

 {
 	const struct path *path;
-	if (file->f_mode & FMODE_NONOTIFY)
+	/*
+	 * FMODE_NONOTIFY are fds generated by fanotify itself which should not
+	 * generate new events. We also don't want to generate events for
+	 * FMODE_PATH fds (involves open & close events) as they are just
+	 * handle creation / destruction events and not "real" file events.
+	 */
+	if (file->f_mode & (FMODE_NONOTIFY | FMODE_PATH))
 		return 0;
 	path = &file->f_path;

include/linux/ftrace.h+3−3

@@ -86,15 +86,15 @@ struct ftrace_hash; · 85 unmodified lines
86		86
87	#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_MODULES) && \	87	#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_MODULES) && \
88	defined(CONFIG_DYNAMIC_FTRACE)	88	defined(CONFIG_DYNAMIC_FTRACE)
89	const char *	89	int
90	ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,	90	ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
91	unsigned long off, char modname, char sym);	91	unsigned long off, char modname, char sym);
92	#else	92	#else
93	static inline const char *	93	static inline int
94	ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,	94	ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
95	unsigned long off, char modname, char sym)	95	unsigned long off, char modname, char sym)
96	{	96	{
97	return NULL;	97	return 0;
98	}	98	}
99	#endif	99	#endif
100		100

include/linux/io_uring_types.h+0−1

@@ -207,7 +207,6 @@ struct io_submit_state { · 206 unmodified lines
207	bool need_plug;	207	bool need_plug;
208	bool cq_flush;	208	bool cq_flush;
209	unsigned short submit_nr;	209	unsigned short submit_nr;
210	unsigned int cqes_count;
211	struct blk_plug plug;	210	struct blk_plug plug;
212	};	211	};
213		212

include/linux/libata.h+1−0

@@ -1249,6 +1249,7 @@ extern int ata_slave_link_init(struct ata_port *ap); · 1248 unmodified lines
1249	extern struct ata_port ata_sas_port_alloc(struct ata_host ,	1249	extern struct ata_port ata_sas_port_alloc(struct ata_host ,
1250	struct ata_port_info , struct Scsi_Host );	1250	struct ata_port_info , struct Scsi_Host );
1251	extern void ata_port_probe(struct ata_port *ap);	1251	extern void ata_port_probe(struct ata_port *ap);
		1252	extern void ata_port_free(struct ata_port *ap);
1252	extern int ata_sas_tport_add(struct device parent, struct ata_port ap);	1253	extern int ata_sas_tport_add(struct device parent, struct ata_port ap);
1253	extern void ata_sas_tport_delete(struct ata_port *ap);	1254	extern void ata_sas_tport_delete(struct ata_port *ap);
1254	int ata_sas_device_configure(struct scsi_device sdev, struct queue_limits lim,	1255	int ata_sas_device_configure(struct scsi_device sdev, struct queue_limits lim,

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

 	u8	   min_mkey_log_entity_size_fixed_buffer_valid[0x1];
 	u8	   reserved_at_402[0x1e];
-	u8	   reserved_at_420[0x3e0];
+	u8	   reserved_at_420[0x20];
+	u8	   reserved_at_440[0x8];
+	u8	   max_num_eqs_24b[0x18];
+	u8	   reserved_at_460[0x3a0];
 };
 enum mlx5_ifc_flow_destination_type {

include/linux/module.h+7−7

@@ -931,11 +931,11 @@ int module_kallsyms_on_each_symbol(const char *modname, · 930 unmodified lines
931	* least KSYM_NAME_LEN long: a pointer to namebuf is returned if	931	* least KSYM_NAME_LEN long: a pointer to namebuf is returned if
932	* found, otherwise NULL.	932	* found, otherwise NULL.
933	*/	933	*/
934	const char *module_address_lookup(unsigned long addr,	934	int module_address_lookup(unsigned long addr,
935	unsigned long *symbolsize,	935	unsigned long *symbolsize,
936	unsigned long *offset,	936	unsigned long *offset,
937	char modname, const unsigned char modbuildid,	937	char modname, const unsigned char modbuildid,
938	char *namebuf);	938	char *namebuf);
939	int lookup_module_symbol_name(unsigned long addr, char *symname);	939	int lookup_module_symbol_name(unsigned long addr, char *symname);
940	int lookup_module_symbol_attrs(unsigned long addr,	940	int lookup_module_symbol_attrs(unsigned long addr,
941	unsigned long *size,	941	unsigned long *size,
@@ -964,14 +964,14 @@ static inline int module_kallsyms_on_each_symbol(const char *modname, · 22 unmodified lines
964	}	964	}
965		965
966	/* For kallsyms to ask for address resolution. NULL means not found. */	966	/* For kallsyms to ask for address resolution. NULL means not found. */
967	static inline const char *module_address_lookup(unsigned long addr,	967	static inline int module_address_lookup(unsigned long addr,
968	unsigned long *symbolsize,	968	unsigned long *symbolsize,
969	unsigned long *offset,	969	unsigned long *offset,
970	char **modname,	970	char **modname,
971	const unsigned char **modbuildid,	971	const unsigned char **modbuildid,
972	char *namebuf)	972	char *namebuf)
973	{	973	{
974	return NULL;	974	return 0;
975	}	975	}
976		976
977	static inline int lookup_module_symbol_name(unsigned long addr, char *symname)	977	static inline int lookup_module_symbol_name(unsigned long addr, char *symname)

include/linux/nvme.h+4−2

 enum {
 	NVMF_RDMA_QPTYPE_CONNECTED	= 1, /* Reliable Connected */
 	NVMF_RDMA_QPTYPE_DATAGRAM	= 2, /* Reliable Datagram */
+	NVMF_RDMA_QPTYPE_INVALID	= 0xff,
 };
-/* RDMA QP Service Type codes for Discovery Log Page entry TSAS
+/* RDMA Provider Type codes for Discovery Log Page entry TSAS
- * RDMA_QPTYPE field
+ * RDMA_PRTYPE field
  */
 enum {
 	NVMF_RDMA_PRTYPE_NOT_SPECIFIED	= 1, /* No Provider Specified */
 	NVMF_TCP_SECTYPE_NONE = 0, /* No Security */
 	NVMF_TCP_SECTYPE_TLS12 = 1, /* TLSv1.2, NVMe-oF 1.1 and NVMe-TCP 3.6.1.1 */
 	NVMF_TCP_SECTYPE_TLS13 = 2, /* TLSv1.3, NVMe-oF 1.1 and NVMe-TCP 3.6.1.1 */
+	NVMF_TCP_SECTYPE_INVALID = 0xff,
 };
 #define NVME_AQ_DEPTH		32

include/linux/phy.h+1−1

@@ -1126,7 +1126,7 @@ struct phy_driver { · 1125 unmodified lines
1126	u8 index, enum led_brightness value);	1126	u8 index, enum led_brightness value);
1127		1127
1128	/**	1128	/**
1129	* @led_blink_set: Set a PHY LED brightness. Index indicates	1129	* @led_blink_set: Set a PHY LED blinking. Index indicates
1130	* which of the PHYs led should be configured to blink. Delays	1130	* which of the PHYs led should be configured to blink. Delays
1131	* are in milliseconds and if both are zero then a sensible	1131	* are in milliseconds and if both are zero then a sensible
1132	* default should be chosen. The call should adjust the	1132	* default should be chosen. The call should adjust the

include/linux/printk.h+0−3

@@ -60,9 +60,6 @@ static inline const char printk_skip_headers(const char buffer) · 59 unmodified lines
60	#define CONSOLE_LOGLEVEL_DEFAULT CONFIG_CONSOLE_LOGLEVEL_DEFAULT	60	#define CONSOLE_LOGLEVEL_DEFAULT CONFIG_CONSOLE_LOGLEVEL_DEFAULT
61	#define CONSOLE_LOGLEVEL_QUIET CONFIG_CONSOLE_LOGLEVEL_QUIET	61	#define CONSOLE_LOGLEVEL_QUIET CONFIG_CONSOLE_LOGLEVEL_QUIET
62		62
63	int add_preferred_console_match(const char match, const char name,
64	const short idx);
65
66	extern int console_printk[];	63	extern int console_printk[];
67		64
68	#define console_loglevel (console_printk[0])	65	#define console_loglevel (console_printk[0])

include/linux/serial_core.h+19−2

@@ -811,8 +811,7 @@ enum UART_TX_FLAGS { · 810 unmodified lines
811	if (pending < WAKEUP_CHARS) { \	811	if (pending < WAKEUP_CHARS) { \
812	uart_write_wakeup(__port); \	812	uart_write_wakeup(__port); \
813	\	813	\
814	if (!((flags) & UART_TX_NOSTOP) && pending == 0 && \	814	if (!((flags) & UART_TX_NOSTOP) && pending == 0) \
815	__port->ops->tx_empty(__port)) \
816	__port->ops->stop_tx(__port); \	815	__port->ops->stop_tx(__port); \
817	} \	816	} \
818	\	817	\
@@ -851,6 +850,24 @@ enum UART_TX_FLAGS { · 32 unmodified lines
851	__count--); \	850	__count--); \
852	})	851	})
853		852
		853	/**
		854	* uart_port_tx_limited_flags -- transmit helper for uart_port with count limiting with flags
		855	* @port: uart port
		856	* @ch: variable to store a character to be written to the HW
		857	* @flags: %UART_TX_NOSTOP or similar
		858	* @count: a limit of characters to send
		859	* @tx_ready: can HW accept more data function
		860	* @put_char: function to write a character
		861	* @tx_done: function to call after the loop is done
		862	*
		863	* See uart_port_tx_limited() for more details.
		864	*/
		865	#define uart_port_tx_limited_flags(port, ch, flags, count, tx_ready, put_char, tx_done) ({ \
		866	unsigned int __count = (count); \
		867	__uart_port_tx(port, ch, flags, tx_ready, put_char, tx_done, __count, \
		868	__count--); \
		869	})
		870
854	/**	871	/**
855	* uart_port_tx -- transmit helper for uart_port	872	* uart_port_tx -- transmit helper for uart_port
856	* @port: uart port	873	* @port: uart port

include/linux/syscalls.h+16−10

 				long nr,
 				struct io_event __user *events,
 				struct __kernel_timespec __user *timeout,
-				const struct __aio_sigset *sig);
+				const struct __aio_sigset __user *sig);
 asmlinkage long sys_io_pgetevents_time32(aio_context_t ctx_id,
 				long min_nr,
 				long nr,
 				struct io_event __user *events,
 				struct old_timespec32 __user *timeout,
-				const struct __aio_sigset *sig);
+				const struct __aio_sigset __user *sig);
 asmlinkage long sys_io_uring_setup(u32 entries,
 				struct io_uring_params __user *p);
 asmlinkage long sys_io_uring_enter(unsigned int fd, u32 to_submit,
 			      u64 __user *mnt_ids, size_t nr_mnt_ids,
 			      unsigned int flags);
 asmlinkage long sys_truncate(const char __user *path, long length);
-asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
+asmlinkage long sys_ftruncate(unsigned int fd, off_t length);
 #if BITS_PER_LONG == 32
 asmlinkage long sys_truncate64(const char __user *path, loff_t length);
 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length);
 asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
 			   umode_t mode);
 asmlinkage long sys_openat2(int dfd, const char __user *filename,
-			    struct open_how *how, size_t size);
+			    struct open_how __user *how, size_t size);
 asmlinkage long sys_close(unsigned int fd);
 asmlinkage long sys_close_range(unsigned int fd, unsigned int max_fd,
 				unsigned int flags);
 asmlinkage long sys_set_robust_list(struct robust_list_head __user *head,
 				    size_t len);
-asmlinkage long sys_futex_waitv(struct futex_waitv *waiters,
+asmlinkage long sys_futex_waitv(struct futex_waitv __user *waiters,
 				unsigned int nr_futexes, unsigned int flags,
 				struct __kernel_timespec __user *timeout, clockid_t clockid);
 				const struct rlimit64 __user *new_rlim,
 				struct rlimit64 __user *old_rlim);
 asmlinkage long sys_fanotify_init(unsigned int flags, unsigned int event_f_flags);
+#if defined(CONFIG_ARCH_SPLIT_ARG64)
+asmlinkage long sys_fanotify_mark(int fanotify_fd, unsigned int flags,
+                                unsigned int mask_1, unsigned int mask_2,
+				int dfd, const char  __user * pathname);
+#else
 asmlinkage long sys_fanotify_mark(int fanotify_fd, unsigned int flags,
 				  u64 mask, int fd,
 				  const char  __user *pathname);
+#endif
 asmlinkage long sys_name_to_handle_at(int dfd, const char __user *name,
 				      struct file_handle __user *handle,
 				      int __user *mnt_id, int flag);
 asmlinkage long sys_getrandom(char __user *buf, size_t count,
 			      unsigned int flags);
 asmlinkage long sys_memfd_create(const char __user *uname_ptr, unsigned int flags);
-asmlinkage long sys_bpf(int cmd, union bpf_attr *attr, unsigned int size);
+asmlinkage long sys_bpf(int cmd, union bpf_attr __user *attr, unsigned int size);
 asmlinkage long sys_execveat(int dfd, const char __user *filename,
 			const char __user *const __user *argv,
 			const char __user *const __user *envp, int flags);
 		struct cachestat_range __user *cstat_range,
 		struct cachestat __user *cstat, unsigned int flags);
 asmlinkage long sys_map_shadow_stack(unsigned long addr, unsigned long size, unsigned int flags);
-asmlinkage long sys_lsm_get_self_attr(unsigned int attr, struct lsm_ctx *ctx,
+asmlinkage long sys_lsm_get_self_attr(unsigned int attr, struct lsm_ctx __user *ctx,
-				      u32 *size, u32 flags);
+				      u32 __user *size, u32 flags);
-asmlinkage long sys_lsm_set_self_attr(unsigned int attr, struct lsm_ctx *ctx,
+asmlinkage long sys_lsm_set_self_attr(unsigned int attr, struct lsm_ctx __user *ctx,
 				      u32 size, u32 flags);
-asmlinkage long sys_lsm_list_modules(u64 *ids, u32 *size, u32 flags);
+asmlinkage long sys_lsm_list_modules(u64 __user *ids, u32 __user *size, u32 flags);
 /*
  * Architecture-specific system calls

include/net/bluetooth/hci.h+11−0

@@ -324,6 +324,17 @@ enum { · 323 unmodified lines
324	* claim to support it.	324	* claim to support it.
325	*/	325	*/
326	HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE,	326	HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE,
		327
		328	/*
		329	* When this quirk is set, the reserved bits of Primary/Secondary_PHY
		330	* inside the LE Extended Advertising Report events are discarded.
		331	* This is required for some Apple/Broadcom controllers which
		332	* abuse these reserved bits for unrelated flags.
		333	*
		334	* This quirk can be set before hci_register_dev is called or
		335	* during the hdev->setup vendor callback.
		336	*/
		337	HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY,
327	};	338	};
328		339
329	/* HCI device flags */	340	/* HCI device flags */

include/net/bluetooth/hci_sync.h+2−0

@@ -38,6 +38,8 @@ int __hci_cmd_sync_status(struct hci_dev *hdev, u16 opcode, u32 plen, · 37 unmodified lines
38	int __hci_cmd_sync_status_sk(struct hci_dev *hdev, u16 opcode, u32 plen,	38	int __hci_cmd_sync_status_sk(struct hci_dev *hdev, u16 opcode, u32 plen,
39	const void *param, u8 event, u32 timeout,	39	const void *param, u8 event, u32 timeout,
40	struct sock *sk);	40	struct sock *sk);
		41	int hci_cmd_sync_status(struct hci_dev *hdev, u16 opcode, u32 plen,
		42	const void *param, u32 timeout);
41		43
42	void hci_cmd_sync_init(struct hci_dev *hdev);	44	void hci_cmd_sync_init(struct hci_dev *hdev);
43	void hci_cmd_sync_clear(struct hci_dev *hdev);	45	void hci_cmd_sync_clear(struct hci_dev *hdev);

include/net/mac80211.h+1−1

@@ -396,7 +396,7 @@ enum ieee80211_bss_change { · 395 unmodified lines
396	BSS_CHANGED_HE_OBSS_PD = 1<<28,	396	BSS_CHANGED_HE_OBSS_PD = 1<<28,
397	BSS_CHANGED_HE_BSS_COLOR = 1<<29,	397	BSS_CHANGED_HE_BSS_COLOR = 1<<29,
398	BSS_CHANGED_FILS_DISCOVERY = 1<<30,	398	BSS_CHANGED_FILS_DISCOVERY = 1<<30,
399	BSS_CHANGED_UNSOL_BCAST_PROBE_RESP = 1<<31,	399	BSS_CHANGED_UNSOL_BCAST_PROBE_RESP = BIT_ULL(31),
400	BSS_CHANGED_MLD_VALID_LINKS = BIT_ULL(33),	400	BSS_CHANGED_MLD_VALID_LINKS = BIT_ULL(33),
401	BSS_CHANGED_MLD_TTLM = BIT_ULL(34),	401	BSS_CHANGED_MLD_TTLM = BIT_ULL(34),
402	BSS_CHANGED_TPE = BIT_ULL(35),	402	BSS_CHANGED_TPE = BIT_ULL(35),

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

@@ -737,7 +737,7 @@ __SC_COMP(__NR_pselect6_time64, sys_pselect6, compat_sys_pselect6_time64) · 736 unmodified lines
737	#define __NR_ppoll_time64 414	737	#define __NR_ppoll_time64 414
738	__SC_COMP(__NR_ppoll_time64, sys_ppoll, compat_sys_ppoll_time64)	738	__SC_COMP(__NR_ppoll_time64, sys_ppoll, compat_sys_ppoll_time64)
739	#define __NR_io_pgetevents_time64 416	739	#define __NR_io_pgetevents_time64 416
740	__SYSCALL(__NR_io_pgetevents_time64, sys_io_pgetevents)	740	__SC_COMP(__NR_io_pgetevents_time64, sys_io_pgetevents, compat_sys_io_pgetevents_time64)
741	#define __NR_recvmmsg_time64 417	741	#define __NR_recvmmsg_time64 417
742	__SC_COMP(__NR_recvmmsg_time64, sys_recvmmsg, compat_sys_recvmmsg_time64)	742	__SC_COMP(__NR_recvmmsg_time64, sys_recvmmsg, compat_sys_recvmmsg_time64)
743	#define __NR_mq_timedsend_time64 418	743	#define __NR_mq_timedsend_time64 418

include/uapi/linux/trace_mmap.h+1−1

@@ -43,6 +43,6 @@ struct trace_buffer_meta { · 42 unmodified lines
43	__u64 Reserved2;	43	__u64 Reserved2;
44	};	44	};
45		45
46	#define TRACE_MMAP_IOCTL_GET_READER _IO('T', 0x1)	46	#define TRACE_MMAP_IOCTL_GET_READER _IO('R', 0x20)
47		47
48	#endif /* _TRACE_MMAP_H_ */	48	#endif /* _TRACE_MMAP_H_ */

io_uring/io_uring.c+2−2

@@ -1259,8 +1259,8 @@ static void io_req_normal_work_add(struct io_kiocb *req) · 1258 unmodified lines
1259	if (ctx->flags & IORING_SETUP_SQPOLL) {	1259	if (ctx->flags & IORING_SETUP_SQPOLL) {
1260	struct io_sq_data *sqd = ctx->sq_data;	1260	struct io_sq_data *sqd = ctx->sq_data;
1261		1261
1262	if (wq_has_sleeper(&sqd->wait))	1262	if (sqd->thread)
1263	wake_up(&sqd->wait);	1263	__set_notify_signal(sqd->thread);
1264	return;	1264	return;
1265	}	1265	}
1266		1266

io_uring/net.c+6−4

 		flags |= MSG_DONTWAIT;
 retry_multishot:
-	kmsg->msg.msg_inq = -1;
-	kmsg->msg.msg_flags = 0;
 	if (io_do_buffer_select(req)) {
 		ret = io_recv_buf_select(req, kmsg, &len, issue_flags);
-		if (unlikely(ret))
+		if (unlikely(ret)) {
+			kmsg->msg.msg_inq = -1;
 			goto out_free;
+		}
 		sr->buf = NULL;
 	}
+	kmsg->msg.msg_flags = 0;
+	kmsg->msg.msg_inq = -1;
 	if (flags & MSG_WAITALL)
 		min_ret = iov_iter_count(&kmsg->msg.msg_iter);

kernel/bpf/core.c+3−4

 	return n ? container_of(n, struct bpf_ksym, tnode) : NULL;
 }
-const char *__bpf_address_lookup(unsigned long addr, unsigned long *size,
+int __bpf_address_lookup(unsigned long addr, unsigned long *size,
 				 unsigned long *off, char *sym)
 {
 	struct bpf_ksym *ksym;
-	char *ret = NULL;
+	int ret = 0;
 	rcu_read_lock();
 	ksym = bpf_ksym_find(addr);
 		unsigned long symbol_start = ksym->start;
 		unsigned long symbol_end = ksym->end;
-		strscpy(sym, ksym->name, KSYM_NAME_LEN);
+		ret = strscpy(sym, ksym->name, KSYM_NAME_LEN);
-		ret = sym;
 		if (size)
 			*size = symbol_end - symbol_start;
 		if (off)

kernel/cpu.c+7−4

 void __init bringup_nonboot_cpus(unsigned int max_cpus)
 {
+	if (!max_cpus)
+		return;
 	/* Try parallel bringup optimization if enabled */
 	if (cpuhp_bringup_cpus_parallel(max_cpus))
 		return;
  * The caller needs to hold cpus read locked while calling this function.
  * Return:
  *   On success:
- *      Positive state number if @state is CPUHP_AP_ONLINE_DYN;
+ *      Positive state number if @state is CPUHP_AP_ONLINE_DYN or CPUHP_BP_PREPARE_DYN;
  *      0 for all other states
  *   On failure: proper (negative) error code
  */
 	ret = cpuhp_store_callbacks(state, name, startup, teardown,
 				    multi_instance);
-	dynstate = state == CPUHP_AP_ONLINE_DYN;
+	dynstate = state == CPUHP_AP_ONLINE_DYN || state == CPUHP_BP_PREPARE_DYN;
 	if (ret > 0 && dynstate) {
 		state = ret;
 		ret = 0;
 out:
 	mutex_unlock(&cpuhp_state_mutex);
 	/*
-	 * If the requested state is CPUHP_AP_ONLINE_DYN, return the
+	 * If the requested state is CPUHP_AP_ONLINE_DYN or CPUHP_BP_PREPARE_DYN,
-	 * dynamically allocated state in case of success.
+	 * return the dynamically allocated state in case of success.
 	 */
 	if (!ret && dynstate)
 		return state;

kernel/exit.c+2−0

 	 * Search through everything else, we should not get here often.
 	 */
 	for_each_process(g) {
+		if (atomic_read(&mm->mm_users) <= 1)
+			break;
 		if (g->flags & PF_KTHREAD)
 			continue;
 		for_each_thread(g, c) {

kernel/kallsyms.c+12−11

 	       !!__bpf_address_lookup(addr, symbolsize, offset, namebuf);
 }
-static const char *kallsyms_lookup_buildid(unsigned long addr,
+static int kallsyms_lookup_buildid(unsigned long addr,
 			unsigned long *symbolsize,
 			unsigned long *offset, char **modname,
 			const unsigned char **modbuildid, char *namebuf)
 {
-	const char *ret;
+	int ret;
 	namebuf[KSYM_NAME_LEN - 1] = 0;
 	namebuf[0] = 0;
 		if (modbuildid)
 			*modbuildid = NULL;
-		ret = namebuf;
+		ret = strlen(namebuf);
 		goto found;
 	}
 			    unsigned long *offset,
 			    char **modname, char *namebuf)
 {
-	return kallsyms_lookup_buildid(addr, symbolsize, offset, modname,
+	int ret = kallsyms_lookup_buildid(addr, symbolsize, offset, modname,
-				       NULL, namebuf);
+					  NULL, namebuf);
+	if (!ret)
+		return NULL;
+	return namebuf;
 }
 int lookup_symbol_name(unsigned long addr, char *symname)
 {
 	char *modname;
 	const unsigned char *buildid;
-	const char *name;
 	unsigned long offset, size;
 	int len;
 	address += symbol_offset;
-	name = kallsyms_lookup_buildid(address, &size, &offset, &modname, &buildid,
+	len = kallsyms_lookup_buildid(address, &size, &offset, &modname, &buildid,
 				       buffer);
-	if (!name)
+	if (!len)
 		return sprintf(buffer, "0x%lx", address - symbol_offset);
-	if (name != buffer)
-		strcpy(buffer, name);
-	len = strlen(buffer);
 	offset -= symbol_offset;
 	if (add_offset)

kernel/module/kallsyms.c+12−13

@@ -321,14 +321,15 @@ void * __weak dereference_module_function_descriptor(struct module *mod, · 320 unmodified lines
321	* For kallsyms to ask for address resolution. NULL means not found. Careful	321	* For kallsyms to ask for address resolution. NULL means not found. Careful
322	* not to lock to avoid deadlock on oopses, simply disable preemption.	322	* not to lock to avoid deadlock on oopses, simply disable preemption.
323	*/	323	*/
324	const char *module_address_lookup(unsigned long addr,	324	int module_address_lookup(unsigned long addr,
325	unsigned long *size,	325	unsigned long *size,
326	unsigned long *offset,	326	unsigned long *offset,
327	char **modname,	327	char **modname,
328	const unsigned char **modbuildid,	328	const unsigned char **modbuildid,
329	char *namebuf)	329	char *namebuf)
330	{	330	{
331	const char *ret = NULL;	331	const char *sym;
		332	int ret = 0;
332	struct module *mod;	333	struct module *mod;
333		334
334	preempt_disable();	335	preempt_disable();
@@ -344,12 +345,10 @@ const char *module_address_lookup(unsigned long addr, · 9 unmodified lines
344	#endif	345	#endif
345	}	346	}
346		347
347	ret = find_kallsyms_symbol(mod, addr, size, offset);	348	sym = find_kallsyms_symbol(mod, addr, size, offset);
348	}	349
349	/* Make a copy in here where it's safe */	350	if (sym)
350	if (ret) {	351	ret = strscpy(namebuf, sym, KSYM_NAME_LEN);
351	strscpy(namebuf, ret, KSYM_NAME_LEN);
352	ret = namebuf;
353	}	352	}
354	preempt_enable();	353	preempt_enable();
355		354

kernel/printk/Makefile+1−1

@@ -1,5 +1,5 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	obj-y = printk.o conopt.o	2	obj-y = printk.o
3	obj-$(CONFIG_PRINTK) += printk_safe.o nbcon.o	3	obj-$(CONFIG_PRINTK) += printk_safe.o nbcon.o
4	obj-$(CONFIG_A11Y_BRAILLE_CONSOLE) += braille.o	4	obj-$(CONFIG_A11Y_BRAILLE_CONSOLE) += braille.o
5	obj-$(CONFIG_PRINTK_INDEX) += index.o	5	obj-$(CONFIG_PRINTK_INDEX) += index.o

kernel/printk/conopt.c+0−146

@@ -1,146 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Kernel command line console options for hardware based addressing
4	*
5	* Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
6	* Author: Tony Lindgren <tony@atomide.com>
7	*/
8
9	#include <linux/console.h>
10	#include <linux/init.h>
11	#include <linux/string.h>
12	#include <linux/types.h>
13
14	#include <asm/errno.h>
15
16	#include "console_cmdline.h"
17
18	/*
19	* Allow longer DEVNAME:0.0 style console naming such as abcd0000.serial:0.0
20	* in addition to the legacy ttyS0 style naming.
21	*/
22	#define CONSOLE_NAME_MAX 32
23
24	#define CONSOLE_OPT_MAX 16
25	#define CONSOLE_BRL_OPT_MAX 16
26
27	struct console_option {
28	char name[CONSOLE_NAME_MAX];
29	char opt[CONSOLE_OPT_MAX];
30	char brl_opt[CONSOLE_BRL_OPT_MAX];
31	u8 has_brl_opt:1;
32	};
33
34	/* Updated only at console_setup() time, no locking needed */
35	static struct console_option conopt[MAX_CMDLINECONSOLES];
36
37	/**
38	* console_opt_save - Saves kernel command line console option for driver use
39	* @str: Kernel command line console name and option
40	* @brl_opt: Braille console options
41	*
42	* Saves a kernel command line console option for driver subsystems to use for
43	* adding a preferred console during init. Called from console_setup() only.
44	*
45	* Return: 0 on success, negative error code on failure.
46	*/
47	int __init console_opt_save(const char str, const char brl_opt)
48	{
49	struct console_option *con;
50	size_t namelen, optlen;
51	const char *opt;
52	int i;
53
54	namelen = strcspn(str, ",");
55	if (namelen == 0 \|\| namelen >= CONSOLE_NAME_MAX)
56	return -EINVAL;
57
58	opt = str + namelen;
59	if (*opt == ',')
60	opt++;
61
62	optlen = strlen(opt);
63	if (optlen >= CONSOLE_OPT_MAX)
64	return -EINVAL;
65
66	for (i = 0; i < MAX_CMDLINECONSOLES; i++) {
67	con = &conopt[i];
68
69	if (con->name[0]) {
70	if (!strncmp(str, con->name, namelen))
71	return 0;
72	continue;
73	}
74
75	/*
76	* The name isn't terminated, only opt is. Empty opt is fine,
77	* but brl_opt can be either empty or NULL. For more info, see
78	* _braille_console_setup().
79	*/
80	strscpy(con->name, str, namelen + 1);
81	strscpy(con->opt, opt, CONSOLE_OPT_MAX);
82	if (brl_opt) {
83	strscpy(con->brl_opt, brl_opt, CONSOLE_BRL_OPT_MAX);
84	con->has_brl_opt = 1;
85	}
86
87	return 0;
88	}
89
90	return -ENOMEM;
91	}
92
93	static struct console_option console_opt_find(const char name)
94	{
95	struct console_option *con;
96	int i;
97
98	for (i = 0; i < MAX_CMDLINECONSOLES; i++) {
99	con = &conopt[i];
100	if (!strcmp(name, con->name))
101	return con;
102	}
103
104	return NULL;
105	}
106
107	/**
108	* add_preferred_console_match - Adds a preferred console if a match is found
109	* @match: Expected console on kernel command line, such as console=DEVNAME:0.0
110	* @name: Name of the console character device to add such as ttyS
111	* @idx: Index for the console
112	*
113	* Allows driver subsystems to add a console after translating the command
114	* line name to the character device name used for the console. Options are
115	* added automatically based on the kernel command line. Duplicate preferred
116	* consoles are ignored by __add_preferred_console().
117	*
118	* Return: 0 on success, negative error code on failure.
119	*/
120	int add_preferred_console_match(const char match, const char name,
121	const short idx)
122	{
123	struct console_option *con;
124	char *brl_opt = NULL;
125
126	if (!match \|\| !strlen(match) \|\| !name \|\| !strlen(name) \|\|
127	idx < 0)
128	return -EINVAL;
129
130	con = console_opt_find(match);
131	if (!con)
132	return -ENOENT;
133
134	/*
135	* See __add_preferred_console(). It checks for NULL brl_options to set
136	* the preferred_console flag. Empty brl_opt instead of NULL leads into
137	* the preferred_console flag not set, and CON_CONSDEV not being set,
138	* and the boot console won't get disabled at the end of console_setup().
139	*/
140	if (con->has_brl_opt)
141	brl_opt = con->brl_opt;
142
143	console_opt_add_preferred_console(name, idx, con->opt, brl_opt);
144
145	return 0;
146	}

kernel/printk/console_cmdline.h+0−6

 #ifndef _CONSOLE_CMDLINE_H
 #define _CONSOLE_CMDLINE_H
-#define MAX_CMDLINECONSOLES 8
-int console_opt_save(const char *str, const char *brl_opt);
-int console_opt_add_preferred_console(const char *name, const short idx,
-				      char *options, char *brl_options);
 struct console_cmdline
 {
 	char	name[16];			/* Name of the driver	    */

kernel/printk/printk.c+4−19

 /*
  *	Array of consoles built from command line options (console=)
  */
+#define MAX_CMDLINECONSOLES 8
 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 static int preferred_console = -1;
 	if (_braille_console_setup(&str, &brl_options))
 		return 1;
-	/* Save the console for driver subsystem use */
-	if (console_opt_save(str, brl_options))
-		return 1;
-	/* Flag register_console() to not call try_enable_default_console() */
-	console_set_on_cmdline = 1;
-	/* Don't attempt to parse a DEVNAME:0.0 style console */
-	if (strchr(str, ':'))
-		return 1;
 	/*
 	 * Decode str into name, index, options.
 	 */
 }
 __setup("console=", console_setup);
-/* Only called from add_preferred_console_match() */
-int console_opt_add_preferred_console(const char *name, const short idx,
-				      char *options, char *brl_options)
-{
-	return __add_preferred_console(name, idx, options, brl_options, true);
-}
 /**
  * add_preferred_console - add a device to the list of preferred consoles.
  * @name: device name
 	 * Note that a console with tty binding will have CON_CONSDEV
 	 * flag set and will be first in the list.
 	 */
-	if (preferred_console < 0 && !console_set_on_cmdline) {
+	if (preferred_console < 0) {
 		if (hlist_empty(&console_list) || !console_first()->device ||
 		    console_first()->flags & CON_BOOT) {
 			try_enable_default_console(newcon);

kernel/sys_ni.c+1−1

 COND_SYSCALL(io_getevents);
 COND_SYSCALL(io_pgetevents_time32);
 COND_SYSCALL(io_pgetevents);
-COND_SYSCALL_COMPAT(io_pgetevents_time32);
 COND_SYSCALL_COMPAT(io_pgetevents);
+COND_SYSCALL_COMPAT(io_pgetevents_time64);
 COND_SYSCALL(io_uring_setup);
 COND_SYSCALL(io_uring_enter);
 COND_SYSCALL(io_uring_register);

kernel/time/hrtimer.c+2−0

@@ -1285,6 +1285,8 @@ void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, · 1284 unmodified lines
1285	struct hrtimer_clock_base *base;	1285	struct hrtimer_clock_base *base;
1286	unsigned long flags;	1286	unsigned long flags;
1287		1287
		1288	if (WARN_ON_ONCE(!timer->function))
		1289	return;
1288	/*	1290	/*
1289	* Check whether the HRTIMER_MODE_SOFT bit and hrtimer.is_soft	1291	* Check whether the HRTIMER_MODE_SOFT bit and hrtimer.is_soft
1290	* match on CONFIG_PREEMPT_RT = n. With PREEMPT_RT check the hard	1292	* match on CONFIG_PREEMPT_RT = n. With PREEMPT_RT check the hard

kernel/trace/ftrace.c+5−8

 	return mod_map;
 }
-static const char *
+static int
 ftrace_func_address_lookup(struct ftrace_mod_map *mod_map,
 			   unsigned long addr, unsigned long *size,
 			   unsigned long *off, char *sym)
 			*size = found_func->size;
 		if (off)
 			*off = addr - found_func->ip;
-		if (sym)
+		return strscpy(sym, found_func->name, KSYM_NAME_LEN);
-			strscpy(sym, found_func->name, KSYM_NAME_LEN);
-		return found_func->name;
 	}
-	return NULL;
+	return 0;
 }
-const char *
+int
 ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
 		   unsigned long *off, char **modname, char *sym)
 {
 	struct ftrace_mod_map *mod_map;
-	const char *ret = NULL;
+	int ret = 0;
 	/* mod_map is freed via call_rcu() */
 	preempt_disable();

lib/closure.c+46−6

@@ -13,7 +13,7 @@ · 12 unmodified lines
13	#include <linux/seq_file.h>	13	#include <linux/seq_file.h>
14	#include <linux/sched/debug.h>	14	#include <linux/sched/debug.h>
15		15
16	static inline void closure_put_after_sub(struct closure *cl, int flags)	16	static inline void closure_put_after_sub_checks(int flags)
17	{	17	{
18	int r = flags & CLOSURE_REMAINING_MASK;	18	int r = flags & CLOSURE_REMAINING_MASK;
19		19
@@ -22,12 +22,17 @@ static inline void closure_put_after_sub(struct closure *cl, int flags) · 2 unmodified lines
22	flags & CLOSURE_GUARD_MASK, (unsigned) __fls(r)))	22	flags & CLOSURE_GUARD_MASK, (unsigned) __fls(r)))
23	r &= ~CLOSURE_GUARD_MASK;	23	r &= ~CLOSURE_GUARD_MASK;
24		24
25	if (!r) {	25	WARN(!r && (flags & ~CLOSURE_DESTRUCTOR),
26	smp_acquire__after_ctrl_dep();	26	"closure ref hit 0 with incorrect flags set: %x (%u)",
		27	flags & ~CLOSURE_DESTRUCTOR, (unsigned) __fls(flags));
		28	}
		29
		30	static inline void closure_put_after_sub(struct closure *cl, int flags)
		31	{
		32	closure_put_after_sub_checks(flags);
27		33
28	WARN(flags & ~CLOSURE_DESTRUCTOR,	34	if (!(flags & CLOSURE_REMAINING_MASK)) {
29	"closure ref hit 0 with incorrect flags set: %x (%u)",	35	smp_acquire__after_ctrl_dep();
30	flags & ~CLOSURE_DESTRUCTOR, (unsigned) __fls(flags));
31		36
32	cl->closure_get_happened = false;	37	cl->closure_get_happened = false;
33		38
@@ -145,6 +150,41 @@ void __sched __closure_sync(struct closure *cl) · 111 unmodified lines
145	}	150	}
146	EXPORT_SYMBOL(__closure_sync);	151	EXPORT_SYMBOL(__closure_sync);
147		152
		153	/*
		154	* closure_return_sync - finish running a closure, synchronously (i.e. waiting
		155	* for outstanding get()s to finish) and returning once closure refcount is 0.
		156	*
		157	* Unlike closure_sync() this doesn't reinit the ref to 1; subsequent
		158	* closure_get_not_zero() calls waill fail.
		159	*/
		160	void __sched closure_return_sync(struct closure *cl)
		161	{
		162	struct closure_syncer s = { .task = current };
		163
		164	cl->s = &s;
		165	set_closure_fn(cl, closure_sync_fn, NULL);
		166
		167	unsigned flags = atomic_sub_return_release(1 + CLOSURE_RUNNING - CLOSURE_DESTRUCTOR,
		168	&cl->remaining);
		169
		170	closure_put_after_sub_checks(flags);
		171
		172	if (unlikely(flags & CLOSURE_REMAINING_MASK)) {
		173	while (1) {
		174	set_current_state(TASK_UNINTERRUPTIBLE);
		175	if (s.done)
		176	break;
		177	schedule();
		178	}
		179
		180	__set_current_state(TASK_RUNNING);
		181	}
		182
		183	if (cl->parent)
		184	closure_put(cl->parent);
		185	}
		186	EXPORT_SYMBOL(closure_return_sync);
		187
148	int __sched __closure_sync_timeout(struct closure *cl, unsigned long timeout)	188	int __sched __closure_sync_timeout(struct closure *cl, unsigned long timeout)
149	{	189	{
150	struct closure_syncer s = { .task = current };	190	struct closure_syncer s = { .task = current };

lib/string_helpers_kunit.c+1−0

@@ -625,4 +625,5 @@ static struct kunit_suite string_helpers_test_suite = { · 624 unmodified lines
625		625
626	kunit_test_suites(&string_helpers_test_suite);	626	kunit_test_suites(&string_helpers_test_suite);
627		627
		628	MODULE_DESCRIPTION("Test cases for string helpers module");
628	MODULE_LICENSE("Dual BSD/GPL");	629	MODULE_LICENSE("Dual BSD/GPL");

lib/string_kunit.c+1−0

@@ -633,4 +633,5 @@ static struct kunit_suite string_test_suite = { · 632 unmodified lines
633		633
634	kunit_test_suites(&string_test_suite);	634	kunit_test_suites(&string_test_suite);
635		635
		636	MODULE_DESCRIPTION("Test cases for string functions");
636	MODULE_LICENSE("GPL v2");	637	MODULE_LICENSE("GPL v2");

mm/page-writeback.c+27−5

 	else
 		bg_thresh = (bg_ratio * available_memory) / PAGE_SIZE;
-	if (bg_thresh >= thresh)
-		bg_thresh = thresh / 2;
 	tsk = current;
 	if (rt_task(tsk)) {
 		bg_thresh += bg_thresh / 4 + global_wb_domain.dirty_limit / 32;
 		thresh += thresh / 4 + global_wb_domain.dirty_limit / 32;
 	}
+	/*
+	 * Dirty throttling logic assumes the limits in page units fit into
+	 * 32-bits. This gives 16TB dirty limits max which is hopefully enough.
+	 */
+	if (thresh > UINT_MAX)
+		thresh = UINT_MAX;
+	/* This makes sure bg_thresh is within 32-bits as well */
+	if (bg_thresh >= thresh)
+		bg_thresh = thresh / 2;
 	dtc->thresh = thresh;
 	dtc->bg_thresh = bg_thresh;
 	if (rt_task(tsk))
 		dirty += dirty / 4;
-	return dirty;
+	/*
+	 * Dirty throttling logic assumes the limits in page units fit into
+	 * 32-bits. This gives 16TB dirty limits max which is hopefully enough.
+	 */
+	return min_t(unsigned long, dirty, UINT_MAX);
 }
 /**
 		void *buffer, size_t *lenp, loff_t *ppos)
 {
 	int ret;
+	unsigned long old_bytes = dirty_background_bytes;
 	ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
-	if (ret == 0 && write)
+	if (ret == 0 && write) {
+		if (DIV_ROUND_UP(dirty_background_bytes, PAGE_SIZE) >
+								UINT_MAX) {
+			dirty_background_bytes = old_bytes;
+			return -ERANGE;
+		}
 		dirty_background_ratio = 0;
+	}
 	return ret;
 }
 	ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
 	if (ret == 0 && write && vm_dirty_bytes != old_bytes) {
+		if (DIV_ROUND_UP(vm_dirty_bytes, PAGE_SIZE) > UINT_MAX) {
+			vm_dirty_bytes = old_bytes;
+			return -ERANGE;
+		}
 		writeback_set_ratelimit();
 		vm_dirty_ratio = 0;
 	}
 	 */
 	dtc->wb_thresh = __wb_calc_thresh(dtc, dtc->thresh);
 	dtc->wb_bg_thresh = dtc->thresh ?
-		div64_u64(dtc->wb_thresh * dtc->bg_thresh, dtc->thresh) : 0;
+		div_u64((u64)dtc->wb_thresh * dtc->bg_thresh, dtc->thresh) : 0;
 	/*
 	 * In order to avoid the stacked BDI deadlock we need

net/bluetooth/hci_conn.c+12−3

 			       U16_MAX, GFP_ATOMIC);
 }
-struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
+static struct hci_conn *__hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
-			      u8 role, u16 handle)
+				       u8 role, u16 handle)
 {
 	struct hci_conn *conn;
 	if (unlikely(handle < 0))
 		return ERR_PTR(-ECONNREFUSED);
-	return hci_conn_add(hdev, type, dst, role, handle);
+	return __hci_conn_add(hdev, type, dst, role, handle);
+}
+struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
+			      u8 role, u16 handle)
+{
+	if (handle > HCI_CONN_HANDLE_MAX)
+		return ERR_PTR(-EINVAL);
+	return __hci_conn_add(hdev, type, dst, role, handle);
 }
 static void hci_conn_cleanup_child(struct hci_conn *conn, u8 reason)

net/bluetooth/hci_core.c+22−54

@@ -63,50 +63,6 @@ DEFINE_MUTEX(hci_cb_list_lock); · 62 unmodified lines
63	/* HCI ID Numbering */	63	/* HCI ID Numbering */
64	static DEFINE_IDA(hci_index_ida);	64	static DEFINE_IDA(hci_index_ida);
65		65
66	static int hci_scan_req(struct hci_request *req, unsigned long opt)
67	{
68	__u8 scan = opt;
69
70	BT_DBG("%s %x", req->hdev->name, scan);
71
72	/* Inquiry and Page scans */
73	hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
74	return 0;
75	}
76
77	static int hci_auth_req(struct hci_request *req, unsigned long opt)
78	{
79	__u8 auth = opt;
80
81	BT_DBG("%s %x", req->hdev->name, auth);
82
83	/* Authentication */
84	hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth);
85	return 0;
86	}
87
88	static int hci_encrypt_req(struct hci_request *req, unsigned long opt)
89	{
90	__u8 encrypt = opt;
91
92	BT_DBG("%s %x", req->hdev->name, encrypt);
93
94	/* Encryption */
95	hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt);
96	return 0;
97	}
98
99	static int hci_linkpol_req(struct hci_request *req, unsigned long opt)
100	{
101	__le16 policy = cpu_to_le16(opt);
102
103	BT_DBG("%s %x", req->hdev->name, policy);
104
105	/* Default link policy */
106	hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy);
107	return 0;
108	}
109
110	/* Get HCI device by index.	66	/* Get HCI device by index.
111	* Device is held on return. */	67	* Device is held on return. */
112	struct hci_dev *hci_dev_get(int index)	68	struct hci_dev *hci_dev_get(int index)
@@ -735,6 +691,7 @@ int hci_dev_cmd(unsigned int cmd, void __user *arg) · 622 unmodified lines
735	{	691	{
736	struct hci_dev *hdev;	692	struct hci_dev *hdev;
737	struct hci_dev_req dr;	693	struct hci_dev_req dr;
		694	__le16 policy;
738	int err = 0;	695	int err = 0;
739		696
740	if (copy_from_user(&dr, arg, sizeof(dr)))	697	if (copy_from_user(&dr, arg, sizeof(dr)))
@@ -761,8 +718,8 @@ int hci_dev_cmd(unsigned int cmd, void __user *arg) · 20 unmodified lines
761		718
762	switch (cmd) {	719	switch (cmd) {
763	case HCISETAUTH:	720	case HCISETAUTH:
764	err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt,	721	err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_AUTH_ENABLE,
765	HCI_INIT_TIMEOUT, NULL);	722	1, &dr.dev_opt, HCI_CMD_TIMEOUT);
766	break;	723	break;
767		724
768	case HCISETENCRYPT:	725	case HCISETENCRYPT:
@@ -773,19 +730,23 @@ int hci_dev_cmd(unsigned int cmd, void __user *arg) · 4 unmodified lines
773		730
774	if (!test_bit(HCI_AUTH, &hdev->flags)) {	731	if (!test_bit(HCI_AUTH, &hdev->flags)) {
775	/* Auth must be enabled first */	732	/* Auth must be enabled first */
776	err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt,	733	err = __hci_cmd_sync_status(hdev,
777	HCI_INIT_TIMEOUT, NULL);	734	HCI_OP_WRITE_AUTH_ENABLE,
		735	1, &dr.dev_opt,
		736	HCI_CMD_TIMEOUT);
778	if (err)	737	if (err)
779	break;	738	break;
780	}	739	}
781		740
782	err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt,	741	err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_ENCRYPT_MODE,
783	HCI_INIT_TIMEOUT, NULL);	742	1, &dr.dev_opt,
		743	HCI_CMD_TIMEOUT);
784	break;	744	break;
785		745
786	case HCISETSCAN:	746	case HCISETSCAN:
787	err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt,	747	err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_SCAN_ENABLE,
788	HCI_INIT_TIMEOUT, NULL);	748	1, &dr.dev_opt,
		749	HCI_CMD_TIMEOUT);
789		750
790	/* Ensure that the connectable and discoverable states	751	/* Ensure that the connectable and discoverable states
791	* get correctly modified as this was a non-mgmt change.	752	* get correctly modified as this was a non-mgmt change.
@@ -795,8 +756,11 @@ int hci_dev_cmd(unsigned int cmd, void __user *arg) · 3 unmodified lines
795	break;	756	break;
796		757
797	case HCISETLINKPOL:	758	case HCISETLINKPOL:
798	err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt,	759	policy = cpu_to_le16(dr.dev_opt);
799	HCI_INIT_TIMEOUT, NULL);	760
		761	err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_DEF_LINK_POLICY,
		762	2, &policy,
		763	HCI_CMD_TIMEOUT);
800	break;	764	break;
801		765
802	case HCISETLINKMODE:	766	case HCISETLINKMODE:
@@ -2751,7 +2715,11 @@ void hci_unregister_dev(struct hci_dev *hdev) · 1948 unmodified lines
2751	list_del(&hdev->list);	2715	list_del(&hdev->list);
2752	write_unlock(&hci_dev_list_lock);	2716	write_unlock(&hci_dev_list_lock);
2753		2717
		2718	cancel_work_sync(&hdev->rx_work);
		2719	cancel_work_sync(&hdev->cmd_work);
		2720	cancel_work_sync(&hdev->tx_work);
2754	cancel_work_sync(&hdev->power_on);	2721	cancel_work_sync(&hdev->power_on);
		2722	cancel_work_sync(&hdev->error_reset);
2755		2723
2756	hci_cmd_sync_clear(hdev);	2724	hci_cmd_sync_clear(hdev);
2757		2725

net/bluetooth/hci_event.c+30−3

 		evt_type = __le16_to_cpu(info->type) & LE_EXT_ADV_EVT_TYPE_MASK;
 		legacy_evt_type = ext_evt_type_to_legacy(hdev, evt_type);
+		if (test_bit(HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY,
+			     &hdev->quirks)) {
+			info->primary_phy &= 0x1f;
+			info->secondary_phy &= 0x1f;
+		}
 		if (legacy_evt_type != LE_ADV_INVALID) {
 			process_adv_report(hdev, legacy_evt_type, &info->bdaddr,
 					   info->bdaddr_type, NULL, 0,
 	struct bt_iso_qos *qos;
 	bool pending = false;
 	u16 handle = __le16_to_cpu(ev->handle);
+	u32 c_sdu_interval, p_sdu_interval;
 	bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
 	pending = test_and_clear_bit(HCI_CONN_CREATE_CIS, &conn->flags);
-	/* Convert ISO Interval (1.25 ms slots) to SDU Interval (us) */
+	/* BLUETOOTH CORE SPECIFICATION Version 5.4 | Vol 6, Part G
-	qos->ucast.in.interval = le16_to_cpu(ev->interval) * 1250;
+	 * page 3075:
-	qos->ucast.out.interval = qos->ucast.in.interval;
+	 * Transport_Latency_C_To_P = CIG_Sync_Delay + (FT_C_To_P) ×
+	 * ISO_Interval + SDU_Interval_C_To_P
+	 * ...
+	 * SDU_Interval = (CIG_Sync_Delay + (FT) x ISO_Interval) -
+	 *					Transport_Latency
+	 */
+	c_sdu_interval = (get_unaligned_le24(ev->cig_sync_delay) +
+			 (ev->c_ft * le16_to_cpu(ev->interval) * 1250)) -
+			get_unaligned_le24(ev->c_latency);
+	p_sdu_interval = (get_unaligned_le24(ev->cig_sync_delay) +
+			 (ev->p_ft * le16_to_cpu(ev->interval) * 1250)) -
+			get_unaligned_le24(ev->p_latency);
 	switch (conn->role) {
 	case HCI_ROLE_SLAVE:
+		qos->ucast.in.interval = c_sdu_interval;
+		qos->ucast.out.interval = p_sdu_interval;
 		/* Convert Transport Latency (us) to Latency (msec) */
 		qos->ucast.in.latency =
 			DIV_ROUND_CLOSEST(get_unaligned_le24(ev->c_latency),
 		qos->ucast.out.phy = ev->p_phy;
 		break;
 	case HCI_ROLE_MASTER:
+		qos->ucast.in.interval = p_sdu_interval;
+		qos->ucast.out.interval = c_sdu_interval;
 		/* Convert Transport Latency (us) to Latency (msec) */
 		qos->ucast.out.latency =
 			DIV_ROUND_CLOSEST(get_unaligned_le24(ev->c_latency),
 		bis = hci_conn_hash_lookup_handle(hdev, handle);
 		if (!bis) {
+			if (handle > HCI_CONN_HANDLE_MAX) {
+				bt_dev_dbg(hdev, "ignore too large handle %u", handle);
+				continue;
+			}
 			bis = hci_conn_add(hdev, ISO_LINK, BDADDR_ANY,
 					   HCI_ROLE_SLAVE, handle);
 			if (IS_ERR(bis))

net/bluetooth/hci_sync.c+13−0

@@ -280,6 +280,19 @@ int __hci_cmd_sync_status(struct hci_dev *hdev, u16 opcode, u32 plen, · 279 unmodified lines
280	}	280	}
281	EXPORT_SYMBOL(__hci_cmd_sync_status);	281	EXPORT_SYMBOL(__hci_cmd_sync_status);
282		282
		283	int hci_cmd_sync_status(struct hci_dev *hdev, u16 opcode, u32 plen,
		284	const void *param, u32 timeout)
		285	{
		286	int err;
		287
		288	hci_req_sync_lock(hdev);
		289	err = __hci_cmd_sync_status(hdev, opcode, plen, param, timeout);
		290	hci_req_sync_unlock(hdev);
		291
		292	return err;
		293	}
		294	EXPORT_SYMBOL(hci_cmd_sync_status);
		295
283	static void hci_cmd_sync_work(struct work_struct *work)	296	static void hci_cmd_sync_work(struct work_struct *work)
284	{	297	{
285	struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_sync_work);	298	struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_sync_work);

net/bluetooth/iso.c+1−2

 		lock_sock(sk);
 		switch (sk->sk_state) {
 		case BT_CONNECT2:
-			if (pi->conn->hcon &&
+			if (test_bit(BT_SK_PA_SYNC, &pi->flags)) {
-			    test_bit(HCI_CONN_PA_SYNC, &pi->conn->hcon->flags)) {
 				iso_conn_big_sync(sk);
 				sk->sk_state = BT_LISTEN;
 			} else {

net/bluetooth/l2cap_core.c+3−0

 	BT_DBG("chan %p, len %d", chan, skb->len);
+	l2cap_chan_lock(chan);
 	if (chan->state != BT_BOUND && chan->state != BT_CONNECTED)
 		goto drop;
 	}
 drop:
+	l2cap_chan_unlock(chan);
 	l2cap_chan_put(chan);
 free_skb:
 	kfree_skb(skb);

net/bluetooth/l2cap_sock.c+11−3

 	BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
+	/* Sock is dead, so set chan data to NULL, avoid other task use invalid
+	 * sock pointer.
+	 */
+	l2cap_pi(sk)->chan->data = NULL;
 	/* Kill poor orphan */
 	l2cap_chan_put(l2cap_pi(sk)->chan);
 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
 {
-	struct sock *sk = chan->data;
+	struct sock *sk;
-	struct l2cap_pinfo *pi = l2cap_pi(sk);
+	struct l2cap_pinfo *pi;
 	int err;
-	lock_sock(sk);
+	sk = chan->data;
+	if (!sk)
+		return -ENXIO;
+	pi = l2cap_pi(sk);
+	lock_sock(sk);
 	if (chan->mode == L2CAP_MODE_ERTM && !list_empty(&pi->rx_busy)) {
 		err = -ENOMEM;
 		goto done;

net/core/datagram.c+13−6

@@ -416,15 +416,22 @@ static int __skb_datagram_iter(const struct sk_buff *skb, int offset, · 415 unmodified lines
416		416
417	end = start + skb_frag_size(frag);	417	end = start + skb_frag_size(frag);
418	if ((copy = end - offset) > 0) {	418	if ((copy = end - offset) > 0) {
419	struct page *page = skb_frag_page(frag);	419	u32 p_off, p_len, copied;
420	u8 *vaddr = kmap(page);	420	struct page *p;
		421	u8 *vaddr;
421		422
422	if (copy > len)	423	if (copy > len)
423	copy = len;	424	copy = len;
424	n = INDIRECT_CALL_1(cb, simple_copy_to_iter,	425
425	vaddr + skb_frag_off(frag) + offset - start,	426	skb_frag_foreach_page(frag,
426	copy, data, to);	427	skb_frag_off(frag) + offset - start,
427	kunmap(page);	428	copy, p, p_off, p_len, copied) {
		429	vaddr = kmap_local_page(p);
		430	n = INDIRECT_CALL_1(cb, simple_copy_to_iter,
		431	vaddr + p_off, p_len, data, to);
		432	kunmap_local(vaddr);
		433	}
		434
428	offset += n;	435	offset += n;
429	if (n != copy)	436	if (n != copy)
430	goto short_copy;	437	goto short_copy;

net/ipv4/inet_diag.c+2−0

 	req.sdiag_family = AF_UNSPEC; /* compatibility */
 	req.sdiag_protocol = inet_diag_type2proto(cb->nlh->nlmsg_type);
 	req.idiag_ext = rc->idiag_ext;
+	req.pad = 0;
 	req.idiag_states = rc->idiag_states;
 	req.id = rc->id;
 	req.sdiag_family = rc->idiag_family;
 	req.sdiag_protocol = inet_diag_type2proto(nlh->nlmsg_type);
 	req.idiag_ext = rc->idiag_ext;
+	req.pad = 0;
 	req.idiag_states = rc->idiag_states;
 	req.id = rc->id;

net/ipv4/tcp_input.c+8−1

 			return;
 		if (tcp_try_undo_dsack(sk))
-			tcp_try_keep_open(sk);
+			tcp_try_to_open(sk, flag);
 		tcp_identify_packet_loss(sk, ack_flag);
 		if (icsk->icsk_ca_state != TCP_CA_Recovery) {
 				 * checked (see tcp_v{4,6}_rcv()).
 				 */
 				break;
+#endif
+#ifdef CONFIG_TCP_AO
+			case TCPOPT_AO:
+				/* TCP AO has already been checked
+				 * (see tcp_inbound_ao_hash()).
+				 */
+				break;
 #endif
 			case TCPOPT_FASTOPEN:
 				tcp_parse_fastopen_option(

net/ipv4/tcp_metrics.c+1−0

@@ -619,6 +619,7 @@ static const struct nla_policy tcp_metrics_nl_policy[TCP_METRICS_ATTR_MAX + 1] = · 618 unmodified lines
619	[TCP_METRICS_ATTR_ADDR_IPV4] = { .type = NLA_U32, },	619	[TCP_METRICS_ATTR_ADDR_IPV4] = { .type = NLA_U32, },
620	[TCP_METRICS_ATTR_ADDR_IPV6] = { .type = NLA_BINARY,	620	[TCP_METRICS_ATTR_ADDR_IPV6] = { .type = NLA_BINARY,
621	.len = sizeof(struct in6_addr), },	621	.len = sizeof(struct in6_addr), },
		622	[TCP_METRICS_ATTR_SADDR_IPV4] = { .type = NLA_U32, },
622	/* Following attributes are not received for GET/DEL,	623	/* Following attributes are not received for GET/DEL,
623	* we keep them for reference	624	* we keep them for reference
624	*/	625	*/

net/mac802154/main.c+8−6

 	}
 	phy->symbol_duration = duration;
-	phy->lifs_period = (IEEE802154_LIFS_PERIOD * phy->symbol_duration) / NSEC_PER_SEC;
+	phy->lifs_period =
-	phy->sifs_period = (IEEE802154_SIFS_PERIOD * phy->symbol_duration) / NSEC_PER_SEC;
+		(IEEE802154_LIFS_PERIOD * phy->symbol_duration) / NSEC_PER_USEC;
+	phy->sifs_period =
+		(IEEE802154_SIFS_PERIOD * phy->symbol_duration) / NSEC_PER_USEC;
 }
 EXPORT_SYMBOL(ieee802154_configure_durations);
 	 * Should be done when all drivers sets this value.
 	 */
-	wpan_phy->lifs_period =
+	wpan_phy->lifs_period =	(IEEE802154_LIFS_PERIOD *
-		(IEEE802154_LIFS_PERIOD * wpan_phy->symbol_duration) / 1000;
+				 wpan_phy->symbol_duration) / NSEC_PER_USEC;
-	wpan_phy->sifs_period =
+	wpan_phy->sifs_period =	(IEEE802154_SIFS_PERIOD *
-		(IEEE802154_SIFS_PERIOD * wpan_phy->symbol_duration) / 1000;
+				 wpan_phy->symbol_duration) / NSEC_PER_USEC;
 }
 int ieee802154_register_hw(struct ieee802154_hw *hw)

net/mac802154/tx.c+4−4

@@ -34,8 +34,8 @@ void ieee802154_xmit_sync_worker(struct work_struct *work) · 33 unmodified lines
34	if (res)	34	if (res)
35	goto err_tx;	35	goto err_tx;
36		36
37	dev->stats.tx_packets++;	37	DEV_STATS_INC(dev, tx_packets);
38	dev->stats.tx_bytes += skb->len;	38	DEV_STATS_ADD(dev, tx_bytes, skb->len);
39		39
40	ieee802154_xmit_complete(&local->hw, skb, false);	40	ieee802154_xmit_complete(&local->hw, skb, false);
41		41
@@ -90,8 +90,8 @@ ieee802154_tx(struct ieee802154_local local, struct sk_buff skb) · 48 unmodified lines
90	if (ret)	90	if (ret)
91	goto err_wake_netif_queue;	91	goto err_wake_netif_queue;
92		92
93	dev->stats.tx_packets++;	93	DEV_STATS_INC(dev, tx_packets);
94	dev->stats.tx_bytes += len;	94	DEV_STATS_ADD(dev, tx_bytes, len);
95	} else {	95	} else {
96	local->tx_skb = skb;	96	local->tx_skb = skb;
97	queue_work(local->workqueue, &local->sync_tx_work);	97	queue_work(local->workqueue, &local->sync_tx_work);

net/netfilter/nf_tables_api.c+1−2

@@ -11552,8 +11552,7 @@ static int nft_rcv_nl_event(struct notifier_block *this, unsigned long event, · 11551 unmodified lines
11552		11552
11553	gc_seq = nft_gc_seq_begin(nft_net);	11553	gc_seq = nft_gc_seq_begin(nft_net);
11554		11554
11555	if (!list_empty(&nf_tables_destroy_list))	11555	nf_tables_trans_destroy_flush_work();
11556	nf_tables_trans_destroy_flush_work();
11557	again:	11556	again:
11558	list_for_each_entry(table, &nft_net->tables, list) {	11557	list_for_each_entry(table, &nft_net->tables, list) {
11559	if (nft_table_has_owner(table) &&	11558	if (nft_table_has_owner(table) &&

net/sunrpc/svc.c+4−1

  */
 void svc_process_bc(struct rpc_rqst *req, struct svc_rqst *rqstp)
 {
+	struct rpc_timeout timeout = {
+		.to_increment		= 0,
+	};
 	struct rpc_task *task;
 	int proc_error;
-	struct rpc_timeout timeout;
 	/* Build the svc_rqst used by the common processing routine */
 	rqstp->rq_xid = req->rq_xid;
 		timeout.to_initval = req->rq_xprt->timeout->to_initval;
 		timeout.to_retries = req->rq_xprt->timeout->to_retries;
 	}
+	timeout.to_maxval = timeout.to_initval;
 	memcpy(&req->rq_snd_buf, &rqstp->rq_res, sizeof(req->rq_snd_buf));
 	task = rpc_run_bc_task(req, &timeout);

net/sunrpc/svc_xprt.c+3−5

 	dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
-	if (!si->serv)
-		return NULL;
 	mutex_lock(si->mutex);
 	if (!pidx)
 		return SEQ_START_TOKEN;
+	if (!si->serv)
+		return NULL;
 	return pidx > si->serv->sv_nrpools ? NULL
 		: &si->serv->sv_pools[pidx - 1];
 }
 {
 	struct svc_info *si = m->private;
-	if (si->serv)
+	mutex_unlock(si->mutex);
-		mutex_unlock(si->mutex);
 }
 static int svc_pool_stats_show(struct seq_file *m, void *p)

net/unix/garbage.c+5−4

 	}
 	if (vertex->index == vertex->scc_index) {
+		struct unix_vertex *v;
 		struct list_head scc;
 		bool scc_dead = true;
 		 */
 		__list_cut_position(&scc, &vertex_stack, &vertex->scc_entry);
-		list_for_each_entry_reverse(vertex, &scc, scc_entry) {
+		list_for_each_entry_reverse(v, &scc, scc_entry) {
 			/* Don't restart DFS from this vertex in unix_walk_scc(). */
-			list_move_tail(&vertex->entry, &unix_visited_vertices);
+			list_move_tail(&v->entry, &unix_visited_vertices);
 			/* Mark vertex as off-stack. */
-			vertex->index = unix_vertex_grouped_index;
+			v->index = unix_vertex_grouped_index;
 			if (scc_dead)
-				scc_dead = unix_vertex_dead(vertex);
+				scc_dead = unix_vertex_dead(v);
 		}
 		if (scc_dead)

scripts/Makefile.dtbinst+1−1

@@ -17,7 +17,7 @@ include $(srctree)/scripts/Kbuild.include · 16 unmodified lines
17	dst := $(INSTALL_DTBS_PATH)	17	dst := $(INSTALL_DTBS_PATH)
18		18
19	quiet_cmd_dtb_install = INSTALL $@	19	quiet_cmd_dtb_install = INSTALL $@
20	cmd_dtb_install = install -D $< $@	20	cmd_dtb_install = install -D -m 0644 $< $@
21		21
22	$(dst)/%: $(obj)/%	22	$(dst)/%: $(obj)/%
23	$(call cmd,dtb_install)	23	$(call cmd,dtb_install)

scripts/Makefile.host+1−1

@@ -146,7 +146,7 @@ $(call multi_depend, $(host-cxxmulti), , -objs -cxxobjs) · 145 unmodified lines
146	# Create .o file from a single .cc (C++) file	146	# Create .o file from a single .cc (C++) file
147	quiet_cmd_host-cxxobjs = HOSTCXX $@	147	quiet_cmd_host-cxxobjs = HOSTCXX $@
148	cmd_host-cxxobjs = $(HOSTCXX) $(hostcxx_flags) -c -o $@ $<	148	cmd_host-cxxobjs = $(HOSTCXX) $(hostcxx_flags) -c -o $@ $<
149	$(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE	149	$(host-cxxobjs): $(obj)/%.o: $(obj)/%.cc FORCE
150	$(call if_changed_dep,host-cxxobjs)	150	$(call if_changed_dep,host-cxxobjs)
151		151
152	# Create executable from a single Rust crate (which may consist of	152	# Create executable from a single Rust crate (which may consist of

scripts/Makefile.package+1−1

@@ -103,7 +103,7 @@ debian-orig: private version = $(shell dpkg-parsechangelog -S Version \| sed 's/- · 102 unmodified lines
103	debian-orig: private orig-name = $(source)_$(version).orig.tar$(debian-orig-suffix)	103	debian-orig: private orig-name = $(source)_$(version).orig.tar$(debian-orig-suffix)
104	debian-orig: mkdebian-opts = --need-source	104	debian-orig: mkdebian-opts = --need-source
105	debian-orig: linux.tar$(debian-orig-suffix) debian	105	debian-orig: linux.tar$(debian-orig-suffix) debian
106	$(Q)if [ "$(df --output=target .. 2>/dev/null)" = "$(df --output=target $< 2>/dev/null)" ]; then \	106	$(Q)if [ "$$(df --output=target .. 2>/dev/null)" = "$$(df --output=target $< 2>/dev/null)" ]; then \
107	ln -f $< ../$(orig-name); \	107	ln -f $< ../$(orig-name); \
108	else \	108	else \
109	cp $< ../$(orig-name); \	109	cp $< ../$(orig-name); \

scripts/gdb/linux/Makefile+1−1

@@ -5,7 +5,7 @@ ifdef building_out_of_srctree · 4 unmodified lines
5	symlinks := $(patsubst $(src)/%,%,$(wildcard $(src)/*.py))	5	symlinks := $(patsubst $(src)/%,%,$(wildcard $(src)/*.py))
6		6
7	quiet_cmd_symlink = SYMLINK $@	7	quiet_cmd_symlink = SYMLINK $@
8	cmd_symlink = ln -fsn $(patsubst $(obj)/%,$(src)/%,$@) $@	8	cmd_symlink = ln -fsn $(patsubst $(obj)/%,$(abspath $(src))/%,$@) $@
9		9
10	always-y += $(symlinks)	10	always-y += $(symlinks)
11	$(addprefix $(obj)/, $(symlinks)): FORCE	11	$(addprefix $(obj)/, $(symlinks)): FORCE

scripts/package/kernel.spec+3−5

 %install
 mkdir -p %{buildroot}/lib/modules/%{KERNELRELEASE}
 cp $(%{make} %{makeflags} -s image_name) %{buildroot}/lib/modules/%{KERNELRELEASE}/vmlinuz
-%{make} %{makeflags} INSTALL_MOD_PATH=%{buildroot} modules_install
+# DEPMOD=true makes depmod no-op. We do not package depmod-generated files.
+%{make} %{makeflags} INSTALL_MOD_PATH=%{buildroot} DEPMOD=true modules_install
 %{make} %{makeflags} INSTALL_HDR_PATH=%{buildroot}/usr headers_install
 cp System.map %{buildroot}/lib/modules/%{KERNELRELEASE}
 cp .config %{buildroot}/lib/modules/%{KERNELRELEASE}/config
 %endif
 {
-	for x in System.map config kernel modules.builtin \
+	echo "/lib/modules/%{KERNELRELEASE}"
-			modules.builtin.modinfo modules.order vmlinuz; do
-		echo "/lib/modules/%{KERNELRELEASE}/${x}"
-	done
 	for x in alias alias.bin builtin.alias.bin builtin.bin dep dep.bin \
 					devname softdep symbols symbols.bin; do

tools/power/x86/turbostat/Makefile+5−1

 override CFLAGS +=	-O2 -Wall -Wextra -I../../../include
 override CFLAGS +=	-DMSRHEADER='"../../../../arch/x86/include/asm/msr-index.h"'
 override CFLAGS +=	-DINTEL_FAMILY_HEADER='"../../../../arch/x86/include/asm/intel-family.h"'
+override CFLAGS +=	-DBUILD_BUG_HEADER='"../../../../include/linux/build_bug.h"'
 override CFLAGS +=	-D_FILE_OFFSET_BITS=64
 override CFLAGS +=	-D_FORTIFY_SOURCE=2
 	@echo "#define GENMASK(h, l) (((~0UL) << (l)) & (~0UL >> (sizeof(long) * 8 - 1 - (h))))" >> $(SNAPSHOT)/bits.h
 	@echo "#define GENMASK_ULL(h, l) (((~0ULL) << (l)) & (~0ULL >> (sizeof(long long) * 8 - 1 - (h))))" >> $(SNAPSHOT)/bits.h
+	@echo '#define BUILD_BUG_ON(cond) do { enum { compile_time_check ## __COUNTER__ = 1/(!(cond)) }; } while (0)' > $(SNAPSHOT)/build_bug.h
 	@echo PWD=. > $(SNAPSHOT)/Makefile
 	@echo "CFLAGS +=	-DMSRHEADER='\"msr-index.h\"'" >> $(SNAPSHOT)/Makefile
 	@echo "CFLAGS +=	-DINTEL_FAMILY_HEADER='\"intel-family.h\"'" >> $(SNAPSHOT)/Makefile
-	@sed -e's/.*MSRHEADER.*//' -e's/.*INTEL_FAMILY_HEADER.*//' Makefile >> $(SNAPSHOT)/Makefile
+	@echo "CFLAGS +=	-DBUILD_BUG_HEADER='\"build_bug.h\"'" >> $(SNAPSHOT)/Makefile
+	@sed -e's/.*MSRHEADER.*//' -e's/.*INTEL_FAMILY_HEADER.*//' -e's/.*BUILD_BUG_HEADER.*//' Makefile >> $(SNAPSHOT)/Makefile
 	@rm -f $(SNAPSHOT).tar.gz
 	tar cvzf $(SNAPSHOT).tar.gz $(SNAPSHOT)

tools/power/x86/turbostat/turbostat.c+10−10

 #define _GNU_SOURCE
 #include MSRHEADER
 #include INTEL_FAMILY_HEADER
+#include BUILD_BUG_HEADER
 #include <stdarg.h>
 #include <stdio.h>
 #include <err.h>
 #include <stdbool.h>
 #include <assert.h>
 #include <linux/kernel.h>
-#include <linux/build_bug.h>
 #define UNUSED(x) (void)(x)
 	if (access("/sys/devices/system/cpu/intel_uncore_frequency/uncore00/current_freq_khz", R_OK))
 		return;
-	if (quiet)
-		return;
 	for (uncore_max_id = 0;; ++uncore_max_id) {
 		sprintf(path_base, "/sys/devices/system/cpu/intel_uncore_frequency/uncore%02d", uncore_max_id);
 		sprintf(path, "%s/fabric_cluster_id", path_base);
 		cluster_id = read_sysfs_int(path);
+		sprintf(path, "%s/current_freq_khz", path_base);
+		sprintf(name_buf, "UMHz%d.%d", domain_id, cluster_id);
+		add_counter(0, path, name_buf, 0, SCOPE_PACKAGE, COUNTER_K2M, FORMAT_AVERAGE, 0, package_id);
+		if (quiet)
+			continue;
 		sprintf(path, "%s/min_freq_khz", path_base);
 		k = read_sysfs_int(path);
 		sprintf(path, "%s/max_freq_khz", path_base);
 		sprintf(path, "%s/current_freq_khz", path_base);
 		k = read_sysfs_int(path);
 		fprintf(outf, " %d MHz\n", k / 1000);
-		sprintf(path, "%s/current_freq_khz", path_base);
-		sprintf(name_buf, "UMHz%d.%d", domain_id, cluster_id);
-		add_counter(0, path, name_buf, 0, SCOPE_PACKAGE, COUNTER_K2M, FORMAT_AVERAGE, 0, package_id);
 	}
 }
 	 * Parse some options early, because they may make other options invalid,
 	 * like adding the MSR counter with --add and at the same time using --no-msr.
 	 */
-	while ((opt = getopt_long_only(argc, argv, "MP", long_options, &option_index)) != -1) {
+	while ((opt = getopt_long_only(argc, argv, "MPn:", long_options, &option_index)) != -1) {
 		switch (opt) {
 		case 'M':
 			no_msr = 1;

tools/testing/cxl/test/cxl.c+4−0

 					  struct cxl_endpoint_dvsec_info *info)
 {
 	struct cxl_hdm *cxlhdm = devm_kzalloc(&port->dev, sizeof(*cxlhdm), GFP_KERNEL);
+	struct device *dev = &port->dev;
 	if (!cxlhdm)
 		return ERR_PTR(-ENOMEM);
 	cxlhdm->port = port;
+	cxlhdm->interleave_mask = ~0U;
+	cxlhdm->iw_cap_mask = ~0UL;
+	dev_set_drvdata(dev, cxlhdm);
 	return cxlhdm;
 }

tools/testing/selftests/kselftest_harness.h+24−19

 #include <sys/wait.h>
 #include <unistd.h>
 #include <setjmp.h>
-#include <syscall.h>
-#include <linux/sched.h>
 #include "kselftest.h"
 #  define TH_LOG_ENABLED 1
 #endif
-/* Wait for the child process to end but without sharing memory mapping. */
-static inline pid_t clone3_vfork(void)
-{
-	struct clone_args args = {
-		.flags = CLONE_VFORK,
-		.exit_signal = SIGCHLD,
-	};
-	return syscall(__NR_clone3, &args, sizeof(args));
-}
 /**
  * TH_LOG()
  *
 		} \
 		if (setjmp(_metadata->env) == 0) { \
 			/* _metadata and potentially self are shared with all forks. */ \
-			child = clone3_vfork(); \
+			child = fork(); \
 			if (child == 0) { \
 				fixture_name##_setup(_metadata, self, variant->data); \
 				/* Let setup failure terminate early. */ \
 		.sa_flags = SA_SIGINFO,
 	};
 	struct sigaction saved_action;
-	int status;
+	/*
+	 * Sets status so that WIFEXITED(status) returns true and
+	 * WEXITSTATUS(status) returns KSFT_FAIL.  This safe default value
+	 * should never be evaluated because of the waitpid(2) check and
+	 * SIGALRM handling.
+	 */
+	int status = KSFT_FAIL << 8;
+	int child;
 	if (sigaction(SIGALRM, &action, &saved_action)) {
 		t->exit_code = KSFT_FAIL;
 	__active_test = t;
 	t->timed_out = false;
 	alarm(t->timeout);
-	waitpid(t->pid, &status, 0);
+	child = waitpid(t->pid, &status, 0);
+	if (child == -1 && errno != EINTR) {
+		t->exit_code = KSFT_FAIL;
+		fprintf(TH_LOG_STREAM,
+			"# %s: Failed to wait for PID %d (errno: %d)\n",
+			t->name, t->pid, errno);
+		return;
+	}
 	alarm(0);
 	if (sigaction(SIGALRM, &saved_action, NULL)) {
 		t->exit_code = KSFT_FAIL;
 				WTERMSIG(status));
 		}
 	} else {
+		t->exit_code = KSFT_FAIL;
 		fprintf(TH_LOG_STREAM,
 			"# %s: Test ended in some other way [%u]\n",
 			t->name,
 	struct __test_xfail *xfail;
 	char test_name[1024];
 	const char *diagnostic;
+	int child;
 	/* reset test struct */
 	t->exit_code = KSFT_PASS;
 	fflush(stdout);
 	fflush(stderr);
-	t->pid = clone3_vfork();
+	child = fork();
-	if (t->pid < 0) {
+	if (child < 0) {
 		ksft_print_msg("ERROR SPAWNING TEST CHILD\n");
 		t->exit_code = KSFT_FAIL;
-	} else if (t->pid == 0) {
+	} else if (child == 0) {
 		setpgrp();
 		t->fn(t, variant);
 		_exit(t->exit_code);
 	} else {
+		t->pid = child;
 		__wait_for_test(t);
 	}
 	ksft_print_msg("         %4s  %s\n",

tools/testing/selftests/net/af_unix/scm_rights.c+23−2

 FIXTURE(scm_rights)
 {
-	int fd[16];
+	int fd[32];
 };
 FIXTURE_VARIANT(scm_rights)
 {
-	char name[16];
+	char name[32];
 	int type;
 	int flags;
 	bool test_listener;
 			     const FIXTURE_VARIANT(scm_rights) *variant,
 			     int n)
 {
+	ASSERT_LE(n * 2, sizeof(self->fd) / sizeof(self->fd[0]));
 	if (variant->test_listener)
 		create_listeners(_metadata, self, n);
 	else
 	close_sockets(8);
 }
+TEST_F(scm_rights, backtrack_from_scc)
+{
+	create_sockets(10);
+	send_fd(0, 1);
+	send_fd(0, 4);
+	send_fd(1, 2);
+	send_fd(2, 3);
+	send_fd(3, 1);
+	send_fd(5, 6);
+	send_fd(5, 9);
+	send_fd(6, 7);
+	send_fd(7, 8);
+	send_fd(8, 6);
+	close_sockets(10);
+}
 TEST_HARNESS_MAIN

tools/testing/selftests/net/msg_zerocopy.c+12−2

 static int  cfg_runtime_ms	= 4200;
 static int  cfg_verbose;
 static int  cfg_waittime_ms	= 500;
+static int  cfg_notification_limit = 32;
 static bool cfg_zerocopy;
 static socklen_t cfg_alen;
 static long packets, bytes, completions, expected_completions;
 static int  zerocopied = -1;
 static uint32_t next_completion;
+static uint32_t sends_since_notify;
 static unsigned long gettimeofday_ms(void)
 {
 		error(1, errno, "send");
 	if (cfg_verbose && ret != len)
 		fprintf(stderr, "send: ret=%u != %u\n", ret, len);
+	sends_since_notify++;
 	if (len) {
 		packets++;
 	/* Detect notification gaps. These should not happen often, if at all.
 	 * Gaps can occur due to drops, reordering and retransmissions.
 	 */
-	if (lo != next_completion)
+	if (cfg_verbose && lo != next_completion)
 		fprintf(stderr, "gap: %u..%u does not append to %u\n",
 			lo, hi, next_completion);
 	next_completion = hi + 1;
 static void do_recv_completions(int fd, int domain)
 {
 	while (do_recv_completion(fd, domain)) {}
+	sends_since_notify = 0;
 }
 /* Wait for all remaining completions on the errqueue */
 		else
 			do_sendmsg(fd, &msg, cfg_zerocopy, domain);
+		if (cfg_zerocopy && sends_since_notify >= cfg_notification_limit)
+			do_recv_completions(fd, domain);
 		while (!do_poll(fd, POLLOUT)) {
 			if (cfg_zerocopy)
 				do_recv_completions(fd, domain);
 	cfg_payload_len = max_payload_len;
-	while ((c = getopt(argc, argv, "46c:C:D:i:mp:rs:S:t:vz")) != -1) {
+	while ((c = getopt(argc, argv, "46c:C:D:i:l:mp:rs:S:t:vz")) != -1) {
 		switch (c) {
 		case '4':
 			if (cfg_family != PF_UNSPEC)
 			if (cfg_ifindex == 0)
 				error(1, errno, "invalid iface: %s", optarg);
 			break;
+		case 'l':
+			cfg_notification_limit = strtoul(optarg, NULL, 0);
+			break;
 		case 'm':
 			cfg_cork_mixed = true;
 			break;

tools/testing/selftests/resctrl/cat_test.c+22−10

 	return ret;
 }
+static bool arch_supports_noncont_cat(const struct resctrl_test *test)
+{
+	unsigned int eax, ebx, ecx, edx;
+	/* AMD always supports non-contiguous CBM. */
+	if (get_vendor() == ARCH_AMD)
+		return true;
+	/* Intel support for non-contiguous CBM needs to be discovered. */
+	if (!strcmp(test->resource, "L3"))
+		__cpuid_count(0x10, 1, eax, ebx, ecx, edx);
+	else if (!strcmp(test->resource, "L2"))
+		__cpuid_count(0x10, 2, eax, ebx, ecx, edx);
+	else
+		return false;
+	return ((ecx >> 3) & 1);
+}
 static int noncont_cat_run_test(const struct resctrl_test *test,
 				const struct user_params *uparams)
 {
 	unsigned long full_cache_mask, cont_mask, noncont_mask;
-	unsigned int eax, ebx, ecx, edx, sparse_masks;
+	unsigned int sparse_masks;
 	int bit_center, ret;
 	char schemata[64];
 	if (ret)
 		return ret;
-	if (!strcmp(test->resource, "L3"))
+	if (arch_supports_noncont_cat(test) != sparse_masks) {
-		__cpuid_count(0x10, 1, eax, ebx, ecx, edx);
+		ksft_print_msg("Hardware and kernel differ on non-contiguous CBM support!\n");
-	else if (!strcmp(test->resource, "L2"))
-		__cpuid_count(0x10, 2, eax, ebx, ecx, edx);
-	else
-		return -EINVAL;
-	if (sparse_masks != ((ecx >> 3) & 1)) {
-		ksft_print_msg("CPUID output doesn't match 'sparse_masks' file content!\n");
 		return 1;
 	}

Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -108,7 +108,7 @@ · 107 unmodified lines
108	95 common fchown sys_fchown	108	95 common fchown sys_fchown
109	96 common getpriority sys_getpriority	109	96 common getpriority sys_getpriority
110	97 common setpriority sys_setpriority	110	97 common setpriority sys_setpriority
111	98 common recv sys_recv	111	98 common recv sys_recv compat_sys_recv
112	99 common statfs sys_statfs compat_sys_statfs	112	99 common statfs sys_statfs compat_sys_statfs
113	100 common fstatfs sys_fstatfs compat_sys_fstatfs	113	100 common fstatfs sys_fstatfs compat_sys_fstatfs
114	101 common stat64 sys_stat64	114	101 common stat64 sys_stat64
@@ -135,7 +135,7 @@ · 20 unmodified lines
135	120 common clone sys_clone_wrapper	135	120 common clone sys_clone_wrapper
136	121 common setdomainname sys_setdomainname	136	121 common setdomainname sys_setdomainname
137	122 common sendfile sys_sendfile compat_sys_sendfile	137	122 common sendfile sys_sendfile compat_sys_sendfile
138	123 common recvfrom sys_recvfrom	138	123 common recvfrom sys_recvfrom compat_sys_recvfrom
139	124 32 adjtimex sys_adjtimex_time32	139	124 32 adjtimex sys_adjtimex_time32
140	124 64 adjtimex sys_adjtimex	140	124 64 adjtimex sys_adjtimex
141	125 common mprotect sys_mprotect	141	125 common mprotect sys_mprotect
@@ -364,7 +364,7 @@ · 222 unmodified lines
364	320 common accept4 sys_accept4	364	320 common accept4 sys_accept4
365	321 common prlimit64 sys_prlimit64	365	321 common prlimit64 sys_prlimit64
366	322 common fanotify_init sys_fanotify_init	366	322 common fanotify_init sys_fanotify_init
367	323 common fanotify_mark sys_fanotify_mark sys32_fanotify_mark	367	323 common fanotify_mark sys_fanotify_mark compat_sys_fanotify_mark
368	324 32 clock_adjtime sys_clock_adjtime32	368	324 32 clock_adjtime sys_clock_adjtime32
369	324 64 clock_adjtime sys_clock_adjtime	369	324 64 clock_adjtime sys_clock_adjtime
370	325 common name_to_handle_at sys_name_to_handle_at	370	325 common name_to_handle_at sys_name_to_handle_at