lael-labs/linux

Documentation/ABI/testing/sysfs-class-power+1−0

@@ -468,6 +468,7 @@ Description: · 467 unmodified lines
468	auto: Charge normally, respect thresholds	468	auto: Charge normally, respect thresholds
469	inhibit-charge: Do not charge while AC is attached	469	inhibit-charge: Do not charge while AC is attached
470	force-discharge: Force discharge while AC is attached	470	force-discharge: Force discharge while AC is attached
		471	================ ====================================
471		472
472	What: /sys/class/power_supply/<supply_name>/technology	473	What: /sys/class/power_supply/<supply_name>/technology
473	Date: May 2007	474	Date: May 2007

Documentation/devicetree/bindings/gpio/sifive,gpio.yaml+0−1

@@ -7,7 +7,6 @@ $schema: http://devicetree.org/meta-schemas/core.yaml# · 6 unmodified lines
7	title: SiFive GPIO controller	7	title: SiFive GPIO controller
8		8
9	maintainers:	9	maintainers:
10	- Yash Shah <yash.shah@sifive.com>
11	- Paul Walmsley <paul.walmsley@sifive.com>	10	- Paul Walmsley <paul.walmsley@sifive.com>
12		11
13	properties:	12	properties:

Documentation/devicetree/bindings/mfd/ti,j721e-system-controller.yaml+1−1

@@ -20,7 +20,7 @@ description: \| · 19 unmodified lines
20		20
21	maintainers:	21	maintainers:
22	- Kishon Vijay Abraham I <kishon@ti.com>	22	- Kishon Vijay Abraham I <kishon@ti.com>
23	- Roger Quadros <rogerq@ti.com	23	- Roger Quadros <rogerq@kernel.org>
24		24
25	properties:	25	properties:
26	compatible:	26	compatible:

Documentation/devicetree/bindings/phy/ti,omap-usb2.yaml+1−1

@@ -8,7 +8,7 @@ title: OMAP USB2 PHY · 7 unmodified lines
8		8
9	maintainers:	9	maintainers:
10	- Kishon Vijay Abraham I <kishon@ti.com>	10	- Kishon Vijay Abraham I <kishon@ti.com>
11	- Roger Quadros <rogerq@ti.com>	11	- Roger Quadros <rogerq@kernel.org>
12		12
13	properties:	13	properties:
14	compatible:	14	compatible:

Documentation/devicetree/bindings/pwm/pwm-sifive.yaml+0−1

@@ -8,7 +8,6 @@ $schema: http://devicetree.org/meta-schemas/core.yaml# · 7 unmodified lines
8	title: SiFive PWM controller	8	title: SiFive PWM controller
9		9
10	maintainers:	10	maintainers:
11	- Yash Shah <yash.shah@sifive.com>
12	- Sagar Kadam <sagar.kadam@sifive.com>	11	- Sagar Kadam <sagar.kadam@sifive.com>
13	- Paul Walmsley <paul.walmsley@sifive.com>	12	- Paul Walmsley <paul.walmsley@sifive.com>
14		13

Documentation/devicetree/bindings/riscv/sifive-l2-cache.yaml+0−1

@@ -9,7 +9,6 @@ title: SiFive L2 Cache Controller · 8 unmodified lines
9		9
10	maintainers:	10	maintainers:
11	- Sagar Kadam <sagar.kadam@sifive.com>	11	- Sagar Kadam <sagar.kadam@sifive.com>
12	- Yash Shah <yash.shah@sifive.com>
13	- Paul Walmsley <paul.walmsley@sifive.com>	12	- Paul Walmsley <paul.walmsley@sifive.com>
14		13
15	description:	14	description:

Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml+1−0

@@ -8,6 +8,7 @@ title: Audio codec controlled by ChromeOS EC · 7 unmodified lines
8		8
9	maintainers:	9	maintainers:
10	- Cheng-Yi Chiang <cychiang@chromium.org>	10	- Cheng-Yi Chiang <cychiang@chromium.org>
		11	- Tzung-Bi Shih <tzungbi@google.com>
11		12
12	description: \|	13	description: \|
13	Google's ChromeOS EC codec is a digital mic codec provided by the	14	Google's ChromeOS EC codec is a digital mic codec provided by the

Documentation/devicetree/bindings/usb/ti,j721e-usb.yaml+1−1

@@ -7,7 +7,7 @@ $schema: "http://devicetree.org/meta-schemas/core.yaml#" · 6 unmodified lines
7	title: Bindings for the TI wrapper module for the Cadence USBSS-DRD controller	7	title: Bindings for the TI wrapper module for the Cadence USBSS-DRD controller
8		8
9	maintainers:	9	maintainers:
10	- Roger Quadros <rogerq@ti.com>	10	- Roger Quadros <rogerq@kernel.org>
11		11
12	properties:	12	properties:
13	compatible:	13	compatible:

Documentation/devicetree/bindings/usb/ti,keystone-dwc3.yaml+1−1

@@ -7,7 +7,7 @@ $schema: http://devicetree.org/meta-schemas/core.yaml# · 6 unmodified lines
7	title: TI Keystone Soc USB Controller	7	title: TI Keystone Soc USB Controller
8		8
9	maintainers:	9	maintainers:
10	- Roger Quadros <rogerq@ti.com>	10	- Roger Quadros <rogerq@kernel.org>
11		11
12	properties:	12	properties:
13	compatible:	13	compatible:

MAINTAINERS+13−16

 CHROMEOS EC CODEC DRIVER
 M:	Cheng-Yi Chiang <cychiang@chromium.org>
+M:	Tzung-Bi Shih <tzungbi@google.com>
 R:	Guenter Roeck <groeck@chromium.org>
 S:	Maintained
 F:	Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml
 S:	Maintained
 F:	drivers/edac/sb_edac.c
-EDAC-SIFIVE
-M:	Yash Shah <yash.shah@sifive.com>
-L:	linux-edac@vger.kernel.org
-S:	Supported
-F:	drivers/edac/sifive_edac.c
 EDAC-SKYLAKE
 M:	Tony Luck <tony.luck@intel.com>
 L:	linux-edac@vger.kernel.org
 W:	https://github.com/o2genum/ideapad-slidebar
 F:	drivers/input/misc/ideapad_slidebar.c
+IDMAPPED MOUNTS
+M:	Christian Brauner <brauner@kernel.org>
+L:	linux-fsdevel@vger.kernel.org
+S:	Maintained
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux.git
+F:	Documentation/filesystems/idmappings.rst
+F:	tools/testing/selftests/mount_setattr/
+F:	include/linux/mnt_idmapping.h
 IDT VersaClock 5 CLOCK DRIVER
 M:	Luca Ceresoli <luca@lucaceresoli.net>
 S:	Maintained
 F:	drivers/misc/fastrpc.c
 F:	include/uapi/misc/fastrpc.h
-QUALCOMM GENERIC INTERFACE I2C DRIVER
-M:	Akash Asthana <akashast@codeaurora.org>
-M:	Mukesh Savaliya <msavaliy@codeaurora.org>
-L:	linux-i2c@vger.kernel.org
-L:	linux-arm-msm@vger.kernel.org
-S:	Supported
-F:	drivers/i2c/busses/i2c-qcom-geni.c
 QUALCOMM HEXAGON ARCHITECTURE
 M:	Brian Cain <bcain@codeaurora.org>
 L:	linux-hexagon@vger.kernel.org
 F:	drivers/mtd/nand/raw/qcom_nandc.c
 QUALCOMM RMNET DRIVER
-M:	Subash Abhinov Kasiviswanathan <subashab@codeaurora.org>
+M:	Subash Abhinov Kasiviswanathan <quic_subashab@quicinc.com>
-M:	Sean Tranchetti <stranche@codeaurora.org>
+M:	Sean Tranchetti <quic_stranche@quicinc.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
 F:	Documentation/networking/device_drivers/cellular/qualcomm/rmnet.rst
 REALTEK RTL83xx SMI DSA ROUTER CHIPS
 M:	Linus Walleij <linus.walleij@linaro.org>
+M:	Alvin Šipraga <alsi@bang-olufsen.dk>
 S:	Maintained
 F:	Documentation/devicetree/bindings/net/dsa/realtek-smi.txt
 F:	drivers/net/dsa/realtek/*

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 17	3	PATCHLEVEL = 17
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc4	5	EXTRAVERSION = -rc5
6	NAME = Superb Owl	6	NAME = Superb Owl
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

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

@@ -106,7 +106,7 @@ · 105 unmodified lines
106	msr_s SYS_ICC_SRE_EL2, x0	106	msr_s SYS_ICC_SRE_EL2, x0
107	isb // Make sure SRE is now set	107	isb // Make sure SRE is now set
108	mrs_s x0, SYS_ICC_SRE_EL2 // Read SRE back,	108	mrs_s x0, SYS_ICC_SRE_EL2 // Read SRE back,
109	tbz x0, #0, 1f // and check that it sticks	109	tbz x0, #0, .Lskip_gicv3_\@ // and check that it sticks
110	msr_s SYS_ICH_HCR_EL2, xzr // Reset ICC_HCR_EL2 to defaults	110	msr_s SYS_ICH_HCR_EL2, xzr // Reset ICC_HCR_EL2 to defaults
111	.Lskip_gicv3_\@:	111	.Lskip_gicv3_\@:
112	.endm	112	.endm

arch/parisc/kernel/unaligned.c+7−7

 	: "r" (val), "r" (regs->ior), "r" (regs->isr)
 	: "r19", "r20", "r21", "r22", "r1", FIXUP_BRANCH_CLOBBER );
-	return 0;
+	return ret;
 }
 static int emulate_std(struct pt_regs *regs, int frreg, int flop)
 {
 	__asm__ __volatile__ (
 "	mtsp	%4, %%sr1\n"
 "	zdep	%2, 29, 2, %%r19\n"
-"	dep	%%r0, 31, 2, %2\n"
+"	dep	%%r0, 31, 2, %3\n"
 "	mtsar	%%r19\n"
 "	zvdepi	-2, 32, %%r19\n"
 "1:	ldw	0(%%sr1,%3),%%r20\n"
 "	andcm	%%r21, %%r19, %%r21\n"
 "	or	%1, %%r20, %1\n"
 "	or	%2, %%r21, %2\n"
-"3:	stw	%1,0(%%sr1,%1)\n"
+"3:	stw	%1,0(%%sr1,%3)\n"
 "4:	stw	%%r1,4(%%sr1,%3)\n"
 "5:	stw	%2,8(%%sr1,%3)\n"
 "	copy	%%r0, %0\n"
 		ret = ERR_NOTHANDLED;	/* "undefined", but lets kill them. */
 		break;
 	}
-#ifdef CONFIG_PA20
 	switch (regs->iir & OPCODE2_MASK)
 	{
 	case OPCODE_FLDD_L:
 		flop=1;
 		ret = emulate_std(regs, R2(regs->iir),1);
 		break;
+#ifdef CONFIG_PA20
 	case OPCODE_LDD_L:
 		ret = emulate_ldd(regs, R2(regs->iir),0);
 		break;
 	case OPCODE_STD_L:
 		ret = emulate_std(regs, R2(regs->iir),0);
 		break;
-	}
 #endif
+	}
 	switch (regs->iir & OPCODE3_MASK)
 	{
 	case OPCODE_FLDW_L:
 		flop=1;
-		ret = emulate_ldw(regs, R2(regs->iir),0);
+		ret = emulate_ldw(regs, R2(regs->iir), 1);
 		break;
 	case OPCODE_LDW_M:
-		ret = emulate_ldw(regs, R2(regs->iir),1);
+		ret = emulate_ldw(regs, R2(regs->iir), 0);
 		break;
 	case OPCODE_FSTW_L:

arch/powerpc/kernel/head_book3s_32.S+2−2

@@ -421,14 +421,14 @@ InstructionTLBMiss: · 420 unmodified lines
421	*/	421	*/
422	/* Get PTE (linux-style) and check access */	422	/* Get PTE (linux-style) and check access */
423	mfspr r3,SPRN_IMISS	423	mfspr r3,SPRN_IMISS
424	#ifdef CONFIG_MODULES	424	#if defined(CONFIG_MODULES) \|\| defined(CONFIG_DEBUG_PAGEALLOC) \|\| defined(CONFIG_KFENCE)
425	lis r1, TASK_SIZE@h /* check if kernel address */	425	lis r1, TASK_SIZE@h /* check if kernel address */
426	cmplw 0,r1,r3	426	cmplw 0,r1,r3
427	#endif	427	#endif
428	mfspr r2, SPRN_SDR1	428	mfspr r2, SPRN_SDR1
429	li r1,_PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_EXEC \| _PAGE_USER	429	li r1,_PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_EXEC \| _PAGE_USER
430	rlwinm r2, r2, 28, 0xfffff000	430	rlwinm r2, r2, 28, 0xfffff000
431	#ifdef CONFIG_MODULES	431	#if defined(CONFIG_MODULES) \|\| defined(CONFIG_DEBUG_PAGEALLOC) \|\| defined(CONFIG_KFENCE)
432	bgt- 112f	432	bgt- 112f
433	lis r2, (swapper_pg_dir - PAGE_OFFSET)@ha /* if kernel address, use */	433	lis r2, (swapper_pg_dir - PAGE_OFFSET)@ha /* if kernel address, use */
434	li r1,_PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_EXEC	434	li r1,_PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_EXEC

arch/powerpc/lib/sstep.c+2−0

 		case BARRIER_EIEIO:
 			eieio();
 			break;
+#ifdef CONFIG_PPC64
 		case BARRIER_LWSYNC:
 			asm volatile("lwsync" : : : "memory");
 			break;
 		case BARRIER_PTESYNC:
 			asm volatile("ptesync" : : : "memory");
 			break;
+#endif
 		}
 		break;

arch/riscv/kernel/sbi.c+47−25

  * Copyright (c) 2020 Western Digital Corporation or its affiliates.
  */
+#include <linux/bits.h>
 #include <linux/init.h>
 #include <linux/pm.h>
 #include <linux/reboot.h>
 			pr_warn("Unable to send any request to hartid > BITS_PER_LONG for SBI v0.1\n");
 			break;
 		}
-		hmask |= 1 << hartid;
+		hmask |= BIT(hartid);
 	}
 	return hmask;
 {
 	unsigned long hart_mask;
-	if (!cpu_mask)
+	if (!cpu_mask || cpumask_empty(cpu_mask))
 		cpu_mask = cpu_online_mask;
 	hart_mask = __sbi_v01_cpumask_to_hartmask(cpu_mask);
 	int result = 0;
 	unsigned long hart_mask;
-	if (!cpu_mask)
+	if (!cpu_mask || cpumask_empty(cpu_mask))
 		cpu_mask = cpu_online_mask;
 	hart_mask = __sbi_v01_cpumask_to_hartmask(cpu_mask);
 static int __sbi_send_ipi_v02(const struct cpumask *cpu_mask)
 {
-	unsigned long hartid, cpuid, hmask = 0, hbase = 0;
+	unsigned long hartid, cpuid, hmask = 0, hbase = 0, htop = 0;
 	struct sbiret ret = {0};
 	int result;
-	if (!cpu_mask)
+	if (!cpu_mask || cpumask_empty(cpu_mask))
 		cpu_mask = cpu_online_mask;
 	for_each_cpu(cpuid, cpu_mask) {
 		hartid = cpuid_to_hartid_map(cpuid);
-		if (hmask && ((hbase + BITS_PER_LONG) <= hartid)) {
+		if (hmask) {
-			ret = sbi_ecall(SBI_EXT_IPI, SBI_EXT_IPI_SEND_IPI,
+			if (hartid + BITS_PER_LONG <= htop ||
-					hmask, hbase, 0, 0, 0, 0);
+			    hbase + BITS_PER_LONG <= hartid) {
-			if (ret.error)
+				ret = sbi_ecall(SBI_EXT_IPI,
-				goto ecall_failed;
+						SBI_EXT_IPI_SEND_IPI, hmask,
-			hmask = 0;
+						hbase, 0, 0, 0, 0);
-			hbase = 0;
+				if (ret.error)
+					goto ecall_failed;
+				hmask = 0;
+			} else if (hartid < hbase) {
+				/* shift the mask to fit lower hartid */
+				hmask <<= hbase - hartid;
+				hbase = hartid;
+			}
 		}
-		if (!hmask)
+		if (!hmask) {
 			hbase = hartid;
-		hmask |= 1UL << (hartid - hbase);
+			htop = hartid;
+		} else if (hartid > htop) {
+			htop = hartid;
+		}
+		hmask |= BIT(hartid - hbase);
 	}
 	if (hmask) {
 			    unsigned long start, unsigned long size,
 			    unsigned long arg4, unsigned long arg5)
 {
-	unsigned long hartid, cpuid, hmask = 0, hbase = 0;
+	unsigned long hartid, cpuid, hmask = 0, hbase = 0, htop = 0;
 	int result;
-	if (!cpu_mask)
+	if (!cpu_mask || cpumask_empty(cpu_mask))
 		cpu_mask = cpu_online_mask;
 	for_each_cpu(cpuid, cpu_mask) {
 		hartid = cpuid_to_hartid_map(cpuid);
-		if (hmask && ((hbase + BITS_PER_LONG) <= hartid)) {
+		if (hmask) {
-			result = __sbi_rfence_v02_call(fid, hmask, hbase,
+			if (hartid + BITS_PER_LONG <= htop ||
-						       start, size, arg4, arg5);
+			    hbase + BITS_PER_LONG <= hartid) {
-			if (result)
+				result = __sbi_rfence_v02_call(fid, hmask,
-				return result;
+						hbase, start, size, arg4, arg5);
-			hmask = 0;
+				if (result)
-			hbase = 0;
+					return result;
+				hmask = 0;
+			} else if (hartid < hbase) {
+				/* shift the mask to fit lower hartid */
+				hmask <<= hbase - hartid;
+				hbase = hartid;
+			}
 		}
-		if (!hmask)
+		if (!hmask) {
 			hbase = hartid;
-		hmask |= 1UL << (hartid - hbase);
+			htop = hartid;
+		} else if (hartid > htop) {
+			htop = hartid;
+		}
+		hmask |= BIT(hartid - hbase);
 	}
 	if (hmask) {

arch/x86/kernel/cpu/sgx/main.c+1−9

 {
 	struct sgx_epc_page *chunk[SGX_NR_TO_SCAN];
 	struct sgx_backing backing[SGX_NR_TO_SCAN];
-	struct sgx_epc_section *section;
 	struct sgx_encl_page *encl_page;
 	struct sgx_epc_page *epc_page;
-	struct sgx_numa_node *node;
 	pgoff_t page_index;
 	int cnt = 0;
 	int ret;
 		kref_put(&encl_page->encl->refcount, sgx_encl_release);
 		epc_page->flags &= ~SGX_EPC_PAGE_RECLAIMER_TRACKED;
-		section = &sgx_epc_sections[epc_page->section];
+		sgx_free_epc_page(epc_page);
-		node = section->node;
-		spin_lock(&node->lock);
-		list_add_tail(&epc_page->list, &node->free_page_list);
-		spin_unlock(&node->lock);
-		atomic_long_inc(&sgx_nr_free_pages);
 	}
 }

arch/x86/kernel/fpu/regset.c+4−5

 		const void *kbuf, const void __user *ubuf)
 {
 	struct fpu *fpu = &target->thread.fpu;
-	struct user32_fxsr_struct newstate;
+	struct fxregs_state newstate;
 	int ret;
-	BUILD_BUG_ON(sizeof(newstate) != sizeof(struct fxregs_state));
 	if (!cpu_feature_enabled(X86_FEATURE_FXSR))
 		return -ENODEV;
 	/* Copy the state  */
 	memcpy(&fpu->fpstate->regs.fxsave, &newstate, sizeof(newstate));
-	/* Clear xmm8..15 */
+	/* Clear xmm8..15 for 32-bit callers */
 	BUILD_BUG_ON(sizeof(fpu->__fpstate.regs.fxsave.xmm_space) != 16 * 16);
-	memset(&fpu->fpstate->regs.fxsave.xmm_space[8], 0, 8 * 16);
+	if (in_ia32_syscall())
+		memset(&fpu->fpstate->regs.fxsave.xmm_space[8*4], 0, 8 * 16);
 	/* Mark FP and SSE as in use when XSAVE is enabled */
 	if (use_xsave())

arch/x86/kernel/ptrace.c+2−2

@@ -1224,7 +1224,7 @@ static struct user_regset x86_64_regsets[] __ro_after_init = { · 1223 unmodified lines
1224	},	1224	},
1225	[REGSET_FP] = {	1225	[REGSET_FP] = {
1226	.core_note_type = NT_PRFPREG,	1226	.core_note_type = NT_PRFPREG,
1227	.n = sizeof(struct user_i387_struct) / sizeof(long),	1227	.n = sizeof(struct fxregs_state) / sizeof(long),
1228	.size = sizeof(long), .align = sizeof(long),	1228	.size = sizeof(long), .align = sizeof(long),
1229	.active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set	1229	.active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set
1230	},	1230	},
@@ -1271,7 +1271,7 @@ static struct user_regset x86_32_regsets[] __ro_after_init = { · 40 unmodified lines
1271	},	1271	},
1272	[REGSET_XFP] = {	1272	[REGSET_XFP] = {
1273	.core_note_type = NT_PRXFPREG,	1273	.core_note_type = NT_PRXFPREG,
1274	.n = sizeof(struct user32_fxsr_struct) / sizeof(u32),	1274	.n = sizeof(struct fxregs_state) / sizeof(u32),
1275	.size = sizeof(u32), .align = sizeof(u32),	1275	.size = sizeof(u32), .align = sizeof(u32),
1276	.active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set	1276	.active = regset_xregset_fpregs_active, .regset_get = xfpregs_get, .set = xfpregs_set
1277	},	1277	},

block/bfq-iosched.c+2−0

@@ -7018,6 +7018,8 @@ static void bfq_exit_queue(struct elevator_queue *e) · 7017 unmodified lines
7018	spin_unlock_irq(&bfqd->lock);	7018	spin_unlock_irq(&bfqd->lock);
7019	#endif	7019	#endif
7020		7020
		7021	wbt_enable_default(bfqd->queue);
		7022
7021	kfree(bfqd);	7023	kfree(bfqd);
7022	}	7024	}
7023		7025

block/blk-core.c+2−8

 	wake_up_all(&q->mq_freeze_wq);
 }
-void blk_set_queue_dying(struct request_queue *q)
-{
-	blk_queue_flag_set(QUEUE_FLAG_DYING, q);
-	blk_queue_start_drain(q);
-}
-EXPORT_SYMBOL_GPL(blk_set_queue_dying);
 /**
  * blk_cleanup_queue - shutdown a request queue
  * @q: request queue to shutdown
 	WARN_ON_ONCE(blk_queue_registered(q));
 	/* mark @q DYING, no new request or merges will be allowed afterwards */
-	blk_set_queue_dying(q);
+	blk_queue_flag_set(QUEUE_FLAG_DYING, q);
+	blk_queue_start_drain(q);
 	blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
 	blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);

block/blk-map.c+1−1

@@ -446,7 +446,7 @@ static struct bio bio_copy_kern(struct request_queue q, void *data, · 445 unmodified lines
446	if (bytes > len)	446	if (bytes > len)
447	bytes = len;	447	bytes = len;
448		448
449	page = alloc_page(GFP_NOIO \| gfp_mask);	449	page = alloc_page(GFP_NOIO \| __GFP_ZERO \| gfp_mask);
450	if (!page)	450	if (!page)
451	goto cleanup;	451	goto cleanup;
452		452

block/blk-mq.c+4−0

@@ -736,6 +736,10 @@ static void blk_complete_request(struct request *req) · 735 unmodified lines
736		736
737	/* Completion has already been traced */	737	/* Completion has already been traced */
738	bio_clear_flag(bio, BIO_TRACE_COMPLETION);	738	bio_clear_flag(bio, BIO_TRACE_COMPLETION);
		739
		740	if (req_op(req) == REQ_OP_ZONE_APPEND)
		741	bio->bi_iter.bi_sector = req->__sector;
		742
739	if (!is_flush)	743	if (!is_flush)
740	bio_endio(bio);	744	bio_endio(bio);
741	bio = next;	745	bio = next;

block/elevator.c+0−2

@@ -525,8 +525,6 @@ void elv_unregister_queue(struct request_queue *q) · 524 unmodified lines
525	kobject_del(&e->kobj);	525	kobject_del(&e->kobj);
526		526
527	e->registered = 0;	527	e->registered = 0;
528	/* Re-enable throttling in case elevator disabled it */
529	wbt_enable_default(q);
530	}	528	}
531	}	529	}
532		530

block/fops.c+2−0

@@ -289,6 +289,8 @@ static void blkdev_bio_end_io_async(struct bio *bio) · 288 unmodified lines
289	struct kiocb *iocb = dio->iocb;	289	struct kiocb *iocb = dio->iocb;
290	ssize_t ret;	290	ssize_t ret;
291		291
		292	WRITE_ONCE(iocb->private, NULL);
		293
292	if (likely(!bio->bi_status)) {	294	if (likely(!bio->bi_status)) {
293	ret = dio->size;	295	ret = dio->size;
294	iocb->ki_pos += ret;	296	iocb->ki_pos += ret;

block/genhd.c+14−0

@@ -548,6 +548,20 @@ out_free_ext_minor: · 547 unmodified lines
548	}	548	}
549	EXPORT_SYMBOL(device_add_disk);	549	EXPORT_SYMBOL(device_add_disk);
550		550
		551	/**
		552	* blk_mark_disk_dead - mark a disk as dead
		553	* @disk: disk to mark as dead
		554	*
		555	* Mark as disk as dead (e.g. surprise removed) and don't accept any new I/O
		556	* to this disk.
		557	*/
		558	void blk_mark_disk_dead(struct gendisk *disk)
		559	{
		560	set_bit(GD_DEAD, &disk->state);
		561	blk_queue_start_drain(disk->queue);
		562	}
		563	EXPORT_SYMBOL_GPL(blk_mark_disk_dead);
		564
551	/**	565	/**
552	* del_gendisk - remove the gendisk	566	* del_gendisk - remove the gendisk
553	* @disk: the struct gendisk to remove	567	* @disk: the struct gendisk to remove

drivers/acpi/processor_idle.c+5−0

 	  DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 	  DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
 	 (void *)1},
+	/* T40 can not handle C3 idle state */
+	{ set_max_cstate, "IBM ThinkPad T40", {
+	  DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
+	  DMI_MATCH(DMI_PRODUCT_NAME, "23737CU")},
+	 (void *)2},
 	{},
 };

drivers/acpi/tables.c+1−1

@@ -400,7 +400,7 @@ int __init_or_acpilib acpi_table_parse_entries_array( · 399 unmodified lines
400		400
401	acpi_get_table(id, instance, &table_header);	401	acpi_get_table(id, instance, &table_header);
402	if (!table_header) {	402	if (!table_header) {
403	pr_warn("%4.4s not present\n", id);	403	pr_debug("%4.4s not present\n", id);
404	return -ENODEV;	404	return -ENODEV;
405	}	405	}
406		406

drivers/block/loop.c+7−1

 #include <linux/ioprio.h>
 #include <linux/blk-cgroup.h>
 #include <linux/sched/mm.h>
+#include <linux/statfs.h>
 #include "loop.h"
 		granularity = 0;
 	} else {
+		struct kstatfs sbuf;
 		max_discard_sectors = UINT_MAX >> 9;
-		granularity = inode->i_sb->s_blocksize;
+		if (!vfs_statfs(&file->f_path, &sbuf))
+			granularity = sbuf.f_bsize;
+		else
+			max_discard_sectors = 0;
 	}
 	if (max_discard_sectors) {

drivers/block/mtip32xx/mtip32xx.c+1−1

@@ -4112,7 +4112,7 @@ static void mtip_pci_remove(struct pci_dev *pdev) · 4111 unmodified lines
4112	"Completion workers still active!\n");	4112	"Completion workers still active!\n");
4113	}	4113	}
4114		4114
4115	blk_set_queue_dying(dd->queue);	4115	blk_mark_disk_dead(dd->disk);
4116	set_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag);	4116	set_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag);
4117		4117
4118	/* Clean up the block layer. */	4118	/* Clean up the block layer. */

drivers/block/rbd.c+1−1

@@ -7185,7 +7185,7 @@ static ssize_t do_rbd_remove(struct bus_type *bus, · 7184 unmodified lines
7185	* IO to complete/fail.	7185	* IO to complete/fail.
7186	*/	7186	*/
7187	blk_mq_freeze_queue(rbd_dev->disk->queue);	7187	blk_mq_freeze_queue(rbd_dev->disk->queue);
7188	blk_set_queue_dying(rbd_dev->disk->queue);	7188	blk_mark_disk_dead(rbd_dev->disk);
7189	}	7189	}
7190		7190
7191	del_gendisk(rbd_dev->disk);	7191	del_gendisk(rbd_dev->disk);

drivers/block/xen-blkfront.c+1−1

@@ -2126,7 +2126,7 @@ static void blkfront_closing(struct blkfront_info *info) · 2125 unmodified lines
2126		2126
2127	/* No more blkif_request(). */	2127	/* No more blkif_request(). */
2128	blk_mq_stop_hw_queues(info->rq);	2128	blk_mq_stop_hw_queues(info->rq);
2129	blk_set_queue_dying(info->rq);	2129	blk_mark_disk_dead(info->gd);
2130	set_capacity(info->gd, 0);	2130	set_capacity(info->gd, 0);
2131		2131
2132	for_each_rinfo(info, rinfo, i) {	2132	for_each_rinfo(info, rinfo, i) {

drivers/dma/at_xdmac.c+3−1

 		__func__, atchan->irq_status);
 	if (!(atchan->irq_status & AT_XDMAC_CIS_LIS) &&
-	    !(atchan->irq_status & error_mask))
+	    !(atchan->irq_status & error_mask)) {
+		spin_unlock_irq(&atchan->lock);
 		return;
+	}
 	if (atchan->irq_status & error_mask)
 		at_xdmac_handle_error(atchan);

drivers/dma/ptdma/ptdma-dev.c+9−8

 	if (!cmd_q->qbase) {
 		dev_err(dev, "unable to allocate command queue\n");
 		ret = -ENOMEM;
-		goto e_dma_alloc;
+		goto e_destroy_pool;
 	}
 	cmd_q->qidx = 0;
 	/* Request an irq */
 	ret = request_irq(pt->pt_irq, pt_core_irq_handler, 0, dev_name(pt->dev), pt);
-	if (ret)
+	if (ret) {
-		goto e_pool;
+		dev_err(dev, "unable to allocate an IRQ\n");
+		goto e_free_dma;
+	}
 	/* Update the device registers with queue information. */
 	cmd_q->qcontrol &= ~CMD_Q_SIZE;
 	/* Register the DMA engine support */
 	ret = pt_dmaengine_register(pt);
 	if (ret)
-		goto e_dmaengine;
+		goto e_free_irq;
 	/* Set up debugfs entries */
 	ptdma_debugfs_setup(pt);
 	return 0;
-e_dmaengine:
+e_free_irq:
 	free_irq(pt->pt_irq, pt);
-e_dma_alloc:
+e_free_dma:
 	dma_free_coherent(dev, cmd_q->qsize, cmd_q->qbase, cmd_q->qbase_dma);
-e_pool:
+e_destroy_pool:
-	dev_err(dev, "unable to allocate an IRQ\n");
 	dma_pool_destroy(pt->cmd_q.dma_pool);
 	return ret;

drivers/dma/sh/rcar-dmac.c+7−2

 	dmac->dev = &pdev->dev;
 	platform_set_drvdata(pdev, dmac);
-	dma_set_max_seg_size(dmac->dev, RCAR_DMATCR_MASK);
+	ret = dma_set_max_seg_size(dmac->dev, RCAR_DMATCR_MASK);
-	dma_set_mask_and_coherent(dmac->dev, DMA_BIT_MASK(40));
+	if (ret)
+		return ret;
+	ret = dma_set_mask_and_coherent(dmac->dev, DMA_BIT_MASK(40));
+	if (ret)
+		return ret;
 	ret = rcar_dmac_parse_of(&pdev->dev, dmac);
 	if (ret < 0)

drivers/dma/sh/shdma-base.c+3−1

@@ -115,8 +115,10 @@ static dma_cookie_t shdma_tx_submit(struct dma_async_tx_descriptor *tx) · 114 unmodified lines
115	ret = pm_runtime_get(schan->dev);	115	ret = pm_runtime_get(schan->dev);
116		116
117	spin_unlock_irq(&schan->chan_lock);	117	spin_unlock_irq(&schan->chan_lock);
118	if (ret < 0)	118	if (ret < 0) {
119	dev_err(schan->dev, "%s(): GET = %d\n", __func__, ret);	119	dev_err(schan->dev, "%s(): GET = %d\n", __func__, ret);
		120	pm_runtime_put(schan->dev);
		121	}
120		122
121	pm_runtime_barrier(schan->dev);	123	pm_runtime_barrier(schan->dev);
122		124

drivers/dma/stm32-dmamux.c+3−1

 	ret = of_dma_router_register(node, stm32_dmamux_route_allocate,
 				     &stm32_dmamux->dmarouter);
 	if (ret)
-		goto err_clk;
+		goto pm_disable;
 	return 0;
+pm_disable:
+	pm_runtime_disable(&pdev->dev);
 err_clk:
 	clk_disable_unprepare(stm32_dmamux->clk);

drivers/edac/edac_mc.c+1−1

@@ -215,7 +215,7 @@ void edac_align_ptr(void *p, unsigned int size, int n_elems) · 214 unmodified lines
215	else	215	else
216	return (char *)ptr;	216	return (char *)ptr;
217		217
218	r = (unsigned long)p % align;	218	r = (unsigned long)ptr % align;
219		219
220	if (r == 0)	220	if (r == 0)
221	return (char *)ptr;	221	return (char *)ptr;

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

 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	/* SMU saves SDMA state for us */
+	if (adev->in_s0ix)
+		return 0;
 	return sdma_v4_0_hw_fini(adev);
 }
 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	/* SMU restores SDMA state for us */
+	if (adev->in_s0ix)
+		return 0;
 	return sdma_v4_0_hw_init(adev);
 }

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

@@ -1238,21 +1238,37 @@ static int sienna_cichlid_populate_umd_state_clk(struct smu_context *smu) · 1237 unmodified lines
1238	&dpm_context->dpm_tables.soc_table;	1238	&dpm_context->dpm_tables.soc_table;
1239	struct smu_umd_pstate_table *pstate_table =	1239	struct smu_umd_pstate_table *pstate_table =
1240	&smu->pstate_table;	1240	&smu->pstate_table;
		1241	struct amdgpu_device *adev = smu->adev;
1241		1242
1242	pstate_table->gfxclk_pstate.min = gfx_table->min;	1243	pstate_table->gfxclk_pstate.min = gfx_table->min;
1243	pstate_table->gfxclk_pstate.peak = gfx_table->max;	1244	pstate_table->gfxclk_pstate.peak = gfx_table->max;
1244	if (gfx_table->max >= SIENNA_CICHLID_UMD_PSTATE_PROFILING_GFXCLK)
1245	pstate_table->gfxclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_GFXCLK;
1246		1245
1247	pstate_table->uclk_pstate.min = mem_table->min;	1246	pstate_table->uclk_pstate.min = mem_table->min;
1248	pstate_table->uclk_pstate.peak = mem_table->max;	1247	pstate_table->uclk_pstate.peak = mem_table->max;
1249	if (mem_table->max >= SIENNA_CICHLID_UMD_PSTATE_PROFILING_MEMCLK)
1250	pstate_table->uclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_MEMCLK;
1251		1248
1252	pstate_table->socclk_pstate.min = soc_table->min;	1249	pstate_table->socclk_pstate.min = soc_table->min;
1253	pstate_table->socclk_pstate.peak = soc_table->max;	1250	pstate_table->socclk_pstate.peak = soc_table->max;
1254	if (soc_table->max >= SIENNA_CICHLID_UMD_PSTATE_PROFILING_SOCCLK)	1251
		1252	switch (adev->asic_type) {
		1253	case CHIP_SIENNA_CICHLID:
		1254	case CHIP_NAVY_FLOUNDER:
		1255	pstate_table->gfxclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_GFXCLK;
		1256	pstate_table->uclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_MEMCLK;
1255	pstate_table->socclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_SOCCLK;	1257	pstate_table->socclk_pstate.standard = SIENNA_CICHLID_UMD_PSTATE_PROFILING_SOCCLK;
		1258	break;
		1259	case CHIP_DIMGREY_CAVEFISH:
		1260	pstate_table->gfxclk_pstate.standard = DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_GFXCLK;
		1261	pstate_table->uclk_pstate.standard = DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_MEMCLK;
		1262	pstate_table->socclk_pstate.standard = DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_SOCCLK;
		1263	break;
		1264	case CHIP_BEIGE_GOBY:
		1265	pstate_table->gfxclk_pstate.standard = BEIGE_GOBY_UMD_PSTATE_PROFILING_GFXCLK;
		1266	pstate_table->uclk_pstate.standard = BEIGE_GOBY_UMD_PSTATE_PROFILING_MEMCLK;
		1267	pstate_table->socclk_pstate.standard = BEIGE_GOBY_UMD_PSTATE_PROFILING_SOCCLK;
		1268	break;
		1269	default:
		1270	break;
		1271	}
1256		1272
1257	return 0;	1273	return 0;
1258	}	1274	}

drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.h+8−0

