lael-labs/linux

.mailmap+4−2

 Lee Jones <lee@kernel.org> <lee.jones@canonical.com>
 Lee Jones <lee@kernel.org> <lee.jones@linaro.org>
 Lee Jones <lee@kernel.org> <lee@ubuntu.com>
-Leonard Crestez <leonard.crestez@nxp.com> Leonard Crestez <cdleonard@gmail.com>
+Leonard Crestez <cdleonard@gmail.com> <leonard.crestez@nxp.com>
+Leonard Crestez <cdleonard@gmail.com> <leonard.crestez@intel.com>
 Leonardo Bras <leobras.c@gmail.com> <leonardo@linux.ibm.com>
 Leonard Göhrs <l.goehrs@pengutronix.de>
 Leonid I Ananiev <leonid.i.ananiev@intel.com>
 Punit Agrawal <punitagrawal@gmail.com> <punit.agrawal@arm.com>
 Qais Yousef <qyousef@layalina.io> <qais.yousef@imgtec.com>
 Qais Yousef <qyousef@layalina.io> <qais.yousef@arm.com>
-Quentin Monnet <quentin@isovalent.com> <quentin.monnet@netronome.com>
+Quentin Monnet <qmo@kernel.org> <quentin.monnet@netronome.com>
+Quentin Monnet <qmo@kernel.org> <quentin@isovalent.com>
 Quentin Perret <qperret@qperret.net> <quentin.perret@arm.com>
 Rafael J. Wysocki <rjw@rjwysocki.net> <rjw@sisk.pl>
 Rajeev Nandan <quic_rajeevny@quicinc.com> <rajeevny@codeaurora.org>

Documentation/arch/x86/resctrl.rst+1−1

@@ -574,7 +574,7 @@ Memory b/w domain is L3 cache. · 573 unmodified lines
574	MB:<cache_id0>=bandwidth0;<cache_id1>=bandwidth1;...	574	MB:<cache_id0>=bandwidth0;<cache_id1>=bandwidth1;...
575		575
576	Memory bandwidth Allocation specified in MiBps	576	Memory bandwidth Allocation specified in MiBps
577	---------------------------------------------	577	----------------------------------------------
578		578
579	Memory bandwidth domain is L3 cache.	579	Memory bandwidth domain is L3 cache.
580	::	580	::

Documentation/kbuild/llvm.rst+1−1

@@ -178,7 +178,7 @@ yet. Bug reports are always welcome at the issue tracker below! · 177 unmodified lines
178	- ``LLVM=1``	178	- ``LLVM=1``
179	* - s390	179	* - s390
180	- Maintained	180	- Maintained
181	- ``CC=clang``	181	- ``LLVM=1`` (LLVM >= 18.1.0), ``CC=clang`` (LLVM < 18.1.0)
182	* - um (User Mode)	182	* - um (User Mode)
183	- Maintained	183	- Maintained
184	- ``LLVM=1``	184	- ``LLVM=1``

MAINTAINERS+61−17

@@ -3942,8 +3942,7 @@ F: kernel/bpf/ringbuf.c · 3941 unmodified lines
3942		3942
3943	BPF [SECURITY & LSM] (Security Audit and Enforcement using BPF)	3943	BPF [SECURITY & LSM] (Security Audit and Enforcement using BPF)
3944	M: KP Singh <kpsingh@kernel.org>	3944	M: KP Singh <kpsingh@kernel.org>
3945	R: Florent Revest <revest@chromium.org>	3945	R: Matt Bobrowski <mattbobrowski@google.com>
3946	R: Brendan Jackman <jackmanb@chromium.org>
3947	L: bpf@vger.kernel.org	3946	L: bpf@vger.kernel.org
3948	S: Maintained	3947	S: Maintained
3949	F: Documentation/bpf/prog_lsm.rst	3948	F: Documentation/bpf/prog_lsm.rst
@@ -3968,7 +3967,7 @@ F: kernel/bpf/bpf_lru* · 18 unmodified lines
3968	F: kernel/bpf/cgroup.c	3967	F: kernel/bpf/cgroup.c
3969		3968
3970	BPF [TOOLING] (bpftool)	3969	BPF [TOOLING] (bpftool)
3971	M: Quentin Monnet <quentin@isovalent.com>	3970	M: Quentin Monnet <qmo@kernel.org>
3972	L: bpf@vger.kernel.org	3971	L: bpf@vger.kernel.org
3973	S: Maintained	3972	S: Maintained
3974	F: kernel/bpf/disasm.*	3973	F: kernel/bpf/disasm.*
@@ -6157,7 +6156,6 @@ DEVICE-MAPPER (LVM) · 2182 unmodified lines
6157	M: Alasdair Kergon <agk@redhat.com>	6156	M: Alasdair Kergon <agk@redhat.com>
6158	M: Mike Snitzer <snitzer@kernel.org>	6157	M: Mike Snitzer <snitzer@kernel.org>
6159	M: Mikulas Patocka <mpatocka@redhat.com>	6158	M: Mikulas Patocka <mpatocka@redhat.com>
6160	M: dm-devel@lists.linux.dev
6161	L: dm-devel@lists.linux.dev	6159	L: dm-devel@lists.linux.dev
6162	S: Maintained	6160	S: Maintained
6163	Q: http://patchwork.kernel.org/project/dm-devel/list/	6161	Q: http://patchwork.kernel.org/project/dm-devel/list/
@@ -6173,7 +6171,6 @@ F: include/uapi/linux/dm-*.h · 9 unmodified lines
6173		6171
6174	DEVICE-MAPPER VDO TARGET	6172	DEVICE-MAPPER VDO TARGET
6175	M: Matthew Sakai <msakai@redhat.com>	6173	M: Matthew Sakai <msakai@redhat.com>
6176	M: dm-devel@lists.linux.dev
6177	L: dm-devel@lists.linux.dev	6174	L: dm-devel@lists.linux.dev
6178	S: Maintained	6175	S: Maintained
6179	F: Documentation/admin-guide/device-mapper/vdo*.rst	6176	F: Documentation/admin-guide/device-mapper/vdo*.rst
@@ -7941,6 +7938,7 @@ M: Gao Xiang <xiang@kernel.org> · 1761 unmodified lines
7941	M: Chao Yu <chao@kernel.org>	7938	M: Chao Yu <chao@kernel.org>
7942	R: Yue Hu <huyue2@coolpad.com>	7939	R: Yue Hu <huyue2@coolpad.com>
7943	R: Jeffle Xu <jefflexu@linux.alibaba.com>	7940	R: Jeffle Xu <jefflexu@linux.alibaba.com>
		7941	R: Sandeep Dhavale <dhavale@google.com>
7944	L: linux-erofs@lists.ozlabs.org	7942	L: linux-erofs@lists.ozlabs.org
7945	S: Maintained	7943	S: Maintained
7946	W: https://erofs.docs.kernel.org	7944	W: https://erofs.docs.kernel.org
@@ -9653,7 +9651,9 @@ L: linux-input@vger.kernel.org · 1706 unmodified lines
9653	S: Maintained	9651	S: Maintained
9654	F: drivers/hid/hid-logitech-hidpp.c	9652	F: drivers/hid/hid-logitech-hidpp.c
9655		9653
9656	HIGH-RESOLUTION TIMERS, CLOCKEVENTS	9654	HIGH-RESOLUTION TIMERS, TIMER WHEEL, CLOCKEVENTS
		9655	M: Anna-Maria Behnsen <anna-maria@linutronix.de>
		9656	M: Frederic Weisbecker <frederic@kernel.org>
9657	M: Thomas Gleixner <tglx@linutronix.de>	9657	M: Thomas Gleixner <tglx@linutronix.de>
9658	L: linux-kernel@vger.kernel.org	9658	L: linux-kernel@vger.kernel.org
9659	S: Maintained	9659	S: Maintained
@@ -9661,9 +9661,13 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core · 1 unmodified line
9661	F: Documentation/timers/	9661	F: Documentation/timers/
9662	F: include/linux/clockchips.h	9662	F: include/linux/clockchips.h
9663	F: include/linux/hrtimer.h	9663	F: include/linux/hrtimer.h
		9664	F: include/linux/timer.h
9664	F: kernel/time/clockevents.c	9665	F: kernel/time/clockevents.c
9665	F: kernel/time/hrtimer.c	9666	F: kernel/time/hrtimer.c
9666	F: kernel/time/timer_*.c	9667	F: kernel/time/timer.c
		9668	F: kernel/time/timer_list.c
		9669	F: kernel/time/timer_migration.*
		9670	F: tools/testing/selftests/timers/
9667		9671
9668	HIGH-SPEED SCC DRIVER FOR AX.25	9672	HIGH-SPEED SCC DRIVER FOR AX.25
9669	L: linux-hams@vger.kernel.org	9673	L: linux-hams@vger.kernel.org
@@ -13134,6 +13138,7 @@ F: drivers/net/ethernet/marvell/mvpp2/ · 3464 unmodified lines
13134		13138
13135	MARVELL MWIFIEX WIRELESS DRIVER	13139	MARVELL MWIFIEX WIRELESS DRIVER
13136	M: Brian Norris <briannorris@chromium.org>	13140	M: Brian Norris <briannorris@chromium.org>
		13141	R: Francesco Dolcini <francesco@dolcini.it>
13137	L: linux-wireless@vger.kernel.org	13142	L: linux-wireless@vger.kernel.org
13138	S: Odd Fixes	13143	S: Odd Fixes
13139	F: drivers/net/wireless/marvell/mwifiex/	13144	F: drivers/net/wireless/marvell/mwifiex/
@@ -15627,9 +15632,10 @@ F: drivers/misc/nsm.c · 2487 unmodified lines
15627	F: include/uapi/linux/nsm.h	15632	F: include/uapi/linux/nsm.h
15628		15633
15629	NOHZ, DYNTICKS SUPPORT	15634	NOHZ, DYNTICKS SUPPORT
		15635	M: Anna-Maria Behnsen <anna-maria@linutronix.de>
15630	M: Frederic Weisbecker <frederic@kernel.org>	15636	M: Frederic Weisbecker <frederic@kernel.org>
15631	M: Thomas Gleixner <tglx@linutronix.de>
15632	M: Ingo Molnar <mingo@kernel.org>	15637	M: Ingo Molnar <mingo@kernel.org>
		15638	M: Thomas Gleixner <tglx@linutronix.de>
15633	L: linux-kernel@vger.kernel.org	15639	L: linux-kernel@vger.kernel.org
15634	S: Maintained	15640	S: Maintained
15635	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/nohz	15641	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/nohz
@@ -17590,15 +17596,20 @@ F: drivers/pnp/ · 1954 unmodified lines
17590	F: include/linux/pnp.h	17596	F: include/linux/pnp.h
17591		17597
17592	POSIX CLOCKS and TIMERS	17598	POSIX CLOCKS and TIMERS
		17599	M: Anna-Maria Behnsen <anna-maria@linutronix.de>
		17600	M: Frederic Weisbecker <frederic@kernel.org>
17593	M: Thomas Gleixner <tglx@linutronix.de>	17601	M: Thomas Gleixner <tglx@linutronix.de>
17594	L: linux-kernel@vger.kernel.org	17602	L: linux-kernel@vger.kernel.org
17595	S: Maintained	17603	S: Maintained
17596	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core	17604	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
17597	F: fs/timerfd.c	17605	F: fs/timerfd.c
17598	F: include/linux/time_namespace.h	17606	F: include/linux/time_namespace.h
17599	F: include/linux/timer*	17607	F: include/linux/timerfd.h
		17608	F: include/uapi/linux/time.h
		17609	F: include/uapi/linux/timerfd.h
17600	F: include/trace/events/timer*	17610	F: include/trace/events/timer*
17601	F: kernel/time/timer	17611	F: kernel/time/itimer.c
		17612	F: kernel/time/posix-*
17602	F: kernel/time/namespace.c	17613	F: kernel/time/namespace.c
17603		17614
17604	POWER MANAGEMENT CORE	17615	POWER MANAGEMENT CORE
@@ -18645,18 +18656,21 @@ REALTEK WIRELESS DRIVER (rtlwifi family) · 1040 unmodified lines
18645	M: Ping-Ke Shih <pkshih@realtek.com>	18656	M: Ping-Ke Shih <pkshih@realtek.com>
18646	L: linux-wireless@vger.kernel.org	18657	L: linux-wireless@vger.kernel.org
18647	S: Maintained	18658	S: Maintained
		18659	T: git https://github.com/pkshih/rtw.git
18648	F: drivers/net/wireless/realtek/rtlwifi/	18660	F: drivers/net/wireless/realtek/rtlwifi/
18649		18661
18650	REALTEK WIRELESS DRIVER (rtw88)	18662	REALTEK WIRELESS DRIVER (rtw88)
18651	M: Ping-Ke Shih <pkshih@realtek.com>	18663	M: Ping-Ke Shih <pkshih@realtek.com>
18652	L: linux-wireless@vger.kernel.org	18664	L: linux-wireless@vger.kernel.org
18653	S: Maintained	18665	S: Maintained
		18666	T: git https://github.com/pkshih/rtw.git
18654	F: drivers/net/wireless/realtek/rtw88/	18667	F: drivers/net/wireless/realtek/rtw88/
18655		18668
18656	REALTEK WIRELESS DRIVER (rtw89)	18669	REALTEK WIRELESS DRIVER (rtw89)
18657	M: Ping-Ke Shih <pkshih@realtek.com>	18670	M: Ping-Ke Shih <pkshih@realtek.com>
18658	L: linux-wireless@vger.kernel.org	18671	L: linux-wireless@vger.kernel.org
18659	S: Maintained	18672	S: Maintained
		18673	T: git https://github.com/pkshih/rtw.git
18660	F: drivers/net/wireless/realtek/rtw89/	18674	F: drivers/net/wireless/realtek/rtw89/
18661		18675
18662	REDPINE WIRELESS DRIVER	18676	REDPINE WIRELESS DRIVER
@@ -18727,13 +18741,24 @@ S: Supported · 64 unmodified lines
18727	F: Documentation/devicetree/bindings/i2c/renesas,iic-emev2.yaml	18741	F: Documentation/devicetree/bindings/i2c/renesas,iic-emev2.yaml
18728	F: drivers/i2c/busses/i2c-emev2.c	18742	F: drivers/i2c/busses/i2c-emev2.c
18729		18743
18730	RENESAS ETHERNET DRIVERS	18744	RENESAS ETHERNET AVB DRIVER
18731	R: Sergey Shtylyov <s.shtylyov@omp.ru>	18745	R: Sergey Shtylyov <s.shtylyov@omp.ru>
18732	L: netdev@vger.kernel.org	18746	L: netdev@vger.kernel.org
18733	L: linux-renesas-soc@vger.kernel.org	18747	L: linux-renesas-soc@vger.kernel.org
18734	F: Documentation/devicetree/bindings/net/renesas,*.yaml	18748	F: Documentation/devicetree/bindings/net/renesas,etheravb.yaml
18735	F: drivers/net/ethernet/renesas/	18749	F: drivers/net/ethernet/renesas/Kconfig
18736	F: include/linux/sh_eth.h	18750	F: drivers/net/ethernet/renesas/Makefile
		18751	F: drivers/net/ethernet/renesas/ravb*
		18752
		18753	RENESAS ETHERNET SWITCH DRIVER
		18754	R: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
		18755	L: netdev@vger.kernel.org
		18756	L: linux-renesas-soc@vger.kernel.org
		18757	F: Documentation/devicetree/bindings/net/renesas,*ether-switch.yaml
		18758	F: drivers/net/ethernet/renesas/Kconfig
		18759	F: drivers/net/ethernet/renesas/Makefile
		18760	F: drivers/net/ethernet/renesas/rcar_gen4*
		18761	F: drivers/net/ethernet/renesas/rswitch*
18737		18762
18738	RENESAS IDT821034 ASoC CODEC	18763	RENESAS IDT821034 ASoC CODEC
18739	M: Herve Codina <herve.codina@bootlin.com>	18764	M: Herve Codina <herve.codina@bootlin.com>
@@ -18843,6 +18868,16 @@ S: Supported · 103 unmodified lines
18843	F: Documentation/devicetree/bindings/i2c/renesas,rzv2m.yaml	18868	F: Documentation/devicetree/bindings/i2c/renesas,rzv2m.yaml
18844	F: drivers/i2c/busses/i2c-rzv2m.c	18869	F: drivers/i2c/busses/i2c-rzv2m.c
18845		18870
		18871	RENESAS SUPERH ETHERNET DRIVER
		18872	R: Sergey Shtylyov <s.shtylyov@omp.ru>
		18873	L: netdev@vger.kernel.org
		18874	L: linux-renesas-soc@vger.kernel.org
		18875	F: Documentation/devicetree/bindings/net/renesas,ether.yaml
		18876	F: drivers/net/ethernet/renesas/Kconfig
		18877	F: drivers/net/ethernet/renesas/Makefile
		18878	F: drivers/net/ethernet/renesas/sh_eth*
		18879	F: include/linux/sh_eth.h
		18880
18846	RENESAS USB PHY DRIVER	18881	RENESAS USB PHY DRIVER
18847	M: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>	18882	M: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
18848	L: linux-renesas-soc@vger.kernel.org	18883	L: linux-renesas-soc@vger.kernel.org
@@ -19179,12 +19214,14 @@ M: Hin-Tak Leung <hintak.leung@gmail.com> · 330 unmodified lines
19179	M: Larry Finger <Larry.Finger@lwfinger.net>	19214	M: Larry Finger <Larry.Finger@lwfinger.net>
19180	L: linux-wireless@vger.kernel.org	19215	L: linux-wireless@vger.kernel.org
19181	S: Maintained	19216	S: Maintained
		19217	T: git https://github.com/pkshih/rtw.git
19182	F: drivers/net/wireless/realtek/rtl818x/rtl8187/	19218	F: drivers/net/wireless/realtek/rtl818x/rtl8187/
19183		19219
19184	RTL8XXXU WIRELESS DRIVER (rtl8xxxu)	19220	RTL8XXXU WIRELESS DRIVER (rtl8xxxu)
19185	M: Jes Sorensen <Jes.Sorensen@gmail.com>	19221	M: Jes Sorensen <Jes.Sorensen@gmail.com>
19186	L: linux-wireless@vger.kernel.org	19222	L: linux-wireless@vger.kernel.org
19187	S: Maintained	19223	S: Maintained
		19224	T: git https://github.com/pkshih/rtw.git
19188	F: drivers/net/wireless/realtek/rtl8xxxu/	19225	F: drivers/net/wireless/realtek/rtl8xxxu/
19189		19226
19190	RTRS TRANSPORT DRIVERS	19227	RTRS TRANSPORT DRIVERS
@@ -22254,13 +22291,20 @@ S: Supported · 3063 unmodified lines
22254	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core	22291	T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
22255	F: include/linux/clocksource.h	22292	F: include/linux/clocksource.h
22256	F: include/linux/time.h	22293	F: include/linux/time.h
		22294	F: include/linux/timekeeper_internal.h
		22295	F: include/linux/timekeeping.h
22257	F: include/linux/timex.h	22296	F: include/linux/timex.h
22258	F: include/uapi/linux/time.h	22297	F: include/uapi/linux/time.h
22259	F: include/uapi/linux/timex.h	22298	F: include/uapi/linux/timex.h
22260	F: kernel/time/alarmtimer.c	22299	F: kernel/time/alarmtimer.c
22261	F: kernel/time/clocksource.c	22300	F: kernel/time/clocksource*
22262	F: kernel/time/ntp.c	22301	F: kernel/time/ntp*
22263	F: kernel/time/time*.c	22302	F: kernel/time/time.c
		22303	F: kernel/time/timeconst.bc
		22304	F: kernel/time/timeconv.c
		22305	F: kernel/time/timecounter.c
		22306	F: kernel/time/timekeeping*
		22307	F: kernel/time/time_test.c
22264	F: tools/testing/selftests/timers/	22308	F: tools/testing/selftests/timers/
22265		22309
22266	TIPC NETWORK LAYER	22310	TIPC NETWORK LAYER

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 6	2	VERSION = 6
3	PATCHLEVEL = 9	3	PATCHLEVEL = 9
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc1	5	EXTRAVERSION = -rc2
6	NAME = Hurr durr I'ma ninja sloth	6	NAME = Hurr durr I'ma ninja sloth
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/include/asm/mman.h+14−0

@@ -0,0 +1,14 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __ASM_MMAN_H__
	3	#define __ASM_MMAN_H__
	4
	5	#include <asm/system_info.h>
	6	#include <uapi/asm/mman.h>
	7
	8	static inline bool arch_memory_deny_write_exec_supported(void)
	9	{
	10	return cpu_architecture() >= CPU_ARCH_ARMv6;
	11	}
	12	#define arch_memory_deny_write_exec_supported arch_memory_deny_write_exec_supported
	13
	14	#endif /* __ASM_MMAN_H__ */

arch/arm64/net/bpf_jit_comp.c+2−2

@@ -943,7 +943,7 @@ static int build_insn(const struct bpf_insn insn, struct jit_ctx ctx, · 942 unmodified lines
943	emit(A64_UXTH(is64, dst, dst), ctx);	943	emit(A64_UXTH(is64, dst, dst), ctx);
944	break;	944	break;
945	case 32:	945	case 32:
946	emit(A64_REV32(is64, dst, dst), ctx);	946	emit(A64_REV32(0, dst, dst), ctx);
947	/* upper 32 bits already cleared */	947	/* upper 32 bits already cleared */
948	break;	948	break;
949	case 64:	949	case 64:
@@ -1256,7 +1256,7 @@ emit_cond_jmp: · 306 unmodified lines
1256	} else {	1256	} else {
1257	emit_a64_mov_i(1, tmp, off, ctx);	1257	emit_a64_mov_i(1, tmp, off, ctx);
1258	if (sign_extend)	1258	if (sign_extend)
1259	emit(A64_LDRSW(dst, src_adj, off_adj), ctx);	1259	emit(A64_LDRSW(dst, src, tmp), ctx);
1260	else	1260	else
1261	emit(A64_LDR32(dst, src, tmp), ctx);	1261	emit(A64_LDR32(dst, src, tmp), ctx);
1262	}	1262	}

arch/hexagon/kernel/vmlinux.lds.S+1−0

@@ -63,6 +63,7 @@ SECTIONS · 62 unmodified lines
63	STABS_DEBUG	63	STABS_DEBUG
64	DWARF_DEBUG	64	DWARF_DEBUG
65	ELF_DETAILS	65	ELF_DETAILS
		66	.hexagon.attributes 0 : { *(.hexagon.attributes) }
66		67
67	DISCARDS	68	DISCARDS
68	}	69	}

arch/mips/Kconfig+9−9

 	bool
-config FIT_IMAGE_FDT_EPM5
-	bool "Include FDT for Mobileye EyeQ5 development platforms"
-	depends on MACH_EYEQ5
-	default n
-	help
-	  Enable this to include the FDT for the EyeQ5 development platforms
-	  from Mobileye in the FIT kernel image.
-	  This requires u-boot on the platform.
 config MACH_NINTENDO64
 	bool "Nintendo 64 console"
 	select CEVT_R4K
 endchoice
+config FIT_IMAGE_FDT_EPM5
+	bool "Include FDT for Mobileye EyeQ5 development platforms"
+	depends on MACH_EYEQ5
+	default n
+	help
+	  Enable this to include the FDT for the EyeQ5 development platforms
+	  from Mobileye in the FIT kernel image.
+	  This requires u-boot on the platform.
 source "arch/mips/alchemy/Kconfig"
 source "arch/mips/ath25/Kconfig"
 source "arch/mips/ath79/Kconfig"

arch/parisc/include/asm/mman.h+14−0

@@ -0,0 +1,14 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __ASM_MMAN_H__
	3	#define __ASM_MMAN_H__
	4
	5	#include <uapi/asm/mman.h>
	6
	7	/* PARISC cannot allow mdwe as it needs writable stacks */
	8	static inline bool arch_memory_deny_write_exec_supported(void)
	9	{
	10	return false;
	11	}
	12	#define arch_memory_deny_write_exec_supported arch_memory_deny_write_exec_supported
	13
	14	#endif /* __ASM_MMAN_H__ */

arch/riscv/net/bpf_jit_comp64.c+16−0

@@ -1463,6 +1463,22 @@ int bpf_jit_emit_insn(const struct bpf_insn insn, struct rv_jit_context ctx, · 1462 unmodified lines
1463	if (ret < 0)	1463	if (ret < 0)
1464	return ret;	1464	return ret;
1465		1465
		1466	if (insn->src_reg == BPF_PSEUDO_KFUNC_CALL) {
		1467	const struct btf_func_model *fm;
		1468	int idx;
		1469
		1470	fm = bpf_jit_find_kfunc_model(ctx->prog, insn);
		1471	if (!fm)
		1472	return -EINVAL;
		1473
		1474	for (idx = 0; idx < fm->nr_args; idx++) {
		1475	u8 reg = bpf_to_rv_reg(BPF_REG_1 + idx, ctx);
		1476
		1477	if (fm->arg_size[idx] == sizeof(int))
		1478	emit_sextw(reg, reg, ctx);
		1479	}
		1480	}
		1481
1466	ret = emit_call(addr, fixed_addr, ctx);	1482	ret = emit_call(addr, fixed_addr, ctx);
1467	if (ret)	1483	if (ret)
1468	return ret;	1484	return ret;

arch/s390/net/bpf_jit_comp.c+20−26

  * PLT for hotpatchable calls. The calling convention is the same as for the
  * ftrace hotpatch trampolines: %r0 is return address, %r1 is clobbered.
  */
-extern const char bpf_plt[];
+struct bpf_plt {
-extern const char bpf_plt_ret[];
+	char code[16];
-extern const char bpf_plt_target[];
+	void *ret;
-extern const char bpf_plt_end[];
+	void *target;
-#define BPF_PLT_SIZE 32
+} __packed;
+extern const struct bpf_plt bpf_plt;
 asm(
 	".pushsection .rodata\n"
 	"	.balign 8\n"
 	"	.balign 8\n"
 	"bpf_plt_ret: .quad 0\n"
 	"bpf_plt_target: .quad 0\n"
-	"bpf_plt_end:\n"
 	"	.popsection\n"
 );
-static void bpf_jit_plt(void *plt, void *ret, void *target)
+static void bpf_jit_plt(struct bpf_plt *plt, void *ret, void *target)
 {
-	memcpy(plt, bpf_plt, BPF_PLT_SIZE);
+	memcpy(plt, &bpf_plt, sizeof(*plt));
-	*(void **)((char *)plt + (bpf_plt_ret - bpf_plt)) = ret;
+	plt->ret = ret;
-	*(void **)((char *)plt + (bpf_plt_target - bpf_plt)) = target ?: ret;
+	plt->target = target;
 }
 /*
 	jit->prg = ALIGN(jit->prg, 8);
 	jit->prologue_plt = jit->prg;
 	if (jit->prg_buf)
-		bpf_jit_plt(jit->prg_buf + jit->prg,
+		bpf_jit_plt((struct bpf_plt *)(jit->prg_buf + jit->prg),
 			    jit->prg_buf + jit->prologue_plt_ret, NULL);
-	jit->prg += BPF_PLT_SIZE;
+	jit->prg += sizeof(struct bpf_plt);
 }
 static int get_probe_mem_regno(const u8 *insn)
 	struct bpf_jit jit;
 	int pass;
-	if (WARN_ON_ONCE(bpf_plt_end - bpf_plt != BPF_PLT_SIZE))
-		return orig_fp;
 	if (!fp->jit_requested)
 		return orig_fp;
 int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,
 		       void *old_addr, void *new_addr)
 {
+	struct bpf_plt expected_plt, current_plt, new_plt, *plt;
 	struct {
 		u16 opc;
 		s32 disp;
 	} __packed insn;
-	char expected_plt[BPF_PLT_SIZE];
-	char current_plt[BPF_PLT_SIZE];
-	char new_plt[BPF_PLT_SIZE];
-	char *plt;
 	char *ret;
 	int err;
 		 */
 	} else {
 		/* Verify the PLT. */
-		plt = (char *)ip + (insn.disp << 1);
+		plt = ip + (insn.disp << 1);
-		err = copy_from_kernel_nofault(current_plt, plt, BPF_PLT_SIZE);
+		err = copy_from_kernel_nofault(&current_plt, plt,
+					       sizeof(current_plt));
 		if (err < 0)
 			return err;
 		ret = (char *)ip + 6;
-		bpf_jit_plt(expected_plt, ret, old_addr);
+		bpf_jit_plt(&expected_plt, ret, old_addr);
-		if (memcmp(current_plt, expected_plt, BPF_PLT_SIZE))
+		if (memcmp(&current_plt, &expected_plt, sizeof(current_plt)))
 			return -EINVAL;
 		/* Adjust the call address. */
-		bpf_jit_plt(new_plt, ret, new_addr);
+		bpf_jit_plt(&new_plt, ret, new_addr);
-		s390_kernel_write(plt + (bpf_plt_target - bpf_plt),
+		s390_kernel_write(&plt->target, &new_plt.target,
-				  new_plt + (bpf_plt_target - bpf_plt),
 				  sizeof(void *));
 	}

arch/x86/Kbuild+1−1

@@ -28,7 +28,7 @@ obj-y += net/ · 27 unmodified lines
28		28
29	obj-$(CONFIG_KEXEC_FILE) += purgatory/	29	obj-$(CONFIG_KEXEC_FILE) += purgatory/
30		30
31	obj-y += virt/svm/	31	obj-y += virt/
32		32
33	# for cleaning	33	# for cleaning
34	subdir- += boot tools	34	subdir- += boot tools

arch/x86/Kconfig+2−0

@@ -2439,6 +2439,8 @@ config USE_X86_SEG_SUPPORT · 2438 unmodified lines
2439	# with named address spaces - see GCC PR sanitizer/111736.	2439	# with named address spaces - see GCC PR sanitizer/111736.
2440	#	2440	#
2441	depends on !KASAN	2441	depends on !KASAN
		2442	# -fsanitize=thread (KCSAN) is also incompatible.
		2443	depends on !KCSAN
2442		2444
2443	config CC_HAS_SLS	2445	config CC_HAS_SLS
2444	def_bool $(cc-option,-mharden-sls=all)	2446	def_bool $(cc-option,-mharden-sls=all)

arch/x86/Makefile+0−2

@@ -251,8 +251,6 @@ archheaders: · 250 unmodified lines
251		251
252	libs-y += arch/x86/lib/	252	libs-y += arch/x86/lib/
253		253
254	core-y += arch/x86/virt/
255
256	# drivers-y are linked after core-y	254	# drivers-y are linked after core-y
257	drivers-$(CONFIG_MATH_EMULATION) += arch/x86/math-emu/	255	drivers-$(CONFIG_MATH_EMULATION) += arch/x86/math-emu/
258	drivers-$(CONFIG_PCI) += arch/x86/pci/	256	drivers-$(CONFIG_PCI) += arch/x86/pci/

arch/x86/boot/compressed/efi_mixed.S+15−5

  */
 #include <linux/linkage.h>
+#include <asm/asm-offsets.h>
 #include <asm/msr.h>
 #include <asm/page_types.h>
 #include <asm/processor-flags.h>
 #include <asm/segment.h>
+#include <asm/setup.h>
 	.code64
 	.text
 SYM_FUNC_START(efi32_stub_entry)
 	call	1f
 1:	popl	%ecx
+	leal	(efi32_boot_args - 1b)(%ecx), %ebx
 	/* Clear BSS */
 	xorl	%eax, %eax
 	popl	%ecx
 	popl	%edx
 	popl	%esi
+	movl	%esi, 8(%ebx)
 	jmp	efi32_entry
 SYM_FUNC_END(efi32_stub_entry)
 #endif
  *
  * Arguments:	%ecx	image handle
  * 		%edx	EFI system table pointer
- *		%esi	struct bootparams pointer (or NULL when not using
- *			the EFI handover protocol)
  *
  * Since this is the point of no return for ordinary execution, no registers
  * are considered live except for the function parameters. [Note that the EFI
 	leal	(efi32_boot_args - 1b)(%ebx), %ebx
 	movl	%ecx, 0(%ebx)
 	movl	%edx, 4(%ebx)
-	movl	%esi, 8(%ebx)
 	movb	$0x0, 12(%ebx)          // efi_is64
+	/*
+	 * Allocate some memory for a temporary struct boot_params, which only
+	 * needs the minimal pieces that startup_32() relies on.
+	 */
+	subl	$PARAM_SIZE, %esp
+	movl	%esp, %esi
+	movl	$PAGE_SIZE, BP_kernel_alignment(%esi)
+	movl	$_end - 1b, BP_init_size(%esi)
+	subl	$startup_32 - 1b, BP_init_size(%esi)
 	/* Disable paging */
 	movl	%cr0, %eax
 	btrl	$X86_CR0_PG_BIT, %eax
 	movl	8(%ebp), %ecx			// image_handle
 	movl	12(%ebp), %edx			// sys_table
-	xorl	%esi, %esi
+	jmp	efi32_entry			// pass %ecx, %edx
-	jmp	efi32_entry			// pass %ecx, %edx, %esi
 						// no other registers remain live
 2:	popl	%edi				// restore callee-save registers

arch/x86/entry/vdso/Makefile+1−0

@@ -41,6 +41,7 @@ obj-$(CONFIG_X86_X32_ABI) += vdso-image-x32.o · 40 unmodified lines
41	obj-$(CONFIG_COMPAT_32) += vdso-image-32.o vdso32-setup.o	41	obj-$(CONFIG_COMPAT_32) += vdso-image-32.o vdso32-setup.o
42		42
43	OBJECT_FILES_NON_STANDARD_vdso-image-32.o := n	43	OBJECT_FILES_NON_STANDARD_vdso-image-32.o := n
		44	OBJECT_FILES_NON_STANDARD_vdso-image-x32.o := n
44	OBJECT_FILES_NON_STANDARD_vdso-image-64.o := n	45	OBJECT_FILES_NON_STANDARD_vdso-image-64.o := n
45	OBJECT_FILES_NON_STANDARD_vdso32-setup.o := n	46	OBJECT_FILES_NON_STANDARD_vdso32-setup.o := n
46		47

arch/x86/events/amd/core.c+34−5

@@ -250,7 +250,7 @@ static const u64 amd_perfmon_event_map[PERF_COUNT_HW_MAX] = · 249 unmodified lines
250	/*	250	/*
251	* AMD Performance Monitor Family 17h and later:	251	* AMD Performance Monitor Family 17h and later:
252	*/	252	*/
253	static const u64 amd_f17h_perfmon_event_map[PERF_COUNT_HW_MAX] =	253	static const u64 amd_zen1_perfmon_event_map[PERF_COUNT_HW_MAX] =
254	{	254	{
255	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,	255	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,
256	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,	256	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,
@@ -262,10 +262,39 @@ static const u64 amd_f17h_perfmon_event_map[PERF_COUNT_HW_MAX] = · 5 unmodified lines
262	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x0187,	262	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x0187,
263	};	263	};
264		264
		265	static const u64 amd_zen2_perfmon_event_map[PERF_COUNT_HW_MAX] =
		266	{
		267	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,
		268	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,
		269	[PERF_COUNT_HW_CACHE_REFERENCES] = 0xff60,
		270	[PERF_COUNT_HW_CACHE_MISSES] = 0x0964,
		271	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c2,
		272	[PERF_COUNT_HW_BRANCH_MISSES] = 0x00c3,
		273	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x00a9,
		274	};
		275
		276	static const u64 amd_zen4_perfmon_event_map[PERF_COUNT_HW_MAX] =
		277	{
		278	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,
		279	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,
		280	[PERF_COUNT_HW_CACHE_REFERENCES] = 0xff60,
		281	[PERF_COUNT_HW_CACHE_MISSES] = 0x0964,
		282	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c2,
		283	[PERF_COUNT_HW_BRANCH_MISSES] = 0x00c3,
		284	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x00a9,
		285	[PERF_COUNT_HW_REF_CPU_CYCLES] = 0x100000120,
		286	};
		287
265	static u64 amd_pmu_event_map(int hw_event)	288	static u64 amd_pmu_event_map(int hw_event)
266	{	289	{
267	if (boot_cpu_data.x86 >= 0x17)	290	if (cpu_feature_enabled(X86_FEATURE_ZEN4) \|\| boot_cpu_data.x86 >= 0x1a)
268	return amd_f17h_perfmon_event_map[hw_event];	291	return amd_zen4_perfmon_event_map[hw_event];
		292
		293	if (cpu_feature_enabled(X86_FEATURE_ZEN2) \|\| boot_cpu_data.x86 >= 0x19)
		294	return amd_zen2_perfmon_event_map[hw_event];
		295
		296	if (cpu_feature_enabled(X86_FEATURE_ZEN1))
		297	return amd_zen1_perfmon_event_map[hw_event];
269		298
270	return amd_perfmon_event_map[hw_event];	299	return amd_perfmon_event_map[hw_event];
271	}	300	}
@@ -904,8 +933,8 @@ static int amd_pmu_v2_handle_irq(struct pt_regs *regs) · 632 unmodified lines
904	if (!status)	933	if (!status)
905	goto done;	934	goto done;
906		935
907	/* Read branch records before unfreezing */	936	/* Read branch records */
908	if (status & GLOBAL_STATUS_LBRS_FROZEN) {	937	if (x86_pmu.lbr_nr) {
909	amd_pmu_lbr_read();	938	amd_pmu_lbr_read();
910	status &= ~GLOBAL_STATUS_LBRS_FROZEN;	939	status &= ~GLOBAL_STATUS_LBRS_FROZEN;
911	}	940	}

arch/x86/events/amd/lbr.c+10−6

@@ -402,10 +402,12 @@ void amd_pmu_lbr_enable_all(void) · 401 unmodified lines
402	wrmsrl(MSR_AMD64_LBR_SELECT, lbr_select);	402	wrmsrl(MSR_AMD64_LBR_SELECT, lbr_select);
403	}	403	}
404		404
405	rdmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl);	405	if (cpu_feature_enabled(X86_FEATURE_AMD_LBR_PMC_FREEZE)) {
406	rdmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg);	406	rdmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl);
		407	wrmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl \| DEBUGCTLMSR_FREEZE_LBRS_ON_PMI);
		408	}
407		409
408	wrmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl \| DEBUGCTLMSR_FREEZE_LBRS_ON_PMI);	410	rdmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg);
409	wrmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg \| DBG_EXTN_CFG_LBRV2EN);	411	wrmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg \| DBG_EXTN_CFG_LBRV2EN);
410	}	412	}
411		413
@@ -418,10 +420,12 @@ void amd_pmu_lbr_disable_all(void) · 6 unmodified lines
418	return;	420	return;
419		421
420	rdmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg);	422	rdmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg);
421	rdmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl);
422
423	wrmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg & ~DBG_EXTN_CFG_LBRV2EN);	423	wrmsrl(MSR_AMD_DBG_EXTN_CFG, dbg_extn_cfg & ~DBG_EXTN_CFG_LBRV2EN);
424	wrmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl & ~DEBUGCTLMSR_FREEZE_LBRS_ON_PMI);	424
		425	if (cpu_feature_enabled(X86_FEATURE_AMD_LBR_PMC_FREEZE)) {
		426	rdmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl);
		427	wrmsrl(MSR_IA32_DEBUGCTLMSR, dbg_ctl & ~DEBUGCTLMSR_FREEZE_LBRS_ON_PMI);
		428	}
425	}	429	}
426		430
427	__init int amd_pmu_lbr_init(void)	431	__init int amd_pmu_lbr_init(void)

arch/x86/include/asm/asm-prototypes.h+1−0

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	#include <asm/asm.h>	14	#include <asm/asm.h>
15	#include <asm/fred.h>	15	#include <asm/fred.h>
16	#include <asm/gsseg.h>	16	#include <asm/gsseg.h>
		17	#include <asm/nospec-branch.h>
17		18
18	#ifndef CONFIG_X86_CMPXCHG64	19	#ifndef CONFIG_X86_CMPXCHG64
19	extern void cmpxchg8b_emu(void);	20	extern void cmpxchg8b_emu(void);

arch/x86/include/asm/cpufeature.h+4−2

 	   CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 18, feature_bit) ||	\
 	   CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 19, feature_bit) ||	\
 	   CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 20, feature_bit) ||	\
+	   CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 21, feature_bit) ||	\
 	   REQUIRED_MASK_CHECK					  ||	\
-	   BUILD_BUG_ON_ZERO(NCAPINTS != 21))
+	   BUILD_BUG_ON_ZERO(NCAPINTS != 22))
 #define DISABLED_MASK_BIT_SET(feature_bit)				\
 	 ( CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  0, feature_bit) ||	\
 	   CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 18, feature_bit) ||	\
 	   CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 19, feature_bit) ||	\
 	   CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 20, feature_bit) ||	\
+	   CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 21, feature_bit) ||	\
 	   DISABLED_MASK_CHECK					  ||	\
-	   BUILD_BUG_ON_ZERO(NCAPINTS != 21))
+	   BUILD_BUG_ON_ZERO(NCAPINTS != 22))
 #define cpu_has(c, bit)							\
 	(__builtin_constant_p(bit) && REQUIRED_MASK_BIT_SET(bit) ? 1 :	\

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

 /*
  * Defines x86 CPU feature bits
  */
-#define NCAPINTS			21	   /* N 32-bit words worth of info */
+#define NCAPINTS			22	   /* N 32-bit words worth of info */
 #define NBUGINTS			2	   /* N 32-bit bug flags */
 /*
 #define X86_FEATURE_IBPB_BRTYPE		(20*32+28) /* "" MSR_PRED_CMD[IBPB] flushes all branch type predictions */
 #define X86_FEATURE_SRSO_NO		(20*32+29) /* "" CPU is not affected by SRSO */
+/*
+ * Extended auxiliary flags: Linux defined - for features scattered in various
+ * CPUID levels like 0x80000022, etc.
+ *
+ * Reuse free bits when adding new feature flags!
+ */
+#define X86_FEATURE_AMD_LBR_PMC_FREEZE	(21*32+ 0) /* AMD LBR and PMC Freeze */
 /*
  * BUG word(s)
  */

arch/x86/include/asm/crash_reserve.h+2−0

@@ -39,4 +39,6 @@ static inline unsigned long crash_low_size_default(void) · 38 unmodified lines
39	#endif	39	#endif
40	}	40	}
41		41
		42	#define HAVE_ARCH_ADD_CRASH_RES_TO_IOMEM_EARLY
		43
42	#endif /* _X86_CRASH_RESERVE_H */	44	#endif /* _X86_CRASH_RESERVE_H */

arch/x86/include/asm/disabled-features.h+2−1

@@ -155,6 +155,7 @@ · 154 unmodified lines
155	#define DISABLED_MASK18 (DISABLE_IBT)	155	#define DISABLED_MASK18 (DISABLE_IBT)
156	#define DISABLED_MASK19 (DISABLE_SEV_SNP)	156	#define DISABLED_MASK19 (DISABLE_SEV_SNP)
157	#define DISABLED_MASK20 0	157	#define DISABLED_MASK20 0
158	#define DISABLED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 21)	158	#define DISABLED_MASK21 0
		159	#define DISABLED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 22)
159		160
160	#endif /* _ASM_X86_DISABLED_FEATURES_H */	161	#endif /* _ASM_X86_DISABLED_FEATURES_H */

arch/x86/include/asm/nospec-branch.h+16−5

 .Lskip_rsb_\@:
 .endm
+/*
+ * The CALL to srso_alias_untrain_ret() must be patched in directly at
+ * the spot where untraining must be done, ie., srso_alias_untrain_ret()
+ * must be the target of a CALL instruction instead of indirectly
+ * jumping to a wrapper which then calls it. Therefore, this macro is
+ * called outside of __UNTRAIN_RET below, for the time being, before the
+ * kernel can support nested alternatives with arbitrary nesting.
+ */
+.macro CALL_UNTRAIN_RET
 #if defined(CONFIG_MITIGATION_UNRET_ENTRY) || defined(CONFIG_MITIGATION_SRSO)
-#define CALL_UNTRAIN_RET	"call entry_untrain_ret"
+	ALTERNATIVE_2 "", "call entry_untrain_ret", X86_FEATURE_UNRET, \
-#else
+		          "call srso_alias_untrain_ret", X86_FEATURE_SRSO_ALIAS
-#define CALL_UNTRAIN_RET	""
 #endif
+.endm
 /*
  * Mitigate RETBleed for AMD/Hygon Zen uarch. Requires KERNEL CR3 because the
 .macro __UNTRAIN_RET ibpb_feature, call_depth_insns
 #if defined(CONFIG_MITIGATION_RETHUNK) || defined(CONFIG_MITIGATION_IBPB_ENTRY)
 	VALIDATE_UNRET_END
-	ALTERNATIVE_3 "",						\
+	CALL_UNTRAIN_RET
-		      CALL_UNTRAIN_RET, X86_FEATURE_UNRET,		\
+	ALTERNATIVE_2 "",						\
 		      "call entry_ibpb", \ibpb_feature,			\
 		     __stringify(\call_depth_insns), X86_FEATURE_CALL_DEPTH
 #endif
 static inline void retbleed_return_thunk(void) {}
 #endif
+extern void srso_alias_untrain_ret(void);
 #ifdef CONFIG_MITIGATION_SRSO
 extern void srso_return_thunk(void);
 extern void srso_alias_return_thunk(void);

arch/x86/include/asm/required-features.h+2−1

@@ -99,6 +99,7 @@ · 98 unmodified lines
99	#define REQUIRED_MASK18 0	99	#define REQUIRED_MASK18 0
100	#define REQUIRED_MASK19 0	100	#define REQUIRED_MASK19 0
101	#define REQUIRED_MASK20 0	101	#define REQUIRED_MASK20 0
102	#define REQUIRED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 21)	102	#define REQUIRED_MASK21 0
		103	#define REQUIRED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 22)
103		104
104	#endif /* _ASM_X86_REQUIRED_FEATURES_H */	105	#endif /* _ASM_X86_REQUIRED_FEATURES_H */

arch/x86/include/asm/sev.h+2−2

 				  unsigned long npages);
 void early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr,
 				 unsigned long npages);
-void __init snp_prep_memory(unsigned long paddr, unsigned int sz, enum psc_op op);
 void snp_set_memory_shared(unsigned long vaddr, unsigned long npages);
 void snp_set_memory_private(unsigned long vaddr, unsigned long npages);
 void snp_set_wakeup_secondary_cpu(void);
 bool snp_init(struct boot_params *bp);
 void __noreturn snp_abort(void);
+void snp_dmi_setup(void);
 int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio);
 void snp_accept_memory(phys_addr_t start, phys_addr_t end);
 u64 snp_get_unsupported_features(u64 status);
 early_snp_set_memory_private(unsigned long vaddr, unsigned long paddr, unsigned long npages) { }
 static inline void __init
 early_snp_set_memory_shared(unsigned long vaddr, unsigned long paddr, unsigned long npages) { }
-static inline void __init snp_prep_memory(unsigned long paddr, unsigned int sz, enum psc_op op) { }
 static inline void snp_set_memory_shared(unsigned long vaddr, unsigned long npages) { }
 static inline void snp_set_memory_private(unsigned long vaddr, unsigned long npages) { }
 static inline void snp_set_wakeup_secondary_cpu(void) { }
 static inline bool snp_init(struct boot_params *bp) { return false; }
 static inline void snp_abort(void) { }
+static inline void snp_dmi_setup(void) { }
 static inline int snp_issue_guest_request(u64 exit_code, struct snp_req_data *input, struct snp_guest_request_ioctl *rio)
 {
 	return -ENOTTY;

arch/x86/include/asm/x86_init.h+2−1

  * @reserve_resources:		reserve the standard resources for the
  *				platform
  * @memory_setup:		platform specific memory setup
- *
+ * @dmi_setup:			platform specific DMI setup
  */
 struct x86_init_resources {
 	void (*probe_roms)(void);
 	void (*reserve_resources)(void);
 	char *(*memory_setup)(void);
+	void (*dmi_setup)(void);
 };
 /**

arch/x86/kernel/cpu/scattered.c+1−0

@@ -49,6 +49,7 @@ static const struct cpuid_bit cpuid_bits[] = { · 48 unmodified lines
49	{ X86_FEATURE_BMEC, CPUID_EBX, 3, 0x80000020, 0 },	49	{ X86_FEATURE_BMEC, CPUID_EBX, 3, 0x80000020, 0 },
50	{ X86_FEATURE_PERFMON_V2, CPUID_EAX, 0, 0x80000022, 0 },	50	{ X86_FEATURE_PERFMON_V2, CPUID_EAX, 0, 0x80000022, 0 },
51	{ X86_FEATURE_AMD_LBR_V2, CPUID_EAX, 1, 0x80000022, 0 },	51	{ X86_FEATURE_AMD_LBR_V2, CPUID_EAX, 1, 0x80000022, 0 },
		52	{ X86_FEATURE_AMD_LBR_PMC_FREEZE, CPUID_EAX, 2, 0x80000022, 0 },
52	{ 0, 0, 0, 0, 0 }	53	{ 0, 0, 0, 0, 0 }
53	};	54	};
54		55

arch/x86/kernel/eisa.c+2−1

 /*
  * EISA specific code
  */
+#include <linux/cc_platform.h>
 #include <linux/ioport.h>
 #include <linux/eisa.h>
 #include <linux/io.h>
 {
 	void __iomem *p;
-	if (xen_pv_domain() && !xen_initial_domain())
+	if ((xen_pv_domain() && !xen_initial_domain()) || cc_platform_has(CC_ATTR_GUEST_SEV_SNP))
 		return 0;
 	p = ioremap(0x0FFFD9, 4);

arch/x86/kernel/nmi.c+14−10

 static char *nmi_check_stall_msg[] = {
 /*									*/
-/* +--------- nsp->idt_seq_snap & 0x1: CPU is in NMI handler.		*/
+/* +--------- nmi_seq & 0x1: CPU is currently in NMI handler.		*/
 /* | +------ cpu_is_offline(cpu)					*/
 /* | | +--- nsp->idt_calls_snap != atomic_long_read(&nsp->idt_calls):	*/
 /* | | |	NMI handler has been invoked.				*/
 		nmi_seq = READ_ONCE(nsp->idt_nmi_seq);
 		if (nsp->idt_nmi_seq_snap + 1 == nmi_seq && (nmi_seq & 0x1)) {
 			msgp = "CPU entered NMI handler function, but has not exited";
-		} else if ((nsp->idt_nmi_seq_snap & 0x1) != (nmi_seq & 0x1)) {
+		} else if (nsp->idt_nmi_seq_snap == nmi_seq ||
-			msgp = "CPU is handling NMIs";
+			   nsp->idt_nmi_seq_snap + 1 == nmi_seq) {
-		} else {
+			idx = ((nmi_seq & 0x1) << 2) |
-			idx = ((nsp->idt_seq_snap & 0x1) << 2) |
 			      (cpu_is_offline(cpu) << 1) |
 			      (nsp->idt_calls_snap != atomic_long_read(&nsp->idt_calls));
 			msgp = nmi_check_stall_msg[idx];
 			if (nsp->idt_ignored_snap != READ_ONCE(nsp->idt_ignored) && (idx & 0x1))
 				modp = ", but OK because ignore_nmis was set";
-			if (nmi_seq & 0x1)
+			if (nsp->idt_nmi_seq_snap + 1 == nmi_seq)
-				msghp = " (CPU currently in NMI handler function)";
-			else if (nsp->idt_nmi_seq_snap + 1 == nmi_seq)
 				msghp = " (CPU exited one NMI handler function)";
+			else if (nmi_seq & 0x1)
+				msghp = " (CPU currently in NMI handler function)";
+			else
+				msghp = " (CPU was never in an NMI handler function)";
+		} else {
+			msgp = "CPU is handling NMIs";
 		}
-		pr_alert("%s: CPU %d: %s%s%s, last activity: %lu jiffies ago.\n",
+		pr_alert("%s: CPU %d: %s%s%s\n", __func__, cpu, msgp, modp, msghp);
-			 __func__, cpu, msgp, modp, msghp, j - READ_ONCE(nsp->recv_jiffies));
+		pr_alert("%s: last activity: %lu jiffies ago.\n",
+			 __func__, j - READ_ONCE(nsp->recv_jiffies));
 	}
 }

arch/x86/kernel/probe_roms.c+0−10

@@ -203,16 +203,6 @@ void __init probe_roms(void) · 202 unmodified lines
203	unsigned char c;	203	unsigned char c;
204	int i;	204	int i;
205		205
206	/*
207	* The ROM memory range is not part of the e820 table and is therefore not
208	* pre-validated by BIOS. The kernel page table maps the ROM region as encrypted
209	* memory, and SNP requires encrypted memory to be validated before access.
210	* Do that here.
211	*/
212	snp_prep_memory(video_rom_resource.start,
213	((system_rom_resource.end + 1) - video_rom_resource.start),
214	SNP_PAGE_STATE_PRIVATE);
215
216	/* video rom */	206	/* video rom */
217	upper = adapter_rom_resources[0].start;	207	upper = adapter_rom_resources[0].start;
218	for (start = video_rom_resource.start; start < upper; start += 2048) {	208	for (start = video_rom_resource.start; start < upper; start += 2048) {

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

 #include <linux/console.h>
 #include <linux/crash_dump.h>
 #include <linux/dma-map-ops.h>
-#include <linux/dmi.h>
 #include <linux/efi.h>
 #include <linux/ima.h>
 #include <linux/init_ohci1394_dma.h>
 		efi_init();
 	reserve_ibft_region();
-	dmi_setup();
+	x86_init.resources.dmi_setup();
 	/*
 	 * VMware detection requires dmi to be available, so this

arch/x86/kernel/sev.c+12−15

 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/psp-sev.h>
+#include <linux/dmi.h>
 #include <uapi/linux/sev-guest.h>
 #include <asm/init.h>
 	early_set_pages_state(vaddr, paddr, npages, SNP_PAGE_STATE_SHARED);
 }
-void __init snp_prep_memory(unsigned long paddr, unsigned int sz, enum psc_op op)
-{
-	unsigned long vaddr, npages;
-	vaddr = (unsigned long)__va(paddr);
-	npages = PAGE_ALIGN(sz) >> PAGE_SHIFT;
-	if (op == SNP_PAGE_STATE_PRIVATE)
-		early_snp_set_memory_private(vaddr, paddr, npages);
-	else if (op == SNP_PAGE_STATE_SHARED)
-		early_snp_set_memory_shared(vaddr, paddr, npages);
-	else
-		WARN(1, "invalid memory op %d\n", op);
-}
 static unsigned long __set_pages_state(struct snp_psc_desc *data, unsigned long vaddr,
 				       unsigned long vaddr_end, int op)
 {
 	sev_es_terminate(SEV_TERM_SET_GEN, GHCB_SNP_UNSUPPORTED);
 }
+/*
+ * SEV-SNP guests should only execute dmi_setup() if EFI_CONFIG_TABLES are
+ * enabled, as the alternative (fallback) logic for DMI probing in the legacy
+ * ROM region can cause a crash since this region is not pre-validated.
+ */
+void __init snp_dmi_setup(void)
+{
+	if (efi_enabled(EFI_CONFIG_TABLES))
+		dmi_setup();
+}
 static void dump_cpuid_table(void)
 {
 	const struct snp_cpuid_table *cpuid_table = snp_cpuid_get_table();

arch/x86/kernel/x86_init.c+2−0

  *
  *  For licencing details see kernel-base/COPYING
  */
+#include <linux/dmi.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/export.h>
 		.probe_roms		= probe_roms,
 		.reserve_resources	= reserve_standard_io_resources,
 		.memory_setup		= e820__memory_setup_default,
+		.dmi_setup		= dmi_setup,
 	},
 	.mpparse = {

arch/x86/lib/retpoline.S+6−5

 	lfence
 	jmp srso_alias_return_thunk
 SYM_FUNC_END(srso_alias_untrain_ret)
+__EXPORT_THUNK(srso_alias_untrain_ret)
 	.popsection
 	.pushsection .text..__x86.rethunk_safe
 SYM_CODE_END(srso_return_thunk)
 #define JMP_SRSO_UNTRAIN_RET "jmp srso_untrain_ret"
-#define JMP_SRSO_ALIAS_UNTRAIN_RET "jmp srso_alias_untrain_ret"
 #else /* !CONFIG_MITIGATION_SRSO */
+/* Dummy for the alternative in CALL_UNTRAIN_RET. */
+SYM_CODE_START(srso_alias_untrain_ret)
+	RET
+SYM_FUNC_END(srso_alias_untrain_ret)
 #define JMP_SRSO_UNTRAIN_RET "ud2"
-#define JMP_SRSO_ALIAS_UNTRAIN_RET "ud2"
 #endif /* CONFIG_MITIGATION_SRSO */
 #ifdef CONFIG_MITIGATION_UNRET_ENTRY
 #if defined(CONFIG_MITIGATION_UNRET_ENTRY) || defined(CONFIG_MITIGATION_SRSO)
 SYM_FUNC_START(entry_untrain_ret)
-	ALTERNATIVE_2 JMP_RETBLEED_UNTRAIN_RET,				\
+	ALTERNATIVE JMP_RETBLEED_UNTRAIN_RET, JMP_SRSO_UNTRAIN_RET, X86_FEATURE_SRSO
-		      JMP_SRSO_UNTRAIN_RET, X86_FEATURE_SRSO,		\
-		      JMP_SRSO_ALIAS_UNTRAIN_RET, X86_FEATURE_SRSO_ALIAS
 SYM_FUNC_END(entry_untrain_ret)
 __EXPORT_THUNK(entry_untrain_ret)

arch/x86/mm/ident_map.c+5−18

 	for (; addr < end; addr = next) {
 		pud_t *pud = pud_page + pud_index(addr);
 		pmd_t *pmd;
-		bool use_gbpage;
 		next = (addr & PUD_MASK) + PUD_SIZE;
 		if (next > end)
 			next = end;
-		/* if this is already a gbpage, this portion is already mapped */
+		if (info->direct_gbpages) {
-		if (pud_leaf(*pud))
-			continue;
-		/* Is using a gbpage allowed? */
-		use_gbpage = info->direct_gbpages;
-		/* Don't use gbpage if it maps more than the requested region. */
-		/* at the begining: */
-		use_gbpage &= ((addr & ~PUD_MASK) == 0);
-		/* ... or at the end: */
-		use_gbpage &= ((next & ~PUD_MASK) == 0);
-		/* Never overwrite existing mappings */
-		use_gbpage &= !pud_present(*pud);
-		if (use_gbpage) {
 			pud_t pudval;
+			if (pud_present(*pud))
+				continue;
+			addr &= PUD_MASK;
 			pudval = __pud((addr - info->offset) | info->page_flag);
 			set_pud(pud, pudval);
 			continue;

arch/x86/mm/mem_encrypt_amd.c+18−0

@@ -492,6 +492,24 @@ void __init sme_early_init(void) · 491 unmodified lines
492	*/	492	*/
493	if (sev_status & MSR_AMD64_SEV_ENABLED)	493	if (sev_status & MSR_AMD64_SEV_ENABLED)
494	ia32_disable();	494	ia32_disable();
		495
		496	/*
		497	* Override init functions that scan the ROM region in SEV-SNP guests,
		498	* as this memory is not pre-validated and would thus cause a crash.
		499	*/
		500	if (sev_status & MSR_AMD64_SEV_SNP_ENABLED) {
		501	x86_init.mpparse.find_mptable = x86_init_noop;
		502	x86_init.pci.init_irq = x86_init_noop;
		503	x86_init.resources.probe_roms = x86_init_noop;
		504
		505	/*
		506	* DMI setup behavior for SEV-SNP guests depends on
		507	* efi_enabled(EFI_CONFIG_TABLES), which hasn't been
		508	* parsed yet. snp_dmi_setup() will run after that
		509	* parsing has happened.
		510	*/
		511	x86_init.resources.dmi_setup = snp_dmi_setup;
		512	}
495	}	513	}
496		514
497	void __init mem_encrypt_free_decrypted_mem(void)	515	void __init mem_encrypt_free_decrypted_mem(void)

arch/x86/virt/Makefile+1−1

@@ -1,2 +1,2 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	obj-y += vmx/	2	obj-y += svm/ vmx/

block/blk-merge.c+1−1

@@ -726,7 +726,7 @@ static int ll_merge_requests_fn(struct request_queue q, struct request req, · 725 unmodified lines
726	* which can be mixed are set in each bio and mark @rq as mixed	726	* which can be mixed are set in each bio and mark @rq as mixed
727	* merged.	727	* merged.
728	*/	728	*/
729	void blk_rq_set_mixed_merge(struct request *rq)	729	static void blk_rq_set_mixed_merge(struct request *rq)
730	{	730	{
731	blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;	731	blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;
732	struct bio *bio;	732	struct bio *bio;

block/blk-mq.c+2−7

 		/*
 		 * Partial zone append completions cannot be supported as the
 		 * BIO fragments may end up not being written sequentially.
-		 * For such case, force the completed nbytes to be equal to
-		 * the BIO size so that bio_advance() sets the BIO remaining
-		 * size to 0 and we end up calling bio_endio() before returning.
 		 */
-		if (bio->bi_iter.bi_size != nbytes) {
+		if (bio->bi_iter.bi_size != nbytes)
 			bio->bi_status = BLK_STS_IOERR;
-			nbytes = bio->bi_iter.bi_size;
+		else
-		} else {
 			bio->bi_iter.bi_sector = rq->__sector;
-		}
 	}
 	bio_advance(bio, nbytes);

block/blk-settings.c+1−2

 	max_hw_sectors = min_not_zero(lim->max_hw_sectors,
 				lim->max_dev_sectors);
 	if (lim->max_user_sectors) {
-		if (lim->max_user_sectors > max_hw_sectors ||
+		if (lim->max_user_sectors < PAGE_SIZE / SECTOR_SIZE)
-		    lim->max_user_sectors < PAGE_SIZE / SECTOR_SIZE)
 			return -EINVAL;
 		lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors);
 	} else {

block/blk.h+0−1

@@ -339,7 +339,6 @@ int ll_back_merge_fn(struct request req, struct bio bio, · 338 unmodified lines
339	bool blk_attempt_req_merge(struct request_queue q, struct request rq,	339	bool blk_attempt_req_merge(struct request_queue q, struct request rq,
340	struct request *next);	340	struct request *next);
341	unsigned int blk_recalc_rq_segments(struct request *rq);	341	unsigned int blk_recalc_rq_segments(struct request *rq);
342	void blk_rq_set_mixed_merge(struct request *rq);
343	bool blk_rq_merge_ok(struct request rq, struct bio bio);	342	bool blk_rq_merge_ok(struct request rq, struct bio bio);
344	enum elv_merge blk_try_merge(struct request rq, struct bio bio);	343	enum elv_merge blk_try_merge(struct request rq, struct bio bio);
345		344

crypto/asymmetric_keys/mscode_parser.c+3−0

 	oid = look_up_OID(value, vlen);
 	switch (oid) {
+	case OID_sha1:
+		ctx->digest_algo = "sha1";
+		break;
 	case OID_sha256:
 		ctx->digest_algo = "sha256";
 		break;

crypto/asymmetric_keys/pkcs7_parser.c+4−0

 	struct pkcs7_parse_context *ctx = context;
 	switch (ctx->last_oid) {
+	case OID_sha1:
+		ctx->sinfo->sig->hash_algo = "sha1";
+		break;
 	case OID_sha256:
 		ctx->sinfo->sig->hash_algo = "sha256";
 		break;
 		ctx->sinfo->sig->pkey_algo = "rsa";
 		ctx->sinfo->sig->encoding = "pkcs1";
 		break;
+	case OID_id_ecdsa_with_sha1:
 	case OID_id_ecdsa_with_sha224:
 	case OID_id_ecdsa_with_sha256:
 	case OID_id_ecdsa_with_sha384:

crypto/asymmetric_keys/public_key.c+2−1

 		 */
 		if (!hash_algo)
 			return -EINVAL;
-		if (strcmp(hash_algo, "sha224") != 0 &&
+		if (strcmp(hash_algo, "sha1") != 0 &&
+		    strcmp(hash_algo, "sha224") != 0 &&
 		    strcmp(hash_algo, "sha256") != 0 &&
 		    strcmp(hash_algo, "sha384") != 0 &&
 		    strcmp(hash_algo, "sha512") != 0 &&

crypto/asymmetric_keys/signature.c+1−1

@@ -115,7 +115,7 @@ EXPORT_SYMBOL_GPL(decrypt_blob); · 114 unmodified lines
115	* Sign the specified data blob using the private key specified by params->key.	115	* Sign the specified data blob using the private key specified by params->key.
116	* The signature is wrapped in an encoding if params->encoding is specified	116	* The signature is wrapped in an encoding if params->encoding is specified
117	* (eg. "pkcs1"). If the encoding needs to know the digest type, this can be	117	* (eg. "pkcs1"). If the encoding needs to know the digest type, this can be
118	* passed through params->hash_algo (eg. "sha512").	118	* passed through params->hash_algo (eg. "sha1").
119	*	119	*
120	* Returns the length of the data placed in the signature buffer or an error.	120	* Returns the length of the data placed in the signature buffer or an error.
121	*/	121	*/

crypto/asymmetric_keys/x509_cert_parser.c+8−0

 	default:
 		return -ENOPKG; /* Unsupported combination */
+	case OID_sha1WithRSAEncryption:
+		ctx->cert->sig->hash_algo = "sha1";
+		goto rsa_pkcs1;
 	case OID_sha256WithRSAEncryption:
 		ctx->cert->sig->hash_algo = "sha256";
 		goto rsa_pkcs1;
 		ctx->cert->sig->hash_algo = "sha224";
 		goto rsa_pkcs1;
+	case OID_id_ecdsa_with_sha1:
+		ctx->cert->sig->hash_algo = "sha1";
+		goto ecdsa;
 	case OID_id_rsassa_pkcs1_v1_5_with_sha3_256:
 		ctx->cert->sig->hash_algo = "sha3-256";
 		goto rsa_pkcs1;

crypto/testmgr.h+80−0

@@ -653,6 +653,30 @@ static const struct akcipher_testvec rsa_tv_template[] = { · 652 unmodified lines
653	static const struct akcipher_testvec ecdsa_nist_p192_tv_template[] = {	653	static const struct akcipher_testvec ecdsa_nist_p192_tv_template[] = {
654	{	654	{
655	.key =	655	.key =
		656	"\x04\xf7\x46\xf8\x2f\x15\xf6\x22\x8e\xd7\x57\x4f\xcc\xe7\xbb\xc1"
		657	"\xd4\x09\x73\xcf\xea\xd0\x15\x07\x3d\xa5\x8a\x8a\x95\x43\xe4\x68"
		658	"\xea\xc6\x25\xc1\xc1\x01\x25\x4c\x7e\xc3\x3c\xa6\x04\x0a\xe7\x08"
		659	"\x98",
		660	.key_len = 49,
		661	.params =
		662	"\x30\x13\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x08\x2a\x86\x48"
		663	"\xce\x3d\x03\x01\x01",
		664	.param_len = 21,
		665	.m =
		666	"\xcd\xb9\xd2\x1c\xb7\x6f\xcd\x44\xb3\xfd\x63\xea\xa3\x66\x7f\xae"
		667	"\x63\x85\xe7\x82",
		668	.m_size = 20,
		669	.algo = OID_id_ecdsa_with_sha1,
		670	.c =
		671	"\x30\x35\x02\x19\x00\xba\xe5\x93\x83\x6e\xb6\x3b\x63\xa0\x27\x91"
		672	"\xc6\xf6\x7f\xc3\x09\xad\x59\xad\x88\x27\xd6\x92\x6b\x02\x18\x10"
		673	"\x68\x01\x9d\xba\xce\x83\x08\xef\x95\x52\x7b\xa0\x0f\xe4\x18\x86"
		674	"\x80\x6f\xa5\x79\x77\xda\xd0",
		675	.c_size = 55,
		676	.public_key_vec = true,
		677	.siggen_sigver_test = true,
		678	}, {
		679	.key =
656	"\x04\xb6\x4b\xb1\xd1\xac\xba\x24\x8f\x65\xb2\x60\x00\x90\xbf\xbd"	680	"\x04\xb6\x4b\xb1\xd1\xac\xba\x24\x8f\x65\xb2\x60\x00\x90\xbf\xbd"
657	"\x78\x05\x73\xe9\x79\x1d\x6f\x7c\x0b\xd2\xc3\x93\xa7\x28\xe1\x75"	681	"\x78\x05\x73\xe9\x79\x1d\x6f\x7c\x0b\xd2\xc3\x93\xa7\x28\xe1\x75"
658	"\xf7\xd5\x95\x1d\x28\x10\xc0\x75\x50\x5c\x1a\x4f\x3f\x8f\xa5\xee"	682	"\xf7\xd5\x95\x1d\x28\x10\xc0\x75\x50\x5c\x1a\x4f\x3f\x8f\xa5\xee"
@@ -756,6 +780,32 @@ static const struct akcipher_testvec ecdsa_nist_p192_tv_template[] = { · 97 unmodified lines
756	static const struct akcipher_testvec ecdsa_nist_p256_tv_template[] = {	780	static const struct akcipher_testvec ecdsa_nist_p256_tv_template[] = {
757	{	781	{
758	.key =	782	.key =
		783	"\x04\xb9\x7b\xbb\xd7\x17\x64\xd2\x7e\xfc\x81\x5d\x87\x06\x83\x41"
		784	"\x22\xd6\x9a\xaa\x87\x17\xec\x4f\x63\x55\x2f\x94\xba\xdd\x83\xe9"
		785	"\x34\x4b\xf3\xe9\x91\x13\x50\xb6\xcb\xca\x62\x08\xe7\x3b\x09\xdc"
		786	"\xc3\x63\x4b\x2d\xb9\x73\x53\xe4\x45\xe6\x7c\xad\xe7\x6b\xb0\xe8"
		787	"\xaf",
		788	.key_len = 65,
		789	.params =
		790	"\x30\x13\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x08\x2a\x86\x48"
		791	"\xce\x3d\x03\x01\x07",
		792	.param_len = 21,
		793	.m =
		794	"\xc2\x2b\x5f\x91\x78\x34\x26\x09\x42\x8d\x6f\x51\xb2\xc5\xaf\x4c"
		795	"\x0b\xde\x6a\x42",
		796	.m_size = 20,
		797	.algo = OID_id_ecdsa_with_sha1,
		798	.c =
		799	"\x30\x46\x02\x21\x00\xf9\x25\xce\x9f\x3a\xa6\x35\x81\xcf\xd4\xe7"
		800	"\xb7\xf0\x82\x56\x41\xf7\xd4\xad\x8d\x94\x5a\x69\x89\xee\xca\x6a"
		801	"\x52\x0e\x48\x4d\xcc\x02\x21\x00\xd7\xe4\xef\x52\x66\xd3\x5b\x9d"
		802	"\x8a\xfa\x54\x93\x29\xa7\x70\x86\xf1\x03\x03\xf3\x3b\xe2\x73\xf7"
		803	"\xfb\x9d\x8b\xde\xd4\x8d\x6f\xad",
		804	.c_size = 72,
		805	.public_key_vec = true,
		806	.siggen_sigver_test = true,
		807	}, {
		808	.key =
759	"\x04\x8b\x6d\xc0\x33\x8e\x2d\x8b\x67\xf5\xeb\xc4\x7f\xa0\xf5\xd9"	809	"\x04\x8b\x6d\xc0\x33\x8e\x2d\x8b\x67\xf5\xeb\xc4\x7f\xa0\xf5\xd9"
760	"\x7b\x03\xa5\x78\x9a\xb5\xea\x14\xe4\x23\xd0\xaf\xd7\x0e\x2e\xa0"	810	"\x7b\x03\xa5\x78\x9a\xb5\xea\x14\xe4\x23\xd0\xaf\xd7\x0e\x2e\xa0"
761	"\xc9\x8b\xdb\x95\xf8\xb3\xaf\xac\x00\x2c\x2c\x1f\x7a\xfd\x95\x88"	811	"\xc9\x8b\xdb\x95\xf8\xb3\xaf\xac\x00\x2c\x2c\x1f\x7a\xfd\x95\x88"
@@ -866,6 +916,36 @@ static const struct akcipher_testvec ecdsa_nist_p256_tv_template[] = { · 104 unmodified lines
866		916
867	static const struct akcipher_testvec ecdsa_nist_p384_tv_template[] = {	917	static const struct akcipher_testvec ecdsa_nist_p384_tv_template[] = {
868	{	918	{
		919	.key = /* secp384r1(sha1) */
		920	"\x04\x89\x25\xf3\x97\x88\xcb\xb0\x78\xc5\x72\x9a\x14\x6e\x7a\xb1"
		921	"\x5a\xa5\x24\xf1\x95\x06\x9e\x28\xfb\xc4\xb9\xbe\x5a\x0d\xd9\x9f"
		922	"\xf3\xd1\x4d\x2d\x07\x99\xbd\xda\xa7\x66\xec\xbb\xea\xba\x79\x42"
		923	"\xc9\x34\x89\x6a\xe7\x0b\xc3\xf2\xfe\x32\x30\xbe\xba\xf9\xdf\x7e"
		924	"\x4b\x6a\x07\x8e\x26\x66\x3f\x1d\xec\xa2\x57\x91\x51\xdd\x17\x0e"
		925	"\x0b\x25\xd6\x80\x5c\x3b\xe6\x1a\x98\x48\x91\x45\x7a\x73\xb0\xc3"
		926	"\xf1",
		927	.key_len = 97,
		928	.params =
		929	"\x30\x10\x06\x07\x2a\x86\x48\xce\x3d\x02\x01\x06\x05\x2b\x81\x04"
		930	"\x00\x22",
		931	.param_len = 18,
		932	.m =
		933	"\x12\x55\x28\xf0\x77\xd5\xb6\x21\x71\x32\x48\xcd\x28\xa8\x25\x22"
		934	"\x3a\x69\xc1\x93",
		935	.m_size = 20,
		936	.algo = OID_id_ecdsa_with_sha1,
		937	.c =
		938	"\x30\x66\x02\x31\x00\xf5\x0f\x24\x4c\x07\x93\x6f\x21\x57\x55\x07"
		939	"\x20\x43\x30\xde\xa0\x8d\x26\x8e\xae\x63\x3f\xbc\x20\x3a\xc6\xf1"
		940	"\x32\x3c\xce\x70\x2b\x78\xf1\x4c\x26\xe6\x5b\x86\xcf\xec\x7c\x7e"
		941	"\xd0\x87\xd7\xd7\x6e\x02\x31\x00\xcd\xbb\x7e\x81\x5d\x8f\x63\xc0"
		942	"\x5f\x63\xb1\xbe\x5e\x4c\x0e\xa1\xdf\x28\x8c\x1b\xfa\xf9\x95\x88"
		943	"\x74\xa0\x0f\xbf\xaf\xc3\x36\x76\x4a\xa1\x59\xf1\x1c\xa4\x58\x26"
		944	"\x79\x12\x2a\xb7\xc5\x15\x92\xc5",
		945	.c_size = 104,
		946	.public_key_vec = true,
		947	.siggen_sigver_test = true,
		948	}, {
869	.key = /* secp384r1(sha224) */	949	.key = /* secp384r1(sha224) */
870	"\x04\x69\x6c\xcf\x62\xee\xd0\x0d\xe5\xb5\x2f\x70\x54\xcf\x26\xa0"	950	"\x04\x69\x6c\xcf\x62\xee\xd0\x0d\xe5\xb5\x2f\x70\x54\xcf\x26\xa0"
871	"\xd9\x98\x8d\x92\x2a\xab\x9b\x11\xcb\x48\x18\xa1\xa9\x0d\xd5\x18"	951	"\xd9\x98\x8d\x92\x2a\xab\x9b\x11\xcb\x48\x18\xa1\xa9\x0d\xd5\x18"

drivers/acpi/acpica/dbnames.c+6−2

@@ -550,8 +550,12 @@ acpi_db_walk_for_fields(acpi_handle obj_handle, · 549 unmodified lines
550	ACPI_FREE(buffer.pointer);	550	ACPI_FREE(buffer.pointer);
551		551
552	buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;	552	buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
553	acpi_evaluate_object(obj_handle, NULL, NULL, &buffer);	553	status = acpi_evaluate_object(obj_handle, NULL, NULL, &buffer);
554		554	if (ACPI_FAILURE(status)) {
		555	acpi_os_printf("Could Not evaluate object %p\n",
		556	obj_handle);
		557	return (AE_OK);
		558	}
555	/*	559	/*
556	* Since this is a field unit, surround the output in braces	560	* Since this is a field unit, surround the output in braces
557	*/	561	*/

drivers/acpi/apei/einj-core.c+1−1

@@ -851,7 +851,7 @@ err_put_table: · 850 unmodified lines
851	return rc;	851	return rc;
852	}	852	}
853		853
854	static void __exit einj_remove(struct platform_device *pdev)	854	static void einj_remove(struct platform_device *pdev)
855	{	855	{
856	struct apei_exec_context ctx;	856	struct apei_exec_context ctx;
857		857

drivers/ata/libata-eh.c+4−1

 				ehc->saved_ncq_enabled |= 1 << devno;
 			/* If we are resuming, wake up the device */
-			if (ap->pflags & ATA_PFLAG_RESUMING)
+			if (ap->pflags & ATA_PFLAG_RESUMING) {
+				dev->flags |= ATA_DFLAG_RESUMING;
 				ehc->i.dev_action[devno] |= ATA_EH_SET_ACTIVE;
+			}
 		}
 	}
 	return 0;
  err:
+	dev->flags &= ~ATA_DFLAG_RESUMING;
 	*r_failed_dev = dev;
 	return rc;
 }

drivers/ata/libata-scsi.c+9−0

 	struct ata_link *link;
 	struct ata_device *dev;
 	unsigned long flags;
+	bool do_resume;
 	int ret = 0;
 	mutex_lock(&ap->scsi_scan_mutex);
 			if (scsi_device_get(sdev))
 				continue;
+			do_resume = dev->flags & ATA_DFLAG_RESUMING;
 			spin_unlock_irqrestore(ap->lock, flags);
+			if (do_resume) {
+				ret = scsi_resume_device(sdev);
+				if (ret == -EWOULDBLOCK)
+					goto unlock;
+				dev->flags &= ~ATA_DFLAG_RESUMING;
+			}
 			ret = scsi_rescan_device(sdev);
 			scsi_device_put(sdev);
 			spin_lock_irqsave(ap->lock, flags);

drivers/crypto/intel/iaa/iaa_crypto_main.c+7−3

 		return -EINVAL;
 	cpus_per_iaa = (nr_nodes * nr_cpus_per_node) / nr_iaa;
+	if (!cpus_per_iaa)
+		cpus_per_iaa = 1;
 out:
 	return 0;
 }
 		}
 	}
-	if (nr_iaa)
+	if (nr_iaa) {
 		cpus_per_iaa = (nr_nodes * nr_cpus_per_node) / nr_iaa;
-	else
+		if (!cpus_per_iaa)
-		cpus_per_iaa = 0;
+			cpus_per_iaa = 1;
+	} else
+		cpus_per_iaa = 1;
 }
 static int wq_table_add_wqs(int iaa, int cpu)

drivers/cxl/Kconfig+0−13

@@ -144,17 +144,4 @@ config CXL_REGION_INVALIDATION_TEST · 143 unmodified lines
144	If unsure, or if this kernel is meant for production environments,	144	If unsure, or if this kernel is meant for production environments,
145	say N.	145	say N.
146		146
147	config CXL_PMU
148	tristate "CXL Performance Monitoring Unit"
149	default CXL_BUS
150	depends on PERF_EVENTS
151	help
152	Support performance monitoring as defined in CXL rev 3.0
153	section 13.2: Performance Monitoring. CXL components may have
154	one or more CXL Performance Monitoring Units (CPMUs).
155
156	Say 'y/m' to enable a driver that will attach to performance
157	monitoring units and provide standard perf based interfaces.
158
159	If unsure say 'm'.
160	endif	147	endif

drivers/dma-buf/st-dma-fence-chain.c+3−3

 		return -ENOMEM;
 	chain = mock_chain(NULL, f, 1);
-	if (!chain)
+	if (chain)
+		dma_fence_enable_sw_signaling(chain);
+	else
 		err = -ENOMEM;
-	dma_fence_enable_sw_signaling(chain);
 	dma_fence_signal(f);
 	dma_fence_put(f);

drivers/dpll/Kconfig+1−1

@@ -4,4 +4,4 @@ · 3 unmodified lines
4	#	4	#
5		5
6	config DPLL	6	config DPLL
7	bool	7	bool

drivers/firmware/efi/libstub/randomalloc.c+1−1

@@ -120,7 +120,7 @@ efi_status_t efi_random_alloc(unsigned long size, · 119 unmodified lines
120	continue;	120	continue;
121	}	121	}
122		122
123	target = round_up(max(md->phys_addr, alloc_min), align) + target_slot * align;	123	target = round_up(max_t(u64, md->phys_addr, alloc_min), align) + target_slot * align;
124	pages = size / EFI_PAGE_SIZE;	124	pages = size / EFI_PAGE_SIZE;
125		125
126	status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS,	126	status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS,

drivers/firmware/efi/libstub/x86-stub.c+1−0

@@ -496,6 +496,7 @@ efi_status_t __efiapi efi_pe_entry(efi_handle_t handle, · 495 unmodified lines
496	hdr->vid_mode = 0xffff;	496	hdr->vid_mode = 0xffff;
497		497
498	hdr->type_of_loader = 0x21;	498	hdr->type_of_loader = 0x21;
		499	hdr->initrd_addr_max = INT_MAX;
499		500
500	/* Convert unicode cmdline to ascii */	501	/* Convert unicode cmdline to ascii */
501	cmdline_ptr = efi_convert_cmdline(image, &options_size);	502	cmdline_ptr = efi_convert_cmdline(image, &options_size);

drivers/gpio/gpiolib-cdev.c+32−6

 	return 0;
 }
+static inline char *make_irq_label(const char *orig)
+{
+	return kstrdup_and_replace(orig, '/', ':', GFP_KERNEL);
+}
+static inline void free_irq_label(const char *label)
+{
+	kfree(label);
+}
 static void edge_detector_stop(struct line *line)
 {
 	if (line->irq) {
-		free_irq(line->irq, line);
+		free_irq_label(free_irq(line->irq, line));
 		line->irq = 0;
 	}
 	unsigned long irqflags = 0;
 	u64 eflags;
 	int irq, ret;
+	char *label;
 	eflags = edflags & GPIO_V2_LINE_EDGE_FLAGS;
 	if (eflags && !kfifo_initialized(&line->req->events)) {
 			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 	irqflags |= IRQF_ONESHOT;
+	label = make_irq_label(line->req->label);
+	if (!label)
+		return -ENOMEM;
 	/* Request a thread to read the events */
 	ret = request_threaded_irq(irq, edge_irq_handler, edge_irq_thread,
-				   irqflags, line->req->label, line);
+				   irqflags, label, line);
-	if (ret)
+	if (ret) {
+		free_irq_label(label);
 		return ret;
+	}
 	line->irq = irq;
 	return 0;
 		blocking_notifier_chain_unregister(&le->gdev->device_notifier,
 						   &le->device_unregistered_nb);
 	if (le->irq)
-		free_irq(le->irq, le);
+		free_irq_label(free_irq(le->irq, le));
 	if (le->desc)
 		gpiod_free(le->desc);
 	kfree(le->label);
 	int fd;
 	int ret;
 	int irq, irqflags = 0;
+	char *label;
 	if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
 		return -EFAULT;
 	if (ret)
 		goto out_free_le;
+	label = make_irq_label(le->label);
+	if (!label) {
+		ret = -ENOMEM;
+		goto out_free_le;
+	}
 	/* Request a thread to read the events */
 	ret = request_threaded_irq(irq,
 				   lineevent_irq_handler,
 				   lineevent_irq_thread,
 				   irqflags,
-				   le->label,
+				   label,
 				   le);
-	if (ret)
+	if (ret) {
+		free_irq_label(label);
 		goto out_free_le;
+	}
 	le->irq = irq;

drivers/gpio/gpiolib.c+18−14

 }
 EXPORT_SYMBOL_GPL(gpiochip_dup_line_label);
+static inline const char *function_name_or_default(const char *con_id)
+{
+	return con_id ?: "(default)";
+}
 /**
  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
  * @gc: GPIO chip
 					    enum gpiod_flags dflags)
 {
 	struct gpio_desc *desc = gpiochip_get_desc(gc, hwnum);
+	const char *name = function_name_or_default(label);
 	int ret;
 	if (IS_ERR(desc)) {
-		chip_err(gc, "failed to get GPIO descriptor\n");
+		chip_err(gc, "failed to get GPIO %s descriptor\n", name);
 		return desc;
 	}
 	ret = gpiod_configure_flags(desc, label, lflags, dflags);
 	if (ret) {
-		chip_err(gc, "setup of own GPIO %s failed\n", label);
 		gpiod_free_commit(desc);
+		chip_err(gc, "setup of own GPIO %s failed\n", name);
 		return ERR_PTR(ret);
 	}
 					      enum gpiod_flags *flags,
 					      unsigned long *lookupflags)
 {
+	const char *name = function_name_or_default(con_id);
 	struct gpio_desc *desc = ERR_PTR(-ENOENT);
 	if (is_of_node(fwnode)) {
-		dev_dbg(consumer, "using DT '%pfw' for '%s' GPIO lookup\n",
+		dev_dbg(consumer, "using DT '%pfw' for '%s' GPIO lookup\n", fwnode, name);
-			fwnode, con_id);
 		desc = of_find_gpio(to_of_node(fwnode), con_id, idx, lookupflags);
 	} else if (is_acpi_node(fwnode)) {
-		dev_dbg(consumer, "using ACPI '%pfw' for '%s' GPIO lookup\n",
+		dev_dbg(consumer, "using ACPI '%pfw' for '%s' GPIO lookup\n", fwnode, name);
-			fwnode, con_id);
 		desc = acpi_find_gpio(fwnode, con_id, idx, flags, lookupflags);
 	} else if (is_software_node(fwnode)) {
-		dev_dbg(consumer, "using swnode '%pfw' for '%s' GPIO lookup\n",
+		dev_dbg(consumer, "using swnode '%pfw' for '%s' GPIO lookup\n", fwnode, name);
-			fwnode, con_id);
 		desc = swnode_find_gpio(fwnode, con_id, idx, lookupflags);
 	}
 					 bool platform_lookup_allowed)
 {
 	unsigned long lookupflags = GPIO_LOOKUP_FLAGS_DEFAULT;
+	const char *name = function_name_or_default(con_id);
 	/*
 	 * scoped_guard() is implemented as a for loop, meaning static
 	 * analyzers will complain about these two not being initialized.
 		}
 		if (IS_ERR(desc)) {
-			dev_dbg(consumer, "No GPIO consumer %s found\n",
+			dev_dbg(consumer, "No GPIO consumer %s found\n", name);
-				con_id);
 			return desc;
 		}
 		 *
 		 * FIXME: Make this more sane and safe.
 		 */
-		dev_info(consumer,
+		dev_info(consumer, "nonexclusive access to GPIO for %s\n", name);
-			 "nonexclusive access to GPIO for %s\n", con_id);
 		return desc;
 	}
 	ret = gpiod_configure_flags(desc, con_id, lookupflags, flags);
 	if (ret < 0) {
-		dev_dbg(consumer, "setup of GPIO %s failed\n", con_id);
 		gpiod_put(desc);
+		dev_dbg(consumer, "setup of GPIO %s failed\n", name);
 		return ERR_PTR(ret);
 	}
 int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
 		unsigned long lflags, enum gpiod_flags dflags)
 {
+	const char *name = function_name_or_default(con_id);
 	int ret;
 	if (lflags & GPIO_ACTIVE_LOW)
 	/* No particular flag request, return here... */
 	if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
-		gpiod_dbg(desc, "no flags found for %s\n", con_id);
+		gpiod_dbg(desc, "no flags found for GPIO %s\n", name);
 		return 0;
 	}

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

@@ -4539,6 +4539,8 @@ int amdgpu_device_prepare(struct drm_device *dev) · 4538 unmodified lines
4539	if (r)	4539	if (r)
4540	goto unprepare;	4540	goto unprepare;
4541		4541
		4542	flush_delayed_work(&adev->gfx.gfx_off_delay_work);
		4543
4542	for (i = 0; i < adev->num_ip_blocks; i++) {	4544	for (i = 0; i < adev->num_ip_blocks; i++) {
4543	if (!adev->ip_blocks[i].status.valid)	4545	if (!adev->ip_blocks[i].status.valid)
4544	continue;	4546	continue;

drivers/gpu/drm/amd/amdgpu/amdgpu_discovery.c+1−0

@@ -2237,6 +2237,7 @@ static int amdgpu_discovery_set_umsch_mm_ip_blocks(struct amdgpu_device *adev) · 2236 unmodified lines
2237	{	2237	{
2238	switch (amdgpu_ip_version(adev, VCN_HWIP, 0)) {	2238	switch (amdgpu_ip_version(adev, VCN_HWIP, 0)) {
2239	case IP_VERSION(4, 0, 5):	2239	case IP_VERSION(4, 0, 5):
		2240	case IP_VERSION(4, 0, 6):
2240	if (amdgpu_umsch_mm & 0x1) {	2241	if (amdgpu_umsch_mm & 0x1) {
2241	amdgpu_device_ip_block_add(adev, &umsch_mm_v4_0_ip_block);	2242	amdgpu_device_ip_block_add(adev, &umsch_mm_v4_0_ip_block);
2242	adev->enable_umsch_mm = true;	2243	adev->enable_umsch_mm = true;

drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c+29−17

 {
 	struct amdgpu_ring *ring = file_inode(f)->i_private;
 	volatile u32 *mqd;
-	int r;
+	u32 *kbuf;
+	int r, i;
 	uint32_t value, result;
 	if (*pos & 3 || size & 3)
 		return -EINVAL;
-	result = 0;
+	kbuf = kmalloc(ring->mqd_size, GFP_KERNEL);
+	if (!kbuf)
+		return -ENOMEM;
 	r = amdgpu_bo_reserve(ring->mqd_obj, false);
 	if (unlikely(r != 0))
-		return r;
+		goto err_free;
 	r = amdgpu_bo_kmap(ring->mqd_obj, (void **)&mqd);
-	if (r) {
+	if (r)
-		amdgpu_bo_unreserve(ring->mqd_obj);
+		goto err_unreserve;
-		return r;
-	}
+	/*
+	 * Copy to local buffer to avoid put_user(), which might fault
+	 * and acquire mmap_sem, under reservation_ww_class_mutex.
+	 */
+	for (i = 0; i < ring->mqd_size/sizeof(u32); i++)
+		kbuf[i] = mqd[i];
+	amdgpu_bo_kunmap(ring->mqd_obj);
+	amdgpu_bo_unreserve(ring->mqd_obj);
+	result = 0;
 	while (size) {
 		if (*pos >= ring->mqd_size)
-			goto done;
+			break;
-		value = mqd[*pos/4];
+		value = kbuf[*pos/4];
 		r = put_user(value, (uint32_t *)buf);
 		if (r)
-			goto done;
+			goto err_free;
 		buf += 4;
 		result += 4;
 		size -= 4;
 		*pos += 4;
 	}
-done:
+	kfree(kbuf);
-	amdgpu_bo_kunmap(ring->mqd_obj);
-	mqd = NULL;
-	amdgpu_bo_unreserve(ring->mqd_obj);
-	if (r)
-		return r;
 	return result;
+err_unreserve:
+	amdgpu_bo_unreserve(ring->mqd_obj);
+err_free:
+	kfree(kbuf);
+	return r;
 }
 static const struct file_operations amdgpu_debugfs_mqd_fops = {

drivers/gpu/drm/amd/amdgpu/amdgpu_umsch_mm.c+10−2

 	mqd->rptr_val = 0;
 	mqd->unmapped = 1;
+	if (adev->vpe.collaborate_mode)
+		memcpy(++mqd, test->mqd_data_cpu_addr, sizeof(struct MQD_INFO));
 	qinfo->mqd_addr = test->mqd_data_gpu_addr;
 	qinfo->csa_addr = test->ctx_data_gpu_addr +
 		offsetof(struct umsch_mm_test_ctx_data, vpe_ctx_csa);
-	qinfo->doorbell_offset_0 = (adev->doorbell_index.vpe_ring + 1) << 1;
+	qinfo->doorbell_offset_0 = 0;
 	qinfo->doorbell_offset_1 = 0;
 }
 	ring[5] = 0;
 	mqd->wptr_val = (6 << 2);
-	// WDOORBELL32(adev->umsch_mm.agdb_index[CONTEXT_PRIORITY_LEVEL_NORMAL], mqd->wptr_val);
+	if (adev->vpe.collaborate_mode)
+		(++mqd)->wptr_val = (6 << 2);
+	WDOORBELL32(adev->umsch_mm.agdb_index[CONTEXT_PRIORITY_LEVEL_NORMAL], mqd->wptr_val);
 	for (i = 0; i < adev->usec_timeout; i++) {
 		if (*fence == test_pattern)
 	switch (amdgpu_ip_version(adev, VCN_HWIP, 0)) {
 	case IP_VERSION(4, 0, 5):
+	case IP_VERSION(4, 0, 6):
 		fw_name = "amdgpu/umsch_mm_4_0_0.bin";
 		break;
 	default:
 	switch (amdgpu_ip_version(adev, VCN_HWIP, 0)) {
 	case IP_VERSION(4, 0, 5):
+	case IP_VERSION(4, 0, 6):
 		umsch_mm_v4_0_set_funcs(&adev->umsch_mm);
 		break;
 	default:

drivers/gpu/drm/amd/amdgpu/amdgpu_umsch_mm.h+10−10

 	UMSCH_SWIP_ENGINE_TYPE_MAX
 };
-enum UMSCH_SWIP_AFFINITY_TYPE {
-	UMSCH_SWIP_AFFINITY_TYPE_ANY = 0,
-	UMSCH_SWIP_AFFINITY_TYPE_VCN0 = 1,
-	UMSCH_SWIP_AFFINITY_TYPE_VCN1 = 2,
-	UMSCH_SWIP_AFFINITY_TYPE_MAX
-};
 enum UMSCH_CONTEXT_PRIORITY_LEVEL {
 	CONTEXT_PRIORITY_LEVEL_IDLE = 0,
 	CONTEXT_PRIORITY_LEVEL_NORMAL = 1,
 struct umsch_mm_set_resource_input {
 	uint32_t vmid_mask_mm_vcn;
 	uint32_t vmid_mask_mm_vpe;
+	uint32_t collaboration_mask_vpe;
 	uint32_t logging_vmid;
 	uint32_t engine_mask;
 	union {
 		struct {
 			uint32_t disable_reset : 1;
 			uint32_t disable_umsch_mm_log : 1;
-			uint32_t reserved : 30;
+			uint32_t use_rs64mem_for_proc_ctx_csa : 1;
+			uint32_t reserved : 29;
 		};
 		uint32_t uint32_all;
 	};
 	uint32_t doorbell_offset_1;
 	enum UMSCH_SWIP_ENGINE_TYPE engine_type;
 	uint32_t affinity;
-	enum UMSCH_SWIP_AFFINITY_TYPE affinity_type;
 	uint64_t mqd_addr;
 	uint64_t h_context;
 	uint64_t h_queue;
 	uint32_t vm_context_cntl;
+	uint32_t process_csa_array_index;
+	uint32_t context_csa_array_index;
 	struct {
 		uint32_t is_context_suspended : 1;
-		uint32_t reserved : 31;
+		uint32_t collaboration_mode : 1;
+		uint32_t reserved : 30;
 	};
 };
 	uint32_t doorbell_offset_0;
 	uint32_t doorbell_offset_1;
 	uint64_t context_csa_addr;
+	uint32_t context_csa_array_index;
 };
 struct MQD_INFO {
 	uint32_t wptr_val;
 	uint32_t rptr_val;
 	uint32_t unmapped;
+	uint32_t vmid;
 };
 struct amdgpu_umsch_mm;

drivers/gpu/drm/amd/amdgpu/amdgpu_vpe.c+6−0

 	struct amdgpu_vpe *vpe = &adev->vpe;
 	int ret;
+	/* Power on VPE */
+	ret = amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_VPE,
+						     AMD_PG_STATE_UNGATE);
+	if (ret)
+		return ret;
 	ret = vpe_load_microcode(vpe);
 	if (ret)
 		return ret;

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

 	umsch->cmd_buf_curr_ptr = umsch->cmd_buf_ptr;
-	if (amdgpu_ip_version(adev, VCN_HWIP, 0) == IP_VERSION(4, 0, 5)) {
+	if (amdgpu_ip_version(adev, VCN_HWIP, 0) >= IP_VERSION(4, 0, 5)) {
 		WREG32_SOC15(VCN, 0, regUVD_IPX_DLDO_CONFIG,
 			1 << UVD_IPX_DLDO_CONFIG__ONO0_PWR_CONFIG__SHIFT);
 		SOC15_WAIT_ON_RREG(VCN, 0, regUVD_IPX_DLDO_STATUS,
 	data = REG_SET_FIELD(data, VCN_UMSCH_RB_DB_CTRL, EN, 0);
 	WREG32_SOC15(VCN, 0, regVCN_UMSCH_RB_DB_CTRL, data);
-	if (amdgpu_ip_version(adev, VCN_HWIP, 0) == IP_VERSION(4, 0, 5)) {
+	if (amdgpu_ip_version(adev, VCN_HWIP, 0) >= IP_VERSION(4, 0, 5)) {
 		WREG32_SOC15(VCN, 0, regUVD_IPX_DLDO_CONFIG,
 			2 << UVD_IPX_DLDO_CONFIG__ONO0_PWR_CONFIG__SHIFT);
 		SOC15_WAIT_ON_RREG(VCN, 0, regUVD_IPX_DLDO_STATUS,
 	set_hw_resources.vmid_mask_mm_vcn = umsch->vmid_mask_mm_vcn;
 	set_hw_resources.vmid_mask_mm_vpe = umsch->vmid_mask_mm_vpe;
+	set_hw_resources.collaboration_mask_vpe =
+		adev->vpe.collaborate_mode ? 0x3 : 0x0;
 	set_hw_resources.engine_mask = umsch->engine_mask;
 	set_hw_resources.vcn0_hqd_mask[0] = umsch->vcn0_hqd_mask;
 	add_queue.h_queue = input_ptr->h_queue;
 	add_queue.vm_context_cntl = input_ptr->vm_context_cntl;
 	add_queue.is_context_suspended = input_ptr->is_context_suspended;
+	add_queue.collaboration_mode = adev->vpe.collaborate_mode ? 1 : 0;
 	add_queue.api_status.api_completion_fence_addr = umsch->ring.fence_drv.gpu_addr;
 	add_queue.api_status.api_completion_fence_value = ++umsch->ring.fence_drv.sync_seq;

drivers/gpu/drm/amd/amdkfd/kfd_chardev.c+2−2

@@ -1523,7 +1523,7 @@ static int kfd_ioctl_get_dmabuf_info(struct file *filep, · 1522 unmodified lines
1523		1523
1524	/* Find a KFD GPU device that supports the get_dmabuf_info query */	1524	/* Find a KFD GPU device that supports the get_dmabuf_info query */
1525	for (i = 0; kfd_topology_enum_kfd_devices(i, &dev) == 0; i++)	1525	for (i = 0; kfd_topology_enum_kfd_devices(i, &dev) == 0; i++)
1526	if (dev)	1526	if (dev && !kfd_devcgroup_check_permission(dev))
1527	break;	1527	break;
1528	if (!dev)	1528	if (!dev)
1529	return -EINVAL;	1529	return -EINVAL;
@@ -1545,7 +1545,7 @@ static int kfd_ioctl_get_dmabuf_info(struct file *filep, · 15 unmodified lines
1545	if (xcp_id >= 0)	1545	if (xcp_id >= 0)
1546	args->gpu_id = dmabuf_adev->kfd.dev->nodes[xcp_id]->id;	1546	args->gpu_id = dmabuf_adev->kfd.dev->nodes[xcp_id]->id;
1547	else	1547	else
1548	args->gpu_id = dmabuf_adev->kfd.dev->nodes[0]->id;	1548	args->gpu_id = dev->id;
1549	args->flags = flags;	1549	args->flags = flags;
1550		1550
1551	/* Copy metadata buffer to user mode */	1551	/* Copy metadata buffer to user mode */

drivers/gpu/drm/amd/amdkfd/kfd_int_process_v10.c+2−1

 				break;
 			}
 			kfd_signal_event_interrupt(pasid, context_id0 & 0x7fffff, 23);
-		} else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE) {
+		} else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE &&
+			   KFD_DBG_EC_TYPE_IS_PACKET(KFD_DEBUG_CP_BAD_OP_ECODE(context_id0))) {
 			kfd_set_dbg_ev_from_interrupt(dev, pasid,
 				KFD_DEBUG_DOORBELL_ID(context_id0),
 				KFD_EC_MASK(KFD_DEBUG_CP_BAD_OP_ECODE(context_id0)),

drivers/gpu/drm/amd/amdkfd/kfd_int_process_v11.c+2−1

 		/* CP */
 		if (source_id == SOC15_INTSRC_CP_END_OF_PIPE)
 			kfd_signal_event_interrupt(pasid, context_id0, 32);
-		else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE)
+		else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE &&
+			 KFD_DBG_EC_TYPE_IS_PACKET(KFD_CTXID0_CP_BAD_OP_ECODE(context_id0)))
 			kfd_set_dbg_ev_from_interrupt(dev, pasid,
 				KFD_CTXID0_DOORBELL_ID(context_id0),
 				KFD_EC_MASK(KFD_CTXID0_CP_BAD_OP_ECODE(context_id0)),

drivers/gpu/drm/amd/amdkfd/kfd_int_process_v9.c+2−1

 				break;
 			}
 			kfd_signal_event_interrupt(pasid, sq_int_data, 24);
-		} else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE) {
+		} else if (source_id == SOC15_INTSRC_CP_BAD_OPCODE &&
+			   KFD_DBG_EC_TYPE_IS_PACKET(KFD_DEBUG_CP_BAD_OP_ECODE(context_id0))) {
 			kfd_set_dbg_ev_from_interrupt(dev, pasid,
 				KFD_DEBUG_DOORBELL_ID(context_id0),
 				KFD_EC_MASK(KFD_DEBUG_CP_BAD_OP_ECODE(context_id0)),

drivers/gpu/drm/amd/amdkfd/kfd_priv.h+1−1

@@ -1473,7 +1473,7 @@ static inline void kfd_flush_tlb(struct kfd_process_device *pdd, · 1472 unmodified lines
1473		1473
1474	static inline bool kfd_flush_tlb_after_unmap(struct kfd_dev *dev)	1474	static inline bool kfd_flush_tlb_after_unmap(struct kfd_dev *dev)
1475	{	1475	{
1476	return KFD_GC_VERSION(dev) > IP_VERSION(9, 4, 2) \|\|	1476	return KFD_GC_VERSION(dev) >= IP_VERSION(9, 4, 2) \|\|
1477	(KFD_GC_VERSION(dev) == IP_VERSION(9, 4, 1) && dev->sdma_fw_version >= 18) \|\|	1477	(KFD_GC_VERSION(dev) == IP_VERSION(9, 4, 1) && dev->sdma_fw_version >= 18) \|\|
1478	KFD_GC_VERSION(dev) == IP_VERSION(9, 4, 0);	1478	KFD_GC_VERSION(dev) == IP_VERSION(9, 4, 0);
1479	}	1479	}

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

@@ -6305,9 +6305,8 @@ create_stream_for_sink(struct drm_connector *connector, · 6304 unmodified lines
6305		6305
6306	if (stream->signal == SIGNAL_TYPE_HDMI_TYPE_A)	6306	if (stream->signal == SIGNAL_TYPE_HDMI_TYPE_A)
6307	mod_build_hf_vsif_infopacket(stream, &stream->vsp_infopacket);	6307	mod_build_hf_vsif_infopacket(stream, &stream->vsp_infopacket);
6308	else if (stream->signal == SIGNAL_TYPE_DISPLAY_PORT \|\|	6308
6309	stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST \|\|	6309	if (stream->link->psr_settings.psr_feature_enabled \|\| stream->link->replay_settings.replay_feature_enabled) {
6310	stream->signal == SIGNAL_TYPE_EDP) {
6311	//	6310	//
6312	// should decide stream support vsc sdp colorimetry capability	6311	// should decide stream support vsc sdp colorimetry capability
6313	// before building vsc info packet	6312	// before building vsc info packet
@@ -6323,9 +6322,8 @@ create_stream_for_sink(struct drm_connector *connector, · 9 unmodified lines
6323	if (stream->out_transfer_func->tf == TRANSFER_FUNCTION_GAMMA22)	6322	if (stream->out_transfer_func->tf == TRANSFER_FUNCTION_GAMMA22)
6324	tf = TRANSFER_FUNC_GAMMA_22;	6323	tf = TRANSFER_FUNC_GAMMA_22;
6325	mod_build_vsc_infopacket(stream, &stream->vsc_infopacket, stream->output_color_space, tf);	6324	mod_build_vsc_infopacket(stream, &stream->vsc_infopacket, stream->output_color_space, tf);
		6325	aconnector->psr_skip_count = AMDGPU_DM_PSR_ENTRY_DELAY;
6326		6326
6327	if (stream->link->psr_settings.psr_feature_enabled)
6328	aconnector->psr_skip_count = AMDGPU_DM_PSR_ENTRY_DELAY;
6329	}	6327	}
6330	finish:	6328	finish:
6331	dc_sink_release(sink);	6329	dc_sink_release(sink);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_psr.c+5−3

  * amdgpu_dm_psr_enable() - enable psr f/w
  * @stream: stream state
  *
- * Return: true if success
  */
-bool amdgpu_dm_psr_enable(struct dc_stream_state *stream)
+void amdgpu_dm_psr_enable(struct dc_stream_state *stream)
 {
 	struct dc_link *link = stream->link;
 	unsigned int vsync_rate_hz = 0;
 	if (link->psr_settings.psr_version < DC_PSR_VERSION_SU_1)
 		power_opt |= psr_power_opt_z10_static_screen;
-	return dc_link_set_psr_allow_active(link, &psr_enable, false, false, &power_opt);
+	dc_link_set_psr_allow_active(link, &psr_enable, false, false, &power_opt);
+	if (link->ctx->dc->caps.ips_support)
+		dc_allow_idle_optimizations(link->ctx->dc, true);
 }
 /*

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_psr.h+1−1

@@ -32,7 +32,7 @@ · 31 unmodified lines
32	#define AMDGPU_DM_PSR_ENTRY_DELAY 5	32	#define AMDGPU_DM_PSR_ENTRY_DELAY 5
33		33
34	void amdgpu_dm_set_psr_caps(struct dc_link *link);	34	void amdgpu_dm_set_psr_caps(struct dc_link *link);
35	bool amdgpu_dm_psr_enable(struct dc_stream_state *stream);	35	void amdgpu_dm_psr_enable(struct dc_stream_state *stream);
36	bool amdgpu_dm_link_setup_psr(struct dc_stream_state *stream);	36	bool amdgpu_dm_link_setup_psr(struct dc_stream_state *stream);
37	bool amdgpu_dm_psr_disable(struct dc_stream_state *stream);	37	bool amdgpu_dm_psr_disable(struct dc_stream_state *stream);
38	bool amdgpu_dm_psr_disable_all(struct amdgpu_display_manager *dm);	38	bool amdgpu_dm_psr_disable_all(struct amdgpu_display_manager *dm);

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn35/dcn35_clk_mgr.c+6−1

 #define CLK1_CLK2_BYPASS_CNTL__CLK2_BYPASS_SEL_MASK		0x00000007L
 #define CLK1_CLK2_BYPASS_CNTL__CLK2_BYPASS_DIV_MASK		0x000F0000L
+#define SMU_VER_THRESHOLD 0x5D4A00 //93.74.0
 #define REG(reg_name) \
 	(ctx->clk_reg_offsets[reg ## reg_name ## _BASE_IDX] + reg ## reg_name)
 static void init_clk_states(struct clk_mgr *clk_mgr)
 {
+	struct clk_mgr_internal *clk_mgr_int = TO_CLK_MGR_INTERNAL(clk_mgr);
 	uint32_t ref_dtbclk = clk_mgr->clks.ref_dtbclk_khz;
 	memset(&(clk_mgr->clks), 0, sizeof(struct dc_clocks));
+	if (clk_mgr_int->smu_ver >= SMU_VER_THRESHOLD)
+		clk_mgr->clks.dtbclk_en = true; // request DTBCLK disable on first commit
 	clk_mgr->clks.ref_dtbclk_khz = ref_dtbclk;	// restore ref_dtbclk
 	clk_mgr->clks.p_state_change_support = true;
 	clk_mgr->clks.prev_p_state_change_support = true;
 		clock_table->NumFclkLevelsEnabled;
 	max_fclk = find_max_clk_value(clock_table->FclkClocks_Freq, num_fclk);
-	num_dcfclk = (clock_table->NumFclkLevelsEnabled > NUM_DCFCLK_DPM_LEVELS) ? NUM_DCFCLK_DPM_LEVELS :
+	num_dcfclk = (clock_table->NumDcfClkLevelsEnabled > NUM_DCFCLK_DPM_LEVELS) ? NUM_DCFCLK_DPM_LEVELS :
 		clock_table->NumDcfClkLevelsEnabled;
 	for (i = 0; i < num_dcfclk; i++) {
 		int j;

drivers/gpu/drm/amd/display/dc/core/dc.c+4−2

 		scratch->blend_tf[i] = *status->plane_states[i]->blend_tf;
 	}
 	scratch->stream_state = *stream;
-	scratch->out_transfer_func = *stream->out_transfer_func;
+	if (stream->out_transfer_func)
+		scratch->out_transfer_func = *stream->out_transfer_func;
 }
 static void restore_planes_and_stream_state(
 		*status->plane_states[i]->blend_tf = scratch->blend_tf[i];
 	}
 	*stream = scratch->stream_state;
-	*stream->out_transfer_func = scratch->out_transfer_func;
+	if (stream->out_transfer_func)
+		*stream->out_transfer_func = scratch->out_transfer_func;
 }
 static bool update_planes_and_stream_state(struct dc *dc,

drivers/gpu/drm/amd/display/dc/dce110/Makefile+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	# Makefile for the 'controller' sub-component of DAL.	23	# Makefile for the 'controller' sub-component of DAL.
24	# It provides the control and status of HW CRTC block.	24	# It provides the control and status of HW CRTC block.
25		25
26	CFLAGS_$(AMDDALPATH)/dc/dce110/dce110_resource.o = $(call cc-disable-warning, override-init)	26	CFLAGS_$(AMDDALPATH)/dc/dce110/dce110_resource.o = -Wno-override-init
27		27
28	DCE110 = dce110_timing_generator.o \	28	DCE110 = dce110_timing_generator.o \
29	dce110_compressor.o dce110_opp_regamma_v.o \	29	dce110_compressor.o dce110_opp_regamma_v.o \

drivers/gpu/drm/amd/display/dc/dce112/Makefile+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	# Makefile for the 'controller' sub-component of DAL.	23	# Makefile for the 'controller' sub-component of DAL.
24	# It provides the control and status of HW CRTC block.	24	# It provides the control and status of HW CRTC block.
25		25
26	CFLAGS_$(AMDDALPATH)/dc/dce112/dce112_resource.o = $(call cc-disable-warning, override-init)	26	CFLAGS_$(AMDDALPATH)/dc/dce112/dce112_resource.o = -Wno-override-init
27		27
28	DCE112 = dce112_compressor.o	28	DCE112 = dce112_compressor.o
29		29

drivers/gpu/drm/amd/display/dc/dce120/Makefile+1−1

@@ -24,7 +24,7 @@ · 23 unmodified lines
24	# It provides the control and status of HW CRTC block.	24	# It provides the control and status of HW CRTC block.
25		25
26		26
27	CFLAGS_$(AMDDALPATH)/dc/dce120/dce120_resource.o = $(call cc-disable-warning, override-init)	27	CFLAGS_$(AMDDALPATH)/dc/dce120/dce120_resource.o = -Wno-override-init
28		28
29	DCE120 = dce120_timing_generator.o	29	DCE120 = dce120_timing_generator.o
30		30

drivers/gpu/drm/amd/display/dc/dce60/Makefile+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	# Makefile for the 'controller' sub-component of DAL.	23	# Makefile for the 'controller' sub-component of DAL.
24	# It provides the control and status of HW CRTC block.	24	# It provides the control and status of HW CRTC block.
25		25
26	CFLAGS_$(AMDDALPATH)/dc/dce60/dce60_resource.o = $(call cc-disable-warning, override-init)	26	CFLAGS_$(AMDDALPATH)/dc/dce60/dce60_resource.o = -Wno-override-init
27		27
28	DCE60 = dce60_timing_generator.o dce60_hw_sequencer.o \	28	DCE60 = dce60_timing_generator.o dce60_hw_sequencer.o \
29	dce60_resource.o	29	dce60_resource.o

drivers/gpu/drm/amd/display/dc/dce80/Makefile+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	# Makefile for the 'controller' sub-component of DAL.	23	# Makefile for the 'controller' sub-component of DAL.
24	# It provides the control and status of HW CRTC block.	24	# It provides the control and status of HW CRTC block.
25		25
26	CFLAGS_$(AMDDALPATH)/dc/dce80/dce80_resource.o = $(call cc-disable-warning, override-init)	26	CFLAGS_$(AMDDALPATH)/dc/dce80/dce80_resource.o = -Wno-override-init
27		27
28	DCE80 = dce80_timing_generator.o	28	DCE80 = dce80_timing_generator.o
29		29

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_mpc.c+32−22

 #define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0]))
+void mpc3_mpc_init(struct mpc *mpc)
+{
+	struct dcn30_mpc *mpc30 = TO_DCN30_MPC(mpc);
+	int opp_id;
+	mpc1_mpc_init(mpc);
+	for (opp_id = 0; opp_id < MAX_OPP; opp_id++) {
+		if (REG(MUX[opp_id]))
+			/* disable mpc out rate and flow control */
+			REG_UPDATE_2(MUX[opp_id], MPC_OUT_RATE_CONTROL_DISABLE,
+					1, MPC_OUT_FLOW_CONTROL_COUNT, 0);
+	}
+}
+void mpc3_mpc_init_single_inst(struct mpc *mpc, unsigned int mpcc_id)
+{
+	struct dcn30_mpc *mpc30 = TO_DCN30_MPC(mpc);
+	mpc1_mpc_init_single_inst(mpc, mpcc_id);
+	/* assuming mpc out mux is connected to opp with the same index at this
+	 * point in time (e.g. transitioning from vbios to driver)
+	 */
+	if (mpcc_id < MAX_OPP && REG(MUX[mpcc_id]))
+		/* disable mpc out rate and flow control */
+		REG_UPDATE_2(MUX[mpcc_id], MPC_OUT_RATE_CONTROL_DISABLE,
+				1, MPC_OUT_FLOW_CONTROL_COUNT, 0);
+}
 bool mpc3_is_dwb_idle(
 	struct mpc *mpc,
 	int dwb_id)
 		MPC_DWB0_MUX, 0xf);
 }
-void mpc3_set_out_rate_control(
-	struct mpc *mpc,
-	int opp_id,
-	bool enable,
-	bool rate_2x_mode,
-	struct mpc_dwb_flow_control *flow_control)
-{
-	struct dcn30_mpc *mpc30 = TO_DCN30_MPC(mpc);
-	REG_UPDATE_2(MUX[opp_id],
-			MPC_OUT_RATE_CONTROL_DISABLE, !enable,
-			MPC_OUT_RATE_CONTROL, rate_2x_mode);
-	if (flow_control)
-		REG_UPDATE_2(MUX[opp_id],
-			MPC_OUT_FLOW_CONTROL_MODE, flow_control->flow_ctrl_mode,
-			MPC_OUT_FLOW_CONTROL_COUNT, flow_control->flow_ctrl_cnt1);
-}
 enum dc_lut_mode mpc3_get_ogam_current(struct mpc *mpc, int mpcc_id)
 {
 	/*Contrary to DCN2 and DCN1 wherein a single status register field holds this info;
 	.read_mpcc_state = mpc3_read_mpcc_state,
 	.insert_plane = mpc1_insert_plane,
 	.remove_mpcc = mpc1_remove_mpcc,
-	.mpc_init = mpc1_mpc_init,
+	.mpc_init = mpc3_mpc_init,
-	.mpc_init_single_inst = mpc1_mpc_init_single_inst,
+	.mpc_init_single_inst = mpc3_mpc_init_single_inst,
 	.update_blending = mpc2_update_blending,
 	.cursor_lock = mpc1_cursor_lock,
 	.get_mpcc_for_dpp = mpc1_get_mpcc_for_dpp,
 	.set_dwb_mux = mpc3_set_dwb_mux,
 	.disable_dwb_mux = mpc3_disable_dwb_mux,
 	.is_dwb_idle = mpc3_is_dwb_idle,
-	.set_out_rate_control = mpc3_set_out_rate_control,
 	.set_gamut_remap = mpc3_set_gamut_remap,
 	.program_shaper = mpc3_program_shaper,
 	.acquire_rmu = mpcc3_acquire_rmu,

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_mpc.h+7−7

 	int num_mpcc,
 	int num_rmu);
+void mpc3_mpc_init(
+	struct mpc *mpc);
+void mpc3_mpc_init_single_inst(
+	struct mpc *mpc,
+	unsigned int mpcc_id);
 bool mpc3_program_shaper(
 		struct mpc *mpc,
 		const struct pwl_params *params,
 	struct mpc *mpc,
 	int dwb_id);
-void mpc3_set_out_rate_control(
-	struct mpc *mpc,
-	int opp_id,
-	bool enable,
-	bool rate_2x_mode,
-	struct mpc_dwb_flow_control *flow_control);
 void mpc3_power_on_ogam_lut(
 	struct mpc *mpc, int mpcc_id,
 	bool power_on);

drivers/gpu/drm/amd/display/dc/dcn32/dcn32_mpc.c+2−3

 	struct dcn30_mpc *mpc30 = TO_DCN30_MPC(mpc);
 	int mpcc_id;
-	mpc1_mpc_init(mpc);
+	mpc3_mpc_init(mpc);
 	if (mpc->ctx->dc->debug.enable_mem_low_power.bits.mpc) {
 		if (mpc30->mpc_mask->MPCC_MCM_SHAPER_MEM_LOW_PWR_MODE && mpc30->mpc_mask->MPCC_MCM_3DLUT_MEM_LOW_PWR_MODE) {
 	.insert_plane = mpc1_insert_plane,
 	.remove_mpcc = mpc1_remove_mpcc,
 	.mpc_init = mpc32_mpc_init,
-	.mpc_init_single_inst = mpc1_mpc_init_single_inst,
+	.mpc_init_single_inst = mpc3_mpc_init_single_inst,
 	.update_blending = mpc2_update_blending,
 	.cursor_lock = mpc1_cursor_lock,
 	.get_mpcc_for_dpp = mpc1_get_mpcc_for_dpp,
 	.set_dwb_mux = mpc3_set_dwb_mux,
 	.disable_dwb_mux = mpc3_disable_dwb_mux,
 	.is_dwb_idle = mpc3_is_dwb_idle,
-	.set_out_rate_control = mpc3_set_out_rate_control,
 	.set_gamut_remap = mpc3_set_gamut_remap,
 	.program_shaper = mpc32_program_shaper,
 	.program_3dlut = mpc32_program_3dlut,

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

@@ -166,8 +166,8 @@ struct _vcs_dpi_soc_bounding_box_st dcn3_5_soc = { · 165 unmodified lines
166	.num_states = 5,	166	.num_states = 5,
167	.sr_exit_time_us = 28.0,	167	.sr_exit_time_us = 28.0,
168	.sr_enter_plus_exit_time_us = 30.0,	168	.sr_enter_plus_exit_time_us = 30.0,
169	.sr_exit_z8_time_us = 210.0,	169	.sr_exit_z8_time_us = 250.0,
170	.sr_enter_plus_exit_z8_time_us = 320.0,	170	.sr_enter_plus_exit_z8_time_us = 350.0,
171	.fclk_change_latency_us = 24.0,	171	.fclk_change_latency_us = 24.0,
172	.usr_retraining_latency_us = 2,	172	.usr_retraining_latency_us = 2,
173	.writeback_latency_us = 12.0,	173	.writeback_latency_us = 12.0,

drivers/gpu/drm/amd/display/dc/dml/dcn351/dcn351_fpu.c+84−19

 	.clock_limits = {
 		{
 			.state = 0,
-			.dispclk_mhz = 1200.0,
+			.dcfclk_mhz = 400.0,
-			.dppclk_mhz = 1200.0,
+			.fabricclk_mhz = 400.0,
+			.socclk_mhz = 600.0,
+			.dram_speed_mts = 3200.0,
+			.dispclk_mhz = 600.0,
+			.dppclk_mhz = 600.0,
 			.phyclk_mhz = 600.0,
 			.phyclk_d18_mhz = 667.0,
-			.dscclk_mhz = 186.0,
+			.dscclk_mhz = 200.0,
 			.dtbclk_mhz = 600.0,
 		},
 		{
 			.state = 1,
-			.dispclk_mhz = 1200.0,
+			.dcfclk_mhz = 600.0,
-			.dppclk_mhz = 1200.0,
+			.fabricclk_mhz = 1000.0,
+			.socclk_mhz = 733.0,
+			.dram_speed_mts = 6400.0,
+			.dispclk_mhz = 800.0,
+			.dppclk_mhz = 800.0,
 			.phyclk_mhz = 810.0,
 			.phyclk_d18_mhz = 667.0,
-			.dscclk_mhz = 209.0,
+			.dscclk_mhz = 266.7,
 			.dtbclk_mhz = 600.0,
 		},
 		{
 			.state = 2,
-			.dispclk_mhz = 1200.0,
+			.dcfclk_mhz = 738.0,
-			.dppclk_mhz = 1200.0,
+			.fabricclk_mhz = 1200.0,
+			.socclk_mhz = 880.0,
+			.dram_speed_mts = 7500.0,
+			.dispclk_mhz = 800.0,
+			.dppclk_mhz = 800.0,
 			.phyclk_mhz = 810.0,
 			.phyclk_d18_mhz = 667.0,
-			.dscclk_mhz = 209.0,
+			.dscclk_mhz = 266.7,
 			.dtbclk_mhz = 600.0,
 		},
 		{
 			.state = 3,
-			.dispclk_mhz = 1200.0,
+			.dcfclk_mhz = 800.0,
-			.dppclk_mhz = 1200.0,
+			.fabricclk_mhz = 1400.0,
+			.socclk_mhz = 978.0,
+			.dram_speed_mts = 7500.0,
+			.dispclk_mhz = 960.0,
+			.dppclk_mhz = 960.0,
 			.phyclk_mhz = 810.0,
 			.phyclk_d18_mhz = 667.0,
-			.dscclk_mhz = 371.0,
+			.dscclk_mhz = 320.0,
 			.dtbclk_mhz = 600.0,
 		},
 		{
 			.state = 4,
+			.dcfclk_mhz = 873.0,
+			.fabricclk_mhz = 1600.0,
+			.socclk_mhz = 1100.0,
+			.dram_speed_mts = 8533.0,
+			.dispclk_mhz = 1066.7,
+			.dppclk_mhz = 1066.7,
+			.phyclk_mhz = 810.0,
+			.phyclk_d18_mhz = 667.0,
+			.dscclk_mhz = 355.6,
+			.dtbclk_mhz = 600.0,
+		},
+		{
+			.state = 5,
+			.dcfclk_mhz = 960.0,
+			.fabricclk_mhz = 1700.0,
+			.socclk_mhz = 1257.0,
+			.dram_speed_mts = 8533.0,
 			.dispclk_mhz = 1200.0,
 			.dppclk_mhz = 1200.0,
 			.phyclk_mhz = 810.0,
 			.phyclk_d18_mhz = 667.0,
-			.dscclk_mhz = 417.0,
+			.dscclk_mhz = 400.0,
+			.dtbclk_mhz = 600.0,
+		},
+		{
+			.state = 6,
+			.dcfclk_mhz = 1067.0,
+			.fabricclk_mhz = 1850.0,
+			.socclk_mhz = 1257.0,
+			.dram_speed_mts = 8533.0,
+			.dispclk_mhz = 1371.4,
+			.dppclk_mhz = 1371.4,
+			.phyclk_mhz = 810.0,
+			.phyclk_d18_mhz = 667.0,
+			.dscclk_mhz = 457.1,
+			.dtbclk_mhz = 600.0,
+		},
+		{
+			.state = 7,
+			.dcfclk_mhz = 1200.0,
+			.fabricclk_mhz = 2000.0,
+			.socclk_mhz = 1467.0,
+			.dram_speed_mts = 8533.0,
+			.dispclk_mhz = 1600.0,
+			.dppclk_mhz = 1600.0,
+			.phyclk_mhz = 810.0,
+			.phyclk_d18_mhz = 667.0,
+			.dscclk_mhz = 533.3,
 			.dtbclk_mhz = 600.0,
 		},
 	},
-	.num_states = 5,
+	.num_states = 8,
 	.sr_exit_time_us = 28.0,
 	.sr_enter_plus_exit_time_us = 30.0,
-	.sr_exit_z8_time_us = 210.0,
+	.sr_exit_z8_time_us = 250.0,
-	.sr_enter_plus_exit_z8_time_us = 320.0,
+	.sr_enter_plus_exit_z8_time_us = 350.0,
 	.fclk_change_latency_us = 24.0,
 	.usr_retraining_latency_us = 2,
 	.writeback_latency_us = 12.0,
 	.do_urgent_latency_adjustment = 0,
 	.urgent_latency_adjustment_fabric_clock_component_us = 0,
 	.urgent_latency_adjustment_fabric_clock_reference_mhz = 0,
+	.num_chans = 4,
+	.dram_clock_change_latency_us = 11.72,
+	.dispclk_dppclk_vco_speed_mhz = 2400.0,
 };
 /*
 				clock_limits[i].socclk_mhz;
 			dc->dml2_options.bbox_overrides.clks_table.clk_entries[i].memclk_mhz =
 				clk_table->entries[i].memclk_mhz * clk_table->entries[i].wck_ratio;
+			dc->dml2_options.bbox_overrides.clks_table.clk_entries[i].dtbclk_mhz =
+				clock_limits[i].dtbclk_mhz;
 			dc->dml2_options.bbox_overrides.clks_table.num_entries_per_clk.num_dcfclk_levels =
 				clk_table->num_entries;
 			dc->dml2_options.bbox_overrides.clks_table.num_entries_per_clk.num_fclk_levels =
 				clk_table->num_entries;
 			dc->dml2_options.bbox_overrides.clks_table.num_entries_per_clk.num_memclk_levels =
 				clk_table->num_entries;
+			dc->dml2_options.bbox_overrides.clks_table.num_entries_per_clk.num_dtbclk_levels =
+				clk_table->num_entries;
 		}
 	}
 		if (context->res_ctx.pipe_ctx[i].plane_state)
 			plane_count++;
 	}
 	/*dcn351 does not support z9/z10*/
 	if (context->stream_count == 0 || plane_count == 0) {
 		support = DCN_ZSTATE_SUPPORT_ALLOW_Z8_ONLY;
 			dc->debug.minimum_z8_residency_time > 0 ? dc->debug.minimum_z8_residency_time : 1000;
 		bool allow_z8 = context->bw_ctx.dml.vba.StutterPeriod > (double)minmum_z8_residency;
 		/*for psr1/psr-su, we allow z8 and z10 based on latency, for replay with IPS enabled, it will enter ips2*/
-		 if (is_pwrseq0 && (is_psr || is_replay))
+		if (is_pwrseq0 && (is_psr || is_replay))
 			support = allow_z8 ? allow_z8 : DCN_ZSTATE_SUPPORT_DISALLOW;
 	}
 	context->bw_ctx.bw.dcn.clk.zstate_support = support;
 }

drivers/gpu/drm/amd/display/dc/dml2/dml2_translation_helper.c+1−5

 		break;
 	case dml_project_dcn35:
+	case dml_project_dcn351:
 		out->num_chans = 4;
 		out->round_trip_ping_latency_dcfclk_cycles = 106;
 		out->smn_latency_us = 2;
 		out->dispclk_dppclk_vco_speed_mhz = 3600;
 		break;
-	case dml_project_dcn351:
-		out->num_chans = 16;
-		out->round_trip_ping_latency_dcfclk_cycles = 1100;
-		out->smn_latency_us = 2;
-		break;
 	}
 	/* ---Overrides if available--- */
 	if (dml2->config.bbox_overrides.dram_num_chan)

drivers/gpu/drm/amd/display/dc/hwss/dce110/dce110_hwseq.c+2−1

 		if (dccg) {
 			dccg->funcs->disable_symclk32_se(dccg, dp_hpo_inst);
 			dccg->funcs->set_dpstreamclk(dccg, REFCLK, tg->inst, dp_hpo_inst);
-			dccg->funcs->set_dtbclk_dto(dccg, &dto_params);
+			if (dccg && dccg->funcs->set_dtbclk_dto)
+				dccg->funcs->set_dtbclk_dto(dccg, &dto_params);
 		}
 	} else if (dccg && dccg->funcs->disable_symclk_se) {
 		dccg->funcs->disable_symclk_se(dccg, stream_enc->stream_enc_inst,

drivers/gpu/drm/amd/display/dc/hwss/dcn314/dcn314_hwseq.c+0−41

@@ -69,29 +69,6 @@ · 68 unmodified lines
69	#define FN(reg_name, field_name) \	69	#define FN(reg_name, field_name) \
70	hws->shifts->field_name, hws->masks->field_name	70	hws->shifts->field_name, hws->masks->field_name
71		71
72	static int calc_mpc_flow_ctrl_cnt(const struct dc_stream_state *stream,
73	int opp_cnt)
74	{
75	bool hblank_halved = optc2_is_two_pixels_per_containter(&stream->timing);
76	int flow_ctrl_cnt;
77
78	if (opp_cnt >= 2)
79	hblank_halved = true;
80
81	flow_ctrl_cnt = stream->timing.h_total - stream->timing.h_addressable -
82	stream->timing.h_border_left -
83	stream->timing.h_border_right;
84
85	if (hblank_halved)
86	flow_ctrl_cnt /= 2;
87
88	/* ODM combine 4:1 case */
89	if (opp_cnt == 4)
90	flow_ctrl_cnt /= 2;
91
92	return flow_ctrl_cnt;
93	}
94
95	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)	72	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)
96	{	73	{
97	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;	74	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;
@@ -183,10 +160,6 @@ void dcn314_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx · 85 unmodified lines
183	struct pipe_ctx *odm_pipe;	160	struct pipe_ctx *odm_pipe;
184	int opp_cnt = 0;	161	int opp_cnt = 0;
185	int opp_inst[MAX_PIPES] = {0};	162	int opp_inst[MAX_PIPES] = {0};
186	bool rate_control_2x_pclk = (pipe_ctx->stream->timing.flags.INTERLACE \|\| optc2_is_two_pixels_per_containter(&pipe_ctx->stream->timing));
187	struct mpc_dwb_flow_control flow_control;
188	struct mpc *mpc = dc->res_pool->mpc;
189	int i;
190		163
191	opp_cnt = get_odm_config(pipe_ctx, opp_inst);	164	opp_cnt = get_odm_config(pipe_ctx, opp_inst);
192		165
@@ -199,20 +172,6 @@ void dcn314_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx · 6 unmodified lines
199	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(	172	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(
200	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);	173	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);
201		174
202	rate_control_2x_pclk = rate_control_2x_pclk \|\| opp_cnt > 1;
203	flow_control.flow_ctrl_mode = 0;
204	flow_control.flow_ctrl_cnt0 = 0x80;
205	flow_control.flow_ctrl_cnt1 = calc_mpc_flow_ctrl_cnt(pipe_ctx->stream, opp_cnt);
206	if (mpc->funcs->set_out_rate_control) {
207	for (i = 0; i < opp_cnt; ++i) {
208	mpc->funcs->set_out_rate_control(
209	mpc, opp_inst[i],
210	true,
211	rate_control_2x_pclk,
212	&flow_control);
213	}
214	}
215
216	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {	175	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {
217	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(	176	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(
218	odm_pipe->stream_res.opp,	177	odm_pipe->stream_res.opp,

drivers/gpu/drm/amd/display/dc/hwss/dcn32/dcn32_hwseq.c+0−41

@@ -966,29 +966,6 @@ void dcn32_init_hw(struct dc *dc) · 965 unmodified lines
966	}	966	}
967	}	967	}
968		968
969	static int calc_mpc_flow_ctrl_cnt(const struct dc_stream_state *stream,
970	int opp_cnt)
971	{
972	bool hblank_halved = optc2_is_two_pixels_per_containter(&stream->timing);
973	int flow_ctrl_cnt;
974
975	if (opp_cnt >= 2)
976	hblank_halved = true;
977
978	flow_ctrl_cnt = stream->timing.h_total - stream->timing.h_addressable -
979	stream->timing.h_border_left -
980	stream->timing.h_border_right;
981
982	if (hblank_halved)
983	flow_ctrl_cnt /= 2;
984
985	/* ODM combine 4:1 case */
986	if (opp_cnt == 4)
987	flow_ctrl_cnt /= 2;
988
989	return flow_ctrl_cnt;
990	}
991
992	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)	969	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)
993	{	970	{
994	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;	971	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;
@@ -1103,10 +1080,6 @@ void dcn32_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx * · 108 unmodified lines
1103	struct pipe_ctx *odm_pipe;	1080	struct pipe_ctx *odm_pipe;
1104	int opp_cnt = 0;	1081	int opp_cnt = 0;
1105	int opp_inst[MAX_PIPES] = {0};	1082	int opp_inst[MAX_PIPES] = {0};
1106	bool rate_control_2x_pclk = (pipe_ctx->stream->timing.flags.INTERLACE \|\| optc2_is_two_pixels_per_containter(&pipe_ctx->stream->timing));
1107	struct mpc_dwb_flow_control flow_control;
1108	struct mpc *mpc = dc->res_pool->mpc;
1109	int i;
1110		1083
1111	opp_cnt = get_odm_config(pipe_ctx, opp_inst);	1084	opp_cnt = get_odm_config(pipe_ctx, opp_inst);
1112		1085
@@ -1119,20 +1092,6 @@ void dcn32_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx * · 6 unmodified lines
1119	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(	1092	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(
1120	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);	1093	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);
1121		1094
1122	rate_control_2x_pclk = rate_control_2x_pclk \|\| opp_cnt > 1;
1123	flow_control.flow_ctrl_mode = 0;
1124	flow_control.flow_ctrl_cnt0 = 0x80;
1125	flow_control.flow_ctrl_cnt1 = calc_mpc_flow_ctrl_cnt(pipe_ctx->stream, opp_cnt);
1126	if (mpc->funcs->set_out_rate_control) {
1127	for (i = 0; i < opp_cnt; ++i) {
1128	mpc->funcs->set_out_rate_control(
1129	mpc, opp_inst[i],
1130	true,
1131	rate_control_2x_pclk,
1132	&flow_control);
1133	}
1134	}
1135
1136	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {	1095	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {
1137	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(	1096	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(
1138	odm_pipe->stream_res.opp,	1097	odm_pipe->stream_res.opp,

drivers/gpu/drm/amd/display/dc/hwss/dcn35/dcn35_hwseq.c+0−41

@@ -358,29 +358,6 @@ void dcn35_init_hw(struct dc *dc) · 357 unmodified lines
358	}	358	}
359	}	359	}
360		360
361	static int calc_mpc_flow_ctrl_cnt(const struct dc_stream_state *stream,
362	int opp_cnt)
363	{
364	bool hblank_halved = optc2_is_two_pixels_per_containter(&stream->timing);
365	int flow_ctrl_cnt;
366
367	if (opp_cnt >= 2)
368	hblank_halved = true;
369
370	flow_ctrl_cnt = stream->timing.h_total - stream->timing.h_addressable -
371	stream->timing.h_border_left -
372	stream->timing.h_border_right;
373
374	if (hblank_halved)
375	flow_ctrl_cnt /= 2;
376
377	/* ODM combine 4:1 case */
378	if (opp_cnt == 4)
379	flow_ctrl_cnt /= 2;
380
381	return flow_ctrl_cnt;
382	}
383
384	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)	361	static void update_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable)
385	{	362	{
386	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;	363	struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;
@@ -474,10 +451,6 @@ void dcn35_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx * · 87 unmodified lines
474	struct pipe_ctx *odm_pipe;	451	struct pipe_ctx *odm_pipe;
475	int opp_cnt = 0;	452	int opp_cnt = 0;
476	int opp_inst[MAX_PIPES] = {0};	453	int opp_inst[MAX_PIPES] = {0};
477	bool rate_control_2x_pclk = (pipe_ctx->stream->timing.flags.INTERLACE \|\| optc2_is_two_pixels_per_containter(&pipe_ctx->stream->timing));
478	struct mpc_dwb_flow_control flow_control;
479	struct mpc *mpc = dc->res_pool->mpc;
480	int i;
481		454
482	opp_cnt = get_odm_config(pipe_ctx, opp_inst);	455	opp_cnt = get_odm_config(pipe_ctx, opp_inst);
483		456
@@ -490,20 +463,6 @@ void dcn35_update_odm(struct dc dc, struct dc_state context, struct pipe_ctx * · 6 unmodified lines
490	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(	463	pipe_ctx->stream_res.tg->funcs->set_odm_bypass(
491	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);	464	pipe_ctx->stream_res.tg, &pipe_ctx->stream->timing);
492		465
493	rate_control_2x_pclk = rate_control_2x_pclk \|\| opp_cnt > 1;
494	flow_control.flow_ctrl_mode = 0;
495	flow_control.flow_ctrl_cnt0 = 0x80;
496	flow_control.flow_ctrl_cnt1 = calc_mpc_flow_ctrl_cnt(pipe_ctx->stream, opp_cnt);
497	if (mpc->funcs->set_out_rate_control) {
498	for (i = 0; i < opp_cnt; ++i) {
499	mpc->funcs->set_out_rate_control(
500	mpc, opp_inst[i],
501	true,
502	rate_control_2x_pclk,
503	&flow_control);
504	}
505	}
506
507	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {	466	for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {
508	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(	467	odm_pipe->stream_res.opp->funcs->opp_pipe_clock_control(
509	odm_pipe->stream_res.opp,	468	odm_pipe->stream_res.opp,

drivers/gpu/drm/amd/display/dc/hwss/dcn351/dcn351_init.c+1−1

@@ -67,7 +67,7 @@ static const struct hw_sequencer_funcs dcn351_funcs = { · 66 unmodified lines
67	.prepare_bandwidth = dcn35_prepare_bandwidth,	67	.prepare_bandwidth = dcn35_prepare_bandwidth,
68	.optimize_bandwidth = dcn35_optimize_bandwidth,	68	.optimize_bandwidth = dcn35_optimize_bandwidth,
69	.update_bandwidth = dcn20_update_bandwidth,	69	.update_bandwidth = dcn20_update_bandwidth,
70	.set_drr = dcn10_set_drr,	70	.set_drr = dcn35_set_drr,
71	.get_position = dcn10_get_position,	71	.get_position = dcn10_get_position,
72	.set_static_screen_control = dcn35_set_static_screen_control,	72	.set_static_screen_control = dcn35_set_static_screen_control,
73	.setup_stereo = dcn10_setup_stereo,	73	.setup_stereo = dcn10_setup_stereo,

drivers/gpu/drm/amd/display/dc/resource/dcn351/dcn351_resource.c+8−3

 	.disable_dcc = DCC_ENABLE,
 	.disable_dpp_power_gate = true,
 	.disable_hubp_power_gate = true,
+	.disable_optc_power_gate = true, /*should the same as above two*/
+	.disable_hpo_power_gate = true, /*dmubfw force domain25 on*/
 	.disable_clock_gate = false,
 	.disable_dsc_power_gate = true,
 	.vsr_support = true,
 	},
 	.seamless_boot_odm_combine = DML_FAIL_SOURCE_PIXEL_FORMAT,
 	.enable_z9_disable_interface = true, /* Allow support for the PMFW interface for disable Z9*/
+	.minimum_z8_residency_time = 2100,
 	.using_dml2 = true,
 	.support_eDP1_5 = true,
 	.enable_hpo_pg_support = false,
 	.enable_legacy_fast_update = true,
 	.enable_single_display_2to1_odm_policy = true,
-	.disable_idle_power_optimizations = true,
+	.disable_idle_power_optimizations = false,
 	.dmcub_emulation = false,
 	.disable_boot_optimizations = false,
 	.disable_unbounded_requesting = false,
 	.disable_z10 = true,
 	.ignore_pg = true,
 	.psp_disabled_wa = true,
-	.ips2_eval_delay_us = 200,
+	.ips2_eval_delay_us = 2000,
-	.ips2_entry_delay_us = 400
+	.ips2_entry_delay_us = 800,
+	.disable_dmub_reallow_idle = true,
+	.static_screen_wait_frames = 2,
 };
 static const struct dc_panel_config panel_config_defaults = {

drivers/gpu/drm/amd/display/modules/info_packet/info_packet.c+5−8

 	}
 	/* VSC packet set to 4 for PSR-SU, or 2 for PSR1 */
-	if (stream->link->psr_settings.psr_feature_enabled) {
+	if (stream->link->psr_settings.psr_version == DC_PSR_VERSION_SU_1)
-		if (stream->link->psr_settings.psr_version == DC_PSR_VERSION_SU_1)
+		vsc_packet_revision = vsc_packet_rev4;
-			vsc_packet_revision = vsc_packet_rev4;
+	else if (stream->link->replay_settings.config.replay_supported)
-		else if (stream->link->psr_settings.psr_version == DC_PSR_VERSION_1)
-			vsc_packet_revision = vsc_packet_rev2;
-	}
-	if (stream->link->replay_settings.config.replay_supported)
 		vsc_packet_revision = vsc_packet_rev4;
+	else if (stream->link->psr_settings.psr_version == DC_PSR_VERSION_1)
+		vsc_packet_revision = vsc_packet_rev2;
 	/* Update to revision 5 for extended colorimetry support */
 	if (stream->use_vsc_sdp_for_colorimetry)

drivers/gpu/drm/amd/include/umsch_mm_4_0_api_def.h+11−2

 				uint32_t enable_level_process_quantum_check : 1;
 				uint32_t is_vcn0_enabled : 1;
 				uint32_t is_vcn1_enabled : 1;
-				uint32_t reserved : 27;
+				uint32_t use_rs64mem_for_proc_ctx_csa : 1;
+				uint32_t reserved : 26;
 			};
 			uint32_t uint32_all;
 		};
 		struct {
 			uint32_t is_context_suspended : 1;
-			uint32_t reserved : 31;
+			uint32_t collaboration_mode : 1;
+			uint32_t reserved : 30;
 		};
 		struct UMSCH_API_STATUS api_status;
+		uint32_t process_csa_array_index;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 		uint64_t context_csa_addr;
 		struct UMSCH_API_STATUS api_status;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 		uint32_t suspend_fence_value;
 		struct UMSCH_API_STATUS api_status;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 		enum UMSCH_ENGINE_TYPE engine_type;
 		struct UMSCH_API_STATUS api_status;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 		union UMSCH_AFFINITY affinity;
 		uint64_t context_csa_addr;
 		struct UMSCH_API_STATUS api_status;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 		uint64_t context_quantum;
 		uint64_t context_csa_addr;
 		struct UMSCH_API_STATUS api_status;
+		uint32_t context_csa_array_index;
 	};
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];

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

@@ -54,14 +54,14 @@ · 53 unmodified lines
54	#define PPSMC_MSG_TestMessage 0x01 ///< To check if PMFW is alive and responding. Requirement specified by PMFW team	54	#define PPSMC_MSG_TestMessage 0x01 ///< To check if PMFW is alive and responding. Requirement specified by PMFW team
55	#define PPSMC_MSG_GetPmfwVersion 0x02 ///< Get PMFW version	55	#define PPSMC_MSG_GetPmfwVersion 0x02 ///< Get PMFW version
56	#define PPSMC_MSG_GetDriverIfVersion 0x03 ///< Get PMFW_DRIVER_IF version	56	#define PPSMC_MSG_GetDriverIfVersion 0x03 ///< Get PMFW_DRIVER_IF version
57	#define PPSMC_MSG_SPARE0 0x04 ///< SPARE	57	#define PPSMC_MSG_PowerDownVcn1 0x04 ///< Power down VCN1
58	#define PPSMC_MSG_SPARE1 0x05 ///< SPARE	58	#define PPSMC_MSG_PowerUpVcn1 0x05 ///< Power up VCN1; VCN1 is power gated by default
59	#define PPSMC_MSG_PowerDownVcn 0x06 ///< Power down VCN	59	#define PPSMC_MSG_PowerDownVcn0 0x06 ///< Power down VCN0
60	#define PPSMC_MSG_PowerUpVcn 0x07 ///< Power up VCN; VCN is power gated by default	60	#define PPSMC_MSG_PowerUpVcn0 0x07 ///< Power up VCN0; VCN0 is power gated by default
61	#define PPSMC_MSG_SetHardMinVcn 0x08 ///< For wireless display	61	#define PPSMC_MSG_SetHardMinVcn0 0x08 ///< For wireless display
62	#define PPSMC_MSG_SetSoftMinGfxclk 0x09 ///< Set SoftMin for GFXCLK, argument is frequency in MHz	62	#define PPSMC_MSG_SetSoftMinGfxclk 0x09 ///< Set SoftMin for GFXCLK, argument is frequency in MHz
63	#define PPSMC_MSG_SPARE2 0x0A ///< SPARE	63	#define PPSMC_MSG_SetHardMinVcn1 0x0A ///< For wireless display
64	#define PPSMC_MSG_SPARE3 0x0B ///< SPARE	64	#define PPSMC_MSG_SetSoftMinVcn1 0x0B ///< Set soft min for VCN1 clocks (VCLK1 and DCLK1)
65	#define PPSMC_MSG_PrepareMp1ForUnload 0x0C ///< Prepare PMFW for GFX driver unload	65	#define PPSMC_MSG_PrepareMp1ForUnload 0x0C ///< Prepare PMFW for GFX driver unload
66	#define PPSMC_MSG_SetDriverDramAddrHigh 0x0D ///< Set high 32 bits of DRAM address for Driver table transfer	66	#define PPSMC_MSG_SetDriverDramAddrHigh 0x0D ///< Set high 32 bits of DRAM address for Driver table transfer
67	#define PPSMC_MSG_SetDriverDramAddrLow 0x0E ///< Set low 32 bits of DRAM address for Driver table transfer	67	#define PPSMC_MSG_SetDriverDramAddrLow 0x0E ///< Set low 32 bits of DRAM address for Driver table transfer
@@ -71,7 +71,7 @@ · 3 unmodified lines
71	#define PPSMC_MSG_GetEnabledSmuFeatures 0x12 ///< Get enabled features in PMFW	71	#define PPSMC_MSG_GetEnabledSmuFeatures 0x12 ///< Get enabled features in PMFW
72	#define PPSMC_MSG_SetHardMinSocclkByFreq 0x13 ///< Set hard min for SOC CLK	72	#define PPSMC_MSG_SetHardMinSocclkByFreq 0x13 ///< Set hard min for SOC CLK
73	#define PPSMC_MSG_SetSoftMinFclk 0x14 ///< Set hard min for FCLK	73	#define PPSMC_MSG_SetSoftMinFclk 0x14 ///< Set hard min for FCLK
74	#define PPSMC_MSG_SetSoftMinVcn 0x15 ///< Set soft min for VCN clocks (VCLK and DCLK)	74	#define PPSMC_MSG_SetSoftMinVcn0 0x15 ///< Set soft min for VCN0 clocks (VCLK0 and DCLK0)
75		75
76	#define PPSMC_MSG_EnableGfxImu 0x16 ///< Enable GFX IMU	76	#define PPSMC_MSG_EnableGfxImu 0x16 ///< Enable GFX IMU
77		77
@@ -84,17 +84,17 @@ · 6 unmodified lines
84		84
85	#define PPSMC_MSG_SetSoftMaxSocclkByFreq 0x1D ///< Set soft max for SOC CLK	85	#define PPSMC_MSG_SetSoftMaxSocclkByFreq 0x1D ///< Set soft max for SOC CLK
86	#define PPSMC_MSG_SetSoftMaxFclkByFreq 0x1E ///< Set soft max for FCLK	86	#define PPSMC_MSG_SetSoftMaxFclkByFreq 0x1E ///< Set soft max for FCLK
87	#define PPSMC_MSG_SetSoftMaxVcn 0x1F ///< Set soft max for VCN clocks (VCLK and DCLK)	87	#define PPSMC_MSG_SetSoftMaxVcn0 0x1F ///< Set soft max for VCN0 clocks (VCLK0 and DCLK0)
88	#define PPSMC_MSG_spare_0x20 0x20	88	#define PPSMC_MSG_spare_0x20 0x20
89	#define PPSMC_MSG_PowerDownJpeg 0x21 ///< Power down Jpeg	89	#define PPSMC_MSG_PowerDownJpeg0 0x21 ///< Power down Jpeg of VCN0
90	#define PPSMC_MSG_PowerUpJpeg 0x22 ///< Power up Jpeg; VCN is power gated by default	90	#define PPSMC_MSG_PowerUpJpeg0 0x22 ///< Power up Jpeg of VCN0; VCN0 is power gated by default
91		91
92	#define PPSMC_MSG_SetHardMinFclkByFreq 0x23 ///< Set hard min for FCLK	92	#define PPSMC_MSG_SetHardMinFclkByFreq 0x23 ///< Set hard min for FCLK
93	#define PPSMC_MSG_SetSoftMinSocclkByFreq 0x24 ///< Set soft min for SOC CLK	93	#define PPSMC_MSG_SetSoftMinSocclkByFreq 0x24 ///< Set soft min for SOC CLK
94	#define PPSMC_MSG_AllowZstates 0x25 ///< Inform PMFM of allowing Zstate entry, i.e. no Miracast activity	94	#define PPSMC_MSG_AllowZstates 0x25 ///< Inform PMFM of allowing Zstate entry, i.e. no Miracast activity
95	#define PPSMC_MSG_Reserved 0x26 ///< Not used	95	#define PPSMC_MSG_PowerDownJpeg1 0x26 ///< Power down Jpeg of VCN1
96	#define PPSMC_MSG_Reserved1 0x27 ///< Not used, previously PPSMC_MSG_RequestActiveWgp	96	#define PPSMC_MSG_PowerUpJpeg1 0x27 ///< Power up Jpeg of VCN1; VCN1 is power gated by default
97	#define PPSMC_MSG_Reserved2 0x28 ///< Not used, previously PPSMC_MSG_QueryActiveWgp	97	#define PPSMC_MSG_SetSoftMaxVcn1 0x28 ///< Set soft max for VCN1 clocks (VCLK1 and DCLK1)
98	#define PPSMC_MSG_PowerDownIspByTile 0x29 ///< ISP is power gated by default	98	#define PPSMC_MSG_PowerDownIspByTile 0x29 ///< ISP is power gated by default
99	#define PPSMC_MSG_PowerUpIspByTile 0x2A ///< This message is used to power up ISP tiles and enable the ISP DPM	99	#define PPSMC_MSG_PowerUpIspByTile 0x2A ///< This message is used to power up ISP tiles and enable the ISP DPM
100	#define PPSMC_MSG_SetHardMinIspiclkByFreq 0x2B ///< Set HardMin by frequency for ISPICLK	100	#define PPSMC_MSG_SetHardMinIspiclkByFreq 0x2B ///< Set HardMin by frequency for ISPICLK

drivers/gpu/drm/amd/pm/swsmu/inc/smu_types.h+10−0

        __SMU_DUMMY_MAP(PowerDownVcn),                 \
        __SMU_DUMMY_MAP(PowerUpJpeg),                  \
        __SMU_DUMMY_MAP(PowerDownJpeg),                \
+       __SMU_DUMMY_MAP(PowerUpJpeg0),                 \
+       __SMU_DUMMY_MAP(PowerDownJpeg0),               \
+       __SMU_DUMMY_MAP(PowerUpJpeg1),                 \
+       __SMU_DUMMY_MAP(PowerDownJpeg1),               \
        __SMU_DUMMY_MAP(BacoAudioD3PME),               \
        __SMU_DUMMY_MAP(ArmD3),                        \
        __SMU_DUMMY_MAP(RunDcBtc),                     \
 	__SMU_DUMMY_MAP(PowerUpSdma),                 \
 	__SMU_DUMMY_MAP(SetHardMinIspclkByFreq),      \
 	__SMU_DUMMY_MAP(SetHardMinVcn),               \
+       __SMU_DUMMY_MAP(SetHardMinVcn0),               \
+       __SMU_DUMMY_MAP(SetHardMinVcn1),               \
 	__SMU_DUMMY_MAP(SetAllowFclkSwitch),          \
 	__SMU_DUMMY_MAP(SetMinVideoGfxclkFreq),       \
 	__SMU_DUMMY_MAP(ActiveProcessNotify),         \
 	__SMU_DUMMY_MAP(SetPhyclkVoltageByFreq),      \
 	__SMU_DUMMY_MAP(SetDppclkVoltageByFreq),      \
 	__SMU_DUMMY_MAP(SetSoftMinVcn),               \
+       __SMU_DUMMY_MAP(SetSoftMinVcn0),              \
+       __SMU_DUMMY_MAP(SetSoftMinVcn1),              \
 	__SMU_DUMMY_MAP(EnablePostCode),              \
 	__SMU_DUMMY_MAP(GetGfxclkFrequency),          \
 	__SMU_DUMMY_MAP(GetFclkFrequency),            \
 	__SMU_DUMMY_MAP(SetSoftMaxSocclkByFreq),      \
 	__SMU_DUMMY_MAP(SetSoftMaxFclkByFreq),        \
 	__SMU_DUMMY_MAP(SetSoftMaxVcn),               \
+       __SMU_DUMMY_MAP(SetSoftMaxVcn0),              \
+       __SMU_DUMMY_MAP(SetSoftMaxVcn1),              \
 	__SMU_DUMMY_MAP(PowerGateMmHub),              \
 	__SMU_DUMMY_MAP(UpdatePmeRestore),            \
 	__SMU_DUMMY_MAP(GpuChangeState),              \

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0.c+44−6

@@ -1402,9 +1402,22 @@ int smu_v14_0_set_vcn_enable(struct smu_context *smu, · 1401 unmodified lines
1402	if (adev->vcn.harvest_config & (1 << i))	1402	if (adev->vcn.harvest_config & (1 << i))
1403	continue;	1403	continue;
1404		1404
1405	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?	1405	if (amdgpu_ip_version(adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 0) \|\|
1406	SMU_MSG_PowerUpVcn : SMU_MSG_PowerDownVcn,	1406	amdgpu_ip_version(adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 1)) {
1407	i << 16U, NULL);	1407	if (i == 0)
		1408	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1409	SMU_MSG_PowerUpVcn0 : SMU_MSG_PowerDownVcn0,
		1410	i << 16U, NULL);
		1411	else if (i == 1)
		1412	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1413	SMU_MSG_PowerUpVcn1 : SMU_MSG_PowerDownVcn1,
		1414	i << 16U, NULL);
		1415	} else {
		1416	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1417	SMU_MSG_PowerUpVcn : SMU_MSG_PowerDownVcn,
		1418	i << 16U, NULL);
		1419	}
		1420
1408	if (ret)	1421	if (ret)
1409	return ret;	1422	return ret;
1410	}	1423	}
@@ -1415,9 +1428,34 @@ int smu_v14_0_set_vcn_enable(struct smu_context *smu, · 4 unmodified lines
1415	int smu_v14_0_set_jpeg_enable(struct smu_context *smu,	1428	int smu_v14_0_set_jpeg_enable(struct smu_context *smu,
1416	bool enable)	1429	bool enable)
1417	{	1430	{
1418	return smu_cmn_send_smc_msg_with_param(smu, enable ?	1431	struct amdgpu_device *adev = smu->adev;
1419	SMU_MSG_PowerUpJpeg : SMU_MSG_PowerDownJpeg,	1432	int i, ret = 0;
1420	0, NULL);	1433
		1434	for (i = 0; i < adev->jpeg.num_jpeg_inst; i++) {
		1435	if (adev->jpeg.harvest_config & (1 << i))
		1436	continue;
		1437
		1438	if (amdgpu_ip_version(adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 0) \|\|
		1439	amdgpu_ip_version(adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 1)) {
		1440	if (i == 0)
		1441	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1442	SMU_MSG_PowerUpJpeg0 : SMU_MSG_PowerDownJpeg0,
		1443	i << 16U, NULL);
		1444	else if (i == 1 && amdgpu_ip_version(adev, MP1_HWIP, 0) == IP_VERSION(14, 0, 1))
		1445	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1446	SMU_MSG_PowerUpJpeg1 : SMU_MSG_PowerDownJpeg1,
		1447	i << 16U, NULL);
		1448	} else {
		1449	ret = smu_cmn_send_smc_msg_with_param(smu, enable ?
		1450	SMU_MSG_PowerUpJpeg : SMU_MSG_PowerDownJpeg,
		1451	i << 16U, NULL);
		1452	}
		1453
		1454	if (ret)
		1455	return ret;
		1456	}
		1457
		1458	return ret;
1421	}	1459	}
1422		1460
1423	int smu_v14_0_run_btc(struct smu_context *smu)	1461	int smu_v14_0_run_btc(struct smu_context *smu)

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_0_ppt.c+14−7

 	MSG_MAP(TestMessage,                    PPSMC_MSG_TestMessage,				1),
 	MSG_MAP(GetSmuVersion,                  PPSMC_MSG_GetPmfwVersion,			1),
 	MSG_MAP(GetDriverIfVersion,             PPSMC_MSG_GetDriverIfVersion,		1),
-	MSG_MAP(PowerDownVcn,                   PPSMC_MSG_PowerDownVcn,				1),
+	MSG_MAP(PowerDownVcn0,                  PPSMC_MSG_PowerDownVcn0,			1),
-	MSG_MAP(PowerUpVcn,                     PPSMC_MSG_PowerUpVcn,				1),
+	MSG_MAP(PowerUpVcn0,                    PPSMC_MSG_PowerUpVcn0,				1),
-	MSG_MAP(SetHardMinVcn,                  PPSMC_MSG_SetHardMinVcn,			1),
+	MSG_MAP(SetHardMinVcn0,                 PPSMC_MSG_SetHardMinVcn0,			1),
+	MSG_MAP(PowerDownVcn1,                  PPSMC_MSG_PowerDownVcn1,			1),
+	MSG_MAP(PowerUpVcn1,                    PPSMC_MSG_PowerUpVcn1,				1),
+	MSG_MAP(SetHardMinVcn1,                 PPSMC_MSG_SetHardMinVcn1,			1),
 	MSG_MAP(SetSoftMinGfxclk,               PPSMC_MSG_SetSoftMinGfxclk,			1),
 	MSG_MAP(PrepareMp1ForUnload,            PPSMC_MSG_PrepareMp1ForUnload,		1),
 	MSG_MAP(SetDriverDramAddrHigh,          PPSMC_MSG_SetDriverDramAddrHigh,	1),
 	MSG_MAP(GetEnabledSmuFeatures,          PPSMC_MSG_GetEnabledSmuFeatures,	1),
 	MSG_MAP(SetHardMinSocclkByFreq,         PPSMC_MSG_SetHardMinSocclkByFreq,	1),
 	MSG_MAP(SetSoftMinFclk,                 PPSMC_MSG_SetSoftMinFclk,			1),
-	MSG_MAP(SetSoftMinVcn,                  PPSMC_MSG_SetSoftMinVcn,			1),
+	MSG_MAP(SetSoftMinVcn0,                 PPSMC_MSG_SetSoftMinVcn0,			1),
+	MSG_MAP(SetSoftMinVcn1,                 PPSMC_MSG_SetSoftMinVcn1,			1),
 	MSG_MAP(EnableGfxImu,                   PPSMC_MSG_EnableGfxImu,				1),
 	MSG_MAP(AllowGfxOff,                    PPSMC_MSG_AllowGfxOff,				1),
 	MSG_MAP(DisallowGfxOff,                 PPSMC_MSG_DisallowGfxOff,			1),
 	MSG_MAP(SetHardMinGfxClk,               PPSMC_MSG_SetHardMinGfxClk,			1),
 	MSG_MAP(SetSoftMaxSocclkByFreq,         PPSMC_MSG_SetSoftMaxSocclkByFreq,	1),
 	MSG_MAP(SetSoftMaxFclkByFreq,           PPSMC_MSG_SetSoftMaxFclkByFreq,		1),
-	MSG_MAP(SetSoftMaxVcn,                  PPSMC_MSG_SetSoftMaxVcn,			1),
+	MSG_MAP(SetSoftMaxVcn0,                 PPSMC_MSG_SetSoftMaxVcn0,			1),
-	MSG_MAP(PowerDownJpeg,                  PPSMC_MSG_PowerDownJpeg,			1),
+	MSG_MAP(SetSoftMaxVcn1,                 PPSMC_MSG_SetSoftMaxVcn1,			1),
-	MSG_MAP(PowerUpJpeg,                    PPSMC_MSG_PowerUpJpeg,				1),
+	MSG_MAP(PowerDownJpeg0,                 PPSMC_MSG_PowerDownJpeg0,			1),
+	MSG_MAP(PowerUpJpeg0,                   PPSMC_MSG_PowerUpJpeg0,				1),
+	MSG_MAP(PowerDownJpeg1,                 PPSMC_MSG_PowerDownJpeg1,			1),
+	MSG_MAP(PowerUpJpeg1,                   PPSMC_MSG_PowerUpJpeg1,				1),
 	MSG_MAP(SetHardMinFclkByFreq,           PPSMC_MSG_SetHardMinFclkByFreq,		1),
 	MSG_MAP(SetSoftMinSocclkByFreq,         PPSMC_MSG_SetSoftMinSocclkByFreq,	1),
 	MSG_MAP(PowerDownIspByTile,             PPSMC_MSG_PowerDownIspByTile,		1),

drivers/gpu/drm/display/drm_dp_helper.c+7−0

@@ -4111,6 +4111,13 @@ int drm_dp_bw_overhead(int lane_count, int hactive, · 4110 unmodified lines
4111	u32 overhead = 1000000;	4111	u32 overhead = 1000000;
4112	int symbol_cycles;	4112	int symbol_cycles;
4113		4113
		4114	if (lane_count == 0 \|\| hactive == 0 \|\| bpp_x16 == 0) {
		4115	DRM_DEBUG_KMS("Invalid BW overhead params: lane_count %d, hactive %d, bpp_x16 %d.%04d\n",
		4116	lane_count, hactive,
		4117	bpp_x16 >> 4, (bpp_x16 & 0xf) * 625);
		4118	return 0;
		4119	}
		4120
4114	/*	4121	/*
4115	* DP Standard v2.1 2.6.4.1	4122	* DP Standard v2.1 2.6.4.1
4116	* SSC downspread and ref clock variation margin:	4123	* SSC downspread and ref clock variation margin:

drivers/gpu/drm/i915/Makefile+3−3

@@ -33,9 +33,9 @@ endif · 32 unmodified lines
33	subdir-ccflags-$(CONFIG_DRM_I915_WERROR) += -Werror	33	subdir-ccflags-$(CONFIG_DRM_I915_WERROR) += -Werror
34		34
35	# Fine grained warnings disable	35	# Fine grained warnings disable
36	CFLAGS_i915_pci.o = $(call cc-disable-warning, override-init)	36	CFLAGS_i915_pci.o = -Wno-override-init
37	CFLAGS_display/intel_display_device.o = $(call cc-disable-warning, override-init)	37	CFLAGS_display/intel_display_device.o = -Wno-override-init
38	CFLAGS_display/intel_fbdev.o = $(call cc-disable-warning, override-init)	38	CFLAGS_display/intel_fbdev.o = -Wno-override-init
39		39
40	# Support compiling the display code separately for both i915 and xe	40	# Support compiling the display code separately for both i915 and xe
41	# drivers. Define I915 when building i915.	41	# drivers. Define I915 when building i915.

drivers/gpu/drm/i915/display/g4x_dp.c+0−2

 {
 	intel_enable_dp(state, encoder, pipe_config, conn_state);
 	intel_edp_backlight_on(pipe_config, conn_state);
-	encoder->audio_enable(encoder, pipe_config, conn_state);
 }
 static void vlv_enable_dp(struct intel_atomic_state *state,
 			  const struct drm_connector_state *conn_state)
 {
 	intel_edp_backlight_on(pipe_config, conn_state);
-	encoder->audio_enable(encoder, pipe_config, conn_state);
 }
 static void g4x_pre_enable_dp(struct intel_atomic_state *state,

drivers/gpu/drm/i915/display/icl_dsi.c+2−1

 	}
 	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_INIT_OTP);
-	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);
 	/* ensure all panel commands dispatched before enabling transcoder */
 	wait_for_cmds_dispatched_to_panel(encoder);
 	/* step6d: enable dsi transcoder */
 	gen11_dsi_enable_transcoder(encoder);
+	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);
 	/* step7: enable backlight */
 	intel_backlight_enable(crtc_state, conn_state);
 	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_BACKLIGHT_ON);

drivers/gpu/drm/i915/display/intel_bios.c+40−6

@@ -1955,16 +1955,12 @@ static int get_init_otp_deassert_fragment_len(struct drm_i915_private *i915, · 1954 unmodified lines
1955	* these devices we split the init OTP sequence into a deassert sequence and	1955	* these devices we split the init OTP sequence into a deassert sequence and
1956	* the actual init OTP part.	1956	* the actual init OTP part.
1957	*/	1957	*/
1958	static void fixup_mipi_sequences(struct drm_i915_private *i915,	1958	static void vlv_fixup_mipi_sequences(struct drm_i915_private *i915,
1959	struct intel_panel *panel)	1959	struct intel_panel *panel)
1960	{	1960	{
1961	u8 *init_otp;	1961	u8 *init_otp;
1962	int len;	1962	int len;
1963		1963
1964	/* Limit this to VLV for now. */
1965	if (!IS_VALLEYVIEW(i915))
1966	return;
1967
1968	/* Limit this to v1 vid-mode sequences */	1964	/* Limit this to v1 vid-mode sequences */
1969	if (panel->vbt.dsi.config->is_cmd_mode \|\|	1965	if (panel->vbt.dsi.config->is_cmd_mode \|\|
1970	panel->vbt.dsi.seq_version != 1)	1966	panel->vbt.dsi.seq_version != 1)
@@ -2000,6 +1996,41 @@ static void fixup_mipi_sequences(struct drm_i915_private *i915, · 29 unmodified lines
2000	panel->vbt.dsi.sequence[MIPI_SEQ_INIT_OTP] = init_otp + len - 1;	1996	panel->vbt.dsi.sequence[MIPI_SEQ_INIT_OTP] = init_otp + len - 1;
2001	}	1997	}
2002		1998
		1999	/*
		2000	* Some machines (eg. Lenovo 82TQ) appear to have broken
		2001	* VBT sequences:
		2002	* - INIT_OTP is not present at all
		2003	* - what should be in INIT_OTP is in DISPLAY_ON
		2004	* - what should be in DISPLAY_ON is in BACKLIGHT_ON
		2005	* (along with the actual backlight stuff)
		2006	*
		2007	* To make those work we simply swap DISPLAY_ON and INIT_OTP.
		2008	*
		2009	* TODO: Do we need to limit this to specific machines,
		2010	* or examine the contents of the sequences to
		2011	* avoid false positives?
		2012	*/
		2013	static void icl_fixup_mipi_sequences(struct drm_i915_private *i915,
		2014	struct intel_panel *panel)
		2015	{
		2016	if (!panel->vbt.dsi.sequence[MIPI_SEQ_INIT_OTP] &&
		2017	panel->vbt.dsi.sequence[MIPI_SEQ_DISPLAY_ON]) {
		2018	drm_dbg_kms(&i915->drm, "Broken VBT: Swapping INIT_OTP and DISPLAY_ON sequences\n");
		2019
		2020	swap(panel->vbt.dsi.sequence[MIPI_SEQ_INIT_OTP],
		2021	panel->vbt.dsi.sequence[MIPI_SEQ_DISPLAY_ON]);
		2022	}
		2023	}
		2024
		2025	static void fixup_mipi_sequences(struct drm_i915_private *i915,
		2026	struct intel_panel *panel)
		2027	{
		2028	if (DISPLAY_VER(i915) >= 11)
		2029	icl_fixup_mipi_sequences(i915, panel);
		2030	else if (IS_VALLEYVIEW(i915))
		2031	vlv_fixup_mipi_sequences(i915, panel);
		2032	}
		2033
2003	static void	2034	static void
2004	parse_mipi_sequence(struct drm_i915_private *i915,	2035	parse_mipi_sequence(struct drm_i915_private *i915,
2005	struct intel_panel *panel)	2036	struct intel_panel *panel)
@@ -3351,6 +3382,9 @@ bool intel_bios_encoder_supports_dp_dual_mode(const struct intel_bios_encoder_da · 1345 unmodified lines
3351	{	3382	{
3352	const struct child_device_config *child = &devdata->child;	3383	const struct child_device_config *child = &devdata->child;
3353		3384
		3385	if (!devdata)
		3386	return false;
		3387
3354	if (!intel_bios_encoder_supports_dp(devdata) \|\|	3388	if (!intel_bios_encoder_supports_dp(devdata) \|\|
3355	!intel_bios_encoder_supports_hdmi(devdata))	3389	!intel_bios_encoder_supports_hdmi(devdata))
3356	return false;	3390	return false;

drivers/gpu/drm/i915/display/intel_cursor.c+1−3

 {
 	struct drm_i915_private *dev_priv =
 		to_i915(plane_state->uapi.plane->dev);
-	const struct drm_framebuffer *fb = plane_state->hw.fb;
-	struct drm_i915_gem_object *obj = intel_fb_obj(fb);
 	u32 base;
 	if (DISPLAY_INFO(dev_priv)->cursor_needs_physical)
-		base = i915_gem_object_get_dma_address(obj, 0);
+		base = plane_state->phys_dma_addr;
 	else
 		base = intel_plane_ggtt_offset(plane_state);

drivers/gpu/drm/i915/display/intel_display_types.h+1−0

@@ -727,6 +727,7 @@ struct intel_plane_state { · 726 unmodified lines
727	#define PLANE_HAS_FENCE BIT(0)	727	#define PLANE_HAS_FENCE BIT(0)
728		728
729	struct intel_fb_view view;	729	struct intel_fb_view view;
		730	u32 phys_dma_addr; /* for cursor_needs_physical */
730		731
731	/* Plane pxp decryption state */	732	/* Plane pxp decryption state */
732	bool decrypt;	733	bool decrypt;

drivers/gpu/drm/i915/display/intel_dp.c+2−10

 #include "intel_dp_tunnel.h"
 #include "intel_dpio_phy.h"
 #include "intel_dpll.h"
+#include "intel_drrs.h"
 #include "intel_fifo_underrun.h"
 #include "intel_hdcp.h"
 #include "intel_hdmi.h"
 		intel_hdmi_infoframe_enable(HDMI_PACKET_TYPE_GAMUT_METADATA);
 }
-static bool cpu_transcoder_has_drrs(struct drm_i915_private *i915,
-				    enum transcoder cpu_transcoder)
-{
-	if (HAS_DOUBLE_BUFFERED_M_N(i915))
-		return true;
-	return intel_cpu_transcoder_has_m2_n2(i915, cpu_transcoder);
-}
 static bool can_enable_drrs(struct intel_connector *connector,
 			    const struct intel_crtc_state *pipe_config,
 			    const struct drm_display_mode *downclock_mode)
 	if (pipe_config->has_pch_encoder)
 		return false;
-	if (!cpu_transcoder_has_drrs(i915, pipe_config->cpu_transcoder))
+	if (!intel_cpu_transcoder_has_drrs(i915, pipe_config->cpu_transcoder))
 		return false;
 	return downclock_mode &&

drivers/gpu/drm/i915/display/intel_dpll_mgr.c+1−1

@@ -2554,7 +2554,7 @@ static void icl_wrpll_params_populate(struct skl_wrpll_params *params, · 2553 unmodified lines
2554	static bool	2554	static bool
2555	ehl_combo_pll_div_frac_wa_needed(struct drm_i915_private *i915)	2555	ehl_combo_pll_div_frac_wa_needed(struct drm_i915_private *i915)
2556	{	2556	{
2557	return (((IS_ELKHARTLAKE(i915) \|\| IS_JASPERLAKE(i915)) &&	2557	return ((IS_ELKHARTLAKE(i915) &&
2558	IS_DISPLAY_STEP(i915, STEP_B0, STEP_FOREVER)) \|\|	2558	IS_DISPLAY_STEP(i915, STEP_B0, STEP_FOREVER)) \|\|
2559	IS_TIGERLAKE(i915) \|\| IS_ALDERLAKE_S(i915) \|\| IS_ALDERLAKE_P(i915)) &&	2559	IS_TIGERLAKE(i915) \|\| IS_ALDERLAKE_S(i915) \|\| IS_ALDERLAKE_P(i915)) &&
2560	i915->display.dpll.ref_clks.nssc == 38400;	2560	i915->display.dpll.ref_clks.nssc == 38400;

drivers/gpu/drm/i915/display/intel_drrs.c+11−3

 	return str[drrs_type];
 }
+bool intel_cpu_transcoder_has_drrs(struct drm_i915_private *i915,
+				   enum transcoder cpu_transcoder)
+{
+	if (HAS_DOUBLE_BUFFERED_M_N(i915))
+		return true;
+	return intel_cpu_transcoder_has_m2_n2(i915, cpu_transcoder);
+}
 static void
 intel_drrs_set_refresh_rate_pipeconf(struct intel_crtc *crtc,
 				     enum drrs_refresh_rate refresh_rate)
 	mutex_lock(&crtc->drrs.mutex);
 	seq_printf(m, "DRRS capable: %s\n",
-		   str_yes_no(crtc_state->has_drrs ||
+		   str_yes_no(intel_cpu_transcoder_has_drrs(i915,
-			      HAS_DOUBLE_BUFFERED_M_N(i915) ||
+							    crtc_state->cpu_transcoder)));
-			      intel_cpu_transcoder_has_m2_n2(i915, crtc_state->cpu_transcoder)));
 	seq_printf(m, "DRRS enabled: %s\n",
 		   str_yes_no(crtc_state->has_drrs));

drivers/gpu/drm/i915/display/intel_drrs.h+3−0

 #include <linux/types.h>
 enum drrs_type;
+enum transcoder;
 struct drm_i915_private;
 struct intel_atomic_state;
 struct intel_crtc;
 struct intel_crtc_state;
 struct intel_connector;
+bool intel_cpu_transcoder_has_drrs(struct drm_i915_private *i915,
+				   enum transcoder cpu_transcoder);
 const char *intel_drrs_type_str(enum drrs_type drrs_type);
 bool intel_drrs_is_active(struct intel_crtc *crtc);
 void intel_drrs_activate(const struct intel_crtc_state *crtc_state);

drivers/gpu/drm/i915/display/intel_dsb.c+14−0

@@ -340,6 +340,17 @@ static int intel_dsb_dewake_scanline(const struct intel_crtc_state *crtc_state) · 339 unmodified lines
340	return max(0, vblank_start - intel_usecs_to_scanlines(adjusted_mode, latency));	340	return max(0, vblank_start - intel_usecs_to_scanlines(adjusted_mode, latency));
341	}	341	}
342		342
		343	static u32 dsb_chicken(struct intel_crtc *crtc)
		344	{
		345	if (crtc->mode_flags & I915_MODE_FLAG_VRR)
		346	return DSB_CTRL_WAIT_SAFE_WINDOW \|
		347	DSB_CTRL_NO_WAIT_VBLANK \|
		348	DSB_INST_WAIT_SAFE_WINDOW \|
		349	DSB_INST_NO_WAIT_VBLANK;
		350	else
		351	return 0;
		352	}
		353
343	static void _intel_dsb_commit(struct intel_dsb *dsb, u32 ctrl,	354	static void _intel_dsb_commit(struct intel_dsb *dsb, u32 ctrl,
344	int dewake_scanline)	355	int dewake_scanline)
345	{	356	{
@@ -361,6 +372,9 @@ static void _intel_dsb_commit(struct intel_dsb *dsb, u32 ctrl, · 15 unmodified lines
361	intel_de_write_fw(dev_priv, DSB_CTRL(pipe, dsb->id),	372	intel_de_write_fw(dev_priv, DSB_CTRL(pipe, dsb->id),
362	ctrl \| DSB_ENABLE);	373	ctrl \| DSB_ENABLE);
363		374
		375	intel_de_write_fw(dev_priv, DSB_CHICKEN(pipe, dsb->id),
		376	dsb_chicken(crtc));
		377
364	intel_de_write_fw(dev_priv, DSB_HEAD(pipe, dsb->id),	378	intel_de_write_fw(dev_priv, DSB_HEAD(pipe, dsb->id),
365	intel_dsb_buffer_ggtt_offset(&dsb->dsb_buf));	379	intel_dsb_buffer_ggtt_offset(&dsb->dsb_buf));
366		380

drivers/gpu/drm/i915/display/intel_fb_pin.c+10−0

@@ -255,6 +255,16 @@ int intel_plane_pin_fb(struct intel_plane_state *plane_state) · 254 unmodified lines
255	return PTR_ERR(vma);	255	return PTR_ERR(vma);
256		256
257	plane_state->ggtt_vma = vma;	257	plane_state->ggtt_vma = vma;
		258
		259	/*
		260	* Pre-populate the dma address before we enter the vblank
		261	* evade critical section as i915_gem_object_get_dma_address()
		262	* will trigger might_sleep() even if it won't actually sleep,
		263	* which is the case when the fb has already been pinned.
		264	*/
		265	if (phys_cursor)
		266	plane_state->phys_dma_addr =
		267	i915_gem_object_get_dma_address(intel_fb_obj(fb), 0);
258	} else {	268	} else {
259	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);	269	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
260		270

drivers/gpu/drm/i915/display/intel_sdvo.c+0−4

 	struct intel_crtc *crtc = to_intel_crtc(old_crtc_state->uapi.crtc);
 	u32 temp;
-	encoder->audio_disable(encoder, old_crtc_state, conn_state);
 	intel_sdvo_set_active_outputs(intel_sdvo, 0);
 	if (0)
 		intel_sdvo_set_encoder_power_state(intel_sdvo,
 		intel_sdvo_set_encoder_power_state(intel_sdvo,
 						   DRM_MODE_DPMS_ON);
 	intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo_connector->output_flag);
-	encoder->audio_enable(encoder, pipe_config, conn_state);
 }
 static enum drm_mode_status

drivers/gpu/drm/i915/display/intel_vrr.c+4−3

 	enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 	/*
-	 * TRANS_SET_CONTEXT_LATENCY with VRR enabled
+	 * This bit seems to have two meanings depending on the platform:
-	 * requires this chicken bit on ADL/DG2.
+	 * TGL: generate VRR "safe window" for DSB vblank waits
+	 * ADL/DG2: make TRANS_SET_CONTEXT_LATENCY effective with VRR
 	 */
-	if (DISPLAY_VER(dev_priv) == 13)
+	if (IS_DISPLAY_VER(dev_priv, 12, 13))
 		intel_de_rmw(dev_priv, CHICKEN_TRANS(cpu_transcoder),
 			     0, PIPE_VBLANK_WITH_DELAY);

drivers/gpu/drm/i915/display/skl_universal_plane.c+3−0

@@ -2295,6 +2295,9 @@ static u8 skl_get_plane_caps(struct drm_i915_private *i915, · 2294 unmodified lines
2295	if (HAS_4TILE(i915))	2295	if (HAS_4TILE(i915))
2296	caps \|= INTEL_PLANE_CAP_TILING_4;	2296	caps \|= INTEL_PLANE_CAP_TILING_4;
2297		2297
		2298	if (!IS_ENABLED(I915) && !HAS_FLAT_CCS(i915))
		2299	return caps;
		2300
2298	if (skl_plane_has_rc_ccs(i915, pipe, plane_id)) {	2301	if (skl_plane_has_rc_ccs(i915, pipe, plane_id)) {
2299	caps \|= INTEL_PLANE_CAP_CCS_RC;	2302	caps \|= INTEL_PLANE_CAP_CCS_RC;
2300	if (DISPLAY_VER(i915) >= 12)	2303	if (DISPLAY_VER(i915) >= 12)

drivers/gpu/drm/i915/gt/intel_engine_pm.c+0−3

@@ -279,9 +279,6 @@ static int __engine_park(struct intel_wakeref *wf) · 278 unmodified lines
279	intel_engine_park_heartbeat(engine);	279	intel_engine_park_heartbeat(engine);
280	intel_breadcrumbs_park(engine->breadcrumbs);	280	intel_breadcrumbs_park(engine->breadcrumbs);
281		281
282	/* Must be reset upon idling, or we may miss the busy wakeup. */
283	GEM_BUG_ON(engine->sched_engine->queue_priority_hint != INT_MIN);
284
285	if (engine->park)	282	if (engine->park)
286	engine->park(engine);	283	engine->park(engine);
287		284

drivers/gpu/drm/i915/gt/intel_execlists_submission.c+3−0

@@ -3272,6 +3272,9 @@ static void execlists_park(struct intel_engine_cs *engine) · 3271 unmodified lines
3272	{	3272	{
3273	cancel_timer(&engine->execlists.timer);	3273	cancel_timer(&engine->execlists.timer);
3274	cancel_timer(&engine->execlists.preempt);	3274	cancel_timer(&engine->execlists.preempt);
		3275
		3276	/* Reset upon idling, or we may delay the busy wakeup. */
		3277	WRITE_ONCE(engine->sched_engine->queue_priority_hint, INT_MIN);
3275	}	3278	}
3276		3279
3277	static void add_to_engine(struct i915_request *rq)	3280	static void add_to_engine(struct i915_request *rq)

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

@@ -1653,6 +1653,7 @@ static void · 1652 unmodified lines
1653	xelpg_gt_workarounds_init(struct intel_gt gt, struct i915_wa_list wal)	1653	xelpg_gt_workarounds_init(struct intel_gt gt, struct i915_wa_list wal)
1654	{	1654	{
1655	/* Wa_14018575942 / Wa_18018781329 */	1655	/* Wa_14018575942 / Wa_18018781329 */
		1656	wa_mcr_write_or(wal, RENDER_MOD_CTRL, FORCE_MISS_FTLB);
1656	wa_mcr_write_or(wal, COMP_MOD_CTRL, FORCE_MISS_FTLB);	1657	wa_mcr_write_or(wal, COMP_MOD_CTRL, FORCE_MISS_FTLB);
1657		1658
1658	/* Wa_22016670082 */	1659	/* Wa_22016670082 */

drivers/gpu/drm/i915/i915_driver.c+1−1

@@ -800,7 +800,7 @@ int i915_driver_probe(struct pci_dev pdev, const struct pci_device_id ent) · 799 unmodified lines
800	goto out_cleanup_modeset2;	800	goto out_cleanup_modeset2;
801		801
802	ret = intel_pxp_init(i915);	802	ret = intel_pxp_init(i915);
803	if (ret != -ENODEV)	803	if (ret && ret != -ENODEV)
804	drm_dbg(&i915->drm, "pxp init failed with %d\n", ret);	804	drm_dbg(&i915->drm, "pxp init failed with %d\n", ret);
805		805
806	ret = intel_display_driver_probe(i915);	806	ret = intel_display_driver_probe(i915);

drivers/gpu/drm/i915/i915_hwmon.c+19−18

 	struct intel_uncore *uncore = ddat->uncore;
 	intel_wakeref_t wakeref;
-	mutex_lock(&hwmon->hwmon_lock);
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		mutex_lock(&hwmon->hwmon_lock);
-	with_intel_runtime_pm(uncore->rpm, wakeref)
 		intel_uncore_rmw(uncore, reg, clear, set);
-	mutex_unlock(&hwmon->hwmon_lock);
+		mutex_unlock(&hwmon->hwmon_lock);
+	}
 }
 /*
 	else
 		rgaddr = hwmon->rg.energy_status_all;
-	mutex_lock(&hwmon->hwmon_lock);
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		mutex_lock(&hwmon->hwmon_lock);
-	with_intel_runtime_pm(uncore->rpm, wakeref)
 		reg_val = intel_uncore_read(uncore, rgaddr);
-	if (reg_val >= ei->reg_val_prev)
+		if (reg_val >= ei->reg_val_prev)
-		ei->accum_energy += reg_val - ei->reg_val_prev;
+			ei->accum_energy += reg_val - ei->reg_val_prev;
-	else
+		else
-		ei->accum_energy += UINT_MAX - ei->reg_val_prev + reg_val;
+			ei->accum_energy += UINT_MAX - ei->reg_val_prev + reg_val;
-	ei->reg_val_prev = reg_val;
+		ei->reg_val_prev = reg_val;
-	*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
+		*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
-				  hwmon->scl_shift_energy);
+					  hwmon->scl_shift_energy);
-	mutex_unlock(&hwmon->hwmon_lock);
+		mutex_unlock(&hwmon->hwmon_lock);
+	}
 }
 static ssize_t
 	/* Block waiting for GuC reset to complete when needed */
 	for (;;) {
+		wakeref = intel_runtime_pm_get(ddat->uncore->rpm);
 		mutex_lock(&hwmon->hwmon_lock);
 		prepare_to_wait(&ddat->waitq, &wait, TASK_INTERRUPTIBLE);
 		}
 		mutex_unlock(&hwmon->hwmon_lock);
+		intel_runtime_pm_put(ddat->uncore->rpm, wakeref);
 		schedule();
 	}
 	finish_wait(&ddat->waitq, &wait);
 	if (ret)
-		goto unlock;
+		goto exit;
-	wakeref = intel_runtime_pm_get(ddat->uncore->rpm);
 	/* Disable PL1 limit and verify, because the limit cannot be disabled on all platforms */
 	if (val == PL1_DISABLE) {
 	intel_uncore_rmw(ddat->uncore, hwmon->rg.pkg_rapl_limit,
 			 PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, nval);
 exit:
-	intel_runtime_pm_put(ddat->uncore->rpm, wakeref);
-unlock:
 	mutex_unlock(&hwmon->hwmon_lock);
+	intel_runtime_pm_put(ddat->uncore->rpm, wakeref);
 	return ret;
 }

drivers/gpu/drm/i915/i915_memcpy.c+2−0

@@ -25,6 +25,8 @@ · 24 unmodified lines
25	#include <linux/kernel.h>	25	#include <linux/kernel.h>
26	#include <linux/string.h>	26	#include <linux/string.h>
27	#include <linux/cpufeature.h>	27	#include <linux/cpufeature.h>
		28	#include <linux/bug.h>
		29	#include <linux/build_bug.h>
28	#include <asm/fpu/api.h>	30	#include <asm/fpu/api.h>
29		31
30	#include "i915_memcpy.h"	32	#include "i915_memcpy.h"

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

@@ -4599,7 +4599,7 @@ · 4598 unmodified lines
4599	#define MTL_CHICKEN_TRANS(trans) _MMIO_TRANS((trans), \	4599	#define MTL_CHICKEN_TRANS(trans) _MMIO_TRANS((trans), \
4600	_MTL_CHICKEN_TRANS_A, \	4600	_MTL_CHICKEN_TRANS_A, \
4601	_MTL_CHICKEN_TRANS_B)	4601	_MTL_CHICKEN_TRANS_B)
4602	#define PIPE_VBLANK_WITH_DELAY REG_BIT(31) /* ADL/DG2 */	4602	#define PIPE_VBLANK_WITH_DELAY REG_BIT(31) /* tgl+ */
4603	#define SKL_UNMASK_VBL_TO_PIPE_IN_SRD REG_BIT(30) /* skl+ */	4603	#define SKL_UNMASK_VBL_TO_PIPE_IN_SRD REG_BIT(30) /* skl+ */
4604	#define HSW_FRAME_START_DELAY_MASK REG_GENMASK(28, 27)	4604	#define HSW_FRAME_START_DELAY_MASK REG_GENMASK(28, 27)
4605	#define HSW_FRAME_START_DELAY(x) REG_FIELD_PREP(HSW_FRAME_START_DELAY_MASK, x)	4605	#define HSW_FRAME_START_DELAY(x) REG_FIELD_PREP(HSW_FRAME_START_DELAY_MASK, x)

drivers/gpu/drm/i915/i915_vma.c+43−7

 #include "gt/intel_engine.h"
 #include "gt/intel_engine_heartbeat.h"
 #include "gt/intel_gt.h"
+#include "gt/intel_gt_pm.h"
 #include "gt/intel_gt_requests.h"
 #include "gt/intel_tlb.h"
 static int __i915_vma_active(struct i915_active *ref)
 {
-	return i915_vma_tryget(active_to_vma(ref)) ? 0 : -ENOENT;
+	struct i915_vma *vma = active_to_vma(ref);
+	if (!i915_vma_tryget(vma))
+		return -ENOENT;
+	/*
+	 * Exclude global GTT VMA from holding a GT wakeref
+	 * while active, otherwise GPU never goes idle.
+	 */
+	if (!i915_vma_is_ggtt(vma)) {
+		/*
+		 * Since we and our _retire() counterpart can be
+		 * called asynchronously, storing a wakeref tracking
+		 * handle inside struct i915_vma is not safe, and
+		 * there is no other good place for that.  Hence,
+		 * use untracked variants of intel_gt_pm_get/put().
+		 */
+		intel_gt_pm_get_untracked(vma->vm->gt);
+	}
+	return 0;
 }
 static void __i915_vma_retire(struct i915_active *ref)
 {
-	i915_vma_put(active_to_vma(ref));
+	struct i915_vma *vma = active_to_vma(ref);
+	if (!i915_vma_is_ggtt(vma)) {
+		/*
+		 * Since we can be called from atomic contexts,
+		 * use an async variant of intel_gt_pm_put().
+		 */
+		intel_gt_pm_put_async_untracked(vma->vm->gt);
+	}
+	i915_vma_put(vma);
 }
 static struct i915_vma *
 	struct i915_vma_work *work = NULL;
 	struct dma_fence *moving = NULL;
 	struct i915_vma_resource *vma_res = NULL;
-	intel_wakeref_t wakeref = 0;
+	intel_wakeref_t wakeref;
 	unsigned int bound;
 	int err;
 	if (err)
 		return err;
-	if (flags & PIN_GLOBAL)
+	/*
-		wakeref = intel_runtime_pm_get(&vma->vm->i915->runtime_pm);
+	 * In case of a global GTT, we must hold a runtime-pm wakeref
+	 * while global PTEs are updated.  In other cases, we hold
+	 * the rpm reference while the VMA is active.  Since runtime
+	 * resume may require allocations, which are forbidden inside
+	 * vm->mutex, get the first rpm wakeref outside of the mutex.
+	 */
+	wakeref = intel_runtime_pm_get(&vma->vm->i915->runtime_pm);
 	if (flags & vma->vm->bind_async_flags) {
 		/* lock VM */
 	if (work)
 		dma_fence_work_commit_imm(&work->base);
 err_rpm:
-	if (wakeref)
+	intel_runtime_pm_put(&vma->vm->i915->runtime_pm, wakeref);
-		intel_runtime_pm_put(&vma->vm->i915->runtime_pm, wakeref);
 	if (moving)
 		dma_fence_put(moving);

drivers/gpu/drm/nouveau/nouveau_dmem.c+6−6

@@ -378,9 +378,9 @@ nouveau_dmem_evict_chunk(struct nouveau_dmem_chunk *chunk) · 377 unmodified lines
378	dma_addr_t *dma_addrs;	378	dma_addr_t *dma_addrs;
379	struct nouveau_fence *fence;	379	struct nouveau_fence *fence;
380		380
381	src_pfns = kcalloc(npages, sizeof(*src_pfns), GFP_KERNEL);	381	src_pfns = kvcalloc(npages, sizeof(*src_pfns), GFP_KERNEL \| __GFP_NOFAIL);
382	dst_pfns = kcalloc(npages, sizeof(*dst_pfns), GFP_KERNEL);	382	dst_pfns = kvcalloc(npages, sizeof(*dst_pfns), GFP_KERNEL \| __GFP_NOFAIL);
383	dma_addrs = kcalloc(npages, sizeof(*dma_addrs), GFP_KERNEL);	383	dma_addrs = kvcalloc(npages, sizeof(*dma_addrs), GFP_KERNEL \| __GFP_NOFAIL);
384		384
385	migrate_device_range(src_pfns, chunk->pagemap.range.start >> PAGE_SHIFT,	385	migrate_device_range(src_pfns, chunk->pagemap.range.start >> PAGE_SHIFT,
386	npages);	386	npages);
@@ -406,11 +406,11 @@ nouveau_dmem_evict_chunk(struct nouveau_dmem_chunk *chunk) · 19 unmodified lines
406	migrate_device_pages(src_pfns, dst_pfns, npages);	406	migrate_device_pages(src_pfns, dst_pfns, npages);
407	nouveau_dmem_fence_done(&fence);	407	nouveau_dmem_fence_done(&fence);
408	migrate_device_finalize(src_pfns, dst_pfns, npages);	408	migrate_device_finalize(src_pfns, dst_pfns, npages);
409	kfree(src_pfns);	409	kvfree(src_pfns);
410	kfree(dst_pfns);	410	kvfree(dst_pfns);
411	for (i = 0; i < npages; i++)	411	for (i = 0; i < npages; i++)
412	dma_unmap_page(chunk->drm->dev->dev, dma_addrs[i], PAGE_SIZE, DMA_BIDIRECTIONAL);	412	dma_unmap_page(chunk->drm->dev->dev, dma_addrs[i], PAGE_SIZE, DMA_BIDIRECTIONAL);
413	kfree(dma_addrs);	413	kvfree(dma_addrs);
414	}	414	}
415		415
416	void	416	void

drivers/gpu/drm/qxl/qxl_cmd.c+0−2

 {
 	uint32_t handle;
 	int idr_ret;
-	int count = 0;
 again:
 	idr_preload(GFP_ATOMIC);
 	spin_lock(&qdev->surf_id_idr_lock);
 	handle = idr_ret;
 	if (handle >= qdev->rom->n_surfaces) {
-		count++;
 		spin_lock(&qdev->surf_id_idr_lock);
 		idr_remove(&qdev->surf_id_idr, handle);
 		spin_unlock(&qdev->surf_id_idr_lock);

drivers/gpu/drm/qxl/qxl_ioctl.c+1−3

 	struct qxl_release *release;
 	struct qxl_bo *cmd_bo;
 	void *fb_cmd;
-	int i, ret, num_relocs;
+	int i, ret;
 	int unwritten;
 	switch (cmd->type) {
 	}
 	/* fill out reloc info structs */
-	num_relocs = 0;
 	for (i = 0; i < cmd->relocs_num; ++i) {
 		struct drm_qxl_reloc reloc;
 		struct drm_qxl_reloc __user *u = u64_to_user_ptr(cmd->relocs);
 			reloc_info[i].dst_bo = cmd_bo;
 			reloc_info[i].dst_offset = reloc.dst_offset + release->release_offset;
 		}
-		num_relocs++;
 		/* reserve and validate the reloc dst bo */
 		if (reloc.reloc_type == QXL_RELOC_TYPE_BO || reloc.src_handle) {

drivers/gpu/drm/rockchip/rockchip_vop2_reg.c+0−2

 static const uint32_t formats_cluster[] = {
 	DRM_FORMAT_XRGB2101010,
-	DRM_FORMAT_ARGB2101010,
 	DRM_FORMAT_XBGR2101010,
-	DRM_FORMAT_ABGR2101010,
 	DRM_FORMAT_XRGB8888,
 	DRM_FORMAT_ARGB8888,
 	DRM_FORMAT_XBGR8888,

drivers/gpu/drm/scheduler/sched_entity.c+9−3

 	entity->guilty = guilty;
 	entity->num_sched_list = num_sched_list;
 	entity->priority = priority;
+	/*
+	 * It's perfectly valid to initialize an entity without having a valid
+	 * scheduler attached. It's just not valid to use the scheduler before it
+	 * is initialized itself.
+	 */
 	entity->sched_list = num_sched_list > 1 ? sched_list : NULL;
 	RCU_INIT_POINTER(entity->last_scheduled, NULL);
 	RB_CLEAR_NODE(&entity->rb_tree_node);
-	if (!sched_list[0]->sched_rq) {
+	if (num_sched_list && !sched_list[0]->sched_rq) {
-		/* Warn drivers not to do this and to fix their DRM
+		/* Since every entry covered by num_sched_list
-		 * calling order.
+		 * should be non-NULL and therefore we warn drivers
+		 * not to do this and to fix their DRM calling order.
 		 */
 		pr_warn("%s: called with uninitialized scheduler\n", __func__);
 	} else if (num_sched_list) {

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c+9−6

@@ -1444,12 +1444,15 @@ static void vmw_debugfs_resource_managers_init(struct vmw_private *vmw) · 1443 unmodified lines
1444	root, "system_ttm");	1444	root, "system_ttm");
1445	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, TTM_PL_VRAM),	1445	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, TTM_PL_VRAM),
1446	root, "vram_ttm");	1446	root, "vram_ttm");
1447	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_GMR),	1447	if (vmw->has_gmr)
1448	root, "gmr_ttm");	1448	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_GMR),
1449	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_MOB),	1449	root, "gmr_ttm");
1450	root, "mob_ttm");	1450	if (vmw->has_mob) {
1451	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_SYSTEM),	1451	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_MOB),
1452	root, "system_mob_ttm");	1452	root, "mob_ttm");
		1453	ttm_resource_manager_create_debugfs(ttm_manager_type(&vmw->bdev, VMW_PL_SYSTEM),
		1454	root, "system_mob_ttm");
		1455	}
1453	}	1456	}
1454		1457
1455	static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,	1458	static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,

drivers/gpu/drm/xe/Makefile+2−2

@@ -172,8 +172,8 @@ subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ · 171 unmodified lines
172	-Ddrm_i915_gem_object=xe_bo \	172	-Ddrm_i915_gem_object=xe_bo \
173	-Ddrm_i915_private=xe_device	173	-Ddrm_i915_private=xe_device
174		174
175	CFLAGS_i915-display/intel_fbdev.o = $(call cc-disable-warning, override-init)	175	CFLAGS_i915-display/intel_fbdev.o = -Wno-override-init
176	CFLAGS_i915-display/intel_display_device.o = $(call cc-disable-warning, override-init)	176	CFLAGS_i915-display/intel_display_device.o = -Wno-override-init
177		177
178	# Rule to build SOC code shared with i915	178	# Rule to build SOC code shared with i915
179	$(obj)/i915-soc/%.o: $(srctree)/drivers/gpu/drm/i915/soc/%.c FORCE	179	$(obj)/i915-soc/%.o: $(srctree)/drivers/gpu/drm/i915/soc/%.c FORCE

drivers/gpu/drm/xe/xe_bo.c+9−50

@@ -144,9 +144,6 @@ static void try_add_system(struct xe_device xe, struct xe_bo bo, · 143 unmodified lines
144	.mem_type = XE_PL_TT,	144	.mem_type = XE_PL_TT,
145	};	145	};
146	*c += 1;	146	*c += 1;
147
148	if (bo->props.preferred_mem_type == XE_BO_PROPS_INVALID)
149	bo->props.preferred_mem_type = XE_PL_TT;
150	}	147	}
151	}	148	}
152		149
@@ -181,25 +178,15 @@ static void add_vram(struct xe_device xe, struct xe_bo bo, · 28 unmodified lines
181	}	178	}
182	places[*c] = place;	179	places[*c] = place;
183	*c += 1;	180	*c += 1;
184
185	if (bo->props.preferred_mem_type == XE_BO_PROPS_INVALID)
186	bo->props.preferred_mem_type = mem_type;
187	}	181	}
188		182
189	static void try_add_vram(struct xe_device xe, struct xe_bo bo,	183	static void try_add_vram(struct xe_device xe, struct xe_bo bo,
190	u32 bo_flags, u32 *c)	184	u32 bo_flags, u32 *c)
191	{	185	{
192	if (bo->props.preferred_gt == XE_GT1) {	186	if (bo_flags & XE_BO_CREATE_VRAM0_BIT)
193	if (bo_flags & XE_BO_CREATE_VRAM1_BIT)	187	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM0, c);
194	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM1, c);	188	if (bo_flags & XE_BO_CREATE_VRAM1_BIT)
195	if (bo_flags & XE_BO_CREATE_VRAM0_BIT)	189	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM1, c);
196	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM0, c);
197	} else {
198	if (bo_flags & XE_BO_CREATE_VRAM0_BIT)
199	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM0, c);
200	if (bo_flags & XE_BO_CREATE_VRAM1_BIT)
201	add_vram(xe, bo, bo->placements, bo_flags, XE_PL_VRAM1, c);
202	}
203	}	190	}
204		191
205	static void try_add_stolen(struct xe_device xe, struct xe_bo bo,	192	static void try_add_stolen(struct xe_device xe, struct xe_bo bo,
@@ -223,17 +210,8 @@ static int __xe_bo_placement_for_flags(struct xe_device xe, struct xe_bo bo, · 17 unmodified lines
223	{	210	{
224	u32 c = 0;	211	u32 c = 0;
225		212
226	bo->props.preferred_mem_type = XE_BO_PROPS_INVALID;	213	try_add_vram(xe, bo, bo_flags, &c);
227		214	try_add_system(xe, bo, bo_flags, &c);
228	/* The order of placements should indicate preferred location */
229
230	if (bo->props.preferred_mem_class == DRM_XE_MEM_REGION_CLASS_SYSMEM) {
231	try_add_system(xe, bo, bo_flags, &c);
232	try_add_vram(xe, bo, bo_flags, &c);
233	} else {
234	try_add_vram(xe, bo, bo_flags, &c);
235	try_add_system(xe, bo, bo_flags, &c);
236	}
237	try_add_stolen(xe, bo, bo_flags, &c);	215	try_add_stolen(xe, bo, bo_flags, &c);
238		216
239	if (!c)	217	if (!c)
@@ -1126,13 +1104,6 @@ static void xe_gem_object_close(struct drm_gem_object *obj, · 886 unmodified lines
1126	}	1104	}
1127	}	1105	}
1128		1106
1129	static bool should_migrate_to_system(struct xe_bo *bo)
1130	{
1131	struct xe_device *xe = xe_bo_device(bo);
1132
1133	return xe_device_in_fault_mode(xe) && bo->props.cpu_atomic;
1134	}
1135
1136	static vm_fault_t xe_gem_fault(struct vm_fault *vmf)	1107	static vm_fault_t xe_gem_fault(struct vm_fault *vmf)
1137	{	1108	{
1138	struct ttm_buffer_object *tbo = vmf->vma->vm_private_data;	1109	struct ttm_buffer_object *tbo = vmf->vma->vm_private_data;
@@ -1141,7 +1112,7 @@ static vm_fault_t xe_gem_fault(struct vm_fault *vmf) · 2 unmodified lines
1141	struct xe_bo *bo = ttm_to_xe_bo(tbo);	1112	struct xe_bo *bo = ttm_to_xe_bo(tbo);
1142	bool needs_rpm = bo->flags & XE_BO_CREATE_VRAM_MASK;	1113	bool needs_rpm = bo->flags & XE_BO_CREATE_VRAM_MASK;
1143	vm_fault_t ret;	1114	vm_fault_t ret;
1144	int idx, r = 0;	1115	int idx;
1145		1116
1146	if (needs_rpm)	1117	if (needs_rpm)
1147	xe_device_mem_access_get(xe);	1118	xe_device_mem_access_get(xe);
@@ -1153,17 +1124,8 @@ static vm_fault_t xe_gem_fault(struct vm_fault *vmf) · 5 unmodified lines
1153	if (drm_dev_enter(ddev, &idx)) {	1124	if (drm_dev_enter(ddev, &idx)) {
1154	trace_xe_bo_cpu_fault(bo);	1125	trace_xe_bo_cpu_fault(bo);
1155		1126
1156	if (should_migrate_to_system(bo)) {	1127	ret = ttm_bo_vm_fault_reserved(vmf, vmf->vma->vm_page_prot,
1157	r = xe_bo_migrate(bo, XE_PL_TT);	1128	TTM_BO_VM_NUM_PREFAULT);
1158	if (r == -EBUSY \|\| r == -ERESTARTSYS \|\| r == -EINTR)
1159	ret = VM_FAULT_NOPAGE;
1160	else if (r)
1161	ret = VM_FAULT_SIGBUS;
1162	}
1163	if (!ret)
1164	ret = ttm_bo_vm_fault_reserved(vmf,
1165	vmf->vma->vm_page_prot,
1166	TTM_BO_VM_NUM_PREFAULT);
1167	drm_dev_exit(idx);	1129	drm_dev_exit(idx);
1168	} else {	1130	} else {
1169	ret = ttm_bo_vm_dummy_page(vmf, vmf->vma->vm_page_prot);	1131	ret = ttm_bo_vm_dummy_page(vmf, vmf->vma->vm_page_prot);
@@ -1291,9 +1253,6 @@ struct xe_bo ___xe_bo_create_locked(struct xe_device xe, struct xe_bo *bo, · 121 unmodified lines
1291	bo->flags = flags;	1253	bo->flags = flags;
1292	bo->cpu_caching = cpu_caching;	1254	bo->cpu_caching = cpu_caching;
1293	bo->ttm.base.funcs = &xe_gem_object_funcs;	1255	bo->ttm.base.funcs = &xe_gem_object_funcs;
1294	bo->props.preferred_mem_class = XE_BO_PROPS_INVALID;
1295	bo->props.preferred_gt = XE_BO_PROPS_INVALID;
1296	bo->props.preferred_mem_type = XE_BO_PROPS_INVALID;
1297	bo->ttm.priority = XE_BO_PRIORITY_NORMAL;	1256	bo->ttm.priority = XE_BO_PRIORITY_NORMAL;
1298	INIT_LIST_HEAD(&bo->pinned_link);	1257	INIT_LIST_HEAD(&bo->pinned_link);
1299	#ifdef CONFIG_PROC_FS	1258	#ifdef CONFIG_PROC_FS

drivers/gpu/drm/xe/xe_bo_types.h+0−19

@@ -56,25 +56,6 @@ struct xe_bo { · 55 unmodified lines
56	*/	56	*/
57	struct list_head client_link;	57	struct list_head client_link;
58	#endif	58	#endif
59	/** @props: BO user controlled properties */
60	struct {
61	/** @preferred_mem: preferred memory class for this BO */
62	s16 preferred_mem_class;
63	/** @prefered_gt: preferred GT for this BO */
64	s16 preferred_gt;
65	/** @preferred_mem_type: preferred memory type */
66	s32 preferred_mem_type;
67	/**
68	* @cpu_atomic: the CPU expects to do atomics operations to
69	* this BO
70	*/
71	bool cpu_atomic;
72	/**
73	* @device_atomic: the device expects to do atomics operations
74	* to this BO
75	*/
76	bool device_atomic;
77	} props;
78	/** @freed: List node for delayed put. */	59	/** @freed: List node for delayed put. */
79	struct llist_node freed;	60	struct llist_node freed;
80	/** @created: Whether the bo has passed initial creation */	61	/** @created: Whether the bo has passed initial creation */

drivers/gpu/drm/xe/xe_device.h+2−2

@@ -58,7 +58,7 @@ static inline struct xe_tile xe_device_get_root_tile(struct xe_device xe) · 57 unmodified lines
58		58
59	static inline struct xe_gt xe_tile_get_gt(struct xe_tile tile, u8 gt_id)	59	static inline struct xe_gt xe_tile_get_gt(struct xe_tile tile, u8 gt_id)
60	{	60	{
61	if (drm_WARN_ON(&tile_to_xe(tile)->drm, gt_id > XE_MAX_GT_PER_TILE))	61	if (drm_WARN_ON(&tile_to_xe(tile)->drm, gt_id >= XE_MAX_GT_PER_TILE))
62	gt_id = 0;	62	gt_id = 0;
63		63
64	return gt_id ? tile->media_gt : tile->primary_gt;	64	return gt_id ? tile->media_gt : tile->primary_gt;
@@ -79,7 +79,7 @@ static inline struct xe_gt xe_device_get_gt(struct xe_device xe, u8 gt_id) · 14 unmodified lines
79	if (MEDIA_VER(xe) >= 13) {	79	if (MEDIA_VER(xe) >= 13) {
80	gt = xe_tile_get_gt(root_tile, gt_id);	80	gt = xe_tile_get_gt(root_tile, gt_id);
81	} else {	81	} else {
82	if (drm_WARN_ON(&xe->drm, gt_id > XE_MAX_TILES_PER_DEVICE))	82	if (drm_WARN_ON(&xe->drm, gt_id >= XE_MAX_TILES_PER_DEVICE))
83	gt_id = 0;	83	gt_id = 0;
84		84
85	gt = xe->tiles[gt_id].primary_gt;	85	gt = xe->tiles[gt_id].primary_gt;

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

@@ -448,7 +448,7 @@ find_hw_engine(struct xe_device *xe, · 447 unmodified lines
448	{	448	{
449	u32 idx;	449	u32 idx;
450		450
451	if (eci.engine_class > ARRAY_SIZE(user_to_xe_engine_class))	451	if (eci.engine_class >= ARRAY_SIZE(user_to_xe_engine_class))
452	return NULL;	452	return NULL;
453		453
454	if (eci.gt_id >= xe->info.gt_count)	454	if (eci.gt_id >= xe->info.gt_count)

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

@@ -1220,7 +1220,7 @@ static int guc_exec_queue_init(struct xe_exec_queue *q) · 1219 unmodified lines
1220	init_waitqueue_head(&ge->suspend_wait);	1220	init_waitqueue_head(&ge->suspend_wait);
1221		1221
1222	timeout = (q->vm && xe_vm_in_lr_mode(q->vm)) ? MAX_SCHEDULE_TIMEOUT :	1222	timeout = (q->vm && xe_vm_in_lr_mode(q->vm)) ? MAX_SCHEDULE_TIMEOUT :
1223	q->sched_props.job_timeout_ms;	1223	msecs_to_jiffies(q->sched_props.job_timeout_ms);
1224	err = xe_sched_init(&ge->sched, &drm_sched_ops, &xe_sched_ops,	1224	err = xe_sched_init(&ge->sched, &drm_sched_ops, &xe_sched_ops,
1225	get_submit_wq(guc),	1225	get_submit_wq(guc),
1226	q->lrc[0].ring.size / MAX_JOB_SIZE_BYTES, 64,	1226	q->lrc[0].ring.size / MAX_JOB_SIZE_BYTES, 64,

drivers/gpu/drm/xe/xe_lrc.c+9−11

 #define REG16(x) \
 	(((x) >> 9) | BIT(7) | BUILD_BUG_ON_ZERO(x >= 0x10000)), \
 	(((x) >> 2) & 0x7f)
-#define END 0
 {
 	const u32 base = hwe->mmio_base;
 	REG16(0x274),
 	REG16(0x270),
-	END
+	0
 };
 static const u8 dg2_xcs_offsets[] = {
 	REG16(0x274),
 	REG16(0x270),
-	END
+	0
 };
 static const u8 gen12_rcs_offsets[] = {
 	REG(0x084),
 	NOP(1),
-	END
+	0
 };
 static const u8 xehp_rcs_offsets[] = {
 	LRI(1, 0),
 	REG(0x0c8),
-	END
+	0
 };
 static const u8 dg2_rcs_offsets[] = {
 	LRI(1, 0),
 	REG(0x0c8),
-	END
+	0
 };
 static const u8 mtl_rcs_offsets[] = {
 	LRI(1, 0),
 	REG(0x0c8),
-	END
+	0
 };
 #define XE2_CTX_COMMON \
 	LRI(1, 0),              /* [0x47] */
 	REG(0x0c8),             /* [0x48] R_PWR_CLK_STATE */
-	END
+	0
 };
 static const u8 xe2_bcs_offsets[] = {
 	REG16(0x200),           /* [0x42] BCS_SWCTRL */
 	REG16(0x204),           /* [0x44] BLIT_CCTL */
-	END
+	0
 };
 static const u8 xe2_xcs_offsets[] = {
 	XE2_CTX_COMMON,
-	END
+	0
 };
-#undef END
 #undef REG16
 #undef REG
 #undef LRI

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

@@ -132,7 +132,7 @@ query_engine_cycles(struct xe_device *xe, · 131 unmodified lines
132	return -EINVAL;	132	return -EINVAL;
133		133
134	eci = &resp.eci;	134	eci = &resp.eci;
135	if (eci->gt_id > XE_MAX_GT_PER_TILE)	135	if (eci->gt_id >= XE_MAX_GT_PER_TILE)
136	return -EINVAL;	136	return -EINVAL;
137		137
138	gt = xe_device_get_gt(xe, eci->gt_id);	138	gt = xe_device_get_gt(xe, eci->gt_id);

drivers/i2c/busses/i2c-i801.c+4−3

 	if (read_write == I2C_SMBUS_READ ||
 	    command == I2C_SMBUS_BLOCK_PROC_CALL) {
-		status = i801_get_block_len(priv);
+		len = i801_get_block_len(priv);
-		if (status < 0)
+		if (len < 0) {
+			status = len;
 			goto out;
+		}
-		len = status;
 		data->block[0] = len;
 		inb_p(SMBHSTCNT(priv));	/* reset the data buffer index */
 		for (i = 0; i < len; i++)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c+25−13

@@ -1139,7 +1139,8 @@ static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid, · 1138 unmodified lines
1139	* requires a breaking update, zero the V bit, write all qwords	1139	* requires a breaking update, zero the V bit, write all qwords
1140	* but 0, then set qword 0	1140	* but 0, then set qword 0
1141	*/	1141	*/
1142	unused_update.data[0] = entry->data[0] & (~STRTAB_STE_0_V);	1142	unused_update.data[0] = entry->data[0] &
		1143	cpu_to_le64(~STRTAB_STE_0_V);
1143	entry_set(smmu, sid, entry, &unused_update, 0, 1);	1144	entry_set(smmu, sid, entry, &unused_update, 0, 1);
1144	entry_set(smmu, sid, entry, target, 1, num_entry_qwords - 1);	1145	entry_set(smmu, sid, entry, target, 1, num_entry_qwords - 1);
1145	entry_set(smmu, sid, entry, target, 0, 1);	1146	entry_set(smmu, sid, entry, target, 0, 1);
@@ -1453,14 +1454,17 @@ static void arm_smmu_make_abort_ste(struct arm_smmu_ste *target) · 307 unmodified lines
1453	FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_ABORT));	1454	FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_ABORT));
1454	}	1455	}
1455		1456
1456	static void arm_smmu_make_bypass_ste(struct arm_smmu_ste *target)	1457	static void arm_smmu_make_bypass_ste(struct arm_smmu_device *smmu,
		1458	struct arm_smmu_ste *target)
1457	{	1459	{
1458	memset(target, 0, sizeof(*target));	1460	memset(target, 0, sizeof(*target));
1459	target->data[0] = cpu_to_le64(	1461	target->data[0] = cpu_to_le64(
1460	STRTAB_STE_0_V \|	1462	STRTAB_STE_0_V \|
1461	FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_BYPASS));	1463	FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_BYPASS));
1462	target->data[1] = cpu_to_le64(	1464
1463	FIELD_PREP(STRTAB_STE_1_SHCFG, STRTAB_STE_1_SHCFG_INCOMING));	1465	if (smmu->features & ARM_SMMU_FEAT_ATTR_TYPES_OVR)
		1466	target->data[1] = cpu_to_le64(FIELD_PREP(STRTAB_STE_1_SHCFG,
		1467	STRTAB_STE_1_SHCFG_INCOMING));
1464	}	1468	}
1465		1469
1466	static void arm_smmu_make_cdtable_ste(struct arm_smmu_ste *target,	1470	static void arm_smmu_make_cdtable_ste(struct arm_smmu_ste *target,
@@ -1523,6 +1527,7 @@ static void arm_smmu_make_s2_domain_ste(struct arm_smmu_ste *target, · 56 unmodified lines
1523	typeof(&pgtbl_cfg->arm_lpae_s2_cfg.vtcr) vtcr =	1527	typeof(&pgtbl_cfg->arm_lpae_s2_cfg.vtcr) vtcr =
1524	&pgtbl_cfg->arm_lpae_s2_cfg.vtcr;	1528	&pgtbl_cfg->arm_lpae_s2_cfg.vtcr;
1525	u64 vtcr_val;	1529	u64 vtcr_val;
		1530	struct arm_smmu_device *smmu = master->smmu;
1526		1531
1527	memset(target, 0, sizeof(*target));	1532	memset(target, 0, sizeof(*target));
1528	target->data[0] = cpu_to_le64(	1533	target->data[0] = cpu_to_le64(
@@ -1531,9 +1536,11 @@ static void arm_smmu_make_s2_domain_ste(struct arm_smmu_ste *target, · 2 unmodified lines
1531		1536
1532	target->data[1] = cpu_to_le64(	1537	target->data[1] = cpu_to_le64(
1533	FIELD_PREP(STRTAB_STE_1_EATS,	1538	FIELD_PREP(STRTAB_STE_1_EATS,
1534	master->ats_enabled ? STRTAB_STE_1_EATS_TRANS : 0) \|	1539	master->ats_enabled ? STRTAB_STE_1_EATS_TRANS : 0));
1535	FIELD_PREP(STRTAB_STE_1_SHCFG,	1540
1536	STRTAB_STE_1_SHCFG_INCOMING));	1541	if (smmu->features & ARM_SMMU_FEAT_ATTR_TYPES_OVR)
		1542	target->data[1] \|= cpu_to_le64(FIELD_PREP(STRTAB_STE_1_SHCFG,
		1543	STRTAB_STE_1_SHCFG_INCOMING));
1537		1544
1538	vtcr_val = FIELD_PREP(STRTAB_STE_2_VTCR_S2T0SZ, vtcr->tsz) \|	1545	vtcr_val = FIELD_PREP(STRTAB_STE_2_VTCR_S2T0SZ, vtcr->tsz) \|
1539	FIELD_PREP(STRTAB_STE_2_VTCR_S2SL0, vtcr->sl) \|	1546	FIELD_PREP(STRTAB_STE_2_VTCR_S2SL0, vtcr->sl) \|
@@ -1560,7 +1567,8 @@ static void arm_smmu_make_s2_domain_ste(struct arm_smmu_ste *target, · 20 unmodified lines
1560	* This can safely directly manipulate the STE memory without a sync sequence	1567	* This can safely directly manipulate the STE memory without a sync sequence
1561	* because the STE table has not been installed in the SMMU yet.	1568	* because the STE table has not been installed in the SMMU yet.
1562	*/	1569	*/
1563	static void arm_smmu_init_initial_stes(struct arm_smmu_ste *strtab,	1570	static void arm_smmu_init_initial_stes(struct arm_smmu_device *smmu,
		1571	struct arm_smmu_ste *strtab,
1564	unsigned int nent)	1572	unsigned int nent)
1565	{	1573	{
1566	unsigned int i;	1574	unsigned int i;
@@ -1569,7 +1577,7 @@ static void arm_smmu_init_initial_stes(struct arm_smmu_ste *strtab, · 2 unmodified lines
1569	if (disable_bypass)	1577	if (disable_bypass)
1570	arm_smmu_make_abort_ste(strtab);	1578	arm_smmu_make_abort_ste(strtab);
1571	else	1579	else
1572	arm_smmu_make_bypass_ste(strtab);	1580	arm_smmu_make_bypass_ste(smmu, strtab);
1573	strtab++;	1581	strtab++;
1574	}	1582	}
1575	}	1583	}
@@ -1597,7 +1605,7 @@ static int arm_smmu_init_l2_strtab(struct arm_smmu_device *smmu, u32 sid) · 21 unmodified lines
1597	return -ENOMEM;	1605	return -ENOMEM;
1598	}	1606	}
1599		1607
1600	arm_smmu_init_initial_stes(desc->l2ptr, 1 << STRTAB_SPLIT);	1608	arm_smmu_init_initial_stes(smmu, desc->l2ptr, 1 << STRTAB_SPLIT);
1601	arm_smmu_write_strtab_l1_desc(strtab, desc);	1609	arm_smmu_write_strtab_l1_desc(strtab, desc);
1602	return 0;	1610	return 0;
1603	}	1611	}
@@ -2637,8 +2645,9 @@ static int arm_smmu_attach_dev_identity(struct iommu_domain *domain, · 1033 unmodified lines
2637	struct device *dev)	2645	struct device *dev)
2638	{	2646	{
2639	struct arm_smmu_ste ste;	2647	struct arm_smmu_ste ste;
		2648	struct arm_smmu_master *master = dev_iommu_priv_get(dev);
2640		2649
2641	arm_smmu_make_bypass_ste(&ste);	2650	arm_smmu_make_bypass_ste(master->smmu, &ste);
2642	return arm_smmu_attach_dev_ste(dev, &ste);	2651	return arm_smmu_attach_dev_ste(dev, &ste);
2643	}	2652	}
2644		2653
@@ -3264,7 +3273,7 @@ static int arm_smmu_init_strtab_linear(struct arm_smmu_device *smmu) · 619 unmodified lines
3264	reg \|= FIELD_PREP(STRTAB_BASE_CFG_LOG2SIZE, smmu->sid_bits);	3273	reg \|= FIELD_PREP(STRTAB_BASE_CFG_LOG2SIZE, smmu->sid_bits);
3265	cfg->strtab_base_cfg = reg;	3274	cfg->strtab_base_cfg = reg;
3266		3275
3267	arm_smmu_init_initial_stes(strtab, cfg->num_l1_ents);	3276	arm_smmu_init_initial_stes(smmu, strtab, cfg->num_l1_ents);
3268	return 0;	3277	return 0;
3269	}	3278	}
3270		3279
@@ -3777,6 +3786,9 @@ static int arm_smmu_device_hw_probe(struct arm_smmu_device *smmu) · 506 unmodified lines
3777	return -ENXIO;	3786	return -ENXIO;
3778	}	3787	}
3779		3788
		3789	if (reg & IDR1_ATTR_TYPES_OVR)
		3790	smmu->features \|= ARM_SMMU_FEAT_ATTR_TYPES_OVR;
		3791
3780	/* Queue sizes, capped to ensure natural alignment */	3792	/* Queue sizes, capped to ensure natural alignment */
3781	smmu->cmdq.q.llq.max_n_shift = min_t(u32, CMDQ_MAX_SZ_SHIFT,	3793	smmu->cmdq.q.llq.max_n_shift = min_t(u32, CMDQ_MAX_SZ_SHIFT,
3782	FIELD_GET(IDR1_CMDQS, reg));	3794	FIELD_GET(IDR1_CMDQS, reg));
@@ -3992,7 +4004,7 @@ static void arm_smmu_rmr_install_bypass_ste(struct arm_smmu_device *smmu) · 209 unmodified lines
3992	* STE table is not programmed to HW, see	4004	* STE table is not programmed to HW, see
3993	* arm_smmu_initial_bypass_stes()	4005	* arm_smmu_initial_bypass_stes()
3994	*/	4006	*/
3995	arm_smmu_make_bypass_ste(	4007	arm_smmu_make_bypass_ste(smmu,
3996	arm_smmu_get_step_for_sid(smmu, rmr->sids[i]));	4008	arm_smmu_get_step_for_sid(smmu, rmr->sids[i]));
3997	}	4009	}
3998	}	4010	}

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h+2−0

 #define IDR1_TABLES_PRESET		(1 << 30)
 #define IDR1_QUEUES_PRESET		(1 << 29)
 #define IDR1_REL			(1 << 28)
+#define IDR1_ATTR_TYPES_OVR		(1 << 27)
 #define IDR1_CMDQS			GENMASK(25, 21)
 #define IDR1_EVTQS			GENMASK(20, 16)
 #define IDR1_PRIQS			GENMASK(15, 11)
 #define ARM_SMMU_FEAT_SVA		(1 << 17)
 #define ARM_SMMU_FEAT_E2H		(1 << 18)
 #define ARM_SMMU_FEAT_NESTING		(1 << 19)
+#define ARM_SMMU_FEAT_ATTR_TYPES_OVR	(1 << 20)
 	u32				features;
 #define ARM_SMMU_OPT_SKIP_PREFETCH	(1 << 0)

drivers/iommu/iommu.c+10−1

 {
 	/* Caller must be a probed driver on dev */
 	struct iommu_group *group = dev->iommu_group;
+	struct group_device *device;
 	void *curr;
 	int ret;
 	if (!group)
 		return -ENODEV;
-	if (!dev_has_iommu(dev) || dev_iommu_ops(dev) != domain->owner)
+	if (!dev_has_iommu(dev) || dev_iommu_ops(dev) != domain->owner ||
+	    pasid == IOMMU_NO_PASID)
 		return -EINVAL;
 	mutex_lock(&group->mutex);
+	for_each_group_device(group, device) {
+		if (pasid >= device->dev->iommu->max_pasids) {
+			ret = -EINVAL;
+			goto out_unlock;
+		}
+	}
 	curr = xa_cmpxchg(&group->pasid_array, pasid, NULL, domain, GFP_KERNEL);
 	if (curr) {
 		ret = xa_err(curr) ? : -EBUSY;

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

@@ -316,7 +316,7 @@ static int armada_370_xp_msi_init(struct device_node *node, · 315 unmodified lines
316	return 0;	316	return 0;
317	}	317	}
318	#else	318	#else
319	static void armada_370_xp_msi_reenable_percpu(void) {}	319	static __maybe_unused void armada_370_xp_msi_reenable_percpu(void) {}
320		320
321	static inline int armada_370_xp_msi_init(struct device_node *node,	321	static inline int armada_370_xp_msi_init(struct device_node *node,
322	phys_addr_t main_int_phys_base)	322	phys_addr_t main_int_phys_base)

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

@@ -4221,7 +4221,7 @@ static int dm_integrity_ctr(struct dm_target ti, unsigned int argc, char *argv · 4220 unmodified lines
4221	} else if (sscanf(opt_string, "sectors_per_bit:%llu%c", &llval, &dummy) == 1) {	4221	} else if (sscanf(opt_string, "sectors_per_bit:%llu%c", &llval, &dummy) == 1) {
4222	log2_sectors_per_bitmap_bit = !llval ? 0 : __ilog2_u64(llval);	4222	log2_sectors_per_bitmap_bit = !llval ? 0 : __ilog2_u64(llval);
4223	} else if (sscanf(opt_string, "bitmap_flush_interval:%u%c", &val, &dummy) == 1) {	4223	} else if (sscanf(opt_string, "bitmap_flush_interval:%u%c", &val, &dummy) == 1) {
4224	if (val >= (uint64_t)UINT_MAX * 1000 / HZ) {	4224	if ((uint64_t)val >= (uint64_t)UINT_MAX * 1000 / HZ) {
4225	r = -EINVAL;	4225	r = -EINVAL;
4226	ti->error = "Invalid bitmap_flush_interval argument";	4226	ti->error = "Invalid bitmap_flush_interval argument";
4227	goto bad;	4227	goto bad;

drivers/md/dm-vdo/murmurhash3.c+8−25

 #include "murmurhash3.h"
+#include <asm/unaligned.h>
 static inline u64 rotl64(u64 x, s8 r)
 {
 	return (x << r) | (x >> (64 - r));
 }
 #define ROTL64(x, y) rotl64(x, y)
-static __always_inline u64 getblock64(const u64 *p, int i)
-{
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-	return p[i];
-#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-	return __builtin_bswap64(p[i]);
-#else
-#error "can't figure out byte order"
-#endif
-}
-static __always_inline void putblock64(u64 *p, int i, u64 value)
-{
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-	p[i] = value;
-#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-	p[i] = __builtin_bswap64(value);
-#else
-#error "can't figure out byte order"
-#endif
-}
 /* Finalization mix - force all bits of a hash block to avalanche */
 	const u64 c1 = 0x87c37b91114253d5LLU;
 	const u64 c2 = 0x4cf5ad432745937fLLU;
+	u64 *hash_out = out;
 	/* body */
 	const u64 *blocks = (const u64 *)(data);
 	int i;
 	for (i = 0; i < nblocks; i++) {
-		u64 k1 = getblock64(blocks, i * 2 + 0);
+		u64 k1 = get_unaligned_le64(&blocks[i * 2]);
-		u64 k2 = getblock64(blocks, i * 2 + 1);
+		u64 k2 = get_unaligned_le64(&blocks[i * 2 + 1]);
 		k1 *= c1;
 		k1 = ROTL64(k1, 31);
 	h1 += h2;
 	h2 += h1;
-	putblock64((u64 *)out, 0, h1);
+	put_unaligned_le64(h1, &hash_out[0]);
-	putblock64((u64 *)out, 1, h2);
+	put_unaligned_le64(h2, &hash_out[1]);
 }

drivers/mmc/core/block.c+2−2

@@ -413,7 +413,7 @@ static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user( · 412 unmodified lines
413	struct mmc_blk_ioc_data *idata;	413	struct mmc_blk_ioc_data *idata;
414	int err;	414	int err;
415		415
416	idata = kmalloc(sizeof(*idata), GFP_KERNEL);	416	idata = kzalloc(sizeof(*idata), GFP_KERNEL);
417	if (!idata) {	417	if (!idata) {
418	err = -ENOMEM;	418	err = -ENOMEM;
419	goto out;	419	goto out;
@@ -488,7 +488,7 @@ static int __mmc_blk_ioctl_cmd(struct mmc_card card, struct mmc_blk_data md, · 68 unmodified lines
488	if (idata->flags & MMC_BLK_IOC_DROP)	488	if (idata->flags & MMC_BLK_IOC_DROP)
489	return 0;	489	return 0;
490		490
491	if (idata->flags & MMC_BLK_IOC_SBC)	491	if (idata->flags & MMC_BLK_IOC_SBC && i > 0)
492	prev_idata = idatas[i - 1];	492	prev_idata = idatas[i - 1];
493		493
494	/*	494	/*

drivers/mmc/host/sdhci-of-dwcmshc.c+17−11

 	return err;
 }
+static void dwcmshc_disable_card_clk(struct sdhci_host *host)
+{
+	u16 ctrl;
+	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+	if (ctrl & SDHCI_CLOCK_CARD_EN) {
+		ctrl &= ~SDHCI_CLOCK_CARD_EN;
+		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
+	}
+}
 static void dwcmshc_remove(struct platform_device *pdev)
 {
 	struct sdhci_host *host = platform_get_drvdata(pdev);
 	struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 	struct rk35xx_priv *rk_priv = priv->priv;
+	pm_runtime_get_sync(&pdev->dev);
+	pm_runtime_disable(&pdev->dev);
+	pm_runtime_put_noidle(&pdev->dev);
 	sdhci_remove_host(host, 0);
+	dwcmshc_disable_card_clk(host);
 	clk_disable_unprepare(pltfm_host->clk);
 	clk_disable_unprepare(priv->bus_clk);
 	if (rk_priv)
 	}
 }
-static void dwcmshc_disable_card_clk(struct sdhci_host *host)
-{
-	u16 ctrl;
-	ctrl = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
-	if (ctrl & SDHCI_CLOCK_CARD_EN) {
-		ctrl &= ~SDHCI_CLOCK_CARD_EN;
-		sdhci_writew(host, ctrl, SDHCI_CLOCK_CONTROL);
-	}
-}
 static int dwcmshc_runtime_suspend(struct device *dev)
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);

drivers/mmc/host/sdhci-omap.c+3−0

@@ -1439,6 +1439,9 @@ static int __maybe_unused sdhci_omap_runtime_suspend(struct device *dev) · 1438 unmodified lines
1439	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);	1439	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1440	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);	1440	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
1441		1441
		1442	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
		1443	mmc_retune_needed(host->mmc);
		1444
1442	if (omap_host->con != -EINVAL)	1445	if (omap_host->con != -EINVAL)
1443	sdhci_runtime_suspend_host(host);	1446	sdhci_runtime_suspend_host(host);
1444		1447

drivers/net/dsa/mt7530.c+3−2

 		     SYS_CTRL_PHY_RST | SYS_CTRL_SW_RST |
 		     SYS_CTRL_REG_RST);
-	mt7530_pll_setup(priv);
 	/* Lower Tx driving for TRGMII path */
 	for (i = 0; i < NUM_TRGMII_CTRL; i++)
 		mt7530_write(priv, MT7530_TRGMII_TD_ODT(i),
 	val |= MHWTRAP_MANUAL;
 	mt7530_write(priv, MT7530_MHWTRAP, val);
+	if ((val & HWTRAP_XTAL_MASK) == HWTRAP_XTAL_40MHZ)
+		mt7530_pll_setup(priv);
 	mt753x_trap_frames(priv);
 	/* Enable and reset MIB counters */

drivers/net/ethernet/broadcom/asp2/bcmasp_intf.c+20−23

 	umac_wl(intf, 0x0, UMC_CMD);
 	umac_wl(intf, UMC_CMD_SW_RESET, UMC_CMD);
 	usleep_range(10, 100);
-	umac_wl(intf, 0x0, UMC_CMD);
+	/* We hold the umac in reset and bring it out of
+	 * reset when phy link is up.
+	 */
 }
 static void umac_set_hw_addr(struct bcmasp_intf *intf,
 	u32 reg;
 	reg = umac_rl(intf, UMC_CMD);
+	if (reg & UMC_CMD_SW_RESET)
+		return;
 	if (enable)
 		reg |= mask;
 	else
 	umac_wl(intf, 0x800, UMC_FRM_LEN);
 	umac_wl(intf, 0xffff, UMC_PAUSE_CNTRL);
 	umac_wl(intf, 0x800, UMC_RX_MAX_PKT_SZ);
-	umac_enable_set(intf, UMC_CMD_PROMISC, 1);
 }
 static int bcmasp_tx_poll(struct napi_struct *napi, int budget)
 			UMC_CMD_HD_EN | UMC_CMD_RX_PAUSE_IGNORE |
 			UMC_CMD_TX_PAUSE_IGNORE);
 		reg |= cmd_bits;
+		if (reg & UMC_CMD_SW_RESET) {
+			reg &= ~UMC_CMD_SW_RESET;
+			umac_wl(intf, reg, UMC_CMD);
+			udelay(2);
+			reg |= UMC_CMD_TX_EN | UMC_CMD_RX_EN | UMC_CMD_PROMISC;
+		}
 		umac_wl(intf, reg, UMC_CMD);
 		active = phy_init_eee(phydev, 0) >= 0;
 		/* Indicate that the MAC is responsible for PHY PM */
 		phydev->mac_managed_pm = true;
-	} else if (!intf->wolopts) {
-		ret = phy_resume(dev->phydev);
-		if (ret)
-			goto err_phy_disable;
 	}
 	umac_reset(intf);
 	umac_init(intf);
-	/* Disable the UniMAC RX/TX */
-	umac_enable_set(intf, (UMC_CMD_RX_EN | UMC_CMD_TX_EN), 0);
 	umac_set_hw_addr(intf, dev->dev_addr);
 	intf->old_duplex = -1;
 	netif_napi_add(intf->ndev, &intf->rx_napi, bcmasp_rx_poll);
 	bcmasp_enable_rx(intf, 1);
-	/* Turn on UniMAC TX/RX */
-	umac_enable_set(intf, (UMC_CMD_RX_EN | UMC_CMD_TX_EN), 1);
 	intf->crc_fwd = !!(umac_rl(intf, UMC_CMD) & UMC_CMD_CRC_FWD);
 	bcmasp_netif_start(dev);
 	if (intf->wolopts & WAKE_FILTER)
 		bcmasp_netfilt_suspend(intf);
-	/* UniMAC receive needs to be turned on */
+	/* Bring UniMAC out of reset if needed and enable RX */
+	reg = umac_rl(intf, UMC_CMD);
+	if (reg & UMC_CMD_SW_RESET)
+		reg &= ~UMC_CMD_SW_RESET;
+	reg |= UMC_CMD_RX_EN | UMC_CMD_PROMISC;
+	umac_wl(intf, reg, UMC_CMD);
 	umac_enable_set(intf, UMC_CMD_RX_EN, 1);
 	if (intf->parent->wol_irq > 0) {
 {
 	struct device *kdev = &intf->parent->pdev->dev;
 	struct net_device *dev = intf->ndev;
-	int ret = 0;
 	if (!netif_running(dev))
 		return 0;
 	bcmasp_netif_deinit(dev);
 	if (!intf->wolopts) {
-		ret = phy_suspend(dev->phydev);
-		if (ret)
-			goto out;
 		if (intf->internal_phy)
 			bcmasp_ephy_enable_set(intf, false);
 		else
 	clk_disable_unprepare(intf->parent->clk);
-	return ret;
+	return 0;
-out:
-	bcmasp_netif_init(dev, false);
-	return ret;
 }
 static void bcmasp_resume_from_wol(struct bcmasp_intf *intf)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_tqp_stats.c+1−1

@@ -85,7 +85,7 @@ int hclge_comm_tqps_update_stats(struct hnae3_handle *handle, · 84 unmodified lines
85	hclge_comm_cmd_setup_basic_desc(&desc, HCLGE_OPC_QUERY_TX_STATS,	85	hclge_comm_cmd_setup_basic_desc(&desc, HCLGE_OPC_QUERY_TX_STATS,
86	true);	86	true);
87		87
88	desc.data[0] = cpu_to_le32(tqp->index & 0x1ff);	88	desc.data[0] = cpu_to_le32(tqp->index);
89	ret = hclge_comm_cmd_send(hw, &desc, 1);	89	ret = hclge_comm_cmd_send(hw, &desc, 1);
90	if (ret) {	90	if (ret) {
91	dev_err(&hw->cmq.csq.pdev->dev,	91	dev_err(&hw->cmq.csq.pdev->dev,

drivers/net/ethernet/hisilicon/hns3/hns3_ethtool.c+17−2

 #define HNS3_NIC_LB_TEST_NO_MEM_ERR	1
 #define HNS3_NIC_LB_TEST_TX_CNT_ERR	2
 #define HNS3_NIC_LB_TEST_RX_CNT_ERR	3
+#define HNS3_NIC_LB_TEST_UNEXECUTED	4
+static int hns3_get_sset_count(struct net_device *netdev, int stringset);
 static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop, bool en)
 {
 static void hns3_self_test(struct net_device *ndev,
 			   struct ethtool_test *eth_test, u64 *data)
 {
+	int cnt = hns3_get_sset_count(ndev, ETH_SS_TEST);
 	struct hns3_nic_priv *priv = netdev_priv(ndev);
 	struct hnae3_handle *h = priv->ae_handle;
 	int st_param[HNAE3_LOOP_NONE][2];
 	bool if_running = netif_running(ndev);
+	int i;
+	/* initialize the loopback test result, avoid marking an unexcuted
+	 * loopback test as PASS.
+	 */
+	for (i = 0; i < cnt; i++)
+		data[i] = HNS3_NIC_LB_TEST_UNEXECUTED;
 	if (hns3_nic_resetting(ndev)) {
 		netdev_err(ndev, "dev resetting!");
-		return;
+		goto failure;
 	}
 	if (!(eth_test->flags & ETH_TEST_FL_OFFLINE))
-		return;
+		goto failure;
 	if (netif_msg_ifdown(h))
 		netdev_info(ndev, "self test start\n");
 	if (netif_msg_ifdown(h))
 		netdev_info(ndev, "self test end\n");
+	return;
+failure:
+	eth_test->flags |= ETH_TEST_FL_FAILED;
 }
 static void hns3_update_limit_promisc_mode(struct net_device *netdev,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c+4−0

 	if (ret)
 		goto err_pci_uninit;
+	devl_lock(hdev->devlink);
 	/* Firmware command queue initialize */
 	ret = hclge_comm_cmd_queue_init(hdev->pdev, &hdev->hw.hw);
 	if (ret)
 	hclge_task_schedule(hdev, round_jiffies_relative(HZ));
+	devl_unlock(hdev->devlink);
 	return 0;
 err_mdiobus_unreg:
 err_cmd_uninit:
 	hclge_comm_cmd_uninit(hdev->ae_dev, &hdev->hw.hw);
 err_devlink_uninit:
+	devl_unlock(hdev->devlink);
 	hclge_devlink_uninit(hdev);
 err_pci_uninit:
 	pcim_iounmap(pdev, hdev->hw.hw.io_base);

drivers/net/ethernet/intel/ice/ice_adminq_cmd.h+2−1

 struct ice_aqc_recipe_to_profile {
 	__le16 profile_id;
 	u8 rsvd[6];
-	DECLARE_BITMAP(recipe_assoc, ICE_MAX_NUM_RECIPES);
+	__le64 recipe_assoc;
 };
+static_assert(sizeof(struct ice_aqc_recipe_to_profile) == 16);
 /* Add/Update/Remove/Get switch rules (indirect 0x02A0, 0x02A1, 0x02A2, 0x02A3)
  */

drivers/net/ethernet/intel/ice/ice_lag.c+2−2

@@ -2041,7 +2041,7 @@ int ice_init_lag(struct ice_pf *pf) · 2040 unmodified lines
2041	/* associate recipes to profiles */	2041	/* associate recipes to profiles */
2042	for (n = 0; n < ICE_PROFID_IPV6_GTPU_IPV6_TCP_INNER; n++) {	2042	for (n = 0; n < ICE_PROFID_IPV6_GTPU_IPV6_TCP_INNER; n++) {
2043	err = ice_aq_get_recipe_to_profile(&pf->hw, n,	2043	err = ice_aq_get_recipe_to_profile(&pf->hw, n,
2044	(u8 *)&recipe_bits, NULL);	2044	&recipe_bits, NULL);
2045	if (err)	2045	if (err)
2046	continue;	2046	continue;
2047		2047
@@ -2049,7 +2049,7 @@ int ice_init_lag(struct ice_pf *pf) · 1 unmodified line
2049	recipe_bits \|= BIT(lag->pf_recipe) \|	2049	recipe_bits \|= BIT(lag->pf_recipe) \|
2050	BIT(lag->lport_recipe);	2050	BIT(lag->lport_recipe);
2051	ice_aq_map_recipe_to_profile(&pf->hw, n,	2051	ice_aq_map_recipe_to_profile(&pf->hw, n,
2052	(u8 *)&recipe_bits, NULL);	2052	recipe_bits, NULL);
2053	}	2053	}
2054	}	2054	}
2055		2055

drivers/net/ethernet/intel/ice/ice_lib.c+9−9

 {
 	struct ice_vsi_cfg_params params = {};
 	struct ice_coalesce_stored *coalesce;
-	int prev_num_q_vectors = 0;
+	int prev_num_q_vectors;
 	struct ice_pf *pf;
 	int ret;
 	if (WARN_ON(vsi->type == ICE_VSI_VF && !vsi->vf))
 		return -EINVAL;
-	coalesce = kcalloc(vsi->num_q_vectors,
-			   sizeof(struct ice_coalesce_stored), GFP_KERNEL);
-	if (!coalesce)
-		return -ENOMEM;
-	prev_num_q_vectors = ice_vsi_rebuild_get_coalesce(vsi, coalesce);
 	ret = ice_vsi_realloc_stat_arrays(vsi);
 	if (ret)
 		goto err_vsi_cfg;
 	if (ret)
 		goto err_vsi_cfg;
+	coalesce = kcalloc(vsi->num_q_vectors,
+			   sizeof(struct ice_coalesce_stored), GFP_KERNEL);
+	if (!coalesce)
+		return -ENOMEM;
+	prev_num_q_vectors = ice_vsi_rebuild_get_coalesce(vsi, coalesce);
 	ret = ice_vsi_cfg_tc_lan(pf, vsi);
 	if (ret) {
 		if (vsi_flags & ICE_VSI_FLAG_INIT) {
 err_vsi_cfg_tc_lan:
 	ice_vsi_decfg(vsi);
-err_vsi_cfg:
 	kfree(coalesce);
+err_vsi_cfg:
 	return ret;
 }

drivers/net/ethernet/intel/ice/ice_switch.c+14−10

  * ice_aq_map_recipe_to_profile - Map recipe to packet profile
  * @hw: pointer to the HW struct
  * @profile_id: package profile ID to associate the recipe with
- * @r_bitmap: Recipe bitmap filled in and need to be returned as response
+ * @r_assoc: Recipe bitmap filled in and need to be returned as response
  * @cd: pointer to command details structure or NULL
  * Recipe to profile association (0x0291)
  */
 int
-ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap,
+ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u64 r_assoc,
 			     struct ice_sq_cd *cd)
 {
 	struct ice_aqc_recipe_to_profile *cmd;
 	/* Set the recipe ID bit in the bitmask to let the device know which
 	 * profile we are associating the recipe to
 	 */
-	memcpy(cmd->recipe_assoc, r_bitmap, sizeof(cmd->recipe_assoc));
+	cmd->recipe_assoc = cpu_to_le64(r_assoc);
 	return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
 }
  * ice_aq_get_recipe_to_profile - Map recipe to packet profile
  * @hw: pointer to the HW struct
  * @profile_id: package profile ID to associate the recipe with
- * @r_bitmap: Recipe bitmap filled in and need to be returned as response
+ * @r_assoc: Recipe bitmap filled in and need to be returned as response
  * @cd: pointer to command details structure or NULL
  * Associate profile ID with given recipe (0x0293)
  */
 int
-ice_aq_get_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap,
+ice_aq_get_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u64 *r_assoc,
 			     struct ice_sq_cd *cd)
 {
 	struct ice_aqc_recipe_to_profile *cmd;
 	status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
 	if (!status)
-		memcpy(r_bitmap, cmd->recipe_assoc, sizeof(cmd->recipe_assoc));
+		*r_assoc = le64_to_cpu(cmd->recipe_assoc);
 	return status;
 }
 static void ice_get_recp_to_prof_map(struct ice_hw *hw)
 {
 	DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES);
+	u64 recp_assoc;
 	u16 i;
 	for (i = 0; i < hw->switch_info->max_used_prof_index + 1; i++) {
 		bitmap_zero(profile_to_recipe[i], ICE_MAX_NUM_RECIPES);
 		bitmap_zero(r_bitmap, ICE_MAX_NUM_RECIPES);
-		if (ice_aq_get_recipe_to_profile(hw, i, (u8 *)r_bitmap, NULL))
+		if (ice_aq_get_recipe_to_profile(hw, i, &recp_assoc, NULL))
 			continue;
+		bitmap_from_arr64(r_bitmap, &recp_assoc, ICE_MAX_NUM_RECIPES);
 		bitmap_copy(profile_to_recipe[i], r_bitmap,
 			    ICE_MAX_NUM_RECIPES);
 		for_each_set_bit(j, r_bitmap, ICE_MAX_NUM_RECIPES)
 	 */
 	list_for_each_entry(fvit, &rm->fv_list, list_entry) {
 		DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES);
+		u64 recp_assoc;
 		u16 j;
 		status = ice_aq_get_recipe_to_profile(hw, fvit->profile_id,
-						      (u8 *)r_bitmap, NULL);
+						      &recp_assoc, NULL);
 		if (status)
 			goto err_unroll;
+		bitmap_from_arr64(r_bitmap, &recp_assoc, ICE_MAX_NUM_RECIPES);
 		bitmap_or(r_bitmap, r_bitmap, rm->r_bitmap,
 			  ICE_MAX_NUM_RECIPES);
 		status = ice_acquire_change_lock(hw, ICE_RES_WRITE);
 		if (status)
 			goto err_unroll;
+		bitmap_to_arr64(&recp_assoc, r_bitmap, ICE_MAX_NUM_RECIPES);
 		status = ice_aq_map_recipe_to_profile(hw, fvit->profile_id,
-						      (u8 *)r_bitmap,
+						      recp_assoc, NULL);
-						      NULL);
 		ice_release_change_lock(hw);
 		if (status)

drivers/net/ethernet/intel/ice/ice_switch.h+2−2

@@ -424,10 +424,10 @@ int ice_aq_add_recipe(struct ice_hw *hw, · 423 unmodified lines
424	struct ice_aqc_recipe_data_elem *s_recipe_list,	424	struct ice_aqc_recipe_data_elem *s_recipe_list,
425	u16 num_recipes, struct ice_sq_cd *cd);	425	u16 num_recipes, struct ice_sq_cd *cd);
426	int	426	int
427	ice_aq_get_recipe_to_profile(struct ice_hw hw, u32 profile_id, u8 r_bitmap,	427	ice_aq_get_recipe_to_profile(struct ice_hw hw, u32 profile_id, u64 r_assoc,
428	struct ice_sq_cd *cd);	428	struct ice_sq_cd *cd);
429	int	429	int
430	ice_aq_map_recipe_to_profile(struct ice_hw hw, u32 profile_id, u8 r_bitmap,	430	ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u64 r_assoc,
431	struct ice_sq_cd *cd);	431	struct ice_sq_cd *cd);
432		432
433	#endif /* _ICE_SWITCH_H_ */	433	#endif /* _ICE_SWITCH_H_ */

drivers/net/ethernet/intel/igc/igc_main.c+0−4

 	if (unlikely(test_bit(IGC_RING_FLAG_TX_HWTSTAMP, &tx_ring->flags) &&
 		     skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
-		/* FIXME: add support for retrieving timestamps from
-		 * the other timer registers before skipping the
-		 * timestamping request.
-		 */
 		unsigned long flags;
 		u32 tstamp_flags;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c+8−8

 		goto err_out;
 	}
-	xs = kzalloc(sizeof(*xs), GFP_KERNEL);
+	algo = xfrm_aead_get_byname(aes_gcm_name, IXGBE_IPSEC_AUTH_BITS, 1);
+	if (unlikely(!algo)) {
+		err = -ENOENT;
+		goto err_out;
+	}
+	xs = kzalloc(sizeof(*xs), GFP_ATOMIC);
 	if (unlikely(!xs)) {
 		err = -ENOMEM;
 		goto err_out;
 		memcpy(&xs->id.daddr.a4, sam->addr, sizeof(xs->id.daddr.a4));
 	xs->xso.dev = adapter->netdev;
-	algo = xfrm_aead_get_byname(aes_gcm_name, IXGBE_IPSEC_AUTH_BITS, 1);
-	if (unlikely(!algo)) {
-		err = -ENOENT;
-		goto err_xs;
-	}
 	aead_len = sizeof(*xs->aead) + IXGBE_IPSEC_KEY_BITS / 8;
-	xs->aead = kzalloc(aead_len, GFP_KERNEL);
+	xs->aead = kzalloc(aead_len, GFP_ATOMIC);
 	if (unlikely(!xs->aead)) {
 		err = -ENOMEM;
 		goto err_xs;

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

 	if (!is_lmac_valid(cgx, lmac_id))
 		return -ENODEV;
+	cfg = cgx_read(cgx, lmac_id, CGXX_GMP_GMI_RXX_FRM_CTL);
+	cfg &= ~CGX_GMP_GMI_RXX_FRM_CTL_CTL_BCK;
+	cfg |= rx_pause ? CGX_GMP_GMI_RXX_FRM_CTL_CTL_BCK : 0x0;
+	cgx_write(cgx, lmac_id, CGXX_GMP_GMI_RXX_FRM_CTL, cfg);
 	cfg = cgx_read(cgx, lmac_id, CGXX_SMUX_RX_FRM_CTL);
 	cfg &= ~CGX_SMUX_RX_FRM_CTL_CTL_BCK;
 	cfg |= rx_pause ? CGX_SMUX_RX_FRM_CTL_CTL_BCK : 0x0;

drivers/net/ethernet/mellanox/mlxbf_gige/mlxbf_gige_main.c+14−7

 	control |= MLXBF_GIGE_CONTROL_PORT_EN;
 	writeq(control, priv->base + MLXBF_GIGE_CONTROL);
-	err = mlxbf_gige_request_irqs(priv);
-	if (err)
-		return err;
 	mlxbf_gige_cache_stats(priv);
 	err = mlxbf_gige_clean_port(priv);
 	if (err)
-		goto free_irqs;
+		return err;
 	/* Clear driver's valid_polarity to match hardware,
 	 * since the above call to clean_port() resets the
 	err = mlxbf_gige_tx_init(priv);
 	if (err)
-		goto free_irqs;
+		goto phy_deinit;
 	err = mlxbf_gige_rx_init(priv);
 	if (err)
 		goto tx_deinit;
 	napi_enable(&priv->napi);
 	netif_start_queue(netdev);
+	err = mlxbf_gige_request_irqs(priv);
+	if (err)
+		goto napi_deinit;
 	/* Set bits in INT_EN that we care about */
 	int_en = MLXBF_GIGE_INT_EN_HW_ACCESS_ERROR |
 		 MLXBF_GIGE_INT_EN_TX_CHECKSUM_INPUTS |
 	return 0;
+napi_deinit:
+	netif_stop_queue(netdev);
+	napi_disable(&priv->napi);
+	netif_napi_del(&priv->napi);
+	mlxbf_gige_rx_deinit(priv);
 tx_deinit:
 	mlxbf_gige_tx_deinit(priv);
-free_irqs:
+phy_deinit:
-	mlxbf_gige_free_irqs(priv);
+	phy_stop(phydev);
 	return err;
 }

drivers/net/ethernet/microchip/lan743x_main.c+18−0

 #define PCS_POWER_STATE_DOWN	0x6
 #define PCS_POWER_STATE_UP	0x4
+#define RFE_RD_FIFO_TH_3_DWORDS	0x3
 static void pci11x1x_strap_get_status(struct lan743x_adapter *adapter)
 {
 	u32 chip_rev;
 	lan743x_pci_cleanup(adapter);
 }
+static void pci11x1x_set_rfe_rd_fifo_threshold(struct lan743x_adapter *adapter)
+{
+	u16 rev = adapter->csr.id_rev & ID_REV_CHIP_REV_MASK_;
+	if (rev == ID_REV_CHIP_REV_PCI11X1X_B0_) {
+		u32 misc_ctl;
+		misc_ctl = lan743x_csr_read(adapter, MISC_CTL_0);
+		misc_ctl &= ~MISC_CTL_0_RFE_READ_FIFO_MASK_;
+		misc_ctl |= FIELD_PREP(MISC_CTL_0_RFE_READ_FIFO_MASK_,
+				       RFE_RD_FIFO_TH_3_DWORDS);
+		lan743x_csr_write(adapter, MISC_CTL_0, misc_ctl);
+	}
+}
 static int lan743x_hardware_init(struct lan743x_adapter *adapter,
 				 struct pci_dev *pdev)
 {
 		pci11x1x_strap_get_status(adapter);
 		spin_lock_init(&adapter->eth_syslock_spinlock);
 		mutex_init(&adapter->sgmii_rw_lock);
+		pci11x1x_set_rfe_rd_fifo_threshold(adapter);
 	} else {
 		adapter->max_tx_channels = LAN743X_MAX_TX_CHANNELS;
 		adapter->used_tx_channels = LAN743X_USED_TX_CHANNELS;

drivers/net/ethernet/microchip/lan743x_main.h+4−0

 #define ID_REV_CHIP_REV_MASK_		(0x0000FFFF)
 #define ID_REV_CHIP_REV_A0_		(0x00000000)
 #define ID_REV_CHIP_REV_B0_		(0x00000010)
+#define ID_REV_CHIP_REV_PCI11X1X_B0_	(0x000000B0)
 #define FPGA_REV			(0x04)
 #define FPGA_REV_GET_MINOR_(fpga_rev)	(((fpga_rev) >> 8) & 0x000000FF)
 #define SGMII_CTL_LINK_STATUS_SOURCE_	BIT(8)
 #define SGMII_CTL_SGMII_POWER_DN_	BIT(1)
+#define MISC_CTL_0			(0x920)
+#define MISC_CTL_0_RFE_READ_FIFO_MASK_	GENMASK(6, 4)
 /* Vendor Specific SGMII MMD details */
 #define SR_VSMMD_PCS_ID1		0x0004
 #define SR_VSMMD_PCS_ID2		0x0005

drivers/net/ethernet/renesas/sh_eth.c+1−1

@@ -50,7 +50,7 @@ · 49 unmodified lines
50	* the macros available to do this only define GCC 8.	50	* the macros available to do this only define GCC 8.
51	*/	51	*/
52	__diag_push();	52	__diag_push();
53	__diag_ignore(GCC, 8, "-Woverride-init",	53	__diag_ignore_all("-Woverride-init",
54	"logic to initialize all and then override some is OK");	54	"logic to initialize all and then override some is OK");
55	static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {	55	static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {
56	SH_ETH_OFFSET_DEFAULTS,	56	SH_ETH_OFFSET_DEFAULTS,

drivers/net/ethernet/xilinx/ll_temac_main.c+1−1

@@ -1443,7 +1443,7 @@ static int temac_probe(struct platform_device *pdev) · 1442 unmodified lines
1443	}	1443	}
1444		1444
1445	/* map device registers */	1445	/* map device registers */
1446	lp->regs = devm_platform_ioremap_resource_byname(pdev, 0);	1446	lp->regs = devm_platform_ioremap_resource(pdev, 0);
1447	if (IS_ERR(lp->regs)) {	1447	if (IS_ERR(lp->regs)) {
1448	dev_err(&pdev->dev, "could not map TEMAC registers\n");	1448	dev_err(&pdev->dev, "could not map TEMAC registers\n");
1449	return -ENOMEM;	1449	return -ENOMEM;

drivers/net/phy/qcom/at803x.c+3−1

 static int at8031_probe(struct phy_device *phydev)
 {
-	struct at803x_priv *priv = phydev->priv;
+	struct at803x_priv *priv;
 	int mode_cfg;
 	int ccr;
 	int ret;
 	if (ret)
 		return ret;
+	priv = phydev->priv;
 	/* Only supported on AR8031/AR8033, the AR8030/AR8035 use strapping
 	 * options.
 	 */

drivers/net/wireless/intel/iwlwifi/fw/dbg.c+8−7

 	struct iwl_fw_dbg_params params = {0};
 	struct iwl_fwrt_dump_data *dump_data =
 		&fwrt->dump.wks[wk_idx].dump_data;
-	u32 policy;
-	u32 time_point;
 	if (!test_bit(wk_idx, &fwrt->dump.active_wks))
 		return;
 	iwl_fw_dbg_stop_restart_recording(fwrt, &params, false);
-	policy = le32_to_cpu(dump_data->trig->apply_policy);
+	if (iwl_trans_dbg_ini_valid(fwrt->trans)) {
-	time_point = le32_to_cpu(dump_data->trig->time_point);
+		u32 policy = le32_to_cpu(dump_data->trig->apply_policy);
+		u32 time_point = le32_to_cpu(dump_data->trig->time_point);
-	if (policy & IWL_FW_INI_APPLY_POLICY_DUMP_COMPLETE_CMD) {
+		if (policy & IWL_FW_INI_APPLY_POLICY_DUMP_COMPLETE_CMD) {
-		IWL_DEBUG_FW_INFO(fwrt, "WRT: sending dump complete\n");
+			IWL_DEBUG_FW_INFO(fwrt, "WRT: sending dump complete\n");
-		iwl_send_dbg_dump_complete_cmd(fwrt, time_point, 0);
+			iwl_send_dbg_dump_complete_cmd(fwrt, time_point, 0);
+		}
 	}
 	if (fwrt->trans->dbg.last_tp_resetfw == IWL_FW_INI_RESET_FW_MODE_STOP_FW_ONLY)
 		iwl_force_nmi(fwrt->trans);

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

 	if (IS_ERR_OR_NULL(vif))
 		return 1;
-	if (ieee80211_vif_is_mld(vif) && vif->cfg.assoc) {
+	if (hweight16(vif->active_links) > 1) {
 		/*
-		 * Select the 'best' link. May need to revisit, it seems
+		 * Select the 'best' link.
-		 * better to not optimize for throughput but rather range,
+		 * May need to revisit, it seems better to not optimize
-		 * reliability and power here - and select 2.4 GHz ...
+		 * for throughput but rather range, reliability and
+		 * power here - and select 2.4 GHz ...
 		 */
-		primary_link =
+		primary_link = iwl_mvm_mld_get_primary_link(mvm, vif,
-			iwl_mvm_mld_get_primary_link(mvm, vif,
+							    vif->active_links);
-						     vif->active_links);
 		if (WARN_ONCE(primary_link < 0, "no primary link in 0x%x\n",
 			      vif->active_links))
 		ret = ieee80211_set_active_links(vif, BIT(primary_link));
 		if (ret)
 			return ret;
+	} else if (vif->active_links) {
+		primary_link = __ffs(vif->active_links);
 	} else {
 		primary_link = 0;
 	}

drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c+7−4

 {
 	struct dentry *dbgfs_dir = vif->debugfs_dir;
 	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
-	char buf[100];
+	char buf[3 * 3 + 11 + (NL80211_WIPHY_NAME_MAXLEN + 1) +
+		 (7 + IFNAMSIZ + 1) + 6 + 1];
+	char name[7 + IFNAMSIZ + 1];
 	/* this will happen in monitor mode */
 	if (!dbgfs_dir)
 	 * find
 	 * netdev:wlan0 -> ../../../ieee80211/phy0/netdev:wlan0/iwlmvm/
 	 */
-	snprintf(buf, 100, "../../../%pd3/iwlmvm", dbgfs_dir);
+	snprintf(name, sizeof(name), "%pd", dbgfs_dir);
+	snprintf(buf, sizeof(buf), "../../../%pd3/iwlmvm", dbgfs_dir);
-	mvmvif->dbgfs_slink = debugfs_create_symlink(dbgfs_dir->d_name.name,
+	mvmvif->dbgfs_slink =
-						     mvm->debugfs_dir, buf);
+		debugfs_create_symlink(name, mvm->debugfs_dir, buf);
 }
 void iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif)

drivers/net/wireless/intel/iwlwifi/mvm/link.c+45−14

 	return ret;
 }
+int iwl_mvm_set_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
+			     struct ieee80211_bss_conf *link_conf)
+{
+	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
+	struct iwl_mvm_vif_link_info *link_info =
+		mvmvif->link[link_conf->link_id];
+	if (link_info->fw_link_id == IWL_MVM_FW_LINK_ID_INVALID) {
+		link_info->fw_link_id = iwl_mvm_get_free_fw_link_id(mvm,
+								    mvmvif);
+		if (link_info->fw_link_id >=
+		    ARRAY_SIZE(mvm->link_id_to_link_conf))
+			return -EINVAL;
+		rcu_assign_pointer(mvm->link_id_to_link_conf[link_info->fw_link_id],
+				   link_conf);
+	}
+	return 0;
+}
 int iwl_mvm_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 		     struct ieee80211_bss_conf *link_conf)
 {
 	struct iwl_link_config_cmd cmd = {};
 	unsigned int cmd_id = WIDE_ID(MAC_CONF_GROUP, LINK_CONFIG_CMD);
 	u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id, 1);
+	int ret;
 	if (WARN_ON_ONCE(!link_info))
 		return -EINVAL;
-	if (link_info->fw_link_id == IWL_MVM_FW_LINK_ID_INVALID) {
+	ret = iwl_mvm_set_link_mapping(mvm, vif, link_conf);
-		link_info->fw_link_id = iwl_mvm_get_free_fw_link_id(mvm,
+	if (ret)
-								    mvmvif);
+		return ret;
-		if (link_info->fw_link_id >= ARRAY_SIZE(mvm->link_id_to_link_conf))
-			return -EINVAL;
-		rcu_assign_pointer(mvm->link_id_to_link_conf[link_info->fw_link_id],
-				   link_conf);
-	}
 	/* Update SF - Disable if needed. if this fails, SF might still be on
 	 * while many macs are bound, which is forbidden - so fail the binding.
 	return ret;
 }
+int iwl_mvm_unset_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
+			       struct ieee80211_bss_conf *link_conf)
+{
+	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
+	struct iwl_mvm_vif_link_info *link_info =
+		mvmvif->link[link_conf->link_id];
+	/* mac80211 thought we have the link, but it was never configured */
+	if (WARN_ON(!link_info ||
+		    link_info->fw_link_id >=
+		    ARRAY_SIZE(mvm->link_id_to_link_conf)))
+		return -EINVAL;
+	RCU_INIT_POINTER(mvm->link_id_to_link_conf[link_info->fw_link_id],
+			 NULL);
+	return 0;
+}
 int iwl_mvm_remove_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 			struct ieee80211_bss_conf *link_conf)
 {
 	struct iwl_link_config_cmd cmd = {};
 	int ret;
-	/* mac80211 thought we have the link, but it was never configured */
+	ret = iwl_mvm_unset_link_mapping(mvm, vif, link_conf);
-	if (WARN_ON(!link_info ||
+	if (ret)
-		    link_info->fw_link_id >= ARRAY_SIZE(mvm->link_id_to_link_conf)))
 		return 0;
-	RCU_INIT_POINTER(mvm->link_id_to_link_conf[link_info->fw_link_id],
-			 NULL);
 	cmd.link_id = cpu_to_le32(link_info->fw_link_id);
 	iwl_mvm_release_fw_link_id(mvm, link_info->fw_link_id);
 	link_info->fw_link_id = IWL_MVM_FW_LINK_ID_INVALID;

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

 	if (mvm->mld_api_is_used && mvm->nvm_data->sku_cap_11be_enable &&
 	    !iwlwifi_mod_params.disable_11ax &&
 	    !iwlwifi_mod_params.disable_11be)
-		hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_MLO;
+		hw->wiphy->flags |= WIPHY_FLAG_DISABLE_WEXT;
 	/* With MLD FW API, it tracks timing by itself,
 	 * no need for any timing from the host
 	mvmvif->mvm = mvm;
 	/* the first link always points to the default one */
+	mvmvif->deflink.fw_link_id = IWL_MVM_FW_LINK_ID_INVALID;
+	mvmvif->deflink.active = 0;
 	mvmvif->link[0] = &mvmvif->deflink;
+	ret = iwl_mvm_set_link_mapping(mvm, vif, &vif->bss_conf);
+	if (ret)
+		goto out;
 	/*
 	 * Not much to do here. The stack will not allow interface
 	 * types or combinations that we didn't advertise, so we
 		mvm->p2p_device_vif = NULL;
 	}
+	iwl_mvm_unset_link_mapping(mvm, vif, &vif->bss_conf);
 	iwl_mvm_mac_ctxt_remove(mvm, vif);
 	RCU_INIT_POINTER(mvm->vif_id_to_mac[mvmvif->id], NULL);

drivers/net/wireless/intel/iwlwifi/mvm/mld-sta.c+6−1

 int iwl_mvm_mld_rm_sta_id(struct iwl_mvm *mvm, u8 sta_id)
 {
-	int ret = iwl_mvm_mld_rm_sta_from_fw(mvm, sta_id);
+	int ret;
 	lockdep_assert_held(&mvm->mutex);
+	if (WARN_ON(sta_id == IWL_MVM_INVALID_STA))
+		return 0;
+	ret = iwl_mvm_mld_rm_sta_from_fw(mvm, sta_id);
 	RCU_INIT_POINTER(mvm->fw_id_to_mac_id[sta_id], NULL);
 	RCU_INIT_POINTER(mvm->fw_id_to_link_sta[sta_id], NULL);
 	return ret;

drivers/net/wireless/intel/iwlwifi/mvm/mvm.h+4−0

 u32 iwl_mvm_get_lmac_id(struct iwl_mvm *mvm, enum nl80211_band band);
 /* Links */
+int iwl_mvm_set_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
+			     struct ieee80211_bss_conf *link_conf);
 int iwl_mvm_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 		     struct ieee80211_bss_conf *link_conf);
 int iwl_mvm_link_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 			 struct ieee80211_bss_conf *link_conf,
 			 u32 changes, bool active);
+int iwl_mvm_unset_link_mapping(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
+			       struct ieee80211_bss_conf *link_conf);
 int iwl_mvm_remove_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 			struct ieee80211_bss_conf *link_conf);
 int iwl_mvm_disable_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif,

drivers/net/wireless/intel/iwlwifi/mvm/rfi.c+6−2

 	if (ret)
 		return ERR_PTR(ret);
-	if (WARN_ON_ONCE(iwl_rx_packet_payload_len(cmd.resp_pkt) != resp_size))
+	if (WARN_ON_ONCE(iwl_rx_packet_payload_len(cmd.resp_pkt) !=
+			 resp_size)) {
+		iwl_free_resp(&cmd);
 		return ERR_PTR(-EIO);
+	}
 	resp = kmemdup(cmd.resp_pkt->data, resp_size, GFP_KERNEL);
+	iwl_free_resp(&cmd);
 	if (!resp)
 		return ERR_PTR(-ENOMEM);
-	iwl_free_resp(&cmd);
 	return resp;
 }

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c+8−12

 static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm *mvm,
 					    struct napi_struct *napi,
 					    struct sk_buff *skb, int queue,
-					    struct ieee80211_sta *sta,
+					    struct ieee80211_sta *sta)
-					    struct ieee80211_link_sta *link_sta)
 {
 	if (unlikely(iwl_mvm_check_pn(mvm, skb, queue, sta))) {
 		kfree_skb(skb);
 		return;
 	}
-	if (sta && sta->valid_links && link_sta) {
-		struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
-		rx_status->link_valid = 1;
-		rx_status->link_id = link_sta->link_id;
-	}
 	ieee80211_rx_napi(mvm->hw, sta, skb, napi);
 }
 		while ((skb = __skb_dequeue(skb_list))) {
 			iwl_mvm_pass_packet_to_mac80211(mvm, napi, skb,
 							reorder_buf->queue,
-							sta, NULL /* FIXME */);
+							sta);
 			reorder_buf->num_stored--;
 		}
 	}
 			if (IS_ERR(sta))
 				sta = NULL;
 			link_sta = rcu_dereference(mvm->fw_id_to_link_sta[id]);
+			if (sta && sta->valid_links && link_sta) {
+				rx_status->link_valid = 1;
+				rx_status->link_id = link_sta->link_id;
+			}
 		}
 	} else if (!is_multicast_ether_addr(hdr->addr2)) {
 		/*
 		    !(desc->amsdu_info & IWL_RX_MPDU_AMSDU_LAST_SUBFRAME))
 			rx_status->flag |= RX_FLAG_AMSDU_MORE;
-		iwl_mvm_pass_packet_to_mac80211(mvm, napi, skb, queue, sta,
+		iwl_mvm_pass_packet_to_mac80211(mvm, napi, skb, queue, sta);
-						link_sta);
 	}
 out:
 	rcu_read_unlock();

drivers/net/wireless/intel/iwlwifi/mvm/time-event.c+2−3

 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
 	struct iwl_mvm_session_prot_notif *notif = (void *)pkt->data;
 	unsigned int ver =
-		iwl_fw_lookup_cmd_ver(mvm->fw,
+		iwl_fw_lookup_notif_ver(mvm->fw, MAC_CONF_GROUP,
-				      WIDE_ID(MAC_CONF_GROUP,
+					SESSION_PROTECTION_NOTIF, 2);
-					      SESSION_PROTECTION_CMD), 2);
 	int id = le32_to_cpu(notif->mac_link_id);
 	struct ieee80211_vif *vif;
 	struct iwl_mvm_vif *mvmvif;

drivers/net/wireless/intel/iwlwifi/queue/tx.c+1−1

@@ -1589,9 +1589,9 @@ void iwl_txq_reclaim(struct iwl_trans *trans, int txq_id, int ssn, · 1588 unmodified lines
1589	return;	1589	return;
1590		1590
1591	tfd_num = iwl_txq_get_cmd_index(txq, ssn);	1591	tfd_num = iwl_txq_get_cmd_index(txq, ssn);
1592	read_ptr = iwl_txq_get_cmd_index(txq, txq->read_ptr);
1593		1592
1594	spin_lock_bh(&txq->lock);	1593	spin_lock_bh(&txq->lock);
		1594	read_ptr = iwl_txq_get_cmd_index(txq, txq->read_ptr);
1595		1595
1596	if (!test_bit(txq_id, trans->txqs.queue_used)) {	1596	if (!test_bit(txq_id, trans->txqs.queue_used)) {
1597	IWL_DEBUG_TX_QUEUES(trans, "Q %d inactive - ignoring idx %d\n",	1597	IWL_DEBUG_TX_QUEUES(trans, "Q %d inactive - ignoring idx %d\n",

drivers/net/wireless/realtek/rtw89/rtw8922a.c+1−1

@@ -2233,7 +2233,7 @@ static void rtw8922a_btc_init_cfg(struct rtw89_dev *rtwdev) · 2232 unmodified lines
2233	* Shared-Ant && BTG-path:WL mask(0x55f), others:WL THRU(0x5ff)	2233	* Shared-Ant && BTG-path:WL mask(0x55f), others:WL THRU(0x5ff)
2234	*/	2234	*/
2235	if (btc->ant_type == BTC_ANT_SHARED && btc->btg_pos == path)	2235	if (btc->ant_type == BTC_ANT_SHARED && btc->btg_pos == path)
2236	rtw8922a_set_trx_mask(rtwdev, path, BTC_BT_TX_GROUP, 0x5ff);	2236	rtw8922a_set_trx_mask(rtwdev, path, BTC_BT_TX_GROUP, 0x55f);
2237	else	2237	else
2238	rtw8922a_set_trx_mask(rtwdev, path, BTC_BT_TX_GROUP, 0x5ff);	2238	rtw8922a_set_trx_mask(rtwdev, path, BTC_BT_TX_GROUP, 0x5ff);
2239		2239

drivers/net/wwan/t7xx/t7xx_cldma.c+2−2

@@ -106,7 +106,7 @@ bool t7xx_cldma_tx_addr_is_set(struct t7xx_cldma_hw *hw_info, unsigned int qno) · 105 unmodified lines
106	{	106	{
107	u32 offset = REG_CLDMA_UL_START_ADDRL_0 + qno * ADDR_SIZE;	107	u32 offset = REG_CLDMA_UL_START_ADDRL_0 + qno * ADDR_SIZE;
108		108
109	return ioread64(hw_info->ap_pdn_base + offset);	109	return ioread64_lo_hi(hw_info->ap_pdn_base + offset);
110	}	110	}
111		111
112	void t7xx_cldma_hw_set_start_addr(struct t7xx_cldma_hw *hw_info, unsigned int qno, u64 address,	112	void t7xx_cldma_hw_set_start_addr(struct t7xx_cldma_hw *hw_info, unsigned int qno, u64 address,
@@ -117,7 +117,7 @@ void t7xx_cldma_hw_set_start_addr(struct t7xx_cldma_hw *hw_info, unsigned int qn · 4 unmodified lines
117		117
118	reg = tx_rx == MTK_RX ? hw_info->ap_ao_base + REG_CLDMA_DL_START_ADDRL_0 :	118	reg = tx_rx == MTK_RX ? hw_info->ap_ao_base + REG_CLDMA_DL_START_ADDRL_0 :
119	hw_info->ap_pdn_base + REG_CLDMA_UL_START_ADDRL_0;	119	hw_info->ap_pdn_base + REG_CLDMA_UL_START_ADDRL_0;
120	iowrite64(address, reg + offset);	120	iowrite64_lo_hi(address, reg + offset);
121	}	121	}
122		122
123	void t7xx_cldma_hw_resume_queue(struct t7xx_cldma_hw *hw_info, unsigned int qno,	123	void t7xx_cldma_hw_resume_queue(struct t7xx_cldma_hw *hw_info, unsigned int qno,

drivers/net/wwan/t7xx/t7xx_hif_cldma.c+5−4

 				return -ENODEV;
 			}
-			gpd_addr = ioread64(hw_info->ap_pdn_base + REG_CLDMA_DL_CURRENT_ADDRL_0 +
+			gpd_addr = ioread64_lo_hi(hw_info->ap_pdn_base +
-					    queue->index * sizeof(u64));
+						  REG_CLDMA_DL_CURRENT_ADDRL_0 +
+						  queue->index * sizeof(u64));
 			if (req->gpd_addr == gpd_addr || hwo_polling_count++ >= 100)
 				return 0;
 		struct t7xx_cldma_hw *hw_info = &md_ctrl->hw_info;
 		/* Check current processing TGPD, 64-bit address is in a table by Q index */
-		ul_curr_addr = ioread64(hw_info->ap_pdn_base + REG_CLDMA_UL_CURRENT_ADDRL_0 +
+		ul_curr_addr = ioread64_lo_hi(hw_info->ap_pdn_base + REG_CLDMA_UL_CURRENT_ADDRL_0 +
-					queue->index * sizeof(u64));
+					      queue->index * sizeof(u64));
 		if (req->gpd_addr != ul_curr_addr) {
 			spin_unlock_irqrestore(&md_ctrl->cldma_lock, flags);
 			dev_err(md_ctrl->dev, "CLDMA%d queue %d is not empty\n",

drivers/net/wwan/t7xx/t7xx_pcie_mac.c+4−4

@@ -75,7 +75,7 @@ static void t7xx_pcie_mac_atr_tables_dis(void __iomem *pbase, enum t7xx_atr_src_ · 74 unmodified lines
75	for (i = 0; i < ATR_TABLE_NUM_PER_ATR; i++) {	75	for (i = 0; i < ATR_TABLE_NUM_PER_ATR; i++) {
76	offset = ATR_PORT_OFFSET * port + ATR_TABLE_OFFSET * i;	76	offset = ATR_PORT_OFFSET * port + ATR_TABLE_OFFSET * i;
77	reg = pbase + ATR_PCIE_WIN0_T0_ATR_PARAM_SRC_ADDR + offset;	77	reg = pbase + ATR_PCIE_WIN0_T0_ATR_PARAM_SRC_ADDR + offset;
78	iowrite64(0, reg);	78	iowrite64_lo_hi(0, reg);
79	}	79	}
80	}	80	}
81		81
@@ -112,17 +112,17 @@ static int t7xx_pcie_mac_atr_cfg(struct t7xx_pci_dev *t7xx_dev, struct t7xx_atr_ · 30 unmodified lines
112		112
113	reg = pbase + ATR_PCIE_WIN0_T0_TRSL_ADDR + offset;	113	reg = pbase + ATR_PCIE_WIN0_T0_TRSL_ADDR + offset;
114	value = cfg->trsl_addr & ATR_PCIE_WIN0_ADDR_ALGMT;	114	value = cfg->trsl_addr & ATR_PCIE_WIN0_ADDR_ALGMT;
115	iowrite64(value, reg);	115	iowrite64_lo_hi(value, reg);
116		116
117	reg = pbase + ATR_PCIE_WIN0_T0_TRSL_PARAM + offset;	117	reg = pbase + ATR_PCIE_WIN0_T0_TRSL_PARAM + offset;
118	iowrite32(cfg->trsl_id, reg);	118	iowrite32(cfg->trsl_id, reg);
119		119
120	reg = pbase + ATR_PCIE_WIN0_T0_ATR_PARAM_SRC_ADDR + offset;	120	reg = pbase + ATR_PCIE_WIN0_T0_ATR_PARAM_SRC_ADDR + offset;
121	value = (cfg->src_addr & ATR_PCIE_WIN0_ADDR_ALGMT) \| (atr_size << 1) \| BIT(0);	121	value = (cfg->src_addr & ATR_PCIE_WIN0_ADDR_ALGMT) \| (atr_size << 1) \| BIT(0);
122	iowrite64(value, reg);	122	iowrite64_lo_hi(value, reg);
123		123
124	/* Ensure ATR is set */	124	/* Ensure ATR is set */
125	ioread64(reg);	125	ioread64_lo_hi(reg);
126	return 0;	126	return 0;
127	}	127	}
128		128

drivers/pinctrl/aspeed/Makefile+1−1

@@ -1,7 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	# Aspeed pinctrl support	2	# Aspeed pinctrl support
3		3
4	ccflags-y += $(call cc-option,-Woverride-init)	4	ccflags-y += -Woverride-init
5	obj-$(CONFIG_PINCTRL_ASPEED) += pinctrl-aspeed.o pinmux-aspeed.o	5	obj-$(CONFIG_PINCTRL_ASPEED) += pinctrl-aspeed.o pinmux-aspeed.o
6	obj-$(CONFIG_PINCTRL_ASPEED_G4) += pinctrl-aspeed-g4.o	6	obj-$(CONFIG_PINCTRL_ASPEED_G4) += pinctrl-aspeed-g4.o
7	obj-$(CONFIG_PINCTRL_ASPEED_G5) += pinctrl-aspeed-g5.o	7	obj-$(CONFIG_PINCTRL_ASPEED_G5) += pinctrl-aspeed-g5.o

drivers/pinctrl/pinctrl-amd.c+1−1

@@ -1159,7 +1159,7 @@ static int amd_gpio_probe(struct platform_device *pdev) · 1158 unmodified lines
1159	}	1159	}
1160		1160
1161	ret = devm_request_irq(&pdev->dev, gpio_dev->irq, amd_gpio_irq_handler,	1161	ret = devm_request_irq(&pdev->dev, gpio_dev->irq, amd_gpio_irq_handler,
1162	IRQF_SHARED \| IRQF_ONESHOT, KBUILD_MODNAME, gpio_dev);	1162	IRQF_SHARED \| IRQF_COND_ONESHOT, KBUILD_MODNAME, gpio_dev);
1163	if (ret)	1163	if (ret)
1164	goto out2;	1164	goto out2;
1165		1165

drivers/pwm/pwm-img.c+2−2

@@ -284,9 +284,9 @@ static int img_pwm_probe(struct platform_device *pdev) · 283 unmodified lines
284	return PTR_ERR(imgchip->sys_clk);	284	return PTR_ERR(imgchip->sys_clk);
285	}	285	}
286		286
287	imgchip->pwm_clk = devm_clk_get(&pdev->dev, "imgchip");	287	imgchip->pwm_clk = devm_clk_get(&pdev->dev, "pwm");
288	if (IS_ERR(imgchip->pwm_clk)) {	288	if (IS_ERR(imgchip->pwm_clk)) {
289	dev_err(&pdev->dev, "failed to get imgchip clock\n");	289	dev_err(&pdev->dev, "failed to get pwm clock\n");
290	return PTR_ERR(imgchip->pwm_clk);	290	return PTR_ERR(imgchip->pwm_clk);
291	}	291	}
292		292

drivers/ras/amd/fmpm.c+39−18

@@ -150,6 +150,8 @@ static unsigned int max_nr_fru; · 149 unmodified lines
150	/* Total length of record including headers and list of descriptor entries. */	150	/* Total length of record including headers and list of descriptor entries. */
151	static size_t max_rec_len;	151	static size_t max_rec_len;
152		152
		153	#define FMPM_MAX_REC_LEN (sizeof(struct fru_rec) + (sizeof(struct cper_fru_poison_desc) * 255))
		154
153	/* Total number of SPA entries across all FRUs. */	155	/* Total number of SPA entries across all FRUs. */
154	static unsigned int spa_nr_entries;	156	static unsigned int spa_nr_entries;
155		157
@@ -475,6 +477,16 @@ static void set_rec_fields(struct fru_rec *rec) · 319 unmodified lines
475	struct cper_section_descriptor *sec_desc = &rec->sec_desc;	477	struct cper_section_descriptor *sec_desc = &rec->sec_desc;
476	struct cper_record_header *hdr = &rec->hdr;	478	struct cper_record_header *hdr = &rec->hdr;
477		479
		480	/*
		481	* This is a saved record created with fewer max_nr_entries.
		482	* Update the record lengths and keep everything else as-is.
		483	*/
		484	if (hdr->record_length && hdr->record_length < max_rec_len) {
		485	pr_debug("Growing record 0x%016llx from %u to %zu bytes\n",
		486	hdr->record_id, hdr->record_length, max_rec_len);
		487	goto update_lengths;
		488	}
		489
478	memcpy(hdr->signature, CPER_SIG_RECORD, CPER_SIG_SIZE);	490	memcpy(hdr->signature, CPER_SIG_RECORD, CPER_SIG_SIZE);
479	hdr->revision = CPER_RECORD_REV;	491	hdr->revision = CPER_RECORD_REV;
480	hdr->signature_end = CPER_SIG_END;	492	hdr->signature_end = CPER_SIG_END;
@@ -489,19 +501,21 @@ static void set_rec_fields(struct fru_rec *rec) · 8 unmodified lines
489	hdr->error_severity = CPER_SEV_RECOVERABLE;	501	hdr->error_severity = CPER_SEV_RECOVERABLE;
490		502
491	hdr->validation_bits = 0;	503	hdr->validation_bits = 0;
492	hdr->record_length = max_rec_len;
493	hdr->creator_id = CPER_CREATOR_FMP;	504	hdr->creator_id = CPER_CREATOR_FMP;
494	hdr->notification_type = CPER_NOTIFY_MCE;	505	hdr->notification_type = CPER_NOTIFY_MCE;
495	hdr->record_id = cper_next_record_id();	506	hdr->record_id = cper_next_record_id();
496	hdr->flags = CPER_HW_ERROR_FLAGS_PREVERR;	507	hdr->flags = CPER_HW_ERROR_FLAGS_PREVERR;
497		508
498	sec_desc->section_offset = sizeof(struct cper_record_header);	509	sec_desc->section_offset = sizeof(struct cper_record_header);
499	sec_desc->section_length = max_rec_len - sizeof(struct cper_record_header);
500	sec_desc->revision = CPER_SEC_REV;	510	sec_desc->revision = CPER_SEC_REV;
501	sec_desc->validation_bits = 0;	511	sec_desc->validation_bits = 0;
502	sec_desc->flags = CPER_SEC_PRIMARY;	512	sec_desc->flags = CPER_SEC_PRIMARY;
503	sec_desc->section_type = CPER_SECTION_TYPE_FMP;	513	sec_desc->section_type = CPER_SECTION_TYPE_FMP;
504	sec_desc->section_severity = CPER_SEV_RECOVERABLE;	514	sec_desc->section_severity = CPER_SEV_RECOVERABLE;
		515
		516	update_lengths:
		517	hdr->record_length = max_rec_len;
		518	sec_desc->section_length = max_rec_len - sizeof(struct cper_record_header);
505	}	519	}
506		520
507	static int save_new_records(void)	521	static int save_new_records(void)
@@ -512,16 +526,18 @@ static int save_new_records(void) · 4 unmodified lines
512	int ret = 0;	526	int ret = 0;
513		527
514	for_each_fru(i, rec) {	528	for_each_fru(i, rec) {
515	if (rec->hdr.record_length)	529	/* No need to update saved records that match the current record size. */
		530	if (rec->hdr.record_length == max_rec_len)
516	continue;	531	continue;
517		532
		533	if (!rec->hdr.record_length)
		534	set_bit(i, new_records);
		535
518	set_rec_fields(rec);	536	set_rec_fields(rec);
519		537
520	ret = update_record_on_storage(rec);	538	ret = update_record_on_storage(rec);
521	if (ret)	539	if (ret)
522	goto out_clear;	540	goto out_clear;
523
524	set_bit(i, new_records);
525	}	541	}
526		542
527	return ret;	543	return ret;
@@ -641,12 +657,7 @@ static int get_saved_records(void) · 113 unmodified lines
641	int ret, pos;	657	int ret, pos;
642	ssize_t len;	658	ssize_t len;
643		659
644	/*	660	old = kmalloc(FMPM_MAX_REC_LEN, GFP_KERNEL);
645	* Assume saved records match current max size.
646	*
647	* However, this may not be true depending on module parameters.
648	*/
649	old = kmalloc(max_rec_len, GFP_KERNEL);
650	if (!old) {	661	if (!old) {
651	ret = -ENOMEM;	662	ret = -ENOMEM;
652	goto out;	663	goto out;
@@ -663,21 +674,31 @@ static int get_saved_records(void) · 10 unmodified lines
663	* Make sure to clear temporary buffer between reads to avoid	674	* Make sure to clear temporary buffer between reads to avoid
664	* leftover data from records of various sizes.	675	* leftover data from records of various sizes.
665	*/	676	*/
666	memset(old, 0, max_rec_len);	677	memset(old, 0, FMPM_MAX_REC_LEN);
667		678
668	len = erst_read_record(record_id, &old->hdr, max_rec_len,	679	len = erst_read_record(record_id, &old->hdr, FMPM_MAX_REC_LEN,
669	sizeof(struct fru_rec), &CPER_CREATOR_FMP);	680	sizeof(struct fru_rec), &CPER_CREATOR_FMP);
670	if (len < 0)	681	if (len < 0)
671	continue;	682	continue;
672		683
673	if (len > max_rec_len) {	684	new = get_valid_record(old);
674	pr_debug("Found record larger than max_rec_len\n");	685	if (!new) {
		686	erst_clear(record_id);
675	continue;	687	continue;
676	}	688	}
677		689
678	new = get_valid_record(old);	690	if (len > max_rec_len) {
679	if (!new)	691	unsigned int saved_nr_entries;
680	erst_clear(record_id);	692
		693	saved_nr_entries = len - sizeof(struct fru_rec);
		694	saved_nr_entries /= sizeof(struct cper_fru_poison_desc);
		695
		696	pr_warn("Saved record found with %u entries.\n", saved_nr_entries);
		697	pr_warn("Please increase max_nr_entries to %u.\n", saved_nr_entries);
		698
		699	ret = -EINVAL;
		700	goto out_end;
		701	}
681		702
682	/* Restore the record */	703	/* Restore the record */
683	memcpy(new, old, len);	704	memcpy(new, old, len);

drivers/ras/debugfs.h+4−0

@@ -4,6 +4,10 @@ · 3 unmodified lines
4		4
5	#include <linux/debugfs.h>	5	#include <linux/debugfs.h>
6		6
		7	#if IS_ENABLED(CONFIG_DEBUG_FS)
7	struct dentry *ras_get_debugfs_root(void);	8	struct dentry *ras_get_debugfs_root(void);
		9	#else
		10	static inline struct dentry *ras_get_debugfs_root(void) { return NULL; }
		11	#endif /* DEBUG_FS */
8		12
9	#endif /* __RAS_DEBUGFS_H__ */	13	#endif /* __RAS_DEBUGFS_H__ */

drivers/s390/net/qeth_core_main.c+36−2

@@ -1179,6 +1179,20 @@ static int qeth_check_irb_error(struct qeth_card card, struct ccw_device cdev, · 1178 unmodified lines
1179	}	1179	}
1180	}	1180	}
1181		1181
		1182	/**
		1183	* qeth_irq() - qeth interrupt handler
		1184	* @cdev: ccw device
		1185	* @intparm: expect pointer to iob
		1186	* @irb: Interruption Response Block
		1187	*
		1188	* In the good path:
		1189	* corresponding qeth channel is locked with last used iob as active_cmd.
		1190	* But this function is also called for error interrupts.
		1191	*
		1192	* Caller ensures that:
		1193	* Interrupts are disabled; ccw device lock is held;
		1194	*
		1195	*/
1182	static void qeth_irq(struct ccw_device *cdev, unsigned long intparm,	1196	static void qeth_irq(struct ccw_device *cdev, unsigned long intparm,
1183	struct irb *irb)	1197	struct irb *irb)
1184	{	1198	{
@@ -1220,11 +1234,10 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, · 35 unmodified lines
1220	iob = (struct qeth_cmd_buffer *) (addr_t)intparm;	1234	iob = (struct qeth_cmd_buffer *) (addr_t)intparm;
1221	}	1235	}
1222		1236
1223	qeth_unlock_channel(card, channel);
1224
1225	rc = qeth_check_irb_error(card, cdev, irb);	1237	rc = qeth_check_irb_error(card, cdev, irb);
1226	if (rc) {	1238	if (rc) {
1227	/* IO was terminated, free its resources. */	1239	/* IO was terminated, free its resources. */
		1240	qeth_unlock_channel(card, channel);
1228	if (iob)	1241	if (iob)
1229	qeth_cancel_cmd(iob, rc);	1242	qeth_cancel_cmd(iob, rc);
1230	return;	1243	return;
@@ -1268,6 +1281,7 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, · 37 unmodified lines
1268	rc = qeth_get_problem(card, cdev, irb);	1281	rc = qeth_get_problem(card, cdev, irb);
1269	if (rc) {	1282	if (rc) {
1270	card->read_or_write_problem = 1;	1283	card->read_or_write_problem = 1;
		1284	qeth_unlock_channel(card, channel);
1271	if (iob)	1285	if (iob)
1272	qeth_cancel_cmd(iob, rc);	1286	qeth_cancel_cmd(iob, rc);
1273	qeth_clear_ipacmd_list(card);	1287	qeth_clear_ipacmd_list(card);
@@ -1276,6 +1290,26 @@ static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, · 2 unmodified lines
1276	}	1290	}
1277	}	1291	}
1278		1292
		1293	if (scsw_cmd_is_valid_cc(&irb->scsw) && irb->scsw.cmd.cc == 1 && iob) {
		1294	/* channel command hasn't started: retry.
		1295	* active_cmd is still set to last iob
		1296	*/
		1297	QETH_CARD_TEXT(card, 2, "irqcc1");
		1298	rc = ccw_device_start_timeout(cdev, __ccw_from_cmd(iob),
		1299	(addr_t)iob, 0, 0, iob->timeout);
		1300	if (rc) {
		1301	QETH_DBF_MESSAGE(2,
		1302	"ccw retry on %x failed, rc = %i\n",
		1303	CARD_DEVID(card), rc);
		1304	QETH_CARD_TEXT_(card, 2, " err%d", rc);
		1305	qeth_unlock_channel(card, channel);
		1306	qeth_cancel_cmd(iob, rc);
		1307	}
		1308	return;
		1309	}
		1310
		1311	qeth_unlock_channel(card, channel);
		1312
1279	if (iob) {	1313	if (iob) {
1280	/* sanity check: */	1314	/* sanity check: */
1281	if (irb->scsw.cmd.count > iob->length) {	1315	if (irb->scsw.cmd.count > iob->length) {

drivers/scsi/bnx2fc/bnx2fc_tgt.c+0−2

 	BNX2FC_TGT_DBG(tgt, "Freeing up session resources\n");
-	spin_lock_bh(&tgt->cq_lock);
 	ctx_base_ptr = tgt->ctx_base;
 	tgt->ctx_base = NULL;
 				    tgt->sq, tgt->sq_dma);
 		tgt->sq = NULL;
 	}
-	spin_unlock_bh(&tgt->cq_lock);
 	if (ctx_base_ptr)
 		iounmap(ctx_base_ptr);

drivers/scsi/ch.c+10−10

 #define MAX_RETRIES   1
-static struct class * ch_sysfs_class;
+static const struct class ch_sysfs_class = {
+	.name = "scsi_changer",
+};
 typedef struct {
 	struct kref         ref;
 	mutex_init(&ch->lock);
 	kref_init(&ch->ref);
 	ch->device = sd;
-	class_dev = device_create(ch_sysfs_class, dev,
+	class_dev = device_create(&ch_sysfs_class, dev,
 				  MKDEV(SCSI_CHANGER_MAJOR, ch->minor), ch,
 				  "s%s", ch->name);
 	if (IS_ERR(class_dev)) {
 	return 0;
 destroy_dev:
-	device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR, ch->minor));
+	device_destroy(&ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR, ch->minor));
 put_device:
 	scsi_device_put(sd);
 remove_idr:
 	dev_set_drvdata(dev, NULL);
 	spin_unlock(&ch_index_lock);
-	device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
+	device_destroy(&ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR, ch->minor));
 	scsi_device_put(ch->device);
 	kref_put(&ch->ref, ch_destroy);
 	return 0;
 	int rc;
 	printk(KERN_INFO "SCSI Media Changer driver v" VERSION " \n");
-        ch_sysfs_class = class_create("scsi_changer");
+	rc = class_register(&ch_sysfs_class);
-        if (IS_ERR(ch_sysfs_class)) {
+	if (rc)
-		rc = PTR_ERR(ch_sysfs_class);
 		return rc;
-        }
 	rc = register_chrdev(SCSI_CHANGER_MAJOR,"ch",&changer_fops);
 	if (rc < 0) {
 		printk("Unable to get major %d for SCSI-Changer\n",
  fail2:
 	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
  fail1:
-	class_destroy(ch_sysfs_class);
+	class_unregister(&ch_sysfs_class);
 	return rc;
 }
 {
 	scsi_unregister_driver(&ch_template.gendrv);
 	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
-	class_destroy(ch_sysfs_class);
+	class_unregister(&ch_sysfs_class);
 	idr_destroy(&ch_index_idr);
 }

drivers/scsi/cxlflash/main.c+10−7

 MODULE_AUTHOR("Matthew R. Ochs <mrochs@linux.vnet.ibm.com>");
 MODULE_LICENSE("GPL");
-static struct class *cxlflash_class;
+static char *cxlflash_devnode(const struct device *dev, umode_t *mode);
+static const struct class cxlflash_class = {
+	.name = "cxlflash",
+	.devnode = cxlflash_devnode,
+};
 static u32 cxlflash_major;
 static DECLARE_BITMAP(cxlflash_minor, CXLFLASH_MAX_ADAPTERS);
 		goto err1;
 	}
-	char_dev = device_create(cxlflash_class, NULL, devno,
+	char_dev = device_create(&cxlflash_class, NULL, devno,
 				 NULL, "cxlflash%d", minor);
 	if (IS_ERR(char_dev)) {
 		rc = PTR_ERR(char_dev);
 	cxlflash_major = MAJOR(devno);
-	cxlflash_class = class_create("cxlflash");
+	rc = class_register(&cxlflash_class);
-	if (IS_ERR(cxlflash_class)) {
+	if (rc) {
-		rc = PTR_ERR(cxlflash_class);
 		pr_err("%s: class_create failed rc=%d\n", __func__, rc);
 		goto err;
 	}
-	cxlflash_class->devnode = cxlflash_devnode;
 out:
 	pr_debug("%s: returning rc=%d\n", __func__, rc);
 	return rc;
 {
 	dev_t devno = MKDEV(cxlflash_major, 0);
-	class_destroy(cxlflash_class);
+	class_unregister(&cxlflash_class);
 	unregister_chrdev_region(devno, CXLFLASH_MAX_ADAPTERS);
 }

drivers/scsi/hosts.c+4−3

 	if (shost->shost_state == SHOST_CREATED) {
 		/*
-		 * Free the shost_dev device name here if scsi_host_alloc()
+		 * Free the shost_dev device name and remove the proc host dir
-		 * and scsi_host_put() have been called but neither
+		 * here if scsi_host_{alloc,put}() have been called but neither
 		 * scsi_host_add() nor scsi_remove_host() has been called.
 		 * This avoids that the memory allocated for the shost_dev
-		 * name is leaked.
+		 * name as well as the proc dir structure are leaked.
 		 */
+		scsi_proc_hostdir_rm(shost->hostt);
 		kfree(dev_name(&shost->shost_dev));
 	}

drivers/scsi/libsas/sas_expander.c+34−17

 /* ---------- Domain revalidation ---------- */
+static void sas_get_sas_addr_and_dev_type(struct smp_disc_resp *disc_resp,
+					  u8 *sas_addr,
+					  enum sas_device_type *type)
+{
+	memcpy(sas_addr, disc_resp->disc.attached_sas_addr, SAS_ADDR_SIZE);
+	*type = to_dev_type(&disc_resp->disc);
+	if (*type == SAS_PHY_UNUSED)
+		memset(sas_addr, 0, SAS_ADDR_SIZE);
+}
 static int sas_get_phy_discover(struct domain_device *dev,
 				int phy_id, struct smp_disc_resp *disc_resp)
 {
 		return -ENOMEM;
 	res = sas_get_phy_discover(dev, phy_id, disc_resp);
-	if (res == 0) {
+	if (res == 0)
-		memcpy(sas_addr, disc_resp->disc.attached_sas_addr,
+		sas_get_sas_addr_and_dev_type(disc_resp, sas_addr, type);
-		       SAS_ADDR_SIZE);
-		*type = to_dev_type(&disc_resp->disc);
-		if (*type == 0)
-			memset(sas_addr, 0, SAS_ADDR_SIZE);
-	}
 	kfree(disc_resp);
 	return res;
 }
 	struct expander_device *ex = &dev->ex_dev;
 	struct ex_phy *phy = &ex->ex_phy[phy_id];
 	enum sas_device_type type = SAS_PHY_UNUSED;
+	struct smp_disc_resp *disc_resp;
 	u8 sas_addr[SAS_ADDR_SIZE];
 	char msg[80] = "";
 	int res;
 		 SAS_ADDR(dev->sas_addr), phy_id, msg);
 	memset(sas_addr, 0, SAS_ADDR_SIZE);
-	res = sas_get_phy_attached_dev(dev, phy_id, sas_addr, &type);
+	disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
+	if (!disc_resp)
+		return -ENOMEM;
+	res = sas_get_phy_discover(dev, phy_id, disc_resp);
 	switch (res) {
 	case SMP_RESP_NO_PHY:
 		phy->phy_state = PHY_NOT_PRESENT;
 		sas_unregister_devs_sas_addr(dev, phy_id, last);
-		return res;
+		goto out_free_resp;
 	case SMP_RESP_PHY_VACANT:
 		phy->phy_state = PHY_VACANT;
 		sas_unregister_devs_sas_addr(dev, phy_id, last);
-		return res;
+		goto out_free_resp;
 	case SMP_RESP_FUNC_ACC:
 		break;
 	case -ECOMM:
 		break;
 	default:
-		return res;
+		goto out_free_resp;
 	}
+	if (res == 0)
+		sas_get_sas_addr_and_dev_type(disc_resp, sas_addr, &type);
 	if ((SAS_ADDR(sas_addr) == 0) || (res == -ECOMM)) {
 		phy->phy_state = PHY_EMPTY;
 		sas_unregister_devs_sas_addr(dev, phy_id, last);
 		/*
-		 * Even though the PHY is empty, for convenience we discover
+		 * Even though the PHY is empty, for convenience we update
-		 * the PHY to update the PHY info, like negotiated linkrate.
+		 * the PHY info, like negotiated linkrate.
 		 */
-		sas_ex_phy_discover(dev, phy_id);
+		if (res == 0)
-		return res;
+			sas_set_ex_phy(dev, phy_id, disc_resp);
+		goto out_free_resp;
 	} else if (SAS_ADDR(sas_addr) == SAS_ADDR(phy->attached_sas_addr) &&
 		   dev_type_flutter(type, phy->attached_dev_type)) {
 		struct domain_device *ata_dev = sas_ex_to_ata(dev, phy_id);
 			action = ", needs recovery";
 		pr_debug("ex %016llx phy%02d broadcast flutter%s\n",
 			 SAS_ADDR(dev->sas_addr), phy_id, action);
-		return res;
+		goto out_free_resp;
 	}
 	/* we always have to delete the old device when we went here */
 		SAS_ADDR(phy->attached_sas_addr));
 	sas_unregister_devs_sas_addr(dev, phy_id, last);
-	return sas_discover_new(dev, phy_id);
+	res = sas_discover_new(dev, phy_id);
+out_free_resp:
+	kfree(disc_resp);
+	return res;
 }
 /**

drivers/scsi/lpfc/lpfc.h+1−1

 	struct timer_list fabric_block_timer;
 	unsigned long bit_flags;
 	atomic_t num_rsrc_err;
-	atomic_t num_cmd_success;
 	unsigned long last_rsrc_error_time;
 	unsigned long last_ramp_down_time;
 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
 	struct timer_list inactive_vmid_poll;
 	/* RAS Support */
+	spinlock_t ras_fwlog_lock; /* do not take while holding another lock */
 	struct lpfc_ras_fwlog ras_fwlog;
 	uint32_t iocb_cnt;

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

@@ -5865,9 +5865,9 @@ lpfc_ras_fwlog_buffsize_set(struct lpfc_hba *phba, uint val) · 5864 unmodified lines
5865	if (phba->cfg_ras_fwlog_func != PCI_FUNC(phba->pcidev->devfn))	5865	if (phba->cfg_ras_fwlog_func != PCI_FUNC(phba->pcidev->devfn))
5866	return -EINVAL;	5866	return -EINVAL;
5867		5867
5868	spin_lock_irq(&phba->hbalock);	5868	spin_lock_irq(&phba->ras_fwlog_lock);
5869	state = phba->ras_fwlog.state;	5869	state = phba->ras_fwlog.state;
5870	spin_unlock_irq(&phba->hbalock);	5870	spin_unlock_irq(&phba->ras_fwlog_lock);
5871		5871
5872	if (state == REG_INPROGRESS) {	5872	if (state == REG_INPROGRESS) {
5873	lpfc_printf_log(phba, KERN_ERR, LOG_SLI, "6147 RAS Logging "	5873	lpfc_printf_log(phba, KERN_ERR, LOG_SLI, "6147 RAS Logging "

drivers/scsi/lpfc/lpfc_bsg.c+20−20

@@ -2513,7 +2513,7 @@ static int lpfcdiag_loop_self_reg(struct lpfc_hba phba, uint16_t rpi) · 2512 unmodified lines
2513	return -ENOMEM;	2513	return -ENOMEM;
2514	}	2514	}
2515		2515
2516	dmabuff = (struct lpfc_dmabuf *)mbox->ctx_buf;	2516	dmabuff = mbox->ctx_buf;
2517	mbox->ctx_buf = NULL;	2517	mbox->ctx_buf = NULL;
2518	mbox->ctx_ndlp = NULL;	2518	mbox->ctx_ndlp = NULL;
2519	status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);	2519	status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
@@ -3169,10 +3169,10 @@ lpfc_bsg_diag_loopback_run(struct bsg_job *job) · 649 unmodified lines
3169	}	3169	}
3170		3170
3171	cmdwqe = &cmdiocbq->wqe;	3171	cmdwqe = &cmdiocbq->wqe;
3172	memset(cmdwqe, 0, sizeof(union lpfc_wqe));	3172	memset(cmdwqe, 0, sizeof(*cmdwqe));
3173	if (phba->sli_rev < LPFC_SLI_REV4) {	3173	if (phba->sli_rev < LPFC_SLI_REV4) {
3174	rspwqe = &rspiocbq->wqe;	3174	rspwqe = &rspiocbq->wqe;
3175	memset(rspwqe, 0, sizeof(union lpfc_wqe));	3175	memset(rspwqe, 0, sizeof(*rspwqe));
3176	}	3176	}
3177		3177
3178	INIT_LIST_HEAD(&head);	3178	INIT_LIST_HEAD(&head);
@@ -3376,7 +3376,7 @@ lpfc_bsg_issue_mbox_cmpl(struct lpfc_hba phba, LPFC_MBOXQ_t pmboxq) · 197 unmodified lines
3376	unsigned long flags;	3376	unsigned long flags;
3377	uint8_t pmb, pmb_buf;	3377	uint8_t pmb, pmb_buf;
3378		3378
3379	dd_data = pmboxq->ctx_ndlp;	3379	dd_data = pmboxq->ctx_u.dd_data;
3380		3380
3381	/*	3381	/*
3382	* The outgoing buffer is readily referred from the dma buffer,	3382	* The outgoing buffer is readily referred from the dma buffer,
@@ -3553,7 +3553,7 @@ lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba phba, LPFC_MBOXQ_t pmboxq) · 170 unmodified lines
3553	struct lpfc_sli_config_mbox *sli_cfg_mbx;	3553	struct lpfc_sli_config_mbox *sli_cfg_mbx;
3554	uint8_t *pmbx;	3554	uint8_t *pmbx;
3555		3555
3556	dd_data = pmboxq->ctx_buf;	3556	dd_data = pmboxq->ctx_u.dd_data;
3557		3557
3558	/* Determine if job has been aborted */	3558	/* Determine if job has been aborted */
3559	spin_lock_irqsave(&phba->ct_ev_lock, flags);	3559	spin_lock_irqsave(&phba->ct_ev_lock, flags);
@@ -3940,7 +3940,7 @@ lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba phba, struct bsg_job job, · 380 unmodified lines
3940	pmboxq->mbox_cmpl = lpfc_bsg_issue_read_mbox_ext_cmpl;	3940	pmboxq->mbox_cmpl = lpfc_bsg_issue_read_mbox_ext_cmpl;
3941		3941
3942	/* context fields to callback function */	3942	/* context fields to callback function */
3943	pmboxq->ctx_buf = dd_data;	3943	pmboxq->ctx_u.dd_data = dd_data;
3944	dd_data->type = TYPE_MBOX;	3944	dd_data->type = TYPE_MBOX;
3945	dd_data->set_job = job;	3945	dd_data->set_job = job;
3946	dd_data->context_un.mbox.pmboxq = pmboxq;	3946	dd_data->context_un.mbox.pmboxq = pmboxq;
@@ -4112,7 +4112,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba phba, struct bsg_job job, · 165 unmodified lines
4112	pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;	4112	pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
4113		4113
4114	/* context fields to callback function */	4114	/* context fields to callback function */
4115	pmboxq->ctx_buf = dd_data;	4115	pmboxq->ctx_u.dd_data = dd_data;
4116	dd_data->type = TYPE_MBOX;	4116	dd_data->type = TYPE_MBOX;
4117	dd_data->set_job = job;	4117	dd_data->set_job = job;
4118	dd_data->context_un.mbox.pmboxq = pmboxq;	4118	dd_data->context_un.mbox.pmboxq = pmboxq;
@@ -4460,7 +4460,7 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba phba, struct bsg_job job, · 341 unmodified lines
4460	pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;	4460	pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
4461		4461
4462	/* context fields to callback function */	4462	/* context fields to callback function */
4463	pmboxq->ctx_buf = dd_data;	4463	pmboxq->ctx_u.dd_data = dd_data;
4464	dd_data->type = TYPE_MBOX;	4464	dd_data->type = TYPE_MBOX;
4465	dd_data->set_job = job;	4465	dd_data->set_job = job;
4466	dd_data->context_un.mbox.pmboxq = pmboxq;	4466	dd_data->context_un.mbox.pmboxq = pmboxq;
@@ -4747,7 +4747,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba phba, struct bsg_job job, · 280 unmodified lines
4747	if (mbox_req->inExtWLen \|\| mbox_req->outExtWLen) {	4747	if (mbox_req->inExtWLen \|\| mbox_req->outExtWLen) {
4748	from = pmbx;	4748	from = pmbx;
4749	ext = from + sizeof(MAILBOX_t);	4749	ext = from + sizeof(MAILBOX_t);
4750	pmboxq->ctx_buf = ext;	4750	pmboxq->ext_buf = ext;
4751	pmboxq->in_ext_byte_len =	4751	pmboxq->in_ext_byte_len =
4752	mbox_req->inExtWLen * sizeof(uint32_t);	4752	mbox_req->inExtWLen * sizeof(uint32_t);
4753	pmboxq->out_ext_byte_len =	4753	pmboxq->out_ext_byte_len =
@@ -4875,7 +4875,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba phba, struct bsg_job job, · 121 unmodified lines
4875	pmboxq->mbox_cmpl = lpfc_bsg_issue_mbox_cmpl;	4875	pmboxq->mbox_cmpl = lpfc_bsg_issue_mbox_cmpl;
4876		4876
4877	/* setup context field to pass wait_queue pointer to wake function */	4877	/* setup context field to pass wait_queue pointer to wake function */
4878	pmboxq->ctx_ndlp = dd_data;	4878	pmboxq->ctx_u.dd_data = dd_data;
4879	dd_data->type = TYPE_MBOX;	4879	dd_data->type = TYPE_MBOX;
4880	dd_data->set_job = job;	4880	dd_data->set_job = job;
4881	dd_data->context_un.mbox.pmboxq = pmboxq;	4881	dd_data->context_un.mbox.pmboxq = pmboxq;
@@ -5070,12 +5070,12 @@ lpfc_bsg_get_ras_config(struct bsg_job *job) · 188 unmodified lines
5070	bsg_reply->reply_data.vendor_reply.vendor_rsp;	5070	bsg_reply->reply_data.vendor_reply.vendor_rsp;
5071		5071
5072	/* Current logging state */	5072	/* Current logging state */
5073	spin_lock_irq(&phba->hbalock);	5073	spin_lock_irq(&phba->ras_fwlog_lock);
5074	if (ras_fwlog->state == ACTIVE)	5074	if (ras_fwlog->state == ACTIVE)
5075	ras_reply->state = LPFC_RASLOG_STATE_RUNNING;	5075	ras_reply->state = LPFC_RASLOG_STATE_RUNNING;
5076	else	5076	else
5077	ras_reply->state = LPFC_RASLOG_STATE_STOPPED;	5077	ras_reply->state = LPFC_RASLOG_STATE_STOPPED;
5078	spin_unlock_irq(&phba->hbalock);	5078	spin_unlock_irq(&phba->ras_fwlog_lock);
5079		5079
5080	ras_reply->log_level = phba->ras_fwlog.fw_loglevel;	5080	ras_reply->log_level = phba->ras_fwlog.fw_loglevel;
5081	ras_reply->log_buff_sz = phba->cfg_ras_fwlog_buffsize;	5081	ras_reply->log_buff_sz = phba->cfg_ras_fwlog_buffsize;
@@ -5132,13 +5132,13 @@ lpfc_bsg_set_ras_config(struct bsg_job *job) · 50 unmodified lines
5132		5132
5133	if (action == LPFC_RASACTION_STOP_LOGGING) {	5133	if (action == LPFC_RASACTION_STOP_LOGGING) {
5134	/* Check if already disabled */	5134	/* Check if already disabled */
5135	spin_lock_irq(&phba->hbalock);	5135	spin_lock_irq(&phba->ras_fwlog_lock);
5136	if (ras_fwlog->state != ACTIVE) {	5136	if (ras_fwlog->state != ACTIVE) {
5137	spin_unlock_irq(&phba->hbalock);	5137	spin_unlock_irq(&phba->ras_fwlog_lock);
5138	rc = -ESRCH;	5138	rc = -ESRCH;
5139	goto ras_job_error;	5139	goto ras_job_error;
5140	}	5140	}
5141	spin_unlock_irq(&phba->hbalock);	5141	spin_unlock_irq(&phba->ras_fwlog_lock);
5142		5142
5143	/* Disable logging */	5143	/* Disable logging */
5144	lpfc_ras_stop_fwlog(phba);	5144	lpfc_ras_stop_fwlog(phba);
@@ -5149,10 +5149,10 @@ lpfc_bsg_set_ras_config(struct bsg_job *job) · 4 unmodified lines
5149	* FW-logging with new log-level. Return status	5149	* FW-logging with new log-level. Return status
5150	* "Logging already Running" to caller.	5150	* "Logging already Running" to caller.
5151	**/	5151	**/
5152	spin_lock_irq(&phba->hbalock);	5152	spin_lock_irq(&phba->ras_fwlog_lock);
5153	if (ras_fwlog->state != INACTIVE)	5153	if (ras_fwlog->state != INACTIVE)
5154	action_status = -EINPROGRESS;	5154	action_status = -EINPROGRESS;
5155	spin_unlock_irq(&phba->hbalock);	5155	spin_unlock_irq(&phba->ras_fwlog_lock);
5156		5156
5157	/* Enable logging */	5157	/* Enable logging */
5158	rc = lpfc_sli4_ras_fwlog_init(phba, log_level,	5158	rc = lpfc_sli4_ras_fwlog_init(phba, log_level,
@@ -5268,13 +5268,13 @@ lpfc_bsg_get_ras_fwlog(struct bsg_job *job) · 109 unmodified lines
5268	goto ras_job_error;	5268	goto ras_job_error;
5269		5269
5270	/* Logging to be stopped before reading */	5270	/* Logging to be stopped before reading */
5271	spin_lock_irq(&phba->hbalock);	5271	spin_lock_irq(&phba->ras_fwlog_lock);
5272	if (ras_fwlog->state == ACTIVE) {	5272	if (ras_fwlog->state == ACTIVE) {
5273	spin_unlock_irq(&phba->hbalock);	5273	spin_unlock_irq(&phba->ras_fwlog_lock);
5274	rc = -EINPROGRESS;	5274	rc = -EINPROGRESS;
5275	goto ras_job_error;	5275	goto ras_job_error;
5276	}	5276	}
5277	spin_unlock_irq(&phba->hbalock);	5277	spin_unlock_irq(&phba->ras_fwlog_lock);
5278		5278
5279	if (job->request_len <	5279	if (job->request_len <
5280	sizeof(struct fc_bsg_request) +	5280	sizeof(struct fc_bsg_request) +

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

@@ -2194,12 +2194,12 @@ static int lpfc_debugfs_ras_log_data(struct lpfc_hba *phba, · 2193 unmodified lines
2194		2194
2195	memset(buffer, 0, size);	2195	memset(buffer, 0, size);
2196		2196
2197	spin_lock_irq(&phba->hbalock);	2197	spin_lock_irq(&phba->ras_fwlog_lock);
2198	if (phba->ras_fwlog.state != ACTIVE) {	2198	if (phba->ras_fwlog.state != ACTIVE) {
2199	spin_unlock_irq(&phba->hbalock);	2199	spin_unlock_irq(&phba->ras_fwlog_lock);
2200	return -EINVAL;	2200	return -EINVAL;
2201	}	2201	}
2202	spin_unlock_irq(&phba->hbalock);	2202	spin_unlock_irq(&phba->ras_fwlog_lock);
2203		2203
2204	list_for_each_entry_safe(dmabuf, next,	2204	list_for_each_entry_safe(dmabuf, next,
2205	&phba->ras_fwlog.fwlog_buff_list, list) {	2205	&phba->ras_fwlog.fwlog_buff_list, list) {
@@ -2250,13 +2250,13 @@ lpfc_debugfs_ras_log_open(struct inode inode, struct file file) · 44 unmodified lines
2250	int size;	2250	int size;
2251	int rc = -ENOMEM;	2251	int rc = -ENOMEM;
2252		2252
2253	spin_lock_irq(&phba->hbalock);	2253	spin_lock_irq(&phba->ras_fwlog_lock);
2254	if (phba->ras_fwlog.state != ACTIVE) {	2254	if (phba->ras_fwlog.state != ACTIVE) {
2255	spin_unlock_irq(&phba->hbalock);	2255	spin_unlock_irq(&phba->ras_fwlog_lock);
2256	rc = -EINVAL;	2256	rc = -EINVAL;
2257	goto out;	2257	goto out;
2258	}	2258	}
2259	spin_unlock_irq(&phba->hbalock);	2259	spin_unlock_irq(&phba->ras_fwlog_lock);
2260		2260
2261	if (check_mul_overflow(LPFC_RAS_MIN_BUFF_POST_SIZE,	2261	if (check_mul_overflow(LPFC_RAS_MIN_BUFF_POST_SIZE,
2262	phba->cfg_ras_fwlog_buffsize, &size))	2262	phba->cfg_ras_fwlog_buffsize, &size))

drivers/scsi/lpfc/lpfc_els.c+21−24

@@ -4437,23 +4437,23 @@ lpfc_els_retry_delay(struct timer_list *t) · 4436 unmodified lines
4437	unsigned long flags;	4437	unsigned long flags;
4438	struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;	4438	struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;
4439		4439
		4440	/* Hold a node reference for outstanding queued work */
		4441	if (!lpfc_nlp_get(ndlp))
		4442	return;
		4443
4440	spin_lock_irqsave(&phba->hbalock, flags);	4444	spin_lock_irqsave(&phba->hbalock, flags);
4441	if (!list_empty(&evtp->evt_listp)) {	4445	if (!list_empty(&evtp->evt_listp)) {
4442	spin_unlock_irqrestore(&phba->hbalock, flags);	4446	spin_unlock_irqrestore(&phba->hbalock, flags);
		4447	lpfc_nlp_put(ndlp);
4443	return;	4448	return;
4444	}	4449	}
4445		4450
4446	/* We need to hold the node by incrementing the reference	4451	evtp->evt_arg1 = ndlp;
4447	* count until the queued work is done	4452	evtp->evt = LPFC_EVT_ELS_RETRY;
4448	*/	4453	list_add_tail(&evtp->evt_listp, &phba->work_list);
4449	evtp->evt_arg1 = lpfc_nlp_get(ndlp);
4450	if (evtp->evt_arg1) {
4451	evtp->evt = LPFC_EVT_ELS_RETRY;
4452	list_add_tail(&evtp->evt_listp, &phba->work_list);
4453	lpfc_worker_wake_up(phba);
4454	}
4455	spin_unlock_irqrestore(&phba->hbalock, flags);	4454	spin_unlock_irqrestore(&phba->hbalock, flags);
4456	return;	4455
		4456	lpfc_worker_wake_up(phba);
4457	}	4457	}
4458		4458
4459	/**	4459	/**
@@ -7238,7 +7238,7 @@ lpfc_get_rdp_info(struct lpfc_hba phba, struct lpfc_rdp_context rdp_context) · 2778 unmodified lines
7238	goto rdp_fail;	7238	goto rdp_fail;
7239	mbox->vport = rdp_context->ndlp->vport;	7239	mbox->vport = rdp_context->ndlp->vport;
7240	mbox->mbox_cmpl = lpfc_mbx_cmpl_rdp_page_a0;	7240	mbox->mbox_cmpl = lpfc_mbx_cmpl_rdp_page_a0;
7241	mbox->ctx_ndlp = (struct lpfc_rdp_context *)rdp_context;	7241	mbox->ctx_u.rdp = rdp_context;
7242	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);	7242	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
7243	if (rc == MBX_NOT_FINISHED) {	7243	if (rc == MBX_NOT_FINISHED) {
7244	lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);	7244	lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
@@ -7290,7 +7290,7 @@ int lpfc_get_sfp_info_wait(struct lpfc_hba *phba, · 45 unmodified lines
7290	mbox->in_ext_byte_len = DMP_SFF_PAGE_A0_SIZE;	7290	mbox->in_ext_byte_len = DMP_SFF_PAGE_A0_SIZE;
7291	mbox->out_ext_byte_len = DMP_SFF_PAGE_A0_SIZE;	7291	mbox->out_ext_byte_len = DMP_SFF_PAGE_A0_SIZE;
7292	mbox->mbox_offset_word = 5;	7292	mbox->mbox_offset_word = 5;
7293	mbox->ctx_buf = virt;	7293	mbox->ext_buf = virt;
7294	} else {	7294	} else {
7295	bf_set(lpfc_mbx_memory_dump_type3_length,	7295	bf_set(lpfc_mbx_memory_dump_type3_length,
7296	&mbox->u.mqe.un.mem_dump_type3, DMP_SFF_PAGE_A0_SIZE);	7296	&mbox->u.mqe.un.mem_dump_type3, DMP_SFF_PAGE_A0_SIZE);
@@ -7298,7 +7298,6 @@ int lpfc_get_sfp_info_wait(struct lpfc_hba *phba, · 1 unmodified line
7298	mbox->u.mqe.un.mem_dump_type3.addr_hi = putPaddrHigh(mp->phys);	7298	mbox->u.mqe.un.mem_dump_type3.addr_hi = putPaddrHigh(mp->phys);
7299	}	7299	}
7300	mbox->vport = phba->pport;	7300	mbox->vport = phba->pport;
7301	mbox->ctx_ndlp = (struct lpfc_rdp_context *)rdp_context;
7302		7301
7303	rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);	7302	rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);
7304	if (rc == MBX_NOT_FINISHED) {	7303	if (rc == MBX_NOT_FINISHED) {
@@ -7307,7 +7306,7 @@ int lpfc_get_sfp_info_wait(struct lpfc_hba *phba, · 2 unmodified lines
7307	}	7306	}
7308		7307
7309	if (phba->sli_rev == LPFC_SLI_REV4)	7308	if (phba->sli_rev == LPFC_SLI_REV4)
7310	mp = (struct lpfc_dmabuf *)(mbox->ctx_buf);	7309	mp = mbox->ctx_buf;
7311	else	7310	else
7312	mp = mpsave;	7311	mp = mpsave;
7313		7312
@@ -7350,7 +7349,7 @@ int lpfc_get_sfp_info_wait(struct lpfc_hba *phba, · 36 unmodified lines
7350	mbox->in_ext_byte_len = DMP_SFF_PAGE_A2_SIZE;	7349	mbox->in_ext_byte_len = DMP_SFF_PAGE_A2_SIZE;
7351	mbox->out_ext_byte_len = DMP_SFF_PAGE_A2_SIZE;	7350	mbox->out_ext_byte_len = DMP_SFF_PAGE_A2_SIZE;
7352	mbox->mbox_offset_word = 5;	7351	mbox->mbox_offset_word = 5;
7353	mbox->ctx_buf = virt;	7352	mbox->ext_buf = virt;
7354	} else {	7353	} else {
7355	bf_set(lpfc_mbx_memory_dump_type3_length,	7354	bf_set(lpfc_mbx_memory_dump_type3_length,
7356	&mbox->u.mqe.un.mem_dump_type3, DMP_SFF_PAGE_A2_SIZE);	7355	&mbox->u.mqe.un.mem_dump_type3, DMP_SFF_PAGE_A2_SIZE);
@@ -7358,7 +7357,6 @@ int lpfc_get_sfp_info_wait(struct lpfc_hba *phba, · 1 unmodified line
7358	mbox->u.mqe.un.mem_dump_type3.addr_hi = putPaddrHigh(mp->phys);	7357	mbox->u.mqe.un.mem_dump_type3.addr_hi = putPaddrHigh(mp->phys);
7359	}	7358	}
7360		7359
7361	mbox->ctx_ndlp = (struct lpfc_rdp_context *)rdp_context;
7362	rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);	7360	rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);
7363	if (bf_get(lpfc_mqe_status, &mbox->u.mqe)) {	7361	if (bf_get(lpfc_mqe_status, &mbox->u.mqe)) {
7364	rc = 1;	7362	rc = 1;
@@ -7500,9 +7498,9 @@ lpfc_els_lcb_rsp(struct lpfc_hba phba, LPFC_MBOXQ_t pmb) · 135 unmodified lines
7500	int rc;	7498	int rc;
7501		7499
7502	mb = &pmb->u.mb;	7500	mb = &pmb->u.mb;
7503	lcb_context = (struct lpfc_lcb_context *)pmb->ctx_ndlp;	7501	lcb_context = pmb->ctx_u.lcb;
7504	ndlp = lcb_context->ndlp;	7502	ndlp = lcb_context->ndlp;
7505	pmb->ctx_ndlp = NULL;	7503	memset(&pmb->ctx_u, 0, sizeof(pmb->ctx_u));
7506	pmb->ctx_buf = NULL;	7504	pmb->ctx_buf = NULL;
7507		7505
7508	shdr = (union lpfc_sli4_cfg_shdr *)	7506	shdr = (union lpfc_sli4_cfg_shdr *)
@@ -7642,7 +7640,7 @@ lpfc_sli4_set_beacon(struct lpfc_vport *vport, · 133 unmodified lines
7642	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,	7640	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
7643	LPFC_MBOX_OPCODE_SET_BEACON_CONFIG, len,	7641	LPFC_MBOX_OPCODE_SET_BEACON_CONFIG, len,
7644	LPFC_SLI4_MBX_EMBED);	7642	LPFC_SLI4_MBX_EMBED);
7645	mbox->ctx_ndlp = (void *)lcb_context;	7643	mbox->ctx_u.lcb = lcb_context;
7646	mbox->vport = phba->pport;	7644	mbox->vport = phba->pport;
7647	mbox->mbox_cmpl = lpfc_els_lcb_rsp;	7645	mbox->mbox_cmpl = lpfc_els_lcb_rsp;
7648	bf_set(lpfc_mbx_set_beacon_port_num, &mbox->u.mqe.un.beacon_config,	7646	bf_set(lpfc_mbx_set_beacon_port_num, &mbox->u.mqe.un.beacon_config,
@@ -8639,9 +8637,9 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba phba, LPFC_MBOXQ_t pmb) · 990 unmodified lines
8639	mb = &pmb->u.mb;	8637	mb = &pmb->u.mb;
8640		8638
8641	ndlp = pmb->ctx_ndlp;	8639	ndlp = pmb->ctx_ndlp;
8642	rxid = (uint16_t)((unsigned long)(pmb->ctx_buf) & 0xffff);	8640	rxid = (uint16_t)(pmb->ctx_u.ox_rx_id & 0xffff);
8643	oxid = (uint16_t)(((unsigned long)(pmb->ctx_buf) >> 16) & 0xffff);	8641	oxid = (uint16_t)((pmb->ctx_u.ox_rx_id >> 16) & 0xffff);
8644	pmb->ctx_buf = NULL;	8642	memset(&pmb->ctx_u, 0, sizeof(pmb->ctx_u));
8645	pmb->ctx_ndlp = NULL;	8643	pmb->ctx_ndlp = NULL;
8646		8644
8647	if (mb->mbxStatus) {	8645	if (mb->mbxStatus) {
@@ -8745,8 +8743,7 @@ lpfc_els_rcv_rls(struct lpfc_vport vport, struct lpfc_iocbq cmdiocb, · 97 unmodified lines
8745	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);	8743	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
8746	if (mbox) {	8744	if (mbox) {
8747	lpfc_read_lnk_stat(phba, mbox);	8745	lpfc_read_lnk_stat(phba, mbox);
8748	mbox->ctx_buf = (void *)((unsigned long)	8746	mbox->ctx_u.ox_rx_id = ox_id << 16 \| ctx;
8749	(ox_id << 16 \| ctx));
8750	mbox->ctx_ndlp = lpfc_nlp_get(ndlp);	8747	mbox->ctx_ndlp = lpfc_nlp_get(ndlp);
8751	if (!mbox->ctx_ndlp)	8748	if (!mbox->ctx_ndlp)
8752	goto node_err;	8749	goto node_err;

drivers/scsi/lpfc/lpfc_hbadisc.c+16−17

 		if (evtp->evt_arg1) {
 			evtp->evt = LPFC_EVT_DEV_LOSS;
 			list_add_tail(&evtp->evt_listp, &phba->work_list);
+			spin_unlock_irqrestore(&phba->hbalock, iflags);
 			lpfc_worker_wake_up(phba);
+			return;
 		}
 		spin_unlock_irqrestore(&phba->hbalock, iflags);
 	} else {
 			lpfc_disc_state_machine(vport, ndlp, NULL,
 						NLP_EVT_DEVICE_RM);
 		}
 	}
-	return;
 }
 /**
 lpfc_mbx_cmpl_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+	struct lpfc_dmabuf *mp = pmb->ctx_buf;
 	struct lpfc_vport  *vport = pmb->vport;
 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 	struct serv_parm *sp = &vport->fc_sparam;
 	struct lpfc_mbx_read_top *la;
 	struct lpfc_sli_ring *pring;
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *)(pmb->ctx_buf);
+	struct lpfc_dmabuf *mp = pmb->ctx_buf;
 	uint8_t attn_type;
 	/* Unblock ELS traffic */
 lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
 	struct lpfc_vport  *vport = pmb->vport;
-	struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+	struct lpfc_dmabuf *mp = pmb->ctx_buf;
-	struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+	struct lpfc_nodelist *ndlp = pmb->ctx_ndlp;
 	/* The driver calls the state machine with the pmb pointer
 	 * but wants to make sure a stale ctx_buf isn't acted on.
 		 * the dump routine is a single-use construct.
 		 */
 		if (pmb->ctx_buf) {
-			mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+			mp = pmb->ctx_buf;
 			lpfc_mbuf_free(phba, mp->virt, mp->phys);
 			kfree(mp);
 			pmb->ctx_buf = NULL;
 		if (phba->sli_rev == LPFC_SLI_REV4) {
 			byte_count = pmb->u.mqe.un.mb_words[5];
-			mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+			mp = pmb->ctx_buf;
 			if (byte_count > sizeof(struct static_vport_info) -
 					offset)
 				byte_count = sizeof(struct static_vport_info)
 {
 	struct lpfc_vport *vport = pmb->vport;
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+	struct lpfc_nodelist *ndlp = pmb->ctx_ndlp;
 	pmb->ctx_ndlp = NULL;
 lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+	struct lpfc_nodelist *ndlp = pmb->ctx_ndlp;
 	struct lpfc_vport *vport = pmb->vport;
 	int rc;
 {
 	struct lpfc_vport *vport = pmb->vport;
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+	struct lpfc_nodelist *ndlp = pmb->ctx_ndlp;
 	pmb->ctx_ndlp = NULL;
 	if (mb->mbxStatus) {
 	struct lpfc_vport  *vport = pmb->vport;
 	struct lpfc_nodelist *ndlp;
-	ndlp = (struct lpfc_nodelist *)(pmb->ctx_ndlp);
+	ndlp = pmb->ctx_ndlp;
 	if (!ndlp)
 		return;
 	lpfc_issue_els_logo(vport, ndlp, 0);
 	if ((mb = phba->sli.mbox_active)) {
 		if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
 		   !(mb->mbox_flag & LPFC_MBX_IMED_UNREG) &&
-		   (ndlp == (struct lpfc_nodelist *)mb->ctx_ndlp)) {
+		   (ndlp == mb->ctx_ndlp)) {
 			mb->ctx_ndlp = NULL;
 			mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 		}
 	list_for_each_entry(mb, &phba->sli.mboxq_cmpl, list) {
 		if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) ||
 			(mb->mbox_flag & LPFC_MBX_IMED_UNREG) ||
-			(ndlp != (struct lpfc_nodelist *)mb->ctx_ndlp))
+			(ndlp != mb->ctx_ndlp))
 			continue;
 		mb->ctx_ndlp = NULL;
 	list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
 		if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
 		   !(mb->mbox_flag & LPFC_MBX_IMED_UNREG) &&
-		    (ndlp == (struct lpfc_nodelist *)mb->ctx_ndlp)) {
+		    (ndlp == mb->ctx_ndlp)) {
 			list_del(&mb->list);
 			lpfc_mbox_rsrc_cleanup(phba, mb, MBOX_THD_LOCKED);
 lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
 	MAILBOX_t *mb = &pmb->u.mb;
-	struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+	struct lpfc_nodelist *ndlp = pmb->ctx_ndlp;
 	struct lpfc_vport    *vport = pmb->vport;
 	pmb->ctx_ndlp = NULL;

drivers/scsi/lpfc/lpfc_init.c+8−5

 		return -EIO;
 	}
-	mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+	mp = pmb->ctx_buf;
 	/* This dmabuf was allocated by lpfc_read_sparam. The dmabuf is no
 	 * longer needed.  Prevent unintended ctx_buf access as the mbox is
 	/* Cleanup any outstanding ELS commands */
 	lpfc_els_flush_all_cmd(phba);
 	psli->slistat.link_event++;
-	lpfc_read_topology(phba, pmb, (struct lpfc_dmabuf *)pmb->ctx_buf);
+	lpfc_read_topology(phba, pmb, pmb->ctx_buf);
 	pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
 	pmb->vport = vport;
 	/* Block ELS IOCBs until we have processed this mbox command */
 	phba->sli.slistat.link_event++;
 	/* Create lpfc_handle_latt mailbox command from link ACQE */
-	lpfc_read_topology(phba, pmb, (struct lpfc_dmabuf *)pmb->ctx_buf);
+	lpfc_read_topology(phba, pmb, pmb->ctx_buf);
 	pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
 	pmb->vport = phba->pport;
 	phba->sli.slistat.link_event++;
 	/* Create lpfc_handle_latt mailbox command from link ACQE */
-	lpfc_read_topology(phba, pmb, (struct lpfc_dmabuf *)pmb->ctx_buf);
+	lpfc_read_topology(phba, pmb, pmb->ctx_buf);
 	pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
 	pmb->vport = phba->pport;
 				"NVME" : " "),
 			(phba->nvmet_support ? "NVMET" : " "));
+	/* ras_fwlog state */
+	spin_lock_init(&phba->ras_fwlog_lock);
 	/* Initialize the IO buffer list used by driver for SLI3 SCSI */
 	spin_lock_init(&phba->scsi_buf_list_get_lock);
 	INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_get);
 		rc = request_threaded_irq(eqhdl->irq,
 					  &lpfc_sli4_hba_intr_handler,
 					  &lpfc_sli4_hba_intr_handler_th,
-					  IRQF_ONESHOT, name, eqhdl);
+					  0, name, eqhdl);
 		if (rc) {
 			lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
 					"0486 MSI-X fast-path (%d) "

drivers/scsi/lpfc/lpfc_mbox.c+10−20

 {
 	struct lpfc_dmabuf *mp;
-	mp = (struct lpfc_dmabuf *)mbox->ctx_buf;
+	mp = mbox->ctx_buf;
 	mbox->ctx_buf = NULL;
 	/* Release the generic BPL buffer memory.  */
 		uint16_t region_id)
 {
 	MAILBOX_t *mb;
-	void *ctx;
 	mb = &pmb->u.mb;
-	ctx = pmb->ctx_buf;
 	/* Setup to dump VPD region */
 	memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 	mb->un.varDmp.word_cnt = (DMP_RSP_SIZE / sizeof (uint32_t));
 	mb->un.varDmp.co = 0;
 	mb->un.varDmp.resp_offset = 0;
-	pmb->ctx_buf = ctx;
 	mb->mbxOwner = OWN_HOST;
 	return;
 }
 lpfc_dump_wakeup_param(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
 	MAILBOX_t *mb;
-	void *ctx;
 	mb = &pmb->u.mb;
-	/* Save context so that we can restore after memset */
-	ctx = pmb->ctx_buf;
 	/* Setup to dump VPD region */
 	memset(pmb, 0, sizeof(LPFC_MBOXQ_t));
 	mb->un.varDmp.word_cnt = WAKE_UP_PARMS_WORD_SIZE;
 	mb->un.varDmp.co = 0;
 	mb->un.varDmp.resp_offset = 0;
-	pmb->ctx_buf = ctx;
 	return;
 }
 	/* Save address for later completion and set the owner to host so that
 	 * the FW knows this mailbox is available for processing.
 	 */
-	pmb->ctx_buf = (uint8_t *)mp;
+	pmb->ctx_buf = mp;
 	mb->mbxOwner = OWN_HOST;
 	return (0);
 }
 	}
 	/* Reinitialize the context pointers to avoid stale usage. */
 	mbox->ctx_buf = NULL;
-	mbox->context3 = NULL;
+	memset(&mbox->ctx_u, 0, sizeof(mbox->ctx_u));
 	kfree(mbox->sge_array);
 	/* Finally, free the mailbox command itself */
 	mempool_free(mbox, phba->mbox_mem_pool);
 {
 	MAILBOX_t *mb;
 	int rc = FAILURE;
-	struct lpfc_rdp_context *rdp_context =
+	struct lpfc_rdp_context *rdp_context = mboxq->ctx_u.rdp;
-			(struct lpfc_rdp_context *)(mboxq->ctx_ndlp);
 	mb = &mboxq->u.mb;
 	if (mb->mbxStatus)
 static void
 lpfc_mbx_cmpl_rdp_page_a2(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)
 {
-	struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *)mbox->ctx_buf;
+	struct lpfc_dmabuf *mp = mbox->ctx_buf;
-	struct lpfc_rdp_context *rdp_context =
+	struct lpfc_rdp_context *rdp_context = mbox->ctx_u.rdp;
-			(struct lpfc_rdp_context *)(mbox->ctx_ndlp);
 	if (bf_get(lpfc_mqe_status, &mbox->u.mqe))
 		goto error_mbox_free;
 	/* Save the dma buffer for cleanup in the final completion. */
 	mbox->ctx_buf = mp;
 	mbox->mbox_cmpl = lpfc_mbx_cmpl_rdp_link_stat;
-	mbox->ctx_ndlp = (struct lpfc_rdp_context *)rdp_context;
+	mbox->ctx_u.rdp = rdp_context;
 	if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT) == MBX_NOT_FINISHED)
 		goto error_mbox_free;
 lpfc_mbx_cmpl_rdp_page_a0(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)
 {
 	int rc;
-	struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *)(mbox->ctx_buf);
+	struct lpfc_dmabuf *mp = mbox->ctx_buf;
-	struct lpfc_rdp_context *rdp_context =
+	struct lpfc_rdp_context *rdp_context = mbox->ctx_u.rdp;
-			(struct lpfc_rdp_context *)(mbox->ctx_ndlp);
 	if (bf_get(lpfc_mqe_status, &mbox->u.mqe))
 		goto error;
 	mbox->u.mqe.un.mem_dump_type3.addr_hi = putPaddrHigh(mp->phys);
 	mbox->mbox_cmpl = lpfc_mbx_cmpl_rdp_page_a2;
-	mbox->ctx_ndlp = (struct lpfc_rdp_context *)rdp_context;
+	mbox->ctx_u.rdp = rdp_context;
 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED)
 		goto error;

drivers/scsi/lpfc/lpfc_nportdisc.c+6−6

@@ -300,7 +300,7 @@ lpfc_defer_plogi_acc(struct lpfc_hba phba, LPFC_MBOXQ_t login_mbox) · 299 unmodified lines
300	int rc;	300	int rc;
301		301
302	ndlp = login_mbox->ctx_ndlp;	302	ndlp = login_mbox->ctx_ndlp;
303	save_iocb = login_mbox->context3;	303	save_iocb = login_mbox->ctx_u.save_iocb;
304		304
305	if (mb->mbxStatus == MBX_SUCCESS) {	305	if (mb->mbxStatus == MBX_SUCCESS) {
306	/* Now that REG_RPI completed successfully,	306	/* Now that REG_RPI completed successfully,
@@ -640,7 +640,7 @@ lpfc_rcv_plogi(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 333 unmodified lines
640	if (!login_mbox->ctx_ndlp)	640	if (!login_mbox->ctx_ndlp)
641	goto out;	641	goto out;
642		642
643	login_mbox->context3 = save_iocb; /* For PLOGI ACC */	643	login_mbox->ctx_u.save_iocb = save_iocb; /* For PLOGI ACC */
644		644
645	spin_lock_irq(&ndlp->lock);	645	spin_lock_irq(&ndlp->lock);
646	ndlp->nlp_flag \|= (NLP_ACC_REGLOGIN \| NLP_RCV_PLOGI);	646	ndlp->nlp_flag \|= (NLP_ACC_REGLOGIN \| NLP_RCV_PLOGI);
@@ -682,8 +682,8 @@ lpfc_mbx_cmpl_resume_rpi(struct lpfc_hba phba, LPFC_MBOXQ_t mboxq) · 35 unmodified lines
682	struct lpfc_nodelist *ndlp;	682	struct lpfc_nodelist *ndlp;
683	uint32_t cmd;	683	uint32_t cmd;
684		684
685	elsiocb = (struct lpfc_iocbq *)mboxq->ctx_buf;	685	elsiocb = mboxq->ctx_u.save_iocb;
686	ndlp = (struct lpfc_nodelist *)mboxq->ctx_ndlp;	686	ndlp = mboxq->ctx_ndlp;
687	vport = mboxq->vport;	687	vport = mboxq->vport;
688	cmd = elsiocb->drvrTimeout;	688	cmd = elsiocb->drvrTimeout;
689		689
@@ -1875,7 +1875,7 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport, · 1185 unmodified lines
1875	/* cleanup any ndlp on mbox q waiting for reglogin cmpl */	1875	/* cleanup any ndlp on mbox q waiting for reglogin cmpl */
1876	if ((mb = phba->sli.mbox_active)) {	1876	if ((mb = phba->sli.mbox_active)) {
1877	if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&	1877	if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
1878	(ndlp == (struct lpfc_nodelist *)mb->ctx_ndlp)) {	1878	(ndlp == mb->ctx_ndlp)) {
1879	ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;	1879	ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
1880	lpfc_nlp_put(ndlp);	1880	lpfc_nlp_put(ndlp);
1881	mb->ctx_ndlp = NULL;	1881	mb->ctx_ndlp = NULL;
@@ -1886,7 +1886,7 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport, · 4 unmodified lines
1886	spin_lock_irq(&phba->hbalock);	1886	spin_lock_irq(&phba->hbalock);
1887	list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {	1887	list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
1888	if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&	1888	if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
1889	(ndlp == (struct lpfc_nodelist *)mb->ctx_ndlp)) {	1889	(ndlp == mb->ctx_ndlp)) {
1890	ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;	1890	ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
1891	lpfc_nlp_put(ndlp);	1891	lpfc_nlp_put(ndlp);
1892	list_del(&mb->list);	1892	list_del(&mb->list);

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

@@ -2616,9 +2616,9 @@ lpfc_nvme_unregister_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 2615 unmodified lines
2616	/* No concern about the role change on the nvme remoteport.	2616	/* No concern about the role change on the nvme remoteport.
2617	* The transport will update it.	2617	* The transport will update it.
2618	*/	2618	*/
2619	spin_lock_irq(&vport->phba->hbalock);	2619	spin_lock_irq(&ndlp->lock);
2620	ndlp->fc4_xpt_flags \|= NVME_XPT_UNREG_WAIT;	2620	ndlp->fc4_xpt_flags \|= NVME_XPT_UNREG_WAIT;
2621	spin_unlock_irq(&vport->phba->hbalock);	2621	spin_unlock_irq(&ndlp->lock);
2622		2622
2623	/* Don't let the host nvme transport keep sending keep-alives	2623	/* Don't let the host nvme transport keep sending keep-alives
2624	* on this remoteport. Vport is unloading, no recovery. The	2624	* on this remoteport. Vport is unloading, no recovery. The

drivers/scsi/lpfc/lpfc_nvmet.c+1−1

@@ -1586,7 +1586,7 @@ lpfc_nvmet_setup_io_context(struct lpfc_hba *phba) · 1585 unmodified lines
1586	wqe = &nvmewqe->wqe;	1586	wqe = &nvmewqe->wqe;
1587		1587
1588	/* Initialize WQE */	1588	/* Initialize WQE */
1589	memset(wqe, 0, sizeof(union lpfc_wqe));	1589	memset(wqe, 0, sizeof(*wqe));
1590		1590
1591	ctx_buf->iocbq->cmd_dmabuf = NULL;	1591	ctx_buf->iocbq->cmd_dmabuf = NULL;
1592	spin_lock(&phba->sli4_hba.sgl_list_lock);	1592	spin_lock(&phba->sli4_hba.sgl_list_lock);

drivers/scsi/lpfc/lpfc_scsi.c+4−19

 	struct Scsi_Host  *shost;
 	struct scsi_device *sdev;
 	unsigned long new_queue_depth;
-	unsigned long num_rsrc_err, num_cmd_success;
+	unsigned long num_rsrc_err;
 	int i;
 	num_rsrc_err = atomic_read(&phba->num_rsrc_err);
-	num_cmd_success = atomic_read(&phba->num_cmd_success);
 	/*
 	 * The error and success command counters are global per
 		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 			shost = lpfc_shost_from_vport(vports[i]);
 			shost_for_each_device(sdev, shost) {
-				new_queue_depth =
+				if (num_rsrc_err >= sdev->queue_depth)
-					sdev->queue_depth * num_rsrc_err /
+					new_queue_depth = 1;
-					(num_rsrc_err + num_cmd_success);
-				if (!new_queue_depth)
-					new_queue_depth = sdev->queue_depth - 1;
 				else
 					new_queue_depth = sdev->queue_depth -
-								new_queue_depth;
+						num_rsrc_err;
 				scsi_change_queue_depth(sdev, new_queue_depth);
 			}
 		}
 	lpfc_destroy_vport_work_array(phba, vports);
 	atomic_set(&phba->num_rsrc_err, 0);
-	atomic_set(&phba->num_cmd_success, 0);
 }
 /**
 		}
 		err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
 	} else {
-		if (vport->phba->cfg_enable_bg) {
-			lpfc_printf_vlog(vport,
-					 KERN_INFO, LOG_SCSI_CMD,
-					 "9038 BLKGRD: rcvd PROT_NORMAL cmd: "
-					 "x%x reftag x%x cnt %u pt %x\n",
-					 cmnd->cmnd[0],
-					 scsi_prot_ref_tag(cmnd),
-					 scsi_logical_block_count(cmnd),
-					 (cmnd->cmnd[1]>>5));
-		}
 		err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
 	}

drivers/scsi/lpfc/lpfc_sli.c+49−50

 	empty = list_empty(&phba->active_rrq_list);
 	list_add_tail(&rrq->list, &phba->active_rrq_list);
 	phba->hba_flag |= HBA_RRQ_ACTIVE;
+	spin_unlock_irqrestore(&phba->hbalock, iflags);
 	if (empty)
 		lpfc_worker_wake_up(phba);
-	spin_unlock_irqrestore(&phba->hbalock, iflags);
 	return 0;
 out:
 	spin_unlock_irqrestore(&phba->hbalock, iflags);
 	 */
 	pmboxq->mbox_flag |= LPFC_MBX_WAKE;
 	spin_lock_irqsave(&phba->hbalock, drvr_flag);
-	pmbox_done = (struct completion *)pmboxq->context3;
+	pmbox_done = pmboxq->ctx_u.mbox_wait;
 	if (pmbox_done)
 		complete(pmbox_done);
 	spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 	if (!test_bit(FC_UNLOADING, &phba->pport->load_flag) &&
 	    pmb->u.mb.mbxCommand == MBX_REG_LOGIN64 &&
 	    !pmb->u.mb.mbxStatus) {
-		mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+		mp = pmb->ctx_buf;
 		if (mp) {
 			pmb->ctx_buf = NULL;
 			lpfc_mbuf_free(phba, mp->virt, mp->phys);
 	}
 	if (pmb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
-		ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+		ndlp = pmb->ctx_ndlp;
 		lpfc_nlp_put(ndlp);
 	}
 	if (pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) {
-		ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+		ndlp = pmb->ctx_ndlp;
 		/* Check to see if there are any deferred events to process */
 		if (ndlp) {
 	/* This nlp_put pairs with lpfc_sli4_resume_rpi */
 	if (pmb->u.mb.mbxCommand == MBX_RESUME_RPI) {
-		ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+		ndlp = pmb->ctx_ndlp;
 		lpfc_nlp_put(ndlp);
 	}
 		goto out_free_mboxq;
 	}
-	mp = (struct lpfc_dmabuf *)mboxq->ctx_buf;
+	mp = mboxq->ctx_buf;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
 	lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
 {
 	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->ras_fwlog_lock);
 	ras_fwlog->state = INACTIVE;
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->ras_fwlog_lock);
 	/* Disable FW logging to host memory */
 	writel(LPFC_CTL_PDEV_CTL_DDL_RAS,
 		ras_fwlog->lwpd.virt = NULL;
 	}
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->ras_fwlog_lock);
 	ras_fwlog->state = INACTIVE;
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->ras_fwlog_lock);
 }
 /**
 		goto disable_ras;
 	}
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->ras_fwlog_lock);
 	ras_fwlog->state = ACTIVE;
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->ras_fwlog_lock);
 	mempool_free(pmb, phba->mbox_mem_pool);
 	return;
 	uint32_t len = 0, fwlog_buffsize, fwlog_entry_count;
 	int rc = 0;
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->ras_fwlog_lock);
 	ras_fwlog->state = INACTIVE;
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->ras_fwlog_lock);
 	fwlog_buffsize = (LPFC_RAS_MIN_BUFF_POST_SIZE *
 			  phba->cfg_ras_fwlog_buffsize);
 	mbx_fwlog->u.request.lwpd.addr_lo = putPaddrLow(ras_fwlog->lwpd.phys);
 	mbx_fwlog->u.request.lwpd.addr_hi = putPaddrHigh(ras_fwlog->lwpd.phys);
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->ras_fwlog_lock);
 	ras_fwlog->state = REG_INPROGRESS;
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->ras_fwlog_lock);
 	mbox->vport = phba->pport;
 	mbox->mbox_cmpl = lpfc_sli4_ras_mbox_cmpl;
 	mboxq->vport = vport;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-	mp = (struct lpfc_dmabuf *)mboxq->ctx_buf;
+	mp = mboxq->ctx_buf;
 	if (rc == MBX_SUCCESS) {
 		memcpy(&vport->fc_sparam, mp->virt, sizeof(struct serv_parm));
 		rc = 0;
 		}
 		/* Copy the mailbox extension data */
-		if (pmbox->in_ext_byte_len && pmbox->ctx_buf) {
+		if (pmbox->in_ext_byte_len && pmbox->ext_buf) {
-			lpfc_sli_pcimem_bcopy(pmbox->ctx_buf,
+			lpfc_sli_pcimem_bcopy(pmbox->ext_buf,
 					      (uint8_t *)phba->mbox_ext,
 					      pmbox->in_ext_byte_len);
 		}
 				= MAILBOX_HBA_EXT_OFFSET;
 		/* Copy the mailbox extension data */
-		if (pmbox->in_ext_byte_len && pmbox->ctx_buf)
+		if (pmbox->in_ext_byte_len && pmbox->ext_buf)
 			lpfc_memcpy_to_slim(phba->MBslimaddr +
 				MAILBOX_HBA_EXT_OFFSET,
-				pmbox->ctx_buf, pmbox->in_ext_byte_len);
+				pmbox->ext_buf, pmbox->in_ext_byte_len);
 		if (mbx->mbxCommand == MBX_CONFIG_PORT)
 			/* copy command data into host mbox for cmpl */
 			lpfc_sli_pcimem_bcopy(phba->mbox, mbx,
 						MAILBOX_CMD_SIZE);
 			/* Copy the mailbox extension data */
-			if (pmbox->out_ext_byte_len && pmbox->ctx_buf) {
+			if (pmbox->out_ext_byte_len && pmbox->ext_buf) {
 				lpfc_sli_pcimem_bcopy(phba->mbox_ext,
-						      pmbox->ctx_buf,
+						      pmbox->ext_buf,
 						      pmbox->out_ext_byte_len);
 			}
 		} else {
 			lpfc_memcpy_from_slim(mbx, phba->MBslimaddr,
 						MAILBOX_CMD_SIZE);
 			/* Copy the mailbox extension data */
-			if (pmbox->out_ext_byte_len && pmbox->ctx_buf) {
+			if (pmbox->out_ext_byte_len && pmbox->ext_buf) {
 				lpfc_memcpy_from_slim(
-					pmbox->ctx_buf,
+					pmbox->ext_buf,
 					phba->MBslimaddr +
 					MAILBOX_HBA_EXT_OFFSET,
 					pmbox->out_ext_byte_len);
 	unsigned long iflags;
 	struct lpfc_work_evt  *evtp = &ndlp->recovery_evt;
+	/* Hold a node reference for outstanding queued work */
+	if (!lpfc_nlp_get(ndlp))
+		return;
 	spin_lock_irqsave(&phba->hbalock, iflags);
 	if (!list_empty(&evtp->evt_listp)) {
 		spin_unlock_irqrestore(&phba->hbalock, iflags);
+		lpfc_nlp_put(ndlp);
 		return;
 	}
-	/* Incrementing the reference count until the queued work is done. */
+	evtp->evt_arg1 = ndlp;
-	evtp->evt_arg1  = lpfc_nlp_get(ndlp);
-	if (!evtp->evt_arg1) {
-		spin_unlock_irqrestore(&phba->hbalock, iflags);
-		return;
-	}
 	evtp->evt = LPFC_EVT_RECOVER_PORT;
 	list_add_tail(&evtp->evt_listp, &phba->work_list);
 	spin_unlock_irqrestore(&phba->hbalock, iflags);
 	/* setup wake call as IOCB callback */
 	pmboxq->mbox_cmpl = lpfc_sli_wake_mbox_wait;
-	/* setup context3 field to pass wait_queue pointer to wake function  */
+	/* setup ctx_u field to pass wait_queue pointer to wake function  */
 	init_completion(&mbox_done);
-	pmboxq->context3 = &mbox_done;
+	pmboxq->ctx_u.mbox_wait = &mbox_done;
 	/* now issue the command */
 	retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
 	if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
 					    msecs_to_jiffies(timeout * 1000));
 		spin_lock_irqsave(&phba->hbalock, flag);
-		pmboxq->context3 = NULL;
+		pmboxq->ctx_u.mbox_wait = NULL;
 		/*
 		 * if LPFC_MBX_WAKE flag is set the mailbox is completed
 		 * else do not free the resources.
 					lpfc_sli_pcimem_bcopy(mbox, pmbox,
 							MAILBOX_CMD_SIZE);
 					if (pmb->out_ext_byte_len &&
-						pmb->ctx_buf)
+						pmb->ext_buf)
 						lpfc_sli_pcimem_bcopy(
 						phba->mbox_ext,
-						pmb->ctx_buf,
+						pmb->ext_buf,
 						pmb->out_ext_byte_len);
 				}
 				if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
 						pmbox->un.varWords[0], 0);
 					if (!pmbox->mbxStatus) {
-						mp = (struct lpfc_dmabuf *)
+						mp = pmb->ctx_buf;
-							(pmb->ctx_buf);
+						ndlp = pmb->ctx_ndlp;
-						ndlp = (struct lpfc_nodelist *)
-							pmb->ctx_ndlp;
 						/* Reg_LOGIN of dflt RPI was
 						 * successful. new lets get
 				      mcqe_status,
 				      pmbox->un.varWords[0], 0);
 		if (mcqe_status == MB_CQE_STATUS_SUCCESS) {
-			mp = (struct lpfc_dmabuf *)(pmb->ctx_buf);
+			mp = pmb->ctx_buf;
-			ndlp = (struct lpfc_nodelist *)pmb->ctx_ndlp;
+			ndlp = pmb->ctx_ndlp;
 			/* Reg_LOGIN of dflt RPI was successful. Mark the
 			 * node as having an UNREG_LOGIN in progress to stop
  * lpfc_sli4_resume_rpi - Remove the rpi bitmask region
  * @ndlp: pointer to lpfc nodelist data structure.
  * @cmpl: completion call-back.
- * @arg: data to load as MBox 'caller buffer information'
+ * @iocbq: data to load as mbox ctx_u information
  *
  * This routine is invoked to remove the memory region that
  * provided rpi via a bitmask.
  **/
 int
 lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp,
-	void (*cmpl)(struct lpfc_hba *, LPFC_MBOXQ_t *), void *arg)
+		     void (*cmpl)(struct lpfc_hba *, LPFC_MBOXQ_t *),
+		     struct lpfc_iocbq *iocbq)
 {
 	LPFC_MBOXQ_t *mboxq;
 	struct lpfc_hba *phba = ndlp->phba;
 	lpfc_resume_rpi(mboxq, ndlp);
 	if (cmpl) {
 		mboxq->mbox_cmpl = cmpl;
-		mboxq->ctx_buf = arg;
+		mboxq->ctx_u.save_iocb = iocbq;
 	} else
 		mboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 	mboxq->ctx_ndlp = ndlp;
 	if (lpfc_sli4_dump_cfg_rg23(phba, mboxq))
 		goto out;
 	mqe = &mboxq->u.mqe;
-	mp = (struct lpfc_dmabuf *)mboxq->ctx_buf;
+	mp = mboxq->ctx_buf;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
 	if (rc)
 		goto out;
 			(mb->u.mb.mbxCommand == MBX_REG_VPI))
 			mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 		if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
-			act_mbx_ndlp = (struct lpfc_nodelist *)mb->ctx_ndlp;
+			act_mbx_ndlp = mb->ctx_ndlp;
 			/* This reference is local to this routine.  The
 			 * reference is removed at routine exit.
 			mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 			if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
-				ndlp = (struct lpfc_nodelist *)mb->ctx_ndlp;
+				ndlp = mb->ctx_ndlp;
 				/* Unregister the RPI when mailbox complete */
 				mb->mbox_flag |= LPFC_MBX_IMED_UNREG;
 				restart_loop = 1;
 	while (!list_empty(&mbox_cmd_list)) {
 		list_remove_head(&mbox_cmd_list, mb, LPFC_MBOXQ_t, list);
 		if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
-			ndlp = (struct lpfc_nodelist *)mb->ctx_ndlp;
+			ndlp = mb->ctx_ndlp;
 			mb->ctx_ndlp = NULL;
 			if (ndlp) {
 				spin_lock(&ndlp->lock);

drivers/scsi/lpfc/lpfc_sli.h+24−6

 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2017-2023 Broadcom. All Rights Reserved. The term *
+ * Copyright (C) 2017-2024 Broadcom. All Rights Reserved. The term *
  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.     *
  * Copyright (C) 2004-2016 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
 		struct lpfc_mqe mqe;
 	} u;
 	struct lpfc_vport *vport; /* virtual port pointer */
-	void *ctx_ndlp;		  /* an lpfc_nodelist pointer */
+	struct lpfc_nodelist *ctx_ndlp;	/* caller ndlp pointer */
-	void *ctx_buf;		  /* an lpfc_dmabuf pointer */
+	struct lpfc_dmabuf *ctx_buf;	/* caller buffer information */
-	void *context3;           /* a generic pointer.  Code must
+	void *ext_buf;			/* extended buffer for extended mbox
-				   * accommodate the actual datatype.
+					 * cmds.  Not a generic pointer.
-				   */
+					 * Use for storing virtual address.
+					 */
+	/* Pointers that are seldom used during mbox execution, but require
+	 * a saved context.
+	 */
+	union {
+		unsigned long ox_rx_id;		/* Used in els_rsp_rls_acc */
+		struct lpfc_rdp_context *rdp;	/* Used in get_rdp_info */
+		struct lpfc_lcb_context *lcb;	/* Used in set_beacon */
+		struct completion *mbox_wait;	/* Used in issue_mbox_wait */
+		struct bsg_job_data *dd_data;	/* Used in bsg_issue_mbox_cmpl
+						 * and
+						 * bsg_issue_mbox_ext_handle_job
+						 */
+		struct lpfc_iocbq *save_iocb;	/* Used in defer_plogi_acc and
+						 * lpfc_mbx_cmpl_resume_rpi
+						 */
+	} ctx_u;
 	void (*mbox_cmpl) (struct lpfc_hba *, struct lpfcMboxq *);
 	uint8_t mbox_flag;

drivers/scsi/lpfc/lpfc_sli4.h+4−3

 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2017-2023 Broadcom. All Rights Reserved. The term *
+ * Copyright (C) 2017-2024 Broadcom. All Rights Reserved. The term *
  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.     *
  * Copyright (C) 2009-2016 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
 void lpfc_sli4_remove_rpis(struct lpfc_hba *);
 void lpfc_sli4_async_event_proc(struct lpfc_hba *);
 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *);
-int lpfc_sli4_resume_rpi(struct lpfc_nodelist *,
+int lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp,
-			void (*)(struct lpfc_hba *, LPFC_MBOXQ_t *), void *);
+			 void (*cmpl)(struct lpfc_hba *, LPFC_MBOXQ_t *),
+			 struct lpfc_iocbq *iocbq);
 void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *phba);
 void lpfc_sli4_nvme_pci_offline_aborted(struct lpfc_hba *phba,
 					struct lpfc_io_buf *lpfc_ncmd);

drivers/scsi/lpfc/lpfc_version.h+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	* included with this package. *	20	* included with this package. *
21	*******************************************************************/	21	*******************************************************************/
22		22
23	#define LPFC_DRIVER_VERSION "14.4.0.0"	23	#define LPFC_DRIVER_VERSION "14.4.0.1"
24	#define LPFC_DRIVER_NAME "lpfc"	24	#define LPFC_DRIVER_NAME "lpfc"
25		25
26	/* Used for SLI 2/3 */	26	/* Used for SLI 2/3 */

drivers/scsi/lpfc/lpfc_vport.c+5−5

 		}
 	}
-	mp = (struct lpfc_dmabuf *)pmb->ctx_buf;
+	mp = pmb->ctx_buf;
 	memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
 	memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
 	       sizeof (struct lpfc_name));
 	lpfc_free_sysfs_attr(vport);
 	lpfc_debugfs_terminate(vport);
-	/* Remove FC host to break driver binding. */
-	fc_remove_host(shost);
-	scsi_remove_host(shost);
 	/* Send the DA_ID and Fabric LOGO to cleanup Nameserver entries. */
 	ndlp = lpfc_findnode_did(vport, Fabric_DID);
 	if (!ndlp)
 skip_logo:
+	/* Remove FC host to break driver binding. */
+	fc_remove_host(shost);
+	scsi_remove_host(shost);
 	lpfc_cleanup(vport);
 	/* Remove scsi host now.  The nodes are cleaned up. */

drivers/scsi/mpi3mr/mpi3mr_app.c+1−1

@@ -1644,7 +1644,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job) · 1643 unmodified lines
1644	if ((mpirep_offset != 0xFF) &&	1644	if ((mpirep_offset != 0xFF) &&
1645	drv_bufs[mpirep_offset].bsg_buf_len) {	1645	drv_bufs[mpirep_offset].bsg_buf_len) {
1646	drv_buf_iter = &drv_bufs[mpirep_offset];	1646	drv_buf_iter = &drv_bufs[mpirep_offset];
1647	drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) - 1 +	1647	drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) +
1648	mrioc->reply_sz);	1648	mrioc->reply_sz);
1649	bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL);	1649	bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL);
1650		1650

drivers/scsi/pmcraid.c+11−9

@@ -61,7 +61,9 @@ static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0); · 60 unmodified lines
61	* pmcraid_minor - minor number(s) to use	61	* pmcraid_minor - minor number(s) to use
62	*/	62	*/
63	static unsigned int pmcraid_major;	63	static unsigned int pmcraid_major;
64	static struct class *pmcraid_class;	64	static const struct class pmcraid_class = {
		65	.name = PMCRAID_DEVFILE,
		66	};
65	static DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);	67	static DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);
66		68
67	/*	69	/*
@@ -4723,7 +4725,7 @@ static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance) · 4655 unmodified lines
4723	if (error)	4725	if (error)
4724	pmcraid_release_minor(minor);	4726	pmcraid_release_minor(minor);
4725	else	4727	else
4726	device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor),	4728	device_create(&pmcraid_class, NULL, MKDEV(pmcraid_major, minor),
4727	NULL, "%s%u", PMCRAID_DEVFILE, minor);	4729	NULL, "%s%u", PMCRAID_DEVFILE, minor);
4728	return error;	4730	return error;
4729	}	4731	}
@@ -4739,7 +4741,7 @@ static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance) · 9 unmodified lines
4739	static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)	4741	static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)
4740	{	4742	{
4741	pmcraid_release_minor(MINOR(pinstance->cdev.dev));	4743	pmcraid_release_minor(MINOR(pinstance->cdev.dev));
4742	device_destroy(pmcraid_class,	4744	device_destroy(&pmcraid_class,
4743	MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));	4745	MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));
4744	cdev_del(&pinstance->cdev);	4746	cdev_del(&pinstance->cdev);
4745	}	4747	}
@@ -5390,10 +5392,10 @@ static int __init pmcraid_init(void) · 644 unmodified lines
5390	}	5392	}
5391		5393
5392	pmcraid_major = MAJOR(dev);	5394	pmcraid_major = MAJOR(dev);
5393	pmcraid_class = class_create(PMCRAID_DEVFILE);
5394		5395
5395	if (IS_ERR(pmcraid_class)) {	5396	error = class_register(&pmcraid_class);
5396	error = PTR_ERR(pmcraid_class);	5397
		5398	if (error) {
5397	pmcraid_err("failed to register with sysfs, error = %x\n",	5399	pmcraid_err("failed to register with sysfs, error = %x\n",
5398	error);	5400	error);
5399	goto out_unreg_chrdev;	5401	goto out_unreg_chrdev;
@@ -5402,7 +5404,7 @@ static int __init pmcraid_init(void) · 2 unmodified lines
5402	error = pmcraid_netlink_init();	5404	error = pmcraid_netlink_init();
5403		5405
5404	if (error) {	5406	if (error) {
5405	class_destroy(pmcraid_class);	5407	class_unregister(&pmcraid_class);
5406	goto out_unreg_chrdev;	5408	goto out_unreg_chrdev;
5407	}	5409	}
5408		5410
@@ -5413,7 +5415,7 @@ static int __init pmcraid_init(void) · 4 unmodified lines
5413		5415
5414	pmcraid_err("failed to register pmcraid driver, error = %x\n",	5416	pmcraid_err("failed to register pmcraid driver, error = %x\n",
5415	error);	5417	error);
5416	class_destroy(pmcraid_class);	5418	class_unregister(&pmcraid_class);
5417	pmcraid_netlink_release();	5419	pmcraid_netlink_release();
5418		5420
5419	out_unreg_chrdev:	5421	out_unreg_chrdev:
@@ -5432,7 +5434,7 @@ static void __exit pmcraid_exit(void) · 12 unmodified lines
5432	unregister_chrdev_region(MKDEV(pmcraid_major, 0),	5434	unregister_chrdev_region(MKDEV(pmcraid_major, 0),
5433	PMCRAID_MAX_ADAPTERS);	5435	PMCRAID_MAX_ADAPTERS);
5434	pci_unregister_driver(&pmcraid_driver);	5436	pci_unregister_driver(&pmcraid_driver);
5435	class_destroy(pmcraid_class);	5437	class_unregister(&pmcraid_class);
5436	}	5438	}
5437		5439
5438	module_init(pmcraid_init);	5440	module_init(pmcraid_init);

drivers/scsi/qla2xxx/qla_attr.c+12−2

 		return;
 	if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
-		qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
+		/* Will wait for wind down of adapter */
+		ql_dbg(ql_dbg_aer, fcport->vha, 0x900c,
+		    "%s pci offline detected (id %06x)\n", __func__,
+		    fcport->d_id.b24);
+		qla_pci_set_eeh_busy(fcport->vha);
+		qla2x00_eh_wait_for_pending_commands(fcport->vha, fcport->d_id.b24,
+		    0, WAIT_TARGET);
 		return;
 	}
 }
 	vha = fcport->vha;
 	if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
-		qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
+		/* Will wait for wind down of adapter */
+		ql_dbg(ql_dbg_aer, fcport->vha, 0x900b,
+		    "%s pci offline detected (id %06x)\n", __func__,
+		    fcport->d_id.b24);
+		qla_pci_set_eeh_busy(vha);
 		qla2x00_eh_wait_for_pending_commands(fcport->vha, fcport->d_id.b24,
 			0, WAIT_TARGET);
 		return;

drivers/scsi/qla2xxx/qla_def.h+1−1

@@ -82,7 +82,7 @@ typedef union { · 81 unmodified lines
82	#include "qla_nvme.h"	82	#include "qla_nvme.h"
83	#define QLA2XXX_DRIVER_NAME "qla2xxx"	83	#define QLA2XXX_DRIVER_NAME "qla2xxx"
84	#define QLA2XXX_APIDEV "ql2xapidev"	84	#define QLA2XXX_APIDEV "ql2xapidev"
85	#define QLA2XXX_MANUFACTURER "Marvell Semiconductor, Inc."	85	#define QLA2XXX_MANUFACTURER "Marvell"
86		86
87	/*	87	/*
88	* We have MAILBOX_REGISTER_COUNT sized arrays in a few places,	88	* We have MAILBOX_REGISTER_COUNT sized arrays in a few places,

drivers/scsi/qla2xxx/qla_gbl.h+1−1

@@ -44,7 +44,7 @@ extern int qla2x00_fabric_login(scsi_qla_host_t , fc_port_t , uint16_t *); · 43 unmodified lines
44	extern int qla2x00_local_device_login(scsi_qla_host_t , fc_port_t );	44	extern int qla2x00_local_device_login(scsi_qla_host_t , fc_port_t );
45		45
46	extern int qla24xx_els_dcmd_iocb(scsi_qla_host_t *, int, port_id_t);	46	extern int qla24xx_els_dcmd_iocb(scsi_qla_host_t *, int, port_id_t);
47	extern int qla24xx_els_dcmd2_iocb(scsi_qla_host_t , int, fc_port_t , bool);	47	extern int qla24xx_els_dcmd2_iocb(scsi_qla_host_t , int, fc_port_t );
48	extern void qla2x00_els_dcmd2_free(scsi_qla_host_t *vha,	48	extern void qla2x00_els_dcmd2_free(scsi_qla_host_t *vha,
49	struct els_plogi *els_plogi);	49	struct els_plogi *els_plogi);
50		50

drivers/scsi/qla2xxx/qla_init.c+65−63

 	return rval;
 done_free_sp:
-	/* ref: INIT */
+	/*
-	kref_put(&sp->cmd_kref, qla2x00_sp_release);
+	 * use qla24xx_async_gnl_sp_done to purge all pending gnl request.
+	 * kref_put is call behind the scene.
+	 */
+	sp->u.iocb_cmd.u.mbx.in_mb[0] = MBS_COMMAND_ERROR;
+	qla24xx_async_gnl_sp_done(sp, QLA_COMMAND_ERROR);
 	fcport->flags &= ~(FCF_ASYNC_SENT);
 done:
 	fcport->flags &= ~(FCF_ASYNC_ACTIVE);
 	return rval;
 }
+static void qla_enable_fce_trace(scsi_qla_host_t *vha)
+{
+	int rval;
+	struct qla_hw_data *ha = vha->hw;
+	if (ha->fce) {
+		ha->flags.fce_enabled = 1;
+		memset(ha->fce, 0, fce_calc_size(ha->fce_bufs));
+		rval = qla2x00_enable_fce_trace(vha,
+		    ha->fce_dma, ha->fce_bufs, ha->fce_mb, &ha->fce_bufs);
+		if (rval) {
+			ql_log(ql_log_warn, vha, 0x8033,
+			    "Unable to reinitialize FCE (%d).\n", rval);
+			ha->flags.fce_enabled = 0;
+		}
+	}
+}
+static void qla_enable_eft_trace(scsi_qla_host_t *vha)
+{
+	int rval;
+	struct qla_hw_data *ha = vha->hw;
+	if (ha->eft) {
+		memset(ha->eft, 0, EFT_SIZE);
+		rval = qla2x00_enable_eft_trace(vha, ha->eft_dma, EFT_NUM_BUFFERS);
+		if (rval) {
+			ql_log(ql_log_warn, vha, 0x8034,
+			    "Unable to reinitialize EFT (%d).\n", rval);
+		}
+	}
+}
 /*
 * qla2x00_initialize_adapter
 *      Initialize board.
 }
 static void
-qla2x00_init_fce_trace(scsi_qla_host_t *vha)
+qla2x00_alloc_fce_trace(scsi_qla_host_t *vha)
 {
-	int rval;
 	dma_addr_t tc_dma;
 	void *tc;
 	struct qla_hw_data *ha = vha->hw;
 		return;
 	}
-	rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
-					ha->fce_mb, &ha->fce_bufs);
-	if (rval) {
-		ql_log(ql_log_warn, vha, 0x00bf,
-		       "Unable to initialize FCE (%d).\n", rval);
-		dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc, tc_dma);
-		return;
-	}
 	ql_dbg(ql_dbg_init, vha, 0x00c0,
 	       "Allocated (%d KB) for FCE...\n", FCE_SIZE / 1024);
-	ha->flags.fce_enabled = 1;
 	ha->fce_dma = tc_dma;
 	ha->fce = tc;
+	ha->fce_bufs = FCE_NUM_BUFFERS;
 }
 static void
-qla2x00_init_eft_trace(scsi_qla_host_t *vha)
+qla2x00_alloc_eft_trace(scsi_qla_host_t *vha)
 {
-	int rval;
 	dma_addr_t tc_dma;
 	void *tc;
 	struct qla_hw_data *ha = vha->hw;
 		return;
 	}
-	rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
-	if (rval) {
-		ql_log(ql_log_warn, vha, 0x00c2,
-		       "Unable to initialize EFT (%d).\n", rval);
-		dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc, tc_dma);
-		return;
-	}
 	ql_dbg(ql_dbg_init, vha, 0x00c3,
 	       "Allocated (%d KB) EFT ...\n", EFT_SIZE / 1024);
 	ha->eft = tc;
 }
-static void
-qla2x00_alloc_offload_mem(scsi_qla_host_t *vha)
-{
-	qla2x00_init_fce_trace(vha);
-	qla2x00_init_eft_trace(vha);
-}
 void
 qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
 {
 		if (ha->tgt.atio_ring)
 			mq_size += ha->tgt.atio_q_length * sizeof(request_t);
-		qla2x00_init_fce_trace(vha);
+		qla2x00_alloc_fce_trace(vha);
 		if (ha->fce)
 			fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
-		qla2x00_init_eft_trace(vha);
+		qla2x00_alloc_eft_trace(vha);
 		if (ha->eft)
 			eft_size = EFT_SIZE;
 	}
 	struct qla_hw_data *ha = vha->hw;
 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 	unsigned long flags;
-	uint16_t fw_major_version;
 	int done_once = 0;
 	if (IS_P3P_TYPE(ha)) {
 					goto failed;
 enable_82xx_npiv:
-				fw_major_version = ha->fw_major_version;
 				if (IS_P3P_TYPE(ha))
 					qla82xx_check_md_needed(vha);
 				else
 				if (rval != QLA_SUCCESS)
 					goto failed;
-				if (!fw_major_version && !(IS_P3P_TYPE(ha)))
-					qla2x00_alloc_offload_mem(vha);
 				if (ql2xallocfwdump && !(IS_P3P_TYPE(ha)))
 					qla2x00_alloc_fw_dump(vha);
+				qla_enable_fce_trace(vha);
+				qla_enable_eft_trace(vha);
 			} else {
 				goto failed;
 			}
 int
 qla2x00_abort_isp(scsi_qla_host_t *vha)
 {
-	int rval;
 	uint8_t        status = 0;
 	struct qla_hw_data *ha = vha->hw;
 	struct scsi_qla_host *vp, *tvp;
 	struct req_que *req = ha->req_q_map[0];
 	unsigned long flags;
+	fc_port_t *fcport;
 	if (vha->flags.online) {
 		qla2x00_abort_isp_cleanup(vha);
 			       "ISP Abort - ISP reg disconnect post nvmram config, exiting.\n");
 			return status;
 		}
+		/* User may have updated [fcp|nvme] prefer in flash */
+		list_for_each_entry(fcport, &vha->vp_fcports, list) {
+			if (NVME_PRIORITY(ha, fcport))
+				fcport->do_prli_nvme = 1;
+			else
+				fcport->do_prli_nvme = 0;
+		}
 		if (!qla2x00_restart_isp(vha)) {
 			clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
 			if (IS_QLA81XX(ha) || IS_QLA8031(ha))
 				qla2x00_get_fw_version(vha);
-			if (ha->fce) {
-				ha->flags.fce_enabled = 1;
-				memset(ha->fce, 0,
-				    fce_calc_size(ha->fce_bufs));
-				rval = qla2x00_enable_fce_trace(vha,
-				    ha->fce_dma, ha->fce_bufs, ha->fce_mb,
-				    &ha->fce_bufs);
-				if (rval) {
-					ql_log(ql_log_warn, vha, 0x8033,
-					    "Unable to reinitialize FCE "
-					    "(%d).\n", rval);
-					ha->flags.fce_enabled = 0;
-				}
-			}
-			if (ha->eft) {
-				memset(ha->eft, 0, EFT_SIZE);
-				rval = qla2x00_enable_eft_trace(vha,
-				    ha->eft_dma, EFT_NUM_BUFFERS);
-				if (rval) {
-					ql_log(ql_log_warn, vha, 0x8034,
-					    "Unable to reinitialize EFT "
-					    "(%d).\n", rval);
-				}
-			}
 		} else {	/* failed the ISP abort */
 			vha->flags.online = 1;
 			if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 				atomic_inc(&vp->vref_count);
 				spin_unlock_irqrestore(&ha->vport_slock, flags);
+				/* User may have updated [fcp|nvme] prefer in flash */
+				list_for_each_entry(fcport, &vp->vp_fcports, list) {
+					if (NVME_PRIORITY(ha, fcport))
+						fcport->do_prli_nvme = 1;
+					else
+						fcport->do_prli_nvme = 0;
+				}
 				qla2x00_vp_abort_isp(vp);
 				spin_lock_irqsave(&ha->vport_slock, flags);

drivers/scsi/qla2xxx/qla_iocb.c+44−24

 qla2x00_sp_release(struct kref *kref)
 {
 	struct srb *sp = container_of(kref, struct srb, cmd_kref);
+	struct scsi_qla_host *vha = sp->vha;
+	switch (sp->type) {
+	case SRB_CT_PTHRU_CMD:
+		/* GPSC & GFPNID use fcport->ct_desc.ct_sns for both req & rsp */
+		if (sp->u.iocb_cmd.u.ctarg.req &&
+			(!sp->fcport ||
+			 sp->u.iocb_cmd.u.ctarg.req != sp->fcport->ct_desc.ct_sns)) {
+			dma_free_coherent(&vha->hw->pdev->dev,
+			    sp->u.iocb_cmd.u.ctarg.req_allocated_size,
+			    sp->u.iocb_cmd.u.ctarg.req,
+			    sp->u.iocb_cmd.u.ctarg.req_dma);
+			sp->u.iocb_cmd.u.ctarg.req = NULL;
+		}
+		if (sp->u.iocb_cmd.u.ctarg.rsp &&
+			(!sp->fcport ||
+			 sp->u.iocb_cmd.u.ctarg.rsp != sp->fcport->ct_desc.ct_sns)) {
+			dma_free_coherent(&vha->hw->pdev->dev,
+			    sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
+			    sp->u.iocb_cmd.u.ctarg.rsp,
+			    sp->u.iocb_cmd.u.ctarg.rsp_dma);
+			sp->u.iocb_cmd.u.ctarg.rsp = NULL;
+		}
+		break;
+	default:
+		break;
+	}
 	sp->free(sp);
 }
 {
 	struct srb_iocb *elsio = &sp->u.iocb_cmd;
-	kfree(sp->fcport);
+	if (sp->fcport)
+		qla2x00_free_fcport(sp->fcport);
 	if (elsio->u.els_logo.els_logo_pyld)
 		dma_free_coherent(&sp->vha->hw->pdev->dev, DMA_POOL_SIZE,
 	 */
 	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 	if (!sp) {
-		kfree(fcport);
+		qla2x00_free_fcport(fcport);
 		ql_log(ql_log_info, vha, 0x70e6,
 		 "SRB allocation failed\n");
 		return -ENOMEM;
 	if (!elsio->u.els_logo.els_logo_pyld) {
 		/* ref: INIT */
 		kref_put(&sp->cmd_kref, qla2x00_sp_release);
+		qla2x00_free_fcport(fcport);
 		return QLA_FUNCTION_FAILED;
 	}
 	if (rval != QLA_SUCCESS) {
 		/* ref: INIT */
 		kref_put(&sp->cmd_kref, qla2x00_sp_release);
+		qla2x00_free_fcport(fcport);
 		return QLA_FUNCTION_FAILED;
 	}
 int
 qla24xx_els_dcmd2_iocb(scsi_qla_host_t *vha, int els_opcode,
-    fc_port_t *fcport, bool wait)
+			fc_port_t *fcport)
 {
 	srb_t *sp;
 	struct srb_iocb *elsio = NULL;
 	if (!sp) {
 		ql_log(ql_log_info, vha, 0x70e6,
 		 "SRB allocation failed\n");
-		fcport->flags &= ~FCF_ASYNC_ACTIVE;
+		goto done;
-		return -ENOMEM;
 	}
 	fcport->flags |= FCF_ASYNC_SENT;
 	ql_dbg(ql_dbg_io, vha, 0x3073,
 	       "%s Enter: PLOGI portid=%06x\n", __func__, fcport->d_id.b24);
-	if (wait)
-		sp->flags = SRB_WAKEUP_ON_COMP;
 	sp->type = SRB_ELS_DCMD;
 	sp->name = "ELS_DCMD";
 	sp->fcport = fcport;
 	if (!elsio->u.els_plogi.els_plogi_pyld) {
 		rval = QLA_FUNCTION_FAILED;
-		goto out;
+		goto done_free_sp;
 	}
 	resp_ptr = elsio->u.els_plogi.els_resp_pyld =
 	if (!elsio->u.els_plogi.els_resp_pyld) {
 		rval = QLA_FUNCTION_FAILED;
-		goto out;
+		goto done_free_sp;
 	}
 	ql_dbg(ql_dbg_io, vha, 0x3073, "PLOGI %p %p\n", ptr, resp_ptr);
 	if (els_opcode == ELS_DCMD_PLOGI && DBELL_ACTIVE(vha)) {
 		struct fc_els_flogi *p = ptr;
 		p->fl_csp.sp_features |= cpu_to_be16(FC_SP_FT_SEC);
 	}
 	    (uint8_t *)elsio->u.els_plogi.els_plogi_pyld,
 	    sizeof(*elsio->u.els_plogi.els_plogi_pyld));
-	init_completion(&elsio->u.els_plogi.comp);
 	rval = qla2x00_start_sp(sp);
 	if (rval != QLA_SUCCESS) {
-		rval = QLA_FUNCTION_FAILED;
+		fcport->flags |= FCF_LOGIN_NEEDED;
+		set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
+		goto done_free_sp;
 	} else {
 		ql_dbg(ql_dbg_disc, vha, 0x3074,
 		    "%s PLOGI sent, hdl=%x, loopid=%x, to port_id %06x from port_id %06x\n",
 		    fcport->d_id.b24, vha->d_id.b24);
 	}
-	if (wait) {
+	return rval;
-		wait_for_completion(&elsio->u.els_plogi.comp);
-		if (elsio->u.els_plogi.comp_status != CS_COMPLETE)
-			rval = QLA_FUNCTION_FAILED;
-	} else {
-		goto done;
-	}
-out:
+done_free_sp:
-	fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 	qla2x00_els_dcmd2_free(vha, &elsio->u.els_plogi);
 	/* ref: INIT */
 	kref_put(&sp->cmd_kref, qla2x00_sp_release);
 done:
+	fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
+	qla2x00_set_fcport_disc_state(fcport, DSC_DELETED);
 	return rval;
 }
 		return -EAGAIN;
 	}
-	pkt = __qla2x00_alloc_iocbs(sp->qpair, sp);
+	pkt = qla2x00_alloc_iocbs_ready(sp->qpair, sp);
 	if (!pkt) {
 		rval = -EAGAIN;
 		ql_log(ql_log_warn, vha, 0x700c,

drivers/scsi/qla2xxx/qla_mbx.c+1−1

@@ -194,7 +194,7 @@ qla2x00_mailbox_command(scsi_qla_host_t vha, mbx_cmd_t mcp) · 193 unmodified lines
194	if (ha->flags.purge_mbox \|\| chip_reset != ha->chip_reset \|\|	194	if (ha->flags.purge_mbox \|\| chip_reset != ha->chip_reset \|\|
195	ha->flags.eeh_busy) {	195	ha->flags.eeh_busy) {
196	ql_log(ql_log_warn, vha, 0xd035,	196	ql_log(ql_log_warn, vha, 0xd035,
197	"Error detected: purge[%d] eeh[%d] cmd=0x%x, Exiting.\n",	197	"Purge mbox: purge[%d] eeh[%d] cmd=0x%x, Exiting.\n",
198	ha->flags.purge_mbox, ha->flags.eeh_busy, mcp->mb[0]);	198	ha->flags.purge_mbox, ha->flags.eeh_busy, mcp->mb[0]);
199	rval = QLA_ABORTED;	199	rval = QLA_ABORTED;
200	goto premature_exit;	200	goto premature_exit;

drivers/scsi/qla2xxx/qla_os.c+2−1

 	ha->init_cb_dma = 0;
 fail_free_vp_map:
 	kfree(ha->vp_map);
+	ha->vp_map = NULL;
 fail:
 	ql_log(ql_log_fatal, NULL, 0x0030,
 	    "Memory allocation failure.\n");
 			break;
 		case QLA_EVT_ELS_PLOGI:
 			qla24xx_els_dcmd2_iocb(vha, ELS_DCMD_PLOGI,
-			    e->u.fcport.fcport, false);
+			    e->u.fcport.fcport);
 			break;
 		case QLA_EVT_SA_REPLACE:
 			rc = qla24xx_issue_sa_replace_iocb(vha, e);

drivers/scsi/qla2xxx/qla_target.c+10−0

@@ -1062,6 +1062,16 @@ void qlt_free_session_done(struct work_struct *work) · 1061 unmodified lines
1062	"%s: sess %p logout completed\n", __func__, sess);	1062	"%s: sess %p logout completed\n", __func__, sess);
1063	}	1063	}
1064		1064
		1065	/* check for any straggling io left behind */
		1066	if (!(sess->flags & FCF_FCP2_DEVICE) &&
		1067	qla2x00_eh_wait_for_pending_commands(sess->vha, sess->d_id.b24, 0, WAIT_TARGET)) {
		1068	ql_log(ql_log_warn, vha, 0x3027,
		1069	"IO not return. Resetting.\n");
		1070	set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
		1071	qla2xxx_wake_dpc(vha);
		1072	qla2x00_wait_for_chip_reset(vha);
		1073	}
		1074
1065	if (sess->logo_ack_needed) {	1075	if (sess->logo_ack_needed) {
1066	sess->logo_ack_needed = 0;	1076	sess->logo_ack_needed = 0;
1067	qla24xx_async_notify_ack(vha, sess,	1077	qla24xx_async_notify_ack(vha, sess,

drivers/scsi/qla2xxx/qla_version.h+2−2

@@ -6,9 +6,9 @@ · 5 unmodified lines
6	/*	6	/*
7	* Driver version	7	* Driver version
8	*/	8	*/
9	#define QLA2XXX_VERSION "10.02.09.100-k"	9	#define QLA2XXX_VERSION "10.02.09.200-k"
10		10
11	#define QLA_DRIVER_MAJOR_VER 10	11	#define QLA_DRIVER_MAJOR_VER 10
12	#define QLA_DRIVER_MINOR_VER 2	12	#define QLA_DRIVER_MINOR_VER 2
13	#define QLA_DRIVER_PATCH_VER 9	13	#define QLA_DRIVER_PATCH_VER 9
14	#define QLA_DRIVER_BETA_VER 100	14	#define QLA_DRIVER_BETA_VER 200

drivers/scsi/scsi_scan.c+34−0

@@ -1642,6 +1642,40 @@ int scsi_add_device(struct Scsi_Host *host, uint channel, · 1641 unmodified lines
1642	}	1642	}
1643	EXPORT_SYMBOL(scsi_add_device);	1643	EXPORT_SYMBOL(scsi_add_device);
1644		1644
		1645	int scsi_resume_device(struct scsi_device *sdev)
		1646	{
		1647	struct device *dev = &sdev->sdev_gendev;
		1648	int ret = 0;
		1649
		1650	device_lock(dev);
		1651
		1652	/*
		1653	* Bail out if the device or its queue are not running. Otherwise,
		1654	* the rescan may block waiting for commands to be executed, with us
		1655	* holding the device lock. This can result in a potential deadlock
		1656	* in the power management core code when system resume is on-going.
		1657	*/
		1658	if (sdev->sdev_state != SDEV_RUNNING \|\|
		1659	blk_queue_pm_only(sdev->request_queue)) {
		1660	ret = -EWOULDBLOCK;
		1661	goto unlock;
		1662	}
		1663
		1664	if (dev->driver && try_module_get(dev->driver->owner)) {
		1665	struct scsi_driver *drv = to_scsi_driver(dev->driver);
		1666
		1667	if (drv->resume)
		1668	ret = drv->resume(dev);
		1669	module_put(dev->driver->owner);
		1670	}
		1671
		1672	unlock:
		1673	device_unlock(dev);
		1674
		1675	return ret;
		1676	}
		1677	EXPORT_SYMBOL(scsi_resume_device);
		1678
1645	int scsi_rescan_device(struct scsi_device *sdev)	1679	int scsi_rescan_device(struct scsi_device *sdev)
1646	{	1680	{
1647	struct device *dev = &sdev->sdev_gendev;	1681	struct device *dev = &sdev->sdev_gendev;

drivers/scsi/sd.c+19−4

 	return sd_suspend_common(dev, true);
 }
-static int sd_resume(struct device *dev, bool runtime)
+static int sd_resume(struct device *dev)
+{
+	struct scsi_disk *sdkp = dev_get_drvdata(dev);
+	sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
+	if (opal_unlock_from_suspend(sdkp->opal_dev)) {
+		sd_printk(KERN_NOTICE, sdkp, "OPAL unlock failed\n");
+		return -EIO;
+	}
+	return 0;
+}
+static int sd_resume_common(struct device *dev, bool runtime)
 {
 	struct scsi_disk *sdkp = dev_get_drvdata(dev);
 	int ret;
 	sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
 	ret = sd_start_stop_device(sdkp, 1);
 	if (!ret) {
-		opal_unlock_from_suspend(sdkp->opal_dev);
+		sd_resume(dev);
 		sdkp->suspended = false;
 	}
 		return 0;
 	}
-	return sd_resume(dev, false);
+	return sd_resume_common(dev, false);
 }
 static int sd_resume_runtime(struct device *dev)
 				  "Failed to clear sense data\n");
 	}
-	return sd_resume(dev, true);
+	return sd_resume_common(dev, true);
 }
 static const struct dev_pm_ops sd_pm_ops = {
 		.pm		= &sd_pm_ops,
 	},
 	.rescan			= sd_rescan,
+	.resume			= sd_resume,
 	.init_command		= sd_init_command,
 	.uninit_command		= sd_uninit_command,
 	.done			= sd_done,

drivers/scsi/sg.c+12−10

 	.llseek = no_llseek,
 };
-static struct class *sg_sysfs_class;
+static const struct class sg_sysfs_class = {
+	.name = "scsi_generic"
+};
 static int sg_sysfs_valid = 0;
 	if (sg_sysfs_valid) {
 		struct device *sg_class_member;
-		sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
+		sg_class_member = device_create(&sg_sysfs_class, cl_dev->parent,
 						MKDEV(SCSI_GENERIC_MAJOR,
 						      sdp->index),
 						sdp, "%s", sdp->name);
 	read_unlock_irqrestore(&sdp->sfd_lock, iflags);
 	sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
-	device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
+	device_destroy(&sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
 	cdev_del(sdp->cdev);
 	sdp->cdev = NULL;
 				    SG_MAX_DEVS, "sg");
 	if (rc)
 		return rc;
-        sg_sysfs_class = class_create("scsi_generic");
+	rc = class_register(&sg_sysfs_class);
-        if ( IS_ERR(sg_sysfs_class) ) {
+	if (rc)
-		rc = PTR_ERR(sg_sysfs_class);
 		goto err_out;
-        }
 	sg_sysfs_valid = 1;
 	rc = scsi_register_interface(&sg_interface);
 	if (0 == rc) {
 #endif				/* CONFIG_SCSI_PROC_FS */
 		return 0;
 	}
-	class_destroy(sg_sysfs_class);
+	class_unregister(&sg_sysfs_class);
 	register_sg_sysctls();
 err_out:
 	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
 	remove_proc_subtree("scsi/sg", NULL);
 #endif				/* CONFIG_SCSI_PROC_FS */
 	scsi_unregister_interface(&sg_interface);
-	class_destroy(sg_sysfs_class);
+	class_unregister(&sg_sysfs_class);
 	sg_sysfs_valid = 0;
 	unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
 				 SG_MAX_DEVS);
 {
 	struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
 	struct sg_device *sdp = sfp->parentdp;
+	struct scsi_device *device = sdp->device;
 	Sg_request *srp;
 	unsigned long iflags;
 			"sg_remove_sfp: sfp=0x%p\n", sfp));
 	kfree(sfp);
-	scsi_device_put(sdp->device);
+	WARN_ON_ONCE(kref_read(&sdp->d_ref) != 1);
 	kref_put(&sdp->d_ref, sg_device_destroy);
+	scsi_device_put(device);
 	module_put(THIS_MODULE);
 }

drivers/scsi/st.c+2−2

@@ -87,7 +87,7 @@ static int try_rdio = 1; · 86 unmodified lines
87	static int try_wdio = 1;	87	static int try_wdio = 1;
88	static int debug_flag;	88	static int debug_flag;
89		89
90	static struct class st_sysfs_class;	90	static const struct class st_sysfs_class;
91	static const struct attribute_group *st_dev_groups[];	91	static const struct attribute_group *st_dev_groups[];
92	static const struct attribute_group *st_drv_groups[];	92	static const struct attribute_group *st_drv_groups[];
93		93
@@ -4438,7 +4438,7 @@ static void scsi_tape_release(struct kref *kref) · 4344 unmodified lines
4438	return;	4438	return;
4439	}	4439	}
4440		4440
4441	static struct class st_sysfs_class = {	4441	static const struct class st_sysfs_class = {
4442	.name = "scsi_tape",	4442	.name = "scsi_tape",
4443	.dev_groups = st_dev_groups,	4443	.dev_groups = st_dev_groups,
4444	};	4444	};

drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c+3−2

 	/* build component create message */
 	m.h.type = MMAL_MSG_TYPE_COMPONENT_CREATE;
 	m.u.component_create.client_component = component->client_component;
-	strncpy(m.u.component_create.name, name,
+	strscpy_pad(m.u.component_create.name, name,
-		sizeof(m.u.component_create.name));
+		    sizeof(m.u.component_create.name));
+	m.u.component_create.pid = 0;
 	ret = send_synchronous_mmal_msg(instance, &m,
 					sizeof(m.u.component_create),

drivers/target/iscsi/iscsi_target_erl1.c+1−2

 	struct iscsi_pdu *pdu)
 {
 	int i, send_recovery_r2t = 0, recovery = 0;
-	u32 length = 0, offset = 0, pdu_count = 0, xfer_len = 0;
+	u32 length = 0, offset = 0, pdu_count = 0;
 	struct iscsit_conn *conn = cmd->conn;
 	struct iscsi_pdu *first_pdu = NULL;
 			if (cmd->pdu_list[i].seq_no == pdu->seq_no) {
 				if (!first_pdu)
 					first_pdu = &cmd->pdu_list[i];
-				xfer_len += cmd->pdu_list[i].length;
 				pdu_count++;
 			} else if (pdu_count)
 				break;

drivers/thermal/devfreq_cooling.c+1−1

@@ -214,7 +214,7 @@ static int devfreq_cooling_get_requested_power(struct thermal_cooling_device *cd · 213 unmodified lines
214		214
215	res = dfc->power_ops->get_real_power(df, power, freq, voltage);	215	res = dfc->power_ops->get_real_power(df, power, freq, voltage);
216	if (!res) {	216	if (!res) {
217	state = dfc->capped_state;	217	state = dfc->max_state - dfc->capped_state;
218		218
219	/* Convert EM power into milli-Watts first */	219	/* Convert EM power into milli-Watts first */
220	rcu_read_lock();	220	rcu_read_lock();

drivers/thermal/thermal_trip.c+2−17

 {
 	const struct thermal_trip *trip;
 	int low = -INT_MAX, high = INT_MAX;
-	bool same_trip = false;
 	int ret;
 	lockdep_assert_held(&tz->lock);
 		return;
 	for_each_trip(tz, trip) {
-		bool low_set = false;
 		int trip_low;
 		trip_low = trip->temperature - trip->hysteresis;
-		if (trip_low < tz->temperature && trip_low > low) {
+		if (trip_low < tz->temperature && trip_low > low)
 			low = trip_low;
-			low_set = true;
-			same_trip = false;
-		}
 		if (trip->temperature > tz->temperature &&
-		    trip->temperature < high) {
+		    trip->temperature < high)
 			high = trip->temperature;
-			same_trip = low_set;
-		}
 	}
 	/* No need to change trip points */
 	if (tz->prev_low_trip == low && tz->prev_high_trip == high)
 		return;
-	/*
-	 * If "high" and "low" are the same, skip the change unless this is the
-	 * first time.
-	 */
-	if (same_trip && (tz->prev_low_trip != -INT_MAX ||
-	    tz->prev_high_trip != INT_MAX))
-		return;
 	tz->prev_low_trip = low;
 	tz->prev_high_trip = high;

drivers/ufs/core/ufs-mcq.c+1−1

@@ -94,7 +94,7 @@ void ufshcd_mcq_config_mac(struct ufs_hba *hba, u32 max_active_cmds) · 93 unmodified lines
94		94
95	val = ufshcd_readl(hba, REG_UFS_MCQ_CFG);	95	val = ufshcd_readl(hba, REG_UFS_MCQ_CFG);
96	val &= ~MCQ_CFG_MAC_MASK;	96	val &= ~MCQ_CFG_MAC_MASK;
97	val \|= FIELD_PREP(MCQ_CFG_MAC_MASK, max_active_cmds);	97	val \|= FIELD_PREP(MCQ_CFG_MAC_MASK, max_active_cmds - 1);
98	ufshcd_writel(hba, val, REG_UFS_MCQ_CFG);	98	ufshcd_writel(hba, val, REG_UFS_MCQ_CFG);
99	}	99	}
100	EXPORT_SYMBOL_GPL(ufshcd_mcq_config_mac);	100	EXPORT_SYMBOL_GPL(ufshcd_mcq_config_mac);

drivers/ufs/host/ufs-qcom.c+4−2

 	list_for_each_entry(clki, head, list) {
 		if (!IS_ERR_OR_NULL(clki->clk) &&
-			!strcmp(clki->name, "core_clk_unipro")) {
+		    !strcmp(clki->name, "core_clk_unipro")) {
-			if (is_scale_up)
+			if (!clki->max_freq)
+				cycles_in_1us = 150; /* default for backwards compatibility */
+			else if (is_scale_up)
 				cycles_in_1us = ceil(clki->max_freq, (1000 * 1000));
 			else
 				cycles_in_1us = ceil(clk_get_rate(clki->clk), (1000 * 1000));

drivers/uio/uio.c+1−1

@@ -792,7 +792,7 @@ static int uio_mmap_dma_coherent(struct vm_area_struct *vma) · 791 unmodified lines
792	*/	792	*/
793	vma->vm_pgoff = 0;	793	vma->vm_pgoff = 0;
794		794
795	addr = (void *)mem->addr;	795	addr = (void *)(uintptr_t)mem->addr;
796	ret = dma_mmap_coherent(mem->dma_device,	796	ret = dma_mmap_coherent(mem->dma_device,
797	vma,	797	vma,
798	addr,	798	addr,

drivers/uio/uio_dmem_genirq.c+2−2

@@ -60,7 +60,7 @@ static int uio_dmem_genirq_open(struct uio_info info, struct inode inode) · 59 unmodified lines
60		60
61	addr = dma_alloc_coherent(&priv->pdev->dev, uiomem->size,	61	addr = dma_alloc_coherent(&priv->pdev->dev, uiomem->size,
62	&uiomem->dma_addr, GFP_KERNEL);	62	&uiomem->dma_addr, GFP_KERNEL);
63	uiomem->addr = addr ? (phys_addr_t) addr : DMEM_MAP_ERROR;	63	uiomem->addr = addr ? (uintptr_t) addr : DMEM_MAP_ERROR;
64	++uiomem;	64	++uiomem;
65	}	65	}
66	priv->refcnt++;	66	priv->refcnt++;
@@ -89,7 +89,7 @@ static int uio_dmem_genirq_release(struct uio_info info, struct inode inode) · 22 unmodified lines
89	break;	89	break;
90	if (uiomem->addr) {	90	if (uiomem->addr) {
91	dma_free_coherent(uiomem->dma_device, uiomem->size,	91	dma_free_coherent(uiomem->dma_device, uiomem->size,
92	(void *) uiomem->addr,	92	(void *) (uintptr_t) uiomem->addr,
93	uiomem->dma_addr);	93	uiomem->dma_addr);
94	}	94	}
95	uiomem->addr = DMEM_MAP_ERROR;	95	uiomem->addr = DMEM_MAP_ERROR;

drivers/uio/uio_pruss.c+1−1

@@ -191,7 +191,7 @@ static int pruss_probe(struct platform_device *pdev) · 190 unmodified lines
191	p->mem[1].size = sram_pool_sz;	191	p->mem[1].size = sram_pool_sz;
192	p->mem[1].memtype = UIO_MEM_PHYS;	192	p->mem[1].memtype = UIO_MEM_PHYS;
193		193
194	p->mem[2].addr = (phys_addr_t) gdev->ddr_vaddr;	194	p->mem[2].addr = (uintptr_t) gdev->ddr_vaddr;
195	p->mem[2].dma_addr = gdev->ddr_paddr;	195	p->mem[2].dma_addr = gdev->ddr_paddr;
196	p->mem[2].size = extram_pool_sz;	196	p->mem[2].size = extram_pool_sz;
197	p->mem[2].memtype = UIO_MEM_DMA_COHERENT;	197	p->mem[2].memtype = UIO_MEM_DMA_COHERENT;

drivers/usb/class/cdc-wdm.c+5−1

 static int service_outstanding_interrupt(struct wdm_device *desc)
 {
 	int rv = 0;
+	int used;
 	/* submit read urb only if the device is waiting for it */
 	if (!desc->resp_count || !--desc->resp_count)
 		goto out;
 	}
-	set_bit(WDM_RESPONDING, &desc->flags);
+	used = test_and_set_bit(WDM_RESPONDING, &desc->flags);
+	if (used)
+		goto out;
 	spin_unlock_irq(&desc->iuspin);
 	rv = usb_submit_urb(desc->response, GFP_KERNEL);
 	spin_lock_irq(&desc->iuspin);

drivers/usb/core/hub.c+16−7

 #define HUB_DEBOUNCE_STEP	  25
 #define HUB_DEBOUNCE_STABLE	 100
-static void hub_release(struct kref *kref);
 static int usb_reset_and_verify_device(struct usb_device *udev);
 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state);
 static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
 	 */
 	intf = to_usb_interface(hub->intfdev);
 	usb_autopm_get_interface_no_resume(intf);
-	kref_get(&hub->kref);
+	hub_get(hub);
 	if (queue_work(hub_wq, &hub->events))
 		return;
 	/* the work has already been scheduled */
 	usb_autopm_put_interface_async(intf);
-	kref_put(&hub->kref, hub_release);
+	hub_put(hub);
 }
 void usb_kick_hub_wq(struct usb_device *hdev)
 			goto init2;
 		goto init3;
 	}
-	kref_get(&hub->kref);
+	hub_get(hub);
 	/* The superspeed hub except for root hub has to use Hub Depth
 	 * value as an offset into the route string to locate the bits
 		device_unlock(&hdev->dev);
 	}
-	kref_put(&hub->kref, hub_release);
+	hub_put(hub);
 }
 /* Implement the continuations for the delays above */
 	kfree(hub);
 }
+void hub_get(struct usb_hub *hub)
+{
+	kref_get(&hub->kref);
+}
+void hub_put(struct usb_hub *hub)
+{
+	kref_put(&hub->kref, hub_release);
+}
 static unsigned highspeed_hubs;
 static void hub_disconnect(struct usb_interface *intf)
 	onboard_hub_destroy_pdevs(&hub->onboard_hub_devs);
-	kref_put(&hub->kref, hub_release);
+	hub_put(hub);
 }
 static bool hub_descriptor_is_sane(struct usb_host_interface *desc)
 	/* Balance the stuff in kick_hub_wq() and allow autosuspend */
 	usb_autopm_put_interface(intf);
-	kref_put(&hub->kref, hub_release);
+	hub_put(hub);
 	kcov_remote_stop();
 }

drivers/usb/core/hub.h+2−0

 extern int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
 		int port1, bool set);
 extern struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev);
+extern void hub_get(struct usb_hub *hub);
+extern void hub_put(struct usb_hub *hub);
 extern int hub_port_debounce(struct usb_hub *hub, int port1,
 		bool must_be_connected);
 extern int usb_clear_port_feature(struct usb_device *hdev,

drivers/usb/core/port.c+34−4

 	u16 portstatus, unused;
 	bool disabled;
 	int rc;
+	struct kernfs_node *kn;
+	hub_get(hub);
 	rc = usb_autopm_get_interface(intf);
 	if (rc < 0)
-		return rc;
+		goto out_hub_get;
+	/*
+	 * Prevent deadlock if another process is concurrently
+	 * trying to unregister hdev.
+	 */
+	kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);
+	if (!kn) {
+		rc = -ENODEV;
+		goto out_autopm;
+	}
 	usb_lock_device(hdev);
 	if (hub->disconnected) {
 		rc = -ENODEV;
 	usb_hub_port_status(hub, port1, &portstatus, &unused);
 	disabled = !usb_port_is_power_on(hub, portstatus);
-out_hdev_lock:
+ out_hdev_lock:
 	usb_unlock_device(hdev);
+	sysfs_unbreak_active_protection(kn);
+ out_autopm:
 	usb_autopm_put_interface(intf);
+ out_hub_get:
+	hub_put(hub);
 	if (rc)
 		return rc;
 	int port1 = port_dev->portnum;
 	bool disabled;
 	int rc;
+	struct kernfs_node *kn;
 	rc = kstrtobool(buf, &disabled);
 	if (rc)
 		return rc;
+	hub_get(hub);
 	rc = usb_autopm_get_interface(intf);
 	if (rc < 0)
-		return rc;
+		goto out_hub_get;
+	/*
+	 * Prevent deadlock if another process is concurrently
+	 * trying to unregister hdev.
+	 */
+	kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);
+	if (!kn) {
+		rc = -ENODEV;
+		goto out_autopm;
+	}
 	usb_lock_device(hdev);
 	if (hub->disconnected) {
 		rc = -ENODEV;
 	if (!rc)
 		rc = count;
-out_hdev_lock:
+ out_hdev_lock:
 	usb_unlock_device(hdev);
+	sysfs_unbreak_active_protection(kn);
+ out_autopm:
 	usb_autopm_put_interface(intf);
+ out_hub_get:
+	hub_put(hub);
 	return rc;
 }

drivers/usb/core/sysfs.c+13−3

 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	bool val;
+	struct kernfs_node *kn;
 	if (kstrtobool(buf, &val) != 0)
 		return -EINVAL;
-	if (val)
+	if (val) {
 		usb_authorize_interface(intf);
-	else
+	} else {
-		usb_deauthorize_interface(intf);
+		/*
+		 * Prevent deadlock if another process is concurrently
+		 * trying to unregister intf.
+		 */
+		kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);
+		if (kn) {
+			usb_deauthorize_interface(intf);
+			sysfs_unbreak_active_protection(kn);
+		}
+	}
 	return count;
 }

drivers/usb/dwc2/core.h+14−0

  * struct dwc2_hregs_backup - Holds host registers state before
  * entering partial power down
  * @hcfg:		Backup of HCFG register
+ * @hflbaddr:		Backup of HFLBADDR register
  * @haintmsk:		Backup of HAINTMSK register
+ * @hcchar:		Backup of HCCHAR register
+ * @hcsplt:		Backup of HCSPLT register
  * @hcintmsk:		Backup of HCINTMSK register
+ * @hctsiz:		Backup of HCTSIZ register
+ * @hdma:		Backup of HCDMA register
+ * @hcdmab:		Backup of HCDMAB register
  * @hprt0:		Backup of HPTR0 register
  * @hfir:		Backup of HFIR register
  * @hptxfsiz:		Backup of HPTXFSIZ register
  */
 struct dwc2_hregs_backup {
 	u32 hcfg;
+	u32 hflbaddr;
 	u32 haintmsk;
+	u32 hcchar[MAX_EPS_CHANNELS];
+	u32 hcsplt[MAX_EPS_CHANNELS];
 	u32 hcintmsk[MAX_EPS_CHANNELS];
+	u32 hctsiz[MAX_EPS_CHANNELS];
+	u32 hcidma[MAX_EPS_CHANNELS];
+	u32 hcidmab[MAX_EPS_CHANNELS];
 	u32 hprt0;
 	u32 hfir;
 	u32 hptxfsiz;
 	bool needs_byte_swap;
 	/* DWC OTG HW Release versions */
+#define DWC2_CORE_REV_4_30a	0x4f54430a
 #define DWC2_CORE_REV_2_71a	0x4f54271a
 #define DWC2_CORE_REV_2_72a     0x4f54272a
 #define DWC2_CORE_REV_2_80a	0x4f54280a
 int dwc2_restore_global_registers(struct dwc2_hsotg *hsotg);
 void dwc2_enable_acg(struct dwc2_hsotg *hsotg);
+void dwc2_wakeup_from_lpm_l1(struct dwc2_hsotg *hsotg, bool remotewakeup);
 /* This function should be called on every hardware interrupt. */
 irqreturn_t dwc2_handle_common_intr(int irq, void *dev);

drivers/usb/dwc2/core_intr.c+48−24

@@ -297,7 +297,8 @@ static void dwc2_handle_session_req_intr(struct dwc2_hsotg *hsotg) · 296 unmodified lines
297		297
298	/* Exit gadget mode clock gating. */	298	/* Exit gadget mode clock gating. */
299	if (hsotg->params.power_down ==	299	if (hsotg->params.power_down ==
300	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended)	300	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended &&
		301	!hsotg->params.no_clock_gating)
301	dwc2_gadget_exit_clock_gating(hsotg, 0);	302	dwc2_gadget_exit_clock_gating(hsotg, 0);
302	}	303	}
303		304
@@ -322,10 +323,11 @@ static void dwc2_handle_session_req_intr(struct dwc2_hsotg *hsotg) · 18 unmodified lines
322	* @hsotg: Programming view of DWC_otg controller	323	* @hsotg: Programming view of DWC_otg controller
323	*	324	*
324	*/	325	*/
325	static void dwc2_wakeup_from_lpm_l1(struct dwc2_hsotg *hsotg)	326	void dwc2_wakeup_from_lpm_l1(struct dwc2_hsotg *hsotg, bool remotewakeup)
326	{	327	{
327	u32 glpmcfg;	328	u32 glpmcfg;
328	u32 i = 0;	329	u32 pcgctl;
		330	u32 dctl;
329		331
330	if (hsotg->lx_state != DWC2_L1) {	332	if (hsotg->lx_state != DWC2_L1) {
331	dev_err(hsotg->dev, "Core isn't in DWC2_L1 state\n");	333	dev_err(hsotg->dev, "Core isn't in DWC2_L1 state\n");
@@ -334,37 +336,57 @@ static void dwc2_wakeup_from_lpm_l1(struct dwc2_hsotg *hsotg) · 2 unmodified lines
334		336
335	glpmcfg = dwc2_readl(hsotg, GLPMCFG);	337	glpmcfg = dwc2_readl(hsotg, GLPMCFG);
336	if (dwc2_is_device_mode(hsotg)) {	338	if (dwc2_is_device_mode(hsotg)) {
337	dev_dbg(hsotg->dev, "Exit from L1 state\n");	339	dev_dbg(hsotg->dev, "Exit from L1 state, remotewakeup=%d\n", remotewakeup);
338	glpmcfg &= ~GLPMCFG_ENBLSLPM;	340	glpmcfg &= ~GLPMCFG_ENBLSLPM;
339	glpmcfg &= ~GLPMCFG_HIRD_THRES_EN;	341	glpmcfg &= ~GLPMCFG_HIRD_THRES_MASK;
340	dwc2_writel(hsotg, glpmcfg, GLPMCFG);	342	dwc2_writel(hsotg, glpmcfg, GLPMCFG);
341		343
342	do {	344	pcgctl = dwc2_readl(hsotg, PCGCTL);
343	glpmcfg = dwc2_readl(hsotg, GLPMCFG);	345	pcgctl &= ~PCGCTL_ENBL_SLEEP_GATING;
		346	dwc2_writel(hsotg, pcgctl, PCGCTL);
344		347
345	if (!(glpmcfg & (GLPMCFG_COREL1RES_MASK \|	348	glpmcfg = dwc2_readl(hsotg, GLPMCFG);
346	GLPMCFG_L1RESUMEOK \| GLPMCFG_SLPSTS)))	349	if (glpmcfg & GLPMCFG_ENBESL) {
347	break;	350	glpmcfg \|= GLPMCFG_RSTRSLPSTS;
		351	dwc2_writel(hsotg, glpmcfg, GLPMCFG);
		352	}
		353
		354	if (remotewakeup) {
		355	if (dwc2_hsotg_wait_bit_set(hsotg, GLPMCFG, GLPMCFG_L1RESUMEOK, 1000)) {
		356	dev_warn(hsotg->dev, "%s: timeout GLPMCFG_L1RESUMEOK\n", __func__);
		357	goto fail;
		358	return;
		359	}
		360
		361	dctl = dwc2_readl(hsotg, DCTL);
		362	dctl \|= DCTL_RMTWKUPSIG;
		363	dwc2_writel(hsotg, dctl, DCTL);
348		364
349	udelay(1);	365	if (dwc2_hsotg_wait_bit_set(hsotg, GINTSTS, GINTSTS_WKUPINT, 1000)) {
350	} while (++i < 200);	366	dev_warn(hsotg->dev, "%s: timeout GINTSTS_WKUPINT\n", __func__);
		367	goto fail;
		368	return;
		369	}
		370	}
351		371
352	if (i == 200) {	372	glpmcfg = dwc2_readl(hsotg, GLPMCFG);
353	dev_err(hsotg->dev, "Failed to exit L1 sleep state in 200us.\n");	373	if (glpmcfg & GLPMCFG_COREL1RES_MASK \|\| glpmcfg & GLPMCFG_SLPSTS \|\|
		374	glpmcfg & GLPMCFG_L1RESUMEOK) {
		375	goto fail;
354	return;	376	return;
355	}	377	}
356	dwc2_gadget_init_lpm(hsotg);	378
		379	/* Inform gadget to exit from L1 */
		380	call_gadget(hsotg, resume);
		381	/* Change to L0 state */
		382	hsotg->lx_state = DWC2_L0;
		383	hsotg->bus_suspended = false;
		384	fail: dwc2_gadget_init_lpm(hsotg);
357	} else {	385	} else {
358	/* TODO */	386	/* TODO */
359	dev_err(hsotg->dev, "Host side LPM is not supported.\n");	387	dev_err(hsotg->dev, "Host side LPM is not supported.\n");
360	return;	388	return;
361	}	389	}
362
363	/* Change to L0 state */
364	hsotg->lx_state = DWC2_L0;
365
366	/* Inform gadget to exit from L1 */
367	call_gadget(hsotg, resume);
368	}	390	}
369		391
370	/*	392	/*
@@ -385,7 +407,7 @@ static void dwc2_handle_wakeup_detected_intr(struct dwc2_hsotg *hsotg) · 14 unmodified lines
385	dev_dbg(hsotg->dev, "%s lxstate = %d\n", __func__, hsotg->lx_state);	407	dev_dbg(hsotg->dev, "%s lxstate = %d\n", __func__, hsotg->lx_state);
386		408
387	if (hsotg->lx_state == DWC2_L1) {	409	if (hsotg->lx_state == DWC2_L1) {
388	dwc2_wakeup_from_lpm_l1(hsotg);	410	dwc2_wakeup_from_lpm_l1(hsotg, false);
389	return;	411	return;
390	}	412	}
391		413
@@ -408,7 +430,8 @@ static void dwc2_handle_wakeup_detected_intr(struct dwc2_hsotg *hsotg) · 16 unmodified lines
408		430
409	/* Exit gadget mode clock gating. */	431	/* Exit gadget mode clock gating. */
410	if (hsotg->params.power_down ==	432	if (hsotg->params.power_down ==
411	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended)	433	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended &&
		434	!hsotg->params.no_clock_gating)
412	dwc2_gadget_exit_clock_gating(hsotg, 0);	435	dwc2_gadget_exit_clock_gating(hsotg, 0);
413	} else {	436	} else {
414	/* Change to L0 state */	437	/* Change to L0 state */
@@ -425,7 +448,8 @@ static void dwc2_handle_wakeup_detected_intr(struct dwc2_hsotg *hsotg) · 10 unmodified lines
425	}	448	}
426		449
427	if (hsotg->params.power_down ==	450	if (hsotg->params.power_down ==
428	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended)	451	DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended &&
		452	!hsotg->params.no_clock_gating)
429	dwc2_host_exit_clock_gating(hsotg, 1);	453	dwc2_host_exit_clock_gating(hsotg, 1);
430		454
431	/*	455	/*

drivers/usb/dwc2/gadget.c+10−0

 		ep->name, req, req->length, req->buf, req->no_interrupt,
 		req->zero, req->short_not_ok);
+	if (hs->lx_state == DWC2_L1) {
+		dwc2_wakeup_from_lpm_l1(hs, true);
+	}
 	/* Prevent new request submission when controller is suspended */
 	if (hs->lx_state != DWC2_L0) {
 		dev_dbg(hs->dev, "%s: submit request only in active state\n",
 		if (hsotg->in_ppd && hsotg->lx_state == DWC2_L2)
 			dwc2_exit_partial_power_down(hsotg, 0, true);
+		/* Exit gadget mode clock gating. */
+		if (hsotg->params.power_down ==
+		    DWC2_POWER_DOWN_PARAM_NONE && hsotg->bus_suspended &&
+		    !hsotg->params.no_clock_gating)
+			dwc2_gadget_exit_clock_gating(hsotg, 0);
 		hsotg->lx_state = DWC2_L0;
 	}

drivers/usb/dwc2/hcd.c+40−9

 			hsotg->available_host_channels--;
 		}
 		qh = list_entry(qh_ptr, struct dwc2_qh, qh_list_entry);
-		if (dwc2_assign_and_init_hc(hsotg, qh))
+		if (dwc2_assign_and_init_hc(hsotg, qh)) {
+			if (hsotg->params.uframe_sched)
+				hsotg->available_host_channels++;
 			break;
+		}
 		/*
 		 * Move the QH from the periodic ready schedule to the
 			hsotg->available_host_channels--;
 		}
-		if (dwc2_assign_and_init_hc(hsotg, qh))
+		if (dwc2_assign_and_init_hc(hsotg, qh)) {
+			if (hsotg->params.uframe_sched)
+				hsotg->available_host_channels++;
 			break;
+		}
 		/*
 		 * Move the QH from the non-periodic inactive schedule to the
 			 urb->actual_length);
 	if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
+		if (!hsotg->params.dma_desc_enable)
+			urb->start_frame = qtd->qh->start_active_frame;
 		urb->error_count = dwc2_hcd_urb_get_error_count(qtd->urb);
 		for (i = 0; i < urb->number_of_packets; ++i) {
 			urb->iso_frame_desc[i].actual_length =
 	}
 	if (hsotg->params.power_down == DWC2_POWER_DOWN_PARAM_NONE &&
-	    hsotg->bus_suspended) {
+	    hsotg->bus_suspended && !hsotg->params.no_clock_gating) {
 		if (dwc2_is_device_mode(hsotg))
 			dwc2_gadget_exit_clock_gating(hsotg, 0);
 		else
 	/* Backup Host regs */
 	hr = &hsotg->hr_backup;
 	hr->hcfg = dwc2_readl(hsotg, HCFG);
+	hr->hflbaddr = dwc2_readl(hsotg, HFLBADDR);
 	hr->haintmsk = dwc2_readl(hsotg, HAINTMSK);
-	for (i = 0; i < hsotg->params.host_channels; ++i)
+	for (i = 0; i < hsotg->params.host_channels; ++i) {
+		hr->hcchar[i] = dwc2_readl(hsotg, HCCHAR(i));
+		hr->hcsplt[i] = dwc2_readl(hsotg, HCSPLT(i));
 		hr->hcintmsk[i] = dwc2_readl(hsotg, HCINTMSK(i));
+		hr->hctsiz[i] = dwc2_readl(hsotg, HCTSIZ(i));
+		hr->hcidma[i] = dwc2_readl(hsotg, HCDMA(i));
+		hr->hcidmab[i] = dwc2_readl(hsotg, HCDMAB(i));
+	}
 	hr->hprt0 = dwc2_read_hprt0(hsotg);
 	hr->hfir = dwc2_readl(hsotg, HFIR);
 	hr->valid = false;
 	dwc2_writel(hsotg, hr->hcfg, HCFG);
+	dwc2_writel(hsotg, hr->hflbaddr, HFLBADDR);
 	dwc2_writel(hsotg, hr->haintmsk, HAINTMSK);
-	for (i = 0; i < hsotg->params.host_channels; ++i)
+	for (i = 0; i < hsotg->params.host_channels; ++i) {
+		dwc2_writel(hsotg, hr->hcchar[i], HCCHAR(i));
+		dwc2_writel(hsotg, hr->hcsplt[i], HCSPLT(i));
 		dwc2_writel(hsotg, hr->hcintmsk[i], HCINTMSK(i));
+		dwc2_writel(hsotg, hr->hctsiz[i], HCTSIZ(i));
+		dwc2_writel(hsotg, hr->hcidma[i], HCDMA(i));
+		dwc2_writel(hsotg, hr->hcidmab[i], HCDMAB(i));
+	}
 	dwc2_writel(hsotg, hr->hprt0, HPRT0);
 	dwc2_writel(hsotg, hr->hfir, HFIR);
 	dwc2_writel(hsotg, hr->hcfg, HCFG);
 	/* De-assert Wakeup Logic */
-	gpwrdn = dwc2_readl(hsotg, GPWRDN);
+	if (!(rem_wakeup && hsotg->hw_params.snpsid >= DWC2_CORE_REV_4_30a)) {
-	gpwrdn &= ~GPWRDN_PMUACTV;
+		gpwrdn = dwc2_readl(hsotg, GPWRDN);
-	dwc2_writel(hsotg, gpwrdn, GPWRDN);
+		gpwrdn &= ~GPWRDN_PMUACTV;
-	udelay(10);
+		dwc2_writel(hsotg, gpwrdn, GPWRDN);
+		udelay(10);
+	}
 	hprt0 = hr->hprt0;
 	hprt0 |= HPRT0_PWR;
 		hprt0 |= HPRT0_RES;
 		dwc2_writel(hsotg, hprt0, HPRT0);
+		/* De-assert Wakeup Logic */
+		if ((rem_wakeup && hsotg->hw_params.snpsid >= DWC2_CORE_REV_4_30a)) {
+			gpwrdn = dwc2_readl(hsotg, GPWRDN);
+			gpwrdn &= ~GPWRDN_PMUACTV;
+			dwc2_writel(hsotg, gpwrdn, GPWRDN);
+			udelay(10);
+		}
 		/* Wait for Resume time and then program HPRT again */
 		mdelay(100);
 		hprt0 &= ~HPRT0_RES;

drivers/usb/dwc2/hcd_ddma.c+11−6

 	idx = qh->td_last;
 	inc = qh->host_interval;
 	hsotg->frame_number = dwc2_hcd_get_frame_number(hsotg);
-	cur_idx = dwc2_frame_list_idx(hsotg->frame_number);
+	cur_idx = idx;
 	next_idx = dwc2_desclist_idx_inc(qh->td_last, inc, qh->dev_speed);
 	/*
 {
 	struct dwc2_dma_desc *dma_desc;
 	struct dwc2_hcd_iso_packet_desc *frame_desc;
+	u16 frame_desc_idx;
+	struct urb *usb_urb = qtd->urb->priv;
 	u16 remain = 0;
 	int rc = 0;
 				DMA_FROM_DEVICE);
 	dma_desc = &qh->desc_list[idx];
+	frame_desc_idx = (idx - qtd->isoc_td_first) & (usb_urb->number_of_packets - 1);
-	frame_desc = &qtd->urb->iso_descs[qtd->isoc_frame_index_last];
+	frame_desc = &qtd->urb->iso_descs[frame_desc_idx];
+	if (idx == qtd->isoc_td_first)
+		usb_urb->start_frame = dwc2_hcd_get_frame_number(hsotg);
 	dma_desc->buf = (u32)(qtd->urb->dma + frame_desc->offset);
 	if (chan->ep_is_in)
 		remain = (dma_desc->status & HOST_DMA_ISOC_NBYTES_MASK) >>
 		frame_desc->status = 0;
 	}
-	if (++qtd->isoc_frame_index == qtd->urb->packet_count) {
+	if (++qtd->isoc_frame_index == usb_urb->number_of_packets) {
 		/*
 		 * urb->status is not used for isoc transfers here. The
 		 * individual frame_desc status are used instead.
 				return;
 			idx = dwc2_desclist_idx_inc(idx, qh->host_interval,
 						    chan->speed);
-			if (!rc)
+			if (rc == 0)
 				continue;
-			if (rc == DWC2_CMPL_DONE)
+			if (rc == DWC2_CMPL_DONE || rc == DWC2_CMPL_STOP)
-				break;
+				goto stop_scan;
 			/* rc == DWC2_CMPL_STOP */

drivers/usb/dwc2/hw.h+1−1

@@ -698,7 +698,7 @@ · 697 unmodified lines
698	#define TXSTS_QTOP_TOKEN_MASK (0x3 << 25)	698	#define TXSTS_QTOP_TOKEN_MASK (0x3 << 25)
699	#define TXSTS_QTOP_TOKEN_SHIFT 25	699	#define TXSTS_QTOP_TOKEN_SHIFT 25
700	#define TXSTS_QTOP_TERMINATE BIT(24)	700	#define TXSTS_QTOP_TERMINATE BIT(24)
701	#define TXSTS_QSPCAVAIL_MASK (0xff << 16)	701	#define TXSTS_QSPCAVAIL_MASK (0x7f << 16)
702	#define TXSTS_QSPCAVAIL_SHIFT 16	702	#define TXSTS_QSPCAVAIL_SHIFT 16
703	#define TXSTS_FSPCAVAIL_MASK (0xffff << 0)	703	#define TXSTS_FSPCAVAIL_MASK (0xffff << 0)
704	#define TXSTS_FSPCAVAIL_SHIFT 0	704	#define TXSTS_FSPCAVAIL_SHIFT 0

drivers/usb/dwc2/platform.c+1−1

@@ -331,7 +331,7 @@ static void dwc2_driver_remove(struct platform_device *dev) · 330 unmodified lines
331		331
332	/* Exit clock gating when driver is removed. */	332	/* Exit clock gating when driver is removed. */
333	if (hsotg->params.power_down == DWC2_POWER_DOWN_PARAM_NONE &&	333	if (hsotg->params.power_down == DWC2_POWER_DOWN_PARAM_NONE &&
334	hsotg->bus_suspended) {	334	hsotg->bus_suspended && !hsotg->params.no_clock_gating) {
335	if (dwc2_is_device_mode(hsotg))	335	if (dwc2_is_device_mode(hsotg))
336	dwc2_gadget_exit_clock_gating(hsotg, 0);	336	dwc2_gadget_exit_clock_gating(hsotg, 0);
337	else	337	else

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

@@ -1519,6 +1519,8 @@ static void dwc3_get_properties(struct dwc3 *dwc) · 1518 unmodified lines
1519	else	1519	else
1520	dwc->sysdev = dwc->dev;	1520	dwc->sysdev = dwc->dev;
1521		1521
		1522	dwc->sys_wakeup = device_may_wakeup(dwc->sysdev);
		1523
1522	ret = device_property_read_string(dev, "usb-psy-name", &usb_psy_name);	1524	ret = device_property_read_string(dev, "usb-psy-name", &usb_psy_name);
1523	if (ret >= 0) {	1525	if (ret >= 0) {
1524	dwc->usb_psy = power_supply_get_by_name(usb_psy_name);	1526	dwc->usb_psy = power_supply_get_by_name(usb_psy_name);

drivers/usb/dwc3/core.h+2−0

  *	3	- Reserved
  * @dis_metastability_quirk: set to disable metastability quirk.
  * @dis_split_quirk: set to disable split boundary.
+ * @sys_wakeup: set if the device may do system wakeup.
  * @wakeup_configured: set if the device is configured for remote wakeup.
  * @suspended: set to track suspend event due to U3/L2.
  * @imod_interval: set the interrupt moderation interval in 250ns
 	unsigned		dis_split_quirk:1;
 	unsigned		async_callbacks:1;
+	unsigned		sys_wakeup:1;
 	unsigned		wakeup_configured:1;
 	unsigned		suspended:1;

drivers/usb/dwc3/dwc3-pci.c+0−2

 #define PCI_DEVICE_ID_INTEL_MTLP		0x7ec1
 #define PCI_DEVICE_ID_INTEL_MTLS		0x7f6f
 #define PCI_DEVICE_ID_INTEL_MTL			0x7e7e
-#define PCI_DEVICE_ID_INTEL_ARLH		0x7ec1
 #define PCI_DEVICE_ID_INTEL_ARLH_PCH		0x777e
 #define PCI_DEVICE_ID_INTEL_TGL			0x9a15
 #define PCI_DEVICE_ID_AMD_MR			0x163a
 	{ PCI_DEVICE_DATA(INTEL, MTLP, &dwc3_pci_intel_swnode) },
 	{ PCI_DEVICE_DATA(INTEL, MTL, &dwc3_pci_intel_swnode) },
 	{ PCI_DEVICE_DATA(INTEL, MTLS, &dwc3_pci_intel_swnode) },
-	{ PCI_DEVICE_DATA(INTEL, ARLH, &dwc3_pci_intel_swnode) },
 	{ PCI_DEVICE_DATA(INTEL, ARLH_PCH, &dwc3_pci_intel_swnode) },
 	{ PCI_DEVICE_DATA(INTEL, TGL, &dwc3_pci_intel_swnode) },

drivers/usb/dwc3/gadget.c+10−0

 	dwc->gadget_driver	= driver;
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	if (dwc->sys_wakeup)
+		device_wakeup_enable(dwc->sysdev);
 	return 0;
 }
 	struct dwc3		*dwc = gadget_to_dwc(g);
 	unsigned long		flags;
+	if (dwc->sys_wakeup)
+		device_wakeup_disable(dwc->sysdev);
 	spin_lock_irqsave(&dwc->lock, flags);
 	dwc->gadget_driver	= NULL;
 	dwc->max_cfg_eps = 0;
 	else
 		dwc3_gadget_set_speed(dwc->gadget, dwc->maximum_speed);
+	/* No system wakeup if no gadget driver bound */
+	if (dwc->sys_wakeup)
+		device_wakeup_disable(dwc->sysdev);
 	return 0;
 err5:

drivers/usb/dwc3/host.c+11−0

 		goto err;
 	}
+	if (dwc->sys_wakeup) {
+		/* Restore wakeup setting if switched from device */
+		device_wakeup_enable(dwc->sysdev);
+		/* Pass on wakeup setting to the new xhci platform device */
+		device_init_wakeup(&xhci->dev, true);
+	}
 	return 0;
 err:
 	platform_device_put(xhci);
 void dwc3_host_exit(struct dwc3 *dwc)
 {
+	if (dwc->sys_wakeup)
+		device_init_wakeup(&dwc->xhci->dev, false);
 	platform_device_unregister(dwc->xhci);
 	dwc->xhci = NULL;
 }

drivers/usb/gadget/udc/core.c+3−1

 {
 	int ret = 0;
-	if (WARN_ON_ONCE(!ep->enabled && ep->address)) {
+	if (!ep->enabled && ep->address) {
+		pr_debug("USB gadget: queue request to disabled ep 0x%x (%s)\n",
+				 ep->address, ep->name);
 		ret = -ESHUTDOWN;
 		goto out;
 	}

drivers/usb/misc/usb-ljca.c+9−13

 	int ret;
 	client = kzalloc(sizeof *client, GFP_KERNEL);
-	if (!client)
+	if (!client) {
+		kfree(data);
 		return -ENOMEM;
+	}
 	client->type = type;
 	client->id = id;
 	auxdev->dev.release = ljca_auxdev_release;
 	ret = auxiliary_device_init(auxdev);
-	if (ret)
+	if (ret) {
+		kfree(data);
 		goto err_free;
+	}
 	ljca_auxdev_acpi_bind(adap, auxdev, adr, id);
 		valid_pin[i] = get_unaligned_le32(&desc->bank_desc[i].valid_pins);
 	bitmap_from_arr32(gpio_info->valid_pin_map, valid_pin, gpio_num);
-	ret = ljca_new_client_device(adap, LJCA_CLIENT_GPIO, 0, "ljca-gpio",
+	return ljca_new_client_device(adap, LJCA_CLIENT_GPIO, 0, "ljca-gpio",
 				     gpio_info, LJCA_GPIO_ACPI_ADR);
-	if (ret)
-		kfree(gpio_info);
-	return ret;
 }
 static int ljca_enumerate_i2c(struct ljca_adapter *adap)
 		ret = ljca_new_client_device(adap, LJCA_CLIENT_I2C, i,
 					     "ljca-i2c", i2c_info,
 					     LJCA_I2C1_ACPI_ADR + i);
-		if (ret) {
+		if (ret)
-			kfree(i2c_info);
 			return ret;
-		}
 	}
 	return 0;
 		ret = ljca_new_client_device(adap, LJCA_CLIENT_SPI, i,
 					     "ljca-spi", spi_info,
 					     LJCA_SPI1_ACPI_ADR + i);
-		if (ret) {
+		if (ret)
-			kfree(spi_info);
 			return ret;
-		}
 	}
 	return 0;

drivers/usb/phy/phy-generic.c+0−7

@@ -262,13 +262,6 @@ int usb_phy_gen_create_phy(struct device dev, struct usb_phy_generic nop) · 261 unmodified lines
262	return dev_err_probe(dev, PTR_ERR(nop->vbus_draw),	262	return dev_err_probe(dev, PTR_ERR(nop->vbus_draw),
263	"could not get vbus regulator\n");	263	"could not get vbus regulator\n");
264		264
265	nop->vbus_draw = devm_regulator_get_exclusive(dev, "vbus");
266	if (PTR_ERR(nop->vbus_draw) == -ENODEV)
267	nop->vbus_draw = NULL;
268	if (IS_ERR(nop->vbus_draw))
269	return dev_err_probe(dev, PTR_ERR(nop->vbus_draw),
270	"could not get vbus regulator\n");
271
272	nop->dev = dev;	265	nop->dev = dev;
273	nop->phy.dev = nop->dev;	266	nop->phy.dev = nop->dev;
274	nop->phy.label = "nop-xceiv";	267	nop->phy.label = "nop-xceiv";

drivers/usb/storage/uas.c+13−15

  * daft to me.
  */
-static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
+static int uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
 {
 	struct uas_dev_info *devinfo = cmnd->device->hostdata;
 	struct urb *urb;
 	urb = uas_alloc_sense_urb(devinfo, gfp, cmnd);
 	if (!urb)
-		return NULL;
+		return -ENOMEM;
 	usb_anchor_urb(urb, &devinfo->sense_urbs);
 	err = usb_submit_urb(urb, gfp);
 	if (err) {
 		usb_unanchor_urb(urb);
 		uas_log_cmd_state(cmnd, "sense submit err", err);
 		usb_free_urb(urb);
-		return NULL;
 	}
-	return urb;
+	return err;
 }
 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 			   struct uas_dev_info *devinfo)
 {
 	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
-	struct urb *urb;
 	int err;
 	lockdep_assert_held(&devinfo->lock);
 	if (cmdinfo->state & SUBMIT_STATUS_URB) {
-		urb = uas_submit_sense_urb(cmnd, GFP_ATOMIC);
+		err = uas_submit_sense_urb(cmnd, GFP_ATOMIC);
-		if (!urb)
+		if (err)
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return err;
 		cmdinfo->state &= ~SUBMIT_STATUS_URB;
 	}
 		cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
 							cmnd, DMA_FROM_DEVICE);
 		if (!cmdinfo->data_in_urb)
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return -ENOMEM;
 		cmdinfo->state &= ~ALLOC_DATA_IN_URB;
 	}
 		if (err) {
 			usb_unanchor_urb(cmdinfo->data_in_urb);
 			uas_log_cmd_state(cmnd, "data in submit err", err);
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return err;
 		}
 		cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
 		cmdinfo->state |= DATA_IN_URB_INFLIGHT;
 		cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
 							cmnd, DMA_TO_DEVICE);
 		if (!cmdinfo->data_out_urb)
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return -ENOMEM;
 		cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
 	}
 		if (err) {
 			usb_unanchor_urb(cmdinfo->data_out_urb);
 			uas_log_cmd_state(cmnd, "data out submit err", err);
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return err;
 		}
 		cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
 		cmdinfo->state |= DATA_OUT_URB_INFLIGHT;
 	if (cmdinfo->state & ALLOC_CMD_URB) {
 		cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, GFP_ATOMIC, cmnd);
 		if (!cmdinfo->cmd_urb)
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return -ENOMEM;
 		cmdinfo->state &= ~ALLOC_CMD_URB;
 	}
 		if (err) {
 			usb_unanchor_urb(cmdinfo->cmd_urb);
 			uas_log_cmd_state(cmnd, "cmd submit err", err);
-			return SCSI_MLQUEUE_DEVICE_BUSY;
+			return err;
 		}
 		cmdinfo->cmd_urb = NULL;
 		cmdinfo->state &= ~SUBMIT_CMD_URB;
 	 * of queueing, no matter how fatal the error
 	 */
 	if (err == -ENODEV) {
-		set_host_byte(cmnd, DID_ERROR);
+		set_host_byte(cmnd, DID_NO_CONNECT);
 		scsi_done(cmnd);
 		goto zombie;
 	}

drivers/usb/typec/class.c+6−1

 {
 	struct typec_port *port = to_typec_port(dev);
 	struct usb_power_delivery *pd;
+	int ret;
 	if (!port->ops || !port->ops->pd_set)
 		return -EOPNOTSUPP;
 	if (!pd)
 		return -EINVAL;
-	return port->ops->pd_set(port, pd);
+	ret = port->ops->pd_set(port, pd);
+	if (ret)
+		return ret;
+	return size;
 }
 static ssize_t select_usb_power_delivery_show(struct device *dev,

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

 	if (data->source_desc.pdo[0]) {
 		for (i = 0; i < PDO_MAX_OBJECTS && data->source_desc.pdo[i]; i++)
-			port->snk_pdo[i] = data->source_desc.pdo[i];
+			port->src_pdo[i] = data->source_desc.pdo[i];
 		port->nr_src_pdo = i + 1;
 	}
 	port->port_source_caps = data->source_cap;
 	port->port_sink_caps = data->sink_cap;
+	typec_port_set_usb_power_delivery(p, NULL);
 	port->selected_pd = pd;
+	typec_port_set_usb_power_delivery(p, port->selected_pd);
 unlock:
 	mutex_unlock(&port->lock);
 	return ret;
 	port->port_source_caps = NULL;
 	for (i = 0; i < port->pd_count; i++) {
 		usb_power_delivery_unregister_capabilities(port->pd_list[i]->sink_cap);
-		kfree(port->pd_list[i]->sink_cap);
 		usb_power_delivery_unregister_capabilities(port->pd_list[i]->source_cap);
-		kfree(port->pd_list[i]->source_cap);
 		devm_kfree(port->dev, port->pd_list[i]);
 		port->pd_list[i] = NULL;
 		usb_power_delivery_unregister(port->pds[i]);

drivers/usb/typec/ucsi/ucsi.c+72−18

 	if (!(cci & UCSI_CCI_COMMAND_COMPLETE))
 		return -EIO;
-	if (cci & UCSI_CCI_NOT_SUPPORTED)
+	if (cci & UCSI_CCI_NOT_SUPPORTED) {
+		if (ucsi_acknowledge_command(ucsi) < 0)
+			dev_err(ucsi->dev,
+				"ACK of unsupported command failed\n");
 		return -EOPNOTSUPP;
+	}
 	if (cci & UCSI_CCI_ERROR) {
 		if (cmd == UCSI_GET_ERROR_STATUS)
 	if (ret < 0)
 		return ret;
-	ret = ucsi_get_cable_identity(con);
+	if (con->ucsi->cap.features & UCSI_CAP_GET_PD_MESSAGE) {
-	if (ret < 0)
+		ret = ucsi_get_cable_identity(con);
-		return ret;
+		if (ret < 0)
+			return ret;
+	}
-	ret = ucsi_register_plug(con);
+	if (con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS) {
-	if (ret < 0)
+		ret = ucsi_register_plug(con);
-		return ret;
+		if (ret < 0)
+			return ret;
-	ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP_P);
+		ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP_P);
-	if (ret < 0)
+		if (ret < 0)
-		return ret;
+			return ret;
+	}
 	return 0;
 }
 			ucsi_register_partner(con);
 			ucsi_partner_task(con, ucsi_check_connection, 1, HZ);
 			ucsi_partner_task(con, ucsi_check_connector_capability, 1, HZ);
-			ucsi_partner_task(con, ucsi_get_partner_identity, 1, HZ);
+			if (con->ucsi->cap.features & UCSI_CAP_GET_PD_MESSAGE)
-			ucsi_partner_task(con, ucsi_check_cable, 1, HZ);
+				ucsi_partner_task(con, ucsi_get_partner_identity, 1, HZ);
+			if (con->ucsi->cap.features & UCSI_CAP_CABLE_DETAILS)
+				ucsi_partner_task(con, ucsi_check_cable, 1, HZ);
 			if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) ==
 			    UCSI_CONSTAT_PWR_OPMODE_PD)
 	if (con->status.change & UCSI_CONSTAT_CAM_CHANGE)
 		ucsi_partner_task(con, ucsi_check_altmodes, 1, 0);
-	clear_bit(EVENT_PENDING, &con->ucsi->flags);
 	mutex_lock(&ucsi->ppm_lock);
+	clear_bit(EVENT_PENDING, &con->ucsi->flags);
 	ret = ucsi_acknowledge_connector_change(ucsi);
 	mutex_unlock(&ucsi->ppm_lock);
 	if (ret)
 		dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
 	struct ucsi_connector *con = &ucsi->connector[num - 1];
 	if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) {
-		dev_dbg(ucsi->dev, "Bogus connector change event\n");
+		dev_dbg(ucsi->dev, "Early connector change event\n");
 		return;
 	}
 static int ucsi_reset_ppm(struct ucsi *ucsi)
 {
-	u64 command = UCSI_PPM_RESET;
+	u64 command;
 	unsigned long tmo;
 	u32 cci;
 	int ret;
 	mutex_lock(&ucsi->ppm_lock);
+	ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
+	if (ret < 0)
+		goto out;
+	/*
+	 * If UCSI_CCI_RESET_COMPLETE is already set we must clear
+	 * the flag before we start another reset. Send a
+	 * UCSI_SET_NOTIFICATION_ENABLE command to achieve this.
+	 * Ignore a timeout and try the reset anyway if this fails.
+	 */
+	if (cci & UCSI_CCI_RESET_COMPLETE) {
+		command = UCSI_SET_NOTIFICATION_ENABLE;
+		ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
+					     sizeof(command));
+		if (ret < 0)
+			goto out;
+		tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
+		do {
+			ret = ucsi->ops->read(ucsi, UCSI_CCI,
+					      &cci, sizeof(cci));
+			if (ret < 0)
+				goto out;
+			if (cci & UCSI_CCI_COMMAND_COMPLETE)
+				break;
+			if (time_is_before_jiffies(tmo))
+				break;
+			msleep(20);
+		} while (1);
+		WARN_ON(cci & UCSI_CCI_RESET_COMPLETE);
+	}
+	command = UCSI_PPM_RESET;
 	ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
 				     sizeof(command));
 	if (ret < 0)
 		ucsi_register_partner(con);
 		ucsi_pwr_opmode_change(con);
 		ucsi_port_psy_changed(con);
-		ucsi_get_partner_identity(con);
+		if (con->ucsi->cap.features & UCSI_CAP_GET_PD_MESSAGE)
-		ucsi_check_cable(con);
+			ucsi_get_partner_identity(con);
+		if (con->ucsi->cap.features & UCSI_CAP_CABLE_DETAILS)
+			ucsi_check_cable(con);
 	}
 	/* Only notify USB controller if partner supports USB data */
 {
 	struct ucsi_connector *con, *connector;
 	u64 command, ntfy;
+	u32 cci;
 	int ret;
 	int i;
 	ucsi->connector = connector;
 	ucsi->ntfy = ntfy;
+	ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
+	if (ret)
+		return ret;
+	if (UCSI_CCI_CONNECTOR(READ_ONCE(cci)))
+		ucsi_connector_change(ucsi, cci);
 	return 0;
 err_unregister:

drivers/usb/typec/ucsi/ucsi.h+3−2

 #define UCSI_CAP_ATTR_POWER_OTHER		BIT(10)
 #define UCSI_CAP_ATTR_POWER_VBUS		BIT(14)
 	u8 num_connectors;
-	u8 features;
+	u16 features;
 #define UCSI_CAP_SET_UOM			BIT(0)
 #define UCSI_CAP_SET_PDM			BIT(1)
 #define UCSI_CAP_ALT_MODE_DETAILS		BIT(2)
 #define UCSI_CAP_CABLE_DETAILS			BIT(5)
 #define UCSI_CAP_EXT_SUPPLY_NOTIFICATIONS	BIT(6)
 #define UCSI_CAP_PD_RESET			BIT(7)
-	u16 reserved_1;
+#define UCSI_CAP_GET_PD_MESSAGE		BIT(8)
+	u8 reserved_1;
 	u8 num_alt_modes;
 	u8 reserved_2;
 	u16 bc_version;

drivers/usb/typec/ucsi/ucsi_acpi.c+33−42

@@ -23,10 +23,11 @@ struct ucsi_acpi { · 22 unmodified lines
23	void *base;	23	void *base;
24	struct completion complete;	24	struct completion complete;
25	unsigned long flags;	25	unsigned long flags;
		26	#define UCSI_ACPI_SUPPRESS_EVENT 0
		27	#define UCSI_ACPI_COMMAND_PENDING 1
		28	#define UCSI_ACPI_ACK_PENDING 2
26	guid_t guid;	29	guid_t guid;
27	u64 cmd;	30	u64 cmd;
28	bool dell_quirk_probed;
29	bool dell_quirk_active;
30	};	31	};
31		32
32	static int ucsi_acpi_dsm(struct ucsi_acpi *ua, int func)	33	static int ucsi_acpi_dsm(struct ucsi_acpi *ua, int func)
@@ -79,9 +80,9 @@ static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset, · 46 unmodified lines
79	int ret;	80	int ret;
80		81
81	if (ack)	82	if (ack)
82	set_bit(ACK_PENDING, &ua->flags);	83	set_bit(UCSI_ACPI_ACK_PENDING, &ua->flags);
83	else	84	else
84	set_bit(COMMAND_PENDING, &ua->flags);	85	set_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags);
85		86
86	ret = ucsi_acpi_async_write(ucsi, offset, val, val_len);	87	ret = ucsi_acpi_async_write(ucsi, offset, val, val_len);
87	if (ret)	88	if (ret)
@@ -92,9 +93,9 @@ static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset, · 4 unmodified lines
92		93
93	out_clear_bit:	94	out_clear_bit:
94	if (ack)	95	if (ack)
95	clear_bit(ACK_PENDING, &ua->flags);	96	clear_bit(UCSI_ACPI_ACK_PENDING, &ua->flags);
96	else	97	else
97	clear_bit(COMMAND_PENDING, &ua->flags);	98	clear_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags);
98		99
99	return ret;	100	return ret;
100	}	101	}
@@ -129,51 +130,40 @@ static const struct ucsi_operations ucsi_zenbook_ops = { · 28 unmodified lines
129	};	130	};
130		131
131	/*	132	/*
132	* Some Dell laptops expect that an ACK command with the	133	* Some Dell laptops don't like ACK commands with the
133	* UCSI_ACK_CONNECTOR_CHANGE bit set is followed by a (separate)	134	* UCSI_ACK_CONNECTOR_CHANGE but not the UCSI_ACK_COMMAND_COMPLETE
134	* ACK command that only has the UCSI_ACK_COMMAND_COMPLETE bit set.	135	* bit set. To work around this send a dummy command and bundle the
135	* If this is not done events are not delivered to OSPM and	136	* UCSI_ACK_CONNECTOR_CHANGE with the UCSI_ACK_COMMAND_COMPLETE
136	* subsequent commands will timeout.	137	* for the dummy command.
137	*/	138	*/
138	static int	139	static int
139	ucsi_dell_sync_write(struct ucsi *ucsi, unsigned int offset,	140	ucsi_dell_sync_write(struct ucsi *ucsi, unsigned int offset,
140	const void *val, size_t val_len)	141	const void *val, size_t val_len)
141	{	142	{
142	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);	143	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
143	u64 cmd = (u64 )val, ack = 0;	144	u64 cmd = (u64 )val;
		145	u64 dummycmd = UCSI_GET_CAPABILITY;
144	int ret;	146	int ret;
145		147
146	if (UCSI_COMMAND(cmd) == UCSI_ACK_CC_CI &&	148	if (cmd == (UCSI_ACK_CC_CI \| UCSI_ACK_CONNECTOR_CHANGE)) {
147	cmd & UCSI_ACK_CONNECTOR_CHANGE)	149	cmd \|= UCSI_ACK_COMMAND_COMPLETE;
148	ack = UCSI_ACK_CC_CI \| UCSI_ACK_COMMAND_COMPLETE;	150
149		151	/*
150	ret = ucsi_acpi_sync_write(ucsi, offset, val, val_len);	152	* The UCSI core thinks it is sending a connector change ack
151	if (ret != 0)	153	* and will accept new connector change events. We don't want
152	return ret;	154	* this to happen for the dummy command as its response will
153	if (ack == 0)	155	* still report the very event that the core is trying to clear.
154	return ret;	156	*/
155		157	set_bit(UCSI_ACPI_SUPPRESS_EVENT, &ua->flags);
156	if (!ua->dell_quirk_probed) {	158	ret = ucsi_acpi_sync_write(ucsi, UCSI_CONTROL, &dummycmd,
157	ua->dell_quirk_probed = true;	159	sizeof(dummycmd));
158		160	clear_bit(UCSI_ACPI_SUPPRESS_EVENT, &ua->flags);
159	cmd = UCSI_GET_CAPABILITY;	161
160	ret = ucsi_acpi_sync_write(ucsi, UCSI_CONTROL, &cmd,	162	if (ret < 0)
161	sizeof(cmd));
162	if (ret == 0)
163	return ucsi_acpi_sync_write(ucsi, UCSI_CONTROL,
164	&ack, sizeof(ack));
165	if (ret != -ETIMEDOUT)
166	return ret;	163	return ret;
167
168	ua->dell_quirk_active = true;
169	dev_err(ua->dev, "Firmware bug: Additional ACK required after ACKing a connector change.\n");
170	dev_err(ua->dev, "Firmware bug: Enabling workaround\n");
171	}	164	}
172		165
173	if (!ua->dell_quirk_active)	166	return ucsi_acpi_sync_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
174	return ret;
175
176	return ucsi_acpi_sync_write(ucsi, UCSI_CONTROL, &ack, sizeof(ack));
177	}	167	}
178		168
179	static const struct ucsi_operations ucsi_dell_ops = {	169	static const struct ucsi_operations ucsi_dell_ops = {
@@ -209,13 +199,14 @@ static void ucsi_acpi_notify(acpi_handle handle, u32 event, void *data) · 29 unmodified lines
209	if (ret)	199	if (ret)
210	return;	200	return;
211		201
212	if (UCSI_CCI_CONNECTOR(cci))	202	if (UCSI_CCI_CONNECTOR(cci) &&
		203	!test_bit(UCSI_ACPI_SUPPRESS_EVENT, &ua->flags))
213	ucsi_connector_change(ua->ucsi, UCSI_CCI_CONNECTOR(cci));	204	ucsi_connector_change(ua->ucsi, UCSI_CCI_CONNECTOR(cci));
214		205
215	if (cci & UCSI_CCI_ACK_COMPLETE && test_bit(ACK_PENDING, &ua->flags))	206	if (cci & UCSI_CCI_ACK_COMPLETE && test_bit(ACK_PENDING, &ua->flags))
216	complete(&ua->complete);	207	complete(&ua->complete);
217	if (cci & UCSI_CCI_COMMAND_COMPLETE &&	208	if (cci & UCSI_CCI_COMMAND_COMPLETE &&
218	test_bit(COMMAND_PENDING, &ua->flags))	209	test_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags))
219	complete(&ua->complete);	210	complete(&ua->complete);
220	}	211	}
221		212

drivers/usb/typec/ucsi/ucsi_glink.c+14−0

@@ -255,6 +255,20 @@ static void pmic_glink_ucsi_notify(struct work_struct *work) · 254 unmodified lines
255	static void pmic_glink_ucsi_register(struct work_struct *work)	255	static void pmic_glink_ucsi_register(struct work_struct *work)
256	{	256	{
257	struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);	257	struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);
		258	int orientation;
		259	int i;
		260
		261	for (i = 0; i < PMIC_GLINK_MAX_PORTS; i++) {
		262	if (!ucsi->port_orientation[i])
		263	continue;
		264	orientation = gpiod_get_value(ucsi->port_orientation[i]);
		265
		266	if (orientation >= 0) {
		267	typec_switch_set(ucsi->port_switch[i],
		268	orientation ? TYPEC_ORIENTATION_REVERSE
		269	: TYPEC_ORIENTATION_NORMAL);
		270	}
		271	}
258		272
259	ucsi_register(ucsi->ucsi);	273	ucsi_register(ucsi->ucsi);
260	}	274	}

drivers/video/fbdev/Kconfig+3−0

 	select FB_CFB_COPYAREA
 	select FB_CFB_FILLRECT
 	select FB_CFB_IMAGEBLIT
+	select FB_IOMEM_FOPS
 config FB_BW2
 	bool "BWtwo support"
 	depends on (FB = y) && (SPARC && FB_SBUS)
 	select FB_CFB_COPYAREA
 	select FB_CFB_IMAGEBLIT
+	select FB_IOMEM_FOPS
 	help
 	  This is the frame buffer device driver for the CGsix (GX, TurboGX)
 	  frame buffer.
 	depends on FB_SBUS && SPARC64
 	select FB_CFB_COPYAREA
 	select FB_CFB_IMAGEBLIT
+	select FB_IOMEM_FOPS
 	help
 	  This is the frame buffer device driver for the Creator, Creator3D,
 	  and Elite3D graphics boards.

fs/9p/vfs_inode.c+10−6

 	struct v9fs_inode __maybe_unused *v9inode = V9FS_I(inode);
 	__le32 __maybe_unused version;
-	truncate_inode_pages_final(&inode->i_data);
+	if (!is_bad_inode(inode)) {
+		truncate_inode_pages_final(&inode->i_data);
-	version = cpu_to_le32(v9inode->qid.version);
+		version = cpu_to_le32(v9inode->qid.version);
-	netfs_clear_inode_writeback(inode, &version);
+		netfs_clear_inode_writeback(inode, &version);
-	clear_inode(inode);
+		clear_inode(inode);
-	filemap_fdatawrite(&inode->i_data);
+		filemap_fdatawrite(&inode->i_data);
 #ifdef CONFIG_9P_FSCACHE
-	fscache_relinquish_cookie(v9fs_inode_cookie(v9inode), false);
+		if (v9fs_inode_cookie(v9inode))
+			fscache_relinquish_cookie(v9fs_inode_cookie(v9inode), false);
 #endif
+	} else
+		clear_inode(inode);
 }
 struct inode *v9fs_fid_iget(struct super_block *sb, struct p9_fid *fid)

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

 	retval = v9fs_init_inode(v9ses, inode, &fid->qid,
 				 st->st_mode, new_decode_dev(st->st_rdev));
+	v9fs_stat2inode_dotl(st, inode, 0);
 	kfree(st);
 	if (retval)
 		goto error;
-	v9fs_stat2inode_dotl(st, inode, 0);
 	v9fs_set_netfs_context(inode);
 	v9fs_cache_inode_get_cookie(inode);
 	retval = v9fs_get_acl(inode, fid);
 			       umode_t omode)
 {
 	int err;
-	struct v9fs_session_info *v9ses;
 	struct p9_fid *fid = NULL, *dfid = NULL;
 	kgid_t gid;
 	const unsigned char *name;
 	struct posix_acl *dacl = NULL, *pacl = NULL;
 	p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
-	v9ses = v9fs_inode2v9ses(dir);
 	omode |= S_IFDIR;
 	if (dir->i_mode & S_ISGID)
 	kgid_t gid;
 	const unsigned char *name;
 	umode_t mode;
-	struct v9fs_session_info *v9ses;
 	struct p9_fid *fid = NULL, *dfid = NULL;
 	struct inode *inode;
 	struct p9_qid qid;
 		 dir->i_ino, dentry, omode,
 		 MAJOR(rdev), MINOR(rdev));
-	v9ses = v9fs_inode2v9ses(dir);
 	dfid = v9fs_parent_fid(dentry);
 	if (IS_ERR(dfid)) {
 		err = PTR_ERR(dfid);

fs/binfmt_elf_fdpic.c+1−1

@@ -1359,7 +1359,7 @@ static int fill_psinfo(struct elf_prpsinfo psinfo, struct task_struct p, · 1358 unmodified lines
1359	SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));	1359	SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1360	SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));	1360	SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1361	rcu_read_unlock();	1361	rcu_read_unlock();
1362	strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));	1362	get_task_comm(psinfo->pr_fname, p);
1363		1363
1364	return 0;	1364	return 0;
1365	}	1365	}

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

 		 * needing to allocate extents from the block group.
 		 */
 		used = btrfs_space_info_used(space_info, true);
-		if (space_info->total_bytes - block_group->length < used) {
+		if (space_info->total_bytes - block_group->length < used &&
+		    block_group->zone_unusable < block_group->length) {
 			/*
 			 * Add a reference for the list, compensate for the ref
 			 * drop under the "next" label for the

fs/btrfs/extent_io.c+13−0

@@ -4333,6 +4333,19 @@ int read_extent_buffer_pages(struct extent_buffer *eb, int wait, int mirror_num, · 4332 unmodified lines
4333	if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))	4333	if (test_and_set_bit(EXTENT_BUFFER_READING, &eb->bflags))
4334	goto done;	4334	goto done;
4335		4335
		4336	/*
		4337	* Between the initial test_bit(EXTENT_BUFFER_UPTODATE) and the above
		4338	* test_and_set_bit(EXTENT_BUFFER_READING), someone else could have
		4339	* started and finished reading the same eb. In this case, UPTODATE
		4340	* will now be set, and we shouldn't read it in again.
		4341	*/
		4342	if (unlikely(test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))) {
		4343	clear_bit(EXTENT_BUFFER_READING, &eb->bflags);
		4344	smp_mb__after_atomic();
		4345	wake_up_bit(&eb->bflags, EXTENT_BUFFER_READING);
		4346	return 0;
		4347	}
		4348
4336	clear_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);	4349	clear_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
4337	eb->read_mirror = 0;	4350	eb->read_mirror = 0;
4338	check_buffer_tree_ref(eb);	4351	check_buffer_tree_ref(eb);

fs/btrfs/extent_map.c+8−8

 		btrfs_warn(fs_info,
 "no extent map found for inode %llu (root %lld) when unpinning extent range [%llu, %llu), generation %llu",
 			   btrfs_ino(inode), btrfs_root_id(inode->root),
-			   start, len, gen);
+			   start, start + len, gen);
 		ret = -ENOENT;
 		goto out;
 	}
 		btrfs_warn(fs_info,
 "found extent map for inode %llu (root %lld) with unexpected start offset %llu when unpinning extent range [%llu, %llu), generation %llu",
 			   btrfs_ino(inode), btrfs_root_id(inode->root),
-			   em->start, start, len, gen);
+			   em->start, start, start + len, gen);
 		ret = -EUCLEAN;
 		goto out;
 	}
 		em->mod_len = em->len;
 	}
-	free_extent_map(em);
 out:
 	write_unlock(&tree->lock);
+	free_extent_map(em);
 	return ret;
 }
 			 */
 			ret = merge_extent_mapping(em_tree, existing,
 						   em, start);
-			if (ret) {
+			if (WARN_ON(ret)) {
 				free_extent_map(em);
 				*em_in = NULL;
-				WARN_ONCE(ret,
+				btrfs_warn(fs_info,
-"extent map merge error existing [%llu, %llu) with em [%llu, %llu) start %llu\n",
+"extent map merge error existing [%llu, %llu) with em [%llu, %llu) start %llu",
-					  existing->start, existing->len,
+					   existing->start, extent_map_end(existing),
-					  orig_start, orig_len, start);
+					   orig_start, orig_start + orig_len, start);
 			}
 			free_extent_map(existing);
 		}

fs/btrfs/scrub.c+11−1

@@ -2812,7 +2812,17 @@ static noinline_for_stack int scrub_supers(struct scrub_ctx *sctx, · 2811 unmodified lines
2812	gen = btrfs_get_last_trans_committed(fs_info);	2812	gen = btrfs_get_last_trans_committed(fs_info);
2813		2813
2814	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {	2814	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
2815	bytenr = btrfs_sb_offset(i);	2815	ret = btrfs_sb_log_location(scrub_dev, i, 0, &bytenr);
		2816	if (ret == -ENOENT)
		2817	break;
		2818
		2819	if (ret) {
		2820	spin_lock(&sctx->stat_lock);
		2821	sctx->stat.super_errors++;
		2822	spin_unlock(&sctx->stat_lock);
		2823	continue;
		2824	}
		2825
2816	if (bytenr + BTRFS_SUPER_INFO_SIZE >	2826	if (bytenr + BTRFS_SUPER_INFO_SIZE >
2817	scrub_dev->commit_total_bytes)	2827	scrub_dev->commit_total_bytes)
2818	break;	2828	break;

fs/btrfs/volumes.c+22−5

@@ -692,6 +692,16 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices, · 691 unmodified lines
692	device->bdev = file_bdev(bdev_file);	692	device->bdev = file_bdev(bdev_file);
693	clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);	693	clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
694		694
		695	if (device->devt != device->bdev->bd_dev) {
		696	btrfs_warn(NULL,
		697	"device %s maj:min changed from %d:%d to %d:%d",
		698	device->name->str, MAJOR(device->devt),
		699	MINOR(device->devt), MAJOR(device->bdev->bd_dev),
		700	MINOR(device->bdev->bd_dev));
		701
		702	device->devt = device->bdev->bd_dev;
		703	}
		704
695	fs_devices->open_devices++;	705	fs_devices->open_devices++;
696	if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) &&	706	if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) &&
697	device->devid != BTRFS_DEV_REPLACE_DEVID) {	707	device->devid != BTRFS_DEV_REPLACE_DEVID) {
@@ -1174,23 +1184,30 @@ static int open_fs_devices(struct btrfs_fs_devices *fs_devices, · 476 unmodified lines
1174	struct btrfs_device *device;	1184	struct btrfs_device *device;
1175	struct btrfs_device *latest_dev = NULL;	1185	struct btrfs_device *latest_dev = NULL;
1176	struct btrfs_device *tmp_device;	1186	struct btrfs_device *tmp_device;
		1187	int ret = 0;
1177		1188
1178	list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,	1189	list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,
1179	dev_list) {	1190	dev_list) {
1180	int ret;	1191	int ret2;
1181		1192
1182	ret = btrfs_open_one_device(fs_devices, device, flags, holder);	1193	ret2 = btrfs_open_one_device(fs_devices, device, flags, holder);
1183	if (ret == 0 &&	1194	if (ret2 == 0 &&
1184	(!latest_dev \|\| device->generation > latest_dev->generation)) {	1195	(!latest_dev \|\| device->generation > latest_dev->generation)) {
1185	latest_dev = device;	1196	latest_dev = device;
1186	} else if (ret == -ENODATA) {	1197	} else if (ret2 == -ENODATA) {
1187	fs_devices->num_devices--;	1198	fs_devices->num_devices--;
1188	list_del(&device->dev_list);	1199	list_del(&device->dev_list);
1189	btrfs_free_device(device);	1200	btrfs_free_device(device);
1190	}	1201	}
		1202	if (ret == 0 && ret2 != 0)
		1203	ret = ret2;
1191	}	1204	}
1192	if (fs_devices->open_devices == 0)	1205
		1206	if (fs_devices->open_devices == 0) {
		1207	if (ret)
		1208	return ret;
1193	return -EINVAL;	1209	return -EINVAL;
		1210	}
1194		1211
1195	fs_devices->opened = 1;	1212	fs_devices->opened = 1;
1196	fs_devices->latest_dev = latest_dev;	1213	fs_devices->latest_dev = latest_dev;

fs/btrfs/zoned.c+7−7

 	if (!map)
 		return -EINVAL;
-	cache->physical_map = btrfs_clone_chunk_map(map, GFP_NOFS);
+	cache->physical_map = map;
-	if (!cache->physical_map) {
-		ret = -ENOMEM;
-		goto out;
-	}
 	zone_info = kcalloc(map->num_stripes, sizeof(*zone_info), GFP_NOFS);
 	if (!zone_info) {
 	}
 	bitmap_free(active);
 	kfree(zone_info);
-	btrfs_free_chunk_map(map);
 	return ret;
 }
 	struct btrfs_chunk_map *map;
 	const bool is_metadata = (block_group->flags &
 			(BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM));
+	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
 	int ret = 0;
 	int i;
 	btrfs_clear_data_reloc_bg(block_group);
 	spin_unlock(&block_group->lock);
+	down_read(&dev_replace->rwsem);
 	map = block_group->physical_map;
 	for (i = 0; i < map->num_stripes; i++) {
 		struct btrfs_device *device = map->stripes[i].dev;
 				       zinfo->zone_size >> SECTOR_SHIFT);
 		memalloc_nofs_restore(nofs_flags);
-		if (ret)
+		if (ret) {
+			up_read(&dev_replace->rwsem);
 			return ret;
+		}
 		if (!(block_group->flags & BTRFS_BLOCK_GROUP_DATA))
 			zinfo->reserved_active_zones++;
 		btrfs_dev_clear_active_zone(device, physical);
 	}
+	up_read(&dev_replace->rwsem);
 	if (!fully_written)
 		btrfs_dec_block_group_ro(block_group);

fs/erofs/super.c+0−1

@@ -430,7 +430,6 @@ static bool erofs_fc_set_dax_mode(struct fs_context *fc, unsigned int mode) · 429 unmodified lines
430		430
431	switch (mode) {	431	switch (mode) {
432	case EROFS_MOUNT_DAX_ALWAYS:	432	case EROFS_MOUNT_DAX_ALWAYS:
433	warnfc(fc, "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
434	set_opt(&ctx->opt, DAX_ALWAYS);	433	set_opt(&ctx->opt, DAX_ALWAYS);
435	clear_opt(&ctx->opt, DAX_NEVER);	434	clear_opt(&ctx->opt, DAX_NEVER);
436	return true;	435	return true;

fs/exec.c+1−0

@@ -895,6 +895,7 @@ int transfer_args_to_stack(struct linux_binprm *bprm, · 894 unmodified lines
895	goto out;	895	goto out;
896	}	896	}
897		897
		898	bprm->exec += sp_location - MAX_ARG_PAGES PAGE_SIZE;
898	*sp_location = sp;	899	*sp_location = sp;
899		900
900	out:	901	out:

fs/gfs2/bmap.c+3−2

 	struct buffer_head *dibh, *bh;
 	struct gfs2_holder rd_gh;
 	unsigned int bsize_shift = sdp->sd_sb.sb_bsize_shift;
-	u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
+	unsigned int bsize = 1 << bsize_shift;
+	u64 lblock = (offset + bsize - 1) >> bsize_shift;
 	__u16 start_list[GFS2_MAX_META_HEIGHT];
 	__u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
 	unsigned int start_aligned, end_aligned;
 	u64 prev_bnr = 0;
 	__be64 *start, *end;
-	if (offset >= maxsize) {
+	if (offset + bsize - 1 >= maxsize) {
 		/*
 		 * The starting point lies beyond the allocated metadata;
 		 * there are no blocks to deallocate.

fs/nfsd/nfs4state.c+25−11

 	else
 		cs_slot = &unconf->cl_cs_slot;
 	status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
-	if (status) {
+	switch (status) {
-		if (status == nfserr_replay_cache) {
+	case nfs_ok:
-			status = nfsd4_replay_create_session(cr_ses, cs_slot);
+		cs_slot->sl_seqid++;
-			goto out_free_conn;
+		cr_ses->seqid = cs_slot->sl_seqid;
-		}
+		break;
+	case nfserr_replay_cache:
+		status = nfsd4_replay_create_session(cr_ses, cs_slot);
+		fallthrough;
+	case nfserr_jukebox:
+		/* The server MUST NOT cache NFS4ERR_DELAY */
+		goto out_free_conn;
+	default:
 		goto out_cache_error;
 	}
-	cs_slot->sl_seqid++;
-	cr_ses->seqid = cs_slot->sl_seqid;
 	/* RFC 8881 Section 18.36.4 Phase 3: Client ID confirmation. */
 	if (conf) {
 		old = find_confirmed_client_by_name(&unconf->cl_name, nn);
 		if (old) {
 			status = mark_client_expired_locked(old);
-			if (status) {
+			if (status)
-				old = NULL;
+				goto out_expired_error;
-				goto out_cache_error;
-			}
 			trace_nfsd_clid_replaced(&old->cl_clientid);
 		}
 		move_to_confirmed(unconf);
 		expire_client(old);
 	return status;
+out_expired_error:
+	old = NULL;
+	/*
+	 * Revert the slot seq_nr change so the server will process
+	 * the client's resend instead of returning a cached response.
+	 */
+	if (status == nfserr_jukebox) {
+		cs_slot->sl_seqid--;
+		cr_ses->seqid = cs_slot->sl_seqid;
+		goto out_free_conn;
+	}
 out_cache_error:
 	nfsd4_cache_create_session(cr_ses, cs_slot, status);
 out_free_conn:

fs/nfsd/vfs.c+2−1

 	trap = lock_rename(tdentry, fdentry);
 	if (IS_ERR(trap)) {
 		err = (rqstp->rq_vers == 2) ? nfserr_acces : nfserr_xdev;
-		goto out;
+		goto out_want_write;
 	}
 	err = fh_fill_pre_attrs(ffhp);
 	if (err != nfs_ok)
 	}
 out_unlock:
 	unlock_rename(tdentry, fdentry);
+out_want_write:
 	fh_drop_write(ffhp);
 	/*

fs/proc/Makefile+1−1

@@ -5,7 +5,7 @@ · 4 unmodified lines
5		5
6	obj-y += proc.o	6	obj-y += proc.o
7		7
8	CFLAGS_task_mmu.o += $(call cc-option,-Wno-override-init,)	8	CFLAGS_task_mmu.o += -Wno-override-init
9	proc-y := nommu.o task_nommu.o	9	proc-y := nommu.o task_nommu.o
10	proc-$(CONFIG_MMU) := task_mmu.o	10	proc-$(CONFIG_MMU) := task_mmu.o
11		11

fs/smb/client/dir.c+7−0

 		goto mknod_out;
 	}
+	trace_smb3_mknod_enter(xid, tcon->ses->Suid, tcon->tid, full_path);
 	rc = tcon->ses->server->ops->make_node(xid, inode, direntry, tcon,
 					       full_path, mode,
 					       device_number);
 mknod_out:
+	if (rc)
+		trace_smb3_mknod_err(xid,  tcon->ses->Suid, tcon->tid, rc);
+	else
+		trace_smb3_mknod_done(xid, tcon->ses->Suid, tcon->tid);
 	free_dentry_path(page);
 	free_xid(xid);
 	cifs_put_tlink(tlink);

fs/smb/client/fscache.c+15−1

 #include "cifs_fs_sb.h"
 #include "cifsproto.h"
+/*
+ * Key for fscache inode.  [!] Contents must match comparisons in cifs_find_inode().
+ */
+struct cifs_fscache_inode_key {
+	__le64  uniqueid;	/* server inode number */
+	__le64  createtime;	/* creation time on server */
+	u8	type;		/* S_IFMT file type */
+} __packed;
 static void cifs_fscache_fill_volume_coherency(
 	struct cifs_tcon *tcon,
 	struct cifs_fscache_volume_coherency_data *cd)
 void cifs_fscache_get_inode_cookie(struct inode *inode)
 {
 	struct cifs_fscache_inode_coherency_data cd;
+	struct cifs_fscache_inode_key key;
 	struct cifsInodeInfo *cifsi = CIFS_I(inode);
 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
+	key.uniqueid	= cpu_to_le64(cifsi->uniqueid);
+	key.createtime	= cpu_to_le64(cifsi->createtime);
+	key.type	= (inode->i_mode & S_IFMT) >> 12;
 	cifs_fscache_fill_coherency(&cifsi->netfs.inode, &cd);
 	cifsi->netfs.cache =
 		fscache_acquire_cookie(tcon->fscache, 0,
-				       &cifsi->uniqueid, sizeof(cifsi->uniqueid),
+				       &key, sizeof(key),
 				       &cd, sizeof(cd),
 				       i_size_read(&cifsi->netfs.inode));
 	if (cifsi->netfs.cache)

fs/smb/client/inode.c+2−0

@@ -1351,6 +1351,8 @@ cifs_find_inode(struct inode inode, void opaque) · 1350 unmodified lines
1351	{	1351	{
1352	struct cifs_fattr *fattr = opaque;	1352	struct cifs_fattr *fattr = opaque;
1353		1353
		1354	/* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
		1355
1354	/* don't match inode with different uniqueid */	1356	/* don't match inode with different uniqueid */
1355	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)	1357	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1356	return 0;	1358	return 0;

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

fs/xfs/libxfs/xfs_sb.c+31−9

 	}
 	if (!xfs_validate_stripe_geometry(mp, XFS_FSB_TO_B(mp, sbp->sb_unit),
-			XFS_FSB_TO_B(mp, sbp->sb_width), 0, false))
+			XFS_FSB_TO_B(mp, sbp->sb_width), 0,
+			xfs_buf_daddr(bp) == XFS_SB_DADDR, false))
 		return -EFSCORRUPTED;
 	/*
 }
 /*
- * sunit, swidth, sectorsize(optional with 0) should be all in bytes,
+ * sunit, swidth, sectorsize(optional with 0) should be all in bytes, so users
- * so users won't be confused by values in error messages.
+ * won't be confused by values in error messages.  This function returns false
+ * if the stripe geometry is invalid and the caller is unable to repair the
+ * stripe configuration later in the mount process.
  */
 bool
 xfs_validate_stripe_geometry(
 	__s64			sunit,
 	__s64			swidth,
 	int			sectorsize,
+	bool			may_repair,
 	bool			silent)
 {
 	if (swidth > INT_MAX) {
 		if (!silent)
 			xfs_notice(mp,
 "stripe width (%lld) is too large", swidth);
-		return false;
+		goto check_override;
 	}
 	if (sunit > swidth) {
 		if (!silent)
 			xfs_notice(mp,
 "stripe unit (%lld) is larger than the stripe width (%lld)", sunit, swidth);
-		return false;
+		goto check_override;
 	}
 	if (sectorsize && (int)sunit % sectorsize) {
 			xfs_notice(mp,
 "stripe unit (%lld) must be a multiple of the sector size (%d)",
 				   sunit, sectorsize);
-		return false;
+		goto check_override;
 	}
 	if (sunit && !swidth) {
 		if (!silent)
 			xfs_notice(mp,
 "invalid stripe unit (%lld) and stripe width of 0", sunit);
-		return false;
+		goto check_override;
 	}
 	if (!sunit && swidth) {
 		if (!silent)
 			xfs_notice(mp,
 "invalid stripe width (%lld) and stripe unit of 0", swidth);
-		return false;
+		goto check_override;
 	}
 	if (sunit && (int)swidth % (int)sunit) {
 			xfs_notice(mp,
 "stripe width (%lld) must be a multiple of the stripe unit (%lld)",
 				   swidth, sunit);
-		return false;
+		goto check_override;
 	}
 	return true;
+check_override:
+	if (!may_repair)
+		return false;
+	/*
+	 * During mount, mp->m_dalign will not be set unless the sunit mount
+	 * option was set. If it was set, ignore the bad stripe alignment values
+	 * and allow the validation and overwrite later in the mount process to
+	 * attempt to overwrite the bad stripe alignment values with the values
+	 * supplied by mount options.
+	 */
+	if (!mp->m_dalign)
+		return false;
+	if (!silent)
+		xfs_notice(mp,
+"Will try to correct with specified mount options sunit (%d) and swidth (%d)",
+			BBTOB(mp->m_dalign), BBTOB(mp->m_swidth));
+	return true;
 }
 /*

fs/xfs/libxfs/xfs_sb.h+3−2

@@ -35,8 +35,9 @@ extern int xfs_sb_get_secondary(struct xfs_mount *mp, · 34 unmodified lines
35	struct xfs_trans *tp, xfs_agnumber_t agno,	35	struct xfs_trans *tp, xfs_agnumber_t agno,
36	struct xfs_buf **bpp);	36	struct xfs_buf **bpp);
37		37
38	extern bool xfs_validate_stripe_geometry(struct xfs_mount *mp,	38	bool xfs_validate_stripe_geometry(struct xfs_mount *mp,
39	__s64 sunit, __s64 swidth, int sectorsize, bool silent);	39	__s64 sunit, __s64 swidth, int sectorsize, bool may_repair,
		40	bool silent);
40		41
41	uint8_t xfs_compute_rextslog(xfs_rtbxlen_t rtextents);	42	uint8_t xfs_compute_rextslog(xfs_rtbxlen_t rtextents);
42		43

fs/xfs/scrub/common.c+1−3

 	struct xfs_scrub	*sc,
 	struct xfs_inode	*ip)
 {
-	if (current->journal_info != NULL) {
+	if (sc->tp) {
-		ASSERT(current->journal_info == sc->tp);
 		/*
 		 * If we are in a transaction, we /cannot/ drop the inode
 		 * ourselves, because the VFS will trigger writeback, which

fs/xfs/xfs_aops.c+0−7

@@ -503,13 +503,6 @@ xfs_vm_writepages( · 502 unmodified lines
503	{	503	{
504	struct xfs_writepage_ctx wpc = { };	504	struct xfs_writepage_ctx wpc = { };
505		505
506	/*
507	* Writing back data in a transaction context can result in recursive
508	* transactions. This is bad, so issue a warning and get out of here.
509	*/
510	if (WARN_ON_ONCE(current->journal_info))
511	return 0;
512
513	xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);	506	xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
514	return iomap_writepages(mapping, wbc, &wpc.ctx, &xfs_writeback_ops);	507	return iomap_writepages(mapping, wbc, &wpc.ctx, &xfs_writeback_ops);
515	}	508	}

fs/xfs/xfs_icache.c+5−3

  *  - Memory shrinkers queued the inactivation worker and it hasn't finished.
  *  - The queue depth exceeds the maximum allowable percpu backlog.
  *
- * Note: If the current thread is running a transaction, we don't ever want to
+ * Note: If we are in a NOFS context here (e.g. current thread is running a
- * wait for other transactions because that could introduce a deadlock.
+ * transaction) the we don't want to block here as inodegc progress may require
+ * filesystem resources we hold to make progress and that could result in a
+ * deadlock. Hence we skip out of here if we are in a scoped NOFS context.
  */
 static inline bool
 xfs_inodegc_want_flush_work(
 	unsigned int		items,
 	unsigned int		shrinker_hits)
 {
-	if (current->journal_info)
+	if (current->flags & PF_MEMALLOC_NOFS)
 		return false;
 	if (shrinker_hits > 0)

fs/xfs/xfs_trans.h+1−8

 xfs_trans_set_context(
 	struct xfs_trans	*tp)
 {
-	ASSERT(current->journal_info == NULL);
 	tp->t_pflags = memalloc_nofs_save();
-	current->journal_info = tp;
 }
 static inline void
 xfs_trans_clear_context(
 	struct xfs_trans	*tp)
 {
-	if (current->journal_info == tp) {
+	memalloc_nofs_restore(tp->t_pflags);
-		memalloc_nofs_restore(tp->t_pflags);
-		current->journal_info = NULL;
-	}
 }
 static inline void
 	struct xfs_trans	*old_tp,
 	struct xfs_trans	*new_tp)
 {
-	ASSERT(current->journal_info == old_tp);
 	new_tp->t_pflags = old_tp->t_pflags;
 	old_tp->t_pflags = 0;
-	current->journal_info = new_tp;
 }
 #endif	/* __XFS_TRANS_H__ */

include/asm-generic/export.h+0−11

@@ -1,11 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	#ifndef __ASM_GENERIC_EXPORT_H
3	#define __ASM_GENERIC_EXPORT_H
4
5	/*
6	* <asm/export.h> and <asm-generic/export.h> are deprecated.
7	* Please include <linux/export.h> directly.
8	*/
9	#include <linux/export.h>
10
11	#endif

include/linux/framer/framer.h+2−2

@@ -181,12 +181,12 @@ static inline int framer_notifier_unregister(struct framer *framer, · 180 unmodified lines
181	return -ENOSYS;	181	return -ENOSYS;
182	}	182	}
183		183
184	struct framer framer_get(struct device dev, const char *con_id)	184	static inline struct framer framer_get(struct device dev, const char *con_id)
185	{	185	{
186	return ERR_PTR(-ENOSYS);	186	return ERR_PTR(-ENOSYS);
187	}	187	}
188		188
189	void framer_put(struct device dev, struct framer framer)	189	static inline void framer_put(struct device dev, struct framer framer)
190	{	190	{
191	}	191	}
192		192

include/linux/gpio/driver.h+15−2

 struct gpio_device *gpio_device_find(const void *data,
 				int (*match)(struct gpio_chip *gc,
 					     const void *data));
-struct gpio_device *gpio_device_find_by_label(const char *label);
-struct gpio_device *gpio_device_find_by_fwnode(const struct fwnode_handle *fwnode);
 struct gpio_device *gpio_device_get(struct gpio_device *gdev);
 void gpio_device_put(struct gpio_device *gdev);
 int gpio_device_get_base(struct gpio_device *gdev);
 const char *gpio_device_get_label(struct gpio_device *gdev);
+struct gpio_device *gpio_device_find_by_label(const char *label);
+struct gpio_device *gpio_device_find_by_fwnode(const struct fwnode_handle *fwnode);
 #else /* CONFIG_GPIOLIB */
 #include <asm/bug.h>
 	return NULL;
 }
+static inline struct gpio_device *gpio_device_find_by_label(const char *label)
+{
+	WARN_ON(1);
+	return NULL;
+}
+static inline struct gpio_device *gpio_device_find_by_fwnode(const struct fwnode_handle *fwnode)
+{
+	WARN_ON(1);
+	return NULL;
+}
 static inline int gpiochip_lock_as_irq(struct gpio_chip *gc,
 				       unsigned int offset)
 {

include/linux/interrupt.h+3−0

  *                later.
  * IRQF_NO_DEBUG - Exclude from runnaway detection for IPI and similar handlers,
  *		   depends on IRQF_PERCPU.
+ * IRQF_COND_ONESHOT - Agree to do IRQF_ONESHOT if already set for a shared
+ *                 interrupt.
  */
 #define IRQF_SHARED		0x00000080
 #define IRQF_PROBE_SHARED	0x00000100
 #define IRQF_COND_SUSPEND	0x00040000
 #define IRQF_NO_AUTOEN		0x00080000
 #define IRQF_NO_DEBUG		0x00100000
+#define IRQF_COND_ONESHOT	0x00200000
 #define IRQF_TIMER		(__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD)

include/linux/libata.h+1−0

@@ -107,6 +107,7 @@ enum { · 106 unmodified lines
107		107
108	ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 20), /* Priority cmds sent to dev */	108	ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 20), /* Priority cmds sent to dev */
109	ATA_DFLAG_CDL_ENABLED = (1 << 21), /* cmd duration limits is enabled */	109	ATA_DFLAG_CDL_ENABLED = (1 << 21), /* cmd duration limits is enabled */
		110	ATA_DFLAG_RESUMING = (1 << 22), /* Device is resuming */
110	ATA_DFLAG_DETACH = (1 << 24),	111	ATA_DFLAG_DETACH = (1 << 24),
111	ATA_DFLAG_DETACHED = (1 << 25),	112	ATA_DFLAG_DETACHED = (1 << 25),
112	ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */	113	ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */

include/linux/mman.h+8−0

@@ -162,6 +162,14 @@ calc_vm_flag_bits(unsigned long flags) · 161 unmodified lines
162		162
163	unsigned long vm_commit_limit(void);	163	unsigned long vm_commit_limit(void);
164		164
		165	#ifndef arch_memory_deny_write_exec_supported
		166	static inline bool arch_memory_deny_write_exec_supported(void)
		167	{
		168	return true;
		169	}
		170	#define arch_memory_deny_write_exec_supported arch_memory_deny_write_exec_supported
		171	#endif
		172
165	/*	173	/*
166	* Denies creating a writable executable mapping or gaining executable permissions.	174	* Denies creating a writable executable mapping or gaining executable permissions.
167	*	175	*

include/linux/oid_registry.h+4−0

  *	  build_OID_registry.pl to generate the data for look_up_OID().
  */
 enum OID {
+	OID_id_dsa_with_sha1,		/* 1.2.840.10030.4.3 */
 	OID_id_dsa,			/* 1.2.840.10040.4.1 */
 	OID_id_ecPublicKey,		/* 1.2.840.10045.2.1 */
 	OID_id_prime192v1,		/* 1.2.840.10045.3.1.1 */
 	OID_id_prime256v1,		/* 1.2.840.10045.3.1.7 */
+	OID_id_ecdsa_with_sha1,		/* 1.2.840.10045.4.1 */
 	OID_id_ecdsa_with_sha224,	/* 1.2.840.10045.4.3.1 */
 	OID_id_ecdsa_with_sha256,	/* 1.2.840.10045.4.3.2 */
 	OID_id_ecdsa_with_sha384,	/* 1.2.840.10045.4.3.3 */
 	/* PKCS#1 {iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-1(1)} */
 	OID_rsaEncryption,		/* 1.2.840.113549.1.1.1 */
+	OID_sha1WithRSAEncryption,	/* 1.2.840.113549.1.1.5 */
 	OID_sha256WithRSAEncryption,	/* 1.2.840.113549.1.1.11 */
 	OID_sha384WithRSAEncryption,	/* 1.2.840.113549.1.1.12 */
 	OID_sha512WithRSAEncryption,	/* 1.2.840.113549.1.1.13 */
 	OID_PKU2U,			/* 1.3.5.1.5.2.7 */
 	OID_Scram,			/* 1.3.6.1.5.5.14 */
 	OID_certAuthInfoAccess,		/* 1.3.6.1.5.5.7.1.1 */
+	OID_sha1,			/* 1.3.14.3.2.26 */
 	OID_id_ansip384r1,		/* 1.3.132.0.34 */
 	OID_sha256,			/* 2.16.840.1.101.3.4.2.1 */
 	OID_sha384,			/* 2.16.840.1.101.3.4.2.2 */

include/linux/pagevec.h+2−2

@@ -11,8 +11,8 @@ · 10 unmodified lines
11		11
12	#include <linux/types.h>	12	#include <linux/types.h>
13		13
14	/* 15 pointers + header align the folio_batch structure to a power of two */	14	/* 31 pointers + header align the folio_batch structure to a power of two */
15	#define PAGEVEC_SIZE 15	15	#define PAGEVEC_SIZE 31
16		16
17	struct folio;	17	struct folio;
18		18

include/linux/skbuff.h+1−6

  *	@list: queue head
  *	@ll_node: anchor in an llist (eg socket defer_list)
  *	@sk: Socket we are owned by
- *	@ip_defrag_offset: (aka @sk) alternate use of @sk, used in
- *		fragmentation management
  *	@dev: Device we arrived on/are leaving by
  *	@dev_scratch: (aka @dev) alternate use of @dev when @dev would be %NULL
  *	@cb: Control buffer. Free for use by every layer. Put private vars here
 		struct llist_node	ll_node;
 	};
-	union {
+	struct sock		*sk;
-		struct sock		*sk;
-		int			ip_defrag_offset;
-	};
 	union {
 		ktime_t		tstamp;

include/net/cfg80211.h+2−0

  *	set this flag to update channels on beacon hints.
  * @WIPHY_FLAG_SUPPORTS_NSTR_NONPRIMARY: support connection to non-primary link
  *	of an NSTR mobile AP MLD.
+ * @WIPHY_FLAG_DISABLE_WEXT: disable wireless extensions for this device
  */
 enum wiphy_flags {
 	WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK		= BIT(0),
 	WIPHY_FLAG_4ADDR_STATION		= BIT(6),
 	WIPHY_FLAG_CONTROL_PORT_PROTOCOL	= BIT(7),
 	WIPHY_FLAG_IBSS_RSN			= BIT(8),
+	WIPHY_FLAG_DISABLE_WEXT			= BIT(9),
 	WIPHY_FLAG_MESH_AUTH			= BIT(10),
 	WIPHY_FLAG_SUPPORTS_EXT_KCK_32          = BIT(11),
 	WIPHY_FLAG_SUPPORTS_NSTR_NONPRIMARY	= BIT(12),

include/net/inet_connection_sock.h+1−0

@@ -175,6 +175,7 @@ void inet_csk_init_xmit_timers(struct sock *sk, · 174 unmodified lines
175	void (delack_handler)(struct timer_list ),	175	void (delack_handler)(struct timer_list ),
176	void (keepalive_handler)(struct timer_list ));	176	void (keepalive_handler)(struct timer_list ));
177	void inet_csk_clear_xmit_timers(struct sock *sk);	177	void inet_csk_clear_xmit_timers(struct sock *sk);
		178	void inet_csk_clear_xmit_timers_sync(struct sock *sk);
178		179
179	static inline void inet_csk_schedule_ack(struct sock *sk)	180	static inline void inet_csk_schedule_ack(struct sock *sk)
180	{	181	{

include/net/sock.h+7−0

@@ -1759,6 +1759,13 @@ static inline void sock_owned_by_me(const struct sock *sk) · 1758 unmodified lines
1759	#endif	1759	#endif
1760	}	1760	}
1761		1761
		1762	static inline void sock_not_owned_by_me(const struct sock *sk)
		1763	{
		1764	#ifdef CONFIG_LOCKDEP
		1765	WARN_ON_ONCE(lockdep_sock_is_held(sk) && debug_locks);
		1766	#endif
		1767	}
		1768
1762	static inline bool sock_owned_by_user(const struct sock *sk)	1769	static inline bool sock_owned_by_user(const struct sock *sk)
1763	{	1770	{
1764	sock_owned_by_me(sk);	1771	sock_owned_by_me(sk);

include/net/xdp_sock.h+2−0

@@ -188,6 +188,8 @@ static inline void xsk_tx_metadata_complete(struct xsk_tx_metadata_compl *compl, · 187 unmodified lines
188	{	188	{
189	if (!compl)	189	if (!compl)
190	return;	190	return;
		191	if (!compl->tx_timestamp)
		192	return;
191		193
192	*compl->tx_timestamp = ops->tmo_fill_timestamp(priv);	194	*compl->tx_timestamp = ops->tmo_fill_timestamp(priv);
193	}	195	}

include/scsi/scsi_driver.h+1−0

@@ -12,6 +12,7 @@ struct request; · 11 unmodified lines
12	struct scsi_driver {	12	struct scsi_driver {
13	struct device_driver gendrv;	13	struct device_driver gendrv;
14		14
		15	int (resume)(struct device );
15	void (rescan)(struct device );	16	void (rescan)(struct device );
16	blk_status_t (init_command)(struct scsi_cmnd );	17	blk_status_t (init_command)(struct scsi_cmnd );
17	void (uninit_command)(struct scsi_cmnd );	18	void (uninit_command)(struct scsi_cmnd );

include/scsi/scsi_host.h+1−0

@@ -767,6 +767,7 @@ scsi_template_proc_dir(const struct scsi_host_template *sht); · 766 unmodified lines
767	#define scsi_template_proc_dir(sht) NULL	767	#define scsi_template_proc_dir(sht) NULL
768	#endif	768	#endif
769	extern void scsi_scan_host(struct Scsi_Host *);	769	extern void scsi_scan_host(struct Scsi_Host *);
		770	extern int scsi_resume_device(struct scsi_device *sdev);
770	extern int scsi_rescan_device(struct scsi_device *sdev);	771	extern int scsi_rescan_device(struct scsi_device *sdev);
771	extern void scsi_remove_host(struct Scsi_Host *);	772	extern void scsi_remove_host(struct Scsi_Host *);
772	extern struct Scsi_Host scsi_host_get(struct Scsi_Host );	773	extern struct Scsi_Host scsi_host_get(struct Scsi_Host );

include/sound/intel-nhlt.h+10−0

 			     u32 bus_id, u8 link_type, u8 vbps, u8 bps,
 			     u8 num_ch, u32 rate, u8 dir, u8 dev_type);
+int intel_nhlt_ssp_device_type(struct device *dev, struct nhlt_acpi_table *nhlt,
+			       u8 virtual_bus_id);
 #else
 static inline struct nhlt_acpi_table *intel_nhlt_init(struct device *dev)
 	return NULL;
 }
+static inline int intel_nhlt_ssp_device_type(struct device *dev,
+					     struct nhlt_acpi_table *nhlt,
+					     u8 virtual_bus_id)
+{
+	return -EINVAL;
+}
 #endif
 #endif

include/uapi/linux/kfd_ioctl.h+14−3

 				 KFD_EC_MASK(EC_DEVICE_NEW))
 #define KFD_EC_MASK_PROCESS	(KFD_EC_MASK(EC_PROCESS_RUNTIME) |	\
 				 KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE))
+#define KFD_EC_MASK_PACKET	(KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) |	\
+				 KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED))
 /* Checks for exception code types for KFD search */
+#define KFD_DBG_EC_IS_VALID(ecode) (ecode > EC_NONE && ecode < EC_MAX)
 #define KFD_DBG_EC_TYPE_IS_QUEUE(ecode)					\
-			(!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE))
+			(KFD_DBG_EC_IS_VALID(ecode) && !!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE))
 #define KFD_DBG_EC_TYPE_IS_DEVICE(ecode)				\
-			(!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE))
+			(KFD_DBG_EC_IS_VALID(ecode) && !!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE))
 #define KFD_DBG_EC_TYPE_IS_PROCESS(ecode)				\
-			(!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS))
+			(KFD_DBG_EC_IS_VALID(ecode) && !!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS))
+#define KFD_DBG_EC_TYPE_IS_PACKET(ecode)				\
+			(KFD_DBG_EC_IS_VALID(ecode) && !!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PACKET))
 /* Runtime enable states */

include/uapi/scsi/scsi_bsg_mpi3mr.h+1−1

@@ -382,7 +382,7 @@ struct mpi3mr_bsg_in_reply_buf { · 381 unmodified lines
382	__u8 mpi_reply_type;	382	__u8 mpi_reply_type;
383	__u8 rsvd1;	383	__u8 rsvd1;
384	__u16 rsvd2;	384	__u16 rsvd2;
385	__u8 reply_buf[1];	385	__u8 reply_buf[];
386	};	386	};
387		387
388	/**	388	/**

include/ufs/ufshcd.h+1−0

@@ -328,6 +328,7 @@ struct ufs_pwr_mode_info { · 327 unmodified lines
328	* @op_runtime_config: called to config Operation and runtime regs Pointers	328	* @op_runtime_config: called to config Operation and runtime regs Pointers
329	* @get_outstanding_cqs: called to get outstanding completion queues	329	* @get_outstanding_cqs: called to get outstanding completion queues
330	* @config_esi: called to config Event Specific Interrupt	330	* @config_esi: called to config Event Specific Interrupt
		331	* @config_scsi_dev: called to configure SCSI device parameters
331	*/	332	*/
332	struct ufs_hba_variant_ops {	333	struct ufs_hba_variant_ops {
333	const char *name;	334	const char *name;

init/initramfs.c+1−1

@@ -682,7 +682,7 @@ static void __init populate_initrd_image(char *err) · 681 unmodified lines
682		682
683	printk(KERN_INFO "rootfs image is not initramfs (%s); looks like an initrd\n",	683	printk(KERN_INFO "rootfs image is not initramfs (%s); looks like an initrd\n",
684	err);	684	err);
685	file = filp_open("/initrd.image", O_WRONLY \| O_CREAT, 0700);	685	file = filp_open("/initrd.image", O_WRONLY\|O_CREAT\|O_LARGEFILE, 0700);
686	if (IS_ERR(file))	686	if (IS_ERR(file))
687	return;	687	return;
688		688

kernel/bpf/Makefile+1−1

@@ -4,7 +4,7 @@ ifneq ($(CONFIG_BPF_JIT_ALWAYS_ON),y) · 3 unmodified lines
4	# ___bpf_prog_run() needs GCSE disabled on x86; see 3193c0836f203 for details	4	# ___bpf_prog_run() needs GCSE disabled on x86; see 3193c0836f203 for details
5	cflags-nogcse-$(CONFIG_X86)$(CONFIG_CC_IS_GCC) := -fno-gcse	5	cflags-nogcse-$(CONFIG_X86)$(CONFIG_CC_IS_GCC) := -fno-gcse
6	endif	6	endif
7	CFLAGS_core.o += $(call cc-disable-warning, override-init) $(cflags-nogcse-yy)	7	CFLAGS_core.o += -Wno-override-init $(cflags-nogcse-yy)
8		8
9	obj-$(CONFIG_BPF_SYSCALL) += syscall.o verifier.o inode.o helpers.o tnum.o log.o token.o	9	obj-$(CONFIG_BPF_SYSCALL) += syscall.o verifier.o inode.o helpers.o tnum.o log.o token.o
10	obj-$(CONFIG_BPF_SYSCALL) += bpf_iter.o map_iter.o task_iter.o prog_iter.o link_iter.o	10	obj-$(CONFIG_BPF_SYSCALL) += bpf_iter.o map_iter.o task_iter.o prog_iter.o link_iter.o

kernel/bpf/arena.c+18−7

 /* number of bytes addressable by LDX/STX insn with 16-bit 'off' field */
 #define GUARD_SZ (1ull << sizeof(((struct bpf_insn *)0)->off) * 8)
-#define KERN_VM_SZ ((1ull << 32) + GUARD_SZ)
+#define KERN_VM_SZ (SZ_4G + GUARD_SZ)
 struct bpf_arena {
 	struct bpf_map map;
 		return ERR_PTR(-EINVAL);
 	vm_range = (u64)attr->max_entries * PAGE_SIZE;
-	if (vm_range > (1ull << 32))
+	if (vm_range > SZ_4G)
 		return ERR_PTR(-E2BIG);
 	if ((attr->map_extra >> 32) != ((attr->map_extra + vm_range - 1) >> 32))
 	if (pgoff)
 		return -EINVAL;
-	if (len > (1ull << 32))
+	if (len > SZ_4G)
 		return -E2BIG;
 	/* if user_vm_start was specified at arena creation time */
 	if (WARN_ON_ONCE(arena->user_vm_start))
 		/* checks at map creation time should prevent this */
 		return -EFAULT;
-	return round_up(ret, 1ull << 32);
+	return round_up(ret, SZ_4G);
 }
 static int arena_map_mmap(struct bpf_map *map, struct vm_area_struct *vma)
 		return -EBUSY;
 	/* Earlier checks should prevent this */
-	if (WARN_ON_ONCE(vma->vm_end - vma->vm_start > (1ull << 32) || vma->vm_pgoff))
+	if (WARN_ON_ONCE(vma->vm_end - vma->vm_start > SZ_4G || vma->vm_pgoff))
 		return -EFAULT;
 	if (remember_vma(arena, vma))
 		if (uaddr & ~PAGE_MASK)
 			return 0;
 		pgoff = compute_pgoff(arena, uaddr);
-		if (pgoff + page_cnt > page_cnt_max)
+		if (pgoff > page_cnt_max - page_cnt)
 			/* requested address will be outside of user VMA */
 			return 0;
 	}
 		goto out;
 	uaddr32 = (u32)(arena->user_vm_start + pgoff * PAGE_SIZE);
-	/* Earlier checks make sure that uaddr32 + page_cnt * PAGE_SIZE will not overflow 32-bit */
+	/* Earlier checks made sure that uaddr32 + page_cnt * PAGE_SIZE - 1
+	 * will not overflow 32-bit. Lower 32-bit need to represent
+	 * contiguous user address range.
+	 * Map these pages at kern_vm_start base.
+	 * kern_vm_start + uaddr32 + page_cnt * PAGE_SIZE - 1 can overflow
+	 * lower 32-bit and it's ok.
+	 */
 	ret = vm_area_map_pages(arena->kern_vm, kern_vm_start + uaddr32,
 				kern_vm_start + uaddr32 + page_cnt * PAGE_SIZE, pages);
 	if (ret) {
 		if (!page)
 			continue;
 		if (page_cnt == 1 && page_mapped(page)) /* mapped by some user process */
+			/* Optimization for the common case of page_cnt==1:
+			 * If page wasn't mapped into some user vma there
+			 * is no need to call zap_pages which is slow. When
+			 * page_cnt is big it's faster to do the batched zap.
+			 */
 			zap_pages(arena, full_uaddr, 1);
 		vm_area_unmap_pages(arena->kern_vm, kaddr, kaddr + PAGE_SIZE);
 		__free_page(page);

kernel/bpf/bloom_filter.c+13−0

@@ -80,6 +80,18 @@ static int bloom_map_get_next_key(struct bpf_map map, void key, void *next_key · 79 unmodified lines
80	return -EOPNOTSUPP;	80	return -EOPNOTSUPP;
81	}	81	}
82		82
		83	/* Called from syscall */
		84	static int bloom_map_alloc_check(union bpf_attr *attr)
		85	{
		86	if (attr->value_size > KMALLOC_MAX_SIZE)
		87	/* if value_size is bigger, the user space won't be able to
		88	* access the elements.
		89	*/
		90	return -E2BIG;
		91
		92	return 0;
		93	}
		94
83	static struct bpf_map bloom_map_alloc(union bpf_attr attr)	95	static struct bpf_map bloom_map_alloc(union bpf_attr attr)
84	{	96	{
85	u32 bitset_bytes, bitset_mask, nr_hash_funcs, nr_bits;	97	u32 bitset_bytes, bitset_mask, nr_hash_funcs, nr_bits;
@@ -191,6 +203,7 @@ static u64 bloom_map_mem_usage(const struct bpf_map *map) · 105 unmodified lines
191	BTF_ID_LIST_SINGLE(bpf_bloom_map_btf_ids, struct, bpf_bloom_filter)	203	BTF_ID_LIST_SINGLE(bpf_bloom_map_btf_ids, struct, bpf_bloom_filter)
192	const struct bpf_map_ops bloom_filter_map_ops = {	204	const struct bpf_map_ops bloom_filter_map_ops = {
193	.map_meta_equal = bpf_map_meta_equal,	205	.map_meta_equal = bpf_map_meta_equal,
		206	.map_alloc_check = bloom_map_alloc_check,
194	.map_alloc = bloom_map_alloc,	207	.map_alloc = bloom_map_alloc,
195	.map_free = bloom_map_free,	208	.map_free = bloom_map_free,
196	.map_get_next_key = bloom_map_get_next_key,	209	.map_get_next_key = bloom_map_get_next_key,

kernel/bpf/helpers.c+1−1

@@ -2548,7 +2548,7 @@ __bpf_kfunc void bpf_throw(u64 cookie) · 2547 unmodified lines
2548	__bpf_kfunc_end_defs();	2548	__bpf_kfunc_end_defs();
2549		2549
2550	BTF_KFUNCS_START(generic_btf_ids)	2550	BTF_KFUNCS_START(generic_btf_ids)
2551	#ifdef CONFIG_KEXEC_CORE	2551	#ifdef CONFIG_CRASH_DUMP
2552	BTF_ID_FLAGS(func, crash_kexec, KF_DESTRUCTIVE)	2552	BTF_ID_FLAGS(func, crash_kexec, KF_DESTRUCTIVE)
2553	#endif	2553	#endif
2554	BTF_ID_FLAGS(func, bpf_obj_new_impl, KF_ACQUIRE \| KF_RET_NULL)	2554	BTF_ID_FLAGS(func, bpf_obj_new_impl, KF_ACQUIRE \| KF_RET_NULL)

kernel/bpf/verifier.c+24−3

 	return reg->type == PTR_TO_FLOW_KEYS;
 }
+static bool is_arena_reg(struct bpf_verifier_env *env, int regno)
+{
+	const struct bpf_reg_state *reg = reg_state(env, regno);
+	return reg->type == PTR_TO_ARENA;
+}
 static u32 *reg2btf_ids[__BPF_REG_TYPE_MAX] = {
 #ifdef CONFIG_NET
 	[PTR_TO_SOCKET] = &btf_sock_ids[BTF_SOCK_TYPE_SOCK],
 	err = check_stack_slot_within_bounds(env, min_off, state, type);
 	if (!err && max_off > 0)
 		err = -EINVAL; /* out of stack access into non-negative offsets */
+	if (!err && access_size < 0)
+		/* access_size should not be negative (or overflow an int); others checks
+		 * along the way should have prevented such an access.
+		 */
+		err = -EFAULT; /* invalid negative access size; integer overflow? */
 	if (err) {
 		if (tnum_is_const(reg->var_off)) {
 	if (is_ctx_reg(env, insn->dst_reg) ||
 	    is_pkt_reg(env, insn->dst_reg) ||
 	    is_flow_key_reg(env, insn->dst_reg) ||
-	    is_sk_reg(env, insn->dst_reg)) {
+	    is_sk_reg(env, insn->dst_reg) ||
+	    is_arena_reg(env, insn->dst_reg)) {
 		verbose(env, "BPF_ATOMIC stores into R%d %s is not allowed\n",
 			insn->dst_reg,
 			reg_type_str(env, reg_state(env, insn->dst_reg)->type));
 					verbose(env, "addr_space_cast insn can only convert between address space 1 and 0\n");
 					return -EINVAL;
 				}
+				if (!env->prog->aux->arena) {
+					verbose(env, "addr_space_cast insn can only be used in a program that has an associated arena\n");
+					return -EINVAL;
+				}
 			} else {
 				if ((insn->off != 0 && insn->off != 8 && insn->off != 16 &&
 				     insn->off != 32) || insn->imm) {
 				if (insn->imm) {
 					/* off == BPF_ADDR_SPACE_CAST */
 					mark_reg_unknown(env, regs, insn->dst_reg);
-					if (insn->imm == 1) /* cast from as(1) to as(0) */
+					if (insn->imm == 1) { /* cast from as(1) to as(0) */
 						dst_reg->type = PTR_TO_ARENA;
+						/* PTR_TO_ARENA is 32-bit */
+						dst_reg->subreg_def = env->insn_idx + 1;
+					}
 				} else if (insn->off == 0) {
 					/* case: R1 = R2
 					 * copy register state to dest reg
 			    (((struct bpf_map *)env->prog->aux->arena)->map_flags & BPF_F_NO_USER_CONV)) {
 				/* convert to 32-bit mov that clears upper 32-bit */
 				insn->code = BPF_ALU | BPF_MOV | BPF_X;
-				/* clear off, so it's a normal 'wX = wY' from JIT pov */
+				/* clear off and imm, so it's a normal 'wX = wY' from JIT pov */
 				insn->off = 0;
+				insn->imm = 0;
 			} /* cast from as(0) to as(1) should be handled by JIT */
 			goto next_insn;
 		}

kernel/crash_reserve.c+7−0

 	crashk_low_res.start = low_base;
 	crashk_low_res.end   = low_base + low_size - 1;
+#ifdef HAVE_ARCH_ADD_CRASH_RES_TO_IOMEM_EARLY
 	insert_resource(&iomem_resource, &crashk_low_res);
+#endif
 #endif
 	return 0;
 }
 	crashk_res.start = crash_base;
 	crashk_res.end = crash_base + crash_size - 1;
+#ifdef HAVE_ARCH_ADD_CRASH_RES_TO_IOMEM_EARLY
+	insert_resource(&iomem_resource, &crashk_res);
+#endif
 }
+#ifndef HAVE_ARCH_ADD_CRASH_RES_TO_IOMEM_EARLY
 static __init int insert_crashkernel_resources(void)
 {
 	if (crashk_res.start < crashk_res.end)
 }
 early_initcall(insert_crashkernel_resources);
 #endif
+#endif

kernel/irq/manage.c+7−2

 		}
 		if (!((old->flags & new->flags) & IRQF_SHARED) ||
-		    (oldtype != (new->flags & IRQF_TRIGGER_MASK)) ||
+		    (oldtype != (new->flags & IRQF_TRIGGER_MASK)))
-		    ((old->flags ^ new->flags) & IRQF_ONESHOT))
+			goto mismatch;
+		if ((old->flags & IRQF_ONESHOT) &&
+		    (new->flags & IRQF_COND_ONESHOT))
+			new->flags |= IRQF_ONESHOT;
+		else if ((old->flags ^ new->flags) & IRQF_ONESHOT)
 			goto mismatch;
 		/* All handlers must agree on per-cpuness */

kernel/module/Kconfig+5−0

 	  possible to load a signed module containing the algorithm to check
 	  the signature on that module.
+config MODULE_SIG_SHA1
+	bool "Sign modules with SHA-1"
+	select CRYPTO_SHA1
 config MODULE_SIG_SHA256
 	bool "Sign modules with SHA-256"
 	select CRYPTO_SHA256
 config MODULE_SIG_HASH
 	string
 	depends on MODULE_SIG || IMA_APPRAISE_MODSIG
+	default "sha1" if MODULE_SIG_SHA1
 	default "sha256" if MODULE_SIG_SHA256
 	default "sha384" if MODULE_SIG_SHA384
 	default "sha512" if MODULE_SIG_SHA512

kernel/printk/printk.c+6−0

 	 */
 	mutex_acquire(&console_lock_dep_map, 0, 1, _THIS_IP_);
+	/*
+	 * Update @console_may_schedule for trylock because the previous
+	 * owner may have been schedulable.
+	 */
+	console_may_schedule = 0;
 	return 1;
 }

kernel/sys.c+5−2

 	if (bits & PR_MDWE_NO_INHERIT && !(bits & PR_MDWE_REFUSE_EXEC_GAIN))
 		return -EINVAL;
-	/* PARISC cannot allow mdwe as it needs writable stacks */
+	/*
-	if (IS_ENABLED(CONFIG_PARISC))
+	 * EOPNOTSUPP might be more appropriate here in principle, but
+	 * existing userspace depends on EINVAL specifically.
+	 */
+	if (!arch_memory_deny_write_exec_supported())
 		return -EINVAL;
 	current_bits = get_current_mdwe();

kernel/time/posix-clock.c+9−7

@@ -129,15 +129,17 @@ static int posix_clock_open(struct inode inode, struct file fp) · 128 unmodified lines
129	goto out;	129	goto out;
130	}	130	}
131	pccontext->clk = clk;	131	pccontext->clk = clk;
132	fp->private_data = pccontext;	132	if (clk->ops.open) {
133	if (clk->ops.open)
134	err = clk->ops.open(pccontext, fp->f_mode);	133	err = clk->ops.open(pccontext, fp->f_mode);
135	else	134	if (err) {
136	err = 0;	135	kfree(pccontext);
137		136	goto out;
138	if (!err) {	137	}
139	get_device(clk->dev);
140	}	138	}
		139
		140	fp->private_data = pccontext;
		141	get_device(clk->dev);
		142	err = 0;
141	out:	143	out:
142	up_read(&clk->rwsem);	144	up_read(&clk->rwsem);
143	return err;	145	return err;

kernel/trace/trace_probe.c+1−1

@@ -839,7 +839,7 @@ out: · 838 unmodified lines
839	void store_trace_entry_data(void edata, struct trace_probe tp, struct pt_regs *regs)	839	void store_trace_entry_data(void edata, struct trace_probe tp, struct pt_regs *regs)
840	{	840	{
841	struct probe_entry_arg *earg = tp->entry_arg;	841	struct probe_entry_arg *earg = tp->entry_arg;
842	unsigned long val;	842	unsigned long val = 0;
843	int i;	843	int i;
844		844
845	if (!earg)	845	if (!earg)

mm/Makefile+1−2

@@ -29,8 +29,7 @@ KCOV_INSTRUMENT_mmzone.o := n · 28 unmodified lines
29	KCOV_INSTRUMENT_vmstat.o := n	29	KCOV_INSTRUMENT_vmstat.o := n
30	KCOV_INSTRUMENT_failslab.o := n	30	KCOV_INSTRUMENT_failslab.o := n
31		31
32	CFLAGS_init-mm.o += $(call cc-disable-warning, override-init)	32	CFLAGS_init-mm.o += -Wno-override-init
33	CFLAGS_init-mm.o += $(call cc-disable-warning, initializer-overrides)
34		33
35	mmu-y := nommu.o	34	mmu-y := nommu.o
36	mmu-$(CONFIG_MMU) := highmem.o memory.o mincore.o \	35	mmu-$(CONFIG_MMU) := highmem.o memory.o mincore.o \

mm/filemap.c+16−0

@@ -4197,7 +4197,23 @@ static void filemap_cachestat(struct address_space *mapping, · 4196 unmodified lines
4197	/* shmem file - in swap cache */	4197	/* shmem file - in swap cache */
4198	swp_entry_t swp = radix_to_swp_entry(folio);	4198	swp_entry_t swp = radix_to_swp_entry(folio);
4199		4199
		4200	/* swapin error results in poisoned entry */
		4201	if (non_swap_entry(swp))
		4202	goto resched;
		4203
		4204	/*
		4205	* Getting a swap entry from the shmem
		4206	* inode means we beat
		4207	* shmem_unuse(). rcu_read_lock()
		4208	* ensures swapoff waits for us before
		4209	* freeing the swapper space. However,
		4210	* we can race with swapping and
		4211	* invalidation, so there might not be
		4212	* a shadow in the swapcache (yet).
		4213	*/
4200	shadow = get_shadow_from_swap_cache(swp);	4214	shadow = get_shadow_from_swap_cache(swp);
		4215	if (!shadow)
		4216	goto resched;
4201	}	4217	}
4202	#endif	4218	#endif
4203	if (workingset_test_recent(shadow, true, &workingset))	4219	if (workingset_test_recent(shadow, true, &workingset))

mm/gup.c+8−6

@@ -1653,20 +1653,22 @@ long populate_vma_page_range(struct vm_area_struct *vma, · 1652 unmodified lines
1653	if (vma->vm_flags & VM_LOCKONFAULT)	1653	if (vma->vm_flags & VM_LOCKONFAULT)
1654	return nr_pages;	1654	return nr_pages;
1655		1655
		1656	/* ... similarly, we've never faulted in PROT_NONE pages */
		1657	if (!vma_is_accessible(vma))
		1658	return -EFAULT;
		1659
1656	gup_flags = FOLL_TOUCH;	1660	gup_flags = FOLL_TOUCH;
1657	/*	1661	/*
1658	* We want to touch writable mappings with a write fault in order	1662	* We want to touch writable mappings with a write fault in order
1659	* to break COW, except for shared mappings because these don't COW	1663	* to break COW, except for shared mappings because these don't COW
1660	* and we would not want to dirty them for nothing.	1664	* and we would not want to dirty them for nothing.
		1665	*
		1666	* Otherwise, do a read fault, and use FOLL_FORCE in case it's not
		1667	* readable (ie write-only or executable).
1661	*/	1668	*/
1662	if ((vma->vm_flags & (VM_WRITE \| VM_SHARED)) == VM_WRITE)	1669	if ((vma->vm_flags & (VM_WRITE \| VM_SHARED)) == VM_WRITE)
1663	gup_flags \|= FOLL_WRITE;	1670	gup_flags \|= FOLL_WRITE;
1664		1671	else
1665	/*
1666	* We want mlock to succeed for regions that have any permissions
1667	* other than PROT_NONE.
1668	*/
1669	if (vma_is_accessible(vma))
1670	gup_flags \|= FOLL_FORCE;	1672	gup_flags \|= FOLL_FORCE;
1671		1673
1672	if (locked)	1674	if (locked)

mm/memory.c+3−1

 		ptep_get_and_clear_full(mm, addr, pte, tlb->fullmm);
 		arch_check_zapped_pte(vma, ptent);
 		tlb_remove_tlb_entry(tlb, pte, addr);
-		VM_WARN_ON_ONCE(userfaultfd_wp(vma));
+		if (userfaultfd_pte_wp(vma, ptent))
+			zap_install_uffd_wp_if_needed(vma, addr, pte, 1,
+						      details, ptent);
 		ksm_might_unmap_zero_page(mm, ptent);
 		return 1;
 	}

mm/page_owner.c+23−10

 static void init_early_allocated_pages(void);
+static inline void set_current_in_page_owner(void)
+{
+	/*
+	 * Avoid recursion.
+	 *
+	 * We might need to allocate more memory from page_owner code, so make
+	 * sure to signal it in order to avoid recursion.
+	 */
+	current->in_page_owner = 1;
+}
+static inline void unset_current_in_page_owner(void)
+{
+	current->in_page_owner = 0;
+}
 static int __init early_page_owner_param(char *buf)
 {
 	int ret = kstrtobool(buf, &page_owner_enabled);
 	depot_stack_handle_t handle;
 	unsigned int nr_entries;
-	/*
-	 * Avoid recursion.
-	 *
-	 * Sometimes page metadata allocation tracking requires more
-	 * memory to be allocated:
-	 * - when new stack trace is saved to stack depot
-	 */
 	if (current->in_page_owner)
 		return dummy_handle;
-	current->in_page_owner = 1;
+	set_current_in_page_owner();
 	nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 2);
 	handle = stack_depot_save(entries, nr_entries, flags);
 	if (!handle)
 		handle = failure_handle;
+	unset_current_in_page_owner();
-	current->in_page_owner = 0;
 	return handle;
 }
 	gfp_mask &= (GFP_ATOMIC | GFP_KERNEL);
 	gfp_mask |= __GFP_NOWARN;
+	set_current_in_page_owner();
 	stack = kmalloc(sizeof(*stack), gfp_mask);
-	if (!stack)
+	if (!stack) {
+		unset_current_in_page_owner();
 		return;
+	}
+	unset_current_in_page_owner();
 	stack->stack_record = stack_record;
 	stack->next = NULL;

mm/shmem_quota.c+7−3

 static int shmem_get_next_id(struct super_block *sb, struct kqid *qid)
 {
 	struct mem_dqinfo *info = sb_dqinfo(sb, qid->type);
-	struct rb_node *node = ((struct rb_root *)info->dqi_priv)->rb_node;
+	struct rb_node *node;
 	qid_t id = from_kqid(&init_user_ns, *qid);
 	struct quota_info *dqopt = sb_dqopt(sb);
 	struct quota_id *entry = NULL;
 		return -ESRCH;
 	down_read(&dqopt->dqio_sem);
+	node = ((struct rb_root *)info->dqi_priv)->rb_node;
 	while (node) {
 		entry = rb_entry(node, struct quota_id, node);
 static int shmem_acquire_dquot(struct dquot *dquot)
 {
 	struct mem_dqinfo *info = sb_dqinfo(dquot->dq_sb, dquot->dq_id.type);
-	struct rb_node **n = &((struct rb_root *)info->dqi_priv)->rb_node;
+	struct rb_node **n;
 	struct shmem_sb_info *sbinfo = dquot->dq_sb->s_fs_info;
 	struct rb_node *parent = NULL, *new_node = NULL;
 	struct quota_id *new_entry, *entry;
 	mutex_lock(&dquot->dq_lock);
 	down_write(&dqopt->dqio_sem);
+	n = &((struct rb_root *)info->dqi_priv)->rb_node;
 	while (*n) {
 		parent = *n;
 		entry = rb_entry(parent, struct quota_id, node);
 static int shmem_release_dquot(struct dquot *dquot)
 {
 	struct mem_dqinfo *info = sb_dqinfo(dquot->dq_sb, dquot->dq_id.type);
-	struct rb_node *node = ((struct rb_root *)info->dqi_priv)->rb_node;
+	struct rb_node *node;
 	qid_t id = from_kqid(&init_user_ns, dquot->dq_id);
 	struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
 	struct quota_id *entry = NULL;
 		goto out_dqlock;
 	down_write(&dqopt->dqio_sem);
+	node = ((struct rb_root *)info->dqi_priv)->rb_node;
 	while (node) {
 		entry = rb_entry(node, struct quota_id, node);

mm/userfaultfd.c+2−1

 		 */
 		down_read(&(*dst_vmap)->vm_lock->lock);
 		if (*dst_vmap != *src_vmap)
-			down_read(&(*src_vmap)->vm_lock->lock);
+			down_read_nested(&(*src_vmap)->vm_lock->lock,
+					 SINGLE_DEPTH_NESTING);
 	}
 	mmap_read_unlock(mm);
 	return err;

mm/zswap.c+39−6

@@ -1080,7 +1080,17 @@ static void zswap_decompress(struct zswap_entry entry, struct page page) · 1079 unmodified lines
1080	mutex_lock(&acomp_ctx->mutex);	1080	mutex_lock(&acomp_ctx->mutex);
1081		1081
1082	src = zpool_map_handle(zpool, entry->handle, ZPOOL_MM_RO);	1082	src = zpool_map_handle(zpool, entry->handle, ZPOOL_MM_RO);
1083	if (acomp_ctx->is_sleepable && !zpool_can_sleep_mapped(zpool)) {	1083	/*
		1084	* If zpool_map_handle is atomic, we cannot reliably utilize its mapped buffer
		1085	* to do crypto_acomp_decompress() which might sleep. In such cases, we must
		1086	* resort to copying the buffer to a temporary one.
		1087	* Meanwhile, zpool_map_handle() might return a non-linearly mapped buffer,
		1088	* such as a kmap address of high memory or even ever a vmap address.
		1089	* However, sg_init_one is only equipped to handle linearly mapped low memory.
		1090	* In such cases, we also must copy the buffer to a temporary and lowmem one.
		1091	*/
		1092	if ((acomp_ctx->is_sleepable && !zpool_can_sleep_mapped(zpool)) \|\|
		1093	!virt_addr_valid(src)) {
1084	memcpy(acomp_ctx->buffer, src, entry->length);	1094	memcpy(acomp_ctx->buffer, src, entry->length);
1085	src = acomp_ctx->buffer;	1095	src = acomp_ctx->buffer;
1086	zpool_unmap_handle(zpool, entry->handle);	1096	zpool_unmap_handle(zpool, entry->handle);
@@ -1094,7 +1104,7 @@ static void zswap_decompress(struct zswap_entry entry, struct page page) · 7 unmodified lines
1094	BUG_ON(acomp_ctx->req->dlen != PAGE_SIZE);	1104	BUG_ON(acomp_ctx->req->dlen != PAGE_SIZE);
1095	mutex_unlock(&acomp_ctx->mutex);	1105	mutex_unlock(&acomp_ctx->mutex);
1096		1106
1097	if (!acomp_ctx->is_sleepable \|\| zpool_can_sleep_mapped(zpool))	1107	if (src != acomp_ctx->buffer)
1098	zpool_unmap_handle(zpool, entry->handle);	1108	zpool_unmap_handle(zpool, entry->handle);
1099	}	1109	}
1100		1110
@@ -1313,6 +1323,14 @@ static unsigned long zswap_shrinker_count(struct shrinker *shrinker, · 212 unmodified lines
1313	if (!zswap_shrinker_enabled \|\| !mem_cgroup_zswap_writeback_enabled(memcg))	1323	if (!zswap_shrinker_enabled \|\| !mem_cgroup_zswap_writeback_enabled(memcg))
1314	return 0;	1324	return 0;
1315		1325
		1326	/*
		1327	* The shrinker resumes swap writeback, which will enter block
		1328	* and may enter fs. XXX: Harmonize with vmscan.c __GFP_FS
		1329	* rules (may_enter_fs()), which apply on a per-folio basis.
		1330	*/
		1331	if (!gfp_has_io_fs(sc->gfp_mask))
		1332	return 0;
		1333
1316	#ifdef CONFIG_MEMCG_KMEM	1334	#ifdef CONFIG_MEMCG_KMEM
1317	mem_cgroup_flush_stats(memcg);	1335	mem_cgroup_flush_stats(memcg);
1318	nr_backing = memcg_page_state(memcg, MEMCG_ZSWAP_B) >> PAGE_SHIFT;	1336	nr_backing = memcg_page_state(memcg, MEMCG_ZSWAP_B) >> PAGE_SHIFT;
@@ -1618,6 +1636,7 @@ bool zswap_load(struct folio *folio) · 299 unmodified lines
1618	swp_entry_t swp = folio->swap;	1636	swp_entry_t swp = folio->swap;
1619	pgoff_t offset = swp_offset(swp);	1637	pgoff_t offset = swp_offset(swp);
1620	struct page *page = &folio->page;	1638	struct page *page = &folio->page;
		1639	bool swapcache = folio_test_swapcache(folio);
1621	struct zswap_tree *tree = swap_zswap_tree(swp);	1640	struct zswap_tree *tree = swap_zswap_tree(swp);
1622	struct zswap_entry *entry;	1641	struct zswap_entry *entry;
1623	u8 *dst;	1642	u8 *dst;
@@ -1630,7 +1649,20 @@ bool zswap_load(struct folio *folio) · 6 unmodified lines
1630	spin_unlock(&tree->lock);	1649	spin_unlock(&tree->lock);
1631	return false;	1650	return false;
1632	}	1651	}
1633	zswap_rb_erase(&tree->rbroot, entry);	1652	/*
		1653	* When reading into the swapcache, invalidate our entry. The
		1654	* swapcache can be the authoritative owner of the page and
		1655	* its mappings, and the pressure that results from having two
		1656	* in-memory copies outweighs any benefits of caching the
		1657	* compression work.
		1658	*
		1659	* (Most swapins go through the swapcache. The notable
		1660	* exception is the singleton fault on SWP_SYNCHRONOUS_IO
		1661	* files, which reads into a private page and may free it if
		1662	* the fault fails. We remain the primary owner of the entry.)
		1663	*/
		1664	if (swapcache)
		1665	zswap_rb_erase(&tree->rbroot, entry);
1634	spin_unlock(&tree->lock);	1666	spin_unlock(&tree->lock);
1635		1667
1636	if (entry->length)	1668	if (entry->length)
@@ -1645,9 +1677,10 @@ bool zswap_load(struct folio *folio) · 8 unmodified lines
1645	if (entry->objcg)	1677	if (entry->objcg)
1646	count_objcg_event(entry->objcg, ZSWPIN);	1678	count_objcg_event(entry->objcg, ZSWPIN);
1647		1679
1648	zswap_entry_free(entry);	1680	if (swapcache) {
1649		1681	zswap_entry_free(entry);
1650	folio_mark_dirty(folio);	1682	folio_mark_dirty(folio);
		1683	}
1651		1684
1652	return true;	1685	return true;
1653	}	1686	}

net/core/sock.c+2−2

@@ -482,7 +482,7 @@ int __sock_queue_rcv_skb(struct sock sk, struct sk_buff skb) · 481 unmodified lines
482	unsigned long flags;	482	unsigned long flags;
483	struct sk_buff_head *list = &sk->sk_receive_queue;	483	struct sk_buff_head *list = &sk->sk_receive_queue;
484		484
485	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {	485	if (atomic_read(&sk->sk_rmem_alloc) >= READ_ONCE(sk->sk_rcvbuf)) {
486	atomic_inc(&sk->sk_drops);	486	atomic_inc(&sk->sk_drops);
487	trace_sock_rcvqueue_full(sk, skb);	487	trace_sock_rcvqueue_full(sk, skb);
488	return -ENOMEM;	488	return -ENOMEM;
@@ -552,7 +552,7 @@ int __sk_receive_skb(struct sock sk, struct sk_buff skb, · 63 unmodified lines
552		552
553	skb->dev = NULL;	553	skb->dev = NULL;
554		554
555	if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {	555	if (sk_rcvqueues_full(sk, READ_ONCE(sk->sk_rcvbuf))) {
556	atomic_inc(&sk->sk_drops);	556	atomic_inc(&sk->sk_drops);
557	goto discard_and_relse;	557	goto discard_and_relse;
558	}	558	}

net/hsr/hsr_slave.c+2−1

@@ -220,7 +220,8 @@ void hsr_del_port(struct hsr_port *port) · 219 unmodified lines
220	netdev_update_features(master->dev);	220	netdev_update_features(master->dev);
221	dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));	221	dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
222	netdev_rx_handler_unregister(port->dev);	222	netdev_rx_handler_unregister(port->dev);
223	dev_set_promiscuity(port->dev, -1);	223	if (!port->hsr->fwd_offloaded)
		224	dev_set_promiscuity(port->dev, -1);
224	netdev_upper_dev_unlink(port->dev, master->dev);	225	netdev_upper_dev_unlink(port->dev, master->dev);
225	}	226	}
226		227

net/ipv4/inet_connection_sock.c+14−0

@@ -771,6 +771,20 @@ void inet_csk_clear_xmit_timers(struct sock *sk) · 770 unmodified lines
771	}	771	}
772	EXPORT_SYMBOL(inet_csk_clear_xmit_timers);	772	EXPORT_SYMBOL(inet_csk_clear_xmit_timers);
773		773
		774	void inet_csk_clear_xmit_timers_sync(struct sock *sk)
		775	{
		776	struct inet_connection_sock *icsk = inet_csk(sk);
		777
		778	/* ongoing timer handlers need to acquire socket lock. */
		779	sock_not_owned_by_me(sk);
		780
		781	icsk->icsk_pending = icsk->icsk_ack.pending = 0;
		782
		783	sk_stop_timer_sync(sk, &icsk->icsk_retransmit_timer);
		784	sk_stop_timer_sync(sk, &icsk->icsk_delack_timer);
		785	sk_stop_timer_sync(sk, &sk->sk_timer);
		786	}
		787
774	void inet_csk_delete_keepalive_timer(struct sock *sk)	788	void inet_csk_delete_keepalive_timer(struct sock *sk)
775	{	789	{
776	sk_stop_timer(sk, &sk->sk_timer);	790	sk_stop_timer(sk, &sk->sk_timer);

net/ipv4/inet_fragment.c+57−13

 #include <net/ip.h>
 #include <net/ipv6.h>
+#include "../core/sock_destructor.h"
 /* Use skb->cb to track consecutive/adjacent fragments coming at
  * the end of the queue. Nodes in the rb-tree queue will
  * contain "runs" of one or more adjacent fragments.
 	};
 	struct sk_buff		*next_frag;
 	int			frag_run_len;
+	int			ip_defrag_offset;
 };
 #define FRAG_CB(skb)		((struct ipfrag_skb_cb *)((skb)->cb))
 	 */
 	if (!last)
 		fragrun_create(q, skb);  /* First fragment. */
-	else if (last->ip_defrag_offset + last->len < end) {
+	else if (FRAG_CB(last)->ip_defrag_offset + last->len < end) {
 		/* This is the common case: skb goes to the end. */
 		/* Detect and discard overlaps. */
-		if (offset < last->ip_defrag_offset + last->len)
+		if (offset < FRAG_CB(last)->ip_defrag_offset + last->len)
 			return IPFRAG_OVERLAP;
-		if (offset == last->ip_defrag_offset + last->len)
+		if (offset == FRAG_CB(last)->ip_defrag_offset + last->len)
 			fragrun_append_to_last(q, skb);
 		else
 			fragrun_create(q, skb);
 			parent = *rbn;
 			curr = rb_to_skb(parent);
-			curr_run_end = curr->ip_defrag_offset +
+			curr_run_end = FRAG_CB(curr)->ip_defrag_offset +
 					FRAG_CB(curr)->frag_run_len;
-			if (end <= curr->ip_defrag_offset)
+			if (end <= FRAG_CB(curr)->ip_defrag_offset)
 				rbn = &parent->rb_left;
 			else if (offset >= curr_run_end)
 				rbn = &parent->rb_right;
-			else if (offset >= curr->ip_defrag_offset &&
+			else if (offset >= FRAG_CB(curr)->ip_defrag_offset &&
 				 end <= curr_run_end)
 				return IPFRAG_DUP;
 			else
 		rb_insert_color(&skb->rbnode, &q->rb_fragments);
 	}
-	skb->ip_defrag_offset = offset;
+	FRAG_CB(skb)->ip_defrag_offset = offset;
 	return IPFRAG_OK;
 }
 			      struct sk_buff *parent)
 {
 	struct sk_buff *fp, *head = skb_rb_first(&q->rb_fragments);
-	struct sk_buff **nextp;
+	void (*destructor)(struct sk_buff *);
+	unsigned int orig_truesize = 0;
+	struct sk_buff **nextp = NULL;
+	struct sock *sk = skb->sk;
 	int delta;
+	if (sk && is_skb_wmem(skb)) {
+		/* TX: skb->sk might have been passed as argument to
+		 * dst->output and must remain valid until tx completes.
+		 *
+		 * Move sk to reassembled skb and fix up wmem accounting.
+		 */
+		orig_truesize = skb->truesize;
+		destructor = skb->destructor;
+	}
 	if (head != skb) {
 		fp = skb_clone(skb, GFP_ATOMIC);
-		if (!fp)
+		if (!fp) {
-			return NULL;
+			head = skb;
+			goto out_restore_sk;
+		}
 		FRAG_CB(fp)->next_frag = FRAG_CB(skb)->next_frag;
 		if (RB_EMPTY_NODE(&skb->rbnode))
 			FRAG_CB(parent)->next_frag = fp;
 					&q->rb_fragments);
 		if (q->fragments_tail == skb)
 			q->fragments_tail = fp;
+		if (orig_truesize) {
+			/* prevent skb_morph from releasing sk */
+			skb->sk = NULL;
+			skb->destructor = NULL;
+		}
 		skb_morph(skb, head);
 		FRAG_CB(skb)->next_frag = FRAG_CB(head)->next_frag;
 		rb_replace_node(&head->rbnode, &skb->rbnode,
 		consume_skb(head);
 		head = skb;
 	}
-	WARN_ON(head->ip_defrag_offset != 0);
+	WARN_ON(FRAG_CB(head)->ip_defrag_offset != 0);
 	delta = -head->truesize;
 	/* Head of list must not be cloned. */
 	if (skb_unclone(head, GFP_ATOMIC))
-		return NULL;
+		goto out_restore_sk;
 	delta += head->truesize;
 	if (delta)
 		clone = alloc_skb(0, GFP_ATOMIC);
 		if (!clone)
-			return NULL;
+			goto out_restore_sk;
 		skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
 		skb_frag_list_init(head);
 		for (i = 0; i < skb_shinfo(head)->nr_frags; i++)
 		nextp = &skb_shinfo(head)->frag_list;
 	}
+out_restore_sk:
+	if (orig_truesize) {
+		int ts_delta = head->truesize - orig_truesize;
+		/* if this reassembled skb is fragmented later,
+		 * fraglist skbs will get skb->sk assigned from head->sk,
+		 * and each frag skb will be released via sock_wfree.
+		 *
+		 * Update sk_wmem_alloc.
+		 */
+		head->sk = sk;
+		head->destructor = destructor;
+		refcount_add(ts_delta, &sk->sk_wmem_alloc);
+	}
 	return nextp;
 }
 EXPORT_SYMBOL(inet_frag_reasm_prepare);
 void inet_frag_reasm_finish(struct inet_frag_queue *q, struct sk_buff *head,
 			    void *reasm_data, bool try_coalesce)
 {
+	struct sock *sk = is_skb_wmem(head) ? head->sk : NULL;
+	const unsigned int head_truesize = head->truesize;
 	struct sk_buff **nextp = reasm_data;
 	struct rb_node *rbn;
 	struct sk_buff *fp;
 	head->prev = NULL;
 	head->tstamp = q->stamp;
 	head->mono_delivery_time = q->mono_delivery_time;
+	if (sk)
+		refcount_add(sum_truesize - head_truesize, &sk->sk_wmem_alloc);
 }
 EXPORT_SYMBOL(inet_frag_reasm_finish);

net/ipv4/ip_fragment.c+1−1

 	}
 	skb_dst_drop(skb);
+	skb_orphan(skb);
 	return -EINPROGRESS;
 insert_error:
 	struct ipq *qp;
 	__IP_INC_STATS(net, IPSTATS_MIB_REASMREQDS);
-	skb_orphan(skb);
 	/* Lookup (or create) queue header */
 	qp = ip_find(net, ip_hdr(skb), user, vif);

net/ipv4/netfilter/Kconfig+1−0

@@ -329,6 +329,7 @@ config NFT_COMPAT_ARP · 328 unmodified lines
329	config IP_NF_ARPFILTER	329	config IP_NF_ARPFILTER
330	tristate "arptables-legacy packet filtering support"	330	tristate "arptables-legacy packet filtering support"
331	select IP_NF_ARPTABLES	331	select IP_NF_ARPTABLES
		332	select NETFILTER_FAMILY_ARP
332	depends on NETFILTER_XTABLES	333	depends on NETFILTER_XTABLES
333	help	334	help
334	ARP packet filtering defines a table `filter', which has a series of	335	ARP packet filtering defines a table `filter', which has a series of

net/ipv4/nexthop.c+3−1

 	struct net *net = nh->net;
 	int err;
-	if (nexthop_notifiers_is_empty(net))
+	if (nexthop_notifiers_is_empty(net)) {
+		*hw_stats_used = false;
 		return 0;
+	}
 	err = nh_notifier_grp_hw_stats_init(&info, nh);
 	if (err)

net/ipv4/tcp.c+2−0

 	lock_sock(sk);
 	__tcp_close(sk, timeout);
 	release_sock(sk);
+	if (!sk->sk_net_refcnt)
+		inet_csk_clear_xmit_timers_sync(sk);
 	sock_put(sk);
 }
 EXPORT_SYMBOL(tcp_close);

net/ipv6/addrconf.c+3−2

 		err = 0;
 		if (fillargs.ifindex) {
-			err = -ENODEV;
 			dev = dev_get_by_index_rcu(tgt_net, fillargs.ifindex);
-			if (!dev)
+			if (!dev) {
+				err = -ENODEV;
 				goto done;
+			}
 			idev = __in6_dev_get(dev);
 			if (idev)
 				err = in6_dump_addrs(idev, skb, cb,

net/ipv6/netfilter/nf_conntrack_reasm.c+1−1

 	}
 	skb_dst_drop(skb);
+	skb_orphan(skb);
 	return -EINPROGRESS;
 insert_error:
 	hdr = ipv6_hdr(skb);
 	fhdr = (struct frag_hdr *)skb_transport_header(skb);
-	skb_orphan(skb);
 	fq = fq_find(net, fhdr->identification, user, hdr,
 		     skb->dev ? skb->dev->ifindex : 0);
 	if (fq == NULL) {

net/mac80211/cfg.c+2−3

 		}
 		if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
-		    sta->sdata->u.vlan.sta) {
+		    sta->sdata->u.vlan.sta)
-			ieee80211_clear_fast_rx(sta);
 			RCU_INIT_POINTER(sta->sdata->u.vlan.sta, NULL);
-		}
 		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
 			ieee80211_vif_dec_num_mcast(sta->sdata);
 		sta->sdata = vlansdata;
+		ieee80211_check_fast_rx(sta);
 		ieee80211_check_fast_xmit(sta);
 		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {

net/mac80211/debug.h+1−1

@@ -158,7 +158,7 @@ do { \ · 157 unmodified lines
158	_sdata_dbg(print, sdata, "[link %d] " fmt, \	158	_sdata_dbg(print, sdata, "[link %d] " fmt, \
159	link_id, ##__VA_ARGS__); \	159	link_id, ##__VA_ARGS__); \
160	else \	160	else \
161	_sdata_dbg(1, sdata, fmt, ##__VA_ARGS__); \	161	_sdata_dbg(print, sdata, fmt, ##__VA_ARGS__); \
162	} while (0)	162	} while (0)
163	#define link_dbg(link, fmt, ...) \	163	#define link_dbg(link, fmt, ...) \
164	_link_id_dbg(1, (link)->sdata, (link)->link_id, \	164	_link_id_dbg(1, (link)->sdata, (link)->link_id, \

net/mac80211/ieee80211_i.h+2−2

@@ -131,7 +131,7 @@ struct ieee80211_bss { · 130 unmodified lines
131	};	131	};
132		132
133	/**	133	/**
134	* enum ieee80211_corrupt_data_flags - BSS data corruption flags	134	* enum ieee80211_bss_corrupt_data_flags - BSS data corruption flags
135	* @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted	135	* @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted
136	* @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted	136	* @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted
137	*	137	*
@@ -144,7 +144,7 @@ enum ieee80211_bss_corrupt_data_flags { · 6 unmodified lines
144	};	144	};
145		145
146	/**	146	/**
147	* enum ieee80211_valid_data_flags - BSS valid data flags	147	* enum ieee80211_bss_valid_data_flags - BSS valid data flags
148	* @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE	148	* @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
149	* @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE	149	* @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
150	* @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE	150	* @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE

net/mac80211/mlme.c+12−3

 	}
 	if (sdata->vif.active_links != active_links) {
+		/* usable links are affected when active_links are changed,
+		 * so notify the driver about the status change
+		 */
+		changed |= BSS_CHANGED_MLD_VALID_LINKS;
+		active_links &= sdata->vif.active_links;
+		if (!active_links)
+			active_links =
+				BIT(__ffs(sdata->vif.valid_links &
+				    ~dormant_links));
 		ret = ieee80211_set_active_links(&sdata->vif, active_links);
 		if (ret) {
 			sdata_info(sdata, "Failed to set TTLM active links\n");
 		goto out;
 	}
-	changed |= BSS_CHANGED_MLD_VALID_LINKS;
 	sdata->vif.suspended_links = suspended_links;
 	if (sdata->vif.suspended_links)
 		changed |= BSS_CHANGED_MLD_TTLM;
 			sdata_info(sdata,
 				   "failed to insert STA entry for the AP (error %d)\n",
 				   err);
-			goto out_err;
+			goto out_release_chan;
 		}
 	} else
 		WARN_ON_ONCE(!ether_addr_equal(link->u.mgd.bssid, cbss->bssid));
 	return 0;
+out_release_chan:
+	ieee80211_link_release_channel(link);
 out_err:
-	ieee80211_link_release_channel(&sdata->deflink);
 	ieee80211_vif_set_links(sdata, 0, 0);
 	return err;
 }

net/netfilter/nf_tables_api.c+42−8

 					 __NFT_TABLE_F_WAS_AWAKEN | \
 					 __NFT_TABLE_F_WAS_ORPHAN)
+static bool nft_table_pending_update(const struct nft_ctx *ctx)
+{
+	struct nftables_pernet *nft_net = nft_pernet(ctx->net);
+	struct nft_trans *trans;
+	if (ctx->table->flags & __NFT_TABLE_F_UPDATE)
+		return true;
+	list_for_each_entry(trans, &nft_net->commit_list, list) {
+		if ((trans->msg_type == NFT_MSG_NEWCHAIN ||
+		     trans->msg_type == NFT_MSG_DELCHAIN) &&
+		    trans->ctx.table == ctx->table &&
+		    nft_trans_chain_update(trans))
+			return true;
+	}
+	return false;
+}
 static int nf_tables_updtable(struct nft_ctx *ctx)
 {
 	struct nft_trans *trans;
 		return -EOPNOTSUPP;
 	/* No dormant off/on/off/on games in single transaction */
-	if (ctx->table->flags & __NFT_TABLE_F_UPDATE)
+	if (nft_table_pending_update(ctx))
 		return -EINVAL;
 	trans = nft_trans_alloc(ctx, NFT_MSG_NEWTABLE,
 		}
 	}
+	if (table->flags & __NFT_TABLE_F_UPDATE &&
+	    !list_empty(&hook.list)) {
+		NL_SET_BAD_ATTR(extack, attr);
+		err = -EOPNOTSUPP;
+		goto err_hooks;
+	}
 	if (!(table->flags & NFT_TABLE_F_DORMANT) &&
 	    nft_is_base_chain(chain) &&
 	    !list_empty(&hook.list)) {
 	struct nft_trans *trans;
 	int err;
+	if (ctx->table->flags & __NFT_TABLE_F_UPDATE)
+		return -EOPNOTSUPP;
 	err = nft_chain_parse_hook(ctx->net, basechain, nla, &chain_hook,
 				   ctx->family, chain->flags, extack);
 	if (err < 0)
 	nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);
 	if (nla[NFTA_CHAIN_HOOK]) {
-		if (chain->flags & NFT_CHAIN_HW_OFFLOAD)
+		if (NFNL_MSG_TYPE(info->nlh->nlmsg_type) == NFT_MSG_DESTROYCHAIN ||
+		    chain->flags & NFT_CHAIN_HW_OFFLOAD)
 			return -EOPNOTSUPP;
 		if (nft_is_base_chain(chain)) {
 			if (nft_trans_chain_update(trans)) {
 				nf_tables_chain_notify(&trans->ctx, NFT_MSG_DELCHAIN,
 						       &nft_trans_chain_hooks(trans));
-				nft_netdev_unregister_hooks(net,
+				if (!(trans->ctx.table->flags & NFT_TABLE_F_DORMANT)) {
-							    &nft_trans_chain_hooks(trans),
+					nft_netdev_unregister_hooks(net,
-							    true);
+								    &nft_trans_chain_hooks(trans),
+								    true);
+				}
 			} else {
 				nft_chain_del(trans->ctx.chain);
 				nf_tables_chain_notify(&trans->ctx, NFT_MSG_DELCHAIN,
 			break;
 		case NFT_MSG_NEWCHAIN:
 			if (nft_trans_chain_update(trans)) {
-				nft_netdev_unregister_hooks(net,
+				if (!(trans->ctx.table->flags & NFT_TABLE_F_DORMANT)) {
-							    &nft_trans_chain_hooks(trans),
+					nft_netdev_unregister_hooks(net,
-							    true);
+								    &nft_trans_chain_hooks(trans),
+								    true);
+				}
 				free_percpu(nft_trans_chain_stats(trans));
 				kfree(nft_trans_chain_name(trans));
 				nft_trans_destroy(trans);

net/nfc/nci/core.c+5−0

 		nfc_send_to_raw_sock(ndev->nfc_dev, skb,
 				     RAW_PAYLOAD_NCI, NFC_DIRECTION_RX);
+		if (!nci_plen(skb->data)) {
+			kfree_skb(skb);
+			break;
+		}
 		/* Process frame */
 		switch (nci_mt(skb->data)) {
 		case NCI_MT_RSP_PKT:

net/sunrpc/auth_gss/gss_krb5_crypto.c+8−6

  * Caller provides the truncation length of the output token (h) in
  * cksumout.len.
  *
- * Note that for RPCSEC, the "initial cipher state" is always all zeroes.
- *
  * Return values:
  *   %GSS_S_COMPLETE: Digest computed, @cksumout filled in
  *   %GSS_S_FAILURE: Call failed
 		      int body_offset, struct xdr_netobj *cksumout)
 {
 	unsigned int ivsize = crypto_sync_skcipher_ivsize(cipher);
-	static const u8 iv[GSS_KRB5_MAX_BLOCKSIZE];
 	struct ahash_request *req;
 	struct scatterlist sg[1];
+	u8 *iv, *checksumdata;
 	int err = -ENOMEM;
-	u8 *checksumdata;
 	checksumdata = kmalloc(crypto_ahash_digestsize(tfm), GFP_KERNEL);
 	if (!checksumdata)
 		return GSS_S_FAILURE;
+	/* For RPCSEC, the "initial cipher state" is always all zeroes. */
+	iv = kzalloc(ivsize, GFP_KERNEL);
+	if (!iv)
+		goto out_free_mem;
 	req = ahash_request_alloc(tfm, GFP_KERNEL);
 	if (!req)
-		goto out_free_cksumdata;
+		goto out_free_mem;
 	ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL);
 	err = crypto_ahash_init(req);
 	if (err)
 out_free_ahash:
 	ahash_request_free(req);
-out_free_cksumdata:
+out_free_mem:
+	kfree(iv);
 	kfree_sensitive(checksumdata);
 	return err ? GSS_S_FAILURE : GSS_S_COMPLETE;
 }

net/tls/tls_sw.c+5−2

 	if (unlikely(flags & MSG_ERRQUEUE))
 		return sock_recv_errqueue(sk, msg, len, SOL_IP, IP_RECVERR);
-	psock = sk_psock_get(sk);
 	err = tls_rx_reader_lock(sk, ctx, flags & MSG_DONTWAIT);
 	if (err < 0)
 		return err;
+	psock = sk_psock_get(sk);
 	bpf_strp_enabled = sk_psock_strp_enabled(psock);
 	/* If crypto failed the connection is broken */
 		}
 		/* Drain records from the rx_list & copy if required */
-		if (is_peek || is_kvec)
+		if (is_peek)
 			err = process_rx_list(ctx, msg, &control, copied + peeked,
 					      decrypted - peeked, is_peek, NULL);
 		else
 			err = process_rx_list(ctx, msg, &control, 0,
 					      async_copy_bytes, is_peek, NULL);
+		/* we could have copied less than we wanted, and possibly nothing */
+		decrypted += max(err, 0) - async_copy_bytes;
 	}
 	copied += decrypted;

net/wireless/trace.h+1−1

@@ -1024,7 +1024,7 @@ TRACE_EVENT(rdev_get_mpp, · 1023 unmodified lines
1024	TRACE_EVENT(rdev_dump_mpp,	1024	TRACE_EVENT(rdev_dump_mpp,
1025	TP_PROTO(struct wiphy wiphy, struct net_device netdev, int _idx,	1025	TP_PROTO(struct wiphy wiphy, struct net_device netdev, int _idx,
1026	u8 dst, u8 mpp),	1026	u8 dst, u8 mpp),
1027	TP_ARGS(wiphy, netdev, _idx, mpp, dst),	1027	TP_ARGS(wiphy, netdev, _idx, dst, mpp),
1028	TP_STRUCT__entry(	1028	TP_STRUCT__entry(
1029	WIPHY_ENTRY	1029	WIPHY_ENTRY
1030	NETDEV_ENTRY	1030	NETDEV_ENTRY

net/wireless/wext-core.c+5−2

  * Authors :	Jean Tourrilhes - HPL - <jt@hpl.hp.com>
  * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
  * Copyright	2009 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright (C) 2024 Intel Corporation
  *
  * (As all part of the Linux kernel, this file is GPL)
  */
 	    dev->ieee80211_ptr->wiphy->wext &&
 	    dev->ieee80211_ptr->wiphy->wext->get_wireless_stats) {
 		wireless_warn_cfg80211_wext();
-		if (dev->ieee80211_ptr->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO)
+		if (dev->ieee80211_ptr->wiphy->flags & (WIPHY_FLAG_SUPPORTS_MLO |
+							WIPHY_FLAG_DISABLE_WEXT))
 			return NULL;
 		return dev->ieee80211_ptr->wiphy->wext->get_wireless_stats(dev);
 	}
 #ifdef CONFIG_CFG80211_WEXT
 	if (dev->ieee80211_ptr && dev->ieee80211_ptr->wiphy) {
 		wireless_warn_cfg80211_wext();
-		if (dev->ieee80211_ptr->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO)
+		if (dev->ieee80211_ptr->wiphy->flags & (WIPHY_FLAG_SUPPORTS_MLO |
+							WIPHY_FLAG_DISABLE_WEXT))
 			return NULL;
 		handlers = dev->ieee80211_ptr->wiphy->wext;
 	}

scripts/Makefile.extrawarn+3−7

 KBUILD_CFLAGS += $(call cc-disable-warning, format-truncation)
 KBUILD_CFLAGS += $(call cc-disable-warning, stringop-truncation)
+KBUILD_CFLAGS += -Wno-override-init # alias for -Wno-initializer-overrides in clang
 ifdef CONFIG_CC_IS_CLANG
 # Clang before clang-16 would warn on default argument promotions.
 ifneq ($(call clang-min-version, 160000),y)
 KBUILD_CFLAGS += $(call cc-option, -Wmaybe-uninitialized)
 KBUILD_CFLAGS += $(call cc-option, -Wunused-macros)
-ifdef CONFIG_CC_IS_CLANG
-KBUILD_CFLAGS += -Winitializer-overrides
-endif
 KBUILD_CPPFLAGS += -DKBUILD_EXTRA_WARN2
 else
 KBUILD_CFLAGS += -Wno-type-limits
 KBUILD_CFLAGS += -Wno-shift-negative-value
-ifdef CONFIG_CC_IS_CLANG
+ifdef CONFIG_CC_IS_GCC
-KBUILD_CFLAGS += -Wno-initializer-overrides
-else
 KBUILD_CFLAGS += -Wno-maybe-uninitialized
 endif

scripts/Makefile.modfinal+1−1

@@ -23,7 +23,7 @@ modname = $(notdir $(@:.mod.o=)) · 22 unmodified lines
23	part-of-module = y	23	part-of-module = y
24		24
25	quiet_cmd_cc_o_c = CC [M] $@	25	quiet_cmd_cc_o_c = CC [M] $@
26	cmd_cc_o_c = $(CC) $(filter-out $(CC_FLAGS_CFI) $(CFLAGS_GCOV), $(c_flags)) -c -o $@ $<	26	cmd_cc_o_c = $(CC) $(filter-out $(CC_FLAGS_CFI) $(CFLAGS_GCOV) $(CFLAGS_KCSAN), $(c_flags)) -c -o $@ $<
27		27
28	%.mod.o: %.mod.c FORCE	28	%.mod.o: %.mod.c FORCE
29	$(call if_changed_dep,cc_o_c)	29	$(call if_changed_dep,cc_o_c)

scripts/bpf_doc.py+2−2

@@ -414,8 +414,8 @@ class PrinterRST(Printer): · 413 unmodified lines
414	version = version.stdout.decode().rstrip()	414	version = version.stdout.decode().rstrip()
415	except:	415	except:
416	try:	416	try:
417	version = subprocess.run(['make', 'kernelversion'], cwd=linuxRoot,	417	version = subprocess.run(['make', '-s', '--no-print-directory', 'kernelversion'],
418	capture_output=True, check=True)	418	cwd=linuxRoot, capture_output=True, check=True)
419	version = version.stdout.decode().rstrip()	419	version = version.stdout.decode().rstrip()
420	except:	420	except:
421	return 'Linux'	421	return 'Linux'

scripts/kconfig/conf.c+0−5

 			continue;
 		}
 		sym_set_tristate_value(child->sym, yes);
-		for (child = child->list; child; child = child->next) {
-			indent += 2;
-			conf(child);
-			indent -= 2;
-		}
 		return 1;
 	}
 }

scripts/kconfig/lkc.h+1−1

@@ -89,7 +89,7 @@ void menu_add_visibility(struct expr *dep); · 88 unmodified lines
89	struct property menu_add_prompt(enum prop_type type, char prompt, struct expr *dep);	89	struct property menu_add_prompt(enum prop_type type, char prompt, struct expr *dep);
90	void menu_add_expr(enum prop_type type, struct expr expr, struct expr dep);	90	void menu_add_expr(enum prop_type type, struct expr expr, struct expr dep);
91	void menu_add_symbol(enum prop_type type, struct symbol sym, struct expr dep);	91	void menu_add_symbol(enum prop_type type, struct symbol sym, struct expr dep);
92	void menu_finalize(struct menu *parent);	92	void menu_finalize(void);
93	void menu_set_type(int type);	93	void menu_set_type(int type);
94		94
95	extern struct menu rootmenu;	95	extern struct menu rootmenu;

scripts/kconfig/lxdialog/checklist.c+1−1

@@ -119,7 +119,7 @@ int dialog_checklist(const char title, const char prompt, int height, · 118 unmodified lines
119	}	119	}
120		120
121	do_resize:	121	do_resize:
122	if (getmaxy(stdscr) < (height + CHECKLIST_HEIGTH_MIN))	122	if (getmaxy(stdscr) < (height + CHECKLIST_HEIGHT_MIN))
123	return -ERRDISPLAYTOOSMALL;	123	return -ERRDISPLAYTOOSMALL;
124	if (getmaxx(stdscr) < (width + CHECKLIST_WIDTH_MIN))	124	if (getmaxx(stdscr) < (width + CHECKLIST_WIDTH_MIN))
125	return -ERRDISPLAYTOOSMALL;	125	return -ERRDISPLAYTOOSMALL;

scripts/kconfig/lxdialog/dialog.h+6−6

@@ -162,17 +162,17 @@ int on_key_esc(WINDOW *win); · 161 unmodified lines
162	int on_key_resize(void);	162	int on_key_resize(void);
163		163
164	/* minimum (re)size values */	164	/* minimum (re)size values */
165	#define CHECKLIST_HEIGTH_MIN 6 /* For dialog_checklist() */	165	#define CHECKLIST_HEIGHT_MIN 6 /* For dialog_checklist() */
166	#define CHECKLIST_WIDTH_MIN 6	166	#define CHECKLIST_WIDTH_MIN 6
167	#define INPUTBOX_HEIGTH_MIN 2 /* For dialog_inputbox() */	167	#define INPUTBOX_HEIGHT_MIN 2 /* For dialog_inputbox() */
168	#define INPUTBOX_WIDTH_MIN 2	168	#define INPUTBOX_WIDTH_MIN 2
169	#define MENUBOX_HEIGTH_MIN 15 /* For dialog_menu() */	169	#define MENUBOX_HEIGHT_MIN 15 /* For dialog_menu() */
170	#define MENUBOX_WIDTH_MIN 65	170	#define MENUBOX_WIDTH_MIN 65
171	#define TEXTBOX_HEIGTH_MIN 8 /* For dialog_textbox() */	171	#define TEXTBOX_HEIGHT_MIN 8 /* For dialog_textbox() */
172	#define TEXTBOX_WIDTH_MIN 8	172	#define TEXTBOX_WIDTH_MIN 8
173	#define YESNO_HEIGTH_MIN 4 /* For dialog_yesno() */	173	#define YESNO_HEIGHT_MIN 4 /* For dialog_yesno() */
174	#define YESNO_WIDTH_MIN 4	174	#define YESNO_WIDTH_MIN 4
175	#define WINDOW_HEIGTH_MIN 19 /* For init_dialog() */	175	#define WINDOW_HEIGHT_MIN 19 /* For init_dialog() */
176	#define WINDOW_WIDTH_MIN 80	176	#define WINDOW_WIDTH_MIN 80
177		177
178	int init_dialog(const char *backtitle);	178	int init_dialog(const char *backtitle);

scripts/kconfig/lxdialog/inputbox.c+1−1

@@ -43,7 +43,7 @@ int dialog_inputbox(const char title, const char prompt, int height, int width · 42 unmodified lines
43	strcpy(instr, init);	43	strcpy(instr, init);
44		44
45	do_resize:	45	do_resize:
46	if (getmaxy(stdscr) <= (height - INPUTBOX_HEIGTH_MIN))	46	if (getmaxy(stdscr) <= (height - INPUTBOX_HEIGHT_MIN))
47	return -ERRDISPLAYTOOSMALL;	47	return -ERRDISPLAYTOOSMALL;
48	if (getmaxx(stdscr) <= (width - INPUTBOX_WIDTH_MIN))	48	if (getmaxx(stdscr) <= (width - INPUTBOX_WIDTH_MIN))
49	return -ERRDISPLAYTOOSMALL;	49	return -ERRDISPLAYTOOSMALL;

scripts/kconfig/lxdialog/menubox.c+1−1

@@ -172,7 +172,7 @@ int dialog_menu(const char title, const char prompt, · 171 unmodified lines
172	do_resize:	172	do_resize:
173	height = getmaxy(stdscr);	173	height = getmaxy(stdscr);
174	width = getmaxx(stdscr);	174	width = getmaxx(stdscr);
175	if (height < MENUBOX_HEIGTH_MIN \|\| width < MENUBOX_WIDTH_MIN)	175	if (height < MENUBOX_HEIGHT_MIN \|\| width < MENUBOX_WIDTH_MIN)
176	return -ERRDISPLAYTOOSMALL;	176	return -ERRDISPLAYTOOSMALL;
177		177
178	height -= 4;	178	height -= 4;

scripts/kconfig/lxdialog/textbox.c+1−1

@@ -175,7 +175,7 @@ int dialog_textbox(const char title, const char tbuf, int initial_height, · 174 unmodified lines
175		175
176	do_resize:	176	do_resize:
177	getmaxyx(stdscr, height, width);	177	getmaxyx(stdscr, height, width);
178	if (height < TEXTBOX_HEIGTH_MIN \|\| width < TEXTBOX_WIDTH_MIN)	178	if (height < TEXTBOX_HEIGHT_MIN \|\| width < TEXTBOX_WIDTH_MIN)
179	return -ERRDISPLAYTOOSMALL;	179	return -ERRDISPLAYTOOSMALL;
180	if (initial_height != 0)	180	if (initial_height != 0)
181	height = initial_height;	181	height = initial_height;

scripts/kconfig/lxdialog/util.c+1−1

@@ -291,7 +291,7 @@ int init_dialog(const char *backtitle) · 290 unmodified lines
291	getyx(stdscr, saved_y, saved_x);	291	getyx(stdscr, saved_y, saved_x);
292		292
293	getmaxyx(stdscr, height, width);	293	getmaxyx(stdscr, height, width);
294	if (height < WINDOW_HEIGTH_MIN \|\| width < WINDOW_WIDTH_MIN) {	294	if (height < WINDOW_HEIGHT_MIN \|\| width < WINDOW_WIDTH_MIN) {
295	endwin();	295	endwin();
296	return -ERRDISPLAYTOOSMALL;	296	return -ERRDISPLAYTOOSMALL;
297	}	297	}

scripts/kconfig/lxdialog/yesno.c+1−1

@@ -32,7 +32,7 @@ int dialog_yesno(const char title, const char prompt, int height, int width) · 31 unmodified lines
32	WINDOW *dialog;	32	WINDOW *dialog;
33		33
34	do_resize:	34	do_resize:
35	if (getmaxy(stdscr) < (height + YESNO_HEIGTH_MIN))	35	if (getmaxy(stdscr) < (height + YESNO_HEIGHT_MIN))
36	return -ERRDISPLAYTOOSMALL;	36	return -ERRDISPLAYTOOSMALL;
37	if (getmaxx(stdscr) < (width + YESNO_WIDTH_MIN))	37	if (getmaxx(stdscr) < (width + YESNO_WIDTH_MIN))
38	return -ERRDISPLAYTOOSMALL;	38	return -ERRDISPLAYTOOSMALL;

scripts/kconfig/mconf.c+2−2

@@ -659,9 +659,9 @@ static void conf_choice(struct menu *menu) · 658 unmodified lines
659	dialog_clear();	659	dialog_clear();
660	res = dialog_checklist(prompt ? prompt : "Main Menu",	660	res = dialog_checklist(prompt ? prompt : "Main Menu",
661	radiolist_instructions,	661	radiolist_instructions,
662	MENUBOX_HEIGTH_MIN,	662	MENUBOX_HEIGHT_MIN,
663	MENUBOX_WIDTH_MIN,	663	MENUBOX_WIDTH_MIN,
664	CHECKLIST_HEIGTH_MIN);	664	CHECKLIST_HEIGHT_MIN);
665	selected = item_activate_selected();	665	selected = item_activate_selected();
666	switch (res) {	666	switch (res) {
667	case 0:	667	case 0:

scripts/kconfig/menu.c+16−6

 	}
 }
-void menu_finalize(struct menu *parent)
+static void _menu_finalize(struct menu *parent, bool inside_choice)
 {
 	struct menu *menu, *last_menu;
 	struct symbol *sym;
 		 * and propagate parent dependencies before moving on.
 		 */
-		if (sym && sym_is_choice(sym)) {
+		bool is_choice = false;
+		if (sym && sym_is_choice(sym))
+			is_choice = true;
+		if (is_choice) {
 			if (sym->type == S_UNKNOWN) {
 				/* find the first choice value to find out choice type */
 				current_entry = parent;
 			}
 		}
-		if (sym && sym_is_choice(sym))
+		if (is_choice)
 			expr_free(parentdep);
 		/*
 		 * moving on
 		 */
 		for (menu = parent->list; menu; menu = menu->next)
-			menu_finalize(menu);
+			_menu_finalize(menu, is_choice);
-	} else if (sym) {
+	} else if (!inside_choice && sym) {
 		/*
 		 * Automatic submenu creation. If sym is a symbol and A, B, C,
 		 * ... are consecutive items (symbols, menus, ifs, etc.) that
 			/* Superset, put in submenu */
 			expr_free(dep2);
 		next:
-			menu_finalize(menu);
+			_menu_finalize(menu, false);
 			menu->parent = parent;
 			last_menu = menu;
 		}
 	}
 }
+void menu_finalize(void)
+{
+	_menu_finalize(&rootmenu, false);
+}
 bool menu_has_prompt(struct menu *menu)
 {
 	if (!menu->prompt)

scripts/kconfig/parser.y+1−1

@@ -515,7 +515,7 @@ void conf_parse(const char *name) · 514 unmodified lines
515	menu_add_prompt(P_MENU, "Main menu", NULL);	515	menu_add_prompt(P_MENU, "Main menu", NULL);
516	}	516	}
517		517
518	menu_finalize(&rootmenu);	518	menu_finalize();
519		519
520	menu = &rootmenu;	520	menu = &rootmenu;
521	while (menu) {	521	while (menu) {

scripts/mod/modpost.c+5−2

 static Elf_Sym *find_tosym(struct elf_info *elf, Elf_Addr addr, Elf_Sym *sym)
 {
+	Elf_Sym *new_sym;
 	/* If the supplied symbol has a valid name, return it */
 	if (is_valid_name(elf, sym))
 		return sym;
 	 * Strive to find a better symbol name, but the resulting name may not
 	 * match the symbol referenced in the original code.
 	 */
-	return symsearch_find_nearest(elf, addr, get_secindex(elf, sym),
+	new_sym = symsearch_find_nearest(elf, addr, get_secindex(elf, sym),
-				      true, 20);
+					 true, 20);
+	return new_sym ? new_sym : sym;
 }
 static bool is_executable_section(struct elf_info *elf, unsigned int secndx)

sound/aoa/soundbus/i2sbus/core.c+1−1

@@ -158,7 +158,7 @@ static int i2sbus_add_dev(struct macio_dev *macio, · 157 unmodified lines
158	struct device_node child, sound = NULL;	158	struct device_node child, sound = NULL;
159	struct resource *r;	159	struct resource *r;
160	int i, layout = 0, rlen, ok = force;	160	int i, layout = 0, rlen, ok = force;
161	char node_name[6];	161	char node_name[8];
162	static const char *rnames[] = { "i2sbus: %pOFn (control)",	162	static const char *rnames[] = { "i2sbus: %pOFn (control)",
163	"i2sbus: %pOFn (tx)",	163	"i2sbus: %pOFn (tx)",
164	"i2sbus: %pOFn (rx)" };	164	"i2sbus: %pOFn (rx)" };

sound/hda/intel-nhlt.c+26−0

@@ -343,3 +343,29 @@ intel_nhlt_get_endpoint_blob(struct device dev, struct nhlt_acpi_table nhlt, · 342 unmodified lines
343	return NULL;	343	return NULL;
344	}	344	}
345	EXPORT_SYMBOL(intel_nhlt_get_endpoint_blob);	345	EXPORT_SYMBOL(intel_nhlt_get_endpoint_blob);
		346
		347	int intel_nhlt_ssp_device_type(struct device dev, struct nhlt_acpi_table nhlt,
		348	u8 virtual_bus_id)
		349	{
		350	struct nhlt_endpoint *epnt;
		351	int i;
		352
		353	if (!nhlt)
		354	return -EINVAL;
		355
		356	epnt = (struct nhlt_endpoint *)nhlt->desc;
		357	for (i = 0; i < nhlt->endpoint_count; i++) {
		358	/* for SSP link the virtual bus id is the SSP port number */
		359	if (epnt->linktype == NHLT_LINK_SSP &&
		360	epnt->virtual_bus_id == virtual_bus_id) {
		361	dev_dbg(dev, "SSP%d: dev_type=%d\n", virtual_bus_id,
		362	epnt->device_type);
		363	return epnt->device_type;
		364	}
		365
		366	epnt = (struct nhlt_endpoint )((u8 )epnt + epnt->length);
		367	}
		368
		369	return -EINVAL;
		370	}
		371	EXPORT_SYMBOL(intel_nhlt_ssp_device_type);

sound/pci/hda/cs35l56_hda.c+4−4

 		goto err;
 	}
-	dev_dbg(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
+	dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
-		cs35l56->system_name, cs35l56->amp_name);
+		 cs35l56->system_name, cs35l56->amp_name);
 	regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
 			       ARRAY_SIZE(cs35l56_hda_dai_config));
 	pm_runtime_mark_last_busy(cs35l56->base.dev);
 	pm_runtime_enable(cs35l56->base.dev);
+	cs35l56->base.init_done = true;
 	ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
 	if (ret) {
 		dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
 		goto pm_err;
 	}
-	cs35l56->base.init_done = true;
 	return 0;
 pm_err:

sound/pci/hda/tas2781_hda_i2c.c+77−41

@@ -89,7 +89,7 @@ struct tas2781_hda { · 88 unmodified lines
89	struct snd_kcontrol *dsp_prog_ctl;	89	struct snd_kcontrol *dsp_prog_ctl;
90	struct snd_kcontrol *dsp_conf_ctl;	90	struct snd_kcontrol *dsp_conf_ctl;
91	struct snd_kcontrol *prof_ctl;	91	struct snd_kcontrol *prof_ctl;
92	struct snd_kcontrol *snd_ctls[3];	92	struct snd_kcontrol *snd_ctls[2];
93	};	93	};
94		94
95	static int tas2781_get_i2c_res(struct acpi_resource ares, void data)	95	static int tas2781_get_i2c_res(struct acpi_resource ares, void data)
@@ -161,8 +161,6 @@ static void tas2781_hda_playback_hook(struct device *dev, int action) · 65 unmodified lines
161	pm_runtime_put_autosuspend(dev);	161	pm_runtime_put_autosuspend(dev);
162	break;	162	break;
163	default:	163	default:
164	dev_dbg(tas_hda->dev, "Playback action not supported: %d\n",
165	action);
166	break;	164	break;
167	}	165	}
168	}	166	}
@@ -185,8 +183,15 @@ static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol, · 16 unmodified lines
185	{	183	{
186	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	184	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
187		185
		186	mutex_lock(&tas_priv->codec_lock);
		187
188	ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;	188	ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
189		189
		190	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
		191	__func__, kcontrol->id.name, tas_priv->rcabin.profile_cfg_id);
		192
		193	mutex_unlock(&tas_priv->codec_lock);
		194
190	return 0;	195	return 0;
191	}	196	}
192		197
@@ -200,11 +205,19 @@ static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol, · 7 unmodified lines
200		205
201	val = clamp(nr_profile, 0, max);	206	val = clamp(nr_profile, 0, max);
202		207
		208	mutex_lock(&tas_priv->codec_lock);
		209
		210	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
		211	__func__, kcontrol->id.name,
		212	tas_priv->rcabin.profile_cfg_id, val);
		213
203	if (tas_priv->rcabin.profile_cfg_id != val) {	214	if (tas_priv->rcabin.profile_cfg_id != val) {
204	tas_priv->rcabin.profile_cfg_id = val;	215	tas_priv->rcabin.profile_cfg_id = val;
205	ret = 1;	216	ret = 1;
206	}	217	}
207		218
		219	mutex_unlock(&tas_priv->codec_lock);
		220
208	return ret;	221	return ret;
209	}	222	}
210		223
@@ -241,8 +254,15 @@ static int tasdevice_program_get(struct snd_kcontrol *kcontrol, · 30 unmodified lines
241	{	254	{
242	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	255	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
243		256
		257	mutex_lock(&tas_priv->codec_lock);
		258
244	ucontrol->value.integer.value[0] = tas_priv->cur_prog;	259	ucontrol->value.integer.value[0] = tas_priv->cur_prog;
245		260
		261	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
		262	__func__, kcontrol->id.name, tas_priv->cur_prog);
		263
		264	mutex_unlock(&tas_priv->codec_lock);
		265
246	return 0;	266	return 0;
247	}	267	}
248		268
@@ -257,11 +277,18 @@ static int tasdevice_program_put(struct snd_kcontrol *kcontrol, · 8 unmodified lines
257		277
258	val = clamp(nr_program, 0, max);	278	val = clamp(nr_program, 0, max);
259		279
		280	mutex_lock(&tas_priv->codec_lock);
		281
		282	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
		283	__func__, kcontrol->id.name, tas_priv->cur_prog, val);
		284
260	if (tas_priv->cur_prog != val) {	285	if (tas_priv->cur_prog != val) {
261	tas_priv->cur_prog = val;	286	tas_priv->cur_prog = val;
262	ret = 1;	287	ret = 1;
263	}	288	}
264		289
		290	mutex_unlock(&tas_priv->codec_lock);
		291
265	return ret;	292	return ret;
266	}	293	}
267		294
@@ -270,8 +297,15 @@ static int tasdevice_config_get(struct snd_kcontrol *kcontrol, · 2 unmodified lines
270	{	297	{
271	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	298	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
272		299
		300	mutex_lock(&tas_priv->codec_lock);
		301
273	ucontrol->value.integer.value[0] = tas_priv->cur_conf;	302	ucontrol->value.integer.value[0] = tas_priv->cur_conf;
274		303
		304	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
		305	__func__, kcontrol->id.name, tas_priv->cur_conf);
		306
		307	mutex_unlock(&tas_priv->codec_lock);
		308
275	return 0;	309	return 0;
276	}	310	}
277		311
@@ -286,54 +320,39 @@ static int tasdevice_config_put(struct snd_kcontrol *kcontrol, · 8 unmodified lines
286		320
287	val = clamp(nr_config, 0, max);	321	val = clamp(nr_config, 0, max);
288		322
		323	mutex_lock(&tas_priv->codec_lock);
		324
		325	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
		326	__func__, kcontrol->id.name, tas_priv->cur_conf, val);
		327
289	if (tas_priv->cur_conf != val) {	328	if (tas_priv->cur_conf != val) {
290	tas_priv->cur_conf = val;	329	tas_priv->cur_conf = val;
291	ret = 1;	330	ret = 1;
292	}	331	}
293		332
		333	mutex_unlock(&tas_priv->codec_lock);
		334
294	return ret;	335	return ret;
295	}	336	}
296		337
297	/*	338	static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,
298	* tas2781_digital_getvol - get the volum control
299	* @kcontrol: control pointer
300	* @ucontrol: User data
301	* Customer Kcontrol for tas2781 is primarily for regmap booking, paging
302	* depends on internal regmap mechanism.
303	* tas2781 contains book and page two-level register map, especially
304	* book switching will set the register BXXP00R7F, after switching to the
305	* correct book, then leverage the mechanism for paging to access the
306	* register.
307	*/
308	static int tas2781_digital_getvol(struct snd_kcontrol *kcontrol,
309	struct snd_ctl_elem_value *ucontrol)	339	struct snd_ctl_elem_value *ucontrol)
310	{	340	{
311	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	341	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
312	struct soc_mixer_control *mc =	342	struct soc_mixer_control *mc =
313	(struct soc_mixer_control *)kcontrol->private_value;	343	(struct soc_mixer_control *)kcontrol->private_value;
		344	int ret;
314		345
315	return tasdevice_digital_getvol(tas_priv, ucontrol, mc);	346	mutex_lock(&tas_priv->codec_lock);
316	}
317		347
318	static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,	348	ret = tasdevice_amp_getvol(tas_priv, ucontrol, mc);
319	struct snd_ctl_elem_value *ucontrol)
320	{
321	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
322	struct soc_mixer_control *mc =
323	(struct soc_mixer_control *)kcontrol->private_value;
324		349
325	return tasdevice_amp_getvol(tas_priv, ucontrol, mc);	350	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %ld\n",
326	}	351	__func__, kcontrol->id.name, ucontrol->value.integer.value[0]);
327		352
328	static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol,	353	mutex_unlock(&tas_priv->codec_lock);
329	struct snd_ctl_elem_value *ucontrol)
330	{
331	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
332	struct soc_mixer_control *mc =
333	(struct soc_mixer_control *)kcontrol->private_value;
334		354
335	/* The check of the given value is in tasdevice_digital_putvol. */	355	return ret;
336	return tasdevice_digital_putvol(tas_priv, ucontrol, mc);
337	}	356	}
338		357
339	static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,	358	static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,
@@ -342,9 +361,19 @@ static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol, · 2 unmodified lines
342	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	361	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
343	struct soc_mixer_control *mc =	362	struct soc_mixer_control *mc =
344	(struct soc_mixer_control *)kcontrol->private_value;	363	(struct soc_mixer_control *)kcontrol->private_value;
		364	int ret;
		365
		366	mutex_lock(&tas_priv->codec_lock);
		367
		368	dev_dbg(tas_priv->dev, "%s: kcontrol %s: -> %ld\n",
		369	__func__, kcontrol->id.name, ucontrol->value.integer.value[0]);
345		370
346	/* The check of the given value is in tasdevice_amp_putvol. */	371	/* The check of the given value is in tasdevice_amp_putvol. */
347	return tasdevice_amp_putvol(tas_priv, ucontrol, mc);	372	ret = tasdevice_amp_putvol(tas_priv, ucontrol, mc);
		373
		374	mutex_unlock(&tas_priv->codec_lock);
		375
		376	return ret;
348	}	377	}
349		378
350	static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,	379	static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,
@@ -352,9 +381,13 @@ static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol, · 1 unmodified line
352	{	381	{
353	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	382	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
354		383
		384	mutex_lock(&tas_priv->codec_lock);
		385
355	ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;	386	ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
356	dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,	387	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
357	tas_priv->force_fwload_status ? "ON" : "OFF");	388	__func__, kcontrol->id.name, tas_priv->force_fwload_status);
		389
		390	mutex_unlock(&tas_priv->codec_lock);
358		391
359	return 0;	392	return 0;
360	}	393	}
@@ -365,14 +398,20 @@ static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol, · 4 unmodified lines
365	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);	398	struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
366	bool change, val = (bool)ucontrol->value.integer.value[0];	399	bool change, val = (bool)ucontrol->value.integer.value[0];
367		400
		401	mutex_lock(&tas_priv->codec_lock);
		402
		403	dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
		404	__func__, kcontrol->id.name,
		405	tas_priv->force_fwload_status, val);
		406
368	if (tas_priv->force_fwload_status == val)	407	if (tas_priv->force_fwload_status == val)
369	change = false;	408	change = false;
370	else {	409	else {
371	change = true;	410	change = true;
372	tas_priv->force_fwload_status = val;	411	tas_priv->force_fwload_status = val;
373	}	412	}
374	dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,	413
375	tas_priv->force_fwload_status ? "ON" : "OFF");	414	mutex_unlock(&tas_priv->codec_lock);
376		415
377	return change;	416	return change;
378	}	417	}
@@ -381,9 +420,6 @@ static const struct snd_kcontrol_new tas2781_snd_controls[] = { · 2 unmodified lines
381	ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,	420	ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,
382	1, 0, 20, 0, tas2781_amp_getvol,	421	1, 0, 20, 0, tas2781_amp_getvol,
383	tas2781_amp_putvol, amp_vol_tlv),	422	tas2781_amp_putvol, amp_vol_tlv),
384	ACARD_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2781_DVC_LVL,
385	0, 0, 200, 1, tas2781_digital_getvol,
386	tas2781_digital_putvol, dvc_tlv),
387	ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,	423	ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,
388	tas2781_force_fwload_get, tas2781_force_fwload_put),	424	tas2781_force_fwload_get, tas2781_force_fwload_put),
389	};	425	};

sound/sh/aica.c+14−3

 		dreamcastcard->clicks++;
 		if (unlikely(dreamcastcard->clicks >= AICA_PERIOD_NUMBER))
 			dreamcastcard->clicks %= AICA_PERIOD_NUMBER;
-		mod_timer(&dreamcastcard->timer, jiffies + 1);
+		if (snd_pcm_running(dreamcastcard->substream))
+			mod_timer(&dreamcastcard->timer, jiffies + 1);
 	}
 }
 	/*timer function - so cannot sleep */
 	int play_period;
 	struct snd_pcm_runtime *runtime;
+	if (!snd_pcm_running(substream))
+		return;
 	runtime = substream->runtime;
 	dreamcastcard = substream->pcm->private_data;
 	/* Have we played out an additional period? */
 	return 0;
 }
+static int snd_aicapcm_pcm_sync_stop(struct snd_pcm_substream *substream)
+{
+	struct snd_card_aica *dreamcastcard = substream->pcm->private_data;
+	del_timer_sync(&dreamcastcard->timer);
+	cancel_work_sync(&dreamcastcard->spu_dma_work);
+	return 0;
+}
 static int snd_aicapcm_pcm_close(struct snd_pcm_substream
 				 *substream)
 {
 	struct snd_card_aica *dreamcastcard = substream->pcm->private_data;
-	flush_work(&(dreamcastcard->spu_dma_work));
-	del_timer(&dreamcastcard->timer);
 	dreamcastcard->substream = NULL;
 	kfree(dreamcastcard->channel);
 	spu_disable();
 	.prepare = snd_aicapcm_pcm_prepare,
 	.trigger = snd_aicapcm_pcm_trigger,
 	.pointer = snd_aicapcm_pcm_pointer,
+	.sync_stop = snd_aicapcm_pcm_sync_stop,
 };
 /* TO DO: set up to handle more than one pcm instance */

sound/soc/sof/ipc4-topology.c+16−3

 	int sample_rate, channel_count;
 	int bit_depth, ret;
 	u32 nhlt_type;
+	int dev_type = 0;
 	/* convert to NHLT type */
 	switch (linktype) {
 						   &bit_depth);
 		if (ret < 0)
 			return ret;
+		/*
+		 * We need to know the type of the external device attached to a SSP
+		 * port to retrieve the blob from NHLT. However, device type is not
+		 * specified in topology.
+		 * Query the type for the port and then pass that information back
+		 * to the blob lookup function.
+		 */
+		dev_type = intel_nhlt_ssp_device_type(sdev->dev, ipc4_data->nhlt,
+						      dai_index);
+		if (dev_type < 0)
+			return dev_type;
 		break;
 	default:
 		return 0;
 	}
-	dev_dbg(sdev->dev, "dai index %d nhlt type %d direction %d\n",
+	dev_dbg(sdev->dev, "dai index %d nhlt type %d direction %d dev type %d\n",
-		dai_index, nhlt_type, dir);
+		dai_index, nhlt_type, dir, dev_type);
 	/* find NHLT blob with matching params */
 	cfg = intel_nhlt_get_endpoint_blob(sdev->dev, ipc4_data->nhlt, dai_index, nhlt_type,
 					   bit_depth, bit_depth, channel_count, sample_rate,
-					   dir, 0);
+					   dir, dev_type);
 	if (!cfg) {
 		dev_err(sdev->dev,

tools/Makefile+6−7

 	@echo ''
 	@echo '  acpi                   - ACPI tools'
 	@echo '  bpf                    - misc BPF tools'
-	@echo '  cgroup                 - cgroup tools'
 	@echo '  counter                - counter tools'
 	@echo '  cpupower               - a tool for all things x86 CPU power'
 	@echo '  debugging              - tools for debugging'
 cpupower: FORCE
 	$(call descend,power/$@)
-cgroup counter firewire hv guest bootconfig spi usb virtio mm bpf iio gpio objtool leds wmi pci firmware debugging tracing: FORCE
+counter firewire hv guest bootconfig spi usb virtio mm bpf iio gpio objtool leds wmi pci firmware debugging tracing: FORCE
 	$(call descend,$@)
 bpf/%: FORCE
 kvm_stat: FORCE
 	$(call descend,kvm/$@)
-all: acpi cgroup counter cpupower gpio hv firewire \
+all: acpi counter cpupower gpio hv firewire \
 		perf selftests bootconfig spi turbostat usb \
 		virtio mm bpf x86_energy_perf_policy \
 		tmon freefall iio objtool kvm_stat wmi \
 cpupower_install:
 	$(call descend,power/$(@:_install=),install)
-cgroup_install counter_install firewire_install gpio_install hv_install iio_install perf_install bootconfig_install spi_install usb_install virtio_install mm_install bpf_install objtool_install wmi_install pci_install debugging_install tracing_install:
+counter_install firewire_install gpio_install hv_install iio_install perf_install bootconfig_install spi_install usb_install virtio_install mm_install bpf_install objtool_install wmi_install pci_install debugging_install tracing_install:
 	$(call descend,$(@:_install=),install)
 selftests_install:
 kvm_stat_install:
 	$(call descend,kvm/$(@:_install=),install)
-install: acpi_install cgroup_install counter_install cpupower_install gpio_install \
+install: acpi_install counter_install cpupower_install gpio_install \
 		hv_install firewire_install iio_install \
 		perf_install selftests_install turbostat_install usb_install \
 		virtio_install mm_install bpf_install x86_energy_perf_policy_install \
 cpupower_clean:
 	$(call descend,power/cpupower,clean)
-cgroup_clean counter_clean hv_clean firewire_clean bootconfig_clean spi_clean usb_clean virtio_clean mm_clean wmi_clean bpf_clean iio_clean gpio_clean objtool_clean leds_clean pci_clean firmware_clean debugging_clean tracing_clean:
+counter_clean hv_clean firewire_clean bootconfig_clean spi_clean usb_clean virtio_clean mm_clean wmi_clean bpf_clean iio_clean gpio_clean objtool_clean leds_clean pci_clean firmware_clean debugging_clean tracing_clean:
 	$(call descend,$(@:_clean=),clean)
 libapi_clean:
 build_clean:
 	$(call descend,build,clean)
-clean: acpi_clean cgroup_clean counter_clean cpupower_clean hv_clean firewire_clean \
+clean: acpi_clean counter_clean cpupower_clean hv_clean firewire_clean \
 		perf_clean selftests_clean turbostat_clean bootconfig_clean spi_clean usb_clean virtio_clean \
 		mm_clean bpf_clean iio_clean x86_energy_perf_policy_clean tmon_clean \
 		freefall_clean build_clean libbpf_clean libsubcmd_clean \

tools/bpf/bpftool/gen.c+1−1

@@ -121,7 +121,7 @@ static bool get_datasec_ident(const char sec_name, char buf, size_t buf_sz) · 120 unmodified lines
121	int i, n;	121	int i, n;
122		122
123	/* recognize hard coded LLVM section name */	123	/* recognize hard coded LLVM section name */
124	if (strcmp(sec_name, ".arena.1") == 0) {	124	if (strcmp(sec_name, ".addr_space.1") == 0) {
125	/* this is the name to use in skeleton */	125	/* this is the name to use in skeleton */
126	snprintf(buf, buf_sz, "arena");	126	snprintf(buf, buf_sz, "arena");
127	return true;	127	return true;

tools/lib/bpf/libbpf.c+7−3

 #define KSYMS_SEC ".ksyms"
 #define STRUCT_OPS_SEC ".struct_ops"
 #define STRUCT_OPS_LINK_SEC ".struct_ops.link"
-#define ARENA_SEC ".arena.1"
+#define ARENA_SEC ".addr_space.1"
 enum libbpf_map_type {
 	LIBBPF_MAP_UNSPEC,
 	return syscall(__NR_memfd_create, name, flags);
 }
+#ifndef MFD_CLOEXEC
+#define MFD_CLOEXEC 0x0001U
+#endif
 static int create_placeholder_fd(void)
 {
 	int fd;
 					goto err_out;
 			}
 			if (map->def.type == BPF_MAP_TYPE_ARENA) {
-				map->mmaped = mmap((void *)map->map_extra, bpf_map_mmap_sz(map),
+				map->mmaped = mmap((void *)(long)map->map_extra,
-						   PROT_READ | PROT_WRITE,
+						   bpf_map_mmap_sz(map), PROT_READ | PROT_WRITE,
 						   map->map_extra ? MAP_SHARED | MAP_FIXED : MAP_SHARED,
 						   map->fd, 0);
 				if (map->mmaped == MAP_FAILED) {

tools/net/ynl/ynl-gen-c.py+5−2

         presence = ''
         for i in range(0, len(ref)):
             presence = f"{var}->{'.'.join(ref[:i] + [''])}_present.{ref[i]}"
-            if self.presence_type() == 'bit':
+            # Every layer below last is a nest, so we know it uses bit presence
-                code.append(presence + ' = 1;')
+            # last layer is "self" and may be a complex type
+            if i == len(ref) - 1 and self.presence_type() != 'bit':
+                continue
+            code.append(presence + ' = 1;')
         code += self._setter_lines(ri, member, presence)
         func_name = f"{op_prefix(ri, direction, deref=deref)}_set_{'_'.join(ref)}"

tools/objtool/check.c+1−1

@@ -585,7 +585,7 @@ static int add_dead_ends(struct objtool_file *file) · 584 unmodified lines
585	struct section *rsec;	585	struct section *rsec;
586	struct reloc *reloc;	586	struct reloc *reloc;
587	struct instruction *insn;	587	struct instruction *insn;
588	unsigned long offset;	588	uint64_t offset;
589		589
590	/*	590	/*
591	* Check for manually annotated dead ends.	591	* Check for manually annotated dead ends.

tools/testing/kunit/configs/all_tests.config+3−0

 CONFIG_INET=y
 CONFIG_MPTCP=y
+CONFIG_NETDEVICES=y
+CONFIG_WLAN=y
 CONFIG_CFG80211=y
 CONFIG_MAC80211=y
 CONFIG_WLAN_VENDOR_INTEL=y
 CONFIG_DAMON_PADDR=y
 CONFIG_DEBUG_FS=y
 CONFIG_DAMON_DBGFS=y
+CONFIG_DAMON_DBGFS_DEPRECATED=y
 CONFIG_REGMAP_BUILD=y

tools/testing/selftests/bpf/bpf_arena_common.h+1−1

@@ -32,7 +32,7 @@ · 31 unmodified lines
32	*/	32	*/
33	#endif	33	#endif
34		34
35	#if defined(__BPF_FEATURE_ARENA_CAST) && !defined(BPF_ARENA_FORCE_ASM)	35	#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) && !defined(BPF_ARENA_FORCE_ASM)
36	#define __arena __attribute__((address_space(1)))	36	#define __arena __attribute__((address_space(1)))
37	#define cast_kern(ptr) /* nop for bpf prog. emitted by LLVM */	37	#define cast_kern(ptr) /* nop for bpf prog. emitted by LLVM */
38	#define cast_user(ptr) /* nop for bpf prog. emitted by LLVM */	38	#define cast_user(ptr) /* nop for bpf prog. emitted by LLVM */

tools/testing/selftests/bpf/prog_tests/arena_htab.c+5−3

@@ -3,12 +3,14 @@ · 2 unmodified lines
3	#include <test_progs.h>	3	#include <test_progs.h>
4	#include <sys/mman.h>	4	#include <sys/mman.h>
5	#include <network_helpers.h>	5	#include <network_helpers.h>
6		6	#include <sys/user.h>
		7	#ifndef PAGE_SIZE /* on some archs it comes in sys/user.h */
		8	#include <unistd.h>
		9	#define PAGE_SIZE getpagesize()
		10	#endif
7	#include "arena_htab_asm.skel.h"	11	#include "arena_htab_asm.skel.h"
8	#include "arena_htab.skel.h"	12	#include "arena_htab.skel.h"
9		13
10	#define PAGE_SIZE 4096
11
12	#include "bpf_arena_htab.h"	14	#include "bpf_arena_htab.h"
13		15
14	static void test_arena_htab_common(struct htab *htab)	16	static void test_arena_htab_common(struct htab *htab)

tools/testing/selftests/bpf/prog_tests/arena_list.c+5−2

@@ -3,8 +3,11 @@ · 2 unmodified lines
3	#include <test_progs.h>	3	#include <test_progs.h>
4	#include <sys/mman.h>	4	#include <sys/mman.h>
5	#include <network_helpers.h>	5	#include <network_helpers.h>
6		6	#include <sys/user.h>
7	#define PAGE_SIZE 4096	7	#ifndef PAGE_SIZE /* on some archs it comes in sys/user.h */
		8	#include <unistd.h>
		9	#define PAGE_SIZE getpagesize()
		10	#endif
8		11
9	#include "bpf_arena_list.h"	12	#include "bpf_arena_list.h"
10	#include "arena_list.skel.h"	13	#include "arena_list.skel.h"

tools/testing/selftests/bpf/prog_tests/bloom_filter_map.c+6−0

 /* Copyright (c) 2021 Facebook */
 #include <sys/syscall.h>
+#include <limits.h>
 #include <test_progs.h>
 #include "bloom_filter_map.skel.h"
 	if (!ASSERT_LT(fd, 0, "bpf_map_create bloom filter invalid value size 0"))
 		close(fd);
+	/* Invalid value size: too big */
+	fd = bpf_map_create(BPF_MAP_TYPE_BLOOM_FILTER, NULL, 0, INT32_MAX, 100, NULL);
+	if (!ASSERT_LT(fd, 0, "bpf_map_create bloom filter invalid value too large"))
+		close(fd);
 	/* Invalid max entries size */
 	fd = bpf_map_create(BPF_MAP_TYPE_BLOOM_FILTER, NULL, 0, sizeof(value), 0, NULL);
 	if (!ASSERT_LT(fd, 0, "bpf_map_create bloom filter invalid max entries size"))

tools/testing/selftests/bpf/prog_tests/verifier.c+2−0

 #include "cap_helpers.h"
 #include "verifier_and.skel.h"
 #include "verifier_arena.skel.h"
+#include "verifier_arena_large.skel.h"
 #include "verifier_array_access.skel.h"
 #include "verifier_basic_stack.skel.h"
 #include "verifier_bitfield_write.skel.h"
 void test_verifier_and(void)                  { RUN(verifier_and); }
 void test_verifier_arena(void)                { RUN(verifier_arena); }
+void test_verifier_arena_large(void)          { RUN(verifier_arena_large); }
 void test_verifier_basic_stack(void)          { RUN(verifier_basic_stack); }
 void test_verifier_bitfield_write(void)       { RUN(verifier_bitfield_write); }
 void test_verifier_bounds(void)               { RUN(verifier_bounds); }

tools/testing/selftests/bpf/progs/arena_htab.c+1−1

@@ -22,7 +22,7 @@ int zero = 0; · 21 unmodified lines
22	SEC("syscall")	22	SEC("syscall")
23	int arena_htab_llvm(void *ctx)	23	int arena_htab_llvm(void *ctx)
24	{	24	{
25	#if defined(__BPF_FEATURE_ARENA_CAST) \|\| defined(BPF_ARENA_FORCE_ASM)	25	#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) \|\| defined(BPF_ARENA_FORCE_ASM)
26	struct htab __arena *htab;	26	struct htab __arena *htab;
27	__u64 i;	27	__u64 i;
28		28

tools/testing/selftests/bpf/progs/arena_list.c+5−5

@@ -30,13 +30,13 @@ int list_sum; · 29 unmodified lines
30	int cnt;	30	int cnt;
31	bool skip = false;	31	bool skip = false;
32		32
33	#ifdef __BPF_FEATURE_ARENA_CAST	33	#ifdef __BPF_FEATURE_ADDR_SPACE_CAST
34	long __arena arena_sum;	34	long __arena arena_sum;
35	int __arena test_val = 1;	35	int __arena test_val = 1;
36	struct arena_list_head __arena global_head;	36	struct arena_list_head __arena global_head;
37	#else	37	#else
38	long arena_sum SEC(".arena.1");	38	long arena_sum SEC(".addr_space.1");
39	int test_val SEC(".arena.1");	39	int test_val SEC(".addr_space.1");
40	#endif	40	#endif
41		41
42	int zero;	42	int zero;
@@ -44,7 +44,7 @@ int zero; · 1 unmodified line
44	SEC("syscall")	44	SEC("syscall")
45	int arena_list_add(void *ctx)	45	int arena_list_add(void *ctx)
46	{	46	{
47	#ifdef __BPF_FEATURE_ARENA_CAST	47	#ifdef __BPF_FEATURE_ADDR_SPACE_CAST
48	__u64 i;	48	__u64 i;
49		49
50	list_head = &global_head;	50	list_head = &global_head;
@@ -66,7 +66,7 @@ int arena_list_add(void *ctx) · 15 unmodified lines
66	SEC("syscall")	66	SEC("syscall")
67	int arena_list_del(void *ctx)	67	int arena_list_del(void *ctx)
68	{	68	{
69	#ifdef __BPF_FEATURE_ARENA_CAST	69	#ifdef __BPF_FEATURE_ADDR_SPACE_CAST
70	struct elem __arena *n;	70	struct elem __arena *n;
71	int sum = 0;	71	int sum = 0;
72		72

tools/testing/selftests/bpf/progs/verifier_arena.c+7−3

 	__uint(type, BPF_MAP_TYPE_ARENA);
 	__uint(map_flags, BPF_F_MMAPABLE);
 	__uint(max_entries, 2); /* arena of two pages close to 32-bit boundary*/
-	__ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
+#ifdef __TARGET_ARCH_arm64
+        __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
+#else
+        __ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
+#endif
 } arena SEC(".maps");
 SEC("syscall")
 __success __retval(0)
 int basic_alloc1(void *ctx)
 {
-#if defined(__BPF_FEATURE_ARENA_CAST)
+#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
 	volatile int __arena *page1, *page2, *no_page, *page3;
 	page1 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
 __success __retval(0)
 int basic_alloc2(void *ctx)
 {
-#if defined(__BPF_FEATURE_ARENA_CAST)
+#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
 	volatile char __arena *page1, *page2, *page3, *page4;
 	page1 = bpf_arena_alloc_pages(&arena, NULL, 2, NUMA_NO_NODE, 0);

tools/testing/selftests/bpf/progs/verifier_arena_large.c+68−0

@@ -0,0 +1,68 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
	3
	4	#include <vmlinux.h>
	5	#include <bpf/bpf_helpers.h>
	6	#include <bpf/bpf_tracing.h>
	7	#include "bpf_misc.h"
	8	#include "bpf_experimental.h"
	9	#include "bpf_arena_common.h"
	10
	11	#define ARENA_SIZE (1ull << 32)
	12
	13	struct {
	14	__uint(type, BPF_MAP_TYPE_ARENA);
	15	__uint(map_flags, BPF_F_MMAPABLE);
	16	__uint(max_entries, ARENA_SIZE / PAGE_SIZE);
	17	} arena SEC(".maps");
	18
	19	SEC("syscall")
	20	__success __retval(0)
	21	int big_alloc1(void *ctx)
	22	{
	23	#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
	24	volatile char __arena page1, page2, no_page, page3;
	25	void __arena *base;
	26
	27	page1 = base = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
	28	if (!page1)
	29	return 1;
	30	*page1 = 1;
	31	page2 = bpf_arena_alloc_pages(&arena, base + ARENA_SIZE - PAGE_SIZE,
	32	1, NUMA_NO_NODE, 0);
	33	if (!page2)
	34	return 2;
	35	*page2 = 2;
	36	no_page = bpf_arena_alloc_pages(&arena, base + ARENA_SIZE,
	37	1, NUMA_NO_NODE, 0);
	38	if (no_page)
	39	return 3;
	40	if (*page1 != 1)
	41	return 4;
	42	if (*page2 != 2)
	43	return 5;
	44	bpf_arena_free_pages(&arena, (void __arena *)page1, 1);
	45	if (*page2 != 2)
	46	return 6;
	47	if (page1 != 0) / use-after-free should return 0 */
	48	return 7;
	49	page3 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
	50	if (!page3)
	51	return 8;
	52	*page3 = 3;
	53	if (page1 != page3)
	54	return 9;
	55	if (*page2 != 2)
	56	return 10;
	57	if (*(page1 + PAGE_SIZE) != 0)
	58	return 11;
	59	if (*(page1 - PAGE_SIZE) != 0)
	60	return 12;
	61	if (*(page2 + PAGE_SIZE) != 0)
	62	return 13;
	63	if (*(page2 - PAGE_SIZE) != 0)
	64	return 14;
	65	#endif
	66	return 0;
	67	}
	68	char _license[] SEC("license") = "GPL";

tools/testing/selftests/dmabuf-heaps/config+3−0

@@ -0,0 +1,3 @@
	1	CONFIG_DMABUF_HEAPS=y
	2	CONFIG_DMABUF_HEAPS_SYSTEM=y
	3	CONFIG_DRM_VGEM=y

tools/testing/selftests/drivers/net/netdevsim/settings+1−0

@@ -0,0 +1 @@
		1	timeout=600

tools/testing/selftests/exec/Makefile+2−2

@@ -19,8 +19,8 @@ include ../lib.mk · 18 unmodified lines
19		19
20	$(OUTPUT)/subdir:	20	$(OUTPUT)/subdir:
21	mkdir -p $@	21	mkdir -p $@
22	$(OUTPUT)/script:	22	$(OUTPUT)/script: Makefile
23	echo '#!/bin/sh' > $@	23	echo '#!/bin/bash' > $@
24	echo 'exit $$*' >> $@	24	echo 'exit $$*' >> $@
25	chmod +x $@	25	chmod +x $@
26	$(OUTPUT)/execveat.symlink: $(OUTPUT)/execveat	26	$(OUTPUT)/execveat.symlink: $(OUTPUT)/execveat

tools/testing/selftests/exec/binfmt_script.py+9−1

 NAME_MAX=int(subprocess.check_output(["getconf", "NAME_MAX", "."]))
 test_num=0
+pass_num=0
+fail_num=0
 code='''#!/usr/bin/perl
 print "Executed interpreter! Args:\n";
 # ...
 def test(name, size, good=True, leading="", root="./", target="/perl",
                      fill="A", arg="", newline="\n", hashbang="#!"):
-    global test_num, tests, NAME_MAX
+    global test_num, pass_num, fail_num, tests, NAME_MAX
     test_num += 1
     if test_num > tests:
         raise ValueError("more binfmt_script tests than expected! (want %d, expected %d)"
         if good:
             print("ok %d - binfmt_script %s (successful good exec)"
                   % (test_num, name))
+            pass_num += 1
         else:
             print("not ok %d - binfmt_script %s succeeded when it should have failed"
                   % (test_num, name))
+            fail_num = 1
     else:
         if good:
             print("not ok %d - binfmt_script %s failed when it should have succeeded (rc:%d)"
                   % (test_num, name, proc.returncode))
+            fail_num = 1
         else:
             print("ok %d - binfmt_script %s (correctly failed bad exec)"
                   % (test_num, name))
+            pass_num += 1
     # Clean up crazy binaries
     os.unlink(script)
 test(name="two-under-leading",   size=int(SIZE/2), leading=" ")
 test(name="two-under-lead-trunc-arg", size=int(SIZE/2), leading=" ", arg=" ")
+print("# Totals: pass:%d fail:%d xfail:0 xpass:0 skip:0 error:0" % (pass_num, fail_num))
 if test_num != tests:
     raise ValueError("fewer binfmt_script tests than expected! (ran %d, expected %d"
                      % (test_num, tests))

tools/testing/selftests/exec/execveat.c+7−5

 	if (child == 0) {
 		/* Child: do execveat(). */
 		rc = execveat_(fd, path, argv, envp, flags);
-		ksft_print_msg("execveat() failed, rc=%d errno=%d (%s)\n",
+		ksft_print_msg("child execveat() failed, rc=%d errno=%d (%s)\n",
 			       rc, errno, strerror(errno));
-		ksft_test_result_fail("%s\n", test_name);
+		exit(errno);
-		exit(1);  /* should not reach here */
 	}
 	/* Parent: wait for & check child's exit status. */
 	rc = waitpid(child, &status, 0);
 	 * "If the command name is found, but it is not an executable utility,
 	 * the exit status shall be 126."), so allow either.
 	 */
-	if (is_script)
+	if (is_script) {
+		ksft_print_msg("Invoke script via root_dfd and relative filename\n");
 		fail += check_execveat_invoked_rc(root_dfd, longpath + 1, 0,
 						  127, 126);
-	else
+	} else {
+		ksft_print_msg("Invoke exec via root_dfd and relative filename\n");
 		fail += check_execveat(root_dfd, longpath + 1, 0);
+	}
 	return fail;
 }

tools/testing/selftests/exec/load_address.c+15−19

 #include <link.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include "../kselftest.h"
 struct Statistics {
 	unsigned long long load_address;
 	unsigned long long misalign;
 	int ret;
+	ksft_print_header();
+	ksft_set_plan(1);
 	ret = dl_iterate_phdr(ExtractStatistics, &extracted);
-	if (ret != 1) {
+	if (ret != 1)
-		fprintf(stderr, "FAILED\n");
+		ksft_exit_fail_msg("FAILED: dl_iterate_phdr\n");
-		return 1;
-	}
-	if (extracted.alignment == 0) {
+	if (extracted.alignment == 0)
-		fprintf(stderr, "No alignment found\n");
+		ksft_exit_fail_msg("FAILED: No alignment found\n");
-		return 1;
+	else if (extracted.alignment & (extracted.alignment - 1))
-	} else if (extracted.alignment & (extracted.alignment - 1)) {
+		ksft_exit_fail_msg("FAILED: Alignment is not a power of 2\n");
-		fprintf(stderr, "Alignment is not a power of 2\n");
-		return 1;
-	}
 	misalign = extracted.load_address & (extracted.alignment - 1);
-	if (misalign) {
+	if (misalign)
-		printf("alignment = %llu, load_address = %llu\n",
+		ksft_exit_fail_msg("FAILED: alignment = %llu, load_address = %llu\n",
-			extracted.alignment, extracted.load_address);
+				   extracted.alignment, extracted.load_address);
-		fprintf(stderr, "FAILED\n");
-		return 1;
-	}
-	fprintf(stderr, "PASS\n");
+	ksft_test_result_pass("Completed\n");
-	return 0;
+	ksft_finished();
 }

tools/testing/selftests/exec/recursion-depth.c+26−27

@@ -23,45 +23,44 @@ · 22 unmodified lines
23	#include <fcntl.h>	23	#include <fcntl.h>
24	#include <sys/mount.h>	24	#include <sys/mount.h>
25	#include <unistd.h>	25	#include <unistd.h>
		26	#include "../kselftest.h"
26		27
27	int main(void)	28	int main(void)
28	{	29	{
		30	int fd, rv;
		31
		32	ksft_print_header();
		33	ksft_set_plan(1);
		34
29	if (unshare(CLONE_NEWNS) == -1) {	35	if (unshare(CLONE_NEWNS) == -1) {
30	if (errno == ENOSYS \|\| errno == EPERM) {	36	if (errno == ENOSYS \|\| errno == EPERM) {
31	fprintf(stderr, "error: unshare, errno %d\n", errno);	37	ksft_test_result_skip("error: unshare, errno %d\n", errno);
32	return 4;	38	ksft_finished();
33	}	39	}
34	fprintf(stderr, "error: unshare, errno %d\n", errno);	40	ksft_exit_fail_msg("error: unshare, errno %d\n", errno);
35	return 1;
36	}
37	if (mount(NULL, "/", NULL, MS_PRIVATE\|MS_REC, NULL) == -1) {
38	fprintf(stderr, "error: mount '/', errno %d\n", errno);
39	return 1;
40	}	41	}
		42
		43	if (mount(NULL, "/", NULL, MS_PRIVATE \| MS_REC, NULL) == -1)
		44	ksft_exit_fail_msg("error: mount '/', errno %d\n", errno);
		45
41	/* Require "exec" filesystem. */	46	/* Require "exec" filesystem. */
42	if (mount(NULL, "/tmp", "ramfs", 0, NULL) == -1) {	47	if (mount(NULL, "/tmp", "ramfs", 0, NULL) == -1)
43	fprintf(stderr, "error: mount ramfs, errno %d\n", errno);	48	ksft_exit_fail_msg("error: mount ramfs, errno %d\n", errno);
44	return 1;
45	}
46		49
47	#define FILENAME "/tmp/1"	50	#define FILENAME "/tmp/1"
48		51
49	int fd = creat(FILENAME, 0700);	52	fd = creat(FILENAME, 0700);
50	if (fd == -1) {	53	if (fd == -1)
51	fprintf(stderr, "error: creat, errno %d\n", errno);	54	ksft_exit_fail_msg("error: creat, errno %d\n", errno);
52	return 1;	55
53	}
54	#define S "#!" FILENAME "\n"	56	#define S "#!" FILENAME "\n"
55	if (write(fd, S, strlen(S)) != strlen(S)) {	57	if (write(fd, S, strlen(S)) != strlen(S))
56	fprintf(stderr, "error: write, errno %d\n", errno);	58	ksft_exit_fail_msg("error: write, errno %d\n", errno);
57	return 1;	59
58	}
59	close(fd);	60	close(fd);
60		61
61	int rv = execve(FILENAME, NULL, NULL);	62	rv = execve(FILENAME, NULL, NULL);
62	if (rv == -1 && errno == ELOOP) {	63	ksft_test_result(rv == -1 && errno == ELOOP,
63	return 0;	64	"execve failed as expected (ret %d, errno %d)\n", rv, errno);
64	}	65	ksft_finished();
65	fprintf(stderr, "error: execve, rv %d, errno %d\n", rv, errno);
66	return 1;
67	}	66	}

tools/testing/selftests/ftrace/test.d/filter/event-filter-function.tc+1−1

@@ -24,7 +24,7 @@ echo 0 > events/enable · 23 unmodified lines
24	echo "Get the most frequently calling function"	24	echo "Get the most frequently calling function"
25	sample_events	25	sample_events
26		26
27	target_func=`cut -d: -f3 trace \| sed 's/call_site=$[^+]$+0x./\1/' \| sort \| uniq -c \| sort \| tail -n 1 \| sed 's/^[ 0-9]*//'`	27	target_func=`cat trace \| grep -o 'call_site=$[^+]$' \| sed 's/call_site=//' \| sort \| uniq -c \| sort \| tail -n 1 \| sed 's/^[ 0-9]//'`
28	if [ -z "$target_func" ]; then	28	if [ -z "$target_func" ]; then
29	exit_fail	29	exit_fail
30	fi	30	fi

tools/testing/selftests/mm/gup_test.c+1−1

@@ -203,7 +203,7 @@ int main(int argc, char **argv) · 202 unmodified lines
203	ksft_print_header();	203	ksft_print_header();
204	ksft_set_plan(nthreads);	204	ksft_set_plan(nthreads);
205		205
206	filed = open(file, O_RDWR\|O_CREAT);	206	filed = open(file, O_RDWR\|O_CREAT, 0664);
207	if (filed < 0)	207	if (filed < 0)
208	ksft_exit_fail_msg("Unable to open %s: %s\n", file, strerror(errno));	208	ksft_exit_fail_msg("Unable to open %s: %s\n", file, strerror(errno));
209		209

tools/testing/selftests/mm/protection_keys.c+5−1

 	shadow_pkey_reg = __read_pkey_reg();
 }
+pid_t parent_pid;
 void restore_settings_atexit(void)
 {
-	cat_into_file(buf, "/proc/sys/vm/nr_hugepages");
+	if (parent_pid == getpid())
+		cat_into_file(buf, "/proc/sys/vm/nr_hugepages");
 }
 void save_settings(void)
 		exit(__LINE__);
 	}
+	parent_pid = getpid();
 	atexit(restore_settings_atexit);
 	close(fd);
 }

tools/testing/selftests/mm/soft-dirty.c+1−1

@@ -137,7 +137,7 @@ static void test_mprotect(int pagemap_fd, int pagesize, bool anon) · 136 unmodified lines
137	if (!map)	137	if (!map)
138	ksft_exit_fail_msg("anon mmap failed\n");	138	ksft_exit_fail_msg("anon mmap failed\n");
139	} else {	139	} else {
140	test_fd = open(fname, O_RDWR \| O_CREAT);	140	test_fd = open(fname, O_RDWR \| O_CREAT, 0664);
141	if (test_fd < 0) {	141	if (test_fd < 0) {
142	ksft_test_result_skip("Test %s open() file failed\n", __func__);	142	ksft_test_result_skip("Test %s open() file failed\n", __func__);
143	return;	143	return;

tools/testing/selftests/mm/split_huge_page_test.c+1−1

@@ -223,7 +223,7 @@ void split_file_backed_thp(void) · 222 unmodified lines
223	ksft_exit_fail_msg("Fail to create file-backed THP split testing file\n");	223	ksft_exit_fail_msg("Fail to create file-backed THP split testing file\n");
224	}	224	}
225		225
226	fd = open(testfile, O_CREAT\|O_WRONLY);	226	fd = open(testfile, O_CREAT\|O_WRONLY, 0664);
227	if (fd == -1) {	227	if (fd == -1) {
228	ksft_perror("Cannot open testing file");	228	ksft_perror("Cannot open testing file");
229	goto cleanup;	229	goto cleanup;

tools/testing/selftests/mm/uffd-common.c+3−0

 unsigned long long *count_verify;
 uffd_test_ops_t *uffd_test_ops;
 uffd_test_case_ops_t *uffd_test_case_ops;
+atomic_bool ready_for_fork;
 static int uffd_mem_fd_create(off_t mem_size, bool hugetlb)
 {
 	pollfd[1].fd = pipefd[cpu*2];
 	pollfd[1].events = POLLIN;
+	ready_for_fork = true;
 	for (;;) {
 		ret = poll(pollfd, 2, -1);
 		if (ret <= 0) {

tools/testing/selftests/mm/uffd-common.h+2−0

 #include <inttypes.h>
 #include <stdint.h>
 #include <sys/random.h>
+#include <stdatomic.h>
 #include "../kselftest.h"
 #include "vm_util.h"
 extern bool test_uffdio_wp;
 extern unsigned long long *count_verify;
 extern volatile bool test_uffdio_copy_eexist;
+extern atomic_bool ready_for_fork;
 extern uffd_test_ops_t anon_uffd_test_ops;
 extern uffd_test_ops_t shmem_uffd_test_ops;

tools/testing/selftests/mm/uffd-unit-tests.c+12−1

 	char c;
 	struct uffd_args args = { 0 };
+	ready_for_fork = false;
 	fcntl(uffd, F_SETFL, uffd_flags | O_NONBLOCK);
 	if (uffd_register(uffd, area_dst, nr_pages * page_size,
 	if (pthread_create(&uffd_mon, NULL, uffd_poll_thread, &args))
 		err("uffd_poll_thread create");
+	while (!ready_for_fork)
+		; /* Wait for the poll_thread to start executing before forking */
 	pid = fork();
 	if (pid < 0)
 		err("fork");
 	char c;
 	struct uffd_args args = { 0 };
+	ready_for_fork = false;
 	fcntl(uffd, F_SETFL, uffd_flags | O_NONBLOCK);
 	if (uffd_register(uffd, area_dst, nr_pages * page_size,
 			  true, wp, false))
 	if (pthread_create(&uffd_mon, NULL, uffd_poll_thread, &args))
 		err("uffd_poll_thread create");
+	while (!ready_for_fork)
+		; /* Wait for the poll_thread to start executing before forking */
 	pid = fork();
 	if (pid < 0)
 		err("fork");
 		.uffd_fn = uffd_sigbus_wp_test,
 		.mem_targets = MEM_ALL,
 		.uffd_feature_required = UFFD_FEATURE_SIGBUS |
-		UFFD_FEATURE_EVENT_FORK | UFFD_FEATURE_PAGEFAULT_FLAG_WP,
+		UFFD_FEATURE_EVENT_FORK | UFFD_FEATURE_PAGEFAULT_FLAG_WP |
+		UFFD_FEATURE_WP_HUGETLBFS_SHMEM,
 	},
 	{
 		.name = "events",

tools/testing/selftests/net/test_vxlan_mdb.sh+128−77

 	local plen=$1; shift
 	local enc_ethtype=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local src=$1; shift
 	local mz=$1; shift
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent dst $vtep2_ip src_vni 10020"
 	run_cmd "tc -n $ns2 filter replace dev vx0 ingress pref 1 handle 101 proto all flower enc_dst_ip $vtep1_ip action pass"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Destination IP - match"
-	run_cmd "ip netns exec $ns1 $mz br0.20 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.20 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Destination IP - no match"
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent dst $vtep1_ip dst_port 1111 src_vni 10020"
 	run_cmd "tc -n $ns2 filter replace dev veth0 ingress pref 1 handle 101 proto $enc_ethtype flower ip_proto udp dst_port 4789 action pass"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev veth0 ingress" 101 1
 	log_test $? 0 "Default destination port - match"
-	run_cmd "ip netns exec $ns1 $mz br0.20 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.20 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev veth0 ingress" 101 1
 	log_test $? 0 "Default destination port - no match"
 	run_cmd "tc -n $ns2 filter replace dev veth0 ingress pref 1 handle 101 proto $enc_ethtype flower ip_proto udp dst_port 1111 action pass"
-	run_cmd "ip netns exec $ns1 $mz br0.20 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.20 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev veth0 ingress" 101 1
 	log_test $? 0 "Non-default destination port - match"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev veth0 ingress" 101 1
 	log_test $? 0 "Non-default destination port - no match"
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent dst $vtep1_ip src_vni 10020"
 	run_cmd "tc -n $ns2 filter replace dev vx0 ingress pref 1 handle 101 proto all flower enc_key_id 10010 action pass"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Default destination VNI - match"
-	run_cmd "ip netns exec $ns1 $mz br0.20 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.20 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Default destination VNI - no match"
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent dst $vtep1_ip vni 10010 src_vni 10020"
 	run_cmd "tc -n $ns2 filter replace dev vx0 ingress pref 1 handle 101 proto all flower enc_key_id 10020 action pass"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Non-default destination VNI - match"
-	run_cmd "ip netns exec $ns1 $mz br0.20 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.20 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Non-default destination VNI - no match"
 	local plen=32
 	local enc_ethtype="ip"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "------------------------------------------------------------------"
 	encap_params_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $enc_ethtype \
-		$grp $src "mausezahn"
+		$grp $grp_dmac $src "mausezahn"
 }
 encap_params_ipv6_ipv4()
 	local plen=32
 	local enc_ethtype="ip"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "------------------------------------------------------------------"
 	encap_params_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $enc_ethtype \
-		$grp $src "mausezahn -6"
+		$grp $grp_dmac $src "mausezahn -6"
 }
 encap_params_ipv4_ipv6()
 	local plen=128
 	local enc_ethtype="ipv6"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "------------------------------------------------------------------"
 	encap_params_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $enc_ethtype \
-		$grp $src "mausezahn"
+		$grp $grp_dmac $src "mausezahn"
 }
 encap_params_ipv6_ipv6()
 	local plen=128
 	local enc_ethtype="ipv6"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "------------------------------------------------------------------"
 	encap_params_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $enc_ethtype \
-		$grp $src "mausezahn -6"
+		$grp $grp_dmac $src "mausezahn -6"
 }
 starg_exclude_ir_common()
 	local vtep2_ip=$1; shift
 	local plen=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local valid_src=$1; shift
 	local invalid_src=$1; shift
 	local mz=$1; shift
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent filter_mode exclude source_list $invalid_src dst $vtep2_ip src_vni 10010"
 	# Check that invalid source is not forwarded to any VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 0
 	log_test $? 0 "Block excluded source - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 0
 	log_test $? 0 "Block excluded source - second VTEP"
 	# Check that valid source is forwarded to both VTEPs.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Forward valid source - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	run_cmd "bridge -n $ns1 mdb del dev vx0 port vx0 grp $grp dst $vtep2_ip src_vni 10010"
 	# Check that invalid source is not forwarded to any VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Block excluded source after removal - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	log_test $? 0 "Block excluded source after removal - second VTEP"
 	# Check that valid source is forwarded to the remaining VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 2
 	log_test $? 0 "Forward valid source after removal - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	local vtep2_ip=198.51.100.200
 	local plen=32
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "-------------------------------------------------------------"
 	starg_exclude_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn"
+		$grp_dmac $valid_src $invalid_src "mausezahn"
 }
 starg_exclude_ir_ipv6_ipv4()
 	local vtep2_ip=198.51.100.200
 	local plen=32
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "-------------------------------------------------------------"
 	starg_exclude_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn -6"
+		$grp_dmac $valid_src $invalid_src "mausezahn -6"
 }
 starg_exclude_ir_ipv4_ipv6()
 	local vtep2_ip=2001:db8:2000::1
 	local plen=128
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "-------------------------------------------------------------"
 	starg_exclude_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn"
+		$grp_dmac $valid_src $invalid_src "mausezahn"
 }
 starg_exclude_ir_ipv6_ipv6()
 	local vtep2_ip=2001:db8:2000::1
 	local plen=128
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "-------------------------------------------------------------"
 	starg_exclude_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn -6"
+		$grp_dmac $valid_src $invalid_src "mausezahn -6"
 }
 starg_include_ir_common()
 	local vtep2_ip=$1; shift
 	local plen=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local valid_src=$1; shift
 	local invalid_src=$1; shift
 	local mz=$1; shift
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent filter_mode include source_list $valid_src dst $vtep2_ip src_vni 10010"
 	# Check that invalid source is not forwarded to any VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 0
 	log_test $? 0 "Block excluded source - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 0
 	log_test $? 0 "Block excluded source - second VTEP"
 	# Check that valid source is forwarded to both VTEPs.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Forward valid source - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	run_cmd "bridge -n $ns1 mdb del dev vx0 port vx0 grp $grp dst $vtep2_ip src_vni 10010"
 	# Check that invalid source is not forwarded to any VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Block excluded source after removal - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	log_test $? 0 "Block excluded source after removal - second VTEP"
 	# Check that valid source is forwarded to the remaining VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 2
 	log_test $? 0 "Forward valid source after removal - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	local vtep2_ip=198.51.100.200
 	local plen=32
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "-------------------------------------------------------------"
 	starg_include_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn"
+		$grp_dmac $valid_src $invalid_src "mausezahn"
 }
 starg_include_ir_ipv6_ipv4()
 	local vtep2_ip=198.51.100.200
 	local plen=32
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "-------------------------------------------------------------"
 	starg_include_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn -6"
+		$grp_dmac $valid_src $invalid_src "mausezahn -6"
 }
 starg_include_ir_ipv4_ipv6()
 	local vtep2_ip=2001:db8:2000::1
 	local plen=128
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "-------------------------------------------------------------"
 	starg_include_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn"
+		$grp_dmac $valid_src $invalid_src "mausezahn"
 }
 starg_include_ir_ipv6_ipv6()
 	local vtep2_ip=2001:db8:2000::1
 	local plen=128
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "-------------------------------------------------------------"
 	starg_include_ir_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $grp \
-		$valid_src $invalid_src "mausezahn -6"
+		$grp_dmac $valid_src $invalid_src "mausezahn -6"
 }
 starg_exclude_p2mp_common()
 	local mcast_grp=$1; shift
 	local plen=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local valid_src=$1; shift
 	local invalid_src=$1; shift
 	local mz=$1; shift
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent filter_mode exclude source_list $invalid_src dst $mcast_grp src_vni 10010 via veth0"
 	# Check that invalid source is not forwarded.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 0
 	log_test $? 0 "Block excluded source"
 	# Check that valid source is forwarded.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Forward valid source"
 	run_cmd "ip -n $ns2 address del $mcast_grp/$plen dev veth0"
 	# Check that valid source is not received anymore.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Receive of valid source after removal from group"
 }
 	local mcast_grp=238.1.1.1
 	local plen=32
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "Data path: (*, G) EXCLUDE - P2MP - IPv4 overlay / IPv4 underlay"
 	echo "---------------------------------------------------------------"
-	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn"
 }
 	local mcast_grp=238.1.1.1
 	local plen=32
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "Data path: (*, G) EXCLUDE - P2MP - IPv6 overlay / IPv4 underlay"
 	echo "---------------------------------------------------------------"
-	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn -6"
 }
 	local mcast_grp=ff0e::2
 	local plen=128
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "Data path: (*, G) EXCLUDE - P2MP - IPv4 overlay / IPv6 underlay"
 	echo "---------------------------------------------------------------"
-	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn"
 }
 	local mcast_grp=ff0e::2
 	local plen=128
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "Data path: (*, G) EXCLUDE - P2MP - IPv6 overlay / IPv6 underlay"
 	echo "---------------------------------------------------------------"
-	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_exclude_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn -6"
 }
 	local mcast_grp=$1; shift
 	local plen=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local valid_src=$1; shift
 	local invalid_src=$1; shift
 	local mz=$1; shift
 	run_cmd "bridge -n $ns1 mdb replace dev vx0 port vx0 grp $grp permanent filter_mode include source_list $valid_src dst $mcast_grp src_vni 10010 via veth0"
 	# Check that invalid source is not forwarded.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $invalid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 0
 	log_test $? 0 "Block excluded source"
 	# Check that valid source is forwarded.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Forward valid source"
 	run_cmd "ip -n $ns2 address del $mcast_grp/$plen dev veth0"
 	# Check that valid source is not received anymore.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $valid_src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Receive of valid source after removal from group"
 }
 	local mcast_grp=238.1.1.1
 	local plen=32
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "Data path: (*, G) INCLUDE - P2MP - IPv4 overlay / IPv4 underlay"
 	echo "---------------------------------------------------------------"
-	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn"
 }
 	local mcast_grp=238.1.1.1
 	local plen=32
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "Data path: (*, G) INCLUDE - P2MP - IPv6 overlay / IPv4 underlay"
 	echo "---------------------------------------------------------------"
-	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn -6"
 }
 	local mcast_grp=ff0e::2
 	local plen=128
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local valid_src=192.0.2.129
 	local invalid_src=192.0.2.145
 	echo "Data path: (*, G) INCLUDE - P2MP - IPv4 overlay / IPv6 underlay"
 	echo "---------------------------------------------------------------"
-	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn"
 }
 	local mcast_grp=ff0e::2
 	local plen=128
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local valid_src=2001:db8:100::1
 	local invalid_src=2001:db8:200::1
 	echo "Data path: (*, G) INCLUDE - P2MP - IPv6 overlay / IPv6 underlay"
 	echo "---------------------------------------------------------------"
-	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp \
+	starg_include_p2mp_common $ns1 $ns2 $mcast_grp $plen $grp $grp_dmac \
 		$valid_src $invalid_src "mausezahn -6"
 }
 	local plen=$1; shift
 	local proto=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local src=$1; shift
 	local mz=$1; shift
 	# Make sure that packets sent from the first VTEP over VLAN 10 are
 	# received by the SVI corresponding to the L3VNI (14000 / VLAN 4000) on
 	# the second VTEP, since it is configured as PVID.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev br0.4000 ingress" 101 1
 	log_test $? 0 "Egress VNI translation - PVID configured"
 	# Remove PVID flag from VLAN 4000 on the second VTEP and make sure
 	# packets are no longer received by the SVI interface.
 	run_cmd "bridge -n $ns2 vlan add vid 4000 dev vx0"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev br0.4000 ingress" 101 1
 	log_test $? 0 "Egress VNI translation - no PVID configured"
 	# Reconfigure the PVID and make sure packets are received again.
 	run_cmd "bridge -n $ns2 vlan add vid 4000 dev vx0 pvid"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev br0.4000 ingress" 101 2
 	log_test $? 0 "Egress VNI translation - PVID reconfigured"
 }
 	local plen=32
 	local proto="ipv4"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "----------------------------------------------------------------"
 	egress_vni_translation_common $ns1 $ns2 $mcast_grp $plen $proto $grp \
-		$src "mausezahn"
+		$grp_dmac $src "mausezahn"
 }
 egress_vni_translation_ipv6_ipv4()
 	local plen=32
 	local proto="ipv6"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "----------------------------------------------------------------"
 	egress_vni_translation_common $ns1 $ns2 $mcast_grp $plen $proto $grp \
-		$src "mausezahn -6"
+		$grp_dmac $src "mausezahn -6"
 }
 egress_vni_translation_ipv4_ipv6()
 	local plen=128
 	local proto="ipv4"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "----------------------------------------------------------------"
 	egress_vni_translation_common $ns1 $ns2 $mcast_grp $plen $proto $grp \
-		$src "mausezahn"
+		$grp_dmac $src "mausezahn"
 }
 egress_vni_translation_ipv6_ipv6()
 	local plen=128
 	local proto="ipv6"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "----------------------------------------------------------------"
 	egress_vni_translation_common $ns1 $ns2 $mcast_grp $plen $proto $grp \
-		$src "mausezahn -6"
+		$grp_dmac $src "mausezahn -6"
 }
 all_zeros_mdb_common()
 	local vtep4_ip=$1; shift
 	local plen=$1; shift
 	local ipv4_grp=239.1.1.1
+	local ipv4_grp_dmac=01:00:5e:01:01:01
 	local ipv4_unreg_grp=239.2.2.2
+	local ipv4_unreg_grp_dmac=01:00:5e:02:02:02
 	local ipv4_ll_grp=224.0.0.100
+	local ipv4_ll_grp_dmac=01:00:5e:00:00:64
 	local ipv4_src=192.0.2.129
 	local ipv6_grp=ff0e::1
+	local ipv6_grp_dmac=33:33:00:00:00:01
 	local ipv6_unreg_grp=ff0e::2
+	local ipv6_unreg_grp_dmac=33:33:00:00:00:02
 	local ipv6_ll_grp=ff02::1
+	local ipv6_ll_grp_dmac=33:33:00:00:00:01
 	local ipv6_src=2001:db8:100::1
 	# Install all-zeros (catchall) MDB entries for IPv4 and IPv6 traffic
 	# Send registered IPv4 multicast and make sure it only arrives to the
 	# first VTEP.
-	run_cmd "ip netns exec $ns1 mausezahn br0.10 -A $ipv4_src -B $ipv4_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn br0.10 -a own -b $ipv4_grp_dmac -A $ipv4_src -B $ipv4_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "Registered IPv4 multicast - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 0
 	# Send unregistered IPv4 multicast that is not link-local and make sure
 	# it arrives to the first and second VTEPs.
-	run_cmd "ip netns exec $ns1 mausezahn br0.10 -A $ipv4_src -B $ipv4_unreg_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn br0.10 -a own -b $ipv4_unreg_grp_dmac -A $ipv4_src -B $ipv4_unreg_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 2
 	log_test $? 0 "Unregistered IPv4 multicast - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	# Send IPv4 link-local multicast traffic and make sure it does not
 	# arrive to any VTEP.
-	run_cmd "ip netns exec $ns1 mausezahn br0.10 -A $ipv4_src -B $ipv4_ll_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn br0.10 -a own -b $ipv4_ll_grp_dmac -A $ipv4_src -B $ipv4_ll_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 2
 	log_test $? 0 "Link-local IPv4 multicast - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 1
 	# Send registered IPv6 multicast and make sure it only arrives to the
 	# third VTEP.
-	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -A $ipv6_src -B $ipv6_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -a own -b $ipv6_grp_dmac -A $ipv6_src -B $ipv6_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 103 1
 	log_test $? 0 "Registered IPv6 multicast - third VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 104 0
 	# Send unregistered IPv6 multicast that is not link-local and make sure
 	# it arrives to the third and fourth VTEPs.
-	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -A $ipv6_src -B $ipv6_unreg_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -a own -b $ipv6_unreg_grp_dmac -A $ipv6_src -B $ipv6_unreg_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 103 2
 	log_test $? 0 "Unregistered IPv6 multicast - third VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 104 1
 	# Send IPv6 link-local multicast traffic and make sure it does not
 	# arrive to any VTEP.
-	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -A $ipv6_src -B $ipv6_ll_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 mausezahn -6 br0.10 -a own -b $ipv6_ll_grp_dmac -A $ipv6_src -B $ipv6_ll_grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 103 2
 	log_test $? 0 "Link-local IPv6 multicast - third VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 104 1
 	local plen=$1; shift
 	local proto=$1; shift
 	local grp=$1; shift
+	local grp_dmac=$1; shift
 	local src=$1; shift
 	local mz=$1; shift
 	# Send IP multicast traffic and make sure it is forwarded by the MDB
 	# and only arrives to the first VTEP.
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "IP multicast - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 0
 	# Remove the MDB entry and make sure that IP multicast is now forwarded
 	# by the FDB to the second VTEP.
 	run_cmd "bridge -n $ns1 mdb del dev vx0 port vx0 grp $grp dst $vtep1_ip src_vni 10010"
-	run_cmd "ip netns exec $ns1 $mz br0.10 -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
+	run_cmd "ip netns exec $ns1 $mz br0.10 -a own -b $grp_dmac -A $src -B $grp -t udp sp=12345,dp=54321 -p 100 -c 1 -q"
 	tc_check_packets "$ns2" "dev vx0 ingress" 101 1
 	log_test $? 0 "IP multicast after removal - first VTEP"
 	tc_check_packets "$ns2" "dev vx0 ingress" 102 2
 	local plen=32
 	local proto="ipv4"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "Data path: MDB with FDB - IPv4 overlay / IPv4 underlay"
 	echo "------------------------------------------------------"
-	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp $src \
+	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp \
-		"mausezahn"
+		$grp_dmac $src "mausezahn"
 }
 mdb_fdb_ipv6_ipv4()
 	local plen=32
 	local proto="ipv6"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "Data path: MDB with FDB - IPv6 overlay / IPv4 underlay"
 	echo "------------------------------------------------------"
-	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp $src \
+	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp \
-		"mausezahn -6"
+		$grp_dmac $src "mausezahn -6"
 }
 mdb_fdb_ipv4_ipv6()
 	local plen=128
 	local proto="ipv4"
 	local grp=239.1.1.1
+	local grp_dmac=01:00:5e:01:01:01
 	local src=192.0.2.129
 	echo
 	echo "Data path: MDB with FDB - IPv4 overlay / IPv6 underlay"
 	echo "------------------------------------------------------"
-	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp $src \
+	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp \
-		"mausezahn"
+		$grp_dmac $src "mausezahn"
 }
 mdb_fdb_ipv6_ipv6()
 	local plen=128
 	local proto="ipv6"
 	local grp=ff0e::1
+	local grp_dmac=33:33:00:00:00:01
 	local src=2001:db8:100::1
 	echo
 	echo "Data path: MDB with FDB - IPv6 overlay / IPv6 underlay"
 	echo "------------------------------------------------------"
-	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp $src \
+	mdb_fdb_common $ns1 $ns2 $vtep1_ip $vtep2_ip $plen $proto $grp \
-		"mausezahn -6"
+		$grp_dmac $src "mausezahn -6"
 }
 mdb_grp1_loop()
 	local vtep1_ip=$1; shift
 	local vtep2_ip=$1; shift
 	local grp1=$1; shift
+	local grp1_dmac=$1; shift
 	local grp2=$1; shift
+	local grp2_dmac=$1; shift
 	local src=$1; shift
 	local mz=$1; shift
 	local pid1
 	pid1=$!
 	mdb_grp2_loop $ns1 $vtep1_ip $vtep2_ip $grp2 &
 	pid2=$!
-	ip netns exec $ns1 $mz br0.10 -A $src -B $grp1 -t udp sp=12345,dp=54321 -p 100 -c 0 -q &
+	ip netns exec $ns1 $mz br0.10 -a own -b $grp1_dmac -A $src -B $grp1 -t udp sp=12345,dp=54321 -p 100 -c 0 -q &
 	pid3=$!
-	ip netns exec $ns1 $mz br0.10 -A $src -B $grp2 -t udp sp=12345,dp=54321 -p 100 -c 0 -q &
+	ip netns exec $ns1 $mz br0.10 -a own -b $grp2_dmac -A $src -B $grp2 -t udp sp=12345,dp=54321 -p 100 -c 0 -q &
 	pid4=$!
 	sleep 30
 	local vtep1_ip=198.51.100.100
 	local vtep2_ip=198.51.100.200
 	local grp1=239.1.1.1
+	local grp1_dmac=01:00:5e:01:01:01
 	local grp2=239.2.2.2
+	local grp2_dmac=01:00:5e:02:02:02
 	local src=192.0.2.129
 	echo
 	echo "Data path: MDB torture test - IPv4 overlay / IPv4 underlay"
 	echo "----------------------------------------------------------"
-	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp2 $src \
+	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp1_dmac $grp2 \
-		"mausezahn"
+		$grp2_dmac $src "mausezahn"
 }
 mdb_torture_ipv6_ipv4()
 	local vtep1_ip=198.51.100.100
 	local vtep2_ip=198.51.100.200
 	local grp1=ff0e::1
+	local grp1_dmac=33:33:00:00:00:01
 	local grp2=ff0e::2
+	local grp2_dmac=33:33:00:00:00:02
 	local src=2001:db8:100::1
 	echo
 	echo "Data path: MDB torture test - IPv6 overlay / IPv4 underlay"
 	echo "----------------------------------------------------------"
-	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp2 $src \
+	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp1_dmac $grp2 \
-		"mausezahn -6"
+		$grp2_dmac $src "mausezahn -6"
 }
 mdb_torture_ipv4_ipv6()
 	local vtep1_ip=2001:db8:1000::1
 	local vtep2_ip=2001:db8:2000::1
 	local grp1=239.1.1.1
+	local grp1_dmac=01:00:5e:01:01:01
 	local grp2=239.2.2.2
+	local grp2_dmac=01:00:5e:02:02:02
 	local src=192.0.2.129
 	echo
 	echo "Data path: MDB torture test - IPv4 overlay / IPv6 underlay"
 	echo "----------------------------------------------------------"
-	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp2 $src \
+	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp1_dmac $grp2 \
-		"mausezahn"
+		$grp2_dmac $src "mausezahn"
 }
 mdb_torture_ipv6_ipv6()
 	local vtep1_ip=2001:db8:1000::1
 	local vtep2_ip=2001:db8:2000::1
 	local grp1=ff0e::1
+	local grp1_dmac=33:33:00:00:00:01
 	local grp2=ff0e::2
+	local grp2_dmac=33:33:00:00:00:02
 	local src=2001:db8:100::1
 	echo
 	echo "Data path: MDB torture test - IPv6 overlay / IPv6 underlay"
 	echo "----------------------------------------------------------"
-	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp2 $src \
+	mdb_torture_common $ns1 $vtep1_ip $vtep2_ip $grp1 $grp1_dmac $grp2 \
-		"mausezahn -6"
+		$grp2_dmac $src "mausezahn -6"
 }
 ################################################################################

tools/testing/selftests/net/tls.c+34−0

@@ -1615,6 +1615,40 @@ TEST_F(tls, getsockopt) · 1614 unmodified lines
1615	EXPECT_EQ(errno, EINVAL);	1615	EXPECT_EQ(errno, EINVAL);
1616	}	1616	}
1617		1617
		1618	TEST_F(tls, recv_efault)
		1619	{
		1620	char *rec1 = "1111111111";
		1621	char *rec2 = "2222222222";
		1622	struct msghdr hdr = {};
		1623	struct iovec iov[2];
		1624	char recv_mem[12];
		1625	int ret;
		1626
		1627	if (self->notls)
		1628	SKIP(return, "no TLS support");
		1629
		1630	EXPECT_EQ(send(self->fd, rec1, 10, 0), 10);
		1631	EXPECT_EQ(send(self->fd, rec2, 10, 0), 10);
		1632
		1633	iov[0].iov_base = recv_mem;
		1634	iov[0].iov_len = sizeof(recv_mem);
		1635	iov[1].iov_base = NULL; /* broken iov to make process_rx_list fail */
		1636	iov[1].iov_len = 1;
		1637
		1638	hdr.msg_iovlen = 2;
		1639	hdr.msg_iov = iov;
		1640
		1641	EXPECT_EQ(recv(self->cfd, recv_mem, 1, 0), 1);
		1642	EXPECT_EQ(recv_mem[0], rec1[0]);
		1643
		1644	ret = recvmsg(self->cfd, &hdr, 0);
		1645	EXPECT_LE(ret, sizeof(recv_mem));
		1646	EXPECT_GE(ret, 9);
		1647	EXPECT_EQ(memcmp(rec1, recv_mem, 9), 0);
		1648	if (ret > 9)
		1649	EXPECT_EQ(memcmp(rec2, recv_mem + 9, ret - 9), 0);
		1650	}
		1651
1618	FIXTURE(tls_err)	1652	FIXTURE(tls_err)
1619	{	1653	{
1620	int fd, cfd;	1654	int fd, cfd;

tools/testing/selftests/seccomp/settings+1−1

@@ -1 +1 @@
1	timeout=120	1	timeout=180

@@ -375,6 +375,7 @@ DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(get_reparse_compound_enter); · 374 unmodified lines
375	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(delete_enter);	375	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(delete_enter);
376	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(mkdir_enter);	376	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(mkdir_enter);
377	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(tdis_enter);	377	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(tdis_enter);
		378	DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(mknod_enter);
378		379
379	DECLARE_EVENT_CLASS(smb3_inf_compound_done_class,	380	DECLARE_EVENT_CLASS(smb3_inf_compound_done_class,
380	TP_PROTO(unsigned int xid,	381	TP_PROTO(unsigned int xid,
@@ -415,7 +416,7 @@ DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(query_wsl_ea_compound_done); · 34 unmodified lines
415	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(delete_done);	416	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(delete_done);
416	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(mkdir_done);	417	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(mkdir_done);
417	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(tdis_done);	418	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(tdis_done);
418		419	DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(mknod_done);
419		420
420	DECLARE_EVENT_CLASS(smb3_inf_compound_err_class,	421	DECLARE_EVENT_CLASS(smb3_inf_compound_err_class,
421	TP_PROTO(unsigned int xid,	422	TP_PROTO(unsigned int xid,
@@ -461,6 +462,7 @@ DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(query_wsl_ea_compound_err); · 39 unmodified lines
461	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(mkdir_err);	462	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(mkdir_err);
462	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(delete_err);	463	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(delete_err);
463	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(tdis_err);	464	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(tdis_err);
		465	DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(mknod_err);
464		466
465	/*	467	/*
466	* For logging SMB3 Status code and Command for responses which return errors	468	* For logging SMB3 Status code and Command for responses which return errors