lael-labs/linux

Documentation/devicetree/bindings/arm/tegra.yaml+1−1

@@ -54,7 +54,7 @@ properties: · 53 unmodified lines
54	- const: toradex,apalis_t30	54	- const: toradex,apalis_t30
55	- const: nvidia,tegra30	55	- const: nvidia,tegra30
56	- items:	56	- items:
57	- const: toradex,apalis_t30-eval-v1.1	57	- const: toradex,apalis_t30-v1.1-eval
58	- const: toradex,apalis_t30-eval	58	- const: toradex,apalis_t30-eval
59	- const: toradex,apalis_t30-v1.1	59	- const: toradex,apalis_t30-v1.1
60	- const: toradex,apalis_t30	60	- const: toradex,apalis_t30

Documentation/devicetree/bindings/display/mediatek/mediatek,disp.txt+1−1

@@ -9,7 +9,7 @@ function block. · 8 unmodified lines
9		9
10	All DISP device tree nodes must be siblings to the central MMSYS_CONFIG node.	10	All DISP device tree nodes must be siblings to the central MMSYS_CONFIG node.
11	For a description of the MMSYS_CONFIG binding, see	11	For a description of the MMSYS_CONFIG binding, see
12	Documentation/devicetree/bindings/arm/mediatek/mediatek,mmsys.txt.	12	Documentation/devicetree/bindings/arm/mediatek/mediatek,mmsys.yaml.
13		13
14	DISP function blocks	14	DISP function blocks
15	====================	15	====================

Documentation/devicetree/bindings/ufs/samsung,exynos-ufs.yaml+89−0

@@ -0,0 +1,89 @@
	1	# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
	2	%YAML 1.2
	3	---
	4	$id: http://devicetree.org/schemas/ufs/samsung,exynos-ufs.yaml#
	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
	6
	7	title: Samsung SoC series UFS host controller Device Tree Bindings
	8
	9	maintainers:
	10	- Alim Akhtar <alim.akhtar@samsung.com>
	11
	12	description: \|
	13	Each Samsung UFS host controller instance should have its own node.
	14	This binding define Samsung specific binding other then what is used
	15	in the common ufshcd bindings
	16	[1] Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
	17
	18	properties:
	19
	20	compatible:
	21	enum:
	22	- samsung,exynos7-ufs
	23
	24	reg:
	25	items:
	26	- description: HCI register
	27	- description: vendor specific register
	28	- description: unipro register
	29	- description: UFS protector register
	30
	31	reg-names:
	32	items:
	33	- const: hci
	34	- const: vs_hci
	35	- const: unipro
	36	- const: ufsp
	37
	38	clocks:
	39	items:
	40	- description: ufs link core clock
	41	- description: unipro main clock
	42
	43	clock-names:
	44	items:
	45	- const: core_clk
	46	- const: sclk_unipro_main
	47
	48	interrupts:
	49	maxItems: 1
	50
	51	phys:
	52	maxItems: 1
	53
	54	phy-names:
	55	const: ufs-phy
	56
	57	required:
	58	- compatible
	59	- reg
	60	- interrupts
	61	- phys
	62	- phy-names
	63	- clocks
	64	- clock-names
	65
	66	additionalProperties: false
	67
	68	examples:
	69	- \|
	70	#include <dt-bindings/interrupt-controller/arm-gic.h>
	71	#include <dt-bindings/clock/exynos7-clk.h>
	72
	73	ufs: ufs@15570000 {
	74	compatible = "samsung,exynos7-ufs";
	75	reg = <0x15570000 0x100>,
	76	<0x15570100 0x100>,
	77	<0x15571000 0x200>,
	78	<0x15572000 0x300>;
	79	reg-names = "hci", "vs_hci", "unipro", "ufsp";
	80	interrupts = <GIC_SPI 200 IRQ_TYPE_LEVEL_HIGH>;
	81	clocks = <&clock_fsys1 ACLK_UFS20_LINK>,
	82	<&clock_fsys1 SCLK_UFSUNIPRO20_USER>;
	83	clock-names = "core_clk", "sclk_unipro_main";
	84	pinctrl-names = "default";
	85	pinctrl-0 = <&ufs_rst_n &ufs_refclk_out>;
	86	phys = <&ufs_phy>;
	87	phy-names = "ufs-phy";
	88	};
	89	...

Documentation/networking/device_drivers/ethernet/intel/ice.rst+1−1

@@ -851,7 +851,7 @@ NOTES: · 850 unmodified lines
851	- 0x88A8 traffic will not be received unless VLAN stripping is disabled with	851	- 0x88A8 traffic will not be received unless VLAN stripping is disabled with
852	the following command::	852	the following command::
853		853
854	# ethool -K <ethX> rxvlan off	854	# ethtool -K <ethX> rxvlan off
855		855
856	- 0x88A8/0x8100 double VLANs cannot be used with 0x8100 or 0x8100/0x8100 VLANS	856	- 0x88A8/0x8100 double VLANs cannot be used with 0x8100 or 0x8100/0x8100 VLANS
857	configured on the same port. 0x88a8/0x8100 traffic will not be received if	857	configured on the same port. 0x88a8/0x8100 traffic will not be received if

Documentation/networking/dsa/sja1105.rst+1−1

@@ -296,7 +296,7 @@ not available. · 295 unmodified lines
296	Device Tree bindings and board design	296	Device Tree bindings and board design
297	=====================================	297	=====================================
298		298
299	This section references ``Documentation/devicetree/bindings/net/dsa/sja1105.txt``	299	This section references ``Documentation/devicetree/bindings/net/dsa/nxp,sja1105.yaml``
300	and aims to showcase some potential switch caveats.	300	and aims to showcase some potential switch caveats.
301		301
302	RMII PHY role and out-of-band signaling	302	RMII PHY role and out-of-band signaling

MAINTAINERS+11−11

 F:	arch/arm/mach-pxa/vpac270.c
 ARM/VT8500 ARM ARCHITECTURE
-M:	Tony Prisk <linux@prisktech.co.nz>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
-S:	Maintained
+S:	Orphan
 F:	Documentation/devicetree/bindings/i2c/i2c-wmt.txt
 F:	arch/arm/mach-vt8500/
 F:	drivers/clocksource/timer-vt8500.c
 F:	drivers/scsi/nsp32*
 NIOS2 ARCHITECTURE
-M:	Ley Foon Tan <ley.foon.tan@intel.com>
+M:	Dinh Nguyen <dinguyen@kernel.org>
 S:	Maintained
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lftan/nios2.git
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dinguyen/linux.git
 F:	arch/nios2/
 NITRO ENCLAVES (NE)
 F:	drivers/pci/controller/pci-ixp4xx.c
 PCI DRIVER FOR INTEL VOLUME MANAGEMENT DEVICE (VMD)
-M:	Jonathan Derrick <jonathan.derrick@intel.com>
+M:	Nirmal Patel <nirmal.patel@linux.intel.com>
+R:	Jonathan Derrick <jonathan.derrick@linux.dev>
 L:	linux-pci@vger.kernel.org
 S:	Supported
 F:	drivers/pci/controller/vmd.c
 SHARED MEMORY COMMUNICATIONS (SMC) SOCKETS
 M:	Karsten Graul <kgraul@linux.ibm.com>
-M:	Guvenc Gulce <guvenc@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 S:	Supported
 W:	http://www.ibm.com/developerworks/linux/linux390/
 F:	arch/x86/boot/video*
 SWIOTLB SUBSYSTEM
-M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
+M:	Christoph Hellwig <hch@infradead.org>
 L:	iommu@lists.linux-foundation.org
 S:	Supported
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/konrad/swiotlb.git
+W:	http://git.infradead.org/users/hch/dma-mapping.git
+T:	git git://git.infradead.org/users/hch/dma-mapping.git
 F:	arch/*/kernel/pci-swiotlb.c
 F:	include/linux/swiotlb.h
 F:	kernel/dma/swiotlb.c
 F:	tools/lib/bpf/xsk*
 XEN BLOCK SUBSYSTEM
-M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
 M:	Roger Pau Monné <roger.pau@citrix.com>
 L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
 S:	Supported
 F:	drivers/net/xen-netback/*
 XEN PCI SUBSYSTEM
-M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
+M:	Juergen Gross <jgross@suse.com>
 L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
 S:	Supported
 F:	arch/x86/pci/*xen*
 F:	sound/xen/*
 XEN SWIOTLB SUBSYSTEM
-M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
+M:	Juergen Gross <jgross@suse.com>
+M:	Stefano Stabellini <sstabellini@kernel.org>
 L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
 L:	iommu@lists.linux-foundation.org
 S:	Supported

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 15	3	PATCHLEVEL = 15
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc1	5	EXTRAVERSION = -rc2
6	NAME = Opossums on Parade	6	NAME = Opossums on Parade
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/alpha/Kconfig+1−2

 	select NEED_SG_DMA_LENGTH
 	select VIRT_TO_BUS
 	select GENERIC_IRQ_PROBE
-	select GENERIC_PCI_IOMAP if PCI
+	select GENERIC_PCI_IOMAP
 	select AUTO_IRQ_AFFINITY if SMP
 	select GENERIC_IRQ_SHOW
 	select ARCH_WANT_IPC_PARSE_VERSION
 config ALPHA_JENSEN
 	bool "Jensen"
-	depends on BROKEN
 	select HAVE_EISA
 	help
 	  DEC PC 150 AXP (aka Jensen): This is a very old Digital system - one

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

@@ -16,3 +16,4 @@ extern void __divlu(void); · 15 unmodified lines
16	extern void __remlu(void);	16	extern void __remlu(void);
17	extern void __divqu(void);	17	extern void __divqu(void);
18	extern void __remqu(void);	18	extern void __remqu(void);
		19	extern unsigned long __udiv_qrnnd(unsigned long *, unsigned long, unsigned long , unsigned long);

arch/alpha/include/asm/jensen.h+4−4

@@ -111,18 +111,18 @@ __EXTERN_INLINE void jensen_set_hae(unsigned long addr) · 110 unmodified lines
111	* convinced that I need one of the newer machines.	111	* convinced that I need one of the newer machines.
112	*/	112	*/
113		113
114	static inline unsigned int jensen_local_inb(unsigned long addr)	114	__EXTERN_INLINE unsigned int jensen_local_inb(unsigned long addr)
115	{	115	{
116	return 0xff & *(vuip)((addr << 9) + EISA_VL82C106);	116	return 0xff & *(vuip)((addr << 9) + EISA_VL82C106);
117	}	117	}
118		118
119	static inline void jensen_local_outb(u8 b, unsigned long addr)	119	__EXTERN_INLINE void jensen_local_outb(u8 b, unsigned long addr)
120	{	120	{
121	*(vuip)((addr << 9) + EISA_VL82C106) = b;	121	*(vuip)((addr << 9) + EISA_VL82C106) = b;
122	mb();	122	mb();
123	}	123	}
124		124
125	static inline unsigned int jensen_bus_inb(unsigned long addr)	125	__EXTERN_INLINE unsigned int jensen_bus_inb(unsigned long addr)
126	{	126	{
127	long result;	127	long result;
128		128
@@ -131,7 +131,7 @@ static inline unsigned int jensen_bus_inb(unsigned long addr) · 2 unmodified lines
131	return __kernel_extbl(result, addr & 3);	131	return __kernel_extbl(result, addr & 3);
132	}	132	}
133		133
134	static inline void jensen_bus_outb(u8 b, unsigned long addr)	134	__EXTERN_INLINE void jensen_bus_outb(u8 b, unsigned long addr)
135	{	135	{
136	jensen_set_hae(0);	136	jensen_set_hae(0);
137	(vuip)((addr << 7) + EISA_IO + 0x00) = b 0x01010101;	137	(vuip)((addr << 7) + EISA_IO + 0x00) = b 0x01010101;

arch/alpha/kernel/sys_jensen.c+5−5

  *
  * Code supporting the Jensen.
  */
+#define __EXTERN_INLINE
+#include <asm/io.h>
+#include <asm/jensen.h>
+#undef  __EXTERN_INLINE
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <asm/ptrace.h>
-#define __EXTERN_INLINE inline
-#include <asm/io.h>
-#include <asm/jensen.h>
-#undef  __EXTERN_INLINE
 #include <asm/dma.h>
 #include <asm/irq.h>
 #include <asm/mmu_context.h>

arch/alpha/lib/Makefile+1−0

@@ -14,6 +14,7 @@ ev6-$(CONFIG_ALPHA_EV6) := ev6- · 13 unmodified lines
14	ev67-$(CONFIG_ALPHA_EV67) := ev67-	14	ev67-$(CONFIG_ALPHA_EV67) := ev67-
15		15
16	lib-y = __divqu.o __remqu.o __divlu.o __remlu.o \	16	lib-y = __divqu.o __remqu.o __divlu.o __remlu.o \
		17	udiv-qrnnd.o \
17	udelay.o \	18	udelay.o \
18	$(ev6-y)memset.o \	19	$(ev6-y)memset.o \
19	$(ev6-y)memcpy.o \	20	$(ev6-y)memcpy.o \

arch/alpha/lib/udiv-qrnnd.Srenamed from arch/alpha/math-emu/qrnnd.S+2−0

  # along with GCC; see the file COPYING.  If not, write to the
  # Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  # MA 02111-1307, USA.
+#include <asm/export.h>
         .set noreorder
         .set noat
 	ret	$31,($26),1
 	.end	__udiv_qrnnd
+EXPORT_SYMBOL(__udiv_qrnnd)

arch/alpha/math-emu/Makefile+1−1

@@ -7,4 +7,4 @@ ccflags-y := -w · 6 unmodified lines
7		7
8	obj-$(CONFIG_MATHEMU) += math-emu.o	8	obj-$(CONFIG_MATHEMU) += math-emu.o
9		9
10	math-emu-objs := math.o qrnnd.o	10	math-emu-objs := math.o

arch/alpha/math-emu/math.c+0−2

@@ -403,5 +403,3 @@ alpha_fp_emul_imprecise (struct pt_regs *regs, unsigned long write_mask) · 402 unmodified lines
403	egress:	403	egress:
404	return si_code;	404	return si_code;
405	}	405	}
406
407	EXPORT_SYMBOL(__udiv_qrnnd);

arch/arm64/kernel/fpsimd.c+1−1

@@ -513,7 +513,7 @@ size_t sve_state_size(struct task_struct const *task) · 512 unmodified lines
513	void sve_alloc(struct task_struct *task)	513	void sve_alloc(struct task_struct *task)
514	{	514	{
515	if (task->thread.sve_state) {	515	if (task->thread.sve_state) {
516	memset(task->thread.sve_state, 0, sve_state_size(current));	516	memset(task->thread.sve_state, 0, sve_state_size(task));
517	return;	517	return;
518	}	518	}
519		519

arch/arm64/kernel/process.c+1−2

 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/nospec.h>
-#include <linux/sched.h>
 #include <linux/stddef.h>
 #include <linux/sysctl.h>
 #include <linux/unistd.h>
 #if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)
 #include <linux/stackprotector.h>
-unsigned long __stack_chk_guard __read_mostly;
+unsigned long __stack_chk_guard __ro_after_init;
 EXPORT_SYMBOL(__stack_chk_guard);
 #endif

arch/parisc/lib/iomap.c+3−1

 	}
 }
+#ifdef CONFIG_PCI
 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
 {
 	if (!INDIRECT_ADDR(addr)) {
 		iounmap(addr);
 	}
 }
+EXPORT_SYMBOL(pci_iounmap);
+#endif
 EXPORT_SYMBOL(ioread8);
 EXPORT_SYMBOL(ioread16);
 EXPORT_SYMBOL(iowrite32_rep);
 EXPORT_SYMBOL(ioport_map);
 EXPORT_SYMBOL(ioport_unmap);
-EXPORT_SYMBOL(pci_iounmap);

arch/powerpc/kernel/interrupt.c+43−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <asm/switch_to.h>	18	#include <asm/switch_to.h>
19	#include <asm/syscall.h>	19	#include <asm/syscall.h>
20	#include <asm/time.h>	20	#include <asm/time.h>
		21	#include <asm/tm.h>
21	#include <asm/unistd.h>	22	#include <asm/unistd.h>
22		23
23	#if defined(CONFIG_PPC_ADV_DEBUG_REGS) && defined(CONFIG_PPC32)	24	#if defined(CONFIG_PPC_ADV_DEBUG_REGS) && defined(CONFIG_PPC32)
@@ -136,6 +137,48 @@ notrace long system_call_exception(long r3, long r4, long r5, · 112 unmodified lines
136	*/	137	*/
137	irq_soft_mask_regs_set_state(regs, IRQS_ENABLED);	138	irq_soft_mask_regs_set_state(regs, IRQS_ENABLED);
138		139
		140	/*
		141	* If system call is called with TM active, set _TIF_RESTOREALL to
		142	* prevent RFSCV being used to return to userspace, because POWER9
		143	* TM implementation has problems with this instruction returning to
		144	* transactional state. Final register values are not relevant because
		145	* the transaction will be aborted upon return anyway. Or in the case
		146	* of unsupported_scv SIGILL fault, the return state does not much
		147	* matter because it's an edge case.
		148	*/
		149	if (IS_ENABLED(CONFIG_PPC_TRANSACTIONAL_MEM) &&
		150	unlikely(MSR_TM_TRANSACTIONAL(regs->msr)))
		151	current_thread_info()->flags \|= _TIF_RESTOREALL;
		152
		153	/*
		154	* If the system call was made with a transaction active, doom it and
		155	* return without performing the system call. Unless it was an
		156	* unsupported scv vector, in which case it's treated like an illegal
		157	* instruction.
		158	*/
		159	#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
		160	if (unlikely(MSR_TM_TRANSACTIONAL(regs->msr)) &&
		161	!trap_is_unsupported_scv(regs)) {
		162	/* Enable TM in the kernel, and disable EE (for scv) */
		163	hard_irq_disable();
		164	mtmsr(mfmsr() \| MSR_TM);
		165
		166	/* tabort, this dooms the transaction, nothing else */
		167	asm volatile(".long 0x7c00071d \| ((%0) << 16)"
		168	:: "r"(TM_CAUSE_SYSCALL\|TM_CAUSE_PERSISTENT));
		169
		170	/*
		171	* Userspace will never see the return value. Execution will
		172	* resume after the tbegin. of the aborted transaction with the
		173	* checkpointed register state. A context switch could occur
		174	* or signal delivered to the process before resuming the
		175	* doomed transaction context, but that should all be handled
		176	* as expected.
		177	*/
		178	return -ENOSYS;
		179	}
		180	#endif // CONFIG_PPC_TRANSACTIONAL_MEM
		181
139	local_irq_enable();	182	local_irq_enable();
140		183
141	if (unlikely(current_thread_info()->flags & _TIF_SYSCALL_DOTRACE)) {	184	if (unlikely(current_thread_info()->flags & _TIF_SYSCALL_DOTRACE)) {

arch/powerpc/kernel/interrupt_64.S+0−41

@@ -12,7 +12,6 @@ · 11 unmodified lines
12	#include <asm/mmu.h>	12	#include <asm/mmu.h>
13	#include <asm/ppc_asm.h>	13	#include <asm/ppc_asm.h>
14	#include <asm/ptrace.h>	14	#include <asm/ptrace.h>
15	#include <asm/tm.h>
16		15
17	.section ".toc","aw"	16	.section ".toc","aw"
18	SYS_CALL_TABLE:	17	SYS_CALL_TABLE:
@@ -55,12 +54,6 @@ COMPAT_SYS_CALL_TABLE: · 36 unmodified lines
55	.globl system_call_vectored_\name	54	.globl system_call_vectored_\name
56	system_call_vectored_\name:	55	system_call_vectored_\name:
57	_ASM_NOKPROBE_SYMBOL(system_call_vectored_\name)	56	_ASM_NOKPROBE_SYMBOL(system_call_vectored_\name)
58	#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
59	BEGIN_FTR_SECTION
60	extrdi. r10, r12, 1, (63-MSR_TS_T_LG) /* transaction active? */
61	bne tabort_syscall
62	END_FTR_SECTION_IFSET(CPU_FTR_TM)
63	#endif
64	SCV_INTERRUPT_TO_KERNEL	57	SCV_INTERRUPT_TO_KERNEL
65	mr r10,r1	58	mr r10,r1
66	ld r1,PACAKSAVE(r13)	59	ld r1,PACAKSAVE(r13)
@@ -247,12 +240,6 @@ _ASM_NOKPROBE_SYMBOL(system_call_common_real) · 180 unmodified lines
247	.globl system_call_common	240	.globl system_call_common
248	system_call_common:	241	system_call_common:
249	_ASM_NOKPROBE_SYMBOL(system_call_common)	242	_ASM_NOKPROBE_SYMBOL(system_call_common)
250	#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
251	BEGIN_FTR_SECTION
252	extrdi. r10, r12, 1, (63-MSR_TS_T_LG) /* transaction active? */
253	bne tabort_syscall
254	END_FTR_SECTION_IFSET(CPU_FTR_TM)
255	#endif
256	mr r10,r1	243	mr r10,r1
257	ld r1,PACAKSAVE(r13)	244	ld r1,PACAKSAVE(r13)
258	std r10,0(r1)	245	std r10,0(r1)
@@ -425,34 +412,6 @@ SOFT_MASK_TABLE(.Lsyscall_rst_start, 1b) · 166 unmodified lines
425	RESTART_TABLE(.Lsyscall_rst_start, .Lsyscall_rst_end, syscall_restart)	412	RESTART_TABLE(.Lsyscall_rst_start, .Lsyscall_rst_end, syscall_restart)
426	#endif	413	#endif
427		414
428	#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
429	tabort_syscall:
430	_ASM_NOKPROBE_SYMBOL(tabort_syscall)
431	/* Firstly we need to enable TM in the kernel */
432	mfmsr r10
433	li r9, 1
434	rldimi r10, r9, MSR_TM_LG, 63-MSR_TM_LG
435	mtmsrd r10, 0
436
437	/* tabort, this dooms the transaction, nothing else */
438	li r9, (TM_CAUSE_SYSCALL\|TM_CAUSE_PERSISTENT)
439	TABORT(R9)
440
441	/*
442	* Return directly to userspace. We have corrupted user register state,
443	* but userspace will never see that register state. Execution will
444	* resume after the tbegin of the aborted transaction with the
445	* checkpointed register state.
446	*/
447	li r9, MSR_RI
448	andc r10, r10, r9
449	mtmsrd r10, 1
450	mtspr SPRN_SRR0, r11
451	mtspr SPRN_SRR1, r12
452	RFI_TO_USER
453	b . /* prevent speculative execution */
454	#endif
455
456	/*	415	/*
457	* If MSR EE/RI was never enabled, IRQs not reconciled, NVGPRs not	416	* If MSR EE/RI was never enabled, IRQs not reconciled, NVGPRs not
458	* touched, no exit work created, then this can be used.	417	* touched, no exit work created, then this can be used.

arch/powerpc/kernel/mce.c+15−2

 {
 	int index;
 	struct machine_check_event evt;
+	unsigned long msr;
 	if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
 		return;
 	memcpy(&local_paca->mce_info->mce_event_queue[index],
 	       &evt, sizeof(evt));
-	/* Queue irq work to process this event later. */
+	/*
-	irq_work_queue(&mce_event_process_work);
+	 * Queue irq work to process this event later. Before
+	 * queuing the work enable translation for non radix LPAR,
+	 * as irq_work_queue may try to access memory outside RMO
+	 * region.
+	 */
+	if (!radix_enabled() && firmware_has_feature(FW_FEATURE_LPAR)) {
+		msr = mfmsr();
+		mtmsr(msr | MSR_IR | MSR_DR);
+		irq_work_queue(&mce_event_process_work);
+		mtmsr(msr);
+	} else {
+		irq_work_queue(&mce_event_process_work);
+	}
 }
 void mce_common_process_ue(struct pt_regs *regs,

arch/powerpc/kvm/book3s_hv_rmhandlers.S+34−2

@@ -2536,7 +2536,7 @@ END_FTR_SECTION_IFCLR(CPU_FTR_P9_TM_HV_ASSIST) · 2535 unmodified lines
2536	/* The following code handles the fake_suspend = 1 case */	2536	/* The following code handles the fake_suspend = 1 case */
2537	mflr r0	2537	mflr r0
2538	std r0, PPC_LR_STKOFF(r1)	2538	std r0, PPC_LR_STKOFF(r1)
2539	stdu r1, -PPC_MIN_STKFRM(r1)	2539	stdu r1, -TM_FRAME_SIZE(r1)
2540		2540
2541	/* Turn on TM. */	2541	/* Turn on TM. */
2542	mfmsr r8	2542	mfmsr r8
@@ -2551,10 +2551,42 @@ BEGIN_FTR_SECTION · 8 unmodified lines
2551	END_FTR_SECTION_IFSET(CPU_FTR_P9_TM_XER_SO_BUG)	2551	END_FTR_SECTION_IFSET(CPU_FTR_P9_TM_XER_SO_BUG)
2552	nop	2552	nop
2553		2553
		2554	/*
		2555	* It's possible that treclaim. may modify registers, if we have lost
		2556	* track of fake-suspend state in the guest due to it using rfscv.
		2557	* Save and restore registers in case this occurs.
		2558	*/
		2559	mfspr r3, SPRN_DSCR
		2560	mfspr r4, SPRN_XER
		2561	mfspr r5, SPRN_AMR
		2562	/* SPRN_TAR would need to be saved here if the kernel ever used it */
		2563	mfcr r12
		2564	SAVE_NVGPRS(r1)
		2565	SAVE_GPR(2, r1)
		2566	SAVE_GPR(3, r1)
		2567	SAVE_GPR(4, r1)
		2568	SAVE_GPR(5, r1)
		2569	stw r12, 8(r1)
		2570	std r1, HSTATE_HOST_R1(r13)
		2571
2554	/* We have to treclaim here because that's the only way to do S->N */	2572	/* We have to treclaim here because that's the only way to do S->N */
2555	li r3, TM_CAUSE_KVM_RESCHED	2573	li r3, TM_CAUSE_KVM_RESCHED
2556	TRECLAIM(R3)	2574	TRECLAIM(R3)
2557		2575
		2576	GET_PACA(r13)
		2577	ld r1, HSTATE_HOST_R1(r13)
		2578	REST_GPR(2, r1)
		2579	REST_GPR(3, r1)
		2580	REST_GPR(4, r1)
		2581	REST_GPR(5, r1)
		2582	lwz r12, 8(r1)
		2583	REST_NVGPRS(r1)
		2584	mtspr SPRN_DSCR, r3
		2585	mtspr SPRN_XER, r4
		2586	mtspr SPRN_AMR, r5
		2587	mtcr r12
		2588	HMT_MEDIUM
		2589
2558	/*	2590	/*
2559	* We were in fake suspend, so we are not going to save the	2591	* We were in fake suspend, so we are not going to save the
2560	* register state as the guest checkpointed state (since	2592	* register state as the guest checkpointed state (since
@@ -2582,7 +2614,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_P9_TM_XER_SO_BUG) · 21 unmodified lines
2582	std r5, VCPU_TFHAR(r9)	2614	std r5, VCPU_TFHAR(r9)
2583	std r6, VCPU_TFIAR(r9)	2615	std r6, VCPU_TFIAR(r9)
2584		2616
2585	addi r1, r1, PPC_MIN_STKFRM	2617	addi r1, r1, TM_FRAME_SIZE
2586	ld r0, PPC_LR_STKOFF(r1)	2618	ld r0, PPC_LR_STKOFF(r1)
2587	mtlr r0	2619	mtlr r0
2588	blr	2620	blr

arch/powerpc/sysdev/xics/xics-common.c+2−2

@@ -348,9 +348,9 @@ static int xics_host_map(struct irq_domain *domain, unsigned int virq, · 347 unmodified lines
348	if (xics_ics->check(xics_ics, hwirq))	348	if (xics_ics->check(xics_ics, hwirq))
349	return -EINVAL;	349	return -EINVAL;
350		350
351	/* No chip data for the XICS domain */	351	/* Let the ICS be the chip data for the XICS domain. For ICS native */
352	irq_domain_set_info(domain, virq, hwirq, xics_ics->chip,	352	irq_domain_set_info(domain, virq, hwirq, xics_ics->chip,
353	NULL, handle_fasteoi_irq, NULL, NULL);	353	xics_ics, handle_fasteoi_irq, NULL, NULL);
354		354
355	return 0;	355	return 0;
356	}	356	}

arch/s390/Kconfig+0−10

@@ -685,16 +685,6 @@ config STACK_GUARD · 684 unmodified lines
685	The minimum size for the stack guard should be 256 for 31 bit and	685	The minimum size for the stack guard should be 256 for 31 bit and
686	512 for 64 bit.	686	512 for 64 bit.
687		687
688	config WARN_DYNAMIC_STACK
689	def_bool n
690	prompt "Emit compiler warnings for function with dynamic stack usage"
691	help
692	This option enables the compiler option -mwarn-dynamicstack. If the
693	compiler supports this options generates warnings for functions
694	that dynamically allocate stack space using alloca.
695
696	Say N if you are unsure.
697
698	endmenu	688	endmenu
699		689
700	menu "I/O subsystem"	690	menu "I/O subsystem"

arch/s390/Makefile+0−7

@@ -85,13 +85,6 @@ cflags-$(CONFIG_CHECK_STACK) += -mstack-guard=$(CONFIG_STACK_GUARD) · 84 unmodified lines
85	endif	85	endif
86	endif	86	endif
87		87
88	ifdef CONFIG_WARN_DYNAMIC_STACK
89	ifneq ($(call cc-option,-mwarn-dynamicstack),)
90	KBUILD_CFLAGS += -mwarn-dynamicstack
91	KBUILD_CFLAGS_DECOMPRESSOR += -mwarn-dynamicstack
92	endif
93	endif
94
95	ifdef CONFIG_EXPOLINE	88	ifdef CONFIG_EXPOLINE
96	ifneq ($(call cc-option,$(CC_FLAGS_MARCH) -mindirect-branch=thunk),)	89	ifneq ($(call cc-option,$(CC_FLAGS_MARCH) -mindirect-branch=thunk),)
97	CC_FLAGS_EXPOLINE := -mindirect-branch=thunk	90	CC_FLAGS_EXPOLINE := -mindirect-branch=thunk

arch/s390/configs/debug_defconfig+5−3

 CONFIG_BPF_JIT_ALWAYS_ON=y
 CONFIG_BPF_LSM=y
 CONFIG_PREEMPT=y
+CONFIG_SCHED_CORE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_BSD_PROCESS_ACCT_V3=y
 CONFIG_TASKSTATS=y
 # CONFIG_NET_VENDOR_HUAWEI is not set
 # CONFIG_NET_VENDOR_INTEL is not set
 # CONFIG_NET_VENDOR_MICROSOFT is not set
+# CONFIG_NET_VENDOR_LITEX is not set
 # CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
 CONFIG_MLX5_CORE=m
 CONFIG_NFSD_V4=y
 CONFIG_NFSD_V4_SECURITY_LABEL=y
 CONFIG_CIFS=m
-CONFIG_CIFS_WEAK_PW_HASH=y
 CONFIG_CIFS_UPCALL=y
 CONFIG_CIFS_XATTR=y
 CONFIG_CIFS_POSIX=y
 CONFIG_CRYPTO_VMAC=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_BLAKE2S=m
+CONFIG_CRYPTO_MD4=m
+CONFIG_CRYPTO_MD5=y
 CONFIG_CRYPTO_MICHAEL_MIC=m
 CONFIG_CRYPTO_RMD160=m
 CONFIG_CRYPTO_SHA3=m
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_DMA_API_DEBUG=y
-CONFIG_STRING_SELFTEST=y
 CONFIG_PRINTK_TIME=y
 CONFIG_DYNAMIC_DEBUG=y
 CONFIG_DEBUG_INFO=y
 CONFIG_FAULT_INJECTION_STACKTRACE_FILTER=y
 CONFIG_LKDTM=m
 CONFIG_TEST_MIN_HEAP=y
-CONFIG_TEST_SORT=y
 CONFIG_KPROBES_SANITY_TEST=y
 CONFIG_RBTREE_TEST=y
 CONFIG_INTERVAL_TREE_TEST=m
 CONFIG_PERCPU_TEST=m
 CONFIG_ATOMIC64_SELFTEST=y
+CONFIG_STRING_SELFTEST=y
 CONFIG_TEST_BITOPS=m
 CONFIG_TEST_BPF=m
 CONFIG_TEST_LIVEPATCH=m

arch/s390/configs/defconfig+4−1

 CONFIG_BPF_JIT=y
 CONFIG_BPF_JIT_ALWAYS_ON=y
 CONFIG_BPF_LSM=y
+CONFIG_SCHED_CORE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_BSD_PROCESS_ACCT_V3=y
 CONFIG_TASKSTATS=y
 # CONFIG_NET_VENDOR_HUAWEI is not set
 # CONFIG_NET_VENDOR_INTEL is not set
 # CONFIG_NET_VENDOR_MICROSOFT is not set
+# CONFIG_NET_VENDOR_LITEX is not set
 # CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
 CONFIG_MLX5_CORE=m
 CONFIG_NFSD_V4=y
 CONFIG_NFSD_V4_SECURITY_LABEL=y
 CONFIG_CIFS=m
-CONFIG_CIFS_WEAK_PW_HASH=y
 CONFIG_CIFS_UPCALL=y
 CONFIG_CIFS_XATTR=y
 CONFIG_CIFS_POSIX=y
 CONFIG_CRYPTO_VMAC=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_BLAKE2S=m
+CONFIG_CRYPTO_MD4=m
+CONFIG_CRYPTO_MD5=y
 CONFIG_CRYPTO_MICHAEL_MIC=m
 CONFIG_CRYPTO_RMD160=m
 CONFIG_CRYPTO_SHA3=m

arch/s390/include/asm/ccwgroup.h+1−1

@@ -55,7 +55,7 @@ int ccwgroup_create_dev(struct device root, struct ccwgroup_driver gdrv, · 54 unmodified lines
55	int num_devices, const char *buf);	55	int num_devices, const char *buf);
56		56
57	extern int ccwgroup_set_online(struct ccwgroup_device *gdev);	57	extern int ccwgroup_set_online(struct ccwgroup_device *gdev);
58	extern int ccwgroup_set_offline(struct ccwgroup_device *gdev);	58	int ccwgroup_set_offline(struct ccwgroup_device *gdev, bool call_gdrv);
59		59
60	extern int ccwgroup_probe_ccwdev(struct ccw_device *cdev);	60	extern int ccwgroup_probe_ccwdev(struct ccw_device *cdev);
61	extern void ccwgroup_remove_ccwdev(struct ccw_device *cdev);	61	extern void ccwgroup_remove_ccwdev(struct ccw_device *cdev);

arch/s390/net/bpf_jit_comp.c+38−32

 #define EMIT6_PCREL(op1, op2, b1, b2, i, off, mask)		\
 ({								\
-	/* Branch instruction needs 6 bytes */			\
+	int rel = (addrs[(i) + (off) + 1] - jit->prg) / 2;	\
-	int rel = (addrs[(i) + (off) + 1] - (addrs[(i) + 1] - 6)) / 2;\
 	_EMIT6((op1) | reg(b1, b2) << 16 | (rel & 0xffff), (op2) | (mask));\
 	REG_SET_SEEN(b1);					\
 	REG_SET_SEEN(b2);					\
 		EMIT4(0xb9080000, dst_reg, src_reg);
 		break;
 	case BPF_ALU | BPF_ADD | BPF_K: /* dst = (u32) dst + (u32) imm */
-		if (!imm)
+		if (imm != 0) {
-			break;
+			/* alfi %dst,imm */
-		/* alfi %dst,imm */
+			EMIT6_IMM(0xc20b0000, dst_reg, imm);
-		EMIT6_IMM(0xc20b0000, dst_reg, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_ADD | BPF_K: /* dst = dst + imm */
 		EMIT4(0xb9090000, dst_reg, src_reg);
 		break;
 	case BPF_ALU | BPF_SUB | BPF_K: /* dst = (u32) dst - (u32) imm */
-		if (!imm)
+		if (imm != 0) {
-			break;
+			/* alfi %dst,-imm */
-		/* alfi %dst,-imm */
+			EMIT6_IMM(0xc20b0000, dst_reg, -imm);
-		EMIT6_IMM(0xc20b0000, dst_reg, -imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_SUB | BPF_K: /* dst = dst - imm */
 		if (!imm)
 			break;
-		/* agfi %dst,-imm */
+		if (imm == -0x80000000) {
-		EMIT6_IMM(0xc2080000, dst_reg, -imm);
+			/* algfi %dst,0x80000000 */
+			EMIT6_IMM(0xc20a0000, dst_reg, 0x80000000);
+		} else {
+			/* agfi %dst,-imm */
+			EMIT6_IMM(0xc2080000, dst_reg, -imm);
+		}
 		break;
 	/*
 	 * BPF_MUL
 		EMIT4(0xb90c0000, dst_reg, src_reg);
 		break;
 	case BPF_ALU | BPF_MUL | BPF_K: /* dst = (u32) dst * (u32) imm */
-		if (imm == 1)
+		if (imm != 1) {
-			break;
+			/* msfi %r5,imm */
-		/* msfi %r5,imm */
+			EMIT6_IMM(0xc2010000, dst_reg, imm);
-		EMIT6_IMM(0xc2010000, dst_reg, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_MUL | BPF_K: /* dst = dst * imm */
 			if (BPF_OP(insn->code) == BPF_MOD)
 				/* lhgi %dst,0 */
 				EMIT4_IMM(0xa7090000, dst_reg, 0);
+			else
+				EMIT_ZERO(dst_reg);
 			break;
 		}
 		/* lhi %w0,0 */
 		EMIT4(0xb9820000, dst_reg, src_reg);
 		break;
 	case BPF_ALU | BPF_XOR | BPF_K: /* dst = (u32) dst ^ (u32) imm */
-		if (!imm)
+		if (imm != 0) {
-			break;
+			/* xilf %dst,imm */
-		/* xilf %dst,imm */
+			EMIT6_IMM(0xc0070000, dst_reg, imm);
-		EMIT6_IMM(0xc0070000, dst_reg, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_XOR | BPF_K: /* dst = dst ^ imm */
 		EMIT6_DISP_LH(0xeb000000, 0x000d, dst_reg, dst_reg, src_reg, 0);
 		break;
 	case BPF_ALU | BPF_LSH | BPF_K: /* dst = (u32) dst << (u32) imm */
-		if (imm == 0)
+		if (imm != 0) {
-			break;
+			/* sll %dst,imm(%r0) */
-		/* sll %dst,imm(%r0) */
+			EMIT4_DISP(0x89000000, dst_reg, REG_0, imm);
-		EMIT4_DISP(0x89000000, dst_reg, REG_0, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_LSH | BPF_K: /* dst = dst << imm */
 		EMIT6_DISP_LH(0xeb000000, 0x000c, dst_reg, dst_reg, src_reg, 0);
 		break;
 	case BPF_ALU | BPF_RSH | BPF_K: /* dst = (u32) dst >> (u32) imm */
-		if (imm == 0)
+		if (imm != 0) {
-			break;
+			/* srl %dst,imm(%r0) */
-		/* srl %dst,imm(%r0) */
+			EMIT4_DISP(0x88000000, dst_reg, REG_0, imm);
-		EMIT4_DISP(0x88000000, dst_reg, REG_0, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_RSH | BPF_K: /* dst = dst >> imm */
 		EMIT6_DISP_LH(0xeb000000, 0x000a, dst_reg, dst_reg, src_reg, 0);
 		break;
 	case BPF_ALU | BPF_ARSH | BPF_K: /* ((s32) dst >> imm */
-		if (imm == 0)
+		if (imm != 0) {
-			break;
+			/* sra %dst,imm(%r0) */
-		/* sra %dst,imm(%r0) */
+			EMIT4_DISP(0x8a000000, dst_reg, REG_0, imm);
-		EMIT4_DISP(0x8a000000, dst_reg, REG_0, imm);
+		}
 		EMIT_ZERO(dst_reg);
 		break;
 	case BPF_ALU64 | BPF_ARSH | BPF_K: /* ((s64) dst) >>= imm */

arch/s390/pci/pci_mmio.c+2−2

@@ -159,7 +159,7 @@ SYSCALL_DEFINE3(s390_pci_mmio_write, unsigned long, mmio_addr, · 158 unmodified lines
159		159
160	mmap_read_lock(current->mm);	160	mmap_read_lock(current->mm);
161	ret = -EINVAL;	161	ret = -EINVAL;
162	vma = find_vma(current->mm, mmio_addr);	162	vma = vma_lookup(current->mm, mmio_addr);
163	if (!vma)	163	if (!vma)
164	goto out_unlock_mmap;	164	goto out_unlock_mmap;
165	if (!(vma->vm_flags & (VM_IO \| VM_PFNMAP)))	165	if (!(vma->vm_flags & (VM_IO \| VM_PFNMAP)))
@@ -298,7 +298,7 @@ SYSCALL_DEFINE3(s390_pci_mmio_read, unsigned long, mmio_addr, · 132 unmodified lines
298		298
299	mmap_read_lock(current->mm);	299	mmap_read_lock(current->mm);
300	ret = -EINVAL;	300	ret = -EINVAL;
301	vma = find_vma(current->mm, mmio_addr);	301	vma = vma_lookup(current->mm, mmio_addr);
302	if (!vma)	302	if (!vma)
303	goto out_unlock_mmap;	303	goto out_unlock_mmap;
304	if (!(vma->vm_flags & (VM_IO \| VM_PFNMAP)))	304	if (!(vma->vm_flags & (VM_IO \| VM_PFNMAP)))

arch/sh/boot/Makefile+8−8

arch/sparc/kernel/ioport.c+3−1

@@ -356,7 +356,9 @@ err_nomem: · 355 unmodified lines
356	void arch_dma_free(struct device dev, size_t size, void cpu_addr,	356	void arch_dma_free(struct device dev, size_t size, void cpu_addr,
357	dma_addr_t dma_addr, unsigned long attrs)	357	dma_addr_t dma_addr, unsigned long attrs)
358	{	358	{
359	if (!sparc_dma_free_resource(cpu_addr, PAGE_ALIGN(size)))	359	size = PAGE_ALIGN(size);
		360
		361	if (!sparc_dma_free_resource(cpu_addr, size))
360	return;	362	return;
361		363
362	dma_make_coherent(dma_addr, size);	364	dma_make_coherent(dma_addr, size);

arch/sparc/lib/iomap.c+2−0

 EXPORT_SYMBOL(ioport_map);
 EXPORT_SYMBOL(ioport_unmap);
+#ifdef CONFIG_PCI
 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
 {
 	/* nothing to do */
 }
 EXPORT_SYMBOL(pci_iounmap);
+#endif

arch/x86/Kconfig+5−0

 config ARCH_HIBERNATION_POSSIBLE
 	def_bool y
+config ARCH_NR_GPIO
+	int
+	default 1024 if X86_64
+	default 512
 config ARCH_SUSPEND_POSSIBLE
 	def_bool y

arch/x86/Makefile_32.cpu+9−3

 tune		= $(call cc-option,-mtune=$(1),$(2))
+ifdef CONFIG_CC_IS_CLANG
+align		:= -falign-functions=0 $(call cc-option,-falign-jumps=0) $(call cc-option,-falign-loops=0)
+else
+align		:= -falign-functions=0 -falign-jumps=0 -falign-loops=0
+endif
 cflags-$(CONFIG_M486SX)		+= -march=i486
 cflags-$(CONFIG_M486)		+= -march=i486
 cflags-$(CONFIG_M586)		+= -march=i586
 # They make zero difference whatsosever to performance at this time.
 cflags-$(CONFIG_MK7)		+= -march=athlon
 cflags-$(CONFIG_MK8)		+= $(call cc-option,-march=k8,-march=athlon)
-cflags-$(CONFIG_MCRUSOE)	+= -march=i686 -falign-functions=0 -falign-jumps=0 -falign-loops=0
+cflags-$(CONFIG_MCRUSOE)	+= -march=i686 $(align)
-cflags-$(CONFIG_MEFFICEON)	+= -march=i686 $(call tune,pentium3) -falign-functions=0 -falign-jumps=0 -falign-loops=0
+cflags-$(CONFIG_MEFFICEON)	+= -march=i686 $(call tune,pentium3) $(align)
 cflags-$(CONFIG_MWINCHIPC6)	+= $(call cc-option,-march=winchip-c6,-march=i586)
 cflags-$(CONFIG_MWINCHIP3D)	+= $(call cc-option,-march=winchip2,-march=i586)
-cflags-$(CONFIG_MCYRIXIII)	+= $(call cc-option,-march=c3,-march=i486) -falign-functions=0 -falign-jumps=0 -falign-loops=0
+cflags-$(CONFIG_MCYRIXIII)	+= $(call cc-option,-march=c3,-march=i486) $(align)
 cflags-$(CONFIG_MVIAC3_2)	+= $(call cc-option,-march=c3-2,-march=i686)
 cflags-$(CONFIG_MVIAC7)		+= -march=i686
 cflags-$(CONFIG_MCORE2)		+= -march=i686 $(call tune,core2)

arch/x86/kernel/cpu/mce/core.c+32−11

 static void kill_me_now(struct callback_head *ch)
 {
+	struct task_struct *p = container_of(ch, struct task_struct, mce_kill_me);
+	p->mce_count = 0;
 	force_sig(SIGBUS);
 }
 	int flags = MF_ACTION_REQUIRED;
 	int ret;
+	p->mce_count = 0;
 	pr_err("Uncorrected hardware memory error in user-access at %llx", p->mce_addr);
 	if (!p->mce_ripv)
 	}
 }
-static void queue_task_work(struct mce *m, int kill_current_task)
+static void queue_task_work(struct mce *m, char *msg, int kill_current_task)
 {
-	current->mce_addr = m->addr;
+	int count = ++current->mce_count;
-	current->mce_kflags = m->kflags;
-	current->mce_ripv = !!(m->mcgstatus & MCG_STATUS_RIPV);
-	current->mce_whole_page = whole_page(m);
-	if (kill_current_task)
+	/* First call, save all the details */
-		current->mce_kill_me.func = kill_me_now;
+	if (count == 1) {
-	else
+		current->mce_addr = m->addr;
-		current->mce_kill_me.func = kill_me_maybe;
+		current->mce_kflags = m->kflags;
+		current->mce_ripv = !!(m->mcgstatus & MCG_STATUS_RIPV);
+		current->mce_whole_page = whole_page(m);
+		if (kill_current_task)
+			current->mce_kill_me.func = kill_me_now;
+		else
+			current->mce_kill_me.func = kill_me_maybe;
+	}
+	/* Ten is likely overkill. Don't expect more than two faults before task_work() */
+	if (count > 10)
+		mce_panic("Too many consecutive machine checks while accessing user data", m, msg);
+	/* Second or later call, make sure page address matches the one from first call */
+	if (count > 1 && (current->mce_addr >> PAGE_SHIFT) != (m->addr >> PAGE_SHIFT))
+		mce_panic("Consecutive machine checks to different user pages", m, msg);
+	/* Do not call task_work_add() more than once */
+	if (count > 1)
+		return;
 	task_work_add(current, &current->mce_kill_me, TWA_RESUME);
 }
 		/* If this triggers there is no way to recover. Die hard. */
 		BUG_ON(!on_thread_stack() || !user_mode(regs));
-		queue_task_work(&m, kill_current_task);
+		queue_task_work(&m, msg, kill_current_task);
 	} else {
 		/*
 		}
 		if (m.kflags & MCE_IN_KERNEL_COPYIN)
-			queue_task_work(&m, kill_current_task);
+			queue_task_work(&m, msg, kill_current_task);
 	}
 out:
 	mce_wrmsrl(MSR_IA32_MCG_STATUS, 0);

arch/x86/mm/init_64.c+3−3

@@ -1432,18 +1432,18 @@ int kern_addr_valid(unsigned long addr) · 1431 unmodified lines
1432	return 0;	1432	return 0;
1433		1433
1434	p4d = p4d_offset(pgd, addr);	1434	p4d = p4d_offset(pgd, addr);
1435	if (p4d_none(*p4d))	1435	if (!p4d_present(*p4d))
1436	return 0;	1436	return 0;
1437		1437
1438	pud = pud_offset(p4d, addr);	1438	pud = pud_offset(p4d, addr);
1439	if (pud_none(*pud))	1439	if (!pud_present(*pud))
1440	return 0;	1440	return 0;
1441		1441
1442	if (pud_large(*pud))	1442	if (pud_large(*pud))
1443	return pfn_valid(pud_pfn(*pud));	1443	return pfn_valid(pud_pfn(*pud));
1444		1444
1445	pmd = pmd_offset(pud, addr);	1445	pmd = pmd_offset(pud, addr);
1446	if (pmd_none(*pmd))	1446	if (!pmd_present(*pmd))
1447	return 0;	1447	return 0;
1448		1448
1449	if (pmd_large(*pmd))	1449	if (pmd_large(*pmd))

arch/x86/mm/pat/memtype.c+6−1

@@ -583,7 +583,12 @@ int memtype_reserve(u64 start, u64 end, enum page_cache_mode req_type, · 582 unmodified lines
583	int err = 0;	583	int err = 0;
584		584
585	start = sanitize_phys(start);	585	start = sanitize_phys(start);
586	end = sanitize_phys(end);	586
		587	/*
		588	* The end address passed into this function is exclusive, but
		589	* sanitize_phys() expects an inclusive address.
		590	*/
		591	end = sanitize_phys(end - 1) + 1;
587	if (start >= end) {	592	if (start >= end) {
588	WARN(1, "%s failed: [mem %#010Lx-%#010Lx], req %s\n", __func__,	593	WARN(1, "%s failed: [mem %#010Lx-%#010Lx], req %s\n", __func__,
589	start, end - 1, cattr_name(req_type));	594	start, end - 1, cattr_name(req_type));

arch/x86/xen/enlighten_pv.c+7−0

 	x86_platform.legacy.rtc = 1;
 }
+static void __init xen_domu_set_legacy_features(void)
+{
+	x86_platform.legacy.rtc = 0;
+}
 /* First C function to be called on Xen boot */
 asmlinkage __visible void __init xen_start_kernel(void)
 {
 		add_preferred_console("xenboot", 0, NULL);
 		if (pci_xen)
 			x86_init.pci.arch_init = pci_xen_init;
+		x86_platform.set_legacy_features =
+				xen_domu_set_legacy_features;
 	} else {
 		const struct dom0_vga_console_info *info =
 			(void *)((char *)xen_start_info +

arch/x86/xen/mmu_pv.c+5−2

 	if (pinned) {
 		struct page *page = pfn_to_page(pfn);
-		if (static_branch_likely(&xen_struct_pages_ready))
+		pinned = false;
+		if (static_branch_likely(&xen_struct_pages_ready)) {
+			pinned = PagePinned(page);
 			SetPagePinned(page);
+		}
 		xen_mc_batch();
 		__set_pfn_prot(pfn, PAGE_KERNEL_RO);
-		if (level == PT_PTE && USE_SPLIT_PTE_PTLOCKS)
+		if (level == PT_PTE && USE_SPLIT_PTE_PTLOCKS && !pinned)
 			__pin_pagetable_pfn(MMUEXT_PIN_L1_TABLE, pfn);
 		xen_mc_issue(PARAVIRT_LAZY_MMU);

block/blk-cgroup.c+14−4

 	if (preloaded)
 		radix_tree_preload_end();
-	ret = blk_iolatency_init(q);
-	if (ret)
-		goto err_destroy_all;
 	ret = blk_ioprio_init(q);
 	if (ret)
 		goto err_destroy_all;
 	if (ret)
 		goto err_destroy_all;
+	ret = blk_iolatency_init(q);
+	if (ret) {
+		blk_throtl_exit(q);
+		goto err_destroy_all;
+	}
 	return 0;
 err_destroy_all:
 	/* alloc failed, nothing's initialized yet, free everything */
 	spin_lock_irq(&q->queue_lock);
 	list_for_each_entry(blkg, &q->blkg_list, q_node) {
+		struct blkcg *blkcg = blkg->blkcg;
+		spin_lock(&blkcg->lock);
 		if (blkg->pd[pol->plid]) {
 			pol->pd_free_fn(blkg->pd[pol->plid]);
 			blkg->pd[pol->plid] = NULL;
 		}
+		spin_unlock(&blkcg->lock);
 	}
 	spin_unlock_irq(&q->queue_lock);
 	ret = -ENOMEM;
 	__clear_bit(pol->plid, q->blkcg_pols);
 	list_for_each_entry(blkg, &q->blkg_list, q_node) {
+		struct blkcg *blkcg = blkg->blkcg;
+		spin_lock(&blkcg->lock);
 		if (blkg->pd[pol->plid]) {
 			if (pol->pd_offline_fn)
 				pol->pd_offline_fn(blkg->pd[pol->plid]);
 			pol->pd_free_fn(blkg->pd[pol->plid]);
 			blkg->pd[pol->plid] = NULL;
 		}
+		spin_unlock(&blkcg->lock);
 	}
 	spin_unlock_irq(&q->queue_lock);

block/blk-integrity.c+8−1

  */
 void blk_integrity_unregister(struct gendisk *disk)
 {
+	struct blk_integrity *bi = &disk->queue->integrity;
+	if (!bi->profile)
+		return;
+	/* ensure all bios are off the integrity workqueue */
+	blk_flush_integrity();
 	blk_queue_flag_clear(QUEUE_FLAG_STABLE_WRITES, disk->queue);
-	memset(&disk->queue->integrity, 0, sizeof(struct blk_integrity));
+	memset(bi, 0, sizeof(*bi));
 }
 EXPORT_SYMBOL(blk_integrity_unregister);

block/blk-mq-tag.c+1−1

@@ -208,7 +208,7 @@ static struct request blk_mq_find_and_get_req(struct blk_mq_tags tags, · 207 unmodified lines
208		208
209	spin_lock_irqsave(&tags->lock, flags);	209	spin_lock_irqsave(&tags->lock, flags);
210	rq = tags->rqs[bitnr];	210	rq = tags->rqs[bitnr];
211	if (!rq \|\| !refcount_inc_not_zero(&rq->ref))	211	if (!rq \|\| rq->tag != bitnr \|\| !refcount_inc_not_zero(&rq->ref))
212	rq = NULL;	212	rq = NULL;
213	spin_unlock_irqrestore(&tags->lock, flags);	213	spin_unlock_irqrestore(&tags->lock, flags);
214	return rq;	214	return rq;

drivers/base/power/trace.c+10−0

 #include <linux/export.h>
 #include <linux/rtc.h>
 #include <linux/suspend.h>
+#include <linux/init.h>
 #include <linux/mc146818rtc.h>
 	const char *file = *(const char **)(tracedata + 2);
 	unsigned int user_hash_value, file_hash_value;
+	if (!x86_platform.legacy.rtc)
+		return;
 	user_hash_value = user % USERHASH;
 	file_hash_value = hash_string(lineno, file, FILEHASH);
 	set_magic_time(user_hash_value, file_hash_value, dev_hash_value);
 static int __init early_resume_init(void)
 {
+	if (!x86_platform.legacy.rtc)
+		return 0;
 	hash_value_early_read = read_magic_time();
 	register_pm_notifier(&pm_trace_nb);
 	return 0;
 	unsigned int val = hash_value_early_read;
 	unsigned int user, file, dev;
+	if (!x86_platform.legacy.rtc)
+		return 0;
 	user = val % USERHASH;
 	val = val / USERHASH;
 	file = val % FILEHASH;

drivers/cpufreq/cpufreq_governor_attr_set.c+1−1

 	if (count)
 		return count;
-	kobject_put(&attr_set->kobj);
 	mutex_destroy(&attr_set->update_lock);
+	kobject_put(&attr_set->kobj);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(gov_attr_set_put);

drivers/cpufreq/intel_pstate.c+14−8

@@ -3205,11 +3205,15 @@ static int __init intel_pstate_init(void) · 3204 unmodified lines
3205	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)	3205	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
3206	return -ENODEV;	3206	return -ENODEV;
3207		3207
3208	if (no_load)
3209	return -ENODEV;
3210
3211	id = x86_match_cpu(hwp_support_ids);	3208	id = x86_match_cpu(hwp_support_ids);
3212	if (id) {	3209	if (id) {
		3210	bool hwp_forced = intel_pstate_hwp_is_enabled();
		3211
		3212	if (hwp_forced)
		3213	pr_info("HWP enabled by BIOS\n");
		3214	else if (no_load)
		3215	return -ENODEV;
		3216
3213	copy_cpu_funcs(&core_funcs);	3217	copy_cpu_funcs(&core_funcs);
3214	/*	3218	/*
3215	* Avoid enabling HWP for processors without EPP support,	3219	* Avoid enabling HWP for processors without EPP support,
@@ -3219,8 +3223,7 @@ static int __init intel_pstate_init(void) · 3 unmodified lines
3219	* If HWP is enabled already, though, there is no choice but to	3223	* If HWP is enabled already, though, there is no choice but to
3220	* deal with it.	3224	* deal with it.
3221	*/	3225	*/
3222	if ((!no_hwp && boot_cpu_has(X86_FEATURE_HWP_EPP)) \|\|	3226	if ((!no_hwp && boot_cpu_has(X86_FEATURE_HWP_EPP)) \|\| hwp_forced) {
3223	intel_pstate_hwp_is_enabled()) {
3224	hwp_active++;	3227	hwp_active++;
3225	hwp_mode_bdw = id->driver_data;	3228	hwp_mode_bdw = id->driver_data;
3226	intel_pstate.attr = hwp_cpufreq_attrs;	3229	intel_pstate.attr = hwp_cpufreq_attrs;
@@ -3235,7 +3238,11 @@ static int __init intel_pstate_init(void) · 8 unmodified lines
3235		3238
3236	goto hwp_cpu_matched;	3239	goto hwp_cpu_matched;
3237	}	3240	}
		3241	pr_info("HWP not enabled\n");
3238	} else {	3242	} else {
		3243	if (no_load)
		3244	return -ENODEV;
		3245
3239	id = x86_match_cpu(intel_pstate_cpu_ids);	3246	id = x86_match_cpu(intel_pstate_cpu_ids);
3240	if (!id) {	3247	if (!id) {
3241	pr_info("CPU model not supported\n");	3248	pr_info("CPU model not supported\n");
@@ -3314,10 +3321,9 @@ static int __init intel_pstate_setup(char *str) · 72 unmodified lines
3314	else if (!strcmp(str, "passive"))	3321	else if (!strcmp(str, "passive"))
3315	default_driver = &intel_cpufreq;	3322	default_driver = &intel_cpufreq;
3316		3323
3317	if (!strcmp(str, "no_hwp")) {	3324	if (!strcmp(str, "no_hwp"))
3318	pr_info("HWP disabled\n");
3319	no_hwp = 1;	3325	no_hwp = 1;
3320	}	3326
3321	if (!strcmp(str, "force"))	3327	if (!strcmp(str, "force"))
3322	force_load = 1;	3328	force_load = 1;
3323	if (!strcmp(str, "hwp_only"))	3329	if (!strcmp(str, "hwp_only"))

drivers/gpu/drm/amd/amdgpu/amdgpu.h+1−1

@@ -758,7 +758,7 @@ enum amd_hw_ip_block_type { · 757 unmodified lines
758	MAX_HWIP	758	MAX_HWIP
759	};	759	};
760		760
761	#define HWIP_MAX_INSTANCE 8	761	#define HWIP_MAX_INSTANCE 10
762		762
763	struct amd_powerplay {	763	struct amd_powerplay {
764	void *pp_handle;	764	void *pp_handle;

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c+10−0

@@ -192,6 +192,16 @@ void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm) · 191 unmodified lines
192	kgd2kfd_suspend(adev->kfd.dev, run_pm);	192	kgd2kfd_suspend(adev->kfd.dev, run_pm);
193	}	193	}
194		194
		195	int amdgpu_amdkfd_resume_iommu(struct amdgpu_device *adev)
		196	{
		197	int r = 0;
		198
		199	if (adev->kfd.dev)
		200	r = kgd2kfd_resume_iommu(adev->kfd.dev);
		201
		202	return r;
		203	}
		204
195	int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm)	205	int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm)
196	{	206	{
197	int r = 0;	207	int r = 0;

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h+7−0

 void amdgpu_amdkfd_fini(void);
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
+int amdgpu_amdkfd_resume_iommu(struct amdgpu_device *adev);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
 			const void *ih_ring_entry);
 			 const struct kgd2kfd_shared_resources *gpu_resources);
 void kgd2kfd_device_exit(struct kfd_dev *kfd);
 void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm);
+int kgd2kfd_resume_iommu(struct kfd_dev *kfd);
 int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_pre_reset(struct kfd_dev *kfd);
 int kgd2kfd_post_reset(struct kfd_dev *kfd);
 {
 }
+static int __maybe_unused kgd2kfd_resume_iommu(struct kfd_dev *kfd)
+{
+	return 0;
+}
 static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
 {
 	return 0;

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c+4−6

@@ -1544,20 +1544,18 @@ int amdgpu_debugfs_init(struct amdgpu_device *adev) · 1543 unmodified lines
1544	struct dentry *ent;	1544	struct dentry *ent;
1545	int r, i;	1545	int r, i;
1546		1546
1547
1548
1549	ent = debugfs_create_file("amdgpu_preempt_ib", 0600, root, adev,	1547	ent = debugfs_create_file("amdgpu_preempt_ib", 0600, root, adev,
1550	&fops_ib_preempt);	1548	&fops_ib_preempt);
1551	if (!ent) {	1549	if (IS_ERR(ent)) {
1552	DRM_ERROR("unable to create amdgpu_preempt_ib debugsfs file\n");	1550	DRM_ERROR("unable to create amdgpu_preempt_ib debugsfs file\n");
1553	return -EIO;	1551	return PTR_ERR(ent);
1554	}	1552	}
1555		1553
1556	ent = debugfs_create_file("amdgpu_force_sclk", 0200, root, adev,	1554	ent = debugfs_create_file("amdgpu_force_sclk", 0200, root, adev,
1557	&fops_sclk_set);	1555	&fops_sclk_set);
1558	if (!ent) {	1556	if (IS_ERR(ent)) {
1559	DRM_ERROR("unable to create amdgpu_set_sclk debugsfs file\n");	1557	DRM_ERROR("unable to create amdgpu_set_sclk debugsfs file\n");
1560	return -EIO;	1558	return PTR_ERR(ent);
1561	}	1559	}
1562		1560
1563	/* Register debugfs entries for amdgpu_ttm */	1561	/* Register debugfs entries for amdgpu_ttm */

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

 	if (r)
 		goto init_failed;
+	r = amdgpu_amdkfd_resume_iommu(adev);
+	if (r)
+		goto init_failed;
 	r = amdgpu_device_ip_hw_init_phase1(adev);
 	if (r)
 		goto init_failed;
 {
 	int r;
+	r = amdgpu_amdkfd_resume_iommu(adev);
+	if (r)
+		return r;
 	r = amdgpu_device_ip_resume_phase1(adev);
 	if (r)
 		return r;
 				dev_warn(tmp_adev->dev, "asic atom init failed!");
 			} else {
 				dev_info(tmp_adev->dev, "GPU reset succeeded, trying to resume\n");
+				r = amdgpu_amdkfd_resume_iommu(tmp_adev);
+				if (r)
+					goto out;
 				r = amdgpu_device_ip_resume_phase1(tmp_adev);
 				if (r)
 					goto out;

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

@@ -598,7 +598,7 @@ void amdgpu_gmc_tmz_set(struct amdgpu_device *adev) · 597 unmodified lines
598	break;	598	break;
599	default:	599	default:
600	adev->gmc.tmz_enabled = false;	600	adev->gmc.tmz_enabled = false;
601	dev_warn(adev->dev,	601	dev_info(adev->dev,
602	"Trusted Memory Zone (TMZ) feature not supported\n");	602	"Trusted Memory Zone (TMZ) feature not supported\n");
603	break;	603	break;
604	}	604	}

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

@@ -757,7 +757,7 @@ Out: · 756 unmodified lines
757	return res;	757	return res;
758	}	758	}
759		759
760	inline uint32_t amdgpu_ras_eeprom_max_record_count(void)	760	uint32_t amdgpu_ras_eeprom_max_record_count(void)
761	{	761	{
762	return RAS_MAX_RECORD_COUNT;	762	return RAS_MAX_RECORD_COUNT;
763	}	763	}

drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.h+1−1

@@ -120,7 +120,7 @@ int amdgpu_ras_eeprom_read(struct amdgpu_ras_eeprom_control *control, · 119 unmodified lines
120	int amdgpu_ras_eeprom_append(struct amdgpu_ras_eeprom_control *control,	120	int amdgpu_ras_eeprom_append(struct amdgpu_ras_eeprom_control *control,
121	struct eeprom_table_record *records, const u32 num);	121	struct eeprom_table_record *records, const u32 num);
122		122
123	inline uint32_t amdgpu_ras_eeprom_max_record_count(void);	123	uint32_t amdgpu_ras_eeprom_max_record_count(void);
124		124
125	void amdgpu_ras_debugfs_set_ret_size(struct amdgpu_ras_eeprom_control *control);	125	void amdgpu_ras_debugfs_set_ret_size(struct amdgpu_ras_eeprom_control *control);
126		126

drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c+2−2

@@ -428,8 +428,8 @@ int amdgpu_debugfs_ring_init(struct amdgpu_device *adev, · 427 unmodified lines
428	ent = debugfs_create_file(name,	428	ent = debugfs_create_file(name,
429	S_IFREG \| S_IRUGO, root,	429	S_IFREG \| S_IRUGO, root,
430	ring, &amdgpu_debugfs_ring_fops);	430	ring, &amdgpu_debugfs_ring_fops);
431	if (!ent)	431	if (IS_ERR(ent))
432	return -ENOMEM;	432	return PTR_ERR(ent);
433		433
434	i_size_write(ent->d_inode, ring->ring_size + 12);	434	i_size_write(ent->d_inode, ring->ring_size + 12);
435	ring->ent = ent;	435	ring->ent = ent;

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c+9−9

 		goto out;
 	}
+	if (bo->type == ttm_bo_type_device &&
+	    new_mem->mem_type == TTM_PL_VRAM &&
+	    old_mem->mem_type != TTM_PL_VRAM) {
+		/* amdgpu_bo_fault_reserve_notify will re-set this if the CPU
+		 * accesses the BO after it's moved.
+		 */
+		abo->flags &= ~AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
+	}
 	if (adev->mman.buffer_funcs_enabled) {
 		if (((old_mem->mem_type == TTM_PL_SYSTEM &&
 		      new_mem->mem_type == TTM_PL_VRAM) ||
 			return r;
 	}
-	if (bo->type == ttm_bo_type_device &&
-	    new_mem->mem_type == TTM_PL_VRAM &&
-	    old_mem->mem_type != TTM_PL_VRAM) {
-		/* amdgpu_bo_fault_reserve_notify will re-set this if the CPU
-		 * accesses the BO after it's moved.
-		 */
-		abo->flags &= ~AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
-	}
 out:
 	/* update statistics */
 	atomic64_add(bo->base.size, &adev->num_bytes_moved);

drivers/gpu/drm/amd/amdkfd/kfd_device.c+36−20

 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 145,
 	.num_sdma_engines = 2,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 145,
 	.num_sdma_engines = 2,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 145,
 	.num_sdma_engines = 2,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 4,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 2,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.mqd_size_aligned = MQD_SIZE_ALIGNED,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
-	.needs_pci_atomics = false,
+	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 1,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 2,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 2,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
 	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 1,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 8,
 	.mqd_size_aligned = MQD_SIZE_ALIGNED,
 	.needs_iommu_device = false,
 	.supports_cwsr = true,
-	.needs_pci_atomics = false,
+	.needs_pci_atomics = true,
+	.no_atomic_fw_version = 92,
 	.num_sdma_engines = 1,
 	.num_xgmi_sdma_engines = 0,
 	.num_sdma_queues_per_engine = 2,
 	if (!kfd)
 		return NULL;
-	/* Allow BIF to recode atomics to PCIe 3.0 AtomicOps.
-	 * 32 and 64-bit requests are possible and must be
-	 * supported.
-	 */
-	kfd->pci_atomic_requested = amdgpu_amdkfd_have_atomics_support(kgd);
-	if (device_info->needs_pci_atomics &&
-	    !kfd->pci_atomic_requested) {
-		dev_info(kfd_device,
-			 "skipped device %x:%x, PCI rejects atomics\n",
-			 pdev->vendor, pdev->device);
-		kfree(kfd);
-		return NULL;
-	}
 	kfd->kgd = kgd;
 	kfd->device_info = device_info;
 	kfd->pdev = pdev;
 	kfd->vm_info.vmid_num_kfd = kfd->vm_info.last_vmid_kfd
 			- kfd->vm_info.first_vmid_kfd + 1;
+	/* Allow BIF to recode atomics to PCIe 3.0 AtomicOps.
+	 * 32 and 64-bit requests are possible and must be
+	 * supported.
+	 */
+	kfd->pci_atomic_requested = amdgpu_amdkfd_have_atomics_support(kfd->kgd);
+	if (!kfd->pci_atomic_requested &&
+	    kfd->device_info->needs_pci_atomics &&
+	    (!kfd->device_info->no_atomic_fw_version ||
+	     kfd->mec_fw_version < kfd->device_info->no_atomic_fw_version)) {
+		dev_info(kfd_device,
+			 "skipped device %x:%x, PCI rejects atomics %d<%d\n",
+			 kfd->pdev->vendor, kfd->pdev->device,
+			 kfd->mec_fw_version,
+			 kfd->device_info->no_atomic_fw_version);
+		return false;
+	}
 	/* Verify module parameters regarding mapped process number*/
 	if ((hws_max_conc_proc < 0)
 			|| (hws_max_conc_proc > kfd->vm_info.vmid_num_kfd)) {
 	return ret;
 }
-static int kfd_resume(struct kfd_dev *kfd)
+int kgd2kfd_resume_iommu(struct kfd_dev *kfd)
 {
 	int err = 0;
 	err = kfd_iommu_resume(kfd);
-	if (err) {
+	if (err)
 		dev_err(kfd_device,
 			"Failed to resume IOMMU for device %x:%x\n",
 			kfd->pdev->vendor, kfd->pdev->device);
-		return err;
+	return err;
-	}
+}
+static int kfd_resume(struct kfd_dev *kfd)
+{
+	int err = 0;
 	err = kfd->dqm->ops.start(kfd->dqm);
 	if (err) {

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

@@ -207,6 +207,7 @@ struct kfd_device_info { · 206 unmodified lines
207	bool supports_cwsr;	207	bool supports_cwsr;
208	bool needs_iommu_device;	208	bool needs_iommu_device;
209	bool needs_pci_atomics;	209	bool needs_pci_atomics;
		210	uint32_t no_atomic_fw_version;
210	unsigned int num_sdma_engines;	211	unsigned int num_sdma_engines;
211	unsigned int num_xgmi_sdma_engines;	212	unsigned int num_xgmi_sdma_engines;
212	unsigned int num_sdma_queues_per_engine;	213	unsigned int num_sdma_queues_per_engine;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+86−23

 	uint32_t agp_base, agp_bot, agp_top;
 	PHYSICAL_ADDRESS_LOC page_table_start, page_table_end, page_table_base;
+	memset(pa_config, 0, sizeof(*pa_config));
 	logical_addr_low  = min(adev->gmc.fb_start, adev->gmc.agp_start) >> 18;
 	pt_base = amdgpu_gmc_pd_addr(adev->gart.bo);
 		return 0;
 #if defined(CONFIG_DRM_AMD_DC_DCN)
-	work = kzalloc(sizeof(*work), GFP_ATOMIC);
+	if (dm->vblank_control_workqueue) {
-	if (!work)
+		work = kzalloc(sizeof(*work), GFP_ATOMIC);
-		return -ENOMEM;
+		if (!work)
+			return -ENOMEM;
-	INIT_WORK(&work->work, vblank_control_worker);
+		INIT_WORK(&work->work, vblank_control_worker);
-	work->dm = dm;
+		work->dm = dm;
-	work->acrtc = acrtc;
+		work->acrtc = acrtc;
-	work->enable = enable;
+		work->enable = enable;
-	if (acrtc_state->stream) {
+		if (acrtc_state->stream) {
-		dc_stream_retain(acrtc_state->stream);
+			dc_stream_retain(acrtc_state->stream);
-		work->stream = acrtc_state->stream;
+			work->stream = acrtc_state->stream;
-	}
+		}
-	queue_work(dm->vblank_control_workqueue, &work->work);
+		queue_work(dm->vblank_control_workqueue, &work->work);
+	}
 #endif
 	return 0;
 #if defined(CONFIG_DRM_AMD_DC_DCN)
 static int dm_update_mst_vcpi_slots_for_dsc(struct drm_atomic_state *state,
-					    struct dc_state *dc_state)
+					    struct dc_state *dc_state,
+					    struct dsc_mst_fairness_vars *vars)
 {
 	struct dc_stream_state *stream = NULL;
 	struct drm_connector *connector;
 	struct drm_connector_state *new_con_state;
 	struct amdgpu_dm_connector *aconnector;
 	struct dm_connector_state *dm_conn_state;
-	int i, j, clock, bpp;
+	int i, j, clock;
 	int vcpi, pbn_div, pbn = 0;
 	for_each_new_connector_in_state(state, connector, new_con_state, i) {
 		}
 		pbn_div = dm_mst_get_pbn_divider(stream->link);
-		bpp = stream->timing.dsc_cfg.bits_per_pixel;
 		clock = stream->timing.pix_clk_100hz / 10;
-		pbn = drm_dp_calc_pbn_mode(clock, bpp, true);
+		/* pbn is calculated by compute_mst_dsc_configs_for_state*/
+		for (j = 0; j < dc_state->stream_count; j++) {
+			if (vars[j].aconnector == aconnector) {
+				pbn = vars[j].pbn;
+				break;
+			}
+		}
 		vcpi = drm_dp_mst_atomic_enable_dsc(state,
 						    aconnector->port,
 						    pbn, pbn_div,
 	}
 }
+static void amdgpu_set_panel_orientation(struct drm_connector *connector)
+{
+	struct drm_encoder *encoder;
+	struct amdgpu_encoder *amdgpu_encoder;
+	const struct drm_display_mode *native_mode;
+	if (connector->connector_type != DRM_MODE_CONNECTOR_eDP &&
+	    connector->connector_type != DRM_MODE_CONNECTOR_LVDS)
+		return;
+	encoder = amdgpu_dm_connector_to_encoder(connector);
+	if (!encoder)
+		return;
+	amdgpu_encoder = to_amdgpu_encoder(encoder);
+	native_mode = &amdgpu_encoder->native_mode;
+	if (native_mode->hdisplay == 0 || native_mode->vdisplay == 0)
+		return;
+	drm_connector_set_panel_orientation_with_quirk(connector,
+						       DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
+						       native_mode->hdisplay,
+						       native_mode->vdisplay);
+}
 static void amdgpu_dm_connector_ddc_get_modes(struct drm_connector *connector,
 					      struct edid *edid)
 {
 		 * restored here.
 		 */
 		amdgpu_dm_update_freesync_caps(connector, edid);
+		amdgpu_set_panel_orientation(connector);
 	} else {
 		amdgpu_dm_connector->num_modes = 0;
 	}
 	    state->content_protection == DRM_MODE_CONTENT_PROTECTION_ENABLED)
 		state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-	/* Check if something is connected/enabled, otherwise we start hdcp but nothing is connected/enabled
+	/* Stream removed and re-enabled
-	 * hot-plug, headless s3, dpms
+	 *
+	 * Can sometimes overlap with the HPD case,
+	 * thus set update_hdcp to false to avoid
+	 * setting HDCP multiple times.
+	 *
+	 * Handles:	DESIRED -> DESIRED (Special case)
+	 */
+	if (!(old_state->crtc && old_state->crtc->enabled) &&
+		state->crtc && state->crtc->enabled &&
+		connector->state->content_protection == DRM_MODE_CONTENT_PROTECTION_DESIRED) {
+		dm_con_state->update_hdcp = false;
+		return true;
+	}
+	/* Hot-plug, headless s3, dpms
+	 *
+	 * Only start HDCP if the display is connected/enabled.
+	 * update_hdcp flag will be set to false until the next
+	 * HPD comes in.
 	 *
 	 * Handles:	DESIRED -> DESIRED (Special case)
 	 */
 		 * If PSR or idle optimizations are enabled then flush out
 		 * any pending work before hardware programming.
 		 */
-		flush_workqueue(dm->vblank_control_workqueue);
+		if (dm->vblank_control_workqueue)
+			flush_workqueue(dm->vblank_control_workqueue);
 #endif
 		bundle->stream_update.stream = acrtc_state->stream;
 		/* if there mode set or reset, disable eDP PSR */
 		if (mode_set_reset_required) {
 #if defined(CONFIG_DRM_AMD_DC_DCN)
-			flush_workqueue(dm->vblank_control_workqueue);
+			if (dm->vblank_control_workqueue)
+				flush_workqueue(dm->vblank_control_workqueue);
 #endif
 			amdgpu_dm_psr_disable_all(dm);
 		}
 	int ret, i;
 	bool lock_and_validation_needed = false;
 	struct dm_crtc_state *dm_old_crtc_state;
+#if defined(CONFIG_DRM_AMD_DC_DCN)
+	struct dsc_mst_fairness_vars vars[MAX_PIPES];
+#endif
 	trace_amdgpu_dm_atomic_check_begin(state);
 			goto fail;
 #if defined(CONFIG_DRM_AMD_DC_DCN)
-		if (!compute_mst_dsc_configs_for_state(state, dm_state->context))
+		if (!compute_mst_dsc_configs_for_state(state, dm_state->context, vars))
 			goto fail;
-		ret = dm_update_mst_vcpi_slots_for_dsc(state, dm_state->context);
+		ret = dm_update_mst_vcpi_slots_for_dsc(state, dm_state->context, vars);
 		if (ret)
 			goto fail;
 #endif
 			goto fail;
 		status = dc_validate_global_state(dc, dm_state->context, false);
 		if (status != DC_OK) {
-			DC_LOG_WARNING("DC global validation failure: %s (%d)",
+			drm_dbg_atomic(dev,
+				       "DC global validation failure: %s (%d)",
 				       dc_status_to_str(status), status);
 			ret = -EINVAL;
 			goto fail;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c+8−10

 	uint32_t num_slices_h;
 	uint32_t num_slices_v;
 	uint32_t bpp_overwrite;
-};
+	struct amdgpu_dm_connector *aconnector;
-struct dsc_mst_fairness_vars {
-	int pbn;
-	bool dsc_enabled;
-	int bpp_x16;
 };
 static int kbps_to_peak_pbn(int kbps)
 static bool compute_mst_dsc_configs_for_link(struct drm_atomic_state *state,
 					     struct dc_state *dc_state,
-					     struct dc_link *dc_link)
+					     struct dc_link *dc_link,
+					     struct dsc_mst_fairness_vars *vars)
 {
 	int i;
 	struct dc_stream_state *stream;
 	struct dsc_mst_fairness_params params[MAX_PIPES];
-	struct dsc_mst_fairness_vars vars[MAX_PIPES];
 	struct amdgpu_dm_connector *aconnector;
 	int count = 0;
 	bool debugfs_overwrite = false;
 		params[count].timing = &stream->timing;
 		params[count].sink = stream->sink;
 		aconnector = (struct amdgpu_dm_connector *)stream->dm_stream_context;
+		params[count].aconnector = aconnector;
 		params[count].port = aconnector->port;
 		params[count].clock_force_enable = aconnector->dsc_settings.dsc_force_enable;
 		if (params[count].clock_force_enable == DSC_CLK_FORCE_ENABLE)
 	}
 	/* Try no compression */
 	for (i = 0; i < count; i++) {
+		vars[i].aconnector = params[i].aconnector;
 		vars[i].pbn = kbps_to_peak_pbn(params[i].bw_range.stream_kbps);
 		vars[i].dsc_enabled = false;
 		vars[i].bpp_x16 = 0;
 }
 bool compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,
-				       struct dc_state *dc_state)
+				       struct dc_state *dc_state,
+				       struct dsc_mst_fairness_vars *vars)
 {
 	int i, j;
 	struct dc_stream_state *stream;
 			return false;
 		mutex_lock(&aconnector->mst_mgr.lock);
-		if (!compute_mst_dsc_configs_for_link(state, dc_state, stream->link)) {
+		if (!compute_mst_dsc_configs_for_link(state, dc_state, stream->link, vars)) {
 			mutex_unlock(&aconnector->mst_mgr.lock);
 			return false;
 		}

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

@@ -39,8 +39,17 @@ void · 38 unmodified lines
39	dm_dp_create_fake_mst_encoders(struct amdgpu_device *adev);	39	dm_dp_create_fake_mst_encoders(struct amdgpu_device *adev);
40		40
41	#if defined(CONFIG_DRM_AMD_DC_DCN)	41	#if defined(CONFIG_DRM_AMD_DC_DCN)
		42
		43	struct dsc_mst_fairness_vars {
		44	int pbn;
		45	bool dsc_enabled;
		46	int bpp_x16;
		47	struct amdgpu_dm_connector *aconnector;
		48	};
		49
42	bool compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,	50	bool compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,
43	struct dc_state *dc_state);	51	struct dc_state *dc_state,
		52	struct dsc_mst_fairness_vars *vars);
44	#endif	53	#endif
45		54
46	#endif	55	#endif

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

@@ -62,7 +62,7 @@ inline void dc_assert_fp_enabled(void) · 61 unmodified lines
62	depth = *pcpu;	62	depth = *pcpu;
63	put_cpu_ptr(&fpu_recursion_depth);	63	put_cpu_ptr(&fpu_recursion_depth);
64		64
65	ASSERT(depth > 1);	65	ASSERT(depth >= 1);
66	}	66	}
67		67
68	/**	68	/**

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

 int dc_link_get_backlight_level(const struct dc_link *link)
 {
 	struct abm *abm = get_abm_from_stream_res(link);
+	struct panel_cntl *panel_cntl = link->panel_cntl;
+	struct dc  *dc = link->ctx->dc;
+	struct dmcu *dmcu = dc->res_pool->dmcu;
+	bool fw_set_brightness = true;
-	if (abm == NULL || abm->funcs->get_current_backlight == NULL)
+	if (dmcu)
-		return DC_ERROR_UNEXPECTED;
+		fw_set_brightness = dmcu->funcs->is_dmcu_initialized(dmcu);
-	return (int) abm->funcs->get_current_backlight(abm);
+	if (!fw_set_brightness && panel_cntl->funcs->get_current_backlight)
+		return panel_cntl->funcs->get_current_backlight(panel_cntl);
+	else if (abm != NULL && abm->funcs->get_current_backlight != NULL)
+		return (int) abm->funcs->get_current_backlight(abm);
+	else
+		return DC_ERROR_UNEXPECTED;
 }
 int dc_link_get_target_backlight_pwm(const struct dc_link *link)

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

@@ -1,4 +1,26 @@
1	/* Copyright 2015 Advanced Micro Devices, Inc. */	1	/*
		2	* Copyright 2015 Advanced Micro Devices, Inc.
		3	*
		4	* Permission is hereby granted, free of charge, to any person obtaining a
		5	* copy of this software and associated documentation files (the "Software"),
		6	* to deal in the Software without restriction, including without limitation
		7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		8	* and/or sell copies of the Software, and to permit persons to whom the
		9	* Software is furnished to do so, subject to the following conditions:
		10	*
		11	* The above copyright notice and this permission notice shall be included in
		12	* all copies or substantial portions of the Software.
		13	*
		14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		17	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
		18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		20	* OTHER DEALINGS IN THE SOFTWARE.
		21	*
		22	* Authors: AMD
		23	*/
2	#include "dm_services.h"	24	#include "dm_services.h"
3	#include "dc.h"	25	#include "dc.h"
4	#include "dc_link_dp.h"	26	#include "dc_link_dp.h"
@@ -1840,9 +1862,13 @@ bool perform_link_training_with_retries( · 1835 unmodified lines
1840	dp_disable_link_phy(link, signal);	1862	dp_disable_link_phy(link, signal);
1841		1863
1842	/* Abort link training if failure due to sink being unplugged. */	1864	/* Abort link training if failure due to sink being unplugged. */
1843	if (status == LINK_TRAINING_ABORT)	1865	if (status == LINK_TRAINING_ABORT) {
1844	break;	1866	enum dc_connection_type type = dc_connection_none;
1845	else if (do_fallback) {	1867
		1868	dc_link_detect_sink(link, &type);
		1869	if (type == dc_connection_none)
		1870	break;
		1871	} else if (do_fallback) {
1846	decide_fallback_link_setting(*link_setting, &current_setting, status);	1872	decide_fallback_link_setting(*link_setting, &current_setting, status);
1847	/* Fail link training if reduced link bandwidth no longer meets	1873	/* Fail link training if reduced link bandwidth no longer meets
1848	* stream requirements.	1874	* stream requirements.

drivers/gpu/drm/amd/display/dc/dce/dce_panel_cntl.c+0−10

 static unsigned int dce_get_16_bit_backlight_from_pwm(struct panel_cntl *panel_cntl)
 {
 	uint64_t current_backlight;
-	uint32_t round_result;
 	uint32_t bl_period, bl_int_count;
 	uint32_t bl_pwm, fractional_duty_cycle_en;
 	uint32_t bl_period_mask, bl_pwm_mask;
 	current_backlight = div_u64(current_backlight, bl_period);
 	current_backlight = (current_backlight + 1) >> 1;
-	current_backlight = (uint64_t)(current_backlight) * bl_period;
-	round_result = (uint32_t)(current_backlight & 0xFFFFFFFF);
-	round_result = (round_result >> (bl_int_count-1)) & 1;
-	current_backlight >>= bl_int_count;
-	current_backlight += round_result;
 	return (uint32_t)(current_backlight);
 }

drivers/gpu/drm/amd/pm/inc/smu11_driver_if_cyan_skillfish.h+35−51

@@ -33,63 +33,47 @@ · 32 unmodified lines
33	#define TABLE_PMSTATUSLOG 3 // Called by Tools for Agm logging	33	#define TABLE_PMSTATUSLOG 3 // Called by Tools for Agm logging
34	#define TABLE_DPMCLOCKS 4 // Called by Driver; defined here, but not used, for backward compatible	34	#define TABLE_DPMCLOCKS 4 // Called by Driver; defined here, but not used, for backward compatible
35	#define TABLE_MOMENTARY_PM 5 // Called by Tools; defined here, but not used, for backward compatible	35	#define TABLE_MOMENTARY_PM 5 // Called by Tools; defined here, but not used, for backward compatible
36	#define TABLE_COUNT 6	36	#define TABLE_SMU_METRICS 6 // Called by Driver
		37	#define TABLE_COUNT 7
37		38
38	#define NUM_DSPCLK_LEVELS 8	39	typedef struct SmuMetricsTable_t {
39	#define NUM_SOCCLK_DPM_LEVELS 8	40	//CPU status
40	#define NUM_DCEFCLK_DPM_LEVELS 4	41	uint16_t CoreFrequency[6]; //[MHz]
41	#define NUM_FCLK_DPM_LEVELS 4	42	uint32_t CorePower[6]; //[mW]
42	#define NUM_MEMCLK_DPM_LEVELS 4	43	uint16_t CoreTemperature[6]; //[centi-Celsius]
		44	uint16_t L3Frequency[2]; //[MHz]
		45	uint16_t L3Temperature[2]; //[centi-Celsius]
		46	uint16_t C0Residency[6]; //Percentage
43		47
44	#define NUMBER_OF_PSTATES 8	48	// GFX status
45	#define NUMBER_OF_CORES 8	49	uint16_t GfxclkFrequency; //[MHz]
		50	uint16_t GfxTemperature; //[centi-Celsius]
46		51
47	typedef enum {	52	// SOC IP info
48	S3_TYPE_ENTRY,	53	uint16_t SocclkFrequency; //[MHz]
49	S5_TYPE_ENTRY,	54	uint16_t VclkFrequency; //[MHz]
50	} Sleep_Type_e;	55	uint16_t DclkFrequency; //[MHz]
		56	uint16_t MemclkFrequency; //[MHz]
51		57
52	typedef enum {	58	// power, VF info for CPU/GFX telemetry rails, and then socket power total
53	GFX_OFF = 0,	59	uint32_t Voltage[2]; //[mV] indices: VDDCR_VDD, VDDCR_GFX
54	GFX_ON = 1,	60	uint32_t Current[2]; //[mA] indices: VDDCR_VDD, VDDCR_GFX
55	} GFX_Mode_e;	61	uint32_t Power[2]; //[mW] indices: VDDCR_VDD, VDDCR_GFX
		62	uint32_t CurrentSocketPower; //[mW]
56		63
57	typedef enum {	64	uint16_t SocTemperature; //[centi-Celsius]
58	CPU_P0 = 0,	65	uint16_t EdgeTemperature;
59	CPU_P1,	66	uint16_t ThrottlerStatus;
60	CPU_P2,	67	uint16_t Spare;
61	CPU_P3,
62	CPU_P4,
63	CPU_P5,
64	CPU_P6,
65	CPU_P7
66	} CPU_PState_e;
67		68
68	typedef enum {	69	} SmuMetricsTable_t;
69	CPU_CORE0 = 0,
70	CPU_CORE1,
71	CPU_CORE2,
72	CPU_CORE3,
73	CPU_CORE4,
74	CPU_CORE5,
75	CPU_CORE6,
76	CPU_CORE7
77	} CORE_ID_e;
78		70
79	typedef enum {	71	typedef struct SmuMetrics_t {
80	DF_DPM0 = 0,	72	SmuMetricsTable_t Current;
81	DF_DPM1,	73	SmuMetricsTable_t Average;
82	DF_DPM2,	74	uint32_t SampleStartTime;
83	DF_DPM3,	75	uint32_t SampleStopTime;
84	DF_PState_Count	76	uint32_t Accnt;
85	} DF_PState_e;	77	} SmuMetrics_t;
86
87	typedef enum {
88	GFX_DPM0 = 0,
89	GFX_DPM1,
90	GFX_DPM2,
91	GFX_DPM3,
92	GFX_PState_Count
93	} GFX_PState_e;
94		78
95	#endif	79	#endif

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

 	__SMU_DUMMY_MAP(SetUclkDpmMode),		\
 	__SMU_DUMMY_MAP(LightSBR),			\
 	__SMU_DUMMY_MAP(GfxDriverResetRecovery),	\
-	__SMU_DUMMY_MAP(BoardPowerCalibration),
+	__SMU_DUMMY_MAP(BoardPowerCalibration),   \
+	__SMU_DUMMY_MAP(RequestGfxclk),           \
+	__SMU_DUMMY_MAP(ForceGfxVid),             \
+	__SMU_DUMMY_MAP(UnforceGfxVid),
 #undef __SMU_DUMMY_MAP
 #define __SMU_DUMMY_MAP(type)	SMU_MSG_##type

drivers/gpu/drm/amd/pm/inc/smu_v11_8_ppsmc.h+8−1

@@ -65,6 +65,13 @@ · 64 unmodified lines
65	#define PPSMC_MSG_SetDriverTableVMID 0x34	65	#define PPSMC_MSG_SetDriverTableVMID 0x34
66	#define PPSMC_MSG_SetSoftMinCclk 0x35	66	#define PPSMC_MSG_SetSoftMinCclk 0x35
67	#define PPSMC_MSG_SetSoftMaxCclk 0x36	67	#define PPSMC_MSG_SetSoftMaxCclk 0x36
68	#define PPSMC_Message_Count 0x37	68	#define PPSMC_MSG_GetGfxFrequency 0x37
		69	#define PPSMC_MSG_GetGfxVid 0x38
		70	#define PPSMC_MSG_ForceGfxFreq 0x39
		71	#define PPSMC_MSG_UnForceGfxFreq 0x3A
		72	#define PPSMC_MSG_ForceGfxVid 0x3B
		73	#define PPSMC_MSG_UnforceGfxVid 0x3C
		74	#define PPSMC_MSG_GetEnabledSmuFeatures 0x3D
		75	#define PPSMC_Message_Count 0x3E
69		76
70	#endif	77	#endif

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

@@ -1404,7 +1404,7 @@ static int smu_disable_dpms(struct smu_context *smu) · 1403 unmodified lines
1404	*/	1404	*/
1405	if (smu->uploading_custom_pp_table &&	1405	if (smu->uploading_custom_pp_table &&
1406	(adev->asic_type >= CHIP_NAVI10) &&	1406	(adev->asic_type >= CHIP_NAVI10) &&
1407	(adev->asic_type <= CHIP_DIMGREY_CAVEFISH))	1407	(adev->asic_type <= CHIP_BEIGE_GOBY))
1408	return smu_disable_all_features_with_exception(smu,	1408	return smu_disable_all_features_with_exception(smu,
1409	true,	1409	true,
1410	SMU_FEATURE_COUNT);	1410	SMU_FEATURE_COUNT);

drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c+6−2

@@ -771,8 +771,12 @@ static int arcturus_print_clk_levels(struct smu_context *smu, · 770 unmodified lines
771	struct smu_11_0_dpm_context *dpm_context = NULL;	771	struct smu_11_0_dpm_context *dpm_context = NULL;
772	uint32_t gen_speed, lane_width;	772	uint32_t gen_speed, lane_width;
773		773
774	if (amdgpu_ras_intr_triggered())	774	smu_cmn_get_sysfs_buf(&buf, &size);
775	return sysfs_emit(buf, "unavailable\n");	775
		776	if (amdgpu_ras_intr_triggered()) {
		777	size += sysfs_emit_at(buf, size, "unavailable\n");
		778	return size;
		779	}
776		780
777	dpm_context = smu_dpm->dpm_context;	781	dpm_context = smu_dpm->dpm_context;
778		782

drivers/gpu/drm/amd/pm/swsmu/smu11/cyan_skillfish_ppt.c+481−0

@@ -44,6 +44,27 @@ · 43 unmodified lines
44	#undef pr_info	44	#undef pr_info
45	#undef pr_debug	45	#undef pr_debug
46		46
		47	/* unit: MHz */
		48	#define CYAN_SKILLFISH_SCLK_MIN 1000
		49	#define CYAN_SKILLFISH_SCLK_MAX 2000
		50	#define CYAN_SKILLFISH_SCLK_DEFAULT 1800
		51
		52	/* unit: mV */
		53	#define CYAN_SKILLFISH_VDDC_MIN 700
		54	#define CYAN_SKILLFISH_VDDC_MAX 1129
		55	#define CYAN_SKILLFISH_VDDC_MAGIC 5118 // 0x13fe
		56
		57	static struct gfx_user_settings {
		58	uint32_t sclk;
		59	uint32_t vddc;
		60	} cyan_skillfish_user_settings;
		61
		62	#define FEATURE_MASK(feature) (1ULL << feature)
		63	#define SMC_DPM_FEATURE ( \
		64	FEATURE_MASK(FEATURE_FCLK_DPM_BIT) \| \
		65	FEATURE_MASK(FEATURE_SOC_DPM_BIT) \| \
		66	FEATURE_MASK(FEATURE_GFX_DPM_BIT))
		67
47	static struct cmn2asic_msg_mapping cyan_skillfish_message_map[SMU_MSG_MAX_COUNT] = {	68	static struct cmn2asic_msg_mapping cyan_skillfish_message_map[SMU_MSG_MAX_COUNT] = {
48	MSG_MAP(TestMessage, PPSMC_MSG_TestMessage, 0),	69	MSG_MAP(TestMessage, PPSMC_MSG_TestMessage, 0),
49	MSG_MAP(GetSmuVersion, PPSMC_MSG_GetSmuVersion, 0),	70	MSG_MAP(GetSmuVersion, PPSMC_MSG_GetSmuVersion, 0),
@@ -52,14 +73,473 @@ static struct cmn2asic_msg_mapping cyan_skillfish_message_map[SMU_MSG_MAX_COUNT] · 2 unmodified lines
52	MSG_MAP(SetDriverDramAddrLow, PPSMC_MSG_SetDriverTableDramAddrLow, 0),	73	MSG_MAP(SetDriverDramAddrLow, PPSMC_MSG_SetDriverTableDramAddrLow, 0),
53	MSG_MAP(TransferTableSmu2Dram, PPSMC_MSG_TransferTableSmu2Dram, 0),	74	MSG_MAP(TransferTableSmu2Dram, PPSMC_MSG_TransferTableSmu2Dram, 0),
54	MSG_MAP(TransferTableDram2Smu, PPSMC_MSG_TransferTableDram2Smu, 0),	75	MSG_MAP(TransferTableDram2Smu, PPSMC_MSG_TransferTableDram2Smu, 0),
		76	MSG_MAP(GetEnabledSmuFeatures, PPSMC_MSG_GetEnabledSmuFeatures, 0),
		77	MSG_MAP(RequestGfxclk, PPSMC_MSG_RequestGfxclk, 0),
		78	MSG_MAP(ForceGfxVid, PPSMC_MSG_ForceGfxVid, 0),
		79	MSG_MAP(UnforceGfxVid, PPSMC_MSG_UnforceGfxVid, 0),
		80	};
		81
		82	static struct cmn2asic_mapping cyan_skillfish_table_map[SMU_TABLE_COUNT] = {
		83	TAB_MAP_VALID(SMU_METRICS),
55	};	84	};
56		85
		86	static int cyan_skillfish_tables_init(struct smu_context *smu)
		87	{
		88	struct smu_table_context *smu_table = &smu->smu_table;
		89	struct smu_table *tables = smu_table->tables;
		90
		91	SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS,
		92	sizeof(SmuMetrics_t),
		93	PAGE_SIZE,
		94	AMDGPU_GEM_DOMAIN_VRAM);
		95
		96	smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
		97	if (!smu_table->metrics_table)
		98	goto err0_out;
		99
		100	smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v2_2);
		101	smu_table->gpu_metrics_table = kzalloc(smu_table->gpu_metrics_table_size, GFP_KERNEL);
		102	if (!smu_table->gpu_metrics_table)
		103	goto err1_out;
		104
		105	smu_table->metrics_time = 0;
		106
		107	return 0;
		108
		109	err1_out:
		110	smu_table->gpu_metrics_table_size = 0;
		111	kfree(smu_table->metrics_table);
		112	err0_out:
		113	return -ENOMEM;
		114	}
		115
		116	static int cyan_skillfish_init_smc_tables(struct smu_context *smu)
		117	{
		118	int ret = 0;
		119
		120	ret = cyan_skillfish_tables_init(smu);
		121	if (ret)
		122	return ret;
		123
		124	return smu_v11_0_init_smc_tables(smu);
		125	}
		126
		127	static int cyan_skillfish_finit_smc_tables(struct smu_context *smu)
		128	{
		129	struct smu_table_context *smu_table = &smu->smu_table;
		130
		131	kfree(smu_table->metrics_table);
		132	smu_table->metrics_table = NULL;
		133
		134	kfree(smu_table->gpu_metrics_table);
		135	smu_table->gpu_metrics_table = NULL;
		136	smu_table->gpu_metrics_table_size = 0;
		137
		138	smu_table->metrics_time = 0;
		139
		140	return 0;
		141	}
		142
		143	static int
		144	cyan_skillfish_get_smu_metrics_data(struct smu_context *smu,
		145	MetricsMember_t member,
		146	uint32_t *value)
		147	{
		148	struct smu_table_context *smu_table = &smu->smu_table;
		149	SmuMetrics_t metrics = (SmuMetrics_t )smu_table->metrics_table;
		150	int ret = 0;
		151
		152	mutex_lock(&smu->metrics_lock);
		153
		154	ret = smu_cmn_get_metrics_table_locked(smu, NULL, false);
		155	if (ret) {
		156	mutex_unlock(&smu->metrics_lock);
		157	return ret;
		158	}
		159
		160	switch (member) {
		161	case METRICS_CURR_GFXCLK:
		162	*value = metrics->Current.GfxclkFrequency;
		163	break;
		164	case METRICS_CURR_SOCCLK:
		165	*value = metrics->Current.SocclkFrequency;
		166	break;
		167	case METRICS_CURR_VCLK:
		168	*value = metrics->Current.VclkFrequency;
		169	break;
		170	case METRICS_CURR_DCLK:
		171	*value = metrics->Current.DclkFrequency;
		172	break;
		173	case METRICS_CURR_UCLK:
		174	*value = metrics->Current.MemclkFrequency;
		175	break;
		176	case METRICS_AVERAGE_SOCKETPOWER:
		177	*value = (metrics->Current.CurrentSocketPower << 8) /
		178	1000;
		179	break;
		180	case METRICS_TEMPERATURE_EDGE:
		181	value = metrics->Current.GfxTemperature / 100
		182	SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
		183	break;
		184	case METRICS_TEMPERATURE_HOTSPOT:
		185	value = metrics->Current.SocTemperature / 100
		186	SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
		187	break;
		188	case METRICS_VOLTAGE_VDDSOC:
		189	*value = metrics->Current.Voltage[0];
		190	break;
		191	case METRICS_VOLTAGE_VDDGFX:
		192	*value = metrics->Current.Voltage[1];
		193	break;
		194	case METRICS_THROTTLER_STATUS:
		195	*value = metrics->Current.ThrottlerStatus;
		196	break;
		197	default:
		198	*value = UINT_MAX;
		199	break;
		200	}
		201
		202	mutex_unlock(&smu->metrics_lock);
		203
		204	return ret;
		205	}
		206
		207	static int cyan_skillfish_read_sensor(struct smu_context *smu,
		208	enum amd_pp_sensors sensor,
		209	void *data,
		210	uint32_t *size)
		211	{
		212	int ret = 0;
		213
		214	if (!data \|\| !size)
		215	return -EINVAL;
		216
		217	mutex_lock(&smu->sensor_lock);
		218
		219	switch (sensor) {
		220	case AMDGPU_PP_SENSOR_GFX_SCLK:
		221	ret = cyan_skillfish_get_smu_metrics_data(smu,
		222	METRICS_CURR_GFXCLK,
		223	(uint32_t *)data);
		224	(uint32_t )data *= 100;
		225	*size = 4;
		226	break;
		227	case AMDGPU_PP_SENSOR_GFX_MCLK:
		228	ret = cyan_skillfish_get_smu_metrics_data(smu,
		229	METRICS_CURR_UCLK,
		230	(uint32_t *)data);
		231	(uint32_t )data *= 100;
		232	*size = 4;
		233	break;
		234	case AMDGPU_PP_SENSOR_GPU_POWER:
		235	ret = cyan_skillfish_get_smu_metrics_data(smu,
		236	METRICS_AVERAGE_SOCKETPOWER,
		237	(uint32_t *)data);
		238	*size = 4;
		239	break;
		240	case AMDGPU_PP_SENSOR_HOTSPOT_TEMP:
		241	ret = cyan_skillfish_get_smu_metrics_data(smu,
		242	METRICS_TEMPERATURE_HOTSPOT,
		243	(uint32_t *)data);
		244	*size = 4;
		245	break;
		246	case AMDGPU_PP_SENSOR_EDGE_TEMP:
		247	ret = cyan_skillfish_get_smu_metrics_data(smu,
		248	METRICS_TEMPERATURE_EDGE,
		249	(uint32_t *)data);
		250	*size = 4;
		251	break;
		252	case AMDGPU_PP_SENSOR_VDDNB:
		253	ret = cyan_skillfish_get_smu_metrics_data(smu,
		254	METRICS_VOLTAGE_VDDSOC,
		255	(uint32_t *)data);
		256	*size = 4;
		257	break;
		258	case AMDGPU_PP_SENSOR_VDDGFX:
		259	ret = cyan_skillfish_get_smu_metrics_data(smu,
		260	METRICS_VOLTAGE_VDDGFX,
		261	(uint32_t *)data);
		262	*size = 4;
		263	break;
		264	default:
		265	ret = -EOPNOTSUPP;
		266	break;
		267	}
		268
		269	mutex_unlock(&smu->sensor_lock);
		270
		271	return ret;
		272	}
		273
		274	static int cyan_skillfish_get_current_clk_freq(struct smu_context *smu,
		275	enum smu_clk_type clk_type,
		276	uint32_t *value)
		277	{
		278	MetricsMember_t member_type;
		279
		280	switch (clk_type) {
		281	case SMU_GFXCLK:
		282	case SMU_SCLK:
		283	member_type = METRICS_CURR_GFXCLK;
		284	break;
		285	case SMU_FCLK:
		286	case SMU_MCLK:
		287	member_type = METRICS_CURR_UCLK;
		288	break;
		289	case SMU_SOCCLK:
		290	member_type = METRICS_CURR_SOCCLK;
		291	break;
		292	case SMU_VCLK:
		293	member_type = METRICS_CURR_VCLK;
		294	break;
		295	case SMU_DCLK:
		296	member_type = METRICS_CURR_DCLK;
		297	break;
		298	default:
		299	return -EINVAL;
		300	}
		301
		302	return cyan_skillfish_get_smu_metrics_data(smu, member_type, value);
		303	}
		304
		305	static int cyan_skillfish_print_clk_levels(struct smu_context *smu,
		306	enum smu_clk_type clk_type,
		307	char *buf)
		308	{
		309	int ret = 0, size = 0;
		310	uint32_t cur_value = 0;
		311
		312	smu_cmn_get_sysfs_buf(&buf, &size);
		313
		314	switch (clk_type) {
		315	case SMU_OD_SCLK:
		316	ret = cyan_skillfish_get_smu_metrics_data(smu, METRICS_CURR_GFXCLK, &cur_value);
		317	if (ret)
		318	return ret;
		319	size += sysfs_emit_at(buf, size,"%s:\n", "OD_SCLK");
		320	size += sysfs_emit_at(buf, size, "0: %uMhz *\n", cur_value);
		321	break;
		322	case SMU_OD_VDDC_CURVE:
		323	ret = cyan_skillfish_get_smu_metrics_data(smu, METRICS_VOLTAGE_VDDGFX, &cur_value);
		324	if (ret)
		325	return ret;
		326	size += sysfs_emit_at(buf, size,"%s:\n", "OD_VDDC");
		327	size += sysfs_emit_at(buf, size, "0: %umV *\n", cur_value);
		328	break;
		329	case SMU_OD_RANGE:
		330	size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
		331	size += sysfs_emit_at(buf, size, "SCLK: %7uMhz %10uMhz\n",
		332	CYAN_SKILLFISH_SCLK_MIN, CYAN_SKILLFISH_SCLK_MAX);
		333	size += sysfs_emit_at(buf, size, "VDDC: %7umV %10umV\n",
		334	CYAN_SKILLFISH_VDDC_MIN, CYAN_SKILLFISH_VDDC_MAX);
		335	break;
		336	case SMU_GFXCLK:
		337	case SMU_SCLK:
		338	case SMU_FCLK:
		339	case SMU_MCLK:
		340	case SMU_SOCCLK:
		341	case SMU_VCLK:
		342	case SMU_DCLK:
		343	ret = cyan_skillfish_get_current_clk_freq(smu, clk_type, &cur_value);
		344	if (ret)
		345	return ret;
		346	size += sysfs_emit_at(buf, size, "0: %uMhz *\n", cur_value);
		347	break;
		348	default:
		349	dev_warn(smu->adev->dev, "Unsupported clock type\n");
		350	return ret;
		351	}
		352
		353	return size;
		354	}
		355
		356	static bool cyan_skillfish_is_dpm_running(struct smu_context *smu)
		357	{
		358	struct amdgpu_device *adev = smu->adev;
		359	int ret = 0;
		360	uint32_t feature_mask[2];
		361	uint64_t feature_enabled;
		362
		363	/* we need to re-init after suspend so return false */
		364	if (adev->in_suspend)
		365	return false;
		366
		367	ret = smu_cmn_get_enabled_32_bits_mask(smu, feature_mask, 2);
		368
		369	if (ret)
		370	return false;
		371
		372	feature_enabled = (uint64_t)feature_mask[0] \|
		373	((uint64_t)feature_mask[1] << 32);
		374
		375	return !!(feature_enabled & SMC_DPM_FEATURE);
		376	}
		377
		378	static ssize_t cyan_skillfish_get_gpu_metrics(struct smu_context *smu,
		379	void **table)
		380	{
		381	struct smu_table_context *smu_table = &smu->smu_table;
		382	struct gpu_metrics_v2_2 *gpu_metrics =
		383	(struct gpu_metrics_v2_2 *)smu_table->gpu_metrics_table;
		384	SmuMetrics_t metrics;
		385	int i, ret = 0;
		386
		387	ret = smu_cmn_get_metrics_table(smu, &metrics, true);
		388	if (ret)
		389	return ret;
		390
		391	smu_cmn_init_soft_gpu_metrics(gpu_metrics, 2, 2);
		392
		393	gpu_metrics->temperature_gfx = metrics.Current.GfxTemperature;
		394	gpu_metrics->temperature_soc = metrics.Current.SocTemperature;
		395
		396	gpu_metrics->average_socket_power = metrics.Current.CurrentSocketPower;
		397	gpu_metrics->average_soc_power = metrics.Current.Power[0];
		398	gpu_metrics->average_gfx_power = metrics.Current.Power[1];
		399
		400	gpu_metrics->average_gfxclk_frequency = metrics.Average.GfxclkFrequency;
		401	gpu_metrics->average_socclk_frequency = metrics.Average.SocclkFrequency;
		402	gpu_metrics->average_uclk_frequency = metrics.Average.MemclkFrequency;
		403	gpu_metrics->average_fclk_frequency = metrics.Average.MemclkFrequency;
		404	gpu_metrics->average_vclk_frequency = metrics.Average.VclkFrequency;
		405	gpu_metrics->average_dclk_frequency = metrics.Average.DclkFrequency;
		406
		407	gpu_metrics->current_gfxclk = metrics.Current.GfxclkFrequency;
		408	gpu_metrics->current_socclk = metrics.Current.SocclkFrequency;
		409	gpu_metrics->current_uclk = metrics.Current.MemclkFrequency;
		410	gpu_metrics->current_fclk = metrics.Current.MemclkFrequency;
		411	gpu_metrics->current_vclk = metrics.Current.VclkFrequency;
		412	gpu_metrics->current_dclk = metrics.Current.DclkFrequency;
		413
		414	for (i = 0; i < 6; i++) {
		415	gpu_metrics->temperature_core[i] = metrics.Current.CoreTemperature[i];
		416	gpu_metrics->average_core_power[i] = metrics.Average.CorePower[i];
		417	gpu_metrics->current_coreclk[i] = metrics.Current.CoreFrequency[i];
		418	}
		419
		420	for (i = 0; i < 2; i++) {
		421	gpu_metrics->temperature_l3[i] = metrics.Current.L3Temperature[i];
		422	gpu_metrics->current_l3clk[i] = metrics.Current.L3Frequency[i];
		423	}
		424
		425	gpu_metrics->throttle_status = metrics.Current.ThrottlerStatus;
		426	gpu_metrics->system_clock_counter = ktime_get_boottime_ns();
		427
		428	table = (void )gpu_metrics;
		429
		430	return sizeof(struct gpu_metrics_v2_2);
		431	}
		432
		433	static int cyan_skillfish_od_edit_dpm_table(struct smu_context *smu,
		434	enum PP_OD_DPM_TABLE_COMMAND type,
		435	long input[], uint32_t size)
		436	{
		437	int ret = 0;
		438	uint32_t vid;
		439
		440	switch (type) {
		441	case PP_OD_EDIT_VDDC_CURVE:
		442	if (size != 3 \|\| input[0] != 0) {
		443	dev_err(smu->adev->dev, "Invalid parameter!\n");
		444	return -EINVAL;
		445	}
		446
		447	if (input[1] <= CYAN_SKILLFISH_SCLK_MIN \|\|
		448	input[1] > CYAN_SKILLFISH_SCLK_MAX) {
		449	dev_err(smu->adev->dev, "Invalid sclk! Valid sclk range: %uMHz - %uMhz\n",
		450	CYAN_SKILLFISH_SCLK_MIN, CYAN_SKILLFISH_SCLK_MAX);
		451	return -EINVAL;
		452	}
		453
		454	if (input[2] <= CYAN_SKILLFISH_VDDC_MIN \|\|
		455	input[2] > CYAN_SKILLFISH_VDDC_MAX) {
		456	dev_err(smu->adev->dev, "Invalid vddc! Valid vddc range: %umV - %umV\n",
		457	CYAN_SKILLFISH_VDDC_MIN, CYAN_SKILLFISH_VDDC_MAX);
		458	return -EINVAL;
		459	}
		460
		461	cyan_skillfish_user_settings.sclk = input[1];
		462	cyan_skillfish_user_settings.vddc = input[2];
		463
		464	break;
		465	case PP_OD_RESTORE_DEFAULT_TABLE:
		466	if (size != 0) {
		467	dev_err(smu->adev->dev, "Invalid parameter!\n");
		468	return -EINVAL;
		469	}
		470
		471	cyan_skillfish_user_settings.sclk = CYAN_SKILLFISH_SCLK_DEFAULT;
		472	cyan_skillfish_user_settings.vddc = CYAN_SKILLFISH_VDDC_MAGIC;
		473
		474	break;
		475	case PP_OD_COMMIT_DPM_TABLE:
		476	if (size != 0) {
		477	dev_err(smu->adev->dev, "Invalid parameter!\n");
		478	return -EINVAL;
		479	}
		480
		481	if (cyan_skillfish_user_settings.sclk < CYAN_SKILLFISH_SCLK_MIN \|\|
		482	cyan_skillfish_user_settings.sclk > CYAN_SKILLFISH_SCLK_MAX) {
		483	dev_err(smu->adev->dev, "Invalid sclk! Valid sclk range: %uMHz - %uMhz\n",
		484	CYAN_SKILLFISH_SCLK_MIN, CYAN_SKILLFISH_SCLK_MAX);
		485	return -EINVAL;
		486	}
		487
		488	if ((cyan_skillfish_user_settings.vddc != CYAN_SKILLFISH_VDDC_MAGIC) &&
		489	(cyan_skillfish_user_settings.vddc < CYAN_SKILLFISH_VDDC_MIN \|\|
		490	cyan_skillfish_user_settings.vddc > CYAN_SKILLFISH_VDDC_MAX)) {
		491	dev_err(smu->adev->dev, "Invalid vddc! Valid vddc range: %umV - %umV\n",
		492	CYAN_SKILLFISH_VDDC_MIN, CYAN_SKILLFISH_VDDC_MAX);
		493	return -EINVAL;
		494	}
		495
		496	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_RequestGfxclk,
		497	cyan_skillfish_user_settings.sclk, NULL);
		498	if (ret) {
		499	dev_err(smu->adev->dev, "Set sclk failed!\n");
		500	return ret;
		501	}
		502
		503	if (cyan_skillfish_user_settings.vddc == CYAN_SKILLFISH_VDDC_MAGIC) {
		504	ret = smu_cmn_send_smc_msg(smu, SMU_MSG_UnforceGfxVid, NULL);
		505	if (ret) {
		506	dev_err(smu->adev->dev, "Unforce vddc failed!\n");
		507	return ret;
		508	}
		509	} else {
		510	/*
		511	* PMFW accepts SVI2 VID code, convert voltage to VID:
		512	* vid = (uint32_t)((1.55 - voltage) * 160.0 + 0.00001)
		513	*/
		514	vid = (1550 - cyan_skillfish_user_settings.vddc) * 160 / 1000;
		515	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ForceGfxVid, vid, NULL);
		516	if (ret) {
		517	dev_err(smu->adev->dev, "Force vddc failed!\n");
		518	return ret;
		519	}
		520	}
		521
		522	break;
		523	default:
		524	return -EOPNOTSUPP;
		525	}
		526
		527	return ret;
		528	}
		529
57	static const struct pptable_funcs cyan_skillfish_ppt_funcs = {	530	static const struct pptable_funcs cyan_skillfish_ppt_funcs = {
58		531
59	.check_fw_status = smu_v11_0_check_fw_status,	532	.check_fw_status = smu_v11_0_check_fw_status,
60	.check_fw_version = smu_v11_0_check_fw_version,	533	.check_fw_version = smu_v11_0_check_fw_version,
61	.init_power = smu_v11_0_init_power,	534	.init_power = smu_v11_0_init_power,
62	.fini_power = smu_v11_0_fini_power,	535	.fini_power = smu_v11_0_fini_power,
		536	.init_smc_tables = cyan_skillfish_init_smc_tables,
		537	.fini_smc_tables = cyan_skillfish_finit_smc_tables,
		538	.read_sensor = cyan_skillfish_read_sensor,
		539	.print_clk_levels = cyan_skillfish_print_clk_levels,
		540	.is_dpm_running = cyan_skillfish_is_dpm_running,
		541	.get_gpu_metrics = cyan_skillfish_get_gpu_metrics,
		542	.od_edit_dpm_table = cyan_skillfish_od_edit_dpm_table,
63	.register_irq_handler = smu_v11_0_register_irq_handler,	543	.register_irq_handler = smu_v11_0_register_irq_handler,
64	.notify_memory_pool_location = smu_v11_0_notify_memory_pool_location,	544	.notify_memory_pool_location = smu_v11_0_notify_memory_pool_location,
65	.send_smc_msg_with_param = smu_cmn_send_smc_msg_with_param,	545	.send_smc_msg_with_param = smu_cmn_send_smc_msg_with_param,
@@ -72,5 +552,6 @@ void cyan_skillfish_set_ppt_funcs(struct smu_context *smu) · 6 unmodified lines
72	{	552	{
73	smu->ppt_funcs = &cyan_skillfish_ppt_funcs;	553	smu->ppt_funcs = &cyan_skillfish_ppt_funcs;
74	smu->message_map = cyan_skillfish_message_map;	554	smu->message_map = cyan_skillfish_message_map;
		555	smu->table_map = cyan_skillfish_table_map;
75	smu->is_apu = true;	556	smu->is_apu = true;
76	}	557	}

drivers/gpu/drm/amd/pm/swsmu/smu11/navi10_ppt.c+25−3

 	struct smu_11_0_overdrive_table *od_settings = smu->od_settings;
 	uint32_t min_value, max_value;
+	smu_cmn_get_sysfs_buf(&buf, &size);
 	switch (clk_type) {
 	case SMU_GFXCLK:
 	case SMU_SCLK:
 	case SMU_OD_RANGE:
 		if (!smu->od_enabled || !od_table || !od_settings)
 			break;
-		size = sysfs_emit(buf, "%s:\n", "OD_RANGE");
+		size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
 		if (navi10_od_feature_is_supported(od_settings, SMU_11_0_ODCAP_GFXCLK_LIMITS)) {
 			navi10_od_setting_get_range(od_settings, SMU_11_0_ODSETTING_GFXCLKFMIN,
 {
 	struct amdgpu_device *adev = smu->adev;
-	if (adev->in_runpm)
+	/*
+	 * This aims the case below:
+	 *   amdgpu driver loaded -> runpm suspend kicked -> sound driver loaded
+	 *
+	 * For NAVI10 and later ASICs, we rely on PMFW to handle the runpm. To
+	 * make that possible, PMFW needs to acknowledge the dstate transition
+	 * process for both gfx(function 0) and audio(function 1) function of
+	 * the ASIC.
+	 *
+	 * The PCI device's initial runpm status is RUNPM_SUSPENDED. So as the
+	 * device representing the audio function of the ASIC. And that means
+	 * even if the sound driver(snd_hda_intel) was not loaded yet, it's still
+	 * possible runpm suspend kicked on the ASIC. However without the dstate
+	 * transition notification from audio function, pmfw cannot handle the
+	 * BACO in/exit correctly. And that will cause driver hang on runpm
+	 * resuming.
+	 *
+	 * To address this, we revert to legacy message way(driver masters the
+	 * timing for BACO in/exit) on sound driver missing.
+	 */
+	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev))
 		return smu_v11_0_baco_set_armd3_sequence(smu, BACO_SEQ_BACO);
 	else
 		return smu_v11_0_baco_enter(smu);
 {
 	struct amdgpu_device *adev = smu->adev;
-	if (adev->in_runpm) {
+	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
 		/* Wait for PMFW handling for the Dstate change */
 		msleep(10);
 		return smu_v11_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);

drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c+5−3

 	uint32_t min_value, max_value;
 	uint32_t smu_version;
+	smu_cmn_get_sysfs_buf(&buf, &size);
 	switch (clk_type) {
 	case SMU_GFXCLK:
 	case SMU_SCLK:
 		if (!smu->od_enabled || !od_table || !od_settings)
 			break;
-		size = sysfs_emit(buf, "%s:\n", "OD_RANGE");
+		size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
 		if (sienna_cichlid_is_od_feature_supported(od_settings, SMU_11_0_7_ODCAP_GFXCLK_LIMITS)) {
 			sienna_cichlid_get_od_setting_range(od_settings, SMU_11_0_7_ODSETTING_GFXCLKFMIN,
 {
 	struct amdgpu_device *adev = smu->adev;
-	if (adev->in_runpm)
+	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev))
 		return smu_v11_0_baco_set_armd3_sequence(smu, BACO_SEQ_BACO);
 	else
 		return smu_v11_0_baco_enter(smu);
 {
 	struct amdgpu_device *adev = smu->adev;
-	if (adev->in_runpm) {
+	if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
 		/* Wait for PMFW handling for the Dstate change */
 		msleep(10);
 		return smu_v11_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c+10−6

 	if (ret)
 		return ret;
+	smu_cmn_get_sysfs_buf(&buf, &size);
 	switch (clk_type) {
 	case SMU_OD_SCLK:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "%s:\n", "OD_SCLK");
+			size += sysfs_emit_at(buf, size, "%s:\n", "OD_SCLK");
 			size += sysfs_emit_at(buf, size, "0: %10uMhz\n",
 			(smu->gfx_actual_hard_min_freq > 0) ? smu->gfx_actual_hard_min_freq : smu->gfx_default_hard_min_freq);
 			size += sysfs_emit_at(buf, size, "1: %10uMhz\n",
 		break;
 	case SMU_OD_CCLK:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "CCLK_RANGE in Core%d:\n",  smu->cpu_core_id_select);
+			size += sysfs_emit_at(buf, size, "CCLK_RANGE in Core%d:\n",  smu->cpu_core_id_select);
 			size += sysfs_emit_at(buf, size, "0: %10uMhz\n",
 			(smu->cpu_actual_soft_min_freq > 0) ? smu->cpu_actual_soft_min_freq : smu->cpu_default_soft_min_freq);
 			size += sysfs_emit_at(buf, size, "1: %10uMhz\n",
 		break;
 	case SMU_OD_RANGE:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "%s:\n", "OD_RANGE");
+			size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
 			size += sysfs_emit_at(buf, size, "SCLK: %7uMhz %10uMhz\n",
 				smu->gfx_default_hard_min_freq, smu->gfx_default_soft_max_freq);
 			size += sysfs_emit_at(buf, size, "CCLK: %7uMhz %10uMhz\n",
 	if (ret)
 		return ret;
+	smu_cmn_get_sysfs_buf(&buf, &size);
 	switch (clk_type) {
 	case SMU_OD_SCLK:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "%s:\n", "OD_SCLK");
+			size += sysfs_emit_at(buf, size, "%s:\n", "OD_SCLK");
 			size += sysfs_emit_at(buf, size, "0: %10uMhz\n",
 			(smu->gfx_actual_hard_min_freq > 0) ? smu->gfx_actual_hard_min_freq : smu->gfx_default_hard_min_freq);
 			size += sysfs_emit_at(buf, size, "1: %10uMhz\n",
 		break;
 	case SMU_OD_CCLK:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "CCLK_RANGE in Core%d:\n",  smu->cpu_core_id_select);
+			size += sysfs_emit_at(buf, size, "CCLK_RANGE in Core%d:\n",  smu->cpu_core_id_select);
 			size += sysfs_emit_at(buf, size, "0: %10uMhz\n",
 			(smu->cpu_actual_soft_min_freq > 0) ? smu->cpu_actual_soft_min_freq : smu->cpu_default_soft_min_freq);
 			size += sysfs_emit_at(buf, size, "1: %10uMhz\n",
 		break;
 	case SMU_OD_RANGE:
 		if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {
-			size = sysfs_emit(buf, "%s:\n", "OD_RANGE");
+			size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
 			size += sysfs_emit_at(buf, size, "SCLK: %7uMhz %10uMhz\n",
 				smu->gfx_default_hard_min_freq, smu->gfx_default_soft_max_freq);
 			size += sysfs_emit_at(buf, size, "CCLK: %7uMhz %10uMhz\n",

drivers/gpu/drm/amd/pm/swsmu/smu12/renoir_ppt.c+2−0

@@ -497,6 +497,8 @@ static int renoir_print_clk_levels(struct smu_context *smu, · 496 unmodified lines
497	if (ret)	497	if (ret)
498	return ret;	498	return ret;
499		499
		500	smu_cmn_get_sysfs_buf(&buf, &size);
		501
500	switch (clk_type) {	502	switch (clk_type) {
501	case SMU_OD_RANGE:	503	case SMU_OD_RANGE:
502	if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {	504	if (smu_dpm_ctx->dpm_level == AMD_DPM_FORCED_LEVEL_MANUAL) {

drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c+8−4

@@ -733,15 +733,19 @@ static int aldebaran_print_clk_levels(struct smu_context *smu, · 732 unmodified lines
733	uint32_t freq_values[3] = {0};	733	uint32_t freq_values[3] = {0};
734	uint32_t min_clk, max_clk;	734	uint32_t min_clk, max_clk;
735		735
736	if (amdgpu_ras_intr_triggered())	736	smu_cmn_get_sysfs_buf(&buf, &size);
737	return sysfs_emit(buf, "unavailable\n");	737
		738	if (amdgpu_ras_intr_triggered()) {
		739	size += sysfs_emit_at(buf, size, "unavailable\n");
		740	return size;
		741	}
738		742
739	dpm_context = smu_dpm->dpm_context;	743	dpm_context = smu_dpm->dpm_context;
740		744
741	switch (type) {	745	switch (type) {
742		746
743	case SMU_OD_SCLK:	747	case SMU_OD_SCLK:
744	size = sysfs_emit(buf, "%s:\n", "GFXCLK");	748	size += sysfs_emit_at(buf, size, "%s:\n", "GFXCLK");
745	fallthrough;	749	fallthrough;
746	case SMU_SCLK:	750	case SMU_SCLK:
747	ret = aldebaran_get_current_clk_freq_by_table(smu, SMU_GFXCLK, &now);	751	ret = aldebaran_get_current_clk_freq_by_table(smu, SMU_GFXCLK, &now);
@@ -795,7 +799,7 @@ static int aldebaran_print_clk_levels(struct smu_context *smu, · 47 unmodified lines
795	break;	799	break;
796		800
797	case SMU_OD_MCLK:	801	case SMU_OD_MCLK:
798	size = sysfs_emit(buf, "%s:\n", "MCLK");	802	size += sysfs_emit_at(buf, size, "%s:\n", "MCLK");
799	fallthrough;	803	fallthrough;
800	case SMU_MCLK:	804	case SMU_MCLK:
801	ret = aldebaran_get_current_clk_freq_by_table(smu, SMU_UCLK, &now);	805	ret = aldebaran_get_current_clk_freq_by_table(smu, SMU_UCLK, &now);

drivers/gpu/drm/amd/pm/swsmu/smu13/yellow_carp_ppt.c+4−2

 	int i, size = 0, ret = 0;
 	uint32_t cur_value = 0, value = 0, count = 0;
+	smu_cmn_get_sysfs_buf(&buf, &size);
 	switch (clk_type) {
 	case SMU_OD_SCLK:
-		size = sysfs_emit(buf, "%s:\n", "OD_SCLK");
+		size += sysfs_emit_at(buf, size, "%s:\n", "OD_SCLK");
 		size += sysfs_emit_at(buf, size, "0: %10uMhz\n",
 		(smu->gfx_actual_hard_min_freq > 0) ? smu->gfx_actual_hard_min_freq : smu->gfx_default_hard_min_freq);
 		size += sysfs_emit_at(buf, size, "1: %10uMhz\n",
 		(smu->gfx_actual_soft_max_freq > 0) ? smu->gfx_actual_soft_max_freq : smu->gfx_default_soft_max_freq);
 		break;
 	case SMU_OD_RANGE:
-		size = sysfs_emit(buf, "%s:\n", "OD_RANGE");
+		size += sysfs_emit_at(buf, size, "%s:\n", "OD_RANGE");
 		size += sysfs_emit_at(buf, size, "SCLK: %7uMhz %10uMhz\n",
 						smu->gfx_default_hard_min_freq, smu->gfx_default_soft_max_freq);
 		break;

drivers/gpu/drm/amd/pm/swsmu/smu_cmn.c+21−0

@@ -1053,3 +1053,24 @@ int smu_cmn_set_mp1_state(struct smu_context *smu, · 1052 unmodified lines
1053		1053
1054	return ret;	1054	return ret;
1055	}	1055	}
		1056
		1057	bool smu_cmn_is_audio_func_enabled(struct amdgpu_device *adev)
		1058	{
		1059	struct pci_dev *p = NULL;
		1060	bool snd_driver_loaded;
		1061
		1062	/*
		1063	* If the ASIC comes with no audio function, we always assume
		1064	* it is "enabled".
		1065	*/
		1066	p = pci_get_domain_bus_and_slot(pci_domain_nr(adev->pdev->bus),
		1067	adev->pdev->bus->number, 1);
		1068	if (!p)
		1069	return true;
		1070
		1071	snd_driver_loaded = pci_is_enabled(p) ? true : false;
		1072
		1073	pci_dev_put(p);
		1074
		1075	return snd_driver_loaded;
		1076	}

drivers/gpu/drm/amd/pm/swsmu/smu_cmn.h+15−0

@@ -110,5 +110,20 @@ void smu_cmn_init_soft_gpu_metrics(void *table, uint8_t frev, uint8_t crev); · 109 unmodified lines
110	int smu_cmn_set_mp1_state(struct smu_context *smu,	110	int smu_cmn_set_mp1_state(struct smu_context *smu,
111	enum pp_mp1_state mp1_state);	111	enum pp_mp1_state mp1_state);
112		112
		113	/*
		114	* Helper function to make sysfs_emit_at() happy. Align buf to
		115	* the current page boundary and record the offset.
		116	*/
		117	static inline void smu_cmn_get_sysfs_buf(char *buf, int offset)
		118	{
		119	if (!*buf \|\| !offset)
		120	return;
		121
		122	offset = offset_in_page(buf);
		123	buf -= offset;
		124	}
		125
		126	bool smu_cmn_is_audio_func_enabled(struct amdgpu_device *adev);
		127
113	#endif	128	#endif
114	#endif	129	#endif

drivers/gpu/drm/etnaviv/etnaviv_buffer.c+1−2

@@ -397,8 +397,7 @@ void etnaviv_buffer_queue(struct etnaviv_gpu *gpu, u32 exec_state, · 396 unmodified lines
397	if (switch_mmu_context) {	397	if (switch_mmu_context) {
398	struct etnaviv_iommu_context *old_context = gpu->mmu_context;	398	struct etnaviv_iommu_context *old_context = gpu->mmu_context;
399		399
400	etnaviv_iommu_context_get(mmu_context);	400	gpu->mmu_context = etnaviv_iommu_context_get(mmu_context);
401	gpu->mmu_context = mmu_context;
402	etnaviv_iommu_context_put(old_context);	401	etnaviv_iommu_context_put(old_context);
403	}	402	}
404		403

drivers/gpu/drm/etnaviv/etnaviv_gem.c+1−2

@@ -294,8 +294,7 @@ struct etnaviv_vram_mapping *etnaviv_gem_mapping_get( · 293 unmodified lines
294	list_del(&mapping->obj_node);	294	list_del(&mapping->obj_node);
295	}	295	}
296		296
297	etnaviv_iommu_context_get(mmu_context);	297	mapping->context = etnaviv_iommu_context_get(mmu_context);
298	mapping->context = mmu_context;
299	mapping->use = 1;	298	mapping->use = 1;
300		299
301	ret = etnaviv_iommu_map_gem(mmu_context, etnaviv_obj,	300	ret = etnaviv_iommu_map_gem(mmu_context, etnaviv_obj,

drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c+1−2

@@ -532,8 +532,7 @@ int etnaviv_ioctl_gem_submit(struct drm_device dev, void data, · 531 unmodified lines
532	goto err_submit_objects;	532	goto err_submit_objects;
533		533
534	submit->ctx = file->driver_priv;	534	submit->ctx = file->driver_priv;
535	etnaviv_iommu_context_get(submit->ctx->mmu);	535	submit->mmu_context = etnaviv_iommu_context_get(submit->ctx->mmu);
536	submit->mmu_context = submit->ctx->mmu;
537	submit->exec_state = args->exec_state;	536	submit->exec_state = args->exec_state;
538	submit->flags = args->flags;	537	submit->flags = args->flags;
539		538

drivers/gpu/drm/etnaviv/etnaviv_gpu.c+25−18

@@ -569,6 +569,12 @@ static int etnaviv_hw_reset(struct etnaviv_gpu *gpu) · 568 unmodified lines
569	/* We rely on the GPU running, so program the clock */	569	/* We rely on the GPU running, so program the clock */
570	etnaviv_gpu_update_clock(gpu);	570	etnaviv_gpu_update_clock(gpu);
571		571
		572	gpu->fe_running = false;
		573	gpu->exec_state = -1;
		574	if (gpu->mmu_context)
		575	etnaviv_iommu_context_put(gpu->mmu_context);
		576	gpu->mmu_context = NULL;
		577
572	return 0;	578	return 0;
573	}	579	}
574		580
@@ -637,19 +643,23 @@ void etnaviv_gpu_start_fe(struct etnaviv_gpu *gpu, u32 address, u16 prefetch) · 62 unmodified lines
637	VIVS_MMUv2_SEC_COMMAND_CONTROL_ENABLE \|	643	VIVS_MMUv2_SEC_COMMAND_CONTROL_ENABLE \|
638	VIVS_MMUv2_SEC_COMMAND_CONTROL_PREFETCH(prefetch));	644	VIVS_MMUv2_SEC_COMMAND_CONTROL_PREFETCH(prefetch));
639	}	645	}
		646
		647	gpu->fe_running = true;
640	}	648	}
641		649
642	static void etnaviv_gpu_start_fe_idleloop(struct etnaviv_gpu *gpu)	650	static void etnaviv_gpu_start_fe_idleloop(struct etnaviv_gpu *gpu,
		651	struct etnaviv_iommu_context *context)
643	{	652	{
644	u32 address = etnaviv_cmdbuf_get_va(&gpu->buffer,
645	&gpu->mmu_context->cmdbuf_mapping);
646	u16 prefetch;	653	u16 prefetch;
		654	u32 address;
647		655
648	/* setup the MMU */	656	/* setup the MMU */
649	etnaviv_iommu_restore(gpu, gpu->mmu_context);	657	etnaviv_iommu_restore(gpu, context);
650		658
651	/* Start command processor */	659	/* Start command processor */
652	prefetch = etnaviv_buffer_init(gpu);	660	prefetch = etnaviv_buffer_init(gpu);
		661	address = etnaviv_cmdbuf_get_va(&gpu->buffer,
		662	&gpu->mmu_context->cmdbuf_mapping);
653		663
654	etnaviv_gpu_start_fe(gpu, address, prefetch);	664	etnaviv_gpu_start_fe(gpu, address, prefetch);
655	}	665	}
@@ -832,7 +842,6 @@ int etnaviv_gpu_init(struct etnaviv_gpu *gpu) · 176 unmodified lines
832	/* Now program the hardware */	842	/* Now program the hardware */
833	mutex_lock(&gpu->lock);	843	mutex_lock(&gpu->lock);
834	etnaviv_gpu_hw_init(gpu);	844	etnaviv_gpu_hw_init(gpu);
835	gpu->exec_state = -1;
836	mutex_unlock(&gpu->lock);	845	mutex_unlock(&gpu->lock);
837		846
838	pm_runtime_mark_last_busy(gpu->dev);	847	pm_runtime_mark_last_busy(gpu->dev);
@@ -1057,8 +1066,6 @@ void etnaviv_gpu_recover_hang(struct etnaviv_gpu *gpu) · 218 unmodified lines
1057	spin_unlock(&gpu->event_spinlock);	1066	spin_unlock(&gpu->event_spinlock);
1058		1067
1059	etnaviv_gpu_hw_init(gpu);	1068	etnaviv_gpu_hw_init(gpu);
1060	gpu->exec_state = -1;
1061	gpu->mmu_context = NULL;
1062		1069
1063	mutex_unlock(&gpu->lock);	1070	mutex_unlock(&gpu->lock);
1064	pm_runtime_mark_last_busy(gpu->dev);	1071	pm_runtime_mark_last_busy(gpu->dev);
@@ -1370,14 +1377,12 @@ struct dma_fence etnaviv_gpu_submit(struct etnaviv_gem_submit submit) · 305 unmodified lines
1370	goto out_unlock;	1377	goto out_unlock;
1371	}	1378	}
1372		1379
1373	if (!gpu->mmu_context) {	1380	if (!gpu->fe_running)
1374	etnaviv_iommu_context_get(submit->mmu_context);	1381	etnaviv_gpu_start_fe_idleloop(gpu, submit->mmu_context);
1375	gpu->mmu_context = submit->mmu_context;	1382
1376	etnaviv_gpu_start_fe_idleloop(gpu);	1383	if (submit->prev_mmu_context)
1377	} else {	1384	etnaviv_iommu_context_put(submit->prev_mmu_context);
1378	etnaviv_iommu_context_get(gpu->mmu_context);	1385	submit->prev_mmu_context = etnaviv_iommu_context_get(gpu->mmu_context);
1379	submit->prev_mmu_context = gpu->mmu_context;
1380	}
1381		1386
1382	if (submit->nr_pmrs) {	1387	if (submit->nr_pmrs) {
1383	gpu->event[event[1]].sync_point = &sync_point_perfmon_sample_pre;	1388	gpu->event[event[1]].sync_point = &sync_point_perfmon_sample_pre;
@@ -1579,7 +1584,7 @@ int etnaviv_gpu_wait_idle(struct etnaviv_gpu *gpu, unsigned int timeout_ms) · 195 unmodified lines
1579		1584
1580	static int etnaviv_gpu_hw_suspend(struct etnaviv_gpu *gpu)	1585	static int etnaviv_gpu_hw_suspend(struct etnaviv_gpu *gpu)
1581	{	1586	{
1582	if (gpu->initialized && gpu->mmu_context) {	1587	if (gpu->initialized && gpu->fe_running) {
1583	/* Replace the last WAIT with END */	1588	/* Replace the last WAIT with END */
1584	mutex_lock(&gpu->lock);	1589	mutex_lock(&gpu->lock);
1585	etnaviv_buffer_end(gpu);	1590	etnaviv_buffer_end(gpu);
@@ -1592,8 +1597,7 @@ static int etnaviv_gpu_hw_suspend(struct etnaviv_gpu *gpu) · 6 unmodified lines
1592	*/	1597	*/
1593	etnaviv_gpu_wait_idle(gpu, 100);	1598	etnaviv_gpu_wait_idle(gpu, 100);
1594		1599
1595	etnaviv_iommu_context_put(gpu->mmu_context);	1600	gpu->fe_running = false;
1596	gpu->mmu_context = NULL;
1597	}	1601	}
1598		1602
1599	gpu->exec_state = -1;	1603	gpu->exec_state = -1;
@@ -1741,6 +1745,9 @@ static void etnaviv_gpu_unbind(struct device dev, struct device master, · 141 unmodified lines
1741	etnaviv_gpu_hw_suspend(gpu);	1745	etnaviv_gpu_hw_suspend(gpu);
1742	#endif	1746	#endif
1743		1747
		1748	if (gpu->mmu_context)
		1749	etnaviv_iommu_context_put(gpu->mmu_context);
		1750
1744	if (gpu->initialized) {	1751	if (gpu->initialized) {
1745	etnaviv_cmdbuf_free(&gpu->buffer);	1752	etnaviv_cmdbuf_free(&gpu->buffer);
1746	etnaviv_iommu_global_fini(gpu);	1753	etnaviv_iommu_global_fini(gpu);

drivers/gpu/drm/etnaviv/etnaviv_gpu.h+1−0

@@ -101,6 +101,7 @@ struct etnaviv_gpu { · 100 unmodified lines
101	struct workqueue_struct *wq;	101	struct workqueue_struct *wq;
102	struct drm_gpu_scheduler sched;	102	struct drm_gpu_scheduler sched;
103	bool initialized;	103	bool initialized;
		104	bool fe_running;
104		105
105	/* 'ring'-buffer: */	106	/* 'ring'-buffer: */
106	struct etnaviv_cmdbuf buffer;	107	struct etnaviv_cmdbuf buffer;

drivers/gpu/drm/etnaviv/etnaviv_iommu.c+4−0

 	struct etnaviv_iommuv1_context *v1_context = to_v1_context(context);
 	u32 pgtable;
+	if (gpu->mmu_context)
+		etnaviv_iommu_context_put(gpu->mmu_context);
+	gpu->mmu_context = etnaviv_iommu_context_get(context);
 	/* set base addresses */
 	gpu_write(gpu, VIVS_MC_MEMORY_BASE_ADDR_RA, context->global->memory_base);
 	gpu_write(gpu, VIVS_MC_MEMORY_BASE_ADDR_FE, context->global->memory_base);

drivers/gpu/drm/etnaviv/etnaviv_iommu_v2.c+8−0

 	if (gpu_read(gpu, VIVS_MMUv2_CONTROL) & VIVS_MMUv2_CONTROL_ENABLE)
 		return;
+	if (gpu->mmu_context)
+		etnaviv_iommu_context_put(gpu->mmu_context);
+	gpu->mmu_context = etnaviv_iommu_context_get(context);
 	prefetch = etnaviv_buffer_config_mmuv2(gpu,
 				(u32)v2_context->mtlb_dma,
 				(u32)context->global->bad_page_dma);
 	if (gpu_read(gpu, VIVS_MMUv2_SEC_CONTROL) & VIVS_MMUv2_SEC_CONTROL_ENABLE)
 		return;
+	if (gpu->mmu_context)
+		etnaviv_iommu_context_put(gpu->mmu_context);
+	gpu->mmu_context = etnaviv_iommu_context_get(context);
 	gpu_write(gpu, VIVS_MMUv2_PTA_ADDRESS_LOW,
 		  lower_32_bits(context->global->v2.pta_dma));
 	gpu_write(gpu, VIVS_MMUv2_PTA_ADDRESS_HIGH,

drivers/gpu/drm/etnaviv/etnaviv_mmu.c+1−0

@@ -199,6 +199,7 @@ static int etnaviv_iommu_find_iova(struct etnaviv_iommu_context *context, · 198 unmodified lines
199	*/	199	*/
200	list_for_each_entry_safe(m, n, &list, scan_node) {	200	list_for_each_entry_safe(m, n, &list, scan_node) {
201	etnaviv_iommu_remove_mapping(context, m);	201	etnaviv_iommu_remove_mapping(context, m);
		202	etnaviv_iommu_context_put(m->context);
202	m->context = NULL;	203	m->context = NULL;
203	list_del_init(&m->mmu_node);	204	list_del_init(&m->mmu_node);
204	list_del_init(&m->scan_node);	205	list_del_init(&m->scan_node);

drivers/gpu/drm/etnaviv/etnaviv_mmu.h+3−1

 struct etnaviv_iommu_context *
 etnaviv_iommu_context_init(struct etnaviv_iommu_global *global,
 			   struct etnaviv_cmdbuf_suballoc *suballoc);
-static inline void etnaviv_iommu_context_get(struct etnaviv_iommu_context *ctx)
+static inline struct etnaviv_iommu_context *
+etnaviv_iommu_context_get(struct etnaviv_iommu_context *ctx)
 {
 	kref_get(&ctx->refcount);
+	return ctx;
 }
 void etnaviv_iommu_context_put(struct etnaviv_iommu_context *ctx);
 void etnaviv_iommu_restore(struct etnaviv_gpu *gpu,

drivers/gpu/drm/i915/Makefile+0−1

@@ -19,7 +19,6 @@ subdir-ccflags-y += $(call cc-disable-warning, missing-field-initializers) · 18 unmodified lines
19	subdir-ccflags-y += $(call cc-disable-warning, unused-but-set-variable)	19	subdir-ccflags-y += $(call cc-disable-warning, unused-but-set-variable)
20	# clang warnings	20	# clang warnings
21	subdir-ccflags-y += $(call cc-disable-warning, sign-compare)	21	subdir-ccflags-y += $(call cc-disable-warning, sign-compare)
22	subdir-ccflags-y += $(call cc-disable-warning, sometimes-uninitialized)
23	subdir-ccflags-y += $(call cc-disable-warning, initializer-overrides)	22	subdir-ccflags-y += $(call cc-disable-warning, initializer-overrides)
24	subdir-ccflags-y += $(call cc-disable-warning, frame-address)	23	subdir-ccflags-y += $(call cc-disable-warning, frame-address)
25	subdir-ccflags-$(CONFIG_DRM_I915_WERROR) += -Werror	24	subdir-ccflags-$(CONFIG_DRM_I915_WERROR) += -Werror

drivers/gpu/drm/i915/display/intel_dp.c+4−1

 	 */
 	if (drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_DPCD_REV,
 			     intel_dp->edp_dpcd, sizeof(intel_dp->edp_dpcd)) ==
-			     sizeof(intel_dp->edp_dpcd))
+			     sizeof(intel_dp->edp_dpcd)) {
 		drm_dbg_kms(&dev_priv->drm, "eDP DPCD: %*ph\n",
 			    (int)sizeof(intel_dp->edp_dpcd),
 			    intel_dp->edp_dpcd);
+		intel_dp->use_max_params = intel_dp->edp_dpcd[0] < DP_EDP_14;
+	}
 	/*
 	 * This has to be called after intel_dp->edp_dpcd is filled, PSR checks
 	 * for SET_POWER_CAPABLE bit in intel_dp->edp_dpcd[1]

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

@@ -848,7 +848,7 @@ intel_dp_link_train_all_phys(struct intel_dp *intel_dp, · 847 unmodified lines
848	}	848	}
849		849
850	if (ret)	850	if (ret)
851	intel_dp_link_train_phy(intel_dp, crtc_state, DP_PHY_DPRX);	851	ret = intel_dp_link_train_phy(intel_dp, crtc_state, DP_PHY_DPRX);
852		852
853	if (intel_dp->set_idle_link_train)	853	if (intel_dp->set_idle_link_train)
854	intel_dp->set_idle_link_train(intel_dp, crtc_state);	854	intel_dp->set_idle_link_train(intel_dp, crtc_state);

drivers/gpu/drm/i915/gem/i915_gem_context.c+3−3

 	trace_i915_context_free(ctx);
 	GEM_BUG_ON(!i915_gem_context_is_closed(ctx));
+	if (ctx->syncobj)
+		drm_syncobj_put(ctx->syncobj);
 	mutex_destroy(&ctx->engines_mutex);
 	mutex_destroy(&ctx->lut_mutex);
 	if (vm)
 		i915_vm_close(vm);
-	if (ctx->syncobj)
-		drm_syncobj_put(ctx->syncobj);
 	ctx->file_priv = ERR_PTR(-EBADF);
 	/*

drivers/gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c+4−3

 		err = PTR_ERR(import);
 		goto out_dmabuf;
 	}
+	import_obj = to_intel_bo(import);
 	if (import != &obj->base) {
 		pr_err("i915_gem_prime_import created a new object!\n");
 		err = -EINVAL;
 		goto out_import;
 	}
-	import_obj = to_intel_bo(import);
 	i915_gem_object_lock(import_obj, NULL);
 	err = __i915_gem_object_get_pages(import_obj);
 		pr_err("i915_gem_prime_import failed with the wrong err=%ld\n",
 		       PTR_ERR(import));
 		err = PTR_ERR(import);
+	} else {
+		err = 0;
 	}
 	dma_buf_put(dmabuf);
 		err = PTR_ERR(import);
 		goto out_dmabuf;
 	}
+	import_obj = to_intel_bo(import);
 	if (import == &obj->base) {
 		pr_err("i915_gem_prime_import reused gem object!\n");
 		goto out_import;
 	}
-	import_obj = to_intel_bo(import);
 	i915_gem_object_lock(import_obj, NULL);
 	err = __i915_gem_object_get_pages(import_obj);
 	if (err) {

drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c+20−6

 	return I915_MMAP_TYPE_GTT;
 }
+static struct drm_i915_gem_object *
+create_sys_or_internal(struct drm_i915_private *i915,
+		       unsigned long size)
+{
+	if (HAS_LMEM(i915)) {
+		struct intel_memory_region *sys_region =
+			i915->mm.regions[INTEL_REGION_SMEM];
+		return __i915_gem_object_create_user(i915, size, &sys_region, 1);
+	}
+	return i915_gem_object_create_internal(i915, size);
+}
 static bool assert_mmap_offset(struct drm_i915_private *i915,
 			       unsigned long size,
 			       int expected)
 	u64 offset;
 	int ret;
-	obj = i915_gem_object_create_internal(i915, size);
+	obj = create_sys_or_internal(i915, size);
 	if (IS_ERR(obj))
 		return expected && expected == PTR_ERR(obj);
 	struct drm_mm_node *hole, *next;
 	int loop, err = 0;
 	u64 offset;
+	int enospc = HAS_LMEM(i915) ? -ENXIO : -ENOSPC;
 	/* Disable background reaper */
 	disable_retire_worker(i915);
 	}
 	/* Too large */
-	if (!assert_mmap_offset(i915, 2 * PAGE_SIZE, -ENOSPC)) {
+	if (!assert_mmap_offset(i915, 2 * PAGE_SIZE, enospc)) {
 		pr_err("Unexpectedly succeeded in inserting too large object into single page hole\n");
 		err = -EINVAL;
 		goto out;
 	}
 	/* Fill the hole, further allocation attempts should then fail */
-	obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
+	obj = create_sys_or_internal(i915, PAGE_SIZE);
 	if (IS_ERR(obj)) {
 		err = PTR_ERR(obj);
 		pr_err("Unable to create object for reclaimed hole\n");
 		goto err_obj;
 	}
-	if (!assert_mmap_offset(i915, PAGE_SIZE, -ENOSPC)) {
+	if (!assert_mmap_offset(i915, PAGE_SIZE, enospc)) {
 		pr_err("Unexpectedly succeeded in inserting object into no holes!\n");
 		err = -EINVAL;
 		goto err_obj;
 static bool can_mmap(struct drm_i915_gem_object *obj, enum i915_mmap_type type)
 {
-	struct drm_i915_private *i915 = to_i915(obj->base.dev);
 	bool no_map;
-	if (HAS_LMEM(i915))
+	if (obj->ops->mmap_offset)
 		return type == I915_MMAP_TYPE_FIXED;
 	else if (type == I915_MMAP_TYPE_FIXED)
 		return false;

drivers/gpu/drm/i915/gt/intel_rps.c+7−1

 u32 intel_rps_read_punit_req(struct intel_rps *rps)
 {
 	struct intel_uncore *uncore = rps_to_uncore(rps);
+	struct intel_runtime_pm *rpm = rps_to_uncore(rps)->rpm;
+	intel_wakeref_t wakeref;
+	u32 freq = 0;
-	return intel_uncore_read(uncore, GEN6_RPNSWREQ);
+	with_intel_runtime_pm_if_in_use(rpm, wakeref)
+		freq = intel_uncore_read(uncore, GEN6_RPNSWREQ);
+	return freq;
 }
 static u32 intel_rps_get_req(u32 pureq)

drivers/gpu/drm/i915/gt/uc/intel_uc.c+3−8

 	__uc_free_load_err_log(uc);
 }
-static inline bool guc_communication_enabled(struct intel_guc *guc)
-{
-	return intel_guc_ct_enabled(&guc->ct);
-}
 /*
  * Events triggered while CT buffers are disabled are logged in the SCRATCH_15
  * register using the same bits used in the CT message payload. Since our
 static void guc_handle_mmio_msg(struct intel_guc *guc)
 {
 	/* we need communication to be enabled to reply to GuC */
-	GEM_BUG_ON(!guc_communication_enabled(guc));
+	GEM_BUG_ON(!intel_guc_ct_enabled(&guc->ct));
 	spin_lock_irq(&guc->irq_lock);
 	if (guc->mmio_msg) {
 	struct drm_i915_private *i915 = gt->i915;
 	int ret;
-	GEM_BUG_ON(guc_communication_enabled(guc));
+	GEM_BUG_ON(intel_guc_ct_enabled(&guc->ct));
 	ret = i915_inject_probe_error(i915, -ENXIO);
 	if (ret)
 		return 0;
 	/* Make sure we enable communication if and only if it's disabled */
-	GEM_BUG_ON(enable_communication == guc_communication_enabled(guc));
+	GEM_BUG_ON(enable_communication == intel_guc_ct_enabled(&guc->ct));
 	if (enable_communication)
 		guc_enable_communication(guc);

drivers/gpu/drm/nouveau/nvkm/engine/device/ctrl.c+1−1

@@ -57,7 +57,7 @@ nvkm_control_mthd_pstate_info(struct nvkm_control ctrl, void data, u32 size) · 56 unmodified lines
57	args->v0.count = 0;	57	args->v0.count = 0;
58	args->v0.ustate_ac = NVIF_CONTROL_PSTATE_INFO_V0_USTATE_DISABLE;	58	args->v0.ustate_ac = NVIF_CONTROL_PSTATE_INFO_V0_USTATE_DISABLE;
59	args->v0.ustate_dc = NVIF_CONTROL_PSTATE_INFO_V0_USTATE_DISABLE;	59	args->v0.ustate_dc = NVIF_CONTROL_PSTATE_INFO_V0_USTATE_DISABLE;
60	args->v0.pwrsrc = -ENOSYS;	60	args->v0.pwrsrc = -ENODEV;
61	args->v0.pstate = NVIF_CONTROL_PSTATE_INFO_V0_PSTATE_UNKNOWN;	61	args->v0.pstate = NVIF_CONTROL_PSTATE_INFO_V0_PSTATE_UNKNOWN;
62	}	62	}
63		63

drivers/gpu/drm/radeon/radeon_kms.c+1−1

@@ -119,7 +119,7 @@ int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags) · 118 unmodified lines
119	#endif	119	#endif
120		120
121	if (pci_find_capability(pdev, PCI_CAP_ID_AGP))	121	if (pci_find_capability(pdev, PCI_CAP_ID_AGP))
122	rdev->agp = radeon_agp_head_init(rdev->ddev);	122	rdev->agp = radeon_agp_head_init(dev);
123	if (rdev->agp) {	123	if (rdev->agp) {
124	rdev->agp->agp_mtrr = arch_phys_wc_add(	124	rdev->agp->agp_mtrr = arch_phys_wc_add(
125	rdev->agp->agp_info.aper_base,	125	rdev->agp->agp_info.aper_base,

drivers/gpu/drm/vc4/vc4_hdmi.c+23−61

 	struct vc4_hdmi *vc4_hdmi = connector_to_vc4_hdmi(connector);
 	bool connected = false;
-	WARN_ON(pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev));
 	if (vc4_hdmi->hpd_gpio &&
 	    gpiod_get_value_cansleep(vc4_hdmi->hpd_gpio)) {
 		connected = true;
 			}
 		}
-		pm_runtime_put(&vc4_hdmi->pdev->dev);
 		return connector_status_connected;
 	}
 	cec_phys_addr_invalidate(vc4_hdmi->cec_adap);
-	pm_runtime_put(&vc4_hdmi->pdev->dev);
 	return connector_status_disconnected;
 }
 	struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
 	struct drm_connector *connector = &vc4_hdmi->connector;
 	struct drm_connector_state *cstate = connector->state;
-	struct drm_crtc *crtc = cstate->crtc;
+	struct drm_crtc *crtc = encoder->crtc;
 	const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
 	union hdmi_infoframe frame;
 	int ret;
 static void vc4_hdmi_enable_scrambling(struct drm_encoder *encoder)
 {
+	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
 	struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
-	struct drm_connector *connector = &vc4_hdmi->connector;
-	struct drm_connector_state *cstate = connector->state;
-	struct drm_crtc *crtc = cstate->crtc;
-	struct drm_display_mode *mode = &crtc->state->adjusted_mode;
 	if (!vc4_hdmi_supports_scrambling(encoder, mode))
 		return;
 static void vc4_hdmi_disable_scrambling(struct drm_encoder *encoder)
 {
 	struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
-	struct drm_connector *connector = &vc4_hdmi->connector;
+	struct drm_crtc *crtc = encoder->crtc;
-	struct drm_connector_state *cstate = connector->state;
 	/*
-	 * At boot, connector->state will be NULL. Since we don't know the
+	 * At boot, encoder->crtc will be NULL. Since we don't know the
 	 * state of the scrambler and in order to avoid any
 	 * inconsistency, let's disable it all the time.
 	 */
-	if (cstate && !vc4_hdmi_supports_scrambling(encoder, &cstate->crtc->mode))
+	if (crtc && !vc4_hdmi_supports_scrambling(encoder, &crtc->mode))
 		return;
-	if (cstate && !vc4_hdmi_mode_needs_scrambling(&cstate->crtc->mode))
+	if (crtc && !vc4_hdmi_mode_needs_scrambling(&crtc->mode))
 		return;
 	if (delayed_work_pending(&vc4_hdmi->scrambling_work))
 		vc4_hdmi->variant->phy_disable(vc4_hdmi);
 	clk_disable_unprepare(vc4_hdmi->pixel_bvb_clock);
+	clk_disable_unprepare(vc4_hdmi->hsm_clock);
 	clk_disable_unprepare(vc4_hdmi->pixel_clock);
 	ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
 		vc4_hdmi_encoder_get_connector_state(encoder, state);
 	struct vc4_hdmi_connector_state *vc4_conn_state =
 		conn_state_to_vc4_hdmi_conn_state(conn_state);
-	struct drm_crtc_state *crtc_state =
+	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
-		drm_atomic_get_new_crtc_state(state, conn_state->crtc);
-	struct drm_display_mode *mode = &crtc_state->adjusted_mode;
 	struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
 	unsigned long bvb_rate, pixel_rate, hsm_rate;
 	int ret;
 		return;
 	}
+	ret = clk_prepare_enable(vc4_hdmi->hsm_clock);
+	if (ret) {
+		DRM_ERROR("Failed to turn on HSM clock: %d\n", ret);
+		clk_disable_unprepare(vc4_hdmi->pixel_clock);
+		return;
+	}
 	vc4_hdmi_cec_update_clk_div(vc4_hdmi);
 	if (pixel_rate > 297000000)
 	ret = clk_set_min_rate(vc4_hdmi->pixel_bvb_clock, bvb_rate);
 	if (ret) {
 		DRM_ERROR("Failed to set pixel bvb clock rate: %d\n", ret);
+		clk_disable_unprepare(vc4_hdmi->hsm_clock);
 		clk_disable_unprepare(vc4_hdmi->pixel_clock);
 		return;
 	}
 	ret = clk_prepare_enable(vc4_hdmi->pixel_bvb_clock);
 	if (ret) {
 		DRM_ERROR("Failed to turn on pixel bvb clock: %d\n", ret);
+		clk_disable_unprepare(vc4_hdmi->hsm_clock);
 		clk_disable_unprepare(vc4_hdmi->pixel_clock);
 		return;
 	}
 static void vc4_hdmi_encoder_pre_crtc_enable(struct drm_encoder *encoder,
 					     struct drm_atomic_state *state)
 {
-	struct drm_connector_state *conn_state =
+	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
-		vc4_hdmi_encoder_get_connector_state(encoder, state);
-	struct drm_crtc_state *crtc_state =
-		drm_atomic_get_new_crtc_state(state, conn_state->crtc);
-	struct drm_display_mode *mode = &crtc_state->adjusted_mode;
 	struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
 	struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
 static void vc4_hdmi_encoder_post_crtc_enable(struct drm_encoder *encoder,
 					      struct drm_atomic_state *state)
 {
-	struct drm_connector_state *conn_state =
+	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
-		vc4_hdmi_encoder_get_connector_state(encoder, state);
-	struct drm_crtc_state *crtc_state =
-		drm_atomic_get_new_crtc_state(state, conn_state->crtc);
-	struct drm_display_mode *mode = &crtc_state->adjusted_mode;
 	struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
 	struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
 	bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
 static void vc4_hdmi_set_n_cts(struct vc4_hdmi *vc4_hdmi, unsigned int samplerate)
 {
-	struct drm_connector *connector = &vc4_hdmi->connector;
+	struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
-	struct drm_crtc *crtc = connector->state->crtc;
+	struct drm_crtc *crtc = encoder->crtc;
 	const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
 	u32 n, cts;
 	u64 tmp;
 static int vc4_hdmi_audio_startup(struct device *dev, void *data)
 {
 	struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
-	struct drm_connector *connector = &vc4_hdmi->connector;
+	struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
 	/*
 	 * If the HDMI encoder hasn't probed, or the encoder is
 	 * currently in DVI mode, treat the codec dai as missing.
 	 */
-	if (!connector->state || !(HDMI_READ(HDMI_RAM_PACKET_CONFIG) &
+	if (!encoder->crtc || !(HDMI_READ(HDMI_RAM_PACKET_CONFIG) &
 				VC4_HDMI_RAM_PACKET_ENABLE))
 		return -ENODEV;
 	return 0;
 }
-#ifdef CONFIG_PM
-static int vc4_hdmi_runtime_suspend(struct device *dev)
-{
-	struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
-	clk_disable_unprepare(vc4_hdmi->hsm_clock);
-	return 0;
-}
-static int vc4_hdmi_runtime_resume(struct device *dev)
-{
-	struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
-	int ret;
-	ret = clk_prepare_enable(vc4_hdmi->hsm_clock);
-	if (ret)
-		return ret;
-	return 0;
-}
-#endif
 static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data)
 {
 	const struct vc4_hdmi_variant *variant = of_device_get_match_data(dev);
 	{}
 };
-static const struct dev_pm_ops vc4_hdmi_pm_ops = {
-	SET_RUNTIME_PM_OPS(vc4_hdmi_runtime_suspend,
-			   vc4_hdmi_runtime_resume,
-			   NULL)
-};
 struct platform_driver vc4_hdmi_driver = {
 	.probe = vc4_hdmi_dev_probe,
 	.remove = vc4_hdmi_dev_remove,
 	.driver = {
 		.name = "vc4_hdmi",
 		.of_match_table = vc4_hdmi_dt_match,
-		.pm = &vc4_hdmi_pm_ops,
 	},
 };

drivers/net/dsa/b53/b53_mdio.c+19−2

@@ -351,9 +351,25 @@ static int b53_mdio_probe(struct mdio_device *mdiodev) · 350 unmodified lines
351	static void b53_mdio_remove(struct mdio_device *mdiodev)	351	static void b53_mdio_remove(struct mdio_device *mdiodev)
352	{	352	{
353	struct b53_device *dev = dev_get_drvdata(&mdiodev->dev);	353	struct b53_device *dev = dev_get_drvdata(&mdiodev->dev);
354	struct dsa_switch *ds = dev->ds;
355		354
356	dsa_unregister_switch(ds);	355	if (!dev)
		356	return;
		357
		358	b53_switch_remove(dev);
		359
		360	dev_set_drvdata(&mdiodev->dev, NULL);
		361	}
		362
		363	static void b53_mdio_shutdown(struct mdio_device *mdiodev)
		364	{
		365	struct b53_device *dev = dev_get_drvdata(&mdiodev->dev);
		366
		367	if (!dev)
		368	return;
		369
		370	b53_switch_shutdown(dev);
		371
		372	dev_set_drvdata(&mdiodev->dev, NULL);
357	}	373	}
358		374
359	static const struct of_device_id b53_of_match[] = {	375	static const struct of_device_id b53_of_match[] = {
@@ -373,6 +389,7 @@ MODULE_DEVICE_TABLE(of, b53_of_match); · 13 unmodified lines
373	static struct mdio_driver b53_mdio_driver = {	389	static struct mdio_driver b53_mdio_driver = {
374	.probe = b53_mdio_probe,	390	.probe = b53_mdio_probe,
375	.remove = b53_mdio_remove,	391	.remove = b53_mdio_remove,
		392	.shutdown = b53_mdio_shutdown,
376	.mdiodrv.driver = {	393	.mdiodrv.driver = {
377	.name = "bcm53xx",	394	.name = "bcm53xx",
378	.of_match_table = b53_of_match,	395	.of_match_table = b53_of_match,

drivers/net/dsa/b53/b53_mmap.c+13−0

 	if (dev)
 		b53_switch_remove(dev);
+	platform_set_drvdata(pdev, NULL);
 	return 0;
 }
+static void b53_mmap_shutdown(struct platform_device *pdev)
+{
+	struct b53_device *dev = platform_get_drvdata(pdev);
+	if (dev)
+		b53_switch_shutdown(dev);
+	platform_set_drvdata(pdev, NULL);
+}
 static const struct of_device_id b53_mmap_of_table[] = {
 	{ .compatible = "brcm,bcm3384-switch" },
 	{ .compatible = "brcm,bcm6328-switch" },
 static struct platform_driver b53_mmap_driver = {
 	.probe = b53_mmap_probe,
 	.remove = b53_mmap_remove,
+	.shutdown = b53_mmap_shutdown,
 	.driver = {
 		.name = "b53-switch",
 		.of_match_table = b53_mmap_of_table,

drivers/net/dsa/b53/b53_priv.h+5−0

 	dsa_unregister_switch(dev->ds);
 }
+static inline void b53_switch_shutdown(struct b53_device *dev)
+{
+	dsa_switch_shutdown(dev->ds);
+}
 #define b53_build_op(type_op_size, val_type)				\
 static inline int b53_##type_op_size(struct b53_device *dev, u8 page,	\
 				     u8 reg, val_type val)		\

drivers/net/dsa/b53/b53_spi.c+13−0

 	if (dev)
 		b53_switch_remove(dev);
+	spi_set_drvdata(spi, NULL);
 	return 0;
 }
+static void b53_spi_shutdown(struct spi_device *spi)
+{
+	struct b53_device *dev = spi_get_drvdata(spi);
+	if (dev)
+		b53_switch_shutdown(dev);
+	spi_set_drvdata(spi, NULL);
+}
 static const struct of_device_id b53_spi_of_match[] = {
 	{ .compatible = "brcm,bcm5325" },
 	{ .compatible = "brcm,bcm5365" },
 	},
 	.probe	= b53_spi_probe,
 	.remove	= b53_spi_remove,
+	.shutdown = b53_spi_shutdown,
 };
 module_spi_driver(b53_spi_driver);

drivers/net/dsa/b53/b53_srab.c+19−2

@@ -629,17 +629,34 @@ static int b53_srab_probe(struct platform_device *pdev) · 628 unmodified lines
629	static int b53_srab_remove(struct platform_device *pdev)	629	static int b53_srab_remove(struct platform_device *pdev)
630	{	630	{
631	struct b53_device *dev = platform_get_drvdata(pdev);	631	struct b53_device *dev = platform_get_drvdata(pdev);
632	struct b53_srab_priv *priv = dev->priv;
633		632
634	b53_srab_intr_set(priv, false);	633	if (!dev)
		634	return 0;
		635
		636	b53_srab_intr_set(dev->priv, false);
635	b53_switch_remove(dev);	637	b53_switch_remove(dev);
636		638
		639	platform_set_drvdata(pdev, NULL);
		640
637	return 0;	641	return 0;
638	}	642	}
639		643
		644	static void b53_srab_shutdown(struct platform_device *pdev)
		645	{
		646	struct b53_device *dev = platform_get_drvdata(pdev);
		647
		648	if (!dev)
		649	return;
		650
		651	b53_switch_shutdown(dev);
		652
		653	platform_set_drvdata(pdev, NULL);
		654	}
		655
640	static struct platform_driver b53_srab_driver = {	656	static struct platform_driver b53_srab_driver = {
641	.probe = b53_srab_probe,	657	.probe = b53_srab_probe,
642	.remove = b53_srab_remove,	658	.remove = b53_srab_remove,
		659	.shutdown = b53_srab_shutdown,
643	.driver = {	660	.driver = {
644	.name = "b53-srab-switch",	661	.name = "b53-srab-switch",
645	.of_match_table = b53_srab_of_match,	662	.of_match_table = b53_srab_of_match,

drivers/net/dsa/bcm_sf2.c+13−1

 	struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 	unsigned int port, count = 0;
-	for (port = 0; port < ARRAY_SIZE(priv->port_sts); port++) {
+	for (port = 0; port < ds->num_ports; port++) {
 		if (dsa_is_cpu_port(ds, port))
 			continue;
 		if (priv->port_sts[port].enabled)
 {
 	struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
+	if (!priv)
+		return 0;
 	priv->wol_ports_mask = 0;
 	/* Disable interrupts */
 	bcm_sf2_intr_disable(priv);
 	if (priv->type == BCM7278_DEVICE_ID)
 		reset_control_assert(priv->rcdev);
+	platform_set_drvdata(pdev, NULL);
 	return 0;
 }
 {
 	struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
+	if (!priv)
+		return;
 	/* For a kernel about to be kexec'd we want to keep the GPHY on for a
 	 * successful MDIO bus scan to occur. If we did turn off the GPHY
 	 * before (e.g: port_disable), this will also power it back on.
 	 */
 	if (priv->hw_params.num_gphy == 1)
 		bcm_sf2_gphy_enable_set(priv->dev->ds, true);
+	dsa_switch_shutdown(priv->dev->ds);
+	platform_set_drvdata(pdev, NULL);
 }
 #ifdef CONFIG_PM_SLEEP

drivers/net/dsa/dsa_loop.c+21−1

@@ -340,10 +340,29 @@ static int dsa_loop_drv_probe(struct mdio_device *mdiodev) · 339 unmodified lines
340	static void dsa_loop_drv_remove(struct mdio_device *mdiodev)	340	static void dsa_loop_drv_remove(struct mdio_device *mdiodev)
341	{	341	{
342	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);	342	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
343	struct dsa_loop_priv *ps = ds->priv;	343	struct dsa_loop_priv *ps;
		344
		345	if (!ds)
		346	return;
		347
		348	ps = ds->priv;
344		349
345	dsa_unregister_switch(ds);	350	dsa_unregister_switch(ds);
346	dev_put(ps->netdev);	351	dev_put(ps->netdev);
		352
		353	dev_set_drvdata(&mdiodev->dev, NULL);
		354	}
		355
		356	static void dsa_loop_drv_shutdown(struct mdio_device *mdiodev)
		357	{
		358	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
		359
		360	if (!ds)
		361	return;
		362
		363	dsa_switch_shutdown(ds);
		364
		365	dev_set_drvdata(&mdiodev->dev, NULL);
347	}	366	}
348		367
349	static struct mdio_driver dsa_loop_drv = {	368	static struct mdio_driver dsa_loop_drv = {
@@ -352,6 +371,7 @@ static struct mdio_driver dsa_loop_drv = { · 2 unmodified lines
352	},	371	},
353	.probe = dsa_loop_drv_probe,	372	.probe = dsa_loop_drv_probe,
354	.remove = dsa_loop_drv_remove,	373	.remove = dsa_loop_drv_remove,
		374	.shutdown = dsa_loop_drv_shutdown,
355	};	375	};
356		376
357	#define NUM_FIXED_PHYS (DSA_LOOP_NUM_PORTS - 2)	377	#define NUM_FIXED_PHYS (DSA_LOOP_NUM_PORTS - 2)

drivers/net/dsa/hirschmann/hellcreek.c+16−0

 {
 	struct hellcreek *hellcreek = platform_get_drvdata(pdev);
+	if (!hellcreek)
+		return 0;
 	hellcreek_hwtstamp_free(hellcreek);
 	hellcreek_ptp_free(hellcreek);
 	dsa_unregister_switch(hellcreek->ds);
 	return 0;
 }
+static void hellcreek_shutdown(struct platform_device *pdev)
+{
+	struct hellcreek *hellcreek = platform_get_drvdata(pdev);
+	if (!hellcreek)
+		return;
+	dsa_switch_shutdown(hellcreek->ds);
+	platform_set_drvdata(pdev, NULL);
+}
 static const struct hellcreek_platform_data de1soc_r1_pdata = {
 	.name		 = "r4c30",
 	.num_ports	 = 4,
 static struct platform_driver hellcreek_driver = {
 	.probe	= hellcreek_probe,
 	.remove = hellcreek_remove,
+	.shutdown = hellcreek_shutdown,
 	.driver = {
 		.name = "hellcreek",
 		.of_match_table = hellcreek_of_match,

drivers/net/dsa/lan9303-core.c+6−0

 }
 EXPORT_SYMBOL(lan9303_remove);
+void lan9303_shutdown(struct lan9303 *chip)
+{
+	dsa_switch_shutdown(chip->ds);
+}
+EXPORT_SYMBOL(lan9303_shutdown);
 MODULE_AUTHOR("Juergen Borleis <kernel@pengutronix.de>");
 MODULE_DESCRIPTION("Core driver for SMSC/Microchip LAN9303 three port ethernet switch");
 MODULE_LICENSE("GPL v2");

drivers/net/dsa/lan9303.h+1−0

@@ -10,3 +10,4 @@ extern const struct lan9303_phy_ops lan9303_indirect_phy_ops; · 9 unmodified lines
10		10
11	int lan9303_probe(struct lan9303 chip, struct device_node np);	11	int lan9303_probe(struct lan9303 chip, struct device_node np);
12	int lan9303_remove(struct lan9303 *chip);	12	int lan9303_remove(struct lan9303 *chip);
		13	void lan9303_shutdown(struct lan9303 *chip);

drivers/net/dsa/lan9303_i2c.c+20−4

 static int lan9303_i2c_remove(struct i2c_client *client)
 {
-	struct lan9303_i2c *sw_dev;
+	struct lan9303_i2c *sw_dev = i2c_get_clientdata(client);
-	sw_dev = i2c_get_clientdata(client);
 	if (!sw_dev)
-		return -ENODEV;
+		return 0;
+	lan9303_remove(&sw_dev->chip);
+	i2c_set_clientdata(client, NULL);
+	return 0;
+}
+static void lan9303_i2c_shutdown(struct i2c_client *client)
+{
+	struct lan9303_i2c *sw_dev = i2c_get_clientdata(client);
+	if (!sw_dev)
+		return;
+	lan9303_shutdown(&sw_dev->chip);
-	return lan9303_remove(&sw_dev->chip);
+	i2c_set_clientdata(client, NULL);
 }
 /*-------------------------------------------------------------------------*/
 	},
 	.probe = lan9303_i2c_probe,
 	.remove = lan9303_i2c_remove,
+	.shutdown = lan9303_i2c_shutdown,
 	.id_table = lan9303_i2c_id,
 };
 module_i2c_driver(lan9303_i2c_driver);

drivers/net/dsa/lan9303_mdio.c+15−0

@@ -138,6 +138,20 @@ static void lan9303_mdio_remove(struct mdio_device *mdiodev) · 137 unmodified lines
138	return;	138	return;
139		139
140	lan9303_remove(&sw_dev->chip);	140	lan9303_remove(&sw_dev->chip);
		141
		142	dev_set_drvdata(&mdiodev->dev, NULL);
		143	}
		144
		145	static void lan9303_mdio_shutdown(struct mdio_device *mdiodev)
		146	{
		147	struct lan9303_mdio *sw_dev = dev_get_drvdata(&mdiodev->dev);
		148
		149	if (!sw_dev)
		150	return;
		151
		152	lan9303_shutdown(&sw_dev->chip);
		153
		154	dev_set_drvdata(&mdiodev->dev, NULL);
141	}	155	}
142		156
143	/-------------------------------------------------------------------------/	157	/-------------------------------------------------------------------------/
@@ -155,6 +169,7 @@ static struct mdio_driver lan9303_mdio_driver = { · 11 unmodified lines
155	},	169	},
156	.probe = lan9303_mdio_probe,	170	.probe = lan9303_mdio_probe,
157	.remove = lan9303_mdio_remove,	171	.remove = lan9303_mdio_remove,
		172	.shutdown = lan9303_mdio_shutdown,
158	};	173	};
159	mdio_module_driver(lan9303_mdio_driver);	174	mdio_module_driver(lan9303_mdio_driver);
160		175

drivers/net/dsa/lantiq_gswip.c+18−0

 	struct gswip_priv *priv = platform_get_drvdata(pdev);
 	int i;
+	if (!priv)
+		return 0;
 	/* disable the switch */
 	gswip_mdio_mask(priv, GSWIP_MDIO_GLOB_ENABLE, 0, GSWIP_MDIO_GLOB);
 	for (i = 0; i < priv->num_gphy_fw; i++)
 		gswip_gphy_fw_remove(priv, &priv->gphy_fw[i]);
+	platform_set_drvdata(pdev, NULL);
 	return 0;
 }
+static void gswip_shutdown(struct platform_device *pdev)
+{
+	struct gswip_priv *priv = platform_get_drvdata(pdev);
+	if (!priv)
+		return;
+	dsa_switch_shutdown(priv->ds);
+	platform_set_drvdata(pdev, NULL);
+}
 static const struct gswip_hw_info gswip_xrx200 = {
 	.max_ports = 7,
 	.cpu_port = 6,
 static struct platform_driver gswip_driver = {
 	.probe = gswip_probe,
 	.remove = gswip_remove,
+	.shutdown = gswip_shutdown,
 	.driver = {
 		.name = "gswip",
 		.of_match_table = gswip_of_match,

drivers/net/dsa/microchip/ksz8795_spi.c+10−1

 	if (dev)
 		ksz_switch_remove(dev);
+	spi_set_drvdata(spi, NULL);
 	return 0;
 }
 {
 	struct ksz_device *dev = spi_get_drvdata(spi);
-	if (dev && dev->dev_ops->shutdown)
+	if (!dev)
+		return;
+	if (dev->dev_ops->shutdown)
 		dev->dev_ops->shutdown(dev);
+	dsa_switch_shutdown(dev->ds);
+	spi_set_drvdata(spi, NULL);
 }
 static const struct of_device_id ksz8795_dt_ids[] = {

drivers/net/dsa/microchip/ksz8863_smi.c+13−0

@@ -191,6 +191,18 @@ static void ksz8863_smi_remove(struct mdio_device *mdiodev) · 190 unmodified lines
191		191
192	if (dev)	192	if (dev)
193	ksz_switch_remove(dev);	193	ksz_switch_remove(dev);
		194
		195	dev_set_drvdata(&mdiodev->dev, NULL);
		196	}
		197
		198	static void ksz8863_smi_shutdown(struct mdio_device *mdiodev)
		199	{
		200	struct ksz_device *dev = dev_get_drvdata(&mdiodev->dev);
		201
		202	if (dev)
		203	dsa_switch_shutdown(dev->ds);
		204
		205	dev_set_drvdata(&mdiodev->dev, NULL);
194	}	206	}
195		207
196	static const struct of_device_id ksz8863_dt_ids[] = {	208	static const struct of_device_id ksz8863_dt_ids[] = {
@@ -203,6 +215,7 @@ MODULE_DEVICE_TABLE(of, ksz8863_dt_ids); · 6 unmodified lines
203	static struct mdio_driver ksz8863_driver = {	215	static struct mdio_driver ksz8863_driver = {
204	.probe = ksz8863_smi_probe,	216	.probe = ksz8863_smi_probe,
205	.remove = ksz8863_smi_remove,	217	.remove = ksz8863_smi_remove,
		218	.shutdown = ksz8863_smi_shutdown,
206	.mdiodrv.driver = {	219	.mdiodrv.driver = {
207	.name = "ksz8863-switch",	220	.name = "ksz8863-switch",
208	.of_match_table = ksz8863_dt_ids,	221	.of_match_table = ksz8863_dt_ids,

drivers/net/dsa/microchip/ksz9477_i2c.c+12−2

 {
 	struct ksz_device *dev = i2c_get_clientdata(i2c);
-	ksz_switch_remove(dev);
+	if (dev)
+		ksz_switch_remove(dev);
+	i2c_set_clientdata(i2c, NULL);
 	return 0;
 }
 {
 	struct ksz_device *dev = i2c_get_clientdata(i2c);
-	if (dev && dev->dev_ops->shutdown)
+	if (!dev)
+		return;
+	if (dev->dev_ops->shutdown)
 		dev->dev_ops->shutdown(dev);
+	dsa_switch_shutdown(dev->ds);
+	i2c_set_clientdata(i2c, NULL);
 }
 static const struct i2c_device_id ksz9477_i2c_id[] = {

drivers/net/dsa/microchip/ksz9477_spi.c+6−2

 	if (dev)
 		ksz_switch_remove(dev);
+	spi_set_drvdata(spi, NULL);
 	return 0;
 }
 {
 	struct ksz_device *dev = spi_get_drvdata(spi);
-	if (dev && dev->dev_ops->shutdown)
+	if (dev)
-		dev->dev_ops->shutdown(dev);
+		dsa_switch_shutdown(dev->ds);
+	spi_set_drvdata(spi, NULL);
 }
 static const struct of_device_id ksz9477_dt_ids[] = {

drivers/net/dsa/mt7530.c+18−0

@@ -3286,6 +3286,9 @@ mt7530_remove(struct mdio_device *mdiodev) · 3285 unmodified lines
3286	struct mt7530_priv *priv = dev_get_drvdata(&mdiodev->dev);	3286	struct mt7530_priv *priv = dev_get_drvdata(&mdiodev->dev);
3287	int ret = 0;	3287	int ret = 0;
3288		3288
		3289	if (!priv)
		3290	return;
		3291
3289	ret = regulator_disable(priv->core_pwr);	3292	ret = regulator_disable(priv->core_pwr);
3290	if (ret < 0)	3293	if (ret < 0)
3291	dev_err(priv->dev,	3294	dev_err(priv->dev,
@@ -3301,11 +3304,26 @@ mt7530_remove(struct mdio_device *mdiodev) · 9 unmodified lines
3301		3304
3302	dsa_unregister_switch(priv->ds);	3305	dsa_unregister_switch(priv->ds);
3303	mutex_destroy(&priv->reg_mutex);	3306	mutex_destroy(&priv->reg_mutex);
		3307
		3308	dev_set_drvdata(&mdiodev->dev, NULL);
		3309	}
		3310
		3311	static void mt7530_shutdown(struct mdio_device *mdiodev)
		3312	{
		3313	struct mt7530_priv *priv = dev_get_drvdata(&mdiodev->dev);
		3314
		3315	if (!priv)
		3316	return;
		3317
		3318	dsa_switch_shutdown(priv->ds);
		3319
		3320	dev_set_drvdata(&mdiodev->dev, NULL);
3304	}	3321	}
3305		3322
3306	static struct mdio_driver mt7530_mdio_driver = {	3323	static struct mdio_driver mt7530_mdio_driver = {
3307	.probe = mt7530_probe,	3324	.probe = mt7530_probe,
3308	.remove = mt7530_remove,	3325	.remove = mt7530_remove,
		3326	.shutdown = mt7530_shutdown,
3309	.mdiodrv.driver = {	3327	.mdiodrv.driver = {
3310	.name = "mt7530",	3328	.name = "mt7530",
3311	.of_match_table = mt7530_of_match,	3329	.of_match_table = mt7530_of_match,

drivers/net/dsa/mv88e6060.c+18−0

@@ -290,7 +290,24 @@ static void mv88e6060_remove(struct mdio_device *mdiodev) · 289 unmodified lines
290	{	290	{
291	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);	291	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
292		292
		293	if (!ds)
		294	return;
		295
293	dsa_unregister_switch(ds);	296	dsa_unregister_switch(ds);
		297
		298	dev_set_drvdata(&mdiodev->dev, NULL);
		299	}
		300
		301	static void mv88e6060_shutdown(struct mdio_device *mdiodev)
		302	{
		303	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
		304
		305	if (!ds)
		306	return;
		307
		308	dsa_switch_shutdown(ds);
		309
		310	dev_set_drvdata(&mdiodev->dev, NULL);
294	}	311	}
295		312
296	static const struct of_device_id mv88e6060_of_match[] = {	313	static const struct of_device_id mv88e6060_of_match[] = {
@@ -303,6 +320,7 @@ static const struct of_device_id mv88e6060_of_match[] = { · 6 unmodified lines
303	static struct mdio_driver mv88e6060_driver = {	320	static struct mdio_driver mv88e6060_driver = {
304	.probe = mv88e6060_probe,	321	.probe = mv88e6060_probe,
305	.remove = mv88e6060_remove,	322	.remove = mv88e6060_remove,
		323	.shutdown = mv88e6060_shutdown,
306	.mdiodrv.driver = {	324	.mdiodrv.driver = {
307	.name = "mv88e6060",	325	.name = "mv88e6060",
308	.of_match_table = mv88e6060_of_match,	326	.of_match_table = mv88e6060_of_match,

drivers/net/dsa/mv88e6xxx/chip.c+35−3

 {
 	mv88e6xxx_teardown_devlink_params(ds);
 	dsa_devlink_resources_unregister(ds);
-	mv88e6xxx_teardown_devlink_regions(ds);
+	mv88e6xxx_teardown_devlink_regions_global(ds);
 }
 static int mv88e6xxx_setup(struct dsa_switch *ds)
 	if (err)
 		goto out_resources;
-	err = mv88e6xxx_setup_devlink_regions(ds);
+	err = mv88e6xxx_setup_devlink_regions_global(ds);
 	if (err)
 		goto out_params;
 	return err;
 }
+static int mv88e6xxx_port_setup(struct dsa_switch *ds, int port)
+{
+	return mv88e6xxx_setup_devlink_regions_port(ds, port);
+}
+static void mv88e6xxx_port_teardown(struct dsa_switch *ds, int port)
+{
+	mv88e6xxx_teardown_devlink_regions_port(ds, port);
+}
 /* prod_id for switch families which do not have a PHY model number */
 static const u16 family_prod_id_table[] = {
 	[MV88E6XXX_FAMILY_6341] = MV88E6XXX_PORT_SWITCH_ID_PROD_6341,
 	.change_tag_protocol	= mv88e6xxx_change_tag_protocol,
 	.setup			= mv88e6xxx_setup,
 	.teardown		= mv88e6xxx_teardown,
+	.port_setup		= mv88e6xxx_port_setup,
+	.port_teardown		= mv88e6xxx_port_teardown,
 	.phylink_validate	= mv88e6xxx_validate,
 	.phylink_mac_link_state	= mv88e6xxx_serdes_pcs_get_state,
 	.phylink_mac_config	= mv88e6xxx_mac_config,
 static void mv88e6xxx_remove(struct mdio_device *mdiodev)
 {
 	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
-	struct mv88e6xxx_chip *chip = ds->priv;
+	struct mv88e6xxx_chip *chip;
+	if (!ds)
+		return;
+	chip = ds->priv;
 	if (chip->info->ptp_support) {
 		mv88e6xxx_hwtstamp_free(chip);
 		mv88e6xxx_g1_irq_free(chip);
 	else
 		mv88e6xxx_irq_poll_free(chip);
+	dev_set_drvdata(&mdiodev->dev, NULL);
+}
+static void mv88e6xxx_shutdown(struct mdio_device *mdiodev)
+{
+	struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
+	if (!ds)
+		return;
+	dsa_switch_shutdown(ds);
+	dev_set_drvdata(&mdiodev->dev, NULL);
 }
 static const struct of_device_id mv88e6xxx_of_match[] = {
 static struct mdio_driver mv88e6xxx_driver = {
 	.probe	= mv88e6xxx_probe,
 	.remove = mv88e6xxx_remove,
+	.shutdown = mv88e6xxx_shutdown,
 	.mdiodrv.driver = {
 		.name = "mv88e6085",
 		.of_match_table = mv88e6xxx_of_match,

drivers/net/dsa/mv88e6xxx/devlink.c+9−64

@@ -647,26 +647,25 @@ static struct mv88e6xxx_region mv88e6xxx_regions[] = { · 646 unmodified lines
647	},	647	},
648	};	648	};
649		649
650	static void	650	void mv88e6xxx_teardown_devlink_regions_global(struct dsa_switch *ds)
651	mv88e6xxx_teardown_devlink_regions_global(struct mv88e6xxx_chip *chip)
652	{	651	{
		652	struct mv88e6xxx_chip *chip = ds->priv;
653	int i;	653	int i;
654		654
655	for (i = 0; i < ARRAY_SIZE(mv88e6xxx_regions); i++)	655	for (i = 0; i < ARRAY_SIZE(mv88e6xxx_regions); i++)
656	dsa_devlink_region_destroy(chip->regions[i]);	656	dsa_devlink_region_destroy(chip->regions[i]);
657	}	657	}
658		658
659	static void	659	void mv88e6xxx_teardown_devlink_regions_port(struct dsa_switch *ds, int port)
660	mv88e6xxx_teardown_devlink_regions_port(struct mv88e6xxx_chip *chip,
661	int port)
662	{	660	{
		661	struct mv88e6xxx_chip *chip = ds->priv;
		662
663	dsa_devlink_region_destroy(chip->ports[port].region);	663	dsa_devlink_region_destroy(chip->ports[port].region);
664	}	664	}
665		665
666	static int mv88e6xxx_setup_devlink_regions_port(struct dsa_switch *ds,	666	int mv88e6xxx_setup_devlink_regions_port(struct dsa_switch *ds, int port)
667	struct mv88e6xxx_chip *chip,
668	int port)
669	{	667	{
		668	struct mv88e6xxx_chip *chip = ds->priv;
670	struct devlink_region *region;	669	struct devlink_region *region;
671		670
672	region = dsa_devlink_port_region_create(ds,	671	region = dsa_devlink_port_region_create(ds,
@@ -681,40 +680,10 @@ static int mv88e6xxx_setup_devlink_regions_port(struct dsa_switch *ds, · 8 unmodified lines
681	return 0;	680	return 0;
682	}	681	}
683		682
684	static void	683	int mv88e6xxx_setup_devlink_regions_global(struct dsa_switch *ds)
685	mv88e6xxx_teardown_devlink_regions_ports(struct mv88e6xxx_chip *chip)
686	{
687	int port;
688
689	for (port = 0; port < mv88e6xxx_num_ports(chip); port++)
690	mv88e6xxx_teardown_devlink_regions_port(chip, port);
691	}
692
693	static int mv88e6xxx_setup_devlink_regions_ports(struct dsa_switch *ds,
694	struct mv88e6xxx_chip *chip)
695	{
696	int port;
697	int err;
698
699	for (port = 0; port < mv88e6xxx_num_ports(chip); port++) {
700	err = mv88e6xxx_setup_devlink_regions_port(ds, chip, port);
701	if (err)
702	goto out;
703	}
704
705	return 0;
706
707	out:
708	while (port-- > 0)
709	mv88e6xxx_teardown_devlink_regions_port(chip, port);
710
711	return err;
712	}
713
714	static int mv88e6xxx_setup_devlink_regions_global(struct dsa_switch *ds,
715	struct mv88e6xxx_chip *chip)
716	{	684	{
717	bool (cond)(struct mv88e6xxx_chip chip);	685	bool (cond)(struct mv88e6xxx_chip chip);
		686	struct mv88e6xxx_chip *chip = ds->priv;
718	struct devlink_region_ops *ops;	687	struct devlink_region_ops *ops;
719	struct devlink_region *region;	688	struct devlink_region *region;
720	u64 size;	689	u64 size;
@@ -753,30 +722,6 @@ out: · 32 unmodified lines
753	return PTR_ERR(region);	722	return PTR_ERR(region);
754	}	723	}
755		724
756	int mv88e6xxx_setup_devlink_regions(struct dsa_switch *ds)
757	{
758	struct mv88e6xxx_chip *chip = ds->priv;
759	int err;
760
761	err = mv88e6xxx_setup_devlink_regions_global(ds, chip);
762	if (err)
763	return err;
764
765	err = mv88e6xxx_setup_devlink_regions_ports(ds, chip);
766	if (err)
767	mv88e6xxx_teardown_devlink_regions_global(chip);
768
769	return err;
770	}
771
772	void mv88e6xxx_teardown_devlink_regions(struct dsa_switch *ds)
773	{
774	struct mv88e6xxx_chip *chip = ds->priv;
775
776	mv88e6xxx_teardown_devlink_regions_ports(chip);
777	mv88e6xxx_teardown_devlink_regions_global(chip);
778	}
779
780	int mv88e6xxx_devlink_info_get(struct dsa_switch *ds,	725	int mv88e6xxx_devlink_info_get(struct dsa_switch *ds,
781	struct devlink_info_req *req,	726	struct devlink_info_req *req,
782	struct netlink_ext_ack *extack)	727	struct netlink_ext_ack *extack)

drivers/net/dsa/mv88e6xxx/devlink.h+4−2

 				struct devlink_param_gset_ctx *ctx);
 int mv88e6xxx_devlink_param_set(struct dsa_switch *ds, u32 id,
 				struct devlink_param_gset_ctx *ctx);
-int mv88e6xxx_setup_devlink_regions(struct dsa_switch *ds);
+int mv88e6xxx_setup_devlink_regions_global(struct dsa_switch *ds);
-void mv88e6xxx_teardown_devlink_regions(struct dsa_switch *ds);
+void mv88e6xxx_teardown_devlink_regions_global(struct dsa_switch *ds);
+int mv88e6xxx_setup_devlink_regions_port(struct dsa_switch *ds, int port);
+void mv88e6xxx_teardown_devlink_regions_port(struct dsa_switch *ds, int port);
 int mv88e6xxx_devlink_info_get(struct dsa_switch *ds,
 			       struct devlink_info_req *req,

drivers/net/dsa/ocelot/felix.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2019-2021 NXP Semiconductors	2	/* Copyright 2019-2021 NXP
3	*	3	*
4	* This is an umbrella module for all network switches that are	4	* This is an umbrella module for all network switches that are
5	* register-compatible with Ocelot and that perform I/O to their host CPU	5	* register-compatible with Ocelot and that perform I/O to their host CPU

drivers/net/dsa/ocelot/felix.h+1−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright 2019 NXP Semiconductors	2	/* Copyright 2019 NXP
3	*/	3	*/
4	#ifndef _MSCC_FELIX_H	4	#ifndef _MSCC_FELIX_H
5	#define _MSCC_FELIX_H	5	#define _MSCC_FELIX_H

drivers/net/dsa/ocelot/felix_vsc9959.c+19−3

 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
 /* Copyright 2017 Microsemi Corporation
- * Copyright 2018-2019 NXP Semiconductors
+ * Copyright 2018-2019 NXP
  */
 #include <linux/fsl/enetc_mdio.h>
 #include <soc/mscc/ocelot_qsys.h>
 static void felix_pci_remove(struct pci_dev *pdev)
 {
-	struct felix *felix;
+	struct felix *felix = pci_get_drvdata(pdev);
-	felix = pci_get_drvdata(pdev);
+	if (!felix)
+		return;
 	dsa_unregister_switch(felix->ds);
 	kfree(felix);
 	pci_disable_device(pdev);
+	pci_set_drvdata(pdev, NULL);
+}
+static void felix_pci_shutdown(struct pci_dev *pdev)
+{
+	struct felix *felix = pci_get_drvdata(pdev);
+	if (!felix)
+		return;
+	dsa_switch_shutdown(felix->ds);
+	pci_set_drvdata(pdev, NULL);
 }
 static struct pci_device_id felix_ids[] = {
 	.id_table	= felix_ids,
 	.probe		= felix_pci_probe,
 	.remove		= felix_pci_remove,
+	.shutdown	= felix_pci_shutdown,
 };
 module_pci_driver(felix_vsc9959_pci_driver);

drivers/net/dsa/ocelot/seville_vsc9953.c+18−2

 static int seville_remove(struct platform_device *pdev)
 {
-	struct felix *felix;
+	struct felix *felix = platform_get_drvdata(pdev);
-	felix = platform_get_drvdata(pdev);
+	if (!felix)
+		return 0;
 	dsa_unregister_switch(felix->ds);
 	kfree(felix->ds);
 	kfree(felix);
+	platform_set_drvdata(pdev, NULL);
 	return 0;
 }
+static void seville_shutdown(struct platform_device *pdev)
+{
+	struct felix *felix = platform_get_drvdata(pdev);
+	if (!felix)
+		return;
+	dsa_switch_shutdown(felix->ds);
+	platform_set_drvdata(pdev, NULL);
+}
 static const struct of_device_id seville_of_match[] = {
 	{ .compatible = "mscc,vsc9953-switch" },
 	{ },
 static struct platform_driver seville_vsc9953_driver = {
 	.probe		= seville_probe,
 	.remove		= seville_remove,
+	.shutdown	= seville_shutdown,
 	.driver = {
 		.name		= "mscc_seville",
 		.of_match_table	= of_match_ptr(seville_of_match),

drivers/net/dsa/qca/ar9331.c+18−0

 	struct ar9331_sw_priv *priv = dev_get_drvdata(&mdiodev->dev);
 	unsigned int i;
+	if (!priv)
+		return;
 	for (i = 0; i < ARRAY_SIZE(priv->port); i++) {
 		struct ar9331_sw_port *port = &priv->port[i];
 	dsa_unregister_switch(&priv->ds);
 	reset_control_assert(priv->sw_reset);
+	dev_set_drvdata(&mdiodev->dev, NULL);
+}
+static void ar9331_sw_shutdown(struct mdio_device *mdiodev)
+{
+	struct ar9331_sw_priv *priv = dev_get_drvdata(&mdiodev->dev);
+	if (!priv)
+		return;
+	dsa_switch_shutdown(&priv->ds);
+	dev_set_drvdata(&mdiodev->dev, NULL);
 }
 static const struct of_device_id ar9331_sw_of_match[] = {
 static struct mdio_driver ar9331_sw_mdio_driver = {
 	.probe = ar9331_sw_probe,
 	.remove = ar9331_sw_remove,
+	.shutdown = ar9331_sw_shutdown,
 	.mdiodrv.driver = {
 		.name = AR9331_SW_NAME,
 		.of_match_table = ar9331_sw_of_match,

drivers/net/dsa/qca8k.c+18−0

@@ -1880,10 +1880,27 @@ qca8k_sw_remove(struct mdio_device *mdiodev) · 1879 unmodified lines
1880	struct qca8k_priv *priv = dev_get_drvdata(&mdiodev->dev);	1880	struct qca8k_priv *priv = dev_get_drvdata(&mdiodev->dev);
1881	int i;	1881	int i;
1882		1882
		1883	if (!priv)
		1884	return;
		1885
1883	for (i = 0; i < QCA8K_NUM_PORTS; i++)	1886	for (i = 0; i < QCA8K_NUM_PORTS; i++)
1884	qca8k_port_set_status(priv, i, 0);	1887	qca8k_port_set_status(priv, i, 0);
1885		1888
1886	dsa_unregister_switch(priv->ds);	1889	dsa_unregister_switch(priv->ds);
		1890
		1891	dev_set_drvdata(&mdiodev->dev, NULL);
		1892	}
		1893
		1894	static void qca8k_sw_shutdown(struct mdio_device *mdiodev)
		1895	{
		1896	struct qca8k_priv *priv = dev_get_drvdata(&mdiodev->dev);
		1897
		1898	if (!priv)
		1899	return;
		1900
		1901	dsa_switch_shutdown(priv->ds);
		1902
		1903	dev_set_drvdata(&mdiodev->dev, NULL);
1887	}	1904	}
1888		1905
1889	#ifdef CONFIG_PM_SLEEP	1906	#ifdef CONFIG_PM_SLEEP
@@ -1940,6 +1957,7 @@ static const struct of_device_id qca8k_of_match[] = { · 50 unmodified lines
1940	static struct mdio_driver qca8kmdio_driver = {	1957	static struct mdio_driver qca8kmdio_driver = {
1941	.probe = qca8k_sw_probe,	1958	.probe = qca8k_sw_probe,
1942	.remove = qca8k_sw_remove,	1959	.remove = qca8k_sw_remove,
		1960	.shutdown = qca8k_sw_shutdown,
1943	.mdiodrv.driver = {	1961	.mdiodrv.driver = {
1944	.name = "qca8k",	1962	.name = "qca8k",
1945	.of_match_table = qca8k_of_match,	1963	.of_match_table = qca8k_of_match,

drivers/net/dsa/realtek-smi-core.c+20−2

 	smi->slave_mii_bus->parent = smi->dev;
 	smi->ds->slave_mii_bus = smi->slave_mii_bus;
-	ret = of_mdiobus_register(smi->slave_mii_bus, mdio_np);
+	ret = devm_of_mdiobus_register(smi->dev, smi->slave_mii_bus, mdio_np);
 	if (ret) {
 		dev_err(smi->dev, "unable to register MDIO bus %s\n",
 			smi->slave_mii_bus->id);
 static int realtek_smi_remove(struct platform_device *pdev)
 {
-	struct realtek_smi *smi = dev_get_drvdata(&pdev->dev);
+	struct realtek_smi *smi = platform_get_drvdata(pdev);
+	if (!smi)
+		return 0;
 	dsa_unregister_switch(smi->ds);
 	if (smi->slave_mii_bus)
 		of_node_put(smi->slave_mii_bus->dev.of_node);
 	gpiod_set_value(smi->reset, 1);
+	platform_set_drvdata(pdev, NULL);
 	return 0;
 }
+static void realtek_smi_shutdown(struct platform_device *pdev)
+{
+	struct realtek_smi *smi = platform_get_drvdata(pdev);
+	if (!smi)
+		return;
+	dsa_switch_shutdown(smi->ds);
+	platform_set_drvdata(pdev, NULL);
+}
 static const struct of_device_id realtek_smi_of_match[] = {
 	{
 		.compatible = "realtek,rtl8366rb",
 	},
 	.probe  = realtek_smi_probe,
 	.remove = realtek_smi_remove,
+	.shutdown = realtek_smi_shutdown,
 };
 module_platform_driver(realtek_smi_driver);

drivers/net/dsa/sja1105/sja1105_clocking.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: BSD-3-Clause	1	// SPDX-License-Identifier: BSD-3-Clause
2	/* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright 2016-2018 NXP
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#include <linux/packing.h>	5	#include <linux/packing.h>

drivers/net/dsa/sja1105/sja1105_devlink.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	2	/* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
3	* Copyright 2020 NXP Semiconductors	3	* Copyright 2020 NXP
4	*/	4	*/
5	#include "sja1105.h"	5	#include "sja1105.h"
6		6

drivers/net/dsa/sja1105/sja1105_flower.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2020, NXP Semiconductors	2	/* Copyright 2020 NXP
3	*/	3	*/
4	#include "sja1105.h"	4	#include "sja1105.h"
5	#include "sja1105_vl.h"	5	#include "sja1105_vl.h"

drivers/net/dsa/sja1105/sja1105_main.c+19−2

 static int sja1105_remove(struct spi_device *spi)
 {
 	struct sja1105_private *priv = spi_get_drvdata(spi);
-	struct dsa_switch *ds = priv->ds;
-	dsa_unregister_switch(ds);
+	if (!priv)
+		return 0;
+	dsa_unregister_switch(priv->ds);
+	spi_set_drvdata(spi, NULL);
 	return 0;
 }
+static void sja1105_shutdown(struct spi_device *spi)
+{
+	struct sja1105_private *priv = spi_get_drvdata(spi);
+	if (!priv)
+		return;
+	dsa_switch_shutdown(priv->ds);
+	spi_set_drvdata(spi, NULL);
+}
 static const struct of_device_id sja1105_dt_ids[] = {
 	{ .compatible = "nxp,sja1105e", .data = &sja1105e_info },
 	{ .compatible = "nxp,sja1105t", .data = &sja1105t_info },
 	},
 	.probe  = sja1105_probe,
 	.remove = sja1105_remove,
+	.shutdown = sja1105_shutdown,
 };
 module_spi_driver(sja1105_driver);

drivers/net/dsa/sja1105/sja1105_mdio.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2021, NXP Semiconductors	2	/* Copyright 2021 NXP
3	*/	3	*/
4	#include <linux/pcs/pcs-xpcs.h>	4	#include <linux/pcs/pcs-xpcs.h>
5	#include <linux/of_mdio.h>	5	#include <linux/of_mdio.h>

drivers/net/dsa/sja1105/sja1105_spi.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: BSD-3-Clause	1	// SPDX-License-Identifier: BSD-3-Clause
2	/* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright 2016-2018 NXP
3	* Copyright (c) 2018, Sensor-Technik Wiedemann GmbH	3	* Copyright (c) 2018, Sensor-Technik Wiedemann GmbH
4	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	4	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
5	*/	5	*/

drivers/net/dsa/sja1105/sja1105_static_config.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: BSD-3-Clause	1	// SPDX-License-Identifier: BSD-3-Clause
2	/* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright 2016-2018 NXP
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#include "sja1105_static_config.h"	5	#include "sja1105_static_config.h"

drivers/net/dsa/sja1105/sja1105_static_config.h+1−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: BSD-3-Clause */	1	/* SPDX-License-Identifier: BSD-3-Clause */
2	/* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright 2016-2018 NXP
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#ifndef _SJA1105_STATIC_CONFIG_H	5	#ifndef _SJA1105_STATIC_CONFIG_H

drivers/net/dsa/sja1105/sja1105_vl.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2020, NXP Semiconductors	2	/* Copyright 2020 NXP
3	*/	3	*/
4	#include <net/tc_act/tc_gate.h>	4	#include <net/tc_act/tc_gate.h>
5	#include <linux/dsa/8021q.h>	5	#include <linux/dsa/8021q.h>

drivers/net/dsa/sja1105/sja1105_vl.h+1−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* Copyright 2020, NXP Semiconductors	2	/* Copyright 2020 NXP
3	*/	3	*/
4	#ifndef _SJA1105_VL_H	4	#ifndef _SJA1105_VL_H
5	#define _SJA1105_VL_H	5	#define _SJA1105_VL_H

drivers/net/dsa/vitesse-vsc73xx-core.c+6−0

 }
 EXPORT_SYMBOL(vsc73xx_remove);
+void vsc73xx_shutdown(struct vsc73xx *vsc)
+{
+	dsa_switch_shutdown(vsc->ds);
+}
+EXPORT_SYMBOL(vsc73xx_shutdown);
 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
 MODULE_DESCRIPTION("Vitesse VSC7385/7388/7395/7398 driver");
 MODULE_LICENSE("GPL v2");

drivers/net/dsa/vitesse-vsc73xx-platform.c+21−1

@@ -116,7 +116,26 @@ static int vsc73xx_platform_remove(struct platform_device *pdev) · 115 unmodified lines
116	{	116	{
117	struct vsc73xx_platform *vsc_platform = platform_get_drvdata(pdev);	117	struct vsc73xx_platform *vsc_platform = platform_get_drvdata(pdev);
118		118
119	return vsc73xx_remove(&vsc_platform->vsc);	119	if (!vsc_platform)
		120	return 0;
		121
		122	vsc73xx_remove(&vsc_platform->vsc);
		123
		124	platform_set_drvdata(pdev, NULL);
		125
		126	return 0;
		127	}
		128
		129	static void vsc73xx_platform_shutdown(struct platform_device *pdev)
		130	{
		131	struct vsc73xx_platform *vsc_platform = platform_get_drvdata(pdev);
		132
		133	if (!vsc_platform)
		134	return;
		135
		136	vsc73xx_shutdown(&vsc_platform->vsc);
		137
		138	platform_set_drvdata(pdev, NULL);
120	}	139	}
121		140
122	static const struct vsc73xx_ops vsc73xx_platform_ops = {	141	static const struct vsc73xx_ops vsc73xx_platform_ops = {
@@ -144,6 +163,7 @@ MODULE_DEVICE_TABLE(of, vsc73xx_of_match); · 21 unmodified lines
144	static struct platform_driver vsc73xx_platform_driver = {	163	static struct platform_driver vsc73xx_platform_driver = {
145	.probe = vsc73xx_platform_probe,	164	.probe = vsc73xx_platform_probe,
146	.remove = vsc73xx_platform_remove,	165	.remove = vsc73xx_platform_remove,
		166	.shutdown = vsc73xx_platform_shutdown,
147	.driver = {	167	.driver = {
148	.name = "vsc73xx-platform",	168	.name = "vsc73xx-platform",
149	.of_match_table = vsc73xx_of_match,	169	.of_match_table = vsc73xx_of_match,

drivers/net/dsa/vitesse-vsc73xx-spi.c+21−1

@@ -163,7 +163,26 @@ static int vsc73xx_spi_remove(struct spi_device *spi) · 162 unmodified lines
163	{	163	{
164	struct vsc73xx_spi *vsc_spi = spi_get_drvdata(spi);	164	struct vsc73xx_spi *vsc_spi = spi_get_drvdata(spi);
165		165
166	return vsc73xx_remove(&vsc_spi->vsc);	166	if (!vsc_spi)
		167	return 0;
		168
		169	vsc73xx_remove(&vsc_spi->vsc);
		170
		171	spi_set_drvdata(spi, NULL);
		172
		173	return 0;
		174	}
		175
		176	static void vsc73xx_spi_shutdown(struct spi_device *spi)
		177	{
		178	struct vsc73xx_spi *vsc_spi = spi_get_drvdata(spi);
		179
		180	if (!vsc_spi)
		181	return;
		182
		183	vsc73xx_shutdown(&vsc_spi->vsc);
		184
		185	spi_set_drvdata(spi, NULL);
167	}	186	}
168		187
169	static const struct vsc73xx_ops vsc73xx_spi_ops = {	188	static const struct vsc73xx_ops vsc73xx_spi_ops = {
@@ -191,6 +210,7 @@ MODULE_DEVICE_TABLE(of, vsc73xx_of_match); · 21 unmodified lines
191	static struct spi_driver vsc73xx_spi_driver = {	210	static struct spi_driver vsc73xx_spi_driver = {
192	.probe = vsc73xx_spi_probe,	211	.probe = vsc73xx_spi_probe,
193	.remove = vsc73xx_spi_remove,	212	.remove = vsc73xx_spi_remove,
		213	.shutdown = vsc73xx_spi_shutdown,
194	.driver = {	214	.driver = {
195	.name = "vsc73xx-spi",	215	.name = "vsc73xx-spi",
196	.of_match_table = vsc73xx_of_match,	216	.of_match_table = vsc73xx_of_match,

drivers/net/dsa/vitesse-vsc73xx.h+1−0

@@ -27,3 +27,4 @@ struct vsc73xx_ops { · 26 unmodified lines
27	int vsc73xx_is_addr_valid(u8 block, u8 subblock);	27	int vsc73xx_is_addr_valid(u8 block, u8 subblock);
28	int vsc73xx_probe(struct vsc73xx *vsc);	28	int vsc73xx_probe(struct vsc73xx *vsc);
29	int vsc73xx_remove(struct vsc73xx *vsc);	29	int vsc73xx_remove(struct vsc73xx *vsc);
		30	void vsc73xx_shutdown(struct vsc73xx *vsc);

drivers/net/dsa/xrs700x/xrs700x.c+6−0

 }
 EXPORT_SYMBOL(xrs700x_switch_remove);
+void xrs700x_switch_shutdown(struct xrs700x *priv)
+{
+	dsa_switch_shutdown(priv->ds);
+}
+EXPORT_SYMBOL(xrs700x_switch_shutdown);
 MODULE_AUTHOR("George McCollister <george.mccollister@gmail.com>");
 MODULE_DESCRIPTION("Arrow SpeedChips XRS700x DSA driver");
 MODULE_LICENSE("GPL v2");

drivers/net/dsa/xrs700x/xrs700x.h+1−0

@@ -40,3 +40,4 @@ struct xrs700x { · 39 unmodified lines
40	struct xrs700x xrs700x_switch_alloc(struct device base, void *devpriv);	40	struct xrs700x xrs700x_switch_alloc(struct device base, void *devpriv);
41	int xrs700x_switch_register(struct xrs700x *priv);	41	int xrs700x_switch_register(struct xrs700x *priv);
42	void xrs700x_switch_remove(struct xrs700x *priv);	42	void xrs700x_switch_remove(struct xrs700x *priv);
		43	void xrs700x_switch_shutdown(struct xrs700x *priv);

drivers/net/dsa/xrs700x/xrs700x_i2c.c+18−0

@@ -109,11 +109,28 @@ static int xrs700x_i2c_remove(struct i2c_client *i2c) · 108 unmodified lines
109	{	109	{
110	struct xrs700x *priv = i2c_get_clientdata(i2c);	110	struct xrs700x *priv = i2c_get_clientdata(i2c);
111		111
		112	if (!priv)
		113	return 0;
		114
112	xrs700x_switch_remove(priv);	115	xrs700x_switch_remove(priv);
113		116
		117	i2c_set_clientdata(i2c, NULL);
		118
114	return 0;	119	return 0;
115	}	120	}
116		121
		122	static void xrs700x_i2c_shutdown(struct i2c_client *i2c)
		123	{
		124	struct xrs700x *priv = i2c_get_clientdata(i2c);
		125
		126	if (!priv)
		127	return;
		128
		129	xrs700x_switch_shutdown(priv);
		130
		131	i2c_set_clientdata(i2c, NULL);
		132	}
		133
117	static const struct i2c_device_id xrs700x_i2c_id[] = {	134	static const struct i2c_device_id xrs700x_i2c_id[] = {
118	{ "xrs700x-switch", 0 },	135	{ "xrs700x-switch", 0 },
119	{},	136	{},
@@ -137,6 +154,7 @@ static struct i2c_driver xrs700x_i2c_driver = { · 17 unmodified lines
137	},	154	},
138	.probe = xrs700x_i2c_probe,	155	.probe = xrs700x_i2c_probe,
139	.remove = xrs700x_i2c_remove,	156	.remove = xrs700x_i2c_remove,
		157	.shutdown = xrs700x_i2c_shutdown,
140	.id_table = xrs700x_i2c_id,	158	.id_table = xrs700x_i2c_id,
141	};	159	};
142		160

drivers/net/dsa/xrs700x/xrs700x_mdio.c+18−0

@@ -136,7 +136,24 @@ static void xrs700x_mdio_remove(struct mdio_device *mdiodev) · 135 unmodified lines
136	{	136	{
137	struct xrs700x *priv = dev_get_drvdata(&mdiodev->dev);	137	struct xrs700x *priv = dev_get_drvdata(&mdiodev->dev);
138		138
		139	if (!priv)
		140	return;
		141
139	xrs700x_switch_remove(priv);	142	xrs700x_switch_remove(priv);
		143
		144	dev_set_drvdata(&mdiodev->dev, NULL);
		145	}
		146
		147	static void xrs700x_mdio_shutdown(struct mdio_device *mdiodev)
		148	{
		149	struct xrs700x *priv = dev_get_drvdata(&mdiodev->dev);
		150
		151	if (!priv)
		152	return;
		153
		154	xrs700x_switch_shutdown(priv);
		155
		156	dev_set_drvdata(&mdiodev->dev, NULL);
140	}	157	}
141		158
142	static const struct of_device_id __maybe_unused xrs700x_mdio_dt_ids[] = {	159	static const struct of_device_id __maybe_unused xrs700x_mdio_dt_ids[] = {
@@ -155,6 +172,7 @@ static struct mdio_driver xrs700x_mdio_driver = { · 12 unmodified lines
155	},	172	},
156	.probe = xrs700x_mdio_probe,	173	.probe = xrs700x_mdio_probe,
157	.remove = xrs700x_mdio_remove,	174	.remove = xrs700x_mdio_remove,
		175	.shutdown = xrs700x_mdio_shutdown,
158	};	176	};
159		177
160	mdio_module_driver(xrs700x_mdio_driver);	178	mdio_module_driver(xrs700x_mdio_driver);

drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c+2−2

 	if (deep) {
 		/* Reinitialize Nic/Vecs objects */
 		aq_nic_deinit(nic, !nic->aq_hw->aq_nic_cfg->wol);
+	}
+	if (netif_running(nic->ndev)) {
 		ret = aq_nic_init(nic);
 		if (ret)
 			goto err_exit;
-	}
-	if (netif_running(nic->ndev)) {
 		ret = aq_nic_start(nic);
 		if (ret)
 			goto err_exit;

drivers/net/ethernet/broadcom/bgmac-bcma.c+2−0

@@ -129,6 +129,8 @@ static int bgmac_probe(struct bcma_device *core) · 128 unmodified lines
129	bcma_set_drvdata(core, bgmac);	129	bcma_set_drvdata(core, bgmac);
130		130
131	err = of_get_mac_address(bgmac->dev->of_node, bgmac->net_dev->dev_addr);	131	err = of_get_mac_address(bgmac->dev->of_node, bgmac->net_dev->dev_addr);
		132	if (err == -EPROBE_DEFER)
		133	return err;
132		134
133	/* If no MAC address assigned via device tree, check SPROM */	135	/* If no MAC address assigned via device tree, check SPROM */
134	if (err) {	136	if (err) {

drivers/net/ethernet/broadcom/bnxt/bnxt.c+4−4

@@ -391,7 +391,7 @@ static bool bnxt_txr_netif_try_stop_queue(struct bnxt *bp, · 390 unmodified lines
391	* netif_tx_queue_stopped().	391	* netif_tx_queue_stopped().
392	*/	392	*/
393	smp_mb();	393	smp_mb();
394	if (bnxt_tx_avail(bp, txr) > bp->tx_wake_thresh) {	394	if (bnxt_tx_avail(bp, txr) >= bp->tx_wake_thresh) {
395	netif_tx_wake_queue(txq);	395	netif_tx_wake_queue(txq);
396	return false;	396	return false;
397	}	397	}
@@ -764,7 +764,7 @@ next_tx_int: · 366 unmodified lines
764	smp_mb();	764	smp_mb();
765		765
766	if (unlikely(netif_tx_queue_stopped(txq)) &&	766	if (unlikely(netif_tx_queue_stopped(txq)) &&
767	bnxt_tx_avail(bp, txr) > bp->tx_wake_thresh &&	767	bnxt_tx_avail(bp, txr) >= bp->tx_wake_thresh &&
768	READ_ONCE(txr->dev_state) != BNXT_DEV_STATE_CLOSING)	768	READ_ONCE(txr->dev_state) != BNXT_DEV_STATE_CLOSING)
769	netif_tx_wake_queue(txq);	769	netif_tx_wake_queue(txq);
770	}	770	}
@@ -2416,7 +2416,7 @@ static int __bnxt_poll_work(struct bnxt bp, struct bnxt_cp_ring_info cpr, · 1645 unmodified lines
2416	if (TX_CMP_TYPE(txcmp) == CMP_TYPE_TX_L2_CMP) {	2416	if (TX_CMP_TYPE(txcmp) == CMP_TYPE_TX_L2_CMP) {
2417	tx_pkts++;	2417	tx_pkts++;
2418	/* return full budget so NAPI will complete. */	2418	/* return full budget so NAPI will complete. */
2419	if (unlikely(tx_pkts > bp->tx_wake_thresh)) {	2419	if (unlikely(tx_pkts >= bp->tx_wake_thresh)) {
2420	rx_pkts = budget;	2420	rx_pkts = budget;
2421	raw_cons = NEXT_RAW_CMP(raw_cons);	2421	raw_cons = NEXT_RAW_CMP(raw_cons);
2422	if (budget)	2422	if (budget)
@@ -3640,7 +3640,7 @@ static int bnxt_init_tx_rings(struct bnxt *bp) · 1217 unmodified lines
3640	u16 i;	3640	u16 i;
3641		3641
3642	bp->tx_wake_thresh = max_t(int, bp->tx_ring_size / 2,	3642	bp->tx_wake_thresh = max_t(int, bp->tx_ring_size / 2,
3643	MAX_SKB_FRAGS + 1);	3643	BNXT_MIN_TX_DESC_CNT);
3644		3644
3645	for (i = 0; i < bp->tx_nr_rings; i++) {	3645	for (i = 0; i < bp->tx_nr_rings; i++) {
3646	struct bnxt_tx_ring_info *txr = &bp->tx_ring[i];	3646	struct bnxt_tx_ring_info *txr = &bp->tx_ring[i];

drivers/net/ethernet/broadcom/bnxt/bnxt.h+5−0

 #define BNXT_MAX_RX_JUM_DESC_CNT	(RX_DESC_CNT * MAX_RX_AGG_PAGES - 1)
 #define BNXT_MAX_TX_DESC_CNT		(TX_DESC_CNT * MAX_TX_PAGES - 1)
+/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1.  We need one extra
+ * BD because the first TX BD is always a long BD.
+ */
+#define BNXT_MIN_TX_DESC_CNT		(MAX_SKB_FRAGS + 2)
 #define RX_RING(x)	(((x) & ~(RX_DESC_CNT - 1)) >> (BNXT_PAGE_SHIFT - 4))
 #define RX_IDX(x)	((x) & (RX_DESC_CNT - 1))

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

@@ -798,7 +798,7 @@ static int bnxt_set_ringparam(struct net_device *dev, · 797 unmodified lines
798		798
799	if ((ering->rx_pending > BNXT_MAX_RX_DESC_CNT) \|\|	799	if ((ering->rx_pending > BNXT_MAX_RX_DESC_CNT) \|\|
800	(ering->tx_pending > BNXT_MAX_TX_DESC_CNT) \|\|	800	(ering->tx_pending > BNXT_MAX_TX_DESC_CNT) \|\|
801	(ering->tx_pending <= MAX_SKB_FRAGS))	801	(ering->tx_pending < BNXT_MIN_TX_DESC_CNT))
802	return -EINVAL;	802	return -EINVAL;
803		803
804	if (netif_running(dev))	804	if (netif_running(dev))

drivers/net/ethernet/freescale/enetc/enetc.c+2−5

 static void enetc_rx_net_dim(struct enetc_int_vector *v)
 {
-	struct dim_sample dim_sample;
+	struct dim_sample dim_sample = {};
 	v->comp_cnt++;
 static int enetc_setup_irqs(struct enetc_ndev_priv *priv)
 {
 	struct pci_dev *pdev = priv->si->pdev;
-	cpumask_t cpu_mask;
 	int i, j, err;
 	for (i = 0; i < priv->bdr_int_num; i++) {
 			enetc_wr(hw, ENETC_SIMSITRV(idx), entry);
 		}
-		cpumask_clear(&cpu_mask);
+		irq_set_affinity_hint(irq, get_cpu_mask(i % num_online_cpus()));
-		cpumask_set_cpu(i % num_online_cpus(), &cpu_mask);
-		irq_set_affinity_hint(irq, &cpu_mask);
 	}
 	return 0;

drivers/net/ethernet/freescale/enetc/enetc_ierb.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)	1	// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2	/* Copyright 2021 NXP Semiconductors	2	/* Copyright 2021 NXP
3	*	3	*
4	* The Integrated Endpoint Register Block (IERB) is configured by pre-boot	4	* The Integrated Endpoint Register Block (IERB) is configured by pre-boot
5	* software and is supposed to be to ENETC what a NVRAM is to a 'real' PCIe	5	* software and is supposed to be to ENETC what a NVRAM is to a 'real' PCIe

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

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */	1	/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
2	/* Copyright 2021 NXP Semiconductors */	2	/* Copyright 2021 NXP */
3		3
4	#include <linux/pci.h>	4	#include <linux/pci.h>
5	#include <linux/platform_device.h>	5	#include <linux/platform_device.h>

drivers/net/ethernet/freescale/fec_main.c+0−1

@@ -4176,5 +4176,4 @@ static struct platform_driver fec_driver = { · 4175 unmodified lines
4176		4176
4177	module_platform_driver(fec_driver);	4177	module_platform_driver(fec_driver);
4178		4178
4179	MODULE_ALIAS("platform:"DRIVER_NAME);
4180	MODULE_LICENSE("GPL");	4179	MODULE_LICENSE("GPL");

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

@@ -2445,12 +2445,12 @@ static void hclge_handle_over_8bd_err(struct hclge_dev *hdev, · 2444 unmodified lines
2445	return;	2445	return;
2446	}	2446	}
2447		2447
2448	dev_err(dev, "PPU_PF_ABNORMAL_INT_ST over_8bd_no_fe found, vf_id(%u), queue_id(%u)\n",	2448	dev_err(dev, "PPU_PF_ABNORMAL_INT_ST over_8bd_no_fe found, vport(%u), queue_id(%u)\n",
2449	vf_id, q_id);	2449	vf_id, q_id);
2450		2450
2451	if (vf_id) {	2451	if (vf_id) {
2452	if (vf_id >= hdev->num_alloc_vport) {	2452	if (vf_id >= hdev->num_alloc_vport) {
2453	dev_err(dev, "invalid vf id(%u)\n", vf_id);	2453	dev_err(dev, "invalid vport(%u)\n", vf_id);
2454	return;	2454	return;
2455	}	2455	}
2456		2456
@@ -2463,8 +2463,8 @@ static void hclge_handle_over_8bd_err(struct hclge_dev *hdev, · 6 unmodified lines
2463		2463
2464	ret = hclge_inform_reset_assert_to_vf(&hdev->vport[vf_id]);	2464	ret = hclge_inform_reset_assert_to_vf(&hdev->vport[vf_id]);
2465	if (ret)	2465	if (ret)
2466	dev_err(dev, "inform reset to vf(%u) failed %d!\n",	2466	dev_err(dev, "inform reset to vport(%u) failed %d!\n",
2467	hdev->vport->vport_id, ret);	2467	vf_id, ret);
2468	} else {	2468	} else {
2469	set_bit(HNAE3_FUNC_RESET, reset_requests);	2469	set_bit(HNAE3_FUNC_RESET, reset_requests);
2470	}	2470	}

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c+55−25

 		if (ret) {
 			dev_err(&hdev->pdev->dev,
 				"set vf(%u) rst failed %d!\n",
-				vport->vport_id, ret);
+				vport->vport_id - HCLGE_VF_VPORT_START_NUM,
+				ret);
 			return ret;
 		}
 		if (ret)
 			dev_warn(&hdev->pdev->dev,
 				 "inform reset to vf(%u) failed %d!\n",
-				 vport->vport_id, ret);
+				 vport->vport_id - HCLGE_VF_VPORT_START_NUM,
+				 ret);
 	}
 	return 0;
 	return 0;
 }
+static int hclge_parse_rss_hfunc(struct hclge_vport *vport, const u8 hfunc,
+				 u8 *hash_algo)
+{
+	switch (hfunc) {
+	case ETH_RSS_HASH_TOP:
+		*hash_algo = HCLGE_RSS_HASH_ALGO_TOEPLITZ;
+		return 0;
+	case ETH_RSS_HASH_XOR:
+		*hash_algo = HCLGE_RSS_HASH_ALGO_SIMPLE;
+		return 0;
+	case ETH_RSS_HASH_NO_CHANGE:
+		*hash_algo = vport->rss_algo;
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
 static int hclge_set_rss(struct hnae3_handle *handle, const u32 *indir,
 			 const  u8 *key, const  u8 hfunc)
 {
 	u8 hash_algo;
 	int ret, i;
+	ret = hclge_parse_rss_hfunc(vport, hfunc, &hash_algo);
+	if (ret) {
+		dev_err(&hdev->pdev->dev, "invalid hfunc type %u\n", hfunc);
+		return ret;
+	}
 	/* Set the RSS Hash Key if specififed by the user */
 	if (key) {
-		switch (hfunc) {
-		case ETH_RSS_HASH_TOP:
-			hash_algo = HCLGE_RSS_HASH_ALGO_TOEPLITZ;
-			break;
-		case ETH_RSS_HASH_XOR:
-			hash_algo = HCLGE_RSS_HASH_ALGO_SIMPLE;
-			break;
-		case ETH_RSS_HASH_NO_CHANGE:
-			hash_algo = vport->rss_algo;
-			break;
-		default:
-			return -EINVAL;
-		}
 		ret = hclge_set_rss_algo_key(hdev, hash_algo, key);
 		if (ret)
 			return ret;
 		/* Update the shadow RSS key with user specified qids */
 		memcpy(vport->rss_hash_key, key, HCLGE_RSS_KEY_SIZE);
-		vport->rss_algo = hash_algo;
+	} else {
+		ret = hclge_set_rss_algo_key(hdev, hash_algo,
+					     vport->rss_hash_key);
+		if (ret)
+			return ret;
 	}
+	vport->rss_algo = hash_algo;
 	/* Update the shadow RSS table with user specified qids */
 	for (i = 0; i < ae_dev->dev_specs.rss_ind_tbl_size; i++)
 		u8 vf = ethtool_get_flow_spec_ring_vf(ring_cookie);
 		u16 tqps;
+		/* To keep consistent with user's configuration, minus 1 when
+		 * printing 'vf', because vf id from ethtool is added 1 for vf.
+		 */
 		if (vf > hdev->num_req_vfs) {
 			dev_err(&hdev->pdev->dev,
-				"Error: vf id (%u) > max vf num (%u)\n",
+				"Error: vf id (%u) should be less than %u\n",
-				vf, hdev->num_req_vfs);
+				vf - 1, hdev->num_req_vfs);
 			return -EINVAL;
 		}
 	if (is_kill && !vlan_id)
 		return 0;
+	if (vlan_id >= VLAN_N_VID)
+		return -EINVAL;
 	ret = hclge_set_vf_vlan_common(hdev, vport_id, is_kill, vlan_id);
 	if (ret) {
 		dev_err(&hdev->pdev->dev,
 	return 0;
 }
-static int hclge_get_reset_status(struct hclge_dev *hdev, u16 queue_id)
+static int hclge_get_reset_status(struct hclge_dev *hdev, u16 queue_id,
+				  u8 *reset_status)
 {
 	struct hclge_reset_tqp_queue_cmd *req;
 	struct hclge_desc desc;
 		return ret;
 	}
-	return hnae3_get_bit(req->ready_to_reset, HCLGE_TQP_RESET_B);
+	*reset_status = hnae3_get_bit(req->ready_to_reset, HCLGE_TQP_RESET_B);
+	return 0;
 }
 u16 hclge_covert_handle_qid_global(struct hnae3_handle *handle, u16 queue_id)
 	struct hclge_vport *vport = hclge_get_vport(handle);
 	struct hclge_dev *hdev = vport->back;
 	u16 reset_try_times = 0;
-	int reset_status;
+	u8 reset_status;
 	u16 queue_gid;
 	int ret;
 	u16 i;
 		}
 		while (reset_try_times++ < HCLGE_TQP_RESET_TRY_TIMES) {
-			reset_status = hclge_get_reset_status(hdev, queue_gid);
+			ret = hclge_get_reset_status(hdev, queue_gid,
+						     &reset_status);
+			if (ret)
+				return ret;
 			if (reset_status)
 				break;
 		struct hclge_vport *vport = &hdev->vport[i];
 		int ret;
-		 /* Send cmd to clear VF's FUNC_RST_ING */
+		 /* Send cmd to clear vport's FUNC_RST_ING */
 		ret = hclge_set_vf_rst(hdev, vport->vport_id, false);
 		if (ret)
 			dev_warn(&hdev->pdev->dev,
-				 "clear vf(%u) rst failed %d!\n",
+				 "clear vport(%u) rst failed %d!\n",
 				 vport->vport_id, ret);
 	}
 }

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c+9−1

 	struct hclge_dev *hdev = vport->back;
 	dev_warn(&hdev->pdev->dev, "PF received VF reset request from VF %u!",
-		 vport->vport_id);
+		 vport->vport_id - HCLGE_VF_VPORT_START_NUM);
 	return hclge_func_reset_cmd(hdev, vport->vport_id);
 }
 				     struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 				     struct hclge_respond_to_vf_msg *resp_msg)
 {
+	struct hnae3_handle *handle = &vport->nic;
+	struct hclge_dev *hdev = vport->back;
 	u16 queue_id, qid_in_pf;
 	memcpy(&queue_id, mbx_req->msg.data, sizeof(queue_id));
+	if (queue_id >= handle->kinfo.num_tqps) {
+		dev_err(&hdev->pdev->dev, "Invalid queue id(%u) from VF %u\n",
+			queue_id, mbx_req->mbx_src_vfid);
+		return;
+	}
 	qid_in_pf = hclge_covert_handle_qid_global(&vport->nic, queue_id);
 	memcpy(resp_msg->data, &qid_in_pf, sizeof(qid_in_pf));
 	resp_msg->len = sizeof(qid_in_pf);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c+1−1

@@ -581,7 +581,7 @@ int hclge_tm_qs_shaper_cfg(struct hclge_vport *vport, int max_tx_rate) · 580 unmodified lines
581	ret = hclge_cmd_send(&hdev->hw, &desc, 1);	581	ret = hclge_cmd_send(&hdev->hw, &desc, 1);
582	if (ret) {	582	if (ret) {
583	dev_err(&hdev->pdev->dev,	583	dev_err(&hdev->pdev->dev,
584	"vf%u, qs%u failed to set tx_rate:%d, ret=%d\n",	584	"vport%u, qs%u failed to set tx_rate:%d, ret=%d\n",
585	vport->vport_id, shap_cfg_cmd->qs_id,	585	vport->vport_id, shap_cfg_cmd->qs_id,
586	max_tx_rate, ret);	586	max_tx_rate, ret);
587	return ret;	587	return ret;

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c+34−18

 	return 0;
 }
+static int hclgevf_parse_rss_hfunc(struct hclgevf_dev *hdev, const u8 hfunc,
+				   u8 *hash_algo)
+{
+	switch (hfunc) {
+	case ETH_RSS_HASH_TOP:
+		*hash_algo = HCLGEVF_RSS_HASH_ALGO_TOEPLITZ;
+		return 0;
+	case ETH_RSS_HASH_XOR:
+		*hash_algo = HCLGEVF_RSS_HASH_ALGO_SIMPLE;
+		return 0;
+	case ETH_RSS_HASH_NO_CHANGE:
+		*hash_algo = hdev->rss_cfg.hash_algo;
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
 static int hclgevf_set_rss(struct hnae3_handle *handle, const u32 *indir,
 			   const u8 *key, const u8 hfunc)
 {
 	struct hclgevf_dev *hdev = hclgevf_ae_get_hdev(handle);
 	struct hclgevf_rss_cfg *rss_cfg = &hdev->rss_cfg;
+	u8 hash_algo;
 	int ret, i;
 	if (hdev->ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2) {
+		ret = hclgevf_parse_rss_hfunc(hdev, hfunc, &hash_algo);
+		if (ret)
+			return ret;
 		/* Set the RSS Hash Key if specififed by the user */
 		if (key) {
-			switch (hfunc) {
+			ret = hclgevf_set_rss_algo_key(hdev, hash_algo, key);
-			case ETH_RSS_HASH_TOP:
+			if (ret) {
-				rss_cfg->hash_algo =
+				dev_err(&hdev->pdev->dev,
-					HCLGEVF_RSS_HASH_ALGO_TOEPLITZ;
+					"invalid hfunc type %u\n", hfunc);
-				break;
-			case ETH_RSS_HASH_XOR:
-				rss_cfg->hash_algo =
-					HCLGEVF_RSS_HASH_ALGO_SIMPLE;
-				break;
-			case ETH_RSS_HASH_NO_CHANGE:
-				break;
-			default:
-				return -EINVAL;
-			}
-			ret = hclgevf_set_rss_algo_key(hdev, rss_cfg->hash_algo,
-						       key);
-			if (ret)
 				return ret;
+			}
 			/* Update the shadow RSS key with user specified qids */
 			memcpy(rss_cfg->rss_hash_key, key,
 			       HCLGEVF_RSS_KEY_SIZE);
+		} else {
+			ret = hclgevf_set_rss_algo_key(hdev, hash_algo,
+						       rss_cfg->rss_hash_key);
+			if (ret)
+				return ret;
 		}
+		rss_cfg->hash_algo = hash_algo;
 	}
 	/* update the shadow RSS table with user specified qids */

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

@@ -335,6 +335,7 @@ config IGC · 334 unmodified lines
335	tristate "Intel(R) Ethernet Controller I225-LM/I225-V support"	335	tristate "Intel(R) Ethernet Controller I225-LM/I225-V support"
336	default n	336	default n
337	depends on PCI	337	depends on PCI
		338	depends on PTP_1588_CLOCK_OPTIONAL
338	help	339	help
339	This driver supports Intel(R) Ethernet Controller I225-LM/I225-V	340	This driver supports Intel(R) Ethernet Controller I225-LM/I225-V
340	family of adapters.	341	family of adapters.

drivers/net/ethernet/mediatek/mtk_ppe_offload.c+3−0

@@ -186,6 +186,9 @@ mtk_flow_offload_replace(struct mtk_eth eth, struct flow_cls_offload f) · 185 unmodified lines
186	int hash;	186	int hash;
187	int i;	187	int i;
188		188
		189	if (rhashtable_lookup(&eth->flow_table, &f->cookie, mtk_flow_ht_params))
		190	return -EEXIST;
		191
189	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_META)) {	192	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_META)) {
190	struct flow_match_meta match;	193	struct flow_match_meta match;
191		194

drivers/net/ethernet/mellanox/mlx4/en_netdev.c+32−18

@@ -372,6 +372,9 @@ mlx4_en_filter_rfs(struct net_device net_dev, const struct sk_buff skb, · 371 unmodified lines
372	int nhoff = skb_network_offset(skb);	372	int nhoff = skb_network_offset(skb);
373	int ret = 0;	373	int ret = 0;
374		374
		375	if (skb->encapsulation)
		376	return -EPROTONOSUPPORT;
		377
375	if (skb->protocol != htons(ETH_P_IP))	378	if (skb->protocol != htons(ETH_P_IP))
376	return -EPROTONOSUPPORT;	379	return -EPROTONOSUPPORT;
377		380
@@ -1269,7 +1272,6 @@ static void mlx4_en_do_set_rx_mode(struct work_struct *work) · 891 unmodified lines
1269	if (!netif_carrier_ok(dev)) {	1272	if (!netif_carrier_ok(dev)) {
1270	if (!mlx4_en_QUERY_PORT(mdev, priv->port)) {	1273	if (!mlx4_en_QUERY_PORT(mdev, priv->port)) {
1271	if (priv->port_state.link_state) {	1274	if (priv->port_state.link_state) {
1272	priv->last_link_state = MLX4_DEV_EVENT_PORT_UP;
1273	netif_carrier_on(dev);	1275	netif_carrier_on(dev);
1274	en_dbg(LINK, priv, "Link Up\n");	1276	en_dbg(LINK, priv, "Link Up\n");
1275	}	1277	}
@@ -1557,26 +1559,36 @@ static void mlx4_en_service_task(struct work_struct *work) · 281 unmodified lines
1557	mutex_unlock(&mdev->state_lock);	1559	mutex_unlock(&mdev->state_lock);
1558	}	1560	}
1559		1561
1560	static void mlx4_en_linkstate(struct work_struct *work)	1562	static void mlx4_en_linkstate(struct mlx4_en_priv *priv)
		1563	{
		1564	struct mlx4_en_port_state *port_state = &priv->port_state;
		1565	struct mlx4_en_dev *mdev = priv->mdev;
		1566	struct net_device *dev = priv->dev;
		1567	bool up;
		1568
		1569	if (mlx4_en_QUERY_PORT(mdev, priv->port))
		1570	port_state->link_state = MLX4_PORT_STATE_DEV_EVENT_PORT_DOWN;
		1571
		1572	up = port_state->link_state == MLX4_PORT_STATE_DEV_EVENT_PORT_UP;
		1573	if (up == netif_carrier_ok(dev))
		1574	netif_carrier_event(dev);
		1575	if (!up) {
		1576	en_info(priv, "Link Down\n");
		1577	netif_carrier_off(dev);
		1578	} else {
		1579	en_info(priv, "Link Up\n");
		1580	netif_carrier_on(dev);
		1581	}
		1582	}
		1583
		1584	static void mlx4_en_linkstate_work(struct work_struct *work)
1561	{	1585	{
1562	struct mlx4_en_priv *priv = container_of(work, struct mlx4_en_priv,	1586	struct mlx4_en_priv *priv = container_of(work, struct mlx4_en_priv,
1563	linkstate_task);	1587	linkstate_task);
1564	struct mlx4_en_dev *mdev = priv->mdev;	1588	struct mlx4_en_dev *mdev = priv->mdev;
1565	int linkstate = priv->link_state;
1566		1589
1567	mutex_lock(&mdev->state_lock);	1590	mutex_lock(&mdev->state_lock);
1568	/* If observable port state changed set carrier state and	1591	mlx4_en_linkstate(priv);
1569	* report to system log */
1570	if (priv->last_link_state != linkstate) {
1571	if (linkstate == MLX4_DEV_EVENT_PORT_DOWN) {
1572	en_info(priv, "Link Down\n");
1573	netif_carrier_off(priv->dev);
1574	} else {
1575	en_info(priv, "Link Up\n");
1576	netif_carrier_on(priv->dev);
1577	}
1578	}
1579	priv->last_link_state = linkstate;
1580	mutex_unlock(&mdev->state_lock);	1592	mutex_unlock(&mdev->state_lock);
1581	}	1593	}
1582		1594
@@ -2079,9 +2091,11 @@ static int mlx4_en_open(struct net_device *dev) · 496 unmodified lines
2079	mlx4_en_clear_stats(dev);	2091	mlx4_en_clear_stats(dev);
2080		2092
2081	err = mlx4_en_start_port(dev);	2093	err = mlx4_en_start_port(dev);
2082	if (err)	2094	if (err) {
2083	en_err(priv, "Failed starting port:%d\n", priv->port);	2095	en_err(priv, "Failed starting port:%d\n", priv->port);
2084		2096	goto out;
		2097	}
		2098	mlx4_en_linkstate(priv);
2085	out:	2099	out:
2086	mutex_unlock(&mdev->state_lock);	2100	mutex_unlock(&mdev->state_lock);
2087	return err;	2101	return err;
@@ -3168,7 +3182,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, · 1080 unmodified lines
3168	spin_lock_init(&priv->stats_lock);	3182	spin_lock_init(&priv->stats_lock);
3169	INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);	3183	INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);
3170	INIT_WORK(&priv->restart_task, mlx4_en_restart);	3184	INIT_WORK(&priv->restart_task, mlx4_en_restart);
3171	INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);	3185	INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate_work);
3172	INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);	3186	INIT_DELAYED_WORK(&priv->stats_task, mlx4_en_do_get_stats);
3173	INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);	3187	INIT_DELAYED_WORK(&priv->service_task, mlx4_en_service_task);
3174	#ifdef CONFIG_RFS_ACCEL	3188	#ifdef CONFIG_RFS_ACCEL

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h+0−1

@@ -552,7 +552,6 @@ struct mlx4_en_priv { · 551 unmodified lines
552		552
553	struct mlx4_hwq_resources res;	553	struct mlx4_hwq_resources res;
554	int link_state;	554	int link_state;
555	int last_link_state;
556	bool port_up;	555	bool port_up;
557	int port;	556	int port;
558	int registered;	557	int registered;

drivers/net/ethernet/mscc/ocelot.c+8−13

 	ocelot_port_writel(ocelot_port, DEV_MAC_ENA_CFG_RX_ENA |
 			   DEV_MAC_ENA_CFG_TX_ENA, DEV_MAC_ENA_CFG);
-	/* Take MAC, Port, Phy (intern) and PCS (SGMII/Serdes) clock out of
-	 * reset
-	 */
-	ocelot_port_writel(ocelot_port, DEV_CLOCK_CFG_LINK_SPEED(speed),
-			   DEV_CLOCK_CFG);
-	/* No PFC */
-	ocelot_write_gix(ocelot, ANA_PFC_PFC_CFG_FC_LINK_SPEED(speed),
-			 ANA_PFC_PFC_CFG, port);
 	/* Core: Enable port for frame transfer */
 	ocelot_fields_write(ocelot, port,
 			    QSYS_SWITCH_PORT_MODE_PORT_ENA, 1);
 	return mask;
 }
-static u32 ocelot_get_bridge_fwd_mask(struct ocelot *ocelot,
+static u32 ocelot_get_bridge_fwd_mask(struct ocelot *ocelot, int src_port,
 				      struct net_device *bridge)
 {
+	struct ocelot_port *ocelot_port = ocelot->ports[src_port];
 	u32 mask = 0;
 	int port;
+	if (!ocelot_port || ocelot_port->bridge != bridge ||
+	    ocelot_port->stp_state != BR_STATE_FORWARDING)
+		return 0;
 	for (port = 0; port < ocelot->num_phys_ports; port++) {
-		struct ocelot_port *ocelot_port = ocelot->ports[port];
+		ocelot_port = ocelot->ports[port];
 		if (!ocelot_port)
 			continue;
 			struct net_device *bridge = ocelot_port->bridge;
 			struct net_device *bond = ocelot_port->bond;
-			mask = ocelot_get_bridge_fwd_mask(ocelot, bridge);
+			mask = ocelot_get_bridge_fwd_mask(ocelot, port, bridge);
 			mask |= cpu_fwd_mask;
 			mask &= ~BIT(port);
 			if (bond) {

drivers/net/ethernet/mscc/ocelot_devlink.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: (GPL-2.0 OR MIT)	1	// SPDX-License-Identifier: (GPL-2.0 OR MIT)
2	/* Copyright 2020-2021 NXP Semiconductors	2	/* Copyright 2020-2021 NXP
3	*/	3	*/
4	#include <net/devlink.h>	4	#include <net/devlink.h>
5	#include "ocelot.h"	5	#include "ocelot.h"

drivers/net/ethernet/mscc/ocelot_mrp.c+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	/* Microsemi Ocelot Switch driver	2	/* Microsemi Ocelot Switch driver
3	*	3	*
4	* Copyright (c) 2017, 2019 Microsemi Corporation	4	* Copyright (c) 2017, 2019 Microsemi Corporation
5	* Copyright 2020-2021 NXP Semiconductors	5	* Copyright 2020-2021 NXP
6	*/	6	*/
7		7
8	#include <linux/if_bridge.h>	8	#include <linux/if_bridge.h>

drivers/net/ethernet/mscc/ocelot_net.c+1−1

@@ -5,7 +5,7 @@ · 4 unmodified lines
5	* mscc_ocelot_switch_lib.	5	* mscc_ocelot_switch_lib.
6	*	6	*
7	* Copyright (c) 2017, 2019 Microsemi Corporation	7	* Copyright (c) 2017, 2019 Microsemi Corporation
8	* Copyright 2020-2021 NXP Semiconductors	8	* Copyright 2020-2021 NXP
9	*/	9	*/
10		10
11	#include <linux/if_bridge.h>	11	#include <linux/if_bridge.h>

drivers/net/ethernet/qlogic/qed/qed_iwarp.c+8−0

@@ -1297,6 +1297,14 @@ qed_iwarp_wait_cid_map_cleared(struct qed_hwfn p_hwfn, struct qed_bmap bmap) · 1296 unmodified lines
1297	prev_weight = weight;	1297	prev_weight = weight;
1298		1298
1299	while (weight) {	1299	while (weight) {
		1300	/* If the HW device is during recovery, all resources are
		1301	* immediately reset without receiving a per-cid indication
		1302	* from HW. In this case we don't expect the cid_map to be
		1303	* cleared.
		1304	*/
		1305	if (p_hwfn->cdev->recov_in_prog)
		1306	return 0;
		1307
1300	msleep(QED_IWARP_MAX_CID_CLEAN_TIME);	1308	msleep(QED_IWARP_MAX_CID_CLEAN_TIME);
1301		1309
1302	weight = bitmap_weight(bmap->bitmap, bmap->max_count);	1310	weight = bitmap_weight(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_roce.c+8−0

@@ -77,6 +77,14 @@ void qed_roce_stop(struct qed_hwfn *p_hwfn) · 76 unmodified lines
77	* Beyond the added delay we clear the bitmap anyway.	77	* Beyond the added delay we clear the bitmap anyway.
78	*/	78	*/
79	while (bitmap_weight(rcid_map->bitmap, rcid_map->max_count)) {	79	while (bitmap_weight(rcid_map->bitmap, rcid_map->max_count)) {
		80	/* If the HW device is during recovery, all resources are
		81	* immediately reset without receiving a per-cid indication
		82	* from HW. In this case we don't expect the cid bitmap to be
		83	* cleared.
		84	*/
		85	if (p_hwfn->cdev->recov_in_prog)
		86	return;
		87
80	msleep(100);	88	msleep(100);
81	if (wait_count++ > 20) {	89	if (wait_count++ > 20) {
82	DP_NOTICE(p_hwfn, "cid bitmap wait timed out\n");	90	DP_NOTICE(p_hwfn, "cid bitmap wait timed out\n");

drivers/net/hamradio/dmascc.c+3−3

@@ -973,7 +973,7 @@ static inline void tx_on(struct scc_priv *priv) · 972 unmodified lines
973	flags = claim_dma_lock();	973	flags = claim_dma_lock();
974	set_dma_mode(priv->param.dma, DMA_MODE_WRITE);	974	set_dma_mode(priv->param.dma, DMA_MODE_WRITE);
975	set_dma_addr(priv->param.dma,	975	set_dma_addr(priv->param.dma,
976	(int) priv->tx_buf[priv->tx_tail] + n);	976	virt_to_bus(priv->tx_buf[priv->tx_tail]) + n);
977	set_dma_count(priv->param.dma,	977	set_dma_count(priv->param.dma,
978	priv->tx_len[priv->tx_tail] - n);	978	priv->tx_len[priv->tx_tail] - n);
979	release_dma_lock(flags);	979	release_dma_lock(flags);
@@ -1020,7 +1020,7 @@ static inline void rx_on(struct scc_priv *priv) · 40 unmodified lines
1020	flags = claim_dma_lock();	1020	flags = claim_dma_lock();
1021	set_dma_mode(priv->param.dma, DMA_MODE_READ);	1021	set_dma_mode(priv->param.dma, DMA_MODE_READ);
1022	set_dma_addr(priv->param.dma,	1022	set_dma_addr(priv->param.dma,
1023	(int) priv->rx_buf[priv->rx_head]);	1023	virt_to_bus(priv->rx_buf[priv->rx_head]));
1024	set_dma_count(priv->param.dma, BUF_SIZE);	1024	set_dma_count(priv->param.dma, BUF_SIZE);
1025	release_dma_lock(flags);	1025	release_dma_lock(flags);
1026	enable_dma(priv->param.dma);	1026	enable_dma(priv->param.dma);
@@ -1233,7 +1233,7 @@ static void special_condition(struct scc_priv *priv, int rc) · 206 unmodified lines
1233	if (priv->param.dma >= 0) {	1233	if (priv->param.dma >= 0) {
1234	flags = claim_dma_lock();	1234	flags = claim_dma_lock();
1235	set_dma_addr(priv->param.dma,	1235	set_dma_addr(priv->param.dma,
1236	(int) priv->rx_buf[priv->rx_head]);	1236	virt_to_bus(priv->rx_buf[priv->rx_head]));
1237	set_dma_count(priv->param.dma, BUF_SIZE);	1237	set_dma_count(priv->param.dma, BUF_SIZE);
1238	release_dma_lock(flags);	1238	release_dma_lock(flags);
1239	} else {	1239	} else {

drivers/net/pcs/pcs-xpcs-nxp.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2021 NXP Semiconductors	2	/* Copyright 2021 NXP
3	*/	3	*/
4	#include <linux/pcs/pcs-xpcs.h>	4	#include <linux/pcs/pcs-xpcs.h>
5	#include "pcs-xpcs.h"	5	#include "pcs-xpcs.h"

drivers/net/phy/mdio_device.c+11−0

 	return 0;
 }
+static void mdio_shutdown(struct device *dev)
+{
+	struct mdio_device *mdiodev = to_mdio_device(dev);
+	struct device_driver *drv = mdiodev->dev.driver;
+	struct mdio_driver *mdiodrv = to_mdio_driver(drv);
+	if (mdiodrv->shutdown)
+		mdiodrv->shutdown(mdiodev);
+}
 /**
  * mdio_driver_register - register an mdio_driver with the MDIO layer
  * @drv: new mdio_driver to register
 	mdiodrv->driver.bus = &mdio_bus_type;
 	mdiodrv->driver.probe = mdio_probe;
 	mdiodrv->driver.remove = mdio_remove;
+	mdiodrv->driver.shutdown = mdio_shutdown;
 	retval = driver_register(&mdiodrv->driver);
 	if (retval) {

drivers/net/usb/hso.c+5−7

 	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 	if (!serial)
-		goto exit;
+		goto err_free_dev;
 	hso_dev->port_data.dev_serial = serial;
 	serial->parent = hso_dev;
 	if (hso_serial_common_create
 	    (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
-		goto exit;
+		goto err_free_serial;
 	serial->tx_data_length--;
 	serial->write_data = hso_mux_serial_write_data;
 	/* done, return it */
 	return hso_dev;
-exit:
+err_free_serial:
-	if (serial) {
+	kfree(serial);
-		tty_unregister_device(tty_drv, serial->minor);
+err_free_dev:
-		kfree(serial);
-	}
 	kfree(hso_dev);
 	return NULL;

drivers/net/virtio_net.c+4−0

@@ -425,6 +425,10 @@ static struct sk_buff page_to_skb(struct virtnet_info vi, · 424 unmodified lines
425		425
426	skb_reserve(skb, p - buf);	426	skb_reserve(skb, p - buf);
427	skb_put(skb, len);	427	skb_put(skb, len);
		428
		429	page = (struct page *)page->private;
		430	if (page)
		431	give_pages(rq, page);
428	goto ok;	432	goto ok;
429	}	433	}
430		434

drivers/net/vxlan.c+1−1

 	LIST_HEAD(list);
 	unsigned int h;
-	rtnl_lock();
 	list_for_each_entry(net, net_list, exit_list) {
 		struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 		unregister_nexthop_notifier(net, &vn->nexthop_notifier_block);
 	}
+	rtnl_lock();
 	list_for_each_entry(net, net_list, exit_list)
 		vxlan_destroy_tunnels(net, &list);

drivers/net/xen-netback/netback.c+1−1

@@ -499,7 +499,7 @@ check_frags: · 498 unmodified lines
499	* the header's copy failed, and they are	499	* the header's copy failed, and they are
500	* sharing a slot, send an error	500	* sharing a slot, send an error
501	*/	501	*/
502	if (i == 0 && sharedslot)	502	if (i == 0 && !first_shinfo && sharedslot)
503	xenvif_idx_release(queue, pending_idx,	503	xenvif_idx_release(queue, pending_idx,
504	XEN_NETIF_RSP_ERROR);	504	XEN_NETIF_RSP_ERROR);
505	else	505	else

drivers/nfc/st-nci/spi.c+1−0

@@ -278,6 +278,7 @@ static int st_nci_spi_remove(struct spi_device *dev) · 277 unmodified lines
278		278
279	static struct spi_device_id st_nci_spi_id_table[] = {	279	static struct spi_device_id st_nci_spi_id_table[] = {
280	{ST_NCI_SPI_DRIVER_NAME, 0},	280	{ST_NCI_SPI_DRIVER_NAME, 0},
		281	{"st21nfcb-spi", 0},
281	{}	282	{}
282	};	283	};
283	MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table);	284	MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table);

drivers/nvme/host/core.c+7−10

 	lockdep_assert_held(&subsys->lock);
 	list_for_each_entry(h, &subsys->nsheads, entry) {
-		if (h->ns_id == nsid && nvme_tryget_ns_head(h))
+		if (h->ns_id != nsid)
+			continue;
+		if (!list_empty(&h->list) && nvme_tryget_ns_head(h))
 			return h;
 	}
 	mutex_lock(&ns->ctrl->subsys->lock);
 	list_del_rcu(&ns->siblings);
+	if (list_empty(&ns->head->list)) {
+		list_del_init(&ns->head->entry);
+		last_path = true;
+	}
 	mutex_unlock(&ns->ctrl->subsys->lock);
 	/* guarantee not available in head->list */
 		nvme_cdev_del(&ns->cdev, &ns->cdev_device);
 	del_gendisk(ns->disk);
 	blk_cleanup_queue(ns->queue);
-	if (blk_get_integrity(ns->disk))
-		blk_integrity_unregister(ns->disk);
 	down_write(&ns->ctrl->namespaces_rwsem);
 	list_del_init(&ns->list);
 	up_write(&ns->ctrl->namespaces_rwsem);
-	/* Synchronize with nvme_init_ns_head() */
-	mutex_lock(&ns->head->subsys->lock);
-	if (list_empty(&ns->head->list)) {
-		list_del_init(&ns->head->entry);
-		last_path = true;
-	}
-	mutex_unlock(&ns->head->subsys->lock);
 	if (last_path)
 		nvme_mpath_shutdown_disk(ns->head);
 	nvme_put_ns(ns);

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

@@ -600,14 +600,17 @@ static int nvme_update_ana_state(struct nvme_ctrl *ctrl, · 599 unmodified lines
600		600
601	down_read(&ctrl->namespaces_rwsem);	601	down_read(&ctrl->namespaces_rwsem);
602	list_for_each_entry(ns, &ctrl->namespaces, list) {	602	list_for_each_entry(ns, &ctrl->namespaces, list) {
603	unsigned nsid = le32_to_cpu(desc->nsids[n]);	603	unsigned nsid;
604		604	again:
		605	nsid = le32_to_cpu(desc->nsids[n]);
605	if (ns->head->ns_id < nsid)	606	if (ns->head->ns_id < nsid)
606	continue;	607	continue;
607	if (ns->head->ns_id == nsid)	608	if (ns->head->ns_id == nsid)
608	nvme_update_ns_ana_state(desc, ns);	609	nvme_update_ns_ana_state(desc, ns);
609	if (++n == nr_nsids)	610	if (++n == nr_nsids)
610	break;	611	break;
		612	if (ns->head->ns_id > nsid)
		613	goto again;
611	}	614	}
612	up_read(&ctrl->namespaces_rwsem);	615	up_read(&ctrl->namespaces_rwsem);
613	return 0;	616	return 0;

drivers/nvme/host/rdma.c+3−13

 	if (!test_and_clear_bit(NVME_RDMA_Q_ALLOCATED, &queue->flags))
 		return;
-	nvme_rdma_destroy_queue_ib(queue);
 	rdma_destroy_id(queue->cm_id);
+	nvme_rdma_destroy_queue_ib(queue);
 	mutex_destroy(&queue->queue_lock);
 }
 	for (i = 0; i < queue->queue_size; i++) {
 		ret = nvme_rdma_post_recv(queue, &queue->rsp_ring[i]);
 		if (ret)
-			goto out_destroy_queue_ib;
+			return ret;
 	}
 	return 0;
-out_destroy_queue_ib:
-	nvme_rdma_destroy_queue_ib(queue);
-	return ret;
 }
 static int nvme_rdma_conn_rejected(struct nvme_rdma_queue *queue,
 	if (ret) {
 		dev_err(ctrl->ctrl.device,
 			"rdma_connect_locked failed (%d).\n", ret);
-		goto out_destroy_queue_ib;
+		return ret;
 	}
 	return 0;
-out_destroy_queue_ib:
-	nvme_rdma_destroy_queue_ib(queue);
-	return ret;
 }
 static int nvme_rdma_cm_handler(struct rdma_cm_id *cm_id,
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 	case RDMA_CM_EVENT_CONNECT_ERROR:
 	case RDMA_CM_EVENT_UNREACHABLE:
-		nvme_rdma_destroy_queue_ib(queue);
-		fallthrough;
 	case RDMA_CM_EVENT_ADDR_ERROR:
 		dev_dbg(queue->ctrl->ctrl.device,
 			"CM error event %d\n", ev->event);

drivers/nvme/host/tcp.c+10−10

 	} while (ret > 0);
 }
+static inline bool nvme_tcp_queue_more(struct nvme_tcp_queue *queue)
+{
+	return !list_empty(&queue->send_list) ||
+		!llist_empty(&queue->req_list) || queue->more_requests;
+}
 static inline void nvme_tcp_queue_request(struct nvme_tcp_request *req,
 		bool sync, bool last)
 {
 		nvme_tcp_send_all(queue);
 		queue->more_requests = false;
 		mutex_unlock(&queue->send_mutex);
-	} else if (last) {
-		queue_work_on(queue->io_cpu, nvme_tcp_wq, &queue->io_work);
 	}
+	if (last && nvme_tcp_queue_more(queue))
+		queue_work_on(queue->io_cpu, nvme_tcp_wq, &queue->io_work);
 }
 static void nvme_tcp_process_req_list(struct nvme_tcp_queue *queue)
 	read_unlock_bh(&sk->sk_callback_lock);
 }
-static inline bool nvme_tcp_queue_more(struct nvme_tcp_queue *queue)
-{
-	return !list_empty(&queue->send_list) ||
-		!llist_empty(&queue->req_list) || queue->more_requests;
-}
 static inline void nvme_tcp_done_send_req(struct nvme_tcp_queue *queue)
 {
 	queue->request = NULL;
 				pending = true;
 			else if (unlikely(result < 0))
 				break;
-		} else
+		}
-			pending = !llist_empty(&queue->req_list);
 		result = nvme_tcp_try_recv(queue);
 		if (result > 0)

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

@@ -1067,7 +1067,7 @@ static ssize_t nvmet_subsys_attr_serial_show(struct config_item *item, · 1066 unmodified lines
1067	{	1067	{
1068	struct nvmet_subsys *subsys = to_subsys(item);	1068	struct nvmet_subsys *subsys = to_subsys(item);
1069		1069
1070	return snprintf(page, PAGE_SIZE, "%*s\n",	1070	return snprintf(page, PAGE_SIZE, "%.*s\n",
1071	NVMET_SN_MAX_SIZE, subsys->serial);	1071	NVMET_SN_MAX_SIZE, subsys->serial);
1072	}	1072	}
1073		1073

drivers/of/device.c+5−1

 			break;
 	}
-	if (i != count && of_reserved_mem_device_init_by_idx(dev, of_node, i))
+	/*
+	 * Attempt to initialize a restricted-dma-pool region if one was found.
+	 * Note that count can hold a negative error code.
+	 */
+	if (i < count && of_reserved_mem_device_init_by_idx(dev, of_node, i))
 		dev_warn(dev, "failed to initialise \"restricted-dma-pool\" memory node\n");
 }

drivers/of/property.c+0−2

 DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells")
 DEFINE_SIMPLE_PROP(leds, "leds", NULL)
 DEFINE_SIMPLE_PROP(backlight, "backlight", NULL)
-DEFINE_SIMPLE_PROP(phy_handle, "phy-handle", NULL)
 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
 DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells")
 	{ .parse_prop = parse_resets, },
 	{ .parse_prop = parse_leds, },
 	{ .parse_prop = parse_backlight, },
-	{ .parse_prop = parse_phy_handle, },
 	{ .parse_prop = parse_gpio_compat, },
 	{ .parse_prop = parse_interrupts, },
 	{ .parse_prop = parse_regulators, },

drivers/pci/pci-acpi.c+1−1

@@ -937,7 +937,7 @@ static struct acpi_device acpi_pci_find_companion(struct device dev); · 936 unmodified lines
937		937
938	void pci_set_acpi_fwnode(struct pci_dev *dev)	938	void pci_set_acpi_fwnode(struct pci_dev *dev)
939	{	939	{
940	if (!ACPI_COMPANION(&dev->dev) && !pci_dev_is_added(dev))	940	if (!dev_fwnode(&dev->dev) && !pci_dev_is_added(dev))
941	ACPI_COMPANION_SET(&dev->dev,	941	ACPI_COMPANION_SET(&dev->dev,
942	acpi_pci_find_companion(&dev->dev));	942	acpi_pci_find_companion(&dev->dev));
943	}	943	}

drivers/pci/quirks.c+7−2

 			      PCI_CLASS_MULTIMEDIA_HD_AUDIO, 8, quirk_gpu_hda);
 /*
- * Create device link for NVIDIA GPU with integrated USB xHCI Host
+ * Create device link for GPUs with integrated USB xHCI Host
  * controller to VGA.
  */
 static void quirk_gpu_usb(struct pci_dev *usb)
 }
 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
 			      PCI_CLASS_SERIAL_USB, 8, quirk_gpu_usb);
+DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_ATI, PCI_ANY_ID,
+			      PCI_CLASS_SERIAL_USB, 8, quirk_gpu_usb);
 /*
- * Create device link for NVIDIA GPU with integrated Type-C UCSI controller
+ * Create device link for GPUs with integrated Type-C UCSI controller
  * to VGA. Currently there is no class code defined for UCSI device over PCI
  * so using UNKNOWN class for now and it will be updated when UCSI
  * over PCI gets a class code.
 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
 			      PCI_CLASS_SERIAL_UNKNOWN, 8,
 			      quirk_gpu_usb_typec_ucsi);
+DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_ATI, PCI_ANY_ID,
+			      PCI_CLASS_SERIAL_UNKNOWN, 8,
+			      quirk_gpu_usb_typec_ucsi);
 /*
  * Enable the NVIDIA GPU integrated HDA controller if the BIOS left it

drivers/pci/vpd.c+26−10

 	return off ?: PCI_VPD_SZ_INVALID;
 }
+static bool pci_vpd_available(struct pci_dev *dev)
+{
+	struct pci_vpd *vpd = &dev->vpd;
+	if (!vpd->cap)
+		return false;
+	if (vpd->len == 0) {
+		vpd->len = pci_vpd_size(dev);
+		if (vpd->len == PCI_VPD_SZ_INVALID) {
+			vpd->cap = 0;
+			return false;
+		}
+	}
+	return true;
+}
 /*
  * Wait for last operation to complete.
  * This code has to spin since there is no other notification from the PCI
 	loff_t end = pos + count;
 	u8 *buf = arg;
-	if (!vpd->cap)
+	if (!pci_vpd_available(dev))
 		return -ENODEV;
 	if (pos < 0)
 	loff_t end = pos + count;
 	int ret = 0;
-	if (!vpd->cap)
+	if (!pci_vpd_available(dev))
 		return -ENODEV;
 	if (pos < 0 || (pos & 3) || (count & 3))
 void pci_vpd_init(struct pci_dev *dev)
 {
+	if (dev->vpd.len == PCI_VPD_SZ_INVALID)
+		return;
 	dev->vpd.cap = pci_find_capability(dev, PCI_CAP_ID_VPD);
 	mutex_init(&dev->vpd.lock);
-	if (!dev->vpd.len)
-		dev->vpd.len = pci_vpd_size(dev);
-	if (dev->vpd.len == PCI_VPD_SZ_INVALID)
-		dev->vpd.cap = 0;
 }
 static ssize_t vpd_read(struct file *filp, struct kobject *kobj,
 void *pci_vpd_alloc(struct pci_dev *dev, unsigned int *size)
 {
-	unsigned int len = dev->vpd.len;
+	unsigned int len;
 	void *buf;
 	int cnt;
-	if (!dev->vpd.cap)
+	if (!pci_vpd_available(dev))
 		return ERR_PTR(-ENODEV);
+	len = dev->vpd.len;
 	buf = kmalloc(len, GFP_KERNEL);
 	if (!buf)
 		return ERR_PTR(-ENOMEM);

drivers/platform/x86/amd-pmc.c+1−1

@@ -71,7 +71,7 @@ · 70 unmodified lines
71	#define AMD_CPU_ID_YC 0x14B5	71	#define AMD_CPU_ID_YC 0x14B5
72		72
73	#define PMC_MSG_DELAY_MIN_US 100	73	#define PMC_MSG_DELAY_MIN_US 100
74	#define RESPONSE_REGISTER_LOOP_MAX 200	74	#define RESPONSE_REGISTER_LOOP_MAX 20000
75		75
76	#define SOC_SUBSYSTEM_IP_MAX 12	76	#define SOC_SUBSYSTEM_IP_MAX 12
77	#define DELAY_MIN_US 2000	77	#define DELAY_MIN_US 2000

drivers/platform/x86/dell/Kconfig+1−2

@@ -166,8 +166,7 @@ config DELL_WMI · 165 unmodified lines
166		166
167	config DELL_WMI_PRIVACY	167	config DELL_WMI_PRIVACY
168	bool "Dell WMI Hardware Privacy Support"	168	bool "Dell WMI Hardware Privacy Support"
169	depends on DELL_WMI	169	depends on LEDS_TRIGGER_AUDIO = y \|\| DELL_WMI = LEDS_TRIGGER_AUDIO
170	depends on LEDS_TRIGGER_AUDIO
171	help	170	help
172	This option adds integration with the "Dell Hardware Privacy"	171	This option adds integration with the "Dell Hardware Privacy"
173	feature of Dell laptops to the dell-wmi driver.	172	feature of Dell laptops to the dell-wmi driver.

drivers/platform/x86/gigabyte-wmi.c+1−0

@@ -144,6 +144,7 @@ static const struct dmi_system_id gigabyte_wmi_known_working_platforms[] = { · 143 unmodified lines
144	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE"),	144	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE"),
145	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE V2"),	145	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE V2"),
146	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 GAMING X V2"),	146	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 GAMING X V2"),
		147	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550I AORUS PRO AX"),
147	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M AORUS PRO-P"),	148	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M AORUS PRO-P"),
148	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M DS3H"),	149	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550M DS3H"),
149	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("Z390 I AORUS PRO WIFI-CF"),	150	DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("Z390 I AORUS PRO WIFI-CF"),

drivers/platform/x86/intel/hid.c+22−5

 	{ }
 };
+/*
+ * Some devices, even non convertible ones, can send incorrect SW_TABLET_MODE
+ * reports. Accept such reports only from devices in this list.
+ */
+static const struct dmi_system_id dmi_auto_add_switch[] = {
+	{
+		.matches = {
+			DMI_EXACT_MATCH(DMI_CHASSIS_TYPE, "31" /* Convertible */),
+		},
+	},
+	{
+		.matches = {
+			DMI_EXACT_MATCH(DMI_CHASSIS_TYPE, "32" /* Detachable */),
+		},
+	},
+	{} /* Array terminator */
+};
 struct intel_hid_priv {
 	struct input_dev *input_dev;
 	struct input_dev *array;
 	struct input_dev *switches;
 	bool wakeup_mode;
-	bool dual_accel;
+	bool auto_add_switch;
 };
 #define HID_EVENT_FILTER_UUID	"eeec56b3-4442-408f-a792-4edd4d758054"
 	 * Some convertible have unreliable VGBS return which could cause incorrect
 	 * SW_TABLET_MODE report, in these cases we enable support when receiving
 	 * the first event instead of during driver setup.
-	 *
-	 * See dual_accel_detect.h for more info on the dual_accel check.
 	 */
-	if (!priv->switches && !priv->dual_accel && (event == 0xcc || event == 0xcd)) {
+	if (!priv->switches && priv->auto_add_switch && (event == 0xcc || event == 0xcd)) {
 		dev_info(&device->dev, "switch event received, enable switches supports\n");
 		err = intel_hid_switches_setup(device);
 		if (err)
 		return -ENOMEM;
 	dev_set_drvdata(&device->dev, priv);
-	priv->dual_accel = dual_accel_detect();
+	/* See dual_accel_detect.h for more info on the dual_accel check. */
+	priv->auto_add_switch = dmi_check_system(dmi_auto_add_switch) && !dual_accel_detect();
 	err = intel_hid_input_setup(device);
 	if (err) {

drivers/platform/x86/intel/punit_ipc.c+1−2

  * which provide mailbox interface for power management usage.
  */
-#include <linux/acpi.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 	.remove = intel_punit_ipc_remove,
 	.driver = {
 		.name = "intel_punit_ipc",
-		.acpi_match_table = ACPI_PTR(punit_ipc_acpi_ids),
+		.acpi_match_table = punit_ipc_acpi_ids,
 	},
 };

drivers/platform/x86/lg-laptop.c+1−1

@@ -655,7 +655,7 @@ static int acpi_add(struct acpi_device *device) · 654 unmodified lines
655	goto out_platform_registered;	655	goto out_platform_registered;
656	}	656	}
657	product = dmi_get_system_info(DMI_PRODUCT_NAME);	657	product = dmi_get_system_info(DMI_PRODUCT_NAME);
658	if (strlen(product) > 4)	658	if (product && strlen(product) > 4)
659	switch (product[4]) {	659	switch (product[4]) {
660	case '5':	660	case '5':
661	case '6':	661	case '6':

drivers/platform/x86/touchscreen_dmi.c+50−4

@@ -100,10 +100,10 @@ static const struct ts_dmi_data chuwi_hi10_air_data = { · 99 unmodified lines
100	};	100	};
101		101
102	static const struct property_entry chuwi_hi10_plus_props[] = {	102	static const struct property_entry chuwi_hi10_plus_props[] = {
103	PROPERTY_ENTRY_U32("touchscreen-min-x", 0),	103	PROPERTY_ENTRY_U32("touchscreen-min-x", 12),
104	PROPERTY_ENTRY_U32("touchscreen-min-y", 5),	104	PROPERTY_ENTRY_U32("touchscreen-min-y", 10),
105	PROPERTY_ENTRY_U32("touchscreen-size-x", 1914),	105	PROPERTY_ENTRY_U32("touchscreen-size-x", 1908),
106	PROPERTY_ENTRY_U32("touchscreen-size-y", 1283),	106	PROPERTY_ENTRY_U32("touchscreen-size-y", 1270),
107	PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hi10plus.fw"),	107	PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hi10plus.fw"),
108	PROPERTY_ENTRY_U32("silead,max-fingers", 10),	108	PROPERTY_ENTRY_U32("silead,max-fingers", 10),
109	PROPERTY_ENTRY_BOOL("silead,home-button"),	109	PROPERTY_ENTRY_BOOL("silead,home-button"),
@@ -111,6 +111,15 @@ static const struct property_entry chuwi_hi10_plus_props[] = { · 1 unmodified line
111	};	111	};
112		112
113	static const struct ts_dmi_data chuwi_hi10_plus_data = {	113	static const struct ts_dmi_data chuwi_hi10_plus_data = {
		114	.embedded_fw = {
		115	.name = "silead/gsl1680-chuwi-hi10plus.fw",
		116	.prefix = { 0xf0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00 },
		117	.length = 34056,
		118	.sha256 = { 0xfd, 0x0a, 0x08, 0x08, 0x3c, 0xa6, 0x34, 0x4e,
		119	0x2c, 0x49, 0x9c, 0xcd, 0x7d, 0x44, 0x9d, 0x38,
		120	0x10, 0x68, 0xb5, 0xbd, 0xb7, 0x2a, 0x63, 0xb5,
		121	0x67, 0x0b, 0x96, 0xbd, 0x89, 0x67, 0x85, 0x09 },
		122	},
114	.acpi_name = "MSSL0017:00",	123	.acpi_name = "MSSL0017:00",
115	.properties = chuwi_hi10_plus_props,	124	.properties = chuwi_hi10_plus_props,
116	};	125	};
@@ -141,6 +150,33 @@ static const struct ts_dmi_data chuwi_hi10_pro_data = { · 24 unmodified lines
141	.properties = chuwi_hi10_pro_props,	150	.properties = chuwi_hi10_pro_props,
142	};	151	};
143		152
		153	static const struct property_entry chuwi_hibook_props[] = {
		154	PROPERTY_ENTRY_U32("touchscreen-min-x", 30),
		155	PROPERTY_ENTRY_U32("touchscreen-min-y", 4),
		156	PROPERTY_ENTRY_U32("touchscreen-size-x", 1892),
		157	PROPERTY_ENTRY_U32("touchscreen-size-y", 1276),
		158	PROPERTY_ENTRY_BOOL("touchscreen-inverted-y"),
		159	PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"),
		160	PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hibook.fw"),
		161	PROPERTY_ENTRY_U32("silead,max-fingers", 10),
		162	PROPERTY_ENTRY_BOOL("silead,home-button"),
		163	{ }
		164	};
		165
		166	static const struct ts_dmi_data chuwi_hibook_data = {
		167	.embedded_fw = {
		168	.name = "silead/gsl1680-chuwi-hibook.fw",
		169	.prefix = { 0xf0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00 },
		170	.length = 40392,
		171	.sha256 = { 0xf7, 0xc0, 0xe8, 0x5a, 0x6c, 0xf2, 0xeb, 0x8d,
		172	0x12, 0xc4, 0x45, 0xbf, 0x55, 0x13, 0x4c, 0x1a,
		173	0x13, 0x04, 0x31, 0x08, 0x65, 0x73, 0xf7, 0xa8,
		174	0x1b, 0x7d, 0x59, 0xc9, 0xe6, 0x97, 0xf7, 0x38 },
		175	},
		176	.acpi_name = "MSSL0017:00",
		177	.properties = chuwi_hibook_props,
		178	};
		179
144	static const struct property_entry chuwi_vi8_props[] = {	180	static const struct property_entry chuwi_vi8_props[] = {
145	PROPERTY_ENTRY_U32("touchscreen-min-x", 4),	181	PROPERTY_ENTRY_U32("touchscreen-min-x", 4),
146	PROPERTY_ENTRY_U32("touchscreen-min-y", 6),	182	PROPERTY_ENTRY_U32("touchscreen-min-y", 6),
@@ -979,6 +1015,16 @@ const struct dmi_system_id touchscreen_dmi_table[] = { · 832 unmodified lines
979	DMI_MATCH(DMI_BOARD_NAME, "Cherry Trail CR"),	1015	DMI_MATCH(DMI_BOARD_NAME, "Cherry Trail CR"),
980	},	1016	},
981	},	1017	},
		1018	{
		1019	/* Chuwi HiBook (CWI514) */
		1020	.driver_data = (void *)&chuwi_hibook_data,
		1021	.matches = {
		1022	DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
		1023	DMI_MATCH(DMI_BOARD_NAME, "Cherry Trail CR"),
		1024	/* Above matches are too generic, add bios-date match */
		1025	DMI_MATCH(DMI_BIOS_DATE, "05/07/2016"),
		1026	},
		1027	},
982	{	1028	{
983	/* Chuwi Vi8 (CWI506) */	1029	/* Chuwi Vi8 (CWI506) */
984	.driver_data = (void *)&chuwi_vi8_data,	1030	.driver_data = (void *)&chuwi_vi8_data,

drivers/ptp/Kconfig+1−0

@@ -174,6 +174,7 @@ config PTP_1588_CLOCK_OCP · 173 unmodified lines
174	depends on I2C && MTD	174	depends on I2C && MTD
175	depends on SERIAL_8250	175	depends on SERIAL_8250
176	depends on !S390	176	depends on !S390
		177	depends on COMMON_CLK
177	select NET_DEVLINK	178	select NET_DEVLINK
178	help	179	help
179	This driver adds support for an OpenCompute time card.	180	This driver adds support for an OpenCompute time card.

drivers/regulator/max14577-regulator.c+0−2

@@ -269,5 +269,3 @@ module_exit(max14577_regulator_exit); · 268 unmodified lines
269	MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");	269	MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
270	MODULE_DESCRIPTION("Maxim 14577/77836 regulator driver");	270	MODULE_DESCRIPTION("Maxim 14577/77836 regulator driver");
271	MODULE_LICENSE("GPL");	271	MODULE_LICENSE("GPL");
272	MODULE_ALIAS("platform:max14577-regulator");
273	MODULE_ALIAS("platform:max77836-regulator");

drivers/regulator/qcom-rpmh-regulator.c+1−1

@@ -991,7 +991,7 @@ static const struct rpmh_vreg_init_data pm8009_1_vreg_data[] = { · 990 unmodified lines
991	RPMH_VREG("ldo4", "ldo%s4", &pmic5_nldo, "vdd-l4"),	991	RPMH_VREG("ldo4", "ldo%s4", &pmic5_nldo, "vdd-l4"),
992	RPMH_VREG("ldo5", "ldo%s5", &pmic5_pldo, "vdd-l5-l6"),	992	RPMH_VREG("ldo5", "ldo%s5", &pmic5_pldo, "vdd-l5-l6"),
993	RPMH_VREG("ldo6", "ldo%s6", &pmic5_pldo, "vdd-l5-l6"),	993	RPMH_VREG("ldo6", "ldo%s6", &pmic5_pldo, "vdd-l5-l6"),
994	RPMH_VREG("ldo7", "ldo%s6", &pmic5_pldo_lv, "vdd-l7"),	994	RPMH_VREG("ldo7", "ldo%s7", &pmic5_pldo_lv, "vdd-l7"),
995	{}	995	{}
996	};	996	};
997		997

drivers/s390/char/sclp_early.c+2−1

 	sclp.has_gisaf = !!(sccb->fac118 & 0x08);
 	sclp.has_hvs = !!(sccb->fac119 & 0x80);
 	sclp.has_kss = !!(sccb->fac98 & 0x01);
-	sclp.has_sipl = !!(sccb->cbl & 0x4000);
 	if (sccb->fac85 & 0x02)
 		S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP;
 	if (sccb->fac91 & 0x40)
 		S390_lowcore.machine_flags |= MACHINE_FLAG_TLB_GUEST;
 	if (sccb->cpuoff > 134)
 		sclp.has_diag318 = !!(sccb->byte_134 & 0x80);
+	if (sccb->cpuoff > 137)
+		sclp.has_sipl = !!(sccb->cbl & 0x4000);
 	sclp.rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
 	sclp.rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
 	sclp.rzm <<= 20;

drivers/s390/cio/ccwgroup.c+8−2

 /**
  * ccwgroup_set_offline() - disable a ccwgroup device
  * @gdev: target ccwgroup device
+ * @call_gdrv: Call the registered gdrv set_offline function
  *
  * This function attempts to put the ccwgroup device into the offline state.
  * Returns:
  *  %0 on success and a negative error value on failure.
  */
-int ccwgroup_set_offline(struct ccwgroup_device *gdev)
+int ccwgroup_set_offline(struct ccwgroup_device *gdev, bool call_gdrv)
 {
 	struct ccwgroup_driver *gdrv = to_ccwgroupdrv(gdev->dev.driver);
 	int ret = -EINVAL;
 		return -EAGAIN;
 	if (gdev->state == CCWGROUP_OFFLINE)
 		goto out;
+	if (!call_gdrv) {
+		ret = 0;
+		goto offline;
+	}
 	if (gdrv->set_offline)
 		ret = gdrv->set_offline(gdev);
 	if (ret)
 		goto out;
+offline:
 	gdev->state = CCWGROUP_OFFLINE;
 out:
 	atomic_set(&gdev->onoff, 0);
 	if (value == 1)
 		ret = ccwgroup_set_online(gdev);
 	else if (value == 0)
-		ret = ccwgroup_set_offline(gdev);
+		ret = ccwgroup_set_offline(gdev, true);
 	else
 		ret = -EINVAL;
 out:

drivers/s390/crypto/ap_bus.c+2−1

  * ap_init_qci_info(): Allocate and query qci config info.
  * Does also update the static variables ap_max_domain_id
  * and ap_max_adapter_id if this info is available.
  */
 static void __init ap_init_qci_info(void)
 {
 /**
  * ap_interrupt_handler() - Schedule ap_tasklet on interrupt
  * @airq: pointer to adapter interrupt descriptor
+ * @floating: ignored
  */
 static void ap_interrupt_handler(struct airq_struct *airq, bool floating)
 {
 /**
  * ap_scan_bus(): Scan the AP bus for new devices
  * Runs periodically, workqueue timer (ap_config_time)
+ * @unused: Unused pointer.
  */
 static void ap_scan_bus(struct work_struct *unused)
 {

drivers/s390/crypto/ap_queue.c+2−2

@@ -20,7 +20,7 @@ static void __ap_flush_queue(struct ap_queue *aq); · 19 unmodified lines
20		20
21	/**	21	/**
22	* ap_queue_enable_irq(): Enable interrupt support on this AP queue.	22	* ap_queue_enable_irq(): Enable interrupt support on this AP queue.
23	* @qid: The AP queue number	23	* @aq: The AP queue
24	* @ind: the notification indicator byte	24	* @ind: the notification indicator byte
25	*	25	*
26	* Enables interruption on AP queue via ap_aqic(). Based on the return	26	* Enables interruption on AP queue via ap_aqic(). Based on the return
@@ -311,7 +311,7 @@ static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq) · 284 unmodified lines
311		311
312	/**	312	/**
313	* ap_sm_reset(): Reset an AP queue.	313	* ap_sm_reset(): Reset an AP queue.
314	* @qid: The AP queue number	314	* @aq: The AP queue
315	*	315	*
316	* Submit the Reset command to an AP queue.	316	* Submit the Reset command to an AP queue.
317	*/	317	*/

drivers/s390/net/qeth_core.h+0−1

@@ -858,7 +858,6 @@ struct qeth_card { · 857 unmodified lines
858	struct napi_struct napi;	858	struct napi_struct napi;
859	struct qeth_rx rx;	859	struct qeth_rx rx;
860	struct delayed_work buffer_reclaim_work;	860	struct delayed_work buffer_reclaim_work;
861	struct work_struct close_dev_work;
862	};	861	};
863		862
864	static inline bool qeth_card_hw_is_reachable(struct qeth_card *card)	863	static inline bool qeth_card_hw_is_reachable(struct qeth_card *card)

drivers/s390/net/qeth_core_main.c+9−13

 static int qeth_qdio_establish(struct qeth_card *);
 static void qeth_free_qdio_queues(struct qeth_card *card);
-static void qeth_close_dev_handler(struct work_struct *work)
-{
-	struct qeth_card *card;
-	card = container_of(work, struct qeth_card, close_dev_work);
-	QETH_CARD_TEXT(card, 2, "cldevhdl");
-	ccwgroup_set_offline(card->gdev);
-}
 static const char *qeth_get_cardname(struct qeth_card *card)
 {
 	if (IS_VM_NIC(card)) {
 				 &card->qdio.in_buf_pool.entry_list, list)
 		list_del(&pool_entry->list);
+	if (!queue)
+		return;
 	for (i = 0; i < ARRAY_SIZE(queue->bufs); i++)
 		queue->bufs[i].pool_entry = NULL;
 }
 	case IPA_CMD_STOPLAN:
 		if (cmd->hdr.return_code == IPA_RC_VEPA_TO_VEB_TRANSITION) {
 			dev_err(&card->gdev->dev,
-				"Interface %s is down because the adjacent port is no longer in reflective relay mode\n",
+				"Adjacent port of interface %s is no longer in reflective relay mode, trigger recovery\n",
 				netdev_name(card->dev));
-			schedule_work(&card->close_dev_work);
+			/* Set offline, then probably fail to set online: */
+			qeth_schedule_recovery(card);
 		} else {
+			/* stay online for subsequent STARTLAN */
 			dev_warn(&card->gdev->dev,
 				 "The link for interface %s on CHPID 0x%X failed\n",
 				 netdev_name(card->dev), card->info.chpid);
 	INIT_LIST_HEAD(&card->ipato.entries);
 	qeth_init_qdio_info(card);
 	INIT_DELAYED_WORK(&card->buffer_reclaim_work, qeth_buffer_reclaim_work);
-	INIT_WORK(&card->close_dev_work, qeth_close_dev_handler);
 	hash_init(card->rx_mode_addrs);
 	hash_init(card->local_addrs4);
 	hash_init(card->local_addrs6);
 		dev_info(&card->gdev->dev,
 			 "Device successfully recovered!\n");
 	} else {
-		ccwgroup_set_offline(card->gdev);
+		qeth_set_offline(card, disc, true);
+		ccwgroup_set_offline(card->gdev, false);
 		dev_warn(&card->gdev->dev,
 			 "The qeth device driver failed to recover an error on the device\n");
 	}

drivers/s390/net/qeth_l2_main.c+0−1

@@ -2307,7 +2307,6 @@ static void qeth_l2_remove_device(struct ccwgroup_device *gdev) · 2306 unmodified lines
2307	if (gdev->state == CCWGROUP_ONLINE)	2307	if (gdev->state == CCWGROUP_ONLINE)
2308	qeth_set_offline(card, card->discipline, false);	2308	qeth_set_offline(card, card->discipline, false);
2309		2309
2310	cancel_work_sync(&card->close_dev_work);
2311	if (card->dev->reg_state == NETREG_REGISTERED) {	2310	if (card->dev->reg_state == NETREG_REGISTERED) {
2312	priv = netdev_priv(card->dev);	2311	priv = netdev_priv(card->dev);
2313	if (priv->brport_features & BR_LEARNING_SYNC) {	2312	if (priv->brport_features & BR_LEARNING_SYNC) {

drivers/s390/net/qeth_l3_main.c+0−1

@@ -1969,7 +1969,6 @@ static void qeth_l3_remove_device(struct ccwgroup_device *cgdev) · 1968 unmodified lines
1969	if (cgdev->state == CCWGROUP_ONLINE)	1969	if (cgdev->state == CCWGROUP_ONLINE)
1970	qeth_set_offline(card, card->discipline, false);	1970	qeth_set_offline(card, card->discipline, false);
1971		1971
1972	cancel_work_sync(&card->close_dev_work);
1973	if (card->dev->reg_state == NETREG_REGISTERED)	1972	if (card->dev->reg_state == NETREG_REGISTERED)
1974	unregister_netdev(card->dev);	1973	unregister_netdev(card->dev);
1975		1974

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

 	int ret;
 	bool use_dma;
+	/* Zero length transfers won't trigger an interrupt on completion */
+	if (!xfer->len) {
+		spi_finalize_current_transfer(ctlr);
+		return 1;
+	}
 	WARN_ON(readl_relaxed(rs->regs + ROCKCHIP_SPI_SSIENR) &&
 		(readl_relaxed(rs->regs + ROCKCHIP_SPI_SR) & SR_BUSY));

drivers/spi/spi-tegra20-slink.c+2−3

 	struct dma_async_tx_descriptor		*tx_dma_desc;
 };
-static int tegra_slink_runtime_suspend(struct device *dev);
-static int tegra_slink_runtime_resume(struct device *dev);
 static inline u32 tegra_slink_readl(struct tegra_slink_data *tspi,
 		unsigned long reg)
 {
 }
 #endif
+#ifdef CONFIG_PM
 static int tegra_slink_runtime_suspend(struct device *dev)
 {
 	struct spi_master *master = dev_get_drvdata(dev);
 	}
 	return 0;
 }
+#endif /* CONFIG_PM */
 static const struct dev_pm_ops slink_pm_ops = {
 	SET_RUNTIME_PM_OPS(tegra_slink_runtime_suspend,

drivers/spi/spi.c+0−8

 	const struct spi_device	*spi = to_spi_device(dev);
 	int len;
-	len = of_device_modalias(dev, buf, PAGE_SIZE);
-	if (len != -ENODEV)
-		return len;
 	len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
 	if (len != -ENODEV)
 		return len;
 	const struct spi_device		*spi = to_spi_device(dev);
 	int rc;
-	rc = of_device_uevent_modalias(dev, env);
-	if (rc != -ENODEV)
-		return rc;
 	rc = acpi_device_uevent_modalias(dev, env);
 	if (rc != -ENODEV)
 		return rc;

drivers/video/fbdev/Kconfig+3−1

 config FB_TGA
 	tristate "TGA/SFB+ framebuffer support"
-	depends on FB && (ALPHA || TC)
+	depends on FB
+	depends on PCI || TC
+	depends on ALPHA || TC
 	select FB_CFB_FILLRECT
 	select FB_CFB_COPYAREA
 	select FB_CFB_IMAGEBLIT

drivers/xen/Kconfig+1−1

@@ -214,7 +214,7 @@ config XEN_PVCALLS_FRONTEND · 213 unmodified lines
214	implements them.	214	implements them.
215		215
216	config XEN_PVCALLS_BACKEND	216	config XEN_PVCALLS_BACKEND
217	bool "XEN PV Calls backend driver"	217	tristate "XEN PV Calls backend driver"
218	depends on INET && XEN && XEN_BACKEND	218	depends on INET && XEN && XEN_BACKEND
219	help	219	help
220	Experimental backend for the Xen PV Calls protocol	220	Experimental backend for the Xen PV Calls protocol

drivers/xen/balloon.c+45−17

@@ -43,6 +43,8 @@ · 42 unmodified lines
43	#include <linux/sched.h>	43	#include <linux/sched.h>
44	#include <linux/cred.h>	44	#include <linux/cred.h>
45	#include <linux/errno.h>	45	#include <linux/errno.h>
		46	#include <linux/freezer.h>
		47	#include <linux/kthread.h>
46	#include <linux/mm.h>	48	#include <linux/mm.h>
47	#include <linux/memblock.h>	49	#include <linux/memblock.h>
48	#include <linux/pagemap.h>	50	#include <linux/pagemap.h>
@@ -115,7 +117,7 @@ static struct ctl_table xen_root[] = { · 66 unmodified lines
115	#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1)	117	#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1)
116		118
117	/*	119	/*
118	* balloon_process() state:	120	* balloon_thread() state:
119	*	121	*
120	* BP_DONE: done or nothing to do,	122	* BP_DONE: done or nothing to do,
121	* BP_WAIT: wait to be rescheduled,	123	* BP_WAIT: wait to be rescheduled,
@@ -130,6 +132,8 @@ enum bp_state { · 8 unmodified lines
130	BP_ECANCELED	132	BP_ECANCELED
131	};	133	};
132		134
		135	/* Main waiting point for xen-balloon thread. */
		136	static DECLARE_WAIT_QUEUE_HEAD(balloon_thread_wq);
133		137
134	static DEFINE_MUTEX(balloon_mutex);	138	static DEFINE_MUTEX(balloon_mutex);
135		139
@@ -144,10 +148,6 @@ static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)]; · 8 unmodified lines
144	static LIST_HEAD(ballooned_pages);	148	static LIST_HEAD(ballooned_pages);
145	static DECLARE_WAIT_QUEUE_HEAD(balloon_wq);	149	static DECLARE_WAIT_QUEUE_HEAD(balloon_wq);
146		150
147	/* Main work function, always executed in process context. */
148	static void balloon_process(struct work_struct *work);
149	static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);
150
151	/* When ballooning out (allocating memory to return to Xen) we don't really	151	/* When ballooning out (allocating memory to return to Xen) we don't really
152	want the kernel to try too hard since that can trigger the oom killer. */	152	want the kernel to try too hard since that can trigger the oom killer. */
153	#define GFP_BALLOON \	153	#define GFP_BALLOON \
@@ -366,7 +366,7 @@ static void xen_online_page(struct page *page, unsigned int order) · 212 unmodified lines
366	static int xen_memory_notifier(struct notifier_block nb, unsigned long val, void v)	366	static int xen_memory_notifier(struct notifier_block nb, unsigned long val, void v)
367	{	367	{
368	if (val == MEM_ONLINE)	368	if (val == MEM_ONLINE)
369	schedule_delayed_work(&balloon_worker, 0);	369	wake_up(&balloon_thread_wq);
370		370
371	return NOTIFY_OK;	371	return NOTIFY_OK;
372	}	372	}
@@ -491,18 +491,43 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) · 118 unmodified lines
491	}	491	}
492		492
493	/*	493	/*
494	* As this is a work item it is guaranteed to run as a single instance only.	494	* Stop waiting if either state is not BP_EAGAIN and ballooning action is
		495	* needed, or if the credit has changed while state is BP_EAGAIN.
		496	*/
		497	static bool balloon_thread_cond(enum bp_state state, long credit)
		498	{
		499	if (state != BP_EAGAIN)
		500	credit = 0;
		501
		502	return current_credit() != credit \|\| kthread_should_stop();
		503	}
		504
		505	/*
		506	* As this is a kthread it is guaranteed to run as a single instance only.
495	* We may of course race updates of the target counts (which are protected	507	* We may of course race updates of the target counts (which are protected
496	* by the balloon lock), or with changes to the Xen hard limit, but we will	508	* by the balloon lock), or with changes to the Xen hard limit, but we will
497	* recover from these in time.	509	* recover from these in time.
498	*/	510	*/
499	static void balloon_process(struct work_struct *work)	511	static int balloon_thread(void *unused)
500	{	512	{
501	enum bp_state state = BP_DONE;	513	enum bp_state state = BP_DONE;
502	long credit;	514	long credit;
		515	unsigned long timeout;
		516
		517	set_freezable();
		518	for (;;) {
		519	if (state == BP_EAGAIN)
		520	timeout = balloon_stats.schedule_delay * HZ;
		521	else
		522	timeout = 3600 * HZ;
		523	credit = current_credit();
503		524
		525	wait_event_interruptible_timeout(balloon_thread_wq,
		526	balloon_thread_cond(state, credit), timeout);
		527
		528	if (kthread_should_stop())
		529	return 0;
504		530
505	do {
506	mutex_lock(&balloon_mutex);	531	mutex_lock(&balloon_mutex);
507		532
508	credit = current_credit();	533	credit = current_credit();
@@ -529,12 +554,7 @@ static void balloon_process(struct work_struct *work) · 20 unmodified lines
529	mutex_unlock(&balloon_mutex);	554	mutex_unlock(&balloon_mutex);
530		555
531	cond_resched();	556	cond_resched();
532		557	}
533	} while (credit && state == BP_DONE);
534
535	/* Schedule more work if there is some still to be done. */
536	if (state == BP_EAGAIN)
537	schedule_delayed_work(&balloon_worker, balloon_stats.schedule_delay * HZ);
538	}	558	}
539		559
540	/* Resets the Xen limit, sets new target, and kicks off processing. */	560	/* Resets the Xen limit, sets new target, and kicks off processing. */
@@ -542,7 +562,7 @@ void balloon_set_new_target(unsigned long target) · 1 unmodified line
542	{	562	{
543	/* No need for lock. Not read-modify-write updates. */	563	/* No need for lock. Not read-modify-write updates. */
544	balloon_stats.target_pages = target;	564	balloon_stats.target_pages = target;
545	schedule_delayed_work(&balloon_worker, 0);	565	wake_up(&balloon_thread_wq);
546	}	566	}
547	EXPORT_SYMBOL_GPL(balloon_set_new_target);	567	EXPORT_SYMBOL_GPL(balloon_set_new_target);
548		568
@@ -647,7 +667,7 @@ void free_xenballooned_pages(int nr_pages, struct page **pages) · 98 unmodified lines
647		667
648	/* The balloon may be too large now. Shrink it if needed. */	668	/* The balloon may be too large now. Shrink it if needed. */
649	if (current_credit())	669	if (current_credit())
650	schedule_delayed_work(&balloon_worker, 0);	670	wake_up(&balloon_thread_wq);
651		671
652	mutex_unlock(&balloon_mutex);	672	mutex_unlock(&balloon_mutex);
653	}	673	}
@@ -679,6 +699,8 @@ static void __init balloon_add_region(unsigned long start_pfn, · 25 unmodified lines
679		699
680	static int __init balloon_init(void)	700	static int __init balloon_init(void)
681	{	701	{
		702	struct task_struct *task;
		703
682	if (!xen_domain())	704	if (!xen_domain())
683	return -ENODEV;	705	return -ENODEV;
684		706
@@ -722,6 +744,12 @@ static int __init balloon_init(void) · 37 unmodified lines
722	}	744	}
723	#endif	745	#endif
724		746
		747	task = kthread_run(balloon_thread, NULL, "xen-balloon");
		748	if (IS_ERR(task)) {
		749	pr_err("xen-balloon thread could not be started, ballooning will not work!\n");
		750	return PTR_ERR(task);
		751	}
		752
725	/* Init the xen-balloon driver. */	753	/* Init the xen-balloon driver. */
726	xen_balloon_init();	754	xen_balloon_init();
727		755

drivers/xen/swiotlb-xen.c+17−20

 static int xen_swiotlb_fixup(void *buf, unsigned long nslabs)
 {
-	int i, rc;
+	int rc;
-	int dma_bits;
+	unsigned int order = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT);
+	unsigned int i, dma_bits = order + PAGE_SHIFT;
 	dma_addr_t dma_handle;
 	phys_addr_t p = virt_to_phys(buf);
-	dma_bits = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT) + PAGE_SHIFT;
+	BUILD_BUG_ON(IO_TLB_SEGSIZE & (IO_TLB_SEGSIZE - 1));
+	BUG_ON(nslabs % IO_TLB_SEGSIZE);
 	i = 0;
 	do {
-		int slabs = min(nslabs - i, (unsigned long)IO_TLB_SEGSIZE);
 		do {
 			rc = xen_create_contiguous_region(
-				p + (i << IO_TLB_SHIFT),
+				p + (i << IO_TLB_SHIFT), order,
-				get_order(slabs << IO_TLB_SHIFT),
 				dma_bits, &dma_handle);
 		} while (rc && dma_bits++ < MAX_DMA_BITS);
 		if (rc)
 			return rc;
-		i += slabs;
+		i += IO_TLB_SEGSIZE;
 	} while (i < nslabs);
 	return 0;
 }
 	return "";
 }
-#define DEFAULT_NSLABS		ALIGN(SZ_64M >> IO_TLB_SHIFT, IO_TLB_SEGSIZE)
+int xen_swiotlb_init(void)
-int __ref xen_swiotlb_init(void)
 {
 	enum xen_swiotlb_err m_ret = XEN_SWIOTLB_UNKNOWN;
 	unsigned long bytes = swiotlb_size_or_default();
 		order--;
 	}
 	if (!start)
-		goto error;
+		goto exit;
 	if (order != get_order(bytes)) {
 		pr_warn("Warning: only able to allocate %ld MB for software IO TLB\n",
 			(PAGE_SIZE << order) >> 20);
 	swiotlb_set_max_segment(PAGE_SIZE);
 	return 0;
 error:
-	if (repeat--) {
+	if (nslabs > 1024 && repeat--) {
 		/* Min is 2MB */
-		nslabs = max(1024UL, (nslabs >> 1));
+		nslabs = max(1024UL, ALIGN(nslabs >> 1, IO_TLB_SEGSIZE));
-		pr_info("Lowering to %luMB\n",
+		bytes = nslabs << IO_TLB_SHIFT;
-			(nslabs << IO_TLB_SHIFT) >> 20);
+		pr_info("Lowering to %luMB\n", bytes >> 20);
 		goto retry;
 	}
+exit:
 	pr_err("%s (rc:%d)\n", xen_swiotlb_error(m_ret), rc);
-	free_pages((unsigned long)start, order);
 	return rc;
 }
 	rc = xen_swiotlb_fixup(start, nslabs);
 	if (rc) {
 		memblock_free(__pa(start), PAGE_ALIGN(bytes));
-		if (repeat--) {
+		if (nslabs > 1024 && repeat--) {
 			/* Min is 2MB */
-			nslabs = max(1024UL, (nslabs >> 1));
+			nslabs = max(1024UL, ALIGN(nslabs >> 1, IO_TLB_SEGSIZE));
 			bytes = nslabs << IO_TLB_SHIFT;
 			pr_info("Lowering to %luMB\n", bytes >> 20);
 			goto retry;
 		panic("%s (rc:%d)", xen_swiotlb_error(XEN_SWIOTLB_EFIXUP), rc);
 	}
-	if (swiotlb_init_with_tbl(start, nslabs, false))
+	if (swiotlb_init_with_tbl(start, nslabs, true))
 		panic("Cannot allocate SWIOTLB buffer");
 	swiotlb_set_max_segment(PAGE_SIZE);
 }

fs/afs/callback.c+42−2

@@ -20,6 +20,37 @@ · 19 unmodified lines
20	#include <linux/sched.h>	20	#include <linux/sched.h>
21	#include "internal.h"	21	#include "internal.h"
22		22
		23	/*
		24	* Handle invalidation of an mmap'd file. We invalidate all the PTEs referring
		25	* to the pages in this file's pagecache, forcing the kernel to go through
		26	* ->fault() or ->page_mkwrite() - at which point we can handle invalidation
		27	* more fully.
		28	*/
		29	void afs_invalidate_mmap_work(struct work_struct *work)
		30	{
		31	struct afs_vnode *vnode = container_of(work, struct afs_vnode, cb_work);
		32
		33	unmap_mapping_pages(vnode->vfs_inode.i_mapping, 0, 0, false);
		34	}
		35
		36	void afs_server_init_callback_work(struct work_struct *work)
		37	{
		38	struct afs_server *server = container_of(work, struct afs_server, initcb_work);
		39	struct afs_vnode *vnode;
		40	struct afs_cell *cell = server->cell;
		41
		42	down_read(&cell->fs_open_mmaps_lock);
		43
		44	list_for_each_entry(vnode, &cell->fs_open_mmaps, cb_mmap_link) {
		45	if (vnode->cb_server == server) {
		46	clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
		47	queue_work(system_unbound_wq, &vnode->cb_work);
		48	}
		49	}
		50
		51	up_read(&cell->fs_open_mmaps_lock);
		52	}
		53
23	/*	54	/*
24	* Allow the fileserver to request callback state (re-)initialisation.	55	* Allow the fileserver to request callback state (re-)initialisation.
25	* Unfortunately, UUIDs are not guaranteed unique.	56	* Unfortunately, UUIDs are not guaranteed unique.
@@ -29,8 +60,11 @@ void afs_init_callback_state(struct afs_server *server) · 3 unmodified lines
29	rcu_read_lock();	60	rcu_read_lock();
30	do {	61	do {
31	server->cb_s_break++;	62	server->cb_s_break++;
32	server = rcu_dereference(server->uuid_next);	63	atomic_inc(&server->cell->fs_s_break);
33	} while (0);	64	if (!list_empty(&server->cell->fs_open_mmaps))
		65	queue_work(system_unbound_wq, &server->initcb_work);
		66
		67	} while ((server = rcu_dereference(server->uuid_next)));
34	rcu_read_unlock();	68	rcu_read_unlock();
35	}	69	}
36		70
@@ -44,11 +78,17 @@ void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reas · 7 unmodified lines
44	clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);	78	clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
45	if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {	79	if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
46	vnode->cb_break++;	80	vnode->cb_break++;
		81	vnode->cb_v_break = vnode->volume->cb_v_break;
47	afs_clear_permits(vnode);	82	afs_clear_permits(vnode);
48		83
49	if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)	84	if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
50	afs_lock_may_be_available(vnode);	85	afs_lock_may_be_available(vnode);
51		86
		87	if (reason != afs_cb_break_for_deleted &&
		88	vnode->status.type == AFS_FTYPE_FILE &&
		89	atomic_read(&vnode->cb_nr_mmap))
		90	queue_work(system_unbound_wq, &vnode->cb_work);
		91
52	trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);	92	trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);
53	} else {	93	} else {
54	trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);	94	trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);

fs/afs/cell.c+2−0

@@ -166,6 +166,8 @@ static struct afs_cell afs_alloc_cell(struct afs_net net, · 165 unmodified lines
166	seqlock_init(&cell->volume_lock);	166	seqlock_init(&cell->volume_lock);
167	cell->fs_servers = RB_ROOT;	167	cell->fs_servers = RB_ROOT;
168	seqlock_init(&cell->fs_lock);	168	seqlock_init(&cell->fs_lock);
		169	INIT_LIST_HEAD(&cell->fs_open_mmaps);
		170	init_rwsem(&cell->fs_open_mmaps_lock);
169	rwlock_init(&cell->vl_servers_lock);	171	rwlock_init(&cell->vl_servers_lock);
170	cell->flags = (1 << AFS_CELL_FL_CHECK_ALIAS);	172	cell->flags = (1 << AFS_CELL_FL_CHECK_ALIAS);
171		173

fs/afs/dir.c+18−39

  */
 static int afs_d_revalidate_rcu(struct dentry *dentry)
 {
-	struct afs_vnode *dvnode, *vnode;
+	struct afs_vnode *dvnode;
 	struct dentry *parent;
-	struct inode *dir, *inode;
+	struct inode *dir;
 	long dir_version, de_version;
 	_enter("%p", dentry);
 			return -ECHILD;
 	}
-	/* Check to see if the vnode referred to by the dentry still
-	 * has a callback.
-	 */
-	if (d_really_is_positive(dentry)) {
-		inode = d_inode_rcu(dentry);
-		if (inode) {
-			vnode = AFS_FS_I(inode);
-			if (!afs_check_validity(vnode))
-				return -ECHILD;
-		}
-	}
 	return 1; /* Still valid */
 }
 	if (IS_ERR(key))
 		key = NULL;
-	if (d_really_is_positive(dentry)) {
+	/* Hold the parent dentry so we can peer at it */
-		inode = d_inode(dentry);
-		if (inode) {
-			vnode = AFS_FS_I(inode);
-			afs_validate(vnode, key);
-			if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
-				goto out_bad;
-		}
-	}
-	/* lock down the parent dentry so we can peer at it */
 	parent = dget_parent(dentry);
 	dir = AFS_FS_I(d_inode(parent));
 	if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
 		_debug("%pd: parent dir deleted", dentry);
-		goto out_bad_parent;
+		goto not_found;
 	}
 	/* We only need to invalidate a dentry if the server's copy changed
 	case 0:
 		/* the filename maps to something */
 		if (d_really_is_negative(dentry))
-			goto out_bad_parent;
+			goto not_found;
 		inode = d_inode(dentry);
 		if (is_bad_inode(inode)) {
 			printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
 			       dentry);
-			goto out_bad_parent;
+			goto not_found;
 		}
 		vnode = AFS_FS_I(inode);
 			       dentry, fid.unique,
 			       vnode->fid.unique,
 			       vnode->vfs_inode.i_generation);
-			write_seqlock(&vnode->cb_lock);
-			set_bit(AFS_VNODE_DELETED, &vnode->flags);
-			write_sequnlock(&vnode->cb_lock);
 			goto not_found;
 		}
 		goto out_valid;
 	default:
 		_debug("failed to iterate dir %pd: %d",
 		       parent, ret);
-		goto out_bad_parent;
+		goto not_found;
 	}
 out_valid:
 	_leave(" = 1 [valid]");
 	return 1;
-	/* the dirent, if it exists, now points to a different vnode */
 not_found:
-	spin_lock(&dentry->d_lock);
-	dentry->d_flags |= DCACHE_NFSFS_RENAMED;
-	spin_unlock(&dentry->d_lock);
-out_bad_parent:
 	_debug("dropping dentry %pd2", dentry);
 	dput(parent);
-out_bad:
 	key_put(key);
 	_leave(" = 0 [bad]");
 		goto error;
 	}
+	ret = afs_validate(vnode, op->key);
+	if (ret < 0)
+		goto error_op;
 	afs_op_set_vnode(op, 0, dvnode);
 	afs_op_set_vnode(op, 1, vnode);
 	op->file[0].dv_delta = 1;
 	op->create.reason	= afs_edit_dir_for_link;
 	return afs_do_sync_operation(op);
+error_op:
+	afs_put_operation(op);
 error:
 	d_drop(dentry);
 	_leave(" = %d", ret);
 	if (IS_ERR(op))
 		return PTR_ERR(op);
+	ret = afs_validate(vnode, op->key);
+	op->error = ret;
+	if (ret < 0)
+		goto error;
 	afs_op_set_vnode(op, 0, orig_dvnode);
 	afs_op_set_vnode(op, 1, new_dvnode); /* May be same as orig_dvnode */
 	op->file[0].dv_delta = 1;

fs/afs/dir_edit.c+2−2

@@ -263,7 +263,7 @@ void afs_edit_dir_add(struct afs_vnode *vnode, · 262 unmodified lines
263	if (b == nr_blocks) {	263	if (b == nr_blocks) {
264	_debug("init %u", b);	264	_debug("init %u", b);
265	afs_edit_init_block(meta, block, b);	265	afs_edit_init_block(meta, block, b);
266	i_size_write(&vnode->vfs_inode, (b + 1) * AFS_DIR_BLOCK_SIZE);	266	afs_set_i_size(vnode, (b + 1) * AFS_DIR_BLOCK_SIZE);
267	}	267	}
268		268
269	/* Only lower dir pages have a counter in the header. */	269	/* Only lower dir pages have a counter in the header. */
@@ -296,7 +296,7 @@ void afs_edit_dir_add(struct afs_vnode *vnode, · 26 unmodified lines
296	new_directory:	296	new_directory:
297	afs_edit_init_block(meta, meta, 0);	297	afs_edit_init_block(meta, meta, 0);
298	i_size = AFS_DIR_BLOCK_SIZE;	298	i_size = AFS_DIR_BLOCK_SIZE;
299	i_size_write(&vnode->vfs_inode, i_size);	299	afs_set_i_size(vnode, i_size);
300	slot = AFS_DIR_RESV_BLOCKS0;	300	slot = AFS_DIR_RESV_BLOCKS0;
301	page = page0;	301	page = page0;
302	block = meta;	302	block = meta;

fs/afs/file.c+83−3

@@ -24,12 +24,16 @@ static void afs_invalidatepage(struct page *page, unsigned int offset, · 23 unmodified lines
24	static int afs_releasepage(struct page *page, gfp_t gfp_flags);	24	static int afs_releasepage(struct page *page, gfp_t gfp_flags);
25		25
26	static void afs_readahead(struct readahead_control *ractl);	26	static void afs_readahead(struct readahead_control *ractl);
		27	static ssize_t afs_file_read_iter(struct kiocb iocb, struct iov_iter iter);
		28	static void afs_vm_open(struct vm_area_struct *area);
		29	static void afs_vm_close(struct vm_area_struct *area);
		30	static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff);
27		31
28	const struct file_operations afs_file_operations = {	32	const struct file_operations afs_file_operations = {
29	.open = afs_open,	33	.open = afs_open,
30	.release = afs_release,	34	.release = afs_release,
31	.llseek = generic_file_llseek,	35	.llseek = generic_file_llseek,
32	.read_iter = generic_file_read_iter,	36	.read_iter = afs_file_read_iter,
33	.write_iter = afs_file_write,	37	.write_iter = afs_file_write,
34	.mmap = afs_file_mmap,	38	.mmap = afs_file_mmap,
35	.splice_read = generic_file_splice_read,	39	.splice_read = generic_file_splice_read,
@@ -59,8 +63,10 @@ const struct address_space_operations afs_fs_aops = { · 23 unmodified lines
59	};	63	};
60		64
61	static const struct vm_operations_struct afs_vm_ops = {	65	static const struct vm_operations_struct afs_vm_ops = {
		66	.open = afs_vm_open,
		67	.close = afs_vm_close,
62	.fault = filemap_fault,	68	.fault = filemap_fault,
63	.map_pages = filemap_map_pages,	69	.map_pages = afs_vm_map_pages,
64	.page_mkwrite = afs_page_mkwrite,	70	.page_mkwrite = afs_page_mkwrite,
65	};	71	};
66		72
@@ -295,7 +301,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) · 228 unmodified lines
295	fsreq->subreq = subreq;	301	fsreq->subreq = subreq;
296	fsreq->pos = subreq->start + subreq->transferred;	302	fsreq->pos = subreq->start + subreq->transferred;
297	fsreq->len = subreq->len - subreq->transferred;	303	fsreq->len = subreq->len - subreq->transferred;
298	fsreq->key = subreq->rreq->netfs_priv;	304	fsreq->key = key_get(subreq->rreq->netfs_priv);
299	fsreq->vnode = vnode;	305	fsreq->vnode = vnode;
300	fsreq->iter = &fsreq->def_iter;	306	fsreq->iter = &fsreq->def_iter;
301		307
@@ -304,6 +310,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) · 2 unmodified lines
304	fsreq->pos, fsreq->len);	310	fsreq->pos, fsreq->len);
305		311
306	afs_fetch_data(fsreq->vnode, fsreq);	312	afs_fetch_data(fsreq->vnode, fsreq);
		313	afs_put_read(fsreq);
307	}	314	}
308		315
309	static int afs_symlink_readpage(struct page *page)	316	static int afs_symlink_readpage(struct page *page)
@@ -490,15 +497,88 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags) · 180 unmodified lines
490	return 1;	497	return 1;
491	}	498	}
492		499
		500	static void afs_add_open_mmap(struct afs_vnode *vnode)
		501	{
		502	if (atomic_inc_return(&vnode->cb_nr_mmap) == 1) {
		503	down_write(&vnode->volume->cell->fs_open_mmaps_lock);
		504
		505	list_add_tail(&vnode->cb_mmap_link,
		506	&vnode->volume->cell->fs_open_mmaps);
		507
		508	up_write(&vnode->volume->cell->fs_open_mmaps_lock);
		509	}
		510	}
		511
		512	static void afs_drop_open_mmap(struct afs_vnode *vnode)
		513	{
		514	if (!atomic_dec_and_test(&vnode->cb_nr_mmap))
		515	return;
		516
		517	down_write(&vnode->volume->cell->fs_open_mmaps_lock);
		518
		519	if (atomic_read(&vnode->cb_nr_mmap) == 0)
		520	list_del_init(&vnode->cb_mmap_link);
		521
		522	up_write(&vnode->volume->cell->fs_open_mmaps_lock);
		523	flush_work(&vnode->cb_work);
		524	}
		525
493	/*	526	/*
494	* Handle setting up a memory mapping on an AFS file.	527	* Handle setting up a memory mapping on an AFS file.
495	*/	528	*/
496	static int afs_file_mmap(struct file file, struct vm_area_struct vma)	529	static int afs_file_mmap(struct file file, struct vm_area_struct vma)
497	{	530	{
		531	struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
498	int ret;	532	int ret;
499		533
		534	afs_add_open_mmap(vnode);
		535
500	ret = generic_file_mmap(file, vma);	536	ret = generic_file_mmap(file, vma);
501	if (ret == 0)	537	if (ret == 0)
502	vma->vm_ops = &afs_vm_ops;	538	vma->vm_ops = &afs_vm_ops;
		539	else
		540	afs_drop_open_mmap(vnode);
503	return ret;	541	return ret;
504	}	542	}
		543
		544	static void afs_vm_open(struct vm_area_struct *vma)
		545	{
		546	afs_add_open_mmap(AFS_FS_I(file_inode(vma->vm_file)));
		547	}
		548
		549	static void afs_vm_close(struct vm_area_struct *vma)
		550	{
		551	afs_drop_open_mmap(AFS_FS_I(file_inode(vma->vm_file)));
		552	}
		553
		554	static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff)
		555	{
		556	struct afs_vnode *vnode = AFS_FS_I(file_inode(vmf->vma->vm_file));
		557	struct afs_file *af = vmf->vma->vm_file->private_data;
		558
		559	switch (afs_validate(vnode, af->key)) {
		560	case 0:
		561	return filemap_map_pages(vmf, start_pgoff, end_pgoff);
		562	case -ENOMEM:
		563	return VM_FAULT_OOM;
		564	case -EINTR:
		565	case -ERESTARTSYS:
		566	return VM_FAULT_RETRY;
		567	case -ESTALE:
		568	default:
		569	return VM_FAULT_SIGBUS;
		570	}
		571	}
		572
		573	static ssize_t afs_file_read_iter(struct kiocb iocb, struct iov_iter iter)
		574	{
		575	struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp));
		576	struct afs_file *af = iocb->ki_filp->private_data;
		577	int ret;
		578
		579	ret = afs_validate(vnode, af->key);
		580	if (ret < 0)
		581	return ret;
		582
		583	return generic_file_read_iter(iocb, iter);
		584	}

fs/afs/fs_probe.c+7−1

 #include <linux/slab.h>
 #include "afs_fs.h"
 #include "internal.h"
+#include "protocol_afs.h"
 #include "protocol_yfs.h"
 static unsigned int afs_fs_probe_fast_poll_interval = 30 * HZ;
 	struct afs_addr_list *alist = call->alist;
 	struct afs_server *server = call->server;
 	unsigned int index = call->addr_ix;
-	unsigned int rtt_us = 0;
+	unsigned int rtt_us = 0, cap0;
 	int ret = call->error;
 	_enter("%pU,%u", &server->uuid, index);
 			clear_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
 			alist->addrs[index].srx_service = call->service_id;
 		}
+		cap0 = ntohl(call->tmp);
+		if (cap0 & AFS3_VICED_CAPABILITY_64BITFILES)
+			set_bit(AFS_SERVER_FL_HAS_FS64, &server->flags);
+		else
+			clear_bit(AFS_SERVER_FL_HAS_FS64, &server->flags);
 	}
 	if (rxrpc_kernel_get_srtt(call->net->socket, call->rxcall, &rtt_us) &&

fs/afs/fsclient.c+20−11

 	struct afs_read *req = op->fetch.req;
 	__be32 *bp;
-	if (upper_32_bits(req->pos) ||
+	if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
-	    upper_32_bits(req->len) ||
-	    upper_32_bits(req->pos + req->len))
 		return afs_fs_fetch_data64(op);
 	_enter("");
 	       (unsigned long long)op->store.pos,
 	       (unsigned long long)op->store.i_size);
-	if (upper_32_bits(op->store.pos) ||
+	if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
-	    upper_32_bits(op->store.size) ||
-	    upper_32_bits(op->store.i_size))
 		return afs_fs_store_data64(op);
 	call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
 	       key_serial(op->key), vp->fid.vid, vp->fid.vnode);
 	ASSERT(attr->ia_valid & ATTR_SIZE);
-	if (upper_32_bits(attr->ia_size))
+	if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
 		return afs_fs_setattr_size64(op);
 	call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
 			return ret;
 		count = ntohl(call->tmp);
 		call->count = count;
 		call->count2 = count;
-		afs_extract_discard(call, count * sizeof(__be32));
+		if (count == 0) {
+			call->unmarshall = 4;
+			call->tmp = 0;
+			break;
+		}
+		/* Extract the first word of the capabilities to call->tmp */
+		afs_extract_to_tmp(call);
 		call->unmarshall++;
 		fallthrough;
-		/* Extract capabilities words */
 	case 2:
 		ret = afs_extract_data(call, false);
 		if (ret < 0)
 			return ret;
-		/* TODO: Examine capabilities */
+		afs_extract_discard(call, (count - 1) * sizeof(__be32));
+		call->unmarshall++;
+		fallthrough;
+		/* Extract remaining capabilities words */
+	case 3:
+		ret = afs_extract_data(call, false);
+		if (ret < 0)
+			return ret;
 		call->unmarshall++;
 		break;

fs/afs/inode.c+43−55

@@ -53,16 +53,6 @@ static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode paren · 52 unmodified lines
53	dump_stack();	53	dump_stack();
54	}	54	}
55		55
56	/*
57	* Set the file size and block count. Estimate the number of 512 bytes blocks
58	* used, rounded up to nearest 1K for consistency with other AFS clients.
59	*/
60	static void afs_set_i_size(struct afs_vnode *vnode, u64 size)
61	{
62	i_size_write(&vnode->vfs_inode, size);
63	vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
64	}
65
66	/*	56	/*
67	* Initialise an inode from the vnode status.	57	* Initialise an inode from the vnode status.
68	*/	58	*/
@@ -587,22 +577,32 @@ static void afs_zap_data(struct afs_vnode *vnode) · 518 unmodified lines
587	}	577	}
588		578
589	/*	579	/*
590	* Get the server reinit counter for a vnode's current server.	580	* Check to see if we have a server currently serving this volume and that it
		581	* hasn't been reinitialised or dropped from the list.
591	*/	582	*/
592	static bool afs_get_s_break_rcu(struct afs_vnode vnode, unsigned int _s_break)	583	static bool afs_check_server_good(struct afs_vnode *vnode)
593	{	584	{
594	struct afs_server_list *slist = rcu_dereference(vnode->volume->servers);	585	struct afs_server_list *slist;
595	struct afs_server *server;	586	struct afs_server *server;
		587	bool good;
596	int i;	588	int i;
597		589
		590	if (vnode->cb_fs_s_break == atomic_read(&vnode->volume->cell->fs_s_break))
		591	return true;
		592
		593	rcu_read_lock();
		594
		595	slist = rcu_dereference(vnode->volume->servers);
598	for (i = 0; i < slist->nr_servers; i++) {	596	for (i = 0; i < slist->nr_servers; i++) {
599	server = slist->servers[i].server;	597	server = slist->servers[i].server;
600	if (server == vnode->cb_server) {	598	if (server == vnode->cb_server) {
601	*_s_break = READ_ONCE(server->cb_s_break);	599	good = (vnode->cb_s_break == server->cb_s_break);
602	return true;	600	rcu_read_unlock();
		601	return good;
603	}	602	}
604	}	603	}
605		604
		605	rcu_read_unlock();
606	return false;	606	return false;
607	}	607	}
608		608
@@ -611,57 +611,46 @@ static bool afs_get_s_break_rcu(struct afs_vnode vnode, unsigned int _s_break) · 2 unmodified lines
611	*/	611	*/
612	bool afs_check_validity(struct afs_vnode *vnode)	612	bool afs_check_validity(struct afs_vnode *vnode)
613	{	613	{
614	struct afs_volume *volume = vnode->volume;
615	enum afs_cb_break_reason need_clear = afs_cb_break_no_break;	614	enum afs_cb_break_reason need_clear = afs_cb_break_no_break;
616	time64_t now = ktime_get_real_seconds();	615	time64_t now = ktime_get_real_seconds();
617	bool valid;	616	unsigned int cb_break;
618	unsigned int cb_break, cb_s_break, cb_v_break;
619	int seq = 0;	617	int seq = 0;
620		618
621	do {	619	do {
622	read_seqbegin_or_lock(&vnode->cb_lock, &seq);	620	read_seqbegin_or_lock(&vnode->cb_lock, &seq);
623	cb_v_break = READ_ONCE(volume->cb_v_break);
624	cb_break = vnode->cb_break;	621	cb_break = vnode->cb_break;
625		622
626	if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags) &&	623	if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
627	afs_get_s_break_rcu(vnode, &cb_s_break)) {	624	if (vnode->cb_v_break != vnode->volume->cb_v_break)
628	if (vnode->cb_s_break != cb_s_break \|\|	625	need_clear = afs_cb_break_for_v_break;
629	vnode->cb_v_break != cb_v_break) {	626	else if (!afs_check_server_good(vnode))
630	vnode->cb_s_break = cb_s_break;	627	need_clear = afs_cb_break_for_s_reinit;
631	vnode->cb_v_break = cb_v_break;	628	else if (test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
632	need_clear = afs_cb_break_for_vsbreak;
633	valid = false;
634	} else if (test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
635	need_clear = afs_cb_break_for_zap;	629	need_clear = afs_cb_break_for_zap;
636	valid = false;	630	else if (vnode->cb_expires_at - 10 <= now)
637	} else if (vnode->cb_expires_at - 10 <= now) {
638	need_clear = afs_cb_break_for_lapsed;	631	need_clear = afs_cb_break_for_lapsed;
639	valid = false;
640	} else {
641	valid = true;
642	}
643	} else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {	632	} else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
644	valid = true;	633	;
645	} else {	634	} else {
646	vnode->cb_v_break = cb_v_break;	635	need_clear = afs_cb_break_no_promise;
647	valid = false;
648	}	636	}
649		637
650	} while (need_seqretry(&vnode->cb_lock, seq));	638	} while (need_seqretry(&vnode->cb_lock, seq));
651		639
652	done_seqretry(&vnode->cb_lock, seq);	640	done_seqretry(&vnode->cb_lock, seq);
653		641
654	if (need_clear != afs_cb_break_no_break) {	642	if (need_clear == afs_cb_break_no_break)
655	write_seqlock(&vnode->cb_lock);	643	return true;
656	if (cb_break == vnode->cb_break)
657	__afs_break_callback(vnode, need_clear);
658	else
659	trace_afs_cb_miss(&vnode->fid, need_clear);
660	write_sequnlock(&vnode->cb_lock);
661	valid = false;
662	}
663		644
664	return valid;	645	write_seqlock(&vnode->cb_lock);
		646	if (need_clear == afs_cb_break_no_promise)
		647	vnode->cb_v_break = vnode->volume->cb_v_break;
		648	else if (cb_break == vnode->cb_break)
		649	__afs_break_callback(vnode, need_clear);
		650	else
		651	trace_afs_cb_miss(&vnode->fid, need_clear);
		652	write_sequnlock(&vnode->cb_lock);
		653	return false;
665	}	654	}
666		655
667	/*	656	/*
@@ -675,21 +664,20 @@ bool afs_check_validity(struct afs_vnode *vnode) · 7 unmodified lines
675	*/	664	*/
676	int afs_validate(struct afs_vnode vnode, struct key key)	665	int afs_validate(struct afs_vnode vnode, struct key key)
677	{	666	{
678	bool valid;
679	int ret;	667	int ret;
680		668
681	_enter("{v={%llx:%llu} fl=%lx},%x",	669	_enter("{v={%llx:%llu} fl=%lx},%x",
682	vnode->fid.vid, vnode->fid.vnode, vnode->flags,	670	vnode->fid.vid, vnode->fid.vnode, vnode->flags,
683	key_serial(key));	671	key_serial(key));
684		672
685	rcu_read_lock();	673	if (unlikely(test_bit(AFS_VNODE_DELETED, &vnode->flags))) {
686	valid = afs_check_validity(vnode);	674	if (vnode->vfs_inode.i_nlink)
687	rcu_read_unlock();	675	clear_nlink(&vnode->vfs_inode);
688		676	goto valid;
689	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))	677	}
690	clear_nlink(&vnode->vfs_inode);
691		678
692	if (valid)	679	if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags) &&
		680	afs_check_validity(vnode))
693	goto valid;	681	goto valid;
694		682
695	down_write(&vnode->validate_lock);	683	down_write(&vnode->validate_lock);

fs/afs/internal.h+21−0

 	/* Active fileserver interaction state. */
 	struct rb_root		fs_servers;	/* afs_server (by server UUID) */
 	seqlock_t		fs_lock;	/* For fs_servers  */
+	struct rw_semaphore	fs_open_mmaps_lock;
+	struct list_head	fs_open_mmaps;	/* List of vnodes that are mmapped */
+	atomic_t		fs_s_break;	/* Counter of CB.InitCallBackState messages */
 	/* VL server list. */
 	rwlock_t		vl_servers_lock; /* Lock on vl_servers */
 	struct hlist_node	addr4_link;	/* Link in net->fs_addresses4 */
 	struct hlist_node	addr6_link;	/* Link in net->fs_addresses6 */
 	struct hlist_node	proc_link;	/* Link in net->fs_proc */
+	struct work_struct	initcb_work;	/* Work for CB.InitCallBackState* */
 	struct afs_server	*gc_next;	/* Next server in manager's list */
 	time64_t		unuse_time;	/* Time at which last unused */
 	unsigned long		flags;
 #define AFS_SERVER_FL_IS_YFS	16		/* Server is YFS not AFS */
 #define AFS_SERVER_FL_NO_IBULK	17		/* Fileserver doesn't support FS.InlineBulkStatus */
 #define AFS_SERVER_FL_NO_RM2	18		/* Fileserver doesn't support YFS.RemoveFile2 */
+#define AFS_SERVER_FL_HAS_FS64	19		/* Fileserver supports FS.{Fetch,Store}Data64 */
 	atomic_t		ref;		/* Object refcount */
 	atomic_t		active;		/* Active user count */
 	u32			addr_version;	/* Address list version */
 	afs_lock_type_t		lock_type : 8;
 	/* outstanding callback notification on this file */
+	struct work_struct	cb_work;	/* Work for mmap'd files */
+	struct list_head	cb_mmap_link;	/* Link in cell->fs_open_mmaps */
 	void			*cb_server;	/* Server with callback/filelock */
+	atomic_t		cb_nr_mmap;	/* Number of mmaps */
+	unsigned int		cb_fs_s_break;	/* Mass server break counter (cell->fs_s_break) */
 	unsigned int		cb_s_break;	/* Mass break counter on ->server */
 	unsigned int		cb_v_break;	/* Mass break counter on ->volume */
 	unsigned int		cb_break;	/* Break counter on vnode */
 /*
  * callback.c
  */
+extern void afs_invalidate_mmap_work(struct work_struct *);
+extern void afs_server_init_callback_work(struct work_struct *work);
 extern void afs_init_callback_state(struct afs_server *);
 extern void __afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
 extern void afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
 			(void *)(unsigned long)dir_vp->scb.status.data_version;
 }
+/*
+ * Set the file size and block count.  Estimate the number of 512 bytes blocks
+ * used, rounded up to nearest 1K for consistency with other AFS clients.
+ */
+static inline void afs_set_i_size(struct afs_vnode *vnode, u64 size)
+{
+	i_size_write(&vnode->vfs_inode, size);
+	vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
+}
 /*
  * Check for a conflicting operation on a directory that we just unlinked from.
  * If someone managed to sneak a link or an unlink in on the file we just

fs/afs/protocol_afs.h+15−0

@@ -0,0 +1,15 @@
	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
	2	/* AFS protocol bits
	3	*
	4	* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
	6	*/
	7
	8
	9	#define AFSCAPABILITIESMAX 196 /* Maximum number of words in a capability set */
	10
	11	/* AFS3 Fileserver capabilities word 0 */
	12	#define AFS3_VICED_CAPABILITY_ERRORTRANS 0x0001 /* Uses UAE errors */
	13	#define AFS3_VICED_CAPABILITY_64BITFILES 0x0002 /* FetchData64 & StoreData64 supported */
	14	#define AFS3_VICED_CAPABILITY_WRITELOCKACL 0x0004 /* Can lock a file even without lock perm */
	15	#define AFS3_VICED_CAPABILITY_SANEACLS 0x0008 /* ACLs reviewed for sanity - don't use */

fs/afs/protocol_yfs.h+6−0

@@ -168,3 +168,9 @@ enum yfs_lock_type { · 167 unmodified lines
168	yfs_LockMandatoryWrite = 0x101,	168	yfs_LockMandatoryWrite = 0x101,
169	yfs_LockMandatoryExtend = 0x102,	169	yfs_LockMandatoryExtend = 0x102,
170	};	170	};
		171
		172	/* RXYFS Viced Capability Flags */
		173	#define YFS_VICED_CAPABILITY_ERRORTRANS 0x0001 /* Deprecated v0.195 */
		174	#define YFS_VICED_CAPABILITY_64BITFILES 0x0002 /* Deprecated v0.195 */
		175	#define YFS_VICED_CAPABILITY_WRITELOCKACL 0x0004 /* Can lock a file even without lock perm */
		176	#define YFS_VICED_CAPABILITY_SANEACLS 0x0008 /* Deprecated v0.195 */

fs/afs/rotate.c+1−0

@@ -374,6 +374,7 @@ selected_server: · 373 unmodified lines
374	if (vnode->cb_server != server) {	374	if (vnode->cb_server != server) {
375	vnode->cb_server = server;	375	vnode->cb_server = server;
376	vnode->cb_s_break = server->cb_s_break;	376	vnode->cb_s_break = server->cb_s_break;
		377	vnode->cb_fs_s_break = atomic_read(&server->cell->fs_s_break);
377	vnode->cb_v_break = vnode->volume->cb_v_break;	378	vnode->cb_v_break = vnode->volume->cb_v_break;
378	clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);	379	clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
379	}	380	}

fs/afs/server.c+2−0

 	server->addr_version = alist->version;
 	server->uuid = *uuid;
 	rwlock_init(&server->fs_lock);
+	INIT_WORK(&server->initcb_work, afs_server_init_callback_work);
 	init_waitqueue_head(&server->probe_wq);
 	INIT_LIST_HEAD(&server->probe_link);
 	spin_lock_init(&server->probe_lock);
 	if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))
 		afs_give_up_callbacks(net, server);
+	flush_work(&server->initcb_work);
 	afs_put_server(net, server, afs_server_trace_destroy);
 }

fs/afs/super.c+1−0

@@ -698,6 +698,7 @@ static struct inode afs_alloc_inode(struct super_block sb) · 697 unmodified lines
698	vnode->lock_state = AFS_VNODE_LOCK_NONE;	698	vnode->lock_state = AFS_VNODE_LOCK_NONE;
699		699
700	init_rwsem(&vnode->rmdir_lock);	700	init_rwsem(&vnode->rmdir_lock);
		701	INIT_WORK(&vnode->cb_work, afs_invalidate_mmap_work);
701		702
702	_leave(" = %p", &vnode->vfs_inode);	703	_leave(" = %p", &vnode->vfs_inode);
703	return &vnode->vfs_inode;	704	return &vnode->vfs_inode;

fs/afs/write.c+24−5

 		write_seqlock(&vnode->cb_lock);
 		i_size = i_size_read(&vnode->vfs_inode);
 		if (maybe_i_size > i_size)
-			i_size_write(&vnode->vfs_inode, maybe_i_size);
+			afs_set_i_size(vnode, maybe_i_size);
 		write_sequnlock(&vnode->cb_lock);
 	}
 			}
 			/* Has the page moved or been split? */
-			if (unlikely(page != xas_reload(&xas)))
+			if (unlikely(page != xas_reload(&xas))) {
+				put_page(page);
 				break;
+			}
-			if (!trylock_page(page))
+			if (!trylock_page(page)) {
+				put_page(page);
 				break;
+			}
 			if (!PageDirty(page) || PageWriteback(page)) {
 				unlock_page(page);
+				put_page(page);
 				break;
 			}
 			t = afs_page_dirty_to(page, priv);
 			if (f != 0 && !new_content) {
 				unlock_page(page);
+				put_page(page);
 				break;
 			}
 ssize_t afs_file_write(struct kiocb *iocb, struct iov_iter *from)
 {
 	struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp));
+	struct afs_file *af = iocb->ki_filp->private_data;
 	ssize_t result;
 	size_t count = iov_iter_count(from);
 	if (!count)
 		return 0;
+	result = afs_validate(vnode, af->key);
+	if (result < 0)
+		return result;
 	result = generic_file_write_iter(iocb, from);
 	_leave(" = %zd", result);
  */
 int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-	struct inode *inode = file_inode(file);
+	struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
-	struct afs_vnode *vnode = AFS_FS_I(inode);
+	struct afs_file *af = file->private_data;
+	int ret;
 	_enter("{%llx:%llu},{n=%pD},%d",
 	       vnode->fid.vid, vnode->fid.vnode, file,
 	       datasync);
+	ret = afs_validate(vnode, af->key);
+	if (ret < 0)
+		return ret;
 	return file_write_and_wait_range(file, start, end);
 }
 	struct file *file = vmf->vma->vm_file;
 	struct inode *inode = file_inode(file);
 	struct afs_vnode *vnode = AFS_FS_I(inode);
+	struct afs_file *af = file->private_data;
 	unsigned long priv;
 	vm_fault_t ret = VM_FAULT_RETRY;
 	_enter("{{%llx:%llu}},{%lx}", vnode->fid.vid, vnode->fid.vnode, page->index);
+	afs_validate(vnode, af->key);
 	sb_start_pagefault(inode->i_sb);
 	/* Wait for the page to be written to the cache before we allow it to

fs/cifs/cache.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cache.c - CIFS filesystem cache index structure definitions	3	* CIFS filesystem cache index structure definitions
4	*	4	*
5	* Copyright (c) 2010 Novell, Inc.	5	* Copyright (c) 2010 Novell, Inc.
6	* Authors(s): Suresh Jayaraman (sjayaraman@suse.de>	6	* Authors(s): Suresh Jayaraman (sjayaraman@suse.de>

fs/cifs/cifs_debug.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* fs/cifs_debug.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2000,2005	4	* Copyright (C) International Business Machines Corp., 2000,2005
6	*	5	*

fs/cifs/cifs_fs_sb.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifs_fs_sb.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002,2004	4	* Copyright (c) International Business Machines Corp., 2002,2004
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifs_ioctl.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifs_ioctl.h
4	*	3	*
5	* Structure definitions for io control for cifs/smb3	4	* Structure definitions for io control for cifs/smb3
6	*	5	*

fs/cifs/cifs_spnego.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cifs_spnego.c -- SPNEGO upcall management for CIFS	3	* SPNEGO upcall management for CIFS
4	*	4	*
5	* Copyright (c) 2007 Red Hat, Inc.	5	* Copyright (c) 2007 Red Hat, Inc.
6	* Author(s): Jeff Layton (jlayton@redhat.com)	6	* Author(s): Jeff Layton (jlayton@redhat.com)

fs/cifs/cifs_spnego.h+1−1

@@ -1,6 +1,6 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifs_spnego.h -- SPNEGO upcall management for CIFS	3	* SPNEGO upcall management for CIFS
4	*	4	*
5	* Copyright (c) 2007 Red Hat, Inc.	5	* Copyright (c) 2007 Red Hat, Inc.
6	* Author(s): Jeff Layton (jlayton@redhat.com)	6	* Author(s): Jeff Layton (jlayton@redhat.com)

fs/cifs/cifs_unicode.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* fs/cifs/cifs_unicode.c
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2000,2009	4	* Copyright (c) International Business Machines Corp., 2000,2009
6	* Modified by Steve French (sfrench@us.ibm.com)	5	* Modified by Steve French (sfrench@us.ibm.com)

fs/cifs/cifsacl.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cifsacl.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2007,2008	4	* Copyright (C) International Business Machines Corp., 2007,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifsacl.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifsacl.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2007	4	* Copyright (c) International Business Machines Corp., 2007
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifsencrypt.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cifsencrypt.c
4	*	3	*
5	* Encryption and hashing operations relating to NTLM, NTLMv2. See MS-NLMP	4	* Encryption and hashing operations relating to NTLM, NTLMv2. See MS-NLMP
6	* for more detailed information	5	* for more detailed information

fs/cifs/cifsfs.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cifsfs.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2008	4	* Copyright (C) International Business Machines Corp., 2002,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifsfs.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifsfs.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002, 2007	4	* Copyright (c) International Business Machines Corp., 2002, 2007
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifsglob.h+1−1

 /* SPDX-License-Identifier: LGPL-2.1 */
 /*
- *   fs/cifs/cifsglob.h
  *
  *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
 #define CIFS_INO_INVALID_MAPPING	  (4) /* pagecache is invalid */
 #define CIFS_INO_LOCK			  (5) /* lock bit for synchronization */
 #define CIFS_INO_MODIFIED_ATTR            (6) /* Indicate change in mtime/ctime */
+#define CIFS_INO_CLOSE_ON_LOCK            (7) /* Not to defer the close when lock is set */
 	unsigned long flags;
 	spinlock_t writers_lock;
 	unsigned int writers;		/* Number of writers on this inode */

fs/cifs/cifspdu.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/cifspdu.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002,2009	4	* Copyright (c) International Business Machines Corp., 2002,2009
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/cifsproto.h+3−1

 /* SPDX-License-Identifier: LGPL-2.1 */
 /*
- *   fs/cifs/cifsproto.h
  *
  *   Copyright (c) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
 extern void cifs_close_all_deferred_files(struct cifs_tcon *cifs_tcon);
+extern void cifs_close_deferred_file_under_dentry(struct cifs_tcon *cifs_tcon,
+				const char *path);
 extern struct TCP_Server_Info *cifs_get_tcp_session(struct smb3_fs_context *ctx);
 extern void cifs_put_tcp_session(struct TCP_Server_Info *server,
 				 int from_reconnect);

fs/cifs/cifssmb.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/cifssmb.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2010	4	* Copyright (C) International Business Machines Corp., 2002,2010
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/connect.c+10−3

 // SPDX-License-Identifier: LGPL-2.1
 /*
- *   fs/cifs/connect.c
  *
  *   Copyright (C) International Business Machines  Corp., 2002,2011
  *   Author(s): Steve French (sfrench@us.ibm.com)
 	module_put_and_exit(0);
 }
-/**
+/*
  * Returns true if srcaddr isn't specified and rhs isn't specified, or
  * if srcaddr is specified and matches the IP address of the rhs argument
  */
 /**
  * cifs_setup_ipc - helper to setup the IPC tcon for the session
+ * @ses: smb session to issue the request on
+ * @ctx: the superblock configuration context to use for building the
+ *       new tree connection for the IPC (interprocess communication RPC)
  *
  * A new IPC connection is made and stored in the session
  * tcon_ipc. The IPC tcon has the same lifetime as the session.
 /**
  * cifs_free_ipc - helper to release the session IPC tcon
+ * @ses: smb session to unmount the IPC from
  *
  * Needs to be called everytime a session is destroyed.
  *
 /**
  * cifs_get_smb_ses - get a session matching @ctx data from @server
+ * @server: server to setup the session to
+ * @ctx: superblock configuration context to use to setup the session
  *
  * This function assumes it is being called from cifs_mount() where we
  * already got a server reference (server refcount +1). See
 /**
  * cifs_get_tcon - get a tcon matching @ctx data from @ses
+ * @ses: smb session to issue the request on
+ * @ctx: the superblock configuration context to use for building the
  *
  * - tcon refcount is the number of mount points using the tcon.
  * - ses refcount is the number of tcon using the session.
 	return full_path;
 }
-/**
+/*
  * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
  *
  * If a referral is found, cifs_sb->ctx->mount_options will be (re-)allocated

fs/cifs/dir.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/dir.c
4	*	3	*
5	* vfs operations that deal with dentries	4	* vfs operations that deal with dentries
6	*	5	*

fs/cifs/dns_resolve.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/dns_resolve.c
4	*	3	*
5	* Copyright (c) 2007 Igor Mammedov	4	* Copyright (c) 2007 Igor Mammedov
6	* Author(s): Igor Mammedov (niallain@gmail.com)	5	* Author(s): Igor Mammedov (niallain@gmail.com)

fs/cifs/dns_resolve.h+2−2

@@ -1,7 +1,7 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/dns_resolve.h -- DNS Resolver upcall management for CIFS DFS	3	* DNS Resolver upcall management for CIFS DFS
4	* Handles host name to IP address resolution	4	* Handles host name to IP address resolution
5	*	5	*
6	* Copyright (c) International Business Machines Corp., 2008	6	* Copyright (c) International Business Machines Corp., 2008
7	* Author(s): Steve French (sfrench@us.ibm.com)	7	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/export.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/export.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2007	4	* Copyright (C) International Business Machines Corp., 2007
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/file.c+2−1

 // SPDX-License-Identifier: LGPL-2.1
 /*
- *   fs/cifs/file.c
  *
  *   vfs operations that deal with files
  *
 		dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL);
 		if ((cinode->oplock == CIFS_CACHE_RHW_FLG) &&
 		    cinode->lease_granted &&
+		    !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) &&
 		    dclose) {
 			if (test_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) {
 				inode->i_ctime = inode->i_mtime = current_time(inode);
 	cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
 			tcon->ses->server);
 	cifs_sb = CIFS_FILE_SB(file);
+	set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);
 	if (cap_unix(tcon->ses) &&
 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&

fs/cifs/fscache.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/fscache.c - CIFS filesystem cache interface	3	* CIFS filesystem cache interface
4	*	4	*
5	* Copyright (c) 2010 Novell, Inc.	5	* Copyright (c) 2010 Novell, Inc.
6	* Author(s): Suresh Jayaraman <sjayaraman@suse.de>	6	* Author(s): Suresh Jayaraman <sjayaraman@suse.de>

fs/cifs/fscache.h+1−1

@@ -1,6 +1,6 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/fscache.h - CIFS filesystem cache interface definitions	3	* CIFS filesystem cache interface definitions
4	*	4	*
5	* Copyright (c) 2010 Novell, Inc.	5	* Copyright (c) 2010 Novell, Inc.
6	* Authors(s): Suresh Jayaraman (sjayaraman@suse.de>	6	* Authors(s): Suresh Jayaraman (sjayaraman@suse.de>

fs/cifs/inode.c+3−4

 // SPDX-License-Identifier: LGPL-2.1
 /*
- *   fs/cifs/inode.c
  *
  *   Copyright (C) International Business Machines  Corp., 2002,2010
  *   Author(s): Steve French (sfrench@us.ibm.com)
 		goto unlink_out;
 	}
-	cifs_close_deferred_file(CIFS_I(inode));
+	cifs_close_deferred_file_under_dentry(tcon, full_path);
 	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
 		goto cifs_rename_exit;
 	}
-	cifs_close_deferred_file(CIFS_I(d_inode(source_dentry)));
+	cifs_close_deferred_file_under_dentry(tcon, from_name);
 	if (d_inode(target_dentry) != NULL)
-		cifs_close_deferred_file(CIFS_I(d_inode(target_dentry)));
+		cifs_close_deferred_file_under_dentry(tcon, to_name);
 	rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
 			    to_name);

fs/cifs/ioctl.c+1−2

 // SPDX-License-Identifier: LGPL-2.1
 /*
- *   fs/cifs/ioctl.c
  *
  *   vfs operations that deal with io control
  *
 			if (pSMBFile == NULL)
 				break;
 			tcon = tlink_tcon(pSMBFile->tlink);
-			caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
+			/* caps = le64_to_cpu(tcon->fsUnixInfo.Capability); */
 			if (get_user(ExtAttrBits, (int __user *)arg)) {
 				rc = -EFAULT;

fs/cifs/link.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/link.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2008	4	* Copyright (C) International Business Machines Corp., 2002,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/misc.c+39−3

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/misc.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2008	4	* Copyright (C) International Business Machines Corp., 2002,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)
@@ -736,7 +735,7 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode) · 729 unmodified lines
736	if (cancel_delayed_work(&cfile->deferred)) {	735	if (cancel_delayed_work(&cfile->deferred)) {
737	tmp_list = kmalloc(sizeof(struct file_list), GFP_ATOMIC);	736	tmp_list = kmalloc(sizeof(struct file_list), GFP_ATOMIC);
738	if (tmp_list == NULL)	737	if (tmp_list == NULL)
739	continue;	738	break;
740	tmp_list->cfile = cfile;	739	tmp_list->cfile = cfile;
741	list_add_tail(&tmp_list->list, &file_head);	740	list_add_tail(&tmp_list->list, &file_head);
742	}	741	}
@@ -767,7 +766,7 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon) · 24 unmodified lines
767	if (cancel_delayed_work(&cfile->deferred)) {	766	if (cancel_delayed_work(&cfile->deferred)) {
768	tmp_list = kmalloc(sizeof(struct file_list), GFP_ATOMIC);	767	tmp_list = kmalloc(sizeof(struct file_list), GFP_ATOMIC);
769	if (tmp_list == NULL)	768	if (tmp_list == NULL)
770	continue;	769	break;
771	tmp_list->cfile = cfile;	770	tmp_list->cfile = cfile;
772	list_add_tail(&tmp_list->list, &file_head);	771	list_add_tail(&tmp_list->list, &file_head);
773	}	772	}
@@ -781,6 +780,43 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon) · 7 unmodified lines
781	kfree(tmp_list);	780	kfree(tmp_list);
782	}	781	}
783	}	782	}
		783	void
		784	cifs_close_deferred_file_under_dentry(struct cifs_tcon tcon, const char path)
		785	{
		786	struct cifsFileInfo *cfile;
		787	struct list_head *tmp;
		788	struct file_list tmp_list, tmp_next_list;
		789	struct list_head file_head;
		790	void *page;
		791	const char *full_path;
		792
		793	INIT_LIST_HEAD(&file_head);
		794	page = alloc_dentry_path();
		795	spin_lock(&tcon->open_file_lock);
		796	list_for_each(tmp, &tcon->openFileList) {
		797	cfile = list_entry(tmp, struct cifsFileInfo, tlist);
		798	full_path = build_path_from_dentry(cfile->dentry, page);
		799	if (strstr(full_path, path)) {
		800	if (delayed_work_pending(&cfile->deferred)) {
		801	if (cancel_delayed_work(&cfile->deferred)) {
		802	tmp_list = kmalloc(sizeof(struct file_list), GFP_ATOMIC);
		803	if (tmp_list == NULL)
		804	break;
		805	tmp_list->cfile = cfile;
		806	list_add_tail(&tmp_list->list, &file_head);
		807	}
		808	}
		809	}
		810	}
		811	spin_unlock(&tcon->open_file_lock);
		812
		813	list_for_each_entry_safe(tmp_list, tmp_next_list, &file_head, list) {
		814	_cifsFileInfo_put(tmp_list->cfile, true, false);
		815	list_del(&tmp_list->list);
		816	kfree(tmp_list);
		817	}
		818	free_dentry_path(page);
		819	}
784		820
785	/* parses DFS refferal V3 structure	821	/* parses DFS refferal V3 structure
786	* caller is responsible for freeing target_nodes	822	* caller is responsible for freeing target_nodes

fs/cifs/netmisc.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* fs/cifs/netmisc.c
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002,2008	4	* Copyright (c) International Business Machines Corp., 2002,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/ntlmssp.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/ntlmssp.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002,2007	4	* Copyright (c) International Business Machines Corp., 2002,2007
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/readdir.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/readdir.c
4	*	3	*
5	* Directory search handling	4	* Directory search handling
6	*	5	*

fs/cifs/rfc1002pdu.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/rfc1002pdu.h
4	*	3	*
5	* Protocol Data Unit definitions for RFC 1001/1002 support	4	* Protocol Data Unit definitions for RFC 1001/1002 support
6	*	5	*

fs/cifs/sess.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/sess.c
4	*	3	*
5	* SMB/CIFS session setup handling routines	4	* SMB/CIFS session setup handling routines
6	*	5	*

fs/cifs/smb2file.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/smb2file.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002, 2011	4	* Copyright (C) International Business Machines Corp., 2002, 2011
6	* Author(s): Steve French (sfrench@us.ibm.com),	5	* Author(s): Steve French (sfrench@us.ibm.com),

fs/cifs/smb2glob.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/smb2glob.h
4	*	3	*
5	* Definitions for various global variables and structures	4	* Definitions for various global variables and structures
6	*	5	*

fs/cifs/smb2inode.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/smb2inode.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002, 2011	4	* Copyright (C) International Business Machines Corp., 2002, 2011
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smb2misc.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/smb2misc.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2011	4	* Copyright (C) International Business Machines Corp., 2002,2011
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smb2pdu.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/smb2pdu.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2009, 2013	4	* Copyright (C) International Business Machines Corp., 2009, 2013
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smb2pdu.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/smb2pdu.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2009, 2013	4	* Copyright (c) International Business Machines Corp., 2009, 2013
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smb2proto.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/smb2proto.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002, 2011	4	* Copyright (c) International Business Machines Corp., 2002, 2011
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smb2status.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/smb2status.h
4	*	3	*
5	* SMB2 Status code (network error) definitions	4	* SMB2 Status code (network error) definitions
6	* Definitions are from MS-ERREF	5	* Definitions are from MS-ERREF

fs/cifs/smb2transport.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/smb2transport.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002, 2011	4	* Copyright (C) International Business Machines Corp., 2002, 2011
6	* Etersoft, 2012	5	* Etersoft, 2012

fs/cifs/smberr.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1 */	1	/* SPDX-License-Identifier: LGPL-2.1 */
2	/*	2	/*
3	* fs/cifs/smberr.h
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2002,2004	4	* Copyright (c) International Business Machines Corp., 2002,2004
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/transport.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/transport.c
4	*	3	*
5	* Copyright (C) International Business Machines Corp., 2002,2008	4	* Copyright (C) International Business Machines Corp., 2002,2008
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/cifs/winucase.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* fs/cifs/winucase.c
4	*	3	*
5	* Copyright (c) Jeffrey Layton <jlayton@redhat.com>, 2013	4	* Copyright (c) Jeffrey Layton <jlayton@redhat.com>, 2013
6	*	5	*

fs/cifs/xattr.c+0−1

@@ -1,6 +1,5 @@
1	// SPDX-License-Identifier: LGPL-2.1	1	// SPDX-License-Identifier: LGPL-2.1
2	/*	2	/*
3	* fs/cifs/xattr.c
4	*	3	*
5	* Copyright (c) International Business Machines Corp., 2003, 2007	4	* Copyright (c) International Business Machines Corp., 2003, 2007
6	* Author(s): Steve French (sfrench@us.ibm.com)	5	* Author(s): Steve French (sfrench@us.ibm.com)

fs/io-wq.c+13−14

 #include <linux/rculist_nulls.h>
 #include <linux/cpu.h>
 #include <linux/tracehook.h>
+#include <uapi/linux/io_uring.h>
 #include "io-wq.h"
 static void io_worker_exit(struct io_worker *worker)
 {
 	struct io_wqe *wqe = worker->wqe;
-	struct io_wqe_acct *acct = io_wqe_get_acct(worker);
 	if (refcount_dec_and_test(&worker->ref))
 		complete(&worker->ref_done);
 	if (worker->flags & IO_WORKER_F_FREE)
 		hlist_nulls_del_rcu(&worker->nulls_node);
 	list_del_rcu(&worker->all_list);
-	acct->nr_workers--;
 	preempt_disable();
 	io_wqe_dec_running(worker);
 	worker->flags = 0;
  */
 static bool io_wqe_create_worker(struct io_wqe *wqe, struct io_wqe_acct *acct)
 {
-	bool do_create = false;
 	/*
 	 * Most likely an attempt to queue unbounded work on an io_wq that
 	 * wasn't setup with any unbounded workers.
 		pr_warn_once("io-wq is not configured for unbound workers");
 	raw_spin_lock(&wqe->lock);
-	if (acct->nr_workers < acct->max_workers) {
+	if (acct->nr_workers == acct->max_workers) {
-		acct->nr_workers++;
+		raw_spin_unlock(&wqe->lock);
-		do_create = true;
+		return true;
 	}
+	acct->nr_workers++;
 	raw_spin_unlock(&wqe->lock);
-	if (do_create) {
+	atomic_inc(&acct->nr_running);
-		atomic_inc(&acct->nr_running);
+	atomic_inc(&wqe->wq->worker_refs);
-		atomic_inc(&wqe->wq->worker_refs);
+	return create_io_worker(wqe->wq, wqe, acct->index);
-		return create_io_worker(wqe->wq, wqe, acct->index);
-	}
-	return true;
 }
 static void io_wqe_inc_running(struct io_worker *worker)
 		}
 		/* timed out, exit unless we're the last worker */
 		if (last_timeout && acct->nr_workers > 1) {
+			acct->nr_workers--;
 			raw_spin_unlock(&wqe->lock);
 			__set_current_state(TASK_RUNNING);
 			break;
 {
 	int i, node, prev = 0;
+	BUILD_BUG_ON((int) IO_WQ_ACCT_BOUND   != (int) IO_WQ_BOUND);
+	BUILD_BUG_ON((int) IO_WQ_ACCT_UNBOUND != (int) IO_WQ_UNBOUND);
+	BUILD_BUG_ON((int) IO_WQ_ACCT_NR      != 2);
 	for (i = 0; i < 2; i++) {
 		if (new_count[i] > task_rlimit(current, RLIMIT_NPROC))
 			new_count[i] = task_rlimit(current, RLIMIT_NPROC);

fs/io_uring.c+144−77

@@ -712,6 +712,7 @@ struct io_async_rw { · 711 unmodified lines
712	struct iovec fast_iov[UIO_FASTIOV];	712	struct iovec fast_iov[UIO_FASTIOV];
713	const struct iovec *free_iovec;	713	const struct iovec *free_iovec;
714	struct iov_iter iter;	714	struct iov_iter iter;
		715	struct iov_iter_state iter_state;
715	size_t bytes_done;	716	size_t bytes_done;
716	struct wait_page_queue wpq;	717	struct wait_page_queue wpq;
717	};	718	};
@@ -735,7 +736,6 @@ enum { · 17 unmodified lines
735	REQ_F_BUFFER_SELECTED_BIT,	736	REQ_F_BUFFER_SELECTED_BIT,
736	REQ_F_COMPLETE_INLINE_BIT,	737	REQ_F_COMPLETE_INLINE_BIT,
737	REQ_F_REISSUE_BIT,	738	REQ_F_REISSUE_BIT,
738	REQ_F_DONT_REISSUE_BIT,
739	REQ_F_CREDS_BIT,	739	REQ_F_CREDS_BIT,
740	REQ_F_REFCOUNT_BIT,	740	REQ_F_REFCOUNT_BIT,
741	REQ_F_ARM_LTIMEOUT_BIT,	741	REQ_F_ARM_LTIMEOUT_BIT,
@@ -782,8 +782,6 @@ enum { · 40 unmodified lines
782	REQ_F_COMPLETE_INLINE = BIT(REQ_F_COMPLETE_INLINE_BIT),	782	REQ_F_COMPLETE_INLINE = BIT(REQ_F_COMPLETE_INLINE_BIT),
783	/* caller should reissue async */	783	/* caller should reissue async */
784	REQ_F_REISSUE = BIT(REQ_F_REISSUE_BIT),	784	REQ_F_REISSUE = BIT(REQ_F_REISSUE_BIT),
785	/* don't attempt request reissue, see io_rw_reissue() */
786	REQ_F_DONT_REISSUE = BIT(REQ_F_DONT_REISSUE_BIT),
787	/* supports async reads */	785	/* supports async reads */
788	REQ_F_NOWAIT_READ = BIT(REQ_F_NOWAIT_READ_BIT),	786	REQ_F_NOWAIT_READ = BIT(REQ_F_NOWAIT_READ_BIT),
789	/* supports async writes */	787	/* supports async writes */
@@ -2444,13 +2442,6 @@ static void io_iopoll_complete(struct io_ring_ctx ctx, unsigned int nr_events, · 1654 unmodified lines
2444	req = list_first_entry(done, struct io_kiocb, inflight_entry);	2442	req = list_first_entry(done, struct io_kiocb, inflight_entry);
2445	list_del(&req->inflight_entry);	2443	list_del(&req->inflight_entry);
2446		2444
2447	if (READ_ONCE(req->result) == -EAGAIN &&
2448	!(req->flags & REQ_F_DONT_REISSUE)) {
2449	req->iopoll_completed = 0;
2450	io_req_task_queue_reissue(req);
2451	continue;
2452	}
2453
2454	__io_cqring_fill_event(ctx, req->user_data, req->result,	2445	__io_cqring_fill_event(ctx, req->user_data, req->result,
2455	io_put_rw_kbuf(req));	2446	io_put_rw_kbuf(req));
2456	(*nr_events)++;	2447	(*nr_events)++;
@@ -2613,8 +2604,7 @@ static bool io_resubmit_prep(struct io_kiocb *req) · 156 unmodified lines
2613		2604
2614	if (!rw)	2605	if (!rw)
2615	return !io_req_prep_async(req);	2606	return !io_req_prep_async(req);
2616	/* may have left rw->iter inconsistent on -EIOCBQUEUED */	2607	iov_iter_restore(&rw->iter, &rw->iter_state);
2617	iov_iter_revert(&rw->iter, req->result - iov_iter_count(&rw->iter));
2618	return true;	2608	return true;
2619	}	2609	}
2620		2610
@@ -2714,10 +2704,9 @@ static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2) · 93 unmodified lines
2714	if (kiocb->ki_flags & IOCB_WRITE)	2704	if (kiocb->ki_flags & IOCB_WRITE)
2715	kiocb_end_write(req);	2705	kiocb_end_write(req);
2716	if (unlikely(res != req->result)) {	2706	if (unlikely(res != req->result)) {
2717	if (!(res == -EAGAIN && io_rw_should_reissue(req) &&	2707	if (res == -EAGAIN && io_rw_should_reissue(req)) {
2718	io_resubmit_prep(req))) {	2708	req->flags \|= REQ_F_REISSUE;
2719	req_set_fail(req);	2709	return;
2720	req->flags \|= REQ_F_DONT_REISSUE;
2721	}	2710	}
2722	}	2711	}
2723		2712
@@ -2843,7 +2832,8 @@ static bool io_file_supports_nowait(struct io_kiocb *req, int rw) · 119 unmodified lines
2843	return __io_file_supports_nowait(req->file, rw);	2832	return __io_file_supports_nowait(req->file, rw);
2844	}	2833	}
2845		2834
2846	static int io_prep_rw(struct io_kiocb req, const struct io_uring_sqe sqe)	2835	static int io_prep_rw(struct io_kiocb req, const struct io_uring_sqe sqe,
		2836	int rw)
2847	{	2837	{
2848	struct io_ring_ctx *ctx = req->ctx;	2838	struct io_ring_ctx *ctx = req->ctx;
2849	struct kiocb *kiocb = &req->rw.kiocb;	2839	struct kiocb *kiocb = &req->rw.kiocb;
@@ -2865,8 +2855,13 @@ static int io_prep_rw(struct io_kiocb req, const struct io_uring_sqe sqe) · 15 unmodified lines
2865	if (unlikely(ret))	2855	if (unlikely(ret))
2866	return ret;	2856	return ret;
2867		2857
2868	/* don't allow async punt for O_NONBLOCK or RWF_NOWAIT */	2858	/*
2869	if ((kiocb->ki_flags & IOCB_NOWAIT) \|\| (file->f_flags & O_NONBLOCK))	2859	* If the file is marked O_NONBLOCK, still allow retry for it if it
		2860	* supports async. Otherwise it's impossible to use O_NONBLOCK files
		2861	* reliably. If not, or it IOCB_NOWAIT is set, don't retry.
		2862	*/
		2863	if ((kiocb->ki_flags & IOCB_NOWAIT) \|\|
		2864	((file->f_flags & O_NONBLOCK) && !io_file_supports_nowait(req, rw)))
2870	req->flags \|= REQ_F_NOWAIT;	2865	req->flags \|= REQ_F_NOWAIT;
2871		2866
2872	ioprio = READ_ONCE(sqe->ioprio);	2867	ioprio = READ_ONCE(sqe->ioprio);
@@ -2931,7 +2926,6 @@ static void kiocb_done(struct kiocb *kiocb, ssize_t ret, · 58 unmodified lines
2931	{	2926	{
2932	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);	2927	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
2933	struct io_async_rw *io = req->async_data;	2928	struct io_async_rw *io = req->async_data;
2934	bool check_reissue = kiocb->ki_complete == io_complete_rw;
2935		2929
2936	/* add previously done IO, if any */	2930	/* add previously done IO, if any */
2937	if (io && io->bytes_done > 0) {	2931	if (io && io->bytes_done > 0) {
@@ -2943,19 +2937,27 @@ static void kiocb_done(struct kiocb *kiocb, ssize_t ret, · 5 unmodified lines
2943		2937
2944	if (req->flags & REQ_F_CUR_POS)	2938	if (req->flags & REQ_F_CUR_POS)
2945	req->file->f_pos = kiocb->ki_pos;	2939	req->file->f_pos = kiocb->ki_pos;
2946	if (ret >= 0 && check_reissue)	2940	if (ret >= 0 && (kiocb->ki_complete == io_complete_rw))
2947	__io_complete_rw(req, ret, 0, issue_flags);	2941	__io_complete_rw(req, ret, 0, issue_flags);
2948	else	2942	else
2949	io_rw_done(kiocb, ret);	2943	io_rw_done(kiocb, ret);
2950		2944
2951	if (check_reissue && (req->flags & REQ_F_REISSUE)) {	2945	if (req->flags & REQ_F_REISSUE) {
2952	req->flags &= ~REQ_F_REISSUE;	2946	req->flags &= ~REQ_F_REISSUE;
2953	if (io_resubmit_prep(req)) {	2947	if (io_resubmit_prep(req)) {
2954	io_req_task_queue_reissue(req);	2948	io_req_task_queue_reissue(req);
2955	} else {	2949	} else {
		2950	unsigned int cflags = io_put_rw_kbuf(req);
		2951	struct io_ring_ctx *ctx = req->ctx;
		2952
2956	req_set_fail(req);	2953	req_set_fail(req);
2957	__io_req_complete(req, issue_flags, ret,	2954	if (issue_flags & IO_URING_F_NONBLOCK) {
2958	io_put_rw_kbuf(req));	2955	mutex_lock(&ctx->uring_lock);
		2956	__io_req_complete(req, issue_flags, ret, cflags);
		2957	mutex_unlock(&ctx->uring_lock);
		2958	} else {
		2959	__io_req_complete(req, issue_flags, ret, cflags);
		2960	}
2959	}	2961	}
2960	}	2962	}
2961	}	2963	}
@@ -3263,12 +3265,15 @@ static ssize_t loop_rw_iter(int rw, struct io_kiocb req, struct iov_iter iter) · 301 unmodified lines
3263	ret = nr;	3265	ret = nr;
3264	break;	3266	break;
3265	}	3267	}
		3268	if (!iov_iter_is_bvec(iter)) {
		3269	iov_iter_advance(iter, nr);
		3270	} else {
		3271	req->rw.len -= nr;
		3272	req->rw.addr += nr;
		3273	}
3266	ret += nr;	3274	ret += nr;
3267	if (nr != iovec.iov_len)	3275	if (nr != iovec.iov_len)
3268	break;	3276	break;
3269	req->rw.len -= nr;
3270	req->rw.addr += nr;
3271	iov_iter_advance(iter, nr);
3272	}	3277	}
3273		3278
3274	return ret;	3279	return ret;
@@ -3315,12 +3320,17 @@ static int io_setup_async_rw(struct io_kiocb req, const struct iovec iovec, · 40 unmodified lines
3315	if (!force && !io_op_defs[req->opcode].needs_async_setup)	3320	if (!force && !io_op_defs[req->opcode].needs_async_setup)
3316	return 0;	3321	return 0;
3317	if (!req->async_data) {	3322	if (!req->async_data) {
		3323	struct io_async_rw *iorw;
		3324
3318	if (io_alloc_async_data(req)) {	3325	if (io_alloc_async_data(req)) {
3319	kfree(iovec);	3326	kfree(iovec);
3320	return -ENOMEM;	3327	return -ENOMEM;
3321	}	3328	}
3322		3329
3323	io_req_map_rw(req, iovec, fast_iov, iter);	3330	io_req_map_rw(req, iovec, fast_iov, iter);
		3331	iorw = req->async_data;
		3332	/* we've copied and mapped the iter, ensure state is saved */
		3333	iov_iter_save_state(&iorw->iter, &iorw->iter_state);
3324	}	3334	}
3325	return 0;	3335	return 0;
3326	}	3336	}
@@ -3339,6 +3349,7 @@ static inline int io_rw_prep_async(struct io_kiocb *req, int rw) · 12 unmodified lines
3339	iorw->free_iovec = iov;	3349	iorw->free_iovec = iov;
3340	if (iov)	3350	if (iov)
3341	req->flags \|= REQ_F_NEED_CLEANUP;	3351	req->flags \|= REQ_F_NEED_CLEANUP;
		3352	iov_iter_save_state(&iorw->iter, &iorw->iter_state);
3342	return 0;	3353	return 0;
3343	}	3354	}
3344		3355
@@ -3346,7 +3357,7 @@ static int io_read_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 1 unmodified line
3346	{	3357	{
3347	if (unlikely(!(req->file->f_mode & FMODE_READ)))	3358	if (unlikely(!(req->file->f_mode & FMODE_READ)))
3348	return -EBADF;	3359	return -EBADF;
3349	return io_prep_rw(req, sqe);	3360	return io_prep_rw(req, sqe, READ);
3350	}	3361	}
3351		3362
3352	/*	3363	/*
@@ -3442,19 +3453,28 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 89 unmodified lines
3442	struct kiocb *kiocb = &req->rw.kiocb;	3453	struct kiocb *kiocb = &req->rw.kiocb;
3443	struct iov_iter __iter, *iter = &__iter;	3454	struct iov_iter __iter, *iter = &__iter;
3444	struct io_async_rw *rw = req->async_data;	3455	struct io_async_rw *rw = req->async_data;
3445	ssize_t io_size, ret, ret2;
3446	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	3456	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
		3457	struct iov_iter_state __state, *state;
		3458	ssize_t ret, ret2;
3447		3459
3448	if (rw) {	3460	if (rw) {
3449	iter = &rw->iter;	3461	iter = &rw->iter;
		3462	state = &rw->iter_state;
		3463	/*
		3464	* We come here from an earlier attempt, restore our state to
		3465	* match in case it doesn't. It's cheap enough that we don't
		3466	* need to make this conditional.
		3467	*/
		3468	iov_iter_restore(iter, state);
3450	iovec = NULL;	3469	iovec = NULL;
3451	} else {	3470	} else {
3452	ret = io_import_iovec(READ, req, &iovec, iter, !force_nonblock);	3471	ret = io_import_iovec(READ, req, &iovec, iter, !force_nonblock);
3453	if (ret < 0)	3472	if (ret < 0)
3454	return ret;	3473	return ret;
		3474	state = &__state;
		3475	iov_iter_save_state(iter, state);
3455	}	3476	}
3456	io_size = iov_iter_count(iter);	3477	req->result = iov_iter_count(iter);
3457	req->result = io_size;
3458		3478
3459	/* Ensure we clear previously set non-block flag */	3479	/* Ensure we clear previously set non-block flag */
3460	if (!force_nonblock)	3480	if (!force_nonblock)
@@ -3468,7 +3488,7 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 7 unmodified lines
3468	return ret ?: -EAGAIN;	3488	return ret ?: -EAGAIN;
3469	}	3489	}
3470		3490
3471	ret = rw_verify_area(READ, req->file, io_kiocb_ppos(kiocb), io_size);	3491	ret = rw_verify_area(READ, req->file, io_kiocb_ppos(kiocb), req->result);
3472	if (unlikely(ret)) {	3492	if (unlikely(ret)) {
3473	kfree(iovec);	3493	kfree(iovec);
3474	return ret;	3494	return ret;
@@ -3484,30 +3504,49 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 9 unmodified lines
3484	/* no retry on NONBLOCK nor RWF_NOWAIT */	3504	/* no retry on NONBLOCK nor RWF_NOWAIT */
3485	if (req->flags & REQ_F_NOWAIT)	3505	if (req->flags & REQ_F_NOWAIT)
3486	goto done;	3506	goto done;
3487	/* some cases will consume bytes even on error returns */
3488	iov_iter_reexpand(iter, iter->count + iter->truncated);
3489	iov_iter_revert(iter, io_size - iov_iter_count(iter));
3490	ret = 0;	3507	ret = 0;
3491	} else if (ret == -EIOCBQUEUED) {	3508	} else if (ret == -EIOCBQUEUED) {
3492	goto out_free;	3509	goto out_free;
3493	} else if (ret <= 0 \|\| ret == io_size \|\| !force_nonblock \|\|	3510	} else if (ret <= 0 \|\| ret == req->result \|\| !force_nonblock \|\|
3494	(req->flags & REQ_F_NOWAIT) \|\| !need_read_all(req)) {	3511	(req->flags & REQ_F_NOWAIT) \|\| !need_read_all(req)) {
3495	/* read all, failed, already did sync or don't want to retry */	3512	/* read all, failed, already did sync or don't want to retry */
3496	goto done;	3513	goto done;
3497	}	3514	}
3498		3515
		3516	/*
		3517	* Don't depend on the iter state matching what was consumed, or being
		3518	* untouched in case of error. Restore it and we'll advance it
		3519	* manually if we need to.
		3520	*/
		3521	iov_iter_restore(iter, state);
		3522
3499	ret2 = io_setup_async_rw(req, iovec, inline_vecs, iter, true);	3523	ret2 = io_setup_async_rw(req, iovec, inline_vecs, iter, true);
3500	if (ret2)	3524	if (ret2)
3501	return ret2;	3525	return ret2;
3502		3526
3503	iovec = NULL;	3527	iovec = NULL;
3504	rw = req->async_data;	3528	rw = req->async_data;
3505	/* now use our persistent iterator, if we aren't already */	3529	/*
3506	iter = &rw->iter;	3530	* Now use our persistent iterator and state, if we aren't already.
		3531	* We've restored and mapped the iter to match.
		3532	*/
		3533	if (iter != &rw->iter) {
		3534	iter = &rw->iter;
		3535	state = &rw->iter_state;
		3536	}
3507		3537
3508	do {	3538	do {
3509	io_size -= ret;	3539	/*
		3540	* We end up here because of a partial read, either from
		3541	* above or inside this loop. Advance the iter by the bytes
		3542	* that were consumed.
		3543	*/
		3544	iov_iter_advance(iter, ret);
		3545	if (!iov_iter_count(iter))
		3546	break;
3510	rw->bytes_done += ret;	3547	rw->bytes_done += ret;
		3548	iov_iter_save_state(iter, state);
		3549
3511	/* if we can retry, do so with the callbacks armed */	3550	/* if we can retry, do so with the callbacks armed */
3512	if (!io_rw_should_retry(req)) {	3551	if (!io_rw_should_retry(req)) {
3513	kiocb->ki_flags &= ~IOCB_WAITQ;	3552	kiocb->ki_flags &= ~IOCB_WAITQ;
@@ -3525,7 +3564,8 @@ static int io_read(struct io_kiocb *req, unsigned int issue_flags) · 11 unmodified lines
3525	return 0;	3564	return 0;
3526	/* we got some bytes, but not all. retry. */	3565	/* we got some bytes, but not all. retry. */
3527	kiocb->ki_flags &= ~IOCB_WAITQ;	3566	kiocb->ki_flags &= ~IOCB_WAITQ;
3528	} while (ret > 0 && ret < io_size);	3567	iov_iter_restore(iter, state);
		3568	} while (ret > 0);
3529	done:	3569	done:
3530	kiocb_done(kiocb, ret, issue_flags);	3570	kiocb_done(kiocb, ret, issue_flags);
3531	out_free:	3571	out_free:
@@ -3539,7 +3579,7 @@ static int io_write_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 7 unmodified lines
3539	{	3579	{
3540	if (unlikely(!(req->file->f_mode & FMODE_WRITE)))	3580	if (unlikely(!(req->file->f_mode & FMODE_WRITE)))
3541	return -EBADF;	3581	return -EBADF;
3542	return io_prep_rw(req, sqe);	3582	return io_prep_rw(req, sqe, WRITE);
3543	}	3583	}
3544		3584
3545	static int io_write(struct io_kiocb *req, unsigned int issue_flags)	3585	static int io_write(struct io_kiocb *req, unsigned int issue_flags)
@@ -3548,19 +3588,24 @@ static int io_write(struct io_kiocb *req, unsigned int issue_flags) · 2 unmodified lines
3548	struct kiocb *kiocb = &req->rw.kiocb;	3588	struct kiocb *kiocb = &req->rw.kiocb;
3549	struct iov_iter __iter, *iter = &__iter;	3589	struct iov_iter __iter, *iter = &__iter;
3550	struct io_async_rw *rw = req->async_data;	3590	struct io_async_rw *rw = req->async_data;
3551	ssize_t ret, ret2, io_size;
3552	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	3591	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
		3592	struct iov_iter_state __state, *state;
		3593	ssize_t ret, ret2;
3553		3594
3554	if (rw) {	3595	if (rw) {
3555	iter = &rw->iter;	3596	iter = &rw->iter;
		3597	state = &rw->iter_state;
		3598	iov_iter_restore(iter, state);
3556	iovec = NULL;	3599	iovec = NULL;
3557	} else {	3600	} else {
3558	ret = io_import_iovec(WRITE, req, &iovec, iter, !force_nonblock);	3601	ret = io_import_iovec(WRITE, req, &iovec, iter, !force_nonblock);
3559	if (ret < 0)	3602	if (ret < 0)
3560	return ret;	3603	return ret;
		3604	state = &__state;
		3605	iov_iter_save_state(iter, state);
3561	}	3606	}
3562	io_size = iov_iter_count(iter);	3607	req->result = iov_iter_count(iter);
3563	req->result = io_size;	3608	ret2 = 0;
3564		3609
3565	/* Ensure we clear previously set non-block flag */	3610	/* Ensure we clear previously set non-block flag */
3566	if (!force_nonblock)	3611	if (!force_nonblock)
@@ -3577,7 +3622,7 @@ static int io_write(struct io_kiocb *req, unsigned int issue_flags) · 10 unmodified lines
3577	(req->flags & REQ_F_ISREG))	3622	(req->flags & REQ_F_ISREG))
3578	goto copy_iov;	3623	goto copy_iov;
3579		3624
3580	ret = rw_verify_area(WRITE, req->file, io_kiocb_ppos(kiocb), io_size);	3625	ret = rw_verify_area(WRITE, req->file, io_kiocb_ppos(kiocb), req->result);
3581	if (unlikely(ret))	3626	if (unlikely(ret))
3582	goto out_free;	3627	goto out_free;
3583		3628
@@ -3624,9 +3669,9 @@ done: · 40 unmodified lines
3624	kiocb_done(kiocb, ret2, issue_flags);	3669	kiocb_done(kiocb, ret2, issue_flags);
3625	} else {	3670	} else {
3626	copy_iov:	3671	copy_iov:
3627	/* some cases will consume bytes even on error returns */	3672	iov_iter_restore(iter, state);
3628	iov_iter_reexpand(iter, iter->count + iter->truncated);	3673	if (ret2 > 0)
3629	iov_iter_revert(iter, io_size - iov_iter_count(iter));	3674	iov_iter_advance(iter, ret2);
3630	ret = io_setup_async_rw(req, iovec, inline_vecs, iter, false);	3675	ret = io_setup_async_rw(req, iovec, inline_vecs, iter, false);
3631	return ret ?: -EAGAIN;	3676	return ret ?: -EAGAIN;
3632	}	3677	}
@@ -7515,6 +7560,14 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events, · 3882 unmodified lines
7515	break;	7560	break;
7516	} while (1);	7561	} while (1);
7517		7562
		7563	if (uts) {
		7564	struct timespec64 ts;
		7565
		7566	if (get_timespec64(&ts, uts))
		7567	return -EFAULT;
		7568	timeout = timespec64_to_jiffies(&ts);
		7569	}
		7570
7518	if (sig) {	7571	if (sig) {
7519	#ifdef CONFIG_COMPAT	7572	#ifdef CONFIG_COMPAT
7520	if (in_compat_syscall())	7573	if (in_compat_syscall())
@@ -7528,14 +7581,6 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events, · 7 unmodified lines
7528	return ret;	7581	return ret;
7529	}	7582	}
7530		7583
7531	if (uts) {
7532	struct timespec64 ts;
7533
7534	if (get_timespec64(&ts, uts))
7535	return -EFAULT;
7536	timeout = timespec64_to_jiffies(&ts);
7537	}
7538
7539	init_waitqueue_func_entry(&iowq.wq, io_wake_function);	7584	init_waitqueue_func_entry(&iowq.wq, io_wake_function);
7540	iowq.wq.private = current;	7585	iowq.wq.private = current;
7541	INIT_LIST_HEAD(&iowq.wq.entry);	7586	INIT_LIST_HEAD(&iowq.wq.entry);
@@ -8284,11 +8329,27 @@ static int io_sqe_file_register(struct io_ring_ctx ctx, struct file file, · 742 unmodified lines
8284	#endif	8329	#endif
8285	}	8330	}
8286		8331
		8332	static int io_queue_rsrc_removal(struct io_rsrc_data *data, unsigned idx,
		8333	struct io_rsrc_node node, void rsrc)
		8334	{
		8335	struct io_rsrc_put *prsrc;
		8336
		8337	prsrc = kzalloc(sizeof(*prsrc), GFP_KERNEL);
		8338	if (!prsrc)
		8339	return -ENOMEM;
		8340
		8341	prsrc->tag = *io_get_tag_slot(data, idx);
		8342	prsrc->rsrc = rsrc;
		8343	list_add(&prsrc->list, &node->rsrc_list);
		8344	return 0;
		8345	}
		8346
8287	static int io_install_fixed_file(struct io_kiocb req, struct file file,	8347	static int io_install_fixed_file(struct io_kiocb req, struct file file,
8288	unsigned int issue_flags, u32 slot_index)	8348	unsigned int issue_flags, u32 slot_index)
8289	{	8349	{
8290	struct io_ring_ctx *ctx = req->ctx;	8350	struct io_ring_ctx *ctx = req->ctx;
8291	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;	8351	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
		8352	bool needs_switch = false;
8292	struct io_fixed_file *file_slot;	8353	struct io_fixed_file *file_slot;
8293	int ret = -EBADF;	8354	int ret = -EBADF;
8294		8355
@@ -8304,9 +8365,22 @@ static int io_install_fixed_file(struct io_kiocb req, struct file file, · 9 unmodified lines
8304		8365
8305	slot_index = array_index_nospec(slot_index, ctx->nr_user_files);	8366	slot_index = array_index_nospec(slot_index, ctx->nr_user_files);
8306	file_slot = io_fixed_file_slot(&ctx->file_table, slot_index);	8367	file_slot = io_fixed_file_slot(&ctx->file_table, slot_index);
8307	ret = -EBADF;	8368
8308	if (file_slot->file_ptr)	8369	if (file_slot->file_ptr) {
8309	goto err;	8370	struct file *old_file;
		8371
		8372	ret = io_rsrc_node_switch_start(ctx);
		8373	if (ret)
		8374	goto err;
		8375
		8376	old_file = (struct file *)(file_slot->file_ptr & FFS_MASK);
		8377	ret = io_queue_rsrc_removal(ctx->file_data, slot_index,
		8378	ctx->rsrc_node, old_file);
		8379	if (ret)
		8380	goto err;
		8381	file_slot->file_ptr = 0;
		8382	needs_switch = true;
		8383	}
8310		8384
8311	*io_get_tag_slot(ctx->file_data, slot_index) = 0;	8385	*io_get_tag_slot(ctx->file_data, slot_index) = 0;
8312	io_fixed_file_set(file_slot, file);	8386	io_fixed_file_set(file_slot, file);
@@ -8318,27 +8392,14 @@ static int io_install_fixed_file(struct io_kiocb req, struct file file, · 5 unmodified lines
8318		8392
8319	ret = 0;	8393	ret = 0;
8320	err:	8394	err:
		8395	if (needs_switch)
		8396	io_rsrc_node_switch(ctx, ctx->file_data);
8321	io_ring_submit_unlock(ctx, !force_nonblock);	8397	io_ring_submit_unlock(ctx, !force_nonblock);
8322	if (ret)	8398	if (ret)
8323	fput(file);	8399	fput(file);
8324	return ret;	8400	return ret;
8325	}	8401	}
8326		8402
8327	static int io_queue_rsrc_removal(struct io_rsrc_data *data, unsigned idx,
8328	struct io_rsrc_node node, void rsrc)
8329	{
8330	struct io_rsrc_put *prsrc;
8331
8332	prsrc = kzalloc(sizeof(*prsrc), GFP_KERNEL);
8333	if (!prsrc)
8334	return -ENOMEM;
8335
8336	prsrc->tag = *io_get_tag_slot(data, idx);
8337	prsrc->rsrc = rsrc;
8338	list_add(&prsrc->list, &node->rsrc_list);
8339	return 0;
8340	}
8341
8342	static int __io_sqe_files_update(struct io_ring_ctx *ctx,	8403	static int __io_sqe_files_update(struct io_ring_ctx *ctx,
8343	struct io_uring_rsrc_update2 *up,	8404	struct io_uring_rsrc_update2 *up,
8344	unsigned nr_args)	8405	unsigned nr_args)
@@ -10560,10 +10621,12 @@ static int io_register_iowq_max_workers(struct io_ring_ctx *ctx, · 2215 unmodified lines
10560	* ordering. Fine to drop uring_lock here, we hold	10621	* ordering. Fine to drop uring_lock here, we hold
10561	* a ref to the ctx.	10622	* a ref to the ctx.
10562	*/	10623	*/
		10624	refcount_inc(&sqd->refs);
10563	mutex_unlock(&ctx->uring_lock);	10625	mutex_unlock(&ctx->uring_lock);
10564	mutex_lock(&sqd->lock);	10626	mutex_lock(&sqd->lock);
10565	mutex_lock(&ctx->uring_lock);	10627	mutex_lock(&ctx->uring_lock);
10566	tctx = sqd->thread->io_uring;	10628	if (sqd->thread)
		10629	tctx = sqd->thread->io_uring;
10567	}	10630	}
10568	} else {	10631	} else {
10569	tctx = current->io_uring;	10632	tctx = current->io_uring;
@@ -10577,16 +10640,20 @@ static int io_register_iowq_max_workers(struct io_ring_ctx *ctx, · 7 unmodified lines
10577	if (ret)	10640	if (ret)
10578	goto err;	10641	goto err;
10579		10642
10580	if (sqd)	10643	if (sqd) {
10581	mutex_unlock(&sqd->lock);	10644	mutex_unlock(&sqd->lock);
		10645	io_put_sq_data(sqd);
		10646	}
10582		10647
10583	if (copy_to_user(arg, new_count, sizeof(new_count)))	10648	if (copy_to_user(arg, new_count, sizeof(new_count)))
10584	return -EFAULT;	10649	return -EFAULT;
10585		10650
10586	return 0;	10651	return 0;
10587	err:	10652	err:
10588	if (sqd)	10653	if (sqd) {
10589	mutex_unlock(&sqd->lock);	10654	mutex_unlock(&sqd->lock);
		10655	io_put_sq_data(sqd);
		10656	}
10590	return ret;	10657	return ret;
10591	}	10658	}
10592		10659

fs/ksmbd/misc.c+67−9

@@ -191,19 +191,77 @@ int get_nlink(struct kstat *st) · 190 unmodified lines
191	return nlink;	191	return nlink;
192	}	192	}
193		193
194	void ksmbd_conv_path_to_unix(char *path)	194	char ksmbd_conv_path_to_unix(char path)
195	{	195	{
		196	size_t path_len, remain_path_len, out_path_len;
		197	char out_path, out_next;
		198	int i, pre_dotdot_cnt = 0, slash_cnt = 0;
		199	bool is_last;
		200
196	strreplace(path, '\\', '/');	201	strreplace(path, '\\', '/');
197	}	202	path_len = strlen(path);
		203	remain_path_len = path_len;
		204	if (path_len == 0)
		205	return ERR_PTR(-EINVAL);
198		206
199	void ksmbd_strip_last_slash(char *path)	207	out_path = kzalloc(path_len + 2, GFP_KERNEL);
200	{	208	if (!out_path)
201	int len = strlen(path);	209	return ERR_PTR(-ENOMEM);
		210	out_path_len = 0;
		211	out_next = out_path;
		212
		213	do {
		214	char *name = path + path_len - remain_path_len;
		215	char *next = strchrnul(name, '/');
		216	size_t name_len = next - name;
		217
		218	is_last = !next[0];
		219	if (name_len == 2 && name[0] == '.' && name[1] == '.') {
		220	pre_dotdot_cnt++;
		221	/* handle the case that path ends with "/.." */
		222	if (is_last)
		223	goto follow_dotdot;
		224	} else {
		225	if (pre_dotdot_cnt) {
		226	follow_dotdot:
		227	slash_cnt = 0;
		228	for (i = out_path_len - 1; i >= 0; i--) {
		229	if (out_path[i] == '/' &&
		230	++slash_cnt == pre_dotdot_cnt + 1)
		231	break;
		232	}
		233
		234	if (i < 0 &&
		235	slash_cnt != pre_dotdot_cnt) {
		236	kfree(out_path);
		237	return ERR_PTR(-EINVAL);
		238	}
		239
		240	out_next = &out_path[i+1];
		241	*out_next = '\0';
		242	out_path_len = i + 1;
202		243
203	while (len && path[len - 1] == '/') {	244	}
204	path[len - 1] = '\0';	245
205	len--;	246	if (name_len != 0 &&
206	}	247	!(name_len == 1 && name[0] == '.') &&
		248	!(name_len == 2 && name[0] == '.' && name[1] == '.')) {
		249	next[0] = '\0';
		250	sprintf(out_next, "%s/", name);
		251	out_next += name_len + 1;
		252	out_path_len += name_len + 1;
		253	next[0] = '/';
		254	}
		255	pre_dotdot_cnt = 0;
		256	}
		257
		258	remain_path_len -= name_len + 1;
		259	} while (!is_last);
		260
		261	if (out_path_len > 0)
		262	out_path[out_path_len-1] = '\0';
		263	path[path_len] = '\0';
		264	return out_path;
207	}	265	}
208		266
209	void ksmbd_conv_path_to_windows(char *path)	267	void ksmbd_conv_path_to_windows(char *path)

fs/ksmbd/misc.h+1−2

 int parse_stream_name(char *filename, char **stream_name, int *s_type);
 char *convert_to_nt_pathname(char *filename, char *sharepath);
 int get_nlink(struct kstat *st);
-void ksmbd_conv_path_to_unix(char *path);
+char *ksmbd_conv_path_to_unix(char *path);
-void ksmbd_strip_last_slash(char *path);
 void ksmbd_conv_path_to_windows(char *path);
 char *ksmbd_extract_sharename(char *treename);
 char *convert_to_unix_name(struct ksmbd_share_config *share, char *name);

fs/ksmbd/smb2pdu.c+13−5

@@ -634,7 +634,7 @@ static char * · 633 unmodified lines
634	smb2_get_name(struct ksmbd_share_config share, const char src,	634	smb2_get_name(struct ksmbd_share_config share, const char src,
635	const int maxlen, struct nls_table *local_nls)	635	const int maxlen, struct nls_table *local_nls)
636	{	636	{
637	char name, unixname;	637	char name, norm_name, *unixname;
638		638
639	name = smb_strndup_from_utf16(src, maxlen, 1, local_nls);	639	name = smb_strndup_from_utf16(src, maxlen, 1, local_nls);
640	if (IS_ERR(name)) {	640	if (IS_ERR(name)) {
@@ -643,11 +643,15 @@ smb2_get_name(struct ksmbd_share_config share, const char src, · 2 unmodified lines
643	}	643	}
644		644
645	/* change it to absolute unix name */	645	/* change it to absolute unix name */
646	ksmbd_conv_path_to_unix(name);	646	norm_name = ksmbd_conv_path_to_unix(name);
647	ksmbd_strip_last_slash(name);	647	if (IS_ERR(norm_name)) {
648		648	kfree(name);
649	unixname = convert_to_unix_name(share, name);	649	return norm_name;
		650	}
650	kfree(name);	651	kfree(name);
		652
		653	unixname = convert_to_unix_name(share, norm_name);
		654	kfree(norm_name);
651	if (!unixname) {	655	if (!unixname) {
652	pr_err("can not convert absolute name\n");	656	pr_err("can not convert absolute name\n");
653	return ERR_PTR(-ENOMEM);	657	return ERR_PTR(-ENOMEM);
@@ -4041,6 +4045,10 @@ static int smb2_get_ea(struct ksmbd_work work, struct ksmbd_file fp, · 3387 unmodified lines
4041	path = &fp->filp->f_path;	4045	path = &fp->filp->f_path;
4042	/* single EA entry is requested with given user.* name */	4046	/* single EA entry is requested with given user.* name */
4043	if (req->InputBufferLength) {	4047	if (req->InputBufferLength) {
		4048	if (le32_to_cpu(req->InputBufferLength) <
		4049	sizeof(struct smb2_ea_info_req))
		4050	return -EINVAL;
		4051
4044	ea_req = (struct smb2_ea_info_req *)req->Buffer;	4052	ea_req = (struct smb2_ea_info_req *)req->Buffer;
4045	} else {	4053	} else {
4046	/* need to send all EAs, if no specific EA is requested*/	4054	/* need to send all EAs, if no specific EA is requested*/

fs/ksmbd/transport_rdma.c+0−1

@@ -20,7 +20,6 @@ · 19 unmodified lines
20	#define SUBMOD_NAME "smb_direct"	20	#define SUBMOD_NAME "smb_direct"
21		21
22	#include <linux/kthread.h>	22	#include <linux/kthread.h>
23	#include <linux/rwlock.h>
24	#include <linux/list.h>	23	#include <linux/list.h>
25	#include <linux/mempool.h>	24	#include <linux/mempool.h>
26	#include <linux/highmem.h>	25	#include <linux/highmem.h>

fs/lockd/svcxdr.h+2−11

 static inline bool
 svcxdr_encode_owner(struct xdr_stream *xdr, const struct xdr_netobj *obj)
 {
-	unsigned int quadlen = XDR_QUADLEN(obj->len);
+	if (obj->len > XDR_MAX_NETOBJ)
-	__be32 *p;
-	if (xdr_stream_encode_u32(xdr, obj->len) < 0)
-		return false;
-	p = xdr_reserve_space(xdr, obj->len);
-	if (!p)
 		return false;
-	p[quadlen - 1] = 0;	/* XDR pad */
+	return xdr_stream_encode_opaque(xdr, obj->data, obj->len) > 0;
-	memcpy(p, obj->data, obj->len);
-	return true;
 }
 #endif /* _LOCKD_SVCXDR_H_ */

fs/nfsd/nfs4state.c+13−3

 }
 static __be32 nfsd4_match_existing_connection(struct svc_rqst *rqst,
-				struct nfsd4_session *session, u32 req)
+		struct nfsd4_session *session, u32 req, struct nfsd4_conn **conn)
 {
 	struct nfs4_client *clp = session->se_client;
 	struct svc_xprt *xpt = rqst->rq_xprt;
 	else
 		status = nfserr_inval;
 	spin_unlock(&clp->cl_lock);
+	if (status == nfs_ok && conn)
+		*conn = c;
 	return status;
 }
 	status = nfserr_wrong_cred;
 	if (!nfsd4_mach_creds_match(session->se_client, rqstp))
 		goto out;
-	status = nfsd4_match_existing_connection(rqstp, session, bcts->dir);
+	status = nfsd4_match_existing_connection(rqstp, session,
-	if (status == nfs_ok || status == nfserr_inval)
+			bcts->dir, &conn);
+	if (status == nfs_ok) {
+		if (bcts->dir == NFS4_CDFC4_FORE_OR_BOTH ||
+				bcts->dir == NFS4_CDFC4_BACK)
+			conn->cn_flags |= NFS4_CDFC4_BACK;
+		nfsd4_probe_callback(session->se_client);
+		goto out;
+	}
+	if (status == nfserr_inval)
 		goto out;
 	status = nfsd4_map_bcts_dir(&bcts->dir);
 	if (status)

fs/qnx4/dir.c+27−9

  * depending on the status field in the last byte. The
  * first byte is where the name start either way, and a
  * zero means it's empty.
+ *
+ * Also, due to a bug in gcc, we don't want to use the
+ * real (differently sized) name arrays in the inode and
+ * link entries, but always the 'de_name[]' one in the
+ * fake struct entry.
+ *
+ * See
+ *
+ *   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99578#c6
+ *
+ * for details, but basically gcc will take the size of the
+ * 'name' array from one of the used union entries randomly.
+ *
+ * This use of 'de_name[]' (48 bytes) avoids the false positive
+ * warnings that would happen if gcc decides to use 'inode.di_name'
+ * (16 bytes) even when the pointer and size were to come from
+ * 'link.dl_name' (48 bytes).
+ *
+ * In all cases the actual name pointer itself is the same, it's
+ * only the gcc internal 'what is the size of this field' logic
+ * that can get confused.
  */
 union qnx4_directory_entry {
 	struct {
-		char de_name;
+		const char de_name[48];
-		char de_pad[62];
+		u8 de_pad[15];
-		char de_status;
+		u8 de_status;
 	};
 	struct qnx4_inode_entry inode;
 	struct qnx4_link_info link;
 		ix = (ctx->pos >> QNX4_DIR_ENTRY_SIZE_BITS) % QNX4_INODES_PER_BLOCK;
 		for (; ix < QNX4_INODES_PER_BLOCK; ix++, ctx->pos += QNX4_DIR_ENTRY_SIZE) {
 			union qnx4_directory_entry *de;
-			const char *name;
 			offset = ix * QNX4_DIR_ENTRY_SIZE;
 			de = (union qnx4_directory_entry *) (bh->b_data + offset);
-			if (!de->de_name)
+			if (!de->de_name[0])
 				continue;
 			if (!(de->de_status & (QNX4_FILE_USED|QNX4_FILE_LINK)))
 				continue;
 			if (!(de->de_status & QNX4_FILE_LINK)) {
 				size = sizeof(de->inode.di_fname);
-				name = de->inode.di_fname;
 				ino = blknum * QNX4_INODES_PER_BLOCK + ix - 1;
 			} else {
 				size = sizeof(de->link.dl_fname);
-				name = de->link.dl_fname;
 				ino = ( le32_to_cpu(de->link.dl_inode_blk) - 1 ) *
 					QNX4_INODES_PER_BLOCK +
 					de->link.dl_inode_ndx;
 			}
-			size = strnlen(name, size);
+			size = strnlen(de->de_name, size);
 			QNX4DEBUG((KERN_INFO "qnx4_readdir:%.*s\n", size, name));
-			if (!dir_emit(ctx, name, size, ino, DT_UNKNOWN)) {
+			if (!dir_emit(ctx, de->de_name, size, ino, DT_UNKNOWN)) {
 				brelse(bh);
 				return 0;
 			}

fs/smbfs_common/smbfsctl.h+1−1

@@ -1,6 +1,6 @@
1	/* SPDX-License-Identifier: LGPL-2.1+ */	1	/* SPDX-License-Identifier: LGPL-2.1+ */
2	/*	2	/*
3	* fs/cifs/smbfsctl.h: SMB, CIFS, SMB2 FSCTL definitions	3	* SMB, CIFS, SMB2 FSCTL definitions
4	*	4	*
5	* Copyright (c) International Business Machines Corp., 2002,2013	5	* Copyright (c) International Business Machines Corp., 2002,2013
6	* Author(s): Steve French (sfrench@us.ibm.com)	6	* Author(s): Steve French (sfrench@us.ibm.com)

include/asm-generic/io.h+3−23

@@ -1023,16 +1023,7 @@ static inline void __iomem *ioport_map(unsigned long port, unsigned int nr) · 1022 unmodified lines
1023	port &= IO_SPACE_LIMIT;	1023	port &= IO_SPACE_LIMIT;
1024	return (port > MMIO_UPPER_LIMIT) ? NULL : PCI_IOBASE + port;	1024	return (port > MMIO_UPPER_LIMIT) ? NULL : PCI_IOBASE + port;
1025	}	1025	}
1026	#define __pci_ioport_unmap __pci_ioport_unmap	1026	#define ARCH_HAS_GENERIC_IOPORT_MAP
1027	static inline void __pci_ioport_unmap(void __iomem *p)
1028	{
1029	uintptr_t start = (uintptr_t) PCI_IOBASE;
1030	uintptr_t addr = (uintptr_t) p;
1031
1032	if (addr >= start && addr < start + IO_SPACE_LIMIT)
1033	return;
1034	iounmap(p);
1035	}
1036	#endif	1027	#endif
1037		1028
1038	#ifndef ioport_unmap	1029	#ifndef ioport_unmap
@@ -1048,21 +1039,10 @@ extern void ioport_unmap(void __iomem *p); · 9 unmodified lines
1048	#endif /* CONFIG_HAS_IOPORT_MAP */	1039	#endif /* CONFIG_HAS_IOPORT_MAP */
1049		1040
1050	#ifndef CONFIG_GENERIC_IOMAP	1041	#ifndef CONFIG_GENERIC_IOMAP
1051	struct pci_dev;
1052	extern void __iomem pci_iomap(struct pci_dev dev, int bar, unsigned long max);
1053
1054	#ifndef __pci_ioport_unmap
1055	static inline void __pci_ioport_unmap(void __iomem *p) {}
1056	#endif
1057
1058	#ifndef pci_iounmap	1042	#ifndef pci_iounmap
1059	#define pci_iounmap pci_iounmap	1043	#define ARCH_WANTS_GENERIC_PCI_IOUNMAP
1060	static inline void pci_iounmap(struct pci_dev dev, void __iomem p)	1044	#endif
1061	{
1062	__pci_ioport_unmap(p);
1063	}
1064	#endif	1045	#endif
1065	#endif /* CONFIG_GENERIC_IOMAP */
1066		1046
1067	#ifndef xlate_dev_mem_ptr	1047	#ifndef xlate_dev_mem_ptr
1068	#define xlate_dev_mem_ptr xlate_dev_mem_ptr	1048	#define xlate_dev_mem_ptr xlate_dev_mem_ptr

include/asm-generic/iomap.h+0−10

@@ -110,16 +110,6 @@ static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size) · 109 unmodified lines
110	}	110	}
111	#endif	111	#endif
112		112
113	#ifdef CONFIG_PCI
114	/* Destroy a virtual mapping cookie for a PCI BAR (memory or IO) */
115	struct pci_dev;
116	extern void pci_iounmap(struct pci_dev dev, void __iomem );
117	#elif defined(CONFIG_GENERIC_IOMAP)
118	struct pci_dev;
119	static inline void pci_iounmap(struct pci_dev dev, void __iomem addr)
120	{ }
121	#endif
122
123	#include <asm-generic/pci_iomap.h>	113	#include <asm-generic/pci_iomap.h>
124		114
125	#endif	115	#endif

include/asm-generic/pci_iomap.h+3−0

 extern void __iomem *pci_iomap_wc_range(struct pci_dev *dev, int bar,
 					unsigned long offset,
 					unsigned long maxlen);
+extern void pci_iounmap(struct pci_dev *dev, void __iomem *);
 /* Create a virtual mapping cookie for a port on a given PCI device.
  * Do not call this directly, it exists to make it easier for architectures
  * to override */
 {
 	return NULL;
 }
+static inline void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
+{ }
 #endif
 #endif /* __ASM_GENERIC_PCI_IOMAP_H */

include/linux/dsa/ocelot.h+1−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0
2	* Copyright 2019-2021 NXP Semiconductors	2	* Copyright 2019-2021 NXP
3	*/	3	*/
4		4
5	#ifndef _NET_DSA_TAG_OCELOT_H	5	#ifndef _NET_DSA_TAG_OCELOT_H

include/linux/mdio.h+3−0

@@ -80,6 +80,9 @@ struct mdio_driver { · 79 unmodified lines
80		80
81	/* Clears up any memory if needed */	81	/* Clears up any memory if needed */
82	void (remove)(struct mdio_device mdiodev);	82	void (remove)(struct mdio_device mdiodev);
		83
		84	/* Quiesces the device on system shutdown, turns off interrupts etc */
		85	void (shutdown)(struct mdio_device mdiodev);
83	};	86	};
84		87
85	static inline struct mdio_driver *	88	static inline struct mdio_driver *

include/linux/packing.h+1−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: BSD-3-Clause	1	/* SPDX-License-Identifier: BSD-3-Clause
2	* Copyright (c) 2016-2018, NXP Semiconductors	2	* Copyright 2016-2018 NXP
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#ifndef _LINUX_PACKING_H	5	#ifndef _LINUX_PACKING_H

include/linux/sched.h+1−0

@@ -1471,6 +1471,7 @@ struct task_struct { · 1470 unmodified lines
1471	mce_whole_page : 1,	1471	mce_whole_page : 1,
1472	__mce_reserved : 62;	1472	__mce_reserved : 62;
1473	struct callback_head mce_kill_me;	1473	struct callback_head mce_kill_me;
		1474	int mce_count;
1474	#endif	1475	#endif
1475		1476
1476	#ifdef CONFIG_KRETPROBES	1477	#ifdef CONFIG_KRETPROBES

include/linux/uio.h+16−5

 	ITER_DISCARD,
 };
+struct iov_iter_state {
+	size_t iov_offset;
+	size_t count;
+	unsigned long nr_segs;
+};
 struct iov_iter {
 	u8 iter_type;
 	bool data_source;
 		};
 		loff_t xarray_start;
 	};
-	size_t truncated;
 };
 static inline enum iter_type iov_iter_type(const struct iov_iter *i)
 	return i->iter_type;
 }
+static inline void iov_iter_save_state(struct iov_iter *iter,
+				       struct iov_iter_state *state)
+{
+	state->iov_offset = iter->iov_offset;
+	state->count = iter->count;
+	state->nr_segs = iter->nr_segs;
+}
 static inline bool iter_is_iovec(const struct iov_iter *i)
 {
 	return iov_iter_type(i) == ITER_IOVEC;
 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
 			size_t maxsize, size_t *start);
 int iov_iter_npages(const struct iov_iter *i, int maxpages);
+void iov_iter_restore(struct iov_iter *i, struct iov_iter_state *state);
 const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags);
 	 * conversion in assignement is by definition greater than all
 	 * values of size_t, including old i->count.
 	 */
-	if (i->count > count) {
+	if (i->count > count)
-		i->truncated += i->count - count;
 		i->count = count;
-	}
 }
 /*
  */
 static inline void iov_iter_reexpand(struct iov_iter *i, size_t count)
 {
-	i->truncated -= count - i->count;
 	i->count = count;
 }

include/net/dsa.h+9−0

 	int	(*change_tag_protocol)(struct dsa_switch *ds, int port,
 				       enum dsa_tag_protocol proto);
+	/* Optional switch-wide initialization and destruction methods */
 	int	(*setup)(struct dsa_switch *ds);
 	void	(*teardown)(struct dsa_switch *ds);
+	/* Per-port initialization and destruction methods. Mandatory if the
+	 * driver registers devlink port regions, optional otherwise.
+	 */
+	int	(*port_setup)(struct dsa_switch *ds, int port);
+	void	(*port_teardown)(struct dsa_switch *ds, int port);
 	u32	(*get_phy_flags)(struct dsa_switch *ds, int port);
 	/*
 void dsa_unregister_switch(struct dsa_switch *ds);
 int dsa_register_switch(struct dsa_switch *ds);
+void dsa_switch_shutdown(struct dsa_switch *ds);
 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index);
 #ifdef CONFIG_PM_SLEEP
 int dsa_switch_suspend(struct dsa_switch *ds);

include/net/sock.h+1−0

@@ -1628,6 +1628,7 @@ static inline void unlock_sock_fast(struct sock *sk, bool slow) · 1627 unmodified lines
1628	release_sock(sk);	1628	release_sock(sk);
1629	__release(&sk->sk_lock.slock);	1629	__release(&sk->sk_lock.slock);
1630	} else {	1630	} else {
		1631	mutex_release(&sk->sk_lock.dep_map, _RET_IP_);
1631	spin_unlock_bh(&sk->sk_lock.slock);	1632	spin_unlock_bh(&sk->sk_lock.slock);
1632	}	1633	}
1633	}	1634	}

include/trace/events/afs.h+6−2

 enum afs_cb_break_reason {
 	afs_cb_break_no_break,
+	afs_cb_break_no_promise,
 	afs_cb_break_for_callback,
 	afs_cb_break_for_deleted,
 	afs_cb_break_for_lapsed,
+	afs_cb_break_for_s_reinit,
 	afs_cb_break_for_unlink,
-	afs_cb_break_for_vsbreak,
+	afs_cb_break_for_v_break,
 	afs_cb_break_for_volume_callback,
 	afs_cb_break_for_zap,
 };
 #define afs_cb_break_reasons						\
 	EM(afs_cb_break_no_break,		"no-break")		\
+	EM(afs_cb_break_no_promise,		"no-promise")		\
 	EM(afs_cb_break_for_callback,		"break-cb")		\
 	EM(afs_cb_break_for_deleted,		"break-del")		\
 	EM(afs_cb_break_for_lapsed,		"break-lapsed")		\
+	EM(afs_cb_break_for_s_reinit,		"s-reinit")		\
 	EM(afs_cb_break_for_unlink,		"break-unlink")		\
-	EM(afs_cb_break_for_vsbreak,		"break-vs")		\
+	EM(afs_cb_break_for_v_break,		"break-v")		\
 	EM(afs_cb_break_for_volume_callback,	"break-v-cb")		\
 	E_(afs_cb_break_for_zap,		"break-zap")

include/uapi/linux/cifs/cifs_mount.h+0−1

@@ -1,6 +1,5 @@
1	/* SPDX-License-Identifier: LGPL-2.1+ WITH Linux-syscall-note */	1	/* SPDX-License-Identifier: LGPL-2.1+ WITH Linux-syscall-note */
2	/*	2	/*
3	* include/uapi/linux/cifs/cifs_mount.h
4	*	3	*
5	* Author(s): Scott Lovenberg (scott.lovenberg@gmail.com)	4	* Author(s): Scott Lovenberg (scott.lovenberg@gmail.com)
6	*	5	*

include/uapi/linux/io_uring.h+7−1

 	IORING_REGISTER_IOWQ_AFF		= 17,
 	IORING_UNREGISTER_IOWQ_AFF		= 18,
-	/* set/get max number of workers */
+	/* set/get max number of io-wq workers */
 	IORING_REGISTER_IOWQ_MAX_WORKERS	= 19,
 	/* this goes last */
 	IORING_REGISTER_LAST
 };
+/* io-wq worker categories */
+enum {
+	IO_WQ_BOUND,
+	IO_WQ_UNBOUND,
+};
 /* deprecated, see struct io_uring_rsrc_update */
 struct io_uring_files_update {
 	__u32 offset;

init/main.c+3−3

@@ -1242,7 +1242,7 @@ trace_initcall_start_cb(void *data, initcall_t fn) · 1241 unmodified lines
1242	{	1242	{
1243	ktime_t calltime = (ktime_t )data;	1243	ktime_t calltime = (ktime_t )data;
1244		1244
1245	printk(KERN_DEBUG "calling %pS @ %i irqs_disabled() %d\n", fn, task_pid_nr(current), irqs_disabled());	1245	printk(KERN_DEBUG "calling %pS @ %i\n", fn, task_pid_nr(current));
1246	*calltime = ktime_get();	1246	*calltime = ktime_get();
1247	}	1247	}
1248		1248
@@ -1256,8 +1256,8 @@ trace_initcall_finish_cb(void *data, initcall_t fn, int ret) · 7 unmodified lines
1256	rettime = ktime_get();	1256	rettime = ktime_get();
1257	delta = ktime_sub(rettime, *calltime);	1257	delta = ktime_sub(rettime, *calltime);
1258	duration = (unsigned long long) ktime_to_ns(delta) >> 10;	1258	duration = (unsigned long long) ktime_to_ns(delta) >> 10;
1259	printk(KERN_DEBUG "initcall %pS returned %d after %lld usecs, irqs_disabled() %d\n",	1259	printk(KERN_DEBUG "initcall %pS returned %d after %lld usecs\n",
1260	fn, ret, duration, irqs_disabled());	1260	fn, ret, duration);
1261	}	1261	}
1262		1262
1263	static ktime_t initcall_calltime;	1263	static ktime_t initcall_calltime;

kernel/dma/debug.c+2−1

@@ -567,7 +567,8 @@ static void add_dma_entry(struct dma_debug_entry *entry) · 566 unmodified lines
567	pr_err("cacheline tracking ENOMEM, dma-debug disabled\n");	567	pr_err("cacheline tracking ENOMEM, dma-debug disabled\n");
568	global_disable = true;	568	global_disable = true;
569	} else if (rc == -EEXIST) {	569	} else if (rc == -EEXIST) {
570	pr_err("cacheline tracking EEXIST, overlapping mappings aren't supported\n");	570	err_printk(entry->dev, entry,
		571	"cacheline tracking EEXIST, overlapping mappings aren't supported\n");
571	}	572	}
572	}	573	}
573		574

kernel/dma/mapping.c+2−1

 /**
  * dma_map_sg_attrs - Map the given buffer for DMA
  * @dev:	The device for which to perform the DMA operation
- * @sg:	The sg_table object describing the buffer
+ * @sg:		The sg_table object describing the buffer
+ * @nents:	Number of entries to map
  * @dir:	DMA direction
  * @attrs:	Optional DMA attributes for the map operation
  *

kernel/events/core.c+1−1

@@ -10193,7 +10193,7 @@ static void perf_event_addr_filters_apply(struct perf_event *event) · 10192 unmodified lines
10193	return;	10193	return;
10194		10194
10195	if (ifh->nr_file_filters) {	10195	if (ifh->nr_file_filters) {
10196	mm = get_task_mm(event->ctx->task);	10196	mm = get_task_mm(task);
10197	if (!mm)	10197	if (!mm)
10198	goto restart;	10198	goto restart;
10199		10199

kernel/locking/rwbase_rt.c+45−20

  * The risk of writer starvation is there, but the pathological use cases
  * which trigger it are not necessarily the typical RT workloads.
  *
+ * Fast-path orderings:
+ * The lock/unlock of readers can run in fast paths: lock and unlock are only
+ * atomic ops, and there is no inner lock to provide ACQUIRE and RELEASE
+ * semantics of rwbase_rt. Atomic ops should thus provide _acquire()
+ * and _release() (or stronger).
+ *
  * Common code shared between RT rw_semaphore and rwlock
  */
 	 * set.
 	 */
 	for (r = atomic_read(&rwb->readers); r < 0;) {
+		/* Fully-ordered if cmpxchg() succeeds, provides ACQUIRE */
 		if (likely(atomic_try_cmpxchg(&rwb->readers, &r, r + 1)))
 			return 1;
 	}
 	/*
 	 * rwb->readers can only hit 0 when a writer is waiting for the
 	 * active readers to leave the critical section.
+	 *
+	 * dec_and_test() is fully ordered, provides RELEASE.
 	 */
 	if (unlikely(atomic_dec_and_test(&rwb->readers)))
 		__rwbase_read_unlock(rwb, state);
 {
 	struct rt_mutex_base *rtm = &rwb->rtmutex;
-	atomic_add(READER_BIAS - bias, &rwb->readers);
+	/*
+	 * _release() is needed in case that reader is in fast path, pairing
+	 * with atomic_try_cmpxchg() in rwbase_read_trylock(), provides RELEASE
+	 */
+	(void)atomic_add_return_release(READER_BIAS - bias, &rwb->readers);
 	raw_spin_unlock_irqrestore(&rtm->wait_lock, flags);
 	rwbase_rtmutex_unlock(rtm);
 }
 	__rwbase_write_unlock(rwb, WRITER_BIAS - 1, flags);
 }
+static inline bool __rwbase_write_trylock(struct rwbase_rt *rwb)
+{
+	/* Can do without CAS because we're serialized by wait_lock. */
+	lockdep_assert_held(&rwb->rtmutex.wait_lock);
+	/*
+	 * _acquire is needed in case the reader is in the fast path, pairing
+	 * with rwbase_read_unlock(), provides ACQUIRE.
+	 */
+	if (!atomic_read_acquire(&rwb->readers)) {
+		atomic_set(&rwb->readers, WRITER_BIAS);
+		return 1;
+	}
+	return 0;
+}
 static int __sched rwbase_write_lock(struct rwbase_rt *rwb,
 				     unsigned int state)
 {
 	atomic_sub(READER_BIAS, &rwb->readers);
 	raw_spin_lock_irqsave(&rtm->wait_lock, flags);
-	/*
+	if (__rwbase_write_trylock(rwb))
-	 * set_current_state() for rw_semaphore
+		goto out_unlock;
-	 * current_save_and_set_rtlock_wait_state() for rwlock
-	 */
-	rwbase_set_and_save_current_state(state);
-	/* Block until all readers have left the critical section. */
+	rwbase_set_and_save_current_state(state);
-	for (; atomic_read(&rwb->readers);) {
+	for (;;) {
 		/* Optimized out for rwlocks */
 		if (rwbase_signal_pending_state(state, current)) {
-			__set_current_state(TASK_RUNNING);
+			rwbase_restore_current_state();
 			__rwbase_write_unlock(rwb, 0, flags);
 			return -EINTR;
 		}
+		if (__rwbase_write_trylock(rwb))
+			break;
 		raw_spin_unlock_irqrestore(&rtm->wait_lock, flags);
+		rwbase_schedule();
+		raw_spin_lock_irqsave(&rtm->wait_lock, flags);
-		/*
-		 * Schedule and wait for the readers to leave the critical
-		 * section. The last reader leaving it wakes the waiter.
-		 */
-		if (atomic_read(&rwb->readers) != 0)
-			rwbase_schedule();
 		set_current_state(state);
-		raw_spin_lock_irqsave(&rtm->wait_lock, flags);
 	}
-	atomic_set(&rwb->readers, WRITER_BIAS);
 	rwbase_restore_current_state();
+out_unlock:
 	raw_spin_unlock_irqrestore(&rtm->wait_lock, flags);
 	return 0;
 }
 	atomic_sub(READER_BIAS, &rwb->readers);
 	raw_spin_lock_irqsave(&rtm->wait_lock, flags);
-	if (!atomic_read(&rwb->readers)) {
+	if (__rwbase_write_trylock(rwb)) {
-		atomic_set(&rwb->readers, WRITER_BIAS);
 		raw_spin_unlock_irqrestore(&rtm->wait_lock, flags);
 		return 1;
 	}

lib/iov_iter.c+36−0

@@ -1972,3 +1972,39 @@ int import_single_range(int rw, void __user *buf, size_t len, · 1971 unmodified lines
1972	return 0;	1972	return 0;
1973	}	1973	}
1974	EXPORT_SYMBOL(import_single_range);	1974	EXPORT_SYMBOL(import_single_range);
		1975
		1976	/**
		1977	* iov_iter_restore() - Restore a &struct iov_iter to the same state as when
		1978	* iov_iter_save_state() was called.
		1979	*
		1980	* @i: &struct iov_iter to restore
		1981	* @state: state to restore from
		1982	*
		1983	* Used after iov_iter_save_state() to bring restore @i, if operations may
		1984	* have advanced it.
		1985	*
		1986	* Note: only works on ITER_IOVEC, ITER_BVEC, and ITER_KVEC
		1987	*/
		1988	void iov_iter_restore(struct iov_iter i, struct iov_iter_state state)
		1989	{
		1990	if (WARN_ON_ONCE(!iov_iter_is_bvec(i) && !iter_is_iovec(i)) &&
		1991	!iov_iter_is_kvec(i))
		1992	return;
		1993	i->iov_offset = state->iov_offset;
		1994	i->count = state->count;
		1995	/*
		1996	* For the *vec iters, nr_segs + iov is constant - if we increment
		1997	* the vec, then we also decrement the nr_segs count. Hence we don't
		1998	* need to track both of these, just one is enough and we can deduct
		1999	* the other from that. ITER_KVEC and ITER_IOVEC are the same struct
		2000	* size, so we can just increment the iov pointer as they are unionzed.
		2001	* ITER_BVEC _may_ be the same size on some archs, but on others it is
		2002	* not. Be safe and handle it separately.
		2003	*/
		2004	BUILD_BUG_ON(sizeof(struct iovec) != sizeof(struct kvec));
		2005	if (iov_iter_is_bvec(i))
		2006	i->bvec -= state->nr_segs - i->nr_segs;
		2007	else
		2008	i->iov -= state->nr_segs - i->nr_segs;
		2009	i->nr_segs = state->nr_segs;
		2010	}

lib/packing.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2	/* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright 2016-2018 NXP
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#include <linux/packing.h>	5	#include <linux/packing.h>

lib/pci_iomap.c+43−0

@@ -134,4 +134,47 @@ void __iomem pci_iomap_wc(struct pci_dev dev, int bar, unsigned long maxlen) · 133 unmodified lines
134	return pci_iomap_wc_range(dev, bar, 0, maxlen);	134	return pci_iomap_wc_range(dev, bar, 0, maxlen);
135	}	135	}
136	EXPORT_SYMBOL_GPL(pci_iomap_wc);	136	EXPORT_SYMBOL_GPL(pci_iomap_wc);
		137
		138	/*
		139	* pci_iounmap() somewhat illogically comes from lib/iomap.c for the
		140	* CONFIG_GENERIC_IOMAP case, because that's the code that knows about
		141	* the different IOMAP ranges.
		142	*
		143	* But if the architecture does not use the generic iomap code, and if
		144	* it has _not_ defined it's own private pci_iounmap function, we define
		145	* it here.
		146	*
		147	* NOTE! This default implementation assumes that if the architecture
		148	* support ioport mapping (HAS_IOPORT_MAP), the ioport mapping will
		149	* be fixed to the range [ PCI_IOBASE, PCI_IOBASE+IO_SPACE_LIMIT [,
		150	* and does not need unmapping with 'ioport_unmap()'.
		151	*
		152	* If you have different rules for your architecture, you need to
		153	* implement your own pci_iounmap() that knows the rules for where
		154	* and how IO vs MEM get mapped.
		155	*
		156	* This code is odd, and the ARCH_HAS/ARCH_WANTS #define logic comes
		157	* from legacy <asm-generic/io.h> header file behavior. In particular,
		158	* it would seem to make sense to do the iounmap(p) for the non-IO-space
		159	* case here regardless, but that's not what the old header file code
		160	* did. Probably incorrectly, but this is meant to be bug-for-bug
		161	* compatible.
		162	*/
		163	#if defined(ARCH_WANTS_GENERIC_PCI_IOUNMAP)
		164
		165	void pci_iounmap(struct pci_dev dev, void __iomem p)
		166	{
		167	#ifdef ARCH_HAS_GENERIC_IOPORT_MAP
		168	uintptr_t start = (uintptr_t) PCI_IOBASE;
		169	uintptr_t addr = (uintptr_t) p;
		170
		171	if (addr >= start && addr < start + IO_SPACE_LIMIT)
		172	return;
		173	iounmap(p);
		174	#endif
		175	}
		176	EXPORT_SYMBOL(pci_iounmap);
		177
		178	#endif /* ARCH_WANTS_GENERIC_PCI_IOUNMAP */
		179
137	#endif /* CONFIG_PCI */	180	#endif /* CONFIG_PCI */

mm/memcontrol.c+0−10

 /* memcg and lruvec stats flushing */
 static void flush_memcg_stats_dwork(struct work_struct *w);
 static DECLARE_DEFERRABLE_WORK(stats_flush_dwork, flush_memcg_stats_dwork);
-static void flush_memcg_stats_work(struct work_struct *w);
-static DECLARE_WORK(stats_flush_work, flush_memcg_stats_work);
-static DEFINE_PER_CPU(unsigned int, stats_flush_threshold);
 static DEFINE_SPINLOCK(stats_flush_lock);
 #define THRESHOLDS_EVENTS_TARGET 128
 	/* Update lruvec */
 	__this_cpu_add(pn->lruvec_stats_percpu->state[idx], val);
-	if (!(__this_cpu_inc_return(stats_flush_threshold) % MEMCG_CHARGE_BATCH))
-		queue_work(system_unbound_wq, &stats_flush_work);
 }
 /**
 	queue_delayed_work(system_unbound_wq, &stats_flush_dwork, 2UL*HZ);
 }
-static void flush_memcg_stats_work(struct work_struct *w)
-{
-	mem_cgroup_flush_stats();
-}
 static void mem_cgroup_css_rstat_flush(struct cgroup_subsys_state *css, int cpu)
 {
 	struct mem_cgroup *memcg = mem_cgroup_from_css(css);

mm/memory.c+1−0

@@ -3403,6 +3403,7 @@ void unmap_mapping_pages(struct address_space *mapping, pgoff_t start, · 3402 unmodified lines
3403	unmap_mapping_range_tree(&mapping->i_mmap, &details);	3403	unmap_mapping_range_tree(&mapping->i_mmap, &details);
3404	i_mmap_unlock_write(mapping);	3404	i_mmap_unlock_write(mapping);
3405	}	3405	}
		3406	EXPORT_SYMBOL_GPL(unmap_mapping_pages);
3406		3407
3407	/**	3408	/**
3408	* unmap_mapping_range - unmap the portion of all mmaps in the specified	3409	* unmap_mapping_range - unmap the portion of all mmaps in the specified

mm/workingset.c+1−0

@@ -352,6 +352,7 @@ void workingset_refault(struct page page, void shadow) · 351 unmodified lines
352		352
353	inc_lruvec_state(lruvec, WORKINGSET_REFAULT_BASE + file);	353	inc_lruvec_state(lruvec, WORKINGSET_REFAULT_BASE + file);
354		354
		355	mem_cgroup_flush_stats();
355	/*	356	/*
356	* Compare the distance to the existing workingset size. We	357	* Compare the distance to the existing workingset size. We
357	* don't activate pages that couldn't stay resident even if	358	* don't activate pages that couldn't stay resident even if

net/core/dev.c+10−6

@@ -6925,12 +6925,16 @@ EXPORT_SYMBOL(napi_disable); · 6924 unmodified lines
6925	*/	6925	*/
6926	void napi_enable(struct napi_struct *n)	6926	void napi_enable(struct napi_struct *n)
6927	{	6927	{
6928	BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));	6928	unsigned long val, new;
6929	smp_mb__before_atomic();	6929
6930	clear_bit(NAPI_STATE_SCHED, &n->state);	6930	do {
6931	clear_bit(NAPI_STATE_NPSVC, &n->state);	6931	val = READ_ONCE(n->state);
6932	if (n->dev->threaded && n->thread)	6932	BUG_ON(!test_bit(NAPI_STATE_SCHED, &val));
6933	set_bit(NAPI_STATE_THREADED, &n->state);	6933
		6934	new = val & ~(NAPIF_STATE_SCHED \| NAPIF_STATE_NPSVC);
		6935	if (n->dev->threaded && n->thread)
		6936	new \|= NAPIF_STATE_THREADED;
		6937	} while (cmpxchg(&n->state, val, new) != val);
6934	}	6938	}
6935	EXPORT_SYMBOL(napi_enable);	6939	EXPORT_SYMBOL(napi_enable);
6936		6940

net/core/sock.c+23−14

 void lock_sock_nested(struct sock *sk, int subclass)
 {
+	/* The sk_lock has mutex_lock() semantics here. */
+	mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
 	might_sleep();
 	spin_lock_bh(&sk->sk_lock.slock);
 	if (sk->sk_lock.owned)
 		__lock_sock(sk);
 	sk->sk_lock.owned = 1;
-	spin_unlock(&sk->sk_lock.slock);
+	spin_unlock_bh(&sk->sk_lock.slock);
-	/*
-	 * The sk_lock has mutex_lock() semantics here:
-	 */
-	mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
-	local_bh_enable();
 }
 EXPORT_SYMBOL(lock_sock_nested);
  */
 bool lock_sock_fast(struct sock *sk) __acquires(&sk->sk_lock.slock)
 {
+	/* The sk_lock has mutex_lock() semantics here. */
+	mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
 	might_sleep();
 	spin_lock_bh(&sk->sk_lock.slock);
-	if (!sk->sk_lock.owned)
+	if (!sk->sk_lock.owned) {
 		/*
-		 * Note : We must disable BH
+		 * Fast path return with bottom halves disabled and
+		 * sock::sk_lock.slock held.
+		 *
+		 * The 'mutex' is not contended and holding
+		 * sock::sk_lock.slock prevents all other lockers to
+		 * proceed so the corresponding unlock_sock_fast() can
+		 * avoid the slow path of release_sock() completely and
+		 * just release slock.
+		 *
+		 * From a semantical POV this is equivalent to 'acquiring'
+		 * the 'mutex', hence the corresponding lockdep
+		 * mutex_release() has to happen in the fast path of
+		 * unlock_sock_fast().
 		 */
 		return false;
+	}
 	__lock_sock(sk);
 	sk->sk_lock.owned = 1;
-	spin_unlock(&sk->sk_lock.slock);
-	/*
-	 * The sk_lock has mutex_lock() semantics here:
-	 */
-	mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
 	__acquire(&sk->sk_lock.slock);
-	local_bh_enable();
+	spin_unlock_bh(&sk->sk_lock.slock);
 	return true;
 }
 EXPORT_SYMBOL(lock_sock_fast);

net/dsa/dsa2.c+106−8

@@ -429,6 +429,7 @@ static int dsa_port_setup(struct dsa_port *dp) · 428 unmodified lines
429	{	429	{
430	struct devlink_port *dlp = &dp->devlink_port;	430	struct devlink_port *dlp = &dp->devlink_port;
431	bool dsa_port_link_registered = false;	431	bool dsa_port_link_registered = false;
		432	struct dsa_switch *ds = dp->ds;
432	bool dsa_port_enabled = false;	433	bool dsa_port_enabled = false;
433	int err = 0;	434	int err = 0;
434		435
@@ -438,6 +439,12 @@ static int dsa_port_setup(struct dsa_port *dp) · 3 unmodified lines
438	INIT_LIST_HEAD(&dp->fdbs);	439	INIT_LIST_HEAD(&dp->fdbs);
439	INIT_LIST_HEAD(&dp->mdbs);	440	INIT_LIST_HEAD(&dp->mdbs);
440		441
		442	if (ds->ops->port_setup) {
		443	err = ds->ops->port_setup(ds, dp->index);
		444	if (err)
		445	return err;
		446	}
		447
441	switch (dp->type) {	448	switch (dp->type) {
442	case DSA_PORT_TYPE_UNUSED:	449	case DSA_PORT_TYPE_UNUSED:
443	dsa_port_disable(dp);	450	dsa_port_disable(dp);
@@ -480,8 +487,11 @@ static int dsa_port_setup(struct dsa_port *dp) · 36 unmodified lines
480	dsa_port_disable(dp);	487	dsa_port_disable(dp);
481	if (err && dsa_port_link_registered)	488	if (err && dsa_port_link_registered)
482	dsa_port_link_unregister_of(dp);	489	dsa_port_link_unregister_of(dp);
483	if (err)	490	if (err) {
		491	if (ds->ops->port_teardown)
		492	ds->ops->port_teardown(ds, dp->index);
484	return err;	493	return err;
		494	}
485		495
486	dp->setup = true;	496	dp->setup = true;
487		497
@@ -533,11 +543,15 @@ static int dsa_port_devlink_setup(struct dsa_port *dp) · 45 unmodified lines
533	static void dsa_port_teardown(struct dsa_port *dp)	543	static void dsa_port_teardown(struct dsa_port *dp)
534	{	544	{
535	struct devlink_port *dlp = &dp->devlink_port;	545	struct devlink_port *dlp = &dp->devlink_port;
		546	struct dsa_switch *ds = dp->ds;
536	struct dsa_mac_addr a, tmp;	547	struct dsa_mac_addr a, tmp;
537		548
538	if (!dp->setup)	549	if (!dp->setup)
539	return;	550	return;
540		551
		552	if (ds->ops->port_teardown)
		553	ds->ops->port_teardown(ds, dp->index);
		554
541	devlink_port_type_clear(dlp);	555	devlink_port_type_clear(dlp);
542		556
543	switch (dp->type) {	557	switch (dp->type) {
@@ -581,6 +595,36 @@ static void dsa_port_devlink_teardown(struct dsa_port *dp) · 37 unmodified lines
581	dp->devlink_port_setup = false;	595	dp->devlink_port_setup = false;
582	}	596	}
583		597
		598	/* Destroy the current devlink port, and create a new one which has the UNUSED
		599	* flavour. At this point, any call to ds->ops->port_setup has been already
		600	* balanced out by a call to ds->ops->port_teardown, so we know that any
		601	* devlink port regions the driver had are now unregistered. We then call its
		602	* ds->ops->port_setup again, in order for the driver to re-create them on the
		603	* new devlink port.
		604	*/
		605	static int dsa_port_reinit_as_unused(struct dsa_port *dp)
		606	{
		607	struct dsa_switch *ds = dp->ds;
		608	int err;
		609
		610	dsa_port_devlink_teardown(dp);
		611	dp->type = DSA_PORT_TYPE_UNUSED;
		612	err = dsa_port_devlink_setup(dp);
		613	if (err)
		614	return err;
		615
		616	if (ds->ops->port_setup) {
		617	/* On error, leave the devlink port registered,
		618	* dsa_switch_teardown will clean it up later.
		619	*/
		620	err = ds->ops->port_setup(ds, dp->index);
		621	if (err)
		622	return err;
		623	}
		624
		625	return 0;
		626	}
		627
584	static int dsa_devlink_info_get(struct devlink *dl,	628	static int dsa_devlink_info_get(struct devlink *dl,
585	struct devlink_info_req *req,	629	struct devlink_info_req *req,
586	struct netlink_ext_ack *extack)	630	struct netlink_ext_ack *extack)
@@ -833,7 +877,7 @@ static int dsa_switch_setup(struct dsa_switch *ds) · 246 unmodified lines
833	devlink_params_publish(ds->devlink);	877	devlink_params_publish(ds->devlink);
834		878
835	if (!ds->slave_mii_bus && ds->ops->phy_read) {	879	if (!ds->slave_mii_bus && ds->ops->phy_read) {
836	ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);	880	ds->slave_mii_bus = mdiobus_alloc();
837	if (!ds->slave_mii_bus) {	881	if (!ds->slave_mii_bus) {
838	err = -ENOMEM;	882	err = -ENOMEM;
839	goto teardown;	883	goto teardown;
@@ -843,13 +887,16 @@ static int dsa_switch_setup(struct dsa_switch *ds) · 3 unmodified lines
843		887
844	err = mdiobus_register(ds->slave_mii_bus);	888	err = mdiobus_register(ds->slave_mii_bus);
845	if (err < 0)	889	if (err < 0)
846	goto teardown;	890	goto free_slave_mii_bus;
847	}	891	}
848		892
849	ds->setup = true;	893	ds->setup = true;
850		894
851	return 0;	895	return 0;
852		896
		897	free_slave_mii_bus:
		898	if (ds->slave_mii_bus && ds->ops->phy_read)
		899	mdiobus_free(ds->slave_mii_bus);
853	teardown:	900	teardown:
854	if (ds->ops->teardown)	901	if (ds->ops->teardown)
855	ds->ops->teardown(ds);	902	ds->ops->teardown(ds);
@@ -872,8 +919,11 @@ static void dsa_switch_teardown(struct dsa_switch *ds) · 16 unmodified lines
872	if (!ds->setup)	919	if (!ds->setup)
873	return;	920	return;
874		921
875	if (ds->slave_mii_bus && ds->ops->phy_read)	922	if (ds->slave_mii_bus && ds->ops->phy_read) {
876	mdiobus_unregister(ds->slave_mii_bus);	923	mdiobus_unregister(ds->slave_mii_bus);
		924	mdiobus_free(ds->slave_mii_bus);
		925	ds->slave_mii_bus = NULL;
		926	}
877		927
878	dsa_switch_unregister_notifier(ds);	928	dsa_switch_unregister_notifier(ds);
879		929
@@ -933,12 +983,9 @@ static int dsa_tree_setup_switches(struct dsa_switch_tree *dst) · 53 unmodified lines
933	list_for_each_entry(dp, &dst->ports, list) {	983	list_for_each_entry(dp, &dst->ports, list) {
934	err = dsa_port_setup(dp);	984	err = dsa_port_setup(dp);
935	if (err) {	985	if (err) {
936	dsa_port_devlink_teardown(dp);	986	err = dsa_port_reinit_as_unused(dp);
937	dp->type = DSA_PORT_TYPE_UNUSED;
938	err = dsa_port_devlink_setup(dp);
939	if (err)	987	if (err)
940	goto teardown;	988	goto teardown;
941	continue;
942	}	989	}
943	}	990	}
944		991
@@ -1043,6 +1090,7 @@ static int dsa_tree_setup(struct dsa_switch_tree *dst) · 98 unmodified lines
1043	teardown_master:	1090	teardown_master:
1044	dsa_tree_teardown_master(dst);	1091	dsa_tree_teardown_master(dst);
1045	teardown_switches:	1092	teardown_switches:
		1093	dsa_tree_teardown_ports(dst);
1046	dsa_tree_teardown_switches(dst);	1094	dsa_tree_teardown_switches(dst);
1047	teardown_cpu_ports:	1095	teardown_cpu_ports:
1048	dsa_tree_teardown_cpu_ports(dst);	1096	dsa_tree_teardown_cpu_ports(dst);
@@ -1557,3 +1605,53 @@ void dsa_unregister_switch(struct dsa_switch *ds) · 508 unmodified lines
1557	mutex_unlock(&dsa2_mutex);	1605	mutex_unlock(&dsa2_mutex);
1558	}	1606	}
1559	EXPORT_SYMBOL_GPL(dsa_unregister_switch);	1607	EXPORT_SYMBOL_GPL(dsa_unregister_switch);
		1608
		1609	/* If the DSA master chooses to unregister its net_device on .shutdown, DSA is
		1610	* blocking that operation from completion, due to the dev_hold taken inside
		1611	* netdev_upper_dev_link. Unlink the DSA slave interfaces from being uppers of
		1612	* the DSA master, so that the system can reboot successfully.
		1613	*/
		1614	void dsa_switch_shutdown(struct dsa_switch *ds)
		1615	{
		1616	struct net_device master, slave_dev;
		1617	LIST_HEAD(unregister_list);
		1618	struct dsa_port *dp;
		1619
		1620	mutex_lock(&dsa2_mutex);
		1621	rtnl_lock();
		1622
		1623	list_for_each_entry(dp, &ds->dst->ports, list) {
		1624	if (dp->ds != ds)
		1625	continue;
		1626
		1627	if (!dsa_port_is_user(dp))
		1628	continue;
		1629
		1630	master = dp->cpu_dp->master;
		1631	slave_dev = dp->slave;
		1632
		1633	netdev_upper_dev_unlink(master, slave_dev);
		1634	/* Just unlinking ourselves as uppers of the master is not
		1635	* sufficient. When the master net device unregisters, that will
		1636	* also call dev_close, which we will catch as NETDEV_GOING_DOWN
		1637	* and trigger a dev_close on our own devices (dsa_slave_close).
		1638	* In turn, that will call dev_mc_unsync on the master's net
		1639	* device. If the master is also a DSA switch port, this will
		1640	* trigger dsa_slave_set_rx_mode which will call dev_mc_sync on
		1641	* its own master. Lockdep will complain about the fact that
		1642	* all cascaded masters have the same dsa_master_addr_list_lock_key,
		1643	* which it normally would not do if the cascaded masters would
		1644	* be in a proper upper/lower relationship, which we've just
		1645	* destroyed.
		1646	* To suppress the lockdep warnings, let's actually unregister
		1647	* the DSA slave interfaces too, to avoid the nonsensical
		1648	* multicast address list synchronization on shutdown.
		1649	*/
		1650	unregister_netdevice_queue(slave_dev, &unregister_list);
		1651	}
		1652	unregister_netdevice_many(&unregister_list);
		1653
		1654	rtnl_unlock();
		1655	mutex_unlock(&dsa2_mutex);
		1656	}
		1657	EXPORT_SYMBOL_GPL(dsa_switch_shutdown);

net/dsa/tag_ocelot.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2019 NXP Semiconductors	2	/* Copyright 2019 NXP
3	*/	3	*/
4	#include <linux/dsa/ocelot.h>	4	#include <linux/dsa/ocelot.h>
5	#include <soc/mscc/ocelot.h>	5	#include <soc/mscc/ocelot.h>

net/dsa/tag_ocelot_8021q.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright 2020-2021 NXP Semiconductors	2	/* Copyright 2020-2021 NXP
3	*	3	*
4	* An implementation of the software-defined tag_8021q.c tagger format, which	4	* An implementation of the software-defined tag_8021q.c tagger format, which
5	* also preserves full functionality under a vlan_filtering bridge. It does	5	* also preserves full functionality under a vlan_filtering bridge. It does

net/ipv4/nexthop.c+16−5

@@ -1982,6 +1982,8 @@ static int replace_nexthop_grp(struct net net, struct nexthop old, · 1981 unmodified lines
1982	rcu_assign_pointer(old->nh_grp, newg);	1982	rcu_assign_pointer(old->nh_grp, newg);
1983		1983
1984	if (newg->resilient) {	1984	if (newg->resilient) {
		1985	/* Make sure concurrent readers are not using 'oldg' anymore. */
		1986	synchronize_net();
1985	rcu_assign_pointer(oldg->res_table, tmp_table);	1987	rcu_assign_pointer(oldg->res_table, tmp_table);
1986	rcu_assign_pointer(oldg->spare->res_table, tmp_table);	1988	rcu_assign_pointer(oldg->spare->res_table, tmp_table);
1987	}	1989	}
@@ -3565,6 +3567,7 @@ static struct notifier_block nh_netdev_notifier = { · 1577 unmodified lines
3565	};	3567	};
3566		3568
3567	static int nexthops_dump(struct net net, struct notifier_block nb,	3569	static int nexthops_dump(struct net net, struct notifier_block nb,
		3570	enum nexthop_event_type event_type,
3568	struct netlink_ext_ack *extack)	3571	struct netlink_ext_ack *extack)
3569	{	3572	{
3570	struct rb_root *root = &net->nexthop.rb_root;	3573	struct rb_root *root = &net->nexthop.rb_root;
@@ -3575,8 +3578,7 @@ static int nexthops_dump(struct net net, struct notifier_block nb, · 4 unmodified lines
3575	struct nexthop *nh;	3578	struct nexthop *nh;
3576		3579
3577	nh = rb_entry(node, struct nexthop, rb_node);	3580	nh = rb_entry(node, struct nexthop, rb_node);
3578	err = call_nexthop_notifier(nb, net, NEXTHOP_EVENT_REPLACE, nh,	3581	err = call_nexthop_notifier(nb, net, event_type, nh, extack);
3579	extack);
3580	if (err)	3582	if (err)
3581	break;	3583	break;
3582	}	3584	}
@@ -3590,7 +3592,7 @@ int register_nexthop_notifier(struct net net, struct notifier_block nb, · 7 unmodified lines
3590	int err;	3592	int err;
3591		3593
3592	rtnl_lock();	3594	rtnl_lock();
3593	err = nexthops_dump(net, nb, extack);	3595	err = nexthops_dump(net, nb, NEXTHOP_EVENT_REPLACE, extack);
3594	if (err)	3596	if (err)
3595	goto unlock;	3597	goto unlock;
3596	err = blocking_notifier_chain_register(&net->nexthop.notifier_chain,	3598	err = blocking_notifier_chain_register(&net->nexthop.notifier_chain,
@@ -3603,8 +3605,17 @@ EXPORT_SYMBOL(register_nexthop_notifier); · 6 unmodified lines
3603		3605
3604	int unregister_nexthop_notifier(struct net net, struct notifier_block nb)	3606	int unregister_nexthop_notifier(struct net net, struct notifier_block nb)
3605	{	3607	{
3606	return blocking_notifier_chain_unregister(&net->nexthop.notifier_chain,	3608	int err;
3607	nb);	3609
		3610	rtnl_lock();
		3611	err = blocking_notifier_chain_unregister(&net->nexthop.notifier_chain,
		3612	nb);
		3613	if (err)
		3614	goto unlock;
		3615	nexthops_dump(net, nb, NEXTHOP_EVENT_DEL, NULL);
		3616	unlock:
		3617	rtnl_unlock();
		3618	return err;
3608	}	3619	}
3609	EXPORT_SYMBOL(unregister_nexthop_notifier);	3620	EXPORT_SYMBOL(unregister_nexthop_notifier);
3610		3621

net/smc/smc_clc.c+2−1

 		goto out_rel;
 	}
 	/* get address to which the internal TCP socket is bound */
-	kernel_getsockname(clcsock, (struct sockaddr *)&addrs);
+	if (kernel_getsockname(clcsock, (struct sockaddr *)&addrs) < 0)
+		goto out_rel;
 	/* analyze IP specific data of net_device belonging to TCP socket */
 	addr6 = (struct sockaddr_in6 *)&addrs;
 	rcu_read_lock();

net/smc/smc_core.c+2−0

@@ -1468,7 +1468,9 @@ static void smc_conn_abort_work(struct work_struct *work) · 1467 unmodified lines
1468	abort_work);	1468	abort_work);
1469	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);	1469	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
1470		1470
		1471	lock_sock(&smc->sk);
1471	smc_conn_kill(conn, true);	1472	smc_conn_kill(conn, true);
		1473	release_sock(&smc->sk);
1472	sock_put(&smc->sk); /* sock_hold done by schedulers of abort_work */	1474	sock_put(&smc->sk); /* sock_hold done by schedulers of abort_work */
1473	}	1475	}
1474		1476

scripts/Makefile.clang+5−0

 else
 CLANG_FLAGS	+= -fintegrated-as
 endif
+# By default, clang only warns when it encounters an unknown warning flag or
+# certain optimization flags it knows it has not implemented.
+# Make it behave more like gcc by erroring when these flags are encountered
+# so they can be implemented or wrapped in cc-option.
 CLANG_FLAGS	+= -Werror=unknown-warning-option
+CLANG_FLAGS	+= -Werror=ignored-optimization-argument
 KBUILD_CFLAGS	+= $(CLANG_FLAGS)
 KBUILD_AFLAGS	+= $(CLANG_FLAGS)
 export CLANG_FLAGS

scripts/Makefile.modpost+1−1

@@ -13,7 +13,7 @@ · 12 unmodified lines
13	# Stage 2 is handled by this file and does the following	13	# Stage 2 is handled by this file and does the following
14	# 1) Find all modules listed in modules.order	14	# 1) Find all modules listed in modules.order
15	# 2) modpost is then used to	15	# 2) modpost is then used to
16	# 3) create one <module>.mod.c file pr. module	16	# 3) create one <module>.mod.c file per module
17	# 4) create one Module.symvers file with CRC for all exported symbols	17	# 4) create one Module.symvers file with CRC for all exported symbols
18		18
19	# Step 3 is used to place certain information in the module's ELF	19	# Step 3 is used to place certain information in the module's ELF

scripts/checkkconfigsymbols.py+3−8

 REGEX_KCONFIG_DEF = re.compile(DEF)
 REGEX_KCONFIG_EXPR = re.compile(EXPR)
 REGEX_KCONFIG_STMT = re.compile(STMT)
-REGEX_KCONFIG_HELP = re.compile(r"^\s+help\s*$")
 REGEX_FILTER_SYMBOLS = re.compile(r"[A-Za-z0-9]$")
 REGEX_NUMERIC = re.compile(r"0[xX][0-9a-fA-F]+|[0-9]+")
 REGEX_QUOTES = re.compile("(\"(.*?)\")")
                      "continue.")
     if args.commit:
+        if args.commit.startswith('HEAD'):
+            sys.exit("The --commit option can't use the HEAD ref")
         args.find = False
     if args.ignore:
     lines = []
     defined = []
     references = []
-    skip = False
     if not os.path.exists(kfile):
         return defined, references
         if REGEX_KCONFIG_DEF.match(line):
             symbol_def = REGEX_KCONFIG_DEF.findall(line)
             defined.append(symbol_def[0])
-            skip = False
-        elif REGEX_KCONFIG_HELP.match(line):
-            skip = True
-        elif skip:
-            # ignore content of help messages
-            pass
         elif REGEX_KCONFIG_STMT.match(line):
             line = REGEX_QUOTES.sub("", line)
             symbols = get_symbols_in_line(line)

scripts/clang-tools/gen_compile_commands.py+1−0

@@ -13,6 +13,7 @@ import logging · 12 unmodified lines
13	import os	13	import os
14	import re	14	import re
15	import subprocess	15	import subprocess
		16	import sys
16		17
17	_DEFAULT_OUTPUT = 'compile_commands.json'	18	_DEFAULT_OUTPUT = 'compile_commands.json'
18	_DEFAULT_LOG_LEVEL = 'WARNING'	19	_DEFAULT_LOG_LEVEL = 'WARNING'

tools/lib/perf/evsel.c+41−23

@@ -43,7 +43,7 @@ void perf_evsel__delete(struct perf_evsel *evsel) · 42 unmodified lines
43	free(evsel);	43	free(evsel);
44	}	44	}
45		45
46	#define FD(e, x, y) ((int ) xyarray__entry(e->fd, x, y))	46	#define FD(e, x, y) ((int *) xyarray__entry(e->fd, x, y))
47	#define MMAP(e, x, y) (e->mmap ? ((struct perf_mmap *) xyarray__entry(e->mmap, x, y)) : NULL)	47	#define MMAP(e, x, y) (e->mmap ? ((struct perf_mmap *) xyarray__entry(e->mmap, x, y)) : NULL)
48		48
49	int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)	49	int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
@@ -54,7 +54,10 @@ int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads) · 4 unmodified lines
54	int cpu, thread;	54	int cpu, thread;
55	for (cpu = 0; cpu < ncpus; cpu++) {	55	for (cpu = 0; cpu < ncpus; cpu++) {
56	for (thread = 0; thread < nthreads; thread++) {	56	for (thread = 0; thread < nthreads; thread++) {
57	FD(evsel, cpu, thread) = -1;	57	int *fd = FD(evsel, cpu, thread);
		58
		59	if (fd)
		60	*fd = -1;
58	}	61	}
59	}	62	}
60	}	63	}
@@ -80,7 +83,7 @@ sys_perf_event_open(struct perf_event_attr *attr, · 19 unmodified lines
80	static int get_group_fd(struct perf_evsel evsel, int cpu, int thread, int group_fd)	83	static int get_group_fd(struct perf_evsel evsel, int cpu, int thread, int group_fd)
81	{	84	{
82	struct perf_evsel *leader = evsel->leader;	85	struct perf_evsel *leader = evsel->leader;
83	int fd;	86	int *fd;
84		87
85	if (evsel == leader) {	88	if (evsel == leader) {
86	*group_fd = -1;	89	*group_fd = -1;
@@ -95,10 +98,10 @@ static int get_group_fd(struct perf_evsel evsel, int cpu, int thread, int grou · 8 unmodified lines
95	return -ENOTCONN;	98	return -ENOTCONN;
96		99
97	fd = FD(leader, cpu, thread);	100	fd = FD(leader, cpu, thread);
98	if (fd == -1)	101	if (fd == NULL \|\| *fd == -1)
99	return -EBADF;	102	return -EBADF;
100		103
101	*group_fd = fd;	104	group_fd = fd;
102		105
103	return 0;	106	return 0;
104	}	107	}
@@ -138,7 +141,11 @@ int perf_evsel__open(struct perf_evsel evsel, struct perf_cpu_map cpus, · 33 unmodified lines
138		141
139	for (cpu = 0; cpu < cpus->nr; cpu++) {	142	for (cpu = 0; cpu < cpus->nr; cpu++) {
140	for (thread = 0; thread < threads->nr; thread++) {	143	for (thread = 0; thread < threads->nr; thread++) {
141	int fd, group_fd;	144	int fd, group_fd, *evsel_fd;
		145
		146	evsel_fd = FD(evsel, cpu, thread);
		147	if (evsel_fd == NULL)
		148	return -EINVAL;
142		149
143	err = get_group_fd(evsel, cpu, thread, &group_fd);	150	err = get_group_fd(evsel, cpu, thread, &group_fd);
144	if (err < 0)	151	if (err < 0)
@@ -151,7 +158,7 @@ int perf_evsel__open(struct perf_evsel evsel, struct perf_cpu_map cpus, · 6 unmodified lines
151	if (fd < 0)	158	if (fd < 0)
152	return -errno;	159	return -errno;
153		160
154	FD(evsel, cpu, thread) = fd;	161	*evsel_fd = fd;
155	}	162	}
156	}	163	}
157		164
@@ -163,9 +170,12 @@ static void perf_evsel__close_fd_cpu(struct perf_evsel *evsel, int cpu) · 5 unmodified lines
163	int thread;	170	int thread;
164		171
165	for (thread = 0; thread < xyarray__max_y(evsel->fd); ++thread) {	172	for (thread = 0; thread < xyarray__max_y(evsel->fd); ++thread) {
166	if (FD(evsel, cpu, thread) >= 0)	173	int *fd = FD(evsel, cpu, thread);
167	close(FD(evsel, cpu, thread));	174
168	FD(evsel, cpu, thread) = -1;	175	if (fd && *fd >= 0) {
		176	close(*fd);
		177	*fd = -1;
		178	}
169	}	179	}
170	}	180	}
171		181
@@ -209,13 +219,12 @@ void perf_evsel__munmap(struct perf_evsel *evsel) · 37 unmodified lines
209		219
210	for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {	220	for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {
211	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {	221	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {
212	int fd = FD(evsel, cpu, thread);	222	int *fd = FD(evsel, cpu, thread);
213	struct perf_mmap *map = MMAP(evsel, cpu, thread);
214		223
215	if (fd < 0)	224	if (fd == NULL \|\| *fd < 0)
216	continue;	225	continue;
217		226
218	perf_mmap__munmap(map);	227	perf_mmap__munmap(MMAP(evsel, cpu, thread));
219	}	228	}
220	}	229	}
221		230
@@ -239,15 +248,16 @@ int perf_evsel__mmap(struct perf_evsel *evsel, int pages) · 17 unmodified lines
239		248
240	for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {	249	for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {
241	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {	250	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {
242	int fd = FD(evsel, cpu, thread);	251	int *fd = FD(evsel, cpu, thread);
243	struct perf_mmap *map = MMAP(evsel, cpu, thread);	252	struct perf_mmap *map;
244		253
245	if (fd < 0)	254	if (fd == NULL \|\| *fd < 0)
246	continue;	255	continue;
247		256
		257	map = MMAP(evsel, cpu, thread);
248	perf_mmap__init(map, NULL, false, NULL);	258	perf_mmap__init(map, NULL, false, NULL);
249		259
250	ret = perf_mmap__mmap(map, &mp, fd, cpu);	260	ret = perf_mmap__mmap(map, &mp, *fd, cpu);
251	if (ret) {	261	if (ret) {
252	perf_evsel__munmap(evsel);	262	perf_evsel__munmap(evsel);
253	return ret;	263	return ret;
@@ -260,7 +270,9 @@ int perf_evsel__mmap(struct perf_evsel *evsel, int pages) · 6 unmodified lines
260		270
261	void perf_evsel__mmap_base(struct perf_evsel evsel, int cpu, int thread)	271	void perf_evsel__mmap_base(struct perf_evsel evsel, int cpu, int thread)
262	{	272	{
263	if (FD(evsel, cpu, thread) < 0 \|\| MMAP(evsel, cpu, thread) == NULL)	273	int *fd = FD(evsel, cpu, thread);
		274
		275	if (fd == NULL \|\| *fd < 0 \|\| MMAP(evsel, cpu, thread) == NULL)
264	return NULL;	276	return NULL;
265		277
266	return MMAP(evsel, cpu, thread)->base;	278	return MMAP(evsel, cpu, thread)->base;
@@ -295,17 +307,18 @@ int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread, · 28 unmodified lines
295	struct perf_counts_values *count)	307	struct perf_counts_values *count)
296	{	308	{
297	size_t size = perf_evsel__read_size(evsel);	309	size_t size = perf_evsel__read_size(evsel);
		310	int *fd = FD(evsel, cpu, thread);
298		311
299	memset(count, 0, sizeof(*count));	312	memset(count, 0, sizeof(*count));
300		313
301	if (FD(evsel, cpu, thread) < 0)	314	if (fd == NULL \|\| *fd < 0)
302	return -EINVAL;	315	return -EINVAL;
303		316
304	if (MMAP(evsel, cpu, thread) &&	317	if (MMAP(evsel, cpu, thread) &&
305	!perf_mmap__read_self(MMAP(evsel, cpu, thread), count))	318	!perf_mmap__read_self(MMAP(evsel, cpu, thread), count))
306	return 0;	319	return 0;
307		320
308	if (readn(FD(evsel, cpu, thread), count->values, size) <= 0)	321	if (readn(*fd, count->values, size) <= 0)
309	return -errno;	322	return -errno;
310		323
311	return 0;	324	return 0;
@@ -318,8 +331,13 @@ static int perf_evsel__run_ioctl(struct perf_evsel *evsel, · 6 unmodified lines
318	int thread;	331	int thread;
319		332
320	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {	333	for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {
321	int fd = FD(evsel, cpu, thread),	334	int err;
322	err = ioctl(fd, ioc, arg);	335	int *fd = FD(evsel, cpu, thread);
		336
		337	if (fd == NULL \|\| *fd < 0)
		338	return -1;
		339
		340	err = ioctl(*fd, ioc, arg);
323		341
324	if (err)	342	if (err)
325	return err;	343	return err;

tools/perf/builtin-script.c+13−11

 	return OUTPUT_TYPE_OTHER;
 }
-static inline unsigned int attr_type(unsigned int type)
-{
-	switch (type) {
-	case OUTPUT_TYPE_SYNTH:
-		return PERF_TYPE_SYNTH;
-	default:
-		return type;
-	}
-}
 static bool output_set_by_user(void)
 {
 	int j;
 		output[type].print_ip_opts |= EVSEL__PRINT_SRCLINE;
 }
+static struct evsel *find_first_output_type(struct evlist *evlist,
+					    unsigned int type)
+{
+	struct evsel *evsel;
+	evlist__for_each_entry(evlist, evsel) {
+		if (output_type(evsel->core.attr.type) == (int)type)
+			return evsel;
+	}
+	return NULL;
+}
 /*
  * verify all user requested events exist and the samples
  * have the expected data
 	struct evsel *evsel;
 	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
-		evsel = perf_session__find_first_evtype(session, attr_type(j));
+		evsel = find_first_output_type(session->evlist, j);
 		/*
 		 * even if fields is set to 0 (ie., show nothing) event must

tools/perf/ui/browser.c+24−9

 }
 void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column,
-			    unsigned int row, bool arrow_down)
+			    unsigned int row, int diff, bool arrow_down)
 {
-	unsigned int end_row;
+	int end_row;
-	if (row >= browser->top_idx)
+	if (diff <= 0)
-		end_row = row - browser->top_idx;
-	else
 		return;
 	SLsmg_set_char_set(1);
 	if (arrow_down) {
+		if (row + diff <= browser->top_idx)
+			return;
+		end_row = row + diff - browser->top_idx;
 		ui_browser__gotorc(browser, end_row, column - 1);
-		SLsmg_write_char(SLSMG_ULCORN_CHAR);
-		ui_browser__gotorc(browser, end_row, column);
-		SLsmg_draw_hline(2);
-		ui_browser__gotorc(browser, end_row + 1, column - 1);
 		SLsmg_write_char(SLSMG_LTEE_CHAR);
+		while (--end_row >= 0 && end_row > (int)(row - browser->top_idx)) {
+			ui_browser__gotorc(browser, end_row, column - 1);
+			SLsmg_draw_vline(1);
+		}
+		end_row = (int)(row - browser->top_idx);
+		if (end_row >= 0) {
+			ui_browser__gotorc(browser, end_row, column - 1);
+			SLsmg_write_char(SLSMG_ULCORN_CHAR);
+			ui_browser__gotorc(browser, end_row, column);
+			SLsmg_draw_hline(2);
+		}
 	} else {
+		if (row < browser->top_idx)
+			return;
+		end_row = row - browser->top_idx;
 		ui_browser__gotorc(browser, end_row, column - 1);
 		SLsmg_write_char(SLSMG_LTEE_CHAR);
 		ui_browser__gotorc(browser, end_row, column);

tools/perf/ui/browser.h+1−1

@@ -51,7 +51,7 @@ void ui_browser__write_graph(struct ui_browser *browser, int graph); · 50 unmodified lines
51	void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,	51	void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
52	u64 start, u64 end);	52	u64 start, u64 end);
53	void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column,	53	void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column,
54	unsigned int row, bool arrow_down);	54	unsigned int row, int diff, bool arrow_down);
55	void __ui_browser__show_title(struct ui_browser browser, const char title);	55	void __ui_browser__show_title(struct ui_browser browser, const char title);
56	void ui_browser__show_title(struct ui_browser browser, const char title);	56	void ui_browser__show_title(struct ui_browser browser, const char title);
57	int ui_browser__show(struct ui_browser browser, const char title,	57	int ui_browser__show(struct ui_browser browser, const char title,

tools/perf/ui/browsers/annotate.c+17−7

 		ab->selection = al;
 }
-static bool is_fused(struct annotate_browser *ab, struct disasm_line *cursor)
+static int is_fused(struct annotate_browser *ab, struct disasm_line *cursor)
 {
 	struct disasm_line *pos = list_prev_entry(cursor, al.node);
 	const char *name;
+	int diff = 1;
+	while (pos && pos->al.offset == -1) {
+		pos = list_prev_entry(pos, al.node);
+		if (!ab->opts->hide_src_code)
+			diff++;
+	}
 	if (!pos)
-		return false;
+		return 0;
 	if (ins__is_lock(&pos->ins))
 		name = pos->ops.locked.ins.name;
 		name = pos->ins.name;
 	if (!name || !cursor->ins.name)
-		return false;
+		return 0;
-	return ins__is_fused(ab->arch, name, cursor->ins.name);
+	if (ins__is_fused(ab->arch, name, cursor->ins.name))
+		return diff;
+	return 0;
 }
 static void annotate_browser__draw_current_jump(struct ui_browser *browser)
 	struct annotation *notes = symbol__annotation(sym);
 	u8 pcnt_width = annotation__pcnt_width(notes);
 	int width;
+	int diff = 0;
 	/* PLT symbols contain external offsets */
 	if (strstr(sym->name, "@plt"))
 				 pcnt_width + 2 + notes->widths.addr + width,
 				 from, to);
-	if (is_fused(ab, cursor)) {
+	diff = is_fused(ab, cursor);
+	if (diff > 0) {
 		ui_browser__mark_fused(browser,
 				       pcnt_width + 3 + notes->widths.addr + width,
-				       from - 1,
+				       from - diff, diff, to > from);
-				       to > from);
 	}
 }

tools/perf/util/bpf-event.c+3−0

 struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
 {
        struct btf *btf;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
        int err = btf__get_from_id(id, &btf);
+#pragma GCC diagnostic pop
        return err ? ERR_PTR(err) : btf;
 }

tools/perf/util/machine.c+1−0

@@ -2149,6 +2149,7 @@ static int add_callchain_ip(struct thread *thread, · 2148 unmodified lines
2149		2149
2150	al.filtered = 0;	2150	al.filtered = 0;
2151	al.sym = NULL;	2151	al.sym = NULL;
		2152	al.srcline = NULL;
2152	if (!cpumode) {	2153	if (!cpumode) {
2153	thread__find_cpumode_addr_location(thread, ip, &al);	2154	thread__find_cpumode_addr_location(thread, ip, &al);
2154	} else {	2155	} else {

tools/testing/selftests/drivers/net/ocelot/tc_flower_chains.sh+1−1

@@ -1,6 +1,6 @@
1	#!/bin/bash	1	#!/bin/bash
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3	# Copyright 2020 NXP Semiconductors	3	# Copyright 2020 NXP
4		4
5	WAIT_TIME=1	5	WAIT_TIME=1
6	NUM_NETIFS=4	6	NUM_NETIFS=4

tools/testing/selftests/net/af_unix/Makefile+1−4

@@ -1,5 +1,2 @@
1	##TEST_GEN_FILES := test_unix_oob	1	TEST_GEN_PROGS := test_unix_oob
2	TEST_PROGS := test_unix_oob
3	include ../../lib.mk	2	include ../../lib.mk
4
5	all: $(TEST_PROGS)

tools/testing/selftests/net/af_unix/test_unix_oob.c+3−2

@@ -271,8 +271,9 @@ main(int argc, char **argv) · 270 unmodified lines
271	read_oob(pfd, &oob);	271	read_oob(pfd, &oob);
272		272
273	if (!signal_recvd \|\| len != 127 \|\| oob != '%' \|\| atmark != 1) {	273	if (!signal_recvd \|\| len != 127 \|\| oob != '%' \|\| atmark != 1) {
274	fprintf(stderr, "Test 3 failed, sigurg %d len %d OOB %c ",	274	fprintf(stderr,
275	"atmark %d\n", signal_recvd, len, oob, atmark);	275	"Test 3 failed, sigurg %d len %d OOB %c atmark %d\n",
		276	signal_recvd, len, oob, atmark);
276	die(1);	277	die(1);
277	}	278	}
278		279

tools/testing/selftests/powerpc/tm/tm-syscall-asm.S+36−1

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	#include <ppc-asm.h>	2	#include <basic_asm.h>
3	#include <asm/unistd.h>	3	#include <asm/unistd.h>
4		4
5	.text	5	.text
@@ -26,3 +26,38 @@ FUNC_START(getppid_tm_suspended) · 20 unmodified lines
26	1:	26	1:
27	li r3, -1	27	li r3, -1
28	blr	28	blr
		29
		30
		31	.macro scv level
		32	.long (0x44000001 \| (\level) << 5)
		33	.endm
		34
		35	FUNC_START(getppid_scv_tm_active)
		36	PUSH_BASIC_STACK(0)
		37	tbegin.
		38	beq 1f
		39	li r0, __NR_getppid
		40	scv 0
		41	tend.
		42	POP_BASIC_STACK(0)
		43	blr
		44	1:
		45	li r3, -1
		46	POP_BASIC_STACK(0)
		47	blr
		48
		49	FUNC_START(getppid_scv_tm_suspended)
		50	PUSH_BASIC_STACK(0)
		51	tbegin.
		52	beq 1f
		53	li r0, __NR_getppid
		54	tsuspend.
		55	scv 0
		56	tresume.
		57	tend.
		58	POP_BASIC_STACK(0)
		59	blr
		60	1:
		61	li r3, -1
		62	POP_BASIC_STACK(0)
		63	blr

tools/testing/selftests/powerpc/tm/tm-syscall.c+29−7

 #include "utils.h"
 #include "tm.h"
+#ifndef PPC_FEATURE2_SCV
+#define PPC_FEATURE2_SCV               0x00100000 /* scv syscall */
+#endif
 extern int getppid_tm_active(void);
 extern int getppid_tm_suspended(void);
+extern int getppid_scv_tm_active(void);
+extern int getppid_scv_tm_suspended(void);
 unsigned retries = 0;
 #define TEST_DURATION 10 /* seconds */
-pid_t getppid_tm(bool suspend)
+pid_t getppid_tm(bool scv, bool suspend)
 {
 	int i;
 	pid_t pid;
 	for (i = 0; i < TM_RETRIES; i++) {
-		if (suspend)
+		if (suspend) {
-			pid = getppid_tm_suspended();
+			if (scv)
-		else
+				pid = getppid_scv_tm_suspended();
-			pid = getppid_tm_active();
+			else
+				pid = getppid_tm_suspended();
+		} else {
+			if (scv)
+				pid = getppid_scv_tm_active();
+			else
+				pid = getppid_tm_active();
+		}
 		if (pid >= 0)
 			return pid;
 		 * Test a syscall within a suspended transaction and verify
 		 * that it succeeds.
 		 */
-		FAIL_IF(getppid_tm(true) == -1); /* Should succeed. */
+		FAIL_IF(getppid_tm(false, true) == -1); /* Should succeed. */
 		/*
 		 * Test a syscall within an active transaction and verify that
 		 * it fails with the correct failure code.
 		 */
-		FAIL_IF(getppid_tm(false) != -1);  /* Should fail... */
+		FAIL_IF(getppid_tm(false, false) != -1);  /* Should fail... */
 		FAIL_IF(!failure_is_persistent()); /* ...persistently... */
 		FAIL_IF(!failure_is_syscall());    /* ...with code syscall. */
+		/* Now do it all again with scv if it is available. */
+		if (have_hwcap2(PPC_FEATURE2_SCV)) {
+			FAIL_IF(getppid_tm(true, true) == -1); /* Should succeed. */
+			FAIL_IF(getppid_tm(true, false) != -1);  /* Should fail... */
+			FAIL_IF(!failure_is_persistent()); /* ...persistently... */
+			FAIL_IF(!failure_is_syscall());    /* ...with code syscall. */
+		}
 		gettimeofday(&now, 0);
 	}

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -80,30 +80,30 @@ $(obj)/vmlinux.bin.xz: $(obj)/vmlinux.bin FORCE · 79 unmodified lines
80	$(obj)/vmlinux.bin.lzo: $(obj)/vmlinux.bin FORCE	80	$(obj)/vmlinux.bin.lzo: $(obj)/vmlinux.bin FORCE
81	$(call if_changed,lzo)	81	$(call if_changed,lzo)
82		82
83	$(obj)/uImage.bz2: $(obj)/vmlinux.bin.bz2	83	$(obj)/uImage.bz2: $(obj)/vmlinux.bin.bz2 FORCE
84	$(call if_changed,uimage,bzip2)	84	$(call if_changed,uimage,bzip2)
85		85
86	$(obj)/uImage.gz: $(obj)/vmlinux.bin.gz	86	$(obj)/uImage.gz: $(obj)/vmlinux.bin.gz FORCE
87	$(call if_changed,uimage,gzip)	87	$(call if_changed,uimage,gzip)
88		88
89	$(obj)/uImage.lzma: $(obj)/vmlinux.bin.lzma	89	$(obj)/uImage.lzma: $(obj)/vmlinux.bin.lzma FORCE
90	$(call if_changed,uimage,lzma)	90	$(call if_changed,uimage,lzma)
91		91
92	$(obj)/uImage.xz: $(obj)/vmlinux.bin.xz	92	$(obj)/uImage.xz: $(obj)/vmlinux.bin.xz FORCE
93	$(call if_changed,uimage,xz)	93	$(call if_changed,uimage,xz)
94		94
95	$(obj)/uImage.lzo: $(obj)/vmlinux.bin.lzo	95	$(obj)/uImage.lzo: $(obj)/vmlinux.bin.lzo FORCE
96	$(call if_changed,uimage,lzo)	96	$(call if_changed,uimage,lzo)
97		97
98	$(obj)/uImage.bin: $(obj)/vmlinux.bin	98	$(obj)/uImage.bin: $(obj)/vmlinux.bin FORCE
99	$(call if_changed,uimage,none)	99	$(call if_changed,uimage,none)
100		100
101	OBJCOPYFLAGS_vmlinux.srec := -I binary -O srec	101	OBJCOPYFLAGS_vmlinux.srec := -I binary -O srec
102	$(obj)/vmlinux.srec: $(obj)/compressed/vmlinux	102	$(obj)/vmlinux.srec: $(obj)/compressed/vmlinux FORCE
103	$(call if_changed,objcopy)	103	$(call if_changed,objcopy)
104		104
105	OBJCOPYFLAGS_uImage.srec := -I binary -O srec	105	OBJCOPYFLAGS_uImage.srec := -I binary -O srec
106	$(obj)/uImage.srec: $(obj)/uImage	106	$(obj)/uImage.srec: $(obj)/uImage FORCE
107	$(call if_changed,objcopy)	107	$(call if_changed,objcopy)
108		108
109	$(obj)/uImage: $(obj)/uImage.$(suffix-y)	109	$(obj)/uImage: $(obj)/uImage.$(suffix-y)