@@ -33,6 +33,14 @@ typedef enum { · 32 unmodified lines
33	#define SIENNA_CICHLID_UMD_PSTATE_PROFILING_SOCCLK 960	33	#define SIENNA_CICHLID_UMD_PSTATE_PROFILING_SOCCLK 960
34	#define SIENNA_CICHLID_UMD_PSTATE_PROFILING_MEMCLK 1000	34	#define SIENNA_CICHLID_UMD_PSTATE_PROFILING_MEMCLK 1000
35		35
		36	#define DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_GFXCLK 1950
		37	#define DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_SOCCLK 960
		38	#define DIMGREY_CAVEFISH_UMD_PSTATE_PROFILING_MEMCLK 676
		39
		40	#define BEIGE_GOBY_UMD_PSTATE_PROFILING_GFXCLK 2200
		41	#define BEIGE_GOBY_UMD_PSTATE_PROFILING_SOCCLK 960
		42	#define BEIGE_GOBY_UMD_PSTATE_PROFILING_MEMCLK 1000
		43
36	extern void sienna_cichlid_set_ppt_funcs(struct smu_context *smu);	44	extern void sienna_cichlid_set_ppt_funcs(struct smu_context *smu);
37		45
38	#endif	46	#endif

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

 static int yellow_carp_mode_reset(struct smu_context *smu, int type)
 {
-	int ret = 0, index = 0;
+	int ret = 0;
-	index = smu_cmn_to_asic_specific_index(smu, CMN2ASIC_MAPPING_MSG,
-				SMU_MSG_GfxDeviceDriverReset);
-	if (index < 0)
-		return index == -EACCES ? 0 : index;
-	ret = smu_cmn_send_smc_msg_with_param(smu, (uint16_t)index, type, NULL);
+	ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_GfxDeviceDriverReset, type, NULL);
 	if (ret)
 		dev_err(smu->adev->dev, "Failed to mode reset!\n");

drivers/gpu/drm/drm_atomic_uapi.c+8−6

 	state->mode_blob = NULL;
 	if (mode) {
+		struct drm_property_blob *blob;
 		drm_mode_convert_to_umode(&umode, mode);
-		state->mode_blob =
+		blob = drm_property_create_blob(crtc->dev,
-			drm_property_create_blob(state->crtc->dev,
+						sizeof(umode), &umode);
-						 sizeof(umode),
+		if (IS_ERR(blob))
-						 &umode);
+			return PTR_ERR(blob);
-		if (IS_ERR(state->mode_blob))
-			return PTR_ERR(state->mode_blob);
 		drm_mode_copy(&state->mode, mode);
+		state->mode_blob = blob;
 		state->enable = true;
 		drm_dbg_atomic(crtc->dev,
 			       "Set [MODE:%s] for [CRTC:%d:%s] state %p\n",

drivers/gpu/drm/drm_gem_cma_helper.c+1−0

@@ -512,6 +512,7 @@ int drm_gem_cma_mmap(struct drm_gem_cma_object cma_obj, struct vm_area_struct · 511 unmodified lines
512	*/	512	*/
513	vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node);	513	vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node);
514	vma->vm_flags &= ~VM_PFNMAP;	514	vma->vm_flags &= ~VM_PFNMAP;
		515	vma->vm_flags \|= VM_DONTEXPAND;
515		516
516	if (cma_obj->map_noncoherent) {	517	if (cma_obj->map_noncoherent) {
517	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);	518	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);

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

@@ -101,6 +101,7 @@ config DRM_I915_USERPTR · 100 unmodified lines
101	config DRM_I915_GVT	101	config DRM_I915_GVT
102	bool "Enable Intel GVT-g graphics virtualization host support"	102	bool "Enable Intel GVT-g graphics virtualization host support"
103	depends on DRM_I915	103	depends on DRM_I915
		104	depends on X86
104	depends on 64BIT	105	depends on 64BIT
105	default n	106	default n
106	help	107	help

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

@@ -1115,7 +1115,8 @@ static int intel_fbc_check_plane(struct intel_atomic_state *state, · 1114 unmodified lines
1115		1115
1116	/* Wa_22010751166: icl, ehl, tgl, dg1, rkl */	1116	/* Wa_22010751166: icl, ehl, tgl, dg1, rkl */
1117	if (DISPLAY_VER(i915) >= 11 &&	1117	if (DISPLAY_VER(i915) >= 11 &&
1118	(plane_state->view.color_plane[0].y + drm_rect_height(&plane_state->uapi.src)) & 3) {	1118	(plane_state->view.color_plane[0].y +
		1119	(drm_rect_height(&plane_state->uapi.src) >> 16)) & 3) {
1119	plane_state->no_fbc_reason = "plane end Y offset misaligned";	1120	plane_state->no_fbc_reason = "plane end Y offset misaligned";
1120	return false;	1121	return false;
1121	}	1122	}

drivers/gpu/drm/i915/display/intel_opregion.c+15−0

@@ -360,6 +360,21 @@ int intel_opregion_notify_encoder(struct intel_encoder *intel_encoder, · 359 unmodified lines
360	port++;	360	port++;
361	}	361	}
362		362
		363	/*
		364	* The port numbering and mapping here is bizarre. The now-obsolete
		365	* swsci spec supports ports numbered [0..4]. Port E is handled as a
		366	* special case, but port F and beyond are not. The functionality is
		367	* supposed to be obsolete for new platforms. Just bail out if the port
		368	* number is out of bounds after mapping.
		369	*/
		370	if (port > 4) {
		371	drm_dbg_kms(&dev_priv->drm,
		372	"[ENCODER:%d:%s] port %c (index %u) out of bounds for display power state notification\n",
		373	intel_encoder->base.base.id, intel_encoder->base.name,
		374	port_name(intel_encoder->port), port);
		375	return -EINVAL;
		376	}
		377
363	if (!enable)	378	if (!enable)
364	parm \|= 4 << 8;	379	parm \|= 4 << 8;
365		380

drivers/gpu/drm/i915/gem/i915_gem_ttm.c+2−4

 	} else if (obj->mm.madv != I915_MADV_WILLNEED) {
 		bo->priority = I915_TTM_PRIO_PURGE;
 	} else if (!i915_gem_object_has_pages(obj)) {
-		if (bo->priority < I915_TTM_PRIO_HAS_PAGES)
+		bo->priority = I915_TTM_PRIO_NO_PAGES;
-			bo->priority = I915_TTM_PRIO_HAS_PAGES;
 	} else {
-		if (bo->priority > I915_TTM_PRIO_NO_PAGES)
+		bo->priority = I915_TTM_PRIO_HAS_PAGES;
-			bo->priority = I915_TTM_PRIO_NO_PAGES;
 	}
 	ttm_bo_move_to_lru_tail(bo, bo->resource, NULL);

drivers/gpu/drm/i915/gvt/gtt.c+2−2

@@ -1148,7 +1148,7 @@ static inline void ppgtt_generate_shadow_entry(struct intel_gvt_gtt_entry *se, · 1147 unmodified lines
1148	ops->set_pfn(se, s->shadow_page.mfn);	1148	ops->set_pfn(se, s->shadow_page.mfn);
1149	}	1149	}
1150		1150
1151	/**	1151	/*
1152	* Check if can do 2M page	1152	* Check if can do 2M page
1153	* @vgpu: target vgpu	1153	* @vgpu: target vgpu
1154	* @entry: target pfn's gtt entry	1154	* @entry: target pfn's gtt entry
@@ -2193,7 +2193,7 @@ static int emulate_ggtt_mmio_read(struct intel_vgpu *vgpu, · 1038 unmodified lines
2193	}	2193	}
2194		2194
2195	/**	2195	/**
2196	* intel_vgpu_emulate_gtt_mmio_read - emulate GTT MMIO register read	2196	* intel_vgpu_emulate_ggtt_mmio_read - emulate GTT MMIO register read
2197	* @vgpu: a vGPU	2197	* @vgpu: a vGPU
2198	* @off: register offset	2198	* @off: register offset
2199	* @p_data: data will be returned to guest	2199	* @p_data: data will be returned to guest

drivers/gpu/drm/i915/intel_pm.c+2−2

@@ -4853,7 +4853,7 @@ static bool check_mbus_joined(u8 active_pipes, · 4852 unmodified lines
4853	{	4853	{
4854	int i;	4854	int i;
4855		4855
4856	for (i = 0; i < dbuf_slices[i].active_pipes; i++) {	4856	for (i = 0; dbuf_slices[i].active_pipes != 0; i++) {
4857	if (dbuf_slices[i].active_pipes == active_pipes)	4857	if (dbuf_slices[i].active_pipes == active_pipes)
4858	return dbuf_slices[i].join_mbus;	4858	return dbuf_slices[i].join_mbus;
4859	}	4859	}
@@ -4870,7 +4870,7 @@ static u8 compute_dbuf_slices(enum pipe pipe, u8 active_pipes, bool join_mbus, · 10 unmodified lines
4870	{	4870	{
4871	int i;	4871	int i;
4872		4872
4873	for (i = 0; i < dbuf_slices[i].active_pipes; i++) {	4873	for (i = 0; dbuf_slices[i].active_pipes != 0; i++) {
4874	if (dbuf_slices[i].active_pipes == active_pipes &&	4874	if (dbuf_slices[i].active_pipes == active_pipes &&
4875	dbuf_slices[i].join_mbus == join_mbus)	4875	dbuf_slices[i].join_mbus == join_mbus)
4876	return dbuf_slices[i].dbuf_mask[pipe];	4876	return dbuf_slices[i].dbuf_mask[pipe];

drivers/gpu/drm/mediatek/mtk_dsi.c+84−83

 	mtk_dsi_poweroff(dsi);
 }
+static int mtk_dsi_encoder_init(struct drm_device *drm, struct mtk_dsi *dsi)
+{
+	int ret;
+	ret = drm_simple_encoder_init(drm, &dsi->encoder,
+				      DRM_MODE_ENCODER_DSI);
+	if (ret) {
+		DRM_ERROR("Failed to encoder init to drm\n");
+		return ret;
+	}
+	dsi->encoder.possible_crtcs = mtk_drm_find_possible_crtc_by_comp(drm, dsi->host.dev);
+	ret = drm_bridge_attach(&dsi->encoder, &dsi->bridge, NULL,
+				DRM_BRIDGE_ATTACH_NO_CONNECTOR);
+	if (ret)
+		goto err_cleanup_encoder;
+	dsi->connector = drm_bridge_connector_init(drm, &dsi->encoder);
+	if (IS_ERR(dsi->connector)) {
+		DRM_ERROR("Unable to create bridge connector\n");
+		ret = PTR_ERR(dsi->connector);
+		goto err_cleanup_encoder;
+	}
+	drm_connector_attach_encoder(dsi->connector, &dsi->encoder);
+	return 0;
+err_cleanup_encoder:
+	drm_encoder_cleanup(&dsi->encoder);
+	return ret;
+}
+static int mtk_dsi_bind(struct device *dev, struct device *master, void *data)
+{
+	int ret;
+	struct drm_device *drm = data;
+	struct mtk_dsi *dsi = dev_get_drvdata(dev);
+	ret = mtk_dsi_encoder_init(drm, dsi);
+	if (ret)
+		return ret;
+	return device_reset_optional(dev);
+}
+static void mtk_dsi_unbind(struct device *dev, struct device *master,
+			   void *data)
+{
+	struct mtk_dsi *dsi = dev_get_drvdata(dev);
+	drm_encoder_cleanup(&dsi->encoder);
+}
+static const struct component_ops mtk_dsi_component_ops = {
+	.bind = mtk_dsi_bind,
+	.unbind = mtk_dsi_unbind,
+};
 static int mtk_dsi_host_attach(struct mipi_dsi_host *host,
 			       struct mipi_dsi_device *device)
 {
 	struct mtk_dsi *dsi = host_to_dsi(host);
+	struct device *dev = host->dev;
+	int ret;
 	dsi->lanes = device->lanes;
 	dsi->format = device->format;
 	dsi->mode_flags = device->mode_flags;
+	dsi->next_bridge = devm_drm_of_get_bridge(dev, dev->of_node, 0, 0);
+	if (IS_ERR(dsi->next_bridge))
+		return PTR_ERR(dsi->next_bridge);
+	drm_bridge_add(&dsi->bridge);
+	ret = component_add(host->dev, &mtk_dsi_component_ops);
+	if (ret) {
+		DRM_ERROR("failed to add dsi_host component: %d\n", ret);
+		drm_bridge_remove(&dsi->bridge);
+		return ret;
+	}
 	return 0;
 }
+static int mtk_dsi_host_detach(struct mipi_dsi_host *host,
+			       struct mipi_dsi_device *device)
+{
+	struct mtk_dsi *dsi = host_to_dsi(host);
+	component_del(host->dev, &mtk_dsi_component_ops);
+	drm_bridge_remove(&dsi->bridge);
+	return 0;
+}
 static void mtk_dsi_wait_for_idle(struct mtk_dsi *dsi)
 {
 	int ret;
 static const struct mipi_dsi_host_ops mtk_dsi_ops = {
 	.attach = mtk_dsi_host_attach,
+	.detach = mtk_dsi_host_detach,
 	.transfer = mtk_dsi_host_transfer,
 };
-static int mtk_dsi_encoder_init(struct drm_device *drm, struct mtk_dsi *dsi)
-{
-	int ret;
-	ret = drm_simple_encoder_init(drm, &dsi->encoder,
-				      DRM_MODE_ENCODER_DSI);
-	if (ret) {
-		DRM_ERROR("Failed to encoder init to drm\n");
-		return ret;
-	}
-	dsi->encoder.possible_crtcs = mtk_drm_find_possible_crtc_by_comp(drm, dsi->host.dev);
-	ret = drm_bridge_attach(&dsi->encoder, &dsi->bridge, NULL,
-				DRM_BRIDGE_ATTACH_NO_CONNECTOR);
-	if (ret)
-		goto err_cleanup_encoder;
-	dsi->connector = drm_bridge_connector_init(drm, &dsi->encoder);
-	if (IS_ERR(dsi->connector)) {
-		DRM_ERROR("Unable to create bridge connector\n");
-		ret = PTR_ERR(dsi->connector);
-		goto err_cleanup_encoder;
-	}
-	drm_connector_attach_encoder(dsi->connector, &dsi->encoder);
-	return 0;
-err_cleanup_encoder:
-	drm_encoder_cleanup(&dsi->encoder);
-	return ret;
-}
-static int mtk_dsi_bind(struct device *dev, struct device *master, void *data)
-{
-	int ret;
-	struct drm_device *drm = data;
-	struct mtk_dsi *dsi = dev_get_drvdata(dev);
-	ret = mtk_dsi_encoder_init(drm, dsi);
-	if (ret)
-		return ret;
-	return device_reset_optional(dev);
-}
-static void mtk_dsi_unbind(struct device *dev, struct device *master,
-			   void *data)
-{
-	struct mtk_dsi *dsi = dev_get_drvdata(dev);
-	drm_encoder_cleanup(&dsi->encoder);
-}
-static const struct component_ops mtk_dsi_component_ops = {
-	.bind = mtk_dsi_bind,
-	.unbind = mtk_dsi_unbind,
-};
 static int mtk_dsi_probe(struct platform_device *pdev)
 {
 	struct mtk_dsi *dsi;
 	struct device *dev = &pdev->dev;
-	struct drm_panel *panel;
 	struct resource *regs;
 	int irq_num;
 	int ret;
 		return ret;
 	}
-	ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0,
-					  &panel, &dsi->next_bridge);
-	if (ret)
-		goto err_unregister_host;
-	if (panel) {
-		dsi->next_bridge = devm_drm_panel_bridge_add(dev, panel);
-		if (IS_ERR(dsi->next_bridge)) {
-			ret = PTR_ERR(dsi->next_bridge);
-			goto err_unregister_host;
-		}
-	}
 	dsi->driver_data = of_device_get_match_data(dev);
 	dsi->engine_clk = devm_clk_get(dev, "engine");
 	dsi->bridge.of_node = dev->of_node;
 	dsi->bridge.type = DRM_MODE_CONNECTOR_DSI;
-	drm_bridge_add(&dsi->bridge);
-	ret = component_add(&pdev->dev, &mtk_dsi_component_ops);
-	if (ret) {
-		dev_err(&pdev->dev, "failed to add component: %d\n", ret);
-		goto err_unregister_host;
-	}
 	return 0;
 err_unregister_host:
 	struct mtk_dsi *dsi = platform_get_drvdata(pdev);
 	mtk_output_dsi_disable(dsi);
-	drm_bridge_remove(&dsi->bridge);
-	component_del(&pdev->dev, &mtk_dsi_component_ops);
 	mipi_dsi_host_unregister(&dsi->host);
 	return 0;

drivers/gpu/drm/radeon/atombios_encoders.c+2−1

@@ -198,7 +198,8 @@ void radeon_atom_backlight_init(struct radeon_encoder *radeon_encoder, · 197 unmodified lines
198	* so don't register a backlight device	198	* so don't register a backlight device
199	*/	199	*/
200	if ((rdev->pdev->subsystem_vendor == PCI_VENDOR_ID_APPLE) &&	200	if ((rdev->pdev->subsystem_vendor == PCI_VENDOR_ID_APPLE) &&
201	(rdev->pdev->device == 0x6741))	201	(rdev->pdev->device == 0x6741) &&
		202	!dmi_match(DMI_PRODUCT_NAME, "iMac12,1"))
202	return;	203	return;
203		204
204	if (!radeon_encoder->enc_priv)	205	if (!radeon_encoder->enc_priv)

drivers/hwmon/hwmon.c+8−6

@@ -214,12 +214,14 @@ static int hwmon_thermal_add_sensor(struct device *dev, int index) · 213 unmodified lines
214		214
215	tzd = devm_thermal_zone_of_sensor_register(dev, index, tdata,	215	tzd = devm_thermal_zone_of_sensor_register(dev, index, tdata,
216	&hwmon_thermal_ops);	216	&hwmon_thermal_ops);
217	/*	217	if (IS_ERR(tzd)) {
218	* If CONFIG_THERMAL_OF is disabled, this returns -ENODEV,	218	if (PTR_ERR(tzd) != -ENODEV)
219	* so ignore that error but forward any other error.	219	return PTR_ERR(tzd);
220	*/	220	dev_info(dev, "temp%d_input not attached to any thermal zone\n",
221	if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV))	221	index + 1);
222	return PTR_ERR(tzd);	222	devm_kfree(dev, tdata);
		223	return 0;
		224	}
223		225
224	err = devm_add_action(dev, hwmon_thermal_remove_sensor, &tdata->node);	226	err = devm_add_action(dev, hwmon_thermal_remove_sensor, &tdata->node);
225	if (err)	227	if (err)

drivers/hwmon/ntc_thermistor.c+1−1

@@ -59,7 +59,7 @@ static const struct platform_device_id ntc_thermistor_id[] = { · 58 unmodified lines
59	[NTC_NCP15XH103] = { "ncp15xh103", TYPE_NCPXXXH103 },	59	[NTC_NCP15XH103] = { "ncp15xh103", TYPE_NCPXXXH103 },
60	[NTC_NCP18WB473] = { "ncp18wb473", TYPE_NCPXXWB473 },	60	[NTC_NCP18WB473] = { "ncp18wb473", TYPE_NCPXXWB473 },
61	[NTC_NCP21WB473] = { "ncp21wb473", TYPE_NCPXXWB473 },	61	[NTC_NCP21WB473] = { "ncp21wb473", TYPE_NCPXXWB473 },
62	[NTC_SSG1404001221] = { "ssg1404-001221", TYPE_NCPXXWB473 },	62	[NTC_SSG1404001221] = { "ssg1404_001221", TYPE_NCPXXWB473 },
63	[NTC_LAST] = { },	63	[NTC_LAST] = { },
64	};	64	};
65		65

drivers/hwmon/pmbus/pmbus_core.c+5−0

 		pmbus_update_sensor_data(client, s2);
 	regval = status & mask;
+	if (regval) {
+		ret = pmbus_write_byte_data(client, page, reg, regval);
+		if (ret)
+			goto unlock;
+	}
 	if (s1 && s2) {
 		s64 v1, v2;

drivers/i2c/busses/Kconfig+3−3

@@ -488,7 +488,7 @@ config I2C_BRCMSTB · 487 unmodified lines
488		488
489	config I2C_CADENCE	489	config I2C_CADENCE
490	tristate "Cadence I2C Controller"	490	tristate "Cadence I2C Controller"
491	depends on ARCH_ZYNQ \|\| ARM64 \|\| XTENSA	491	depends on ARCH_ZYNQ \|\| ARM64 \|\| XTENSA \|\| COMPILE_TEST
492	help	492	help
493	Say yes here to select Cadence I2C Host Controller. This controller is	493	Say yes here to select Cadence I2C Host Controller. This controller is
494	e.g. used by Xilinx Zynq.	494	e.g. used by Xilinx Zynq.
@@ -680,7 +680,7 @@ config I2C_IMG · 185 unmodified lines
680		680
681	config I2C_IMX	681	config I2C_IMX
682	tristate "IMX I2C interface"	682	tristate "IMX I2C interface"
683	depends on ARCH_MXC \|\| ARCH_LAYERSCAPE \|\| COLDFIRE	683	depends on ARCH_MXC \|\| ARCH_LAYERSCAPE \|\| COLDFIRE \|\| COMPILE_TEST
684	select I2C_SLAVE	684	select I2C_SLAVE
685	help	685	help
686	Say Y here if you want to use the IIC bus controller on	686	Say Y here if you want to use the IIC bus controller on
@@ -935,7 +935,7 @@ config I2C_QCOM_GENI · 248 unmodified lines
935		935
936	config I2C_QUP	936	config I2C_QUP
937	tristate "Qualcomm QUP based I2C controller"	937	tristate "Qualcomm QUP based I2C controller"
938	depends on ARCH_QCOM	938	depends on ARCH_QCOM \|\| COMPILE_TEST
939	help	939	help
940	If you say yes to this option, support will be included for the	940	If you say yes to this option, support will be included for the
941	built-in I2C interface on the Qualcomm SoCs.	941	built-in I2C interface on the Qualcomm SoCs.

drivers/i2c/busses/i2c-bcm2835.c+11−0

 #define BCM2835_I2C_FIFO	0x10
 #define BCM2835_I2C_DIV		0x14
 #define BCM2835_I2C_DEL		0x18
+/*
+ * 16-bit field for the number of SCL cycles to wait after rising SCL
+ * before deciding the slave is not responding. 0 disables the
+ * timeout detection.
+ */
 #define BCM2835_I2C_CLKT	0x1c
 #define BCM2835_I2C_C_READ	BIT(0)
 	adap->dev.of_node = pdev->dev.of_node;
 	adap->quirks = of_device_get_match_data(&pdev->dev);
+	/*
+	 * Disable the hardware clock stretching timeout. SMBUS
+	 * specifies a limit for how long the device can stretch the
+	 * clock, but core I2C doesn't.
+	 */
+	bcm2835_i2c_writel(i2c_dev, BCM2835_I2C_CLKT, 0);
 	bcm2835_i2c_writel(i2c_dev, BCM2835_I2C_C, 0);
 	ret = i2c_add_adapter(adap);

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

@@ -673,7 +673,7 @@ static int brcmstb_i2c_probe(struct platform_device *pdev) · 672 unmodified lines
673		673
674	/* set the data in/out register size for compatible SoCs */	674	/* set the data in/out register size for compatible SoCs */
675	if (of_device_is_compatible(dev->device->of_node,	675	if (of_device_is_compatible(dev->device->of_node,
676	"brcmstb,brcmper-i2c"))	676	"brcm,brcmper-i2c"))
677	dev->data_regsz = sizeof(u8);	677	dev->data_regsz = sizeof(u8);
678	else	678	else
679	dev->data_regsz = sizeof(u32);	679	dev->data_regsz = sizeof(u32);

drivers/i2c/busses/i2c-qcom-cci.c+11−5

 		cci->master[idx].adap.quirks = &cci->data->quirks;
 		cci->master[idx].adap.algo = &cci_algo;
 		cci->master[idx].adap.dev.parent = dev;
-		cci->master[idx].adap.dev.of_node = child;
+		cci->master[idx].adap.dev.of_node = of_node_get(child);
 		cci->master[idx].master = idx;
 		cci->master[idx].cci = cci;
 			continue;
 		ret = i2c_add_adapter(&cci->master[i].adap);
-		if (ret < 0)
+		if (ret < 0) {
+			of_node_put(cci->master[i].adap.dev.of_node);
 			goto error_i2c;
+		}
 	}
 	pm_runtime_set_autosuspend_delay(dev, MSEC_PER_SEC);
 	return 0;
 error_i2c:
-	for (; i >= 0; i--) {
+	for (--i ; i >= 0; i--) {
-		if (cci->master[i].cci)
+		if (cci->master[i].cci) {
 			i2c_del_adapter(&cci->master[i].adap);
+			of_node_put(cci->master[i].adap.dev.of_node);
+		}
 	}
 error:
 	disable_irq(cci->irq);
 	int i;
 	for (i = 0; i < cci->data->num_masters; i++) {
-		if (cci->master[i].cci)
+		if (cci->master[i].cci) {
 			i2c_del_adapter(&cci->master[i].adap);
+			of_node_put(cci->master[i].adap.dev.of_node);
+		}
 		cci_halt(cci, i);
 	}

drivers/input/input.c+6−0

 	/* KEY_RESERVED is not supposed to be transmitted to userspace. */
 	__clear_bit(KEY_RESERVED, dev->keybit);
+	/* Buttonpads should not map BTN_RIGHT and/or BTN_MIDDLE. */
+	if (test_bit(INPUT_PROP_BUTTONPAD, dev->propbit)) {
+		__clear_bit(BTN_RIGHT, dev->keybit);
+		__clear_bit(BTN_MIDDLE, dev->keybit);
+	}
 	/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
 	input_cleanse_bitmasks(dev);

drivers/input/mouse/psmouse-smbus.c+10−0

 				    "Marking SMBus companion %s as gone\n",
 				    dev_name(&smbdev->client->dev));
 			smbdev->dead = true;
+			device_link_remove(&smbdev->client->dev,
+					   &smbdev->psmouse->ps2dev.serio->dev);
 			serio_rescan(smbdev->psmouse->ps2dev.serio);
 		} else {
 			list_del(&smbdev->node);
 		kfree(smbdev);
 	} else {
 		smbdev->dead = true;
+		device_link_remove(&smbdev->client->dev,
+				   &psmouse->ps2dev.serio->dev);
 		psmouse_dbg(smbdev->psmouse,
 			    "posting removal request for SMBus companion %s\n",
 			    dev_name(&smbdev->client->dev));
 	if (smbdev->client) {
 		/* We have our companion device */
+		if (!device_link_add(&smbdev->client->dev,
+				     &psmouse->ps2dev.serio->dev,
+				     DL_FLAG_STATELESS))
+			psmouse_warn(psmouse,
+				     "failed to set up link with iSMBus companion %s\n",
+				     dev_name(&smbdev->client->dev));
 		return 0;
 	}

drivers/input/touchscreen/zinitix.c+12−0

@@ -571,8 +571,20 @@ static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume); · 570 unmodified lines
571		571
572	#ifdef CONFIG_OF	572	#ifdef CONFIG_OF
573	static const struct of_device_id zinitix_of_match[] = {	573	static const struct of_device_id zinitix_of_match[] = {
		574	{ .compatible = "zinitix,bt402" },
		575	{ .compatible = "zinitix,bt403" },
		576	{ .compatible = "zinitix,bt404" },
		577	{ .compatible = "zinitix,bt412" },
		578	{ .compatible = "zinitix,bt413" },
		579	{ .compatible = "zinitix,bt431" },
		580	{ .compatible = "zinitix,bt432" },
		581	{ .compatible = "zinitix,bt531" },
574	{ .compatible = "zinitix,bt532" },	582	{ .compatible = "zinitix,bt532" },
		583	{ .compatible = "zinitix,bt538" },
575	{ .compatible = "zinitix,bt541" },	584	{ .compatible = "zinitix,bt541" },
		585	{ .compatible = "zinitix,bt548" },
		586	{ .compatible = "zinitix,bt554" },
		587	{ .compatible = "zinitix,at100" },
576	{ }	588	{ }
577	};	589	};
578	MODULE_DEVICE_TABLE(of, zinitix_of_match);	590	MODULE_DEVICE_TABLE(of, zinitix_of_match);

drivers/md/dm.c+1−1

@@ -2077,7 +2077,7 @@ static void __dm_destroy(struct mapped_device *md, bool wait) · 2076 unmodified lines
2077	set_bit(DMF_FREEING, &md->flags);	2077	set_bit(DMF_FREEING, &md->flags);
2078	spin_unlock(&_minor_lock);	2078	spin_unlock(&_minor_lock);
2079		2079
2080	blk_set_queue_dying(md->queue);	2080	blk_mark_disk_dead(md->disk);
2081		2081
2082	/*	2082	/*
2083	* Take suspend_lock so that presuspend and postsuspend methods	2083	* Take suspend_lock so that presuspend and postsuspend methods

drivers/mtd/devices/phram.c+8−4

 		}
 	}
-	if (erasesize)
-		div_u64_rem(len, (uint32_t)erasesize, &rem);
 	if (len == 0 || erasesize == 0 || erasesize > len
-	    || erasesize > UINT_MAX || rem) {
+	    || erasesize > UINT_MAX) {
 		parse_err("illegal erasesize or len\n");
 		ret = -EINVAL;
 		goto error;
 	}
+	div_u64_rem(len, (uint32_t)erasesize, &rem);
+	if (rem) {
+		parse_err("len is not multiple of erasesize\n");
+		ret = -EINVAL;
+		goto error;
+	}
 	ret = register_device(name, start, len, (uint32_t)erasesize);
 	if (ret)
 		goto error;

drivers/mtd/nand/raw/Kconfig+2−1

 	tristate "OMAP2, OMAP3, OMAP4 and Keystone NAND controller"
 	depends on ARCH_OMAP2PLUS || ARCH_KEYSTONE || ARCH_K3 || COMPILE_TEST
 	depends on HAS_IOMEM
-	select OMAP_GPMC if ARCH_K3
+	select MEMORY
+	select OMAP_GPMC
 	help
 	  Support for NAND flash on Texas Instruments OMAP2, OMAP3, OMAP4
 	  and Keystone platforms.

drivers/mtd/nand/raw/brcmnand/brcmnand.c+1−1

@@ -2106,7 +2106,7 @@ static int brcmnand_read_by_pio(struct mtd_info mtd, struct nand_chip chip, · 2105 unmodified lines
2106	mtd->oobsize / trans,	2106	mtd->oobsize / trans,
2107	host->hwcfg.sector_size_1k);	2107	host->hwcfg.sector_size_1k);
2108		2108
2109	if (!ret) {	2109	if (ret != -EBADMSG) {
2110	*err_addr = brcmnand_get_uncorrecc_addr(ctrl);	2110	*err_addr = brcmnand_get_uncorrecc_addr(ctrl);
2111		2111
2112	if (*err_addr)	2112	if (*err_addr)

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c+2−1

 		this->hw.must_apply_timings = false;
 		ret = gpmi_nfc_apply_timings(this);
 		if (ret)
-			return ret;
+			goto out_pm;
 	}
 	dev_dbg(this->dev, "%s: %d instructions\n", __func__, op->ninstrs);
 	this->bch = false;
+out_pm:
 	pm_runtime_mark_last_busy(this->dev);
 	pm_runtime_put_autosuspend(this->dev);

drivers/mtd/nand/raw/ingenic/ingenic_ecc.c+6−1

 	struct ingenic_ecc *ecc;
 	pdev = of_find_device_by_node(np);
-	if (!pdev || !platform_get_drvdata(pdev))
+	if (!pdev)
 		return ERR_PTR(-EPROBE_DEFER);
+	if (!platform_get_drvdata(pdev)) {
+		put_device(&pdev->dev);
+		return ERR_PTR(-EPROBE_DEFER);
+	}
 	ecc = platform_get_drvdata(pdev);
 	clk_prepare_enable(ecc->clk);

drivers/mtd/nand/raw/qcom_nandc.c+6−8

 /*
  * Copyright (c) 2016, The Linux Foundation. All rights reserved.
  */
 #include <linux/clk.h>
 #include <linux/slab.h>
 #include <linux/bitops.h>
 	if (dma_mapping_error(dev, nandc->base_dma))
 		return -ENXIO;
-	ret = qcom_nandc_alloc(nandc);
-	if (ret)
-		goto err_nandc_alloc;
 	ret = clk_prepare_enable(nandc->core_clk);
 	if (ret)
 		goto err_core_clk;
 	if (ret)
 		goto err_aon_clk;
+	ret = qcom_nandc_alloc(nandc);
+	if (ret)
+		goto err_nandc_alloc;
 	ret = qcom_nandc_setup(nandc);
 	if (ret)
 		goto err_setup;
 	return 0;
 err_setup:
+	qcom_nandc_unalloc(nandc);
+err_nandc_alloc:
 	clk_disable_unprepare(nandc->aon_clk);
 err_aon_clk:
 	clk_disable_unprepare(nandc->core_clk);
 err_core_clk:
-	qcom_nandc_unalloc(nandc);
-err_nandc_alloc:
 	dma_unmap_resource(dev, res->start, resource_size(res),
 			   DMA_BIDIRECTIONAL, 0);
 	return ret;
 }

drivers/mtd/parsers/qcomsmempart.c+23−13

 			       const struct mtd_partition **pparts,
 			       struct mtd_part_parser_data *data)
 {
+	size_t len = SMEM_FLASH_PTABLE_HDR_LEN;
+	int ret, i, j, tmpparts, numparts = 0;
 	struct smem_flash_pentry *pentry;
 	struct smem_flash_ptable *ptable;
-	size_t len = SMEM_FLASH_PTABLE_HDR_LEN;
 	struct mtd_partition *parts;
-	int ret, i, numparts;
 	char *name, *c;
 	if (IS_ENABLED(CONFIG_MTD_SPI_NOR_USE_4K_SECTORS)
 	pr_debug("Parsing partition table info from SMEM\n");
 	ptable = qcom_smem_get(SMEM_APPS, SMEM_AARM_PARTITION_TABLE, &len);
 	if (IS_ERR(ptable)) {
-		pr_err("Error reading partition table header\n");
+		if (PTR_ERR(ptable) != -EPROBE_DEFER)
+			pr_err("Error reading partition table header\n");
 		return PTR_ERR(ptable);
 	}
 	}
 	/* Ensure that # of partitions is less than the max we have allocated */
-	numparts = le32_to_cpu(ptable->numparts);
+	tmpparts = le32_to_cpu(ptable->numparts);
-	if (numparts > SMEM_FLASH_PTABLE_MAX_PARTS_V4) {
+	if (tmpparts > SMEM_FLASH_PTABLE_MAX_PARTS_V4) {
 		pr_err("Partition numbers exceed the max limit\n");
 		return -EINVAL;
 	}
 		return PTR_ERR(ptable);
 	}
+	for (i = 0; i < tmpparts; i++) {
+		pentry = &ptable->pentry[i];
+		if (pentry->name[0] != '\0')
+			numparts++;
+	}
 	parts = kcalloc(numparts, sizeof(*parts), GFP_KERNEL);
 	if (!parts)
 		return -ENOMEM;
-	for (i = 0; i < numparts; i++) {
+	for (i = 0, j = 0; i < tmpparts; i++) {
 		pentry = &ptable->pentry[i];
 		if (pentry->name[0] == '\0')
 			continue;
 		for (c = name; *c != '\0'; c++)
 			*c = tolower(*c);
-		parts[i].name = name;
+		parts[j].name = name;
-		parts[i].offset = le32_to_cpu(pentry->offset) * mtd->erasesize;
+		parts[j].offset = le32_to_cpu(pentry->offset) * mtd->erasesize;
-		parts[i].mask_flags = pentry->attr;
+		parts[j].mask_flags = pentry->attr;
-		parts[i].size = le32_to_cpu(pentry->length) * mtd->erasesize;
+		parts[j].size = le32_to_cpu(pentry->length) * mtd->erasesize;
 		pr_debug("%d: %s offs=0x%08x size=0x%08x attr:0x%08x\n",
 			 i, pentry->name, le32_to_cpu(pentry->offset),
 			 le32_to_cpu(pentry->length), pentry->attr);
+		j++;
 	}
 	pr_debug("SMEM partition table found: ver: %d len: %d\n",
-		 le32_to_cpu(ptable->version), numparts);
+		 le32_to_cpu(ptable->version), tmpparts);
 	*pparts = parts;
 	return numparts;
 out_free_parts:
-	while (--i >= 0)
+	while (--j >= 0)
-		kfree(parts[i].name);
+		kfree(parts[j].name);
 	kfree(parts);
 	*pparts = NULL;
 	for (i = 0; i < nr_parts; i++)
 		kfree(pparts[i].name);
+	kfree(pparts);
 }
 static const struct of_device_id qcomsmem_of_match_table[] = {

drivers/net/dsa/microchip/ksz_common.c+23−3

@@ -26,7 +26,7 @@ void ksz_update_port_member(struct ksz_device *dev, int port) · 25 unmodified lines
26	struct dsa_switch *ds = dev->ds;	26	struct dsa_switch *ds = dev->ds;
27	u8 port_member = 0, cpu_port;	27	u8 port_member = 0, cpu_port;
28	const struct dsa_port *dp;	28	const struct dsa_port *dp;
29	int i;	29	int i, j;
30		30
31	if (!dsa_is_user_port(ds, port))	31	if (!dsa_is_user_port(ds, port))
32	return;	32	return;
@@ -45,13 +45,33 @@ void ksz_update_port_member(struct ksz_device *dev, int port) · 12 unmodified lines
45	continue;	45	continue;
46	if (!dsa_port_bridge_same(dp, other_dp))	46	if (!dsa_port_bridge_same(dp, other_dp))
47	continue;	47	continue;
		48	if (other_p->stp_state != BR_STATE_FORWARDING)
		49	continue;
48		50
49	if (other_p->stp_state == BR_STATE_FORWARDING &&	51	if (p->stp_state == BR_STATE_FORWARDING) {
50	p->stp_state == BR_STATE_FORWARDING) {
51	val \|= BIT(port);	52	val \|= BIT(port);
52	port_member \|= BIT(i);	53	port_member \|= BIT(i);
53	}	54	}
54		55
		56	/* Retain port [i]'s relationship to other ports than [port] */
		57	for (j = 0; j < ds->num_ports; j++) {
		58	const struct dsa_port *third_dp;
		59	struct ksz_port *third_p;
		60
		61	if (j == i)
		62	continue;
		63	if (j == port)
		64	continue;
		65	if (!dsa_is_user_port(ds, j))
		66	continue;
		67	third_p = &dev->ports[j];
		68	if (third_p->stp_state != BR_STATE_FORWARDING)
		69	continue;
		70	third_dp = dsa_to_port(ds, j);
		71	if (dsa_port_bridge_same(other_dp, third_dp))
		72	val \|= BIT(j);
		73	}
		74
55	dev->dev_ops->cfg_port_member(dev, i, val \| cpu_port);	75	dev->dev_ops->cfg_port_member(dev, i, val \| cpu_port);
56	}	76	}
57		77

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c+3−0

 MODULE_FIRMWARE(FW_FILE_NAME_E1);
 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
 MODULE_FIRMWARE(FW_FILE_NAME_E2);
