lael-labs/linux

.mailmap+1−0

@@ -225,6 +225,7 @@ Pratyush Anand <pratyush.anand@gmail.com> <pratyush.anand@st.com> · 224 unmodified lines
225	Praveen BP <praveenbp@ti.com>	225	Praveen BP <praveenbp@ti.com>
226	Punit Agrawal <punitagrawal@gmail.com> <punit.agrawal@arm.com>	226	Punit Agrawal <punitagrawal@gmail.com> <punit.agrawal@arm.com>
227	Qais Yousef <qsyousef@gmail.com> <qais.yousef@imgtec.com>	227	Qais Yousef <qsyousef@gmail.com> <qais.yousef@imgtec.com>
		228	Quentin Monnet <quentin@isovalent.com> <quentin.monnet@netronome.com>
228	Quentin Perret <qperret@qperret.net> <quentin.perret@arm.com>	229	Quentin Perret <qperret@qperret.net> <quentin.perret@arm.com>
229	Rafael J. Wysocki <rjw@rjwysocki.net> <rjw@sisk.pl>	230	Rafael J. Wysocki <rjw@rjwysocki.net> <rjw@sisk.pl>
230	Rajesh Shah <rajesh.shah@intel.com>	231	Rajesh Shah <rajesh.shah@intel.com>

Documentation/arm64/silicon-errata.rst+2−0

 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX GICv3  | #23154          | CAVIUM_ERRATUM_23154        |
 +----------------+-----------------+-----------------+-----------------------------+
+| Cavium         | ThunderX GICv3  | #38539          | N/A                         |
++----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX Core   | #27456          | CAVIUM_ERRATUM_27456        |
 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX Core   | #30115          | CAVIUM_ERRATUM_30115        |

Documentation/driver-api/dmaengine/provider.rst+10−2

Documentation/filesystems/zonefs.txt+13−5

     |    option    | condition | size     read    write    read    write |
     +--------------+-----------+-----------------------------------------+
     |              | good      | fixed    yes     no       yes     yes   |
-    | remount-ro   | read-only | fixed    yes     no       yes     no    |
+    | remount-ro   | read-only | as is    yes     no       yes     no    |
     | (default)    | offline   |   0      no      no       no      no    |
     +--------------+-----------+-----------------------------------------+
     |              | good      | fixed    yes     no       yes     yes   |
-    | zone-ro      | read-only | fixed    yes     no       yes     no    |
+    | zone-ro      | read-only | as is    yes     no       yes     no    |
     |              | offline   |   0      no      no       no      no    |
     +--------------+-----------+-----------------------------------------+
     |              | good      |   0      no      no       yes     yes   |
     |              | offline   |   0      no      no       no      no    |
     +--------------+-----------+-----------------------------------------+
     |              | good      | fixed    yes     yes      yes     yes   |
-    | repair       | read-only | fixed    yes     no       yes     no    |
+    | repair       | read-only | as is    yes     no       yes     no    |
     |              | offline   |   0      no      no       no      no    |
     +--------------+-----------+-----------------------------------------+
 * zone-offline
 * repair
-The I/O error actions defined for each behavior are detailed in the previous
+The run-time I/O error actions defined for each behavior are detailed in the
-section.
+previous section. Mount time I/O errors will cause the mount operation to fail.
+The handling of read-only zones also differs between mount-time and run-time.
+If a read-only zone is found at mount time, the zone is always treated in the
+same manner as offline zones, that is, all accesses are disabled and the zone
+file size set to 0. This is necessary as the write pointer of read-only zones
+is defined as invalib by the ZBC and ZAC standards, making it impossible to
+discover the amount of data that has been written to the zone. In the case of a
+read-only zone discovered at run-time, as indicated in the previous section.
+the size of the zone file is left unchanged from its last updated value.
 Zonefs User Space Tools
 =======================

Documentation/kbuild/kbuild.rst+1−1

@@ -237,7 +237,7 @@ This is solely useful to speed up test compiles. · 236 unmodified lines
237	KBUILD_EXTRA_SYMBOLS	237	KBUILD_EXTRA_SYMBOLS
238	--------------------	238	--------------------
239	For modules that use symbols from other modules.	239	For modules that use symbols from other modules.
240	See more details in modules.txt.	240	See more details in modules.rst.
241		241
242	ALLSOURCE_ARCHS	242	ALLSOURCE_ARCHS
243	---------------	243	---------------

Documentation/kbuild/kconfig-macro-language.rst+1−1

@@ -44,7 +44,7 @@ intermediate:: · 43 unmodified lines
44	def_bool y	44	def_bool y
45		45
46	Then, Kconfig moves onto the evaluation stage to resolve inter-symbol	46	Then, Kconfig moves onto the evaluation stage to resolve inter-symbol
47	dependency as explained in kconfig-language.txt.	47	dependency as explained in kconfig-language.rst.
48		48
49		49
50	Variables	50	Variables

Documentation/kbuild/makefiles.rst+3−3

@@ -924,7 +924,7 @@ When kbuild executes, the following steps are followed (roughly): · 923 unmodified lines
924	$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that	924	$(KBUILD_AFLAGS_MODULE) is used to add arch-specific options that
925	are used for assembler.	925	are used for assembler.
926		926
927	From commandline AFLAGS_MODULE shall be used (see kbuild.txt).	927	From commandline AFLAGS_MODULE shall be used (see kbuild.rst).
928		928
929	KBUILD_CFLAGS_KERNEL	929	KBUILD_CFLAGS_KERNEL
930	$(CC) options specific for built-in	930	$(CC) options specific for built-in
@@ -937,7 +937,7 @@ When kbuild executes, the following steps are followed (roughly): · 6 unmodified lines
937		937
938	$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that	938	$(KBUILD_CFLAGS_MODULE) is used to add arch-specific options that
939	are used for $(CC).	939	are used for $(CC).
940	From commandline CFLAGS_MODULE shall be used (see kbuild.txt).	940	From commandline CFLAGS_MODULE shall be used (see kbuild.rst).
941		941
942	KBUILD_LDFLAGS_MODULE	942	KBUILD_LDFLAGS_MODULE
943	Options for $(LD) when linking modules	943	Options for $(LD) when linking modules
@@ -945,7 +945,7 @@ When kbuild executes, the following steps are followed (roughly): · 1 unmodified line
945	$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options	945	$(KBUILD_LDFLAGS_MODULE) is used to add arch-specific options
946	used when linking modules. This is often a linker script.	946	used when linking modules. This is often a linker script.
947		947
948	From commandline LDFLAGS_MODULE shall be used (see kbuild.txt).	948	From commandline LDFLAGS_MODULE shall be used (see kbuild.rst).
949		949
950	KBUILD_LDS	950	KBUILD_LDS
951		951

Documentation/kbuild/modules.rst+2−2

@@ -470,9 +470,9 @@ build. · 469 unmodified lines
470		470
471	The syntax of the Module.symvers file is::	471	The syntax of the Module.symvers file is::
472		472
473	<CRC> <Symbol> <Namespace> <Module> <Export Type>	473	<CRC> <Symbol> <Module> <Export Type> <Namespace>
474		474
475	0xe1cc2a05 usb_stor_suspend USB_STORAGE drivers/usb/storage/usb-storage EXPORT_SYMBOL_GPL	475	0xe1cc2a05 usb_stor_suspend drivers/usb/storage/usb-storage EXPORT_SYMBOL_GPL USB_STORAGE
476		476
477	The fields are separated by tabs and values may be empty (e.g.	477	The fields are separated by tabs and values may be empty (e.g.
478	if no namespace is defined for an exported symbol).	478	if no namespace is defined for an exported symbol).

MAINTAINERS+7−2

 F:	net/802/hippi.c
 F:	drivers/net/hippi/
+HISILICON DMA DRIVER
+M:	Zhou Wang <wangzhou1@hisilicon.com>
+L:	dmaengine@vger.kernel.org
+S:	Maintained
+F:	drivers/dma/hisi_dma.c
 HISILICON SECURITY ENGINE V2 DRIVER (SEC2)
 M:	Zaibo Xu <xuzaibo@huawei.com>
 L:	linux-crypto@vger.kernel.org
 S:	Supported
 F:	drivers/dma/idxd/*
 F:	include/uapi/linux/idxd.h
-F:	include/linux/idxd.h
 INTEL IDLE DRIVER
 M:	Jacob Pan <jacob.jun.pan@linux.intel.com>
 M:	Luca Coelho <luciano.coelho@intel.com>
 M:	Intel Linux Wireless <linuxwifi@intel.com>
 L:	linux-wireless@vger.kernel.org
-W:	http://intellinuxwireless.org
+W:	https://wireless.wiki.kernel.org/en/users/drivers/iwlwifi
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi.git
 S:	Supported
 F:	drivers/net/wireless/intel/iwlwifi/

Makefile+2−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 6	3	PATCHLEVEL = 6
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc5	5	EXTRAVERSION = -rc7
6	NAME = Kleptomaniac Octopus	6	NAME = Kleptomaniac Octopus
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION
@@ -1804,7 +1804,7 @@ existing-targets := $(wildcard $(sort $(targets))) · 1795 unmodified lines
1804		1804
1805	-include $(foreach f,$(existing-targets),$(dir $(f)).$(notdir $(f)).cmd)	1805	-include $(foreach f,$(existing-targets),$(dir $(f)).$(notdir $(f)).cmd)
1806		1806
1807	endif # config-targets	1807	endif # config-build
1808	endif # mixed-build	1808	endif # mixed-build
1809	endif # need-sub-make	1809	endif # need-sub-make
1810		1810

arch/arc/Kconfig+2−2

@@ -154,7 +154,7 @@ config ARC_CPU_HS · 153 unmodified lines
154	help	154	help
155	Support for ARC HS38x Cores based on ARCv2 ISA	155	Support for ARC HS38x Cores based on ARCv2 ISA
156	The notable features are:	156	The notable features are:
157	- SMP configurations of upto 4 core with coherency	157	- SMP configurations of up to 4 cores with coherency
158	- Optional L2 Cache and IO-Coherency	158	- Optional L2 Cache and IO-Coherency
159	- Revised Interrupt Architecture (multiple priorites, reg banks,	159	- Revised Interrupt Architecture (multiple priorites, reg banks,
160	auto stack switch, auto regfile save/restore)	160	auto stack switch, auto regfile save/restore)
@@ -192,7 +192,7 @@ config ARC_SMP_HALT_ON_RESET · 31 unmodified lines
192	help	192	help
193	In SMP configuration cores can be configured as Halt-on-reset	193	In SMP configuration cores can be configured as Halt-on-reset
194	or they could all start at same time. For Halt-on-reset, non	194	or they could all start at same time. For Halt-on-reset, non
195	masters are parked until Master kicks them so they can start of	195	masters are parked until Master kicks them so they can start off
196	at designated entry point. For other case, all jump to common	196	at designated entry point. For other case, all jump to common
197	entry point and spin wait for Master's signal.	197	entry point and spin wait for Master's signal.
198		198

arch/arc/configs/nps_defconfig+0−2

 CONFIG_MODULE_FORCE_LOAD=y
 CONFIG_MODULE_UNLOAD=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ARC_PLAT_EZNPS=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=4096

arch/arc/configs/nsimosci_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ARC_BUILTIN_DTB_NAME="nsimosci"
 # CONFIG_COMPACTION is not set
 CONFIG_NET=y

arch/arc/configs/nsimosci_hs_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ISA_ARCV2=y
 CONFIG_ARC_BUILTIN_DTB_NAME="nsimosci_hs"
 # CONFIG_COMPACTION is not set

arch/arc/configs/nsimosci_hs_smp_defconfig+0−2

 CONFIG_KPROBES=y
 CONFIG_MODULES=y
 # CONFIG_BLK_DEV_BSG is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-# CONFIG_IOSCHED_CFQ is not set
 CONFIG_ISA_ARCV2=y
 CONFIG_SMP=y
 # CONFIG_ARC_TIMERS_64BIT is not set

arch/arc/include/asm/fpu.h+2−0

@@ -43,6 +43,8 @@ extern void fpu_init_task(struct pt_regs *regs); · 42 unmodified lines
43		43
44	#endif /* !CONFIG_ISA_ARCOMPACT */	44	#endif /* !CONFIG_ISA_ARCOMPACT */
45		45
		46	struct task_struct;
		47
46	extern void fpu_save_restore(struct task_struct p, struct task_struct n);	48	extern void fpu_save_restore(struct task_struct p, struct task_struct n);
47		49
48	#else /* !CONFIG_ARC_FPU_SAVE_RESTORE */	50	#else /* !CONFIG_ARC_FPU_SAVE_RESTORE */

arch/arc/include/asm/linkage.h+2−0

@@ -29,6 +29,8 @@ · 28 unmodified lines
29	.endm	29	.endm
30		30
31	#define ASM_NL ` /* use '`' to mark new line in macro */	31	#define ASM_NL ` /* use '`' to mark new line in macro */
		32	#define __ALIGN .align 4
		33	#define __ALIGN_STR __stringify(__ALIGN)
32		34
33	/* annotation for data we want in DCCM - if enabled in .config */	35	/* annotation for data we want in DCCM - if enabled in .config */
34	.macro ARCFP_DATA nm	36	.macro ARCFP_DATA nm

arch/arc/kernel/setup.c+1−1

 #include <linux/delay.h>
 #include <linux/root_dev.h>
 #include <linux/clk.h>
-#include <linux/clk-provider.h>
 #include <linux/clocksource.h>
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/cpu.h>
+#include <linux/of_clk.h>
 #include <linux/of_fdt.h>
 #include <linux/of.h>
 #include <linux/cache.h>

arch/arc/kernel/troubleshoot.c+12−15

 			if (IS_ERR(nm))
 				nm = "?";
 		}
-		pr_info("    @off 0x%lx in [%s]\n"
+		pr_info("  @off 0x%lx in [%s]  VMA: 0x%08lx to 0x%08lx\n",
-			"    VMA: 0x%08lx to 0x%08lx\n",
 			vma->vm_start < TASK_UNMAPPED_BASE ?
 				address : address - vma->vm_start,
 			nm, vma->vm_start, vma->vm_end);
 	unsigned int vec, cause_code;
 	unsigned long address;
-	pr_info("\n[ECR   ]: 0x%08lx => ", regs->event);
 	/* For Data fault, this is data address not instruction addr */
 	address = current->thread.fault_address;
 	/* For DTLB Miss or ProtV, display the memory involved too */
 	if (vec == ECR_V_DTLB_MISS) {
-		pr_cont("Invalid %s @ 0x%08lx by insn @ 0x%08lx\n",
+		pr_cont("Invalid %s @ 0x%08lx by insn @ %pS\n",
 		       (cause_code == 0x01) ? "Read" :
 		       ((cause_code == 0x02) ? "Write" : "EX"),
-		       address, regs->ret);
+		       address, (void *)regs->ret);
 	} else if (vec == ECR_V_ITLB_MISS) {
 		pr_cont("Insn could not be fetched\n");
 	} else if (vec == ECR_V_MACH_CHK) {
 	show_ecr_verbose(regs);
-	pr_info("[EFA   ]: 0x%08lx\n[BLINK ]: %pS\n[ERET  ]: %pS\n",
-		current->thread.fault_address,
-		(void *)regs->blink, (void *)regs->ret);
 	if (user_mode(regs))
 		show_faulting_vma(regs->ret); /* faulting code, not data */
-	pr_info("[STAT32]: 0x%08lx", regs->status32);
+	pr_info("ECR: 0x%08lx EFA: 0x%08lx ERET: 0x%08lx\n",
+		regs->event, current->thread.fault_address, regs->ret);
+	pr_info("STAT32: 0x%08lx", regs->status32);
 #define STS_BIT(r, bit)	r->status32 & STATUS_##bit##_MASK ? #bit" " : ""
 #ifdef CONFIG_ISA_ARCOMPACT
-	pr_cont(" : %2s%2s%2s%2s%2s%2s%2s\n",
+	pr_cont(" [%2s%2s%2s%2s%2s%2s%2s]",
 			(regs->status32 & STATUS_U_MASK) ? "U " : "K ",
 			STS_BIT(regs, DE), STS_BIT(regs, AE),
 			STS_BIT(regs, A2), STS_BIT(regs, A1),
 			STS_BIT(regs, E2), STS_BIT(regs, E1));
 #else
-	pr_cont(" : %2s%2s%2s%2s\n",
+	pr_cont(" [%2s%2s%2s%2s]",
 			STS_BIT(regs, IE),
 			(regs->status32 & STATUS_U_MASK) ? "U " : "K ",
 			STS_BIT(regs, DE), STS_BIT(regs, AE));
 #endif
-	pr_info("BTA: 0x%08lx\t SP: 0x%08lx\t FP: 0x%08lx\n",
+	pr_cont("  BTA: 0x%08lx\n", regs->bta);
-		regs->bta, regs->sp, regs->fp);
+	pr_info("BLK: %pS\n SP: 0x%08lx  FP: 0x%08lx\n",
+		(void *)regs->blink, regs->sp, regs->fp);
 	pr_info("LPS: 0x%08lx\tLPE: 0x%08lx\tLPC: 0x%08lx\n",
 	       regs->lp_start, regs->lp_end, regs->lp_count);

arch/arm/Makefile+3−1

 ifeq ($(CONFIG_STACKPROTECTOR_PER_TASK),y)
 prepare: stack_protector_prepare
 stack_protector_prepare: prepare0
-	$(eval KBUILD_CFLAGS += \
+	$(eval SSP_PLUGIN_CFLAGS := \
 		-fplugin-arg-arm_ssp_per_task_plugin-tso=$(shell	\
 			awk '{if ($$2 == "THREAD_SZ_ORDER") print $$3;}'\
 				include/generated/asm-offsets.h)	\
 		-fplugin-arg-arm_ssp_per_task_plugin-offset=$(shell	\
 			awk '{if ($$2 == "TI_STACK_CANARY") print $$3;}'\
 				include/generated/asm-offsets.h))
+	$(eval KBUILD_CFLAGS += $(SSP_PLUGIN_CFLAGS))
+	$(eval GCC_PLUGINS_CFLAGS += $(SSP_PLUGIN_CFLAGS))
 endif
 all:	$(notdir $(KBUILD_IMAGE))

arch/arm/boot/compressed/Makefile+2−2

 		$(libfdt) $(libfdt_hdrs) hyp-stub.S
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
-KBUILD_CFLAGS += $(DISABLE_ARM_SSP_PER_TASK_PLUGIN)
 ifeq ($(CONFIG_FUNCTION_TRACER),y)
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
 CFLAGS_fdt_rw.o := $(nossp-flags-y)
 CFLAGS_fdt_wip.o := $(nossp-flags-y)
-ccflags-y := -fpic $(call cc-option,-mno-single-pic-base,) -fno-builtin -I$(obj)
+ccflags-y := -fpic $(call cc-option,-mno-single-pic-base,) -fno-builtin \
+	     -I$(obj) $(DISABLE_ARM_SSP_PER_TASK_PLUGIN)
 asflags-y := -DZIMAGE
 # Supply kernel BSS size to the decompressor via a linker symbol.

arch/arm/kernel/vdso.c+2−0

@@ -94,6 +94,8 @@ static bool __init cntvct_functional(void) · 93 unmodified lines
94	* this.	94	* this.
95	*/	95	*/
96	np = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");	96	np = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");
		97	if (!np)
		98	np = of_find_compatible_node(NULL, NULL, "arm,armv8-timer");
97	if (!np)	99	if (!np)
98	goto out_put;	100	goto out_put;
99		101

arch/arm/lib/copy_from_user.S+1−1

@@ -118,7 +118,7 @@ ENTRY(arm_copy_from_user) · 117 unmodified lines
118		118
119	ENDPROC(arm_copy_from_user)	119	ENDPROC(arm_copy_from_user)
120		120
121	.pushsection .fixup,"ax"	121	.pushsection .text.fixup,"ax"
122	.align 0	122	.align 0
123	copy_abort_preamble	123	copy_abort_preamble
124	ldmfd sp!, {r1, r2, r3}	124	ldmfd sp!, {r1, r2, r3}

arch/arm64/boot/dts/freescale/fsl-ls1043a-rdb.dts+2−2

@@ -119,12 +119,12 @@ · 118 unmodified lines
119		119
120	ethernet@e4000 {	120	ethernet@e4000 {
121	phy-handle = <&rgmii_phy1>;	121	phy-handle = <&rgmii_phy1>;
122	phy-connection-type = "rgmii-txid";	122	phy-connection-type = "rgmii-id";
123	};	123	};
124		124
125	ethernet@e6000 {	125	ethernet@e6000 {
126	phy-handle = <&rgmii_phy2>;	126	phy-handle = <&rgmii_phy2>;
127	phy-connection-type = "rgmii-txid";	127	phy-connection-type = "rgmii-id";
128	};	128	};
129		129
130	ethernet@e8000 {	130	ethernet@e8000 {

arch/arm64/boot/dts/freescale/fsl-ls1046a-rdb.dts+2−2

@@ -131,12 +131,12 @@ · 130 unmodified lines
131	&fman0 {	131	&fman0 {
132	ethernet@e4000 {	132	ethernet@e4000 {
133	phy-handle = <&rgmii_phy1>;	133	phy-handle = <&rgmii_phy1>;
134	phy-connection-type = "rgmii";	134	phy-connection-type = "rgmii-id";
135	};	135	};
136		136
137	ethernet@e6000 {	137	ethernet@e6000 {
138	phy-handle = <&rgmii_phy2>;	138	phy-handle = <&rgmii_phy2>;
139	phy-connection-type = "rgmii";	139	phy-connection-type = "rgmii-id";
140	};	140	};
141		141
142	ethernet@e8000 {	142	ethernet@e8000 {

arch/arm64/crypto/chacha-neon-glue.c+4−4

@@ -55,10 +55,10 @@ static void chacha_doneon(u32 state, u8 dst, const u8 *src, · 54 unmodified lines
55	break;	55	break;
56	}	56	}
57	chacha_4block_xor_neon(state, dst, src, nrounds, l);	57	chacha_4block_xor_neon(state, dst, src, nrounds, l);
58	bytes -= CHACHA_BLOCK_SIZE * 5;	58	bytes -= l;
59	src += CHACHA_BLOCK_SIZE * 5;	59	src += l;
60	dst += CHACHA_BLOCK_SIZE * 5;	60	dst += l;
61	state[12] += 5;	61	state[12] += DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE);
62	}	62	}
63	}	63	}
64		64

arch/arm64/include/asm/mmu.h+1−3

  */
 #define ASID(mm)	((mm)->context.id.counter & 0xffff)
-extern bool arm64_use_ng_mappings;
 static inline bool arm64_kernel_unmapped_at_el0(void)
 {
-	return arm64_use_ng_mappings;
+	return cpus_have_const_cap(ARM64_UNMAP_KERNEL_AT_EL0);
 }
 typedef void (*bp_hardening_cb_t)(void);

arch/arm64/include/asm/pgtable-prot.h+4−2

 #include <asm/pgtable-types.h>
+extern bool arm64_use_ng_mappings;
 #define _PROT_DEFAULT		(PTE_TYPE_PAGE | PTE_AF | PTE_SHARED)
 #define _PROT_SECT_DEFAULT	(PMD_TYPE_SECT | PMD_SECT_AF | PMD_SECT_S)
-#define PTE_MAYBE_NG		(arm64_kernel_unmapped_at_el0() ? PTE_NG : 0)
+#define PTE_MAYBE_NG		(arm64_use_ng_mappings ? PTE_NG : 0)
-#define PMD_MAYBE_NG		(arm64_kernel_unmapped_at_el0() ? PMD_SECT_NG : 0)
+#define PMD_MAYBE_NG		(arm64_use_ng_mappings ? PMD_SECT_NG : 0)
 #define PROT_DEFAULT		(_PROT_DEFAULT | PTE_MAYBE_NG)
 #define PROT_SECT_DEFAULT	(_PROT_SECT_DEFAULT | PMD_MAYBE_NG)

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

 #define __NR_compat_gettimeofday	78
 #define __NR_compat_sigreturn		119
 #define __NR_compat_rt_sigreturn	173
-#define __NR_compat_clock_getres	247
 #define __NR_compat_clock_gettime	263
+#define __NR_compat_clock_getres	264
 #define __NR_compat_clock_gettime64	403
 #define __NR_compat_clock_getres_time64	406

arch/arm64/kernel/smp.c+20−5

 }
 #endif
+/*
+ * The number of CPUs online, not counting this CPU (which may not be
+ * fully online and so not counted in num_online_cpus()).
+ */
+static inline unsigned int num_other_online_cpus(void)
+{
+	unsigned int this_cpu_online = cpu_online(smp_processor_id());
+	return num_online_cpus() - this_cpu_online;
+}
 void smp_send_stop(void)
 {
 	unsigned long timeout;
-	if (num_online_cpus() > 1) {
+	if (num_other_online_cpus()) {
 		cpumask_t mask;
 		cpumask_copy(&mask, cpu_online_mask);
 	/* Wait up to one second for other CPUs to stop */
 	timeout = USEC_PER_SEC;
-	while (num_online_cpus() > 1 && timeout--)
+	while (num_other_online_cpus() && timeout--)
 		udelay(1);
-	if (num_online_cpus() > 1)
+	if (num_other_online_cpus())
 		pr_warn("SMP: failed to stop secondary CPUs %*pbl\n",
 			cpumask_pr_args(cpu_online_mask));
 	cpus_stopped = 1;
-	if (num_online_cpus() == 1) {
+	/*
+	 * If this cpu is the only one alive at this point in time, online or
+	 * not, there are no stop messages to be sent around, so just back out.
+	 */
+	if (num_other_online_cpus() == 0) {
 		sdei_mask_local_cpu();
 		return;
 	}
 	cpumask_copy(&mask, cpu_online_mask);
 	cpumask_clear_cpu(smp_processor_id(), &mask);
-	atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
+	atomic_set(&waiting_for_crash_ipi, num_other_online_cpus());
 	pr_crit("SMP: stopping secondary CPUs\n");
 	smp_cross_call(&mask, IPI_CPU_CRASH_STOP);

arch/powerpc/kvm/book3s_pr.c+1−0

@@ -1817,6 +1817,7 @@ static void kvmppc_core_vcpu_free_pr(struct kvm_vcpu *vcpu) · 1816 unmodified lines
1817	{	1817	{
1818	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);	1818	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
1819		1819
		1820	kvmppc_mmu_destroy_pr(vcpu);
1820	free_page((unsigned long)vcpu->arch.shared & PAGE_MASK);	1821	free_page((unsigned long)vcpu->arch.shared & PAGE_MASK);
1821	#ifdef CONFIG_KVM_BOOK3S_32_HANDLER	1822	#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
1822	kfree(vcpu->arch.shadow_vcpu);	1823	kfree(vcpu->arch.shadow_vcpu);

arch/powerpc/kvm/powerpc.c+0−2

 	return 0;
 out_vcpu_uninit:
-	kvmppc_mmu_destroy(vcpu);
 	kvmppc_subarch_vcpu_uninit(vcpu);
 	return err;
 }
 	kvmppc_core_vcpu_free(vcpu);
-	kvmppc_mmu_destroy(vcpu);
 	kvmppc_subarch_vcpu_uninit(vcpu);
 }

arch/powerpc/mm/kasan/kasan_init_32.c+2−7

 	unsigned long k_cur;
 	phys_addr_t pa = __pa(kasan_early_shadow_page);
-	if (!early_mmu_has_feature(MMU_FTR_HPTE_TABLE)) {
-		int ret = kasan_init_shadow_page_tables(k_start, k_end);
-		if (ret)
-			panic("kasan: kasan_init_shadow_page_tables() failed");
-	}
 	for (k_cur = k_start & PAGE_MASK; k_cur < k_end; k_cur += PAGE_SIZE) {
 		pmd_t *pmd = pmd_offset(pud_offset(pgd_offset_k(k_cur), k_cur), k_cur);
 		pte_t *ptep = pte_offset_kernel(pmd, k_cur);
 	int ret;
 	struct memblock_region *reg;
-	if (early_mmu_has_feature(MMU_FTR_HPTE_TABLE)) {
+	if (early_mmu_has_feature(MMU_FTR_HPTE_TABLE) ||
+	    IS_ENABLED(CONFIG_KASAN_VMALLOC)) {
 		ret = kasan_init_shadow_page_tables(KASAN_SHADOW_START, KASAN_SHADOW_END);
 		if (ret)

arch/s390/kvm/kvm-s390.c+17−1

@@ -3268,7 +3268,10 @@ static void kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) · 3267 unmodified lines
3268	/* Initial reset is a superset of the normal reset */	3268	/* Initial reset is a superset of the normal reset */
3269	kvm_arch_vcpu_ioctl_normal_reset(vcpu);	3269	kvm_arch_vcpu_ioctl_normal_reset(vcpu);
3270		3270
3271	/* this equals initial cpu reset in pop, but we don't switch to ESA */	3271	/*
		3272	* This equals initial cpu reset in pop, but we don't switch to ESA.
		3273	* We do not only reset the internal data, but also ...
		3274	*/
3272	vcpu->arch.sie_block->gpsw.mask = 0;	3275	vcpu->arch.sie_block->gpsw.mask = 0;
3273	vcpu->arch.sie_block->gpsw.addr = 0;	3276	vcpu->arch.sie_block->gpsw.addr = 0;
3274	kvm_s390_set_prefix(vcpu, 0);	3277	kvm_s390_set_prefix(vcpu, 0);
@@ -3278,6 +3281,19 @@ static void kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) · 3 unmodified lines
3278	memset(vcpu->arch.sie_block->gcr, 0, sizeof(vcpu->arch.sie_block->gcr));	3281	memset(vcpu->arch.sie_block->gcr, 0, sizeof(vcpu->arch.sie_block->gcr));
3279	vcpu->arch.sie_block->gcr[0] = CR0_INITIAL_MASK;	3282	vcpu->arch.sie_block->gcr[0] = CR0_INITIAL_MASK;
3280	vcpu->arch.sie_block->gcr[14] = CR14_INITIAL_MASK;	3283	vcpu->arch.sie_block->gcr[14] = CR14_INITIAL_MASK;
		3284
		3285	/* ... the data in sync regs */
		3286	memset(vcpu->run->s.regs.crs, 0, sizeof(vcpu->run->s.regs.crs));
		3287	vcpu->run->s.regs.ckc = 0;
		3288	vcpu->run->s.regs.crs[0] = CR0_INITIAL_MASK;
		3289	vcpu->run->s.regs.crs[14] = CR14_INITIAL_MASK;
		3290	vcpu->run->psw_addr = 0;
		3291	vcpu->run->psw_mask = 0;
		3292	vcpu->run->s.regs.todpr = 0;
		3293	vcpu->run->s.regs.cputm = 0;
		3294	vcpu->run->s.regs.ckc = 0;
		3295	vcpu->run->s.regs.pp = 0;
		3296	vcpu->run->s.regs.gbea = 1;
3281	vcpu->run->s.regs.fpc = 0;	3297	vcpu->run->s.regs.fpc = 0;
3282	vcpu->arch.sie_block->gbea = 1;	3298	vcpu->arch.sie_block->gbea = 1;
3283	vcpu->arch.sie_block->pp = 0;	3299	vcpu->arch.sie_block->pp = 0;

arch/x86/events/amd/uncore.c+7−10

 	/*
 	 * NB and Last level cache counters (MSRs) are shared across all cores
-	 * that share the same NB / Last level cache. Interrupts can be directed
+	 * that share the same NB / Last level cache.  On family 16h and below,
-	 * to a single target core, however, event counts generated by processes
+	 * Interrupts can be directed to a single target core, however, event
-	 * running on other cores cannot be masked out. So we do not support
+	 * counts generated by processes running on other cores cannot be masked
-	 * sampling and per-thread events.
+	 * out. So we do not support sampling and per-thread events via
+	 * CAP_NO_INTERRUPT, and we do not enable counter overflow interrupts:
 	 */
-	if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK)
-		return -EINVAL;
-	/* and we do not enable counter overflow interrupts */
 	hwc->config = event->attr.config & AMD64_RAW_EVENT_MASK_NB;
 	hwc->idx = -1;
 	.start		= amd_uncore_start,
 	.stop		= amd_uncore_stop,
 	.read		= amd_uncore_read,
-	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE,
+	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT,
 };
 static struct pmu amd_llc_pmu = {
 	.start		= amd_uncore_start,
 	.stop		= amd_uncore_stop,
 	.read		= amd_uncore_read,
-	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE,
+	.capabilities	= PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT,
 };
 static struct amd_uncore *amd_uncore_alloc(unsigned int cpu)

arch/x86/include/asm/kvm_emulate.h+0−1

@@ -360,7 +360,6 @@ struct x86_emulate_ctxt { · 359 unmodified lines
360	u64 d;	360	u64 d;
361	unsigned long _eip;	361	unsigned long _eip;
362	struct operand memop;	362	struct operand memop;
363	/* Fields above regs are cleared together. */
364	unsigned long _regs[NR_VCPU_REGS];	363	unsigned long _regs[NR_VCPU_REGS];
365	struct operand *memopp;	364	struct operand *memopp;
366	struct fetch_cache fetch;	365	struct fetch_cache fetch;

arch/x86/kernel/apic/vector.c+8−6

 	bool managed = apicd->is_managed;
 	/*
-	 * This should never happen. Managed interrupts are not
+	 * Managed interrupts are usually not migrated away
-	 * migrated except on CPU down, which does not involve the
+	 * from an online CPU, but CPU isolation 'managed_irq'
-	 * cleanup vector. But try to keep the accounting correct
+	 * can make that happen.
-	 * nevertheless.
+	 * 1) Activation does not take the isolation into account
+	 *    to keep the code simple
+	 * 2) Migration away from an isolated CPU can happen when
+	 *    a non-isolated CPU which is in the calculated
+	 *    affinity mask comes online.
 	 */
-	WARN_ON_ONCE(managed);
 	trace_vector_free_moved(apicd->irq, cpu, vector, managed);
 	irq_matrix_free(vector_matrix, cpu, vector, managed);
 	per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;

arch/x86/kernel/cpu/mce/intel.c+5−4

 			return;
 		if ((val & 3UL) == 1UL) {
-			/* PPIN available but disabled: */
+			/* PPIN locked in disabled mode */
 			return;
 		}
-		/* If PPIN is disabled, but not locked, try to enable: */
+		/* If PPIN is disabled, try to enable */
-		if (!(val & 3UL)) {
+		if (!(val & 2UL)) {
 			wrmsrl_safe(MSR_PPIN_CTL,  val | 2UL);
 			rdmsrl_safe(MSR_PPIN_CTL, &val);
 		}
-		if ((val & 3UL) == 2UL)
+		/* Is the enable bit set? */
+		if (val & 2UL)
 			set_cpu_cap(c, X86_FEATURE_INTEL_PPIN);
 	}
 }

arch/x86/kernel/cpu/mce/therm_throt.c+7−2

 {
 	struct thermal_state *state = &per_cpu(thermal_state, cpu);
 	struct device *dev = get_cpu_device(cpu);
+	u32 l;
+	/* Mask the thermal vector before draining evtl. pending work */
+	l = apic_read(APIC_LVTTHMR);
+	apic_write(APIC_LVTTHMR, l | APIC_LVT_MASKED);
-	cancel_delayed_work(&state->package_throttle.therm_work);
+	cancel_delayed_work_sync(&state->package_throttle.therm_work);
-	cancel_delayed_work(&state->core_throttle.therm_work);
+	cancel_delayed_work_sync(&state->core_throttle.therm_work);
 	state->package_throttle.rate_control_active = false;
 	state->core_throttle.rate_control_active = false;

arch/x86/kvm/Kconfig+1−1

@@ -68,7 +68,7 @@ config KVM_WERROR · 67 unmodified lines
68	depends on (X86_64 && !KASAN) \|\| !COMPILE_TEST	68	depends on (X86_64 && !KASAN) \|\| !COMPILE_TEST
69	depends on EXPERT	69	depends on EXPERT
70	help	70	help
71	Add -Werror to the build flags for (and only for) i915.ko.	71	Add -Werror to the build flags for KVM.
72		72
73	If in doubt, say "N".	73	If in doubt, say "N".
74		74

arch/x86/kvm/emulate.c+1−0

@@ -5173,6 +5173,7 @@ int x86_decode_insn(struct x86_emulate_ctxt ctxt, void insn, int insn_len) · 5172 unmodified lines
5173	ctxt->fetch.ptr = ctxt->fetch.data;	5173	ctxt->fetch.ptr = ctxt->fetch.data;
5174	ctxt->fetch.end = ctxt->fetch.data + insn_len;	5174	ctxt->fetch.end = ctxt->fetch.data + insn_len;
5175	ctxt->opcode_len = 1;	5175	ctxt->opcode_len = 1;
		5176	ctxt->intercept = x86_intercept_none;
5176	if (insn_len > 0)	5177	if (insn_len > 0)
5177	memcpy(ctxt->fetch.data, insn, insn_len);	5178	memcpy(ctxt->fetch.data, insn, insn_len);
5178	else {	5179	else {

arch/x86/kvm/ioapic.c+5−2

 		if (e->fields.delivery_mode == APIC_DM_FIXED) {
 			struct kvm_lapic_irq irq;
-			irq.shorthand = APIC_DEST_NOSHORT;
 			irq.vector = e->fields.vector;
 			irq.delivery_mode = e->fields.delivery_mode << 8;
-			irq.dest_id = e->fields.dest_id;
 			irq.dest_mode =
 			    kvm_lapic_irq_dest_mode(!!e->fields.dest_mode);
+			irq.level = false;
+			irq.trig_mode = e->fields.trig_mode;
+			irq.shorthand = APIC_DEST_NOSHORT;
+			irq.dest_id = e->fields.dest_id;
+			irq.msi_redir_hint = false;
 			bitmap_zero(&vcpu_bitmap, 16);
 			kvm_bitmap_or_dest_vcpus(ioapic->kvm, &irq,
 						 &vcpu_bitmap);

arch/x86/kvm/svm.c+2−1

@@ -6312,7 +6312,8 @@ static void svm_handle_exit_irqoff(struct kvm_vcpu *vcpu, · 6311 unmodified lines
6312	enum exit_fastpath_completion *exit_fastpath)	6312	enum exit_fastpath_completion *exit_fastpath)
6313	{	6313	{
6314	if (!is_guest_mode(vcpu) &&	6314	if (!is_guest_mode(vcpu) &&
6315	to_svm(vcpu)->vmcb->control.exit_code == EXIT_REASON_MSR_WRITE)	6315	to_svm(vcpu)->vmcb->control.exit_code == SVM_EXIT_MSR &&
		6316	to_svm(vcpu)->vmcb->control.exit_info_1)
6316	*exit_fastpath = handle_fastpath_set_msr_irqoff(vcpu);	6317	*exit_fastpath = handle_fastpath_set_msr_irqoff(vcpu);
6317	}	6318	}
6318		6319

arch/x86/kvm/vmx/nested.c+3−2

 		return;
 	kvm_vcpu_unmap(vcpu, &vmx->nested.hv_evmcs_map, true);
-	vmx->nested.hv_evmcs_vmptr = -1ull;
+	vmx->nested.hv_evmcs_vmptr = 0;
 	vmx->nested.hv_evmcs = NULL;
 }
 	if (!nested_enlightened_vmentry(vcpu, &evmcs_gpa))
 		return 1;
-	if (unlikely(evmcs_gpa != vmx->nested.hv_evmcs_vmptr)) {
+	if (unlikely(!vmx->nested.hv_evmcs ||
+		     evmcs_gpa != vmx->nested.hv_evmcs_vmptr)) {
 		if (!vmx->nested.hv_evmcs)
 			vmx->nested.current_vmptr = -1ull;

arch/x86/kvm/vmx/vmx.c+14−2

 	kvm_cpu_vmxoff();
 }
+/*
+ * There is no X86_FEATURE for SGX yet, but anyway we need to query CPUID
+ * directly instead of going through cpu_has(), to ensure KVM is trapping
+ * ENCLS whenever it's supported in hardware.  It does not matter whether
+ * the host OS supports or has enabled SGX.
+ */
+static bool cpu_has_sgx(void)
+{
+	return cpuid_eax(0) >= 0x12 && (cpuid_eax(0x12) & BIT(0));
+}
 static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
 				      u32 msr, u32 *result)
 {
 			SECONDARY_EXEC_ENABLE_USR_WAIT_PAUSE |
 			SECONDARY_EXEC_PT_USE_GPA |
 			SECONDARY_EXEC_PT_CONCEAL_VMX |
-			SECONDARY_EXEC_ENABLE_VMFUNC |
+			SECONDARY_EXEC_ENABLE_VMFUNC;
-			SECONDARY_EXEC_ENCLS_EXITING;
+		if (cpu_has_sgx())
+			opt2 |= SECONDARY_EXEC_ENCLS_EXITING;
 		if (adjust_vmx_controls(min2, opt2,
 					MSR_IA32_VMX_PROCBASED_CTLS2,
 					&_cpu_based_2nd_exec_control) < 0)

arch/x86/kvm/x86.c+5−3

 		cpu = get_cpu();
 		policy = cpufreq_cpu_get(cpu);
-		if (policy && policy->cpuinfo.max_freq)
+		if (policy) {
-			max_tsc_khz = policy->cpuinfo.max_freq;
+			if (policy->cpuinfo.max_freq)
+				max_tsc_khz = policy->cpuinfo.max_freq;
+			cpufreq_cpu_put(policy);
+		}
 		put_cpu();
-		cpufreq_cpu_put(policy);
 #endif
 		cpufreq_register_notifier(&kvmclock_cpufreq_notifier_block,
 					  CPUFREQ_TRANSITION_NOTIFIER);

arch/x86/mm/fault.c+24−2

 	return pmd_k;
 }
-void vmalloc_sync_all(void)
+static void vmalloc_sync(void)
 {
 	unsigned long address;
 	}
 }
+void vmalloc_sync_mappings(void)
+{
+	vmalloc_sync();
+}
+void vmalloc_sync_unmappings(void)
+{
+	vmalloc_sync();
+}
 /*
  * 32-bit:
  *
 #else /* CONFIG_X86_64: */
-void vmalloc_sync_all(void)
+void vmalloc_sync_mappings(void)
 {
+	/*
+	 * 64-bit mappings might allocate new p4d/pud pages
+	 * that need to be propagated to all tasks' PGDs.
+	 */
 	sync_global_pgds(VMALLOC_START & PGDIR_MASK, VMALLOC_END);
 }
+void vmalloc_sync_unmappings(void)
+{
+	/*
+	 * Unmappings never allocate or free p4d/pud pages.
+	 * No work is required here.
+	 */
+}
 /*
  * 64-bit:
  *

arch/x86/mm/ioremap.c+21−0

@@ -106,6 +106,22 @@ static unsigned int __ioremap_check_encrypted(struct resource *res) · 105 unmodified lines
106	return 0;	106	return 0;
107	}	107	}
108		108
		109	/*
		110	* The EFI runtime services data area is not covered by walk_mem_res(), but must
		111	* be mapped encrypted when SEV is active.
		112	*/
		113	static void __ioremap_check_other(resource_size_t addr, struct ioremap_desc *desc)
		114	{
		115	if (!sev_active())
		116	return;
		117
		118	if (!IS_ENABLED(CONFIG_EFI))
		119	return;
		120
		121	if (efi_mem_type(addr) == EFI_RUNTIME_SERVICES_DATA)
		122	desc->flags \|= IORES_MAP_ENCRYPTED;
		123	}
		124
109	static int __ioremap_collect_map_flags(struct resource res, void arg)	125	static int __ioremap_collect_map_flags(struct resource res, void arg)
110	{	126	{
111	struct ioremap_desc *desc = arg;	127	struct ioremap_desc *desc = arg;
@@ -124,6 +140,9 @@ static int __ioremap_collect_map_flags(struct resource res, void arg) · 12 unmodified lines
124	* To avoid multiple resource walks, this function walks resources marked as	140	* To avoid multiple resource walks, this function walks resources marked as
125	* IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a	141	* IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
126	* resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).	142	* resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
		143	*
		144	* After that, deal with misc other ranges in __ioremap_check_other() which do
		145	* not fall into the above category.
127	*/	146	*/
128	static void __ioremap_check_mem(resource_size_t addr, unsigned long size,	147	static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
129	struct ioremap_desc *desc)	148	struct ioremap_desc *desc)
@@ -135,6 +154,8 @@ static void __ioremap_check_mem(resource_size_t addr, unsigned long size, · 5 unmodified lines
135	memset(desc, 0, sizeof(struct ioremap_desc));	154	memset(desc, 0, sizeof(struct ioremap_desc));
136		155
137	walk_mem_res(start, end, desc, __ioremap_collect_map_flags);	156	walk_mem_res(start, end, desc, __ioremap_collect_map_flags);
		157
		158	__ioremap_check_other(addr, desc);
138	}	159	}
139		160
140	/*	161	/*

arch/x86/net/bpf_jit_comp32.c+6−4

 			}
 			/* and dreg_lo,sreg_lo */
 			EMIT2(0x23, add_2reg(0xC0, sreg_lo, dreg_lo));
-			/* and dreg_hi,sreg_hi */
+			if (is_jmp64) {
-			EMIT2(0x23, add_2reg(0xC0, sreg_hi, dreg_hi));
+				/* and dreg_hi,sreg_hi */
-			/* or dreg_lo,dreg_hi */
+				EMIT2(0x23, add_2reg(0xC0, sreg_hi, dreg_hi));
-			EMIT2(0x09, add_2reg(0xC0, dreg_lo, dreg_hi));
+				/* or dreg_lo,dreg_hi */
+				EMIT2(0x09, add_2reg(0xC0, dreg_lo, dreg_hi));
+			}
 			goto emit_cond_jmp;
 		}
 		case BPF_JMP | BPF_JSET | BPF_K:

block/blk-iocost.c+1−1

@@ -1318,7 +1318,7 @@ static bool iocg_is_idle(struct ioc_gq *iocg) · 1317 unmodified lines
1318	return false;	1318	return false;
1319		1319
1320	/* is something in flight? */	1320	/* is something in flight? */
1321	if (atomic64_read(&iocg->done_vtime) < atomic64_read(&iocg->vtime))	1321	if (atomic64_read(&iocg->done_vtime) != atomic64_read(&iocg->vtime))
1322	return false;	1322	return false;
1323		1323
1324	return true;	1324	return true;

block/blk-mq-sched.c+22−0

@@ -398,6 +398,28 @@ void blk_mq_sched_insert_request(struct request *rq, bool at_head, · 397 unmodified lines
398	WARN_ON(e && (rq->tag != -1));	398	WARN_ON(e && (rq->tag != -1));
399		399
400	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {	400	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {
		401	/*
		402	* Firstly normal IO request is inserted to scheduler queue or
		403	* sw queue, meantime we add flush request to dispatch queue(
		404	* hctx->dispatch) directly and there is at most one in-flight
		405	* flush request for each hw queue, so it doesn't matter to add
		406	* flush request to tail or front of the dispatch queue.
		407	*
		408	* Secondly in case of NCQ, flush request belongs to non-NCQ
		409	* command, and queueing it will fail when there is any
		410	* in-flight normal IO request(NCQ command). When adding flush
		411	* rq to the front of hctx->dispatch, it is easier to introduce
		412	* extra time to flush rq's latency because of S_SCHED_RESTART
		413	* compared with adding to the tail of dispatch queue, then
		414	* chance of flush merge is increased, and less flush requests
		415	* will be issued to controller. It is observed that ~10% time
		416	* is saved in blktests block/004 on disk attached to AHCI/NCQ
		417	* drive when adding flush rq to the front of hctx->dispatch.
		418	*
		419	* Simply queue flush rq to the front of hctx->dispatch so that
		420	* intensive flush workloads can benefit in case of NCQ HW.
		421	*/
		422	at_head = (rq->rq_flags & RQF_FLUSH_SEQ) ? true : at_head;
401	blk_mq_request_bypass_insert(rq, at_head, false);	423	blk_mq_request_bypass_insert(rq, at_head, false);
402	goto run;	424	goto run;
403	}	425	}

block/genhd.c+36−0

@@ -301,6 +301,42 @@ struct hd_struct disk_map_sector_rcu(struct gendisk disk, sector_t sector) · 300 unmodified lines
301	}	301	}
302	EXPORT_SYMBOL_GPL(disk_map_sector_rcu);	302	EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
303		303
		304	/**
		305	* disk_has_partitions
		306	* @disk: gendisk of interest
		307	*
		308	* Walk through the partition table and check if valid partition exists.
		309	*
		310	* CONTEXT:
		311	* Don't care.
		312	*
		313	* RETURNS:
		314	* True if the gendisk has at least one valid non-zero size partition.
		315	* Otherwise false.
		316	*/
		317	bool disk_has_partitions(struct gendisk *disk)
		318	{
		319	struct disk_part_tbl *ptbl;
		320	int i;
		321	bool ret = false;
		322
		323	rcu_read_lock();
		324	ptbl = rcu_dereference(disk->part_tbl);
		325
		326	/* Iterate partitions skipping the whole device at index 0 */
		327	for (i = 1; i < ptbl->len; i++) {
		328	if (rcu_dereference(ptbl->part[i])) {
		329	ret = true;
		330	break;
		331	}
		332	}
		333
		334	rcu_read_unlock();
		335
		336	return ret;
		337	}
		338	EXPORT_SYMBOL_GPL(disk_has_partitions);
		339
304	/*	340	/*
305	* Can be deleted altogether. Later.	341	* Can be deleted altogether. Later.
306	*	342	*

drivers/acpi/apei/ghes.c+1−1

@@ -171,7 +171,7 @@ int ghes_estatus_pool_init(int num_ghes) · 170 unmodified lines
171	* New allocation must be visible in all pgd before it can be found by	171	* New allocation must be visible in all pgd before it can be found by
172	* an NMI allocating from the pool.	172	* an NMI allocating from the pool.
173	*/	173	*/
174	vmalloc_sync_all();	174	vmalloc_sync_mappings();
175		175
176	rc = gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1);	176	rc = gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1);
177	if (rc)	177	if (rc)

drivers/android/binderfs.c+1−0

@@ -448,6 +448,7 @@ static int binderfs_binder_ctl_create(struct super_block *sb) · 447 unmodified lines
448	inode->i_uid = info->root_uid;	448	inode->i_uid = info->root_uid;
449	inode->i_gid = info->root_gid;	449	inode->i_gid = info->root_gid;
450		450
		451	refcount_set(&device->ref, 1);
451	device->binderfs_inode = inode;	452	device->binderfs_inode = inode;
452	device->miscdev.minor = minor;	453	device->miscdev.minor = minor;
453		454

drivers/clk/clk.c+2−2

@@ -4713,7 +4713,7 @@ EXPORT_SYMBOL(of_clk_get_by_name); · 4712 unmodified lines
4713	*	4713	*
4714	* Returns: The number of clocks that are possible parents of this node	4714	* Returns: The number of clocks that are possible parents of this node
4715	*/	4715	*/
4716	unsigned int of_clk_get_parent_count(struct device_node *np)	4716	unsigned int of_clk_get_parent_count(const struct device_node *np)
4717	{	4717	{
4718	int count;	4718	int count;
4719		4719
@@ -4725,7 +4725,7 @@ unsigned int of_clk_get_parent_count(struct device_node *np) · 5 unmodified lines
4725	}	4725	}
4726	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);	4726	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
4727		4727
4728	const char of_clk_get_parent_name(struct device_node np, int index)	4728	const char of_clk_get_parent_name(const struct device_node np, int index)
4729	{	4729	{
4730	struct of_phandle_args clkspec;	4730	struct of_phandle_args clkspec;
4731	struct property *prop;	4731	struct property *prop;

drivers/clk/qcom/dispcc-sc7180.c+0−19

@@ -592,24 +592,6 @@ static struct clk_branch disp_cc_mdss_rot_clk = { · 591 unmodified lines
592	},	592	},
593	};	593	};
594		594
595	static struct clk_branch disp_cc_mdss_rscc_ahb_clk = {
596	.halt_reg = 0x400c,
597	.halt_check = BRANCH_HALT,
598	.clkr = {
599	.enable_reg = 0x400c,
600	.enable_mask = BIT(0),
601	.hw.init = &(struct clk_init_data){
602	.name = "disp_cc_mdss_rscc_ahb_clk",
603	.parent_data = &(const struct clk_parent_data){
604	.hw = &disp_cc_mdss_ahb_clk_src.clkr.hw,
605	},
606	.num_parents = 1,
607	.flags = CLK_IS_CRITICAL \| CLK_SET_RATE_PARENT,
608	.ops = &clk_branch2_ops,
609	},
610	},
611	};
612
613	static struct clk_branch disp_cc_mdss_rscc_vsync_clk = {	595	static struct clk_branch disp_cc_mdss_rscc_vsync_clk = {
614	.halt_reg = 0x4008,	596	.halt_reg = 0x4008,
615	.halt_check = BRANCH_HALT,	597	.halt_check = BRANCH_HALT,
@@ -687,7 +669,6 @@ static struct clk_regmap *disp_cc_sc7180_clocks[] = { · 71 unmodified lines
687	[DISP_CC_MDSS_PCLK0_CLK_SRC] = &disp_cc_mdss_pclk0_clk_src.clkr,	669	[DISP_CC_MDSS_PCLK0_CLK_SRC] = &disp_cc_mdss_pclk0_clk_src.clkr,
688	[DISP_CC_MDSS_ROT_CLK] = &disp_cc_mdss_rot_clk.clkr,	670	[DISP_CC_MDSS_ROT_CLK] = &disp_cc_mdss_rot_clk.clkr,
689	[DISP_CC_MDSS_ROT_CLK_SRC] = &disp_cc_mdss_rot_clk_src.clkr,	671	[DISP_CC_MDSS_ROT_CLK_SRC] = &disp_cc_mdss_rot_clk_src.clkr,
690	[DISP_CC_MDSS_RSCC_AHB_CLK] = &disp_cc_mdss_rscc_ahb_clk.clkr,
691	[DISP_CC_MDSS_RSCC_VSYNC_CLK] = &disp_cc_mdss_rscc_vsync_clk.clkr,	672	[DISP_CC_MDSS_RSCC_VSYNC_CLK] = &disp_cc_mdss_rscc_vsync_clk.clkr,
692	[DISP_CC_MDSS_VSYNC_CLK] = &disp_cc_mdss_vsync_clk.clkr,	673	[DISP_CC_MDSS_VSYNC_CLK] = &disp_cc_mdss_vsync_clk.clkr,
693	[DISP_CC_MDSS_VSYNC_CLK_SRC] = &disp_cc_mdss_vsync_clk_src.clkr,	674	[DISP_CC_MDSS_VSYNC_CLK_SRC] = &disp_cc_mdss_vsync_clk_src.clkr,

drivers/clk/qcom/videocc-sc7180.c+1−1

@@ -97,7 +97,7 @@ static struct clk_branch video_cc_vcodec0_axi_clk = { · 96 unmodified lines
97		97
98	static struct clk_branch video_cc_vcodec0_core_clk = {	98	static struct clk_branch video_cc_vcodec0_core_clk = {
99	.halt_reg = 0x890,	99	.halt_reg = 0x890,
100	.halt_check = BRANCH_HALT,	100	.halt_check = BRANCH_HALT_VOTED,
101	.clkr = {	101	.clkr = {
102	.enable_reg = 0x890,	102	.enable_reg = 0x890,
103	.enable_mask = BIT(0),	103	.enable_mask = BIT(0),

drivers/dma/dmaengine.c+1−1

@@ -1151,7 +1151,7 @@ int dma_async_device_register(struct dma_device *device) · 1150 unmodified lines
1151	}	1151	}
1152		1152
1153	if (!device->device_release)	1153	if (!device->device_release)
1154	dev_warn(device->dev,	1154	dev_dbg(device->dev,
1155	"WARN: Device release is not defined so it is not safe to unbind this driver while in use\n");	1155	"WARN: Device release is not defined so it is not safe to unbind this driver while in use\n");
1156		1156
1157	kref_init(&device->ref);	1157	kref_init(&device->ref);

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

@@ -81,9 +81,9 @@ static int idxd_cdev_open(struct inode inode, struct file filp) · 80 unmodified lines
81	dev = &idxd->pdev->dev;	81	dev = &idxd->pdev->dev;
82	idxd_cdev = &wq->idxd_cdev;	82	idxd_cdev = &wq->idxd_cdev;
83		83
84	dev_dbg(dev, "%s called\n", __func__);	84	dev_dbg(dev, "%s called: %d\n", __func__, idxd_wq_refcount(wq));
85		85
86	if (idxd_wq_refcount(wq) > 1 && wq_dedicated(wq))	86	if (idxd_wq_refcount(wq) > 0 && wq_dedicated(wq))
87	return -EBUSY;	87	return -EBUSY;
88		88
89	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);	89	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

drivers/dma/ti/k3-udma-glue.c+19−10

@@ -564,12 +564,12 @@ static int k3_udma_glue_cfg_rx_flow(struct k3_udma_glue_rx_channel *rx_chn, · 563 unmodified lines
564	if (IS_ERR(flow->udma_rflow)) {	564	if (IS_ERR(flow->udma_rflow)) {
565	ret = PTR_ERR(flow->udma_rflow);	565	ret = PTR_ERR(flow->udma_rflow);
566	dev_err(dev, "UDMAX rflow get err %d\n", ret);	566	dev_err(dev, "UDMAX rflow get err %d\n", ret);
567	goto err;	567	return ret;
568	}	568	}
569		569
570	if (flow->udma_rflow_id != xudma_rflow_get_id(flow->udma_rflow)) {	570	if (flow->udma_rflow_id != xudma_rflow_get_id(flow->udma_rflow)) {
571	xudma_rflow_put(rx_chn->common.udmax, flow->udma_rflow);	571	ret = -ENODEV;
572	return -ENODEV;	572	goto err_rflow_put;
573	}	573	}
574		574
575	/* request and cfg rings */	575	/* request and cfg rings */
@@ -578,7 +578,7 @@ static int k3_udma_glue_cfg_rx_flow(struct k3_udma_glue_rx_channel *rx_chn, · 2 unmodified lines
578	if (!flow->ringrx) {	578	if (!flow->ringrx) {
579	ret = -ENODEV;	579	ret = -ENODEV;
580	dev_err(dev, "Failed to get RX ring\n");	580	dev_err(dev, "Failed to get RX ring\n");
581	goto err;	581	goto err_rflow_put;
582	}	582	}
583		583
584	flow->ringrxfdq = k3_ringacc_request_ring(rx_chn->common.ringacc,	584	flow->ringrxfdq = k3_ringacc_request_ring(rx_chn->common.ringacc,
@@ -586,19 +586,19 @@ static int k3_udma_glue_cfg_rx_flow(struct k3_udma_glue_rx_channel *rx_chn, · 1 unmodified line
586	if (!flow->ringrxfdq) {	586	if (!flow->ringrxfdq) {
587	ret = -ENODEV;	587	ret = -ENODEV;
588	dev_err(dev, "Failed to get RXFDQ ring\n");	588	dev_err(dev, "Failed to get RXFDQ ring\n");
589	goto err;	589	goto err_ringrx_free;
590	}	590	}
591		591
592	ret = k3_ringacc_ring_cfg(flow->ringrx, &flow_cfg->rx_cfg);	592	ret = k3_ringacc_ring_cfg(flow->ringrx, &flow_cfg->rx_cfg);
593	if (ret) {	593	if (ret) {
594	dev_err(dev, "Failed to cfg ringrx %d\n", ret);	594	dev_err(dev, "Failed to cfg ringrx %d\n", ret);
595	goto err;	595	goto err_ringrxfdq_free;
596	}	596	}
597		597
598	ret = k3_ringacc_ring_cfg(flow->ringrxfdq, &flow_cfg->rxfdq_cfg);	598	ret = k3_ringacc_ring_cfg(flow->ringrxfdq, &flow_cfg->rxfdq_cfg);
599	if (ret) {	599	if (ret) {
600	dev_err(dev, "Failed to cfg ringrxfdq %d\n", ret);	600	dev_err(dev, "Failed to cfg ringrxfdq %d\n", ret);
601	goto err;	601	goto err_ringrxfdq_free;
602	}	602	}
603		603
604	if (rx_chn->remote) {	604	if (rx_chn->remote) {
@@ -648,7 +648,7 @@ static int k3_udma_glue_cfg_rx_flow(struct k3_udma_glue_rx_channel *rx_chn, · 43 unmodified lines
648	if (ret) {	648	if (ret) {
649	dev_err(dev, "flow%d config failed: %d\n", flow->udma_rflow_id,	649	dev_err(dev, "flow%d config failed: %d\n", flow->udma_rflow_id,
650	ret);	650	ret);
651	goto err;	651	goto err_ringrxfdq_free;
652	}	652	}
653		653
654	rx_chn->flows_ready++;	654	rx_chn->flows_ready++;
@@ -656,8 +656,17 @@ static int k3_udma_glue_cfg_rx_flow(struct k3_udma_glue_rx_channel *rx_chn, · 1 unmodified line
656	flow->udma_rflow_id, rx_chn->flows_ready);	656	flow->udma_rflow_id, rx_chn->flows_ready);
657		657
658	return 0;	658	return 0;
659	err:	659
660	k3_udma_glue_release_rx_flow(rx_chn, flow_idx);	660	err_ringrxfdq_free:
		661	k3_ringacc_ring_free(flow->ringrxfdq);
		662
		663	err_ringrx_free:
		664	k3_ringacc_ring_free(flow->ringrx);
		665
		666	err_rflow_put:
		667	xudma_rflow_put(rx_chn->common.udmax, flow->udma_rflow);
		668	flow->udma_rflow = NULL;
		669
661	return ret;	670	return ret;
662	}	671	}
663		672

drivers/firmware/efi/efivars.c+23−9

 efivar_attr_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
 	char *str = buf;
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	if (var->Attributes & EFI_VARIABLE_NON_VOLATILE)
 efivar_size_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
 	char *str = buf;
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	str += sprintf(str, "0x%lx\n", var->DataSize);
 efivar_data_read(struct efivar_entry *entry, char *buf)
 {
 	struct efi_variable *var = &entry->var;
+	unsigned long size = sizeof(var->Data);
+	int ret;
 	if (!entry || !buf)
 		return -EINVAL;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &size, var->Data);
-	if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+	var->DataSize = size;
+	if (ret)
 		return -EIO;
 	memcpy(buf, var->Data, var->DataSize);
 	u8 *data;
 	int err;
+	if (!entry || !buf)
+		return -EINVAL;
 	if (in_compat_syscall()) {
 		struct compat_efi_variable *compat;
 {
 	struct efi_variable *var = &entry->var;
 	struct compat_efi_variable *compat;
+	unsigned long datasize = sizeof(var->Data);
 	size_t size;
+	int ret;
 	if (!entry || !buf)
 		return 0;
-	var->DataSize = 1024;
+	ret = efivar_entry_get(entry, &var->Attributes, &datasize, var->Data);
-	if (efivar_entry_get(entry, &entry->var.Attributes,
+	var->DataSize = datasize;
-			     &entry->var.DataSize, entry->var.Data))
+	if (ret)
 		return -EIO;
 	if (in_compat_syscall()) {

drivers/gpio/gpiolib-acpi.c+114−26

@@ -21,18 +21,21 @@ · 20 unmodified lines
21	#include "gpiolib.h"	21	#include "gpiolib.h"
22	#include "gpiolib-acpi.h"	22	#include "gpiolib-acpi.h"
23		23
24	#define QUIRK_NO_EDGE_EVENTS_ON_BOOT 0x01l
25	#define QUIRK_NO_WAKEUP 0x02l
26
27	static int run_edge_events_on_boot = -1;	24	static int run_edge_events_on_boot = -1;
28	module_param(run_edge_events_on_boot, int, 0444);	25	module_param(run_edge_events_on_boot, int, 0444);
29	MODULE_PARM_DESC(run_edge_events_on_boot,	26	MODULE_PARM_DESC(run_edge_events_on_boot,
30	"Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto");	27	"Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto");
31		28
32	static int honor_wakeup = -1;	29	static char *ignore_wake;
33	module_param(honor_wakeup, int, 0444);	30	module_param(ignore_wake, charp, 0444);
34	MODULE_PARM_DESC(honor_wakeup,	31	MODULE_PARM_DESC(ignore_wake,
35	"Honor the ACPI wake-capable flag: 0=no, 1=yes, -1=auto");	32	"controller@pin combos on which to ignore the ACPI wake flag "
		33	"ignore_wake=controller@pin[,controller@pin[,...]]");
		34
		35	struct acpi_gpiolib_dmi_quirk {
		36	bool no_edge_events_on_boot;
		37	char *ignore_wake;
		38	};
36		39
37	/**	40	/**
38	* struct acpi_gpio_event - ACPI GPIO event handler data	41	* struct acpi_gpio_event - ACPI GPIO event handler data
@@ -202,6 +205,57 @@ static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio) · 163 unmodified lines
202	acpi_gpiochip_request_irq(acpi_gpio, event);	205	acpi_gpiochip_request_irq(acpi_gpio, event);
203	}	206	}
204		207
		208	static bool acpi_gpio_in_ignore_list(const char *controller_in, int pin_in)
		209	{
		210	const char controller, pin_str;
		211	int len, pin;
		212	char *endp;
		213
		214	controller = ignore_wake;
		215	while (controller) {
		216	pin_str = strchr(controller, '@');
		217	if (!pin_str)
		218	goto err;
		219
		220	len = pin_str - controller;
		221	if (len == strlen(controller_in) &&
		222	strncmp(controller, controller_in, len) == 0) {
		223	pin = simple_strtoul(pin_str + 1, &endp, 10);
		224	if (endp != 0 && endp != ',')
		225	goto err;
		226
		227	if (pin == pin_in)
		228	return true;
		229	}
		230
		231	controller = strchr(controller, ',');
		232	if (controller)
		233	controller++;
		234	}
		235
		236	return false;
		237	err:
		238	pr_err_once("Error invalid value for gpiolib_acpi.ignore_wake: %s\n",
		239	ignore_wake);
		240	return false;
		241	}
		242
		243	static bool acpi_gpio_irq_is_wake(struct device *parent,
		244	struct acpi_resource_gpio *agpio)
		245	{
		246	int pin = agpio->pin_table[0];
		247
		248	if (agpio->wake_capable != ACPI_WAKE_CAPABLE)
		249	return false;
		250
		251	if (acpi_gpio_in_ignore_list(dev_name(parent), pin)) {
		252	dev_info(parent, "Ignoring wakeup on pin %d\n", pin);
		253	return false;
		254	}
		255
		256	return true;
		257	}
		258
205	/* Always returns AE_OK so that we keep looping over the resources */	259	/* Always returns AE_OK so that we keep looping over the resources */
206	static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares,	260	static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares,
207	void *context)	261	void *context)
@@ -289,7 +343,7 @@ static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, · 81 unmodified lines
289	event->handle = evt_handle;	343	event->handle = evt_handle;
290	event->handler = handler;	344	event->handler = handler;
291	event->irq = irq;	345	event->irq = irq;
292	event->irq_is_wake = honor_wakeup && agpio->wake_capable == ACPI_WAKE_CAPABLE;	346	event->irq_is_wake = acpi_gpio_irq_is_wake(chip->parent, agpio);
293	event->pin = pin;	347	event->pin = pin;
294	event->desc = desc;	348	event->desc = desc;
295		349
@@ -1328,7 +1382,9 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { · 1032 unmodified lines
1328	DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),	1382	DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),
1329	DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),	1383	DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),
1330	},	1384	},
1331	.driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT,	1385	.driver_data = &(struct acpi_gpiolib_dmi_quirk) {
		1386	.no_edge_events_on_boot = true,
		1387	},
1332	},	1388	},
1333	{	1389	{
1334	/*	1390	/*
@@ -1341,16 +1397,20 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { · 6 unmodified lines
1341	DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"),	1397	DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"),
1342	DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"),	1398	DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"),
1343	},	1399	},
1344	.driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT,	1400	.driver_data = &(struct acpi_gpiolib_dmi_quirk) {
		1401	.no_edge_events_on_boot = true,
		1402	},
1345	},	1403	},
1346	{	1404	{
1347	/*	1405	/*
1348	* Various HP X2 10 Cherry Trail models use an external	1406	* HP X2 10 models with Cherry Trail SoC + TI PMIC use an
1349	* embedded-controller connected via I2C + an ACPI GPIO	1407	* external embedded-controller connected via I2C + an ACPI GPIO
1350	* event handler. The embedded controller generates various	1408	* event handler on INT33FF:01 pin 0, causing spurious wakeups.
1351	* spurious wakeup events when suspended. So disable wakeup	1409	* When suspending by closing the LID, the power to the USB
1352	* for its handler (it uses the only ACPI GPIO event handler).	1410	* keyboard is turned off, causing INT0002 ACPI events to
1353	* This breaks wakeup when opening the lid, the user needs	1411	* trigger once the XHCI controller notices the keyboard is
		1412	* gone. So INT0002 events cause spurious wakeups too. Ignoring
		1413	* EC wakes breaks wakeup when opening the lid, the user needs
1354	* to press the power-button to wakeup the system. The	1414	* to press the power-button to wakeup the system. The
1355	* alternative is suspend simply not working, which is worse.	1415	* alternative is suspend simply not working, which is worse.
1356	*/	1416	*/
@@ -1358,33 +1418,61 @@ static const struct dmi_system_id gpiolib_acpi_quirks[] = { · 1 unmodified line
1358	DMI_MATCH(DMI_SYS_VENDOR, "HP"),	1418	DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1359	DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),	1419	DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),
1360	},	1420	},
1361	.driver_data = (void *)QUIRK_NO_WAKEUP,	1421	.driver_data = &(struct acpi_gpiolib_dmi_quirk) {
		1422	.ignore_wake = "INT33FF:01@0,INT0002:00@2",
		1423	},
		1424	},
		1425	{
		1426	/*
		1427	* HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an
		1428	* external embedded-controller connected via I2C + an ACPI GPIO
		1429	* event handler on INT33FC:02 pin 28, causing spurious wakeups.
		1430	*/
		1431	.matches = {
		1432	DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
		1433	DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
		1434	DMI_MATCH(DMI_BOARD_NAME, "815D"),
		1435	},
		1436	.driver_data = &(struct acpi_gpiolib_dmi_quirk) {
		1437	.ignore_wake = "INT33FC:02@28",
		1438	},
		1439	},
		1440	{
		1441	/*
		1442	* HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an
		1443	* external embedded-controller connected via I2C + an ACPI GPIO
		1444	* event handler on INT33FF:01 pin 0, causing spurious wakeups.
		1445	*/
		1446	.matches = {
		1447	DMI_MATCH(DMI_SYS_VENDOR, "HP"),
		1448	DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
		1449	DMI_MATCH(DMI_BOARD_NAME, "813E"),
		1450	},
		1451	.driver_data = &(struct acpi_gpiolib_dmi_quirk) {
		1452	.ignore_wake = "INT33FF:01@0",
		1453	},
1362	},	1454	},
1363	{} /* Terminating entry */	1455	{} /* Terminating entry */
1364	};	1456	};
1365		1457
1366	static int acpi_gpio_setup_params(void)	1458	static int acpi_gpio_setup_params(void)
1367	{	1459	{
		1460	const struct acpi_gpiolib_dmi_quirk *quirk = NULL;
1368	const struct dmi_system_id *id;	1461	const struct dmi_system_id *id;
1369	long quirks = 0;
1370		1462
1371	id = dmi_first_match(gpiolib_acpi_quirks);	1463	id = dmi_first_match(gpiolib_acpi_quirks);
1372	if (id)	1464	if (id)
1373	quirks = (long)id->driver_data;	1465	quirk = id->driver_data;
1374		1466
1375	if (run_edge_events_on_boot < 0) {	1467	if (run_edge_events_on_boot < 0) {
1376	if (quirks & QUIRK_NO_EDGE_EVENTS_ON_BOOT)	1468	if (quirk && quirk->no_edge_events_on_boot)
1377	run_edge_events_on_boot = 0;	1469	run_edge_events_on_boot = 0;
1378	else	1470	else
1379	run_edge_events_on_boot = 1;	1471	run_edge_events_on_boot = 1;
1380	}	1472	}
1381		1473
1382	if (honor_wakeup < 0) {	1474	if (ignore_wake == NULL && quirk && quirk->ignore_wake)
1383	if (quirks & QUIRK_NO_WAKEUP)	1475	ignore_wake = quirk->ignore_wake;
1384	honor_wakeup = 0;
1385	else
1386	honor_wakeup = 1;
1387	}
1388		1476
1389	return 0;	1477	return 0;
1390	}	1478	}

drivers/gpio/gpiolib.c+8−1

 {
 	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
+	/*
+	 * Since we override .irq_disable() we need to mimic the
+	 * behaviour of __irq_disable() in irq/chip.c.
+	 * First call .irq_disable() if it exists, else mimic the
+	 * behaviour of mask_irq() which calls .irq_mask() if
+	 * it exists.
+	 */
 	if (chip->irq.irq_disable)
 		chip->irq.irq_disable(d);
-	else
+	else if (chip->irq.chip->irq_mask)
 		chip->irq.chip->irq_mask(d);
 	gpiochip_disable_irq(chip, d->hwirq);
 }

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c+3−3

@@ -781,11 +781,11 @@ static ssize_t amdgpu_debugfs_gpr_read(struct file f, char __user buf, · 780 unmodified lines
781	ssize_t result = 0;	781	ssize_t result = 0;
782	uint32_t offset, se, sh, cu, wave, simd, thread, bank, *data;	782	uint32_t offset, se, sh, cu, wave, simd, thread, bank, *data;
783		783
784	if (size & 3 \|\| *pos & 3)	784	if (size > 4096 \|\| size & 3 \|\| *pos & 3)
785	return -EINVAL;	785	return -EINVAL;
786		786
787	/* decode offset */	787	/* decode offset */
788	offset = *pos & GENMASK_ULL(11, 0);	788	offset = (*pos & GENMASK_ULL(11, 0)) >> 2;
789	se = (*pos & GENMASK_ULL(19, 12)) >> 12;	789	se = (*pos & GENMASK_ULL(19, 12)) >> 12;
790	sh = (*pos & GENMASK_ULL(27, 20)) >> 20;	790	sh = (*pos & GENMASK_ULL(27, 20)) >> 20;
791	cu = (*pos & GENMASK_ULL(35, 28)) >> 28;	791	cu = (*pos & GENMASK_ULL(35, 28)) >> 28;
@@ -823,7 +823,7 @@ static ssize_t amdgpu_debugfs_gpr_read(struct file f, char __user buf, · 31 unmodified lines
823	while (size) {	823	while (size) {
824	uint32_t value;	824	uint32_t value;
825		825
826	value = data[offset++];	826	value = data[result >> 2];
827	r = put_user(value, (uint32_t *)buf);	827	r = put_user(value, (uint32_t *)buf);
828	if (r) {	828	if (r) {
829	result = r;	829	result = r;

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

 				if (r)
 					goto out;
+				amdgpu_fbdev_set_suspend(tmp_adev, 0);
 				/* must succeed. */
 				amdgpu_ras_resume(tmp_adev);
 		 */
 		amdgpu_unregister_gpu_instance(tmp_adev);
+		amdgpu_fbdev_set_suspend(adev, 1);
 		/* disable ras on ALL IPs */
 		if (!(in_ras_intr && !use_baco) &&
 		      amdgpu_device_ip_need_full_reset(tmp_adev))

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

@@ -693,7 +693,7 @@ static int jpeg_v2_0_set_clockgating_state(void *handle, · 692 unmodified lines
693	bool enable = (state == AMD_CG_STATE_GATE);	693	bool enable = (state == AMD_CG_STATE_GATE);
694		694
695	if (enable) {	695	if (enable) {
696	if (jpeg_v2_0_is_idle(handle))	696	if (!jpeg_v2_0_is_idle(handle))
697	return -EBUSY;	697	return -EBUSY;
698	jpeg_v2_0_enable_clock_gating(adev);	698	jpeg_v2_0_enable_clock_gating(adev);
699	} else {	699	} else {

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

@@ -477,7 +477,7 @@ static int jpeg_v2_5_set_clockgating_state(void *handle, · 476 unmodified lines
477	continue;	477	continue;
478		478
479	if (enable) {	479	if (enable) {
480	if (jpeg_v2_5_is_idle(handle))	480	if (!jpeg_v2_5_is_idle(handle))
481	return -EBUSY;	481	return -EBUSY;
482	jpeg_v2_5_enable_clock_gating(adev, i);	482	jpeg_v2_5_enable_clock_gating(adev, i);
483	} else {	483	} else {

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

@@ -1352,7 +1352,7 @@ static int vcn_v1_0_set_clockgating_state(void *handle, · 1351 unmodified lines
1352		1352
1353	if (enable) {	1353	if (enable) {
1354	/* wait for STATUS to clear */	1354	/* wait for STATUS to clear */
1355	if (vcn_v1_0_is_idle(handle))	1355	if (!vcn_v1_0_is_idle(handle))
1356	return -EBUSY;	1356	return -EBUSY;
1357	vcn_v1_0_enable_clock_gating(adev);	1357	vcn_v1_0_enable_clock_gating(adev);
1358	} else {	1358	} else {

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

@@ -1217,7 +1217,7 @@ static int vcn_v2_0_set_clockgating_state(void *handle, · 1216 unmodified lines
1217		1217
1218	if (enable) {	1218	if (enable) {
1219	/* wait for STATUS to clear */	1219	/* wait for STATUS to clear */
1220	if (vcn_v2_0_is_idle(handle))	1220	if (!vcn_v2_0_is_idle(handle))
1221	return -EBUSY;	1221	return -EBUSY;
1222	vcn_v2_0_enable_clock_gating(adev);	1222	vcn_v2_0_enable_clock_gating(adev);
1223	} else {	1223	} else {

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

@@ -1672,7 +1672,7 @@ static int vcn_v2_5_set_clockgating_state(void *handle, · 1671 unmodified lines
1672	return 0;	1672	return 0;
1673		1673
1674	if (enable) {	1674	if (enable) {
1675	if (vcn_v2_5_is_idle(handle))	1675	if (!vcn_v2_5_is_idle(handle))
1676	return -EBUSY;	1676	return -EBUSY;
1677	vcn_v2_5_enable_clock_gating(adev);	1677	vcn_v2_5_enable_clock_gating(adev);
1678	} else {	1678	} else {

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

 	acrtc_state = to_dm_crtc_state(acrtc->base.state);
-	DRM_DEBUG_DRIVER("crtc:%d, vupdate-vrr:%d\n", acrtc->crtc_id,
+	DRM_DEBUG_DRIVER("crtc:%d, vupdate-vrr:%d, planes:%d\n", acrtc->crtc_id,
-				amdgpu_dm_vrr_active(acrtc_state));
+			 amdgpu_dm_vrr_active(acrtc_state),
+			 acrtc_state->active_planes);
 	amdgpu_dm_crtc_handle_crc_irq(&acrtc->base);
 	drm_crtc_handle_vblank(&acrtc->base);
 			&acrtc_state->vrr_params.adjust);
 	}
-	if (acrtc->pflip_status == AMDGPU_FLIP_SUBMITTED) {
+	/*
+	 * If there aren't any active_planes then DCH HUBP may be clock-gated.
+	 * In that case, pageflip completion interrupts won't fire and pageflip
+	 * completion events won't get delivered. Prevent this by sending
+	 * pending pageflip events from here if a flip is still pending.
+	 *
+	 * If any planes are enabled, use dm_pflip_high_irq() instead, to
+	 * avoid race conditions between flip programming and completion,
+	 * which could cause too early flip completion events.
+	 */
+	if (acrtc->pflip_status == AMDGPU_FLIP_SUBMITTED &&
+	    acrtc_state->active_planes == 0) {
 		if (acrtc->event) {
 			drm_crtc_send_vblank_event(&acrtc->base, acrtc->event);
 			acrtc->event = NULL;

drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c+11−0

@@ -3401,6 +3401,17 @@ static bool retrieve_link_cap(struct dc_link *link) · 3400 unmodified lines
3401	sink_id.ieee_device_id,	3401	sink_id.ieee_device_id,
3402	sizeof(sink_id.ieee_device_id));	3402	sizeof(sink_id.ieee_device_id));
3403		3403
		3404	/* Quirk Apple MBP 2017 15" Retina panel: Wrong DP_MAX_LINK_RATE */
		3405	{
		3406	uint8_t str_mbp_2017[] = { 101, 68, 21, 101, 98, 97 };
		3407
		3408	if ((link->dpcd_caps.sink_dev_id == 0x0010fa) &&
		3409	!memcmp(link->dpcd_caps.sink_dev_id_str, str_mbp_2017,
		3410	sizeof(str_mbp_2017))) {
		3411	link->reported_link_cap.link_rate = 0x0c;
		3412	}
		3413	}
		3414
3404	core_link_read_dpcd(	3415	core_link_read_dpcd(
3405	link,	3416	link,
3406	DP_SINK_HW_REVISION_START,	3417	DP_SINK_HW_REVISION_START,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_init.c+0−1

@@ -108,7 +108,6 @@ static const struct hwseq_private_funcs dcn20_private_funcs = { · 107 unmodified lines
108	.enable_power_gating_plane = dcn20_enable_power_gating_plane,	108	.enable_power_gating_plane = dcn20_enable_power_gating_plane,
109	.dpp_pg_control = dcn20_dpp_pg_control,	109	.dpp_pg_control = dcn20_dpp_pg_control,
110	.hubp_pg_control = dcn20_hubp_pg_control,	110	.hubp_pg_control = dcn20_hubp_pg_control,
111	.dsc_pg_control = NULL,
112	.update_odm = dcn20_update_odm,	111	.update_odm = dcn20_update_odm,
113	.dsc_pg_control = dcn20_dsc_pg_control,	112	.dsc_pg_control = dcn20_dsc_pg_control,
114	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,	113	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_init.c+0−1

@@ -116,7 +116,6 @@ static const struct hwseq_private_funcs dcn21_private_funcs = { · 115 unmodified lines
116	.enable_power_gating_plane = dcn20_enable_power_gating_plane,	116	.enable_power_gating_plane = dcn20_enable_power_gating_plane,
117	.dpp_pg_control = dcn20_dpp_pg_control,	117	.dpp_pg_control = dcn20_dpp_pg_control,
118	.hubp_pg_control = dcn20_hubp_pg_control,	118	.hubp_pg_control = dcn20_hubp_pg_control,
119	.dsc_pg_control = NULL,
120	.update_odm = dcn20_update_odm,	119	.update_odm = dcn20_update_odm,
121	.dsc_pg_control = dcn20_dsc_pg_control,	120	.dsc_pg_control = dcn20_dsc_pg_control,
122	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,	121	.get_surface_visual_confirm_color = dcn10_get_surface_visual_confirm_color,

drivers/gpu/drm/arm/display/komeda/komeda_drv.c+2−2

@@ -146,14 +146,14 @@ static const struct of_device_id komeda_of_match[] = { · 145 unmodified lines
146		146
147	MODULE_DEVICE_TABLE(of, komeda_of_match);	147	MODULE_DEVICE_TABLE(of, komeda_of_match);
148		148
149	static int komeda_rt_pm_suspend(struct device *dev)	149	static int __maybe_unused komeda_rt_pm_suspend(struct device *dev)
150	{	150	{
151	struct komeda_drv *mdrv = dev_get_drvdata(dev);	151	struct komeda_drv *mdrv = dev_get_drvdata(dev);
152		152
153	return komeda_dev_suspend(mdrv->mdev);	153	return komeda_dev_suspend(mdrv->mdev);
154	}	154	}
155		155
156	static int komeda_rt_pm_resume(struct device *dev)	156	static int __maybe_unused komeda_rt_pm_resume(struct device *dev)
157	{	157	{
158	struct komeda_drv *mdrv = dev_get_drvdata(dev);	158	struct komeda_drv *mdrv = dev_get_drvdata(dev);
159		159

drivers/gpu/drm/bochs/bochs_hw.c+2−4

 		size = min(size, mem);
 	}
-	if (pci_request_region(pdev, 0, "bochs-drm") != 0) {
+	if (pci_request_region(pdev, 0, "bochs-drm") != 0)
-		DRM_ERROR("Cannot request framebuffer\n");
+		DRM_WARN("Cannot request framebuffer, boot fb still active?\n");
-		return -EBUSY;
-	}
 	bochs->fb_map = ioremap(addr, size);
 	if (bochs->fb_map == NULL) {

drivers/gpu/drm/bridge/synopsys/dw-hdmi.c+26−20

 		frame.colorspace = HDMI_COLORSPACE_RGB;
 	/* Set up colorimetry */
-	switch (hdmi->hdmi_data.enc_out_encoding) {
+	if (!hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format)) {
-	case V4L2_YCBCR_ENC_601:
+		switch (hdmi->hdmi_data.enc_out_encoding) {
-		if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV601)
+		case V4L2_YCBCR_ENC_601:
-			frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV601)
-		else
+				frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			else
+				frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			break;
+		case V4L2_YCBCR_ENC_709:
+			if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV709)
+				frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
+			else
+				frame.colorimetry = HDMI_COLORIMETRY_ITU_709;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
+			break;
+		default: /* Carries no data */
 			frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
+			frame.extended_colorimetry =
+					HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			break;
+		}
+	} else {
+		frame.colorimetry = HDMI_COLORIMETRY_NONE;
 		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+			HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
-		break;
-	case V4L2_YCBCR_ENC_709:
-		if (hdmi->hdmi_data.enc_in_encoding == V4L2_YCBCR_ENC_XV709)
-			frame.colorimetry = HDMI_COLORIMETRY_EXTENDED;
-		else
-			frame.colorimetry = HDMI_COLORIMETRY_ITU_709;
-		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
-		break;
-	default: /* Carries no data */
-		frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
-		frame.extended_colorimetry =
-				HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
-		break;
 	}
 	frame.scan_mode = HDMI_SCAN_MODE_NONE;

drivers/gpu/drm/drm_lease.c+2−1

 	}
 	DRM_DEBUG_LEASE("Creating lease\n");
+	/* lessee will take the ownership of leases */
 	lessee = drm_lease_create(lessor, &leases);
 	if (IS_ERR(lessee)) {
 		ret = PTR_ERR(lessee);
+		idr_destroy(&leases);
 		goto out_leases;
 	}
 out_leases:
 	put_unused_fd(fd);
-	idr_destroy(&leases);
 	DRM_DEBUG_LEASE("drm_mode_create_lease_ioctl failed: %d\n", ret);
 	return ret;

drivers/gpu/drm/i915/gt/intel_lrc.c+12−40

 	spin_unlock(&old->breadcrumbs.irq_lock);
 }
-static struct i915_request *
-last_active(const struct intel_engine_execlists *execlists)
-{
-	struct i915_request * const *last = READ_ONCE(execlists->active);
-	while (*last && i915_request_completed(*last))
-		last++;
-	return *last;
-}
 #define for_each_waiter(p__, rq__) \
 	list_for_each_entry_lockless(p__, \
 				     &(rq__)->sched.waiters_list, \
 	(void)I915_SELFTEST_ONLY(execlists->preempt_hang.count++);
 }
-static unsigned long active_preempt_timeout(struct intel_engine_cs *engine)
+static unsigned long active_preempt_timeout(struct intel_engine_cs *engine,
+					    const struct i915_request *rq)
 {
-	struct i915_request *rq;
-	rq = last_active(&engine->execlists);
 	if (!rq)
 		return 0;
 	return READ_ONCE(engine->props.preempt_timeout_ms);
 }
-static void set_preempt_timeout(struct intel_engine_cs *engine)
+static void set_preempt_timeout(struct intel_engine_cs *engine,
+				const struct i915_request *rq)
 {
 	if (!intel_engine_has_preempt_reset(engine))
 		return;
 	set_timer_ms(&engine->execlists.preempt,
-		     active_preempt_timeout(engine));
+		     active_preempt_timeout(engine, rq));
 }
 static inline void clear_ports(struct i915_request **ports, int count)
 	struct intel_engine_execlists * const execlists = &engine->execlists;
 	struct i915_request **port = execlists->pending;
 	struct i915_request ** const last_port = port + execlists->port_mask;
+	struct i915_request * const *active;
 	struct i915_request *last;
 	struct rb_node *rb;
 	bool submit = false;
 	 * i.e. we will retrigger preemption following the ack in case
 	 * of trouble.
 	 */
-	last = last_active(execlists);
+	active = READ_ONCE(execlists->active);
+	while ((last = *active) && i915_request_completed(last))
+		active++;
 	if (last) {
 		if (need_preempt(engine, last, rb)) {
 			ENGINE_TRACE(engine,
 		 * Skip if we ended up with exactly the same set of requests,
 		 * e.g. trying to timeslice a pair of ordered contexts
 		 */
-		if (!memcmp(execlists->active, execlists->pending,
+		if (!memcmp(active, execlists->pending,
 			    (port - execlists->pending + 1) * sizeof(*port))) {
 			do
 				execlists_schedule_out(fetch_and_zero(port));
 		clear_ports(port + 1, last_port - port);
 		execlists_submit_ports(engine);
-		set_preempt_timeout(engine);
+		set_preempt_timeout(engine, *active);
 	} else {
 skip_submit:
 		ring_set_paused(engine, 0);
 		*cs++ = preparser_disable(false);
 		intel_ring_advance(request, cs);
-		/*
-		 * Wa_1604544889:tgl
-		 */
-		if (IS_TGL_REVID(request->i915, TGL_REVID_A0, TGL_REVID_A0)) {
-			flags = 0;
-			flags |= PIPE_CONTROL_CS_STALL;
-			flags |= PIPE_CONTROL_HDC_PIPELINE_FLUSH;
-			flags |= PIPE_CONTROL_STORE_DATA_INDEX;
-			flags |= PIPE_CONTROL_QW_WRITE;
-			cs = intel_ring_begin(request, 6);
-			if (IS_ERR(cs))
-				return PTR_ERR(cs);
-			cs = gen8_emit_pipe_control(cs, flags,
-						    LRC_PPHWSP_SCRATCH_ADDR);
-			intel_ring_advance(request, cs);
-		}
 	}
 	return 0;

drivers/gpu/drm/i915/gt/intel_workarounds.c+22−3

@@ -1529,15 +1529,34 @@ err_obj: · 1528 unmodified lines
1529	return ERR_PTR(err);	1529	return ERR_PTR(err);
1530	}	1530	}
1531		1531
		1532	static const struct {
		1533	u32 start;
		1534	u32 end;
		1535	} mcr_ranges_gen8[] = {
		1536	{ .start = 0x5500, .end = 0x55ff },
		1537	{ .start = 0x7000, .end = 0x7fff },
		1538	{ .start = 0x9400, .end = 0x97ff },
		1539	{ .start = 0xb000, .end = 0xb3ff },
		1540	{ .start = 0xe000, .end = 0xe7ff },
		1541	{},
		1542	};
		1543
1532	static bool mcr_range(struct drm_i915_private *i915, u32 offset)	1544	static bool mcr_range(struct drm_i915_private *i915, u32 offset)
1533	{	1545	{
		1546	int i;
		1547
		1548	if (INTEL_GEN(i915) < 8)
		1549	return false;
		1550
1534	/*	1551	/*
1535	* Registers in this range are affected by the MCR selector	1552	* Registers in these ranges are affected by the MCR selector
1536	* which only controls CPU initiated MMIO. Routing does not	1553	* which only controls CPU initiated MMIO. Routing does not
1537	* work for CS access so we cannot verify them on this path.	1554	* work for CS access so we cannot verify them on this path.
1538	*/	1555	*/
1539	if (INTEL_GEN(i915) >= 8 && (offset >= 0xb000 && offset <= 0xb4ff))	1556	for (i = 0; mcr_ranges_gen8[i].start; i++)
1540	return true;	1557	if (offset >= mcr_ranges_gen8[i].start &&
		1558	offset <= mcr_ranges_gen8[i].end)
		1559	return true;
1541		1560
1542	return false;	1561	return false;
1543	}	1562	}

drivers/hid/hid-google-hammer.c+2−0

 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
+	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
+		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,

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

 #define USB_DEVICE_ID_GOOGLE_WHISKERS	0x5030
 #define USB_DEVICE_ID_GOOGLE_MASTERBALL	0x503c
 #define USB_DEVICE_ID_GOOGLE_MAGNEMITE	0x503d
+#define USB_DEVICE_ID_GOOGLE_MOONBALL	0x5044
 #define USB_VENDOR_ID_GOTOP		0x08f2
 #define USB_DEVICE_ID_SUPER_Q2		0x007f
 #define USB_DEVICE_ID_LENOVO_X1_COVER	0x6085
 #define USB_DEVICE_ID_LENOVO_X1_TAB	0x60a3
 #define USB_DEVICE_ID_LENOVO_X1_TAB3	0x60b5
+#define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D	0x608d
 #define USB_VENDOR_ID_LG		0x1fd2
 #define USB_DEVICE_ID_LG_MULTITOUCH	0x0064

drivers/hid/hid-picolcd_fb.c+2−2

@@ -458,9 +458,9 @@ static ssize_t picolcd_fb_update_rate_show(struct device *dev, · 457 unmodified lines
458	if (ret >= PAGE_SIZE)	458	if (ret >= PAGE_SIZE)
459	break;	459	break;
460	else if (i == fb_update_rate)	460	else if (i == fb_update_rate)
461	ret += snprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);	461	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i);
462	else	462	else
463	ret += snprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);	463	ret += scnprintf(buf+ret, PAGE_SIZE-ret, "%u ", i);
464	if (ret > 0)	464	if (ret > 0)
465	buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';	465	buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n';
466	return ret;	466	return ret;

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

@@ -103,6 +103,7 @@ static const struct hid_device_id hid_quirks[] = { · 102 unmodified lines
103	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT },	103	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT },
104	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT },	104	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT },
105	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL },	105	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL },
		106	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D), HID_QUIRK_ALWAYS_POLL },
106	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C007), HID_QUIRK_ALWAYS_POLL },	107	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C007), HID_QUIRK_ALWAYS_POLL },
107	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C077), HID_QUIRK_ALWAYS_POLL },	108	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_C077), HID_QUIRK_ALWAYS_POLL },
108	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KEYBOARD_G710_PLUS), HID_QUIRK_NOGET },	109	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KEYBOARD_G710_PLUS), HID_QUIRK_NOGET },

drivers/hid/hid-sensor-custom.c+3−3

@@ -313,7 +313,7 @@ static ssize_t show_value(struct device dev, struct device_attribute attr, · 312 unmodified lines
313		313
314	while (i < ret) {	314	while (i < ret) {
315	if (i + attribute->size > ret) {	315	if (i + attribute->size > ret) {
316	len += snprintf(&buf[len],	316	len += scnprintf(&buf[len],
317	PAGE_SIZE - len,	317	PAGE_SIZE - len,
318	"%d ", values[i]);	318	"%d ", values[i]);
319	break;	319	break;
@@ -336,10 +336,10 @@ static ssize_t show_value(struct device dev, struct device_attribute attr, · 16 unmodified lines
336	++i;	336	++i;
337	break;	337	break;
338	}	338	}
339	len += snprintf(&buf[len], PAGE_SIZE - len,	339	len += scnprintf(&buf[len], PAGE_SIZE - len,
340	"%lld ", value);	340	"%lld ", value);
341	}	341	}
342	len += snprintf(&buf[len], PAGE_SIZE - len, "\n");	342	len += scnprintf(&buf[len], PAGE_SIZE - len, "\n");
343		343
344	return len;	344	return len;
345	} else if (input)	345	} else if (input)

drivers/hwtracing/intel_th/msu.c+7−6

 	if (old != expect) {
 		ret = -EINVAL;
-		dev_warn_ratelimited(msc_dev(win->msc),
-				     "expected lockout state %d, got %d\n",
-				     expect, old);
 		goto unlock;
 	}
 		/* from intel_th_msc_window_unlock(), don't warn if not locked */
 		if (expect == WIN_LOCKED && old == new)
 			return 0;
+		dev_warn_ratelimited(msc_dev(win->msc),
+				     "expected lockout state %d, got %d\n",
+				     expect, old);
 	}
 	return ret;
 	lockdep_assert_held(&msc->buf_mutex);
 	if (msc->mode > MSC_MODE_MULTI)
-		return -ENOTSUPP;
+		return -EINVAL;
 	if (msc->mode == MSC_MODE_MULTI) {
 		if (msc_win_set_lockout(msc->cur_win, WIN_READY, WIN_INUSE))
 	} else if (msc->mode == MSC_MODE_MULTI) {
 		ret = msc_buffer_multi_alloc(msc, nr_pages, nr_wins);
 	} else {
-		ret = -ENOTSUPP;
+		ret = -EINVAL;
 	}
 	if (!ret) {
 		if (ret >= 0)
 			*ppos = iter->offset;
 	} else {
-		ret = -ENOTSUPP;
+		ret = -EINVAL;
 	}
 put_count:

drivers/hwtracing/intel_th/pci.c+5−0

 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4da6),
 		.driver_data = (kernel_ulong_t)&intel_th_2x,
 	},
+	{
+		/* Elkhart Lake CPU */
+		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4529),
+		.driver_data = (kernel_ulong_t)&intel_th_2x,
+	},
 	{
 		/* Elkhart Lake */
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4b26),

drivers/hwtracing/stm/p_sys-t.c+3−3

@@ -238,7 +238,7 @@ static struct configfs_attribute *sys_t_policy_attrs[] = { · 237 unmodified lines
238	static inline bool sys_t_need_ts(struct sys_t_output *op)	238	static inline bool sys_t_need_ts(struct sys_t_output *op)
239	{	239	{
240	if (op->node.ts_interval &&	240	if (op->node.ts_interval &&
241	time_after(op->ts_jiffies + op->node.ts_interval, jiffies)) {	241	time_after(jiffies, op->ts_jiffies + op->node.ts_interval)) {
242	op->ts_jiffies = jiffies;	242	op->ts_jiffies = jiffies;
243		243
244	return true;	244	return true;
@@ -250,8 +250,8 @@ static inline bool sys_t_need_ts(struct sys_t_output *op) · 5 unmodified lines
250	static bool sys_t_need_clock_sync(struct sys_t_output *op)	250	static bool sys_t_need_clock_sync(struct sys_t_output *op)
251	{	251	{
252	if (op->node.clocksync_interval &&	252	if (op->node.clocksync_interval &&
253	time_after(op->clocksync_jiffies + op->node.clocksync_interval,	253	time_after(jiffies,
254	jiffies)) {	254	op->clocksync_jiffies + op->node.clocksync_interval)) {
255	op->clocksync_jiffies = jiffies;	255	op->clocksync_jiffies = jiffies;
256		256
257	return true;	257	return true;

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

@@ -313,6 +313,7 @@ static void i2c_dw_pci_remove(struct pci_dev *pdev) · 312 unmodified lines
313	pm_runtime_get_noresume(&pdev->dev);	313	pm_runtime_get_noresume(&pdev->dev);
314		314
315	i2c_del_adapter(&dev->adapter);	315	i2c_del_adapter(&dev->adapter);
		316	devm_free_irq(&pdev->dev, dev->irq, dev);
316	pci_free_irq_vectors(pdev);	317	pci_free_irq_vectors(pdev);
317	}	318	}
318		319

drivers/i2c/busses/i2c-gpio.c+1−1

@@ -348,7 +348,7 @@ static struct gpio_desc i2c_gpio_get_desc(struct device dev, · 347 unmodified lines
348	if (ret == -ENOENT)	348	if (ret == -ENOENT)
349	retdesc = ERR_PTR(-EPROBE_DEFER);	349	retdesc = ERR_PTR(-EPROBE_DEFER);
350		350
351	if (ret != -EPROBE_DEFER)	351	if (PTR_ERR(retdesc) != -EPROBE_DEFER)
352	dev_err(dev, "error trying to get descriptor: %d\n", ret);	352	dev_err(dev, "error trying to get descriptor: %d\n", ret);
353		353
354	return retdesc;	354	return retdesc;

drivers/i2c/busses/i2c-i801.c+12−33

@@ -132,11 +132,6 @@ · 131 unmodified lines
132	#define TCOBASE 0x050	132	#define TCOBASE 0x050
133	#define TCOCTL 0x054	133	#define TCOCTL 0x054
134		134
135	#define ACPIBASE 0x040
136	#define ACPIBASE_SMI_OFF 0x030
137	#define ACPICTRL 0x044
138	#define ACPICTRL_EN 0x080
139
140	#define SBREG_BAR 0x10	135	#define SBREG_BAR 0x10
141	#define SBREG_SMBCTRL 0xc6000c	136	#define SBREG_SMBCTRL 0xc6000c
142	#define SBREG_SMBCTRL_DNV 0xcf000c	137	#define SBREG_SMBCTRL_DNV 0xcf000c
@@ -1553,7 +1548,7 @@ i801_add_tco_spt(struct i801_priv priv, struct pci_dev pci_dev, · 1410 unmodified lines
1553	pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden);	1548	pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden);
1554	spin_unlock(&p2sb_spinlock);	1549	spin_unlock(&p2sb_spinlock);
1555		1550
1556	res = &tco_res[ICH_RES_MEM_OFF];	1551	res = &tco_res[1];
1557	if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS)	1552	if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS)
1558	res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV;	1553	res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV;
1559	else	1554	else
@@ -1563,7 +1558,7 @@ i801_add_tco_spt(struct i801_priv priv, struct pci_dev pci_dev, · 3 unmodified lines
1563	res->flags = IORESOURCE_MEM;	1558	res->flags = IORESOURCE_MEM;
1564		1559
1565	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,	1560	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,
1566	tco_res, 3, &spt_tco_platform_data,	1561	tco_res, 2, &spt_tco_platform_data,
1567	sizeof(spt_tco_platform_data));	1562	sizeof(spt_tco_platform_data));
1568	}	1563	}
1569		1564
@@ -1576,17 +1571,16 @@ static struct platform_device * · 6 unmodified lines
1576	i801_add_tco_cnl(struct i801_priv priv, struct pci_dev pci_dev,	1571	i801_add_tco_cnl(struct i801_priv priv, struct pci_dev pci_dev,
1577	struct resource *tco_res)	1572	struct resource *tco_res)
1578	{	1573	{
1579	return platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,	1574	return platform_device_register_resndata(&pci_dev->dev,
1580	tco_res, 2, &cnl_tco_platform_data,	1575	"iTCO_wdt", -1, tco_res, 1, &cnl_tco_platform_data,
1581	sizeof(cnl_tco_platform_data));	1576	sizeof(cnl_tco_platform_data));
1582	}	1577	}
1583		1578
1584	static void i801_add_tco(struct i801_priv *priv)	1579	static void i801_add_tco(struct i801_priv *priv)
1585	{	1580	{
1586	u32 base_addr, tco_base, tco_ctl, ctrl_val;
1587	struct pci_dev *pci_dev = priv->pci_dev;	1581	struct pci_dev *pci_dev = priv->pci_dev;
1588	struct resource tco_res[3], *res;	1582	struct resource tco_res[2], *res;
1589	unsigned int devfn;	1583	u32 tco_base, tco_ctl;
1590		1584
1591	/* If we have ACPI based watchdog use that instead */	1585	/* If we have ACPI based watchdog use that instead */
1592	if (acpi_has_watchdog())	1586	if (acpi_has_watchdog())
@@ -1601,30 +1595,15 @@ static void i801_add_tco(struct i801_priv *priv) · 8 unmodified lines
1601	return;	1595	return;
1602		1596
1603	memset(tco_res, 0, sizeof(tco_res));	1597	memset(tco_res, 0, sizeof(tco_res));
1604
1605	res = &tco_res[ICH_RES_IO_TCO];
1606	res->start = tco_base & ~1;
1607	res->end = res->start + 32 - 1;
1608	res->flags = IORESOURCE_IO;
1609
1610	/*	1598	/*
1611	* Power Management registers.	1599	* Always populate the main iTCO IO resource here. The second entry
		1600	* for NO_REBOOT MMIO is filled by the SPT specific function.
1612	*/	1601	*/
1613	devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 2);	1602	res = &tco_res[0];
1614	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPIBASE, &base_addr);	1603	res->start = tco_base & ~1;
1615		1604	res->end = res->start + 32 - 1;
1616	res = &tco_res[ICH_RES_IO_SMI];
1617	res->start = (base_addr & ~1) + ACPIBASE_SMI_OFF;
1618	res->end = res->start + 3;
1619	res->flags = IORESOURCE_IO;	1605	res->flags = IORESOURCE_IO;
1620		1606
1621	/*
1622	* Enable the ACPI I/O space.
1623	*/
1624	pci_bus_read_config_dword(pci_dev->bus, devfn, ACPICTRL, &ctrl_val);
1625	ctrl_val \|= ACPICTRL_EN;
1626	pci_bus_write_config_dword(pci_dev->bus, devfn, ACPICTRL, ctrl_val);
1627
1628	if (priv->features & FEATURE_TCO_CNL)	1607	if (priv->features & FEATURE_TCO_CNL)
1629	priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res);	1608	priv->tco_pdev = i801_add_tco_cnl(priv, pci_dev, tco_res);
1630	else	1609	else

drivers/i2c/i2c-core-acpi.c+9−1

 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
 {
 	struct device *dev;
+	struct i2c_client *client;
 	dev = bus_find_device_by_acpi_dev(&i2c_bus_type, adev);
-	return dev ? i2c_verify_client(dev) : NULL;
+	if (!dev)
+		return NULL;
+	client = i2c_verify_client(dev);
+	if (!client)
+		put_device(dev);
+	return client;
 }
 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,

drivers/iio/accel/adxl372.c+1−0

@@ -237,6 +237,7 @@ static const struct adxl372_axis_lookup adxl372_axis_lookup_table[] = { · 236 unmodified lines
237	.realbits = 12, \	237	.realbits = 12, \
238	.storagebits = 16, \	238	.storagebits = 16, \
239	.shift = 4, \	239	.shift = 4, \
		240	.endianness = IIO_BE, \
240	}, \	241	}, \
241	}	242	}
242		243

drivers/iio/accel/st_accel_i2c.c+1−1

@@ -110,7 +110,7 @@ MODULE_DEVICE_TABLE(of, st_accel_of_match); · 109 unmodified lines
110		110
111	#ifdef CONFIG_ACPI	111	#ifdef CONFIG_ACPI
112	static const struct acpi_device_id st_accel_acpi_match[] = {	112	static const struct acpi_device_id st_accel_acpi_match[] = {
113	{"SMO8840", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},	113	{"SMO8840", (kernel_ulong_t)LIS2DH12_ACCEL_DEV_NAME},
114	{"SMO8A90", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},	114	{"SMO8A90", (kernel_ulong_t)LNG2DM_ACCEL_DEV_NAME},
115	{ },	115	{ },
116	};	116	};

drivers/iio/adc/at91-sama5d2_adc.c+15−0

@@ -723,6 +723,7 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) · 722 unmodified lines
723		723
724	for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {	724	for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {
725	struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);	725	struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);
		726	u32 cor;
726		727
727	if (!chan)	728	if (!chan)
728	continue;	729	continue;
@@ -731,6 +732,20 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) · 2 unmodified lines
731	chan->type == IIO_PRESSURE)	732	chan->type == IIO_PRESSURE)
732	continue;	733	continue;
733		734
		735	if (state) {
		736	cor = at91_adc_readl(st, AT91_SAMA5D2_COR);
		737
		738	if (chan->differential)
		739	cor \|= (BIT(chan->channel) \|
		740	BIT(chan->channel2)) <<
		741	AT91_SAMA5D2_COR_DIFF_OFFSET;
		742	else
		743	cor &= ~(BIT(chan->channel) <<
		744	AT91_SAMA5D2_COR_DIFF_OFFSET);
		745
		746	at91_adc_writel(st, AT91_SAMA5D2_COR, cor);
		747	}
		748
734	if (state) {	749	if (state) {
735	at91_adc_writel(st, AT91_SAMA5D2_CHER,	750	at91_adc_writel(st, AT91_SAMA5D2_CHER,
736	BIT(chan->channel));	751	BIT(chan->channel));

drivers/iio/adc/stm32-dfsdm-adc.c+10−33

 	}
 }
-static irqreturn_t stm32_dfsdm_adc_trigger_handler(int irq, void *p)
-{
-	struct iio_poll_func *pf = p;
-	struct iio_dev *indio_dev = pf->indio_dev;
-	struct stm32_dfsdm_adc *adc = iio_priv(indio_dev);
-	int available = stm32_dfsdm_adc_dma_residue(adc);
-	while (available >= indio_dev->scan_bytes) {
-		s32 *buffer = (s32 *)&adc->rx_buf[adc->bufi];
-		stm32_dfsdm_process_data(adc, buffer);
-		iio_push_to_buffers_with_timestamp(indio_dev, buffer,
-						   pf->timestamp);
-		available -= indio_dev->scan_bytes;
-		adc->bufi += indio_dev->scan_bytes;
-		if (adc->bufi >= adc->buf_sz)
-			adc->bufi = 0;
-	}
-	iio_trigger_notify_done(indio_dev->trig);
-	return IRQ_HANDLED;
-}
 static void stm32_dfsdm_dma_buffer_done(void *data)
 {
 	struct iio_dev *indio_dev = data;
 	int available = stm32_dfsdm_adc_dma_residue(adc);
 	size_t old_pos;
-	if (indio_dev->currentmode & INDIO_BUFFER_TRIGGERED) {
-		iio_trigger_poll_chained(indio_dev->trig);
-		return;
-	}
 	/*
 	 * FIXME: In Kernel interface does not support cyclic DMA buffer,and
 	 * offers only an interface to push data samples per samples.
 			adc->bufi = 0;
 			old_pos = 0;
 		}
-		/* regular iio buffer without trigger */
+		/*
+		 * In DMA mode the trigger services of IIO are not used
+		 * (e.g. no call to iio_trigger_poll).
+		 * Calling irq handler associated to the hardware trigger is not
+		 * relevant as the conversions have already been done. Data
+		 * transfers are performed directly in DMA callback instead.
+		 * This implementation avoids to call trigger irq handler that
+		 * may sleep, in an atomic context (DMA irq handler context).
+		 */
 		if (adc->dev_data->type == DFSDM_IIO)
 			iio_push_to_buffers(indio_dev, buffer);
 	}
 	}
 	ret = iio_triggered_buffer_setup(indio_dev,
-					 &iio_pollfunc_store_time,
+					 &iio_pollfunc_store_time, NULL,
-					 &stm32_dfsdm_adc_trigger_handler,
 					 &stm32_dfsdm_buffer_setup_ops);
 	if (ret) {
 		stm32_dfsdm_dma_release(indio_dev);

drivers/iio/chemical/Kconfig+2−0

 	tristate "SPS30 particulate matter sensor"
 	depends on I2C
 	select CRC8
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
 	help
 	  Say Y here to build support for the Sensirion SPS30 particulate
 	  matter sensor.

drivers/iio/light/vcnl4000.c+8−7

@@ -167,16 +167,17 @@ static int vcnl4200_init(struct vcnl4000_data *data) · 166 unmodified lines
167	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;	167	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
168	switch (id) {	168	switch (id) {
169	case VCNL4200_PROD_ID:	169	case VCNL4200_PROD_ID:
170	/* Integration time is 50ms, but the experiments */	170	/* Default wait time is 50ms, add 20% tolerance. */
171	/* show 54ms in total. */	171	data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
172	data->vcnl4200_al.sampling_rate = ktime_set(0, 54000 * 1000);	172	/* Default wait time is 4.8ms, add 20% tolerance. */
173	data->vcnl4200_ps.sampling_rate = ktime_set(0, 4200 * 1000);	173	data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
174	data->al_scale = 24000;	174	data->al_scale = 24000;
175	break;	175	break;
176	case VCNL4040_PROD_ID:	176	case VCNL4040_PROD_ID:
177	/* Integration time is 80ms, add 10ms. */	177	/* Default wait time is 80ms, add 20% tolerance. */
178	data->vcnl4200_al.sampling_rate = ktime_set(0, 100000 * 1000);	178	data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
179	data->vcnl4200_ps.sampling_rate = ktime_set(0, 100000 * 1000);	179	/* Default wait time is 5ms, add 20% tolerance. */
		180	data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
180	data->al_scale = 120000;	181	data->al_scale = 120000;
181	break;	182	break;
182	}	183	}

drivers/iio/magnetometer/ak8974.c+1−1

@@ -564,7 +564,7 @@ static int ak8974_read_raw(struct iio_dev *indio_dev, · 563 unmodified lines
564	* We read all axes and discard all but one, for optimized	564	* We read all axes and discard all but one, for optimized
565	* reading, use the triggered buffer.	565	* reading, use the triggered buffer.
566	*/	566	*/
567	*val = le16_to_cpu(hw_values[chan->address]);	567	*val = (s16)le16_to_cpu(hw_values[chan->address]);
568		568
569	ret = IIO_VAL_INT;	569	ret = IIO_VAL_INT;
570	}	570	}

drivers/iio/proximity/ping.c+1−1

@@ -269,7 +269,7 @@ static const struct iio_chan_spec ping_chan_spec[] = { · 268 unmodified lines
269		269
270	static const struct of_device_id of_ping_match[] = {	270	static const struct of_device_id of_ping_match[] = {
271	{ .compatible = "parallax,ping", .data = &pa_ping_cfg},	271	{ .compatible = "parallax,ping", .data = &pa_ping_cfg},
272	{ .compatible = "parallax,laserping", .data = &pa_ping_cfg},	272	{ .compatible = "parallax,laserping", .data = &pa_laser_ping_cfg},
273	{},	273	{},
274	};	274	};
275		275

drivers/iio/trigger/stm32-timer-trigger.c+9−2

 	return 0;
 }
-static void stm32_timer_stop(struct stm32_timer_trigger *priv)
+static void stm32_timer_stop(struct stm32_timer_trigger *priv,
+			     struct iio_trigger *trig)
 {
 	u32 ccer, cr1;
 	regmap_write(priv->regmap, TIM_PSC, 0);
 	regmap_write(priv->regmap, TIM_ARR, 0);
+	/* Force disable master mode */
+	if (stm32_timer_is_trgo2_name(trig->name))
+		regmap_update_bits(priv->regmap, TIM_CR2, TIM_CR2_MMS2, 0);
+	else
+		regmap_update_bits(priv->regmap, TIM_CR2, TIM_CR2_MMS, 0);
 	/* Make sure that registers are updated */
 	regmap_update_bits(priv->regmap, TIM_EGR, TIM_EGR_UG, TIM_EGR_UG);
 }
 		return ret;
 	if (freq == 0) {
-		stm32_timer_stop(priv);
+		stm32_timer_stop(priv, trig);
 	} else {
 		ret = stm32_timer_start(priv, trig, freq);
 		if (ret)

drivers/iommu/amd_iommu.c+2−2

@@ -3826,7 +3826,7 @@ int amd_iommu_activate_guest_mode(void *data) · 3825 unmodified lines
3826	entry->lo.fields_vapic.ga_tag = ir_data->ga_tag;	3826	entry->lo.fields_vapic.ga_tag = ir_data->ga_tag;
3827		3827
3828	return modify_irte_ga(ir_data->irq_2_irte.devid,	3828	return modify_irte_ga(ir_data->irq_2_irte.devid,
3829	ir_data->irq_2_irte.index, entry, NULL);	3829	ir_data->irq_2_irte.index, entry, ir_data);
3830	}	3830	}
3831	EXPORT_SYMBOL(amd_iommu_activate_guest_mode);	3831	EXPORT_SYMBOL(amd_iommu_activate_guest_mode);
3832		3832
@@ -3852,7 +3852,7 @@ int amd_iommu_deactivate_guest_mode(void *data) · 19 unmodified lines
3852	APICID_TO_IRTE_DEST_HI(cfg->dest_apicid);	3852	APICID_TO_IRTE_DEST_HI(cfg->dest_apicid);
3853		3853
3854	return modify_irte_ga(ir_data->irq_2_irte.devid,	3854	return modify_irte_ga(ir_data->irq_2_irte.devid,
3855	ir_data->irq_2_irte.index, entry, NULL);	3855	ir_data->irq_2_irte.index, entry, ir_data);
3856	}	3856	}
3857	EXPORT_SYMBOL(amd_iommu_deactivate_guest_mode);	3857	EXPORT_SYMBOL(amd_iommu_deactivate_guest_mode);
3858		3858

drivers/iommu/dma-iommu.c+8−8

@@ -177,15 +177,15 @@ static int cookie_init_hw_msi_region(struct iommu_dma_cookie *cookie, · 176 unmodified lines
177	start -= iova_offset(iovad, start);	177	start -= iova_offset(iovad, start);
178	num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);	178	num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);
179		179
180	msi_page = kcalloc(num_pages, sizeof(*msi_page), GFP_KERNEL);
181	if (!msi_page)
182	return -ENOMEM;
183
184	for (i = 0; i < num_pages; i++) {	180	for (i = 0; i < num_pages; i++) {
185	msi_page[i].phys = start;	181	msi_page = kmalloc(sizeof(*msi_page), GFP_KERNEL);
186	msi_page[i].iova = start;	182	if (!msi_page)
187	INIT_LIST_HEAD(&msi_page[i].list);	183	return -ENOMEM;
188	list_add(&msi_page[i].list, &cookie->msi_page_list);	184
		185	msi_page->phys = start;
		186	msi_page->iova = start;
		187	INIT_LIST_HEAD(&msi_page->list);
		188	list_add(&msi_page->list, &cookie->msi_page_list);
189	start += iovad->granule;	189	start += iovad->granule;
190	}	190	}
191		191

drivers/iommu/dmar.c+17−7

 #include <linux/slab.h>
 #include <linux/iommu.h>
 #include <linux/numa.h>
+#include <linux/limits.h>
 #include <asm/irq_remapping.h>
 #include <asm/iommu_table.h>
 	BUG_ON(dev->is_virtfn);
+	/*
+	 * Ignore devices that have a domain number higher than what can
+	 * be looked up in DMAR, e.g. VMD subdevices with domain 0x10000
+	 */
+	if (pci_domain_nr(dev->bus) > U16_MAX)
+		return NULL;
 	/* Only generate path[] for device addition event */
 	if (event == BUS_NOTIFY_ADD_DEVICE)
 		for (tmp = dev; tmp; tmp = tmp->bus->self)
 {
 	struct dmar_drhd_unit *dmaru;
-	list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list)
+	list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list,
+				dmar_rcu_check())
 		if (dmaru->segment == drhd->segment &&
 		    dmaru->reg_base_addr == drhd->address)
 			return dmaru;
 	/* Check for NUL termination within the designated length */
 	if (strnlen(andd->device_name, header->length - 8) == header->length - 8) {
-		WARN_TAINT(1, TAINT_FIRMWARE_WORKAROUND,
+		pr_warn(FW_BUG
 			   "Your BIOS is broken; ANDD object name is not NUL-terminated\n"
 			   "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 			   dmi_get_system_info(DMI_BIOS_VENDOR),
 			   dmi_get_system_info(DMI_BIOS_VERSION),
 			   dmi_get_system_info(DMI_PRODUCT_VERSION));
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 		return -EINVAL;
 	}
 	pr_info("ANDD device: %x name: %s\n", andd->device_number,
 			return 0;
 		}
 	}
-	WARN_TAINT(
+	pr_warn(FW_BUG
-		1, TAINT_FIRMWARE_WORKAROUND,
 		"Your BIOS is broken; RHSA refers to non-existent DMAR unit at %llx\n"
 		"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
-		drhd->reg_base_addr,
+		rhsa->base_address,
 		dmi_get_system_info(DMI_BIOS_VENDOR),
 		dmi_get_system_info(DMI_BIOS_VERSION),
 		dmi_get_system_info(DMI_PRODUCT_VERSION));
+	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 	return 0;
 }
 static void warn_invalid_dmar(u64 addr, const char *message)
 {
-	WARN_TAINT_ONCE(
+	pr_warn_once(FW_BUG
-		1, TAINT_FIRMWARE_WORKAROUND,
 		"Your BIOS is broken; DMAR reported at address %llx%s!\n"
 		"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 		addr, message,
 		dmi_get_system_info(DMI_BIOS_VENDOR),
 		dmi_get_system_info(DMI_BIOS_VERSION),
 		dmi_get_system_info(DMI_PRODUCT_VERSION));
+	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 }
 static int __ref

drivers/iommu/intel-iommu-debugfs.c+35−16

@@ -33,38 +33,42 @@ struct iommu_regset { · 32 unmodified lines
33		33
34	#define IOMMU_REGSET_ENTRY(_reg_) \	34	#define IOMMU_REGSET_ENTRY(_reg_) \
35	{ DMAR_##_reg_##_REG, __stringify(_reg_) }	35	{ DMAR_##_reg_##_REG, __stringify(_reg_) }
36	static const struct iommu_regset iommu_regs[] = {	36
		37	static const struct iommu_regset iommu_regs_32[] = {
37	IOMMU_REGSET_ENTRY(VER),	38	IOMMU_REGSET_ENTRY(VER),
38	IOMMU_REGSET_ENTRY(CAP),
39	IOMMU_REGSET_ENTRY(ECAP),
40	IOMMU_REGSET_ENTRY(GCMD),	39	IOMMU_REGSET_ENTRY(GCMD),
41	IOMMU_REGSET_ENTRY(GSTS),	40	IOMMU_REGSET_ENTRY(GSTS),
42	IOMMU_REGSET_ENTRY(RTADDR),
43	IOMMU_REGSET_ENTRY(CCMD),
44	IOMMU_REGSET_ENTRY(FSTS),	41	IOMMU_REGSET_ENTRY(FSTS),
45	IOMMU_REGSET_ENTRY(FECTL),	42	IOMMU_REGSET_ENTRY(FECTL),
46	IOMMU_REGSET_ENTRY(FEDATA),	43	IOMMU_REGSET_ENTRY(FEDATA),
47	IOMMU_REGSET_ENTRY(FEADDR),	44	IOMMU_REGSET_ENTRY(FEADDR),
48	IOMMU_REGSET_ENTRY(FEUADDR),	45	IOMMU_REGSET_ENTRY(FEUADDR),
49	IOMMU_REGSET_ENTRY(AFLOG),
50	IOMMU_REGSET_ENTRY(PMEN),	46	IOMMU_REGSET_ENTRY(PMEN),
51	IOMMU_REGSET_ENTRY(PLMBASE),	47	IOMMU_REGSET_ENTRY(PLMBASE),
52	IOMMU_REGSET_ENTRY(PLMLIMIT),	48	IOMMU_REGSET_ENTRY(PLMLIMIT),
		49	IOMMU_REGSET_ENTRY(ICS),
		50	IOMMU_REGSET_ENTRY(PRS),
		51	IOMMU_REGSET_ENTRY(PECTL),
		52	IOMMU_REGSET_ENTRY(PEDATA),
		53	IOMMU_REGSET_ENTRY(PEADDR),
		54	IOMMU_REGSET_ENTRY(PEUADDR),
		55	};
		56
		57	static const struct iommu_regset iommu_regs_64[] = {
		58	IOMMU_REGSET_ENTRY(CAP),
		59	IOMMU_REGSET_ENTRY(ECAP),
		60	IOMMU_REGSET_ENTRY(RTADDR),
		61	IOMMU_REGSET_ENTRY(CCMD),
		62	IOMMU_REGSET_ENTRY(AFLOG),
53	IOMMU_REGSET_ENTRY(PHMBASE),	63	IOMMU_REGSET_ENTRY(PHMBASE),
54	IOMMU_REGSET_ENTRY(PHMLIMIT),	64	IOMMU_REGSET_ENTRY(PHMLIMIT),
55	IOMMU_REGSET_ENTRY(IQH),	65	IOMMU_REGSET_ENTRY(IQH),
56	IOMMU_REGSET_ENTRY(IQT),	66	IOMMU_REGSET_ENTRY(IQT),
57	IOMMU_REGSET_ENTRY(IQA),	67	IOMMU_REGSET_ENTRY(IQA),
58	IOMMU_REGSET_ENTRY(ICS),
59	IOMMU_REGSET_ENTRY(IRTA),	68	IOMMU_REGSET_ENTRY(IRTA),
60	IOMMU_REGSET_ENTRY(PQH),	69	IOMMU_REGSET_ENTRY(PQH),
61	IOMMU_REGSET_ENTRY(PQT),	70	IOMMU_REGSET_ENTRY(PQT),
62	IOMMU_REGSET_ENTRY(PQA),	71	IOMMU_REGSET_ENTRY(PQA),
63	IOMMU_REGSET_ENTRY(PRS),
64	IOMMU_REGSET_ENTRY(PECTL),
65	IOMMU_REGSET_ENTRY(PEDATA),
66	IOMMU_REGSET_ENTRY(PEADDR),
67	IOMMU_REGSET_ENTRY(PEUADDR),
68	IOMMU_REGSET_ENTRY(MTRRCAP),	72	IOMMU_REGSET_ENTRY(MTRRCAP),
69	IOMMU_REGSET_ENTRY(MTRRDEF),	73	IOMMU_REGSET_ENTRY(MTRRDEF),
70	IOMMU_REGSET_ENTRY(MTRR_FIX64K_00000),	74	IOMMU_REGSET_ENTRY(MTRR_FIX64K_00000),
@@ -127,10 +131,16 @@ static int iommu_regset_show(struct seq_file m, void unused) · 56 unmodified lines
127	* by adding the offset to the pointer (virtual address).	131	* by adding the offset to the pointer (virtual address).
128	*/	132	*/
129	raw_spin_lock_irqsave(&iommu->register_lock, flag);	133	raw_spin_lock_irqsave(&iommu->register_lock, flag);
130	for (i = 0 ; i < ARRAY_SIZE(iommu_regs); i++) {	134	for (i = 0 ; i < ARRAY_SIZE(iommu_regs_32); i++) {
131	value = dmar_readq(iommu->reg + iommu_regs[i].offset);	135	value = dmar_readl(iommu->reg + iommu_regs_32[i].offset);
		136	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",
		137	iommu_regs_32[i].regs, iommu_regs_32[i].offset,
		138	value);
		139	}
		140	for (i = 0 ; i < ARRAY_SIZE(iommu_regs_64); i++) {
		141	value = dmar_readq(iommu->reg + iommu_regs_64[i].offset);
132	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",	142	seq_printf(m, "%-16s\t0x%02x\t\t0x%016llx\n",
133	iommu_regs[i].regs, iommu_regs[i].offset,	143	iommu_regs_64[i].regs, iommu_regs_64[i].offset,
134	value);	144	value);
135	}	145	}
136	raw_spin_unlock_irqrestore(&iommu->register_lock, flag);	146	raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
@@ -272,9 +282,16 @@ static int dmar_translation_struct_show(struct seq_file m, void unused) · 135 unmodified lines
272	{	282	{
273	struct dmar_drhd_unit *drhd;	283	struct dmar_drhd_unit *drhd;
274	struct intel_iommu *iommu;	284	struct intel_iommu *iommu;
		285	u32 sts;
275		286
276	rcu_read_lock();	287	rcu_read_lock();
277	for_each_active_iommu(iommu, drhd) {	288	for_each_active_iommu(iommu, drhd) {
		289	sts = dmar_readl(iommu->reg + DMAR_GSTS_REG);
		290	if (!(sts & DMA_GSTS_TES)) {
		291	seq_printf(m, "DMA Remapping is not enabled on %s\n",
		292	iommu->name);
		293	continue;
		294	}
278	root_tbl_walk(m, iommu);	295	root_tbl_walk(m, iommu);
279	seq_putc(m, '\n');	296	seq_putc(m, '\n');
280	}	297	}
@@ -415,6 +432,7 @@ static int ir_translation_struct_show(struct seq_file m, void unused) · 134 unmodified lines
415	struct dmar_drhd_unit *drhd;	432	struct dmar_drhd_unit *drhd;
416	struct intel_iommu *iommu;	433	struct intel_iommu *iommu;
417	u64 irta;	434	u64 irta;
		435	u32 sts;
418		436
419	rcu_read_lock();	437	rcu_read_lock();
420	for_each_active_iommu(iommu, drhd) {	438	for_each_active_iommu(iommu, drhd) {
@@ -424,7 +442,8 @@ static int ir_translation_struct_show(struct seq_file m, void unused) · 3 unmodified lines
424	seq_printf(m, "Remapped Interrupt supported on IOMMU: %s\n",	442	seq_printf(m, "Remapped Interrupt supported on IOMMU: %s\n",
425	iommu->name);	443	iommu->name);
426		444
427	if (iommu->ir_table) {	445	sts = dmar_readl(iommu->reg + DMAR_GSTS_REG);
		446	if (iommu->ir_table && (sts & DMA_GSTS_IRES)) {
428	irta = virt_to_phys(iommu->ir_table->base);	447	irta = virt_to_phys(iommu->ir_table->base);
429	seq_printf(m, " IR table address:%llx\n", irta);	448	seq_printf(m, " IR table address:%llx\n", irta);
430	ir_tbl_remap_entry_show(m, iommu);	449	ir_tbl_remap_entry_show(m, iommu);

drivers/iommu/intel-iommu.c+19−9

 	/* we know that the this iommu should be at offset 0xa000 from vtbar */
 	drhd = dmar_find_matched_drhd_unit(pdev);
-	if (WARN_TAINT_ONCE(!drhd || drhd->reg_base_addr - vtbar != 0xa000,
+	if (!drhd || drhd->reg_base_addr - vtbar != 0xa000) {
-			    TAINT_FIRMWARE_WORKAROUND,
+		pr_warn_once(FW_BUG "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n");
-			    "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n"))
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 		pdev->dev.archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO;
+	}
 }
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB, quirk_ioat_snb_local_iommu);
 	struct dmar_rmrr_unit *rmrru;
 	rmrr = (struct acpi_dmar_reserved_memory *)header;
-	if (rmrr_sanity_check(rmrr))
+	if (rmrr_sanity_check(rmrr)) {
-		WARN_TAINT(1, TAINT_FIRMWARE_WORKAROUND,
+		pr_warn(FW_BUG
 			   "Your BIOS is broken; bad RMRR [%#018Lx-%#018Lx]\n"
 			   "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
 			   rmrr->base_address, rmrr->end_address,
 			   dmi_get_system_info(DMI_BIOS_VENDOR),
 			   dmi_get_system_info(DMI_BIOS_VERSION),
 			   dmi_get_system_info(DMI_PRODUCT_VERSION));
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
+	}
 	rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
 	if (!rmrru)
 	down_write(&dmar_global_lock);
+	if (!no_iommu)
+		intel_iommu_debugfs_init();
 	if (no_iommu || dmar_disabled) {
 		/*
 		 * We exit the function here to ensure IOMMU's remapping and
 	init_iommu_pm_ops();
+	down_read(&dmar_global_lock);
 	for_each_active_iommu(iommu, drhd) {
 		iommu_device_sysfs_add(&iommu->iommu, NULL,
 				       intel_iommu_groups,
 		iommu_device_set_ops(&iommu->iommu, &intel_iommu_ops);
 		iommu_device_register(&iommu->iommu);
 	}
+	up_read(&dmar_global_lock);
 	bus_set_iommu(&pci_bus_type, &intel_iommu_ops);
 	if (si_domain && !hw_pass_through)
 	down_read(&dmar_global_lock);
 	if (probe_acpi_namespace_devices())
 		pr_warn("ACPI name space devices didn't probe correctly\n");
-	up_read(&dmar_global_lock);
 	/* Finally, we enable the DMA remapping hardware. */
 	for_each_iommu(iommu, drhd) {
 		iommu_disable_protect_mem_regions(iommu);
 	}
+	up_read(&dmar_global_lock);
 	pr_info("Intel(R) Virtualization Technology for Directed I/O\n");
 	intel_iommu_enabled = 1;
-	intel_iommu_debugfs_init();
 	return 0;
 	u64 phys = 0;
 	pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT, &level);
-	if (pte)
+	if (pte && dma_pte_present(pte))
-		phys = dma_pte_addr(pte);
+		phys = dma_pte_addr(pte) +
+			(iova & (BIT_MASK(level_to_offset_bits(level) +
+						VTD_PAGE_SHIFT) - 1));
 	return phys;
 }

drivers/iommu/io-pgtable-arm.c+2−2

@@ -468,7 +468,7 @@ static int arm_lpae_map(struct io_pgtable_ops *ops, unsigned long iova, · 467 unmodified lines
468	arm_lpae_iopte *ptep = data->pgd;	468	arm_lpae_iopte *ptep = data->pgd;
469	int ret, lvl = data->start_level;	469	int ret, lvl = data->start_level;
470	arm_lpae_iopte prot;	470	arm_lpae_iopte prot;
471	long iaext = (long)iova >> cfg->ias;	471	long iaext = (s64)iova >> cfg->ias;
472		472
473	/* If no access, then nothing to do */	473	/* If no access, then nothing to do */
474	if (!(iommu_prot & (IOMMU_READ \| IOMMU_WRITE)))	474	if (!(iommu_prot & (IOMMU_READ \| IOMMU_WRITE)))
@@ -645,7 +645,7 @@ static size_t arm_lpae_unmap(struct io_pgtable_ops *ops, unsigned long iova, · 170 unmodified lines
645	struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);	645	struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
646	struct io_pgtable_cfg *cfg = &data->iop.cfg;	646	struct io_pgtable_cfg *cfg = &data->iop.cfg;
647	arm_lpae_iopte *ptep = data->pgd;	647	arm_lpae_iopte *ptep = data->pgd;
648	long iaext = (long)iova >> cfg->ias;	648	long iaext = (s64)iova >> cfg->ias;
649		649
650	if (WARN_ON(!size \|\| (size & cfg->pgsize_bitmap) != size))	650	if (WARN_ON(!size \|\| (size & cfg->pgsize_bitmap) != size))
651	return 0;	651	return 0;

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

@@ -34,6 +34,7 @@ · 33 unmodified lines
34	#define GICD_INT_NMI_PRI (GICD_INT_DEF_PRI & ~0x80)	34	#define GICD_INT_NMI_PRI (GICD_INT_DEF_PRI & ~0x80)
35		35
36	#define FLAGS_WORKAROUND_GICR_WAKER_MSM8996 (1ULL << 0)	36	#define FLAGS_WORKAROUND_GICR_WAKER_MSM8996 (1ULL << 0)
		37	#define FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539 (1ULL << 1)
37		38
38	struct redist_region {	39	struct redist_region {
39	void __iomem *redist_base;	40	void __iomem *redist_base;
@@ -1464,6 +1465,15 @@ static bool gic_enable_quirk_msm8996(void *data) · 1424 unmodified lines
1464	return true;	1465	return true;
1465	}	1466	}
1466		1467
		1468	static bool gic_enable_quirk_cavium_38539(void *data)
		1469	{
		1470	struct gic_chip_data *d = data;
		1471
		1472	d->flags \|= FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539;
		1473
		1474	return true;
		1475	}
		1476
1467	static bool gic_enable_quirk_hip06_07(void *data)	1477	static bool gic_enable_quirk_hip06_07(void *data)
1468	{	1478	{
1469	struct gic_chip_data *d = data;	1479	struct gic_chip_data *d = data;
@@ -1502,6 +1512,19 @@ static const struct gic_quirk gic_quirks[] = { · 32 unmodified lines
1502	.mask = 0xffffffff,	1512	.mask = 0xffffffff,
1503	.init = gic_enable_quirk_hip06_07,	1513	.init = gic_enable_quirk_hip06_07,
1504	},	1514	},
		1515	{
		1516	/*
		1517	* Reserved register accesses generate a Synchronous
		1518	* External Abort. This erratum applies to:
		1519	* - ThunderX: CN88xx
		1520	* - OCTEON TX: CN83xx, CN81xx
		1521	* - OCTEON TX2: CN93xx, CN96xx, CN98xx, CNF95xx*
		1522	*/
		1523	.desc = "GICv3: Cavium erratum 38539",
		1524	.iidr = 0xa000034c,
		1525	.mask = 0xe8f00fff,
		1526	.init = gic_enable_quirk_cavium_38539,
		1527	},
1505	{	1528	{
1506	}	1529	}
1507	};	1530	};
@@ -1577,7 +1600,12 @@ static int __init gic_init_bases(void __iomem *dist_base, · 69 unmodified lines
1577	pr_info("%d SPIs implemented\n", GIC_LINE_NR - 32);	1600	pr_info("%d SPIs implemented\n", GIC_LINE_NR - 32);
1578	pr_info("%d Extended SPIs implemented\n", GIC_ESPI_NR);	1601	pr_info("%d Extended SPIs implemented\n", GIC_ESPI_NR);
1579		1602
1580	gic_data.rdists.gicd_typer2 = readl_relaxed(gic_data.dist_base + GICD_TYPER2);	1603	/*
		1604	* ThunderX1 explodes on reading GICD_TYPER2, in violation of the
		1605	* architecture spec (which says that reserved registers are RES0).
		1606	*/
		1607	if (!(gic_data.flags & FLAGS_WORKAROUND_CAVIUM_ERRATUM_38539))
		1608	gic_data.rdists.gicd_typer2 = readl_relaxed(gic_data.dist_base + GICD_TYPER2);
1581		1609
1582	gic_data.domain = irq_domain_create_tree(handle, &gic_irq_domain_ops,	1610	gic_data.domain = irq_domain_create_tree(handle, &gic_irq_domain_ops,
1583	&gic_data);	1611	&gic_data);

drivers/macintosh/windfarm_ad7417_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);
+static const struct of_device_id wf_ad7417_of_id[] = {
+	{ .compatible = "ad7417", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_ad7417_of_id);
 static struct i2c_driver wf_ad7417_driver = {
 	.driver = {
 		.name	= "wf_ad7417",
+		.of_match_table = wf_ad7417_of_id,
 	},
 	.probe		= wf_ad7417_probe,
 	.remove		= wf_ad7417_remove,

drivers/macintosh/windfarm_fcu_controls.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_fcu_id);
+static const struct of_device_id wf_fcu_of_id[] = {
+	{ .compatible = "fcu", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_fcu_of_id);
 static struct i2c_driver wf_fcu_driver = {
 	.driver = {
 		.name	= "wf_fcu",
+		.of_match_table = wf_fcu_of_id,
 	},
 	.probe		= wf_fcu_probe,
 	.remove		= wf_fcu_remove,

drivers/macintosh/windfarm_lm75_sensor.c+15−1

 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
+#include <linux/of_device.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
 			 const struct i2c_device_id *id)
 {
 	struct wf_lm75_sensor *lm;
-	int rc, ds1775 = id->driver_data;
+	int rc, ds1775;
 	const char *name, *loc;
+	if (id)
+		ds1775 = id->driver_data;
+	else
+		ds1775 = !!of_device_get_match_data(&client->dev);
 	DBG("wf_lm75: creating  %s device at address 0x%02x\n",
 	    ds1775 ? "ds1775" : "lm75", client->addr);
 };
 MODULE_DEVICE_TABLE(i2c, wf_lm75_id);
+static const struct of_device_id wf_lm75_of_id[] = {
+	{ .compatible = "lm75", .data = (void *)0},
+	{ .compatible = "ds1775", .data = (void *)1 },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_lm75_of_id);
 static struct i2c_driver wf_lm75_driver = {
 	.driver = {
 		.name	= "wf_lm75",
+		.of_match_table = wf_lm75_of_id,
 	},
 	.probe		= wf_lm75_probe,
 	.remove		= wf_lm75_remove,

drivers/macintosh/windfarm_lm87_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_lm87_id);
+static const struct of_device_id wf_lm87_of_id[] = {
+	{ .compatible = "lm87cimt", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_lm87_of_id);
 static struct i2c_driver wf_lm87_driver = {
 	.driver = {
 		.name	= "wf_lm87",
+		.of_match_table = wf_lm87_of_id,
 	},
 	.probe		= wf_lm87_probe,
 	.remove		= wf_lm87_remove,

drivers/macintosh/windfarm_max6690_sensor.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_max6690_id);
+static const struct of_device_id wf_max6690_of_id[] = {
+	{ .compatible = "max6690", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_max6690_of_id);
 static struct i2c_driver wf_max6690_driver = {
 	.driver = {
 		.name		= "wf_max6690",
+		.of_match_table = wf_max6690_of_id,
 	},
 	.probe		= wf_max6690_probe,
 	.remove		= wf_max6690_remove,

drivers/macintosh/windfarm_smu_sat.c+7−0

 };
 MODULE_DEVICE_TABLE(i2c, wf_sat_id);
+static const struct of_device_id wf_sat_of_id[] = {
+	{ .compatible = "smu-sat", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, wf_sat_of_id);
 static struct i2c_driver wf_sat_driver = {
 	.driver = {
 		.name		= "wf_smu_sat",
+		.of_match_table = wf_sat_of_id,
 	},
 	.probe		= wf_sat_probe,
 	.remove		= wf_sat_remove,

drivers/misc/cardreader/rts5227.c+1−1

@@ -394,7 +394,7 @@ static const struct pcr_ops rts522a_pcr_ops = { · 393 unmodified lines
394	void rts522a_init_params(struct rtsx_pcr *pcr)	394	void rts522a_init_params(struct rtsx_pcr *pcr)
395	{	395	{
396	rts5227_init_params(pcr);	396	rts5227_init_params(pcr);
397		397	pcr->tx_initial_phase = SET_CLOCK_PHASE(20, 20, 11);
398	pcr->reg_pm_ctrl3 = RTS522A_PM_CTRL3;	398	pcr->reg_pm_ctrl3 = RTS522A_PM_CTRL3;
399		399
400	pcr->option.ocp_en = 1;	400	pcr->option.ocp_en = 1;

drivers/misc/cardreader/rts5249.c+2−0

 void rts524a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =
 		LTR_L1OFF_SNOOZE_SSPWRGATE_5250_DEF;
 void rts525a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->tx_initial_phase = SET_CLOCK_PHASE(25, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =
 		LTR_L1OFF_SNOOZE_SSPWRGATE_5250_DEF;

drivers/misc/cardreader/rts5260.c+1−1

@@ -662,7 +662,7 @@ void rts5260_init_params(struct rtsx_pcr *pcr) · 661 unmodified lines
662	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	662	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
663	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	663	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
664	pcr->aspm_en = ASPM_L1_EN;	664	pcr->aspm_en = ASPM_L1_EN;
665	pcr->tx_initial_phase = SET_CLOCK_PHASE(1, 29, 16);	665	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
666	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	666	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
667		667
668	pcr->ic_version = rts5260_get_ic_version(pcr);	668	pcr->ic_version = rts5260_get_ic_version(pcr);

drivers/misc/cardreader/rts5261.c+1−1

@@ -764,7 +764,7 @@ void rts5261_init_params(struct rtsx_pcr *pcr) · 763 unmodified lines
764	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	764	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
765	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	765	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
766	pcr->aspm_en = ASPM_L1_EN;	766	pcr->aspm_en = ASPM_L1_EN;
767	pcr->tx_initial_phase = SET_CLOCK_PHASE(20, 27, 16);	767	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 11);
768	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	768	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
769		769
770	pcr->ic_version = rts5261_get_ic_version(pcr);	770	pcr->ic_version = rts5261_get_ic_version(pcr);

drivers/misc/eeprom/at24.c+2−1

 	 * chip is functional.
 	 */
 	err = at24_read(at24, 0, &test_byte, 1);
-	pm_runtime_idle(dev);
 	if (err) {
 		pm_runtime_disable(dev);
 		regulator_disable(at24->vcc_reg);
 		return -ENODEV;
 	}
+	pm_runtime_idle(dev);
 	if (writable)
 		dev_info(dev, "%u byte %s EEPROM, writable, %u bytes/write\n",
 			 byte_len, client->name, at24->write_max);

drivers/mmc/core/core.c+4−1

 	 * the erase operation does not exceed the max_busy_timeout, we should
 	 * use R1B response. Or we need to prevent the host from doing hw busy
 	 * detection, which is done by converting to a R1 response instead.
+	 * Note, some hosts requires R1B, which also means they are on their own
+	 * when it comes to deal with the busy timeout.
 	 */
-	if (card->host->max_busy_timeout &&
+	if (!(card->host->caps & MMC_CAP_NEED_RSP_BUSY) &&
+	    card->host->max_busy_timeout &&
 	    busy_timeout > card->host->max_busy_timeout) {
 		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
 	} else {

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

 	 * If the max_busy_timeout of the host is specified, validate it against
 	 * the sleep cmd timeout. A failure means we need to prevent the host
 	 * from doing hw busy detection, which is done by converting to a R1
-	 * response instead of a R1B.
+	 * response instead of a R1B. Note, some hosts requires R1B, which also
+	 * means they are on their own when it comes to deal with the busy
+	 * timeout.
 	 */
-	if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
+	if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
+	    (timeout_ms > host->max_busy_timeout)) {
 		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 	} else {
 		cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;

drivers/mmc/core/mmc_ops.c+4−2

 	 * If the max_busy_timeout of the host is specified, make sure it's
 	 * enough to fit the used timeout_ms. In case it's not, let's instruct
 	 * the host to avoid HW busy detection, by converting to a R1 response
-	 * instead of a R1B.
+	 * instead of a R1B. Note, some hosts requires R1B, which also means
+	 * they are on their own when it comes to deal with the busy timeout.
 	 */
-	if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout))
+	if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
+	    (timeout_ms > host->max_busy_timeout))
 		use_r1b_resp = false;
 	cmd.opcode = MMC_SWITCH;

drivers/mmc/host/rtsx_pci_sdmmc.c+8−5

@@ -606,19 +606,22 @@ static int sd_change_phase(struct realtek_pci_sdmmc *host, · 605 unmodified lines
606	u8 sample_point, bool rx)	606	u8 sample_point, bool rx)
607	{	607	{
608	struct rtsx_pcr *pcr = host->pcr;	608	struct rtsx_pcr *pcr = host->pcr;
609		609	u16 SD_VP_CTL = 0;
610	dev_dbg(sdmmc_dev(host), "%s(%s): sample_point = %d\n",	610	dev_dbg(sdmmc_dev(host), "%s(%s): sample_point = %d\n",
611	__func__, rx ? "RX" : "TX", sample_point);	611	__func__, rx ? "RX" : "TX", sample_point);
612		612
613	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, CHANGE_CLK);	613	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, CHANGE_CLK);
614	if (rx)	614	if (rx) {
		615	SD_VP_CTL = SD_VPRX_CTL;
615	rtsx_pci_write_register(pcr, SD_VPRX_CTL,	616	rtsx_pci_write_register(pcr, SD_VPRX_CTL,
616	PHASE_SELECT_MASK, sample_point);	617	PHASE_SELECT_MASK, sample_point);
617	else	618	} else {
		619	SD_VP_CTL = SD_VPTX_CTL;
618	rtsx_pci_write_register(pcr, SD_VPTX_CTL,	620	rtsx_pci_write_register(pcr, SD_VPTX_CTL,
619	PHASE_SELECT_MASK, sample_point);	621	PHASE_SELECT_MASK, sample_point);
620	rtsx_pci_write_register(pcr, SD_VPCLK0_CTL, PHASE_NOT_RESET, 0);	622	}
621	rtsx_pci_write_register(pcr, SD_VPCLK0_CTL, PHASE_NOT_RESET,	623	rtsx_pci_write_register(pcr, SD_VP_CTL, PHASE_NOT_RESET, 0);
		624	rtsx_pci_write_register(pcr, SD_VP_CTL, PHASE_NOT_RESET,
622	PHASE_NOT_RESET);	625	PHASE_NOT_RESET);
623	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, 0);	626	rtsx_pci_write_register(pcr, CLK_CTL, CHANGE_CLK, 0);
624	rtsx_pci_write_register(pcr, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);	627	rtsx_pci_write_register(pcr, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);

drivers/mmc/host/sdhci-acpi.c+82−2

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	#include <linux/pm.h>	23	#include <linux/pm.h>
24	#include <linux/pm_runtime.h>	24	#include <linux/pm_runtime.h>
25	#include <linux/delay.h>	25	#include <linux/delay.h>
		26	#include <linux/dmi.h>
26		27
27	#include <linux/mmc/host.h>	28	#include <linux/mmc/host.h>
28	#include <linux/mmc/pm.h>	29	#include <linux/mmc/pm.h>
@@ -72,9 +73,16 @@ struct sdhci_acpi_host { · 43 unmodified lines
72	const struct sdhci_acpi_slot *slot;	73	const struct sdhci_acpi_slot *slot;
73	struct platform_device *pdev;	74	struct platform_device *pdev;
74	bool use_runtime_pm;	75	bool use_runtime_pm;
		76	bool is_intel;
		77	bool reset_signal_volt_on_suspend;
75	unsigned long private[0] ____cacheline_aligned;	78	unsigned long private[0] ____cacheline_aligned;
76	};	79	};
77		80
		81	enum {
		82	DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP = BIT(0),
		83	DMI_QUIRK_SD_NO_WRITE_PROTECT = BIT(1),
		84	};
		85
78	static inline void sdhci_acpi_priv(struct sdhci_acpi_host c)	86	static inline void sdhci_acpi_priv(struct sdhci_acpi_host c)
79	{	87	{
80	return (void *)c->private;	88	return (void *)c->private;
@@ -391,6 +399,8 @@ static int intel_probe_slot(struct platform_device pdev, struct acpi_device ad · 310 unmodified lines
391	host->mmc_host_ops.start_signal_voltage_switch =	399	host->mmc_host_ops.start_signal_voltage_switch =
392	intel_start_signal_voltage_switch;	400	intel_start_signal_voltage_switch;
393		401
		402	c->is_intel = true;
		403
394	return 0;	404	return 0;
395	}	405	}
396		406
@@ -647,6 +657,36 @@ static const struct acpi_device_id sdhci_acpi_ids[] = { · 250 unmodified lines
647	};	657	};
648	MODULE_DEVICE_TABLE(acpi, sdhci_acpi_ids);	658	MODULE_DEVICE_TABLE(acpi, sdhci_acpi_ids);
649		659
		660	static const struct dmi_system_id sdhci_acpi_quirks[] = {
		661	{
		662	/*
		663	* The Lenovo Miix 320-10ICR has a bug in the _PS0 method of
		664	* the SHC1 ACPI device, this bug causes it to reprogram the
		665	* wrong LDO (DLDO3) to 1.8V if 1.8V modes are used and the
		666	* card is (runtime) suspended + resumed. DLDO3 is used for
		667	* the LCD and setting it to 1.8V causes the LCD to go black.
		668	*/
		669	.matches = {
		670	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		671	DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
		672	},
		673	.driver_data = (void *)DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP,
		674	},
		675	{
		676	/*
		677	* The Acer Aspire Switch 10 (SW5-012) microSD slot always
		678	* reports the card being write-protected even though microSD
		679	* cards do not have a write-protect switch at all.
		680	*/
		681	.matches = {
		682	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
		683	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
		684	},
		685	.driver_data = (void *)DMI_QUIRK_SD_NO_WRITE_PROTECT,
		686	},
		687	{} /* Terminating entry */
		688	};
		689
650	static const struct sdhci_acpi_slot sdhci_acpi_get_slot(struct acpi_device adev)	690	static const struct sdhci_acpi_slot sdhci_acpi_get_slot(struct acpi_device adev)
651	{	691	{
652	const struct sdhci_acpi_uid_slot *u;	692	const struct sdhci_acpi_uid_slot *u;
@@ -663,17 +703,23 @@ static int sdhci_acpi_probe(struct platform_device *pdev) · 10 unmodified lines
663	struct device *dev = &pdev->dev;	703	struct device *dev = &pdev->dev;
664	const struct sdhci_acpi_slot *slot;	704	const struct sdhci_acpi_slot *slot;
665	struct acpi_device device, child;	705	struct acpi_device device, child;
		706	const struct dmi_system_id *id;
666	struct sdhci_acpi_host *c;	707	struct sdhci_acpi_host *c;
667	struct sdhci_host *host;	708	struct sdhci_host *host;
668	struct resource *iomem;	709	struct resource *iomem;
669	resource_size_t len;	710	resource_size_t len;
670	size_t priv_size;	711	size_t priv_size;
		712	int quirks = 0;
671	int err;	713	int err;
672		714
673	device = ACPI_COMPANION(dev);	715	device = ACPI_COMPANION(dev);
674	if (!device)	716	if (!device)
675	return -ENODEV;	717	return -ENODEV;
676		718
		719	id = dmi_first_match(sdhci_acpi_quirks);
		720	if (id)
		721	quirks = (long)id->driver_data;
		722
677	slot = sdhci_acpi_get_slot(device);	723	slot = sdhci_acpi_get_slot(device);
678		724
679	/* Power on the SDHCI controller and its children */	725	/* Power on the SDHCI controller and its children */
@@ -759,6 +805,12 @@ static int sdhci_acpi_probe(struct platform_device *pdev) · 79 unmodified lines
759	dev_warn(dev, "failed to setup card detect gpio\n");	805	dev_warn(dev, "failed to setup card detect gpio\n");
760	c->use_runtime_pm = false;	806	c->use_runtime_pm = false;
761	}	807	}
		808
		809	if (quirks & DMI_QUIRK_RESET_SD_SIGNAL_VOLT_ON_SUSP)
		810	c->reset_signal_volt_on_suspend = true;
		811
		812	if (quirks & DMI_QUIRK_SD_NO_WRITE_PROTECT)
		813	host->mmc->caps2 \|= MMC_CAP2_NO_WRITE_PROTECT;
762	}	814	}
763		815
764	err = sdhci_setup_host(host);	816	err = sdhci_setup_host(host);
@@ -823,17 +875,39 @@ static int sdhci_acpi_remove(struct platform_device *pdev) · 58 unmodified lines
823	return 0;	875	return 0;
824	}	876	}
825		877
		878	static void __maybe_unused sdhci_acpi_reset_signal_voltage_if_needed(
		879	struct device *dev)
		880	{
		881	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
		882	struct sdhci_host *host = c->host;
		883
		884	if (c->is_intel && c->reset_signal_volt_on_suspend &&
		885	host->mmc->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_330) {
		886	struct intel_host *intel_host = sdhci_acpi_priv(c);
		887	unsigned int fn = INTEL_DSM_V33_SWITCH;
		888	u32 result = 0;
		889
		890	intel_dsm(intel_host, dev, fn, &result);
		891	}
		892	}
		893
826	#ifdef CONFIG_PM_SLEEP	894	#ifdef CONFIG_PM_SLEEP
827		895
828	static int sdhci_acpi_suspend(struct device *dev)	896	static int sdhci_acpi_suspend(struct device *dev)
829	{	897	{
830	struct sdhci_acpi_host *c = dev_get_drvdata(dev);	898	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
831	struct sdhci_host *host = c->host;	899	struct sdhci_host *host = c->host;
		900	int ret;
832		901
833	if (host->tuning_mode != SDHCI_TUNING_MODE_3)	902	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
834	mmc_retune_needed(host->mmc);	903	mmc_retune_needed(host->mmc);
835		904
836	return sdhci_suspend_host(host);	905	ret = sdhci_suspend_host(host);
		906	if (ret)
		907	return ret;
		908
		909	sdhci_acpi_reset_signal_voltage_if_needed(dev);
		910	return 0;
837	}	911	}
838		912
839	static int sdhci_acpi_resume(struct device *dev)	913	static int sdhci_acpi_resume(struct device *dev)
@@ -853,11 +927,17 @@ static int sdhci_acpi_runtime_suspend(struct device *dev) · 13 unmodified lines
853	{	927	{
854	struct sdhci_acpi_host *c = dev_get_drvdata(dev);	928	struct sdhci_acpi_host *c = dev_get_drvdata(dev);
855	struct sdhci_host *host = c->host;	929	struct sdhci_host *host = c->host;
		930	int ret;
856		931
857	if (host->tuning_mode != SDHCI_TUNING_MODE_3)	932	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
858	mmc_retune_needed(host->mmc);	933	mmc_retune_needed(host->mmc);
859		934
860	return sdhci_runtime_suspend_host(host);	935	ret = sdhci_runtime_suspend_host(host);
		936	if (ret)
		937	return ret;
		938
		939	sdhci_acpi_reset_signal_voltage_if_needed(dev);
		940	return 0;
861	}	941	}
862		942
863	static int sdhci_acpi_runtime_resume(struct device *dev)	943	static int sdhci_acpi_runtime_resume(struct device *dev)

drivers/mmc/host/sdhci-cadence.c+16−2

 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include "sdhci-pltfm.h"
 	.set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
 };
+static const struct sdhci_pltfm_data sdhci_cdns_uniphier_pltfm_data = {
+	.ops = &sdhci_cdns_ops,
+	.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
+};
 static const struct sdhci_pltfm_data sdhci_cdns_pltfm_data = {
 	.ops = &sdhci_cdns_ops,
 };
 static int sdhci_cdns_probe(struct platform_device *pdev)
 {
 	struct sdhci_host *host;
+	const struct sdhci_pltfm_data *data;
 	struct sdhci_pltfm_host *pltfm_host;
 	struct sdhci_cdns_priv *priv;
 	struct clk *clk;
 	if (ret)
 		return ret;
+	data = of_device_get_match_data(dev);
+	if (!data)
+		data = &sdhci_cdns_pltfm_data;
 	nr_phy_params = sdhci_cdns_phy_param_count(dev->of_node);
-	host = sdhci_pltfm_init(pdev, &sdhci_cdns_pltfm_data,
+	host = sdhci_pltfm_init(pdev, data,
 				struct_size(priv, phy_params, nr_phy_params));
 	if (IS_ERR(host)) {
 		ret = PTR_ERR(host);
 };
 static const struct of_device_id sdhci_cdns_match[] = {
-	{ .compatible = "socionext,uniphier-sd4hc" },
+	{
+		.compatible = "socionext,uniphier-sd4hc",
+		.data = &sdhci_cdns_uniphier_pltfm_data,
+	},
 	{ .compatible = "cdns,sd4hc" },
 	{ /* sentinel */ }
 };

drivers/mmc/host/sdhci-of-at91.c+6−2

 	sdhci_reset(host, mask);
-	if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	if ((host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	    || mmc_gpio_get_cd(host->mmc) >= 0)
 		sdhci_at91_set_force_card_detect(host);
 	if (priv->cal_always_on && (mask & SDHCI_RESET_ALL))
 	 * detection procedure using the SDMCC_CD signal is bypassed.
 	 * This bit is reset when a software reset for all command is performed
 	 * so we need to implement our own reset function to set back this bit.
+	 *
+	 * WA: SAMA5D2 doesn't drive CMD if using CD GPIO line.
 	 */
-	if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	if ((host->mmc->caps & MMC_CAP_NONREMOVABLE)
+	    || mmc_gpio_get_cd(host->mmc) >= 0)
 		sdhci_at91_set_force_card_detect(host);
 	pm_runtime_put_autosuspend(&pdev->dev);

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

@@ -1192,6 +1192,9 @@ static int sdhci_omap_probe(struct platform_device *pdev) · 1191 unmodified lines
1192	if (of_find_property(dev->of_node, "dmas", NULL))	1192	if (of_find_property(dev->of_node, "dmas", NULL))
1193	sdhci_switch_external_dma(host, true);	1193	sdhci_switch_external_dma(host, true);
1194		1194
		1195	/* R1B responses is required to properly manage HW busy detection. */
		1196	mmc->caps \|= MMC_CAP_NEED_RSP_BUSY;
		1197
1195	ret = sdhci_setup_host(host);	1198	ret = sdhci_setup_host(host);
1196	if (ret)	1199	if (ret)
1197	goto err_put_sync;	1200	goto err_put_sync;

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

@@ -1552,6 +1552,9 @@ static int sdhci_tegra_probe(struct platform_device *pdev) · 1551 unmodified lines
1552	if (tegra_host->soc_data->nvquirks & NVQUIRK_ENABLE_DDR50)	1552	if (tegra_host->soc_data->nvquirks & NVQUIRK_ENABLE_DDR50)
1553	host->mmc->caps \|= MMC_CAP_1_8V_DDR;	1553	host->mmc->caps \|= MMC_CAP_1_8V_DDR;
1554		1554
		1555	/* R1B responses is required to properly manage HW busy detection. */
		1556	host->mmc->caps \|= MMC_CAP_NEED_RSP_BUSY;
		1557
1555	tegra_sdhci_parse_dt(host);	1558	tegra_sdhci_parse_dt(host);
1556		1559
1557	tegra_host->power_gpio = devm_gpiod_get_optional(&pdev->dev, "power",	1560	tegra_host->power_gpio = devm_gpiod_get_optional(&pdev->dev, "power",

drivers/net/Kconfig+1−0

@@ -149,6 +149,7 @@ config NET_FC · 148 unmodified lines
149	config IFB	149	config IFB
150	tristate "Intermediate Functional Block support"	150	tristate "Intermediate Functional Block support"
151	depends on NET_CLS_ACT	151	depends on NET_CLS_ACT
		152	select NET_REDIRECT
152	---help---	153	---help---
153	This is an intermediate driver that allows sharing of	154	This is an intermediate driver that allows sharing of
154	resources.	155	resources.

drivers/net/caif/caif_spi.c+36−36

drivers/net/can/slcan.c+3−0

 	tty->disc_data = NULL;
 	clear_bit(SLF_INUSE, &sl->flags);
 	slc_free_netdev(sl->dev);
+	/* do not call free_netdev before rtnl_unlock */
+	rtnl_unlock();
 	free_netdev(sl->dev);
+	return err;
 err_exit:
 	rtnl_unlock();

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

@@ -566,7 +566,7 @@ mt7530_mib_reset(struct dsa_switch *ds) · 565 unmodified lines
566	static void	566	static void
567	mt7530_port_set_status(struct mt7530_priv *priv, int port, int enable)	567	mt7530_port_set_status(struct mt7530_priv *priv, int port, int enable)
568	{	568	{
569	u32 mask = PMCR_TX_EN \| PMCR_RX_EN;	569	u32 mask = PMCR_TX_EN \| PMCR_RX_EN \| PMCR_FORCE_LNK;
570		570
571	if (enable)	571	if (enable)
572	mt7530_set(priv, MT7530_PMCR_P(port), mask);	572	mt7530_set(priv, MT7530_PMCR_P(port), mask);
@@ -1502,7 +1502,7 @@ static void mt7530_phylink_mac_config(struct dsa_switch *ds, int port, · 929 unmodified lines
1502	mcr_new &= ~(PMCR_FORCE_SPEED_1000 \| PMCR_FORCE_SPEED_100 \|	1502	mcr_new &= ~(PMCR_FORCE_SPEED_1000 \| PMCR_FORCE_SPEED_100 \|
1503	PMCR_FORCE_FDX \| PMCR_TX_FC_EN \| PMCR_RX_FC_EN);	1503	PMCR_FORCE_FDX \| PMCR_TX_FC_EN \| PMCR_RX_FC_EN);
1504	mcr_new \|= PMCR_IFG_XMIT(1) \| PMCR_MAC_MODE \| PMCR_BACKOFF_EN \|	1504	mcr_new \|= PMCR_IFG_XMIT(1) \| PMCR_MAC_MODE \| PMCR_BACKOFF_EN \|
1505	PMCR_BACKPR_EN \| PMCR_FORCE_MODE \| PMCR_FORCE_LNK;	1505	PMCR_BACKPR_EN \| PMCR_FORCE_MODE;
1506		1506
1507	/* Are we connected to external phy */	1507	/* Are we connected to external phy */
1508	if (port == 5 && dsa_is_user_port(ds, 5))	1508	if (port == 5 && dsa_is_user_port(ds, 5))

drivers/net/ethernet/amazon/ena/ena_netdev.c+60−18

@@ -1015,13 +1015,9 @@ static int ena_refill_rx_bufs(struct ena_ring *rx_ring, u32 num) · 1014 unmodified lines
1015	struct ena_rx_buffer *rx_info;	1015	struct ena_rx_buffer *rx_info;
1016		1016
1017	req_id = rx_ring->free_ids[next_to_use];	1017	req_id = rx_ring->free_ids[next_to_use];
1018	rc = validate_rx_req_id(rx_ring, req_id);
1019	if (unlikely(rc < 0))
1020	break;
1021		1018
1022	rx_info = &rx_ring->rx_buffer_info[req_id];	1019	rx_info = &rx_ring->rx_buffer_info[req_id];
1023		1020
1024
1025	rc = ena_alloc_rx_page(rx_ring, rx_info,	1021	rc = ena_alloc_rx_page(rx_ring, rx_info,
1026	GFP_ATOMIC \| __GFP_COMP);	1022	GFP_ATOMIC \| __GFP_COMP);
1027	if (unlikely(rc < 0)) {	1023	if (unlikely(rc < 0)) {
@@ -1376,9 +1372,15 @@ static struct sk_buff ena_rx_skb(struct ena_ring rx_ring, · 348 unmodified lines
1376	struct ena_rx_buffer *rx_info;	1372	struct ena_rx_buffer *rx_info;
1377	u16 len, req_id, buf = 0;	1373	u16 len, req_id, buf = 0;
1378	void *va;	1374	void *va;
		1375	int rc;
1379		1376
1380	len = ena_bufs[buf].len;	1377	len = ena_bufs[buf].len;
1381	req_id = ena_bufs[buf].req_id;	1378	req_id = ena_bufs[buf].req_id;
		1379
		1380	rc = validate_rx_req_id(rx_ring, req_id);
		1381	if (unlikely(rc < 0))
		1382	return NULL;
		1383
1382	rx_info = &rx_ring->rx_buffer_info[req_id];	1384	rx_info = &rx_ring->rx_buffer_info[req_id];
1383		1385
1384	if (unlikely(!rx_info->page)) {	1386	if (unlikely(!rx_info->page)) {
@@ -1451,6 +1453,11 @@ static struct sk_buff ena_rx_skb(struct ena_ring rx_ring, · 66 unmodified lines
1451	buf++;	1453	buf++;
1452	len = ena_bufs[buf].len;	1454	len = ena_bufs[buf].len;
1453	req_id = ena_bufs[buf].req_id;	1455	req_id = ena_bufs[buf].req_id;
		1456
		1457	rc = validate_rx_req_id(rx_ring, req_id);
		1458	if (unlikely(rc < 0))
		1459	return NULL;
		1460
1454	rx_info = &rx_ring->rx_buffer_info[req_id];	1461	rx_info = &rx_ring->rx_buffer_info[req_id];
1455	} while (1);	1462	} while (1);
1456		1463
@@ -1965,7 +1972,7 @@ static int ena_enable_msix(struct ena_adapter *adapter) · 508 unmodified lines
1965	}	1972	}
1966		1973
1967	/* Reserved the max msix vectors we might need */	1974	/* Reserved the max msix vectors we might need */
1968	msix_vecs = ENA_MAX_MSIX_VEC(adapter->num_io_queues);	1975	msix_vecs = ENA_MAX_MSIX_VEC(adapter->max_num_io_queues);
1969	netif_dbg(adapter, probe, adapter->netdev,	1976	netif_dbg(adapter, probe, adapter->netdev,
1970	"trying to enable MSI-X, vectors %d\n", msix_vecs);	1977	"trying to enable MSI-X, vectors %d\n", msix_vecs);
1971		1978
@@ -2065,6 +2072,7 @@ static int ena_request_mgmnt_irq(struct ena_adapter *adapter) · 93 unmodified lines
2065		2072
2066	static int ena_request_io_irq(struct ena_adapter *adapter)	2073	static int ena_request_io_irq(struct ena_adapter *adapter)
2067	{	2074	{
		2075	u32 io_queue_count = adapter->num_io_queues + adapter->xdp_num_queues;
2068	unsigned long flags = 0;	2076	unsigned long flags = 0;
2069	struct ena_irq *irq;	2077	struct ena_irq *irq;
2070	int rc = 0, i, k;	2078	int rc = 0, i, k;
@@ -2075,7 +2083,7 @@ static int ena_request_io_irq(struct ena_adapter *adapter) · 4 unmodified lines
2075	return -EINVAL;	2083	return -EINVAL;
2076	}	2084	}
2077		2085
2078	for (i = ENA_IO_IRQ_FIRST_IDX; i < adapter->msix_vecs; i++) {	2086	for (i = ENA_IO_IRQ_FIRST_IDX; i < ENA_MAX_MSIX_VEC(io_queue_count); i++) {
2079	irq = &adapter->irq_tbl[i];	2087	irq = &adapter->irq_tbl[i];
2080	rc = request_irq(irq->vector, irq->handler, flags, irq->name,	2088	rc = request_irq(irq->vector, irq->handler, flags, irq->name,
2081	irq->data);	2089	irq->data);
@@ -2116,6 +2124,7 @@ static void ena_free_mgmnt_irq(struct ena_adapter *adapter) · 34 unmodified lines
2116		2124
2117	static void ena_free_io_irq(struct ena_adapter *adapter)	2125	static void ena_free_io_irq(struct ena_adapter *adapter)
2118	{	2126	{
		2127	u32 io_queue_count = adapter->num_io_queues + adapter->xdp_num_queues;
2119	struct ena_irq *irq;	2128	struct ena_irq *irq;
2120	int i;	2129	int i;
2121		2130
@@ -2126,7 +2135,7 @@ static void ena_free_io_irq(struct ena_adapter *adapter) · 4 unmodified lines
2126	}	2135	}
2127	#endif /* CONFIG_RFS_ACCEL */	2136	#endif /* CONFIG_RFS_ACCEL */
2128		2137
2129	for (i = ENA_IO_IRQ_FIRST_IDX; i < adapter->msix_vecs; i++) {	2138	for (i = ENA_IO_IRQ_FIRST_IDX; i < ENA_MAX_MSIX_VEC(io_queue_count); i++) {
2130	irq = &adapter->irq_tbl[i];	2139	irq = &adapter->irq_tbl[i];
2131	irq_set_affinity_hint(irq->vector, NULL);	2140	irq_set_affinity_hint(irq->vector, NULL);
2132	free_irq(irq->vector, irq->data);	2141	free_irq(irq->vector, irq->data);
@@ -2141,12 +2150,13 @@ static void ena_disable_msix(struct ena_adapter *adapter) · 8 unmodified lines
2141		2150
2142	static void ena_disable_io_intr_sync(struct ena_adapter *adapter)	2151	static void ena_disable_io_intr_sync(struct ena_adapter *adapter)
2143	{	2152	{
		2153	u32 io_queue_count = adapter->num_io_queues + adapter->xdp_num_queues;
2144	int i;	2154	int i;
2145		2155
2146	if (!netif_running(adapter->netdev))	2156	if (!netif_running(adapter->netdev))
2147	return;	2157	return;
2148		2158
2149	for (i = ENA_IO_IRQ_FIRST_IDX; i < adapter->msix_vecs; i++)	2159	for (i = ENA_IO_IRQ_FIRST_IDX; i < ENA_MAX_MSIX_VEC(io_queue_count); i++)
2150	synchronize_irq(adapter->irq_tbl[i].vector);	2160	synchronize_irq(adapter->irq_tbl[i].vector);
2151	}	2161	}
2152		2162
@@ -3474,6 +3484,7 @@ static int ena_restore_device(struct ena_adapter *adapter) · 1321 unmodified lines
3474		3484
3475	mod_timer(&adapter->timer_service, round_jiffies(jiffies + HZ));	3485	mod_timer(&adapter->timer_service, round_jiffies(jiffies + HZ));
3476	dev_err(&pdev->dev, "Device reset completed successfully\n");	3486	dev_err(&pdev->dev, "Device reset completed successfully\n");
		3487	adapter->last_keep_alive_jiffies = jiffies;
3477		3488
3478	return rc;	3489	return rc;
3479	err_disable_msix:	3490	err_disable_msix:
@@ -4318,13 +4329,15 @@ err_disable_device: · 838 unmodified lines
4318		4329
4319	/*****************************************************************************/	4330	/*****************************************************************************/
4320		4331
4321	/* ena_remove - Device Removal Routine	4332	/* __ena_shutoff - Helper used in both PCI remove/shutdown routines
4322	* @pdev: PCI device information struct	4333	* @pdev: PCI device information struct
		4334	* @shutdown: Is it a shutdown operation? If false, means it is a removal
4323	*	4335	*
4324	* ena_remove is called by the PCI subsystem to alert the driver	4336	* __ena_shutoff is a helper routine that does the real work on shutdown and
4325	* that it should release a PCI device.	4337	* removal paths; the difference between those paths is with regards to whether
		4338	* dettach or unregister the netdevice.
4326	*/	4339	*/
4327	static void ena_remove(struct pci_dev *pdev)	4340	static void __ena_shutoff(struct pci_dev *pdev, bool shutdown)
4328	{	4341	{
4329	struct ena_adapter *adapter = pci_get_drvdata(pdev);	4342	struct ena_adapter *adapter = pci_get_drvdata(pdev);
4330	struct ena_com_dev *ena_dev;	4343	struct ena_com_dev *ena_dev;
@@ -4343,13 +4356,17 @@ static void ena_remove(struct pci_dev *pdev) · 12 unmodified lines
4343		4356
4344	cancel_work_sync(&adapter->reset_task);	4357	cancel_work_sync(&adapter->reset_task);
4345		4358
4346	rtnl_lock();	4359	rtnl_lock(); /* lock released inside the below if-else block */
4347	ena_destroy_device(adapter, true);	4360	ena_destroy_device(adapter, true);
4348	rtnl_unlock();	4361	if (shutdown) {
4349		4362	netif_device_detach(netdev);
4350	unregister_netdev(netdev);	4363	dev_close(netdev);
4351		4364	rtnl_unlock();
4352	free_netdev(netdev);	4365	} else {
		4366	rtnl_unlock();
		4367	unregister_netdev(netdev);
		4368	free_netdev(netdev);
		4369	}
4353		4370
4354	ena_com_rss_destroy(ena_dev);	4371	ena_com_rss_destroy(ena_dev);
4355		4372
@@ -4364,6 +4381,30 @@ static void ena_remove(struct pci_dev *pdev) · 8 unmodified lines
4364	vfree(ena_dev);	4381	vfree(ena_dev);
4365	}	4382	}
4366		4383
		4384	/* ena_remove - Device Removal Routine
		4385	* @pdev: PCI device information struct
		4386	*
		4387	* ena_remove is called by the PCI subsystem to alert the driver
		4388	* that it should release a PCI device.
		4389	*/
		4390
		4391	static void ena_remove(struct pci_dev *pdev)
		4392	{
		4393	__ena_shutoff(pdev, false);
		4394	}
		4395
		4396	/* ena_shutdown - Device Shutdown Routine
		4397	* @pdev: PCI device information struct
		4398	*
		4399	* ena_shutdown is called by the PCI subsystem to alert the driver that
		4400	* a shutdown/reboot (or kexec) is happening and device must be disabled.
		4401	*/
		4402
		4403	static void ena_shutdown(struct pci_dev *pdev)
		4404	{
		4405	__ena_shutoff(pdev, true);
		4406	}
		4407
4367	#ifdef CONFIG_PM	4408	#ifdef CONFIG_PM
4368	/* ena_suspend - PM suspend callback	4409	/* ena_suspend - PM suspend callback
4369	* @pdev: PCI device information struct	4410	* @pdev: PCI device information struct
@@ -4413,6 +4454,7 @@ static struct pci_driver ena_pci_driver = { · 43 unmodified lines
4413	.id_table = ena_pci_tbl,	4454	.id_table = ena_pci_tbl,
4414	.probe = ena_probe,	4455	.probe = ena_probe,
4415	.remove = ena_remove,	4456	.remove = ena_remove,
		4457	.shutdown = ena_shutdown,
4416	#ifdef CONFIG_PM	4458	#ifdef CONFIG_PM
4417	.suspend = ena_suspend,	4459	.suspend = ena_suspend,
4418	.resume = ena_resume,	4460	.resume = ena_resume,

drivers/net/ethernet/broadcom/bnxt/bnxt.c+20−8

@@ -6860,12 +6860,12 @@ skip_rdma: · 6859 unmodified lines
6860	}	6860	}
6861	ena \|= FUNC_BACKING_STORE_CFG_REQ_DFLT_ENABLES;	6861	ena \|= FUNC_BACKING_STORE_CFG_REQ_DFLT_ENABLES;
6862	rc = bnxt_hwrm_func_backing_store_cfg(bp, ena);	6862	rc = bnxt_hwrm_func_backing_store_cfg(bp, ena);
6863	if (rc)	6863	if (rc) {
6864	netdev_err(bp->dev, "Failed configuring context mem, rc = %d.\n",	6864	netdev_err(bp->dev, "Failed configuring context mem, rc = %d.\n",
6865	rc);	6865	rc);
6866	else	6866	return rc;
6867	ctx->flags \|= BNXT_CTX_FLAG_INITED;	6867	}
6868		6868	ctx->flags \|= BNXT_CTX_FLAG_INITED;
6869	return 0;	6869	return 0;
6870	}	6870	}
6871		6871
@@ -7384,14 +7384,22 @@ static int bnxt_hwrm_port_qstats_ext(struct bnxt *bp) · 512 unmodified lines
7384	pri2cos = &resp2->pri0_cos_queue_id;	7384	pri2cos = &resp2->pri0_cos_queue_id;
7385	for (i = 0; i < 8; i++) {	7385	for (i = 0; i < 8; i++) {
7386	u8 queue_id = pri2cos[i];	7386	u8 queue_id = pri2cos[i];
		7387	u8 queue_idx;
7387		7388
		7389	/* Per port queue IDs start from 0, 10, 20, etc */
		7390	queue_idx = queue_id % 10;
		7391	if (queue_idx > BNXT_MAX_QUEUE) {
		7392	bp->pri2cos_valid = false;
		7393	goto qstats_done;
		7394	}
7388	for (j = 0; j < bp->max_q; j++) {	7395	for (j = 0; j < bp->max_q; j++) {
7389	if (bp->q_ids[j] == queue_id)	7396	if (bp->q_ids[j] == queue_id)
7390	bp->pri2cos[i] = j;	7397	bp->pri2cos_idx[i] = queue_idx;
7391	}	7398	}
7392	}	7399	}
7393	bp->pri2cos_valid = 1;	7400	bp->pri2cos_valid = 1;
7394	}	7401	}
		7402	qstats_done:
7395	mutex_unlock(&bp->hwrm_cmd_lock);	7403	mutex_unlock(&bp->hwrm_cmd_lock);
7396	return rc;	7404	return rc;
7397	}	7405	}
@@ -11644,6 +11652,10 @@ static int bnxt_set_dflt_rings(struct bnxt *bp, bool sh) · 4246 unmodified lines
11644	bp->rx_nr_rings++;	11652	bp->rx_nr_rings++;
11645	bp->cp_nr_rings++;	11653	bp->cp_nr_rings++;
11646	}	11654	}
		11655	if (rc) {
		11656	bp->tx_nr_rings = 0;
		11657	bp->rx_nr_rings = 0;
		11658	}
11647	return rc;	11659	return rc;
11648	}	11660	}
11649		11661
@@ -11929,12 +11941,12 @@ init_err_pci_clean: · 279 unmodified lines
11929	bnxt_hwrm_func_drv_unrgtr(bp);	11941	bnxt_hwrm_func_drv_unrgtr(bp);
11930	bnxt_free_hwrm_short_cmd_req(bp);	11942	bnxt_free_hwrm_short_cmd_req(bp);
11931	bnxt_free_hwrm_resources(bp);	11943	bnxt_free_hwrm_resources(bp);
11932	bnxt_free_ctx_mem(bp);
11933	kfree(bp->ctx);
11934	bp->ctx = NULL;
11935	kfree(bp->fw_health);	11944	kfree(bp->fw_health);
11936	bp->fw_health = NULL;	11945	bp->fw_health = NULL;
11937	bnxt_cleanup_pci(bp);	11946	bnxt_cleanup_pci(bp);
		11947	bnxt_free_ctx_mem(bp);
		11948	kfree(bp->ctx);
		11949	bp->ctx = NULL;
11938		11950
11939	init_err_free:	11951	init_err_free:
11940	free_netdev(dev);	11952	free_netdev(dev);

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

@@ -1718,7 +1718,7 @@ struct bnxt { · 1717 unmodified lines
1718	u16 fw_rx_stats_ext_size;	1718	u16 fw_rx_stats_ext_size;
1719	u16 fw_tx_stats_ext_size;	1719	u16 fw_tx_stats_ext_size;
1720	u16 hw_ring_stats_size;	1720	u16 hw_ring_stats_size;
1721	u8 pri2cos[8];	1721	u8 pri2cos_idx[8];
1722	u8 pri2cos_valid;	1722	u8 pri2cos_valid;
1723		1723
1724	u16 hwrm_max_req_len;	1724	u16 hwrm_max_req_len;

drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c+10−5

 {
 	struct bnxt *bp = netdev_priv(dev);
 	struct ieee_ets *my_ets = bp->ieee_ets;
+	int rc;
 	ets->ets_cap = bp->max_tc;
 	if (!my_ets) {
-		int rc;
 		if (bp->dcbx_cap & DCB_CAP_DCBX_HOST)
 			return 0;
 		my_ets = kzalloc(sizeof(*my_ets), GFP_KERNEL);
 		if (!my_ets)
-			return 0;
+			return -ENOMEM;
 		rc = bnxt_hwrm_queue_cos2bw_qcfg(bp, my_ets);
 		if (rc)
-			return 0;
+			goto error;
 		rc = bnxt_hwrm_queue_pri2cos_qcfg(bp, my_ets);
 		if (rc)
-			return 0;
+			goto error;
+		/* cache result */
+		bp->ieee_ets = my_ets;
 	}
 	ets->cbs = my_ets->cbs;
 	memcpy(ets->tc_tsa, my_ets->tc_tsa, sizeof(ets->tc_tsa));
 	memcpy(ets->prio_tc, my_ets->prio_tc, sizeof(ets->prio_tc));
 	return 0;
+error:
+	kfree(my_ets);
+	return rc;
 }
 static int bnxt_dcbnl_ieee_setets(struct net_device *dev, struct ieee_ets *ets)

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

drivers/net/ethernet/broadcom/genet/bcmgenet.c+42−100

@@ -95,12 +95,6 @@ static inline void dmadesc_set_length_status(struct bcmgenet_priv *priv, · 94 unmodified lines
95	bcmgenet_writel(value, d + DMA_DESC_LENGTH_STATUS);	95	bcmgenet_writel(value, d + DMA_DESC_LENGTH_STATUS);
96	}	96	}
97		97
98	static inline u32 dmadesc_get_length_status(struct bcmgenet_priv *priv,
99	void __iomem *d)
100	{
101	return bcmgenet_readl(d + DMA_DESC_LENGTH_STATUS);
102	}
103
104	static inline void dmadesc_set_addr(struct bcmgenet_priv *priv,	98	static inline void dmadesc_set_addr(struct bcmgenet_priv *priv,
105	void __iomem *d,	99	void __iomem *d,
106	dma_addr_t addr)	100	dma_addr_t addr)
@@ -509,61 +503,6 @@ static int bcmgenet_set_link_ksettings(struct net_device *dev, · 402 unmodified lines
509	return phy_ethtool_ksettings_set(dev->phydev, cmd);	503	return phy_ethtool_ksettings_set(dev->phydev, cmd);
510	}	504	}
511		505
512	static void bcmgenet_set_rx_csum(struct net_device *dev,
513	netdev_features_t wanted)
514	{
515	struct bcmgenet_priv *priv = netdev_priv(dev);
516	u32 rbuf_chk_ctrl;
517	bool rx_csum_en;
518
519	rx_csum_en = !!(wanted & NETIF_F_RXCSUM);
520
521	rbuf_chk_ctrl = bcmgenet_rbuf_readl(priv, RBUF_CHK_CTRL);
522
523	/* enable rx checksumming */
524	if (rx_csum_en)
525	rbuf_chk_ctrl \|= RBUF_RXCHK_EN \| RBUF_L3_PARSE_DIS;
526	else
527	rbuf_chk_ctrl &= ~RBUF_RXCHK_EN;
528	priv->desc_rxchk_en = rx_csum_en;
529
530	/* If UniMAC forwards CRC, we need to skip over it to get
531	* a valid CHK bit to be set in the per-packet status word
532	*/
533	if (rx_csum_en && priv->crc_fwd_en)
534	rbuf_chk_ctrl \|= RBUF_SKIP_FCS;
535	else
536	rbuf_chk_ctrl &= ~RBUF_SKIP_FCS;
537
538	bcmgenet_rbuf_writel(priv, rbuf_chk_ctrl, RBUF_CHK_CTRL);
539	}
540
541	static void bcmgenet_set_tx_csum(struct net_device *dev,
542	netdev_features_t wanted)
543	{
544	struct bcmgenet_priv *priv = netdev_priv(dev);
545	bool desc_64b_en;
546	u32 tbuf_ctrl, rbuf_ctrl;
547
548	tbuf_ctrl = bcmgenet_tbuf_ctrl_get(priv);
549	rbuf_ctrl = bcmgenet_rbuf_readl(priv, RBUF_CTRL);
550
551	desc_64b_en = !!(wanted & NETIF_F_HW_CSUM);
552
553	/* enable 64 bytes descriptor in both directions (RBUF and TBUF) */
554	if (desc_64b_en) {
555	tbuf_ctrl \|= RBUF_64B_EN;
556	rbuf_ctrl \|= RBUF_64B_EN;
557	} else {
558	tbuf_ctrl &= ~RBUF_64B_EN;
559	rbuf_ctrl &= ~RBUF_64B_EN;
560	}
561	priv->desc_64b_en = desc_64b_en;
562
563	bcmgenet_tbuf_ctrl_set(priv, tbuf_ctrl);
564	bcmgenet_rbuf_writel(priv, rbuf_ctrl, RBUF_CTRL);
565	}
566
567	static int bcmgenet_set_features(struct net_device *dev,	506	static int bcmgenet_set_features(struct net_device *dev,
568	netdev_features_t features)	507	netdev_features_t features)
569	{	508	{
@@ -579,9 +518,6 @@ static int bcmgenet_set_features(struct net_device *dev, · 9 unmodified lines
579	reg = bcmgenet_umac_readl(priv, UMAC_CMD);	518	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
580	priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);	519	priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);
581		520
582	bcmgenet_set_tx_csum(dev, features);
583	bcmgenet_set_rx_csum(dev, features);
584
585	clk_disable_unprepare(priv->clk);	521	clk_disable_unprepare(priv->clk);
586		522
587	return ret;	523	return ret;
@@ -1474,8 +1410,8 @@ static void bcmgenet_tx_reclaim_all(struct net_device *dev) · 886 unmodified lines
1474	/* Reallocate the SKB to put enough headroom in front of it and insert	1410	/* Reallocate the SKB to put enough headroom in front of it and insert
1475	* the transmit checksum offsets in the descriptors	1411	* the transmit checksum offsets in the descriptors
1476	*/	1412	*/
1477	static struct sk_buff bcmgenet_put_tx_csum(struct net_device dev,	1413	static struct sk_buff bcmgenet_add_tsb(struct net_device dev,
1478	struct sk_buff *skb)	1414	struct sk_buff *skb)
1479	{	1415	{
1480	struct bcmgenet_priv *priv = netdev_priv(dev);	1416	struct bcmgenet_priv *priv = netdev_priv(dev);
1481	struct status_64 *status = NULL;	1417	struct status_64 *status = NULL;
@@ -1589,13 +1525,11 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff skb, struct net_device dev) · 107 unmodified lines
1589	*/	1525	*/
1590	GENET_CB(skb)->bytes_sent = skb->len;	1526	GENET_CB(skb)->bytes_sent = skb->len;
1591		1527
1592	/* set the SKB transmit checksum */	1528	/* add the Transmit Status Block */
1593	if (priv->desc_64b_en) {	1529	skb = bcmgenet_add_tsb(dev, skb);
1594	skb = bcmgenet_put_tx_csum(dev, skb);	1530	if (!skb) {
1595	if (!skb) {	1531	ret = NETDEV_TX_OK;
1596	ret = NETDEV_TX_OK;	1532	goto out;
1597	goto out;
1598	}
1599	}	1533	}
1600		1534
1601	for (i = 0; i <= nr_frags; i++) {	1535	for (i = 0; i <= nr_frags; i++) {
@@ -1774,6 +1708,9 @@ static unsigned int bcmgenet_desc_rx(struct bcmgenet_rx_ring *ring, · 172 unmodified lines
1774		1708
1775	while ((rxpktprocessed < rxpkttoprocess) &&	1709	while ((rxpktprocessed < rxpkttoprocess) &&
1776	(rxpktprocessed < budget)) {	1710	(rxpktprocessed < budget)) {
		1711	struct status_64 *status;
		1712	__be16 rx_csum;
		1713
1777	cb = &priv->rx_cbs[ring->read_ptr];	1714	cb = &priv->rx_cbs[ring->read_ptr];
1778	skb = bcmgenet_rx_refill(priv, cb);	1715	skb = bcmgenet_rx_refill(priv, cb);
1779		1716
@@ -1782,20 +1719,12 @@ static unsigned int bcmgenet_desc_rx(struct bcmgenet_rx_ring *ring, · 2 unmodified lines
1782	goto next;	1719	goto next;
1783	}	1720	}
1784		1721
1785	if (!priv->desc_64b_en) {	1722	status = (struct status_64 *)skb->data;
1786	dma_length_status =	1723	dma_length_status = status->length_status;
1787	dmadesc_get_length_status(priv, cb->bd_addr);	1724	if (dev->features & NETIF_F_RXCSUM) {
1788	} else {
1789	struct status_64 *status;
1790	__be16 rx_csum;
1791
1792	status = (struct status_64 *)skb->data;
1793	dma_length_status = status->length_status;
1794	rx_csum = (__force __be16)(status->rx_csum & 0xffff);	1725	rx_csum = (__force __be16)(status->rx_csum & 0xffff);
1795	if (priv->desc_rxchk_en) {	1726	skb->csum = (__force __wsum)ntohs(rx_csum);
1796	skb->csum = (__force __wsum)ntohs(rx_csum);	1727	skb->ip_summed = CHECKSUM_COMPLETE;
1797	skb->ip_summed = CHECKSUM_COMPLETE;
1798	}
1799	}	1728	}
1800		1729
1801	/* DMA flags and length are still valid no matter how	1730	/* DMA flags and length are still valid no matter how
@@ -1839,14 +1768,10 @@ static unsigned int bcmgenet_desc_rx(struct bcmgenet_rx_ring *ring, · 37 unmodified lines
1839	} /* error packet */	1768	} /* error packet */
1840		1769
1841	skb_put(skb, len);	1770	skb_put(skb, len);
1842	if (priv->desc_64b_en) {
1843	skb_pull(skb, 64);
1844	len -= 64;
1845	}
1846		1771
1847	/* remove hardware 2bytes added for IP alignment */	1772	/* remove RSB and hardware 2bytes added for IP alignment */
1848	skb_pull(skb, 2);	1773	skb_pull(skb, 66);
1849	len -= 2;	1774	len -= 66;
1850		1775
1851	if (priv->crc_fwd_en) {	1776	if (priv->crc_fwd_en) {
1852	skb_trim(skb, len - ETH_FCS_LEN);	1777	skb_trim(skb, len - ETH_FCS_LEN);
@@ -1964,6 +1889,8 @@ static void umac_enable_set(struct bcmgenet_priv *priv, u32 mask, bool enable) · 111 unmodified lines
1964	u32 reg;	1889	u32 reg;
1965		1890
1966	reg = bcmgenet_umac_readl(priv, UMAC_CMD);	1891	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
		1892	if (reg & CMD_SW_RESET)
		1893	return;
1967	if (enable)	1894	if (enable)
1968	reg \|= mask;	1895	reg \|= mask;
1969	else	1896	else
@@ -1983,11 +1910,9 @@ static void reset_umac(struct bcmgenet_priv *priv) · 13 unmodified lines
1983	bcmgenet_rbuf_ctrl_set(priv, 0);	1910	bcmgenet_rbuf_ctrl_set(priv, 0);
1984	udelay(10);	1911	udelay(10);
1985		1912
1986	/* disable MAC while updating its registers */	1913	/* issue soft reset and disable MAC while updating its registers */
1987	bcmgenet_umac_writel(priv, 0, UMAC_CMD);	1914	bcmgenet_umac_writel(priv, CMD_SW_RESET, UMAC_CMD);
1988		1915	udelay(2);
1989	/* issue soft reset with (rg)mii loopback to ensure a stable rxclk */
1990	bcmgenet_umac_writel(priv, CMD_SW_RESET \| CMD_LCL_LOOP_EN, UMAC_CMD);
1991	}	1916	}
1992		1917
1993	static void bcmgenet_intr_disable(struct bcmgenet_priv *priv)	1918	static void bcmgenet_intr_disable(struct bcmgenet_priv *priv)
@@ -2037,11 +1962,28 @@ static void init_umac(struct bcmgenet_priv *priv) · 43 unmodified lines
2037		1962
2038	bcmgenet_umac_writel(priv, ENET_MAX_MTU_SIZE, UMAC_MAX_FRAME_LEN);	1963	bcmgenet_umac_writel(priv, ENET_MAX_MTU_SIZE, UMAC_MAX_FRAME_LEN);
2039		1964
2040	/* init rx registers, enable ip header optimization */	1965	/* init tx registers, enable TSB */
		1966	reg = bcmgenet_tbuf_ctrl_get(priv);
		1967	reg \|= TBUF_64B_EN;
		1968	bcmgenet_tbuf_ctrl_set(priv, reg);
		1969
		1970	/* init rx registers, enable ip header optimization and RSB */
2041	reg = bcmgenet_rbuf_readl(priv, RBUF_CTRL);	1971	reg = bcmgenet_rbuf_readl(priv, RBUF_CTRL);
2042	reg \|= RBUF_ALIGN_2B;	1972	reg \|= RBUF_ALIGN_2B \| RBUF_64B_EN;
2043	bcmgenet_rbuf_writel(priv, reg, RBUF_CTRL);	1973	bcmgenet_rbuf_writel(priv, reg, RBUF_CTRL);
2044		1974
		1975	/* enable rx checksumming */
		1976	reg = bcmgenet_rbuf_readl(priv, RBUF_CHK_CTRL);
		1977	reg \|= RBUF_RXCHK_EN \| RBUF_L3_PARSE_DIS;
		1978	/* If UniMAC forwards CRC, we need to skip over it to get
		1979	* a valid CHK bit to be set in the per-packet status word
		1980	*/
		1981	if (priv->crc_fwd_en)
		1982	reg \|= RBUF_SKIP_FCS;
		1983	else
		1984	reg &= ~RBUF_SKIP_FCS;
		1985	bcmgenet_rbuf_writel(priv, reg, RBUF_CHK_CTRL);
		1986
2045	if (!GENET_IS_V1(priv) && !GENET_IS_V2(priv))	1987	if (!GENET_IS_V1(priv) && !GENET_IS_V2(priv))
2046	bcmgenet_rbuf_writel(priv, 1, RBUF_TBUF_SIZE_CTRL);	1988	bcmgenet_rbuf_writel(priv, 1, RBUF_TBUF_SIZE_CTRL);
2047		1989

drivers/net/ethernet/broadcom/genet/bcmgenet.h+1−2

 #define  RBUF_FLTR_LEN_SHIFT		8
 #define TBUF_CTRL			0x00
+#define  TBUF_64B_EN			(1 << 0)
 #define TBUF_BP_MC			0x0C
 #define TBUF_ENERGY_CTRL		0x14
 #define  TBUF_EEE_EN			(1 << 0)
 	unsigned int irq0_stat;
 	/* HW descriptors/checksum variables */
-	bool desc_64b_en;
-	bool desc_rxchk_en;
 	bool crc_fwd_en;
 	u32 dma_max_burst_length;

drivers/net/ethernet/broadcom/genet/bcmgenet_wol.c+5−1

 		return -EINVAL;
 	}
-	/* disable RX */
+	/* Can't suspend with WoL if MAC is still in reset */
 	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
+	if (reg & CMD_SW_RESET)
+		reg &= ~CMD_SW_RESET;
+	/* disable RX */
 	reg &= ~CMD_RX_EN;
 	bcmgenet_umac_writel(priv, reg, UMAC_CMD);
 	mdelay(10);

drivers/net/ethernet/broadcom/genet/bcmmii.c+6−34

@@ -95,6 +95,12 @@ void bcmgenet_mii_setup(struct net_device *dev) · 94 unmodified lines
95	CMD_HD_EN \|	95	CMD_HD_EN \|
96	CMD_RX_PAUSE_IGNORE \| CMD_TX_PAUSE_IGNORE);	96	CMD_RX_PAUSE_IGNORE \| CMD_TX_PAUSE_IGNORE);
97	reg \|= cmd_bits;	97	reg \|= cmd_bits;
		98	if (reg & CMD_SW_RESET) {
		99	reg &= ~CMD_SW_RESET;
		100	bcmgenet_umac_writel(priv, reg, UMAC_CMD);
		101	udelay(2);
		102	reg \|= CMD_TX_EN \| CMD_RX_EN;
		103	}
98	bcmgenet_umac_writel(priv, reg, UMAC_CMD);	104	bcmgenet_umac_writel(priv, reg, UMAC_CMD);
99	} else {	105	} else {
100	/* done if nothing has changed */	106	/* done if nothing has changed */
@@ -181,38 +187,8 @@ int bcmgenet_mii_config(struct net_device *dev, bool init) · 80 unmodified lines
181	const char *phy_name = NULL;	187	const char *phy_name = NULL;
182	u32 id_mode_dis = 0;	188	u32 id_mode_dis = 0;
183	u32 port_ctrl;	189	u32 port_ctrl;
184	int bmcr = -1;
185	int ret;
186	u32 reg;	190	u32 reg;
187		191
188	/* MAC clocking workaround during reset of umac state machines */
189	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
190	if (reg & CMD_SW_RESET) {
191	/* An MII PHY must be isolated to prevent TXC contention */
192	if (priv->phy_interface == PHY_INTERFACE_MODE_MII) {
193	ret = phy_read(phydev, MII_BMCR);
194	if (ret >= 0) {
195	bmcr = ret;
196	ret = phy_write(phydev, MII_BMCR,
197	bmcr \| BMCR_ISOLATE);
198	}
199	if (ret) {
200	netdev_err(dev, "failed to isolate PHY\n");
201	return ret;
202	}
203	}
204	/* Switch MAC clocking to RGMII generated clock */
205	bcmgenet_sys_writel(priv, PORT_MODE_EXT_GPHY, SYS_PORT_CTRL);
206	/* Ensure 5 clks with Rx disabled
207	* followed by 5 clks with Reset asserted
208	*/
209	udelay(4);
210	reg &= ~(CMD_SW_RESET \| CMD_LCL_LOOP_EN);
211	bcmgenet_umac_writel(priv, reg, UMAC_CMD);
212	/* Ensure 5 more clocks before Rx is enabled */
213	udelay(2);
214	}
215
216	switch (priv->phy_interface) {	192	switch (priv->phy_interface) {
217	case PHY_INTERFACE_MODE_INTERNAL:	193	case PHY_INTERFACE_MODE_INTERNAL:
218	phy_name = "internal PHY";	194	phy_name = "internal PHY";
@@ -282,10 +258,6 @@ int bcmgenet_mii_config(struct net_device *dev, bool init) · 63 unmodified lines
282		258
283	bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);	259	bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);
284		260
285	/* Restore the MII PHY after isolation */
286	if (bmcr >= 0)
287	phy_write(phydev, MII_BMCR, bmcr);
288
289	priv->ext_phy = !priv->internal_phy &&	261	priv->ext_phy = !priv->internal_phy &&
290	(priv->phy_interface != PHY_INTERFACE_MODE_MOCA);	262	(priv->phy_interface != PHY_INTERFACE_MODE_MOCA);
291		263

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c+2−2

@@ -1033,7 +1033,7 @@ void clear_all_filters(struct adapter *adapter) · 1032 unmodified lines
1033	adapter->tids.tid_tab[i];	1033	adapter->tids.tid_tab[i];
1034		1034
1035	if (f && (f->valid \|\| f->pending))	1035	if (f && (f->valid \|\| f->pending))
1036	cxgb4_del_filter(dev, i, &f->fs);	1036	cxgb4_del_filter(dev, f->tid, &f->fs);
1037	}	1037	}
1038		1038
1039	sb = t4_read_reg(adapter, LE_DB_SRVR_START_INDEX_A);	1039	sb = t4_read_reg(adapter, LE_DB_SRVR_START_INDEX_A);
@@ -1041,7 +1041,7 @@ void clear_all_filters(struct adapter *adapter) · 1 unmodified line
1041	f = (struct filter_entry *)adapter->tids.tid_tab[i];	1041	f = (struct filter_entry *)adapter->tids.tid_tab[i];
1042		1042
1043	if (f && (f->valid \|\| f->pending))	1043	if (f && (f->valid \|\| f->pending))
1044	cxgb4_del_filter(dev, i, &f->fs);	1044	cxgb4_del_filter(dev, f->tid, &f->fs);
1045	}	1045	}
1046	}	1046	}
1047	}	1047	}

drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c+3−0

 			     FW_PTP_CMD_PORTID_V(0));
 	c.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(sizeof(c) / 16));
 	c.u.ts.sc = FW_PTP_SC_ADJ_FTIME;
+	c.u.ts.sign = (delta < 0) ? 1 : 0;
+	if (delta < 0)
+		delta = -delta;
 	c.u.ts.tm = cpu_to_be64(delta);
 	err = t4_wr_mbox(adapter, adapter->mbox, &c, sizeof(c), NULL);

drivers/net/ethernet/chelsio/cxgb4/sge.c+10−42

@@ -1307,8 +1307,9 @@ static inline void write_tso_wr(struct adapter adap, struct sk_buff *skb, · 1306 unmodified lines
1307	int t4_sge_eth_txq_egress_update(struct adapter adap, struct sge_eth_txq eq,	1307	int t4_sge_eth_txq_egress_update(struct adapter adap, struct sge_eth_txq eq,
1308	int maxreclaim)	1308	int maxreclaim)
1309	{	1309	{
		1310	unsigned int reclaimed, hw_cidx;
1310	struct sge_txq *q = &eq->q;	1311	struct sge_txq *q = &eq->q;
1311	unsigned int reclaimed;	1312	int hw_in_use;
1312		1313
1313	if (!q->in_use \|\| !__netif_tx_trylock(eq->txq))	1314	if (!q->in_use \|\| !__netif_tx_trylock(eq->txq))
1314	return 0;	1315	return 0;
@@ -1316,12 +1317,17 @@ int t4_sge_eth_txq_egress_update(struct adapter adap, struct sge_eth_txq eq, · 1 unmodified line
1316	/* Reclaim pending completed TX Descriptors. */	1317	/* Reclaim pending completed TX Descriptors. */
1317	reclaimed = reclaim_completed_tx(adap, &eq->q, maxreclaim, true);	1318	reclaimed = reclaim_completed_tx(adap, &eq->q, maxreclaim, true);
1318		1319
		1320	hw_cidx = ntohs(READ_ONCE(q->stat->cidx));
		1321	hw_in_use = q->pidx - hw_cidx;
		1322	if (hw_in_use < 0)
		1323	hw_in_use += q->size;
		1324
1319	/* If the TX Queue is currently stopped and there's now more than half	1325	/* If the TX Queue is currently stopped and there's now more than half
1320	* the queue available, restart it. Otherwise bail out since the rest	1326	* the queue available, restart it. Otherwise bail out since the rest
1321	* of what we want do here is with the possibility of shipping any	1327	* of what we want do here is with the possibility of shipping any
1322	* currently buffered Coalesced TX Work Request.	1328	* currently buffered Coalesced TX Work Request.
1323	*/	1329	*/
1324	if (netif_tx_queue_stopped(eq->txq) && txq_avail(q) > (q->size / 2)) {	1330	if (netif_tx_queue_stopped(eq->txq) && hw_in_use < (q->size / 2)) {
1325	netif_tx_wake_queue(eq->txq);	1331	netif_tx_wake_queue(eq->txq);
1326	eq->q.restarts++;	1332	eq->q.restarts++;
1327	}	1333	}
@@ -1491,16 +1497,7 @@ static netdev_tx_t cxgb4_eth_xmit(struct sk_buff skb, struct net_device dev) · 163 unmodified lines
1491	* has opened up.	1497	* has opened up.
1492	*/	1498	*/
1493	eth_txq_stop(q);	1499	eth_txq_stop(q);
1494		1500	wr_mid \|= FW_WR_EQUEQ_F \| FW_WR_EQUIQ_F;
1495	/* If we're using the SGE Doorbell Queue Timer facility, we
1496	* don't need to ask the Firmware to send us Egress Queue CIDX
1497	* Updates: the Hardware will do this automatically. And
1498	* since we send the Ingress Queue CIDX Updates to the
1499	* corresponding Ethernet Response Queue, we'll get them very
1500	* quickly.
1501	*/
1502	if (!q->dbqt)
1503	wr_mid \|= FW_WR_EQUEQ_F \| FW_WR_EQUIQ_F;
1504	}	1501	}
1505		1502
1506	wr = (void *)&q->q.desc[q->q.pidx];	1503	wr = (void *)&q->q.desc[q->q.pidx];
@@ -1810,16 +1807,7 @@ static netdev_tx_t cxgb4_vf_eth_xmit(struct sk_buff *skb, · 303 unmodified lines
1810	* has opened up.	1807	* has opened up.
1811	*/	1808	*/
1812	eth_txq_stop(txq);	1809	eth_txq_stop(txq);
1813		1810	wr_mid \|= FW_WR_EQUEQ_F \| FW_WR_EQUIQ_F;
1814	/* If we're using the SGE Doorbell Queue Timer facility, we
1815	* don't need to ask the Firmware to send us Egress Queue CIDX
1816	* Updates: the Hardware will do this automatically. And
1817	* since we send the Ingress Queue CIDX Updates to the
1818	* corresponding Ethernet Response Queue, we'll get them very
1819	* quickly.
1820	*/
1821	if (!txq->dbqt)
1822	wr_mid \|= FW_WR_EQUEQ_F \| FW_WR_EQUIQ_F;
1823	}	1811	}
1824		1812
1825	/* Start filling in our Work Request. Note that we do _not_ handle	1813	/* Start filling in our Work Request. Note that we do _not_ handle
@@ -3375,26 +3363,6 @@ static void t4_tx_completion_handler(struct sge_rspq *rspq, · 1549 unmodified lines
3375	}	3363	}
3376		3364
3377	txq = &s->ethtxq[pi->first_qset + rspq->idx];	3365	txq = &s->ethtxq[pi->first_qset + rspq->idx];
3378
3379	/* We've got the Hardware Consumer Index Update in the Egress Update
3380	* message. If we're using the SGE Doorbell Queue Timer mechanism,
3381	* these Egress Update messages will be our sole CIDX Updates we get
3382	* since we don't want to chew up PCIe bandwidth for both Ingress
3383	* Messages and Status Page writes. However, The code which manages
3384	* reclaiming successfully DMA'ed TX Work Requests uses the CIDX value
3385	* stored in the Status Page at the end of the TX Queue. It's easiest
3386	* to simply copy the CIDX Update value from the Egress Update message
3387	* to the Status Page. Also note that no Endian issues need to be
3388	* considered here since both are Big Endian and we're just copying
3389	* bytes consistently ...
3390	*/
3391	if (txq->dbqt) {
3392	struct cpl_sge_egr_update *egr;
3393
3394	egr = (struct cpl_sge_egr_update *)rsp;
3395	WRITE_ONCE(txq->q.stat->cidx, egr->cidx);
3396	}
3397
3398	t4_sge_eth_txq_egress_update(adapter, txq, -1);	3366	t4_sge_eth_txq_egress_update(adapter, txq, -1);
3399	}	3367	}
3400		3368

drivers/net/ethernet/freescale/fman/fman_memac.c+1−1

@@ -778,7 +778,7 @@ int memac_adjust_link(struct fman_mac *memac, u16 speed) · 777 unmodified lines
778	/* Set full duplex */	778	/* Set full duplex */
779	tmp &= ~IF_MODE_HD;	779	tmp &= ~IF_MODE_HD;
780		780
781	if (memac->phy_if == PHY_INTERFACE_MODE_RGMII) {	781	if (phy_interface_mode_is_rgmii(memac->phy_if)) {
782	/* Configure RGMII in manual mode */	782	/* Configure RGMII in manual mode */
783	tmp &= ~IF_MODE_RGMII_AUTO;	783	tmp &= ~IF_MODE_RGMII_AUTO;
784	tmp &= ~IF_MODE_RGMII_SP_MASK;	784	tmp &= ~IF_MODE_RGMII_SP_MASK;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c+4−1

 	spin_unlock_bh(&cmdq->cmdq_lock);
-	if (!wait_for_completion_timeout(&done, CMDQ_TIMEOUT)) {
+	if (!wait_for_completion_timeout(&done,
+					 msecs_to_jiffies(CMDQ_TIMEOUT))) {
 		spin_lock_bh(&cmdq->cmdq_lock);
 		if (cmdq->errcode[curr_prod_idx] == &errcode)
 	if (!CMDQ_WQE_COMPLETED(be32_to_cpu(ctrl->ctrl_info)))
 		return -EBUSY;
+	dma_rmb();
 	errcode = CMDQ_WQE_ERRCODE_GET(be32_to_cpu(status->status_info), VAL);
 	cmdq_sync_cmd_handler(cmdq, ci, errcode);

drivers/net/ethernet/huawei/hinic/hinic_hw_dev.c+2−49

@@ -360,50 +360,6 @@ static int wait_for_db_state(struct hinic_hwdev *hwdev) · 359 unmodified lines
360	return -EFAULT;	360	return -EFAULT;
361	}	361	}
362		362
363	static int wait_for_io_stopped(struct hinic_hwdev *hwdev)
364	{
365	struct hinic_cmd_io_status cmd_io_status;
366	struct hinic_hwif *hwif = hwdev->hwif;
367	struct pci_dev *pdev = hwif->pdev;
368	struct hinic_pfhwdev *pfhwdev;
369	unsigned long end;
370	u16 out_size;
371	int err;
372
373	if (!HINIC_IS_PF(hwif) && !HINIC_IS_PPF(hwif)) {
374	dev_err(&pdev->dev, "Unsupported PCI Function type\n");
375	return -EINVAL;
376	}
377
378	pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev);
379
380	cmd_io_status.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
381
382	end = jiffies + msecs_to_jiffies(IO_STATUS_TIMEOUT);
383	do {
384	err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM,
385	HINIC_COMM_CMD_IO_STATUS_GET,
386	&cmd_io_status, sizeof(cmd_io_status),
387	&cmd_io_status, &out_size,
388	HINIC_MGMT_MSG_SYNC);
389	if ((err) \|\| (out_size != sizeof(cmd_io_status))) {
390	dev_err(&pdev->dev, "Failed to get IO status, ret = %d\n",
391	err);
392	return err;
393	}
394
395	if (cmd_io_status.status == IO_STOPPED) {
396	dev_info(&pdev->dev, "IO stopped\n");
397	return 0;
398	}
399
400	msleep(20);
401	} while (time_before(jiffies, end));
402
403	dev_err(&pdev->dev, "Wait for IO stopped - Timeout\n");
404	return -ETIMEDOUT;
405	}
406
407	/**	363	/**
408	* clear_io_resource - set the IO resources as not active in the NIC	364	* clear_io_resource - set the IO resources as not active in the NIC
409	* @hwdev: the NIC HW device	365	* @hwdev: the NIC HW device
@@ -423,11 +379,8 @@ static int clear_io_resources(struct hinic_hwdev *hwdev) · 13 unmodified lines
423	return -EINVAL;	379	return -EINVAL;
424	}	380	}
425		381
426	err = wait_for_io_stopped(hwdev);	382	/* sleep 100ms to wait for firmware stopping I/O */
427	if (err) {	383	msleep(100);
428	dev_err(&pdev->dev, "IO has not stopped yet\n");
429	return err;
430	}
431		384
432	cmd_clear_io_res.func_idx = HINIC_HWIF_FUNC_IDX(hwif);	385	cmd_clear_io_res.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
433		386

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c+19−7

@@ -188,7 +188,7 @@ static u8 eq_cons_idx_checksum_set(u32 val) · 187 unmodified lines
188	* eq_update_ci - update the HW cons idx of event queue	188	* eq_update_ci - update the HW cons idx of event queue
189	* @eq: the event queue to update the cons idx for	189	* @eq: the event queue to update the cons idx for
190	**/	190	**/
191	static void eq_update_ci(struct hinic_eq *eq)	191	static void eq_update_ci(struct hinic_eq *eq, u32 arm_state)
192	{	192	{
193	u32 val, addr = EQ_CONS_IDX_REG_ADDR(eq);	193	u32 val, addr = EQ_CONS_IDX_REG_ADDR(eq);
194		194
@@ -202,7 +202,7 @@ static void eq_update_ci(struct hinic_eq *eq) · 7 unmodified lines
202		202
203	val \|= HINIC_EQ_CI_SET(eq->cons_idx, IDX) \|	203	val \|= HINIC_EQ_CI_SET(eq->cons_idx, IDX) \|
204	HINIC_EQ_CI_SET(eq->wrapped, WRAPPED) \|	204	HINIC_EQ_CI_SET(eq->wrapped, WRAPPED) \|
205	HINIC_EQ_CI_SET(EQ_ARMED, INT_ARMED);	205	HINIC_EQ_CI_SET(arm_state, INT_ARMED);
206		206
207	val \|= HINIC_EQ_CI_SET(eq_cons_idx_checksum_set(val), XOR_CHKSUM);	207	val \|= HINIC_EQ_CI_SET(eq_cons_idx_checksum_set(val), XOR_CHKSUM);
208		208
@@ -235,6 +235,8 @@ static void aeq_irq_handler(struct hinic_eq *eq) · 26 unmodified lines
235	if (HINIC_EQ_ELEM_DESC_GET(aeqe_desc, WRAPPED) == eq->wrapped)	235	if (HINIC_EQ_ELEM_DESC_GET(aeqe_desc, WRAPPED) == eq->wrapped)
236	break;	236	break;
237		237
		238	dma_rmb();
		239
238	event = HINIC_EQ_ELEM_DESC_GET(aeqe_desc, TYPE);	240	event = HINIC_EQ_ELEM_DESC_GET(aeqe_desc, TYPE);
239	if (event >= HINIC_MAX_AEQ_EVENTS) {	241	if (event >= HINIC_MAX_AEQ_EVENTS) {
240	dev_err(&pdev->dev, "Unknown AEQ Event %d\n", event);	242	dev_err(&pdev->dev, "Unknown AEQ Event %d\n", event);
@@ -347,7 +349,7 @@ static void eq_irq_handler(void *data) · 106 unmodified lines
347	else if (eq->type == HINIC_CEQ)	349	else if (eq->type == HINIC_CEQ)
348	ceq_irq_handler(eq);	350	ceq_irq_handler(eq);
349		351
350	eq_update_ci(eq);	352	eq_update_ci(eq, EQ_ARMED);
351	}	353	}
352		354
353	/**	355	/**
@@ -702,7 +704,7 @@ static int init_eq(struct hinic_eq eq, struct hinic_hwif hwif, · 348 unmodified lines
702	}	704	}
703		705
704	set_eq_ctrls(eq);	706	set_eq_ctrls(eq);
705	eq_update_ci(eq);	707	eq_update_ci(eq, EQ_ARMED);
706		708
707	err = alloc_eq_pages(eq);	709	err = alloc_eq_pages(eq);
708	if (err) {	710	if (err) {
@@ -752,18 +754,28 @@ err_req_irq: · 43 unmodified lines
752	**/	754	**/
753	static void remove_eq(struct hinic_eq *eq)	755	static void remove_eq(struct hinic_eq *eq)
754	{	756	{
755	struct msix_entry *entry = &eq->msix_entry;	757	hinic_set_msix_state(eq->hwif, eq->msix_entry.entry,
756		758	HINIC_MSIX_DISABLE);
757	free_irq(entry->vector, eq);	759	free_irq(eq->msix_entry.vector, eq);
758		760
759	if (eq->type == HINIC_AEQ) {	761	if (eq->type == HINIC_AEQ) {
760	struct hinic_eq_work *aeq_work = &eq->aeq_work;	762	struct hinic_eq_work *aeq_work = &eq->aeq_work;
761		763
762	cancel_work_sync(&aeq_work->work);	764	cancel_work_sync(&aeq_work->work);
		765	/* clear aeq_len to avoid hw access host memory */
		766	hinic_hwif_write_reg(eq->hwif,
		767	HINIC_CSR_AEQ_CTRL_1_ADDR(eq->q_id), 0);
763	} else if (eq->type == HINIC_CEQ) {	768	} else if (eq->type == HINIC_CEQ) {
764	tasklet_kill(&eq->ceq_tasklet);	769	tasklet_kill(&eq->ceq_tasklet);
		770	/* clear ceq_len to avoid hw access host memory */
		771	hinic_hwif_write_reg(eq->hwif,
		772	HINIC_CSR_CEQ_CTRL_1_ADDR(eq->q_id), 0);
765	}	773	}
766		774
		775	/* update cons_idx to avoid invalid interrupt */
		776	eq->cons_idx = hinic_hwif_read_reg(eq->hwif, EQ_PROD_IDX_REG_ADDR(eq));
		777	eq_update_ci(eq, EQ_NOT_ARMED);
		778
767	free_eq_pages(eq);	779	free_eq_pages(eq);
768	}	780	}
769		781

drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c+3−2

 #define MSG_NOT_RESP                    0xFFFF
-#define MGMT_MSG_TIMEOUT                1000
+#define MGMT_MSG_TIMEOUT                5000
 #define mgmt_to_pfhwdev(pf_mgmt)        \
 		container_of(pf_mgmt, struct hinic_pfhwdev, pf_to_mgmt)
 		goto unlock_sync_msg;
 	}
-	if (!wait_for_completion_timeout(recv_done, MGMT_MSG_TIMEOUT)) {
+	if (!wait_for_completion_timeout(recv_done,
+					 msecs_to_jiffies(MGMT_MSG_TIMEOUT))) {
 		dev_err(&pdev->dev, "MGMT timeout, MSG id = %d\n", msg_id);
 		err = -ETIMEDOUT;
 		goto unlock_sync_msg;

drivers/net/ethernet/huawei/hinic/hinic_rx.c+3−0

@@ -350,6 +350,9 @@ static int rxq_recv(struct hinic_rxq *rxq, int budget) · 349 unmodified lines
350	if (!rq_wqe)	350	if (!rq_wqe)
351	break;	351	break;
352		352
		353	/* make sure we read rx_done before packet length */
		354	dma_rmb();
		355
353	cqe = rq->cqe[ci];	356	cqe = rq->cqe[ci];
354	status = be32_to_cpu(cqe->status);	357	status = be32_to_cpu(cqe->status);
355	hinic_rq_get_sge(rxq->rq, rq_wqe, ci, &sge);	358	hinic_rq_get_sge(rxq->rq, rq_wqe, ci, &sge);

drivers/net/ethernet/huawei/hinic/hinic_tx.c+3−1

 #define HW_CONS_IDX(sq)                 be16_to_cpu(*(u16 *)((sq)->hw_ci_addr))
-#define MIN_SKB_LEN                     17
+#define MIN_SKB_LEN			32
 #define	MAX_PAYLOAD_OFFSET	        221
 #define TRANSPORT_OFFSET(l4_hdr, skb)	((u32)((l4_hdr) - (skb)->data))
 	do {
 		hw_ci = HW_CONS_IDX(sq) & wq->mask;
+		dma_rmb();
 		/* Reading a WQEBB to get real WQE size and consumer index. */
 		sq_wqe = hinic_sq_read_wqebb(sq, &skb, &wqe_size, &sw_ci);
 		if ((!sq_wqe) ||

drivers/net/ethernet/marvell/mvmdio.c+2−2

@@ -364,8 +364,8 @@ static int orion_mdio_probe(struct platform_device *pdev) · 363 unmodified lines
364	writel(MVMDIO_ERR_INT_SMI_DONE,	364	writel(MVMDIO_ERR_INT_SMI_DONE,
365	dev->regs + MVMDIO_ERR_INT_MASK);	365	dev->regs + MVMDIO_ERR_INT_MASK);
366		366
367	} else if (dev->err_interrupt < 0) {	367	} else if (dev->err_interrupt == -EPROBE_DEFER) {
368	ret = dev->err_interrupt;	368	ret = -EPROBE_DEFER;
369	goto out_mdio;	369	goto out_mdio;
370	}	370	}
371		371

drivers/net/ethernet/marvell/mvneta.c+1−2

 	/* For the case where the last mvneta_poll did not process all
 	 * RX packets
 	 */
-	rx_queue = fls(((cause_rx_tx >> 8) & 0xff));
 	cause_rx_tx |= pp->neta_armada3700 ? pp->cause_rx_tx :
 		port->cause_rx_tx;
+	rx_queue = fls(((cause_rx_tx >> 8) & 0xff));
 	if (rx_queue) {
 		rx_queue = rx_queue - 1;
 		if (pp->bm_priv)

drivers/net/ethernet/mellanox/mlx4/mcg.c+31−31

@@ -906,59 +906,59 @@ static void mlx4_err_rule(struct mlx4_dev dev, char str, · 905 unmodified lines
906	int len = 0;	906	int len = 0;
907		907
908	mlx4_err(dev, "%s", str);	908	mlx4_err(dev, "%s", str);
909	len += snprintf(buf + len, BUF_SIZE - len,	909	len += scnprintf(buf + len, BUF_SIZE - len,
910	"port = %d prio = 0x%x qp = 0x%x ",	910	"port = %d prio = 0x%x qp = 0x%x ",
911	rule->port, rule->priority, rule->qpn);	911	rule->port, rule->priority, rule->qpn);
912		912
913	list_for_each_entry(cur, &rule->list, list) {	913	list_for_each_entry(cur, &rule->list, list) {
914	switch (cur->id) {	914	switch (cur->id) {
915	case MLX4_NET_TRANS_RULE_ID_ETH:	915	case MLX4_NET_TRANS_RULE_ID_ETH:
916	len += snprintf(buf + len, BUF_SIZE - len,	916	len += scnprintf(buf + len, BUF_SIZE - len,
917	"dmac = %pM ", &cur->eth.dst_mac);	917	"dmac = %pM ", &cur->eth.dst_mac);
918	if (cur->eth.ether_type)	918	if (cur->eth.ether_type)
919	len += snprintf(buf + len, BUF_SIZE - len,	919	len += scnprintf(buf + len, BUF_SIZE - len,
920	"ethertype = 0x%x ",	920	"ethertype = 0x%x ",
921	be16_to_cpu(cur->eth.ether_type));	921	be16_to_cpu(cur->eth.ether_type));
922	if (cur->eth.vlan_id)	922	if (cur->eth.vlan_id)
923	len += snprintf(buf + len, BUF_SIZE - len,	923	len += scnprintf(buf + len, BUF_SIZE - len,
924	"vlan-id = %d ",	924	"vlan-id = %d ",
925	be16_to_cpu(cur->eth.vlan_id));	925	be16_to_cpu(cur->eth.vlan_id));
926	break;	926	break;
927		927
928	case MLX4_NET_TRANS_RULE_ID_IPV4:	928	case MLX4_NET_TRANS_RULE_ID_IPV4:
929	if (cur->ipv4.src_ip)	929	if (cur->ipv4.src_ip)
930	len += snprintf(buf + len, BUF_SIZE - len,	930	len += scnprintf(buf + len, BUF_SIZE - len,
931	"src-ip = %pI4 ",	931	"src-ip = %pI4 ",
932	&cur->ipv4.src_ip);	932	&cur->ipv4.src_ip);
933	if (cur->ipv4.dst_ip)	933	if (cur->ipv4.dst_ip)
934	len += snprintf(buf + len, BUF_SIZE - len,	934	len += scnprintf(buf + len, BUF_SIZE - len,
935	"dst-ip = %pI4 ",	935	"dst-ip = %pI4 ",
936	&cur->ipv4.dst_ip);	936	&cur->ipv4.dst_ip);
937	break;	937	break;
938		938
939	case MLX4_NET_TRANS_RULE_ID_TCP:	939	case MLX4_NET_TRANS_RULE_ID_TCP:
940	case MLX4_NET_TRANS_RULE_ID_UDP:	940	case MLX4_NET_TRANS_RULE_ID_UDP:
941	if (cur->tcp_udp.src_port)	941	if (cur->tcp_udp.src_port)
942	len += snprintf(buf + len, BUF_SIZE - len,	942	len += scnprintf(buf + len, BUF_SIZE - len,
943	"src-port = %d ",	943	"src-port = %d ",
944	be16_to_cpu(cur->tcp_udp.src_port));	944	be16_to_cpu(cur->tcp_udp.src_port));
945	if (cur->tcp_udp.dst_port)	945	if (cur->tcp_udp.dst_port)
946	len += snprintf(buf + len, BUF_SIZE - len,	946	len += scnprintf(buf + len, BUF_SIZE - len,
947	"dst-port = %d ",	947	"dst-port = %d ",
948	be16_to_cpu(cur->tcp_udp.dst_port));	948	be16_to_cpu(cur->tcp_udp.dst_port));
949	break;	949	break;
950		950
951	case MLX4_NET_TRANS_RULE_ID_IB:	951	case MLX4_NET_TRANS_RULE_ID_IB:
952	len += snprintf(buf + len, BUF_SIZE - len,	952	len += scnprintf(buf + len, BUF_SIZE - len,
953	"dst-gid = %pI6\n", cur->ib.dst_gid);	953	"dst-gid = %pI6\n", cur->ib.dst_gid);
954	len += snprintf(buf + len, BUF_SIZE - len,	954	len += scnprintf(buf + len, BUF_SIZE - len,
955	"dst-gid-mask = %pI6\n",	955	"dst-gid-mask = %pI6\n",
956	cur->ib.dst_gid_msk);	956	cur->ib.dst_gid_msk);
957	break;	957	break;
958		958
959	case MLX4_NET_TRANS_RULE_ID_VXLAN:	959	case MLX4_NET_TRANS_RULE_ID_VXLAN:
960	len += snprintf(buf + len, BUF_SIZE - len,	960	len += scnprintf(buf + len, BUF_SIZE - len,
961	"VNID = %d ", be32_to_cpu(cur->vxlan.vni));	961	"VNID = %d ", be32_to_cpu(cur->vxlan.vni));
962	break;	962	break;
963	case MLX4_NET_TRANS_RULE_ID_IPV6:	963	case MLX4_NET_TRANS_RULE_ID_IPV6:
964	break;	964	break;
@@ -967,7 +967,7 @@ static void mlx4_err_rule(struct mlx4_dev dev, char str, · 2 unmodified lines
967	break;	967	break;
968	}	968	}
969	}	969	}
970	len += snprintf(buf + len, BUF_SIZE - len, "\n");	970	len += scnprintf(buf + len, BUF_SIZE - len, "\n");
971	mlx4_err(dev, "%s", buf);	971	mlx4_err(dev, "%s", buf);
972		972
973	if (len >= BUF_SIZE)	973	if (len >= BUF_SIZE)

drivers/net/ethernet/mellanox/mlx5/core/en.h+2−0

 struct mlx5e_sq_wqe_info {
 	u8  opcode;
+	u8 num_wqebbs;
 	/* Auxiliary data for different opcodes. */
 	union {
 void mlx5e_activate_rq(struct mlx5e_rq *rq);
 void mlx5e_deactivate_rq(struct mlx5e_rq *rq);
 void mlx5e_free_rx_descs(struct mlx5e_rq *rq);
+void mlx5e_free_rx_in_progress_descs(struct mlx5e_rq *rq);
 void mlx5e_activate_icosq(struct mlx5e_icosq *icosq);
 void mlx5e_deactivate_icosq(struct mlx5e_icosq *icosq);

drivers/net/ethernet/mellanox/mlx5/core/en/health.h+1−2

@@ -11,8 +11,7 @@ · 10 unmodified lines
11		11
12	static inline bool cqe_syndrome_needs_recover(u8 syndrome)	12	static inline bool cqe_syndrome_needs_recover(u8 syndrome)
13	{	13	{
14	return syndrome == MLX5_CQE_SYNDROME_LOCAL_LENGTH_ERR \|\|	14	return syndrome == MLX5_CQE_SYNDROME_LOCAL_QP_OP_ERR \|\|
15	syndrome == MLX5_CQE_SYNDROME_LOCAL_QP_OP_ERR \|\|
16	syndrome == MLX5_CQE_SYNDROME_LOCAL_PROT_ERR \|\|	15	syndrome == MLX5_CQE_SYNDROME_LOCAL_PROT_ERR \|\|
17	syndrome == MLX5_CQE_SYNDROME_WR_FLUSH_ERR;	16	syndrome == MLX5_CQE_SYNDROME_WR_FLUSH_ERR;
18	}	17	}

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

@@ -90,7 +90,7 @@ static int mlx5e_rx_reporter_err_icosq_cqe_recover(void *ctx) · 89 unmodified lines
90	goto out;	90	goto out;
91		91
92	mlx5e_reset_icosq_cc_pc(icosq);	92	mlx5e_reset_icosq_cc_pc(icosq);
93	mlx5e_free_rx_descs(rq);	93	mlx5e_free_rx_in_progress_descs(rq);
94	clear_bit(MLX5E_SQ_STATE_RECOVERING, &icosq->state);	94	clear_bit(MLX5E_SQ_STATE_RECOVERING, &icosq->state);
95	mlx5e_activate_icosq(icosq);	95	mlx5e_activate_icosq(icosq);
96	mlx5e_activate_rq(rq);	96	mlx5e_activate_rq(rq);

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h+4−2

 static inline void mlx5e_rqwq_reset(struct mlx5e_rq *rq)
 {
-	if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ)
+	if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) {
 		mlx5_wq_ll_reset(&rq->mpwqe.wq);
-	else
+		rq->mpwqe.actual_wq_head = 0;
+	} else {
 		mlx5_wq_cyc_reset(&rq->wqe.wq);
+	}
 }
 /* SW parser related functions */

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.h+2−2

@@ -38,8 +38,8 @@ enum { · 37 unmodified lines
38		38
39	enum {	39	enum {
40	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_START = 0,	40	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_START = 0,
41	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_SEARCHING = 1,	41	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_TRACKING = 1,
42	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_TRACKING = 2,	42	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_SEARCHING = 2,
43	};	43	};
44		44
45	struct mlx5e_ktls_offload_context_tx {	45	struct mlx5e_ktls_offload_context_tx {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c+1−1

@@ -218,7 +218,7 @@ tx_sync_info_get(struct mlx5e_ktls_offload_context_tx *priv_tx, · 217 unmodified lines
218	* this packet was already acknowledged and its record info	218	* this packet was already acknowledged and its record info
219	* was released.	219	* was released.
220	*/	220	*/
221	ends_before = before(tcp_seq + datalen, tls_record_start_seq(record));	221	ends_before = before(tcp_seq + datalen - 1, tls_record_start_seq(record));
222		222
223	if (unlikely(tls_record_is_start_marker(record))) {	223	if (unlikely(tls_record_is_start_marker(record))) {
224	ret = ends_before ? MLX5E_KTLS_SYNC_SKIP_NO_DATA : MLX5E_KTLS_SYNC_FAIL;	224	ret = ends_before ? MLX5E_KTLS_SYNC_SKIP_NO_DATA : MLX5E_KTLS_SYNC_FAIL;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+24−7

@@ -814,6 +814,29 @@ int mlx5e_wait_for_min_rx_wqes(struct mlx5e_rq *rq, int wait_time) · 813 unmodified lines
814	return -ETIMEDOUT;	814	return -ETIMEDOUT;
815	}	815	}
816		816
		817	void mlx5e_free_rx_in_progress_descs(struct mlx5e_rq *rq)
		818	{
		819	struct mlx5_wq_ll *wq;
		820	u16 head;
		821	int i;
		822
		823	if (rq->wq_type != MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ)
		824	return;
		825
		826	wq = &rq->mpwqe.wq;
		827	head = wq->head;
		828
		829	/* Outstanding UMR WQEs (in progress) start at wq->head */
		830	for (i = 0; i < rq->mpwqe.umr_in_progress; i++) {
		831	rq->dealloc_wqe(rq, head);
		832	head = mlx5_wq_ll_get_wqe_next_ix(wq, head);
		833	}
		834
		835	rq->mpwqe.actual_wq_head = wq->head;
		836	rq->mpwqe.umr_in_progress = 0;
		837	rq->mpwqe.umr_completed = 0;
		838	}
		839
817	void mlx5e_free_rx_descs(struct mlx5e_rq *rq)	840	void mlx5e_free_rx_descs(struct mlx5e_rq *rq)
818	{	841	{
819	__be16 wqe_ix_be;	842	__be16 wqe_ix_be;
@@ -821,14 +844,8 @@ void mlx5e_free_rx_descs(struct mlx5e_rq *rq) · 1 unmodified line
821		844
822	if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) {	845	if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) {
823	struct mlx5_wq_ll *wq = &rq->mpwqe.wq;	846	struct mlx5_wq_ll *wq = &rq->mpwqe.wq;
824	u16 head = wq->head;
825	int i;
826		847
827	/* Outstanding UMR WQEs (in progress) start at wq->head */	848	mlx5e_free_rx_in_progress_descs(rq);
828	for (i = 0; i < rq->mpwqe.umr_in_progress; i++) {
829	rq->dealloc_wqe(rq, head);
830	head = mlx5_wq_ll_get_wqe_next_ix(wq, head);
831	}
832		849
833	while (!mlx5_wq_ll_is_empty(wq)) {	850	while (!mlx5_wq_ll_is_empty(wq)) {
834	struct mlx5e_rx_wqe_ll *wqe;	851	struct mlx5e_rx_wqe_ll *wqe;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+5−6

 	/* fill sq frag edge with nops to avoid wqe wrapping two pages */
 	for (; wi < edge_wi; wi++) {
 		wi->opcode = MLX5_OPCODE_NOP;
+		wi->num_wqebbs = 1;
 		mlx5e_post_nop(wq, sq->sqn, &sq->pc);
 	}
 }
 	umr_wqe->uctrl.xlt_offset = cpu_to_be16(xlt_offset);
 	sq->db.ico_wqe[pi].opcode = MLX5_OPCODE_UMR;
+	sq->db.ico_wqe[pi].num_wqebbs = MLX5E_UMR_WQEBBS;
 	sq->db.ico_wqe[pi].umr.rq = rq;
 	sq->pc += MLX5E_UMR_WQEBBS;
 			ci = mlx5_wq_cyc_ctr2ix(&sq->wq, sqcc);
 			wi = &sq->db.ico_wqe[ci];
+			sqcc += wi->num_wqebbs;
 			if (last_wqe && unlikely(get_cqe_opcode(cqe) != MLX5_CQE_REQ)) {
 				netdev_WARN_ONCE(cq->channel->netdev,
 				break;
 			}
-			if (likely(wi->opcode == MLX5_OPCODE_UMR)) {
+			if (likely(wi->opcode == MLX5_OPCODE_UMR))
-				sqcc += MLX5E_UMR_WQEBBS;
 				wi->umr.rq->mpwqe.umr_completed++;
-			} else if (likely(wi->opcode == MLX5_OPCODE_NOP)) {
+			else if (unlikely(wi->opcode != MLX5_OPCODE_NOP))
-				sqcc++;
-			} else {
 				netdev_WARN_ONCE(cq->channel->netdev,
 						 "Bad OPCODE in ICOSQ WQE info: 0x%x\n",
 						 wi->opcode);
-			}
 		} while (!last_wqe);

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

 			continue;
 		if (f->field_bsize == 32) {
-			mask_be32 = *(__be32 *)&mask;
+			mask_be32 = (__be32)mask;
 			mask = (__force unsigned long)cpu_to_le32(be32_to_cpu(mask_be32));
 		} else if (f->field_bsize == 16) {
-			mask_be16 = *(__be16 *)&mask;
+			mask_be32 = (__be32)mask;
+			mask_be16 = *(__be16 *)&mask_be32;
 			mask = (__force unsigned long)cpu_to_le16(be16_to_cpu(mask_be16));
 		}

drivers/net/ethernet/mellanox/mlx5/core/en_txrx.c+1−0

@@ -79,6 +79,7 @@ void mlx5e_trigger_irq(struct mlx5e_icosq *sq) · 78 unmodified lines
79	u16 pi = mlx5_wq_cyc_ctr2ix(wq, sq->pc);	79	u16 pi = mlx5_wq_cyc_ctr2ix(wq, sq->pc);
80		80
81	sq->db.ico_wqe[pi].opcode = MLX5_OPCODE_NOP;	81	sq->db.ico_wqe[pi].opcode = MLX5_OPCODE_NOP;
		82	sq->db.ico_wqe[pi].num_wqebbs = 1;
82	nopwqe = mlx5e_post_nop(wq, sq->sqn, &sq->pc);	83	nopwqe = mlx5e_post_nop(wq, sq->sqn, &sq->pc);
83	mlx5e_notify_hw(wq, sq->pc, sq->uar_map, &nopwqe->ctrl);	84	mlx5e_notify_hw(wq, sq->pc, sq->uar_map, &nopwqe->ctrl);
84	}	85	}

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

 			break;
 	if (i == MLX5_MAX_PORTS) {
-		if (ldev->nb.notifier_call)
+		if (ldev->nb.notifier_call) {
 			unregister_netdevice_notifier_net(&init_net, &ldev->nb);
+			ldev->nb.notifier_call = NULL;
+		}
 		mlx5_lag_mp_cleanup(ldev);
 		cancel_delayed_work_sync(&ldev->bond_work);
 		mlx5_lag_dev_free(ldev);

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c+0−1

@@ -933,7 +933,6 @@ static int dr_actions_l2_rewrite(struct mlx5dr_domain *dmn, · 932 unmodified lines
933		933
934	action->rewrite.data = (void *)ops;	934	action->rewrite.data = (void *)ops;
935	action->rewrite.num_of_actions = i;	935	action->rewrite.num_of_actions = i;
936	action->rewrite.chunk->byte_size = i * sizeof(*ops);
937		936
938	ret = mlx5dr_send_postsend_action(dmn, action);	937	ret = mlx5dr_send_postsend_action(dmn, action);
939	if (ret) {	938	if (ret) {

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_send.c+2−1

@@ -558,7 +558,8 @@ int mlx5dr_send_postsend_action(struct mlx5dr_domain *dmn, · 557 unmodified lines
558	int ret;	558	int ret;
559		559
560	send_info.write.addr = (uintptr_t)action->rewrite.data;	560	send_info.write.addr = (uintptr_t)action->rewrite.data;
561	send_info.write.length = action->rewrite.chunk->byte_size;	561	send_info.write.length = action->rewrite.num_of_actions *
		562	DR_MODIFY_ACTION_SIZE;
562	send_info.write.lkey = 0;	563	send_info.write.lkey = 0;
563	send_info.remote_addr = action->rewrite.chunk->mr_addr;	564	send_info.remote_addr = action->rewrite.chunk->mr_addr;
564	send_info.rkey = action->rewrite.chunk->rkey;	565	send_info.rkey = action->rewrite.chunk->rkey;

drivers/net/ethernet/mellanox/mlx5/core/vport.c+3−0

 		MLX5_SET64(hca_vport_context, ctx, port_guid, req->port_guid);
 	if (req->field_select & MLX5_HCA_VPORT_SEL_NODE_GUID)
 		MLX5_SET64(hca_vport_context, ctx, node_guid, req->node_guid);
+	MLX5_SET(hca_vport_context, ctx, cap_mask1, req->cap_mask1);
+	MLX5_SET(hca_vport_context, ctx, cap_mask1_field_select,
+		 req->cap_mask1_perm);
 	err = mlx5_cmd_exec(dev, in, in_sz, out, sizeof(out));
 ex:
 	kfree(in);

drivers/net/ethernet/mellanox/mlxsw/pci.c+39−11

 			    mbox->mapaddr);
 }
-static int mlxsw_pci_sw_reset(struct mlxsw_pci *mlxsw_pci,
+static int mlxsw_pci_sys_ready_wait(struct mlxsw_pci *mlxsw_pci,
-			      const struct pci_device_id *id)
+				    const struct pci_device_id *id,
+				    u32 *p_sys_status)
 {
 	unsigned long end;
-	char mrsr_pl[MLXSW_REG_MRSR_LEN];
+	u32 val;
-	int err;
-	mlxsw_reg_mrsr_pack(mrsr_pl);
-	err = mlxsw_reg_write(mlxsw_pci->core, MLXSW_REG(mrsr), mrsr_pl);
-	if (err)
-		return err;
 	if (id->device == PCI_DEVICE_ID_MELLANOX_SWITCHX2) {
 		msleep(MLXSW_PCI_SW_RESET_TIMEOUT_MSECS);
 		return 0;
 	}
-	/* We must wait for the HW to become responsive once again. */
+	/* We must wait for the HW to become responsive. */
 	msleep(MLXSW_PCI_SW_RESET_WAIT_MSECS);
 	end = jiffies + msecs_to_jiffies(MLXSW_PCI_SW_RESET_TIMEOUT_MSECS);
 	do {
-		u32 val = mlxsw_pci_read32(mlxsw_pci, FW_READY);
+		val = mlxsw_pci_read32(mlxsw_pci, FW_READY);
 		if ((val & MLXSW_PCI_FW_READY_MASK) == MLXSW_PCI_FW_READY_MAGIC)
 			return 0;
 		cond_resched();
 	} while (time_before(jiffies, end));
+	*p_sys_status = val & MLXSW_PCI_FW_READY_MASK;
 	return -EBUSY;
 }
+static int mlxsw_pci_sw_reset(struct mlxsw_pci *mlxsw_pci,
+			      const struct pci_device_id *id)
+{
+	struct pci_dev *pdev = mlxsw_pci->pdev;
+	char mrsr_pl[MLXSW_REG_MRSR_LEN];
+	u32 sys_status;
+	int err;
+	err = mlxsw_pci_sys_ready_wait(mlxsw_pci, id, &sys_status);
+	if (err) {
+		dev_err(&pdev->dev, "Failed to reach system ready status before reset. Status is 0x%x\n",
+			sys_status);
+		return err;
+	}
+	mlxsw_reg_mrsr_pack(mrsr_pl);
+	err = mlxsw_reg_write(mlxsw_pci->core, MLXSW_REG(mrsr), mrsr_pl);
+	if (err)
+		return err;
+	err = mlxsw_pci_sys_ready_wait(mlxsw_pci, id, &sys_status);
+	if (err) {
+		dev_err(&pdev->dev, "Failed to reach system ready status after reset. Status is 0x%x\n",
+			sys_status);
+		return err;
+	}
+	return 0;
+}
 static int mlxsw_pci_alloc_irq_vectors(struct mlxsw_pci *mlxsw_pci)
 {
 	int err;

drivers/net/ethernet/mellanox/mlxsw/reg.h+1−1

@@ -3572,7 +3572,7 @@ MLXSW_ITEM32(reg, qeec, mase, 0x10, 31, 1); · 3571 unmodified lines
3572	* When in bytes mode, value is specified in units of 1000bps.	3572	* When in bytes mode, value is specified in units of 1000bps.
3573	* Access: RW	3573	* Access: RW
3574	*/	3574	*/
3575	MLXSW_ITEM32(reg, qeec, max_shaper_rate, 0x10, 0, 28);	3575	MLXSW_ITEM32(reg, qeec, max_shaper_rate, 0x10, 0, 31);
3576		3576
3577	/* reg_qeec_de	3577	/* reg_qeec_de
3578	* DWRR configuration enable. Enables configuration of the dwrr and	3578	* DWRR configuration enable. Enables configuration of the dwrr and

drivers/net/ethernet/neterion/vxge/vxge-config.h+1−1

@@ -2045,7 +2045,7 @@ vxge_hw_vpath_strip_fcs_check(struct __vxge_hw_device *hldev, u64 vpath_mask); · 2044 unmodified lines
2045	if ((level >= VXGE_ERR && VXGE_COMPONENT_LL & VXGE_DEBUG_ERR_MASK) \|\| \	2045	if ((level >= VXGE_ERR && VXGE_COMPONENT_LL & VXGE_DEBUG_ERR_MASK) \|\| \
2046	(level >= VXGE_TRACE && VXGE_COMPONENT_LL & VXGE_DEBUG_TRACE_MASK))\	2046	(level >= VXGE_TRACE && VXGE_COMPONENT_LL & VXGE_DEBUG_TRACE_MASK))\
2047	if ((mask & VXGE_DEBUG_MASK) == mask) \	2047	if ((mask & VXGE_DEBUG_MASK) == mask) \
2048	printk(fmt "\n", __VA_ARGS__); \	2048	printk(fmt "\n", ##__VA_ARGS__); \
2049	} while (0)	2049	} while (0)
2050	#else	2050	#else
2051	#define vxge_debug_ll(level, mask, fmt, ...)	2051	#define vxge_debug_ll(level, mask, fmt, ...)

drivers/net/ethernet/neterion/vxge/vxge-main.h+7−7

drivers/net/ethernet/netronome/nfp/nfpcore/nfp6000_pcie.c+4−4

@@ -616,7 +616,7 @@ static int enable_bars(struct nfp6000_pcie *nfp, u16 interface) · 615 unmodified lines
616	if (bar->iomem) {	616	if (bar->iomem) {
617	int pf;	617	int pf;
618		618
619	msg += snprintf(msg, end - msg, "0.0: General/MSI-X SRAM, ");	619	msg += scnprintf(msg, end - msg, "0.0: General/MSI-X SRAM, ");
620	atomic_inc(&bar->refcnt);	620	atomic_inc(&bar->refcnt);
621	bars_free--;	621	bars_free--;
622		622
@@ -661,7 +661,7 @@ static int enable_bars(struct nfp6000_pcie *nfp, u16 interface) · 38 unmodified lines
661		661
662	/* Configure, and lock, BAR0.1 for PCIe XPB (MSI-X PBA) */	662	/* Configure, and lock, BAR0.1 for PCIe XPB (MSI-X PBA) */
663	bar = &nfp->bar[1];	663	bar = &nfp->bar[1];
664	msg += snprintf(msg, end - msg, "0.1: PCIe XPB/MSI-X PBA, ");	664	msg += scnprintf(msg, end - msg, "0.1: PCIe XPB/MSI-X PBA, ");
665	atomic_inc(&bar->refcnt);	665	atomic_inc(&bar->refcnt);
666	bars_free--;	666	bars_free--;
667		667
@@ -680,8 +680,8 @@ static int enable_bars(struct nfp6000_pcie *nfp, u16 interface) · 12 unmodified lines
680	bar->iomem = ioremap(nfp_bar_resource_start(bar),	680	bar->iomem = ioremap(nfp_bar_resource_start(bar),
681	nfp_bar_resource_len(bar));	681	nfp_bar_resource_len(bar));
682	if (bar->iomem) {	682	if (bar->iomem) {
683	msg += snprintf(msg, end - msg,	683	msg += scnprintf(msg, end - msg,
684	"0.%d: Explicit%d, ", 4 + i, i);	684	"0.%d: Explicit%d, ", 4 + i, i);
685	atomic_inc(&bar->refcnt);	685	atomic_inc(&bar->refcnt);
686	bars_free--;	686	bars_free--;
687		687

drivers/net/ethernet/pensando/ionic/ionic_if.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB OR BSD-2-Clause */	1	/* SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) OR BSD-2-Clause */
2	/* Copyright (c) 2017-2019 Pensando Systems, Inc. All rights reserved. */	2	/* Copyright (c) 2017-2019 Pensando Systems, Inc. All rights reserved. */
3		3
4	#ifndef _IONIC_IF_H_	4	#ifndef _IONIC_IF_H_

drivers/net/ethernet/pensando/ionic/ionic_lif.c+7−7

drivers/net/ethernet/pensando/ionic/ionic_regs.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB OR BSD-2-Clause */	1	/* SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) OR BSD-2-Clause */
2	/* Copyright (c) 2018-2019 Pensando Systems, Inc. All rights reserved. */	2	/* Copyright (c) 2018-2019 Pensando Systems, Inc. All rights reserved. */
3		3
4	#ifndef IONIC_REGS_H	4	#ifndef IONIC_REGS_H

drivers/net/ethernet/realtek/r8169_main.c+1−1

@@ -5091,7 +5091,7 @@ static int rtl_alloc_irq(struct rtl8169_private *tp) · 5090 unmodified lines
5091	RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable);	5091	RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable);
5092	rtl_lock_config_regs(tp);	5092	rtl_lock_config_regs(tp);
5093	/* fall through */	5093	/* fall through */
5094	case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_24:	5094	case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_17:
5095	flags = PCI_IRQ_LEGACY;	5095	flags = PCI_IRQ_LEGACY;
5096	break;	5096	break;
5097	default:	5097	default:

drivers/net/ethernet/sfc/mcdi.c+18−14

 		 * progress on a NIC at any one time.  So no need for locking.
 		 */
 		for (i = 0; i < hdr_len / 4 && bytes < PAGE_SIZE; i++)
-			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,
+			bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-					  " %08x", le32_to_cpu(hdr[i].u32[0]));
+					   " %08x",
+					   le32_to_cpu(hdr[i].u32[0]));
 		for (i = 0; i < inlen / 4 && bytes < PAGE_SIZE; i++)
-			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,
+			bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-					  " %08x", le32_to_cpu(inbuf[i].u32[0]));
+					   " %08x",
+					   le32_to_cpu(inbuf[i].u32[0]));
 		netif_info(efx, hw, efx->net_dev, "MCDI RPC REQ:%s\n", buf);
 	}
 		 */
 		for (i = 0; i < hdr_len && bytes < PAGE_SIZE; i++) {
 			efx->type->mcdi_read_response(efx, &hdr, (i * 4), 4);
-			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,
+			bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-					  " %08x", le32_to_cpu(hdr.u32[0]));
+					   " %08x", le32_to_cpu(hdr.u32[0]));
 		}
 		for (i = 0; i < data_len && bytes < PAGE_SIZE; i++) {
 			efx->type->mcdi_read_response(efx, &hdr,
 					mcdi->resp_hdr_len + (i * 4), 4);
-			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,
+			bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-					  " %08x", le32_to_cpu(hdr.u32[0]));
+					   " %08x", le32_to_cpu(hdr.u32[0]));
 		}
 		netif_info(efx, hw, efx->net_dev, "MCDI RPC RESP:%s\n", buf);
 	}
 	ver_words = (__le16 *)MCDI_PTR(outbuf, GET_VERSION_OUT_VERSION);
-	offset = snprintf(buf, len, "%u.%u.%u.%u",
+	offset = scnprintf(buf, len, "%u.%u.%u.%u",
-			  le16_to_cpu(ver_words[0]), le16_to_cpu(ver_words[1]),
+			   le16_to_cpu(ver_words[0]),
-			  le16_to_cpu(ver_words[2]), le16_to_cpu(ver_words[3]));
+			   le16_to_cpu(ver_words[1]),
+			   le16_to_cpu(ver_words[2]),
+			   le16_to_cpu(ver_words[3]));
 	/* EF10 may have multiple datapath firmware variants within a
 	 * single version.  Report which variants are running.
 	if (efx_nic_rev(efx) >= EFX_REV_HUNT_A0) {
 		struct efx_ef10_nic_data *nic_data = efx->nic_data;
-		offset += snprintf(buf + offset, len - offset, " rx%x tx%x",
+		offset += scnprintf(buf + offset, len - offset, " rx%x tx%x",
-				   nic_data->rx_dpcpu_fw_id,
+				    nic_data->rx_dpcpu_fw_id,
-				   nic_data->tx_dpcpu_fw_id);
+				    nic_data->tx_dpcpu_fw_id);
 		/* It's theoretically possible for the string to exceed 31
 		 * characters, though in practice the first three version

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

@@ -1411,7 +1411,7 @@ static int rk_gmac_probe(struct platform_device *pdev) · 1410 unmodified lines
1411		1411
1412	ret = rk_gmac_clk_init(plat_dat);	1412	ret = rk_gmac_clk_init(plat_dat);
1413	if (ret)	1413	if (ret)
1414	return ret;	1414	goto err_remove_config_dt;
1415		1415
1416	ret = rk_gmac_powerup(plat_dat->bsp_priv);	1416	ret = rk_gmac_powerup(plat_dat->bsp_priv);
1417	if (ret)	1417	if (ret)

drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c+10−4

 	 * In case the wake up interrupt is not passed from the platform
 	 * so the driver will continue to use the mac irq (ndev->irq)
 	 */
-	stmmac_res->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
+	stmmac_res->wol_irq =
+		platform_get_irq_byname_optional(pdev, "eth_wake_irq");
 	if (stmmac_res->wol_irq < 0) {
 		if (stmmac_res->wol_irq == -EPROBE_DEFER)
 			return -EPROBE_DEFER;
+		dev_info(&pdev->dev, "IRQ eth_wake_irq not found\n");
 		stmmac_res->wol_irq = stmmac_res->irq;
 	}
-	stmmac_res->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
+	stmmac_res->lpi_irq =
-	if (stmmac_res->lpi_irq == -EPROBE_DEFER)
+		platform_get_irq_byname_optional(pdev, "eth_lpi");
-		return -EPROBE_DEFER;
+	if (stmmac_res->lpi_irq < 0) {
+		if (stmmac_res->lpi_irq == -EPROBE_DEFER)
+			return -EPROBE_DEFER;
+		dev_info(&pdev->dev, "IRQ eth_lpi not found\n");
+	}
 	stmmac_res->addr = devm_platform_ioremap_resource(pdev, 0);

drivers/net/geneve.c+6−2

 		if (!net_eq(dev_net(geneve->dev), net))
 			unregister_netdevice_queue(geneve->dev, head);
 	}
-	WARN_ON_ONCE(!list_empty(&gn->sock_list));
 }
 static void __net_exit geneve_exit_batch_net(struct list_head *net_list)
 	/* unregister the devices gathered above */
 	unregister_netdevice_many(&list);
 	rtnl_unlock();
+	list_for_each_entry(net, net_list, exit_list) {
+		const struct geneve_net *gn = net_generic(net, geneve_net_id);
+		WARN_ON_ONCE(!list_empty(&gn->sock_list));
+	}
 }
 static struct pernet_operations geneve_net_ops = {

drivers/net/ifb.c+3−3

@@ -75,7 +75,7 @@ static void ifb_ri_tasklet(unsigned long _txp) · 74 unmodified lines
75	}	75	}
76		76
77	while ((skb = __skb_dequeue(&txp->tq)) != NULL) {	77	while ((skb = __skb_dequeue(&txp->tq)) != NULL) {
78	skb->tc_redirected = 0;	78	skb->redirected = 0;
79	skb->tc_skip_classify = 1;	79	skb->tc_skip_classify = 1;
80		80
81	u64_stats_update_begin(&txp->tsync);	81	u64_stats_update_begin(&txp->tsync);
@@ -96,7 +96,7 @@ static void ifb_ri_tasklet(unsigned long _txp) · 14 unmodified lines
96	rcu_read_unlock();	96	rcu_read_unlock();
97	skb->skb_iif = txp->dev->ifindex;	97	skb->skb_iif = txp->dev->ifindex;
98		98
99	if (!skb->tc_from_ingress) {	99	if (!skb->from_ingress) {
100	dev_queue_xmit(skb);	100	dev_queue_xmit(skb);
101	} else {	101	} else {
102	skb_pull_rcsum(skb, skb->mac_len);	102	skb_pull_rcsum(skb, skb->mac_len);
@@ -243,7 +243,7 @@ static netdev_tx_t ifb_xmit(struct sk_buff skb, struct net_device dev) · 140 unmodified lines
243	txp->rx_bytes += skb->len;	243	txp->rx_bytes += skb->len;
244	u64_stats_update_end(&txp->rsync);	244	u64_stats_update_end(&txp->rsync);
245		245
246	if (!skb->tc_redirected \|\| !skb->skb_iif) {	246	if (!skb->redirected \|\| !skb->skb_iif) {
247	dev_kfree_skb(skb);	247	dev_kfree_skb(skb);
248	dev->stats.rx_dropped++;	248	dev->stats.rx_dropped++;
249	return NETDEV_TX_OK;	249	return NETDEV_TX_OK;

drivers/net/macsec.c+3−0

 #include <net/macsec.h>
 #include <linux/phy.h>
 #include <linux/byteorder/generic.h>
+#include <linux/if_arp.h>
 #include <uapi/linux/if_macsec.h>
 	real_dev = __dev_get_by_index(net, nla_get_u32(tb[IFLA_LINK]));
 	if (!real_dev)
 		return -ENODEV;
+	if (real_dev->type != ARPHRD_ETHER)
+		return -EINVAL;
 	dev->priv_flags |= IFF_MACSEC;

drivers/net/netdevsim/ipsec.c+15−15

@@ -29,9 +29,9 @@ static ssize_t nsim_dbg_netdev_ops_read(struct file *filp, · 28 unmodified lines
29	return -ENOMEM;	29	return -ENOMEM;
30		30
31	p = buf;	31	p = buf;
32	p += snprintf(p, bufsize - (p - buf),	32	p += scnprintf(p, bufsize - (p - buf),
33	"SA count=%u tx=%u\n",	33	"SA count=%u tx=%u\n",
34	ipsec->count, ipsec->tx);	34	ipsec->count, ipsec->tx);
35		35
36	for (i = 0; i < NSIM_IPSEC_MAX_SA_COUNT; i++) {	36	for (i = 0; i < NSIM_IPSEC_MAX_SA_COUNT; i++) {
37	struct nsim_sa *sap = &ipsec->sa[i];	37	struct nsim_sa *sap = &ipsec->sa[i];
@@ -39,18 +39,18 @@ static ssize_t nsim_dbg_netdev_ops_read(struct file *filp, · 1 unmodified line
39	if (!sap->used)	39	if (!sap->used)
40	continue;	40	continue;
41		41
42	p += snprintf(p, bufsize - (p - buf),	42	p += scnprintf(p, bufsize - (p - buf),
43	"sa[%i] %cx ipaddr=0x%08x %08x %08x %08x\n",	43	"sa[%i] %cx ipaddr=0x%08x %08x %08x %08x\n",
44	i, (sap->rx ? 'r' : 't'), sap->ipaddr[0],	44	i, (sap->rx ? 'r' : 't'), sap->ipaddr[0],
45	sap->ipaddr[1], sap->ipaddr[2], sap->ipaddr[3]);	45	sap->ipaddr[1], sap->ipaddr[2], sap->ipaddr[3]);
46	p += snprintf(p, bufsize - (p - buf),	46	p += scnprintf(p, bufsize - (p - buf),
47	"sa[%i] spi=0x%08x proto=0x%x salt=0x%08x crypt=%d\n",	47	"sa[%i] spi=0x%08x proto=0x%x salt=0x%08x crypt=%d\n",
48	i, be32_to_cpu(sap->xs->id.spi),	48	i, be32_to_cpu(sap->xs->id.spi),
49	sap->xs->id.proto, sap->salt, sap->crypt);	49	sap->xs->id.proto, sap->salt, sap->crypt);
50	p += snprintf(p, bufsize - (p - buf),	50	p += scnprintf(p, bufsize - (p - buf),
51	"sa[%i] key=0x%08x %08x %08x %08x\n",	51	"sa[%i] key=0x%08x %08x %08x %08x\n",
52	i, sap->key[0], sap->key[1],	52	i, sap->key[0], sap->key[1],
53	sap->key[2], sap->key[3]);	53	sap->key[2], sap->key[3]);
54	}	54	}
55		55
56	len = simple_read_from_buffer(buffer, count, ppos, buf, p - buf);	56	len = simple_read_from_buffer(buffer, count, ppos, buf, p - buf);

drivers/net/phy/dp83867.c+20−1

 #define DP83867_CTRL		0x1f
 /* Extended Registers */
-#define DP83867_CFG4            0x0031
+#define DP83867_FLD_THR_CFG	0x002e
+#define DP83867_CFG4		0x0031
 #define DP83867_CFG4_SGMII_ANEG_MASK (BIT(5) | BIT(6))
 #define DP83867_CFG4_SGMII_ANEG_TIMER_11MS   (3 << 5)
 #define DP83867_CFG4_SGMII_ANEG_TIMER_800US  (2 << 5)
 #define DP83867_STRAP_STS2_CLK_SKEW_RX_MASK	GENMASK(2, 0)
 #define DP83867_STRAP_STS2_CLK_SKEW_RX_SHIFT	0
 #define DP83867_STRAP_STS2_CLK_SKEW_NONE	BIT(2)
+#define DP83867_STRAP_STS2_STRAP_FLD		BIT(10)
 /* PHY CTRL bits */
 #define DP83867_PHYCR_TX_FIFO_DEPTH_SHIFT	14
 /* CFG4 bits */
 #define DP83867_CFG4_PORT_MIRROR_EN              BIT(0)
+/* FLD_THR_CFG */
+#define DP83867_FLD_THR_CFG_ENERGY_LOST_THR_MASK	0x7
 enum {
 	DP83867_PORT_MIRROING_KEEP,
 	DP83867_PORT_MIRROING_EN,
 		phy_clear_bits_mmd(phydev, DP83867_DEVADDR, DP83867_CFG4,
 				   BIT(7));
+	bs = phy_read_mmd(phydev, DP83867_DEVADDR, DP83867_STRAP_STS2);
+	if (bs & DP83867_STRAP_STS2_STRAP_FLD) {
+		/* When using strap to enable FLD, the ENERGY_LOST_FLD_THR will
+		 * be set to 0x2. This may causes the PHY link to be unstable -
+		 * the default value 0x1 need to be restored.
+		 */
+		ret = phy_modify_mmd(phydev, DP83867_DEVADDR,
+				     DP83867_FLD_THR_CFG,
+				     DP83867_FLD_THR_CFG_ENERGY_LOST_THR_MASK,
+				     0x1);
+		if (ret)
+			return ret;
+	}
 	if (phy_interface_is_rgmii(phydev) ||
 	    phydev->interface == PHY_INTERFACE_MODE_SGMII) {
 		val = phy_read(phydev, MII_DP83867_PHYCTRL);

drivers/net/phy/mdio-bcm-unimac.c+2−4

 		return -ENOMEM;
 	}
-	priv->clk = devm_clk_get(&pdev->dev, NULL);
+	priv->clk = devm_clk_get_optional(&pdev->dev, NULL);
-	if (PTR_ERR(priv->clk) == -EPROBE_DEFER)
+	if (IS_ERR(priv->clk))
 		return PTR_ERR(priv->clk);
-	else
-		priv->clk = NULL;
 	ret = clk_prepare_enable(priv->clk);
 	if (ret)

drivers/net/phy/mdio-mux-bcm-iproc.c+6−1

 static int mdio_mux_iproc_resume(struct device *dev)
 {
 	struct iproc_mdiomux_desc *md = dev_get_drvdata(dev);
+	int rc;
-	clk_prepare_enable(md->core_clk);
+	rc = clk_prepare_enable(md->core_clk);
+	if (rc) {
+		dev_err(md->dev, "failed to enable core clk\n");
+		return rc;
+	}
 	mdio_mux_iproc_config(md);
 	return 0;

drivers/net/phy/sfp-bus.c+18−14

@@ -572,13 +572,15 @@ static void sfp_upstream_clear(struct sfp_bus *bus) · 571 unmodified lines
572	* the sfp_bus structure, incrementing its reference count. This must	572	* the sfp_bus structure, incrementing its reference count. This must
573	* be put via sfp_bus_put() when done.	573	* be put via sfp_bus_put() when done.
574	*	574	*
575	* Returns: on success, a pointer to the sfp_bus structure,	575	* Returns:
576	* %NULL if no SFP is specified,	576	* - on success, a pointer to the sfp_bus structure,
577	* on failure, an error pointer value:	577	* - %NULL if no SFP is specified,
578	* corresponding to the errors detailed for	578	* - on failure, an error pointer value:
579	* fwnode_property_get_reference_args().	579	*
580	* %-ENOMEM if we failed to allocate the bus.	580	* - corresponding to the errors detailed for
581	* an error from the upstream's connect_phy() method.	581	* fwnode_property_get_reference_args().
		582	* - %-ENOMEM if we failed to allocate the bus.
		583	* - an error from the upstream's connect_phy() method.
582	*/	584	*/
583	struct sfp_bus sfp_bus_find_fwnode(struct fwnode_handle fwnode)	585	struct sfp_bus sfp_bus_find_fwnode(struct fwnode_handle fwnode)
584	{	586	{
@@ -612,13 +614,15 @@ EXPORT_SYMBOL_GPL(sfp_bus_find_fwnode); · 27 unmodified lines
612	* the SFP bus using sfp_register_upstream(). This takes a reference on the	614	* the SFP bus using sfp_register_upstream(). This takes a reference on the
613	* bus, so it is safe to put the bus after this call.	615	* bus, so it is safe to put the bus after this call.
614	*	616	*
615	* Returns: on success, a pointer to the sfp_bus structure,	617	* Returns:
616	* %NULL if no SFP is specified,	618	* - on success, a pointer to the sfp_bus structure,
617	* on failure, an error pointer value:	619	* - %NULL if no SFP is specified,
618	* corresponding to the errors detailed for	620	* - on failure, an error pointer value:
619	* fwnode_property_get_reference_args().	621	*
620	* %-ENOMEM if we failed to allocate the bus.	622	* - corresponding to the errors detailed for
621	* an error from the upstream's connect_phy() method.	623	* fwnode_property_get_reference_args().
		624	* - %-ENOMEM if we failed to allocate the bus.
		625	* - an error from the upstream's connect_phy() method.
622	*/	626	*/
623	int sfp_bus_add_upstream(struct sfp_bus bus, void upstream,	627	int sfp_bus_add_upstream(struct sfp_bus bus, void upstream,
624	const struct sfp_upstream_ops *ops)	628	const struct sfp_upstream_ops *ops)

drivers/net/usb/qmi_wwan.c+1−0

@@ -1210,6 +1210,7 @@ static const struct usb_device_id products[] = { · 1209 unmodified lines
1210	{QMI_FIXED_INTF(0x1435, 0xd182, 5)}, /* Wistron NeWeb D18 */	1210	{QMI_FIXED_INTF(0x1435, 0xd182, 5)}, /* Wistron NeWeb D18 */
1211	{QMI_FIXED_INTF(0x1435, 0xd191, 4)}, /* Wistron NeWeb D19Q1 */	1211	{QMI_FIXED_INTF(0x1435, 0xd191, 4)}, /* Wistron NeWeb D19Q1 */
1212	{QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */	1212	{QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */
		1213	{QMI_FIXED_INTF(0x1690, 0x7588, 4)}, /* ASKEY WWHC050 */
1213	{QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */	1214	{QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */
1214	{QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */	1215	{QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */
1215	{QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */	1216	{QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */

drivers/net/vxlan.c+9−2

 /* Setup stats when device is created */
 static int vxlan_init(struct net_device *dev)
 {
+	struct vxlan_dev *vxlan = netdev_priv(dev);
+	int err;
 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 	if (!dev->tstats)
 		return -ENOMEM;
+	err = gro_cells_init(&vxlan->gro_cells, dev);
+	if (err) {
+		free_percpu(dev->tstats);
+		return err;
+	}
 	return 0;
 }
 	vxlan->dev = dev;
-	gro_cells_init(&vxlan->gro_cells, dev);
 	for (h = 0; h < FDB_HASH_SIZE; ++h) {
 		spin_lock_init(&vxlan->hash_lock[h]);
 		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);

drivers/net/wireguard/device.c+1−1

@@ -122,7 +122,7 @@ static netdev_tx_t wg_xmit(struct sk_buff skb, struct net_device dev) · 121 unmodified lines
122	u32 mtu;	122	u32 mtu;
123	int ret;	123	int ret;
124		124
125	if (unlikely(wg_skb_examine_untrusted_ip_hdr(skb) != skb->protocol)) {	125	if (unlikely(!wg_check_packet_protocol(skb))) {
126	ret = -EPROTONOSUPPORT;	126	ret = -EPROTONOSUPPORT;
127	net_dbg_ratelimited("%s: Invalid IP packet\n", dev->name);	127	net_dbg_ratelimited("%s: Invalid IP packet\n", dev->name);
128	goto err;	128	goto err;

drivers/net/wireguard/netlink.c+2−6

 		peer = wg_peer_create(wg, public_key, preshared_key);
 		if (IS_ERR(peer)) {
-			/* Similar to the above, if the key is invalid, we skip
+			ret = PTR_ERR(peer);
-			 * it without fanfare, so that services don't need to
-			 * worry about doing key validation themselves.
-			 */
-			ret = PTR_ERR(peer) == -EKEYREJECTED ? 0 : PTR_ERR(peer);
 			peer = NULL;
 			goto out;
 		}
 							 private_key);
 		list_for_each_entry_safe(peer, temp, &wg->peer_list,
 					 peer_list) {
-			BUG_ON(!wg_noise_precompute_static_static(peer));
+			wg_noise_precompute_static_static(peer);
 			wg_noise_expire_current_peer_keypairs(peer);
 		}
 		wg_cookie_checker_precompute_device_keys(&wg->cookie_checker);

drivers/net/wireguard/noise.c+29−26

 }
 /* Must hold peer->handshake.static_identity->lock */
-bool wg_noise_precompute_static_static(struct wg_peer *peer)
+void wg_noise_precompute_static_static(struct wg_peer *peer)
 {
-	bool ret;
 	down_write(&peer->handshake.lock);
-	if (peer->handshake.static_identity->has_identity) {
+	if (!peer->handshake.static_identity->has_identity ||
-		ret = curve25519(
+	    !curve25519(peer->handshake.precomputed_static_static,
-			peer->handshake.precomputed_static_static,
 			peer->handshake.static_identity->static_private,
-			peer->handshake.remote_static);
+			peer->handshake.remote_static))
-	} else {
-		u8 empty[NOISE_PUBLIC_KEY_LEN] = { 0 };
-		ret = curve25519(empty, empty, peer->handshake.remote_static);
 		memset(peer->handshake.precomputed_static_static, 0,
 		       NOISE_PUBLIC_KEY_LEN);
-	}
 	up_write(&peer->handshake.lock);
-	return ret;
 }
-bool wg_noise_handshake_init(struct noise_handshake *handshake,
+void wg_noise_handshake_init(struct noise_handshake *handshake,
-			   struct noise_static_identity *static_identity,
+			     struct noise_static_identity *static_identity,
-			   const u8 peer_public_key[NOISE_PUBLIC_KEY_LEN],
+			     const u8 peer_public_key[NOISE_PUBLIC_KEY_LEN],
-			   const u8 peer_preshared_key[NOISE_SYMMETRIC_KEY_LEN],
+			     const u8 peer_preshared_key[NOISE_SYMMETRIC_KEY_LEN],
-			   struct wg_peer *peer)
+			     struct wg_peer *peer)
 {
 	memset(handshake, 0, sizeof(*handshake));
 	init_rwsem(&handshake->lock);
 		       NOISE_SYMMETRIC_KEY_LEN);
 	handshake->static_identity = static_identity;
 	handshake->state = HANDSHAKE_ZEROED;
-	return wg_noise_precompute_static_static(peer);
+	wg_noise_precompute_static_static(peer);
 }
 static void handshake_zero(struct noise_handshake *handshake)
 	return true;
 }
+static bool __must_check mix_precomputed_dh(u8 chaining_key[NOISE_HASH_LEN],
+					    u8 key[NOISE_SYMMETRIC_KEY_LEN],
+					    const u8 precomputed[NOISE_PUBLIC_KEY_LEN])
+{
+	static u8 zero_point[NOISE_PUBLIC_KEY_LEN];
+	if (unlikely(!crypto_memneq(precomputed, zero_point, NOISE_PUBLIC_KEY_LEN)))
+		return false;
+	kdf(chaining_key, key, NULL, precomputed, NOISE_HASH_LEN,
+	    NOISE_SYMMETRIC_KEY_LEN, 0, NOISE_PUBLIC_KEY_LEN,
+	    chaining_key);
+	return true;
+}
 static void mix_hash(u8 hash[NOISE_HASH_LEN], const u8 *src, size_t src_len)
 {
 	struct blake2s_state blake;
 			NOISE_PUBLIC_KEY_LEN, key, handshake->hash);
 	/* ss */
-	kdf(handshake->chaining_key, key, NULL,
+	if (!mix_precomputed_dh(handshake->chaining_key, key,
-	    handshake->precomputed_static_static, NOISE_HASH_LEN,
+				handshake->precomputed_static_static))
-	    NOISE_SYMMETRIC_KEY_LEN, 0, NOISE_PUBLIC_KEY_LEN,
+		goto out;
-	    handshake->chaining_key);
 	/* {t} */
 	tai64n_now(timestamp);
 	handshake = &peer->handshake;
 	/* ss */
-	kdf(chaining_key, key, NULL, handshake->precomputed_static_static,
+	if (!mix_precomputed_dh(chaining_key, key,
-	    NOISE_HASH_LEN, NOISE_SYMMETRIC_KEY_LEN, 0, NOISE_PUBLIC_KEY_LEN,
+				handshake->precomputed_static_static))
-	    chaining_key);
+	    goto out;
 	/* {t} */
 	if (!message_decrypt(t, src->encrypted_timestamp,

drivers/net/wireguard/noise.h+6−6

drivers/net/wireguard/peer.c+2−5

 		return ERR_PTR(ret);
 	peer->device = wg;
-	if (!wg_noise_handshake_init(&peer->handshake, &wg->static_identity,
+	wg_noise_handshake_init(&peer->handshake, &wg->static_identity,
-				     public_key, preshared_key, peer)) {
+				public_key, preshared_key, peer);
-		ret = -EKEYREJECTED;
-		goto err_1;
-	}
 	if (dst_cache_init(&peer->endpoint_cache, GFP_KERNEL))
 		goto err_1;
 	if (wg_packet_queue_init(&peer->tx_queue, wg_packet_tx_worker, false,

drivers/net/wireguard/queueing.h+8−2

 #define PACKET_PEER(skb) (PACKET_CB(skb)->keypair->entry.peer)
 /* Returns either the correct skb->protocol value, or 0 if invalid. */
-static inline __be16 wg_skb_examine_untrusted_ip_hdr(struct sk_buff *skb)
+static inline __be16 wg_examine_packet_protocol(struct sk_buff *skb)
 {
 	if (skb_network_header(skb) >= skb->head &&
 	    (skb_network_header(skb) + sizeof(struct iphdr)) <=
 	return 0;
 }
+static inline bool wg_check_packet_protocol(struct sk_buff *skb)
+{
+	__be16 real_protocol = wg_examine_packet_protocol(skb);
+	return real_protocol && skb->protocol == real_protocol;
+}
 static inline void wg_reset_packet(struct sk_buff *skb)
 {
 	skb_scrub_packet(skb, true);
 	skb->dev = NULL;
 #ifdef CONFIG_NET_SCHED
 	skb->tc_index = 0;
-	skb_reset_tc(skb);
 #endif
+	skb_reset_redirect(skb);
 	skb->hdr_len = skb_headroom(skb);
 	skb_reset_mac_header(skb);
 	skb_reset_network_header(skb);

drivers/net/wireguard/receive.c+3−4

 	size_t data_offset, data_len, header_len;
 	struct udphdr *udp;
-	if (unlikely(wg_skb_examine_untrusted_ip_hdr(skb) != skb->protocol ||
+	if (unlikely(!wg_check_packet_protocol(skb) ||
 		     skb_transport_header(skb) < skb->head ||
 		     (skb_transport_header(skb) + sizeof(struct udphdr)) >
 			     skb_tail_pointer(skb)))
 	 */
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 	skb->csum_level = ~0; /* All levels */
-	skb->protocol = wg_skb_examine_untrusted_ip_hdr(skb);
+	skb->protocol = wg_examine_packet_protocol(skb);
 	if (skb->protocol == htons(ETH_P_IP)) {
 		len = ntohs(ip_hdr(skb)->tot_len);
 		if (unlikely(len < sizeof(struct iphdr)))
 		wg_packet_consume_data(wg, skb);
 		break;
 	default:
-		net_dbg_skb_ratelimited("%s: Invalid packet from %pISpfsc\n",
+		WARN(1, "Non-exhaustive parsing of packet header lead to unknown packet type!\n");
-					wg->dev->name, skb);
 		goto err;
 	}
 	return;

drivers/net/wireless/intel/iwlwifi/cfg/22000.c+2−0

 	 * HT size; mac80211 would otherwise pick the HE max (256) by default.
 	 */
 	.max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
+	.tx_with_siso_diversity = true,
 	.num_rbds = IWL_NUM_RBDS_22000_HE,
 };
 	 * HT size; mac80211 would otherwise pick the HE max (256) by default.
 	 */
 	.max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
+	.tx_with_siso_diversity = true,
 	.num_rbds = IWL_NUM_RBDS_22000_HE,
 };

drivers/net/wireless/intel/iwlwifi/fw/acpi.c+8−6

  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
- * Copyright (C) 2019 Intel Corporation
+ * Copyright (C) 2019 - 2020 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * BSD LICENSE
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
- * Copyright (C) 2019 Intel Corporation
+ * Copyright (C) 2019 - 2020 Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 }
 IWL_EXPORT_SYMBOL(iwl_validate_sar_geo_profile);
-void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
+int iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
-		      struct iwl_per_chain_offset_group *table)
+		     struct iwl_per_chain_offset_group *table)
 {
 	int ret, i, j;
 	if (!iwl_sar_geo_support(fwrt))
-		return;
+		return -EOPNOTSUPP;
 	ret = iwl_sar_get_wgds_table(fwrt);
 	if (ret < 0) {
 				"Geo SAR BIOS table invalid or unavailable. (%d)\n",
 				ret);
 		/* we don't fail if the table is not available */
-		return;
+		return -ENOENT;
 	}
 	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
 					i, j, value[1], value[2], value[0]);
 		}
 	}
+	return 0;
 }
 IWL_EXPORT_SYMBOL(iwl_sar_geo_init);

drivers/net/wireless/intel/iwlwifi/fw/acpi.h+8−6

  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
- * Copyright(c) 2018 - 2019        Intel Corporation
+ * Copyright(c) 2018 - 2020        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * BSD LICENSE
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
- * Copyright(c) 2018 - 2019       Intel Corporation
+ * Copyright(c) 2018 - 2020       Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 int iwl_validate_sar_geo_profile(struct iwl_fw_runtime *fwrt,
 				 struct iwl_host_cmd *cmd);
-void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
+int iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
-		      struct iwl_per_chain_offset_group *table);
+		     struct iwl_per_chain_offset_group *table);
 #else /* CONFIG_ACPI */
 static inline void *iwl_acpi_get_object(struct device *dev, acpi_string method)
 	return -ENOENT;
 }
-static inline void iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
+static inline int iwl_sar_geo_init(struct iwl_fw_runtime *fwrt,
-				    struct iwl_per_chain_offset_group *table)
+				   struct iwl_per_chain_offset_group *table)
 {
+	return -ENOENT;
 }
 #endif /* CONFIG_ACPI */

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

  * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
- * Copyright(c) 2018 - 2019 Intel Corporation
+ * Copyright(c) 2018 - 2020 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2017 Intel Deutschland GmbH
- * Copyright(c) 2018 - 2019 Intel Corporation
+ * Copyright(c) 2018 - 2020 Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 		goto out;
 	}
-	/*
+	offs = rxf_data.offset;
-	 * region register have absolute value so apply rxf offset after
-	 * reading the registers
-	 */
-	offs += rxf_data.offset;
 	/* Lock fence */
 	iwl_write_prph_no_grab(fwrt->trans, RXF_SET_FENCE_MODE + offs, 0x1);
 		goto out;
 	}
-	if (iwl_fw_dbg_stop_restart_recording(fwrt, &params, true)) {
+	iwl_fw_dbg_stop_restart_recording(fwrt, &params, true);
-		IWL_ERR(fwrt, "Failed to stop DBGC recording, aborting dump\n");
-		goto out;
-	}
 	IWL_DEBUG_FW_INFO(fwrt, "WRT: Data collection start\n");
 	if (iwl_trans_dbg_ini_valid(fwrt->trans))
 	return 0;
 }
-int iwl_fw_dbg_stop_restart_recording(struct iwl_fw_runtime *fwrt,
+void iwl_fw_dbg_stop_restart_recording(struct iwl_fw_runtime *fwrt,
-				      struct iwl_fw_dbg_params *params,
+				       struct iwl_fw_dbg_params *params,
-				      bool stop)
+				       bool stop)
 {
 	int ret = 0;
 	if (test_bit(STATUS_FW_ERROR, &fwrt->trans->status))
-		return 0;
+		return;
 	if (fw_has_capa(&fwrt->fw->ucode_capa,
 			IWL_UCODE_TLV_CAPA_DBG_SUSPEND_RESUME_CMD_SUPP))
 			iwl_fw_set_dbg_rec_on(fwrt);
 	}
 #endif
-	return ret;
 }
 IWL_EXPORT_SYMBOL(iwl_fw_dbg_stop_restart_recording);

drivers/net/wireless/intel/iwlwifi/fw/dbg.h+3−3

@@ -239,9 +239,9 @@ _iwl_fw_dbg_trigger_simple_stop(struct iwl_fw_runtime *fwrt, · 238 unmodified lines
239	_iwl_fw_dbg_trigger_simple_stop((fwrt), (wdev), \	239	_iwl_fw_dbg_trigger_simple_stop((fwrt), (wdev), \
240	iwl_fw_dbg_get_trigger((fwrt)->fw,\	240	iwl_fw_dbg_get_trigger((fwrt)->fw,\
241	(trig)))	241	(trig)))
242	int iwl_fw_dbg_stop_restart_recording(struct iwl_fw_runtime *fwrt,	242	void iwl_fw_dbg_stop_restart_recording(struct iwl_fw_runtime *fwrt,
243	struct iwl_fw_dbg_params *params,	243	struct iwl_fw_dbg_params *params,
244	bool stop);	244	bool stop);
245		245
246	#ifdef CONFIG_IWLWIFI_DEBUGFS	246	#ifdef CONFIG_IWLWIFI_DEBUGFS
247	static inline void iwl_fw_set_dbg_rec_on(struct iwl_fw_runtime *fwrt)	247	static inline void iwl_fw_set_dbg_rec_on(struct iwl_fw_runtime *fwrt)

drivers/net/wireless/intel/iwlwifi/iwl-drv.c+1−1

@@ -1467,7 +1467,7 @@ static void iwl_req_fw_callback(const struct firmware ucode_raw, void context) · 1466 unmodified lines
1467	kmemdup(pieces->dbg_conf_tlv[i],	1467	kmemdup(pieces->dbg_conf_tlv[i],
1468	pieces->dbg_conf_tlv_len[i],	1468	pieces->dbg_conf_tlv_len[i],
1469	GFP_KERNEL);	1469	GFP_KERNEL);
1470	if (!pieces->dbg_conf_tlv_len[i])	1470	if (!pieces->dbg_conf_tlv[i])
1471	goto out_free_fw;	1471	goto out_free_fw;
1472	}	1472	}
1473	}	1473	}

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

 	u16 cmd_wide_id =  WIDE_ID(PHY_OPS_GROUP, GEO_TX_POWER_LIMIT);
 	union geo_tx_power_profiles_cmd cmd;
 	u16 len;
+	int ret;
 	cmd.geo_cmd.ops = cpu_to_le32(IWL_PER_CHAIN_OFFSET_SET_TABLES);
-	iwl_sar_geo_init(&mvm->fwrt, cmd.geo_cmd.table);
+	ret = iwl_sar_geo_init(&mvm->fwrt, cmd.geo_cmd.table);
+	/*
+	 * It is a valid scenario to not support SAR, or miss wgds table,
+	 * but in that case there is no need to send the command.
+	 */
+	if (ret)
+		return 0;
 	cmd.geo_cmd.table_revision = cpu_to_le32(mvm->fwrt.geo_rev);

drivers/net/wireless/intel/iwlwifi/mvm/rs-fw.c+26−9

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	* GPL LICENSE SUMMARY	6	* GPL LICENSE SUMMARY
7	*	7	*
8	* Copyright(c) 2017 Intel Deutschland GmbH	8	* Copyright(c) 2017 Intel Deutschland GmbH
9	* Copyright(c) 2018 - 2019 Intel Corporation	9	* Copyright(c) 2018 - 2020 Intel Corporation
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of version 2 of the GNU General Public License as	12	* it under the terms of version 2 of the GNU General Public License as
@@ -27,7 +27,7 @@ · 14 unmodified lines
27	* BSD LICENSE	27	* BSD LICENSE
28	*	28	*
29	* Copyright(c) 2017 Intel Deutschland GmbH	29	* Copyright(c) 2017 Intel Deutschland GmbH
30	* Copyright(c) 2018 - 2019 Intel Corporation	30	* Copyright(c) 2018 - 2020 Intel Corporation
31	* All rights reserved.	31	* All rights reserved.
32	*	32	*
33	* Redistribution and use in source and binary forms, with or without	33	* Redistribution and use in source and binary forms, with or without
@@ -147,7 +147,11 @@ static u16 rs_fw_get_config_flags(struct iwl_mvm *mvm, · 113 unmodified lines
147	(vht_ena && (vht_cap->cap & IEEE80211_VHT_CAP_RXLDPC))))	147	(vht_ena && (vht_cap->cap & IEEE80211_VHT_CAP_RXLDPC))))
148	flags \|= IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK;	148	flags \|= IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK;
149		149
150	/* consider our LDPC support in case of HE */	150	/* consider LDPC support in case of HE */
		151	if (he_cap->has_he && (he_cap->he_cap_elem.phy_cap_info[1] &
		152	IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD))
		153	flags \|= IWL_TLC_MNG_CFG_FLAGS_LDPC_MSK;
		154
151	if (sband->iftype_data && sband->iftype_data->he_cap.has_he &&	155	if (sband->iftype_data && sband->iftype_data->he_cap.has_he &&
152	!(sband->iftype_data->he_cap.he_cap_elem.phy_cap_info[1] &	156	!(sband->iftype_data->he_cap.he_cap_elem.phy_cap_info[1] &
153	IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD))	157	IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD))
@@ -191,11 +195,13 @@ rs_fw_vht_set_enabled_rates(const struct ieee80211_sta *sta, · 37 unmodified lines
191	{	195	{
192	u16 supp;	196	u16 supp;
193	int i, highest_mcs;	197	int i, highest_mcs;
		198	u8 nss = sta->rx_nss;
194		199
195	for (i = 0; i < sta->rx_nss; i++) {	200	/* the station support only a single receive chain */
196	if (i == IWL_TLC_NSS_MAX)	201	if (sta->smps_mode == IEEE80211_SMPS_STATIC)
197	break;	202	nss = 1;
198		203
		204	for (i = 0; i < nss && i < IWL_TLC_NSS_MAX; i++) {
199	highest_mcs = rs_fw_vht_highest_rx_mcs_index(vht_cap, i + 1);	205	highest_mcs = rs_fw_vht_highest_rx_mcs_index(vht_cap, i + 1);
200	if (!highest_mcs)	206	if (!highest_mcs)
201	continue;	207	continue;
@@ -241,8 +247,13 @@ rs_fw_he_set_enabled_rates(const struct ieee80211_sta *sta, · 39 unmodified lines
241	u16 tx_mcs_160 =	247	u16 tx_mcs_160 =
242	le16_to_cpu(sband->iftype_data->he_cap.he_mcs_nss_supp.tx_mcs_160);	248	le16_to_cpu(sband->iftype_data->he_cap.he_mcs_nss_supp.tx_mcs_160);
243	int i;	249	int i;
		250	u8 nss = sta->rx_nss;
		251
		252	/* the station support only a single receive chain */
		253	if (sta->smps_mode == IEEE80211_SMPS_STATIC)
		254	nss = 1;
244		255
245	for (i = 0; i < sta->rx_nss && i < IWL_TLC_NSS_MAX; i++) {	256	for (i = 0; i < nss && i < IWL_TLC_NSS_MAX; i++) {
246	u16 _mcs_160 = (mcs_160 >> (2 * i)) & 0x3;	257	u16 _mcs_160 = (mcs_160 >> (2 * i)) & 0x3;
247	u16 _mcs_80 = (mcs_80 >> (2 * i)) & 0x3;	258	u16 _mcs_80 = (mcs_80 >> (2 * i)) & 0x3;
248	u16 _tx_mcs_160 = (tx_mcs_160 >> (2 * i)) & 0x3;	259	u16 _tx_mcs_160 = (tx_mcs_160 >> (2 * i)) & 0x3;
@@ -303,8 +314,14 @@ static void rs_fw_set_supp_rates(struct ieee80211_sta *sta, · 54 unmodified lines
303	cmd->mode = IWL_TLC_MNG_MODE_HT;	314	cmd->mode = IWL_TLC_MNG_MODE_HT;
304	cmd->ht_rates[IWL_TLC_NSS_1][IWL_TLC_HT_BW_NONE_160] =	315	cmd->ht_rates[IWL_TLC_NSS_1][IWL_TLC_HT_BW_NONE_160] =
305	cpu_to_le16(ht_cap->mcs.rx_mask[0]);	316	cpu_to_le16(ht_cap->mcs.rx_mask[0]);
306	cmd->ht_rates[IWL_TLC_NSS_2][IWL_TLC_HT_BW_NONE_160] =	317
307	cpu_to_le16(ht_cap->mcs.rx_mask[1]);	318	/* the station support only a single receive chain */
		319	if (sta->smps_mode == IEEE80211_SMPS_STATIC)
		320	cmd->ht_rates[IWL_TLC_NSS_2][IWL_TLC_HT_BW_NONE_160] =
		321	0;
		322	else
		323	cmd->ht_rates[IWL_TLC_NSS_2][IWL_TLC_HT_BW_NONE_160] =
		324	cpu_to_le16(ht_cap->mcs.rx_mask[1]);
308	}	325	}
309	}	326	}
310		327

drivers/net/wireless/intel/iwlwifi/mvm/time-event.c+4−0

 		if (!le32_to_cpu(notif->status)) {
 			iwl_mvm_te_check_disconnect(mvm, vif,
 						    "Session protection failure");
+			spin_lock_bh(&mvm->time_event_lock);
 			iwl_mvm_te_clear_data(mvm, te_data);
+			spin_unlock_bh(&mvm->time_event_lock);
 		}
 		if (le32_to_cpu(notif->start)) {
 			 */
 			iwl_mvm_te_check_disconnect(mvm, vif,
 						    "No beacon heard and the session protection is over already...");
+			spin_lock_bh(&mvm->time_event_lock);
 			iwl_mvm_te_clear_data(mvm, te_data);
+			spin_unlock_bh(&mvm->time_event_lock);
 		}
 		goto out_unlock;

drivers/net/wireless/intel/iwlwifi/pcie/drv.c+0−1

@@ -939,7 +939,6 @@ static const struct iwl_dev_info iwl_dev_info_table[] = { · 938 unmodified lines
939	IWL_DEV_INFO(0x2723, 0x1653, iwl_ax200_cfg_cc, iwl_ax200_killer_1650w_name),	939	IWL_DEV_INFO(0x2723, 0x1653, iwl_ax200_cfg_cc, iwl_ax200_killer_1650w_name),
940	IWL_DEV_INFO(0x2723, 0x1654, iwl_ax200_cfg_cc, iwl_ax200_killer_1650x_name),	940	IWL_DEV_INFO(0x2723, 0x1654, iwl_ax200_cfg_cc, iwl_ax200_killer_1650x_name),
941	IWL_DEV_INFO(0x2723, IWL_CFG_ANY, iwl_ax200_cfg_cc, iwl_ax200_name),	941	IWL_DEV_INFO(0x2723, IWL_CFG_ANY, iwl_ax200_cfg_cc, iwl_ax200_name),
942
943	#endif /* CONFIG_IWLMVM */	942	#endif /* CONFIG_IWLMVM */
944	};	943	};
945		944

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/trx.h+1−0

@@ -561,6 +561,7 @@ static inline void clear_pci_tx_desc_content(__le32 *__pdesc, int _size) · 560 unmodified lines
561	rxmcs == DESC92C_RATE11M)	561	rxmcs == DESC92C_RATE11M)
562		562
563	struct phy_status_rpt {	563	struct phy_status_rpt {
		564	u8 padding[2];
564	u8 ch_corr[2];	565	u8 ch_corr[2];
565	u8 cck_sig_qual_ofdm_pwdb_all;	566	u8 cck_sig_qual_ofdm_pwdb_all;
566	u8 cck_agc_rpt_ofdm_cfosho_a;	567	u8 cck_agc_rpt_ofdm_cfosho_a;

drivers/net/wireless/ti/wlcore/main.c+1−1

@@ -6274,7 +6274,7 @@ static int wl1271_init_ieee80211(struct wl1271 *wl) · 6273 unmodified lines
6274	wl->hw->wiphy->flags \|= WIPHY_FLAG_AP_UAPSD \|	6274	wl->hw->wiphy->flags \|= WIPHY_FLAG_AP_UAPSD \|
6275	WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL \|	6275	WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL \|
6276	WIPHY_FLAG_HAS_CHANNEL_SWITCH \|	6276	WIPHY_FLAG_HAS_CHANNEL_SWITCH \|
6277	+ WIPHY_FLAG_IBSS_RSN;	6277	WIPHY_FLAG_IBSS_RSN;
6278		6278
6279	wl->hw->wiphy->features \|= NL80211_FEATURE_AP_SCAN;	6279	wl->hw->wiphy->features \|= NL80211_FEATURE_AP_SCAN;
6280		6280

drivers/nfc/fdp/fdp.c+2−3

 	const struct firmware *fw;
 	struct sk_buff *skb;
 	unsigned long len;
-	u8 max_size, payload_size;
+	int max_size, payload_size;
 	int rc = 0;
 	if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) ||
 	while (len) {
-		payload_size = min_t(unsigned long, (unsigned long) max_size,
+		payload_size = min_t(unsigned long, max_size, len);
-				     len);
 		skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + payload_size),
 				    GFP_KERNEL);

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

 	if (new)
 		blk_mq_free_tag_set(ctrl->ctrl.admin_tagset);
 out_free_async_qe:
-	nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
+	if (ctrl->async_event_sqe.data) {
-		sizeof(struct nvme_command), DMA_TO_DEVICE);
+		nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
-	ctrl->async_event_sqe.data = NULL;
+			sizeof(struct nvme_command), DMA_TO_DEVICE);
+		ctrl->async_event_sqe.data = NULL;
+	}
 out_free_queue:
 	nvme_rdma_free_queue(&ctrl->queues[0]);
 	return error;

drivers/nvme/target/tcp.c+9−3

 	return 1;
 }
-static int nvmet_try_send_data(struct nvmet_tcp_cmd *cmd)
+static int nvmet_try_send_data(struct nvmet_tcp_cmd *cmd, bool last_in_batch)
 {
 	struct nvmet_tcp_queue *queue = cmd->queue;
 	int ret;
 	while (cmd->cur_sg) {
 		struct page *page = sg_page(cmd->cur_sg);
 		u32 left = cmd->cur_sg->length - cmd->offset;
+		int flags = MSG_DONTWAIT;
+		if ((!last_in_batch && cmd->queue->send_list_len) ||
+		    cmd->wbytes_done + left < cmd->req.transfer_len ||
+		    queue->data_digest || !queue->nvme_sq.sqhd_disabled)
+			flags |= MSG_MORE;
 		ret = kernel_sendpage(cmd->queue->sock, page, cmd->offset,
-					left, MSG_DONTWAIT | MSG_MORE);
+					left, flags);
 		if (ret <= 0)
 			return ret;
 	}
 	if (cmd->state == NVMET_TCP_SEND_DATA) {
-		ret = nvmet_try_send_data(cmd);
+		ret = nvmet_try_send_data(cmd, last_in_batch);
 		if (ret <= 0)
 			goto done_send;
 	}

drivers/rtc/Kconfig+1−0

@@ -327,6 +327,7 @@ config RTC_DRV_MAX6900 · 326 unmodified lines
327	config RTC_DRV_MAX8907	327	config RTC_DRV_MAX8907
328	tristate "Maxim MAX8907"	328	tristate "Maxim MAX8907"
329	depends on MFD_MAX8907 \|\| COMPILE_TEST	329	depends on MFD_MAX8907 \|\| COMPILE_TEST
		330	select REGMAP_IRQ
330	help	331	help
331	If you say yes here you will get support for the	332	If you say yes here you will get support for the
332	RTC of Maxim MAX8907 PMIC.	333	RTC of Maxim MAX8907 PMIC.

drivers/s390/block/dasd.c+24−3

 		     (unsigned long) block);
 	INIT_LIST_HEAD(&block->ccw_queue);
 	spin_lock_init(&block->queue_lock);
+	INIT_LIST_HEAD(&block->format_list);
+	spin_lock_init(&block->format_lock);
 	timer_setup(&block->timer, dasd_block_timeout, 0);
 	spin_lock_init(&block->profile.lock);
 	if (dasd_ese_needs_format(cqr->block, irb)) {
 		if (rq_data_dir((struct request *)cqr->callback_data) == READ) {
-			device->discipline->ese_read(cqr);
+			device->discipline->ese_read(cqr, irb);
 			cqr->status = DASD_CQR_SUCCESS;
 			cqr->stopclk = now;
 			dasd_device_clear_timer(device);
 			dasd_schedule_device_bh(device);
 			return;
 		}
-		fcqr = device->discipline->ese_format(device, cqr);
+		fcqr = device->discipline->ese_format(device, cqr, irb);
 		if (IS_ERR(fcqr)) {
+			if (PTR_ERR(fcqr) == -EINVAL) {
+				cqr->status = DASD_CQR_ERROR;
+				return;
+			}
 			/*
 			 * If we can't format now, let the request go
 			 * one extra round. Maybe we can format later.
 			 */
 			cqr->status = DASD_CQR_QUEUED;
+			dasd_schedule_device_bh(device);
+			return;
 		} else {
 			fcqr->status = DASD_CQR_QUEUED;
 			cqr->status = DASD_CQR_QUEUED;
 {
 	struct request *req;
 	blk_status_t error = BLK_STS_OK;
+	unsigned int proc_bytes;
 	int status;
 	req = (struct request *) cqr->callback_data;
 	dasd_profile_end(cqr->block, cqr, req);
+	proc_bytes = cqr->proc_bytes;
 	status = cqr->block->base->discipline->free_cp(cqr, req);
 	if (status < 0)
 		error = errno_to_blk_status(status);
 		blk_mq_end_request(req, error);
 		blk_mq_run_hw_queues(req->q, true);
 	} else {
-		blk_mq_complete_request(req);
+		/*
+		 * Partial completed requests can happen with ESE devices.
+		 * During read we might have gotten a NRF error and have to
+		 * complete a request partially.
+		 */
+		if (proc_bytes) {
+			blk_update_request(req, BLK_STS_OK,
+					   blk_rq_bytes(req) - proc_bytes);
+			blk_mq_requeue_request(req, true);
+		} else {
+			blk_mq_complete_request(req);
+		}
 	}
 }

drivers/s390/block/dasd_eckd.c+156−7

@@ -207,6 +207,45 @@ static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) · 206 unmodified lines
207	geo->head \|= head;	207	geo->head \|= head;
208	}	208	}
209		209
		210	/*
		211	* calculate failing track from sense data depending if
		212	* it is an EAV device or not
		213	*/
		214	static int dasd_eckd_track_from_irb(struct irb irb, struct dasd_device device,
		215	sector_t *track)
		216	{
		217	struct dasd_eckd_private *private = device->private;
		218	u8 *sense = NULL;
		219	u32 cyl;
		220	u8 head;
		221
		222	sense = dasd_get_sense(irb);
		223	if (!sense) {
		224	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
		225	"ESE error no sense data\n");
		226	return -EINVAL;
		227	}
		228	if (!(sense[27] & DASD_SENSE_BIT_2)) {
		229	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
		230	"ESE error no valid track data\n");
		231	return -EINVAL;
		232	}
		233
		234	if (sense[27] & DASD_SENSE_BIT_3) {
		235	/* enhanced addressing */
		236	cyl = sense[30] << 20;
		237	cyl \|= (sense[31] & 0xF0) << 12;
		238	cyl \|= sense[28] << 8;
		239	cyl \|= sense[29];
		240	} else {
		241	cyl = sense[29] << 8;
		242	cyl \|= sense[30];
		243	}
		244	head = sense[31] & 0x0F;
		245	track = cyl private->rdc_data.trk_per_cyl + head;
		246	return 0;
		247	}
		248
210	static int set_timestamp(struct ccw1 ccw, struct DE_eckd_data data,	249	static int set_timestamp(struct ccw1 ccw, struct DE_eckd_data data,
211	struct dasd_device *device)	250	struct dasd_device *device)
212	{	251	{
@@ -2986,6 +3025,37 @@ static int dasd_eckd_format_device(struct dasd_device *base, · 2773 unmodified lines
2986	0, NULL);	3025	0, NULL);
2987	}	3026	}
2988		3027
		3028	static bool test_and_set_format_track(struct dasd_format_entry *to_format,
		3029	struct dasd_block *block)
		3030	{
		3031	struct dasd_format_entry *format;
		3032	unsigned long flags;
		3033	bool rc = false;
		3034
		3035	spin_lock_irqsave(&block->format_lock, flags);
		3036	list_for_each_entry(format, &block->format_list, list) {
		3037	if (format->track == to_format->track) {
		3038	rc = true;
		3039	goto out;
		3040	}
		3041	}
		3042	list_add_tail(&to_format->list, &block->format_list);
		3043
		3044	out:
		3045	spin_unlock_irqrestore(&block->format_lock, flags);
		3046	return rc;
		3047	}
		3048
		3049	static void clear_format_track(struct dasd_format_entry *format,
		3050	struct dasd_block *block)
		3051	{
		3052	unsigned long flags;
		3053
		3054	spin_lock_irqsave(&block->format_lock, flags);
		3055	list_del_init(&format->list);
		3056	spin_unlock_irqrestore(&block->format_lock, flags);
		3057	}
		3058
2989	/*	3059	/*
2990	* Callback function to free ESE format requests.	3060	* Callback function to free ESE format requests.
2991	*/	3061	*/
@@ -2993,15 +3063,19 @@ static void dasd_eckd_ese_format_cb(struct dasd_ccw_req cqr, void data) · 1 unmodified line
2993	{	3063	{
2994	struct dasd_device *device = cqr->startdev;	3064	struct dasd_device *device = cqr->startdev;
2995	struct dasd_eckd_private *private = device->private;	3065	struct dasd_eckd_private *private = device->private;
		3066	struct dasd_format_entry *format = data;
2996		3067
		3068	clear_format_track(format, cqr->basedev->block);
2997	private->count--;	3069	private->count--;
2998	dasd_ffree_request(cqr, device);	3070	dasd_ffree_request(cqr, device);
2999	}	3071	}
3000		3072
3001	static struct dasd_ccw_req *	3073	static struct dasd_ccw_req *
3002	dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr)	3074	dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr,
		3075	struct irb *irb)
3003	{	3076	{
3004	struct dasd_eckd_private *private;	3077	struct dasd_eckd_private *private;
		3078	struct dasd_format_entry *format;
3005	struct format_data_t fdata;	3079	struct format_data_t fdata;
3006	unsigned int recs_per_trk;	3080	unsigned int recs_per_trk;
3007	struct dasd_ccw_req *fcqr;	3081	struct dasd_ccw_req *fcqr;
@@ -3011,23 +3085,39 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 3 unmodified lines
3011	struct request *req;	3085	struct request *req;
3012	sector_t first_trk;	3086	sector_t first_trk;
3013	sector_t last_trk;	3087	sector_t last_trk;
		3088	sector_t curr_trk;
3014	int rc;	3089	int rc;
3015		3090
3016	req = cqr->callback_data;	3091	req = cqr->callback_data;
3017	base = cqr->block->base;	3092	block = cqr->block;
		3093	base = block->base;
3018	private = base->private;	3094	private = base->private;
3019	block = base->block;
3020	blksize = block->bp_block;	3095	blksize = block->bp_block;
3021	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);	3096	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
		3097	format = &startdev->format_entry;
3022		3098
3023	first_trk = blk_rq_pos(req) >> block->s2b_shift;	3099	first_trk = blk_rq_pos(req) >> block->s2b_shift;
3024	sector_div(first_trk, recs_per_trk);	3100	sector_div(first_trk, recs_per_trk);
3025	last_trk =	3101	last_trk =
3026	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;	3102	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
3027	sector_div(last_trk, recs_per_trk);	3103	sector_div(last_trk, recs_per_trk);
		3104	rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
		3105	if (rc)
		3106	return ERR_PTR(rc);
3028		3107
3029	fdata.start_unit = first_trk;	3108	if (curr_trk < first_trk \|\| curr_trk > last_trk) {
3030	fdata.stop_unit = last_trk;	3109	DBF_DEV_EVENT(DBF_WARNING, startdev,
		3110	"ESE error track %llu not within range %llu - %llu\n",
		3111	curr_trk, first_trk, last_trk);
		3112	return ERR_PTR(-EINVAL);
		3113	}
		3114	format->track = curr_trk;
		3115	/* test if track is already in formatting by another thread */
		3116	if (test_and_set_format_track(format, block))
		3117	return ERR_PTR(-EEXIST);
		3118
		3119	fdata.start_unit = curr_trk;
		3120	fdata.stop_unit = curr_trk;
3031	fdata.blksize = blksize;	3121	fdata.blksize = blksize;
3032	fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;	3122	fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;
3033		3123
@@ -3044,6 +3134,7 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 10 unmodified lines
3044	return fcqr;	3134	return fcqr;
3045		3135
3046	fcqr->callback = dasd_eckd_ese_format_cb;	3136	fcqr->callback = dasd_eckd_ese_format_cb;
		3137	fcqr->callback_data = (void *) format;
3047		3138
3048	return fcqr;	3139	return fcqr;
3049	}	3140	}
@@ -3051,29 +3142,87 @@ dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr) · 1 unmodified line
3051	/*	3142	/*
3052	* When data is read from an unformatted area of an ESE volume, this function	3143	* When data is read from an unformatted area of an ESE volume, this function
3053	* returns zeroed data and thereby mimics a read of zero data.	3144	* returns zeroed data and thereby mimics a read of zero data.
		3145	*
		3146	* The first unformatted track is the one that got the NRF error, the address is
		3147	* encoded in the sense data.
		3148	*
		3149	* All tracks before have returned valid data and should not be touched.
		3150	* All tracks after the unformatted track might be formatted or not. This is
		3151	* currently not known, remember the processed data and return the remainder of
		3152	* the request to the blocklayer in __dasd_cleanup_cqr().
3054	*/	3153	*/
3055	static void dasd_eckd_ese_read(struct dasd_ccw_req *cqr)	3154	static int dasd_eckd_ese_read(struct dasd_ccw_req cqr, struct irb irb)
3056	{	3155	{
		3156	struct dasd_eckd_private *private;
		3157	sector_t first_trk, last_trk;
		3158	sector_t first_blk, last_blk;
3057	unsigned int blksize, off;	3159	unsigned int blksize, off;
		3160	unsigned int recs_per_trk;
3058	struct dasd_device *base;	3161	struct dasd_device *base;
3059	struct req_iterator iter;	3162	struct req_iterator iter;
		3163	struct dasd_block *block;
		3164	unsigned int skip_block;
		3165	unsigned int blk_count;
3060	struct request *req;	3166	struct request *req;
3061	struct bio_vec bv;	3167	struct bio_vec bv;
		3168	sector_t curr_trk;
		3169	sector_t end_blk;
3062	char *dst;	3170	char *dst;
		3171	int rc;
3063		3172
3064	req = (struct request *) cqr->callback_data;	3173	req = (struct request *) cqr->callback_data;
3065	base = cqr->block->base;	3174	base = cqr->block->base;
3066	blksize = base->block->bp_block;	3175	blksize = base->block->bp_block;
		3176	block = cqr->block;
		3177	private = base->private;
		3178	skip_block = 0;
		3179	blk_count = 0;
		3180
		3181	recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
		3182	first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift;
		3183	sector_div(first_trk, recs_per_trk);
		3184	last_trk = last_blk =
		3185	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
		3186	sector_div(last_trk, recs_per_trk);
		3187	rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
		3188	if (rc)
		3189	return rc;
		3190
		3191	/* sanity check if the current track from sense data is valid */
		3192	if (curr_trk < first_trk \|\| curr_trk > last_trk) {
		3193	DBF_DEV_EVENT(DBF_WARNING, base,
		3194	"ESE error track %llu not within range %llu - %llu\n",
		3195	curr_trk, first_trk, last_trk);
		3196	return -EINVAL;
		3197	}
		3198
		3199	/*
		3200	* if not the first track got the NRF error we have to skip over valid
		3201	* blocks
		3202	*/
		3203	if (curr_trk != first_trk)
		3204	skip_block = curr_trk * recs_per_trk - first_blk;
		3205
		3206	/* we have no information beyond the current track */
		3207	end_blk = (curr_trk + 1) * recs_per_trk;
3067		3208
3068	rq_for_each_segment(bv, req, iter) {	3209	rq_for_each_segment(bv, req, iter) {
3069	dst = page_address(bv.bv_page) + bv.bv_offset;	3210	dst = page_address(bv.bv_page) + bv.bv_offset;
3070	for (off = 0; off < bv.bv_len; off += blksize) {	3211	for (off = 0; off < bv.bv_len; off += blksize) {
3071	if (dst && rq_data_dir(req) == READ) {	3212	if (first_blk + blk_count >= end_blk) {
		3213	cqr->proc_bytes = blk_count * blksize;
		3214	return 0;
		3215	}
		3216	if (dst && !skip_block) {
3072	dst += off;	3217	dst += off;
3073	memset(dst, 0, blksize);	3218	memset(dst, 0, blksize);
		3219	} else {
		3220	skip_block--;
3074	}	3221	}
		3222	blk_count++;
3075	}	3223	}
3076	}	3224	}
		3225	return 0;
3077	}	3226	}
3078		3227
3079	/*	3228	/*

drivers/s390/block/dasd_int.h+13−2

 	void (*callback)(struct dasd_ccw_req *, void *data);
 	void *callback_data;
+	unsigned int proc_bytes;	/* bytes for partial completion */
 };
 /*
 	int (*ext_pool_warn_thrshld)(struct dasd_device *);
 	int (*ext_pool_oos)(struct dasd_device *);
 	int (*ext_pool_exhaust)(struct dasd_device *, struct dasd_ccw_req *);
-	struct dasd_ccw_req *(*ese_format)(struct dasd_device *, struct dasd_ccw_req *);
+	struct dasd_ccw_req *(*ese_format)(struct dasd_device *,
-	void (*ese_read)(struct dasd_ccw_req *);
+					   struct dasd_ccw_req *, struct irb *);
+	int (*ese_read)(struct dasd_ccw_req *, struct irb *);
 };
 extern struct dasd_discipline *dasd_diag_discipline_pointer;
 	spinlock_t lock;
 };
+struct dasd_format_entry {
+	struct list_head list;
+	sector_t track;
+};
 struct dasd_device {
 	/* Block device stuff. */
 	struct dasd_block *block;
 	struct dentry *debugfs_dentry;
 	struct dentry *hosts_dentry;
 	struct dasd_profile profile;
+	struct dasd_format_entry format_entry;
 };
 struct dasd_block {
 	struct dentry *debugfs_dentry;
 	struct dasd_profile profile;
+	struct list_head format_list;
+	spinlock_t format_lock;
 };
 struct dasd_attention_data {

drivers/scsi/ipr.c+2−1

 	ioa_cfg->max_devs_supported = ipr_max_devs;
 	if (ioa_cfg->sis64) {
+		host->max_channel = IPR_MAX_SIS64_BUSES;
 		host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
 		host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
 		if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
 					   + ((sizeof(struct ipr_config_table_entry64)
 					       * ioa_cfg->max_devs_supported)));
 	} else {
+		host->max_channel = IPR_VSET_BUS;
 		host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
 		host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
 		if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
 					       * ioa_cfg->max_devs_supported)));
 	}
-	host->max_channel = IPR_VSET_BUS;
 	host->unique_id = host->host_no;
 	host->max_cmd_len = IPR_MAX_CDB_LEN;
 	host->can_queue = ioa_cfg->max_cmds;

drivers/scsi/ipr.h+1−0

@@ -1300,6 +1300,7 @@ struct ipr_resource_entry { · 1299 unmodified lines
1300	#define IPR_ARRAY_VIRTUAL_BUS 0x1	1300	#define IPR_ARRAY_VIRTUAL_BUS 0x1
1301	#define IPR_VSET_VIRTUAL_BUS 0x2	1301	#define IPR_VSET_VIRTUAL_BUS 0x2
1302	#define IPR_IOAFP_VIRTUAL_BUS 0x3	1302	#define IPR_IOAFP_VIRTUAL_BUS 0x3
		1303	#define IPR_MAX_SIS64_BUSES 0x4
1303		1304
1304	#define IPR_GET_RES_PHYS_LOC(res) \	1305	#define IPR_GET_RES_PHYS_LOC(res) \
1305	(((res)->bus << 24) \| ((res)->target << 8) \| (res)->lun)	1306	(((res)->bus << 24) \| ((res)->target << 8) \| (res)->lun)

drivers/scsi/ufs/ufshcd.c+14−7

 void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit)
 {
 	unsigned long flags;
+	bool update = false;
-	if (!(hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT))
+	if (!ufshcd_is_auto_hibern8_supported(hba))
 		return;
 	spin_lock_irqsave(hba->host->host_lock, flags);
-	if (hba->ahit == ahit)
+	if (hba->ahit != ahit) {
-		goto out_unlock;
+		hba->ahit = ahit;
-	hba->ahit = ahit;
+		update = true;
-	if (!pm_runtime_suspended(hba->dev))
+	}
-		ufshcd_writel(hba, hba->ahit, REG_AUTO_HIBERNATE_IDLE_TIMER);
-out_unlock:
 	spin_unlock_irqrestore(hba->host->host_lock, flags);
+	if (update && !pm_runtime_suspended(hba->dev)) {
+		pm_runtime_get_sync(hba->dev);
+		ufshcd_hold(hba, false);
+		ufshcd_auto_hibern8_enable(hba);
+		ufshcd_release(hba);
+		pm_runtime_put(hba->dev);
+	}
 }
 EXPORT_SYMBOL_GPL(ufshcd_auto_hibern8_update);

drivers/slimbus/qcom-ngd-ctrl.c+3−0

 	{
 		.compatible = "qcom,slim-ngd-v1.5.0",
 		.data = &ngd_v1_5_offset_info,
+	},{
+		.compatible = "qcom,slim-ngd-v2.1.0",
+		.data = &ngd_v1_5_offset_info,
 	},
 	{}
 };

drivers/staging/greybus/tools/loopback_test.c+11−10

 #include <signal.h>
 #define MAX_NUM_DEVICES 10
+#define MAX_SYSFS_PREFIX 0x80
 #define MAX_SYSFS_PATH	0x200
 #define CSV_MAX_LINE	0x1000
 #define SYSFS_MAX_INT	0x20
 };
 struct loopback_device {
-	char name[MAX_SYSFS_PATH];
+	char name[MAX_STR_LEN];
 	char sysfs_entry[MAX_SYSFS_PATH];
 	char debugfs_entry[MAX_SYSFS_PATH];
 	struct loopback_results results;
 	int stop_all;
 	int poll_count;
 	char test_name[MAX_STR_LEN];
-	char sysfs_prefix[MAX_SYSFS_PATH];
+	char sysfs_prefix[MAX_SYSFS_PREFIX];
-	char debugfs_prefix[MAX_SYSFS_PATH];
+	char debugfs_prefix[MAX_SYSFS_PREFIX];
 	struct timespec poll_timeout;
 	struct loopback_device devices[MAX_NUM_DEVICES];
 	struct loopback_results aggregate_results;
 static int open_poll_files(struct loopback_test *t)
 {
 	struct loopback_device *dev;
-	char buf[MAX_STR_LEN];
+	char buf[MAX_SYSFS_PATH + MAX_STR_LEN];
 	char dummy;
 	int fds_idx = 0;
 	int i;
 			goto err;
 		}
 		read(t->fds[fds_idx].fd, &dummy, 1);
-		t->fds[fds_idx].events = EPOLLERR|EPOLLPRI;
+		t->fds[fds_idx].events = POLLERR | POLLPRI;
 		t->fds[fds_idx].revents = 0;
 		fds_idx++;
 	}
 		}
 		for (i = 0; i < t->poll_count; i++) {
-			if (t->fds[i].revents & EPOLLPRI) {
+			if (t->fds[i].revents & POLLPRI) {
 				/* Dummy read to clear the event */
 				read(t->fds[i].fd, &dummy, 1);
 				number_of_events++;
 			t.iteration_max = atoi(optarg);
 			break;
 		case 'S':
-			snprintf(t.sysfs_prefix, MAX_SYSFS_PATH, "%s", optarg);
+			snprintf(t.sysfs_prefix, MAX_SYSFS_PREFIX, "%s", optarg);
 			break;
 		case 'D':
-			snprintf(t.debugfs_prefix, MAX_SYSFS_PATH, "%s", optarg);
+			snprintf(t.debugfs_prefix, MAX_SYSFS_PREFIX, "%s", optarg);
 			break;
 		case 'm':
 			t.mask = atol(optarg);
 	}
 	if (!strcmp(t.sysfs_prefix, ""))
-		snprintf(t.sysfs_prefix, MAX_SYSFS_PATH, "%s", sysfs_prefix);
+		snprintf(t.sysfs_prefix, MAX_SYSFS_PREFIX, "%s", sysfs_prefix);
 	if (!strcmp(t.debugfs_prefix, ""))
-		snprintf(t.debugfs_prefix, MAX_SYSFS_PATH, "%s", debugfs_prefix);
+		snprintf(t.debugfs_prefix, MAX_SYSFS_PREFIX, "%s", debugfs_prefix);
 	ret = find_loopback_devices(&t);
 	if (ret)

drivers/staging/rtl8188eu/os_dep/usb_intf.c+1−0

@@ -38,6 +38,7 @@ static const struct usb_device_id rtw_usb_id_tbl[] = { · 37 unmodified lines
38	{USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */	38	{USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
39	{USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */	39	{USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
40	{USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */	40	{USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */
		41	{USB_DEVICE(0x2C4E, 0x0102)}, /* MERCUSYS MW150US v2 */
41	{USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */	42	{USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */
42	{USB_DEVICE(USB_VENDER_ID_REALTEK, 0xffef)}, /* Rosewill RNX-N150NUB */	43	{USB_DEVICE(USB_VENDER_ID_REALTEK, 0xffef)}, /* Rosewill RNX-N150NUB */
43	{} /* Terminating entry */	44	{} /* Terminating entry */

drivers/staging/speakup/main.c+1−1

@@ -561,7 +561,7 @@ static u_long get_word(struct vc_data *vc) · 560 unmodified lines
561	return 0;	561	return 0;
562	} else if (tmpx < vc->vc_cols - 2 &&	562	} else if (tmpx < vc->vc_cols - 2 &&
563	(ch == SPACE \|\| ch == 0 \|\| (ch < 0x100 && IS_WDLM(ch))) &&	563	(ch == SPACE \|\| ch == 0 \|\| (ch < 0x100 && IS_WDLM(ch))) &&
564	get_char(vc, (u_short *)&tmp_pos + 1, &temp) > SPACE) {	564	get_char(vc, (u_short *)tmp_pos + 1, &temp) > SPACE) {
565	tmp_pos += 2;	565	tmp_pos += 2;
566	tmpx++;	566	tmpx++;
567	} else {	567	} else {

drivers/staging/wfx/hif_tx.c+8−7

 	else
 		control_reg_write(wdev, 0);
 	mutex_unlock(&wdev->hif_cmd.lock);
+	mutex_unlock(&wdev->hif_cmd.key_renew_lock);
 	kfree(hif);
 	return ret;
 }
 }
 int hif_join(struct wfx_vif *wvif, const struct ieee80211_bss_conf *conf,
-	     const struct ieee80211_channel *channel, const u8 *ssidie)
+	     struct ieee80211_channel *channel, const u8 *ssid, int ssidlen)
 {
 	int ret;
 	struct hif_msg *hif;
 	body->basic_rate_set =
 		cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));
 	memcpy(body->bssid, conf->bssid, sizeof(body->bssid));
-	if (!conf->ibss_joined && ssidie) {
+	if (!conf->ibss_joined && ssid) {
-		body->ssid_length = cpu_to_le32(ssidie[1]);
+		body->ssid_length = cpu_to_le32(ssidlen);
-		memcpy(body->ssid, &ssidie[2], ssidie[1]);
+		memcpy(body->ssid, ssid, ssidlen);
 	}
 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_JOIN, sizeof(*body));
 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
 	struct hif_msg *hif;
 	struct hif_req_start *body = wfx_alloc_hif(sizeof(*body), &hif);
-	body->dtim_period = conf->dtim_period,
+	body->dtim_period = conf->dtim_period;
-	body->short_preamble = conf->use_short_preamble,
+	body->short_preamble = conf->use_short_preamble;
-	body->channel_number = cpu_to_le16(channel->hw_value),
+	body->channel_number = cpu_to_le16(channel->hw_value);
 	body->beacon_interval = cpu_to_le32(conf->beacon_int);
 	body->basic_rate_set =
 		cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));

drivers/staging/wfx/hif_tx.h+1−1

@@ -46,7 +46,7 @@ int hif_scan(struct wfx_vif wvif, struct cfg80211_scan_request req80211, · 45 unmodified lines
46	int chan_start, int chan_num);	46	int chan_start, int chan_num);
47	int hif_stop_scan(struct wfx_vif *wvif);	47	int hif_stop_scan(struct wfx_vif *wvif);
48	int hif_join(struct wfx_vif wvif, const struct ieee80211_bss_conf conf,	48	int hif_join(struct wfx_vif wvif, const struct ieee80211_bss_conf conf,
49	const struct ieee80211_channel channel, const u8 ssidie);	49	struct ieee80211_channel channel, const u8 ssid, int ssidlen);
50	int hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);	50	int hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);
51	int hif_set_bss_params(struct wfx_vif *wvif,	51	int hif_set_bss_params(struct wfx_vif *wvif,
52	const struct hif_req_set_bss_params *arg);	52	const struct hif_req_set_bss_params *arg);

drivers/staging/wfx/hif_tx_mib.h+10−5

 }
 static inline int hif_set_association_mode(struct wfx_vif *wvif,
-					   struct ieee80211_bss_conf *info,
+					   struct ieee80211_bss_conf *info)
-					   struct ieee80211_sta_ht_cap *ht_cap)
 {
 	int basic_rates = wfx_rate_mask_to_hw(wvif->wdev, info->basic_rates);
+	struct ieee80211_sta *sta = NULL;
 	struct hif_mib_set_association_mode val = {
 		.preambtype_use = 1,
 		.mode = 1,
 		.basic_rate_set = cpu_to_le32(basic_rates)
 	};
+	rcu_read_lock(); // protect sta
+	if (info->bssid && !info->ibss_joined)
+		sta = ieee80211_find_sta(wvif->vif, info->bssid);
 	// FIXME: it is strange to not retrieve all information from bss_info
-	if (ht_cap && ht_cap->ht_supported) {
+	if (sta && sta->ht_cap.ht_supported) {
-		val.mpdu_start_spacing = ht_cap->ampdu_density;
+		val.mpdu_start_spacing = sta->ht_cap.ampdu_density;
 		if (!(info->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
-			val.greenfield = !!(ht_cap->cap & IEEE80211_HT_CAP_GRN_FLD);
+			val.greenfield = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD);
 	}
+	rcu_read_unlock();
 	return hif_write_mib(wvif->wdev, wvif->id,
 			     HIF_MIB_ID_SET_ASSOCIATION_MODE, &val, sizeof(val));

drivers/staging/wfx/sta.c+15−10

 static void wfx_do_join(struct wfx_vif *wvif)
 {
 	int ret;
-	const u8 *ssidie;
 	struct ieee80211_bss_conf *conf = &wvif->vif->bss_conf;
 	struct cfg80211_bss *bss = NULL;
+	u8 ssid[IEEE80211_MAX_SSID_LEN];
+	const u8 *ssidie = NULL;
+	int ssidlen = 0;
 	wfx_tx_lock_flush(wvif->wdev);
 	if (!wvif->beacon_int)
 		wvif->beacon_int = 1;
-	rcu_read_lock();
+	rcu_read_lock(); // protect ssidie
 	if (!conf->ibss_joined)
 		ssidie = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
-	else
+	if (ssidie) {
-		ssidie = NULL;
+		ssidlen = ssidie[1];
+		memcpy(ssid, &ssidie[2], ssidie[1]);
+	}
+	rcu_read_unlock();
 	wfx_tx_flush(wvif->wdev);
 	wfx_set_mfp(wvif, bss);
-	/* Perform actual join */
 	wvif->wdev->tx_burst_idx = -1;
-	ret = hif_join(wvif, conf, wvif->channel, ssidie);
+	ret = hif_join(wvif, conf, wvif->channel, ssid, ssidlen);
-	rcu_read_unlock();
 	if (ret) {
 		ieee80211_connection_loss(wvif->vif);
 		wvif->join_complete_status = -1;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(sta_priv->buffered); i++)
-		WARN(sta_priv->buffered[i], "release station while Tx is in progress");
+		if (sta_priv->buffered[i])
+			dev_warn(wvif->wdev->dev, "release station while %d pending frame on queue %d",
+				 sta_priv->buffered[i], i);
 	// FIXME: see note in wfx_sta_add()
 	if (vif->type == NL80211_IFTYPE_STATION)
 		return 0;
 			wfx_rate_mask_to_hw(wvif->wdev, sta->supp_rates[wvif->channel->band]);
 	else
 		wvif->bss_params.operational_rate_set = -1;
+	rcu_read_unlock();
 	if (sta &&
 	    info->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
 		hif_dual_cts_protection(wvif, true);
 	wvif->bss_params.beacon_lost_count = 20;
 	wvif->bss_params.aid = info->aid;
-	hif_set_association_mode(wvif, info, sta ? &sta->ht_cap : NULL);
+	hif_set_association_mode(wvif, info);
-	rcu_read_unlock();
 	if (!info->ibss_joined) {
 		hif_keep_alive_period(wvif, 30 /* sec */);

drivers/thunderbolt/switch.c+1−1

@@ -954,7 +954,7 @@ static bool tb_port_is_width_supported(struct tb_port *port, int width) · 953 unmodified lines
954	ret = tb_port_read(port, &phy, TB_CFG_PORT,	954	ret = tb_port_read(port, &phy, TB_CFG_PORT,
955	port->cap_phy + LANE_ADP_CS_0, 1);	955	port->cap_phy + LANE_ADP_CS_0, 1);
956	if (ret)	956	if (ret)
957	return ret;	957	return false;
958		958
959	widths = (phy & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>	959	widths = (phy & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>
960	LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;	960	LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;

drivers/tty/tty_io.c+6−8

 	tty_debug_hangup(tty, "freeing structure\n");
 	/*
 	 * The release_tty function takes care of the details of clearing
-	 * the slots and preserving the termios structure. The tty_unlock_pair
+	 * the slots and preserving the termios structure.
-	 * should be safe as we keep a kref while the tty is locked (so the
-	 * unlock never unlocks a freed tty).
 	 */
 	mutex_lock(&tty_mutex);
 	tty_port_set_kopened(tty->port, 0);
 	tty_debug_hangup(tty, "freeing structure\n");
 	/*
 	 * The release_tty function takes care of the details of clearing
-	 * the slots and preserving the termios structure. The tty_unlock_pair
+	 * the slots and preserving the termios structure.
-	 * should be safe as we keep a kref while the tty is locked (so the
-	 * unlock never unlocks a freed tty).
 	 */
 	mutex_lock(&tty_mutex);
 	release_tty(tty, idx);
 	struct serial_struct32 v32;
 	struct serial_struct v;
 	int err;
-	memset(&v, 0, sizeof(struct serial_struct));
-	if (!tty->ops->set_serial)
+	memset(&v, 0, sizeof(v));
+	memset(&v32, 0, sizeof(v32));
+	if (!tty->ops->get_serial)
 		return -ENOTTY;
 	err = tty->ops->get_serial(tty, &v);
 	if (!err) {

drivers/usb/chipidea/udc.c+4−3

 static void ci_hdrc_gadget_connect(struct usb_gadget *_gadget, int is_active)
 {
 	struct ci_hdrc *ci = container_of(_gadget, struct ci_hdrc, gadget);
-	unsigned long flags;
 	if (is_active) {
 		pm_runtime_get_sync(&_gadget->dev);
 		hw_device_reset(ci);
-		spin_lock_irqsave(&ci->lock, flags);
+		spin_lock_irq(&ci->lock);
 		if (ci->driver) {
 			hw_device_state(ci, ci->ep0out->qh.dma);
 			usb_gadget_set_state(_gadget, USB_STATE_POWERED);
+			spin_unlock_irq(&ci->lock);
 			usb_udc_vbus_handler(_gadget, true);
+		} else {
+			spin_unlock_irq(&ci->lock);
 		}
-		spin_unlock_irqrestore(&ci->lock, flags);
 	} else {
 		usb_udc_vbus_handler(_gadget, false);
 		if (ci->driver)

drivers/usb/class/cdc-acm.c+21−13

 	ss->xmit_fifo_size = acm->writesize;
 	ss->baud_base = le32_to_cpu(acm->line.dwDTERate);
-	ss->close_delay	= acm->port.close_delay / 10;
+	ss->close_delay	= jiffies_to_msecs(acm->port.close_delay) / 10;
 	ss->closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 				ASYNC_CLOSING_WAIT_NONE :
-				acm->port.closing_wait / 10;
+				jiffies_to_msecs(acm->port.closing_wait) / 10;
 	return 0;
 }
 {
 	struct acm *acm = tty->driver_data;
 	unsigned int closing_wait, close_delay;
+	unsigned int old_closing_wait, old_close_delay;
 	int retval = 0;
-	close_delay = ss->close_delay * 10;
+	close_delay = msecs_to_jiffies(ss->close_delay * 10);
 	closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
-			ASYNC_CLOSING_WAIT_NONE : ss->closing_wait * 10;
+			ASYNC_CLOSING_WAIT_NONE :
+			msecs_to_jiffies(ss->closing_wait * 10);
+	/* we must redo the rounding here, so that the values match */
+	old_close_delay	= jiffies_to_msecs(acm->port.close_delay) / 10;
+	old_closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+				ASYNC_CLOSING_WAIT_NONE :
+				jiffies_to_msecs(acm->port.closing_wait) / 10;
 	mutex_lock(&acm->port.mutex);
-	if (!capable(CAP_SYS_ADMIN)) {
+	if ((ss->close_delay != old_close_delay) ||
-		if ((close_delay != acm->port.close_delay) ||
+            (ss->closing_wait != old_closing_wait)) {
-		    (closing_wait != acm->port.closing_wait))
+		if (!capable(CAP_SYS_ADMIN))
 			retval = -EPERM;
-		else
+		else {
-			retval = -EOPNOTSUPP;
+			acm->port.close_delay  = close_delay;
-	} else {
+			acm->port.closing_wait = closing_wait;
-		acm->port.close_delay  = close_delay;
+		}
-		acm->port.closing_wait = closing_wait;
+	} else
-	}
+		retval = -EOPNOTSUPP;
 	mutex_unlock(&acm->port.mutex);
 	return retval;

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

 	{ USB_DEVICE(0x0b05, 0x17e0), .driver_info =
 			USB_QUIRK_IGNORE_REMOTE_WAKEUP },
+	/* Realtek hub in Dell WD19 (Type-C) */
+	{ USB_DEVICE(0x0bda, 0x0487), .driver_info = USB_QUIRK_NO_LPM },
+	/* Generic RTL8153 based ethernet adapters */
+	{ USB_DEVICE(0x0bda, 0x8153), .driver_info = USB_QUIRK_NO_LPM },
 	/* Action Semiconductor flash disk */
 	{ USB_DEVICE(0x10d6, 0x2200), .driver_info =
 			USB_QUIRK_STRING_FETCH_255 },

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

@@ -136,7 +136,8 @@ static void xhci_pci_quirks(struct device dev, struct xhci_hcd xhci) · 135 unmodified lines
136	xhci->quirks \|= XHCI_AMD_PLL_FIX;	136	xhci->quirks \|= XHCI_AMD_PLL_FIX;
137		137
138	if (pdev->vendor == PCI_VENDOR_ID_AMD &&	138	if (pdev->vendor == PCI_VENDOR_ID_AMD &&
139	(pdev->device == 0x15e0 \|\|	139	(pdev->device == 0x145c \|\|
		140	pdev->device == 0x15e0 \|\|
140	pdev->device == 0x15e1 \|\|	141	pdev->device == 0x15e1 \|\|
141	pdev->device == 0x43bb))	142	pdev->device == 0x43bb))
142	xhci->quirks \|= XHCI_SUSPEND_DELAY;	143	xhci->quirks \|= XHCI_SUSPEND_DELAY;

drivers/usb/host/xhci-plat.c+1−0

@@ -445,6 +445,7 @@ MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match); · 444 unmodified lines
445	static struct platform_driver usb_xhci_driver = {	445	static struct platform_driver usb_xhci_driver = {
446	.probe = xhci_plat_probe,	446	.probe = xhci_plat_probe,
447	.remove = xhci_plat_remove,	447	.remove = xhci_plat_remove,
		448	.shutdown = usb_hcd_platform_shutdown,
448	.driver = {	449	.driver = {
449	.name = "xhci-hcd",	450	.name = "xhci-hcd",
450	.pm = &xhci_plat_pm_ops,	451	.pm = &xhci_plat_pm_ops,

drivers/usb/host/xhci-trace.h+6−17

 	),
 	TP_printk("ep%d%s-%s: urb %p pipe %u slot %d length %d/%d sgs %d/%d stream %d flags %08x",
 			__entry->epnum, __entry->dir_in ? "in" : "out",
-			({ char *s;
+			__print_symbolic(__entry->type,
-			switch (__entry->type) {
+				   { USB_ENDPOINT_XFER_INT,	"intr" },
-			case USB_ENDPOINT_XFER_INT:
+				   { USB_ENDPOINT_XFER_CONTROL,	"control" },
-				s = "intr";
+				   { USB_ENDPOINT_XFER_BULK,	"bulk" },
-				break;
+				   { USB_ENDPOINT_XFER_ISOC,	"isoc" }),
-			case USB_ENDPOINT_XFER_CONTROL:
+			__entry->urb, __entry->pipe, __entry->slot_id,
-				s = "control";
-				break;
-			case USB_ENDPOINT_XFER_BULK:
-				s = "bulk";
-				break;
-			case USB_ENDPOINT_XFER_ISOC:
-				s = "isoc";
-				break;
-			default:
-				s = "UNKNOWN";
-			} s; }), __entry->urb, __entry->pipe, __entry->slot_id,
 			__entry->actual, __entry->length, __entry->num_mapped_sgs,
 			__entry->num_sgs, __entry->stream, __entry->flags
 		)

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

 	  .driver_info = NCTRL(0) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110a, 0xff),	/* Telit ME910G1 */
 	  .driver_info = NCTRL(0) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110b, 0xff),	/* Telit ME910G1 (ECM) */
+	  .driver_info = NCTRL(0) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910),
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910_USBCFG4),

drivers/usb/serial/pl2303.c+1−0

@@ -99,6 +99,7 @@ static const struct usb_device_id id_table[] = { · 98 unmodified lines
99	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },	99	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
100	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },	100	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
101	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },	101	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
		102	{ USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
102	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },	103	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
103	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },	104	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
104	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },	105	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },

drivers/usb/serial/pl2303.h+1−0

@@ -130,6 +130,7 @@ · 129 unmodified lines
130	#define HP_LM920_PRODUCT_ID 0x026b	130	#define HP_LM920_PRODUCT_ID 0x026b
131	#define HP_TD620_PRODUCT_ID 0x0956	131	#define HP_TD620_PRODUCT_ID 0x0956
132	#define HP_LD960_PRODUCT_ID 0x0b39	132	#define HP_LD960_PRODUCT_ID 0x0b39
		133	#define HP_LD381_PRODUCT_ID 0x0f7f
133	#define HP_LCM220_PRODUCT_ID 0x3139	134	#define HP_LCM220_PRODUCT_ID 0x3139
134	#define HP_LCM960_PRODUCT_ID 0x3239	135	#define HP_LCM960_PRODUCT_ID 0x3239
135	#define HP_LD220_PRODUCT_ID 0x3524	136	#define HP_LD220_PRODUCT_ID 0x3524

drivers/usb/typec/ucsi/displayport.c+11−1

 		return;
 	dp = typec_altmode_get_drvdata(alt);
+	if (!dp)
+		return;
 	dp->data.conf = 0;
 	dp->data.status = 0;
 	dp->initialized = false;
 	struct typec_altmode *alt;
 	struct ucsi_dp *dp;
+	mutex_lock(&con->lock);
 	/* We can't rely on the firmware with the capabilities. */
 	desc->vdo |= DP_CAP_DP_SIGNALING | DP_CAP_RECEPTACLE;
 	desc->vdo |= all_assignments << 16;
 	alt = typec_port_register_altmode(con->port, desc);
-	if (IS_ERR(alt))
+	if (IS_ERR(alt)) {
+		mutex_unlock(&con->lock);
 		return alt;
+	}
 	dp = devm_kzalloc(&alt->dev, sizeof(*dp), GFP_KERNEL);
 	if (!dp) {
 		typec_unregister_altmode(alt);
+		mutex_unlock(&con->lock);
 		return ERR_PTR(-ENOMEM);
 	}
 	alt->ops = &ucsi_displayport_ops;
 	typec_altmode_set_drvdata(alt, dp);
+	mutex_unlock(&con->lock);
 	return alt;
 }

drivers/watchdog/iTCO_vendor.h+2−0

 /* SPDX-License-Identifier: GPL-2.0 */
 /* iTCO Vendor Specific Support hooks */
 #ifdef CONFIG_ITCO_VENDOR_SUPPORT
+extern int iTCO_vendorsupport;
 extern void iTCO_vendor_pre_start(struct resource *, unsigned int);
 extern void iTCO_vendor_pre_stop(struct resource *);
 extern int iTCO_vendor_check_noreboot_on(void);
 #else
+#define iTCO_vendorsupport				0
 #define iTCO_vendor_pre_start(acpibase, heartbeat)	{}
 #define iTCO_vendor_pre_stop(acpibase)			{}
 #define iTCO_vendor_check_noreboot_on()			1

drivers/watchdog/iTCO_vendor_support.c+9−7

 /* Broken BIOS */
 #define BROKEN_BIOS		911
-static int vendorsupport;
+int iTCO_vendorsupport;
-module_param(vendorsupport, int, 0);
+EXPORT_SYMBOL(iTCO_vendorsupport);
+module_param_named(vendorsupport, iTCO_vendorsupport, int, 0);
 MODULE_PARM_DESC(vendorsupport, "iTCO vendor specific support mode, default="
 			"0 (none), 1=SuperMicro Pent3, 911=Broken SMI BIOS");
 void iTCO_vendor_pre_start(struct resource *smires,
 			   unsigned int heartbeat)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		supermicro_old_pre_start(smires);
 		break;
 void iTCO_vendor_pre_stop(struct resource *smires)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		supermicro_old_pre_stop(smires);
 		break;
 int iTCO_vendor_check_noreboot_on(void)
 {
-	switch (vendorsupport) {
+	switch (iTCO_vendorsupport) {
 	case SUPERMICRO_OLD_BOARD:
 		return 0;
 	default:
 static int __init iTCO_vendor_init_module(void)
 {
-	if (vendorsupport == SUPERMICRO_NEW_BOARD) {
+	if (iTCO_vendorsupport == SUPERMICRO_NEW_BOARD) {
 		pr_warn("Option vendorsupport=%d is no longer supported, "
 			"please use the w83627hf_wdt driver instead\n",
 			SUPERMICRO_NEW_BOARD);
 		return -EINVAL;
 	}
-	pr_info("vendor-support=%d\n", vendorsupport);
+	pr_info("vendor-support=%d\n", iTCO_vendorsupport);
 	return 0;
 }

drivers/watchdog/iTCO_wdt.c+16−12

 	if (!p->tco_res)
 		return -ENODEV;
-	p->smi_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_SMI);
-	if (!p->smi_res)
-		return -ENODEV;
 	p->iTCO_version = pdata->version;
 	p->pci_dev = to_pci_dev(dev->parent);
+	p->smi_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_SMI);
+	if (p->smi_res) {
+		/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
+		if (!devm_request_region(dev, p->smi_res->start,
+					 resource_size(p->smi_res),
+					 pdev->name)) {
+			pr_err("I/O address 0x%04llx already in use, device disabled\n",
+			       (u64)SMI_EN(p));
+			return -EBUSY;
+		}
+	} else if (iTCO_vendorsupport ||
+		   turn_SMI_watchdog_clear_off >= p->iTCO_version) {
+		pr_err("SMI I/O resource is missing\n");
+		return -ENODEV;
+	}
 	iTCO_wdt_no_reboot_bit_setup(p, pdata);
 	/*
 	/* Set the NO_REBOOT bit to prevent later reboots, just for sure */
 	p->update_no_reboot_bit(p->no_reboot_priv, true);
-	/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
-	if (!devm_request_region(dev, p->smi_res->start,
-				 resource_size(p->smi_res),
-				 pdev->name)) {
-		pr_err("I/O address 0x%04llx already in use, device disabled\n",
-		       (u64)SMI_EN(p));
-		return -EBUSY;
-	}
 	if (turn_SMI_watchdog_clear_off >= p->iTCO_version) {
 		/*
 		 * Bit 13: TCO_EN -> 0

fs/afs/addr_list.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	void afs_put_addrlist(struct afs_addr_list *alist)	19	void afs_put_addrlist(struct afs_addr_list *alist)
20	{	20	{
21	if (alist && refcount_dec_and_test(&alist->usage))	21	if (alist && refcount_dec_and_test(&alist->usage))
22	call_rcu(&alist->rcu, (rcu_callback_t)kfree);	22	kfree_rcu(alist, rcu);
23	}	23	}
24		24
25	/*	25	/*

fs/afs/cmservice.c+12−2

 	call->buffer = NULL;
 }
+/*
+ * Abort a service call from within an action function.
+ */
+static void afs_abort_service_call(struct afs_call *call, u32 abort_code, int error,
+				   const char *why)
+{
+	rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+				abort_code, error, why);
+	afs_set_call_complete(call, error, 0);
+}
 /*
  * The server supplied a list of callbacks that it wanted to break.
  */
 	if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
 		afs_send_empty_reply(call);
 	else
-		rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+		afs_abort_service_call(call, 1, 1, "K-1");
-					1, 1, "K-1");
 	afs_put_call(call);
 	_leave("");

fs/afs/internal.h+11−3

  * List of server addresses.
  */
 struct afs_addr_list {
-	struct rcu_head		rcu;		/* Must be first */
+	struct rcu_head		rcu;
 	refcount_t		usage;
 	u32			version;	/* Version */
 	unsigned char		max_addrs;
 	};
 	unsigned char		unmarshall;	/* unmarshalling phase */
 	unsigned char		addr_ix;	/* Address in ->alist */
-	bool			incoming;	/* T if incoming call */
+	bool			drop_ref;	/* T if need to drop ref for incoming call */
 	bool			send_pages;	/* T if data from mapping should be sent */
 	bool			need_attention;	/* T if RxRPC poked us */
 	bool			async;		/* T if asynchronous */
 		ok = true;
 	}
 	spin_unlock_bh(&call->state_lock);
-	if (ok)
+	if (ok) {
 		trace_afs_call_done(call);
+		/* Asynchronous calls have two refs to release - one from the alloc and
+		 * one queued with the work item - and we can't just deallocate the
+		 * call because the work item may be queued again.
+		 */
+		if (call->drop_ref)
+			afs_put_call(call);
+	}
 }
 /*

fs/afs/rxrpc.c+10−64

 static void afs_wake_up_call_waiter(struct sock *, struct rxrpc_call *, unsigned long);
 static void afs_wake_up_async_call(struct sock *, struct rxrpc_call *, unsigned long);
-static void afs_delete_async_call(struct work_struct *);
 static void afs_process_async_call(struct work_struct *);
 static void afs_rx_new_call(struct sock *, struct rxrpc_call *, unsigned long);
 static void afs_rx_discard_new_call(struct rxrpc_call *, unsigned long);
 	int n = atomic_dec_return(&call->usage);
 	int o = atomic_read(&net->nr_outstanding_calls);
-	trace_afs_call(call, afs_call_trace_put, n + 1, o,
+	trace_afs_call(call, afs_call_trace_put, n, o,
 		       __builtin_return_address(0));
 	ASSERTCMP(n, >=, 0);
 	/* If the call is going to be asynchronous, we need an extra ref for
 	 * the call to hold itself so the caller need not hang on to its ref.
 	 */
-	if (call->async)
+	if (call->async) {
 		afs_get_call(call, afs_call_trace_get);
+		call->drop_ref = true;
+	}
 	/* create a call */
 	rxcall = rxrpc_kernel_begin_call(call->net->socket, srx, call->key,
 					  afs_wake_up_async_call :
 					  afs_wake_up_call_waiter),
 					 call->upgrade,
-					 call->intr,
+					 (call->intr ? RXRPC_PREINTERRUPTIBLE :
+					  RXRPC_UNINTERRUPTIBLE),
 					 call->debug_id);
 	if (IS_ERR(rxcall)) {
 		ret = PTR_ERR(rxcall);
 done:
 	if (call->type->done)
 		call->type->done(call);
-	if (state == AFS_CALL_COMPLETE && call->incoming)
-		afs_put_call(call);
 out:
 	_leave("");
 	return;
 long afs_wait_for_call_to_complete(struct afs_call *call,
 				   struct afs_addr_cursor *ac)
 {
-	signed long rtt2, timeout;
 	long ret;
-	bool stalled = false;
-	u64 rtt;
-	u32 life, last_life;
 	bool rxrpc_complete = false;
 	DECLARE_WAITQUEUE(myself, current);
 	if (ret < 0)
 		goto out;
-	rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
-	rtt2 = nsecs_to_jiffies64(rtt) * 2;
-	if (rtt2 < 2)
-		rtt2 = 2;
-	timeout = rtt2;
-	rxrpc_kernel_check_life(call->net->socket, call->rxcall, &last_life);
 	add_wait_queue(&call->waitq, &myself);
 	for (;;) {
 		set_current_state(TASK_UNINTERRUPTIBLE);
 			call->need_attention = false;
 			__set_current_state(TASK_RUNNING);
 			afs_deliver_to_call(call);
-			timeout = rtt2;
 			continue;
 		}
 		if (afs_check_call_state(call, AFS_CALL_COMPLETE))
 			break;
-		if (!rxrpc_kernel_check_life(call->net->socket, call->rxcall, &life)) {
+		if (!rxrpc_kernel_check_life(call->net->socket, call->rxcall)) {
 			/* rxrpc terminated the call. */
 			rxrpc_complete = true;
 			break;
 		}
-		if (call->intr && timeout == 0 &&
+		schedule();
-		    life == last_life && signal_pending(current)) {
-			if (stalled)
-				break;
-			__set_current_state(TASK_RUNNING);
-			rxrpc_kernel_probe_life(call->net->socket, call->rxcall);
-			timeout = rtt2;
-			stalled = true;
-			continue;
-		}
-		if (life != last_life) {
-			timeout = rtt2;
-			last_life = life;
-			stalled = false;
-		}
-		timeout = schedule_timeout(timeout);
 	}
 	remove_wait_queue(&call->waitq, &myself);
 	u = atomic_fetch_add_unless(&call->usage, 1, 0);
 	if (u != 0) {
-		trace_afs_call(call, afs_call_trace_wake, u,
+		trace_afs_call(call, afs_call_trace_wake, u + 1,
 			       atomic_read(&call->net->nr_outstanding_calls),
 			       __builtin_return_address(0));
 	}
 }
-/*
- * Delete an asynchronous call.  The work item carries a ref to the call struct
- * that we need to release.
- */
-static void afs_delete_async_call(struct work_struct *work)
-{
-	struct afs_call *call = container_of(work, struct afs_call, async_work);
-	_enter("");
-	afs_put_call(call);
-	_leave("");
-}
 /*
  * Perform I/O processing on an asynchronous call.  The work item carries a ref
  * to the call struct that we either need to release or to pass on.
 		afs_deliver_to_call(call);
 	}
-	if (call->state == AFS_CALL_COMPLETE) {
-		/* We have two refs to release - one from the alloc and one
-		 * queued with the work item - and we can't just deallocate the
-		 * call because the work item may be queued again.
-		 */
-		call->async_work.func = afs_delete_async_call;
-		if (!queue_work(afs_async_calls, &call->async_work))
-			afs_put_call(call);
-	}
 	afs_put_call(call);
 	_leave("");
 }
 			if (!call)
 				break;
+			call->drop_ref = true;
 			call->async = true;
 			call->state = AFS_CALL_SV_AWAIT_OP_ID;
 			init_waitqueue_head(&call->waitq);

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

@@ -856,9 +856,9 @@ static void clear_incompat_bg_bits(struct btrfs_fs_info *fs_info, u64 flags) · 855 unmodified lines
856	found_raid1c34 = true;	856	found_raid1c34 = true;
857	up_read(&sinfo->groups_sem);	857	up_read(&sinfo->groups_sem);
858	}	858	}
859	if (found_raid56)	859	if (!found_raid56)
860	btrfs_clear_fs_incompat(fs_info, RAID56);	860	btrfs_clear_fs_incompat(fs_info, RAID56);
861	if (found_raid1c34)	861	if (!found_raid1c34)
862	btrfs_clear_fs_incompat(fs_info, RAID1C34);	862	btrfs_clear_fs_incompat(fs_info, RAID1C34);
863	}	863	}
864	}	864	}

fs/btrfs/inode.c+4−0

 		ret = btrfs_sync_log(trans, BTRFS_I(old_inode)->root, &ctx);
 		if (ret)
 			commit_transaction = true;
+	} else if (sync_log) {
+		mutex_lock(&root->log_mutex);
+		list_del(&ctx.list);
+		mutex_unlock(&root->log_mutex);
 	}
 	if (commit_transaction) {
 		ret = btrfs_commit_transaction(trans);

fs/cifs/file.c+2−1

 	rc = posix_lock_file(file, flock, NULL);
 	up_write(&cinode->lock_sem);
 	if (rc == FILE_LOCK_DEFERRED) {
-		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
+		rc = wait_event_interruptible(flock->fl_wait,
+					list_empty(&flock->fl_blocked_member));
 		if (!rc)
 			goto try_again;
 		locks_delete_block(flock);

fs/cifs/inode.c+1−1

@@ -2191,7 +2191,7 @@ int cifs_getattr(const struct path path, struct kstat stat, · 2190 unmodified lines
2191	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))	2191	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2192	stat->gid = current_fsgid();	2192	stat->gid = current_fsgid();
2193	}	2193	}
2194	return rc;	2194	return 0;
2195	}	2195	}
2196		2196
2197	int cifs_fiemap(struct inode inode, struct fiemap_extent_info fei, u64 start,	2197	int cifs_fiemap(struct inode inode, struct fiemap_extent_info fei, u64 start,

fs/cifs/smb2ops.c+3−1

 		goto qdf_free;
 	}
+	atomic_inc(&tcon->num_remote_opens);
 	qd_rsp = (struct smb2_query_directory_rsp *)rsp_iov[1].iov_base;
 	if (qd_rsp->sync_hdr.Status == STATUS_NO_MORE_FILES) {
 		trace_smb3_query_dir_done(xid, fid->persistent_fid,
 	if (rc)
 		goto out;
-	if (out_data_len < sizeof(struct file_allocated_range_buffer)) {
+	if (out_data_len && out_data_len < sizeof(struct file_allocated_range_buffer)) {
 		rc = -EINVAL;
 		goto out;
 	}

fs/eventpoll.c+4−4

@@ -1854,9 +1854,9 @@ fetch_events: · 1853 unmodified lines
1854	waiter = true;	1854	waiter = true;
1855	init_waitqueue_entry(&wait, current);	1855	init_waitqueue_entry(&wait, current);
1856		1856
1857	spin_lock_irq(&ep->wq.lock);	1857	write_lock_irq(&ep->lock);
1858	__add_wait_queue_exclusive(&ep->wq, &wait);	1858	__add_wait_queue_exclusive(&ep->wq, &wait);
1859	spin_unlock_irq(&ep->wq.lock);	1859	write_unlock_irq(&ep->lock);
1860	}	1860	}
1861		1861
1862	for (;;) {	1862	for (;;) {
@@ -1904,9 +1904,9 @@ send_events: · 41 unmodified lines
1904	goto fetch_events;	1904	goto fetch_events;
1905		1905
1906	if (waiter) {	1906	if (waiter) {
1907	spin_lock_irq(&ep->wq.lock);	1907	write_lock_irq(&ep->lock);
1908	__remove_wait_queue(&ep->wq, &wait);	1908	__remove_wait_queue(&ep->wq, &wait);
1909	spin_unlock_irq(&ep->wq.lock);	1909	write_unlock_irq(&ep->lock);
1910	}	1910	}
1911		1911
1912	return res;	1912	return res;

fs/file.c+6−1

 	return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags);
 }
+int __get_unused_fd_flags(unsigned flags, unsigned long nofile)
+{
+	return __alloc_fd(current->files, 0, nofile, flags);
+}
 int get_unused_fd_flags(unsigned flags)
 {
-	return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags);
+	return __get_unused_fd_flags(flags, rlimit(RLIMIT_NOFILE));
 }
 EXPORT_SYMBOL(get_unused_fd_flags);

fs/fuse/dev.c+3−3

 void fuse_request_end(struct fuse_conn *fc, struct fuse_req *req)
 {
 	struct fuse_iqueue *fiq = &fc->iq;
-	bool async;
 	if (test_and_set_bit(FR_FINISHED, &req->flags))
 		goto put_request;
-	async = req->args->end;
 	/*
 	 * test_and_set_bit() implies smp_mb() between bit
 	 * changing and below intr_entry check. Pairs with
 		wake_up(&req->waitq);
 	}
-	if (async)
+	if (test_bit(FR_ASYNC, &req->flags))
 		req->args->end(fc, req->args, req->out.h.error);
 put_request:
 	fuse_put_request(fc, req);
 	req->in.h.opcode = args->opcode;
 	req->in.h.nodeid = args->nodeid;
 	req->args = args;
+	if (args->end)
+		__set_bit(FR_ASYNC, &req->flags);
 }
 ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)

fs/fuse/fuse_i.h+2−0

  * FR_SENT:		request is in userspace, waiting for an answer
  * FR_FINISHED:		request is finished
  * FR_PRIVATE:		request is on private list
+ * FR_ASYNC:		request is asynchronous
  */
 enum fuse_req_flag {
 	FR_ISREPLY,
 	FR_SENT,
 	FR_FINISHED,
 	FR_PRIVATE,
+	FR_ASYNC,
 };
 /**

fs/inode.c+1−0

@@ -138,6 +138,7 @@ int inode_init_always(struct super_block sb, struct inode inode) · 137 unmodified lines
138	inode->i_sb = sb;	138	inode->i_sb = sb;
139	inode->i_blkbits = sb->s_blocksize_bits;	139	inode->i_blkbits = sb->s_blocksize_bits;
140	inode->i_flags = 0;	140	inode->i_flags = 0;
		141	atomic64_set(&inode->i_sequence, 0);
141	atomic_set(&inode->i_count, 1);	142	atomic_set(&inode->i_count, 1);
142	inode->i_op = &empty_iops;	143	inode->i_op = &empty_iops;
143	inode->i_fop = &no_open_fops;	144	inode->i_fop = &no_open_fops;

fs/io_uring.c+29−18

@@ -191,7 +191,6 @@ struct fixed_file_data { · 190 unmodified lines
191	struct llist_head put_llist;	191	struct llist_head put_llist;
192	struct work_struct ref_work;	192	struct work_struct ref_work;
193	struct completion done;	193	struct completion done;
194	struct rcu_head rcu;
195	};	194	};
196		195
197	struct io_ring_ctx {	196	struct io_ring_ctx {
@@ -344,6 +343,7 @@ struct io_accept { · 146 unmodified lines
344	struct sockaddr __user *addr;	343	struct sockaddr __user *addr;
345	int __user *addr_len;	344	int __user *addr_len;
346	int flags;	345	int flags;
		346	unsigned long nofile;
347	};	347	};
348		348
349	struct io_sync {	349	struct io_sync {
@@ -398,6 +398,7 @@ struct io_open { · 48 unmodified lines
398	struct filename *filename;	398	struct filename *filename;
399	struct statx __user *buffer;	399	struct statx __user *buffer;
400	struct open_how how;	400	struct open_how how;
		401	unsigned long nofile;
401	};	402	};
402		403
403	struct io_files_update {	404	struct io_files_update {
@@ -2578,6 +2579,7 @@ static int io_openat_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 2174 unmodified lines
2578	return ret;	2579	return ret;
2579	}	2580	}
2580		2581
		2582	req->open.nofile = rlimit(RLIMIT_NOFILE);
2581	req->flags \|= REQ_F_NEED_CLEANUP;	2583	req->flags \|= REQ_F_NEED_CLEANUP;
2582	return 0;	2584	return 0;
2583	}	2585	}
@@ -2619,6 +2621,7 @@ static int io_openat2_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 35 unmodified lines
2619	return ret;	2621	return ret;
2620	}	2622	}
2621		2623
		2624	req->open.nofile = rlimit(RLIMIT_NOFILE);
2622	req->flags \|= REQ_F_NEED_CLEANUP;	2625	req->flags \|= REQ_F_NEED_CLEANUP;
2623	return 0;	2626	return 0;
2624	}	2627	}
@@ -2637,7 +2640,7 @@ static int io_openat2(struct io_kiocb req, struct io_kiocb *nxt, · 12 unmodified lines
2637	if (ret)	2640	if (ret)
2638	goto err;	2641	goto err;
2639		2642
2640	ret = get_unused_fd_flags(req->open.how.flags);	2643	ret = __get_unused_fd_flags(req->open.how.flags, req->open.nofile);
2641	if (ret < 0)	2644	if (ret < 0)
2642	goto err;	2645	goto err;
2643		2646
@@ -3322,6 +3325,7 @@ static int io_accept_prep(struct io_kiocb req, const struct io_uring_sqe sqe) · 678 unmodified lines
3322	accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));	3325	accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
3323	accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));	3326	accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
3324	accept->flags = READ_ONCE(sqe->accept_flags);	3327	accept->flags = READ_ONCE(sqe->accept_flags);
		3328	accept->nofile = rlimit(RLIMIT_NOFILE);
3325	return 0;	3329	return 0;
3326	#else	3330	#else
3327	return -EOPNOTSUPP;	3331	return -EOPNOTSUPP;
@@ -3338,7 +3342,8 @@ static int __io_accept(struct io_kiocb req, struct io_kiocb *nxt, · 10 unmodified lines
3338		3342
3339	file_flags = force_nonblock ? O_NONBLOCK : 0;	3343	file_flags = force_nonblock ? O_NONBLOCK : 0;
3340	ret = __sys_accept4_file(req->file, file_flags, accept->addr,	3344	ret = __sys_accept4_file(req->file, file_flags, accept->addr,
3341	accept->addr_len, accept->flags);	3345	accept->addr_len, accept->flags,
		3346	accept->nofile);
3342	if (ret == -EAGAIN && force_nonblock)	3347	if (ret == -EAGAIN && force_nonblock)
3343	return -EAGAIN;	3348	return -EAGAIN;
3344	if (ret == -ERESTARTSYS)	3349	if (ret == -ERESTARTSYS)
@@ -4132,6 +4137,9 @@ static int io_req_defer_prep(struct io_kiocb *req, · 787 unmodified lines
4132	{	4137	{
4133	ssize_t ret = 0;	4138	ssize_t ret = 0;
4134		4139
		4140	if (!sqe)
		4141	return 0;
		4142
4135	if (io_op_defs[req->opcode].file_table) {	4143	if (io_op_defs[req->opcode].file_table) {
4136	ret = io_grab_files(req);	4144	ret = io_grab_files(req);
4137	if (unlikely(ret))	4145	if (unlikely(ret))
@@ -4908,6 +4916,11 @@ err_req: · 770 unmodified lines
4908	if (sqe_flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {	4916	if (sqe_flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {
4909	req->flags \|= REQ_F_LINK;	4917	req->flags \|= REQ_F_LINK;
4910	INIT_LIST_HEAD(&req->link_list);	4918	INIT_LIST_HEAD(&req->link_list);
		4919
		4920	if (io_alloc_async_ctx(req)) {
		4921	ret = -EAGAIN;
		4922	goto err_req;
		4923	}
4911	ret = io_req_defer_prep(req, sqe);	4924	ret = io_req_defer_prep(req, sqe);
4912	if (ret)	4925	if (ret)
4913	req->flags \|= REQ_F_FAIL_LINK;	4926	req->flags \|= REQ_F_FAIL_LINK;
@@ -5331,24 +5344,21 @@ static void io_file_ref_kill(struct percpu_ref *ref) · 417 unmodified lines
5331	complete(&data->done);	5344	complete(&data->done);
5332	}	5345	}
5333		5346
5334	static void __io_file_ref_exit_and_free(struct rcu_head *rcu)	5347	static void io_file_ref_exit_and_free(struct work_struct *work)
5335	{	5348	{
5336	struct fixed_file_data *data = container_of(rcu, struct fixed_file_data,	5349	struct fixed_file_data *data;
5337	rcu);	5350
5338	percpu_ref_exit(&data->refs);	5351	data = container_of(work, struct fixed_file_data, ref_work);
5339	kfree(data);
5340	}
5341		5352
5342	static void io_file_ref_exit_and_free(struct rcu_head *rcu)
5343	{
5344	/*	5353	/*
5345	* We need to order our exit+free call against the potentially	5354	* Ensure any percpu-ref atomic switch callback has run, it could have
5346	* existing call_rcu() for switching to atomic. One way to do that	5355	* been in progress when the files were being unregistered. Once
5347	* is to have this rcu callback queue the final put and free, as we	5356	* that's done, we can safely exit and free the ref and containing
5348	* could otherwise have a pre-existing atomic switch complete _after_	5357	* data structure.
5349	* the free callback we queued.
5350	*/	5358	*/
5351	call_rcu(rcu, __io_file_ref_exit_and_free);	5359	rcu_barrier();
		5360	percpu_ref_exit(&data->refs);
		5361	kfree(data);
5352	}	5362	}
5353		5363
5354	static int io_sqe_files_unregister(struct io_ring_ctx *ctx)	5364	static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
@@ -5369,7 +5379,8 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) · 14 unmodified lines
5369	for (i = 0; i < nr_tables; i++)	5379	for (i = 0; i < nr_tables; i++)
5370	kfree(data->table[i].files);	5380	kfree(data->table[i].files);
5371	kfree(data->table);	5381	kfree(data->table);
5372	call_rcu(&data->rcu, io_file_ref_exit_and_free);	5382	INIT_WORK(&data->ref_work, io_file_ref_exit_and_free);
		5383	queue_work(system_wq, &data->ref_work);
5373	ctx->file_data = NULL;	5384	ctx->file_data = NULL;
5374	ctx->nr_user_files = 0;	5385	ctx->nr_user_files = 0;
5375	return 0;	5386	return 0;

fs/locks.c+48−6

 {
 	locks_delete_global_blocked(waiter);
 	list_del_init(&waiter->fl_blocked_member);
-	waiter->fl_blocker = NULL;
 }
 static void __locks_wake_up_blocks(struct file_lock *blocker)
 			waiter->fl_lmops->lm_notify(waiter);
 		else
 			wake_up(&waiter->fl_wait);
+		/*
+		 * The setting of fl_blocker to NULL marks the "done"
+		 * point in deleting a block. Paired with acquire at the top
+		 * of locks_delete_block().
+		 */
+		smp_store_release(&waiter->fl_blocker, NULL);
 	}
 }
 {
 	int status = -ENOENT;
+	/*
+	 * If fl_blocker is NULL, it won't be set again as this thread "owns"
+	 * the lock and is the only one that might try to claim the lock.
+	 *
+	 * We use acquire/release to manage fl_blocker so that we can
+	 * optimize away taking the blocked_lock_lock in many cases.
+	 *
+	 * The smp_load_acquire guarantees two things:
+	 *
+	 * 1/ that fl_blocked_requests can be tested locklessly. If something
+	 * was recently added to that list it must have been in a locked region
+	 * *before* the locked region when fl_blocker was set to NULL.
+	 *
+	 * 2/ that no other thread is accessing 'waiter', so it is safe to free
+	 * it.  __locks_wake_up_blocks is careful not to touch waiter after
+	 * fl_blocker is released.
+	 *
+	 * If a lockless check of fl_blocker shows it to be NULL, we know that
+	 * no new locks can be inserted into its fl_blocked_requests list, and
+	 * can avoid doing anything further if the list is empty.
+	 */
+	if (!smp_load_acquire(&waiter->fl_blocker) &&
+	    list_empty(&waiter->fl_blocked_requests))
+		return status;
 	spin_lock(&blocked_lock_lock);
 	if (waiter->fl_blocker)
 		status = 0;
 	__locks_wake_up_blocks(waiter);
 	__locks_delete_block(waiter);
+	/*
+	 * The setting of fl_blocker to NULL marks the "done" point in deleting
+	 * a block. Paired with acquire at the top of this function.
+	 */
+	smp_store_release(&waiter->fl_blocker, NULL);
 	spin_unlock(&blocked_lock_lock);
 	return status;
 }
 		error = posix_lock_inode(inode, fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+					list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}
 		error = posix_lock_inode(inode, &fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl.fl_wait, !fl.fl_blocker);
+		error = wait_event_interruptible(fl.fl_wait,
+					list_empty(&fl.fl_blocked_member));
 		if (!error) {
 			/*
 			 * If we've been sleeping someone might have
 	locks_dispose_list(&dispose);
 	error = wait_event_interruptible_timeout(new_fl->fl_wait,
-						!new_fl->fl_blocker, break_time);
+					list_empty(&new_fl->fl_blocked_member),
+					break_time);
 	percpu_down_read(&file_rwsem);
 	spin_lock(&ctx->flc_lock);
 		error = flock_lock_inode(inode, fl);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+				list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}
 		error = vfs_lock_file(filp, cmd, fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
 			break;
-		error = wait_event_interruptible(fl->fl_wait, !fl->fl_blocker);
+		error = wait_event_interruptible(fl->fl_wait,
+					list_empty(&fl->fl_blocked_member));
 		if (error)
 			break;
 	}

fs/nfs/client.c+1−0

@@ -153,6 +153,7 @@ struct nfs_client nfs_alloc_client(const struct nfs_client_initdata cl_init) · 152 unmodified lines
153	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)	153	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
154	goto error_0;	154	goto error_0;
155		155
		156	clp->cl_minorversion = cl_init->minorversion;
156	clp->cl_nfs_mod = cl_init->nfs_mod;	157	clp->cl_nfs_mod = cl_init->nfs_mod;
157	if (!try_module_get(clp->cl_nfs_mod->owner))	158	if (!try_module_get(clp->cl_nfs_mod->owner))
158	goto error_dealloc;	159	goto error_dealloc;

fs/nfs/fs_context.c+9−0

 	if (len > maxnamlen)
 		goto out_hostname;
+	kfree(ctx->nfs_server.hostname);
 	/* N.B. caller will free nfs_server.hostname in all cases */
 	ctx->nfs_server.hostname = kmemdup_nul(dev_name, len, GFP_KERNEL);
 	if (!ctx->nfs_server.hostname)
 		}
 		ctx->nfs_mod = nfs_mod;
 	}
+	/* Ensure the filesystem context has the correct fs_type */
+	if (fc->fs_type != ctx->nfs_mod->nfs_fs) {
+		module_put(fc->fs_type->owner);
+		__module_get(ctx->nfs_mod->nfs_fs->owner);
+		fc->fs_type = ctx->nfs_mod->nfs_fs;
+	}
 	return 0;
 out_no_device_name:

fs/nfs/fscache.c+2−0

 struct nfs_server_key {
 	struct {
 		uint16_t	nfsversion;		/* NFS protocol version */
+		uint32_t	minorversion;		/* NFSv4 minor version */
 		uint16_t	family;			/* address family */
 		__be16		port;			/* IP port */
 	} hdr;
 	memset(&key, 0, sizeof(key));
 	key.hdr.nfsversion = clp->rpc_ops->version;
+	key.hdr.minorversion = clp->cl_minorversion;
 	key.hdr.family = clp->cl_addr.ss_family;
 	switch (clp->cl_addr.ss_family) {

fs/nfs/namespace.c+1−1

@@ -153,7 +153,7 @@ struct vfsmount nfs_d_automount(struct path path) · 152 unmodified lines
153	/* Open a new filesystem context, transferring parameters from the	153	/* Open a new filesystem context, transferring parameters from the
154	* parent superblock, including the network namespace.	154	* parent superblock, including the network namespace.
155	*/	155	*/
156	fc = fs_context_for_submount(&nfs_fs_type, path->dentry);	156	fc = fs_context_for_submount(path->mnt->mnt_sb->s_type, path->dentry);
157	if (IS_ERR(fc))	157	if (IS_ERR(fc))
158	return ERR_CAST(fc);	158	return ERR_CAST(fc);
159		159

fs/nfs/nfs4client.c+0−1

@@ -216,7 +216,6 @@ struct nfs_client nfs4_alloc_client(const struct nfs_client_initdata cl_init) · 215 unmodified lines
216	INIT_LIST_HEAD(&clp->cl_ds_clients);	216	INIT_LIST_HEAD(&clp->cl_ds_clients);
217	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");	217	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
218	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;	218	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
219	clp->cl_minorversion = cl_init->minorversion;
220	clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];	219	clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
221	clp->cl_mig_gen = 1;	220	clp->cl_mig_gen = 1;
222	#if IS_ENABLED(CONFIG_NFS_V4_1)	221	#if IS_ENABLED(CONFIG_NFS_V4_1)

fs/overlayfs/Kconfig+1−0

@@ -93,6 +93,7 @@ config OVERLAY_FS_XINO_AUTO · 92 unmodified lines
93	bool "Overlayfs: auto enable inode number mapping"	93	bool "Overlayfs: auto enable inode number mapping"
94	default n	94	default n
95	depends on OVERLAY_FS	95	depends on OVERLAY_FS
		96	depends on 64BIT
96	help	97	help
97	If this config option is enabled then overlay filesystems will use	98	If this config option is enabled then overlay filesystems will use
98	unused high bits in undelying filesystem inode numbers to map all	99	unused high bits in undelying filesystem inode numbers to map all

fs/overlayfs/file.c+6−0

 	if (iocb->ki_flags & IOCB_WRITE) {
 		struct inode *inode = file_inode(orig_iocb->ki_filp);
+		/* Actually acquired in ovl_write_iter() */
+		__sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
+				      SB_FREEZE_WRITE);
 		file_end_write(iocb->ki_filp);
 		ovl_copyattr(ovl_inode_real(inode), inode);
 	}
 			goto out;
 		file_start_write(real.file);
+		/* Pacify lockdep, same trick as done in aio_write() */
+		__sb_writers_release(file_inode(real.file)->i_sb,
+				     SB_FREEZE_WRITE);
 		aio_req->fd = real;
 		real.flags = 0;
 		aio_req->orig_iocb = iocb;

fs/overlayfs/overlayfs.h+6−1

 	return ovl_same_dev(sb) ? OVL_FS(sb)->xino_mode : 0;
 }
-static inline int ovl_inode_lock(struct inode *inode)
+static inline void ovl_inode_lock(struct inode *inode)
+{
+	mutex_lock(&OVL_I(inode)->lock);
+}
+static inline int ovl_inode_lock_interruptible(struct inode *inode)
 {
 	return mutex_lock_interruptible(&OVL_I(inode)->lock);
 }

fs/overlayfs/super.c+8−1

 		if (ofs->config.xino == OVL_XINO_ON)
 			pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n");
 		ofs->xino_mode = 0;
+	} else if (ofs->config.xino == OVL_XINO_OFF) {
+		ofs->xino_mode = -1;
 	} else if (ofs->config.xino == OVL_XINO_ON && ofs->xino_mode < 0) {
 		/*
 		 * This is a roundup of number of bits needed for encoding
 	sb->s_stack_depth = 0;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	/* Assume underlaying fs uses 32bit inodes unless proven otherwise */
-	if (ofs->config.xino != OVL_XINO_OFF)
+	if (ofs->config.xino != OVL_XINO_OFF) {
 		ofs->xino_mode = BITS_PER_LONG - 32;
+		if (!ofs->xino_mode) {
+			pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n");
+			ofs->config.xino = OVL_XINO_OFF;
+		}
+	}
 	/* alloc/destroy_inode needed for setting up traps in inode cache */
 	sb->s_op = &ovl_super_operations;

fs/overlayfs/util.c+2−2

@@ -509,7 +509,7 @@ int ovl_copy_up_start(struct dentry *dentry, int flags) · 508 unmodified lines
509	struct inode *inode = d_inode(dentry);	509	struct inode *inode = d_inode(dentry);
510	int err;	510	int err;
511		511
512	err = ovl_inode_lock(inode);	512	err = ovl_inode_lock_interruptible(inode);
513	if (!err && ovl_already_copied_up_locked(dentry, flags)) {	513	if (!err && ovl_already_copied_up_locked(dentry, flags)) {
514	err = 1; /* Already copied up */	514	err = 1; /* Already copied up */
515	ovl_inode_unlock(inode);	515	ovl_inode_unlock(inode);
@@ -764,7 +764,7 @@ int ovl_nlink_start(struct dentry *dentry) · 248 unmodified lines
764	return err;	764	return err;
765	}	765	}
766		766
767	err = ovl_inode_lock(inode);	767	err = ovl_inode_lock_interruptible(inode);
768	if (err)	768	if (err)
769	return err;	769	return err;
770		770

fs/zonefs/super.c+21−7

  * amount of readable data in the zone.
  */
 static loff_t zonefs_check_zone_condition(struct inode *inode,
-					  struct blk_zone *zone, bool warn)
+					  struct blk_zone *zone, bool warn,
+					  bool mount)
 {
 	struct zonefs_inode_info *zi = ZONEFS_I(inode);
 		zone->wp = zone->start;
 		return 0;
 	case BLK_ZONE_COND_READONLY:
-		/* Do not allow writes in read-only zones */
+		/*
+		 * The write pointer of read-only zones is invalid. If such a
+		 * zone is found during mount, the file size cannot be retrieved
+		 * so we treat the zone as offline (mount == true case).
+		 * Otherwise, keep the file size as it was when last updated
+		 * so that the user can recover data. In both cases, writes are
+		 * always disabled for the zone.
+		 */
 		if (warn)
 			zonefs_warn(inode->i_sb, "inode %lu: read-only zone\n",
 				    inode->i_ino);
 		inode->i_flags |= S_IMMUTABLE;
+		if (mount) {
+			zone->cond = BLK_ZONE_COND_OFFLINE;
+			inode->i_mode &= ~0777;
+			zone->wp = zone->start;
+			return 0;
+		}
 		inode->i_mode &= ~0222;
-		/* fallthrough */
+		return i_size_read(inode);
 	default:
 		if (zi->i_ztype == ZONEFS_ZTYPE_CNV)
 			return zi->i_max_size;
 	 * as there is no inconsistency between the inode size and the amount of
 	 * data writen in the zone (data_size).
 	 */
-	data_size = zonefs_check_zone_condition(inode, zone, true);
+	data_size = zonefs_check_zone_condition(inode, zone, true, false);
 	isize = i_size_read(inode);
 	if (zone->cond != BLK_ZONE_COND_OFFLINE &&
 	    zone->cond != BLK_ZONE_COND_READONLY &&
 		if (zone->cond != BLK_ZONE_COND_OFFLINE) {
 			zone->cond = BLK_ZONE_COND_OFFLINE;
 			data_size = zonefs_check_zone_condition(inode, zone,
-								false);
+								false, false);
 		}
 	} else if (zone->cond == BLK_ZONE_COND_READONLY ||
 		   sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO) {
 		if (zone->cond != BLK_ZONE_COND_READONLY) {
 			zone->cond = BLK_ZONE_COND_READONLY;
 			data_size = zonefs_check_zone_condition(inode, zone,
-								false);
+								false, false);
 		}
 	}
 	zi->i_zsector = zone->start;
 	zi->i_max_size = min_t(loff_t, MAX_LFS_FILESIZE,
 			       zone->len << SECTOR_SHIFT);
-	zi->i_wpoffset = zonefs_check_zone_condition(inode, zone, true);
+	zi->i_wpoffset = zonefs_check_zone_condition(inode, zone, true, true);
 	inode->i_uid = sbi->s_uid;
 	inode->i_gid = sbi->s_gid;

include/dt-bindings/clock/imx8mn-clock.h+2−2

@@ -122,8 +122,8 @@ · 121 unmodified lines
122	#define IMX8MN_CLK_I2C1 105	122	#define IMX8MN_CLK_I2C1 105
123	#define IMX8MN_CLK_I2C2 106	123	#define IMX8MN_CLK_I2C2 106
124	#define IMX8MN_CLK_I2C3 107	124	#define IMX8MN_CLK_I2C3 107
125	#define IMX8MN_CLK_I2C4 118	125	#define IMX8MN_CLK_I2C4 108
126	#define IMX8MN_CLK_UART1 119	126	#define IMX8MN_CLK_UART1 109
127	#define IMX8MN_CLK_UART2 110	127	#define IMX8MN_CLK_UART2 110
128	#define IMX8MN_CLK_UART3 111	128	#define IMX8MN_CLK_UART3 111
129	#define IMX8MN_CLK_UART4 112	129	#define IMX8MN_CLK_UART4 112

include/linux/dmar.h+9−5

 extern struct rw_semaphore dmar_global_lock;
 extern struct list_head dmar_drhd_units;
-#define for_each_drhd_unit(drhd) \
+#define for_each_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())
 #define for_each_active_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (drhd->ignored) {} else
 #define for_each_active_iommu(i, drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, drhd->ignored) {} else
 #define for_each_iommu(i, drhd)						\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, 0) {} else
 static inline bool dmar_rcu_check(void)

include/linux/dsa/8021q.h+0−7

 int dsa_8021q_rx_source_port(u16 vid);
-struct sk_buff *dsa_8021q_remove_header(struct sk_buff *skb);
 #else
 int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,
 	return 0;
 }
-struct sk_buff *dsa_8021q_remove_header(struct sk_buff *skb)
-{
-	return NULL;
-}
 #endif /* IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q) */
 #endif /* _NET_DSA_8021Q_H */

include/linux/file.h+1−0

@@ -85,6 +85,7 @@ extern int f_dupfd(unsigned int from, struct file *file, unsigned flags); · 84 unmodified lines
85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);	85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
86	extern void set_close_on_exec(unsigned int fd, int flag);	86	extern void set_close_on_exec(unsigned int fd, int flag);
87	extern bool get_close_on_exec(unsigned int fd);	87	extern bool get_close_on_exec(unsigned int fd);
		88	extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
88	extern int get_unused_fd_flags(unsigned flags);	89	extern int get_unused_fd_flags(unsigned flags);
89	extern void put_unused_fd(unsigned int fd);	90	extern void put_unused_fd(unsigned int fd);
90		91

include/linux/fs.h+1−0

@@ -698,6 +698,7 @@ struct inode { · 697 unmodified lines
698	struct rcu_head i_rcu;	698	struct rcu_head i_rcu;
699	};	699	};
700	atomic64_t i_version;	700	atomic64_t i_version;
		701	atomic64_t i_sequence; /* see futex */
701	atomic_t i_count;	702	atomic_t i_count;
702	atomic_t i_dio_count;	703	atomic_t i_dio_count;
703	atomic_t i_writecount;	704	atomic_t i_writecount;

include/linux/futex.h+10−7

 union futex_key {
 	struct {
+		u64 i_seq;
 		unsigned long pgoff;
-		struct inode *inode;
+		unsigned int offset;
-		int offset;
 	} shared;
 	struct {
+		union {
+			struct mm_struct *mm;
+			u64 __tmp;
+		};
 		unsigned long address;
-		struct mm_struct *mm;
+		unsigned int offset;
-		int offset;
 	} private;
 	struct {
+		u64 ptr;
 		unsigned long word;
-		void *ptr;
+		unsigned int offset;
-		int offset;
 	} both;
 };
-#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = NULL } }
+#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = 0ULL } }
 #ifdef CONFIG_FUTEX
 enum {

include/linux/genhd.h+1−12

 		!(disk->flags & GENHD_FL_NO_PART_SCAN);
 }
-static inline bool disk_has_partitions(struct gendisk *disk)
-{
-	bool ret = false;
-	rcu_read_lock();
-	if (rcu_dereference(disk->part_tbl)->len > 1)
-		ret = true;
-	rcu_read_unlock();
-	return ret;
-}
 static inline dev_t disk_devt(struct gendisk *disk)
 {
 	return MKDEV(disk->major, disk->first_minor);
 extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
 					     sector_t sector);
+bool disk_has_partitions(struct gendisk *disk);
 /*
  * Macros to operate on percpu disk statistics:

include/linux/intel-iommu.h+2−0

@@ -123,6 +123,8 @@ · 122 unmodified lines
123		123
124	#define dmar_readq(a) readq(a)	124	#define dmar_readq(a) readq(a)
125	#define dmar_writeq(a,v) writeq(v,a)	125	#define dmar_writeq(a,v) writeq(v,a)
		126	#define dmar_readl(a) readl(a)
		127	#define dmar_writel(a, v) writel(v, a)
126		128
127	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)	129	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)
128	#define DMAR_VER_MINOR(v) ((v) & 0x0f)	130	#define DMAR_VER_MINOR(v) ((v) & 0x0f)

include/linux/mmc/host.h+1−0

@@ -333,6 +333,7 @@ struct mmc_host { · 332 unmodified lines
333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \	333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \
334	MMC_CAP_UHS_DDR50)	334	MMC_CAP_UHS_DDR50)
335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */	335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */
		336	#define MMC_CAP_NEED_RSP_BUSY (1 << 22) /* Commands with R1B can't use R1. */
336	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */	337	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */
337	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */	338	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */
338	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */	339	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */

include/linux/netlink.h+13−0

@@ -115,6 +115,19 @@ static inline void nl_set_extack_cookie_u64(struct netlink_ext_ack *extack, · 114 unmodified lines
115	{	115	{
116	u64 __cookie = cookie;	116	u64 __cookie = cookie;
117		117
		118	if (!extack)
		119	return;
		120	memcpy(extack->cookie, &__cookie, sizeof(__cookie));
		121	extack->cookie_len = sizeof(__cookie);
		122	}
		123
		124	static inline void nl_set_extack_cookie_u32(struct netlink_ext_ack *extack,
		125	u32 cookie)
		126	{
		127	u32 __cookie = cookie;
		128
		129	if (!extack)
		130	return;
118	memcpy(extack->cookie, &__cookie, sizeof(__cookie));	131	memcpy(extack->cookie, &__cookie, sizeof(__cookie));
119	extack->cookie_len = sizeof(__cookie);	132	extack->cookie_len = sizeof(__cookie);
120	}	133	}

include/linux/of_clk.h+4−4

@@ -11,17 +11,17 @@ struct of_device_id; · 10 unmodified lines
11		11
12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)	12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)
13		13
14	unsigned int of_clk_get_parent_count(struct device_node *np);	14	unsigned int of_clk_get_parent_count(const struct device_node *np);
15	const char of_clk_get_parent_name(struct device_node np, int index);	15	const char of_clk_get_parent_name(const struct device_node np, int index);
16	void of_clk_init(const struct of_device_id *matches);	16	void of_clk_init(const struct of_device_id *matches);
17		17
18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */	18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */
19		19
20	static inline unsigned int of_clk_get_parent_count(struct device_node *np)	20	static inline unsigned int of_clk_get_parent_count(const struct device_node *np)
21	{	21	{
22	return 0;	22	return 0;
23	}	23	}
24	static inline const char of_clk_get_parent_name(struct device_node np,	24	static inline const char of_clk_get_parent_name(const struct device_node np,
25	int index)	25	int index)
26	{	26	{
27	return NULL;	27	return NULL;

include/linux/page-flags.h+1−1

@@ -311,7 +311,7 @@ static inline int TestClearPage##uname(struct page *page) { return 0; } · 310 unmodified lines
311		311
312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)	312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)
313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)	313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)
314	PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)	314	PAGEFLAG(Error, error, PF_NO_TAIL) TESTCLEARFLAG(Error, error, PF_NO_TAIL)
315	PAGEFLAG(Referenced, referenced, PF_HEAD)	315	PAGEFLAG(Referenced, referenced, PF_HEAD)
316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)	316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)	317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)

include/linux/skbuff.h+32−4

@@ -645,8 +645,8 @@ typedef unsigned char *sk_buff_data_t; · 644 unmodified lines
645	* @offload_l3_fwd_mark: Packet was L3-forwarded in hardware	645	* @offload_l3_fwd_mark: Packet was L3-forwarded in hardware
646	* @tc_skip_classify: do not classify packet. set by IFB device	646	* @tc_skip_classify: do not classify packet. set by IFB device
647	* @tc_at_ingress: used within tc_classify to distinguish in/egress	647	* @tc_at_ingress: used within tc_classify to distinguish in/egress
648	* @tc_redirected: packet was redirected by a tc action	648	* @redirected: packet was redirected by packet classifier
649	* @tc_from_ingress: if tc_redirected, tc_at_ingress at time of redirect	649	* @from_ingress: packet was redirected from the ingress path
650	* @peeked: this packet has been seen already, so stats have been	650	* @peeked: this packet has been seen already, so stats have been
651	* done for it, don't do them again	651	* done for it, don't do them again
652	* @nf_trace: netfilter packet trace flag	652	* @nf_trace: netfilter packet trace flag
@@ -848,8 +848,10 @@ struct sk_buff { · 195 unmodified lines
848	#ifdef CONFIG_NET_CLS_ACT	848	#ifdef CONFIG_NET_CLS_ACT
849	__u8 tc_skip_classify:1;	849	__u8 tc_skip_classify:1;
850	__u8 tc_at_ingress:1;	850	__u8 tc_at_ingress:1;
851	__u8 tc_redirected:1;	851	#endif
852	__u8 tc_from_ingress:1;	852	#ifdef CONFIG_NET_REDIRECT
		853	__u8 redirected:1;
		854	__u8 from_ingress:1;
853	#endif	855	#endif
854	#ifdef CONFIG_TLS_DEVICE	856	#ifdef CONFIG_TLS_DEVICE
855	__u8 decrypted:1;	857	__u8 decrypted:1;
@@ -4571,5 +4573,31 @@ static inline __wsum lco_csum(struct sk_buff *skb) · 3715 unmodified lines
4571	return csum_partial(l4_hdr, csum_start - l4_hdr, partial);	4573	return csum_partial(l4_hdr, csum_start - l4_hdr, partial);
4572	}	4574	}
4573		4575
		4576	static inline bool skb_is_redirected(const struct sk_buff *skb)
		4577	{
		4578	#ifdef CONFIG_NET_REDIRECT
		4579	return skb->redirected;
		4580	#else
		4581	return false;
		4582	#endif
		4583	}
		4584
		4585	static inline void skb_set_redirected(struct sk_buff *skb, bool from_ingress)
		4586	{
		4587	#ifdef CONFIG_NET_REDIRECT
		4588	skb->redirected = 1;
		4589	skb->from_ingress = from_ingress;
		4590	if (skb->from_ingress)
		4591	skb->tstamp = 0;
		4592	#endif
		4593	}
		4594
		4595	static inline void skb_reset_redirect(struct sk_buff *skb)
		4596	{
		4597	#ifdef CONFIG_NET_REDIRECT
		4598	skb->redirected = 0;
		4599	#endif
		4600	}
		4601
4574	#endif /* __KERNEL__ */	4602	#endif /* __KERNEL__ */
4575	#endif /* _LINUX_SKBUFF_H */	4603	#endif /* _LINUX_SKBUFF_H */

include/linux/socket.h+2−1

 			int addr_len);
 extern int __sys_accept4_file(struct file *file, unsigned file_flags,
 			struct sockaddr __user *upeer_sockaddr,
-			 int __user *upeer_addrlen, int flags);
+			 int __user *upeer_addrlen, int flags,
+			 unsigned long nofile);
 extern int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
 			 int __user *upeer_addrlen, int flags);
 extern int __sys_socket(int family, int type, int protocol);

include/linux/vmalloc.h+3−2

@@ -141,8 +141,9 @@ extern int remap_vmalloc_range_partial(struct vm_area_struct *vma, · 140 unmodified lines
141		141
142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,	142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,
143	unsigned long pgoff);	143	unsigned long pgoff);
144	void vmalloc_sync_all(void);	144	void vmalloc_sync_mappings(void);
145		145	void vmalloc_sync_unmappings(void);
		146
146	/*	147	/*
147	* Lowlevel-APIs (not for driver use!)	148	* Lowlevel-APIs (not for driver use!)
148	*/	149	*/

include/net/af_rxrpc.h+8−4

 struct socket;
 struct rxrpc_call;
+enum rxrpc_interruptibility {
+	RXRPC_INTERRUPTIBLE,	/* Call is interruptible */
+	RXRPC_PREINTERRUPTIBLE,	/* Call can be cancelled whilst waiting for a slot */
+	RXRPC_UNINTERRUPTIBLE,	/* Call should not be interruptible at all */
+};
 /*
  * Debug ID counter for tracing.
  */
 					   gfp_t,
 					   rxrpc_notify_rx_t,
 					   bool,
-					   bool,
+					   enum rxrpc_interruptibility,
 					   unsigned int);
 int rxrpc_kernel_send_data(struct socket *, struct rxrpc_call *,
 			   struct msghdr *, size_t,
 			       rxrpc_user_attach_call_t, unsigned long, gfp_t,
 			       unsigned int);
 void rxrpc_kernel_set_tx_length(struct socket *, struct rxrpc_call *, s64);
-bool rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *,
+bool rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *);
-			     u32 *);
-void rxrpc_kernel_probe_life(struct socket *, struct rxrpc_call *);
 u32 rxrpc_kernel_get_epoch(struct socket *, struct rxrpc_call *);
 bool rxrpc_kernel_get_reply_time(struct socket *, struct rxrpc_call *,
 				 ktime_t *);

include/net/sch_generic.h+0−16

@@ -675,22 +675,6 @@ void __qdisc_calculate_pkt_len(struct sk_buff *skb, · 674 unmodified lines
675	const struct qdisc_size_table *stab);	675	const struct qdisc_size_table *stab);
676	int skb_do_redirect(struct sk_buff *);	676	int skb_do_redirect(struct sk_buff *);
677		677
678	static inline void skb_reset_tc(struct sk_buff *skb)
679	{
680	#ifdef CONFIG_NET_CLS_ACT
681	skb->tc_redirected = 0;
682	#endif
683	}
684
685	static inline bool skb_is_tc_redirected(const struct sk_buff *skb)
686	{
687	#ifdef CONFIG_NET_CLS_ACT
688	return skb->tc_redirected;
689	#else
690	return false;
691	#endif
692	}
693
694	static inline bool skb_at_tc_ingress(const struct sk_buff *skb)	678	static inline bool skb_at_tc_ingress(const struct sk_buff *skb)
695	{	679	{
696	#ifdef CONFIG_NET_CLS_ACT	680	#ifdef CONFIG_NET_CLS_ACT

include/trace/events/afs.h+1−1

@@ -233,7 +233,7 @@ enum afs_cb_break_reason { · 232 unmodified lines
233	EM(afs_call_trace_get, "GET ") \	233	EM(afs_call_trace_get, "GET ") \
234	EM(afs_call_trace_put, "PUT ") \	234	EM(afs_call_trace_put, "PUT ") \
235	EM(afs_call_trace_wake, "WAKE ") \	235	EM(afs_call_trace_wake, "WAKE ") \
236	E_(afs_call_trace_work, "WORK ")	236	E_(afs_call_trace_work, "QUEUE")
237		237
238	#define afs_server_traces \	238	#define afs_server_traces \
239	EM(afs_server_trace_alloc, "ALLOC ") \	239	EM(afs_server_trace_alloc, "ALLOC ") \

init/Kconfig+1−2

@@ -767,8 +767,7 @@ config ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH · 766 unmodified lines
767	bool	767	bool
768		768
769	config CC_HAS_INT128	769	config CC_HAS_INT128
770	def_bool y	770	def_bool !$(cc-option,$(m64-flag) -D__SIZEOF_INT128__=0) && 64BIT
771	depends on !$(cc-option,-D__SIZEOF_INT128__=0)
772		771
773	#	772	#
774	# For architectures that know their GCC __int128 support is sound	773	# For architectures that know their GCC __int128 support is sound

kernel/bpf/bpf_struct_ops.c+11−3

 	prev_state = cmpxchg(&st_map->kvalue.state,
 			     BPF_STRUCT_OPS_STATE_INUSE,
 			     BPF_STRUCT_OPS_STATE_TOBEFREE);
-	if (prev_state == BPF_STRUCT_OPS_STATE_INUSE) {
+	switch (prev_state) {
+	case BPF_STRUCT_OPS_STATE_INUSE:
 		st_map->st_ops->unreg(&st_map->kvalue.data);
 		if (refcount_dec_and_test(&st_map->kvalue.refcnt))
 			bpf_map_put(map);
+		return 0;
+	case BPF_STRUCT_OPS_STATE_TOBEFREE:
+		return -EINPROGRESS;
+	case BPF_STRUCT_OPS_STATE_INIT:
+		return -ENOENT;
+	default:
+		WARN_ON_ONCE(1);
+		/* Should never happen.  Treat it as not found. */
+		return -ENOENT;
 	}
-	return 0;
 }
 static void bpf_struct_ops_map_seq_show_elem(struct bpf_map *map, void *key,

kernel/bpf/btf.c+1−1

@@ -2418,7 +2418,7 @@ static int btf_enum_check_member(struct btf_verifier_env *env, · 2417 unmodified lines
2418		2418
2419	struct_size = struct_type->size;	2419	struct_size = struct_type->size;
2420	bytes_offset = BITS_ROUNDDOWN_BYTES(struct_bits_off);	2420	bytes_offset = BITS_ROUNDDOWN_BYTES(struct_bits_off);
2421	if (struct_size - bytes_offset < sizeof(int)) {	2421	if (struct_size - bytes_offset < member_type->size) {
2422	btf_verifier_log_member(env, struct_type, member,	2422	btf_verifier_log_member(env, struct_type, member,
2423	"Member exceeds struct_size");	2423	"Member exceeds struct_size");
2424	return -EINVAL;	2424	return -EINVAL;

kernel/bpf/cgroup.c+5−2

 	for (i = 0; i < NR; i++)
 		bpf_prog_array_free(arrays[i]);
+	for (p = cgroup_parent(cgrp); p; p = cgroup_parent(p))
+		cgroup_bpf_put(p);
 	percpu_ref_exit(&cgrp->bpf.refcnt);
 	return -ENOMEM;
 	u32 saved_flags = (flags & (BPF_F_ALLOW_OVERRIDE | BPF_F_ALLOW_MULTI));
 	struct list_head *progs = &cgrp->bpf.progs[type];
 	struct bpf_prog *old_prog = NULL;
-	struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE],
+	struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE] = {};
-		*old_storage[MAX_BPF_CGROUP_STORAGE_TYPE] = {NULL};
+	struct bpf_cgroup_storage *old_storage[MAX_BPF_CGROUP_STORAGE_TYPE] = {};
 	struct bpf_prog_list *pl, *replace_pl = NULL;
 	enum bpf_cgroup_storage_type stype;
 	int err;

kernel/bpf/syscall.c+5−0

 	if (IS_ERR(map))
 		return PTR_ERR(map);
+	if (map->map_type == BPF_MAP_TYPE_STRUCT_OPS) {
+		fdput(f);
+		return -ENOTSUPP;
+	}
 	mutex_lock(&map->freeze_mutex);
 	if (map->writecnt) {

kernel/futex.c+55−38

  */
 static struct futex_hash_bucket *hash_futex(union futex_key *key)
 {
-	u32 hash = jhash2((u32*)&key->both.word,
+	u32 hash = jhash2((u32 *)key, offsetof(typeof(*key), both.offset) / 4,
-			  (sizeof(key->both.word)+sizeof(key->both.ptr))/4,
 			  key->both.offset);
 	return &futex_queues[hash & (futex_hashsize - 1)];
 }
 	switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
 	case FUT_OFF_INODE:
-		ihold(key->shared.inode); /* implies smp_mb(); (B) */
+		smp_mb();		/* explicit smp_mb(); (B) */
 		break;
 	case FUT_OFF_MMSHARED:
 		futex_get_mm(key); /* implies smp_mb(); (B) */
 	switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
 	case FUT_OFF_INODE:
-		iput(key->shared.inode);
 		break;
 	case FUT_OFF_MMSHARED:
 		mmdrop(key->private.mm);
 	return timeout;
 }
+/*
+ * Generate a machine wide unique identifier for this inode.
+ *
+ * This relies on u64 not wrapping in the life-time of the machine; which with
+ * 1ns resolution means almost 585 years.
+ *
+ * This further relies on the fact that a well formed program will not unmap
+ * the file while it has a (shared) futex waiting on it. This mapping will have
+ * a file reference which pins the mount and inode.
+ *
+ * If for some reason an inode gets evicted and read back in again, it will get
+ * a new sequence number and will _NOT_ match, even though it is the exact same
+ * file.
+ *
+ * It is important that match_futex() will never have a false-positive, esp.
+ * for PI futexes that can mess up the state. The above argues that false-negatives
+ * are only possible for malformed programs.
+ */
+static u64 get_inode_sequence_number(struct inode *inode)
+{
+	static atomic64_t i_seq;
+	u64 old;
+	/* Does the inode already have a sequence number? */
+	old = atomic64_read(&inode->i_sequence);
+	if (likely(old))
+		return old;
+	for (;;) {
+		u64 new = atomic64_add_return(1, &i_seq);
+		if (WARN_ON_ONCE(!new))
+			continue;
+		old = atomic64_cmpxchg_relaxed(&inode->i_sequence, 0, new);
+		if (old)
+			return old;
+		return new;
+	}
+}
 /**
  * get_futex_key() - Get parameters which are the keys for a futex
  * @uaddr:	virtual address of the futex
  *
  * The key words are stored in @key on success.
  *
- * For shared mappings, it's (page->index, file_inode(vma->vm_file),
+ * For shared mappings (when @fshared), the key is:
- * offset_within_page).  For private mappings, it's (uaddr, current->mm).
+ *   ( inode->i_sequence, page->index, offset_within_page )
- * We can usually work out the index without swapping in the page.
+ * [ also see get_inode_sequence_number() ]
+ *
+ * For private mappings (or when !@fshared), the key is:
+ *   ( current->mm, address, 0 )
+ *
+ * This allows (cross process, where applicable) identification of the futex
+ * without keeping the page pinned for the duration of the FUTEX_WAIT.
  *
  * lock_page() might sleep, the caller should not hold a spinlock.
  */
 		key->private.mm = mm;
 		key->private.address = address;
-		get_futex_key_refs(key); /* implies smp_mb(); (B) */
 	} else {
 		struct inode *inode;
 			goto again;
 		}
-		/*
-		 * Take a reference unless it is about to be freed. Previously
-		 * this reference was taken by ihold under the page lock
-		 * pinning the inode in place so i_lock was unnecessary. The
-		 * only way for this check to fail is if the inode was
-		 * truncated in parallel which is almost certainly an
-		 * application bug. In such a case, just retry.
-		 *
-		 * We are not calling into get_futex_key_refs() in file-backed
-		 * cases, therefore a successful atomic_inc return below will
-		 * guarantee that get_futex_key() will still imply smp_mb(); (B).
-		 */
-		if (!atomic_inc_not_zero(&inode->i_count)) {
-			rcu_read_unlock();
-			put_page(page);
-			goto again;
-		}
-		/* Should be impossible but lets be paranoid for now */
-		if (WARN_ON_ONCE(inode->i_mapping != mapping)) {
-			err = -EFAULT;
-			rcu_read_unlock();
-			iput(inode);
-			goto out;
-		}
 		key->both.offset |= FUT_OFF_INODE; /* inode-based key */
-		key->shared.inode = inode;
+		key->shared.i_seq = get_inode_sequence_number(inode);
 		key->shared.pgoff = basepage_index(tail);
 		rcu_read_unlock();
 	}
+	get_futex_key_refs(key); /* implies smp_mb(); (B) */
 out:
 	put_page(page);
 	return err;

kernel/notifier.c+1−1

@@ -519,7 +519,7 @@ NOKPROBE_SYMBOL(notify_die); · 518 unmodified lines
519		519
520	int register_die_notifier(struct notifier_block *nb)	520	int register_die_notifier(struct notifier_block *nb)
521	{	521	{
522	vmalloc_sync_all();	522	vmalloc_sync_mappings();
523	return atomic_notifier_chain_register(&die_chain, nb);	523	return atomic_notifier_chain_register(&die_chain, nb);
524	}	524	}
525	EXPORT_SYMBOL_GPL(register_die_notifier);	525	EXPORT_SYMBOL_GPL(register_die_notifier);

kernel/sys.c+2−0

 #include <linux/syscalls.h>
 #include <linux/kprobes.h>
 #include <linux/user_namespace.h>
+#include <linux/time_namespace.h>
 #include <linux/binfmts.h>
 #include <linux/sched.h>
 	memset(info, 0, sizeof(struct sysinfo));
 	ktime_get_boottime_ts64(&tp);
+	timens_add_boottime(&tp);
 	info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
 	get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);

kernel/trace/bpf_trace.c+1−1

@@ -730,7 +730,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type) · 729 unmodified lines
730	if (unlikely(!nmi_uaccess_okay()))	730	if (unlikely(!nmi_uaccess_okay()))
731	return -EPERM;	731	return -EPERM;
732		732
733	if (in_nmi()) {	733	if (irqs_disabled()) {
734	/* Do an early check on signal validity. Otherwise,	734	/* Do an early check on signal validity. Otherwise,
735	* the error is lost in deferred irq_work.	735	* the error is lost in deferred irq_work.
736	*/	736	*/

lib/crypto/chacha20poly1305-selftest.c+8−3

 	     && total_len <= 1 << 10; ++total_len) {
 		for (i = 0; i <= total_len; ++i) {
 			for (j = i; j <= total_len; ++j) {
+				k = 0;
 				sg_init_table(sg_src, 3);
-				sg_set_buf(&sg_src[0], input, i);
+				if (i)
-				sg_set_buf(&sg_src[1], input + i, j - i);
+					sg_set_buf(&sg_src[k++], input, i);
-				sg_set_buf(&sg_src[2], input + j, total_len - j);
+				if (j - i)
+					sg_set_buf(&sg_src[k++], input + i, j - i);
+				if (total_len - j)
+					sg_set_buf(&sg_src[k++], input + j, total_len - j);
+				sg_init_marker(sg_src, k);
 				memset(computed_output, 0, total_len);
 				memset(input, 0, total_len);

mm/madvise.c+9−3

 		}
 		page = pmd_page(orig_pmd);
+		/* Do not interfere with other mappings of this page */
+		if (page_mapcount(page) != 1)
+			goto huge_unlock;
 		if (next - addr != HPAGE_PMD_SIZE) {
 			int err;
-			if (page_mapcount(page) != 1)
-				goto huge_unlock;
 			get_page(page);
 			spin_unlock(ptl);
 			lock_page(page);
 			continue;
 		}
+		/* Do not interfere with other mappings of this page */
+		if (page_mapcount(page) != 1)
+			continue;
 		VM_BUG_ON_PAGE(PageTransCompound(page), page);
 		if (pte_young(ptent)) {

mm/memcontrol.c+66−37

@@ -2297,28 +2297,41 @@ static void high_work_func(struct work_struct *work) · 2296 unmodified lines
2297	#define MEMCG_DELAY_SCALING_SHIFT 14	2297	#define MEMCG_DELAY_SCALING_SHIFT 14
2298		2298
2299	/*	2299	/*
2300	* Scheduled by try_charge() to be executed from the userland return path	2300	* Get the number of jiffies that we should penalise a mischievous cgroup which
2301	* and reclaims memory over the high limit.	2301	* is exceeding its memory.high by checking both it and its ancestors.
2302	*/	2302	*/
2303	void mem_cgroup_handle_over_high(void)	2303	static unsigned long calculate_high_delay(struct mem_cgroup *memcg,
		2304	unsigned int nr_pages)
2304	{	2305	{
2305	unsigned long usage, high, clamped_high;	2306	unsigned long penalty_jiffies;
2306	unsigned long pflags;	2307	u64 max_overage = 0;
2307	unsigned long penalty_jiffies, overage;
2308	unsigned int nr_pages = current->memcg_nr_pages_over_high;
2309	struct mem_cgroup *memcg;
2310		2308
2311	if (likely(!nr_pages))	2309	do {
2312	return;	2310	unsigned long usage, high;
		2311	u64 overage;
2313		2312
2314	memcg = get_mem_cgroup_from_mm(current->mm);	2313	usage = page_counter_read(&memcg->memory);
2315	reclaim_high(memcg, nr_pages, GFP_KERNEL);	2314	high = READ_ONCE(memcg->high);
2316	current->memcg_nr_pages_over_high = 0;	2315
		2316	/*
		2317	* Prevent division by 0 in overage calculation by acting as if
		2318	* it was a threshold of 1 page
		2319	*/
		2320	high = max(high, 1UL);
		2321
		2322	overage = usage - high;
		2323	overage <<= MEMCG_DELAY_PRECISION_SHIFT;
		2324	overage = div64_u64(overage, high);
		2325
		2326	if (overage > max_overage)
		2327	max_overage = overage;
		2328	} while ((memcg = parent_mem_cgroup(memcg)) &&
		2329	!mem_cgroup_is_root(memcg));
		2330
		2331	if (!max_overage)
		2332	return 0;
2317		2333
2318	/*	2334	/*
2319	* memory.high is breached and reclaim is unable to keep up. Throttle
2320	* allocators proactively to slow down excessive growth.
2321	*
2322	* We use overage compared to memory.high to calculate the number of	2335	* We use overage compared to memory.high to calculate the number of
2323	* jiffies to sleep (penalty_jiffies). Ideally this value should be	2336	* jiffies to sleep (penalty_jiffies). Ideally this value should be
2324	* fairly lenient on small overages, and increasingly harsh when the	2337	* fairly lenient on small overages, and increasingly harsh when the
@@ -2326,24 +2339,9 @@ void mem_cgroup_handle_over_high(void) · 1 unmodified line
2326	* its crazy behaviour, so we exponentially increase the delay based on	2339	* its crazy behaviour, so we exponentially increase the delay based on
2327	* overage amount.	2340	* overage amount.
2328	*/	2341	*/
2329		2342	penalty_jiffies = max_overage * max_overage * HZ;
2330	usage = page_counter_read(&memcg->memory);	2343	penalty_jiffies >>= MEMCG_DELAY_PRECISION_SHIFT;
2331	high = READ_ONCE(memcg->high);	2344	penalty_jiffies >>= MEMCG_DELAY_SCALING_SHIFT;
2332
2333	if (usage <= high)
2334	goto out;
2335
2336	/*
2337	* Prevent division by 0 in overage calculation by acting as if it was a
2338	* threshold of 1 page
2339	*/
2340	clamped_high = max(high, 1UL);
2341
2342	overage = div_u64((u64)(usage - high) << MEMCG_DELAY_PRECISION_SHIFT,
2343	clamped_high);
2344
2345	penalty_jiffies = ((u64)overage * overage * HZ)
2346	>> (MEMCG_DELAY_PRECISION_SHIFT + MEMCG_DELAY_SCALING_SHIFT);
2347		2345
2348	/*	2346	/*
2349	* Factor in the task's own contribution to the overage, such that four	2347	* Factor in the task's own contribution to the overage, such that four
@@ -2360,7 +2358,32 @@ void mem_cgroup_handle_over_high(void) · 10 unmodified lines
2360	* application moving forwards and also permit diagnostics, albeit	2358	* application moving forwards and also permit diagnostics, albeit
2361	* extremely slowly.	2359	* extremely slowly.
2362	*/	2360	*/
2363	penalty_jiffies = min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);	2361	return min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);
		2362	}
		2363
		2364	/*
		2365	* Scheduled by try_charge() to be executed from the userland return path
		2366	* and reclaims memory over the high limit.
		2367	*/
		2368	void mem_cgroup_handle_over_high(void)
		2369	{
		2370	unsigned long penalty_jiffies;
		2371	unsigned long pflags;
		2372	unsigned int nr_pages = current->memcg_nr_pages_over_high;
		2373	struct mem_cgroup *memcg;
		2374
		2375	if (likely(!nr_pages))
		2376	return;
		2377
		2378	memcg = get_mem_cgroup_from_mm(current->mm);
		2379	reclaim_high(memcg, nr_pages, GFP_KERNEL);
		2380	current->memcg_nr_pages_over_high = 0;
		2381
		2382	/*
		2383	* memory.high is breached and reclaim is unable to keep up. Throttle
		2384	* allocators proactively to slow down excessive growth.
		2385	*/
		2386	penalty_jiffies = calculate_high_delay(memcg, nr_pages);
2364		2387
2365	/*	2388	/*
2366	* Don't sleep if the amount of jiffies this memcg owes us is so low	2389	* Don't sleep if the amount of jiffies this memcg owes us is so low
@@ -4027,7 +4050,7 @@ static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg, · 1660 unmodified lines
4027	struct mem_cgroup_thresholds *thresholds;	4050	struct mem_cgroup_thresholds *thresholds;
4028	struct mem_cgroup_threshold_ary *new;	4051	struct mem_cgroup_threshold_ary *new;
4029	unsigned long usage;	4052	unsigned long usage;
4030	int i, j, size;	4053	int i, j, size, entries;
4031		4054
4032	mutex_lock(&memcg->thresholds_lock);	4055	mutex_lock(&memcg->thresholds_lock);
4033		4056
@@ -4047,14 +4070,20 @@ static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg, · 13 unmodified lines
4047	__mem_cgroup_threshold(memcg, type == _MEMSWAP);	4070	__mem_cgroup_threshold(memcg, type == _MEMSWAP);
4048		4071
4049	/* Calculate new number of threshold */	4072	/* Calculate new number of threshold */
4050	size = 0;	4073	size = entries = 0;
4051	for (i = 0; i < thresholds->primary->size; i++) {	4074	for (i = 0; i < thresholds->primary->size; i++) {
4052	if (thresholds->primary->entries[i].eventfd != eventfd)	4075	if (thresholds->primary->entries[i].eventfd != eventfd)
4053	size++;	4076	size++;
		4077	else
		4078	entries++;
4054	}	4079	}
4055		4080
4056	new = thresholds->spare;	4081	new = thresholds->spare;
4057		4082
		4083	/* If no items related to eventfd have been cleared, nothing to do */
		4084	if (!entries)
		4085	goto unlock;
		4086
4058	/* Set thresholds array to NULL if we don't have thresholds */	4087	/* Set thresholds array to NULL if we don't have thresholds */
4059	if (!size) {	4088	if (!size) {
4060	kfree(new);	4089	kfree(new);

mm/mmu_notifier.c+18−9

 	 * ->release returns.
 	 */
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist)
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu))
 		/*
 		 * If ->release runs before mmu_notifier_unregister it must be
 		 * handled, as it's the only way for the driver to flush all
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->clear_flush_young)
 			young |= subscription->ops->clear_flush_young(
 				subscription, mm, start, end);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->clear_young)
 			young |= subscription->ops->clear_young(subscription,
 								mm, start, end);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->test_young) {
 			young = subscription->ops->test_young(subscription, mm,
 							      address);
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->change_pte)
 			subscription->ops->change_pte(subscription, mm, address,
 						      pte);
 	int id;
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist) {
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		const struct mmu_notifier_ops *ops = subscription->ops;
 		if (ops->invalidate_range_start) {
 	int id;
 	id = srcu_read_lock(&srcu);
-	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist) {
+	hlist_for_each_entry_rcu(subscription, &subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		/*
 		 * Call invalidate_range here too to avoid the need for the
 		 * subsystem of having to register an invalidate_range_end
 	id = srcu_read_lock(&srcu);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 srcu_read_lock_held(&srcu)) {
 		if (subscription->ops->invalidate_range)
 			subscription->ops->invalidate_range(subscription, mm,
 							    start, end);
 	spin_lock(&mm->notifier_subscriptions->lock);
 	hlist_for_each_entry_rcu(subscription,
-				 &mm->notifier_subscriptions->list, hlist) {
+				 &mm->notifier_subscriptions->list, hlist,
+				 lockdep_is_held(&mm->notifier_subscriptions->lock)) {
 		if (subscription->ops != ops)
 			continue;

mm/nommu.c+7−3

 EXPORT_SYMBOL_GPL(vm_unmap_aliases);
 /*
- * Implement a stub for vmalloc_sync_all() if the architecture chose not to
+ * Implement a stub for vmalloc_sync_[un]mapping() if the architecture
- * have one.
+ * chose not to have one.
  */
-void __weak vmalloc_sync_all(void)
+void __weak vmalloc_sync_mappings(void)
+{
+}
+void __weak vmalloc_sync_unmappings(void)
 {
 }

mm/slub.c+30−11

@@ -1973,8 +1973,6 @@ static void get_partial(struct kmem_cache s, gfp_t flags, int node, · 1972 unmodified lines
1973		1973
1974	if (node == NUMA_NO_NODE)	1974	if (node == NUMA_NO_NODE)
1975	searchnode = numa_mem_id();	1975	searchnode = numa_mem_id();
1976	else if (!node_present_pages(node))
1977	searchnode = node_to_mem_node(node);
1978		1976
1979	object = get_partial_node(s, get_node(s, searchnode), c, flags);	1977	object = get_partial_node(s, get_node(s, searchnode), c, flags);
1980	if (object \|\| node != NUMA_NO_NODE)	1978	if (object \|\| node != NUMA_NO_NODE)
@@ -2563,17 +2561,27 @@ static void ___slab_alloc(struct kmem_cache s, gfp_t gfpflags, int node, · 582 unmodified lines
2563	struct page *page;	2561	struct page *page;
2564		2562
2565	page = c->page;	2563	page = c->page;
2566	if (!page)	2564	if (!page) {
		2565	/*
		2566	* if the node is not online or has no normal memory, just
		2567	* ignore the node constraint
		2568	*/
		2569	if (unlikely(node != NUMA_NO_NODE &&
		2570	!node_state(node, N_NORMAL_MEMORY)))
		2571	node = NUMA_NO_NODE;
2567	goto new_slab;	2572	goto new_slab;
		2573	}
2568	redo:	2574	redo:
2569		2575
2570	if (unlikely(!node_match(page, node))) {	2576	if (unlikely(!node_match(page, node))) {
2571	int searchnode = node;	2577	/*
2572		2578	* same as above but node_match() being false already
2573	if (node != NUMA_NO_NODE && !node_present_pages(node))	2579	* implies node != NUMA_NO_NODE
2574	searchnode = node_to_mem_node(node);	2580	*/
2575		2581	if (!node_state(node, N_NORMAL_MEMORY)) {
2576	if (unlikely(!node_match(page, searchnode))) {	2582	node = NUMA_NO_NODE;
		2583	goto redo;
		2584	} else {
2577	stat(s, ALLOC_NODE_MISMATCH);	2585	stat(s, ALLOC_NODE_MISMATCH);
2578	deactivate_slab(s, page, c->freelist, c);	2586	deactivate_slab(s, page, c->freelist, c);
2579	goto new_slab;	2587	goto new_slab;
@@ -2997,11 +3005,13 @@ redo: · 417 unmodified lines
2997	barrier();	3005	barrier();
2998		3006
2999	if (likely(page == c->page)) {	3007	if (likely(page == c->page)) {
3000	set_freepointer(s, tail_obj, c->freelist);	3008	void **freelist = READ_ONCE(c->freelist);
		3009
		3010	set_freepointer(s, tail_obj, freelist);
3001		3011
3002	if (unlikely(!this_cpu_cmpxchg_double(	3012	if (unlikely(!this_cpu_cmpxchg_double(
3003	s->cpu_slab->freelist, s->cpu_slab->tid,	3013	s->cpu_slab->freelist, s->cpu_slab->tid,
3004	c->freelist, tid,	3014	freelist, tid,
3005	head, next_tid(tid)))) {	3015	head, next_tid(tid)))) {
3006		3016
3007	note_cmpxchg_failure("slab_free", s, tid);	3017	note_cmpxchg_failure("slab_free", s, tid);
@@ -3174,6 +3184,15 @@ int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size, · 166 unmodified lines
3174	void *object = c->freelist;	3184	void *object = c->freelist;
3175		3185
3176	if (unlikely(!object)) {	3186	if (unlikely(!object)) {
		3187	/*
		3188	* We may have removed an object from c->freelist using
		3189	* the fastpath in the previous iteration; in that case,
		3190	* c->tid has not been bumped yet.
		3191	* Since ___slab_alloc() may reenable interrupts while
		3192	* allocating memory, we should bump c->tid now.
		3193	*/
		3194	c->tid = next_tid(c->tid);
		3195
3177	/*	3196	/*
3178	* Invoking slow path likely have side-effect	3197	* Invoking slow path likely have side-effect
3179	* of re-populating per CPU c->freelist	3198	* of re-populating per CPU c->freelist

mm/sparse.c+6−2

 	struct mem_section *ms = __pfn_to_section(pfn);
 	bool section_is_early = early_section(ms);
 	struct page *memmap = NULL;
+	bool empty;
 	unsigned long *subsection_map = ms->usage
 		? &ms->usage->subsection_map[0] : NULL;
 	 * For 2/ and 3/ the SPARSEMEM_VMEMMAP={y,n} cases are unified
 	 */
 	bitmap_xor(subsection_map, map, subsection_map, SUBSECTIONS_PER_SECTION);
-	if (bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION)) {
+	empty = bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION);
+	if (empty) {
 		unsigned long section_nr = pfn_to_section_nr(pfn);
 		/*
 			ms->usage = NULL;
 		}
 		memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);
-		ms->section_mem_map = (unsigned long)NULL;
 	}
 	if (section_is_early && memmap)
 		free_map_bootmem(memmap);
 	else
 		depopulate_section_memmap(pfn, nr_pages, altmap);
+	if (empty)
+		ms->section_mem_map = (unsigned long)NULL;
 }
 static struct page * __meminit section_activate(int nid, unsigned long pfn,

mm/vmalloc.c+7−4

 	 * First make sure the mappings are removed from all page-tables
 	 * before they are freed.
 	 */
-	vmalloc_sync_all();
+	vmalloc_sync_unmappings();
 	/*
 	 * TODO: to calculate a flush range without looping.
 EXPORT_SYMBOL(remap_vmalloc_range);
 /*
- * Implement a stub for vmalloc_sync_all() if the architecture chose not to
+ * Implement stubs for vmalloc_sync_[un]mappings () if the architecture chose
- * have one.
+ * not to have one.
  *
  * The purpose of this function is to make sure the vmalloc area
  * mappings are identical in all page-tables in the system.
  */
-void __weak vmalloc_sync_all(void)
+void __weak vmalloc_sync_mappings(void)
 {
 }
+void __weak vmalloc_sync_unmappings(void)
+{
+}
 static int f(pte_t *pte, unsigned long addr, void *data)
 {

net/Kconfig+3−0

@@ -52,6 +52,9 @@ config NET_INGRESS · 51 unmodified lines
52	config NET_EGRESS	52	config NET_EGRESS
53	bool	53	bool
54		54
		55	config NET_REDIRECT
		56	bool
		57
55	config SKB_EXTENSIONS	58	config SKB_EXTENSIONS
56	bool	59	bool
57		60

net/bpfilter/main.c+8−6

 #include <asm/unistd.h>
 #include "msgfmt.h"
-int debug_fd;
+FILE *debug_f;
 static int handle_get_cmd(struct mbox_request *cmd)
 {
 		struct mbox_reply reply;
 		int n;
+		fprintf(debug_f, "testing the buffer\n");
 		n = read(0, &req, sizeof(req));
 		if (n != sizeof(req)) {
-			dprintf(debug_fd, "invalid request %d\n", n);
+			fprintf(debug_f, "invalid request %d\n", n);
 			return;
 		}
 		n = write(1, &reply, sizeof(reply));
 		if (n != sizeof(reply)) {
-			dprintf(debug_fd, "reply failed %d\n", n);
+			fprintf(debug_f, "reply failed %d\n", n);
 			return;
 		}
 	}
 int main(void)
 {
-	debug_fd = open("/dev/kmsg", 00000002);
+	debug_f = fopen("/dev/kmsg", "w");
-	dprintf(debug_fd, "Started bpfilter\n");
+	setvbuf(debug_f, 0, _IOLBF, 0);
+	fprintf(debug_f, "Started bpfilter\n");
 	loop();
-	close(debug_fd);
+	fclose(debug_f);
 	return 0;
 }

net/core/dev.c+3−3

@@ -4516,7 +4516,7 @@ static u32 netif_receive_generic_xdp(struct sk_buff *skb, · 4515 unmodified lines
4516	/* Reinjected packets coming from act_mirred or similar should	4516	/* Reinjected packets coming from act_mirred or similar should
4517	* not get XDP generic processing.	4517	* not get XDP generic processing.
4518	*/	4518	*/
4519	if (skb_is_tc_redirected(skb))	4519	if (skb_is_redirected(skb))
4520	return XDP_PASS;	4520	return XDP_PASS;
4521		4521
4522	/* XDP packets must be linear and must have sufficient headroom	4522	/* XDP packets must be linear and must have sufficient headroom
@@ -5063,7 +5063,7 @@ skip_taps: · 540 unmodified lines
5063	goto out;	5063	goto out;
5064	}	5064	}
5065	#endif	5065	#endif
5066	skb_reset_tc(skb);	5066	skb_reset_redirect(skb);
5067	skip_classify:	5067	skip_classify:
5068	if (pfmemalloc && !skb_pfmemalloc_protocol(skb))	5068	if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
5069	goto drop;	5069	goto drop;
@@ -5195,7 +5195,7 @@ static int __netif_receive_skb_one_core(struct sk_buff *skb, bool pfmemalloc) · 125 unmodified lines
5195	*	5195	*
5196	* More direct receive version of netif_receive_skb(). It should	5196	* More direct receive version of netif_receive_skb(). It should
5197	* only be used by callers that have a need to skip RPS and Generic XDP.	5197	* only be used by callers that have a need to skip RPS and Generic XDP.
5198	* Caller must also take care of handling if (page_is_)pfmemalloc.	5198	* Caller must also take care of handling if ``(page_is_)pfmemalloc``.
5199	*	5199	*
5200	* This function may only be called from softirq context and interrupts	5200	* This function may only be called from softirq context and interrupts
5201	* should be enabled.	5201	* should be enabled.

net/core/pktgen.c+1−1

@@ -3362,7 +3362,7 @@ static void pktgen_xmit(struct pktgen_dev *pkt_dev) · 3361 unmodified lines
3362	/* skb was 'freed' by stack, so clean few	3362	/* skb was 'freed' by stack, so clean few
3363	* bits and reuse it	3363	* bits and reuse it
3364	*/	3364	*/
3365	skb_reset_tc(skb);	3365	skb_reset_redirect(skb);
3366	} while (--burst > 0);	3366	} while (--burst > 0);
3367	goto out; /* Skips xmit_mode M_START_XMIT */	3367	goto out; /* Skips xmit_mode M_START_XMIT */
3368	} else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {	3368	} else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {

net/core/sock_map.c+8−4

 	struct bpf_stab *stab = container_of(map, struct bpf_stab, map);
 	int i;
+	/* After the sync no updates or deletes will be in-flight so it
+	 * is safe to walk map and remove entries without risking a race
+	 * in EEXIST update case.
+	 */
 	synchronize_rcu();
-	raw_spin_lock_bh(&stab->lock);
 	for (i = 0; i < stab->map.max_entries; i++) {
 		struct sock **psk = &stab->sks[i];
 		struct sock *sk;
 			release_sock(sk);
 		}
 	}
-	raw_spin_unlock_bh(&stab->lock);
 	/* wait for psock readers accessing its map link */
 	synchronize_rcu();
 	struct hlist_node *node;
 	int i;
+	/* After the sync no updates or deletes will be in-flight so it
+	 * is safe to walk map and remove entries without risking a race
+	 * in EEXIST update case.
+	 */
 	synchronize_rcu();
 	for (i = 0; i < htab->buckets_num; i++) {
 		bucket = sock_hash_select_bucket(htab, i);
-		raw_spin_lock_bh(&bucket->lock);
 		hlist_for_each_entry_safe(elem, node, &bucket->head, node) {
 			hlist_del_rcu(&elem->node);
 			lock_sock(elem->sk);
 			rcu_read_unlock();
 			release_sock(elem->sk);
 		}
-		raw_spin_unlock_bh(&bucket->lock);
 	}
 	/* wait for psock readers accessing its map link */

net/dsa/tag_8021q.c+0−43

@@ -298,47 +298,4 @@ struct sk_buff dsa_8021q_xmit(struct sk_buff skb, struct net_device *netdev, · 297 unmodified lines
298	}	298	}
299	EXPORT_SYMBOL_GPL(dsa_8021q_xmit);	299	EXPORT_SYMBOL_GPL(dsa_8021q_xmit);
300		300
301	/* In the DSA packet_type handler, skb->data points in the middle of the VLAN
302	* tag, after tpid and before tci. This is because so far, ETH_HLEN
303	* (DMAC, SMAC, EtherType) bytes were pulled.
304	* There are 2 bytes of VLAN tag left in skb->data, and upper
305	* layers expect the 'real' EtherType to be consumed as well.
306	* Coincidentally, a VLAN header is also of the same size as
307	* the number of bytes that need to be pulled.
308	*
309	* skb_mac_header skb->data
310	* \| \|
311	* v v
312	* \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|
313	* +-----------------------+-----------------------+-------+-------+-------+
314	* \| Destination MAC \| Source MAC \| TPID \| TCI \| EType \|
315	* +-----------------------+-----------------------+-------+-------+-------+
316	* ^ \| \|
317	* \|<--VLAN_HLEN-->to <---VLAN_HLEN--->
318	* from \|
319	* >>>>>>> v
320	* >>>>>>> \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|
321	* >>>>>>> +-----------------------+-----------------------+-------+
322	* >>>>>>> \| Destination MAC \| Source MAC \| EType \|
323	* +-----------------------+-----------------------+-------+
324	* ^ ^
325	* (now part of \| \|
326	* skb->head) skb_mac_header skb->data
327	*/
328	struct sk_buff dsa_8021q_remove_header(struct sk_buff skb)
329	{
330	u8 *from = skb_mac_header(skb);
331	u8 *dest = from + VLAN_HLEN;
332
333	memmove(dest, from, ETH_HLEN - VLAN_HLEN);
334	skb_pull(skb, VLAN_HLEN);
335	skb_push(skb, ETH_HLEN);
336	skb_reset_mac_header(skb);
337	skb_reset_mac_len(skb);
338	skb_pull_rcsum(skb, ETH_HLEN);
339
340	return skb;
341	}
342	EXPORT_SYMBOL_GPL(dsa_8021q_remove_header);
343
344	MODULE_LICENSE("GPL v2");	301	MODULE_LICENSE("GPL v2");

net/dsa/tag_brcm.c+2−0

@@ -140,6 +140,8 @@ static struct sk_buff brcm_tag_rcv_ll(struct sk_buff skb, · 139 unmodified lines
140	/* Remove Broadcom tag and update checksum */	140	/* Remove Broadcom tag and update checksum */
141	skb_pull_rcsum(skb, BRCM_TAG_LEN);	141	skb_pull_rcsum(skb, BRCM_TAG_LEN);
142		142
		143	skb->offload_fwd_mark = 1;
		144
143	return skb;	145	return skb;
144	}	146	}
145		147

net/dsa/tag_sja1105.c+9−10

 {
 	struct sja1105_meta meta = {0};
 	int source_port, switch_id;
-	struct vlan_ethhdr *hdr;
+	struct ethhdr *hdr;
 	u16 tpid, vid, tci;
 	bool is_link_local;
 	bool is_tagged;
 	bool is_meta;
-	hdr = vlan_eth_hdr(skb);
+	hdr = eth_hdr(skb);
-	tpid = ntohs(hdr->h_vlan_proto);
+	tpid = ntohs(hdr->h_proto);
 	is_tagged = (tpid == ETH_P_SJA1105);
 	is_link_local = sja1105_is_link_local(skb);
 	is_meta = sja1105_is_meta_frame(skb);
 	if (is_tagged) {
 		/* Normal traffic path. */
-		tci = ntohs(hdr->h_vlan_TCI);
+		skb_push_rcsum(skb, ETH_HLEN);
+		__skb_vlan_pop(skb, &tci);
+		skb_pull_rcsum(skb, ETH_HLEN);
+		skb_reset_network_header(skb);
+		skb_reset_transport_header(skb);
 		vid = tci & VLAN_VID_MASK;
 		source_port = dsa_8021q_rx_source_port(vid);
 		switch_id = dsa_8021q_rx_switch_id(vid);
 		return NULL;
 	}
-	/* Delete/overwrite fake VLAN header, DSA expects to not find
-	 * it there, see dsa_switch_rcv: skb_push(skb, ETH_HLEN).
-	 */
-	if (is_tagged)
-		skb = dsa_8021q_remove_header(skb);
 	return sja1105_rcv_meta_state_machine(skb, &meta, is_link_local,
 					      is_meta);
 }

net/ethtool/debug.c+3−1

 	if (ret < 0)
 		return ret;
 	dev = req_info.dev;
+	ret = -EOPNOTSUPP;
 	if (!dev->ethtool_ops->get_msglevel || !dev->ethtool_ops->set_msglevel)
-		return -EOPNOTSUPP;
+		goto out_dev;
 	rtnl_lock();
 	ret = ethnl_ops_begin(dev);
 	ethnl_ops_complete(dev);
 out_rtnl:
 	rtnl_unlock();
+out_dev:
 	dev_put(dev);
 	return ret;
 }

net/ethtool/linkinfo.c+3−1

 	if (ret < 0)
 		return ret;
 	dev = req_info.dev;
+	ret = -EOPNOTSUPP;
 	if (!dev->ethtool_ops->get_link_ksettings ||
 	    !dev->ethtool_ops->set_link_ksettings)
-		return -EOPNOTSUPP;
+		goto out_dev;
 	rtnl_lock();
 	ret = ethnl_ops_begin(dev);
 	ethnl_ops_complete(dev);
 out_rtnl:
 	rtnl_unlock();
+out_dev:
 	dev_put(dev);
 	return ret;
 }

net/ethtool/linkmodes.c+3−1

 	if (ret < 0)
 		return ret;
 	dev = req_info.dev;
+	ret = -EOPNOTSUPP;
 	if (!dev->ethtool_ops->get_link_ksettings ||
 	    !dev->ethtool_ops->set_link_ksettings)
-		return -EOPNOTSUPP;
+		goto out_dev;
 	rtnl_lock();
 	ret = ethnl_ops_begin(dev);
 	ethnl_ops_complete(dev);
 out_rtnl:
 	rtnl_unlock();
+out_dev:
 	dev_put(dev);
 	return ret;
 }

net/ethtool/netlink.c+12−4

 	struct nlattr *tb[ETHTOOL_A_HEADER_MAX + 1];
 	const struct nlattr *devname_attr;
 	struct net_device *dev = NULL;
+	u32 flags = 0;
 	int ret;
 	if (!header) {
 			       ethnl_header_policy, extack);
 	if (ret < 0)
 		return ret;
-	devname_attr = tb[ETHTOOL_A_HEADER_DEV_NAME];
+	if (tb[ETHTOOL_A_HEADER_FLAGS]) {
+		flags = nla_get_u32(tb[ETHTOOL_A_HEADER_FLAGS]);
+		if (flags & ~ETHTOOL_FLAG_ALL) {
+			NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_HEADER_FLAGS],
+					    "unrecognized request flags");
+			nl_set_extack_cookie_u32(extack, ETHTOOL_FLAG_ALL);
+			return -EOPNOTSUPP;
+		}
+	}
+	devname_attr = tb[ETHTOOL_A_HEADER_DEV_NAME];
 	if (tb[ETHTOOL_A_HEADER_DEV_INDEX]) {
 		u32 ifindex = nla_get_u32(tb[ETHTOOL_A_HEADER_DEV_INDEX]);
 	}
 	req_info->dev = dev;
-	if (tb[ETHTOOL_A_HEADER_FLAGS])
+	req_info->flags = flags;
-		req_info->flags = nla_get_u32(tb[ETHTOOL_A_HEADER_FLAGS]);
 	return 0;
 }

net/ethtool/wol.c+3−1

 	if (ret < 0)
 		return ret;
 	dev = req_info.dev;
+	ret = -EOPNOTSUPP;
 	if (!dev->ethtool_ops->get_wol || !dev->ethtool_ops->set_wol)
-		return -EOPNOTSUPP;
+		goto out_dev;
 	rtnl_lock();
 	ret = ethnl_ops_begin(dev);
 	ethnl_ops_complete(dev);
 out_rtnl:
 	rtnl_unlock();
+out_dev:
 	dev_put(dev);
 	return ret;
 }

net/hsr/hsr_framereg.c+2−7

 	struct hsr_port *port;
 	unsigned long tdiff;
-	rcu_read_lock();
 	node = find_node_by_addr_A(&hsr->node_db, addr);
-	if (!node) {
+	if (!node)
-		rcu_read_unlock();
+		return -ENOENT;
-		return -ENOENT;	/* No such entry */
-	}
 	ether_addr_copy(addr_b, node->macaddress_B);
 		*addr_b_ifindex = -1;
 	}
-	rcu_read_unlock();
 	return 0;
 }

net/hsr/hsr_netlink.c+42−28

 	if (!na)
 		goto invalid;
-	hsr_dev = __dev_get_by_index(genl_info_net(info),
+	rcu_read_lock();
-				     nla_get_u32(info->attrs[HSR_A_IFINDEX]));
+	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
+				       nla_get_u32(info->attrs[HSR_A_IFINDEX]));
 	if (!hsr_dev)
-		goto invalid;
+		goto rcu_unlock;
 	if (!is_hsr_master(hsr_dev))
-		goto invalid;
+		goto rcu_unlock;
 	/* Send reply */
-	skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+	skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
 	if (!skb_out) {
 		res = -ENOMEM;
 		goto fail;
 	res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
 	if (res < 0)
 		goto nla_put_failure;
-	rcu_read_lock();
 	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
 	if (port)
 		res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
 				  port->dev->ifindex);
-	rcu_read_unlock();
 	if (res < 0)
 		goto nla_put_failure;
 	res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
 	if (res < 0)
 		goto nla_put_failure;
-	rcu_read_lock();
 	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
 	if (port)
 		res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
 				  port->dev->ifindex);
-	rcu_read_unlock();
 	if (res < 0)
 		goto nla_put_failure;
+	rcu_read_unlock();
 	genlmsg_end(skb_out, msg_head);
 	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
 	return 0;
+rcu_unlock:
+	rcu_read_unlock();
 invalid:
 	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
 	return 0;
 	/* Fall through */
 fail:
+	rcu_read_unlock();
 	return res;
 }
  */
 static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
 {
-	/* For receiving */
+	unsigned char addr[ETH_ALEN];
-	struct nlattr *na;
 	struct net_device *hsr_dev;
-	/* For sending */
 	struct sk_buff *skb_out;
-	void *msg_head;
 	struct hsr_priv *hsr;
-	void *pos;
+	bool restart = false;
-	unsigned char addr[ETH_ALEN];
+	struct nlattr *na;
+	void *pos = NULL;
+	void *msg_head;
 	int res;
 	if (!info)
 	if (!na)
 		goto invalid;
-	hsr_dev = __dev_get_by_index(genl_info_net(info),
+	rcu_read_lock();
-				     nla_get_u32(info->attrs[HSR_A_IFINDEX]));
+	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
+				       nla_get_u32(info->attrs[HSR_A_IFINDEX]));
 	if (!hsr_dev)
-		goto invalid;
+		goto rcu_unlock;
 	if (!is_hsr_master(hsr_dev))
-		goto invalid;
+		goto rcu_unlock;
+restart:
 	/* Send reply */
-	skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+	skb_out = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 	if (!skb_out) {
 		res = -ENOMEM;
 		goto fail;
 		goto nla_put_failure;
 	}
-	res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
+	if (!restart) {
-	if (res < 0)
+		res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
-		goto nla_put_failure;
+		if (res < 0)
+			goto nla_put_failure;
+	}
 	hsr = netdev_priv(hsr_dev);
-	rcu_read_lock();
+	if (!pos)
-	pos = hsr_get_next_node(hsr, NULL, addr);
+		pos = hsr_get_next_node(hsr, NULL, addr);
 	while (pos) {
 		res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
 		if (res < 0) {
-			rcu_read_unlock();
+			if (res == -EMSGSIZE) {
+				genlmsg_end(skb_out, msg_head);
+				genlmsg_unicast(genl_info_net(info), skb_out,
+						info->snd_portid);
+				restart = true;
+				goto restart;
+			}
 			goto nla_put_failure;
 		}
 		pos = hsr_get_next_node(hsr, pos, addr);
 	return 0;
+rcu_unlock:
+	rcu_read_unlock();
 invalid:
 	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
 	return 0;
 nla_put_failure:
-	kfree_skb(skb_out);
+	nlmsg_free(skb_out);
 	/* Fall through */
 fail:
+	rcu_read_unlock();
 	return res;
 }
 	.version = 1,
 	.maxattr = HSR_A_MAX,
 	.policy = hsr_genl_policy,
+	.netnsok = true,
 	.module = THIS_MODULE,
 	.ops = hsr_ops,
 	.n_ops = ARRAY_SIZE(hsr_ops),

net/hsr/hsr_slave.c+4−4

 	if (!port)
 		return -ENOMEM;
+	port->hsr = hsr;
+	port->dev = dev;
+	port->type = type;
 	if (type != HSR_PT_MASTER) {
 		res = hsr_portdev_setup(hsr, dev, port, extack);
 		if (res)
 			goto fail_dev_setup;
 	}
-	port->hsr = hsr;
-	port->dev = dev;
-	port->type = type;
 	list_add_tail_rcu(&port->port_list, &hsr->ports);
 	synchronize_rcu();

net/ipv4/fib_frontend.c+2−0

@@ -997,7 +997,9 @@ static int inet_dump_fib(struct sk_buff skb, struct netlink_callback cb) · 996 unmodified lines
997	return -ENOENT;	997	return -ENOENT;
998	}	998	}
999		999
		1000	rcu_read_lock();
1000	err = fib_table_dump(tb, skb, cb, &filter);	1001	err = fib_table_dump(tb, skb, cb, &filter);
		1002	rcu_read_unlock();
1001	return skb->len ? : err;	1003	return skb->len ? : err;
1002	}	1004	}
1003		1005

net/ipv4/ip_gre.c+87−18

@@ -1153,6 +1153,24 @@ static int ipgre_netlink_parms(struct net_device *dev, · 1152 unmodified lines
1153	if (data[IFLA_GRE_FWMARK])	1153	if (data[IFLA_GRE_FWMARK])
1154	*fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);	1154	*fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1155		1155
		1156	return 0;
		1157	}
		1158
		1159	static int erspan_netlink_parms(struct net_device *dev,
		1160	struct nlattr *data[],
		1161	struct nlattr *tb[],
		1162	struct ip_tunnel_parm *parms,
		1163	__u32 *fwmark)
		1164	{
		1165	struct ip_tunnel *t = netdev_priv(dev);
		1166	int err;
		1167
		1168	err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
		1169	if (err)
		1170	return err;
		1171	if (!data)
		1172	return 0;
		1173
1156	if (data[IFLA_GRE_ERSPAN_VER]) {	1174	if (data[IFLA_GRE_ERSPAN_VER]) {
1157	t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);	1175	t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1158		1176
@@ -1276,45 +1294,70 @@ static void ipgre_tap_setup(struct net_device *dev) · 117 unmodified lines
1276	ip_tunnel_setup(dev, gre_tap_net_id);	1294	ip_tunnel_setup(dev, gre_tap_net_id);
1277	}	1295	}
1278		1296
1279	static int ipgre_newlink(struct net src_net, struct net_device dev,	1297	static int
1280	struct nlattr tb[], struct nlattr data[],	1298	ipgre_newlink_encap_setup(struct net_device dev, struct nlattr data[])
1281	struct netlink_ext_ack *extack)
1282	{	1299	{
1283	struct ip_tunnel_parm p;
1284	struct ip_tunnel_encap ipencap;	1300	struct ip_tunnel_encap ipencap;
1285	__u32 fwmark = 0;
1286	int err;
1287		1301
1288	if (ipgre_netlink_encap_parms(data, &ipencap)) {	1302	if (ipgre_netlink_encap_parms(data, &ipencap)) {
1289	struct ip_tunnel *t = netdev_priv(dev);	1303	struct ip_tunnel *t = netdev_priv(dev);
1290	err = ip_tunnel_encap_setup(t, &ipencap);	1304	int err = ip_tunnel_encap_setup(t, &ipencap);
1291		1305
1292	if (err < 0)	1306	if (err < 0)
1293	return err;	1307	return err;
1294	}	1308	}
1295		1309
		1310	return 0;
		1311	}
		1312
		1313	static int ipgre_newlink(struct net src_net, struct net_device dev,
		1314	struct nlattr tb[], struct nlattr data[],
		1315	struct netlink_ext_ack *extack)
		1316	{
		1317	struct ip_tunnel_parm p;
		1318	__u32 fwmark = 0;
		1319	int err;
		1320
		1321	err = ipgre_newlink_encap_setup(dev, data);
		1322	if (err)
		1323	return err;
		1324
1296	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);	1325	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1297	if (err < 0)	1326	if (err < 0)
1298	return err;	1327	return err;
1299	return ip_tunnel_newlink(dev, tb, &p, fwmark);	1328	return ip_tunnel_newlink(dev, tb, &p, fwmark);
1300	}	1329	}
1301		1330
		1331	static int erspan_newlink(struct net src_net, struct net_device dev,
		1332	struct nlattr tb[], struct nlattr data[],
		1333	struct netlink_ext_ack *extack)
		1334	{
		1335	struct ip_tunnel_parm p;
		1336	__u32 fwmark = 0;
		1337	int err;
		1338
		1339	err = ipgre_newlink_encap_setup(dev, data);
		1340	if (err)
		1341	return err;
		1342
		1343	err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
		1344	if (err)
		1345	return err;
		1346	return ip_tunnel_newlink(dev, tb, &p, fwmark);
		1347	}
		1348
1302	static int ipgre_changelink(struct net_device dev, struct nlattr tb[],	1349	static int ipgre_changelink(struct net_device dev, struct nlattr tb[],
1303	struct nlattr *data[],	1350	struct nlattr *data[],
1304	struct netlink_ext_ack *extack)	1351	struct netlink_ext_ack *extack)
1305	{	1352	{
1306	struct ip_tunnel *t = netdev_priv(dev);	1353	struct ip_tunnel *t = netdev_priv(dev);
1307	struct ip_tunnel_encap ipencap;
1308	__u32 fwmark = t->fwmark;	1354	__u32 fwmark = t->fwmark;
1309	struct ip_tunnel_parm p;	1355	struct ip_tunnel_parm p;
1310	int err;	1356	int err;
1311		1357
1312	if (ipgre_netlink_encap_parms(data, &ipencap)) {	1358	err = ipgre_newlink_encap_setup(dev, data);
1313	err = ip_tunnel_encap_setup(t, &ipencap);	1359	if (err)
1314		1360	return err;
1315	if (err < 0)
1316	return err;
1317	}
1318		1361
1319	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);	1362	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1320	if (err < 0)	1363	if (err < 0)
@@ -1327,8 +1370,34 @@ static int ipgre_changelink(struct net_device dev, struct nlattr tb[], · 6 unmodified lines
1327	t->parms.i_flags = p.i_flags;	1370	t->parms.i_flags = p.i_flags;
1328	t->parms.o_flags = p.o_flags;	1371	t->parms.o_flags = p.o_flags;
1329		1372
1330	if (strcmp(dev->rtnl_link_ops->kind, "erspan"))	1373	ipgre_link_update(dev, !tb[IFLA_MTU]);
1331	ipgre_link_update(dev, !tb[IFLA_MTU]);	1374
		1375	return 0;
		1376	}
		1377
		1378	static int erspan_changelink(struct net_device dev, struct nlattr tb[],
		1379	struct nlattr *data[],
		1380	struct netlink_ext_ack *extack)
		1381	{
		1382	struct ip_tunnel *t = netdev_priv(dev);
		1383	__u32 fwmark = t->fwmark;
		1384	struct ip_tunnel_parm p;
		1385	int err;
		1386
		1387	err = ipgre_newlink_encap_setup(dev, data);
		1388	if (err)
		1389	return err;
		1390
		1391	err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
		1392	if (err < 0)
		1393	return err;
		1394
		1395	err = ip_tunnel_changelink(dev, tb, &p, fwmark);
		1396	if (err < 0)
		1397	return err;
		1398
		1399	t->parms.i_flags = p.i_flags;
		1400	t->parms.o_flags = p.o_flags;
1332		1401
1333	return 0;	1402	return 0;
1334	}	1403	}
@@ -1519,8 +1588,8 @@ static struct rtnl_link_ops erspan_link_ops __read_mostly = { · 184 unmodified lines
1519	.priv_size = sizeof(struct ip_tunnel),	1588	.priv_size = sizeof(struct ip_tunnel),
1520	.setup = erspan_setup,	1589	.setup = erspan_setup,
1521	.validate = erspan_validate,	1590	.validate = erspan_validate,
1522	.newlink = ipgre_newlink,	1591	.newlink = erspan_newlink,
1523	.changelink = ipgre_changelink,	1592	.changelink = erspan_changelink,
1524	.dellink = ip_tunnel_dellink,	1593	.dellink = ip_tunnel_dellink,
1525	.get_size = ipgre_get_size,	1594	.get_size = ipgre_get_size,
1526	.fill_info = ipgre_fill_info,	1595	.fill_info = ipgre_fill_info,

net/ipv4/tcp.c+3−1

 			err = -EPERM;
 		else if (tp->repair_queue == TCP_SEND_QUEUE)
 			WRITE_ONCE(tp->write_seq, val);
-		else if (tp->repair_queue == TCP_RECV_QUEUE)
+		else if (tp->repair_queue == TCP_RECV_QUEUE) {
 			WRITE_ONCE(tp->rcv_nxt, val);
+			WRITE_ONCE(tp->copied_seq, val);
+		}
 		else
 			err = -EINVAL;
 		break;

net/ipv4/tcp_output.c+10−2

 		if (unlikely(!skb))
 			return -ENOBUFS;
+		/* retransmit skbs might have a non zero value in skb->dev
+		 * because skb->dev is aliased with skb->rbnode.rb_left
+		 */
+		skb->dev = NULL;
 	}
 	inet = inet_sk(sk);
 		tcp_skb_tsorted_save(skb) {
 			nskb = __pskb_copy(skb, MAX_TCP_HEADER, GFP_ATOMIC);
-			err = nskb ? tcp_transmit_skb(sk, nskb, 0, GFP_ATOMIC) :
+			if (nskb) {
-				     -ENOBUFS;
+				nskb->dev = NULL;
+				err = tcp_transmit_skb(sk, nskb, 0, GFP_ATOMIC);
+			} else {
+				err = -ENOBUFS;
+			}
 		} tcp_skb_tsorted_restore(skb);
 		if (!err) {

net/netfilter/nf_flow_table_core.c+3−0

 	nf_flow_table_iterate(flow_table, nf_flow_table_do_cleanup, NULL);
 	nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step, flow_table);
 	nf_flow_table_offload_flush(flow_table);
+	if (nf_flowtable_hw_offload(flow_table))
+		nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step,
+				      flow_table);
 	rhashtable_destroy(&flow_table->rhashtable);
 	mutex_destroy(&flow_table->flow_block_lock);
 }

net/netfilter/nf_flow_table_ip.c+10−4

 	if (test_bit(NF_FLOW_SNAT, &flow->flags) &&
 	    (nf_flow_snat_port(flow, skb, thoff, iph->protocol, dir) < 0 ||
-	     nf_flow_snat_ip(flow, skb, iph, thoff, dir) < 0))
+	     nf_flow_snat_ip(flow, skb, ip_hdr(skb), thoff, dir) < 0))
 		return -1;
+	iph = ip_hdr(skb);
 	if (test_bit(NF_FLOW_DNAT, &flow->flags) &&
 	    (nf_flow_dnat_port(flow, skb, thoff, iph->protocol, dir) < 0 ||
-	     nf_flow_dnat_ip(flow, skb, iph, thoff, dir) < 0))
+	     nf_flow_dnat_ip(flow, skb, ip_hdr(skb), thoff, dir) < 0))
 		return -1;
 	return 0;
 	if (!pskb_may_pull(skb, thoff + sizeof(*ports)))
 		return -1;
+	iph = ip_hdr(skb);
 	ports = (struct flow_ports *)(skb_network_header(skb) + thoff);
 	tuple->src_v4.s_addr	= iph->saddr;
 	if (test_bit(NF_FLOW_SNAT, &flow->flags) &&
 	    (nf_flow_snat_port(flow, skb, thoff, ip6h->nexthdr, dir) < 0 ||
-	     nf_flow_snat_ipv6(flow, skb, ip6h, thoff, dir) < 0))
+	     nf_flow_snat_ipv6(flow, skb, ipv6_hdr(skb), thoff, dir) < 0))
 		return -1;
+	ip6h = ipv6_hdr(skb);
 	if (test_bit(NF_FLOW_DNAT, &flow->flags) &&
 	    (nf_flow_dnat_port(flow, skb, thoff, ip6h->nexthdr, dir) < 0 ||
-	     nf_flow_dnat_ipv6(flow, skb, ip6h, thoff, dir) < 0))
+	     nf_flow_dnat_ipv6(flow, skb, ipv6_hdr(skb), thoff, dir) < 0))
 		return -1;
 	return 0;
 	if (!pskb_may_pull(skb, thoff + sizeof(*ports)))
 		return -1;
+	ip6h = ipv6_hdr(skb);
 	ports = (struct flow_ports *)(skb_network_header(skb) + thoff);
 	tuple->src_v6		= ip6h->saddr;

net/netfilter/nf_flow_table_offload.c+1−0

@@ -120,6 +120,7 @@ static int nf_flow_rule_match(struct nf_flow_match *match, · 119 unmodified lines
120	default:	120	default:
121	return -EOPNOTSUPP;	121	return -EOPNOTSUPP;
122	}	122	}
		123	mask->control.addr_type = 0xffff;
123	match->dissector.used_keys \|= BIT(key->control.addr_type);	124	match->dissector.used_keys \|= BIT(key->control.addr_type);
124	mask->basic.n_proto = 0xffff;	125	mask->basic.n_proto = 0xffff;
125		126

net/netfilter/nf_tables_api.c+5−0

 				err = -EBUSY;
 			else if (!(nlmsg_flags & NLM_F_EXCL))
 				err = 0;
+		} else if (err == -ENOTEMPTY) {
+			/* ENOTEMPTY reports overlapping between this element
+			 * and an existing one.
+			 */
+			err = -EEXIST;
 		}
 		goto err_element_clash;
 	}

net/netfilter/nft_fwd_netdev.c+12−0

 	struct nft_fwd_netdev *priv = nft_expr_priv(expr);
 	int oif = regs->data[priv->sreg_dev];
+	/* This is used by ifb only. */
+	skb_set_redirected(pkt->skb, true);
 	nf_fwd_netdev_egress(pkt, oif);
 	regs->verdict.code = NF_STOLEN;
 }
 	return -1;
 }
+static int nft_fwd_validate(const struct nft_ctx *ctx,
+			    const struct nft_expr *expr,
+			    const struct nft_data **data)
+{
+	return nft_chain_validate_hooks(ctx->chain, (1 << NF_NETDEV_INGRESS));
+}
 static struct nft_expr_type nft_fwd_netdev_type;
 static const struct nft_expr_ops nft_fwd_neigh_netdev_ops = {
 	.type		= &nft_fwd_netdev_type,
 	.eval		= nft_fwd_neigh_eval,
 	.init		= nft_fwd_neigh_init,
 	.dump		= nft_fwd_neigh_dump,
+	.validate	= nft_fwd_validate,
 };
 static const struct nft_expr_ops nft_fwd_netdev_ops = {
 	.eval		= nft_fwd_netdev_eval,
 	.init		= nft_fwd_netdev_init,
 	.dump		= nft_fwd_netdev_dump,
+	.validate	= nft_fwd_validate,
 	.offload	= nft_fwd_netdev_offload,
 };

net/netfilter/nft_set_pipapo.c+27−7

@@ -1164,21 +1164,41 @@ static int nft_pipapo_insert(const struct net net, const struct nft_set set, · 1163 unmodified lines
1164	struct nft_pipapo_field *f;	1164	struct nft_pipapo_field *f;
1165	int i, bsize_max, err = 0;	1165	int i, bsize_max, err = 0;
1166		1166
		1167	if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END))
		1168	end = (const u8 *)nft_set_ext_key_end(ext)->data;
		1169	else
		1170	end = start;
		1171
1167	dup = pipapo_get(net, set, start, genmask);	1172	dup = pipapo_get(net, set, start, genmask);
1168	if (PTR_ERR(dup) == -ENOENT) {	1173	if (!IS_ERR(dup)) {
1169	if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END)) {	1174	/* Check if we already have the same exact entry */
1170	end = (const u8 *)nft_set_ext_key_end(ext)->data;	1175	const struct nft_data dup_key, dup_end;
1171	dup = pipapo_get(net, set, end, nft_genmask_next(net));	1176
1172	} else {	1177	dup_key = nft_set_ext_key(&dup->ext);
1173	end = start;	1178	if (nft_set_ext_exists(&dup->ext, NFT_SET_EXT_KEY_END))
		1179	dup_end = nft_set_ext_key_end(&dup->ext);
		1180	else
		1181	dup_end = dup_key;
		1182
		1183	if (!memcmp(start, dup_key->data, sizeof(*dup_key->data)) &&
		1184	!memcmp(end, dup_end->data, sizeof(*dup_end->data))) {
		1185	*ext2 = &dup->ext;
		1186	return -EEXIST;
1174	}	1187	}
		1188
		1189	return -ENOTEMPTY;
		1190	}
		1191
		1192	if (PTR_ERR(dup) == -ENOENT) {
		1193	/* Look for partially overlapping entries */
		1194	dup = pipapo_get(net, set, end, nft_genmask_next(net));
1175	}	1195	}
1176		1196
1177	if (PTR_ERR(dup) != -ENOENT) {	1197	if (PTR_ERR(dup) != -ENOENT) {
1178	if (IS_ERR(dup))	1198	if (IS_ERR(dup))
1179	return PTR_ERR(dup);	1199	return PTR_ERR(dup);
1180	*ext2 = &dup->ext;	1200	*ext2 = &dup->ext;
1181	return -EEXIST;	1201	return -ENOTEMPTY;
1182	}	1202	}
1183		1203
1184	/* Validate */	1204	/* Validate */

net/netfilter/nft_set_rbtree.c+78−9

@@ -33,6 +33,11 @@ static bool nft_rbtree_interval_end(const struct nft_rbtree_elem *rbe) · 32 unmodified lines
33	(*nft_set_ext_flags(&rbe->ext) & NFT_SET_ELEM_INTERVAL_END);	33	(*nft_set_ext_flags(&rbe->ext) & NFT_SET_ELEM_INTERVAL_END);
34	}	34	}
35		35
		36	static bool nft_rbtree_interval_start(const struct nft_rbtree_elem *rbe)
		37	{
		38	return !nft_rbtree_interval_end(rbe);
		39	}
		40
36	static bool nft_rbtree_equal(const struct nft_set set, const void this,	41	static bool nft_rbtree_equal(const struct nft_set set, const void this,
37	const struct nft_rbtree_elem *interval)	42	const struct nft_rbtree_elem *interval)
38	{	43	{
@@ -64,7 +69,7 @@ static bool __nft_rbtree_lookup(const struct net net, const struct nft_set set · 25 unmodified lines
64	if (interval &&	69	if (interval &&
65	nft_rbtree_equal(set, this, interval) &&	70	nft_rbtree_equal(set, this, interval) &&
66	nft_rbtree_interval_end(rbe) &&	71	nft_rbtree_interval_end(rbe) &&
67	!nft_rbtree_interval_end(interval))	72	nft_rbtree_interval_start(interval))
68	continue;	73	continue;
69	interval = rbe;	74	interval = rbe;
70	} else if (d > 0)	75	} else if (d > 0)
@@ -89,7 +94,7 @@ static bool __nft_rbtree_lookup(const struct net net, const struct nft_set set · 18 unmodified lines
89		94
90	if (set->flags & NFT_SET_INTERVAL && interval != NULL &&	95	if (set->flags & NFT_SET_INTERVAL && interval != NULL &&
91	nft_set_elem_active(&interval->ext, genmask) &&	96	nft_set_elem_active(&interval->ext, genmask) &&
92	!nft_rbtree_interval_end(interval)) {	97	nft_rbtree_interval_start(interval)) {
93	*ext = &interval->ext;	98	*ext = &interval->ext;
94	return true;	99	return true;
95	}	100	}
@@ -208,8 +213,43 @@ static int __nft_rbtree_insert(const struct net net, const struct nft_set set, · 112 unmodified lines
208	u8 genmask = nft_genmask_next(net);	213	u8 genmask = nft_genmask_next(net);
209	struct nft_rbtree_elem *rbe;	214	struct nft_rbtree_elem *rbe;
210	struct rb_node parent, *p;	215	struct rb_node parent, *p;
		216	bool overlap = false;
211	int d;	217	int d;
212		218
		219	/* Detect overlaps as we descend the tree. Set the flag in these cases:
		220	*
		221	* a1. \|__ _ _? >\|__ _ _ (insert start after existing start)
		222	* a2. _ _ __>\| ?_ _ __\| (insert end before existing end)
		223	* a3. _ _ ___\| ?_ _ _>\| (insert end after existing end)
		224	* a4. >\|__ _ _ _ _ __\| (insert start before existing end)
		225	*
		226	* and clear it later on, as we eventually reach the points indicated by
		227	* '?' above, in the cases described below. We'll always meet these
		228	* later, locally, due to tree ordering, and overlaps for the intervals
		229	* that are the closest together are always evaluated last.
		230	*
		231	* b1. \|__ _ _! >\|__ _ _ (insert start after existing end)
		232	* b2. _ _ __>\| !_ _ __\| (insert end before existing start)
		233	* b3. !_____>\| (insert end after existing start)
		234	*
		235	* Case a4. resolves to b1.:
		236	* - if the inserted start element is the leftmost, because the '0'
		237	* element in the tree serves as end element
		238	* - otherwise, if an existing end is found. Note that end elements are
		239	* always inserted after corresponding start elements.
		240	*
		241	* For a new, rightmost pair of elements, we'll hit cases b1. and b3.,
		242	* in that order.
		243	*
		244	* The flag is also cleared in two special cases:
		245	*
		246	* b4. \|__ _ _!\|<_ _ _ (insert start right before existing end)
		247	* b5. \|__ _ >\|!__ _ _ (insert end right after existing start)
		248	*
		249	* which always happen as last step and imply that no further
		250	* overlapping is possible.
		251	*/
		252
213	parent = NULL;	253	parent = NULL;
214	p = &priv->root.rb_node;	254	p = &priv->root.rb_node;
215	while (*p != NULL) {	255	while (*p != NULL) {
@@ -218,17 +258,42 @@ static int __nft_rbtree_insert(const struct net net, const struct nft_set set, · 2 unmodified lines
218	d = memcmp(nft_set_ext_key(&rbe->ext),	258	d = memcmp(nft_set_ext_key(&rbe->ext),
219	nft_set_ext_key(&new->ext),	259	nft_set_ext_key(&new->ext),
220	set->klen);	260	set->klen);
221	if (d < 0)	261	if (d < 0) {
222	p = &parent->rb_left;	262	p = &parent->rb_left;
223	else if (d > 0)	263
		264	if (nft_rbtree_interval_start(new)) {
		265	overlap = nft_rbtree_interval_start(rbe) &&
		266	nft_set_elem_active(&rbe->ext,
		267	genmask);
		268	} else {
		269	overlap = nft_rbtree_interval_end(rbe) &&
		270	nft_set_elem_active(&rbe->ext,
		271	genmask);
		272	}
		273	} else if (d > 0) {
224	p = &parent->rb_right;	274	p = &parent->rb_right;
225	else {	275
		276	if (nft_rbtree_interval_end(new)) {
		277	overlap = nft_rbtree_interval_end(rbe) &&
		278	nft_set_elem_active(&rbe->ext,
		279	genmask);
		280	} else if (nft_rbtree_interval_end(rbe) &&
		281	nft_set_elem_active(&rbe->ext, genmask)) {
		282	overlap = true;
		283	}
		284	} else {
226	if (nft_rbtree_interval_end(rbe) &&	285	if (nft_rbtree_interval_end(rbe) &&
227	!nft_rbtree_interval_end(new)) {	286	nft_rbtree_interval_start(new)) {
228	p = &parent->rb_left;	287	p = &parent->rb_left;
229	} else if (!nft_rbtree_interval_end(rbe) &&	288
		289	if (nft_set_elem_active(&rbe->ext, genmask))
		290	overlap = false;
		291	} else if (nft_rbtree_interval_start(rbe) &&
230	nft_rbtree_interval_end(new)) {	292	nft_rbtree_interval_end(new)) {
231	p = &parent->rb_right;	293	p = &parent->rb_right;
		294
		295	if (nft_set_elem_active(&rbe->ext, genmask))
		296	overlap = false;
232	} else if (nft_set_elem_active(&rbe->ext, genmask)) {	297	} else if (nft_set_elem_active(&rbe->ext, genmask)) {
233	*ext = &rbe->ext;	298	*ext = &rbe->ext;
234	return -EEXIST;	299	return -EEXIST;
@@ -237,6 +302,10 @@ static int __nft_rbtree_insert(const struct net net, const struct nft_set set, · 2 unmodified lines
237	}	302	}
238	}	303	}
239	}	304	}
		305
		306	if (overlap)
		307	return -ENOTEMPTY;
		308
240	rb_link_node_rcu(&new->node, parent, p);	309	rb_link_node_rcu(&new->node, parent, p);
241	rb_insert_color(&new->node, &priv->root);	310	rb_insert_color(&new->node, &priv->root);
242	return 0;	311	return 0;
@@ -317,10 +386,10 @@ static void nft_rbtree_deactivate(const struct net net, · 74 unmodified lines
317	parent = parent->rb_right;	386	parent = parent->rb_right;
318	else {	387	else {
319	if (nft_rbtree_interval_end(rbe) &&	388	if (nft_rbtree_interval_end(rbe) &&
320	!nft_rbtree_interval_end(this)) {	389	nft_rbtree_interval_start(this)) {
321	parent = parent->rb_left;	390	parent = parent->rb_left;
322	continue;	391	continue;
323	} else if (!nft_rbtree_interval_end(rbe) &&	392	} else if (nft_rbtree_interval_start(rbe) &&
324	nft_rbtree_interval_end(this)) {	393	nft_rbtree_interval_end(this)) {
325	parent = parent->rb_right;	394	parent = parent->rb_right;
326	continue;	395	continue;

net/netlink/af_netlink.c+17−26

@@ -2392,19 +2392,14 @@ void netlink_ack(struct sk_buff in_skb, struct nlmsghdr nlh, int err, · 2391 unmodified lines
2392	if (nlk_has_extack && extack && extack->_msg)	2392	if (nlk_has_extack && extack && extack->_msg)
2393	tlvlen += nla_total_size(strlen(extack->_msg) + 1);	2393	tlvlen += nla_total_size(strlen(extack->_msg) + 1);
2394		2394
2395	if (err) {	2395	if (err && !(nlk->flags & NETLINK_F_CAP_ACK))
2396	if (!(nlk->flags & NETLINK_F_CAP_ACK))	2396	payload += nlmsg_len(nlh);
2397	payload += nlmsg_len(nlh);	2397	else
2398	else
2399	flags \|= NLM_F_CAPPED;
2400	if (nlk_has_extack && extack && extack->bad_attr)
2401	tlvlen += nla_total_size(sizeof(u32));
2402	} else {
2403	flags \|= NLM_F_CAPPED;	2398	flags \|= NLM_F_CAPPED;
2404		2399	if (err && nlk_has_extack && extack && extack->bad_attr)
2405	if (nlk_has_extack && extack && extack->cookie_len)	2400	tlvlen += nla_total_size(sizeof(u32));
2406	tlvlen += nla_total_size(extack->cookie_len);	2401	if (nlk_has_extack && extack && extack->cookie_len)
2407	}	2402	tlvlen += nla_total_size(extack->cookie_len);
2408		2403
2409	if (tlvlen)	2404	if (tlvlen)
2410	flags \|= NLM_F_ACK_TLVS;	2405	flags \|= NLM_F_ACK_TLVS;
@@ -2427,20 +2422,16 @@ void netlink_ack(struct sk_buff in_skb, struct nlmsghdr nlh, int err, · 16 unmodified lines
2427	WARN_ON(nla_put_string(skb, NLMSGERR_ATTR_MSG,	2422	WARN_ON(nla_put_string(skb, NLMSGERR_ATTR_MSG,
2428	extack->_msg));	2423	extack->_msg));
2429	}	2424	}
2430	if (err) {	2425	if (err && extack->bad_attr &&
2431	if (extack->bad_attr &&	2426	!WARN_ON((u8 *)extack->bad_attr < in_skb->data \|\|
2432	!WARN_ON((u8 *)extack->bad_attr < in_skb->data \|\|	2427	(u8 *)extack->bad_attr >= in_skb->data +
2433	(u8 *)extack->bad_attr >= in_skb->data +	2428	in_skb->len))
2434	in_skb->len))	2429	WARN_ON(nla_put_u32(skb, NLMSGERR_ATTR_OFFS,
2435	WARN_ON(nla_put_u32(skb, NLMSGERR_ATTR_OFFS,	2430	(u8 *)extack->bad_attr -
2436	(u8 *)extack->bad_attr -	2431	(u8 *)nlh));
2437	(u8 *)nlh));	2432	if (extack->cookie_len)
2438	} else {	2433	WARN_ON(nla_put(skb, NLMSGERR_ATTR_COOKIE,
2439	if (extack->cookie_len)	2434	extack->cookie_len, extack->cookie));
2440	WARN_ON(nla_put(skb, NLMSGERR_ATTR_COOKIE,
2441	extack->cookie_len,
2442	extack->cookie));
2443	}
2444	}	2435	}
2445		2436
2446	nlmsg_end(skb, rep);	2437	nlmsg_end(skb, rep);

net/packet/af_packet.c+21−0

 	struct timespec64 ts;
 	__u32 ts_status;
 	bool is_drop_n_account = false;
+	unsigned int slot_id = 0;
 	bool do_vnet = false;
 	/* struct tpacket{2,3}_hdr is aligned to a multiple of TPACKET_ALIGNMENT.
 	if (!h.raw)
 		goto drop_n_account;
+	if (po->tp_version <= TPACKET_V2) {
+		slot_id = po->rx_ring.head;
+		if (test_bit(slot_id, po->rx_ring.rx_owner_map))
+			goto drop_n_account;
+		__set_bit(slot_id, po->rx_ring.rx_owner_map);
+	}
 	if (do_vnet &&
 	    virtio_net_hdr_from_skb(skb, h.raw + macoff -
 				    sizeof(struct virtio_net_hdr),
 #endif
 	if (po->tp_version <= TPACKET_V2) {
+		spin_lock(&sk->sk_receive_queue.lock);
 		__packet_set_status(po, h.raw, status);
+		__clear_bit(slot_id, po->rx_ring.rx_owner_map);
+		spin_unlock(&sk->sk_receive_queue.lock);
 		sk->sk_data_ready(sk);
 	} else {
 		prb_clear_blk_fill_status(&po->rx_ring);
 {
 	struct pgv *pg_vec = NULL;
 	struct packet_sock *po = pkt_sk(sk);
+	unsigned long *rx_owner_map = NULL;
 	int was_running, order = 0;
 	struct packet_ring_buffer *rb;
 	struct sk_buff_head *rb_queue;
 			}
 			break;
 		default:
+			if (!tx_ring) {
+				rx_owner_map = bitmap_alloc(req->tp_frame_nr,
+					GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO);
+				if (!rx_owner_map)
+					goto out_free_pg_vec;
+			}
 			break;
 		}
 	}
 		err = 0;
 		spin_lock_bh(&rb_queue->lock);
 		swap(rb->pg_vec, pg_vec);
+		if (po->tp_version <= TPACKET_V2)
+			swap(rb->rx_owner_map, rx_owner_map);
 		rb->frame_max = (req->tp_frame_nr - 1);
 		rb->head = 0;
 		rb->frame_size = req->tp_frame_size;
 	}
 out_free_pg_vec:
+	bitmap_free(rx_owner_map);
 	if (pg_vec)
 		free_pg_vec(pg_vec, order, req->tp_block_nr);
 out:

net/packet/internal.h+4−1

@@ -70,7 +70,10 @@ struct packet_ring_buffer { · 69 unmodified lines
70		70
71	unsigned int __percpu *pending_refcnt;	71	unsigned int __percpu *pending_refcnt;
72		72
73	struct tpacket_kbdq_core prb_bdqc;	73	union {
		74	unsigned long *rx_owner_map;
		75	struct tpacket_kbdq_core prb_bdqc;
		76	};
74	};	77	};
75		78
76	extern struct mutex fanout_mutex;	79	extern struct mutex fanout_mutex;

net/rxrpc/af_rxrpc.c+5−32

 					   gfp_t gfp,
 					   rxrpc_notify_rx_t notify_rx,
 					   bool upgrade,
-					   bool intr,
+					   enum rxrpc_interruptibility interruptibility,
 					   unsigned int debug_id)
 {
 	struct rxrpc_conn_parameters cp;
 	memset(&p, 0, sizeof(p));
 	p.user_call_ID = user_call_ID;
 	p.tx_total_len = tx_total_len;
-	p.intr = intr;
+	p.interruptibility = interruptibility;
 	memset(&cp, 0, sizeof(cp));
 	cp.local		= rx->local;
  * rxrpc_kernel_check_life - Check to see whether a call is still alive
  * @sock: The socket the call is on
  * @call: The call to check
- * @_life: Where to store the life value
  *
- * Allow a kernel service to find out whether a call is still alive - ie. we're
+ * Allow a kernel service to find out whether a call is still alive -
- * getting ACKs from the server.  Passes back in *_life a number representing
+ * ie. whether it has completed.
- * the life state which can be compared to that returned by a previous call and
- * return true if the call is still alive.
- *
- * If the life state stalls, rxrpc_kernel_probe_life() should be called and
- * then 2RTT waited.
  */
 bool rxrpc_kernel_check_life(const struct socket *sock,
-			     const struct rxrpc_call *call,
+			     const struct rxrpc_call *call)
-			     u32 *_life)
 {
-	*_life = call->acks_latest;
 	return call->state != RXRPC_CALL_COMPLETE;
 }
 EXPORT_SYMBOL(rxrpc_kernel_check_life);
-/**
- * rxrpc_kernel_probe_life - Poke the peer to see if it's still alive
- * @sock: The socket the call is on
- * @call: The call to check
- *
- * In conjunction with rxrpc_kernel_check_life(), allow a kernel service to
- * find out whether a call is still alive by pinging it.  This should cause the
- * life state to be bumped in about 2*RTT.
- *
- * The must be called in TASK_RUNNING state on pain of might_sleep() objecting.
- */
-void rxrpc_kernel_probe_life(struct socket *sock, struct rxrpc_call *call)
-{
-	rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false,
-			  rxrpc_propose_ack_ping_for_check_life);
-	rxrpc_send_ack_packet(call, true, NULL);
-}
-EXPORT_SYMBOL(rxrpc_kernel_probe_life);
 /**
  * rxrpc_kernel_get_epoch - Retrieve the epoch value from a call.
  * @sock: The socket the call is on

net/rxrpc/ar-internal.h+2−3

 	RXRPC_CALL_BEGAN_RX_TIMER,	/* We began the expect_rx_by timer */
 	RXRPC_CALL_RX_HEARD,		/* The peer responded at least once to this call */
 	RXRPC_CALL_RX_UNDERRUN,		/* Got data underrun */
-	RXRPC_CALL_IS_INTR,		/* The call is interruptible */
 	RXRPC_CALL_DISCONNECTED,	/* The call has been disconnected */
 };
 	atomic_t		usage;
 	u16			service_id;	/* service ID */
 	u8			security_ix;	/* Security type */
+	enum rxrpc_interruptibility interruptibility; /* At what point call may be interrupted */
 	u32			call_id;	/* call ID on connection  */
 	u32			cid;		/* connection ID plus channel index */
 	int			debug_id;	/* debug ID for printks */
 	/* transmission-phase ACK management */
 	ktime_t			acks_latest_ts;	/* Timestamp of latest ACK received */
-	rxrpc_serial_t		acks_latest;	/* serial number of latest ACK received */
 	rxrpc_seq_t		acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */
 	rxrpc_seq_t		acks_lost_top;	/* tx_top at the time lost-ack ping sent */
 	rxrpc_serial_t		acks_lost_ping;	/* Serial number of probe ACK */
 		u32		normal;		/* Max time since last call packet (msec) */
 	} timeouts;
 	u8			nr_timeouts;	/* Number of timeouts specified */
-	bool			intr;		/* The call is interruptible */
+	enum rxrpc_interruptibility interruptibility; /* How is interruptible is the call? */
 };
 struct rxrpc_send_params {

net/rxrpc/call_object.c+1−2

@@ -237,8 +237,7 @@ struct rxrpc_call rxrpc_new_client_call(struct rxrpc_sock rx, · 236 unmodified lines
237	return call;	237	return call;
238	}	238	}
239		239
240	if (p->intr)	240	call->interruptibility = p->interruptibility;
241	__set_bit(RXRPC_CALL_IS_INTR, &call->flags);
242	call->tx_total_len = p->tx_total_len;	241	call->tx_total_len = p->tx_total_len;
243	trace_rxrpc_call(call->debug_id, rxrpc_call_new_client,	242	trace_rxrpc_call(call->debug_id, rxrpc_call_new_client,
244	atomic_read(&call->usage),	243	atomic_read(&call->usage),

net/rxrpc/conn_client.c+10−3

 		add_wait_queue_exclusive(&call->waitq, &myself);
 		for (;;) {
-			if (test_bit(RXRPC_CALL_IS_INTR, &call->flags))
+			switch (call->interruptibility) {
+			case RXRPC_INTERRUPTIBLE:
+			case RXRPC_PREINTERRUPTIBLE:
 				set_current_state(TASK_INTERRUPTIBLE);
-			else
+				break;
+			case RXRPC_UNINTERRUPTIBLE:
+			default:
 				set_current_state(TASK_UNINTERRUPTIBLE);
+				break;
+			}
 			if (call->call_id)
 				break;
-			if (test_bit(RXRPC_CALL_IS_INTR, &call->flags) &&
+			if ((call->interruptibility == RXRPC_INTERRUPTIBLE ||
+			     call->interruptibility == RXRPC_PREINTERRUPTIBLE) &&
 			    signal_pending(current)) {
 				ret = -ERESTARTSYS;
 				break;

net/rxrpc/input.c+0−1

@@ -882,7 +882,6 @@ static void rxrpc_input_ack(struct rxrpc_call call, struct sk_buff skb) · 881 unmodified lines
882	before(prev_pkt, call->ackr_prev_seq))	882	before(prev_pkt, call->ackr_prev_seq))
883	goto out;	883	goto out;
884	call->acks_latest_ts = skb->tstamp;	884	call->acks_latest_ts = skb->tstamp;
885	call->acks_latest = sp->hdr.serial;
886		885
887	call->ackr_first_seq = first_soft_ack;	886	call->ackr_first_seq = first_soft_ack;
888	call->ackr_prev_seq = prev_pkt;	887	call->ackr_prev_seq = prev_pkt;

net/rxrpc/sendmsg.c+56−19

 #include <net/af_rxrpc.h>
 #include "ar-internal.h"
+/*
+ * Return true if there's sufficient Tx queue space.
+ */
+static bool rxrpc_check_tx_space(struct rxrpc_call *call, rxrpc_seq_t *_tx_win)
+{
+	unsigned int win_size =
+		min_t(unsigned int, call->tx_winsize,
+		      call->cong_cwnd + call->cong_extra);
+	rxrpc_seq_t tx_win = READ_ONCE(call->tx_hard_ack);
+	if (_tx_win)
+		*_tx_win = tx_win;
+	return call->tx_top - tx_win < win_size;
+}
 /*
  * Wait for space to appear in the Tx queue or a signal to occur.
  */
 {
 	for (;;) {
 		set_current_state(TASK_INTERRUPTIBLE);
-		if (call->tx_top - call->tx_hard_ack <
+		if (rxrpc_check_tx_space(call, NULL))
-		    min_t(unsigned int, call->tx_winsize,
-			  call->cong_cwnd + call->cong_extra))
 			return 0;
 		if (call->state >= RXRPC_CALL_COMPLETE)
  * Wait for space to appear in the Tx queue uninterruptibly, but with
  * a timeout of 2*RTT if no progress was made and a signal occurred.
  */
-static int rxrpc_wait_for_tx_window_nonintr(struct rxrpc_sock *rx,
+static int rxrpc_wait_for_tx_window_waitall(struct rxrpc_sock *rx,
 					    struct rxrpc_call *call)
 {
 	rxrpc_seq_t tx_start, tx_win;
 	rtt = READ_ONCE(call->peer->rtt);
 	rtt2 = nsecs_to_jiffies64(rtt) * 2;
-	if (rtt2 < 1)
+	if (rtt2 < 2)
-		rtt2 = 1;
+		rtt2 = 2;
 	timeout = rtt2;
 	tx_start = READ_ONCE(call->tx_hard_ack);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		tx_win = READ_ONCE(call->tx_hard_ack);
-		if (call->tx_top - tx_win <
+		if (rxrpc_check_tx_space(call, &tx_win))
-		    min_t(unsigned int, call->tx_winsize,
-			  call->cong_cwnd + call->cong_extra))
 			return 0;
 		if (call->state >= RXRPC_CALL_COMPLETE)
 			return call->error;
-		if (test_bit(RXRPC_CALL_IS_INTR, &call->flags) &&
+		if (timeout == 0 &&
-		    timeout == 0 &&
 		    tx_win == tx_start && signal_pending(current))
 			return -EINTR;
 	}
 }
+/*
+ * Wait for space to appear in the Tx queue uninterruptibly.
+ */
+static int rxrpc_wait_for_tx_window_nonintr(struct rxrpc_sock *rx,
+					    struct rxrpc_call *call,
+					    long *timeo)
+{
+	for (;;) {
+		set_current_state(TASK_UNINTERRUPTIBLE);
+		if (rxrpc_check_tx_space(call, NULL))
+			return 0;
+		if (call->state >= RXRPC_CALL_COMPLETE)
+			return call->error;
+		trace_rxrpc_transmit(call, rxrpc_transmit_wait);
+		*timeo = schedule_timeout(*timeo);
+	}
+}
 /*
  * wait for space to appear in the transmit/ACK window
  * - caller holds the socket locked
 	add_wait_queue(&call->waitq, &myself);
-	if (waitall)
+	switch (call->interruptibility) {
-		ret = rxrpc_wait_for_tx_window_nonintr(rx, call);
+	case RXRPC_INTERRUPTIBLE:
-	else
+		if (waitall)
-		ret = rxrpc_wait_for_tx_window_intr(rx, call, timeo);
+			ret = rxrpc_wait_for_tx_window_waitall(rx, call);
+		else
+			ret = rxrpc_wait_for_tx_window_intr(rx, call, timeo);
+		break;
+	case RXRPC_PREINTERRUPTIBLE:
+	case RXRPC_UNINTERRUPTIBLE:
+	default:
+		ret = rxrpc_wait_for_tx_window_nonintr(rx, call, timeo);
+		break;
+	}
 	remove_wait_queue(&call->waitq, &myself);
 	set_current_state(TASK_RUNNING);
 			_debug("alloc");
-			if (call->tx_top - call->tx_hard_ack >=
+			if (!rxrpc_check_tx_space(call, NULL)) {
-			    min_t(unsigned int, call->tx_winsize,
-				  call->cong_cwnd + call->cong_extra)) {
 				ret = -EAGAIN;
 				if (msg->msg_flags & MSG_DONTWAIT)
 					goto maybe_error;
 		.call.tx_total_len	= -1,
 		.call.user_call_ID	= 0,
 		.call.nr_timeouts	= 0,
-		.call.intr		= true,
+		.call.interruptibility	= RXRPC_INTERRUPTIBLE,
 		.abort_code		= 0,
 		.command		= RXRPC_CMD_SEND_DATA,
 		.exclusive		= false,

net/sched/act_ct.c+1−1

@@ -1273,7 +1273,7 @@ static int tcf_ct_init(struct net net, struct nlattr nla, · 1272 unmodified lines
1273	if (goto_ch)	1273	if (goto_ch)
1274	tcf_chain_put_by_act(goto_ch);	1274	tcf_chain_put_by_act(goto_ch);
1275	if (params)	1275	if (params)
1276	kfree_rcu(params, rcu);	1276	call_rcu(&params->rcu, tcf_ct_params_free);
1277	if (res == ACT_P_CREATED)	1277	if (res == ACT_P_CREATED)
1278	tcf_idr_insert(tn, *a);	1278	tcf_idr_insert(tn, *a);
1279		1279

net/sched/act_mirred.c+2−4

@@ -284,10 +284,8 @@ static int tcf_mirred_act(struct sk_buff skb, const struct tc_action a, · 283 unmodified lines
284		284
285	/* mirror is always swallowed */	285	/* mirror is always swallowed */
286	if (is_redirect) {	286	if (is_redirect) {
287	skb2->tc_redirected = 1;	287	skb_set_redirected(skb2, skb2->tc_at_ingress);
288	skb2->tc_from_ingress = skb2->tc_at_ingress;	288
289	if (skb2->tc_from_ingress)
290	skb2->tstamp = 0;
291	/* let's the caller reinsert the packet, if possible */	289	/* let's the caller reinsert the packet, if possible */
292	if (use_reinsert) {	290	if (use_reinsert) {
293	res->ingress = want_ingress;	291	res->ingress = want_ingress;

net/sched/cls_route.c+2−2

@@ -534,8 +534,8 @@ static int route4_change(struct net net, struct sk_buff in_skb, · 533 unmodified lines
534	fp = &b->ht[h];	534	fp = &b->ht[h];
535	for (pfp = rtnl_dereference(*fp); pfp;	535	for (pfp = rtnl_dereference(*fp); pfp;
536	fp = &pfp->next, pfp = rtnl_dereference(*fp)) {	536	fp = &pfp->next, pfp = rtnl_dereference(*fp)) {
537	if (pfp == f) {	537	if (pfp == fold) {
538	*fp = f->next;	538	rcu_assign_pointer(*fp, fold->next);
539	break;	539	break;
540	}	540	}
541	}	541	}

net/sched/cls_tcindex.c+3−0

 					      struct tcindex_data,
 					      rwork);
+	rtnl_lock();
 	kfree(p->perfect);
 	kfree(p);
+	rtnl_unlock();
 }
 static void tcindex_free_perfect_hash(struct tcindex_data *cp)
 		if (tcindex_alloc_perfect_hash(net, cp) < 0)
 			goto errout;
+		cp->alloc_hash = cp->hash;
 		for (i = 0; i < min(cp->hash, p->hash); i++)
 			cp->perfect[i].res = p->perfect[i].res;
 		balloc = 1;

net/sched/sch_cbs.c+11−1

 	s64 credits;
 	int len;
+	/* The previous packet is still being sent */
+	if (now < q->last) {
+		qdisc_watchdog_schedule_ns(&q->watchdog, q->last);
+		return NULL;
+	}
 	if (q->credits < 0) {
 		credits = timediff_to_credits(now - q->last, q->idleslope);
 	credits += q->credits;
 	q->credits = max_t(s64, credits, q->locredit);
-	q->last = now;
+	/* Estimate of the transmission of the last byte of the packet in ns */
+	if (unlikely(atomic64_read(&q->port_rate) == 0))
+		q->last = now;
+	else
+		q->last = now + div64_s64(len * NSEC_PER_SEC,
+					  atomic64_read(&q->port_rate));
 	return skb;
 }

net/socket.c+5−3

 int __sys_accept4_file(struct file *file, unsigned file_flags,
 		       struct sockaddr __user *upeer_sockaddr,
-		       int __user *upeer_addrlen, int flags)
+		       int __user *upeer_addrlen, int flags,
+		       unsigned long nofile)
 {
 	struct socket *sock, *newsock;
 	struct file *newfile;
 	 */
 	__module_get(newsock->ops->owner);
-	newfd = get_unused_fd_flags(flags);
+	newfd = __get_unused_fd_flags(flags, nofile);
 	if (unlikely(newfd < 0)) {
 		err = newfd;
 		sock_release(newsock);
 	f = fdget(fd);
 	if (f.file) {
 		ret = __sys_accept4_file(f.file, 0, upeer_sockaddr,
-						upeer_addrlen, flags);
+						upeer_addrlen, flags,
+						rlimit(RLIMIT_NOFILE));
 		if (f.flags)
 			fput(f.file);
 	}

scripts/Kconfig.include+7−0

@@ -44,3 +44,10 @@ $(error-if,$(success, $(LD) -v \| grep -q gold), gold linker '$(LD)' not supporte · 43 unmodified lines
44		44
45	# gcc version including patch level	45	# gcc version including patch level
46	gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))	46	gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))
		47
		48	# machine bit flags
		49	# $(m32-flag): -m32 if the compiler supports it, or an empty string otherwise.
		50	# $(m64-flag): -m64 if the compiler supports it, or an empty string otherwise.
		51	cc-option-bit = $(if-success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null,$(1))
		52	m32-flag := $(cc-option-bit,-m32)
		53	m64-flag := $(cc-option-bit,-m64)

scripts/Makefile.extrawarn+1−0

@@ -48,6 +48,7 @@ KBUILD_CFLAGS += -Wno-initializer-overrides · 47 unmodified lines
48	KBUILD_CFLAGS += -Wno-format	48	KBUILD_CFLAGS += -Wno-format
49	KBUILD_CFLAGS += -Wno-sign-compare	49	KBUILD_CFLAGS += -Wno-sign-compare
50	KBUILD_CFLAGS += -Wno-format-zero-length	50	KBUILD_CFLAGS += -Wno-format-zero-length
		51	KBUILD_CFLAGS += $(call cc-disable-warning, pointer-to-enum-cast)
51	endif	52	endif
52		53
53	endif	54	endif

scripts/export_report.pl+1−1

@@ -94,7 +94,7 @@ if (defined $opt{'o'}) { · 93 unmodified lines
94	#	94	#
95	while ( <$module_symvers> ) {	95	while ( <$module_symvers> ) {
96	chomp;	96	chomp;
97	my (undef, $symbol, $namespace, $module, $gpl) = split('\t');	97	my (undef, $symbol, $module, $gpl, $namespace) = split('\t');
98	$SYMBOL { $symbol } = [ $module , "0" , $symbol, $gpl];	98	$SYMBOL { $symbol } = [ $module , "0" , $symbol, $gpl];
99	}	99	}
100	close($module_symvers);	100	close($module_symvers);

scripts/kallsyms.c+4−4

 		return NULL;
 	}
-	if (is_ignored_symbol(name, type))
-		return NULL;
-	/* Ignore most absolute/undefined (?) symbols. */
 	if (strcmp(name, "_text") == 0)
 		_text = addr;
+	/* Ignore most absolute/undefined (?) symbols. */
+	if (is_ignored_symbol(name, type))
+		return NULL;
 	check_symbol_range(name, addr, text_ranges, ARRAY_SIZE(text_ranges));
 	check_symbol_range(name, addr, &percpu_range, 1);

scripts/mod/modpost.c+14−13

 static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
 {
-	Elf_Shdr *sechdr = &info->sechdrs[sym->st_shndx];
+	unsigned int secindex = get_secindex(info, sym);
+	Elf_Shdr *sechdr = &info->sechdrs[secindex];
 	unsigned long offset;
 	offset = sym->st_value;
 }
 /* parse Module.symvers file. line format:
- * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
+ * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
  **/
 static void read_dump(const char *fname, unsigned int kernel)
 {
 		return;
 	while ((line = get_next_line(&pos, file, size))) {
-		char *symname, *namespace, *modname, *d, *export, *end;
+		char *symname, *namespace, *modname, *d, *export;
 		unsigned int crc;
 		struct module *mod;
 		struct symbol *s;
 		if (!(symname = strchr(line, '\t')))
 			goto fail;
 		*symname++ = '\0';
-		if (!(namespace = strchr(symname, '\t')))
+		if (!(modname = strchr(symname, '\t')))
-			goto fail;
-		*namespace++ = '\0';
-		if (!(modname = strchr(namespace, '\t')))
 			goto fail;
 		*modname++ = '\0';
-		if ((export = strchr(modname, '\t')) != NULL)
+		if (!(export = strchr(modname, '\t')))
-			*export++ = '\0';
+			goto fail;
-		if (export && ((end = strchr(export, '\t')) != NULL))
+		*export++ = '\0';
-			*end = '\0';
+		if (!(namespace = strchr(export, '\t')))
+			goto fail;
+		*namespace++ = '\0';
 		crc = strtoul(line, &d, 16);
 		if (*symname == '\0' || *modname == '\0' || *d != '\0')
 			goto fail;
 				namespace = symbol->namespace;
 				buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
 					   symbol->crc, symbol->name,
-					   namespace ? namespace : "",
 					   symbol->module->name,
-					   export_str(symbol->export));
+					   export_str(symbol->export),
+					   namespace ? namespace : "");
 			}
 			symbol = symbol->next;
 		}

sound/core/oss/pcm_plugin.c+10−2

 		while (plugin->next) {
 			if (plugin->dst_frames)
 				frames = plugin->dst_frames(plugin, frames);
-			if (snd_BUG_ON((snd_pcm_sframes_t)frames <= 0))
+			if ((snd_pcm_sframes_t)frames <= 0)
 				return -ENXIO;
 			plugin = plugin->next;
 			err = snd_pcm_plugin_alloc(plugin, frames);
 		while (plugin->prev) {
 			if (plugin->src_frames)
 				frames = plugin->src_frames(plugin, frames);
-			if (snd_BUG_ON((snd_pcm_sframes_t)frames <= 0))
+			if ((snd_pcm_sframes_t)frames <= 0)
 				return -ENXIO;
 			plugin = plugin->prev;
 			err = snd_pcm_plugin_alloc(plugin, frames);
 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 		plugin = snd_pcm_plug_last(plug);
 		while (plugin && drv_frames > 0) {
+			if (drv_frames > plugin->buf_frames)
+				drv_frames = plugin->buf_frames;
 			plugin_prev = plugin->prev;
 			if (plugin->src_frames)
 				drv_frames = plugin->src_frames(plugin, drv_frames);
 			plugin_next = plugin->next;
 			if (plugin->dst_frames)
 				drv_frames = plugin->dst_frames(plugin, drv_frames);
+			if (drv_frames > plugin->buf_frames)
+				drv_frames = plugin->buf_frames;
 			plugin = plugin_next;
 		}
 	} else
 				if (frames < 0)
 					return frames;
 			}
+			if (frames > plugin->buf_frames)
+				frames = plugin->buf_frames;
 			plugin = plugin_next;
 		}
 	} else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
 		plugin = snd_pcm_plug_last(plug);
 		while (plugin) {
+			if (frames > plugin->buf_frames)
+				frames = plugin->buf_frames;
 			plugin_prev = plugin->prev;
 			if (plugin->src_frames) {
 				frames = plugin->src_frames(plugin, frames);

sound/core/seq/oss/seq_oss_midi.c+1−0

@@ -602,6 +602,7 @@ send_midi_event(struct seq_oss_devinfo dp, struct snd_seq_event ev, struct seq · 601 unmodified lines
602	len = snd_seq_oss_timer_start(dp->timer);	602	len = snd_seq_oss_timer_start(dp->timer);
603	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {	603	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
604	snd_seq_oss_readq_sysex(dp->readq, mdev->seq_device, ev);	604	snd_seq_oss_readq_sysex(dp->readq, mdev->seq_device, ev);
		605	snd_midi_event_reset_decode(mdev->coder);
605	} else {	606	} else {
606	len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);	607	len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
607	if (len > 0)	608	if (len > 0)

sound/core/seq/seq_virmidi.c+1−0

@@ -81,6 +81,7 @@ static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev, · 80 unmodified lines
81	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)	81	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
82	continue;	82	continue;
83	snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream);	83	snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream);
		84	snd_midi_event_reset_decode(vmidi->parser);
84	} else {	85	} else {
85	len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev);	86	len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev);
86	if (len > 0)	87	if (len > 0)

sound/pci/hda/patch_realtek.c+25−0

@@ -8051,6 +8051,8 @@ static int patch_alc269(struct hda_codec *codec) · 8050 unmodified lines
8051	spec->gen.mixer_nid = 0;	8051	spec->gen.mixer_nid = 0;
8052	break;	8052	break;
8053	case 0x10ec0225:	8053	case 0x10ec0225:
		8054	codec->power_save_node = 1;
		8055	/* fall through */
8054	case 0x10ec0295:	8056	case 0x10ec0295:
8055	case 0x10ec0299:	8057	case 0x10ec0299:
8056	spec->codec_variant = ALC269_TYPE_ALC225;	8058	spec->codec_variant = ALC269_TYPE_ALC225;
@@ -8610,6 +8612,8 @@ enum { · 553 unmodified lines
8610	ALC669_FIXUP_ACER_ASPIRE_ETHOS,	8612	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
8611	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,	8613	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
8612	ALC671_FIXUP_HP_HEADSET_MIC2,	8614	ALC671_FIXUP_HP_HEADSET_MIC2,
		8615	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
		8616	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
8613	};	8617	};
8614		8618
8615	static const struct hda_fixup alc662_fixups[] = {	8619	static const struct hda_fixup alc662_fixups[] = {
@@ -8955,6 +8959,25 @@ static const struct hda_fixup alc662_fixups[] = { · 339 unmodified lines
8955	.type = HDA_FIXUP_FUNC,	8959	.type = HDA_FIXUP_FUNC,
8956	.v.func = alc671_fixup_hp_headset_mic2,	8960	.v.func = alc671_fixup_hp_headset_mic2,
8957	},	8961	},
		8962	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
		8963	.type = HDA_FIXUP_PINS,
		8964	.v.pins = (const struct hda_pintbl[]) {
		8965	{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
		8966	{ }
		8967	},
		8968	.chained = true,
		8969	.chain_id = ALC662_FIXUP_USI_FUNC
		8970	},
		8971	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
		8972	.type = HDA_FIXUP_PINS,
		8973	.v.pins = (const struct hda_pintbl[]) {
		8974	{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
		8975	{ 0x1b, 0x0221144f },
		8976	{ }
		8977	},
		8978	.chained = true,
		8979	.chain_id = ALC662_FIXUP_USI_FUNC
		8980	},
8958	};	8981	};
8959		8982
8960	static const struct snd_pci_quirk alc662_fixup_tbl[] = {	8983	static const struct snd_pci_quirk alc662_fixup_tbl[] = {
@@ -8966,6 +8989,8 @@ static const struct snd_pci_quirk alc662_fixup_tbl[] = { · 5 unmodified lines
8966	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),	8989	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
8967	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),	8990	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
8968	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),	8991	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
		8992	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
		8993	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
8969	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),	8994	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8970	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),	8995	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8971	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),	8996	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),

sound/usb/line6/driver.c+1−1

@@ -305,7 +305,7 @@ static void line6_data_received(struct urb *urb) · 304 unmodified lines
305	line6_midibuf_read(mb, line6->buffer_message,	305	line6_midibuf_read(mb, line6->buffer_message,
306	LINE6_MIDI_MESSAGE_MAXLEN);	306	LINE6_MIDI_MESSAGE_MAXLEN);
307		307
308	if (done == 0)	308	if (done <= 0)
309	break;	309	break;
310		310
311	line6->message_length = done;	311	line6->message_length = done;

sound/usb/line6/midibuf.c+1−1

@@ -159,7 +159,7 @@ int line6_midibuf_read(struct midi_buffer this, unsigned char data, · 158 unmodified lines
159	int midi_length_prev =	159	int midi_length_prev =
160	midibuf_message_length(this->command_prev);	160	midibuf_message_length(this->command_prev);
161		161
162	if (midi_length_prev > 0) {	162	if (midi_length_prev > 1) {
163	midi_length = midi_length_prev - 1;	163	midi_length = midi_length_prev - 1;
164	repeat = 1;	164	repeat = 1;
165	} else	165	} else

tools/include/uapi/asm/errno.h+7−7

@@ -1,18 +1,18 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	#if defined(__i386__) \|\| defined(__x86_64__)	2	#if defined(__i386__) \|\| defined(__x86_64__)
3	#include "../../arch/x86/include/uapi/asm/errno.h"	3	#include "../../../arch/x86/include/uapi/asm/errno.h"
4	#elif defined(__powerpc__)	4	#elif defined(__powerpc__)
5	#include "../../arch/powerpc/include/uapi/asm/errno.h"	5	#include "../../../arch/powerpc/include/uapi/asm/errno.h"
6	#elif defined(__sparc__)	6	#elif defined(__sparc__)
7	#include "../../arch/sparc/include/uapi/asm/errno.h"	7	#include "../../../arch/sparc/include/uapi/asm/errno.h"
8	#elif defined(__alpha__)	8	#elif defined(__alpha__)
9	#include "../../arch/alpha/include/uapi/asm/errno.h"	9	#include "../../../arch/alpha/include/uapi/asm/errno.h"
10	#elif defined(__mips__)	10	#elif defined(__mips__)
11	#include "../../arch/mips/include/uapi/asm/errno.h"	11	#include "../../../arch/mips/include/uapi/asm/errno.h"
12	#elif defined(__ia64__)	12	#elif defined(__ia64__)
13	#include "../../arch/ia64/include/uapi/asm/errno.h"	13	#include "../../../arch/ia64/include/uapi/asm/errno.h"
14	#elif defined(__xtensa__)	14	#elif defined(__xtensa__)
15	#include "../../arch/xtensa/include/uapi/asm/errno.h"	15	#include "../../../arch/xtensa/include/uapi/asm/errno.h"
16	#else	16	#else
17	#include <asm-generic/errno.h>	17	#include <asm-generic/errno.h>
18	#endif	18	#endif

tools/include/uapi/linux/in.h+2−0

 #define IPPROTO_UDPLITE		IPPROTO_UDPLITE
   IPPROTO_MPLS = 137,		/* MPLS in IP (RFC 4023)		*/
 #define IPPROTO_MPLS		IPPROTO_MPLS
+  IPPROTO_ETHERNET = 143,	/* Ethernet-within-IPv6 Encapsulation	*/
+#define IPPROTO_ETHERNET	IPPROTO_ETHERNET
   IPPROTO_RAW = 255,		/* Raw IP packets			*/
 #define IPPROTO_RAW		IPPROTO_RAW
   IPPROTO_MPTCP = 262,		/* Multipath TCP connection		*/

tools/perf/Makefile+1−1

@@ -35,7 +35,7 @@ endif · 34 unmodified lines
35	# Only pass canonical directory names as the output directory:	35	# Only pass canonical directory names as the output directory:
36	#	36	#
37	ifneq ($(O),)	37	ifneq ($(O),)
38	FULL_O := $(shell readlink -f $(O) \|\| echo $(O))	38	FULL_O := $(shell cd $(PWD); readlink -f $(O) \|\| echo $(O))
39	endif	39	endif
40		40
41	#	41	#

tools/perf/arch/arm64/util/arm-spe.c+10−10

@@ -11,17 +11,17 @@ · 10 unmodified lines
11	#include <linux/zalloc.h>	11	#include <linux/zalloc.h>
12	#include <time.h>	12	#include <time.h>
13		13
14	#include "../../util/cpumap.h"	14	#include "../../../util/cpumap.h"
15	#include "../../util/event.h"	15	#include "../../../util/event.h"
16	#include "../../util/evsel.h"	16	#include "../../../util/evsel.h"
17	#include "../../util/evlist.h"	17	#include "../../../util/evlist.h"
18	#include "../../util/session.h"	18	#include "../../../util/session.h"
19	#include <internal/lib.h> // page_size	19	#include <internal/lib.h> // page_size
20	#include "../../util/pmu.h"	20	#include "../../../util/pmu.h"
21	#include "../../util/debug.h"	21	#include "../../../util/debug.h"
22	#include "../../util/auxtrace.h"	22	#include "../../../util/auxtrace.h"
23	#include "../../util/record.h"	23	#include "../../../util/record.h"
24	#include "../../util/arm-spe.h"	24	#include "../../../util/arm-spe.h"
25		25
26	#define KiB(x) ((x) * 1024)	26	#define KiB(x) ((x) * 1024)
27	#define MiB(x) ((x) * 1024 * 1024)	27	#define MiB(x) ((x) * 1024 * 1024)

tools/perf/arch/arm64/util/perf_regs.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	#include "../../util/perf_regs.h"	2	#include "../../../util/perf_regs.h"
3		3
4	const struct sample_reg sample_reg_masks[] = {	4	const struct sample_reg sample_reg_masks[] = {
5	SMPL_REG_END	5	SMPL_REG_END

tools/perf/arch/powerpc/util/perf_regs.c+2−2

@@ -4,8 +4,8 @@ · 3 unmodified lines
4	#include <regex.h>	4	#include <regex.h>
5	#include <linux/zalloc.h>	5	#include <linux/zalloc.h>
6		6
7	#include "../../util/perf_regs.h"	7	#include "../../../util/perf_regs.h"
8	#include "../../util/debug.h"	8	#include "../../../util/debug.h"
9		9
10	#include <linux/kernel.h>	10	#include <linux/kernel.h>
11		11

tools/perf/arch/x86/util/auxtrace.c+7−7

@@ -7,13 +7,13 @@ · 6 unmodified lines
7	#include <errno.h>	7	#include <errno.h>
8	#include <stdbool.h>	8	#include <stdbool.h>
9		9
10	#include "../../util/header.h"	10	#include "../../../util/header.h"
11	#include "../../util/debug.h"	11	#include "../../../util/debug.h"
12	#include "../../util/pmu.h"	12	#include "../../../util/pmu.h"
13	#include "../../util/auxtrace.h"	13	#include "../../../util/auxtrace.h"
14	#include "../../util/intel-pt.h"	14	#include "../../../util/intel-pt.h"
15	#include "../../util/intel-bts.h"	15	#include "../../../util/intel-bts.h"
16	#include "../../util/evlist.h"	16	#include "../../../util/evlist.h"
17		17
18	static	18	static
19	struct auxtrace_record auxtrace_record__init_intel(struct evlist evlist,	19	struct auxtrace_record auxtrace_record__init_intel(struct evlist evlist,

tools/perf/arch/x86/util/event.c+6−6

@@ -3,12 +3,12 @@ · 2 unmodified lines
3	#include <linux/string.h>	3	#include <linux/string.h>
4	#include <linux/zalloc.h>	4	#include <linux/zalloc.h>
5		5
6	#include "../../util/event.h"	6	#include "../../../util/event.h"
7	#include "../../util/synthetic-events.h"	7	#include "../../../util/synthetic-events.h"
8	#include "../../util/machine.h"	8	#include "../../../util/machine.h"
9	#include "../../util/tool.h"	9	#include "../../../util/tool.h"
10	#include "../../util/map.h"	10	#include "../../../util/map.h"
11	#include "../../util/debug.h"	11	#include "../../../util/debug.h"
12		12
13	#if defined(__x86_64__)	13	#if defined(__x86_64__)
14		14

tools/perf/arch/x86/util/header.c+2−2

@@ -7,8 +7,8 @@ · 6 unmodified lines
7	#include <string.h>	7	#include <string.h>
8	#include <regex.h>	8	#include <regex.h>
9		9
10	#include "../../util/debug.h"	10	#include "../../../util/debug.h"
11	#include "../../util/header.h"	11	#include "../../../util/header.h"
12		12
13	static inline void	13	static inline void
14	cpuid(unsigned int op, unsigned int a, unsigned int b, unsigned int *c,	14	cpuid(unsigned int op, unsigned int a, unsigned int b, unsigned int *c,

tools/perf/arch/x86/util/intel-bts.c+12−12

@@ -11,18 +11,18 @@ · 10 unmodified lines
11	#include <linux/log2.h>	11	#include <linux/log2.h>
12	#include <linux/zalloc.h>	12	#include <linux/zalloc.h>
13		13
14	#include "../../util/cpumap.h"	14	#include "../../../util/cpumap.h"
15	#include "../../util/event.h"	15	#include "../../../util/event.h"
16	#include "../../util/evsel.h"	16	#include "../../../util/evsel.h"
17	#include "../../util/evlist.h"	17	#include "../../../util/evlist.h"
18	#include "../../util/mmap.h"	18	#include "../../../util/mmap.h"
19	#include "../../util/session.h"	19	#include "../../../util/session.h"
20	#include "../../util/pmu.h"	20	#include "../../../util/pmu.h"
21	#include "../../util/debug.h"	21	#include "../../../util/debug.h"
22	#include "../../util/record.h"	22	#include "../../../util/record.h"
23	#include "../../util/tsc.h"	23	#include "../../../util/tsc.h"
24	#include "../../util/auxtrace.h"	24	#include "../../../util/auxtrace.h"
25	#include "../../util/intel-bts.h"	25	#include "../../../util/intel-bts.h"
26	#include <internal/lib.h> // page_size	26	#include <internal/lib.h> // page_size
27		27
28	#define KiB(x) ((x) * 1024)	28	#define KiB(x) ((x) * 1024)

tools/perf/arch/x86/util/intel-pt.c+15−15

@@ -13,23 +13,23 @@ · 12 unmodified lines
13	#include <linux/zalloc.h>	13	#include <linux/zalloc.h>
14	#include <cpuid.h>	14	#include <cpuid.h>
15		15
16	#include "../../util/session.h"	16	#include "../../../util/session.h"
17	#include "../../util/event.h"	17	#include "../../../util/event.h"
18	#include "../../util/evlist.h"	18	#include "../../../util/evlist.h"
19	#include "../../util/evsel.h"	19	#include "../../../util/evsel.h"
20	#include "../../util/evsel_config.h"	20	#include "../../../util/evsel_config.h"
21	#include "../../util/cpumap.h"	21	#include "../../../util/cpumap.h"
22	#include "../../util/mmap.h"	22	#include "../../../util/mmap.h"
23	#include <subcmd/parse-options.h>	23	#include <subcmd/parse-options.h>
24	#include "../../util/parse-events.h"	24	#include "../../../util/parse-events.h"
25	#include "../../util/pmu.h"	25	#include "../../../util/pmu.h"
26	#include "../../util/debug.h"	26	#include "../../../util/debug.h"
27	#include "../../util/auxtrace.h"	27	#include "../../../util/auxtrace.h"
28	#include "../../util/record.h"	28	#include "../../../util/record.h"
29	#include "../../util/target.h"	29	#include "../../../util/target.h"
30	#include "../../util/tsc.h"	30	#include "../../../util/tsc.h"
31	#include <internal/lib.h> // page_size	31	#include <internal/lib.h> // page_size
32	#include "../../util/intel-pt.h"	32	#include "../../../util/intel-pt.h"
33		33
34	#define KiB(x) ((x) * 1024)	34	#define KiB(x) ((x) * 1024)
35	#define MiB(x) ((x) * 1024 * 1024)	35	#define MiB(x) ((x) * 1024 * 1024)

tools/perf/arch/x86/util/machine.c+3−3

@@ -5,9 +5,9 @@ · 4 unmodified lines
5	#include <stdlib.h>	5	#include <stdlib.h>
6		6
7	#include <internal/lib.h> // page_size	7	#include <internal/lib.h> // page_size
8	#include "../../util/machine.h"	8	#include "../../../util/machine.h"
9	#include "../../util/map.h"	9	#include "../../../util/map.h"
10	#include "../../util/symbol.h"	10	#include "../../../util/symbol.h"
11	#include <linux/ctype.h>	11	#include <linux/ctype.h>
12		12
13	#include <symbol/kallsyms.h>	13	#include <symbol/kallsyms.h>

tools/perf/arch/x86/util/perf_regs.c+4−4

@@ -5,10 +5,10 @@ · 4 unmodified lines
5	#include <linux/kernel.h>	5	#include <linux/kernel.h>
6	#include <linux/zalloc.h>	6	#include <linux/zalloc.h>
7		7
8	#include "../../perf-sys.h"	8	#include "../../../perf-sys.h"
9	#include "../../util/perf_regs.h"	9	#include "../../../util/perf_regs.h"
10	#include "../../util/debug.h"	10	#include "../../../util/debug.h"
11	#include "../../util/event.h"	11	#include "../../../util/event.h"
12		12
13	const struct sample_reg sample_reg_masks[] = {	13	const struct sample_reg sample_reg_masks[] = {
14	SMPL_REG(AX, PERF_REG_X86_AX),	14	SMPL_REG(AX, PERF_REG_X86_AX),

tools/perf/arch/x86/util/pmu.c+3−3

@@ -4,9 +4,9 @@ · 3 unmodified lines
4	#include <linux/stddef.h>	4	#include <linux/stddef.h>
5	#include <linux/perf_event.h>	5	#include <linux/perf_event.h>
6		6
7	#include "../../util/intel-pt.h"	7	#include "../../../util/intel-pt.h"
8	#include "../../util/intel-bts.h"	8	#include "../../../util/intel-bts.h"
9	#include "../../util/pmu.h"	9	#include "../../../util/pmu.h"
10		10
11	struct perf_event_attr perf_pmu__get_default_config(struct perf_pmu pmu __maybe_unused)	11	struct perf_event_attr perf_pmu__get_default_config(struct perf_pmu pmu __maybe_unused)
12	{	12	{

tools/perf/bench/bench.h+4−0

@@ -2,6 +2,10 @@ · 1 unmodified line
2	#ifndef BENCH_H	2	#ifndef BENCH_H
3	#define BENCH_H	3	#define BENCH_H
4		4
		5	#include <sys/time.h>
		6
		7	extern struct timeval bench__start, bench__end, bench__runtime;
		8
5	/*	9	/*
6	* The madvise transparent hugepage constants were added in glibc	10	* The madvise transparent hugepage constants were added in glibc
7	* 2.13. For compatibility with older versions of glibc, define these	11	* 2.13. For compatibility with older versions of glibc, define these

tools/perf/bench/epoll-ctl.c+4−4

 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 8;
-struct timeval start, end, runtime;
 static bool done, __verbose, randomize;
 /*
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void nest_epollfd(void)
 		exit(EXIT_FAILURE);
 	}
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	do_threads(worker, cpu);

tools/perf/bench/epoll-wait.c+6−6

 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 8;
-struct timeval start, end, runtime;
 static bool wdone, done, __verbose, randomize, nonblocking;
 /*
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void print_summary(void)
 	printf("\nAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
 		exit(EXIT_FAILURE);
 	}
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	do_threads(worker, cpu);
 		qsort(worker, nthreads, sizeof(struct worker), cmpworker);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);

tools/perf/bench/futex-hash.c+7−6

 static bool fshared = false, done = false, silent = false;
 static int futex_flag = 0;
-struct timeval start, end, runtime;
+struct timeval bench__start, bench__end, bench__runtime;
 static pthread_mutex_t thread_lock;
 static unsigned int threads_starting;
 static struct stats throughput_stats;
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void print_summary(void)
 	printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 int bench_futex_hash(int argc, const char **argv)
 	if (!cpu)
 		goto errmem;
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
 	pthread_attr_init(&thread_attr);
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	for (i = 0; i < nthreads; i++) {
 		worker[i].tid = i;
 		worker[i].futex = calloc(nfutexes, sizeof(*worker[i].futex));
 	pthread_mutex_destroy(&thread_lock);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);
 		if (!silent) {
 			if (nfutexes == 1)

tools/perf/bench/futex-lock-pi.c+6−6

 static bool done = false, fshared = false;
 static unsigned int nthreads = 0;
 static int futex_flag = 0;
-struct timeval start, end, runtime;
 static pthread_mutex_t thread_lock;
 static unsigned int threads_starting;
 static struct stats throughput_stats;
 	printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
-	       (int) runtime.tv_sec);
+	       (int)bench__runtime.tv_sec);
 }
 static void toggle_done(int sig __maybe_unused,
 {
 	/* inform all threads that we're done for the day */
 	done = true;
-	gettimeofday(&end, NULL);
+	gettimeofday(&bench__end, NULL);
-	timersub(&end, &start, &runtime);
+	timersub(&bench__end, &bench__start, &bench__runtime);
 }
 static void *workerfn(void *arg)
 	if (!cpu)
 		err(EXIT_FAILURE, "calloc");
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	threads_starting = nthreads;
 	pthread_attr_init(&thread_attr);
-	gettimeofday(&start, NULL);
+	gettimeofday(&bench__start, NULL);
 	create_threads(worker, thread_attr, cpu);
 	pthread_attr_destroy(&thread_attr);
 	pthread_mutex_destroy(&thread_lock);
 	for (i = 0; i < nthreads; i++) {
-		unsigned long t = worker[i].ops/runtime.tv_sec;
+		unsigned long t = worker[i].ops / bench__runtime.tv_sec;
 		update_stats(&throughput_stats, t);
 		if (!silent)

tools/perf/bench/futex-requeue.c+1−0

@@ -128,6 +128,7 @@ int bench_futex_requeue(int argc, const char **argv) · 127 unmodified lines
128	if (!cpu)	128	if (!cpu)
129	err(EXIT_FAILURE, "cpu_map__new");	129	err(EXIT_FAILURE, "cpu_map__new");
130		130
		131	memset(&act, 0, sizeof(act));
131	sigfillset(&act.sa_mask);	132	sigfillset(&act.sa_mask);
132	act.sa_sigaction = toggle_done;	133	act.sa_sigaction = toggle_done;
133	sigaction(SIGINT, &act, NULL);	134	sigaction(SIGINT, &act, NULL);

tools/perf/bench/futex-wake-parallel.c+1−0

@@ -234,6 +234,7 @@ int bench_futex_wake_parallel(int argc, const char **argv) · 233 unmodified lines
234	exit(EXIT_FAILURE);	234	exit(EXIT_FAILURE);
235	}	235	}
236		236
		237	memset(&act, 0, sizeof(act));
237	sigfillset(&act.sa_mask);	238	sigfillset(&act.sa_mask);
238	act.sa_sigaction = toggle_done;	239	act.sa_sigaction = toggle_done;
239	sigaction(SIGINT, &act, NULL);	240	sigaction(SIGINT, &act, NULL);

tools/perf/bench/futex-wake.c+3−2

 static pthread_mutex_t thread_lock;
 static pthread_cond_t thread_parent, thread_worker;
 static struct stats waketime_stats, wakeup_stats;
-static unsigned int ncpus, threads_starting, nthreads = 0;
+static unsigned int threads_starting, nthreads = 0;
 static int futex_flag = 0;
 static const struct option options[] = {
 	if (!cpu)
 		err(EXIT_FAILURE, "calloc");
+	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);
 	if (!nthreads)
-		nthreads = ncpus;
+		nthreads = cpu->nr;
 	worker = calloc(nthreads, sizeof(*worker));
 	if (!worker)

tools/perf/builtin-diff.c+2−1

@@ -1312,7 +1312,8 @@ static int cycles_printf(struct hist_entry he, struct hist_entry pair, · 1311 unmodified lines
1312	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,	1312	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
1313	he->ms.sym);	1313	he->ms.sym);
1314		1314
1315	if ((start_line != SRCLINE_UNKNOWN) && (end_line != SRCLINE_UNKNOWN)) {	1315	if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) &&
		1316	(strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) {
1316	scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",	1317	scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",
1317	start_line, end_line, block_he->diff.cycles);	1318	start_line, end_line, block_he->diff.cycles);
1318	} else {	1319	} else {

tools/perf/builtin-top.c+3−1

 	delay_msecs = top->delay_secs * MSEC_PER_SEC;
 	set_term_quiet_input(&save);
 	/* trash return*/
-	getc(stdin);
+	clearerr(stdin);
+	if (poll(&stdin_poll, 1, 0) > 0)
+		getc(stdin);
 	while (!done) {
 		perf_top__print_sym_table(top);

tools/perf/pmu-events/jevents.c+9−6

@@ -1082,10 +1082,9 @@ static int process_one_file(const char fpath, const struct stat sb, · 1081 unmodified lines
1082	*/	1082	*/
1083	int main(int argc, char *argv[])	1083	int main(int argc, char *argv[])
1084	{	1084	{
1085	int rc;	1085	int rc, ret = 0;
1086	int maxfds;	1086	int maxfds;
1087	char ldirname[PATH_MAX];	1087	char ldirname[PATH_MAX];
1088
1089	const char *arch;	1088	const char *arch;
1090	const char *output_file;	1089	const char *output_file;
1091	const char *start_dirname;	1090	const char *start_dirname;
@@ -1156,7 +1155,8 @@ int main(int argc, char *argv[]) · 64 unmodified lines
1156	/* Make build fail */	1155	/* Make build fail */
1157	fclose(eventsfp);	1156	fclose(eventsfp);
1158	free_arch_std_events();	1157	free_arch_std_events();
1159	return 1;	1158	ret = 1;
		1159	goto out_free_mapfile;
1160	} else if (rc) {	1160	} else if (rc) {
1161	goto empty_map;	1161	goto empty_map;
1162	}	1162	}
@@ -1174,14 +1174,17 @@ int main(int argc, char *argv[]) · 11 unmodified lines
1174	/* Make build fail */	1174	/* Make build fail */
1175	fclose(eventsfp);	1175	fclose(eventsfp);
1176	free_arch_std_events();	1176	free_arch_std_events();
1177	return 1;	1177	ret = 1;
1178	}	1178	}
1179		1179
1180	return 0;	1180
		1181	goto out_free_mapfile;
1181		1182
1182	empty_map:	1183	empty_map:
1183	fclose(eventsfp);	1184	fclose(eventsfp);
1184	create_empty_mapping(output_file);	1185	create_empty_mapping(output_file);
1185	free_arch_std_events();	1186	free_arch_std_events();
1186	return 0;	1187	out_free_mapfile:
		1188	free(mapfile);
		1189	return ret;
1187	}	1190	}

tools/perf/tests/bp_account.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	#include "../perf-sys.h"	19	#include "../perf-sys.h"
20	#include "cloexec.h"	20	#include "cloexec.h"
21		21
22	volatile long the_var;	22	static volatile long the_var;
23		23
24	static noinline int test_function(void)	24	static noinline int test_function(void)
25	{	25	{

tools/perf/util/block-info.c+2−1

@@ -295,7 +295,8 @@ static int block_range_entry(struct perf_hpp_fmt fmt, struct perf_hpp hpp, · 294 unmodified lines
295	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,	295	end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
296	he->ms.sym);	296	he->ms.sym);
297		297
298	if ((start_line != SRCLINE_UNKNOWN) && (end_line != SRCLINE_UNKNOWN)) {	298	if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) &&
		299	(strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) {
299	scnprintf(buf, sizeof(buf), "[%s -> %s]",	300	scnprintf(buf, sizeof(buf), "[%s -> %s]",
300	start_line, end_line);	301	start_line, end_line);
301	} else {	302	} else {

tools/perf/util/env.c+2−2

 const char *perf_env__arch(struct perf_env *env)
 {
-	struct utsname uts;
 	char *arch_name;
 	if (!env || !env->arch) { /* Assume local operation */
-		if (uname(&uts) < 0)
+		static struct utsname uts = { .machine[0] = '\0', };
+		if (uts.machine[0] == '\0' && uname(&uts) < 0)
 			return NULL;
 		arch_name = uts.machine;
 	} else

tools/perf/util/map.c+2−2

@@ -89,7 +89,7 @@ static inline bool replace_android_lib(const char filename, char newfilename) · 88 unmodified lines
89	return true;	89	return true;
90	}	90	}
91		91
92	if (!strncmp(filename, "/system/lib/", 11)) {	92	if (!strncmp(filename, "/system/lib/", 12)) {
93	char ndk, app;	93	char ndk, app;
94	const char *arch;	94	const char *arch;
95	size_t ndk_length;	95	size_t ndk_length;
@@ -431,7 +431,7 @@ int map__fprintf_srcline(struct map map, u64 addr, const char prefix, · 335 unmodified lines
431		431
432	if (map && map->dso) {	432	if (map && map->dso) {
433	char *srcline = map__srcline(map, addr, NULL);	433	char *srcline = map__srcline(map, addr, NULL);
434	if (srcline != SRCLINE_UNKNOWN)	434	if (strncmp(srcline, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)
435	ret = fprintf(fp, "%s%s", prefix, srcline);	435	ret = fprintf(fp, "%s%s", prefix, srcline);
436	free_srcline(srcline);	436	free_srcline(srcline);
437	}	437	}

tools/perf/util/parse-events.c+25−31

 				path = zalloc(sizeof(*path));
 				if (!path)
 					return NULL;
-				path->system = malloc(MAX_EVENT_LENGTH);
+				if (asprintf(&path->system, "%.*s", MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
-				if (!path->system) {
 					free(path);
 					return NULL;
 				}
-				path->name = malloc(MAX_EVENT_LENGTH);
+				if (asprintf(&path->name, "%.*s", MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
-				if (!path->name) {
 					zfree(&path->system);
 					free(path);
 					return NULL;
 				}
-				strncpy(path->system, sys_dirent->d_name,
-					MAX_EVENT_LENGTH);
-				strncpy(path->name, evt_dirent->d_name,
-					MAX_EVENT_LENGTH);
 				return path;
 			}
 		}
 static int get_config_terms(struct list_head *head_config,
 			    struct list_head *head_terms __maybe_unused)
 {
-#define ADD_CONFIG_TERM(__type)					\
+#define ADD_CONFIG_TERM(__type, __weak)				\
 	struct perf_evsel_config_term *__t;			\
 								\
 	__t = zalloc(sizeof(*__t));				\
 								\
 	INIT_LIST_HEAD(&__t->list);				\
 	__t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;	\
-	__t->weak	= term->weak;				\
+	__t->weak	= __weak;				\
 	list_add_tail(&__t->list, head_terms)
-#define ADD_CONFIG_TERM_VAL(__type, __name, __val)		\
+#define ADD_CONFIG_TERM_VAL(__type, __name, __val, __weak)	\
 do {								\
-	ADD_CONFIG_TERM(__type);				\
+	ADD_CONFIG_TERM(__type, __weak);			\
 	__t->val.__name = __val;				\
 } while (0)
-#define ADD_CONFIG_TERM_STR(__type, __val)			\
+#define ADD_CONFIG_TERM_STR(__type, __val, __weak)		\
 do {								\
-	ADD_CONFIG_TERM(__type);				\
+	ADD_CONFIG_TERM(__type, __weak);			\
 	__t->val.str = strdup(__val);				\
 	if (!__t->val.str) {					\
 		zfree(&__t);					\
 	list_for_each_entry(term, head_config, list) {
 		switch (term->type_term) {
 		case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
-			ADD_CONFIG_TERM_VAL(PERIOD, period, term->val.num);
+			ADD_CONFIG_TERM_VAL(PERIOD, period, term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
-			ADD_CONFIG_TERM_VAL(FREQ, freq, term->val.num);
+			ADD_CONFIG_TERM_VAL(FREQ, freq, term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_TIME:
-			ADD_CONFIG_TERM_VAL(TIME, time, term->val.num);
+			ADD_CONFIG_TERM_VAL(TIME, time, term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
-			ADD_CONFIG_TERM_STR(CALLGRAPH, term->val.str);
+			ADD_CONFIG_TERM_STR(CALLGRAPH, term->val.str, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
-			ADD_CONFIG_TERM_STR(BRANCH, term->val.str);
+			ADD_CONFIG_TERM_STR(BRANCH, term->val.str, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 			ADD_CONFIG_TERM_VAL(STACK_USER, stack_user,
-					    term->val.num);
+					    term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_INHERIT:
 			ADD_CONFIG_TERM_VAL(INHERIT, inherit,
-					    term->val.num ? 1 : 0);
+					    term->val.num ? 1 : 0, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
 			ADD_CONFIG_TERM_VAL(INHERIT, inherit,
-					    term->val.num ? 0 : 1);
+					    term->val.num ? 0 : 1, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
 			ADD_CONFIG_TERM_VAL(MAX_STACK, max_stack,
-					    term->val.num);
+					    term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
 			ADD_CONFIG_TERM_VAL(MAX_EVENTS, max_events,
-					    term->val.num);
+					    term->val.num, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
 			ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
-					    term->val.num ? 1 : 0);
+					    term->val.num ? 1 : 0, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
 			ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
-					    term->val.num ? 0 : 1);
+					    term->val.num ? 0 : 1, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
-			ADD_CONFIG_TERM_STR(DRV_CFG, term->val.str);
+			ADD_CONFIG_TERM_STR(DRV_CFG, term->val.str, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_PERCORE:
 			ADD_CONFIG_TERM_VAL(PERCORE, percore,
-					    term->val.num ? true : false);
+					    term->val.num ? true : false, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
 			ADD_CONFIG_TERM_VAL(AUX_OUTPUT, aux_output,
-					    term->val.num ? 1 : 0);
+					    term->val.num ? 1 : 0, term->weak);
 			break;
 		case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
 			ADD_CONFIG_TERM_VAL(AUX_SAMPLE_SIZE, aux_sample_size,
-					    term->val.num);
+					    term->val.num, term->weak);
 			break;
 		default:
 			break;
 	}
 	if (bits)
-		ADD_CONFIG_TERM_VAL(CFG_CHG, cfg_chg, bits);
+		ADD_CONFIG_TERM_VAL(CFG_CHG, cfg_chg, bits, false);
 #undef ADD_CONFIG_TERM
 	return 0;

tools/perf/util/probe-file.c+3−0

 		} else
 			ret = strlist__add(sl, tev.event);
 		clear_probe_trace_event(&tev);
+		/* Skip if there is same name multi-probe event in the list */
+		if (ret == -EEXIST)
+			ret = 0;
 		if (ret < 0)
 			break;
 	}

tools/perf/util/probe-finder.c+8−3

 		return -EINVAL;
 	}
-	/* Try to get actual symbol name from symtab */
+	if (dwarf_entrypc(sp_die, &eaddr) == 0) {
-	symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+		/* If the DIE has entrypc, use it. */
+		symbol = dwarf_diename(sp_die);
+	} else {
+		/* Try to get actual symbol name and address from symtab */
+		symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+		eaddr = sym.st_value;
+	}
 	if (!symbol) {
 		pr_warning("Failed to find symbol at 0x%lx\n",
 			   (unsigned long)paddr);
 		return -ENOENT;
 	}
-	eaddr = sym.st_value;
 	tp->offset = (unsigned long)(paddr - eaddr);
 	tp->address = (unsigned long)paddr;

tools/perf/util/setup.py+6−4

 from subprocess import Popen, PIPE
 from re import sub
+cc = getenv("CC")
+cc_is_clang = b"clang version" in Popen([cc, "-v"], stderr=PIPE).stderr.readline()
 def clang_has_option(option):
-    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if b"unknown argument" in o] == [ ]
+    return [o for o in Popen([cc, option], stderr=PIPE).stderr.readlines() if b"unknown argument" in o] == [ ]
-cc = getenv("CC")
+if cc_is_clang:
-if cc == "clang":
     from distutils.sysconfig import get_config_vars
     vars = get_config_vars()
     for var in ('CFLAGS', 'OPT'):
 cflags = getenv('CFLAGS', '').split()
 # switch off several checks (need to be at the end of cflags list)
 cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter', '-Wno-redundant-decls' ]
-if cc != "clang":
+if not cc_is_clang:
     cflags += ['-Wno-cast-function-type' ]
 src_perf  = getenv('srctree') + '/tools/perf'

tools/perf/util/symbol.c+6−7

 		goto out;
 	}
-	if (dso->kernel) {
+	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
+		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
+		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
+		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
+	if (dso->kernel && !kmod) {
 		if (dso->kernel == DSO_TYPE_KERNEL)
 			ret = dso__load_kernel_sym(dso, map);
 		else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 	if (!name)
 		goto out;
-	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
-		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
-		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
-		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
 	/*
 	 * Read the build id if possible. This is required for
 	 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c+1−1

@@ -82,7 +82,7 @@ static struct pci_access *pci_acc; · 81 unmodified lines
82	static struct pci_dev *amd_fam14h_pci_dev;	82	static struct pci_dev *amd_fam14h_pci_dev;
83	static int nbp1_entered;	83	static int nbp1_entered;
84		84
85	struct timespec start_time;	85	static struct timespec start_time;
86	static unsigned long long timediff;	86	static unsigned long long timediff;
87		87
88	#ifdef DEBUG	88	#ifdef DEBUG

tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c+1−1

@@ -19,7 +19,7 @@ struct cpuidle_monitor cpuidle_sysfs_monitor; · 18 unmodified lines
19		19
20	static unsigned long long **previous_count;	20	static unsigned long long **previous_count;
21	static unsigned long long **current_count;	21	static unsigned long long **current_count;
22	struct timespec start_time;	22	static struct timespec start_time;
23	static unsigned long long timediff;	23	static unsigned long long timediff;
24		24
25	static int cpuidle_get_count_percent(unsigned int id, double *percent,	25	static int cpuidle_get_count_percent(unsigned int id, double *percent,

tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c+2−0

@@ -27,6 +27,8 @@ struct cpuidle_monitor *all_monitors[] = { · 26 unmodified lines
27	0	27	0
28	};	28	};
29		29
		30	int cpu_count;
		31
30	static struct cpuidle_monitor *monitors[MONITORS_MAX];	32	static struct cpuidle_monitor *monitors[MONITORS_MAX];
31	static unsigned int avail_monitors;	33	static unsigned int avail_monitors;
32		34

tools/power/cpupower/utils/idle_monitor/cpupower-monitor.h+1−1

@@ -25,7 +25,7 @@ · 24 unmodified lines
25	#endif	25	#endif
26	#define CSTATE_DESC_LEN 60	26	#define CSTATE_DESC_LEN 60
27		27
28	int cpu_count;	28	extern int cpu_count;
29		29
30	/* Hard to define the right names ...: */	30	/* Hard to define the right names ...: */
31	enum power_range_e {	31	enum power_range_e {

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

@@ -16,7 +16,7 @@ override CFLAGS += -D_FORTIFY_SOURCE=2 · 15 unmodified lines
16		16
17	%: %.c	17	%: %.c
18	@mkdir -p $(BUILD_OUTPUT)	18	@mkdir -p $(BUILD_OUTPUT)
19	$(CC) $(CFLAGS) $< -o $(BUILD_OUTPUT)/$@ $(LDFLAGS)	19	$(CC) $(CFLAGS) $< -o $(BUILD_OUTPUT)/$@ $(LDFLAGS) -lcap
20		20
21	.PHONY : clean	21	.PHONY : clean
22	clean :	22	clean :

tools/power/x86/turbostat/turbostat.c+113−29

 #include <sched.h>
 #include <time.h>
 #include <cpuid.h>
-#include <linux/capability.h>
+#include <sys/capability.h>
 #include <errno.h>
 #include <math.h>
 void setup_all_buffers(void);
+char *sys_lpi_file;
+char *sys_lpi_file_sysfs = "/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us";
+char *sys_lpi_file_debugfs = "/sys/kernel/debug/pmc_core/slp_s0_residency_usec";
 int cpu_is_not_present(int cpu)
 {
 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
  *
  * record snapshot of
  * /sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us
- *
- * return 1 if config change requires a restart, else return 0
  */
 int snapshot_cpu_lpi_us(void)
 {
 /*
  * snapshot_sys_lpi()
  *
- * record snapshot of
+ * record snapshot of sys_lpi_file
- * /sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us
- *
- * return 1 if config change requires a restart, else return 0
  */
 int snapshot_sys_lpi_us(void)
 {
 	FILE *fp;
 	int retval;
-	fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", "r");
+	fp = fopen_or_die(sys_lpi_file, "r");
 	retval = fscanf(fp, "%lld", &cpuidle_cur_sys_lpi_us);
 	if (retval != 1) {
 			err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
 }
-void check_permissions()
+/*
+ * check for CAP_SYS_RAWIO
+ * return 0 on success
+ * return 1 on fail
+ */
+int check_for_cap_sys_rawio(void)
 {
-	struct __user_cap_header_struct cap_header_data;
+	cap_t caps;
-	cap_user_header_t cap_header = &cap_header_data;
+	cap_flag_value_t cap_flag_value;
-	struct __user_cap_data_struct cap_data_data;
-	cap_user_data_t cap_data = &cap_data_data;
-	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
-	int do_exit = 0;
-	char pathname[32];
-	/* check for CAP_SYS_RAWIO */
+	caps = cap_get_proc();
-	cap_header->pid = getpid();
+	if (caps == NULL)
-	cap_header->version = _LINUX_CAPABILITY_VERSION;
+		err(-6, "cap_get_proc\n");
-	if (capget(cap_header, cap_data) < 0)
-		err(-6, "capget(2) failed");
-	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
+	if (cap_get_flag(caps, CAP_SYS_RAWIO, CAP_EFFECTIVE, &cap_flag_value))
-		do_exit++;
+		err(-6, "cap_get\n");
+	if (cap_flag_value != CAP_SET) {
 		warnx("capget(CAP_SYS_RAWIO) failed,"
 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
+		return 1;
 	}
+	if (cap_free(caps) == -1)
+		err(-6, "cap_free\n");
+	return 0;
+}
+void check_permissions(void)
+{
+	int do_exit = 0;
+	char pathname[32];
+	/* check for CAP_SYS_RAWIO */
+	do_exit += check_for_cap_sys_rawio();
 	/* test file permissions */
 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
 	if (euidaccess(pathname, R_OK)) {
 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
 	case INTEL_FAM6_ATOM_GOLDMONT_D:	/* DNV */
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
 		pkg_cstate_limits = glm_pkg_cstate_limits;
 		break;
 	default:
 	}
 	return 0;
 }
+int is_ehl(unsigned int family, unsigned int model)
+{
+	if (!genuine_intel)
+		return 0;
+	switch (model) {
+	case INTEL_FAM6_ATOM_TREMONT:
+		return 1;
+	}
+	return 0;
+}
 int has_turbo_ratio_limit(unsigned int family, unsigned int model)
 {
 	dump_nhm_cst_cfg();
 }
+static void dump_sysfs_file(char *path)
+{
+	FILE *input;
+	char cpuidle_buf[64];
+	input = fopen(path, "r");
+	if (input == NULL) {
+		if (debug)
+			fprintf(outf, "NSFOD %s\n", path);
+		return;
+	}
+	if (!fgets(cpuidle_buf, sizeof(cpuidle_buf), input))
+		err(1, "%s: failed to read file", path);
+	fclose(input);
+	fprintf(outf, "%s: %s", strrchr(path, '/') + 1, cpuidle_buf);
+}
 static void
 dump_sysfs_cstate_config(void)
 {
 	if (!DO_BIC(BIC_sysfs))
 		return;
+	if (access("/sys/devices/system/cpu/cpuidle", R_OK)) {
+		fprintf(outf, "cpuidle not loaded\n");
+		return;
+	}
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_driver");
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_governor");
+	dump_sysfs_file("/sys/devices/system/cpu/cpuidle/current_governor_ro");
 	for (state = 0; state < 10; ++state) {
 		sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/name",
 		else
 			BIC_PRESENT(BIC_PkgWatt);
 		break;
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
+		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
+		if (rapl_joules) {
+			BIC_PRESENT(BIC_Pkg_J);
+			BIC_PRESENT(BIC_Cor_J);
+			BIC_PRESENT(BIC_RAM_J);
+			BIC_PRESENT(BIC_GFX_J);
+		} else {
+			BIC_PRESENT(BIC_PkgWatt);
+			BIC_PRESENT(BIC_CorWatt);
+			BIC_PRESENT(BIC_RAMWatt);
+			BIC_PRESENT(BIC_GFXWatt);
+		}
+		break;
 	case INTEL_FAM6_SKYLAKE_L:	/* SKL */
 	case INTEL_FAM6_CANNONLAKE_L:	/* CNL */
 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
 	case INTEL_FAM6_ATOM_GOLDMONT:		/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
 	case INTEL_FAM6_ATOM_GOLDMONT_D:	/* DNV */
+	case INTEL_FAM6_ATOM_TREMONT:		/* EHL */
 		return 1;
 	}
 	return 0;
 	case INTEL_FAM6_CANNONLAKE_L:	/* CNL */
 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
 	case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+	case INTEL_FAM6_ATOM_TREMONT:	/* EHL */
 		return 1;
 	}
 	return 0;
 	case INTEL_FAM6_SKYLAKE:
 	case INTEL_FAM6_KABYLAKE_L:
 	case INTEL_FAM6_KABYLAKE:
+	case INTEL_FAM6_COMETLAKE_L:
+	case INTEL_FAM6_COMETLAKE:
 		return INTEL_FAM6_SKYLAKE_L;
 	case INTEL_FAM6_ICELAKE_L:
 	case INTEL_FAM6_ICELAKE_NNPI:
+	case INTEL_FAM6_TIGERLAKE_L:
+	case INTEL_FAM6_TIGERLAKE:
 		return INTEL_FAM6_CANNONLAKE_L;
 	case INTEL_FAM6_ATOM_TREMONT_D:
 		return INTEL_FAM6_ATOM_GOLDMONT_D;
+	case INTEL_FAM6_ATOM_TREMONT_L:
+		return INTEL_FAM6_ATOM_TREMONT;
+	case INTEL_FAM6_ICELAKE_X:
+		return INTEL_FAM6_SKYLAKE_X;
 	}
 	return model;
 }
 	do_slm_cstates = is_slm(family, model);
 	do_knl_cstates  = is_knl(family, model);
-	if (do_slm_cstates || do_knl_cstates || is_cnl(family, model))
+	if (do_slm_cstates || do_knl_cstates || is_cnl(family, model) ||
+	    is_ehl(family, model))
 		BIC_NOT_PRESENT(BIC_CPU_c3);
 	if (!quiet)
 	else
 		BIC_NOT_PRESENT(BIC_CPU_LPI);
-	if (!access("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", R_OK))
+	if (!access(sys_lpi_file_sysfs, R_OK)) {
+		sys_lpi_file = sys_lpi_file_sysfs;
 		BIC_PRESENT(BIC_SYS_LPI);
-	else
+	} else if (!access(sys_lpi_file_debugfs, R_OK)) {
+		sys_lpi_file = sys_lpi_file_debugfs;
+		BIC_PRESENT(BIC_SYS_LPI);
+	} else {
+		sys_lpi_file_sysfs = NULL;
 		BIC_NOT_PRESENT(BIC_SYS_LPI);
+	}
 	if (!quiet)
 		decode_misc_feature_control();
 }
 void print_version() {
-	fprintf(outf, "turbostat version 19.08.31"
+	fprintf(outf, "turbostat version 20.03.20"
 		" - Len Brown <lenb@kernel.org>\n");
 }
 	}
 	msrp->msr_num = msr_num;
-	strncpy(msrp->name, name, NAME_BYTES);
+	strncpy(msrp->name, name, NAME_BYTES - 1);
 	if (path)
-		strncpy(msrp->path, path, PATH_BYTES);
+		strncpy(msrp->path, path, PATH_BYTES - 1);
 	msrp->width = width;
 	msrp->type = type;
 	msrp->format = format;

tools/scripts/Makefile.include+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	ifneq ($(O),)	2	ifneq ($(O),)
3	ifeq ($(origin O), command line)	3	ifeq ($(origin O), command line)
4	dummy := $(if $(shell test -d $(O) \|\| echo $(O)),$(error O=$(O) does not exist),)	4	dummy := $(if $(shell cd $(PWD); test -d $(O) \|\| echo $(O)),$(error O=$(O) does not exist),)
5	ABSOLUTE_O := $(shell cd $(O) ; pwd)	5	ABSOLUTE_O := $(shell cd $(PWD); cd $(O) ; pwd)
6	OUTPUT := $(ABSOLUTE_O)/$(if $(subdir),$(subdir)/)	6	OUTPUT := $(ABSOLUTE_O)/$(if $(subdir),$(subdir)/)
7	COMMAND_O := O=$(ABSOLUTE_O)	7	COMMAND_O := O=$(ABSOLUTE_O)
8	ifeq ($(objtree),)	8	ifeq ($(objtree),)

tools/testing/selftests/Makefile+1−0

@@ -33,6 +33,7 @@ TARGETS += memory-hotplug · 32 unmodified lines
33	TARGETS += mount	33	TARGETS += mount
34	TARGETS += mqueue	34	TARGETS += mqueue
35	TARGETS += net	35	TARGETS += net
		36	TARGETS += net/forwarding
36	TARGETS += net/mptcp	37	TARGETS += net/mptcp
37	TARGETS += netfilter	38	TARGETS += netfilter
38	TARGETS += networking/timestamping	39	TARGETS += networking/timestamping

tools/testing/selftests/bpf/prog_tests/send_signal_sched_switch.c+60−0

@@ -0,0 +1,60 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <test_progs.h>
	3	#include <stdio.h>
	4	#include <stdlib.h>
	5	#include <sys/mman.h>
	6	#include <pthread.h>
	7	#include <sys/types.h>
	8	#include <sys/stat.h>
	9	#include <fcntl.h>
	10	#include "test_send_signal_kern.skel.h"
	11
	12	static void sigusr1_handler(int signum)
	13	{
	14	}
	15
	16	#define THREAD_COUNT 100
	17
	18	static void worker(void p)
	19	{
	20	int i;
	21
	22	for ( i = 0; i < 1000; i++)
	23	usleep(1);
	24
	25	return NULL;
	26	}
	27
	28	void test_send_signal_sched_switch(void)
	29	{
	30	struct test_send_signal_kern *skel;
	31	pthread_t threads[THREAD_COUNT];
	32	u32 duration = 0;
	33	int i, err;
	34
	35	signal(SIGUSR1, sigusr1_handler);
	36
	37	skel = test_send_signal_kern__open_and_load();
	38	if (CHECK(!skel, "skel_open_and_load", "skeleton open_and_load failed\n"))
	39	return;
	40
	41	skel->bss->pid = getpid();
	42	skel->bss->sig = SIGUSR1;
	43
	44	err = test_send_signal_kern__attach(skel);
	45	if (CHECK(err, "skel_attach", "skeleton attach failed\n"))
	46	goto destroy_skel;
	47
	48	for (i = 0; i < THREAD_COUNT; i++) {
	49	err = pthread_create(threads + i, NULL, worker, NULL);
	50	if (CHECK(err, "pthread_create", "Error creating thread, %s\n",
	51	strerror(errno)))
	52	goto destroy_skel;
	53	}
	54
	55	for (i = 0; i < THREAD_COUNT; i++)
	56	pthread_join(threads[i], NULL);
	57
	58	destroy_skel:
	59	test_send_signal_kern__destroy(skel);
	60	}

tools/testing/selftests/bpf/progs/test_send_signal_kern.c+6−0

 	return bpf_send_signal_test(ctx);
 }
+SEC("tracepoint/sched/sched_switch")
+int send_signal_tp_sched(void *ctx)
+{
+	return bpf_send_signal_test(ctx);
+}
 SEC("perf_event")
 int send_signal_perf(void *ctx)
 {

tools/testing/selftests/bpf/test_btf.c+42−0

@@ -1062,6 +1062,48 @@ static struct btf_raw_test raw_tests[] = { · 1061 unmodified lines
1062	.err_str = "Member exceeds struct_size",	1062	.err_str = "Member exceeds struct_size",
1063	},	1063	},
1064		1064
		1065	/* Test member unexceeds the size of struct
		1066	*
		1067	* enum E {
		1068	* E0,
		1069	* E1,
		1070	* };
		1071	*
		1072	* struct A {
		1073	* char m;
		1074	* enum E __attribute__((packed)) n;
		1075	* };
		1076	*/
		1077	{
		1078	.descr = "size check test #5",
		1079	.raw_types = {
		1080	/* int / / [1] */
		1081	BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
		1082	/* char / / [2] */
		1083	BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),
		1084	/* enum E { / / [3] */
		1085	BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 1),
		1086	BTF_ENUM_ENC(NAME_TBD, 0),
		1087	BTF_ENUM_ENC(NAME_TBD, 1),
		1088	/* } */
		1089	/* struct A { / / [4] */
		1090	BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 2),
		1091	BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* char m; */
		1092	BTF_MEMBER_ENC(NAME_TBD, 3, 8),/* enum E __attribute__((packed)) n; */
		1093	/* } */
		1094	BTF_END_RAW,
		1095	},
		1096	.str_sec = "\0E\0E0\0E1\0A\0m\0n",
		1097	.str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
		1098	.map_type = BPF_MAP_TYPE_ARRAY,
		1099	.map_name = "size_check5_map",
		1100	.key_size = sizeof(int),
		1101	.value_size = 2,
		1102	.key_type_id = 1,
		1103	.value_type_id = 4,
		1104	.max_entries = 4,
		1105	},
		1106
1065	/* typedef const void * const_void_ptr;	1107	/* typedef const void * const_void_ptr;
1066	* struct A {	1108	* struct A {
1067	* const_void_ptr m;	1109	* const_void_ptr m;

tools/testing/selftests/bpf/verifier/jmp32.c+15−0

@@ -61,6 +61,21 @@ · 60 unmodified lines
61	},	61	},
62	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	62	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
63	},	63	},
		64	{
		65	"jset32: ignores upper bits",
		66	.insns = {
		67	BPF_MOV64_IMM(BPF_REG_0, 0),
		68	BPF_LD_IMM64(BPF_REG_7, 0x8000000000000000),
		69	BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
		70	BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
		71	BPF_EXIT_INSN(),
		72	BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
		73	BPF_MOV64_IMM(BPF_REG_0, 2),
		74	BPF_EXIT_INSN(),
		75	},
		76	.result = ACCEPT,
		77	.retval = 2,
		78	},
64	{	79	{
65	"jset32: min/max deduction",	80	"jset32: min/max deduction",
66	.insns = {	81	.insns = {

tools/testing/selftests/net/Makefile+3−1

 TEST_PROGS += udpgro_bench.sh udpgro.sh test_vxlan_under_vrf.sh reuseport_addr_any.sh
 TEST_PROGS += test_vxlan_fdb_changelink.sh so_txtime.sh ipv6_flowlabel.sh
 TEST_PROGS += tcp_fastopen_backup_key.sh fcnal-test.sh l2tp.sh traceroute.sh
-TEST_PROGS += fin_ack_lat.sh
+TEST_PROGS += fin_ack_lat.sh fib_nexthop_multiprefix.sh fib_nexthops.sh
+TEST_PROGS += altnames.sh icmp_redirect.sh ip6_gre_headroom.sh
+TEST_PROGS += route_localnet.sh
 TEST_PROGS += reuseaddr_ports_exhausted.sh
 TEST_PROGS_EXTENDED := in_netns.sh
 TEST_GEN_FILES =  socket nettest

tools/testing/selftests/net/forwarding/Makefile+76−0

@@ -0,0 +1,76 @@
	1	# SPDX-License-Identifier: GPL-2.0+ OR MIT
	2
	3	TEST_PROGS = bridge_igmp.sh \
	4	bridge_port_isolation.sh \
	5	bridge_sticky_fdb.sh \
	6	bridge_vlan_aware.sh \
	7	bridge_vlan_unaware.sh \
	8	ethtool.sh \
	9	gre_inner_v4_multipath.sh \
	10	gre_inner_v6_multipath.sh \
	11	gre_multipath.sh \
	12	ip6gre_inner_v4_multipath.sh \
	13	ip6gre_inner_v6_multipath.sh \
	14	ipip_flat_gre_key.sh \
	15	ipip_flat_gre_keys.sh \
	16	ipip_flat_gre.sh \
	17	ipip_hier_gre_key.sh \
	18	ipip_hier_gre_keys.sh \
	19	ipip_hier_gre.sh \
	20	loopback.sh \
	21	mirror_gre_bound.sh \
	22	mirror_gre_bridge_1d.sh \
	23	mirror_gre_bridge_1d_vlan.sh \
	24	mirror_gre_bridge_1q_lag.sh \
	25	mirror_gre_bridge_1q.sh \
	26	mirror_gre_changes.sh \
	27	mirror_gre_flower.sh \
	28	mirror_gre_lag_lacp.sh \
	29	mirror_gre_neigh.sh \
	30	mirror_gre_nh.sh \
	31	mirror_gre.sh \
	32	mirror_gre_vlan_bridge_1q.sh \
	33	mirror_gre_vlan.sh \
	34	mirror_vlan.sh \
	35	router_bridge.sh \
	36	router_bridge_vlan.sh \
	37	router_broadcast.sh \
	38	router_mpath_nh.sh \
	39	router_multicast.sh \
	40	router_multipath.sh \
	41	router.sh \
	42	router_vid_1.sh \
	43	sch_ets.sh \
	44	sch_tbf_ets.sh \
	45	sch_tbf_prio.sh \
	46	sch_tbf_root.sh \
	47	tc_actions.sh \
	48	tc_chains.sh \
	49	tc_flower_router.sh \
	50	tc_flower.sh \
	51	tc_shblocks.sh \
	52	tc_vlan_modify.sh \
	53	vxlan_asymmetric.sh \
	54	vxlan_bridge_1d_port_8472.sh \
	55	vxlan_bridge_1d.sh \
	56	vxlan_bridge_1q_port_8472.sh \
	57	vxlan_bridge_1q.sh \
	58	vxlan_symmetric.sh
	59
	60	TEST_PROGS_EXTENDED := devlink_lib.sh \
	61	ethtool_lib.sh \
	62	fib_offload_lib.sh \
	63	forwarding.config.sample \
	64	ipip_lib.sh \
	65	lib.sh \
	66	mirror_gre_lib.sh \
	67	mirror_gre_topo_lib.sh \
	68	mirror_lib.sh \
	69	mirror_topo_lib.sh \
	70	sch_ets_core.sh \
	71	sch_ets_tests.sh \
	72	sch_tbf_core.sh \
	73	sch_tbf_etsprio.sh \
	74	tc_common.sh
	75
	76	include ../../lib.mk

tools/testing/selftests/net/forwarding/ethtool_lib.sh+0−0

File mode changed from 100755 to 100644.

tools/testing/selftests/net/reuseport_addr_any.c+4−0

 #include <sys/socket.h>
 #include <unistd.h>
+#ifndef SOL_DCCP
+#define SOL_DCCP 269
+#endif
 static const char *IP4_ADDR = "127.0.0.1";
 static const char *IP6_ADDR = "::1";
 static const char *IP4_MAPPED6 = "::ffff:127.0.0.1";

tools/testing/selftests/netfilter/Makefile+5−1

@@ -3,6 +3,10 @@ · 2 unmodified lines
3		3
4	TEST_PROGS := nft_trans_stress.sh nft_nat.sh bridge_brouter.sh \	4	TEST_PROGS := nft_trans_stress.sh nft_nat.sh bridge_brouter.sh \
5	conntrack_icmp_related.sh nft_flowtable.sh ipvs.sh \	5	conntrack_icmp_related.sh nft_flowtable.sh ipvs.sh \
6	nft_concat_range.sh	6	nft_concat_range.sh \
		7	nft_queue.sh
		8
		9	LDLIBS = -lmnl
		10	TEST_GEN_FILES = nf-queue
7		11
8	include ../lib.mk	12	include ../lib.mk

tools/testing/selftests/netfilter/config+6−0

@@ -1,2 +1,8 @@
1	CONFIG_NET_NS=y	1	CONFIG_NET_NS=y
2	CONFIG_NF_TABLES_INET=y	2	CONFIG_NF_TABLES_INET=y
		3	CONFIG_NFT_QUEUE=m
		4	CONFIG_NFT_NAT=m
		5	CONFIG_NFT_REDIR=m
		6	CONFIG_NFT_MASQ=m
		7	CONFIG_NFT_FLOW_OFFLOAD=m
		8	CONFIG_NF_CT_NETLINK=m

tools/testing/selftests/netfilter/nf-queue.c+352−0

@@ -0,0 +1,352 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#include <errno.h>
	4	#include <stdbool.h>
	5	#include <stdio.h>
	6	#include <stdint.h>
	7	#include <stdlib.h>
	8	#include <unistd.h>
	9	#include <string.h>
	10	#include <time.h>
	11	#include <arpa/inet.h>
	12
	13	#include <libmnl/libmnl.h>
	14	#include <linux/netfilter.h>
	15	#include <linux/netfilter/nfnetlink.h>
	16	#include <linux/netfilter/nfnetlink_queue.h>
	17
	18	struct options {
	19	bool count_packets;
	20	int verbose;
	21	unsigned int queue_num;
	22	unsigned int timeout;
	23	};
	24
	25	static unsigned int queue_stats[5];
	26	static struct options opts;
	27
	28	static void help(const char *p)
	29	{
	30	printf("Usage: %s [-c\|-v [-vv] ] [-t timeout] [-q queue_num]\n", p);
	31	}
	32
	33	static int parse_attr_cb(const struct nlattr attr, void data)
	34	{
	35	const struct nlattr **tb = data;
	36	int type = mnl_attr_get_type(attr);
	37
	38	/* skip unsupported attribute in user-space */
	39	if (mnl_attr_type_valid(attr, NFQA_MAX) < 0)
	40	return MNL_CB_OK;
	41
	42	switch (type) {
	43	case NFQA_MARK:
	44	case NFQA_IFINDEX_INDEV:
	45	case NFQA_IFINDEX_OUTDEV:
	46	case NFQA_IFINDEX_PHYSINDEV:
	47	case NFQA_IFINDEX_PHYSOUTDEV:
	48	if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0) {
	49	perror("mnl_attr_validate");
	50	return MNL_CB_ERROR;
	51	}
	52	break;
	53	case NFQA_TIMESTAMP:
	54	if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC,
	55	sizeof(struct nfqnl_msg_packet_timestamp)) < 0) {
	56	perror("mnl_attr_validate2");
	57	return MNL_CB_ERROR;
	58	}
	59	break;
	60	case NFQA_HWADDR:
	61	if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC,
	62	sizeof(struct nfqnl_msg_packet_hw)) < 0) {
	63	perror("mnl_attr_validate2");
	64	return MNL_CB_ERROR;
	65	}
	66	break;
	67	case NFQA_PAYLOAD:
	68	break;
	69	}
	70	tb[type] = attr;
	71	return MNL_CB_OK;
	72	}
	73
	74	static int queue_cb(const struct nlmsghdr nlh, void data)
	75	{
	76	struct nlattr *tb[NFQA_MAX+1] = { 0 };
	77	struct nfqnl_msg_packet_hdr *ph = NULL;
	78	uint32_t id = 0;
	79
	80	(void)data;
	81
	82	mnl_attr_parse(nlh, sizeof(struct nfgenmsg), parse_attr_cb, tb);
	83	if (tb[NFQA_PACKET_HDR]) {
	84	ph = mnl_attr_get_payload(tb[NFQA_PACKET_HDR]);
	85	id = ntohl(ph->packet_id);
	86
	87	if (opts.verbose > 0)
	88	printf("packet hook=%u, hwproto 0x%x",
	89	ntohs(ph->hw_protocol), ph->hook);
	90
	91	if (ph->hook >= 5) {
	92	fprintf(stderr, "Unknown hook %d\n", ph->hook);
	93	return MNL_CB_ERROR;
	94	}
	95
	96	if (opts.verbose > 0) {
	97	uint32_t skbinfo = 0;
	98
	99	if (tb[NFQA_SKB_INFO])
	100	skbinfo = ntohl(mnl_attr_get_u32(tb[NFQA_SKB_INFO]));
	101	if (skbinfo & NFQA_SKB_CSUMNOTREADY)
	102	printf(" csumnotready");
	103	if (skbinfo & NFQA_SKB_GSO)
	104	printf(" gso");
	105	if (skbinfo & NFQA_SKB_CSUM_NOTVERIFIED)
	106	printf(" csumnotverified");
	107	puts("");
	108	}
	109
	110	if (opts.count_packets)
	111	queue_stats[ph->hook]++;
	112	}
	113
	114	return MNL_CB_OK + id;
	115	}
	116
	117	static struct nlmsghdr *
	118	nfq_build_cfg_request(char *buf, uint8_t command, int queue_num)
	119	{
	120	struct nlmsghdr *nlh = mnl_nlmsg_put_header(buf);
	121	struct nfqnl_msg_config_cmd cmd = {
	122	.command = command,
	123	.pf = htons(AF_INET),
	124	};
	125	struct nfgenmsg *nfg;
	126
	127	nlh->nlmsg_type = (NFNL_SUBSYS_QUEUE << 8) \| NFQNL_MSG_CONFIG;
	128	nlh->nlmsg_flags = NLM_F_REQUEST;
	129
	130	nfg = mnl_nlmsg_put_extra_header(nlh, sizeof(*nfg));
	131
	132	nfg->nfgen_family = AF_UNSPEC;
	133	nfg->version = NFNETLINK_V0;
	134	nfg->res_id = htons(queue_num);
	135
	136	mnl_attr_put(nlh, NFQA_CFG_CMD, sizeof(cmd), &cmd);
	137
	138	return nlh;
	139	}
	140
	141	static struct nlmsghdr *
	142	nfq_build_cfg_params(char *buf, uint8_t mode, int range, int queue_num)
	143	{
	144	struct nlmsghdr *nlh = mnl_nlmsg_put_header(buf);
	145	struct nfqnl_msg_config_params params = {
	146	.copy_range = htonl(range),
	147	.copy_mode = mode,
	148	};
	149	struct nfgenmsg *nfg;
	150
	151	nlh->nlmsg_type = (NFNL_SUBSYS_QUEUE << 8) \| NFQNL_MSG_CONFIG;
	152	nlh->nlmsg_flags = NLM_F_REQUEST;
	153
	154	nfg = mnl_nlmsg_put_extra_header(nlh, sizeof(*nfg));
	155	nfg->nfgen_family = AF_UNSPEC;
	156	nfg->version = NFNETLINK_V0;
	157	nfg->res_id = htons(queue_num);
	158
	159	mnl_attr_put(nlh, NFQA_CFG_PARAMS, sizeof(params), &params);
	160
	161	return nlh;
	162	}
	163
	164	static struct nlmsghdr *
	165	nfq_build_verdict(char *buf, int id, int queue_num, int verd)
	166	{
	167	struct nfqnl_msg_verdict_hdr vh = {
	168	.verdict = htonl(verd),
	169	.id = htonl(id),
	170	};
	171	struct nlmsghdr *nlh;
	172	struct nfgenmsg *nfg;
	173
	174	nlh = mnl_nlmsg_put_header(buf);
	175	nlh->nlmsg_type = (NFNL_SUBSYS_QUEUE << 8) \| NFQNL_MSG_VERDICT;
	176	nlh->nlmsg_flags = NLM_F_REQUEST;
	177	nfg = mnl_nlmsg_put_extra_header(nlh, sizeof(*nfg));
	178	nfg->nfgen_family = AF_UNSPEC;
	179	nfg->version = NFNETLINK_V0;
	180	nfg->res_id = htons(queue_num);
	181
	182	mnl_attr_put(nlh, NFQA_VERDICT_HDR, sizeof(vh), &vh);
	183
	184	return nlh;
	185	}
	186
	187	static void print_stats(void)
	188	{
	189	unsigned int last, total;
	190	int i;
	191
	192	if (!opts.count_packets)
	193	return;
	194
	195	total = 0;
	196	last = queue_stats[0];
	197
	198	for (i = 0; i < 5; i++) {
	199	printf("hook %d packets %08u\n", i, queue_stats[i]);
	200	last = queue_stats[i];
	201	total += last;
	202	}
	203
	204	printf("%u packets total\n", total);
	205	}
	206
	207	struct mnl_socket *open_queue(void)
	208	{
	209	char buf[MNL_SOCKET_BUFFER_SIZE];
	210	unsigned int queue_num;
	211	struct mnl_socket *nl;
	212	struct nlmsghdr *nlh;
	213	struct timeval tv;
	214	uint32_t flags;
	215
	216	nl = mnl_socket_open(NETLINK_NETFILTER);
	217	if (nl == NULL) {
	218	perror("mnl_socket_open");
	219	exit(EXIT_FAILURE);
	220	}
	221
	222	if (mnl_socket_bind(nl, 0, MNL_SOCKET_AUTOPID) < 0) {
	223	perror("mnl_socket_bind");
	224	exit(EXIT_FAILURE);
	225	}
	226
	227	queue_num = opts.queue_num;
	228	nlh = nfq_build_cfg_request(buf, NFQNL_CFG_CMD_BIND, queue_num);
	229
	230	if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
	231	perror("mnl_socket_sendto");
	232	exit(EXIT_FAILURE);
	233	}
	234
	235	nlh = nfq_build_cfg_params(buf, NFQNL_COPY_PACKET, 0xFFFF, queue_num);
	236
	237	flags = NFQA_CFG_F_GSO \| NFQA_CFG_F_UID_GID;
	238	mnl_attr_put_u32(nlh, NFQA_CFG_FLAGS, htonl(flags));
	239	mnl_attr_put_u32(nlh, NFQA_CFG_MASK, htonl(flags));
	240
	241	if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
	242	perror("mnl_socket_sendto");
	243	exit(EXIT_FAILURE);
	244	}
	245
	246	memset(&tv, 0, sizeof(tv));
	247	tv.tv_sec = opts.timeout;
	248	if (opts.timeout && setsockopt(mnl_socket_get_fd(nl),
	249	SOL_SOCKET, SO_RCVTIMEO,
	250	&tv, sizeof(tv))) {
	251	perror("setsockopt(SO_RCVTIMEO)");
	252	exit(EXIT_FAILURE);
	253	}
	254
	255	return nl;
	256	}
	257
	258	static int mainloop(void)
	259	{
	260	unsigned int buflen = 64 * 1024 + MNL_SOCKET_BUFFER_SIZE;
	261	struct mnl_socket *nl;
	262	struct nlmsghdr *nlh;
	263	unsigned int portid;
	264	char *buf;
	265	int ret;
	266
	267	buf = malloc(buflen);
	268	if (!buf) {
	269	perror("malloc");
	270	exit(EXIT_FAILURE);
	271	}
	272
	273	nl = open_queue();
	274	portid = mnl_socket_get_portid(nl);
	275
	276	for (;;) {
	277	uint32_t id;
	278
	279	ret = mnl_socket_recvfrom(nl, buf, buflen);
	280	if (ret == -1) {
	281	if (errno == ENOBUFS)
	282	continue;
	283
	284	if (errno == EAGAIN) {
	285	errno = 0;
	286	ret = 0;
	287	break;
	288	}
	289
	290	perror("mnl_socket_recvfrom");
	291	exit(EXIT_FAILURE);
	292	}
	293
	294	ret = mnl_cb_run(buf, ret, 0, portid, queue_cb, NULL);
	295	if (ret < 0) {
	296	perror("mnl_cb_run");
	297	exit(EXIT_FAILURE);
	298	}
	299
	300	id = ret - MNL_CB_OK;
	301	nlh = nfq_build_verdict(buf, id, opts.queue_num, NF_ACCEPT);
	302	if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
	303	perror("mnl_socket_sendto");
	304	exit(EXIT_FAILURE);
	305	}
	306	}
	307
	308	mnl_socket_close(nl);
	309
	310	return ret;
	311	}
	312
	313	static void parse_opts(int argc, char **argv)
	314	{
	315	int c;
	316
	317	while ((c = getopt(argc, argv, "chvt:q:")) != -1) {
	318	switch (c) {
	319	case 'c':
	320	opts.count_packets = true;
	321	break;
	322	case 'h':
	323	help(argv[0]);
	324	exit(0);
	325	break;
	326	case 'q':
	327	opts.queue_num = atoi(optarg);
	328	if (opts.queue_num > 0xffff)
	329	opts.queue_num = 0;
	330	break;
	331	case 't':
	332	opts.timeout = atoi(optarg);
	333	break;
	334	case 'v':
	335	opts.verbose++;
	336	break;
	337	}
	338	}
	339	}
	340
	341	int main(int argc, char *argv[])
	342	{
	343	int ret;
	344
	345	parse_opts(argc, argv);
	346
	347	ret = mainloop();
	348	if (opts.count_packets)
	349	print_stats();
	350
	351	return ret;
	352	}

tools/testing/selftests/netfilter/nft_queue.sh+332−0

@@ -0,0 +1,332 @@
	1	#!/bin/bash
	2	#
	3	# This tests nf_queue:
	4	# 1. can process packets from all hooks
	5	# 2. support running nfqueue from more than one base chain
	6	#
	7	# Kselftest framework requirement - SKIP code is 4.
	8	ksft_skip=4
	9	ret=0
	10
	11	sfx=$(mktemp -u "XXXXXXXX")
	12	ns1="ns1-$sfx"
	13	ns2="ns2-$sfx"
	14	nsrouter="nsrouter-$sfx"
	15
	16	cleanup()
	17	{
	18	ip netns del ${ns1}
	19	ip netns del ${ns2}
	20	ip netns del ${nsrouter}
	21	rm -f "$TMPFILE0"
	22	rm -f "$TMPFILE1"
	23	}
	24
	25	nft --version > /dev/null 2>&1
	26	if [ $? -ne 0 ];then
	27	echo "SKIP: Could not run test without nft tool"
	28	exit $ksft_skip
	29	fi
	30
	31	ip -Version > /dev/null 2>&1
	32	if [ $? -ne 0 ];then
	33	echo "SKIP: Could not run test without ip tool"
	34	exit $ksft_skip
	35	fi
	36
	37	ip netns add ${nsrouter}
	38	if [ $? -ne 0 ];then
	39	echo "SKIP: Could not create net namespace"
	40	exit $ksft_skip
	41	fi
	42
	43	TMPFILE0=$(mktemp)
	44	TMPFILE1=$(mktemp)
	45	trap cleanup EXIT
	46
	47	ip netns add ${ns1}
	48	ip netns add ${ns2}
	49
	50	ip link add veth0 netns ${nsrouter} type veth peer name eth0 netns ${ns1} > /dev/null 2>&1
	51	if [ $? -ne 0 ];then
	52	echo "SKIP: No virtual ethernet pair device support in kernel"
	53	exit $ksft_skip
	54	fi
	55	ip link add veth1 netns ${nsrouter} type veth peer name eth0 netns ${ns2}
	56
	57	ip -net ${nsrouter} link set lo up
	58	ip -net ${nsrouter} link set veth0 up
	59	ip -net ${nsrouter} addr add 10.0.1.1/24 dev veth0
	60	ip -net ${nsrouter} addr add dead:1::1/64 dev veth0
	61
	62	ip -net ${nsrouter} link set veth1 up
	63	ip -net ${nsrouter} addr add 10.0.2.1/24 dev veth1
	64	ip -net ${nsrouter} addr add dead:2::1/64 dev veth1
	65
	66	ip -net ${ns1} link set lo up
	67	ip -net ${ns1} link set eth0 up
	68
	69	ip -net ${ns2} link set lo up
	70	ip -net ${ns2} link set eth0 up
	71
	72	ip -net ${ns1} addr add 10.0.1.99/24 dev eth0
	73	ip -net ${ns1} addr add dead:1::99/64 dev eth0
	74	ip -net ${ns1} route add default via 10.0.1.1
	75	ip -net ${ns1} route add default via dead:1::1
	76
	77	ip -net ${ns2} addr add 10.0.2.99/24 dev eth0
	78	ip -net ${ns2} addr add dead:2::99/64 dev eth0
	79	ip -net ${ns2} route add default via 10.0.2.1
	80	ip -net ${ns2} route add default via dead:2::1
	81
	82	load_ruleset() {
	83	local name=$1
	84	local prio=$2
	85
	86	ip netns exec ${nsrouter} nft -f - <<EOF
	87	table inet $name {
	88	chain nfq {
	89	ip protocol icmp queue bypass
	90	icmpv6 type { "echo-request", "echo-reply" } queue num 1 bypass
	91	}
	92	chain pre {
	93	type filter hook prerouting priority $prio; policy accept;
	94	jump nfq
	95	}
	96	chain input {
	97	type filter hook input priority $prio; policy accept;
	98	jump nfq
	99	}
	100	chain forward {
	101	type filter hook forward priority $prio; policy accept;
	102	tcp dport 12345 queue num 2
	103	jump nfq
	104	}
	105	chain output {
	106	type filter hook output priority $prio; policy accept;
	107	tcp dport 12345 queue num 3
	108	jump nfq
	109	}
	110	chain post {
	111	type filter hook postrouting priority $prio; policy accept;
	112	jump nfq
	113	}
	114	}
	115	EOF
	116	}
	117
	118	load_counter_ruleset() {
	119	local prio=$1
	120
	121	ip netns exec ${nsrouter} nft -f - <<EOF
	122	table inet countrules {
	123	chain pre {
	124	type filter hook prerouting priority $prio; policy accept;
	125	counter
	126	}
	127	chain input {
	128	type filter hook input priority $prio; policy accept;
	129	counter
	130	}
	131	chain forward {
	132	type filter hook forward priority $prio; policy accept;
	133	counter
	134	}
	135	chain output {
	136	type filter hook output priority $prio; policy accept;
	137	counter
	138	}
	139	chain post {
	140	type filter hook postrouting priority $prio; policy accept;
	141	counter
	142	}
	143	}
	144	EOF
	145	}
	146
	147	test_ping() {
	148	ip netns exec ${ns1} ping -c 1 -q 10.0.2.99 > /dev/null
	149	if [ $? -ne 0 ];then
	150	return 1
	151	fi
	152
	153	ip netns exec ${ns1} ping -c 1 -q dead:2::99 > /dev/null
	154	if [ $? -ne 0 ];then
	155	return 1
	156	fi
	157
	158	return 0
	159	}
	160
	161	test_ping_router() {
	162	ip netns exec ${ns1} ping -c 1 -q 10.0.2.1 > /dev/null
	163	if [ $? -ne 0 ];then
	164	return 1
	165	fi
	166
	167	ip netns exec ${ns1} ping -c 1 -q dead:2::1 > /dev/null
	168	if [ $? -ne 0 ];then
	169	return 1
	170	fi
	171
	172	return 0
	173	}
	174
	175	test_queue_blackhole() {
	176	local proto=$1
	177
	178	ip netns exec ${nsrouter} nft -f - <<EOF
	179	table $proto blackh {
	180	chain forward {
	181	type filter hook forward priority 0; policy accept;
	182	queue num 600
	183	}
	184	}
	185	EOF
	186	if [ $proto = "ip" ] ;then
	187	ip netns exec ${ns1} ping -c 1 -q 10.0.2.99 > /dev/null
	188	lret=$?
	189	elif [ $proto = "ip6" ]; then
	190	ip netns exec ${ns1} ping -c 1 -q dead:2::99 > /dev/null
	191	lret=$?
	192	else
	193	lret=111
	194	fi
	195
	196	# queue without bypass keyword should drop traffic if no listener exists.
	197	if [ $lret -eq 0 ];then
	198	echo "FAIL: $proto expected failure, got $lret" 1>&2
	199	exit 1
	200	fi
	201
	202	ip netns exec ${nsrouter} nft delete table $proto blackh
	203	if [ $? -ne 0 ] ;then
	204	echo "FAIL: $proto: Could not delete blackh table"
	205	exit 1
	206	fi
	207
	208	echo "PASS: $proto: statement with no listener results in packet drop"
	209	}
	210
	211	test_queue()
	212	{
	213	local expected=$1
	214	local last=""
	215
	216	# spawn nf-queue listeners
	217	ip netns exec ${nsrouter} ./nf-queue -c -q 0 -t 3 > "$TMPFILE0" &
	218	ip netns exec ${nsrouter} ./nf-queue -c -q 1 -t 3 > "$TMPFILE1" &
	219	sleep 1
	220	test_ping
	221	ret=$?
	222	if [ $ret -ne 0 ];then
	223	echo "FAIL: netns routing/connectivity with active listener on queue $queue: $ret" 1>&2
	224	exit $ret
	225	fi
	226
	227	test_ping_router
	228	ret=$?
	229	if [ $ret -ne 0 ];then
	230	echo "FAIL: netns router unreachable listener on queue $queue: $ret" 1>&2
	231	exit $ret
	232	fi
	233
	234	wait
	235	ret=$?
	236
	237	for file in $TMPFILE0 $TMPFILE1; do
	238	last=$(tail -n1 "$file")
	239	if [ x"$last" != x"$expected packets total" ]; then
	240	echo "FAIL: Expected $expected packets total, but got $last" 1>&2
	241	cat "$file" 1>&2
	242
	243	ip netns exec ${nsrouter} nft list ruleset
	244	exit 1
	245	fi
	246	done
	247
	248	echo "PASS: Expected and received $last"
	249	}
	250
	251	test_tcp_forward()
	252	{
	253	ip netns exec ${nsrouter} ./nf-queue -q 2 -t 10 &
	254	local nfqpid=$!
	255
	256	tmpfile=$(mktemp) \|\| exit 1
	257	dd conv=sparse status=none if=/dev/zero bs=1M count=100 of=$tmpfile
	258	ip netns exec ${ns2} nc -w 5 -l -p 12345 <"$tmpfile" >/dev/null &
	259	local rpid=$!
	260
	261	sleep 1
	262	ip netns exec ${ns1} nc -w 5 10.0.2.99 12345 <"$tmpfile" >/dev/null &
	263
	264	rm -f "$tmpfile"
	265
	266	wait $rpid
	267	wait $lpid
	268	[ $? -eq 0 ] && echo "PASS: tcp and nfqueue in forward chain"
	269	}
	270
	271	test_tcp_localhost()
	272	{
	273	tc -net "${nsrouter}" qdisc add dev lo root netem loss random 1%
	274
	275	tmpfile=$(mktemp) \|\| exit 1
	276
	277	dd conv=sparse status=none if=/dev/zero bs=1M count=900 of=$tmpfile
	278	ip netns exec ${nsrouter} nc -w 5 -l -p 12345 <"$tmpfile" >/dev/null &
	279	local rpid=$!
	280
	281	ip netns exec ${nsrouter} ./nf-queue -q 3 -t 30 &
	282	local nfqpid=$!
	283
	284	sleep 1
	285	ip netns exec ${nsrouter} nc -w 5 127.0.0.1 12345 <"$tmpfile" > /dev/null
	286	rm -f "$tmpfile"
	287
	288	wait $rpid
	289	[ $? -eq 0 ] && echo "PASS: tcp via loopback"
	290	}
	291
	292	ip netns exec ${nsrouter} sysctl net.ipv6.conf.all.forwarding=1 > /dev/null
	293	ip netns exec ${nsrouter} sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null
	294	ip netns exec ${nsrouter} sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null
	295
	296	load_ruleset "filter" 0
	297
	298	sleep 3
	299
	300	test_ping
	301	ret=$?
	302	if [ $ret -eq 0 ];then
	303	# queue bypass works (rules were skipped, no listener)
	304	echo "PASS: ${ns1} can reach ${ns2}"
	305	else
	306	echo "FAIL: ${ns1} cannot reach ${ns2}: $ret" 1>&2
	307	exit $ret
	308	fi
	309
	310	test_queue_blackhole ip
	311	test_queue_blackhole ip6
	312
	313	# dummy ruleset to add base chains between the
	314	# queueing rules. We don't want the second reinject
	315	# to re-execute the old hooks.
	316	load_counter_ruleset 10
	317
	318	# we are hooking all: prerouting/input/forward/output/postrouting.
	319	# we ping ${ns2} from ${ns1} via ${nsrouter} using ipv4 and ipv6, so:
	320	# 1x icmp prerouting,forward,postrouting -> 3 queue events (6 incl. reply).
	321	# 1x icmp prerouting,input,output postrouting -> 4 queue events incl. reply.
	322	# so we expect that userspace program receives 10 packets.
	323	test_queue 10
	324
	325	# same. We queue to a second program as well.
	326	load_ruleset "filter2" 20
	327	test_queue 20
	328
	329	test_tcp_forward
	330	test_tcp_localhost
	331
	332	exit $ret

tools/testing/selftests/wireguard/netns.sh+10−5

 n0 wg set wg0 peer "$pub2" allowed-ips ::/0,1700::/111,5000::/4,e000::/37,9000::/75
 n0 wg set wg0 peer "$pub2" allowed-ips ::/0
 n0 wg set wg0 peer "$pub2" remove
-low_order_points=( AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= 4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuAA= X5yVvKNQjCSx0LFVnIPvWwREXMRYHI6G2CJO3dCfEVc= 7P///////////////////////////////////////38= 7f///////////////////////////////////////38= 7v///////////////////////////////////////38= )
+for low_order_point in AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= 4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuAA= X5yVvKNQjCSx0LFVnIPvWwREXMRYHI6G2CJO3dCfEVc= 7P///////////////////////////////////////38= 7f///////////////////////////////////////38= 7v///////////////////////////////////////38=; do
-n0 wg set wg0 private-key /dev/null ${low_order_points[@]/#/peer }
+	n0 wg set wg0 peer "$low_order_point" persistent-keepalive 1 endpoint 127.0.0.1:1111
-[[ -z $(n0 wg show wg0 peers) ]]
+done
-n0 wg set wg0 private-key <(echo "$key1") ${low_order_points[@]/#/peer }
+[[ -n $(n0 wg show wg0 peers) ]]
-[[ -z $(n0 wg show wg0 peers) ]]
+exec 4< <(n0 ncat -l -u -p 1111)
+ncat_pid=$!
+waitncatudp $netns0 $ncat_pid
+ip0 link set wg0 up
+! read -r -n 1 -t 2 <&4 || false
+kill $ncat_pid
 ip0 link del wg0
 declare -A objects

tools/testing/selftests/wireguard/qemu/Makefile+1−1

@@ -41,7 +41,7 @@ $(DISTFILES_PATH)/$(1): · 40 unmodified lines
41	flock -x $$@.lock -c '[ -f $$@ ] && exit 0; wget -O $$@.tmp $(MIRROR)$(1) \|\| wget -O $$@.tmp $(2)$(1) \|\| rm -f $$@.tmp; [ -f $$@.tmp ] \|\| exit 1; if echo "$(3) $$@.tmp" \| sha256sum -c -; then mv $$@.tmp $$@; else rm -f $$@.tmp; exit 71; fi'	41	flock -x $$@.lock -c '[ -f $$@ ] && exit 0; wget -O $$@.tmp $(MIRROR)$(1) \|\| wget -O $$@.tmp $(2)$(1) \|\| rm -f $$@.tmp; [ -f $$@.tmp ] \|\| exit 1; if echo "$(3) $$@.tmp" \| sha256sum -c -; then mv $$@.tmp $$@; else rm -f $$@.tmp; exit 71; fi'
42	endef	42	endef
43		43
44	$(eval $(call tar_download,MUSL,musl,1.1.24,.tar.gz,https://www.musl-libc.org/releases/,1370c9a812b2cf2a7d92802510cca0058cc37e66a7bedd70051f0a34015022a3))	44	$(eval $(call tar_download,MUSL,musl,1.2.0,.tar.gz,https://musl.libc.org/releases/,c6de7b191139142d3f9a7b5b702c9cae1b5ee6e7f57e582da9328629408fd4e8))
45	$(eval $(call tar_download,IPERF,iperf,3.7,.tar.gz,https://downloads.es.net/pub/iperf/,d846040224317caf2f75c843d309a950a7db23f9b44b94688ccbe557d6d1710c))	45	$(eval $(call tar_download,IPERF,iperf,3.7,.tar.gz,https://downloads.es.net/pub/iperf/,d846040224317caf2f75c843d309a950a7db23f9b44b94688ccbe557d6d1710c))
46	$(eval $(call tar_download,BASH,bash,5.0,.tar.gz,https://ftp.gnu.org/gnu/bash/,b4a80f2ac66170b2913efbfb9f2594f1f76c7b1afd11f799e22035d63077fb4d))	46	$(eval $(call tar_download,BASH,bash,5.0,.tar.gz,https://ftp.gnu.org/gnu/bash/,b4a80f2ac66170b2913efbfb9f2594f1f76c7b1afd11f799e22035d63077fb4d))
47	$(eval $(call tar_download,IPROUTE2,iproute2,5.4.0,.tar.xz,https://www.kernel.org/pub/linux/utils/net/iproute2/,fe97aa60a0d4c5ac830be18937e18dc3400ca713a33a89ad896ff1e3d46086ae))	47	$(eval $(call tar_download,IPROUTE2,iproute2,5.4.0,.tar.xz,https://www.kernel.org/pub/linux/utils/net/iproute2/,fe97aa60a0d4c5ac830be18937e18dc3400ca713a33a89ad896ff1e3d46086ae))

tools/testing/selftests/wireguard/qemu/init.c+0−1

@@ -13,7 +13,6 @@ · 12 unmodified lines
13	#include <fcntl.h>	13	#include <fcntl.h>
14	#include <sys/wait.h>	14	#include <sys/wait.h>
15	#include <sys/mount.h>	15	#include <sys/mount.h>
16	#include <sys/types.h>
17	#include <sys/stat.h>	16	#include <sys/stat.h>
18	#include <sys/types.h>	17	#include <sys/types.h>
19	#include <sys/io.h>	18	#include <sys/io.h>

tools/testing/selftests/wireguard/qemu/kernel.config+0−1

@@ -56,7 +56,6 @@ CONFIG_NO_HZ_IDLE=y · 55 unmodified lines
56	CONFIG_NO_HZ_FULL=n	56	CONFIG_NO_HZ_FULL=n
57	CONFIG_HZ_PERIODIC=n	57	CONFIG_HZ_PERIODIC=n
58	CONFIG_HIGH_RES_TIMERS=y	58	CONFIG_HIGH_RES_TIMERS=y
59	CONFIG_COMPAT_32BIT_TIME=y
60	CONFIG_ARCH_RANDOM=y	59	CONFIG_ARCH_RANDOM=y
61	CONFIG_FILE_LOCKING=y	60	CONFIG_FILE_LOCKING=y
62	CONFIG_POSIX_TIMERS=y	61	CONFIG_POSIX_TIMERS=y

usr/Kconfig+11−11

 	  If in doubt, select 'None'
-config INITRAMFS_COMPRESSION_NONE
-	bool "None"
-	help
-	  Do not compress the built-in initramfs at all. This may sound wasteful
-	  in space, but, you should be aware that the built-in initramfs will be
-	  compressed at a later stage anyways along with the rest of the kernel,
-	  on those architectures that support this. However, not compressing the
-	  initramfs may lead to slightly higher memory consumption during a
-	  short time at boot, while both the cpio image and the unpacked
-	  filesystem image will be present in memory simultaneously
 config INITRAMFS_COMPRESSION_GZIP
 	bool "Gzip"
 	depends on RD_GZIP
 	  If you choose this, keep in mind that most distros don't provide lz4
 	  by default which could cause a build failure.
+config INITRAMFS_COMPRESSION_NONE
+	bool "None"
+	help
+	  Do not compress the built-in initramfs at all. This may sound wasteful
+	  in space, but, you should be aware that the built-in initramfs will be
+	  compressed at a later stage anyways along with the rest of the kernel,
+	  on those architectures that support this. However, not compressing the
+	  initramfs may lead to slightly higher memory consumption during a
+	  short time at boot, while both the cpio image and the unpacked
+	  filesystem image will be present in memory simultaneously
 endchoice

@@ -266,11 +266,15 @@ to use. · 265 unmodified lines
266	attached (via the dmaengine_desc_attach_metadata() helper to the descriptor.	266	attached (via the dmaengine_desc_attach_metadata() helper to the descriptor.
267		267
268	From the DMA driver the following is expected for this mode:	268	From the DMA driver the following is expected for this mode:
		269
269	- DMA_MEM_TO_DEV / DEV_MEM_TO_MEM	270	- DMA_MEM_TO_DEV / DEV_MEM_TO_MEM
		271
270	The data from the provided metadata buffer should be prepared for the DMA	272	The data from the provided metadata buffer should be prepared for the DMA
271	controller to be sent alongside of the payload data. Either by copying to a	273	controller to be sent alongside of the payload data. Either by copying to a
272	hardware descriptor, or highly coupled packet.	274	hardware descriptor, or highly coupled packet.
		275
273	- DMA_DEV_TO_MEM	276	- DMA_DEV_TO_MEM
		277
274	On transfer completion the DMA driver must copy the metadata to the client	278	On transfer completion the DMA driver must copy the metadata to the client
275	provided metadata buffer before notifying the client about the completion.	279	provided metadata buffer before notifying the client about the completion.
276	After the transfer completion, DMA drivers must not touch the metadata	280	After the transfer completion, DMA drivers must not touch the metadata
@@ -284,10 +288,14 @@ to use. · 7 unmodified lines
284	and dmaengine_desc_set_metadata_len() is provided as helper functions.	288	and dmaengine_desc_set_metadata_len() is provided as helper functions.
285		289
286	From the DMA driver the following is expected for this mode:	290	From the DMA driver the following is expected for this mode:
287	- get_metadata_ptr	291
		292	- get_metadata_ptr()
		293
288	Should return a pointer for the metadata buffer, the maximum size of the	294	Should return a pointer for the metadata buffer, the maximum size of the
289	metadata buffer and the currently used / valid (if any) bytes in the buffer.	295	metadata buffer and the currently used / valid (if any) bytes in the buffer.
290	- set_metadata_len	296
		297	- set_metadata_len()
		298
291	It is called by the clients after it have placed the metadata to the buffer	299	It is called by the clients after it have placed the metadata to the buffer
292	to let the DMA driver know the number of valid bytes provided.	300	to let the DMA driver know the number of valid bytes provided.
293		301

@@ -141,29 +141,29 @@ static ssize_t dbgfs_state(struct file file, char __user user_buf, · 140 unmodified lines
141	return 0;	141	return 0;
142		142
143	/* Print out debug information. */	143	/* Print out debug information. */
144	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	144	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
145	"CAIF SPI debug information:\n");	145	"CAIF SPI debug information:\n");
146		146
147	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len), FLAVOR);	147	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len), FLAVOR);
148		148
149	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	149	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
150	"STATE: %d\n", cfspi->dbg_state);	150	"STATE: %d\n", cfspi->dbg_state);
151	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	151	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
152	"Previous CMD: 0x%x\n", cfspi->pcmd);	152	"Previous CMD: 0x%x\n", cfspi->pcmd);
153	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	153	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
154	"Current CMD: 0x%x\n", cfspi->cmd);	154	"Current CMD: 0x%x\n", cfspi->cmd);
155	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	155	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
156	"Previous TX len: %d\n", cfspi->tx_ppck_len);	156	"Previous TX len: %d\n", cfspi->tx_ppck_len);
157	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	157	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
158	"Previous RX len: %d\n", cfspi->rx_ppck_len);	158	"Previous RX len: %d\n", cfspi->rx_ppck_len);
159	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	159	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
160	"Current TX len: %d\n", cfspi->tx_cpck_len);	160	"Current TX len: %d\n", cfspi->tx_cpck_len);
161	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	161	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
162	"Current RX len: %d\n", cfspi->rx_cpck_len);	162	"Current RX len: %d\n", cfspi->rx_cpck_len);
163	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	163	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
164	"Next TX len: %d\n", cfspi->tx_npck_len);	164	"Next TX len: %d\n", cfspi->tx_npck_len);
165	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	165	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
166	"Next RX len: %d\n", cfspi->rx_npck_len);	166	"Next RX len: %d\n", cfspi->rx_npck_len);
167		167
168	if (len > DEBUGFS_BUF_SIZE)	168	if (len > DEBUGFS_BUF_SIZE)
169	len = DEBUGFS_BUF_SIZE;	169	len = DEBUGFS_BUF_SIZE;
@@ -180,23 +180,23 @@ static ssize_t print_frame(char buf, size_t size, char frm, · 10 unmodified lines
180	int len = 0;	180	int len = 0;
181	int i;	181	int i;
182	for (i = 0; i < count; i++) {	182	for (i = 0; i < count; i++) {
183	len += snprintf((buf + len), (size - len),	183	len += scnprintf((buf + len), (size - len),
184	"[0x" BYTE_HEX_FMT "]",	184	"[0x" BYTE_HEX_FMT "]",
185	frm[i]);	185	frm[i]);
186	if ((i == cut) && (count > (cut * 2))) {	186	if ((i == cut) && (count > (cut * 2))) {
187	/* Fast forward. */	187	/* Fast forward. */
188	i = count - cut;	188	i = count - cut;
189	len += snprintf((buf + len), (size - len),	189	len += scnprintf((buf + len), (size - len),
190	"--- %zu bytes skipped ---\n",	190	"--- %zu bytes skipped ---\n",
191	count - (cut * 2));	191	count - (cut * 2));
192	}	192	}
193		193
194	if ((!(i % 10)) && i) {	194	if ((!(i % 10)) && i) {
195	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	195	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
196	"\n");	196	"\n");
197	}	197	}
198	}	198	}
199	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len), "\n");	199	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len), "\n");
200	return len;	200	return len;
201	}	201	}
202		202
@@ -214,18 +214,18 @@ static ssize_t dbgfs_frame(struct file file, char __user user_buf, · 11 unmodified lines
214	return 0;	214	return 0;
215		215
216	/* Print out debug information. */	216	/* Print out debug information. */
217	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	217	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
218	"Current frame:\n");	218	"Current frame:\n");
219		219
220	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	220	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
221	"Tx data (Len: %d):\n", cfspi->tx_cpck_len);	221	"Tx data (Len: %d):\n", cfspi->tx_cpck_len);
222		222
223	len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),	223	len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),
224	cfspi->xfer.va_tx[0],	224	cfspi->xfer.va_tx[0],
225	(cfspi->tx_cpck_len + SPI_CMD_SZ), 100);	225	(cfspi->tx_cpck_len + SPI_CMD_SZ), 100);
226		226
227	len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),	227	len += scnprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
228	"Rx data (Len: %d):\n", cfspi->rx_cpck_len);	228	"Rx data (Len: %d):\n", cfspi->rx_cpck_len);
229		229
230	len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),	230	len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),
231	cfspi->xfer.va_rx,	231	cfspi->xfer.va_rx,

@@ -589,25 +589,25 @@ skip_ring_stats: · 588 unmodified lines
589	if (bp->pri2cos_valid) {	589	if (bp->pri2cos_valid) {
590	for (i = 0; i < 8; i++, j++) {	590	for (i = 0; i < 8; i++, j++) {
591	long n = bnxt_rx_bytes_pri_arr[i].base_off +	591	long n = bnxt_rx_bytes_pri_arr[i].base_off +
592	bp->pri2cos[i];	592	bp->pri2cos_idx[i];
593		593
594	buf[j] = le64_to_cpu(*(rx_port_stats_ext + n));	594	buf[j] = le64_to_cpu(*(rx_port_stats_ext + n));
595	}	595	}
596	for (i = 0; i < 8; i++, j++) {	596	for (i = 0; i < 8; i++, j++) {
597	long n = bnxt_rx_pkts_pri_arr[i].base_off +	597	long n = bnxt_rx_pkts_pri_arr[i].base_off +
598	bp->pri2cos[i];	598	bp->pri2cos_idx[i];
599		599
600	buf[j] = le64_to_cpu(*(rx_port_stats_ext + n));	600	buf[j] = le64_to_cpu(*(rx_port_stats_ext + n));
601	}	601	}
602	for (i = 0; i < 8; i++, j++) {	602	for (i = 0; i < 8; i++, j++) {
603	long n = bnxt_tx_bytes_pri_arr[i].base_off +	603	long n = bnxt_tx_bytes_pri_arr[i].base_off +
604	bp->pri2cos[i];	604	bp->pri2cos_idx[i];
605		605
606	buf[j] = le64_to_cpu(*(tx_port_stats_ext + n));	606	buf[j] = le64_to_cpu(*(tx_port_stats_ext + n));
607	}	607	}
608	for (i = 0; i < 8; i++, j++) {	608	for (i = 0; i < 8; i++, j++) {
609	long n = bnxt_tx_pkts_pri_arr[i].base_off +	609	long n = bnxt_tx_pkts_pri_arr[i].base_off +
610	bp->pri2cos[i];	610	bp->pri2cos_idx[i];
611		611
612	buf[j] = le64_to_cpu(*(tx_port_stats_ext + n));	612	buf[j] = le64_to_cpu(*(tx_port_stats_ext + n));
613	}	613	}

@@ -452,49 +452,49 @@ int vxge_fw_upgrade(struct vxgedev vdev, char fw_name, int override); · 451 unmodified lines
452		452
453	#if (VXGE_DEBUG_LL_CONFIG & VXGE_DEBUG_MASK)	453	#if (VXGE_DEBUG_LL_CONFIG & VXGE_DEBUG_MASK)
454	#define vxge_debug_ll_config(level, fmt, ...) \	454	#define vxge_debug_ll_config(level, fmt, ...) \
455	vxge_debug_ll(level, VXGE_DEBUG_LL_CONFIG, fmt, __VA_ARGS__)	455	vxge_debug_ll(level, VXGE_DEBUG_LL_CONFIG, fmt, ##__VA_ARGS__)
456	#else	456	#else
457	#define vxge_debug_ll_config(level, fmt, ...)	457	#define vxge_debug_ll_config(level, fmt, ...)
458	#endif	458	#endif
459		459
460	#if (VXGE_DEBUG_INIT & VXGE_DEBUG_MASK)	460	#if (VXGE_DEBUG_INIT & VXGE_DEBUG_MASK)
461	#define vxge_debug_init(level, fmt, ...) \	461	#define vxge_debug_init(level, fmt, ...) \
462	vxge_debug_ll(level, VXGE_DEBUG_INIT, fmt, __VA_ARGS__)	462	vxge_debug_ll(level, VXGE_DEBUG_INIT, fmt, ##__VA_ARGS__)
463	#else	463	#else
464	#define vxge_debug_init(level, fmt, ...)	464	#define vxge_debug_init(level, fmt, ...)
465	#endif	465	#endif
466		466
467	#if (VXGE_DEBUG_TX & VXGE_DEBUG_MASK)	467	#if (VXGE_DEBUG_TX & VXGE_DEBUG_MASK)
468	#define vxge_debug_tx(level, fmt, ...) \	468	#define vxge_debug_tx(level, fmt, ...) \
469	vxge_debug_ll(level, VXGE_DEBUG_TX, fmt, __VA_ARGS__)	469	vxge_debug_ll(level, VXGE_DEBUG_TX, fmt, ##__VA_ARGS__)
470	#else	470	#else
471	#define vxge_debug_tx(level, fmt, ...)	471	#define vxge_debug_tx(level, fmt, ...)
472	#endif	472	#endif
473		473
474	#if (VXGE_DEBUG_RX & VXGE_DEBUG_MASK)	474	#if (VXGE_DEBUG_RX & VXGE_DEBUG_MASK)
475	#define vxge_debug_rx(level, fmt, ...) \	475	#define vxge_debug_rx(level, fmt, ...) \
476	vxge_debug_ll(level, VXGE_DEBUG_RX, fmt, __VA_ARGS__)	476	vxge_debug_ll(level, VXGE_DEBUG_RX, fmt, ##__VA_ARGS__)
477	#else	477	#else
478	#define vxge_debug_rx(level, fmt, ...)	478	#define vxge_debug_rx(level, fmt, ...)
479	#endif	479	#endif
480		480
481	#if (VXGE_DEBUG_MEM & VXGE_DEBUG_MASK)	481	#if (VXGE_DEBUG_MEM & VXGE_DEBUG_MASK)
482	#define vxge_debug_mem(level, fmt, ...) \	482	#define vxge_debug_mem(level, fmt, ...) \
483	vxge_debug_ll(level, VXGE_DEBUG_MEM, fmt, __VA_ARGS__)	483	vxge_debug_ll(level, VXGE_DEBUG_MEM, fmt, ##__VA_ARGS__)
484	#else	484	#else
485	#define vxge_debug_mem(level, fmt, ...)	485	#define vxge_debug_mem(level, fmt, ...)
486	#endif	486	#endif
487		487
488	#if (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK)	488	#if (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK)
489	#define vxge_debug_entryexit(level, fmt, ...) \	489	#define vxge_debug_entryexit(level, fmt, ...) \
490	vxge_debug_ll(level, VXGE_DEBUG_ENTRYEXIT, fmt, __VA_ARGS__)	490	vxge_debug_ll(level, VXGE_DEBUG_ENTRYEXIT, fmt, ##__VA_ARGS__)
491	#else	491	#else
492	#define vxge_debug_entryexit(level, fmt, ...)	492	#define vxge_debug_entryexit(level, fmt, ...)
493	#endif	493	#endif
494		494
495	#if (VXGE_DEBUG_INTR & VXGE_DEBUG_MASK)	495	#if (VXGE_DEBUG_INTR & VXGE_DEBUG_MASK)
496	#define vxge_debug_intr(level, fmt, ...) \	496	#define vxge_debug_intr(level, fmt, ...) \
497	vxge_debug_ll(level, VXGE_DEBUG_INTR, fmt, __VA_ARGS__)	497	vxge_debug_ll(level, VXGE_DEBUG_INTR, fmt, ##__VA_ARGS__)
498	#else	498	#else
499	#define vxge_debug_intr(level, fmt, ...)	499	#define vxge_debug_intr(level, fmt, ...)
500	#endif	500	#endif

@@ -953,18 +953,18 @@ static void ionic_lif_rx_mode(struct ionic_lif *lif, unsigned int rx_mode) · 952 unmodified lines
953	int i;	953	int i;
954	#define REMAIN(__x) (sizeof(buf) - (__x))	954	#define REMAIN(__x) (sizeof(buf) - (__x))
955		955
956	i = snprintf(buf, sizeof(buf), "rx_mode 0x%04x -> 0x%04x:",	956	i = scnprintf(buf, sizeof(buf), "rx_mode 0x%04x -> 0x%04x:",
957	lif->rx_mode, rx_mode);	957	lif->rx_mode, rx_mode);
958	if (rx_mode & IONIC_RX_MODE_F_UNICAST)	958	if (rx_mode & IONIC_RX_MODE_F_UNICAST)
959	i += snprintf(&buf[i], REMAIN(i), " RX_MODE_F_UNICAST");	959	i += scnprintf(&buf[i], REMAIN(i), " RX_MODE_F_UNICAST");
960	if (rx_mode & IONIC_RX_MODE_F_MULTICAST)	960	if (rx_mode & IONIC_RX_MODE_F_MULTICAST)
961	i += snprintf(&buf[i], REMAIN(i), " RX_MODE_F_MULTICAST");	961	i += scnprintf(&buf[i], REMAIN(i), " RX_MODE_F_MULTICAST");
962	if (rx_mode & IONIC_RX_MODE_F_BROADCAST)	962	if (rx_mode & IONIC_RX_MODE_F_BROADCAST)
963	i += snprintf(&buf[i], REMAIN(i), " RX_MODE_F_BROADCAST");	963	i += scnprintf(&buf[i], REMAIN(i), " RX_MODE_F_BROADCAST");
964	if (rx_mode & IONIC_RX_MODE_F_PROMISC)	964	if (rx_mode & IONIC_RX_MODE_F_PROMISC)
965	i += snprintf(&buf[i], REMAIN(i), " RX_MODE_F_PROMISC");	965	i += scnprintf(&buf[i], REMAIN(i), " RX_MODE_F_PROMISC");
966	if (rx_mode & IONIC_RX_MODE_F_ALLMULTI)	966	if (rx_mode & IONIC_RX_MODE_F_ALLMULTI)
967	i += snprintf(&buf[i], REMAIN(i), " RX_MODE_F_ALLMULTI");	967	i += scnprintf(&buf[i], REMAIN(i), " RX_MODE_F_ALLMULTI");
968	netdev_dbg(lif->netdev, "lif%d %s\n", lif->index, buf);	968	netdev_dbg(lif->netdev, "lif%d %s\n", lif->index, buf);
969		969
970	err = ionic_adminq_post_wait(lif, &ctx);	970	err = ionic_adminq_post_wait(lif, &ctx);

@@ -94,11 +94,11 @@ struct noise_handshake { · 93 unmodified lines
94	struct wg_device;	94	struct wg_device;
95		95
96	void wg_noise_init(void);	96	void wg_noise_init(void);
97	bool wg_noise_handshake_init(struct noise_handshake *handshake,	97	void wg_noise_handshake_init(struct noise_handshake *handshake,
98	struct noise_static_identity *static_identity,	98	struct noise_static_identity *static_identity,
99	const u8 peer_public_key[NOISE_PUBLIC_KEY_LEN],	99	const u8 peer_public_key[NOISE_PUBLIC_KEY_LEN],
100	const u8 peer_preshared_key[NOISE_SYMMETRIC_KEY_LEN],	100	const u8 peer_preshared_key[NOISE_SYMMETRIC_KEY_LEN],
101	struct wg_peer *peer);	101	struct wg_peer *peer);
102	void wg_noise_handshake_clear(struct noise_handshake *handshake);	102	void wg_noise_handshake_clear(struct noise_handshake *handshake);
103	static inline void wg_noise_reset_last_sent_handshake(atomic64_t *handshake_ns)	103	static inline void wg_noise_reset_last_sent_handshake(atomic64_t *handshake_ns)
104	{	104	{
@@ -116,7 +116,7 @@ void wg_noise_expire_current_peer_keypairs(struct wg_peer *peer); · 11 unmodified lines
116	void wg_noise_set_static_identity_private_key(	116	void wg_noise_set_static_identity_private_key(
117	struct noise_static_identity *static_identity,	117	struct noise_static_identity *static_identity,
118	const u8 private_key[NOISE_PUBLIC_KEY_LEN]);	118	const u8 private_key[NOISE_PUBLIC_KEY_LEN]);
119	bool wg_noise_precompute_static_static(struct wg_peer *peer);	119	void wg_noise_precompute_static_static(struct wg_peer *peer);
120		120
121	bool	121	bool
122	wg_noise_handshake_create_initiation(struct message_handshake_initiation *dst,	122	wg_noise_handshake_create_initiation(struct message_handshake_initiation *dst,