+MODULE_FIRMWARE(FW_FILE_NAME_E1_V15);
+MODULE_FIRMWARE(FW_FILE_NAME_E1H_V15);
+MODULE_FIRMWARE(FW_FILE_NAME_E2_V15);
 int bnx2x_num_queues;
 module_param_named(num_queues, bnx2x_num_queues, int, 0444);

drivers/net/ethernet/broadcom/bnxt/bnxt.c+35−12

 		return rc;
 	req->vnic_id = cpu_to_le32(vnic->fw_vnic_id);
-	req->num_mc_entries = cpu_to_le32(vnic->mc_list_count);
+	if (vnic->rx_mask & CFA_L2_SET_RX_MASK_REQ_MASK_MCAST) {
-	req->mc_tbl_addr = cpu_to_le64(vnic->mc_list_mapping);
+		req->num_mc_entries = cpu_to_le32(vnic->mc_list_count);
+		req->mc_tbl_addr = cpu_to_le64(vnic->mc_list_mapping);
+	}
 	req->mask = cpu_to_le32(vnic->rx_mask);
 	return hwrm_req_send_silent(bp, req);
 }
 	return 0;
 }
+static void bnxt_remap_fw_health_regs(struct bnxt *bp)
+{
+	if (!bp->fw_health)
+		return;
+	if (bp->fw_cap & BNXT_FW_CAP_ERROR_RECOVERY) {
+		bp->fw_health->status_reliable = true;
+		bp->fw_health->resets_reliable = true;
+	} else {
+		bnxt_try_map_fw_health_reg(bp);
+	}
+}
 static int bnxt_hwrm_error_recovery_qcfg(struct bnxt *bp)
 {
 	struct bnxt_fw_health *fw_health = bp->fw_health;
 	vnic->uc_filter_count = 1;
 	vnic->rx_mask = 0;
+	if (test_bit(BNXT_STATE_HALF_OPEN, &bp->state))
+		goto skip_rx_mask;
 	if (bp->dev->flags & IFF_BROADCAST)
 		vnic->rx_mask |= CFA_L2_SET_RX_MASK_REQ_MASK_BCAST;
 	if (bp->dev->flags & IFF_ALLMULTI) {
 		vnic->rx_mask |= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
 		vnic->mc_list_count = 0;
-	} else {
+	} else if (bp->dev->flags & IFF_MULTICAST) {
 		u32 mask = 0;
 		bnxt_mc_list_updated(bp, &mask);
 	if (rc)
 		goto err_out;
+skip_rx_mask:
 	rc = bnxt_hwrm_set_coal(bp);
 	if (rc)
 		netdev_warn(bp->dev, "HWRM set coalescing failure rc: %x\n",
 		resc_reinit = true;
 	if (flags & FUNC_DRV_IF_CHANGE_RESP_FLAGS_HOT_FW_RESET_DONE)
 		fw_reset = true;
-	else if (bp->fw_health && !bp->fw_health->status_reliable)
+	else
-		bnxt_try_map_fw_health_reg(bp);
+		bnxt_remap_fw_health_regs(bp);
 	if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state) && !fw_reset) {
 		netdev_err(bp->dev, "RESET_DONE not set during FW reset.\n");
 		goto half_open_err;
 	}
-	rc = bnxt_alloc_mem(bp, false);
+	rc = bnxt_alloc_mem(bp, true);
 	if (rc) {
 		netdev_err(bp->dev, "bnxt_alloc_mem err: %x\n", rc);
 		goto half_open_err;
 	}
-	rc = bnxt_init_nic(bp, false);
+	set_bit(BNXT_STATE_HALF_OPEN, &bp->state);
+	rc = bnxt_init_nic(bp, true);
 	if (rc) {
+		clear_bit(BNXT_STATE_HALF_OPEN, &bp->state);
 		netdev_err(bp->dev, "bnxt_init_nic err: %x\n", rc);
 		goto half_open_err;
 	}
 half_open_err:
 	bnxt_free_skbs(bp);
-	bnxt_free_mem(bp, false);
+	bnxt_free_mem(bp, true);
 	dev_close(bp->dev);
 	return rc;
 }
  */
 void bnxt_half_close_nic(struct bnxt *bp)
 {
-	bnxt_hwrm_resource_free(bp, false, false);
+	bnxt_hwrm_resource_free(bp, false, true);
 	bnxt_free_skbs(bp);
-	bnxt_free_mem(bp, false);
+	bnxt_free_mem(bp, true);
+	clear_bit(BNXT_STATE_HALF_OPEN, &bp->state);
 }
 void bnxt_reenable_sriov(struct bnxt *bp)
 	if (dev->flags & IFF_ALLMULTI) {
 		mask |= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
 		vnic->mc_list_count = 0;
-	} else {
+	} else if (dev->flags & IFF_MULTICAST) {
 		mc_update = bnxt_mc_list_updated(bp, &mask);
 	}
 	    !bnxt_promisc_ok(bp))
 		vnic->rx_mask &= ~CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS;
 	rc = bnxt_hwrm_cfa_l2_set_rx_mask(bp, 0);
-	if (rc && vnic->mc_list_count) {
+	if (rc && (vnic->rx_mask & CFA_L2_SET_RX_MASK_REQ_MASK_MCAST)) {
 		netdev_info(bp->dev, "Failed setting MC filters rc: %d, turning on ALL_MCAST mode\n",
 			    rc);
+		vnic->rx_mask &= ~CFA_L2_SET_RX_MASK_REQ_MASK_MCAST;
 		vnic->rx_mask |= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
 		vnic->mc_list_count = 0;
 		rc = bnxt_hwrm_cfa_l2_set_rx_mask(bp, 0);

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

@@ -1921,6 +1921,7 @@ struct bnxt { · 1920 unmodified lines
1921	#define BNXT_STATE_RECOVER 12	1921	#define BNXT_STATE_RECOVER 12
1922	#define BNXT_STATE_FW_NON_FATAL_COND 13	1922	#define BNXT_STATE_FW_NON_FATAL_COND 13
1923	#define BNXT_STATE_FW_ACTIVATE_RESET 14	1923	#define BNXT_STATE_FW_ACTIVATE_RESET 14
		1924	#define BNXT_STATE_HALF_OPEN 15 /* For offline ethtool tests */
1924		1925
1925	#define BNXT_NO_FW_ACCESS(bp) \	1926	#define BNXT_NO_FW_ACCESS(bp) \
1926	(test_bit(BNXT_STATE_FW_FATAL_COND, &(bp)->state) \|\| \	1927	(test_bit(BNXT_STATE_FW_FATAL_COND, &(bp)->state) \|\| \

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c+31−8

@@ -367,6 +367,16 @@ bnxt_dl_livepatch_report_err(struct bnxt bp, struct netlink_ext_ack extack, · 366 unmodified lines
367	}	367	}
368	}	368	}
369		369
		370	/* Live patch status in NVM */
		371	#define BNXT_LIVEPATCH_NOT_INSTALLED 0
		372	#define BNXT_LIVEPATCH_INSTALLED FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL
		373	#define BNXT_LIVEPATCH_REMOVED FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE
		374	#define BNXT_LIVEPATCH_MASK (FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL \| \
		375	FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE)
		376	#define BNXT_LIVEPATCH_ACTIVATED BNXT_LIVEPATCH_MASK
		377
		378	#define BNXT_LIVEPATCH_STATE(flags) ((flags) & BNXT_LIVEPATCH_MASK)
		379
370	static int	380	static int
371	bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack)	381	bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack)
372	{	382	{
@@ -374,8 +384,9 @@ bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack) · 1 unmodified line
374	struct hwrm_fw_livepatch_query_input *query_req;	384	struct hwrm_fw_livepatch_query_input *query_req;
375	struct hwrm_fw_livepatch_output *patch_resp;	385	struct hwrm_fw_livepatch_output *patch_resp;
376	struct hwrm_fw_livepatch_input *patch_req;	386	struct hwrm_fw_livepatch_input *patch_req;
		387	u16 flags, live_patch_state;
		388	bool activated = false;
377	u32 installed = 0;	389	u32 installed = 0;
378	u16 flags;
379	u8 target;	390	u8 target;
380	int rc;	391	int rc;
381		392
@@ -394,7 +405,6 @@ bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack) · 12 unmodified lines
394	hwrm_req_drop(bp, query_req);	405	hwrm_req_drop(bp, query_req);
395	return rc;	406	return rc;
396	}	407	}
397	patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_ACTIVATE;
398	patch_req->loadtype = FW_LIVEPATCH_REQ_LOADTYPE_NVM_INSTALL;	408	patch_req->loadtype = FW_LIVEPATCH_REQ_LOADTYPE_NVM_INSTALL;
399	patch_resp = hwrm_req_hold(bp, patch_req);	409	patch_resp = hwrm_req_hold(bp, patch_req);
400		410
@@ -407,12 +417,20 @@ bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack) · 6 unmodified lines
407	}	417	}
408		418
409	flags = le16_to_cpu(query_resp->status_flags);	419	flags = le16_to_cpu(query_resp->status_flags);
410	if (~flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL)	420	live_patch_state = BNXT_LIVEPATCH_STATE(flags);
		421
		422	if (live_patch_state == BNXT_LIVEPATCH_NOT_INSTALLED)
411	continue;	423	continue;
412	if ((flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE) &&	424
413	!strncmp(query_resp->active_ver, query_resp->install_ver,	425	if (live_patch_state == BNXT_LIVEPATCH_ACTIVATED) {
414	sizeof(query_resp->active_ver)))	426	activated = true;
415	continue;	427	continue;
		428	}
		429
		430	if (live_patch_state == BNXT_LIVEPATCH_INSTALLED)
		431	patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_ACTIVATE;
		432	else if (live_patch_state == BNXT_LIVEPATCH_REMOVED)
		433	patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_DEACTIVATE;
416		434
417	patch_req->fw_target = target;	435	patch_req->fw_target = target;
418	rc = hwrm_req_send(bp, patch_req);	436	rc = hwrm_req_send(bp, patch_req);
@@ -424,8 +442,13 @@ bnxt_dl_livepatch_activate(struct bnxt bp, struct netlink_ext_ack extack) · 5 unmodified lines
424	}	442	}
425		443
426	if (!rc && !installed) {	444	if (!rc && !installed) {
427	NL_SET_ERR_MSG_MOD(extack, "No live patches found");	445	if (activated) {
428	rc = -ENOENT;	446	NL_SET_ERR_MSG_MOD(extack, "Live patch already activated");
		447	rc = -EEXIST;
		448	} else {
		449	NL_SET_ERR_MSG_MOD(extack, "No live patches found");
		450	rc = -ENOENT;
		451	}
429	}	452	}
430	hwrm_req_drop(bp, query_req);	453	hwrm_req_drop(bp, query_req);
431	hwrm_req_drop(bp, patch_req);	454	hwrm_req_drop(bp, patch_req);

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

 #include "bnxt_hsi.h"
 #include "bnxt.h"
 #include "bnxt_hwrm.h"
+#include "bnxt_ulp.h"
 #include "bnxt_xdp.h"
 #include "bnxt_ptp.h"
 #include "bnxt_ethtool.h"
 	case PORT_PHY_QCFG_RESP_ACTIVE_FEC_FEC_RS272_IEEE_ACTIVE:
 		fec->active_fec |= ETHTOOL_FEC_LLRS;
 		break;
+	case PORT_PHY_QCFG_RESP_ACTIVE_FEC_FEC_NONE_ACTIVE:
+		fec->active_fec |= ETHTOOL_FEC_OFF;
+		break;
 	}
 	return 0;
 }
 	if (!skb)
 		return -ENOMEM;
 	data = skb_put(skb, pkt_size);
-	eth_broadcast_addr(data);
+	ether_addr_copy(&data[i], bp->dev->dev_addr);
 	i += ETH_ALEN;
 	ether_addr_copy(&data[i], bp->dev->dev_addr);
 	i += ETH_ALEN;
 	if (!offline) {
 		bnxt_run_fw_tests(bp, test_mask, &test_results);
 	} else {
-		rc = bnxt_close_nic(bp, false, false);
+		bnxt_ulp_stop(bp);
-		if (rc)
+		rc = bnxt_close_nic(bp, true, false);
+		if (rc) {
+			bnxt_ulp_start(bp, rc);
 			return;
+		}
 		bnxt_run_fw_tests(bp, test_mask, &test_results);
 		buf[BNXT_MACLPBK_TEST_IDX] = 1;
 		if (rc) {
 			bnxt_hwrm_mac_loopback(bp, false);
 			etest->flags |= ETH_TEST_FL_FAILED;
+			bnxt_ulp_start(bp, rc);
 			return;
 		}
 		if (bnxt_run_loopback(bp))
 		}
 		bnxt_hwrm_phy_loopback(bp, false, false);
 		bnxt_half_close_nic(bp);
-		rc = bnxt_open_nic(bp, false, true);
+		rc = bnxt_open_nic(bp, true, true);
+		bnxt_ulp_start(bp, rc);
 	}
 	if (rc || bnxt_test_irq(bp)) {
 		buf[BNXT_IRQ_TEST_IDX] = 1;

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c+9−3

 		/* Last byte of resp contains valid bit */
 		valid = ((u8 *)ctx->resp) + len - 1;
-		for (j = 0; j < HWRM_VALID_BIT_DELAY_USEC; j++) {
+		for (j = 0; j < HWRM_VALID_BIT_DELAY_USEC; ) {
 			/* make sure we read from updated DMA memory */
 			dma_rmb();
 			if (*valid)
 				break;
-			usleep_range(1, 5);
+			if (j < 10) {
+				udelay(1);
+				j++;
+			} else {
+				usleep_range(20, 30);
+				j += 20;
+			}
 		}
 		if (j >= HWRM_VALID_BIT_DELAY_USEC) {
 			hwrm_err(bp, ctx, "Error (timeout: %u) msg {0x%x 0x%x} len:%d v:%d\n",
-				 hwrm_total_timeout(i), req_type,
+				 hwrm_total_timeout(i) + j, req_type,
 				 le16_to_cpu(ctx->req->seq_id), len, *valid);
 			goto exit;
 		}

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

@@ -90,7 +90,7 @@ static inline unsigned int hwrm_total_timeout(unsigned int n) · 89 unmodified lines
90	}	90	}
91		91
92		92
93	#define HWRM_VALID_BIT_DELAY_USEC 150	93	#define HWRM_VALID_BIT_DELAY_USEC 50000
94		94
95	static inline bool bnxt_cfa_hwrm_message(u16 req_type)	95	static inline bool bnxt_cfa_hwrm_message(u16 req_type)
96	{	96	{

drivers/net/ethernet/faraday/ftgmac100.c+129−114

 	return 0;
 }
-static void ftgmac100_adjust_link(struct net_device *netdev)
-{
-	struct ftgmac100 *priv = netdev_priv(netdev);
-	struct phy_device *phydev = netdev->phydev;
-	bool tx_pause, rx_pause;
-	int new_speed;
-	/* We store "no link" as speed 0 */
-	if (!phydev->link)
-		new_speed = 0;
-	else
-		new_speed = phydev->speed;
-	/* Grab pause settings from PHY if configured to do so */
-	if (priv->aneg_pause) {
-		rx_pause = tx_pause = phydev->pause;
-		if (phydev->asym_pause)
-			tx_pause = !rx_pause;
-	} else {
-		rx_pause = priv->rx_pause;
-		tx_pause = priv->tx_pause;
-	}
-	/* Link hasn't changed, do nothing */
-	if (phydev->speed == priv->cur_speed &&
-	    phydev->duplex == priv->cur_duplex &&
-	    rx_pause == priv->rx_pause &&
-	    tx_pause == priv->tx_pause)
-		return;
-	/* Print status if we have a link or we had one and just lost it,
-	 * don't print otherwise.
-	 */
-	if (new_speed || priv->cur_speed)
-		phy_print_status(phydev);
-	priv->cur_speed = new_speed;
-	priv->cur_duplex = phydev->duplex;
-	priv->rx_pause = rx_pause;
-	priv->tx_pause = tx_pause;
-	/* Link is down, do nothing else */
-	if (!new_speed)
-		return;
-	/* Disable all interrupts */
-	iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
-	/* Reset the adapter asynchronously */
-	schedule_work(&priv->reset_task);
-}
-static int ftgmac100_mii_probe(struct net_device *netdev)
-{
-	struct ftgmac100 *priv = netdev_priv(netdev);
-	struct platform_device *pdev = to_platform_device(priv->dev);
-	struct device_node *np = pdev->dev.of_node;
-	struct phy_device *phydev;
-	phy_interface_t phy_intf;
-	int err;
-	/* Default to RGMII. It's a gigabit part after all */
-	err = of_get_phy_mode(np, &phy_intf);
-	if (err)
-		phy_intf = PHY_INTERFACE_MODE_RGMII;
-	/* Aspeed only supports these. I don't know about other IP
-	 * block vendors so I'm going to just let them through for
-	 * now. Note that this is only a warning if for some obscure
-	 * reason the DT really means to lie about it or it's a newer
-	 * part we don't know about.
-	 *
-	 * On the Aspeed SoC there are additionally straps and SCU
-	 * control bits that could tell us what the interface is
-	 * (or allow us to configure it while the IP block is held
-	 * in reset). For now I chose to keep this driver away from
-	 * those SoC specific bits and assume the device-tree is
-	 * right and the SCU has been configured properly by pinmux
-	 * or the firmware.
-	 */
-	if (priv->is_aspeed && !(phy_interface_mode_is_rgmii(phy_intf))) {
-		netdev_warn(netdev,
-			    "Unsupported PHY mode %s !\n",
-			    phy_modes(phy_intf));
-	}
-	phydev = phy_find_first(priv->mii_bus);
-	if (!phydev) {
-		netdev_info(netdev, "%s: no PHY found\n", netdev->name);
-		return -ENODEV;
-	}
-	phydev = phy_connect(netdev, phydev_name(phydev),
-			     &ftgmac100_adjust_link, phy_intf);
-	if (IS_ERR(phydev)) {
-		netdev_err(netdev, "%s: Could not attach to PHY\n", netdev->name);
-		return PTR_ERR(phydev);
-	}
-	/* Indicate that we support PAUSE frames (see comment in
-	 * Documentation/networking/phy.rst)
-	 */
-	phy_support_asym_pause(phydev);
-	/* Display what we found */
-	phy_attached_info(phydev);
-	return 0;
-}
 static int ftgmac100_mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum)
 {
 	struct net_device *netdev = bus->priv;
 	return err;
 }
-static void ftgmac100_reset_task(struct work_struct *work)
+static void ftgmac100_reset(struct ftgmac100 *priv)
 {
-	struct ftgmac100 *priv = container_of(work, struct ftgmac100,
-					      reset_task);
 	struct net_device *netdev = priv->netdev;
 	int err;
 	rtnl_unlock();
 }
+static void ftgmac100_reset_task(struct work_struct *work)
+{
+	struct ftgmac100 *priv = container_of(work, struct ftgmac100,
+					      reset_task);
+	ftgmac100_reset(priv);
+}
+static void ftgmac100_adjust_link(struct net_device *netdev)
+{
+	struct ftgmac100 *priv = netdev_priv(netdev);
+	struct phy_device *phydev = netdev->phydev;
+	bool tx_pause, rx_pause;
+	int new_speed;
+	/* We store "no link" as speed 0 */
+	if (!phydev->link)
+		new_speed = 0;
+	else
+		new_speed = phydev->speed;
+	/* Grab pause settings from PHY if configured to do so */
+	if (priv->aneg_pause) {
+		rx_pause = tx_pause = phydev->pause;
+		if (phydev->asym_pause)
+			tx_pause = !rx_pause;
+	} else {
+		rx_pause = priv->rx_pause;
+		tx_pause = priv->tx_pause;
+	}
+	/* Link hasn't changed, do nothing */
+	if (phydev->speed == priv->cur_speed &&
+	    phydev->duplex == priv->cur_duplex &&
+	    rx_pause == priv->rx_pause &&
+	    tx_pause == priv->tx_pause)
+		return;
+	/* Print status if we have a link or we had one and just lost it,
+	 * don't print otherwise.
+	 */
+	if (new_speed || priv->cur_speed)
+		phy_print_status(phydev);
+	priv->cur_speed = new_speed;
+	priv->cur_duplex = phydev->duplex;
+	priv->rx_pause = rx_pause;
+	priv->tx_pause = tx_pause;
+	/* Link is down, do nothing else */
+	if (!new_speed)
+		return;
+	/* Disable all interrupts */
+	iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
+	/* Release phy lock to allow ftgmac100_reset to aquire it, keeping lock
+	 * order consistent to prevent dead lock.
+	 */
+	if (netdev->phydev)
+		mutex_unlock(&netdev->phydev->lock);
+	ftgmac100_reset(priv);
+	if (netdev->phydev)
+		mutex_lock(&netdev->phydev->lock);
+}
+static int ftgmac100_mii_probe(struct net_device *netdev)
+{
+	struct ftgmac100 *priv = netdev_priv(netdev);
+	struct platform_device *pdev = to_platform_device(priv->dev);
+	struct device_node *np = pdev->dev.of_node;
+	struct phy_device *phydev;
+	phy_interface_t phy_intf;
+	int err;
+	/* Default to RGMII. It's a gigabit part after all */
+	err = of_get_phy_mode(np, &phy_intf);
+	if (err)
+		phy_intf = PHY_INTERFACE_MODE_RGMII;
+	/* Aspeed only supports these. I don't know about other IP
+	 * block vendors so I'm going to just let them through for
+	 * now. Note that this is only a warning if for some obscure
+	 * reason the DT really means to lie about it or it's a newer
+	 * part we don't know about.
+	 *
+	 * On the Aspeed SoC there are additionally straps and SCU
+	 * control bits that could tell us what the interface is
+	 * (or allow us to configure it while the IP block is held
+	 * in reset). For now I chose to keep this driver away from
+	 * those SoC specific bits and assume the device-tree is
+	 * right and the SCU has been configured properly by pinmux
+	 * or the firmware.
+	 */
+	if (priv->is_aspeed && !(phy_interface_mode_is_rgmii(phy_intf))) {
+		netdev_warn(netdev,
+			    "Unsupported PHY mode %s !\n",
+			    phy_modes(phy_intf));
+	}
+	phydev = phy_find_first(priv->mii_bus);
+	if (!phydev) {
+		netdev_info(netdev, "%s: no PHY found\n", netdev->name);
+		return -ENODEV;
+	}
+	phydev = phy_connect(netdev, phydev_name(phydev),
+			     &ftgmac100_adjust_link, phy_intf);
+	if (IS_ERR(phydev)) {
+		netdev_err(netdev, "%s: Could not attach to PHY\n", netdev->name);
+		return PTR_ERR(phydev);
+	}
+	/* Indicate that we support PAUSE frames (see comment in
+	 * Documentation/networking/phy.rst)
+	 */
+	phy_support_asym_pause(phydev);
+	/* Display what we found */
+	phy_attached_info(phydev);
+	return 0;
+}
 static int ftgmac100_open(struct net_device *netdev)
 {
 	struct ftgmac100 *priv = netdev_priv(netdev);

drivers/net/ethernet/ibm/ibmvnic.c+5−1

 		   be64_to_cpu(session_token));
 	rc = plpar_hcall_norets(H_VIOCTL, adapter->vdev->unit_address,
 				H_SESSION_ERR_DETECTED, session_token, 0, 0);
-	if (rc)
+	if (rc) {
 		netdev_err(netdev,
 			   "H_VIOCTL initiated failover failed, rc %ld\n",
 			   rc);
+		goto last_resort;
+	}
+	return count;
 last_resort:
 	netdev_dbg(netdev, "Trying to send CRQ_CMD, the last resort\n");

drivers/net/ethernet/intel/i40e/i40e_main.c+1−11

@@ -5386,15 +5386,7 @@ static int i40e_vsi_configure_bw_alloc(struct i40e_vsi *vsi, u8 enabled_tc, · 5385 unmodified lines
5386	/* There is no need to reset BW when mqprio mode is on. */	5386	/* There is no need to reset BW when mqprio mode is on. */
5387	if (pf->flags & I40E_FLAG_TC_MQPRIO)	5387	if (pf->flags & I40E_FLAG_TC_MQPRIO)
5388	return 0;	5388	return 0;
5389		5389	if (!vsi->mqprio_qopt.qopt.hw && !(pf->flags & I40E_FLAG_DCB_ENABLED)) {
5390	if (!vsi->mqprio_qopt.qopt.hw) {
5391	if (pf->flags & I40E_FLAG_DCB_ENABLED)
5392	goto skip_reset;
5393
5394	if (IS_ENABLED(CONFIG_I40E_DCB) &&
5395	i40e_dcb_hw_get_num_tc(&pf->hw) == 1)
5396	goto skip_reset;
5397
5398	ret = i40e_set_bw_limit(vsi, vsi->seid, 0);	5390	ret = i40e_set_bw_limit(vsi, vsi->seid, 0);
5399	if (ret)	5391	if (ret)
5400	dev_info(&pf->pdev->dev,	5392	dev_info(&pf->pdev->dev,
@@ -5402,8 +5394,6 @@ static int i40e_vsi_configure_bw_alloc(struct i40e_vsi *vsi, u8 enabled_tc, · 1 unmodified line
5402	vsi->seid);	5394	vsi->seid);
5403	return ret;	5395	return ret;
5404	}	5396	}
5405
5406	skip_reset:
5407	memset(&bw_data, 0, sizeof(bw_data));	5397	memset(&bw_data, 0, sizeof(bw_data));
5408	bw_data.tc_valid_bits = enabled_tc;	5398	bw_data.tc_valid_bits = enabled_tc;
5409	for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++)	5399	for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++)

drivers/net/ethernet/intel/ice/ice.h+0−1

@@ -281,7 +281,6 @@ enum ice_pf_state { · 280 unmodified lines
281	ICE_VFLR_EVENT_PENDING,	281	ICE_VFLR_EVENT_PENDING,
282	ICE_FLTR_OVERFLOW_PROMISC,	282	ICE_FLTR_OVERFLOW_PROMISC,
283	ICE_VF_DIS,	283	ICE_VF_DIS,
284	ICE_VF_DEINIT_IN_PROGRESS,
285	ICE_CFG_BUSY,	284	ICE_CFG_BUSY,
286	ICE_SERVICE_SCHED,	285	ICE_SERVICE_SCHED,
287	ICE_SERVICE_DIS,	286	ICE_SERVICE_DIS,

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

@@ -3379,7 +3379,7 @@ ice_cfg_phy_fec(struct ice_port_info pi, struct ice_aqc_set_phy_cfg_data cfg, · 3378 unmodified lines
3379		3379
3380	if (fec == ICE_FEC_AUTO && ice_fw_supports_link_override(hw) &&	3380	if (fec == ICE_FEC_AUTO && ice_fw_supports_link_override(hw) &&
3381	!ice_fw_supports_report_dflt_cfg(hw)) {	3381	!ice_fw_supports_report_dflt_cfg(hw)) {
3382	struct ice_link_default_override_tlv tlv;	3382	struct ice_link_default_override_tlv tlv = { 0 };
3383		3383
3384	status = ice_get_link_default_override(&tlv, pi);	3384	status = ice_get_link_default_override(&tlv, pi);
3385	if (status)	3385	if (status)

drivers/net/ethernet/intel/ice/ice_eswitch.c+1−0

@@ -44,6 +44,7 @@ ice_eswitch_add_vf_mac_rule(struct ice_pf pf, struct ice_vf vf, const u8 *mac) · 43 unmodified lines
44	ctrl_vsi->rxq_map[vf->vf_id];	44	ctrl_vsi->rxq_map[vf->vf_id];
45	rule_info.flags_info.act \|= ICE_SINGLE_ACT_LB_ENABLE;	45	rule_info.flags_info.act \|= ICE_SINGLE_ACT_LB_ENABLE;
46	rule_info.flags_info.act_valid = true;	46	rule_info.flags_info.act_valid = true;
		47	rule_info.tun_type = ICE_SW_TUN_AND_NON_TUN;
47		48
48	err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info,	49	err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info,
49	vf->repr->mac_rule);	50	vf->repr->mac_rule);

drivers/net/ethernet/intel/ice/ice_main.c+2−0

 				 * reset, so print the event prior to reset.
 				 */
 				ice_print_vf_rx_mdd_event(vf);
+				mutex_lock(&pf->vf[i].cfg_lock);
 				ice_reset_vf(&pf->vf[i], false);
+				mutex_unlock(&pf->vf[i].cfg_lock);
 			}
 		}
 	}

drivers/net/ethernet/intel/ice/ice_protocol_type.h+1−0

@@ -47,6 +47,7 @@ enum ice_protocol_type { · 46 unmodified lines
47		47
48	enum ice_sw_tunnel_type {	48	enum ice_sw_tunnel_type {
49	ICE_NON_TUN = 0,	49	ICE_NON_TUN = 0,
		50	ICE_SW_TUN_AND_NON_TUN,
50	ICE_SW_TUN_VXLAN,	51	ICE_SW_TUN_VXLAN,
51	ICE_SW_TUN_GENEVE,	52	ICE_SW_TUN_GENEVE,
52	ICE_SW_TUN_NVGRE,	53	ICE_SW_TUN_NVGRE,

drivers/net/ethernet/intel/ice/ice_ptp.c+4−1

 static int ice_ptp_adjtime_nonatomic(struct ptp_clock_info *info, s64 delta)
 {
 	struct timespec64 now, then;
+	int ret;
 	then = ns_to_timespec64(delta);
-	ice_ptp_gettimex64(info, &now, NULL);
+	ret = ice_ptp_gettimex64(info, &now, NULL);
+	if (ret)
+		return ret;
 	now = timespec64_add(now, then);
 	return ice_ptp_settime64(info, (const struct timespec64 *)&now);

drivers/net/ethernet/intel/ice/ice_switch.c+3−1

 	case ICE_SW_TUN_NVGRE:
 		prof_type = ICE_PROF_TUN_GRE;
 		break;
+	case ICE_SW_TUN_AND_NON_TUN:
 	default:
 		prof_type = ICE_PROF_ALL;
 		break;
 	if (status)
 		goto err_ice_add_adv_rule;
-	if (rinfo->tun_type != ICE_NON_TUN) {
+	if (rinfo->tun_type != ICE_NON_TUN &&
+	    rinfo->tun_type != ICE_SW_TUN_AND_NON_TUN) {
 		status = ice_fill_adv_packet_tun(hw, rinfo->tun_type,
 						 s_rule->pdata.lkup_tx_rx.hdr,
 						 pkt_offsets);

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

@@ -709,7 +709,7 @@ ice_tc_set_port(struct flow_match_ports match, · 708 unmodified lines
709	fltr->flags \|= ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT;	709	fltr->flags \|= ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT;
710	else	710	else
711	fltr->flags \|= ICE_TC_FLWR_FIELD_DEST_L4_PORT;	711	fltr->flags \|= ICE_TC_FLWR_FIELD_DEST_L4_PORT;
712	fltr->flags \|= ICE_TC_FLWR_FIELD_DEST_L4_PORT;	712
713	headers->l4_key.dst_port = match.key->dst;	713	headers->l4_key.dst_port = match.key->dst;
714	headers->l4_mask.dst_port = match.mask->dst;	714	headers->l4_mask.dst_port = match.mask->dst;
715	}	715	}
@@ -718,7 +718,7 @@ ice_tc_set_port(struct flow_match_ports match, · 2 unmodified lines
718	fltr->flags \|= ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT;	718	fltr->flags \|= ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT;
719	else	719	else
720	fltr->flags \|= ICE_TC_FLWR_FIELD_SRC_L4_PORT;	720	fltr->flags \|= ICE_TC_FLWR_FIELD_SRC_L4_PORT;
721	fltr->flags \|= ICE_TC_FLWR_FIELD_SRC_L4_PORT;	721
722	headers->l4_key.src_port = match.key->src;	722	headers->l4_key.src_port = match.key->src;
723	headers->l4_mask.src_port = match.mask->src;	723	headers->l4_mask.src_port = match.mask->src;
724	}	724	}

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c+25−17

 	struct ice_hw *hw = &pf->hw;
 	unsigned int tmp, i;
-	set_bit(ICE_VF_DEINIT_IN_PROGRESS, pf->state);
 	if (!pf->vf)
 		return;
 	else
 		dev_warn(dev, "VFs are assigned - not disabling SR-IOV\n");
-	/* Avoid wait time by stopping all VFs at the same time */
-	ice_for_each_vf(pf, i)
-		ice_dis_vf_qs(&pf->vf[i]);
 	tmp = pf->num_alloc_vfs;
 	pf->num_qps_per_vf = 0;
 	pf->num_alloc_vfs = 0;
 	for (i = 0; i < tmp; i++) {
-		if (test_bit(ICE_VF_STATE_INIT, pf->vf[i].vf_states)) {
+		struct ice_vf *vf = &pf->vf[i];
+		mutex_lock(&vf->cfg_lock);
+		ice_dis_vf_qs(vf);
+		if (test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
 			/* disable VF qp mappings and set VF disable state */
-			ice_dis_vf_mappings(&pf->vf[i]);
+			ice_dis_vf_mappings(vf);
-			set_bit(ICE_VF_STATE_DIS, pf->vf[i].vf_states);
+			set_bit(ICE_VF_STATE_DIS, vf->vf_states);
-			ice_free_vf_res(&pf->vf[i]);
+			ice_free_vf_res(vf);
 		}
-		mutex_destroy(&pf->vf[i].cfg_lock);
+		mutex_unlock(&vf->cfg_lock);
+		mutex_destroy(&vf->cfg_lock);
 	}
 	if (ice_sriov_free_msix_res(pf))
 				i);
 	clear_bit(ICE_VF_DIS, pf->state);
-	clear_bit(ICE_VF_DEINIT_IN_PROGRESS, pf->state);
 	clear_bit(ICE_FLAG_SRIOV_ENA, pf->flags);
 }
 	ice_for_each_vf(pf, v) {
 		vf = &pf->vf[v];
+		mutex_lock(&vf->cfg_lock);
 		vf->driver_caps = 0;
 		ice_vc_set_default_allowlist(vf);
 		ice_vf_pre_vsi_rebuild(vf);
 		ice_vf_rebuild_vsi(vf);
 		ice_vf_post_vsi_rebuild(vf);
+		mutex_unlock(&vf->cfg_lock);
 	}
 	if (ice_is_eswitch_mode_switchdev(pf))
 	u32 reg;
 	int i;
+	lockdep_assert_held(&vf->cfg_lock);
 	dev = ice_pf_to_dev(pf);
 	if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) {
 		bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
 		/* read GLGEN_VFLRSTAT register to find out the flr VFs */
 		reg = rd32(hw, GLGEN_VFLRSTAT(reg_idx));
-		if (reg & BIT(bit_idx))
+		if (reg & BIT(bit_idx)) {
 			/* GLGEN_VFLRSTAT bit will be cleared in ice_reset_vf */
+			mutex_lock(&vf->cfg_lock);
 			ice_reset_vf(vf, true);
+			mutex_unlock(&vf->cfg_lock);
+		}
 	}
 }
 	if (!vf)
 		return;
+	mutex_lock(&vf->cfg_lock);
 	ice_vc_reset_vf(vf);
+	mutex_unlock(&vf->cfg_lock);
 }
 /**
 	struct device *dev;
 	int err = 0;
-	/* if de-init is underway, don't process messages from VF */
-	if (test_bit(ICE_VF_DEINIT_IN_PROGRESS, pf->state))
-		return;
 	dev = ice_pf_to_dev(pf);
 	if (ice_validate_vf_id(pf, vf_id)) {
 		err = -EINVAL;

drivers/net/ethernet/marvell/mv643xx_eth.c+14−10

 static struct platform_device *port_platdev[3];
+static void mv643xx_eth_shared_of_remove(void)
+{
+	int n;
+	for (n = 0; n < 3; n++) {
+		platform_device_del(port_platdev[n]);
+		port_platdev[n] = NULL;
+	}
+}
 static int mv643xx_eth_shared_of_add_port(struct platform_device *pdev,
 					  struct device_node *pnp)
 {
 		return -EINVAL;
 	}
-	of_get_mac_address(pnp, ppd.mac_addr);
+	ret = of_get_mac_address(pnp, ppd.mac_addr);
+	if (ret)
+		return ret;
 	mv643xx_eth_property(pnp, "tx-queue-size", ppd.tx_queue_size);
 	mv643xx_eth_property(pnp, "tx-sram-addr", ppd.tx_sram_addr);
 		ret = mv643xx_eth_shared_of_add_port(pdev, pnp);
 		if (ret) {
 			of_node_put(pnp);
+			mv643xx_eth_shared_of_remove();
 			return ret;
 		}
 	}
 	return 0;
 }
-static void mv643xx_eth_shared_of_remove(void)
-{
-	int n;
-	for (n = 0; n < 3; n++) {
-		platform_device_del(port_platdev[n]);
-		port_platdev[n] = NULL;
-	}
-}
 #else
 static inline int mv643xx_eth_shared_of_probe(struct platform_device *pdev)
 {

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c+3−3

 	dev->max_mtu = MVPP2_BM_JUMBO_PKT_SIZE;
 	dev->dev.of_node = port_node;
+	port->pcs_gmac.ops = &mvpp2_phylink_gmac_pcs_ops;
+	port->pcs_xlg.ops = &mvpp2_phylink_xlg_pcs_ops;
 	if (!mvpp2_use_acpi_compat_mode(port_fwnode)) {
 		port->phylink_config.dev = &dev->dev;
 		port->phylink_config.type = PHYLINK_NETDEV;
 				  port->phylink_config.supported_interfaces);
 		}
-		port->pcs_gmac.ops = &mvpp2_phylink_gmac_pcs_ops;
-		port->pcs_xlg.ops = &mvpp2_phylink_xlg_pcs_ops;
 		phylink = phylink_create(&port->phylink_config, port_fwnode,
 					 phy_mode, &mvpp2_phylink_ops);
 		if (IS_ERR(phylink)) {

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

 	struct netlink_ext_ack *extack;
 	u32 actions;
 	bool ct;
+	bool ct_clear;
 	bool encap;
 	bool decap;
 	bool mpls_push;
 	bool ptype_host;
 	const struct ip_tunnel_info *tun_info;
+	struct mlx5e_mpls_info mpls_info;
 	int ifindexes[MLX5_MAX_FLOW_FWD_VPORTS];
 	int if_count;
 	struct mlx5_tc_ct_priv *ct_priv;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/ct.c+5−0

 	bool clear_action = act->ct.action & TCA_CT_ACT_CLEAR;
 	int err;
+	/* It's redundant to do ct clear more than once. */
+	if (clear_action && parse_state->ct_clear)
+		return 0;
 	err = mlx5_tc_ct_parse_action(parse_state->ct_priv, attr,
 				      &attr->parse_attr->mod_hdr_acts,
 				      act, parse_state->extack);
 		flow_flag_set(parse_state->flow, CT);
 		parse_state->ct = true;
 	}
+	parse_state->ct_clear = clear_action;
 	return 0;
 }

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/mirred.c+6−0

 		return -ENOMEM;
 	parse_state->encap = false;
+	if (parse_state->mpls_push) {
+		memcpy(&parse_attr->mpls_info[esw_attr->out_count],
+		       &parse_state->mpls_info, sizeof(parse_state->mpls_info));
+		parse_state->mpls_push = false;
+	}
 	esw_attr->dests[esw_attr->out_count].flags |= MLX5_ESW_DEST_ENCAP;
 	esw_attr->out_count++;
 	/* attr->dests[].rep is resolved when we handle encap */

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/mpls.c+11−0

 	return true;
 }
+static void
+copy_mpls_info(struct mlx5e_mpls_info *mpls_info,
+	       const struct flow_action_entry *act)
+{
+	mpls_info->label = act->mpls_push.label;
+	mpls_info->tc = act->mpls_push.tc;
+	mpls_info->bos = act->mpls_push.bos;
+	mpls_info->ttl = act->mpls_push.ttl;
+}
 static int
 tc_act_parse_mpls_push(struct mlx5e_tc_act_parse_state *parse_state,
 		       const struct flow_action_entry *act,
 		       struct mlx5_flow_attr *attr)
 {
 	parse_state->mpls_push = true;
+	copy_mpls_info(&parse_state->mpls_info, act);
 	return 0;
 }

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

@@ -35,6 +35,7 @@ enum { · 34 unmodified lines
35		35
36	struct mlx5e_tc_flow_parse_attr {	36	struct mlx5e_tc_flow_parse_attr {
37	const struct ip_tunnel_info *tun_info[MLX5_MAX_FLOW_FWD_VPORTS];	37	const struct ip_tunnel_info *tun_info[MLX5_MAX_FLOW_FWD_VPORTS];
		38	struct mlx5e_mpls_info mpls_info[MLX5_MAX_FLOW_FWD_VPORTS];
38	struct net_device *filter_dev;	39	struct net_device *filter_dev;
39	struct mlx5_flow_spec spec;	40	struct mlx5_flow_spec spec;
40	struct pedit_headers_action hdrs[__PEDIT_CMD_MAX];	41	struct pedit_headers_action hdrs[__PEDIT_CMD_MAX];

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

 	struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 	struct mlx5e_tc_flow_parse_attr *parse_attr;
 	const struct ip_tunnel_info *tun_info;
+	const struct mlx5e_mpls_info *mpls_info;
 	unsigned long tbl_time_before = 0;
 	struct mlx5e_encap_entry *e;
 	struct mlx5e_encap_key key;
 	parse_attr = attr->parse_attr;
 	tun_info = parse_attr->tun_info[out_index];
+	mpls_info = &parse_attr->mpls_info[out_index];
 	family = ip_tunnel_info_af(tun_info);
 	key.ip_tun_key = &tun_info->key;
 	key.tc_tunnel = mlx5e_get_tc_tun(mirred_dev);
 		goto out_err_init;
 	}
 	e->tun_info = tun_info;
+	memcpy(&e->mpls_info, mpls_info, sizeof(*mpls_info));
 	err = mlx5e_tc_tun_init_encap_attr(mirred_dev, priv, e, extack);
 	if (err)
 		goto out_err_init;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_mplsoudp.c+13−20

 			       struct mlx5e_encap_entry *r)
 {
 	const struct ip_tunnel_key *tun_key = &r->tun_info->key;
+	const struct mlx5e_mpls_info *mpls_info = &r->mpls_info;
 	struct udphdr *udp = (struct udphdr *)(buf);
 	struct mpls_shim_hdr *mpls;
-	u32 tun_id;
-	tun_id = be32_to_cpu(tunnel_id_to_key32(tun_key->tun_id));
 	mpls = (struct mpls_shim_hdr *)(udp + 1);
 	*ip_proto = IPPROTO_UDP;
 	udp->dest = tun_key->tp_dst;
-	*mpls = mpls_entry_encode(tun_id, tun_key->ttl, tun_key->tos, true);
+	*mpls = mpls_entry_encode(mpls_info->label, mpls_info->ttl, mpls_info->tc, mpls_info->bos);
 	return 0;
 }
 			void *headers_v)
 {
 	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
-	struct flow_match_enc_keyid enc_keyid;
 	struct flow_match_mpls match;
 	void *misc2_c;
 	void *misc2_v;
-	misc2_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
-			       misc_parameters_2);
-	misc2_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
-			       misc_parameters_2);
-	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_MPLS))
-		return 0;
-	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID))
-		return 0;
-	flow_rule_match_enc_keyid(rule, &enc_keyid);
-	if (!enc_keyid.mask->keyid)
-		return 0;
 	if (!MLX5_CAP_ETH(priv->mdev, tunnel_stateless_mpls_over_udp) &&
 	    !(MLX5_CAP_GEN(priv->mdev, flex_parser_protocols) & MLX5_FLEX_PROTO_CW_MPLS_UDP))
 		return -EOPNOTSUPP;
+	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID))
+		return -EOPNOTSUPP;
+	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_MPLS))
+		return 0;
 	flow_rule_match_mpls(rule, &match);
 	/* Only support matching the first LSE */
 	if (match.mask->used_lses != 1)
 		return -EOPNOTSUPP;
+	misc2_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
+			       misc_parameters_2);
+	misc2_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
+			       misc_parameters_2);
 	MLX5_SET(fte_match_set_misc2, misc2_c,
 		 outer_first_mpls_over_udp.mpls_label,
 		 match.mask->ls[0].mpls_label);

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

@@ -1792,7 +1792,7 @@ static int mlx5e_get_module_eeprom(struct net_device *netdev, · 1791 unmodified lines
1792	if (size_read < 0) {	1792	if (size_read < 0) {
1793	netdev_err(priv->netdev, "%s: mlx5_query_eeprom failed:0x%x\n",	1793	netdev_err(priv->netdev, "%s: mlx5_query_eeprom failed:0x%x\n",
1794	__func__, size_read);	1794	__func__, size_read);
1795	return 0;	1795	return size_read;
1796	}	1796	}
1797		1797
1798	i += size_read;	1798	i += size_read;

drivers/net/ethernet/mellanox/mlx5/core/en_rep.h+8−0

 	struct rcu_head rcu;
 };
+struct mlx5e_mpls_info {
+	u32             label;
+	u8              tc;
+	u8              bos;
+	u8              ttl;
+};
 struct mlx5e_encap_entry {
 	/* attached neigh hash entry */
 	struct mlx5e_neigh_hash_entry *nhe;
 	struct list_head route_list;
 	struct mlx5_pkt_reformat *pkt_reformat;
 	const struct ip_tunnel_info *tun_info;
+	struct mlx5e_mpls_info mpls_info;
 	unsigned char h_dest[ETH_ALEN];	/* destination eth addr	*/
 	struct net_device *out_dev;

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

@@ -1348,7 +1348,8 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, · 1347 unmodified lines
1348	}	1348	}
1349		1349
1350	/* True when explicitly set via priv flag, or XDP prog is loaded */	1350	/* True when explicitly set via priv flag, or XDP prog is loaded */
1351	if (test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state))	1351	if (test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state) \|\|
		1352	get_cqe_tls_offload(cqe))
1352	goto csum_unnecessary;	1353	goto csum_unnecessary;
1353		1354
1354	/* CQE csum doesn't cover padding octets in short ethernet	1355	/* CQE csum doesn't cover padding octets in short ethernet

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

@@ -334,6 +334,7 @@ void mlx5e_self_test(struct net_device ndev, struct ethtool_test etest, · 333 unmodified lines
334	netdev_info(ndev, "\t[%d] %s start..\n", i, st.name);	334	netdev_info(ndev, "\t[%d] %s start..\n", i, st.name);
335	buf[count] = st.st_func(priv);	335	buf[count] = st.st_func(priv);
336	netdev_info(ndev, "\t[%d] %s end: result(%lld)\n", i, st.name, buf[count]);	336	netdev_info(ndev, "\t[%d] %s end: result(%lld)\n", i, st.name, buf[count]);
		337	count++;
337	}	338	}
338		339
339	mutex_unlock(&priv->state_lock);	340	mutex_unlock(&priv->state_lock);

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

 	u32 in[MLX5_ST_SZ_DW(ppcnt_reg)] = {};
 	int sz = MLX5_ST_SZ_BYTES(ppcnt_reg);
-	if (!MLX5_CAP_PCAM_FEATURE(mdev, ppcnt_statistical_group))
-		return;
 	MLX5_SET(ppcnt_reg, in, local_port, 1);
 	MLX5_SET(ppcnt_reg, in, grp, MLX5_PHYSICAL_LAYER_STATISTICAL_GROUP);
 	if (mlx5_core_access_reg(mdev, in, sz, ppcnt_phy_statistical,
 void mlx5e_stats_fec_get(struct mlx5e_priv *priv,
 			 struct ethtool_fec_stats *fec_stats)
 {
+	if (!MLX5_CAP_PCAM_FEATURE(priv->mdev, ppcnt_statistical_group))
+		return;
 	fec_set_corrected_bits_total(priv, fec_stats);
 	fec_set_block_stats(priv, fec_stats);
 }

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+12−0

@@ -3316,6 +3316,18 @@ actions_match_supported(struct mlx5e_priv *priv, · 3315 unmodified lines
3316	return false;	3316	return false;
3317	}	3317	}
3318		3318
		3319	if (!(~actions &
		3320	(MLX5_FLOW_CONTEXT_ACTION_FWD_DEST \| MLX5_FLOW_CONTEXT_ACTION_DROP))) {
		3321	NL_SET_ERR_MSG_MOD(extack, "Rule cannot support forward+drop action");
		3322	return false;
		3323	}
		3324
		3325	if (actions & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR &&
		3326	actions & MLX5_FLOW_CONTEXT_ACTION_DROP) {
		3327	NL_SET_ERR_MSG_MOD(extack, "Drop with modify header action is not supported");
		3328	return false;
		3329	}
		3330
3319	if (actions & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR &&	3331	if (actions & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR &&
3320	!modify_header_match_supported(priv, &parse_attr->spec, flow_action,	3332	!modify_header_match_supported(priv, &parse_attr->spec, flow_action,
3321	actions, ct_flow, ct_clear, extack))	3333	actions, ct_flow, ct_clear, extack))

drivers/net/ethernet/mellanox/mlx5/core/esw/qos.c+1−1

@@ -697,7 +697,7 @@ void mlx5_esw_qos_vport_disable(struct mlx5_eswitch esw, struct mlx5_vport vpo · 696 unmodified lines
697	}	697	}
698		698
699	int mlx5_esw_qos_set_vport_rate(struct mlx5_eswitch esw, struct mlx5_vport vport,	699	int mlx5_esw_qos_set_vport_rate(struct mlx5_eswitch esw, struct mlx5_vport vport,
700	u32 min_rate, u32 max_rate)	700	u32 max_rate, u32 min_rate)
701	{	701	{
702	int err;	702	int err;
703		703

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

@@ -2839,10 +2839,6 @@ bool mlx5_esw_vport_match_metadata_supported(const struct mlx5_eswitch *esw) · 2838 unmodified lines
2839	if (!MLX5_CAP_ESW_FLOWTABLE(esw->dev, flow_source))	2839	if (!MLX5_CAP_ESW_FLOWTABLE(esw->dev, flow_source))
2840	return false;	2840	return false;
2841		2841
2842	if (mlx5_core_is_ecpf_esw_manager(esw->dev) \|\|
2843	mlx5_ecpf_vport_exists(esw->dev))
2844	return false;
2845
2846	return true;	2842	return true;
2847	}	2843	}
2848		2844

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c+2−0

 		fte->node.del_hw_func = NULL;
 		up_write_ref_node(&fte->node, false);
 		tree_put_node(&fte->node, false);
+	} else {
+		up_write_ref_node(&fte->node, false);
 	}
 	kfree(handle);
 }

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

@@ -121,6 +121,9 @@ u32 mlx5_chains_get_nf_ft_chain(struct mlx5_fs_chains *chains) · 120 unmodified lines
121		121
122	u32 mlx5_chains_get_prio_range(struct mlx5_fs_chains *chains)	122	u32 mlx5_chains_get_prio_range(struct mlx5_fs_chains *chains)
123	{	123	{
		124	if (!mlx5_chains_prios_supported(chains))
		125	return 1;
		126
124	if (mlx5_chains_ignore_flow_level_supported(chains))	127	if (mlx5_chains_ignore_flow_level_supported(chains))
125	return UINT_MAX;	128	return UINT_MAX;
126		129

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

 	/* Check log_max_qp from HCA caps to set in current profile */
 	if (prof->log_max_qp == LOG_MAX_SUPPORTED_QPS) {
-		prof->log_max_qp = MLX5_CAP_GEN_MAX(dev, log_max_qp);
+		prof->log_max_qp = min_t(u8, 17, MLX5_CAP_GEN_MAX(dev, log_max_qp));
 	} else if (MLX5_CAP_GEN_MAX(dev, log_max_qp) < prof->log_max_qp) {
 		mlx5_core_warn(dev, "log_max_qp value in current profile is %d, changing it to HCA capability limit (%d)\n",
 			       prof->log_max_qp,
 	{ PCI_VDEVICE(MELLANOX, 0x101e), MLX5_PCI_DEV_IS_VF},	/* ConnectX Family mlx5Gen Virtual Function */
 	{ PCI_VDEVICE(MELLANOX, 0x101f) },			/* ConnectX-6 LX */
 	{ PCI_VDEVICE(MELLANOX, 0x1021) },			/* ConnectX-7 */
+	{ PCI_VDEVICE(MELLANOX, 0x1023) },			/* ConnectX-8 */
 	{ PCI_VDEVICE(MELLANOX, 0xa2d2) },			/* BlueField integrated ConnectX-5 network controller */
 	{ PCI_VDEVICE(MELLANOX, 0xa2d3), MLX5_PCI_DEV_IS_VF},	/* BlueField integrated ConnectX-5 network controller VF */
 	{ PCI_VDEVICE(MELLANOX, 0xa2d6) },			/* BlueField-2 integrated ConnectX-6 Dx network controller */
 	{ PCI_VDEVICE(MELLANOX, 0xa2dc) },			/* BlueField-3 integrated ConnectX-7 network controller */
+	{ PCI_VDEVICE(MELLANOX, 0xa2df) },			/* BlueField-4 integrated ConnectX-8 network controller */
 	{ 0, }
 };

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_icm_pool.c+81−39

@@ -4,7 +4,6 @@ · 3 unmodified lines
4	#include "dr_types.h"	4	#include "dr_types.h"
5		5
6	#define DR_ICM_MODIFY_HDR_ALIGN_BASE 64	6	#define DR_ICM_MODIFY_HDR_ALIGN_BASE 64
7	#define DR_ICM_SYNC_THRESHOLD_POOL (64 * 1024 * 1024)
8		7
9	struct mlx5dr_icm_pool {	8	struct mlx5dr_icm_pool {
10	enum mlx5dr_icm_type icm_type;	9	enum mlx5dr_icm_type icm_type;
@@ -136,37 +135,35 @@ static void dr_icm_pool_mr_destroy(struct mlx5dr_icm_mr *icm_mr) · 125 unmodified lines
136	kvfree(icm_mr);	135	kvfree(icm_mr);
137	}	136	}
138		137
139	static int dr_icm_chunk_ste_init(struct mlx5dr_icm_chunk *chunk)	138	static int dr_icm_buddy_get_ste_size(struct mlx5dr_icm_buddy_mem *buddy)
140	{	139	{
141	chunk->ste_arr = kvzalloc(chunk->num_of_entries *	140	/* We support only one type of STE size, both for ConnectX-5 and later
142	sizeof(chunk->ste_arr[0]), GFP_KERNEL);	141	* devices. Once the support for match STE which has a larger tag is
143	if (!chunk->ste_arr)	142	* added (32B instead of 16B), the STE size for devices later than
144	return -ENOMEM;	143	* ConnectX-5 needs to account for that.
145		144	*/
146	chunk->hw_ste_arr = kvzalloc(chunk->num_of_entries *	145	return DR_STE_SIZE_REDUCED;
147	DR_STE_SIZE_REDUCED, GFP_KERNEL);	146	}
148	if (!chunk->hw_ste_arr)
149	goto out_free_ste_arr;
150
151	chunk->miss_list = kvmalloc(chunk->num_of_entries *
152	sizeof(chunk->miss_list[0]), GFP_KERNEL);
153	if (!chunk->miss_list)
154	goto out_free_hw_ste_arr;
155		147
156	return 0;	148	static void dr_icm_chunk_ste_init(struct mlx5dr_icm_chunk *chunk, int offset)
		149	{
		150	struct mlx5dr_icm_buddy_mem *buddy = chunk->buddy_mem;
		151	int index = offset / DR_STE_SIZE;
157		152
158	out_free_hw_ste_arr:	153	chunk->ste_arr = &buddy->ste_arr[index];
159	kvfree(chunk->hw_ste_arr);	154	chunk->miss_list = &buddy->miss_list[index];
160	out_free_ste_arr:	155	chunk->hw_ste_arr = buddy->hw_ste_arr +
161	kvfree(chunk->ste_arr);	156	index * dr_icm_buddy_get_ste_size(buddy);
162	return -ENOMEM;
163	}	157	}
164		158
165	static void dr_icm_chunk_ste_cleanup(struct mlx5dr_icm_chunk *chunk)	159	static void dr_icm_chunk_ste_cleanup(struct mlx5dr_icm_chunk *chunk)
166	{	160	{
167	kvfree(chunk->miss_list);	161	struct mlx5dr_icm_buddy_mem *buddy = chunk->buddy_mem;
168	kvfree(chunk->hw_ste_arr);	162
169	kvfree(chunk->ste_arr);	163	memset(chunk->hw_ste_arr, 0,
		164	chunk->num_of_entries * dr_icm_buddy_get_ste_size(buddy));
		165	memset(chunk->ste_arr, 0,
		166	chunk->num_of_entries * sizeof(chunk->ste_arr[0]));
170	}	167	}
171		168
172	static enum mlx5dr_icm_type	169	static enum mlx5dr_icm_type
@@ -189,6 +186,44 @@ static void dr_icm_chunk_destroy(struct mlx5dr_icm_chunk *chunk, · 16 unmodified lines
189	kvfree(chunk);	186	kvfree(chunk);
190	}	187	}
191		188
		189	static int dr_icm_buddy_init_ste_cache(struct mlx5dr_icm_buddy_mem *buddy)
		190	{
		191	int num_of_entries =
		192	mlx5dr_icm_pool_chunk_size_to_entries(buddy->pool->max_log_chunk_sz);
		193
		194	buddy->ste_arr = kvcalloc(num_of_entries,
		195	sizeof(struct mlx5dr_ste), GFP_KERNEL);
		196	if (!buddy->ste_arr)
		197	return -ENOMEM;
		198
		199	/* Preallocate full STE size on non-ConnectX-5 devices since
		200	* we need to support both full and reduced with the same cache.
		201	*/
		202	buddy->hw_ste_arr = kvcalloc(num_of_entries,
		203	dr_icm_buddy_get_ste_size(buddy), GFP_KERNEL);
		204	if (!buddy->hw_ste_arr)
		205	goto free_ste_arr;
		206
		207	buddy->miss_list = kvmalloc(num_of_entries * sizeof(struct list_head), GFP_KERNEL);
		208	if (!buddy->miss_list)
		209	goto free_hw_ste_arr;
		210
		211	return 0;
		212
		213	free_hw_ste_arr:
		214	kvfree(buddy->hw_ste_arr);
		215	free_ste_arr:
		216	kvfree(buddy->ste_arr);
		217	return -ENOMEM;
		218	}
		219
		220	static void dr_icm_buddy_cleanup_ste_cache(struct mlx5dr_icm_buddy_mem *buddy)
		221	{
		222	kvfree(buddy->ste_arr);
		223	kvfree(buddy->hw_ste_arr);
		224	kvfree(buddy->miss_list);
		225	}
		226
192	static int dr_icm_buddy_create(struct mlx5dr_icm_pool *pool)	227	static int dr_icm_buddy_create(struct mlx5dr_icm_pool *pool)
193	{	228	{
194	struct mlx5dr_icm_buddy_mem *buddy;	229	struct mlx5dr_icm_buddy_mem *buddy;
@@ -208,11 +243,19 @@ static int dr_icm_buddy_create(struct mlx5dr_icm_pool *pool) · 13 unmodified lines
208	buddy->icm_mr = icm_mr;	243	buddy->icm_mr = icm_mr;
209	buddy->pool = pool;	244	buddy->pool = pool;
210		245
		246	if (pool->icm_type == DR_ICM_TYPE_STE) {
		247	/* Reduce allocations by preallocating and reusing the STE structures */
		248	if (dr_icm_buddy_init_ste_cache(buddy))
		249	goto err_cleanup_buddy;
		250	}
		251
211	/* add it to the -start- of the list in order to search in it first */	252	/* add it to the -start- of the list in order to search in it first */
212	list_add(&buddy->list_node, &pool->buddy_mem_list);	253	list_add(&buddy->list_node, &pool->buddy_mem_list);
213		254
214	return 0;	255	return 0;
215		256
		257	err_cleanup_buddy:
		258	mlx5dr_buddy_cleanup(buddy);
216	err_free_buddy:	259	err_free_buddy:
217	kvfree(buddy);	260	kvfree(buddy);
218	free_mr:	261	free_mr:
@@ -234,6 +277,9 @@ static void dr_icm_buddy_destroy(struct mlx5dr_icm_buddy_mem *buddy) · 15 unmodified lines
234		277
235	mlx5dr_buddy_cleanup(buddy);	278	mlx5dr_buddy_cleanup(buddy);
236		279
		280	if (buddy->pool->icm_type == DR_ICM_TYPE_STE)
		281	dr_icm_buddy_cleanup_ste_cache(buddy);
		282
237	kvfree(buddy);	283	kvfree(buddy);
238	}	284	}
239		285
@@ -261,34 +307,30 @@ dr_icm_chunk_create(struct mlx5dr_icm_pool *pool, · 21 unmodified lines
261	chunk->byte_size =	307	chunk->byte_size =
262	mlx5dr_icm_pool_chunk_size_to_byte(chunk_size, pool->icm_type);	308	mlx5dr_icm_pool_chunk_size_to_byte(chunk_size, pool->icm_type);
263	chunk->seg = seg;	309	chunk->seg = seg;
		310	chunk->buddy_mem = buddy_mem_pool;
264		311
265	if (pool->icm_type == DR_ICM_TYPE_STE && dr_icm_chunk_ste_init(chunk)) {	312	if (pool->icm_type == DR_ICM_TYPE_STE)
266	mlx5dr_err(pool->dmn,	313	dr_icm_chunk_ste_init(chunk, offset);
267	"Failed to init ste arrays (order: %d)\n",
268	chunk_size);
269	goto out_free_chunk;
270	}
271		314
272	buddy_mem_pool->used_memory += chunk->byte_size;	315	buddy_mem_pool->used_memory += chunk->byte_size;
273	chunk->buddy_mem = buddy_mem_pool;
274	INIT_LIST_HEAD(&chunk->chunk_list);	316	INIT_LIST_HEAD(&chunk->chunk_list);
275		317
276	/* chunk now is part of the used_list */	318	/* chunk now is part of the used_list */
277	list_add_tail(&chunk->chunk_list, &buddy_mem_pool->used_list);	319	list_add_tail(&chunk->chunk_list, &buddy_mem_pool->used_list);
278		320
279	return chunk;	321	return chunk;
280
281	out_free_chunk:
282	kvfree(chunk);
283	return NULL;
284	}	322	}
285		323
286	static bool dr_icm_pool_is_sync_required(struct mlx5dr_icm_pool *pool)	324	static bool dr_icm_pool_is_sync_required(struct mlx5dr_icm_pool *pool)
287	{	325	{
288	if (pool->hot_memory_size > DR_ICM_SYNC_THRESHOLD_POOL)	326	int allow_hot_size;
289	return true;	327
		328	/* sync when hot memory reaches half of the pool size */
		329	allow_hot_size =
		330	mlx5dr_icm_pool_chunk_size_to_byte(pool->max_log_chunk_sz,
		331	pool->icm_type) / 2;
290		332
291	return false;	333	return pool->hot_memory_size > allow_hot_size;
292	}	334	}
293		335
294	static int dr_icm_pool_sync_all_buddy_pools(struct mlx5dr_icm_pool *pool)	336	static int dr_icm_pool_sync_all_buddy_pools(struct mlx5dr_icm_pool *pool)

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_matcher.c+4−16

 	return (spec->dmac_47_16 || spec->dmac_15_0);
 }
-static bool dr_mask_is_src_addr_set(struct mlx5dr_match_spec *spec)
-{
-	return (spec->src_ip_127_96 || spec->src_ip_95_64 ||
-		spec->src_ip_63_32 || spec->src_ip_31_0);
-}
-static bool dr_mask_is_dst_addr_set(struct mlx5dr_match_spec *spec)
-{
-	return (spec->dst_ip_127_96 || spec->dst_ip_95_64 ||
-		spec->dst_ip_63_32 || spec->dst_ip_31_0);
-}
 static bool dr_mask_is_l3_base_set(struct mlx5dr_match_spec *spec)
 {
 	return (spec->ip_protocol || spec->frag || spec->tcp_flags ||
 						    &mask, inner, rx);
 		if (outer_ipv == DR_RULE_IPV6) {
-			if (dr_mask_is_dst_addr_set(&mask.outer))
+			if (DR_MASK_IS_DST_IP_SET(&mask.outer))
 				mlx5dr_ste_build_eth_l3_ipv6_dst(ste_ctx, &sb[idx++],
 								 &mask, inner, rx);
-			if (dr_mask_is_src_addr_set(&mask.outer))
+			if (DR_MASK_IS_SRC_IP_SET(&mask.outer))
 				mlx5dr_ste_build_eth_l3_ipv6_src(ste_ctx, &sb[idx++],
 								 &mask, inner, rx);
 						    &mask, inner, rx);
 		if (inner_ipv == DR_RULE_IPV6) {
-			if (dr_mask_is_dst_addr_set(&mask.inner))
+			if (DR_MASK_IS_DST_IP_SET(&mask.inner))
 				mlx5dr_ste_build_eth_l3_ipv6_dst(ste_ctx, &sb[idx++],
 								 &mask, inner, rx);
-			if (dr_mask_is_src_addr_set(&mask.inner))
+			if (DR_MASK_IS_SRC_IP_SET(&mask.inner))
 				mlx5dr_ste_build_eth_l3_ipv6_src(ste_ctx, &sb[idx++],
 								 &mask, inner, rx);

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c+31−1

@@ -602,12 +602,34 @@ int mlx5dr_ste_set_action_decap_l3_list(struct mlx5dr_ste_ctx *ste_ctx, · 601 unmodified lines
602	used_hw_action_num);	602	used_hw_action_num);
603	}	603	}
604		604
		605	static int dr_ste_build_pre_check_spec(struct mlx5dr_domain *dmn,
		606	struct mlx5dr_match_spec *spec)
		607	{
		608	if (spec->ip_version) {
		609	if (spec->ip_version != 0xf) {
		610	mlx5dr_err(dmn,
		611	"Partial ip_version mask with src/dst IP is not supported\n");
		612	return -EINVAL;
		613	}
		614	} else if (spec->ethertype != 0xffff &&
		615	(DR_MASK_IS_SRC_IP_SET(spec) \|\| DR_MASK_IS_DST_IP_SET(spec))) {
		616	mlx5dr_err(dmn,
		617	"Partial/no ethertype mask with src/dst IP is not supported\n");
		618	return -EINVAL;
		619	}
		620
		621	return 0;
		622	}
		623
605	int mlx5dr_ste_build_pre_check(struct mlx5dr_domain *dmn,	624	int mlx5dr_ste_build_pre_check(struct mlx5dr_domain *dmn,
606	u8 match_criteria,	625	u8 match_criteria,
607	struct mlx5dr_match_param *mask,	626	struct mlx5dr_match_param *mask,
608	struct mlx5dr_match_param *value)	627	struct mlx5dr_match_param *value)
609	{	628	{
610	if (!value && (match_criteria & DR_MATCHER_CRITERIA_MISC)) {	629	if (value)
		630	return 0;
		631
		632	if (match_criteria & DR_MATCHER_CRITERIA_MISC) {
611	if (mask->misc.source_port && mask->misc.source_port != 0xffff) {	633	if (mask->misc.source_port && mask->misc.source_port != 0xffff) {
612	mlx5dr_err(dmn,	634	mlx5dr_err(dmn,
613	"Partial mask source_port is not supported\n");	635	"Partial mask source_port is not supported\n");
@@ -621,6 +643,14 @@ int mlx5dr_ste_build_pre_check(struct mlx5dr_domain *dmn, · 7 unmodified lines
621	}	643	}
622	}	644	}
623		645
		646	if ((match_criteria & DR_MATCHER_CRITERIA_OUTER) &&
		647	dr_ste_build_pre_check_spec(dmn, &mask->outer))
		648	return -EINVAL;
		649
		650	if ((match_criteria & DR_MATCHER_CRITERIA_INNER) &&
		651	dr_ste_build_pre_check_spec(dmn, &mask->inner))
		652	return -EINVAL;
		653
624	return 0;	654	return 0;
625	}	655	}
626		656

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

@@ -798,6 +798,16 @@ struct mlx5dr_match_param { · 797 unmodified lines
798	(_misc3)->icmpv4_code \|\| \	798	(_misc3)->icmpv4_code \|\| \
799	(_misc3)->icmpv4_header_data)	799	(_misc3)->icmpv4_header_data)
800		800
		801	#define DR_MASK_IS_SRC_IP_SET(_spec) ((_spec)->src_ip_127_96 \|\| \
		802	(_spec)->src_ip_95_64 \|\| \
		803	(_spec)->src_ip_63_32 \|\| \
		804	(_spec)->src_ip_31_0)
		805
		806	#define DR_MASK_IS_DST_IP_SET(_spec) ((_spec)->dst_ip_127_96 \|\| \
		807	(_spec)->dst_ip_95_64 \|\| \
		808	(_spec)->dst_ip_63_32 \|\| \
		809	(_spec)->dst_ip_31_0)
		810
801	struct mlx5dr_esw_caps {	811	struct mlx5dr_esw_caps {
802	u64 drop_icm_address_rx;	812	u64 drop_icm_address_rx;
803	u64 drop_icm_address_tx;	813	u64 drop_icm_address_tx;

drivers/net/ethernet/mellanox/mlx5/core/steering/fs_dr.c+26−7

 		dst->dest_attr.vport.flags & MLX5_FLOW_DEST_VPORT_REFORMAT_ID;
 }
-#define MLX5_FLOW_CONTEXT_ACTION_MAX  32
+/* We want to support a rule with 32 destinations, which means we need to
+ * account for 32 destinations plus usually a counter plus one more action
+ * for a multi-destination flow table.
+ */
+#define MLX5_FLOW_CONTEXT_ACTION_MAX  34
 static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns,
 				  struct mlx5_flow_table *ft,
 				  struct mlx5_flow_group *group,
 			enum mlx5_flow_destination_type type = dst->dest_attr.type;
 			u32 id;
-			if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX ||
+			if (fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX ||
-			    num_term_actions >= MLX5_FLOW_CONTEXT_ACTION_MAX) {
+			    num_term_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
-				err = -ENOSPC;
+				err = -EOPNOTSUPP;
 				goto free_actions;
 			}
 			    MLX5_FLOW_DESTINATION_TYPE_COUNTER)
 				continue;
-			if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
+			if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX ||
-				err = -ENOSPC;
+			    fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
+				err = -EOPNOTSUPP;
 				goto free_actions;
 			}
 	params.match_sz = match_sz;
 	params.match_buf = (u64 *)fte->val;
 	if (num_term_actions == 1) {
-		if (term_actions->reformat)
+		if (term_actions->reformat) {
+			if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
+				err = -EOPNOTSUPP;
+				goto free_actions;
+			}
 			actions[num_actions++] = term_actions->reformat;
+		}
+		if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
+			err = -EOPNOTSUPP;
+			goto free_actions;
+		}
 		actions[num_actions++] = term_actions->dest;
 	} else if (num_term_actions > 1) {
 		bool ignore_flow_level =
 			!!(fte->action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL);
+		if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX ||
+		    fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
+			err = -EOPNOTSUPP;
+			goto free_actions;
+		}
 		tmp_action = mlx5dr_action_create_mult_dest_tbl(domain,
 								term_actions,
 								num_term_actions,

drivers/net/ethernet/mellanox/mlx5/core/steering/mlx5dr.h+5−0

 	 * sync_ste command sets them free.
 	 */
 	struct list_head	hot_list;
+	/* Memory optimisation */
+	struct mlx5dr_ste	*ste_arr;
+	struct list_head	*miss_list;
+	u8			*hw_ste_arr;
 };
 int mlx5dr_buddy_init(struct mlx5dr_icm_buddy_mem *buddy,

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c+2−2

 			  int port, bool mod)
 {
 	struct nfp_flower_priv *priv = app->priv;
-	int ida_idx = NFP_MAX_MAC_INDEX, err;
 	struct nfp_tun_offloaded_mac *entry;
+	int ida_idx = -1, err;
 	u16 nfp_mac_idx = 0;
 	entry = nfp_tunnel_lookup_offloaded_macs(app, netdev->dev_addr);
 err_free_entry:
 	kfree(entry);
 err_free_ida:
-	if (ida_idx != NFP_MAX_MAC_INDEX)
+	if (ida_idx != -1)
 		ida_simple_remove(&priv->tun.mac_off_ids, ida_idx);
 	return err;

drivers/net/ethernet/xilinx/ll_temac_main.c+2−0

@@ -1434,6 +1434,8 @@ static int temac_probe(struct platform_device *pdev) · 1433 unmodified lines
1434	lp->indirect_lock = devm_kmalloc(&pdev->dev,	1434	lp->indirect_lock = devm_kmalloc(&pdev->dev,
1435	sizeof(*lp->indirect_lock),	1435	sizeof(*lp->indirect_lock),
1436	GFP_KERNEL);	1436	GFP_KERNEL);
		1437	if (!lp->indirect_lock)
		1438	return -ENOMEM;
1437	spin_lock_init(lp->indirect_lock);	1439	spin_lock_init(lp->indirect_lock);
1438	}	1440	}
1439		1441

drivers/net/hamradio/6pack.c+2−2

 	 */
 	netif_stop_queue(sp->dev);
+	unregister_netdev(sp->dev);
 	del_timer_sync(&sp->tx_t);
 	del_timer_sync(&sp->resync_t);
-	unregister_netdev(sp->dev);
 	/* Free all 6pack frame buffers after unreg. */
 	kfree(sp->rbuff);
 	kfree(sp->xbuff);

drivers/net/mdio/mdio-ipq4019.c+5−1

 	if (ret)
 		return ret;
-	return clk_prepare_enable(priv->mdio_clk);
+	ret = clk_prepare_enable(priv->mdio_clk);
+	if (ret == 0)
+		mdelay(10);
+	return ret;
 }
 static int ipq4019_mdio_probe(struct platform_device *pdev)

drivers/net/usb/sr9700.c+1−1

@@ -413,7 +413,7 @@ static int sr9700_rx_fixup(struct usbnet dev, struct sk_buff skb) · 412 unmodified lines
413	/* ignore the CRC length */	413	/* ignore the CRC length */
414	len = (skb->data[1] \| (skb->data[2] << 8)) - 4;	414	len = (skb->data[1] \| (skb->data[2] << 8)) - 4;
415		415
416	if (len > ETH_FRAME_LEN)	416	if (len > ETH_FRAME_LEN \|\| len > skb->len)
417	return 0;	417	return 0;
418		418
419	/* the last packet of current skb */	419	/* the last packet of current skb */

drivers/net/xen-netback/xenbus.c+5−9

 		unsigned int queue_index;
 		xen_unregister_watchers(vif);
+		xenbus_rm(XBT_NIL, be->dev->nodename, "hotplug-status");
 #ifdef CONFIG_DEBUG_FS
 		xenvif_debugfs_delif(vif);
 #endif /* CONFIG_DEBUG_FS */
 		/* Not interested in this watch anymore. */
 		unregister_hotplug_status_watch(be);
-		xenbus_rm(XBT_NIL, be->dev->nodename, "hotplug-status");
 	}
 	kfree(str);
 }
 	xenvif_carrier_on(be->vif);
 	unregister_hotplug_status_watch(be);
-	if (xenbus_exists(XBT_NIL, dev->nodename, "hotplug-status")) {
+	err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, NULL,
-		err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch,
+				   hotplug_status_changed,
-					   NULL, hotplug_status_changed,
+				   "%s/%s", dev->nodename, "hotplug-status");
-					   "%s/%s", dev->nodename,
+	if (!err)
-					   "hotplug-status");
-		if (err)
-			goto err;
 		be->have_hotplug_status_watch = 1;
-	}
 	netif_tx_wake_all_queues(be->vif->dev);

drivers/nvme/host/core.c+9−12

 	return 0;
 }
-static int nvme_configure_metadata(struct nvme_ns *ns, struct nvme_id_ns *id)
+static void nvme_configure_metadata(struct nvme_ns *ns, struct nvme_id_ns *id)
 {
 	struct nvme_ctrl *ctrl = ns->ctrl;
 	ns->features &= ~(NVME_NS_METADATA_SUPPORTED | NVME_NS_EXT_LBAS);
 	if (!ns->ms || !(ctrl->ops->flags & NVME_F_METADATA_SUPPORTED))
-		return 0;
+		return;
 	if (ctrl->ops->flags & NVME_F_FABRICS) {
 		/*
 		 * The NVMe over Fabrics specification only supports metadata as
 		 * remap the separate metadata buffer from the block layer.
 		 */
 		if (WARN_ON_ONCE(!(id->flbas & NVME_NS_FLBAS_META_EXT)))
-			return -EINVAL;
+			return;
 		ns->features |= NVME_NS_EXT_LBAS;
 		else
 			ns->features |= NVME_NS_METADATA_SUPPORTED;
 	}
-	return 0;
 }
 static void nvme_set_queue_limits(struct nvme_ctrl *ctrl,
 	ns->lba_shift = id->lbaf[lbaf].ds;
 	nvme_set_queue_limits(ns->ctrl, ns->queue);
-	ret = nvme_configure_metadata(ns, id);
+	nvme_configure_metadata(ns, id);
-	if (ret)
-		goto out_unfreeze;
 	nvme_set_chunk_sectors(ns, id);
 	nvme_update_disk_info(ns->disk, ns, id);
 	if (blk_queue_is_zoned(ns->queue)) {
 		ret = nvme_revalidate_zones(ns);
 		if (ret && !nvme_first_scan(ns->disk))
-			goto out;
+			return ret;
 	}
 	if (nvme_ns_head_multipath(ns->head)) {
 	return 0;
 out_unfreeze:
-	blk_mq_unfreeze_queue(ns->disk->queue);
-out:
 	/*
 	 * If probing fails due an unsupported feature, hide the block device,
 	 * but still allow other access.
 	 */
 	if (ret == -ENODEV) {
 		ns->disk->flags |= GENHD_FL_HIDDEN;
+		set_bit(NVME_NS_READY, &ns->flags);
 		ret = 0;
 	}
+	blk_mq_unfreeze_queue(ns->disk->queue);
 	return ret;
 }
 	if (test_and_set_bit(NVME_NS_DEAD, &ns->flags))
 		return;
-	blk_set_queue_dying(ns->queue);
+	blk_mark_disk_dead(ns->disk);
 	nvme_start_ns_queue(ns);
 	set_capacity_and_notify(ns->disk, 0);

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

@@ -848,7 +848,7 @@ void nvme_mpath_remove_disk(struct nvme_ns_head *head) · 847 unmodified lines
848	{	848	{
849	if (!head->disk)	849	if (!head->disk)
850	return;	850	return;
851	blk_set_queue_dying(head->disk->queue);	851	blk_mark_disk_dead(head->disk);
852	/* make sure all pending bios are cleaned up */	852	/* make sure all pending bios are cleaned up */
853	kblockd_schedule_work(&head->requeue_work);	853	kblockd_schedule_work(&head->requeue_work);
854	flush_work(&head->requeue_work);	854	flush_work(&head->requeue_work);

drivers/nvme/host/tcp.c+49−14

 	u32			data_len;
 	u32			pdu_len;
 	u32			pdu_sent;
+	u32			h2cdata_left;
+	u32			h2cdata_offset;
 	u16			ttag;
 	__le16			status;
 	struct list_head	entry;
 	struct nvme_tcp_request *request;
 	int			queue_size;
+	u32			maxh2cdata;
 	size_t			cmnd_capsule_len;
 	struct nvme_tcp_ctrl	*ctrl;
 	unsigned long		flags;
 	return ret;
 }
-static void nvme_tcp_setup_h2c_data_pdu(struct nvme_tcp_request *req,
+static void nvme_tcp_setup_h2c_data_pdu(struct nvme_tcp_request *req)
-		struct nvme_tcp_r2t_pdu *pdu)
 {
 	struct nvme_tcp_data_pdu *data = req->pdu;
 	struct nvme_tcp_queue *queue = req->queue;
 	struct request *rq = blk_mq_rq_from_pdu(req);
+	u32 h2cdata_sent = req->pdu_len;
 	u8 hdgst = nvme_tcp_hdgst_len(queue);
 	u8 ddgst = nvme_tcp_ddgst_len(queue);
 	req->state = NVME_TCP_SEND_H2C_PDU;
 	req->offset = 0;
-	req->pdu_len = le32_to_cpu(pdu->r2t_length);
+	req->pdu_len = min(req->h2cdata_left, queue->maxh2cdata);
 	req->pdu_sent = 0;
+	req->h2cdata_left -= req->pdu_len;
+	req->h2cdata_offset += h2cdata_sent;
 	memset(data, 0, sizeof(*data));
 	data->hdr.type = nvme_tcp_h2c_data;
-	data->hdr.flags = NVME_TCP_F_DATA_LAST;
+	if (!req->h2cdata_left)
+		data->hdr.flags = NVME_TCP_F_DATA_LAST;
 	if (queue->hdr_digest)
 		data->hdr.flags |= NVME_TCP_F_HDGST;
 	if (queue->data_digest)
 	data->hdr.pdo = data->hdr.hlen + hdgst;
 	data->hdr.plen =
 		cpu_to_le32(data->hdr.hlen + hdgst + req->pdu_len + ddgst);
-	data->ttag = pdu->ttag;
+	data->ttag = req->ttag;
 	data->command_id = nvme_cid(rq);
-	data->data_offset = pdu->r2t_offset;
+	data->data_offset = cpu_to_le32(req->h2cdata_offset);
 	data->data_length = cpu_to_le32(req->pdu_len);
 }
 	struct nvme_tcp_request *req;
 	struct request *rq;
 	u32 r2t_length = le32_to_cpu(pdu->r2t_length);
+	u32 r2t_offset = le32_to_cpu(pdu->r2t_offset);
 	rq = nvme_find_rq(nvme_tcp_tagset(queue), pdu->command_id);
 	if (!rq) {
 		return -EPROTO;
 	}
-	if (unlikely(le32_to_cpu(pdu->r2t_offset) < req->data_sent)) {
+	if (unlikely(r2t_offset < req->data_sent)) {
 		dev_err(queue->ctrl->ctrl.device,
 			"req %d unexpected r2t offset %u (expected %zu)\n",
-			rq->tag, le32_to_cpu(pdu->r2t_offset), req->data_sent);
+			rq->tag, r2t_offset, req->data_sent);
 		return -EPROTO;
 	}
-	nvme_tcp_setup_h2c_data_pdu(req, pdu);
+	req->pdu_len = 0;
+	req->h2cdata_left = r2t_length;
+	req->h2cdata_offset = r2t_offset;
+	req->ttag = pdu->ttag;
+	nvme_tcp_setup_h2c_data_pdu(req);
 	nvme_tcp_queue_request(req, false, true);
 	return 0;
 {
 	struct nvme_tcp_queue *queue = req->queue;
 	int req_data_len = req->data_len;
+	u32 h2cdata_left = req->h2cdata_left;
 	while (true) {
 		struct page *page = nvme_tcp_req_cur_page(req);
 				req->state = NVME_TCP_SEND_DDGST;
 				req->offset = 0;
 			} else {
-				nvme_tcp_done_send_req(queue);
+				if (h2cdata_left)
+					nvme_tcp_setup_h2c_data_pdu(req);
+				else
+					nvme_tcp_done_send_req(queue);
 			}
 			return 1;
 		}
 	if (queue->hdr_digest && !req->offset)
 		nvme_tcp_hdgst(queue->snd_hash, pdu, sizeof(*pdu));
-	ret = kernel_sendpage(queue->sock, virt_to_page(pdu),
+	if (!req->h2cdata_left)
-			offset_in_page(pdu) + req->offset, len,
+		ret = kernel_sendpage(queue->sock, virt_to_page(pdu),
-			MSG_DONTWAIT | MSG_MORE | MSG_SENDPAGE_NOTLAST);
+				offset_in_page(pdu) + req->offset, len,
+				MSG_DONTWAIT | MSG_MORE | MSG_SENDPAGE_NOTLAST);
+	else
+		ret = sock_no_sendpage(queue->sock, virt_to_page(pdu),
+				offset_in_page(pdu) + req->offset, len,
+				MSG_DONTWAIT | MSG_MORE);
 	if (unlikely(ret <= 0))
 		return ret;
 {
 	struct nvme_tcp_queue *queue = req->queue;
 	size_t offset = req->offset;
+	u32 h2cdata_left = req->h2cdata_left;
 	int ret;
 	struct msghdr msg = { .msg_flags = MSG_DONTWAIT };
 	struct kvec iov = {
 		return ret;
 	if (offset + ret == NVME_TCP_DIGEST_LENGTH) {
-		nvme_tcp_done_send_req(queue);
+		if (h2cdata_left)
+			nvme_tcp_setup_h2c_data_pdu(req);
+		else
+			nvme_tcp_done_send_req(queue);
 		return 1;
 	}
 	struct msghdr msg = {};
 	struct kvec iov;
 	bool ctrl_hdgst, ctrl_ddgst;
+	u32 maxh2cdata;
 	int ret;
 	icreq = kzalloc(sizeof(*icreq), GFP_KERNEL);
 		goto free_icresp;
 	}
+	maxh2cdata = le32_to_cpu(icresp->maxdata);
+	if ((maxh2cdata % 4) || (maxh2cdata < NVME_TCP_MIN_MAXH2CDATA)) {
+		pr_err("queue %d: invalid maxh2cdata returned %u\n",
+		       nvme_tcp_queue_id(queue), maxh2cdata);
+		goto free_icresp;
+	}
+	queue->maxh2cdata = maxh2cdata;
 	ret = 0;
 free_icresp:
 	kfree(icresp);
 	req->data_sent = 0;
 	req->pdu_len = 0;
 	req->pdu_sent = 0;
+	req->h2cdata_left = 0;
 	req->data_len = blk_rq_nr_phys_segments(rq) ?
 				blk_rq_payload_bytes(rq) : 0;
 	req->curr_bio = rq->bio;

drivers/of/fdt.c+1−1

@@ -648,8 +648,8 @@ void __init early_init_fdt_scan_reserved_mem(void) · 647 unmodified lines
648	}	648	}
649		649
650	fdt_scan_reserved_mem();	650	fdt_scan_reserved_mem();
651	fdt_init_reserved_mem();
652	fdt_reserve_elfcorehdr();	651	fdt_reserve_elfcorehdr();
		652	fdt_init_reserved_mem();
653	}	653	}
654		654
655	/**	655	/**

drivers/of/unittest.c+8−8

@@ -513,24 +513,24 @@ static void __init of_unittest_parse_phandle_with_args(void) · 512 unmodified lines
513	memset(&args, 0, sizeof(args));	513	memset(&args, 0, sizeof(args));
514		514
515	EXPECT_BEGIN(KERN_INFO,	515	EXPECT_BEGIN(KERN_INFO,
516	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");	516	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
517		517
518	rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",	518	rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
519	"#phandle-cells", 1, &args);	519	"#phandle-cells", 1, &args);
520		520
521	EXPECT_END(KERN_INFO,	521	EXPECT_END(KERN_INFO,
522	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");	522	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
523		523
524	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);	524	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
525		525
526	EXPECT_BEGIN(KERN_INFO,	526	EXPECT_BEGIN(KERN_INFO,
527	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");	527	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
528		528
529	rc = of_count_phandle_with_args(np, "phandle-list-bad-args",	529	rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
530	"#phandle-cells");	530	"#phandle-cells");
531		531
532	EXPECT_END(KERN_INFO,	532	EXPECT_END(KERN_INFO,
533	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");	533	"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
534		534
535	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);	535	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
536	}	536	}
@@ -670,12 +670,12 @@ static void __init of_unittest_parse_phandle_with_args_map(void) · 133 unmodified lines
670	memset(&args, 0, sizeof(args));	670	memset(&args, 0, sizeof(args));
671		671
672	EXPECT_BEGIN(KERN_INFO,	672	EXPECT_BEGIN(KERN_INFO,
673	"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");	673	"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found 1");
674		674
675	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",	675	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
676	"phandle", 1, &args);	676	"phandle", 1, &args);
677	EXPECT_END(KERN_INFO,	677	EXPECT_END(KERN_INFO,
678	"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");	678	"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found 1");
679		679
680	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);	680	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
681	}	681	}
@@ -1257,12 +1257,12 @@ static void __init of_unittest_platform_populate(void) · 575 unmodified lines
1257	unittest(pdev, "device 2 creation failed\n");	1257	unittest(pdev, "device 2 creation failed\n");
1258		1258
1259	EXPECT_BEGIN(KERN_INFO,	1259	EXPECT_BEGIN(KERN_INFO,
1260	"platform testcase-data:testcase-device2: IRQ index 0 not found");	1260	"platform testcase-data:testcase-device2: error -ENXIO: IRQ index 0 not found");
1261		1261
1262	irq = platform_get_irq(pdev, 0);	1262	irq = platform_get_irq(pdev, 0);
1263		1263
1264	EXPECT_END(KERN_INFO,	1264	EXPECT_END(KERN_INFO,
1265	"platform testcase-data:testcase-device2: IRQ index 0 not found");	1265	"platform testcase-data:testcase-device2: error -ENXIO: IRQ index 0 not found");
1266		1266
1267	unittest(irq < 0 && irq != -EPROBE_DEFER,	1267	unittest(irq < 0 && irq != -EPROBE_DEFER,
1268	"device parsing error failed - %d\n", irq);	1268	"device parsing error failed - %d\n", irq);

drivers/pci/controller/pci-mvebu.c+2−1

@@ -1329,7 +1329,8 @@ static int mvebu_pcie_probe(struct platform_device *pdev) · 1328 unmodified lines
1329	* indirectly via kernel emulated PCI bridge driver.	1329	* indirectly via kernel emulated PCI bridge driver.
1330	*/	1330	*/
1331	mvebu_pcie_setup_hw(port);	1331	mvebu_pcie_setup_hw(port);
1332	mvebu_pcie_set_local_dev_nr(port, 0);	1332	mvebu_pcie_set_local_dev_nr(port, 1);
		1333	mvebu_pcie_set_local_bus_nr(port, 0);
1333	}	1334	}
1334		1335
1335	pcie->nports = i;	1336	pcie->nports = i;

drivers/pci/quirks.c+9−5

  */
 static void quirk_amd_harvest_no_ats(struct pci_dev *pdev)
 {
-	if ((pdev->device == 0x7312 && pdev->revision != 0x00) ||
-	    (pdev->device == 0x7340 && pdev->revision != 0xc5) ||
-	    (pdev->device == 0x7341 && pdev->revision != 0x00))
-		return;
 	if (pdev->device == 0x15d8) {
 		if (pdev->revision == 0xcf &&
 		    pdev->subsystem_vendor == 0xea50 &&
 /* AMD Iceland dGPU */
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x6900, quirk_amd_harvest_no_ats);
 /* AMD Navi10 dGPU */
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7310, quirk_amd_harvest_no_ats);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7312, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7318, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7319, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x731a, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x731b, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x731e, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x731f, quirk_amd_harvest_no_ats);
 /* AMD Navi14 dGPU */
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7340, quirk_amd_harvest_no_ats);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7341, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7347, quirk_amd_harvest_no_ats);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x734f, quirk_amd_harvest_no_ats);
 /* AMD Raven platform iGPU */
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x15d8, quirk_amd_harvest_no_ats);
 #endif /* CONFIG_PCI_ATS */

drivers/platform/surface/surface3_power.c+10−3

 	}
 	bix->last_full_charg_capacity = ret;
-	/* get serial number */
+	/*
+	 * Get serial number, on some devices (with unofficial replacement
+	 * battery?) reading any of the serial number range addresses gets
+	 * nacked in this case just leave the serial number empty.
+	 */
 	ret = i2c_smbus_read_i2c_block_data(client, MSHW0011_BAT0_REG_SERIAL_NO,
 					    sizeof(buf), buf);
-	if (ret != sizeof(buf)) {
+	if (ret == -EREMOTEIO) {
+		/* no serial number available */
+	} else if (ret != sizeof(buf)) {
 		dev_err(&client->dev, "Error reading serial no: %d\n", ret);
 		return ret;
+	} else {
+		snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf);
 	}
-	snprintf(bix->serial, ARRAY_SIZE(bix->serial), "%3pE%6pE", buf + 7, buf);
 	/* get cycle count */
 	ret = i2c_smbus_read_word_data(client, MSHW0011_BAT0_REG_CYCLE_CNT);

drivers/platform/x86/amd-pmc.c+33−9

 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
+#include <linux/pm_qos.h>
 #include <linux/rtc.h>
 #include <linux/suspend.h>
 #include <linux/seq_file.h>
 #define PMC_MSG_DELAY_MIN_US		50
 #define RESPONSE_REGISTER_LOOP_MAX	20000
+/* QoS request for letting CPUs in idle states, but not the deepest */
+#define AMD_PMC_MAX_IDLE_STATE_LATENCY	3
 #define SOC_SUBSYSTEM_IP_MAX	12
 #define DELAY_MIN_US		2000
 #define DELAY_MAX_US		3000
 	struct device *dev;
 	struct pci_dev *rdev;
 	struct mutex lock; /* generic mutex lock */
+	struct pm_qos_request amd_pmc_pm_qos_req;
 #if IS_ENABLED(CONFIG_DEBUG_FS)
 	struct dentry *dbgfs_dir;
 #endif /* CONFIG_DEBUG_FS */
 	rc = rtc_alarm_irq_enable(rtc_device, 0);
 	dev_dbg(pdev->dev, "wakeup timer programmed for %lld seconds\n", duration);
+	/*
+	 * Prevent CPUs from getting into deep idle states while sending OS_HINT
+	 * which is otherwise generally safe to send when at least one of the CPUs
+	 * is not in deep idle states.
+	 */
+	cpu_latency_qos_update_request(&pdev->amd_pmc_pm_qos_req, AMD_PMC_MAX_IDLE_STATE_LATENCY);
+	wake_up_all_idle_cpus();
 	return rc;
 }
 	/* Activate CZN specific RTC functionality */
 	if (pdev->cpu_id == AMD_CPU_ID_CZN) {
 		rc = amd_pmc_verify_czn_rtc(pdev, &arg);
-		if (rc < 0)
+		if (rc)
-			return rc;
+			goto fail;
 	}
 	/* Dump the IdleMask before we send hint to SMU */
 	amd_pmc_idlemask_read(pdev, dev, NULL);
 	msg = amd_pmc_get_os_hint(pdev);
 	rc = amd_pmc_send_cmd(pdev, arg, NULL, msg, 0);
-	if (rc)
+	if (rc) {
 		dev_err(pdev->dev, "suspend failed\n");
+		goto fail;
+	}
 	if (enable_stb)
 		rc = amd_pmc_write_stb(pdev, AMD_PMC_STB_PREDEF);
-	if (rc)	{
+	if (rc) {
 		dev_err(pdev->dev, "error writing to STB\n");
-		return rc;
+		goto fail;
 	}
+	return 0;
+fail:
+	if (pdev->cpu_id == AMD_CPU_ID_CZN)
+		cpu_latency_qos_update_request(&pdev->amd_pmc_pm_qos_req,
+						PM_QOS_DEFAULT_VALUE);
 	return rc;
 }
 	/* Write data incremented by 1 to distinguish in stb_read */
 	if (enable_stb)
 		rc = amd_pmc_write_stb(pdev, AMD_PMC_STB_PREDEF + 1);
-	if (rc)	{
+	if (rc)
 		dev_err(pdev->dev, "error writing to STB\n");
-		return rc;
-	}
-	return 0;
+	/* Restore the QoS request back to defaults if it was set */
+	if (pdev->cpu_id == AMD_CPU_ID_CZN)
+		cpu_latency_qos_update_request(&pdev->amd_pmc_pm_qos_req,
+						PM_QOS_DEFAULT_VALUE);
+	return rc;
 }
 static const struct dev_pm_ops amd_pmc_pm_ops = {
 	amd_pmc_get_smu_version(dev);
 	platform_set_drvdata(pdev, dev);
 	amd_pmc_dbgfs_register(dev);
+	cpu_latency_qos_add_request(&dev->amd_pmc_pm_qos_req, PM_QOS_DEFAULT_VALUE);
 	return 0;
 err_pci_dev_put:

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

@@ -2223,7 +2223,7 @@ static int fan_curve_check_present(struct asus_wmi asus, bool available, · 2222 unmodified lines
2223		2223
2224	err = fan_curve_get_factory_default(asus, fan_dev);	2224	err = fan_curve_get_factory_default(asus, fan_dev);
2225	if (err) {	2225	if (err) {
2226	if (err == -ENODEV)	2226	if (err == -ENODEV \|\| err == -ENODATA)
2227	return 0;	2227	return 0;
2228	return err;	2228	return err;
2229	}	2229	}

drivers/platform/x86/intel/int3472/tps68470_board_data.c+2−1

@@ -100,7 +100,8 @@ static struct gpiod_lookup_table surface_go_tps68470_gpios = { · 99 unmodified lines
100	.dev_id = "i2c-INT347A:00",	100	.dev_id = "i2c-INT347A:00",
101	.table = {	101	.table = {
102	GPIO_LOOKUP("tps68470-gpio", 9, "reset", GPIO_ACTIVE_LOW),	102	GPIO_LOOKUP("tps68470-gpio", 9, "reset", GPIO_ACTIVE_LOW),
103	GPIO_LOOKUP("tps68470-gpio", 7, "powerdown", GPIO_ACTIVE_LOW)	103	GPIO_LOOKUP("tps68470-gpio", 7, "powerdown", GPIO_ACTIVE_LOW),
		104	{ }
104	}	105	}
105	};	106	};
106		107

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

@@ -8703,6 +8703,7 @@ static const struct tpacpi_quirk fan_quirk_table[] __initconst = { · 8702 unmodified lines
8703	TPACPI_Q_LNV3('N', '4', '0', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (4nd gen) */	8703	TPACPI_Q_LNV3('N', '4', '0', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (4nd gen) */
8704	TPACPI_Q_LNV3('N', '3', '0', TPACPI_FAN_2CTL), /* P15 (1st gen) / P15v (1st gen) */	8704	TPACPI_Q_LNV3('N', '3', '0', TPACPI_FAN_2CTL), /* P15 (1st gen) / P15v (1st gen) */
8705	TPACPI_Q_LNV3('N', '3', '2', TPACPI_FAN_2CTL), /* X1 Carbon (9th gen) */	8705	TPACPI_Q_LNV3('N', '3', '2', TPACPI_FAN_2CTL), /* X1 Carbon (9th gen) */
		8706	TPACPI_Q_LNV3('N', '3', '7', TPACPI_FAN_2CTL), /* T15g (2nd gen) */
8706	TPACPI_Q_LNV3('N', '1', 'O', TPACPI_FAN_NOFAN), /* X1 Tablet (2nd gen) */	8707	TPACPI_Q_LNV3('N', '1', 'O', TPACPI_FAN_NOFAN), /* X1 Tablet (2nd gen) */
8707	};	8708	};
8708		8709

drivers/power/supply/bq256xx_charger.c+3−0

@@ -1523,6 +1523,9 @@ static int bq256xx_hw_init(struct bq256xx_device *bq) · 1522 unmodified lines
1523	BQ256XX_WDT_BIT_SHIFT);	1523	BQ256XX_WDT_BIT_SHIFT);
1524		1524
1525	ret = power_supply_get_battery_info(bq->charger, &bat_info);	1525	ret = power_supply_get_battery_info(bq->charger, &bat_info);
		1526	if (ret == -ENOMEM)
		1527	return ret;
		1528
1526	if (ret) {	1529	if (ret) {
1527	dev_warn(bq->dev, "battery info missing, default values will be applied\n");	1530	dev_warn(bq->dev, "battery info missing, default values will be applied\n");
1528		1531

drivers/power/supply/cw2015_battery.c+1−1

@@ -689,7 +689,7 @@ static int cw_bat_probe(struct i2c_client *client) · 688 unmodified lines
689	if (ret) {	689	if (ret) {
690	/* Allocate an empty battery */	690	/* Allocate an empty battery */
691	cw_bat->battery = devm_kzalloc(&client->dev,	691	cw_bat->battery = devm_kzalloc(&client->dev,
692	sizeof(cw_bat->battery),	692	sizeof(*cw_bat->battery),
693	GFP_KERNEL);	693	GFP_KERNEL);
694	if (!cw_bat->battery)	694	if (!cw_bat->battery)
695	return -ENOMEM;	695	return -ENOMEM;

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

@@ -592,6 +592,7 @@ struct lpfc_vport { · 591 unmodified lines
592	#define FC_VPORT_LOGO_RCVD 0x200 /* LOGO received on vport */	592	#define FC_VPORT_LOGO_RCVD 0x200 /* LOGO received on vport */
593	#define FC_RSCN_DISCOVERY 0x400 /* Auth all devices after RSCN */	593	#define FC_RSCN_DISCOVERY 0x400 /* Auth all devices after RSCN */
594	#define FC_LOGO_RCVD_DID_CHNG 0x800 /* FDISC on phys port detect DID chng*/	594	#define FC_LOGO_RCVD_DID_CHNG 0x800 /* FDISC on phys port detect DID chng*/
		595	#define FC_PT2PT_NO_NVME 0x1000 /* Don't send NVME PRLI */
595	#define FC_SCSI_SCAN_TMO 0x4000 /* scsi scan timer running */	596	#define FC_SCSI_SCAN_TMO 0x4000 /* scsi scan timer running */
596	#define FC_ABORT_DISCOVERY 0x8000 /* we want to abort discovery */	597	#define FC_ABORT_DISCOVERY 0x8000 /* we want to abort discovery */
597	#define FC_NDISC_ACTIVE 0x10000 /* NPort discovery active */	598	#define FC_NDISC_ACTIVE 0x10000 /* NPort discovery active */

drivers/scsi/lpfc/lpfc_attr.c+3−0

@@ -1315,6 +1315,9 @@ lpfc_issue_lip(struct Scsi_Host *shost) · 1314 unmodified lines
1315	pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;	1315	pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1316	pmboxq->u.mb.mbxOwner = OWN_HOST;	1316	pmboxq->u.mb.mbxOwner = OWN_HOST;
1317		1317
		1318	if ((vport->fc_flag & FC_PT2PT) && (vport->fc_flag & FC_PT2PT_NO_NVME))
		1319	vport->fc_flag &= ~FC_PT2PT_NO_NVME;
		1320
1318	mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);	1321	mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
1319		1322
1320	if ((mbxstatus == MBX_SUCCESS) &&	1323	if ((mbxstatus == MBX_SUCCESS) &&

drivers/scsi/lpfc/lpfc_els.c+19−1

@@ -1072,7 +1072,8 @@ stop_rr_fcf_flogi: · 1071 unmodified lines
1072		1072
1073	/* FLOGI failed, so there is no fabric */	1073	/* FLOGI failed, so there is no fabric */
1074	spin_lock_irq(shost->host_lock);	1074	spin_lock_irq(shost->host_lock);
1075	vport->fc_flag &= ~(FC_FABRIC \| FC_PUBLIC_LOOP);	1075	vport->fc_flag &= ~(FC_FABRIC \| FC_PUBLIC_LOOP \|
		1076	FC_PT2PT_NO_NVME);
1076	spin_unlock_irq(shost->host_lock);	1077	spin_unlock_irq(shost->host_lock);
1077		1078
1078	/* If private loop, then allow max outstanding els to be	1079	/* If private loop, then allow max outstanding els to be
@@ -4607,6 +4608,23 @@ lpfc_els_retry(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 3528 unmodified lines
4607	/* Added for Vendor specifc support	4608	/* Added for Vendor specifc support
4608	* Just keep retrying for these Rsn / Exp codes	4609	* Just keep retrying for these Rsn / Exp codes
4609	*/	4610	*/
		4611	if ((vport->fc_flag & FC_PT2PT) &&
		4612	cmd == ELS_CMD_NVMEPRLI) {
		4613	switch (stat.un.b.lsRjtRsnCode) {
		4614	case LSRJT_UNABLE_TPC:
		4615	case LSRJT_INVALID_CMD:
		4616	case LSRJT_LOGICAL_ERR:
		4617	case LSRJT_CMD_UNSUPPORTED:
		4618	lpfc_printf_vlog(vport, KERN_WARNING, LOG_ELS,
		4619	"0168 NVME PRLI LS_RJT "
		4620	"reason %x port doesn't "
		4621	"support NVME, disabling NVME\n",
		4622	stat.un.b.lsRjtRsnCode);
		4623	retry = 0;
		4624	vport->fc_flag \|= FC_PT2PT_NO_NVME;
		4625	goto out_retry;
		4626	}
		4627	}
4610	switch (stat.un.b.lsRjtRsnCode) {	4628	switch (stat.un.b.lsRjtRsnCode) {
4611	case LSRJT_UNABLE_TPC:	4629	case LSRJT_UNABLE_TPC:
4612	/* The driver has a VALID PLOGI but the rport has	4630	/* The driver has a VALID PLOGI but the rport has

drivers/scsi/lpfc/lpfc_nportdisc.c+3−2

 			 * is configured try it.
 			 */
 			ndlp->nlp_fc4_type |= NLP_FC4_FCP;
-			if ((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
+			if ((!(vport->fc_flag & FC_PT2PT_NO_NVME)) &&
-			    (vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) {
+			    (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
+			    vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) {
 				ndlp->nlp_fc4_type |= NLP_FC4_NVME;
 				/* We need to update the localport also */
 				lpfc_nvme_update_localport(vport);

drivers/scsi/qedi/qedi_fw.c+2−4

 			qedi_cmd->list_tmf_work = NULL;
 		}
 	}
+	spin_unlock_bh(&qedi_conn->tmf_work_lock);
-	if (!found) {
+	if (!found)
-		spin_unlock_bh(&qedi_conn->tmf_work_lock);
 		goto check_cleanup_reqs;
-	}
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 		  "TMF work, cqe->tid=0x%x, tmf flags=0x%x, cid=0x%x\n",
 	qedi_cmd->state = CLEANUP_RECV;
 unlock:
 	spin_unlock_bh(&conn->session->back_lock);
-	spin_unlock_bh(&qedi_conn->tmf_work_lock);
 	wake_up_interruptible(&qedi_conn->wait_queue);
 	return;

drivers/scsi/ufs/ufshcd.c+1−1

@@ -2681,7 +2681,7 @@ static int ufshcd_map_queues(struct Scsi_Host *shost) · 2680 unmodified lines
2681	break;	2681	break;
2682	case HCTX_TYPE_READ:	2682	case HCTX_TYPE_READ:
2683	map->nr_queues = 0;	2683	map->nr_queues = 0;
2684	break;	2684	continue;
2685	default:	2685	default:
2686	WARN_ON_ONCE(true);	2686	WARN_ON_ONCE(true);
2687	}	2687	}

drivers/soc/mediatek/mtk-scpsys.c+4−11

 	return ret;
 }
-static int init_clks(struct platform_device *pdev, struct clk **clk)
+static void init_clks(struct platform_device *pdev, struct clk **clk)
 {
 	int i;
-	for (i = CLK_NONE + 1; i < CLK_MAX; i++) {
+	for (i = CLK_NONE + 1; i < CLK_MAX; i++)
 		clk[i] = devm_clk_get(&pdev->dev, clk_names[i]);
-		if (IS_ERR(clk[i]))
-			return PTR_ERR(clk[i]);
-	}
-	return 0;
 }
 static struct scp *init_scp(struct platform_device *pdev,
 {
 	struct genpd_onecell_data *pd_data;
 	struct resource *res;
-	int i, j, ret;
+	int i, j;
 	struct scp *scp;
 	struct clk *clk[CLK_MAX];
 	pd_data->num_domains = num;
-	ret = init_clks(pdev, clk);
+	init_clks(pdev, clk);
-	if (ret)
-		return ERR_PTR(ret);
 	for (i = 0; i < num; i++) {
 		struct scp_domain *scpd = &scp->domains[i];

drivers/vhost/vsock.c+14−7

 	return ret;
 }
-static int vhost_vsock_stop(struct vhost_vsock *vsock)
+static int vhost_vsock_stop(struct vhost_vsock *vsock, bool check_owner)
 {
 	size_t i;
-	int ret;
+	int ret = 0;
 	mutex_lock(&vsock->dev.mutex);
-	ret = vhost_dev_check_owner(&vsock->dev);
+	if (check_owner) {
-	if (ret)
+		ret = vhost_dev_check_owner(&vsock->dev);
-		goto err;
+		if (ret)
+			goto err;
+	}
 	for (i = 0; i < ARRAY_SIZE(vsock->vqs); i++) {
 		struct vhost_virtqueue *vq = &vsock->vqs[i];
 	 * inefficient.  Room for improvement here. */
 	vsock_for_each_connected_socket(vhost_vsock_reset_orphans);
-	vhost_vsock_stop(vsock);
+	/* Don't check the owner, because we are in the release path, so we
+	 * need to stop the vsock device in any case.
+	 * vhost_vsock_stop() can not fail in this case, so we don't need to
+	 * check the return code.
+	 */
+	vhost_vsock_stop(vsock, false);
 	vhost_vsock_flush(vsock);
 	vhost_dev_stop(&vsock->dev);
 		if (start)
 			return vhost_vsock_start(vsock);
 		else
-			return vhost_vsock_stop(vsock);
+			return vhost_vsock_stop(vsock, true);
 	case VHOST_GET_FEATURES:
 		features = VHOST_VSOCK_FEATURES;
 		if (copy_to_user(argp, &features, sizeof(features)))

fs/cifs/cifsacl.c+6−3

 		pnntace = (struct cifs_ace *) (nacl_base + nsize);
 		nsize += setup_special_mode_ACE(pnntace, nmode);
 		num_aces++;
+		pnntace = (struct cifs_ace *) (nacl_base + nsize);
+		nsize += setup_authusers_ACE(pnntace);
+		num_aces++;
 		goto set_size;
 	}
 		if (uid_valid(uid)) { /* chown */
 			uid_t id;
-			nowner_sid_ptr = kmalloc(sizeof(struct cifs_sid),
+			nowner_sid_ptr = kzalloc(sizeof(struct cifs_sid),
 								GFP_KERNEL);
 			if (!nowner_sid_ptr) {
 				rc = -ENOMEM;
 		}
 		if (gid_valid(gid)) { /* chgrp */
 			gid_t id;
-			ngroup_sid_ptr = kmalloc(sizeof(struct cifs_sid),
+			ngroup_sid_ptr = kzalloc(sizeof(struct cifs_sid),
 								GFP_KERNEL);
 			if (!ngroup_sid_ptr) {
 				rc = -ENOMEM;
 	nsecdesclen = secdesclen;
 	if (pnmode && *pnmode != NO_CHANGE_64) { /* chmod */
 		if (mode_from_sid)
-			nsecdesclen += sizeof(struct cifs_ace);
+			nsecdesclen += 2 * sizeof(struct cifs_ace);
 		else /* cifsacl */
 			nsecdesclen += 5 * sizeof(struct cifs_ace);
 	} else { /* chown */

fs/cifs/cifsfs.c+1−0

@@ -919,6 +919,7 @@ cifs_smb3_do_mount(struct file_system_type *fs_type, · 918 unmodified lines
919		919
920	out_super:	920	out_super:
921	deactivate_locked_super(sb);	921	deactivate_locked_super(sb);
		922	return root;
922	out:	923	out:
923	if (cifs_sb) {	924	if (cifs_sb) {
924	kfree(cifs_sb->prepath);	925	kfree(cifs_sb->prepath);

fs/cifs/fs_context.c+2−2

@@ -149,7 +149,7 @@ const struct fs_parameter_spec smb3_fs_parameters[] = { · 148 unmodified lines
149	fsparam_u32("echo_interval", Opt_echo_interval),	149	fsparam_u32("echo_interval", Opt_echo_interval),
150	fsparam_u32("max_credits", Opt_max_credits),	150	fsparam_u32("max_credits", Opt_max_credits),
151	fsparam_u32("handletimeout", Opt_handletimeout),	151	fsparam_u32("handletimeout", Opt_handletimeout),
152	fsparam_u32("snapshot", Opt_snapshot),	152	fsparam_u64("snapshot", Opt_snapshot),
153	fsparam_u32("max_channels", Opt_max_channels),	153	fsparam_u32("max_channels", Opt_max_channels),
154		154
155	/* Mount options which take string value */	155	/* Mount options which take string value */
@@ -1078,7 +1078,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc, · 922 unmodified lines
1078	ctx->echo_interval = result.uint_32;	1078	ctx->echo_interval = result.uint_32;
1079	break;	1079	break;
1080	case Opt_snapshot:	1080	case Opt_snapshot:
1081	ctx->snapshot_time = result.uint_32;	1081	ctx->snapshot_time = result.uint_64;
1082	break;	1082	break;
1083	case Opt_max_credits:	1083	case Opt_max_credits:
1084	if (result.uint_32 < 20 \|\| result.uint_32 > 60000) {	1084	if (result.uint_32 < 20 \|\| result.uint_32 > 60000) {

fs/cifs/sess.c+6−5

 	struct cifs_server_iface *ifaces = NULL;
 	size_t iface_count;
-	if (ses->server->dialect < SMB30_PROT_ID) {
-		cifs_dbg(VFS, "multichannel is not supported on this protocol version, use 3.0 or above\n");
-		return 0;
-	}
 	spin_lock(&ses->chan_lock);
 	new_chan_count = old_chan_count = ses->chan_count;
 		return 0;
 	}
+	if (ses->server->dialect < SMB30_PROT_ID) {
+		spin_unlock(&ses->chan_lock);
+		cifs_dbg(VFS, "multichannel is not supported on this protocol version, use 3.0 or above\n");
+		return 0;
+	}
 	if (!(ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
 		ses->chan_max = 1;
 		spin_unlock(&ses->chan_lock);

fs/cifs/xattr.c+2−0

 				switch (handler->flags) {
 				case XATTR_CIFS_NTSD_FULL:
 					aclflags = (CIFS_ACL_OWNER |
+						    CIFS_ACL_GROUP |
 						    CIFS_ACL_DACL |
 						    CIFS_ACL_SACL);
 					break;
 				case XATTR_CIFS_NTSD:
 					aclflags = (CIFS_ACL_OWNER |
+						    CIFS_ACL_GROUP |
 						    CIFS_ACL_DACL);
 					break;
 				case XATTR_CIFS_ACL:

fs/io_uring.c+17−7

 		} else {
 			list_add_tail(&buf->list, &(*head)->list);
 		}
+		cond_resched();
 	}
 	return i ? i : -ENOMEM;
 /* when returns >0, the caller should retry */
 static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx,
 					  struct io_wait_queue *iowq,
-					  signed long *timeout)
+					  ktime_t timeout)
 {
 	int ret;
 	if (test_bit(0, &ctx->check_cq_overflow))
 		return 1;
-	*timeout = schedule_timeout(*timeout);
+	if (!schedule_hrtimeout(&timeout, HRTIMER_MODE_ABS))
-	return !*timeout ? -ETIME : 1;
+		return -ETIME;
+	return 1;
 }
 /*
 {
 	struct io_wait_queue iowq;
 	struct io_rings *rings = ctx->rings;
-	signed long timeout = MAX_SCHEDULE_TIMEOUT;
+	ktime_t timeout = KTIME_MAX;
 	int ret;
 	do {
 		if (get_timespec64(&ts, uts))
 			return -EFAULT;
-		timeout = timespec64_to_jiffies(&ts);
+		timeout = ktime_add_ns(timespec64_to_ktime(ts), ktime_get_ns());
 	}
 	if (sig) {
 		}
 		prepare_to_wait_exclusive(&ctx->cq_wait, &iowq.wq,
 						TASK_INTERRUPTIBLE);
-		ret = io_cqring_wait_schedule(ctx, &iowq, &timeout);
+		ret = io_cqring_wait_schedule(ctx, &iowq, timeout);
 		finish_wait(&ctx->cq_wait, &iowq.wq);
 		cond_resched();
 	} while (ret > 0);
 		ret = wait_for_completion_interruptible(&data->done);
 		if (!ret) {
 			mutex_lock(&ctx->uring_lock);
-			break;
+			if (atomic_read(&data->refs) > 0) {
+				/*
+				 * it has been revived by another thread while
+				 * we were unlocked
+				 */
+				mutex_unlock(&ctx->uring_lock);
+			} else {
+				break;
+			}
 		}
 		atomic_inc(&data->refs);

fs/namespace.c+30−0

@@ -469,6 +469,24 @@ void mnt_drop_write_file(struct file *file) · 468 unmodified lines
469	}	469	}
470	EXPORT_SYMBOL(mnt_drop_write_file);	470	EXPORT_SYMBOL(mnt_drop_write_file);
471		471
		472	/**
		473	* mnt_hold_writers - prevent write access to the given mount
		474	* @mnt: mnt to prevent write access to
		475	*
		476	* Prevents write access to @mnt if there are no active writers for @mnt.
		477	* This function needs to be called and return successfully before changing
		478	* properties of @mnt that need to remain stable for callers with write access
		479	* to @mnt.
		480	*
		481	* After this functions has been called successfully callers must pair it with
		482	* a call to mnt_unhold_writers() in order to stop preventing write access to
		483	* @mnt.
		484	*
		485	* Context: This function expects lock_mount_hash() to be held serializing
		486	* setting MNT_WRITE_HOLD.
		487	* Return: On success 0 is returned.
		488	* On error, -EBUSY is returned.
		489	*/
472	static inline int mnt_hold_writers(struct mount *mnt)	490	static inline int mnt_hold_writers(struct mount *mnt)
473	{	491	{
474	mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD;	492	mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD;
@@ -500,6 +518,18 @@ static inline int mnt_hold_writers(struct mount *mnt) · 25 unmodified lines
500	return 0;	518	return 0;
501	}	519	}
502		520
		521	/**
		522	* mnt_unhold_writers - stop preventing write access to the given mount
		523	* @mnt: mnt to stop preventing write access to
		524	*
		525	* Stop preventing write access to @mnt allowing callers to gain write access
		526	* to @mnt again.
		527	*
		528	* This function can only be called after a successful call to
		529	* mnt_hold_writers().
		530	*
		531	* Context: This function expects lock_mount_hash() to be held.
		532	*/
503	static inline void mnt_unhold_writers(struct mount *mnt)	533	static inline void mnt_unhold_writers(struct mount *mnt)
504	{	534	{
505	/*	535	/*

fs/nfs/dir.c+2−2

@@ -2010,14 +2010,14 @@ no_open: · 2009 unmodified lines
2010	if (!res) {	2010	if (!res) {
2011	inode = d_inode(dentry);	2011	inode = d_inode(dentry);
2012	if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&	2012	if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&
2013	!S_ISDIR(inode->i_mode))	2013	!(S_ISDIR(inode->i_mode) \|\| S_ISLNK(inode->i_mode)))
2014	res = ERR_PTR(-ENOTDIR);	2014	res = ERR_PTR(-ENOTDIR);
2015	else if (inode && S_ISREG(inode->i_mode))	2015	else if (inode && S_ISREG(inode->i_mode))
2016	res = ERR_PTR(-EOPENSTALE);	2016	res = ERR_PTR(-EOPENSTALE);
2017	} else if (!IS_ERR(res)) {	2017	} else if (!IS_ERR(res)) {
2018	inode = d_inode(res);	2018	inode = d_inode(res);
2019	if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&	2019	if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&
2020	!S_ISDIR(inode->i_mode)) {	2020	!(S_ISDIR(inode->i_mode) \|\| S_ISLNK(inode->i_mode))) {
2021	dput(res);	2021	dput(res);
2022	res = ERR_PTR(-ENOTDIR);	2022	res = ERR_PTR(-ENOTDIR);
2023	} else if (inode && S_ISREG(inode->i_mode)) {	2023	} else if (inode && S_ISREG(inode->i_mode)) {

fs/nfs/inode.c+3−6

 	}
 	/* Flush out writes to the server in order to update c/mtime.  */
-	if ((request_mask & (STATX_CTIME|STATX_MTIME)) &&
+	if ((request_mask & (STATX_CTIME | STATX_MTIME)) &&
-			S_ISREG(inode->i_mode)) {
+	    S_ISREG(inode->i_mode))
-		err = filemap_write_and_wait(inode->i_mapping);
+		filemap_write_and_wait(inode->i_mapping);
-		if (err)
-			goto out;
-	}
 	/*
 	 * We may force a getattr if the user cares about atime.

fs/nfs/nfs4proc.c+1−2

 				NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL |
 				NFS_INO_INVALID_SIZE | NFS_INO_INVALID_OTHER |
 				NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_NLINK |
-				NFS_INO_INVALID_MODE | NFS_INO_INVALID_XATTR |
+				NFS_INO_INVALID_MODE | NFS_INO_INVALID_XATTR;
-				NFS_INO_REVAL_PAGECACHE;
 		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
 	}
 	nfsi->attrtimeo_timestamp = jiffies;

include/linux/blkdev.h+2−1

@@ -748,7 +748,8 @@ extern bool blk_queue_can_use_dma_map_merging(struct request_queue *q, · 747 unmodified lines
748		748
749	bool __must_check blk_get_queue(struct request_queue *);	749	bool __must_check blk_get_queue(struct request_queue *);
750	extern void blk_put_queue(struct request_queue *);	750	extern void blk_put_queue(struct request_queue *);
751	extern void blk_set_queue_dying(struct request_queue *);	751
		752	void blk_mark_disk_dead(struct gendisk *disk);
752		753
753	#ifdef CONFIG_BLOCK	754	#ifdef CONFIG_BLOCK
754	/*	755	/*

include/linux/nvme-tcp.h+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#define NVME_TCP_DISC_PORT 8009	12	#define NVME_TCP_DISC_PORT 8009
13	#define NVME_TCP_ADMIN_CCSZ SZ_8K	13	#define NVME_TCP_ADMIN_CCSZ SZ_8K
14	#define NVME_TCP_DIGEST_LENGTH 4	14	#define NVME_TCP_DIGEST_LENGTH 4
		15	#define NVME_TCP_MIN_MAXH2CDATA 4096
15		16
16	enum nvme_tcp_pfv {	17	enum nvme_tcp_pfv {
17	NVME_TCP_PFV_1_0 = 0x0,	18	NVME_TCP_PFV_1_0 = 0x0,

include/linux/sched/task.h+2−2

@@ -54,8 +54,8 @@ extern asmlinkage void schedule_tail(struct task_struct *prev); · 53 unmodified lines
54	extern void init_idle(struct task_struct *idle, int cpu);	54	extern void init_idle(struct task_struct *idle, int cpu);
55		55
56	extern int sched_fork(unsigned long clone_flags, struct task_struct *p);	56	extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
57	extern void sched_post_fork(struct task_struct *p,	57	extern void sched_cgroup_fork(struct task_struct p, struct kernel_clone_args kargs);
58	struct kernel_clone_args *kargs);	58	extern void sched_post_fork(struct task_struct *p);
59	extern void sched_dead(struct task_struct *p);	59	extern void sched_dead(struct task_struct *p);
60		60
61	void __noreturn do_task_dead(void);	61	void __noreturn do_task_dead(void);

include/linux/slab.h+1−2

@@ -660,8 +660,7 @@ static inline __alloc_size(1, 2) void *kcalloc(size_t n, size_t size, gfp_t flag · 659 unmodified lines
660	* allocator where we care about the real place the memory allocation	660	* allocator where we care about the real place the memory allocation
661	* request comes from.	661	* request comes from.
662	*/	662	*/
663	extern void *__kmalloc_track_caller(size_t size, gfp_t flags, unsigned long caller)	663	extern void *__kmalloc_track_caller(size_t size, gfp_t flags, unsigned long caller);
664	__alloc_size(1);
665	#define kmalloc_track_caller(size, flags) \	664	#define kmalloc_track_caller(size, flags) \
666	__kmalloc_track_caller(size, flags, _RET_IP_)	665	__kmalloc_track_caller(size, flags, _RET_IP_)
667		666

include/net/checksum.h+29−23

 #include <asm/checksum.h>
 #ifndef _HAVE_ARCH_COPY_AND_CSUM_FROM_USER
-static inline
+static __always_inline
 __wsum csum_and_copy_from_user (const void __user *src, void *dst,
 				      int len)
 {
 #endif
 #ifndef HAVE_CSUM_COPY_USER
-static __inline__ __wsum csum_and_copy_to_user
+static __always_inline __wsum csum_and_copy_to_user
 (const void *src, void __user *dst, int len)
 {
 	__wsum sum = csum_partial(src, len, ~0U);
 #endif
 #ifndef _HAVE_ARCH_CSUM_AND_COPY
-static inline __wsum
+static __always_inline __wsum
 csum_partial_copy_nocheck(const void *src, void *dst, int len)
 {
 	memcpy(dst, src, len);
 #endif
 #ifndef HAVE_ARCH_CSUM_ADD
-static inline __wsum csum_add(__wsum csum, __wsum addend)
+static __always_inline __wsum csum_add(__wsum csum, __wsum addend)
 {
 	u32 res = (__force u32)csum;
 	res += (__force u32)addend;
 }
 #endif
-static inline __wsum csum_sub(__wsum csum, __wsum addend)
+static __always_inline __wsum csum_sub(__wsum csum, __wsum addend)
 {
 	return csum_add(csum, ~addend);
 }
-static inline __sum16 csum16_add(__sum16 csum, __be16 addend)
+static __always_inline __sum16 csum16_add(__sum16 csum, __be16 addend)
 {
 	u16 res = (__force u16)csum;
 	return (__force __sum16)(res + (res < (__force u16)addend));
 }
-static inline __sum16 csum16_sub(__sum16 csum, __be16 addend)
+static __always_inline __sum16 csum16_sub(__sum16 csum, __be16 addend)
 {
 	return csum16_add(csum, ~addend);
 }
-static inline __wsum csum_shift(__wsum sum, int offset)
+static __always_inline __wsum csum_shift(__wsum sum, int offset)
 {
 	/* rotate sum to align it with a 16b boundary */
 	if (offset & 1)
 	return sum;
 }
-static inline __wsum
+static __always_inline __wsum
 csum_block_add(__wsum csum, __wsum csum2, int offset)
 {
 	return csum_add(csum, csum_shift(csum2, offset));
 }
-static inline __wsum
+static __always_inline __wsum
 csum_block_add_ext(__wsum csum, __wsum csum2, int offset, int len)
 {
 	return csum_block_add(csum, csum2, offset);
 }
-static inline __wsum
+static __always_inline __wsum
 csum_block_sub(__wsum csum, __wsum csum2, int offset)
 {
 	return csum_block_add(csum, ~csum2, offset);
 }
-static inline __wsum csum_unfold(__sum16 n)
+static __always_inline __wsum csum_unfold(__sum16 n)
 {
 	return (__force __wsum)n;
 }
-static inline __wsum csum_partial_ext(const void *buff, int len, __wsum sum)
+static __always_inline
+__wsum csum_partial_ext(const void *buff, int len, __wsum sum)
 {
 	return csum_partial(buff, len, sum);
 }
 #define CSUM_MANGLED_0 ((__force __sum16)0xffff)
-static inline void csum_replace_by_diff(__sum16 *sum, __wsum diff)
+static __always_inline void csum_replace_by_diff(__sum16 *sum, __wsum diff)
 {
 	*sum = csum_fold(csum_add(diff, ~csum_unfold(*sum)));
 }
-static inline void csum_replace4(__sum16 *sum, __be32 from, __be32 to)
+static __always_inline void csum_replace4(__sum16 *sum, __be32 from, __be32 to)
 {
 	__wsum tmp = csum_sub(~csum_unfold(*sum), (__force __wsum)from);
  *  m : old value of a 16bit field
  *  m' : new value of a 16bit field
  */
-static inline void csum_replace2(__sum16 *sum, __be16 old, __be16 new)
+static __always_inline void csum_replace2(__sum16 *sum, __be16 old, __be16 new)
 {
 	*sum = ~csum16_add(csum16_sub(~(*sum), old), new);
 }
+static inline void csum_replace(__wsum *csum, __wsum old, __wsum new)
+{
+	*csum = csum_add(csum_sub(*csum, old), new);
+}
 struct sk_buff;
 void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
 			      __be32 from, __be32 to, bool pseudohdr);
 void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb,
 				     __wsum diff, bool pseudohdr);
-static inline void inet_proto_csum_replace2(__sum16 *sum, struct sk_buff *skb,
+static __always_inline
-					    __be16 from, __be16 to,
+void inet_proto_csum_replace2(__sum16 *sum, struct sk_buff *skb,
-					    bool pseudohdr)
+			      __be16 from, __be16 to, bool pseudohdr)
 {
 	inet_proto_csum_replace4(sum, skb, (__force __be32)from,
 				 (__force __be32)to, pseudohdr);
 }
-static inline __wsum remcsum_adjust(void *ptr, __wsum csum,
+static __always_inline __wsum remcsum_adjust(void *ptr, __wsum csum,
-				    int start, int offset)
+					     int start, int offset)
 {
 	__sum16 *psum = (__sum16 *)(ptr + offset);
 	__wsum delta;
 	return delta;
 }
-static inline void remcsum_unadjust(__sum16 *psum, __wsum delta)
+static __always_inline void remcsum_unadjust(__sum16 *psum, __wsum delta)
 {
 	*psum = csum_fold(csum_sub(delta, (__force __wsum)*psum));
 }
-static inline __wsum wsum_negate(__wsum val)
+static __always_inline __wsum wsum_negate(__wsum val)
 {
 	return (__force __wsum)-((__force u32)val);
 }

include/net/netfilter/nf_tables.h+1−1

 	int				(*offload)(struct nft_offload_ctx *ctx,
 						   struct nft_flow_rule *flow,
 						   const struct nft_expr *expr);
+	bool				(*offload_action)(const struct nft_expr *expr);
 	void				(*offload_stats)(struct nft_expr *expr,
 							 const struct flow_stats *stats);
-	u32				offload_flags;
 	const struct nft_expr_type	*type;
 	void				*data;
 };

include/net/netfilter/nf_tables_offload.h+0−2

@@ -67,8 +67,6 @@ struct nft_flow_rule { · 66 unmodified lines
67	struct flow_rule *rule;	67	struct flow_rule *rule;
68	};	68	};
69		69
70	#define NFT_OFFLOAD_F_ACTION (1 << 0)
71
72	void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow,	70	void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow,
73	enum flow_dissector_key_id addr_type);	71	enum flow_dissector_key_id addr_type);
74		72

include/net/sock.h+2−2

@@ -509,7 +509,7 @@ struct sock { · 508 unmodified lines
509	#endif	509	#endif
510	u16 sk_tsflags;	510	u16 sk_tsflags;
511	u8 sk_shutdown;	511	u8 sk_shutdown;
512	u32 sk_tskey;	512	atomic_t sk_tskey;
513	atomic_t sk_zckey;	513	atomic_t sk_zckey;
514		514
515	u8 sk_clockid;	515	u8 sk_clockid;
@@ -2681,7 +2681,7 @@ static inline void _sock_tx_timestamp(struct sock *sk, __u16 tsflags, · 2165 unmodified lines
2681	__sock_tx_timestamp(tsflags, tx_flags);	2681	__sock_tx_timestamp(tsflags, tx_flags);
2682	if (tsflags & SOF_TIMESTAMPING_OPT_ID && tskey &&	2682	if (tsflags & SOF_TIMESTAMPING_OPT_ID && tskey &&
2683	tsflags & SOF_TIMESTAMPING_TX_RECORD_MASK)	2683	tsflags & SOF_TIMESTAMPING_TX_RECORD_MASK)
2684	*tskey = sk->sk_tskey++;	2684	*tskey = atomic_inc_return(&sk->sk_tskey) - 1;
2685	}	2685	}
2686	if (unlikely(sock_flag(sk, SOCK_WIFI_STATUS)))	2686	if (unlikely(sock_flag(sk, SOCK_WIFI_STATUS)))
2687	*tx_flags \|= SKBTX_WIFI_STATUS;	2687	*tx_flags \|= SKBTX_WIFI_STATUS;

kernel/cgroup/cgroup-v1.c+4−2

 					  char *buf, size_t nbytes, loff_t off)
 {
 	struct cgroup *cgrp;
+	struct cgroup_file_ctx *ctx;
 	BUILD_BUG_ON(sizeof(cgrp->root->release_agent_path) < PATH_MAX);
 	 * Release agent gets called with all capabilities,
 	 * require capabilities to set release agent.
 	 */
-	if ((of->file->f_cred->user_ns != &init_user_ns) ||
+	ctx = of->priv;
-	    !capable(CAP_SYS_ADMIN))
+	if ((ctx->ns->user_ns != &init_user_ns) ||
+	    !file_ns_capable(of->file, &init_user_ns, CAP_SYS_ADMIN))
 		return -EPERM;
 	cgrp = cgroup_kn_lock_live(of->kn, false);

kernel/cgroup/cgroup.c+14−0

@@ -6166,6 +6166,20 @@ static int cgroup_css_set_fork(struct kernel_clone_args *kargs) · 6165 unmodified lines
6166	if (ret)	6166	if (ret)
6167	goto err;	6167	goto err;
6168		6168
		6169	/*
		6170	* Spawning a task directly into a cgroup works by passing a file
		6171	* descriptor to the target cgroup directory. This can even be an O_PATH
		6172	* file descriptor. But it can never be a cgroup.procs file descriptor.
		6173	* This was done on purpose so spawning into a cgroup could be
		6174	* conceptualized as an atomic
		6175	*
		6176	* fd = openat(dfd_cgroup, "cgroup.procs", ...);
		6177	* write(fd, <child-pid>, ...);
		6178	*
		6179	* sequence, i.e. it's a shorthand for the caller opening and writing
		6180	* cgroup.procs of the cgroup indicated by @dfd_cgroup. This allows us
		6181	* to always use the caller's credentials.
		6182	*/
6169	ret = cgroup_attach_permissions(cset->dfl_cgrp, dst_cgrp, sb,	6183	ret = cgroup_attach_permissions(cset->dfl_cgrp, dst_cgrp, sb,
6170	!(kargs->flags & CLONE_THREAD),	6184	!(kargs->flags & CLONE_THREAD),
6171	current->nsproxy->cgroup_ns);	6185	current->nsproxy->cgroup_ns);

kernel/cgroup/cpuset.c+7−5

 	cgroup_taskset_first(tset, &css);
 	cs = css_cs(css);
+	cpus_read_lock();
 	percpu_down_write(&cpuset_rwsem);
 	guarantee_online_mems(cs, &cpuset_attach_nodemask_to);
 		wake_up(&cpuset_attach_wq);
 	percpu_up_write(&cpuset_rwsem);
+	cpus_read_unlock();
 }
 /* The various types of files and directories in a cpuset file system */
 	return cs;
 }
-/**
+/*
- * cpuset_node_allowed - Can we allocate on a memory node?
+ * __cpuset_node_allowed - Can we allocate on a memory node?
  * @node: is this an allowed node?
  * @gfp_mask: memory allocation flags
  *
 int cpuset_memory_pressure_enabled __read_mostly;
-/**
+/*
- * cpuset_memory_pressure_bump - keep stats of per-cpuset reclaims.
+ * __cpuset_memory_pressure_bump - keep stats of per-cpuset reclaims.
  *
  * Keep a running average of the rate of synchronous (direct)
  * page reclaim efforts initiated by tasks in each cpuset.
  * "memory_pressure".  Value displayed is an integer
  * representing the recent rate of entry into the synchronous
  * (direct) page reclaim by any task attached to the cpuset.
- **/
+ */
 void __cpuset_memory_pressure_bump(void)
 {

kernel/cred.c+2−7

 int set_cred_ucounts(struct cred *new)
 {
-	struct task_struct *task = current;
-	const struct cred *old = task->real_cred;
 	struct ucounts *new_ucounts, *old_ucounts = new->ucounts;
-	if (new->user == old->user && new->user_ns == old->user_ns)
-		return 0;
 	/*
 	 * This optimization is needed because alloc_ucounts() uses locks
 	 * for table lookups.
 	 */
-	if (old_ucounts->ns == new->user_ns && uid_eq(old_ucounts->uid, new->euid))
+	if (old_ucounts->ns == new->user_ns && uid_eq(old_ucounts->uid, new->uid))
 		return 0;
-	if (!(new_ucounts = alloc_ucounts(new->user_ns, new->euid)))
+	if (!(new_ucounts = alloc_ucounts(new->user_ns, new->uid)))
 		return -EAGAIN;
 	new->ucounts = new_ucounts;

kernel/fork.c+20−10

 #ifdef CONFIG_PROVE_LOCKING
 	DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
 #endif
+	retval = copy_creds(p, clone_flags);
+	if (retval < 0)
+		goto bad_fork_free;
 	retval = -EAGAIN;
 	if (is_ucounts_overlimit(task_ucounts(p), UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC))) {
 		if (p->real_cred->user != INIT_USER &&
 		    !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
-			goto bad_fork_free;
+			goto bad_fork_cleanup_count;
 	}
 	current->flags &= ~PF_NPROC_EXCEEDED;
-	retval = copy_creds(p, clone_flags);
-	if (retval < 0)
-		goto bad_fork_free;
 	/*
 	 * If multiple threads are within copy_process(), then this check
 	 * triggers too late. This doesn't hurt, the check is only there
 	if (retval)
 		goto bad_fork_put_pidfd;
+	/*
+	 * Now that the cgroups are pinned, re-clone the parent cgroup and put
+	 * the new task on the correct runqueue. All this *before* the task
+	 * becomes visible.
+	 *
+	 * This isn't part of ->can_fork() because while the re-cloning is
+	 * cgroup specific, it unconditionally needs to place the task on a
+	 * runqueue.
+	 */
+	sched_cgroup_fork(p, args);
 	/*
 	 * From this point on we must avoid any synchronous user-space
 	 * communication until we take the tasklist-lock. In particular, we do
 		goto bad_fork_cancel_cgroup;
 	}
-	/* past the last point of failure */
-	if (pidfile)
-		fd_install(pidfd, pidfile);
 	init_task_pid_links(p);
 	if (likely(p->pid)) {
 		ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);
 	syscall_tracepoint_update(p);
 	write_unlock_irq(&tasklist_lock);
+	if (pidfile)
+		fd_install(pidfd, pidfile);
 	proc_fork_connector(p);
-	sched_post_fork(p, args);
+	sched_post_fork(p);
 	cgroup_post_fork(p, args);
 	perf_event_fork(p);

kernel/locking/lockdep.c+2−2

@@ -3462,7 +3462,7 @@ struct lock_class lock_chain_get_class(struct lock_chain chain, int i) · 3461 unmodified lines
3462	u16 chain_hlock = chain_hlocks[chain->base + i];	3462	u16 chain_hlock = chain_hlocks[chain->base + i];
3463	unsigned int class_idx = chain_hlock_class_idx(chain_hlock);	3463	unsigned int class_idx = chain_hlock_class_idx(chain_hlock);
3464		3464
3465	return lock_classes + class_idx - 1;	3465	return lock_classes + class_idx;
3466	}	3466	}
3467		3467
3468	/*	3468	/*
@@ -3530,7 +3530,7 @@ static void print_chain_keys_chain(struct lock_chain *chain) · 61 unmodified lines
3530	hlock_id = chain_hlocks[chain->base + i];	3530	hlock_id = chain_hlocks[chain->base + i];
3531	chain_key = print_chain_key_iteration(hlock_id, chain_key);	3531	chain_key = print_chain_key_iteration(hlock_id, chain_key);
3532		3532
3533	print_lock_name(lock_classes + chain_hlock_class_idx(hlock_id) - 1);	3533	print_lock_name(lock_classes + chain_hlock_class_idx(hlock_id));
3534	printk("\n");	3534	printk("\n");
3535	}	3535	}
3536	}	3536	}

kernel/sched/core.c+21−13

 }
 #endif
-static void set_load_weight(struct task_struct *p)
+static void set_load_weight(struct task_struct *p, bool update_load)
 {
-	bool update_load = !(READ_ONCE(p->__state) & TASK_NEW);
 	int prio = p->static_prio - MAX_RT_PRIO;
 	struct load_weight *load = &p->se.load;
 			p->static_prio = NICE_TO_PRIO(0);
 		p->prio = p->normal_prio = p->static_prio;
-		set_load_weight(p);
+		set_load_weight(p, false);
 		/*
 		 * We don't need the reset flag anymore after the fork. It has
 	init_entity_runnable_average(&p->se);
 #ifdef CONFIG_SCHED_INFO
 	if (likely(sched_info_on()))
 		memset(&p->sched_info, 0, sizeof(p->sched_info));
 	return 0;
 }
-void sched_post_fork(struct task_struct *p, struct kernel_clone_args *kargs)
+void sched_cgroup_fork(struct task_struct *p, struct kernel_clone_args *kargs)
 {
 	unsigned long flags;
-#ifdef CONFIG_CGROUP_SCHED
-	struct task_group *tg;
-#endif
+	/*
+	 * Because we're not yet on the pid-hash, p->pi_lock isn't strictly
+	 * required yet, but lockdep gets upset if rules are violated.
+	 */
 	raw_spin_lock_irqsave(&p->pi_lock, flags);
 #ifdef CONFIG_CGROUP_SCHED
-	tg = container_of(kargs->cset->subsys[cpu_cgrp_id],
+	if (1) {
-			  struct task_group, css);
+		struct task_group *tg;
-	p->sched_task_group = autogroup_task_group(p, tg);
+		tg = container_of(kargs->cset->subsys[cpu_cgrp_id],
+				  struct task_group, css);
+		tg = autogroup_task_group(p, tg);
+		p->sched_task_group = tg;
+	}
 #endif
 	rseq_migrate(p);
 	/*
 	if (p->sched_class->task_fork)
 		p->sched_class->task_fork(p);
 	raw_spin_unlock_irqrestore(&p->pi_lock, flags);
+}
+void sched_post_fork(struct task_struct *p)
+{
 	uclamp_post_fork(p);
 }
 		put_prev_task(rq, p);
 	p->static_prio = NICE_TO_PRIO(nice);
-	set_load_weight(p);
+	set_load_weight(p, true);
 	old_prio = p->prio;
 	p->prio = effective_prio(p);
 	 */
 	p->rt_priority = attr->sched_priority;
 	p->normal_prio = normal_prio(p);
-	set_load_weight(p);
+	set_load_weight(p, true);
 }
 /*
 #endif
 	}
-	set_load_weight(&init_task);
+	set_load_weight(&init_task, false);
 	/*
 	 * The boot idle thread does lazy MMU switching as well:

kernel/sys.c+14−6

 	if (!new_user)
 		return -EAGAIN;
+	free_uid(new->user);
+	new->user = new_user;
+	return 0;
+}
+static void flag_nproc_exceeded(struct cred *new)
+{
+	if (new->ucounts == current_ucounts())
+		return;
 	/*
 	 * We don't fail in case of NPROC limit excess here because too many
 	 * poorly written programs don't check set*uid() return code, assuming
 	 * failure to the execve() stage.
 	 */
 	if (is_ucounts_overlimit(new->ucounts, UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC)) &&
-			new_user != INIT_USER &&
+			new->user != INIT_USER)
-			!capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
 		current->flags |= PF_NPROC_EXCEEDED;
 	else
 		current->flags &= ~PF_NPROC_EXCEEDED;
-	free_uid(new->user);
-	new->user = new_user;
-	return 0;
 }
 /*
 	if (retval < 0)
 		goto error;
+	flag_nproc_exceeded(new);
 	return commit_creds(new);
 error:
 	if (retval < 0)
 		goto error;
+	flag_nproc_exceeded(new);
 	return commit_creds(new);
 error:
 	if (retval < 0)
 		goto error;
+	flag_nproc_exceeded(new);
 	return commit_creds(new);
 error:

kernel/ucount.c+2−1

 	if (rlimit > LONG_MAX)
 		max = LONG_MAX;
 	for (iter = ucounts; iter; iter = iter->ns->ucounts) {
-		if (get_ucounts_value(iter, type) > max)
+		long val = get_ucounts_value(iter, type);
+		if (val < 0 || val > max)
 			return true;
 		max = READ_ONCE(iter->ns->ucount_max[type]);
 	}

lib/iov_iter.c+2−0

 		return 0;
 	buf->ops = &page_cache_pipe_buf_ops;
+	buf->flags = 0;
 	get_page(page);
 	buf->page = page;
 	buf->offset = offset;
 			break;
 		buf->ops = &default_pipe_buf_ops;
+		buf->flags = 0;
 		buf->page = page;
 		buf->offset = 0;
 		buf->len = min_t(ssize_t, left, PAGE_SIZE);

net/can/j1939/transport.c+1−1

@@ -2006,7 +2006,7 @@ struct j1939_session j1939_tp_send(struct j1939_priv priv, · 2005 unmodified lines
2006	/* set the end-packet for broadcast */	2006	/* set the end-packet for broadcast */
2007	session->pkt.last = session->pkt.total;	2007	session->pkt.last = session->pkt.total;
2008		2008
2009	skcb->tskey = session->sk->sk_tskey++;	2009	skcb->tskey = atomic_inc_return(&session->sk->sk_tskey) - 1;
2010	session->tskey = skcb->tskey;	2010	session->tskey = skcb->tskey;
2011		2011
2012	return session;	2012	return session;

net/core/net-sysfs.c+1−1

@@ -213,7 +213,7 @@ static ssize_t speed_show(struct device *dev, · 212 unmodified lines
213	if (!rtnl_trylock())	213	if (!rtnl_trylock())
214	return restart_syscall();	214	return restart_syscall();
215		215
216	if (netif_running(netdev)) {	216	if (netif_running(netdev) && netif_device_present(netdev)) {
217	struct ethtool_link_ksettings cmd;	217	struct ethtool_link_ksettings cmd;
218		218
219	if (!__ethtool_get_link_ksettings(netdev, &cmd))	219	if (!__ethtool_get_link_ksettings(netdev, &cmd))

net/core/skbuff.c+3−3

@@ -2307,7 +2307,7 @@ void __pskb_pull_tail(struct sk_buff skb, int delta) · 2306 unmodified lines
2307	/* Free pulled out fragments. */	2307	/* Free pulled out fragments. */
2308	while ((list = skb_shinfo(skb)->frag_list) != insp) {	2308	while ((list = skb_shinfo(skb)->frag_list) != insp) {
2309	skb_shinfo(skb)->frag_list = list->next;	2309	skb_shinfo(skb)->frag_list = list->next;
2310	kfree_skb(list);	2310	consume_skb(list);
2311	}	2311	}
2312	/* And insert new clone at head. */	2312	/* And insert new clone at head. */
2313	if (clone) {	2313	if (clone) {
@@ -4761,7 +4761,7 @@ static void __skb_complete_tx_timestamp(struct sk_buff *skb, · 2447 unmodified lines
4761	if (sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID) {	4761	if (sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID) {
4762	serr->ee.ee_data = skb_shinfo(skb)->tskey;	4762	serr->ee.ee_data = skb_shinfo(skb)->tskey;
4763	if (sk_is_tcp(sk))	4763	if (sk_is_tcp(sk))
4764	serr->ee.ee_data -= sk->sk_tskey;	4764	serr->ee.ee_data -= atomic_read(&sk->sk_tskey);
4765	}	4765	}
4766		4766
4767	err = sock_queue_err_skb(sk, skb);	4767	err = sock_queue_err_skb(sk, skb);
@@ -6132,7 +6132,7 @@ static int pskb_carve_frag_list(struct sk_buff *skb, · 1364 unmodified lines
6132	/* Free pulled out fragments. */	6132	/* Free pulled out fragments. */
6133	while ((list = shinfo->frag_list) != insp) {	6133	while ((list = shinfo->frag_list) != insp) {
6134	shinfo->frag_list = list->next;	6134	shinfo->frag_list = list->next;
6135	kfree_skb(list);	6135	consume_skb(list);
6136	}	6136	}
6137	/* And insert new clone at head. */	6137	/* And insert new clone at head. */
6138	if (clone) {	6138	if (clone) {

net/core/sock.c+2−2

@@ -879,9 +879,9 @@ int sock_set_timestamping(struct sock *sk, int optname, · 878 unmodified lines
879	if ((1 << sk->sk_state) &	879	if ((1 << sk->sk_state) &
880	(TCPF_CLOSE \| TCPF_LISTEN))	880	(TCPF_CLOSE \| TCPF_LISTEN))
881	return -EINVAL;	881	return -EINVAL;
882	sk->sk_tskey = tcp_sk(sk)->snd_una;	882	atomic_set(&sk->sk_tskey, tcp_sk(sk)->snd_una);
883	} else {	883	} else {
884	sk->sk_tskey = 0;	884	atomic_set(&sk->sk_tskey, 0);
885	}	885	}
886	}	886	}
887		887

net/dsa/master.c+6−1

 	dev->dsa_ptr->netdev_ops = ops;
 }
+/* Keep the master always promiscuous if the tagging protocol requires that
+ * (garbles MAC DA) or if it doesn't support unicast filtering, case in which
+ * it would revert to promiscuous mode as soon as we call dev_uc_add() on it
+ * anyway.
+ */
 static void dsa_master_set_promiscuity(struct net_device *dev, int inc)
 {
 	const struct dsa_device_ops *ops = dev->dsa_ptr->tag_ops;
-	if (!ops->promisc_on_master)
+	if ((dev->priv_flags & IFF_UNICAST_FLT) && !ops->promisc_on_master)
 		return;
 	ASSERT_RTNL();

net/dsa/port.c+22−7

 		.tree_index = dp->ds->dst->index,
 		.sw_index = dp->ds->index,
 		.port = dp->index,
-		.bridge = *dp->bridge,
 	};
 	int err;
+	/* If the port could not be offloaded to begin with, then
+	 * there is nothing to do.
+	 */
+	if (!dp->bridge)
+		return;
+	info.bridge = *dp->bridge;
 	/* Here the port is already unbridged. Reflect the current configuration
 	 * so that drivers can program their chips accordingly.
 	 */
 	struct dsa_port *cpu_dp = dp->cpu_dp;
 	int err;
-	err = dev_uc_add(cpu_dp->master, addr);
+	/* Avoid a call to __dev_set_promiscuity() on the master, which
-	if (err)
+	 * requires rtnl_lock(), since we can't guarantee that is held here,
-		return err;
+	 * and we can't take it either.
+	 */
+	if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
+		err = dev_uc_add(cpu_dp->master, addr);
+		if (err)
+			return err;
+	}
 	return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
 }
 	struct dsa_port *cpu_dp = dp->cpu_dp;
 	int err;
-	err = dev_uc_del(cpu_dp->master, addr);
+	if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
-	if (err)
+		err = dev_uc_del(cpu_dp->master, addr);
-		return err;
+		if (err)
+			return err;
+	}
 	return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
 }

net/ipv4/af_inet.c+4−1

 	}
 	ops = rcu_dereference(inet_offloads[proto]);
-	if (likely(ops && ops->callbacks.gso_segment))
+	if (likely(ops && ops->callbacks.gso_segment)) {
 		segs = ops->callbacks.gso_segment(skb, features);
+		if (!segs)
+			skb->network_header = skb_mac_header(skb) + nhoff - skb->head;
+	}
 	if (IS_ERR_OR_NULL(segs))
 		goto out;

net/ipv4/ip_output.c+1−1

@@ -991,7 +991,7 @@ static int __ip_append_data(struct sock *sk, · 990 unmodified lines
991		991
992	if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&	992	if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
993	sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)	993	sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
994	tskey = sk->sk_tskey++;	994	tskey = atomic_inc_return(&sk->sk_tskey) - 1;
995		995
996	hh_len = LL_RESERVED_SPACE(rt->dst.dev);	996	hh_len = LL_RESERVED_SPACE(rt->dst.dev);
997		997

net/ipv4/ping.c+0−1

@@ -187,7 +187,6 @@ static struct sock ping_lookup(struct net net, struct sk_buff *skb, u16 ident) · 186 unmodified lines
187	(int)ident, &ipv6_hdr(skb)->daddr, dif);	187	(int)ident, &ipv6_hdr(skb)->daddr, dif);
188	#endif	188	#endif
189	} else {	189	} else {
190	pr_err("ping: protocol(%x) is not supported\n", ntohs(skb->protocol));
191	return NULL;	190	return NULL;
192	}	191	}
193		192

net/ipv4/udp_tunnel_nic.c+1−1

@@ -846,7 +846,7 @@ udp_tunnel_nic_unregister(struct net_device dev, struct udp_tunnel_nic utn) · 845 unmodified lines
846	list_for_each_entry(node, &info->shared->devices, list)	846	list_for_each_entry(node, &info->shared->devices, list)
847	if (node->dev == dev)	847	if (node->dev == dev)
848	break;	848	break;
849	if (node->dev != dev)	849	if (list_entry_is_head(node, &info->shared->devices, list))
850	return;	850	return;
851		851
852	list_del(&node->list);	852	list_del(&node->list);

net/ipv6/addrconf.c+2−0

 	    nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
 		goto error;
+	spin_lock_bh(&ifa->lock);
 	if (!((ifa->flags&IFA_F_PERMANENT) &&
 	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
 		preferred = ifa->prefered_lft;
 		preferred = INFINITY_LIFE_TIME;
 		valid = INFINITY_LIFE_TIME;
 	}
+	spin_unlock_bh(&ifa->lock);
 	if (!ipv6_addr_any(&ifa->peer_addr)) {
 		if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||

net/ipv6/ip6_offload.c+2−0

@@ -114,6 +114,8 @@ static struct sk_buff ipv6_gso_segment(struct sk_buff skb, · 113 unmodified lines
114	if (likely(ops && ops->callbacks.gso_segment)) {	114	if (likely(ops && ops->callbacks.gso_segment)) {
115	skb_reset_transport_header(skb);	115	skb_reset_transport_header(skb);
116	segs = ops->callbacks.gso_segment(skb, features);	116	segs = ops->callbacks.gso_segment(skb, features);
		117	if (!segs)
		118	skb->network_header = skb_mac_header(skb) + nhoff - skb->head;
117	}	119	}
118		120
119	if (IS_ERR_OR_NULL(segs))	121	if (IS_ERR_OR_NULL(segs))

net/ipv6/ip6_output.c+1−1

@@ -1464,7 +1464,7 @@ static int __ip6_append_data(struct sock *sk, · 1463 unmodified lines
1464		1464
1465	if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&	1465	if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
1466	sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)	1466	sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
1467	tskey = sk->sk_tskey++;	1467	tskey = atomic_inc_return(&sk->sk_tskey) - 1;
1468		1468
1469	hh_len = LL_RESERVED_SPACE(rt->dst.dev);	1469	hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1470		1470

net/mptcp/mib.c+2−0

 	SNMP_MIB_ITEM("AddAddr", MPTCP_MIB_ADDADDR),
 	SNMP_MIB_ITEM("EchoAdd", MPTCP_MIB_ECHOADD),
 	SNMP_MIB_ITEM("PortAdd", MPTCP_MIB_PORTADD),
+	SNMP_MIB_ITEM("AddAddrDrop", MPTCP_MIB_ADDADDRDROP),
 	SNMP_MIB_ITEM("MPJoinPortSynRx", MPTCP_MIB_JOINPORTSYNRX),
 	SNMP_MIB_ITEM("MPJoinPortSynAckRx", MPTCP_MIB_JOINPORTSYNACKRX),
 	SNMP_MIB_ITEM("MPJoinPortAckRx", MPTCP_MIB_JOINPORTACKRX),
 	SNMP_MIB_ITEM("MismatchPortSynRx", MPTCP_MIB_MISMATCHPORTSYNRX),
 	SNMP_MIB_ITEM("MismatchPortAckRx", MPTCP_MIB_MISMATCHPORTACKRX),
 	SNMP_MIB_ITEM("RmAddr", MPTCP_MIB_RMADDR),
+	SNMP_MIB_ITEM("RmAddrDrop", MPTCP_MIB_RMADDRDROP),
 	SNMP_MIB_ITEM("RmSubflow", MPTCP_MIB_RMSUBFLOW),
 	SNMP_MIB_ITEM("MPPrioTx", MPTCP_MIB_MPPRIOTX),
 	SNMP_MIB_ITEM("MPPrioRx", MPTCP_MIB_MPPRIORX),

net/mptcp/mib.h+2−0

 	MPTCP_MIB_ADDADDR,		/* Received ADD_ADDR with echo-flag=0 */
 	MPTCP_MIB_ECHOADD,		/* Received ADD_ADDR with echo-flag=1 */
 	MPTCP_MIB_PORTADD,		/* Received ADD_ADDR with a port-number */
+	MPTCP_MIB_ADDADDRDROP,		/* Dropped incoming ADD_ADDR */
 	MPTCP_MIB_JOINPORTSYNRX,	/* Received a SYN MP_JOIN with a different port-number */
 	MPTCP_MIB_JOINPORTSYNACKRX,	/* Received a SYNACK MP_JOIN with a different port-number */
 	MPTCP_MIB_JOINPORTACKRX,	/* Received an ACK MP_JOIN with a different port-number */
 	MPTCP_MIB_MISMATCHPORTSYNRX,	/* Received a SYN MP_JOIN with a mismatched port-number */
 	MPTCP_MIB_MISMATCHPORTACKRX,	/* Received an ACK MP_JOIN with a mismatched port-number */
 	MPTCP_MIB_RMADDR,		/* Received RM_ADDR */
+	MPTCP_MIB_RMADDRDROP,		/* Dropped incoming RM_ADDR */
 	MPTCP_MIB_RMSUBFLOW,		/* Remove a subflow */
 	MPTCP_MIB_MPPRIOTX,		/* Transmit a MP_PRIO */
 	MPTCP_MIB_MPPRIORX,		/* Received a MP_PRIO */

net/mptcp/pm.c+6−2

 		mptcp_pm_add_addr_send_ack(msk);
 	} else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
 		pm->remote = *addr;
+	} else {
+		__MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_ADDADDRDROP);
 	}
 	spin_unlock_bh(&pm->lock);
 		mptcp_event_addr_removed(msk, rm_list->ids[i]);
 	spin_lock_bh(&pm->lock);
-	mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED);
+	if (mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED))
-	pm->rm_list_rx = *rm_list;
+		pm->rm_list_rx = *rm_list;
+	else
+		__MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_RMADDRDROP);
 	spin_unlock_bh(&pm->lock);
 }

net/mptcp/pm_netlink.c+24−5

 	if (msk->pm.add_addr_signaled < add_addr_signal_max) {
 		local = select_signal_address(pernet, msk);
+		/* due to racing events on both ends we can reach here while
+		 * previous add address is still running: if we invoke now
+		 * mptcp_pm_announce_addr(), that will fail and the
+		 * corresponding id will be marked as used.
+		 * Instead let the PM machinery reschedule us when the
+		 * current address announce will be completed.
+		 */
+		if (msk->pm.addr_signal & BIT(MPTCP_ADD_ADDR_SIGNAL))
+			return;
 		if (local) {
 			if (mptcp_pm_alloc_anno_list(msk, local)) {
 				__clear_bit(local->addr.id, msk->pm.id_avail_bitmap);
 	unsigned int add_addr_accept_max;
 	struct mptcp_addr_info remote;
 	unsigned int subflows_max;
+	bool reset_port = false;
 	int i, nr;
 	add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
 		 msk->pm.add_addr_accepted, add_addr_accept_max,
 		 msk->pm.remote.family);
-	if (lookup_subflow_by_daddr(&msk->conn_list, &msk->pm.remote))
+	remote = msk->pm.remote;
+	if (lookup_subflow_by_daddr(&msk->conn_list, &remote))
 		goto add_addr_echo;
+	/* pick id 0 port, if none is provided the remote address */
+	if (!remote.port) {
+		reset_port = true;
+		remote.port = sk->sk_dport;
+	}
 	/* connect to the specified remote address, using whatever
 	 * local address the routing configuration will pick.
 	 */
-	remote = msk->pm.remote;
-	if (!remote.port)
-		remote.port = sk->sk_dport;
 	nr = fill_local_addresses_vec(msk, addrs);
 	msk->pm.add_addr_accepted++;
 		__mptcp_subflow_connect(sk, &addrs[i], &remote);
 	spin_lock_bh(&msk->pm.lock);
+	/* be sure to echo exactly the received address */
+	if (reset_port)
+		remote.port = 0;
 add_addr_echo:
-	mptcp_pm_announce_addr(msk, &msk->pm.remote, true);
+	mptcp_pm_announce_addr(msk, &remote, true);
 	mptcp_pm_nl_addr_send_ack(msk);
 }

net/netfilter/nf_tables_api.c+12−4

 {
 	struct nft_object *newobj;
 	struct nft_trans *trans;
-	int err;
+	int err = -ENOMEM;
+	if (!try_module_get(type->owner))
+		return -ENOENT;
 	trans = nft_trans_alloc(ctx, NFT_MSG_NEWOBJ,
 				sizeof(struct nft_trans_obj));
 	if (!trans)
-		return -ENOMEM;
+		goto err_trans;
 	newobj = nft_obj_init(ctx, type, attr);
 	if (IS_ERR(newobj)) {
 err_free_trans:
 	kfree(trans);
+err_trans:
+	module_put(type->owner);
 	return err;
 }
 	if (obj->ops->update)
 		obj->ops->update(obj, newobj);
-	kfree(newobj);
+	nft_obj_destroy(&trans->ctx, newobj);
 }
 static void nft_commit_release(struct nft_trans *trans)
 			break;
 		case NFT_MSG_NEWOBJ:
 			if (nft_trans_obj_update(trans)) {
-				kfree(nft_trans_obj_newobj(trans));
+				nft_obj_destroy(&trans->ctx, nft_trans_obj_newobj(trans));
 				nft_trans_destroy(trans);
 			} else {
 				trans->ctx.table->use--;
 static void __nft_release_hook(struct net *net, struct nft_table *table)
 {
+	struct nft_flowtable *flowtable;
 	struct nft_chain *chain;
 	list_for_each_entry(chain, &table->chains, list)
 		nf_tables_unregister_hook(net, table, chain);
+	list_for_each_entry(flowtable, &table->flowtables, list)
+		nft_unregister_flowtable_net_hooks(net, &flowtable->hook_list);
 }
 static void __nft_release_hooks(struct net *net)

net/netfilter/nf_tables_offload.c+2−1

@@ -94,7 +94,8 @@ struct nft_flow_rule nft_flow_rule_create(struct net net, · 93 unmodified lines
94		94
95	expr = nft_expr_first(rule);	95	expr = nft_expr_first(rule);
96	while (nft_expr_more(rule, expr)) {	96	while (nft_expr_more(rule, expr)) {
97	if (expr->ops->offload_flags & NFT_OFFLOAD_F_ACTION)	97	if (expr->ops->offload_action &&
		98	expr->ops->offload_action(expr))
98	num_actions++;	99	num_actions++;
99		100
100	expr = nft_expr_next(expr);	101	expr = nft_expr_next(expr);

net/netfilter/nft_dup_netdev.c+6−0

 	return nft_fwd_dup_netdev_offload(ctx, flow, FLOW_ACTION_MIRRED, oif);
 }
+static bool nft_dup_netdev_offload_action(const struct nft_expr *expr)
+{
+	return true;
+}
 static struct nft_expr_type nft_dup_netdev_type;
 static const struct nft_expr_ops nft_dup_netdev_ops = {
 	.type		= &nft_dup_netdev_type,
 	.init		= nft_dup_netdev_init,
 	.dump		= nft_dup_netdev_dump,
 	.offload	= nft_dup_netdev_offload,
+	.offload_action	= nft_dup_netdev_offload_action,
 };
 static struct nft_expr_type nft_dup_netdev_type __read_mostly = {

net/netfilter/nft_fwd_netdev.c+6−0

 	return nft_fwd_dup_netdev_offload(ctx, flow, FLOW_ACTION_REDIRECT, oif);
 }
+static bool nft_fwd_netdev_offload_action(const struct nft_expr *expr)
+{
+	return true;
+}
 struct nft_fwd_neigh {
 	u8			sreg_dev;
 	u8			sreg_addr;
 	.dump		= nft_fwd_netdev_dump,
 	.validate	= nft_fwd_validate,
 	.offload	= nft_fwd_netdev_offload,
+	.offload_action	= nft_fwd_netdev_offload_action,
 };
 static const struct nft_expr_ops *

net/netfilter/nft_immediate.c+11−1

 	return 0;
 }
+static bool nft_immediate_offload_action(const struct nft_expr *expr)
+{
+	const struct nft_immediate_expr *priv = nft_expr_priv(expr);
+	if (priv->dreg == NFT_REG_VERDICT)
+		return true;
+	return false;
+}
 static const struct nft_expr_ops nft_imm_ops = {
 	.type		= &nft_imm_type,
 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_immediate_expr)),
 	.dump		= nft_immediate_dump,
 	.validate	= nft_immediate_validate,
 	.offload	= nft_immediate_offload,
-	.offload_flags	= NFT_OFFLOAD_F_ACTION,
+	.offload_action	= nft_immediate_offload_action,
 };
 struct nft_expr_type nft_imm_type __read_mostly = {

net/netfilter/nft_limit.c+18−0

 	return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);
 }
+static void nft_limit_obj_pkts_destroy(const struct nft_ctx *ctx,
+				       struct nft_object *obj)
+{
+	struct nft_limit_priv_pkts *priv = nft_obj_data(obj);
+	nft_limit_destroy(ctx, &priv->limit);
+}
 static struct nft_object_type nft_limit_obj_type;
 static const struct nft_object_ops nft_limit_obj_pkts_ops = {
 	.type		= &nft_limit_obj_type,
 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_limit_priv_pkts)),
 	.init		= nft_limit_obj_pkts_init,
+	.destroy	= nft_limit_obj_pkts_destroy,
 	.eval		= nft_limit_obj_pkts_eval,
 	.dump		= nft_limit_obj_pkts_dump,
 };
 	return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
 }
+static void nft_limit_obj_bytes_destroy(const struct nft_ctx *ctx,
+					struct nft_object *obj)
+{
+	struct nft_limit_priv *priv = nft_obj_data(obj);
+	nft_limit_destroy(ctx, priv);
+}
 static struct nft_object_type nft_limit_obj_type;
 static const struct nft_object_ops nft_limit_obj_bytes_ops = {
 	.type		= &nft_limit_obj_type,
 	.size		= sizeof(struct nft_limit_priv),
 	.init		= nft_limit_obj_bytes_init,
+	.destroy	= nft_limit_obj_bytes_destroy,
 	.eval		= nft_limit_obj_bytes_eval,
 	.dump		= nft_limit_obj_bytes_dump,
 };

net/netfilter/xt_socket.c+2−0

 {
 	if (par->family == NFPROTO_IPV4)
 		nf_defrag_ipv4_disable(par->net);
+#if IS_ENABLED(CONFIG_IP6_NF_IPTABLES)
 	else if (par->family == NFPROTO_IPV6)
 		nf_defrag_ipv6_disable(par->net);
+#endif
 }
 static struct xt_match socket_mt_reg[] __read_mostly = {

net/openvswitch/actions.c+38−8

@@ -423,12 +423,43 @@ static void set_ipv6_addr(struct sk_buff *skb, u8 l4_proto, · 422 unmodified lines
423	memcpy(addr, new_addr, sizeof(__be32[4]));	423	memcpy(addr, new_addr, sizeof(__be32[4]));
424	}	424	}
425		425
426	static void set_ipv6_fl(struct ipv6hdr *nh, u32 fl, u32 mask)	426	static void set_ipv6_dsfield(struct sk_buff skb, struct ipv6hdr nh, u8 ipv6_tclass, u8 mask)
427	{	427	{
		428	u8 old_ipv6_tclass = ipv6_get_dsfield(nh);
		429
		430	ipv6_tclass = OVS_MASKED(old_ipv6_tclass, ipv6_tclass, mask);
		431
		432	if (skb->ip_summed == CHECKSUM_COMPLETE)
		433	csum_replace(&skb->csum, (__force __wsum)(old_ipv6_tclass << 12),
		434	(__force __wsum)(ipv6_tclass << 12));
		435
		436	ipv6_change_dsfield(nh, ~mask, ipv6_tclass);
		437	}
		438
		439	static void set_ipv6_fl(struct sk_buff skb, struct ipv6hdr nh, u32 fl, u32 mask)
		440	{
		441	u32 ofl;
		442
		443	ofl = nh->flow_lbl[0] << 16 \| nh->flow_lbl[1] << 8 \| nh->flow_lbl[2];
		444	fl = OVS_MASKED(ofl, fl, mask);
		445
428	/* Bits 21-24 are always unmasked, so this retains their values. */	446	/* Bits 21-24 are always unmasked, so this retains their values. */
429	OVS_SET_MASKED(nh->flow_lbl[0], (u8)(fl >> 16), (u8)(mask >> 16));	447	nh->flow_lbl[0] = (u8)(fl >> 16);
430	OVS_SET_MASKED(nh->flow_lbl[1], (u8)(fl >> 8), (u8)(mask >> 8));	448	nh->flow_lbl[1] = (u8)(fl >> 8);
431	OVS_SET_MASKED(nh->flow_lbl[2], (u8)fl, (u8)mask);	449	nh->flow_lbl[2] = (u8)fl;
		450
		451	if (skb->ip_summed == CHECKSUM_COMPLETE)
		452	csum_replace(&skb->csum, (__force __wsum)htonl(ofl), (__force __wsum)htonl(fl));
		453	}
		454
		455	static void set_ipv6_ttl(struct sk_buff skb, struct ipv6hdr nh, u8 new_ttl, u8 mask)
		456	{
		457	new_ttl = OVS_MASKED(nh->hop_limit, new_ttl, mask);
		458
		459	if (skb->ip_summed == CHECKSUM_COMPLETE)
		460	csum_replace(&skb->csum, (__force __wsum)(nh->hop_limit << 8),
		461	(__force __wsum)(new_ttl << 8));
		462	nh->hop_limit = new_ttl;
432	}	463	}
433		464
434	static void set_ip_ttl(struct sk_buff skb, struct iphdr nh, u8 new_ttl,	465	static void set_ip_ttl(struct sk_buff skb, struct iphdr nh, u8 new_ttl,
@@ -546,18 +577,17 @@ static int set_ipv6(struct sk_buff skb, struct sw_flow_key flow_key, · 111 unmodified lines
546	}	577	}
547	}	578	}
548	if (mask->ipv6_tclass) {	579	if (mask->ipv6_tclass) {
549	ipv6_change_dsfield(nh, ~mask->ipv6_tclass, key->ipv6_tclass);	580	set_ipv6_dsfield(skb, nh, key->ipv6_tclass, mask->ipv6_tclass);
550	flow_key->ip.tos = ipv6_get_dsfield(nh);	581	flow_key->ip.tos = ipv6_get_dsfield(nh);
551	}	582	}
552	if (mask->ipv6_label) {	583	if (mask->ipv6_label) {
553	set_ipv6_fl(nh, ntohl(key->ipv6_label),	584	set_ipv6_fl(skb, nh, ntohl(key->ipv6_label),
554	ntohl(mask->ipv6_label));	585	ntohl(mask->ipv6_label));
555	flow_key->ipv6.label =	586	flow_key->ipv6.label =
556	(__be32 )nh & htonl(IPV6_FLOWINFO_FLOWLABEL);	587	(__be32 )nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
557	}	588	}
558	if (mask->ipv6_hlimit) {	589	if (mask->ipv6_hlimit) {
559	OVS_SET_MASKED(nh->hop_limit, key->ipv6_hlimit,	590	set_ipv6_ttl(skb, nh, key->ipv6_hlimit, mask->ipv6_hlimit);
560	mask->ipv6_hlimit);
561	flow_key->ip.ttl = nh->hop_limit;	591	flow_key->ip.ttl = nh->hop_limit;
562	}	592	}
563	return 0;	593	return 0;

net/sched/act_api.c+1−1

@@ -274,7 +274,7 @@ static int tcf_action_offload_add_ex(struct tc_action *action, · 273 unmodified lines
274	err = tc_setup_action(&fl_action->action, actions);	274	err = tc_setup_action(&fl_action->action, actions);
275	if (err) {	275	if (err) {
276	NL_SET_ERR_MSG_MOD(extack,	276	NL_SET_ERR_MSG_MOD(extack,
277	"Failed to setup tc actions for offload\n");	277	"Failed to setup tc actions for offload");
278	goto fl_err;	278	goto fl_err;
279	}	279	}
280		280

net/sched/act_ct.c+0−5

 	struct nf_conn *ct;
 	u8 dir;
-	/* Previously seen or loopback */
-	ct = nf_ct_get(skb, &ctinfo);
-	if ((ct && !nf_ct_is_template(ct)) || ctinfo == IP_CT_UNTRACKED)
-		return false;
 	switch (family) {
 	case NFPROTO_IPV4:
 		if (!tcf_ct_flow_table_fill_tuple_ipv4(skb, &tuple, &tcph))

net/smc/smc_pnet.c+21−21

@@ -113,7 +113,7 @@ static int smc_pnet_remove_by_pnetid(struct net net, char pnet_name) · 112 unmodified lines
113	pnettable = &sn->pnettable;	113	pnettable = &sn->pnettable;
114		114
115	/* remove table entry */	115	/* remove table entry */
116	write_lock(&pnettable->lock);	116	mutex_lock(&pnettable->lock);
117	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist,	117	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist,
118	list) {	118	list) {
119	if (!pnet_name \|\|	119	if (!pnet_name \|\|
@@ -131,7 +131,7 @@ static int smc_pnet_remove_by_pnetid(struct net net, char pnet_name) · 11 unmodified lines
131	rc = 0;	131	rc = 0;
132	}	132	}
133	}	133	}
134	write_unlock(&pnettable->lock);	134	mutex_unlock(&pnettable->lock);
135		135
136	/* if this is not the initial namespace, stop here */	136	/* if this is not the initial namespace, stop here */
137	if (net != &init_net)	137	if (net != &init_net)
@@ -192,7 +192,7 @@ static int smc_pnet_add_by_ndev(struct net_device *ndev) · 54 unmodified lines
192	sn = net_generic(net, smc_net_id);	192	sn = net_generic(net, smc_net_id);
193	pnettable = &sn->pnettable;	193	pnettable = &sn->pnettable;
194		194
195	write_lock(&pnettable->lock);	195	mutex_lock(&pnettable->lock);
196	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist, list) {	196	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist, list) {
197	if (pnetelem->type == SMC_PNET_ETH && !pnetelem->ndev &&	197	if (pnetelem->type == SMC_PNET_ETH && !pnetelem->ndev &&
198	!strncmp(pnetelem->eth_name, ndev->name, IFNAMSIZ)) {	198	!strncmp(pnetelem->eth_name, ndev->name, IFNAMSIZ)) {
@@ -206,7 +206,7 @@ static int smc_pnet_add_by_ndev(struct net_device *ndev) · 7 unmodified lines
206	break;	206	break;
207	}	207	}
208	}	208	}
209	write_unlock(&pnettable->lock);	209	mutex_unlock(&pnettable->lock);
210	return rc;	210	return rc;
211	}	211	}
212		212
@@ -224,7 +224,7 @@ static int smc_pnet_remove_by_ndev(struct net_device *ndev) · 11 unmodified lines
224	sn = net_generic(net, smc_net_id);	224	sn = net_generic(net, smc_net_id);
225	pnettable = &sn->pnettable;	225	pnettable = &sn->pnettable;
226		226
227	write_lock(&pnettable->lock);	227	mutex_lock(&pnettable->lock);
228	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist, list) {	228	list_for_each_entry_safe(pnetelem, tmp_pe, &pnettable->pnetlist, list) {
229	if (pnetelem->type == SMC_PNET_ETH && pnetelem->ndev == ndev) {	229	if (pnetelem->type == SMC_PNET_ETH && pnetelem->ndev == ndev) {
230	dev_put_track(pnetelem->ndev, &pnetelem->dev_tracker);	230	dev_put_track(pnetelem->ndev, &pnetelem->dev_tracker);
@@ -237,7 +237,7 @@ static int smc_pnet_remove_by_ndev(struct net_device *ndev) · 6 unmodified lines
237	break;	237	break;
238	}	238	}
239	}	239	}
240	write_unlock(&pnettable->lock);	240	mutex_unlock(&pnettable->lock);
241	return rc;	241	return rc;
242	}	242	}
243		243
@@ -370,7 +370,7 @@ static int smc_pnet_add_eth(struct smc_pnettable pnettable, struct net net, · 126 unmodified lines
370	strncpy(new_pe->eth_name, eth_name, IFNAMSIZ);	370	strncpy(new_pe->eth_name, eth_name, IFNAMSIZ);
371	rc = -EEXIST;	371	rc = -EEXIST;
372	new_netdev = true;	372	new_netdev = true;
373	write_lock(&pnettable->lock);	373	mutex_lock(&pnettable->lock);
374	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {	374	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {
375	if (tmp_pe->type == SMC_PNET_ETH &&	375	if (tmp_pe->type == SMC_PNET_ETH &&
376	!strncmp(tmp_pe->eth_name, eth_name, IFNAMSIZ)) {	376	!strncmp(tmp_pe->eth_name, eth_name, IFNAMSIZ)) {
@@ -385,9 +385,9 @@ static int smc_pnet_add_eth(struct smc_pnettable pnettable, struct net net, · 8 unmodified lines
385	GFP_ATOMIC);	385	GFP_ATOMIC);
386	}	386	}
387	list_add_tail(&new_pe->list, &pnettable->pnetlist);	387	list_add_tail(&new_pe->list, &pnettable->pnetlist);
388	write_unlock(&pnettable->lock);	388	mutex_unlock(&pnettable->lock);
389	} else {	389	} else {
390	write_unlock(&pnettable->lock);	390	mutex_unlock(&pnettable->lock);
391	kfree(new_pe);	391	kfree(new_pe);
392	goto out_put;	392	goto out_put;
393	}	393	}
@@ -448,7 +448,7 @@ static int smc_pnet_add_ib(struct smc_pnettable pnettable, char ib_name, · 54 unmodified lines
448	new_pe->ib_port = ib_port;	448	new_pe->ib_port = ib_port;
449		449
450	new_ibdev = true;	450	new_ibdev = true;
451	write_lock(&pnettable->lock);	451	mutex_lock(&pnettable->lock);
452	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {	452	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {
453	if (tmp_pe->type == SMC_PNET_IB &&	453	if (tmp_pe->type == SMC_PNET_IB &&
454	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX)) {	454	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX)) {
@@ -458,9 +458,9 @@ static int smc_pnet_add_ib(struct smc_pnettable pnettable, char ib_name, · 3 unmodified lines
458	}	458	}
459	if (new_ibdev) {	459	if (new_ibdev) {
460	list_add_tail(&new_pe->list, &pnettable->pnetlist);	460	list_add_tail(&new_pe->list, &pnettable->pnetlist);
461	write_unlock(&pnettable->lock);	461	mutex_unlock(&pnettable->lock);
462	} else {	462	} else {
463	write_unlock(&pnettable->lock);	463	mutex_unlock(&pnettable->lock);
464	kfree(new_pe);	464	kfree(new_pe);
465	}	465	}
466	return (new_ibdev) ? 0 : -EEXIST;	466	return (new_ibdev) ? 0 : -EEXIST;
@@ -605,7 +605,7 @@ static int _smc_pnet_dump(struct net net, struct sk_buff skb, u32 portid, · 138 unmodified lines
605	pnettable = &sn->pnettable;	605	pnettable = &sn->pnettable;
606		606
607	/* dump pnettable entries */	607	/* dump pnettable entries */
608	read_lock(&pnettable->lock);	608	mutex_lock(&pnettable->lock);
609	list_for_each_entry(pnetelem, &pnettable->pnetlist, list) {	609	list_for_each_entry(pnetelem, &pnettable->pnetlist, list) {
610	if (pnetid && !smc_pnet_match(pnetelem->pnet_name, pnetid))	610	if (pnetid && !smc_pnet_match(pnetelem->pnet_name, pnetid))
611	continue;	611	continue;
@@ -620,7 +620,7 @@ static int _smc_pnet_dump(struct net net, struct sk_buff skb, u32 portid, · 8 unmodified lines
620	break;	620	break;
621	}	621	}
622	}	622	}
623	read_unlock(&pnettable->lock);	623	mutex_unlock(&pnettable->lock);
624	return idx;	624	return idx;
625	}	625	}
626		626
@@ -864,7 +864,7 @@ int smc_pnet_net_init(struct net *net) · 237 unmodified lines
864	struct smc_pnetids_ndev *pnetids_ndev = &sn->pnetids_ndev;	864	struct smc_pnetids_ndev *pnetids_ndev = &sn->pnetids_ndev;
865		865
866	INIT_LIST_HEAD(&pnettable->pnetlist);	866	INIT_LIST_HEAD(&pnettable->pnetlist);
867	rwlock_init(&pnettable->lock);	867	mutex_init(&pnettable->lock);
868	INIT_LIST_HEAD(&pnetids_ndev->list);	868	INIT_LIST_HEAD(&pnetids_ndev->list);
869	rwlock_init(&pnetids_ndev->lock);	869	rwlock_init(&pnetids_ndev->lock);
870		870
@@ -947,7 +947,7 @@ static int smc_pnet_find_ndev_pnetid_by_table(struct net_device *ndev, · 76 unmodified lines
947	sn = net_generic(net, smc_net_id);	947	sn = net_generic(net, smc_net_id);
948	pnettable = &sn->pnettable;	948	pnettable = &sn->pnettable;
949		949
950	read_lock(&pnettable->lock);	950	mutex_lock(&pnettable->lock);
951	list_for_each_entry(pnetelem, &pnettable->pnetlist, list) {	951	list_for_each_entry(pnetelem, &pnettable->pnetlist, list) {
952	if (pnetelem->type == SMC_PNET_ETH && ndev == pnetelem->ndev) {	952	if (pnetelem->type == SMC_PNET_ETH && ndev == pnetelem->ndev) {
953	/* get pnetid of netdev device */	953	/* get pnetid of netdev device */
@@ -956,7 +956,7 @@ static int smc_pnet_find_ndev_pnetid_by_table(struct net_device *ndev, · 2 unmodified lines
956	break;	956	break;
957	}	957	}
958	}	958	}
959	read_unlock(&pnettable->lock);	959	mutex_unlock(&pnettable->lock);
960	return rc;	960	return rc;
961	}	961	}
962		962
@@ -1159,7 +1159,7 @@ int smc_pnetid_by_table_ib(struct smc_ib_device *smcibdev, u8 ib_port) · 196 unmodified lines
1159	sn = net_generic(&init_net, smc_net_id);	1159	sn = net_generic(&init_net, smc_net_id);
1160	pnettable = &sn->pnettable;	1160	pnettable = &sn->pnettable;
1161		1161
1162	read_lock(&pnettable->lock);	1162	mutex_lock(&pnettable->lock);
1163	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {	1163	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {
1164	if (tmp_pe->type == SMC_PNET_IB &&	1164	if (tmp_pe->type == SMC_PNET_IB &&
1165	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX) &&	1165	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX) &&
@@ -1169,7 +1169,7 @@ int smc_pnetid_by_table_ib(struct smc_ib_device *smcibdev, u8 ib_port) · 3 unmodified lines
1169	break;	1169	break;
1170	}	1170	}
1171	}	1171	}
1172	read_unlock(&pnettable->lock);	1172	mutex_unlock(&pnettable->lock);
1173		1173
1174	return rc;	1174	return rc;
1175	}	1175	}
@@ -1188,7 +1188,7 @@ int smc_pnetid_by_table_smcd(struct smcd_dev *smcddev) · 12 unmodified lines
1188	sn = net_generic(&init_net, smc_net_id);	1188	sn = net_generic(&init_net, smc_net_id);
1189	pnettable = &sn->pnettable;	1189	pnettable = &sn->pnettable;
1190		1190
1191	read_lock(&pnettable->lock);	1191	mutex_lock(&pnettable->lock);
1192	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {	1192	list_for_each_entry(tmp_pe, &pnettable->pnetlist, list) {
1193	if (tmp_pe->type == SMC_PNET_IB &&	1193	if (tmp_pe->type == SMC_PNET_IB &&
1194	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX)) {	1194	!strncmp(tmp_pe->ib_name, ib_name, IB_DEVICE_NAME_MAX)) {
@@ -1197,7 +1197,7 @@ int smc_pnetid_by_table_smcd(struct smcd_dev *smcddev) · 2 unmodified lines
1197	break;	1197	break;
1198	}	1198	}
1199	}	1199	}
1200	read_unlock(&pnettable->lock);	1200	mutex_unlock(&pnettable->lock);
1201		1201
1202	return rc;	1202	return rc;
1203	}	1203	}

net/smc/smc_pnet.h+1−1

@@ -29,7 +29,7 @@ struct smc_link_group; · 28 unmodified lines
29	* @pnetlist: List of PNETIDs	29	* @pnetlist: List of PNETIDs
30	*/	30	*/
31	struct smc_pnettable {	31	struct smc_pnettable {
32	rwlock_t lock;	32	struct mutex lock;
33	struct list_head pnetlist;	33	struct list_head pnetlist;
34	};	34	};
35		35

net/tipc/name_table.c+1−1

@@ -967,7 +967,7 @@ static int __tipc_nl_add_nametable_publ(struct tipc_nl_msg *msg, · 966 unmodified lines
967	list_for_each_entry(p, &sr->all_publ, all_publ)	967	list_for_each_entry(p, &sr->all_publ, all_publ)
968	if (p->key == *last_key)	968	if (p->key == *last_key)
969	break;	969	break;
970	if (p->key != *last_key)	970	if (list_entry_is_head(p, &sr->all_publ, all_publ))
971	return -EPIPE;	971	return -EPIPE;
972	} else {	972	} else {
973	p = list_first_entry(&sr->all_publ,	973	p = list_first_entry(&sr->all_publ,

net/tipc/socket.c+1−1

@@ -3749,7 +3749,7 @@ static int __tipc_nl_list_sk_publ(struct sk_buff *skb, · 3748 unmodified lines
3749	if (p->key == *last_publ)	3749	if (p->key == *last_publ)
3750	break;	3750	break;
3751	}	3751	}
3752	if (p->key != *last_publ) {	3752	if (list_entry_is_head(p, &tsk->publications, binding_sock)) {
3753	/* We never set seq or call nl_dump_check_consistent()	3753	/* We never set seq or call nl_dump_check_consistent()
3754	* this means that setting prev_seq here will cause the	3754	* this means that setting prev_seq here will cause the
3755	* consistence check to fail in the netlink callback	3755	* consistence check to fail in the netlink callback

security/selinux/ima.c+2−2

@@ -77,7 +77,7 @@ void selinux_ima_measure_state_locked(struct selinux_state *state) · 76 unmodified lines
77	size_t policy_len;	77	size_t policy_len;
78	int rc = 0;	78	int rc = 0;
79		79
80	WARN_ON(!mutex_is_locked(&state->policy_mutex));	80	lockdep_assert_held(&state->policy_mutex);
81		81
82	state_str = selinux_ima_collect_state(state);	82	state_str = selinux_ima_collect_state(state);
83	if (!state_str) {	83	if (!state_str) {
@@ -117,7 +117,7 @@ void selinux_ima_measure_state_locked(struct selinux_state *state) · 33 unmodified lines
117	*/	117	*/
118	void selinux_ima_measure_state(struct selinux_state *state)	118	void selinux_ima_measure_state(struct selinux_state *state)
119	{	119	{
120	WARN_ON(mutex_is_locked(&state->policy_mutex));	120	lockdep_assert_not_held(&state->policy_mutex);
121		121
122	mutex_lock(&state->policy_mutex);	122	mutex_lock(&state->policy_mutex);
123	selinux_ima_measure_state_locked(state);	123	selinux_ima_measure_state_locked(state);

sound/core/memalloc.c+10−5

@@ -511,7 +511,8 @@ static void snd_dma_noncontig_alloc(struct snd_dma_buffer dmab, size_t size) · 510 unmodified lines
511	DEFAULT_GFP, 0);	511	DEFAULT_GFP, 0);
512	if (!sgt)	512	if (!sgt)
513	return NULL;	513	return NULL;
514	dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->dev.dir);	514	dmab->dev.need_sync = dma_need_sync(dmab->dev.dev,
		515	sg_dma_address(sgt->sgl));
515	p = dma_vmap_noncontiguous(dmab->dev.dev, size, sgt);	516	p = dma_vmap_noncontiguous(dmab->dev.dev, size, sgt);
516	if (p)	517	if (p)
517	dmab->private_data = sgt;	518	dmab->private_data = sgt;
@@ -540,9 +541,9 @@ static void snd_dma_noncontig_sync(struct snd_dma_buffer *dmab, · 22 unmodified lines
540	if (mode == SNDRV_DMA_SYNC_CPU) {	541	if (mode == SNDRV_DMA_SYNC_CPU) {
541	if (dmab->dev.dir == DMA_TO_DEVICE)	542	if (dmab->dev.dir == DMA_TO_DEVICE)
542	return;	543	return;
		544	invalidate_kernel_vmap_range(dmab->area, dmab->bytes);
543	dma_sync_sgtable_for_cpu(dmab->dev.dev, dmab->private_data,	545	dma_sync_sgtable_for_cpu(dmab->dev.dev, dmab->private_data,
544	dmab->dev.dir);	546	dmab->dev.dir);
545	invalidate_kernel_vmap_range(dmab->area, dmab->bytes);
546	} else {	547	} else {
547	if (dmab->dev.dir == DMA_FROM_DEVICE)	548	if (dmab->dev.dir == DMA_FROM_DEVICE)
548	return;	549	return;
@@ -671,9 +672,13 @@ static const struct snd_malloc_ops snd_dma_sg_wc_ops = { · 122 unmodified lines
671	*/	672	*/
672	static void snd_dma_noncoherent_alloc(struct snd_dma_buffer dmab, size_t size)	673	static void snd_dma_noncoherent_alloc(struct snd_dma_buffer dmab, size_t size)
673	{	674	{
674	dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->dev.dir);	675	void *p;
675	return dma_alloc_noncoherent(dmab->dev.dev, size, &dmab->addr,	676
676	dmab->dev.dir, DEFAULT_GFP);	677	p = dma_alloc_noncoherent(dmab->dev.dev, size, &dmab->addr,
		678	dmab->dev.dir, DEFAULT_GFP);
		679	if (p)
		680	dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->addr);
		681	return p;
677	}	682	}
678		683
679	static void snd_dma_noncoherent_free(struct snd_dma_buffer *dmab)	684	static void snd_dma_noncoherent_free(struct snd_dma_buffer *dmab)

sound/pci/hda/hda_intel.c+4−2

 	/* forced codec slots */
 	SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
 	SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
+	SND_PCI_QUIRK(0x1558, 0x0351, "Schenker Dock 15", 0x105),
 	/* WinFast VP200 H (Teradici) user reported broken communication */
 	SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
 	{}
 	assign_position_fix(chip, check_position_fix(chip, position_fix[dev]));
-	check_probe_mask(chip, dev);
 	if (single_cmd < 0) /* allow fallback to single_cmd at errors */
 		chip->fallback_to_single_cmd = 1;
 	else /* explicitly set to single_cmd or not */
 		chip->bus.core.needs_damn_long_delay = 1;
 	}
+	check_probe_mask(chip, dev);
 	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
 	if (err < 0) {
 		dev_err(card->dev, "Error creating device [card]!\n");
 		dma_bits = 32;
 	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(dma_bits)))
 		dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32));
+	dma_set_max_seg_size(&pci->dev, UINT_MAX);
 	/* read number of streams from GCAP register instead of using
 	 * hardcoded value

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

  * COEF access helper functions
  */
+static void coef_mutex_lock(struct hda_codec *codec)
+{
+	struct alc_spec *spec = codec->spec;
+	snd_hda_power_up_pm(codec);
+	mutex_lock(&spec->coef_mutex);
+}
+static void coef_mutex_unlock(struct hda_codec *codec)
+{
+	struct alc_spec *spec = codec->spec;
+	mutex_unlock(&spec->coef_mutex);
+	snd_hda_power_down_pm(codec);
+}
 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 				 unsigned int coef_idx)
 {
 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 			       unsigned int coef_idx)
 {
-	struct alc_spec *spec = codec->spec;
 	unsigned int val;
-	mutex_lock(&spec->coef_mutex);
+	coef_mutex_lock(codec);
 	val = __alc_read_coefex_idx(codec, nid, coef_idx);
-	mutex_unlock(&spec->coef_mutex);
+	coef_mutex_unlock(codec);
 	return val;
 }
 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 				 unsigned int coef_idx, unsigned int coef_val)
 {
-	struct alc_spec *spec = codec->spec;
+	coef_mutex_lock(codec);
-	mutex_lock(&spec->coef_mutex);
 	__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
-	mutex_unlock(&spec->coef_mutex);
+	coef_mutex_unlock(codec);
 }
 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 				  unsigned int coef_idx, unsigned int mask,
 				  unsigned int bits_set)
 {
-	struct alc_spec *spec = codec->spec;
+	coef_mutex_lock(codec);
-	mutex_lock(&spec->coef_mutex);
 	__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
-	mutex_unlock(&spec->coef_mutex);
+	coef_mutex_unlock(codec);
 }
 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
 static void alc_process_coef_fw(struct hda_codec *codec,
 				const struct coef_fw *fw)
 {
-	struct alc_spec *spec = codec->spec;
+	coef_mutex_lock(codec);
-	mutex_lock(&spec->coef_mutex);
 	for (; fw->nid; fw++) {
 		if (fw->mask == (unsigned short)-1)
 			__alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 			__alc_update_coefex_idx(codec, fw->nid, fw->idx,
 						fw->mask, fw->val);
 	}
-	mutex_unlock(&spec->coef_mutex);
+	coef_mutex_unlock(codec);
 }
 /*
 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+	SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
 	SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
 	SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
 	SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),

sound/soc/amd/acp/acp-mach.h+0−1

@@ -21,7 +21,6 @@ · 20 unmodified lines
21	#include <linux/gpio/consumer.h>	21	#include <linux/gpio/consumer.h>
22		22
23	#define EN_SPKR_GPIO_GB 0x11F	23	#define EN_SPKR_GPIO_GB 0x11F
24	#define EN_SPKR_GPIO_NK 0x146
25	#define EN_SPKR_GPIO_NONE -EINVAL	24	#define EN_SPKR_GPIO_NONE -EINVAL
26		25
27	enum be_id {	26	enum be_id {

sound/soc/amd/acp/acp-sof-mach.c+2−2

@@ -37,7 +37,7 @@ static struct acp_card_drvdata sof_rt5682_max_data = { · 36 unmodified lines
37	.hs_codec_id = RT5682,	37	.hs_codec_id = RT5682,
38	.amp_codec_id = MAX98360A,	38	.amp_codec_id = MAX98360A,
39	.dmic_codec_id = DMIC,	39	.dmic_codec_id = DMIC,
40	.gpio_spkr_en = EN_SPKR_GPIO_NK,	40	.gpio_spkr_en = EN_SPKR_GPIO_NONE,
41	};	41	};
42		42
43	static struct acp_card_drvdata sof_rt5682s_max_data = {	43	static struct acp_card_drvdata sof_rt5682s_max_data = {
@@ -47,7 +47,7 @@ static struct acp_card_drvdata sof_rt5682s_max_data = { · 3 unmodified lines
47	.hs_codec_id = RT5682S,	47	.hs_codec_id = RT5682S,
48	.amp_codec_id = MAX98360A,	48	.amp_codec_id = MAX98360A,
49	.dmic_codec_id = DMIC,	49	.dmic_codec_id = DMIC,
50	.gpio_spkr_en = EN_SPKR_GPIO_NK,	50	.gpio_spkr_en = EN_SPKR_GPIO_NONE,
51	};	51	};
52		52
53	static const struct snd_kcontrol_new acp_controls[] = {	53	static const struct snd_kcontrol_new acp_controls[] = {

sound/soc/codecs/rt5668.c+7−5

@@ -1022,11 +1022,13 @@ static void rt5668_jack_detect_handler(struct work_struct *work) · 1021 unmodified lines
1022	container_of(work, struct rt5668_priv, jack_detect_work.work);	1022	container_of(work, struct rt5668_priv, jack_detect_work.work);
1023	int val, btn_type;	1023	int val, btn_type;
1024		1024
1025	while (!rt5668->component)	1025	if (!rt5668->component \|\| !rt5668->component->card \|\|
1026	usleep_range(10000, 15000);	1026	!rt5668->component->card->instantiated) {
1027		1027	/* card not yet ready, try later */
1028	while (!rt5668->component->card->instantiated)	1028	mod_delayed_work(system_power_efficient_wq,
1029	usleep_range(10000, 15000);	1029	&rt5668->jack_detect_work, msecs_to_jiffies(15));
		1030	return;
		1031	}
1030		1032
1031	mutex_lock(&rt5668->calibrate_mutex);	1033	mutex_lock(&rt5668->calibrate_mutex);
1032		1034

sound/soc/codecs/rt5682.c+7−5

@@ -1092,11 +1092,13 @@ void rt5682_jack_detect_handler(struct work_struct *work) · 1091 unmodified lines
1092	struct snd_soc_dapm_context *dapm;	1092	struct snd_soc_dapm_context *dapm;
1093	int val, btn_type;	1093	int val, btn_type;
1094		1094
1095	while (!rt5682->component)	1095	if (!rt5682->component \|\| !rt5682->component->card \|\|
1096	usleep_range(10000, 15000);	1096	!rt5682->component->card->instantiated) {
1097		1097	/* card not yet ready, try later */
1098	while (!rt5682->component->card->instantiated)	1098	mod_delayed_work(system_power_efficient_wq,
1099	usleep_range(10000, 15000);	1099	&rt5682->jack_detect_work, msecs_to_jiffies(15));
		1100	return;
		1101	}
1100		1102
1101	dapm = snd_soc_component_get_dapm(rt5682->component);	1103	dapm = snd_soc_component_get_dapm(rt5682->component);
1102		1104

sound/soc/codecs/rt5682s.c+7−5

@@ -824,11 +824,13 @@ static void rt5682s_jack_detect_handler(struct work_struct *work) · 823 unmodified lines
824	container_of(work, struct rt5682s_priv, jack_detect_work.work);	824	container_of(work, struct rt5682s_priv, jack_detect_work.work);
825	int val, btn_type;	825	int val, btn_type;
826		826
827	while (!rt5682s->component)	827	if (!rt5682s->component \|\| !rt5682s->component->card \|\|
828	usleep_range(10000, 15000);	828	!rt5682s->component->card->instantiated) {
829		829	/* card not yet ready, try later */
830	while (!rt5682s->component->card->instantiated)	830	mod_delayed_work(system_power_efficient_wq,
831	usleep_range(10000, 15000);	831	&rt5682s->jack_detect_work, msecs_to_jiffies(15));
		832	return;
		833	}
832		834
833	mutex_lock(&rt5682s->jdet_mutex);	835	mutex_lock(&rt5682s->jdet_mutex);
834	mutex_lock(&rt5682s->calibrate_mutex);	836	mutex_lock(&rt5682s->calibrate_mutex);

sound/soc/codecs/tas2770.c+6−1

 		gpiod_set_value_cansleep(tas2770->reset_gpio, 0);
 		msleep(20);
 		gpiod_set_value_cansleep(tas2770->reset_gpio, 1);
+		usleep_range(1000, 2000);
 	}
 	snd_soc_component_write(tas2770->component, TAS2770_SW_RST,
 		TAS2770_RST);
+	usleep_range(1000, 2000);
 }
 static int tas2770_set_bias_level(struct snd_soc_component *component,
 	if (tas2770->sdz_gpio) {
 		gpiod_set_value_cansleep(tas2770->sdz_gpio, 1);
+		usleep_range(1000, 2000);
 	} else {
 		ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL,
 						    TAS2770_PWR_CTRL_MASK,
 	tas2770->component = component;
-	if (tas2770->sdz_gpio)
+	if (tas2770->sdz_gpio) {
 		gpiod_set_value_cansleep(tas2770->sdz_gpio, 1);
+		usleep_range(1000, 2000);
+	}
 	tas2770_reset(tas2770);

sound/soc/codecs/wm_adsp.c+2−1

@@ -1441,7 +1441,8 @@ static int wm_adsp_buffer_parse_coeff(struct cs_dsp_coeff_ctl *cs_ctl) · 1440 unmodified lines
1441	int ret, i;	1441	int ret, i;
1442		1442
1443	for (i = 0; i < 5; ++i) {	1443	for (i = 0; i < 5; ++i) {
1444	ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1, sizeof(coeff_v1));	1444	ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1,
		1445	min(cs_ctl->len, sizeof(coeff_v1)));
1445	if (ret < 0)	1446	if (ret < 0)
1446	return ret;	1447	return ret;
1447		1448

sound/soc/intel/skylake/skl.c+1−0

@@ -952,6 +952,7 @@ static int skl_first_init(struct hdac_bus *bus) · 951 unmodified lines
952	/* allow 64bit DMA address if supported by H/W */	952	/* allow 64bit DMA address if supported by H/W */
953	if (dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(64)))	953	if (dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(64)))
954	dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(32));	954	dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(32));
		955	dma_set_max_seg_size(bus->dev, UINT_MAX);
955		956
956	/* initialize streams */	957	/* initialize streams */
957	snd_hdac_ext_stream_init_all	958	snd_hdac_ext_stream_init_all

sound/soc/qcom/lpass-platform.c+4−4

@@ -524,7 +524,7 @@ static int lpass_platform_pcmops_trigger(struct snd_soc_component *component, · 523 unmodified lines
524	return -EINVAL;	524	return -EINVAL;
525	}	525	}
526		526
527	ret = regmap_update_bits(map, reg_irqclr, val_irqclr, val_irqclr);	527	ret = regmap_write_bits(map, reg_irqclr, val_irqclr, val_irqclr);
528	if (ret) {	528	if (ret) {
529	dev_err(soc_runtime->dev, "error writing to irqclear reg: %d\n", ret);	529	dev_err(soc_runtime->dev, "error writing to irqclear reg: %d\n", ret);
530	return ret;	530	return ret;
@@ -665,7 +665,7 @@ static irqreturn_t lpass_dma_interrupt_handler( · 134 unmodified lines
665	return -EINVAL;	665	return -EINVAL;
666	}	666	}
667	if (interrupts & LPAIF_IRQ_PER(chan)) {	667	if (interrupts & LPAIF_IRQ_PER(chan)) {
668	rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_PER(chan) \| val));	668	rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_PER(chan) \| val));
669	if (rv) {	669	if (rv) {
670	dev_err(soc_runtime->dev,	670	dev_err(soc_runtime->dev,
671	"error writing to irqclear reg: %d\n", rv);	671	"error writing to irqclear reg: %d\n", rv);
@@ -676,7 +676,7 @@ static irqreturn_t lpass_dma_interrupt_handler( · 4 unmodified lines
676	}	676	}
677		677
678	if (interrupts & LPAIF_IRQ_XRUN(chan)) {	678	if (interrupts & LPAIF_IRQ_XRUN(chan)) {
679	rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_XRUN(chan) \| val));	679	rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_XRUN(chan) \| val));
680	if (rv) {	680	if (rv) {
681	dev_err(soc_runtime->dev,	681	dev_err(soc_runtime->dev,
682	"error writing to irqclear reg: %d\n", rv);	682	"error writing to irqclear reg: %d\n", rv);
@@ -688,7 +688,7 @@ static irqreturn_t lpass_dma_interrupt_handler( · 5 unmodified lines
688	}	688	}
689		689
690	if (interrupts & LPAIF_IRQ_ERR(chan)) {	690	if (interrupts & LPAIF_IRQ_ERR(chan)) {
691	rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_ERR(chan) \| val));	691	rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_ERR(chan) \| val));
692	if (rv) {	692	if (rv) {
693	dev_err(soc_runtime->dev,	693	dev_err(soc_runtime->dev,
694	"error writing to irqclear reg: %d\n", rv);	694	"error writing to irqclear reg: %d\n", rv);

sound/soc/soc-ops.c+31−10

 	unsigned int sign_bit = mc->sign_bit;
 	unsigned int mask = (1 << fls(max)) - 1;
 	unsigned int invert = mc->invert;
-	int err;
+	int err, ret;
 	bool type_2r = false;
 	unsigned int val2 = 0;
 	unsigned int val, val_mask;
 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
 	if (err < 0)
 		return err;
+	ret = err;
-	if (type_2r)
+	if (type_2r) {
 		err = snd_soc_component_update_bits(component, reg2, val_mask,
-			val2);
+						    val2);
+		/* Don't discard any error code or drop change flag */
+		if (ret == 0 || err < 0) {
+			ret = err;
+		}
+	}
-	return err;
+	return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
 	int min = mc->min;
 	unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
 	int err = 0;
+	int ret;
 	unsigned int val, val_mask;
 	if (ucontrol->value.integer.value[0] < 0)
 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
 	if (err < 0)
 		return err;
+	ret = err;
 	if (snd_soc_volsw_is_stereo(mc)) {
 		unsigned int val2;
 		err = snd_soc_component_update_bits(component, reg2, val_mask,
 			val2);
+		/* Don't discard any error code or drop change flag */
+		if (ret == 0 || err < 0) {
+			ret = err;
+		}
 	}
 	return err;
 }
 	unsigned int mask = (1 << fls(max)) - 1;
 	unsigned int invert = mc->invert;
 	unsigned int val, val_mask;
-	int ret;
+	int err, ret;
 	if (invert)
 		val = (max - ucontrol->value.integer.value[0]) & mask;
 	val_mask = mask << shift;
 	val = val << shift;
-	ret = snd_soc_component_update_bits(component, reg, val_mask, val);
+	err = snd_soc_component_update_bits(component, reg, val_mask, val);
-	if (ret < 0)
+	if (err < 0)
-		return ret;
+		return err;
+	ret = err;
 	if (snd_soc_volsw_is_stereo(mc)) {
 		if (invert)
 		val_mask = mask << shift;
 		val = val << shift;
-		ret = snd_soc_component_update_bits(component, rreg, val_mask,
+		err = snd_soc_component_update_bits(component, rreg, val_mask,
 			val);
+		/* Don't discard any error code or drop change flag */
+		if (ret == 0 || err < 0) {
+			ret = err;
+		}
 	}
 	return ret;
 	unsigned long mask = (1UL<<mc->nbits)-1;
 	long max = mc->max;
 	long val = ucontrol->value.integer.value[0];
+	int ret = 0;
 	unsigned int i;
 	if (val < mc->min || val > mc->max)
 							regmask, regval);
 		if (err < 0)
 			return err;
+		if (err > 0)
+			ret = err;
 	}
-	return 0;
+	return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);

sound/soc/sof/intel/hda.c+1−0

@@ -956,6 +956,7 @@ int hda_dsp_probe(struct snd_sof_dev *sdev) · 955 unmodified lines
956	dev_dbg(sdev->dev, "DMA mask is 32 bit\n");	956	dev_dbg(sdev->dev, "DMA mask is 32 bit\n");
957	dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32));	957	dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32));
958	}	958	}
		959	dma_set_max_seg_size(&pci->dev, UINT_MAX);
959		960
960	/* init streams */	961	/* init streams */
961	ret = hda_dsp_stream_init(sdev);	962	ret = hda_dsp_stream_init(sdev);

sound/usb/implicit.c+2−2

 static const struct snd_usb_implicit_fb_match playback_implicit_fb_quirks[] = {
 	/* Generic matching */
 	IMPLICIT_FB_GENERIC_DEV(0x0499, 0x1509), /* Steinberg UR22 */
-	IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2080), /* M-Audio FastTrack Ultra */
-	IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2081), /* M-Audio FastTrack Ultra */
 	IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2030), /* M-Audio Fast Track C400 */
 	IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2031), /* M-Audio Fast Track C600 */
 	/* Fixed EP */
 	/* FIXME: check the availability of generic matching */
+	IMPLICIT_FB_FIXED_DEV(0x0763, 0x2080, 0x81, 2), /* M-Audio FastTrack Ultra */
+	IMPLICIT_FB_FIXED_DEV(0x0763, 0x2081, 0x81, 2), /* M-Audio FastTrack Ultra */
 	IMPLICIT_FB_FIXED_DEV(0x2466, 0x8010, 0x81, 2), /* Fractal Audio Axe-Fx III */
 	IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0001, 0x81, 2), /* Solid State Logic SSL2 */
 	IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0002, 0x81, 2), /* Solid State Logic SSL2+ */

sound/usb/mixer.c+3−6

 				err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
 							cval->cache_val[idx]);
 				if (err < 0)
-					return err;
+					break;
 			}
 			idx++;
 		}
 	} else {
 		/* master */
-		if (cval->cached) {
+		if (cval->cached)
-			err = snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
+			snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
-			if (err < 0)
-				return err;
-		}
 	}
 	return 0;

tools/cgroup/memcg_slabinfo.py+15−15

@@ -11,7 +11,7 @@ from drgn.helpers.linux import list_for_each_entry, list_empty · 10 unmodified lines
11	from drgn.helpers.linux import for_each_page	11	from drgn.helpers.linux import for_each_page
12	from drgn.helpers.linux.cpumask import for_each_online_cpu	12	from drgn.helpers.linux.cpumask import for_each_online_cpu
13	from drgn.helpers.linux.percpu import per_cpu_ptr	13	from drgn.helpers.linux.percpu import per_cpu_ptr
14	from drgn import container_of, FaultError, Object	14	from drgn import container_of, FaultError, Object, cast
15		15
16		16
17	DESC = """	17	DESC = """
@@ -69,15 +69,15 @@ def oo_objects(s): · 51 unmodified lines
69		69
70		70
71	def count_partial(n, fn):	71	def count_partial(n, fn):
72	nr_pages = 0	72	nr_objs = 0
73	for page in list_for_each_entry('struct page', n.partial.address_of_(),	73	for slab in list_for_each_entry('struct slab', n.partial.address_of_(),
74	'lru'):	74	'slab_list'):
75	nr_pages += fn(page)	75	nr_objs += fn(slab)
76	return nr_pages	76	return nr_objs
77		77
78		78
79	def count_free(page):	79	def count_free(slab):
80	return page.objects - page.inuse	80	return slab.objects - slab.inuse
81		81
82		82
83	def slub_get_slabinfo(s, cfg):	83	def slub_get_slabinfo(s, cfg):
@@ -145,14 +145,14 @@ def detect_kernel_config(): · 61 unmodified lines
145	return cfg	145	return cfg
146		146
147		147
148	def for_each_slab_page(prog):	148	def for_each_slab(prog):
149	PGSlab = 1 << prog.constant('PG_slab')	149	PGSlab = 1 << prog.constant('PG_slab')
150	PGHead = 1 << prog.constant('PG_head')	150	PGHead = 1 << prog.constant('PG_head')
151		151
152	for page in for_each_page(prog):	152	for page in for_each_page(prog):
153	try:	153	try:
154	if page.flags.value_() & PGSlab:	154	if page.flags.value_() & PGSlab:
155	yield page	155	yield cast('struct slab *', page)
156	except FaultError:	156	except FaultError:
157	pass	157	pass
158		158
@@ -190,13 +190,13 @@ def main(): · 31 unmodified lines
190	'list'):	190	'list'):
191	obj_cgroups.add(ptr.value_())	191	obj_cgroups.add(ptr.value_())
192		192
193	# look over all slab pages, belonging to non-root memcgs	193	# look over all slab folios and look for objects belonging
194	# and look for objects belonging to the given memory cgroup	194	# to the given memory cgroup
195	for page in for_each_slab_page(prog):	195	for slab in for_each_slab(prog):
196	objcg_vec_raw = page.memcg_data.value_()	196	objcg_vec_raw = slab.memcg_data.value_()
197	if objcg_vec_raw == 0:	197	if objcg_vec_raw == 0:
198	continue	198	continue
199	cache = page.slab_cache	199	cache = slab.slab_cache
200	if not cache:	200	if not cache:
201	continue	201	continue
202	addr = cache.value_()	202	addr = cache.value_()

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

@@ -3,8 +3,8 @@ CFLAGS = -Wall · 2 unmodified lines
3	CFLAGS += -Wno-nonnull	3	CFLAGS += -Wno-nonnull
4	CFLAGS += -D_GNU_SOURCE	4	CFLAGS += -D_GNU_SOURCE
5		5
6	TEST_PROGS := binfmt_script non-regular	6	TEST_PROGS := binfmt_script
7	TEST_GEN_PROGS := execveat load_address_4096 load_address_2097152 load_address_16777216	7	TEST_GEN_PROGS := execveat load_address_4096 load_address_2097152 load_address_16777216 non-regular
8	TEST_GEN_FILES := execveat.symlink execveat.denatured script subdir	8	TEST_GEN_FILES := execveat.symlink execveat.denatured script subdir
9	# Makefile is a run-time dependency, since it's accessed by the execveat test	9	# Makefile is a run-time dependency, since it's accessed by the execveat test
10	TEST_FILES := Makefile	10	TEST_FILES := Makefile

tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc+1−1

@@ -19,7 +19,7 @@ fail() { # mesg · 18 unmodified lines
19		19
20	FILTER=set_ftrace_filter	20	FILTER=set_ftrace_filter
21	FUNC1="schedule"	21	FUNC1="schedule"
22	FUNC2="do_softirq"	22	FUNC2="scheduler_tick"
23		23
24	ALL_FUNCS="#### all functions enabled ####"	24	ALL_FUNCS="#### all functions enabled ####"
25		25

tools/testing/selftests/mount_setattr/mount_setattr_test.c+2−2

@@ -1236,7 +1236,7 @@ static int get_userns_fd(unsigned long nsid, unsigned long hostid, unsigned long · 1235 unmodified lines
1236	}	1236	}
1237		1237
1238	/**	1238	/**
1239	* Validate that an attached mount in our mount namespace can be idmapped.	1239	* Validate that an attached mount in our mount namespace cannot be idmapped.
1240	* (The kernel enforces that the mount's mount namespace and the caller's mount	1240	* (The kernel enforces that the mount's mount namespace and the caller's mount
1241	* namespace match.)	1241	* namespace match.)
1242	*/	1242	*/
@@ -1259,7 +1259,7 @@ TEST_F(mount_setattr_idmapped, attached_mount_inside_current_mount_namespace) · 16 unmodified lines
1259		1259
1260	attr.userns_fd = get_userns_fd(0, 10000, 10000);	1260	attr.userns_fd = get_userns_fd(0, 10000, 10000);
1261	ASSERT_GE(attr.userns_fd, 0);	1261	ASSERT_GE(attr.userns_fd, 0);
1262	ASSERT_EQ(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);	1262	ASSERT_NE(sys_mount_setattr(open_tree_fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), 0);
1263	ASSERT_EQ(close(attr.userns_fd), 0);	1263	ASSERT_EQ(close(attr.userns_fd), 0);
1264	ASSERT_EQ(close(open_tree_fd), 0);	1264	ASSERT_EQ(close(open_tree_fd), 0);
1265	}	1265	}

tools/testing/selftests/net/mptcp/diag.sh+37−7

 		__chk_nr "grep -c remote_key" $*
 }
+# $1: ns, $2: port
+wait_local_port_listen()
+{
+	local listener_ns="${1}"
+	local port="${2}"
+	local port_hex i
+	port_hex="$(printf "%04X" "${port}")"
+	for i in $(seq 10); do
+		ip netns exec "${listener_ns}" cat /proc/net/tcp | \
+			awk "BEGIN {rc=1} {if (\$2 ~ /:${port_hex}\$/ && \$4 ~ /0A/) {rc=0; exit}} END {exit rc}" &&
+			break
+		sleep 0.1
+	done
+}
+wait_connected()
+{
+	local listener_ns="${1}"
+	local port="${2}"
+	local port_hex i
+	port_hex="$(printf "%04X" "${port}")"
+	for i in $(seq 10); do
+		ip netns exec ${listener_ns} grep -q " 0100007F:${port_hex} " /proc/net/tcp && break
+		sleep 0.1
+	done
+}
 trap cleanup EXIT
 ip netns add $ns
 		ip netns exec $ns \
 			./mptcp_connect -p 10000 -l -t ${timeout_poll} \
 				0.0.0.0 >/dev/null &
-sleep 0.1
+wait_local_port_listen $ns 10000
 chk_msk_nr 0 "no msk on netns creation"
 echo "b" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10000 -j -t ${timeout_poll} \
+			./mptcp_connect -p 10000 -r 0 -t ${timeout_poll} \
 				127.0.0.1 >/dev/null &
-sleep 0.1
+wait_connected $ns 10000
 chk_msk_nr 2 "after MPC handshake "
 chk_msk_remote_key_nr 2 "....chk remote_key"
 chk_msk_fallback_nr 0 "....chk no fallback"
 		ip netns exec $ns \
 			./mptcp_connect -p 10001 -l -s TCP -t ${timeout_poll} \
 				0.0.0.0 >/dev/null &
-sleep 0.1
+wait_local_port_listen $ns 10001
 echo "b" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10001 -j -t ${timeout_poll} \
+			./mptcp_connect -p 10001 -r 0 -t ${timeout_poll} \
 				127.0.0.1 >/dev/null &
-sleep 0.1
+wait_connected $ns 10001
 chk_msk_fallback_nr 1 "check fallback"
 flush_pids
 				./mptcp_connect -p $((I+10001)) -l -w 10 \
 					-t ${timeout_poll} 0.0.0.0 >/dev/null &
 done
-sleep 0.1
+wait_local_port_listen $ns $((NR_CLIENTS + 10001))
 for I in `seq 1 $NR_CLIENTS`; do
 	echo "b" | \

tools/testing/selftests/net/mptcp/mptcp_join.sh+25−7

@@ -799,6 +799,7 @@ chk_join_nr() · 798 unmodified lines
799	local ack_nr=$4	799	local ack_nr=$4
800	local count	800	local count
801	local dump_stats	801	local dump_stats
		802	local with_cookie
802		803
803	printf "%02u %-36s %s" "$TEST_COUNT" "$msg" "syn"	804	printf "%02u %-36s %s" "$TEST_COUNT" "$msg" "syn"
804	count=`ip netns exec $ns1 nstat -as \| grep MPTcpExtMPJoinSynRx \| awk '{print $2}'`	805	count=`ip netns exec $ns1 nstat -as \| grep MPTcpExtMPJoinSynRx \| awk '{print $2}'`
@@ -812,12 +813,20 @@ chk_join_nr() · 7 unmodified lines
812	fi	813	fi
813		814
814	echo -n " - synack"	815	echo -n " - synack"
		816	with_cookie=`ip netns exec $ns2 sysctl -n net.ipv4.tcp_syncookies`
815	count=`ip netns exec $ns2 nstat -as \| grep MPTcpExtMPJoinSynAckRx \| awk '{print $2}'`	817	count=`ip netns exec $ns2 nstat -as \| grep MPTcpExtMPJoinSynAckRx \| awk '{print $2}'`
816	[ -z "$count" ] && count=0	818	[ -z "$count" ] && count=0
817	if [ "$count" != "$syn_ack_nr" ]; then	819	if [ "$count" != "$syn_ack_nr" ]; then
818	echo "[fail] got $count JOIN[s] synack expected $syn_ack_nr"	820	# simult connections exceeding the limit with cookie enabled could go up to
819	ret=1	821	# synack validation as the conn limit can be enforced reliably only after
820	dump_stats=1	822	# the subflow creation
		823	if [ "$with_cookie" = 2 ] && [ "$count" -gt "$syn_ack_nr" ] && [ "$count" -le "$syn_nr" ]; then
		824	echo -n "[ ok ]"
		825	else
		826	echo "[fail] got $count JOIN[s] synack expected $syn_ack_nr"
		827	ret=1
		828	dump_stats=1
		829	fi
821	else	830	else
822	echo -n "[ ok ]"	831	echo -n "[ ok ]"
823	fi	832	fi
@@ -891,11 +900,17 @@ chk_add_nr() · 67 unmodified lines
891	local mis_ack_nr=${8:-0}	900	local mis_ack_nr=${8:-0}
892	local count	901	local count
893	local dump_stats	902	local dump_stats
		903	local timeout
		904
		905	timeout=`ip netns exec $ns1 sysctl -n net.mptcp.add_addr_timeout`
894		906
895	printf "%-39s %s" " " "add"	907	printf "%-39s %s" " " "add"
896	count=`ip netns exec $ns2 nstat -as \| grep MPTcpExtAddAddr \| awk '{print $2}'`	908	count=`ip netns exec $ns2 nstat -as MPTcpExtAddAddr \| grep MPTcpExtAddAddr \| awk '{print $2}'`
897	[ -z "$count" ] && count=0	909	[ -z "$count" ] && count=0
898	if [ "$count" != "$add_nr" ]; then	910
		911	# if the test configured a short timeout tolerate greater then expected
		912	# add addrs options, due to retransmissions
		913	if [ "$count" != "$add_nr" ] && [ "$timeout" -gt 1 -o "$count" -lt "$add_nr" ]; then
899	echo "[fail] got $count ADD_ADDR[s] expected $add_nr"	914	echo "[fail] got $count ADD_ADDR[s] expected $add_nr"
900	ret=1	915	ret=1
901	dump_stats=1	916	dump_stats=1
@@ -1100,7 +1115,7 @@ wait_for_tw() · 198 unmodified lines
1100	local ns=$1	1115	local ns=$1
1101		1116
1102	while [ $time -lt $timeout_ms ]; do	1117	while [ $time -lt $timeout_ms ]; do
1103	local cnt=$(ip netns exec $ns ss -t state time-wait \|wc -l)	1118	local cnt=$(ip netns exec $ns nstat -as TcpAttemptFails \| grep TcpAttemptFails \| awk '{print $2}')
1104		1119
1105	[ "$cnt" = 1 ] && return 1	1120	[ "$cnt" = 1 ] && return 1
1106	time=$((time + 100))	1121	time=$((time + 100))
@@ -1297,7 +1312,10 @@ signal_address_tests() · 190 unmodified lines
1297	pm_nl_add_endpoint $ns2 10.0.2.2 flags signal	1312	pm_nl_add_endpoint $ns2 10.0.2.2 flags signal
1298	pm_nl_add_endpoint $ns2 10.0.3.2 flags signal	1313	pm_nl_add_endpoint $ns2 10.0.3.2 flags signal
1299	pm_nl_add_endpoint $ns2 10.0.4.2 flags signal	1314	pm_nl_add_endpoint $ns2 10.0.4.2 flags signal
1300	run_tests $ns1 $ns2 10.0.1.1	1315
		1316	# the peer could possibly miss some addr notification, allow retransmission
		1317	ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1
		1318	run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1301	chk_join_nr "signal addresses race test" 3 3 3	1319	chk_join_nr "signal addresses race test" 3 3 3
1302		1320
1303	# the server will not signal the address terminating	1321	# the server will not signal the address terminating

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

@@ -1,5 +1,5 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	CFLAGS += -Wl,-no-as-needed -Wall	2	CFLAGS += -Wl,-no-as-needed -Wall -isystem ../../../../usr/include/
3	LDFLAGS += -lpthread	3	LDFLAGS += -lpthread
4		4
5	TEST_GEN_PROGS := seccomp_bpf seccomp_benchmark	5	TEST_GEN_PROGS := seccomp_bpf seccomp_benchmark