lael-labs/linux

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

 +----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A510     | #2051678        | ARM64_ERRATUM_2051678       |
 +----------------+-----------------+-----------------+-----------------------------+
+| ARM            | Cortex-A510     | #2077057        | ARM64_ERRATUM_2077057       |
++----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A710     | #2119858        | ARM64_ERRATUM_2119858       |
 +----------------+-----------------+-----------------+-----------------------------+
 | ARM            | Cortex-A710     | #2054223        | ARM64_ERRATUM_2054223       |

Documentation/dev-tools/kunit/usage.rst+1−1

@@ -242,7 +242,7 @@ example: · 241 unmodified lines
242		242
243	int rectangle_area(struct shape *this)	243	int rectangle_area(struct shape *this)
244	{	244	{
245	struct rectangle *self = container_of(this, struct shape, parent);	245	struct rectangle *self = container_of(this, struct rectangle, parent);
246		246
247	return self->length * self->width;	247	return self->length * self->width;
248	};	248	};

Documentation/filesystems/netfs_library.rst+16−0

@@ -462,6 +462,10 @@ operation table looks like the following:: · 461 unmodified lines
462	struct iov_iter *iter,	462	struct iov_iter *iter,
463	netfs_io_terminated_t term_func,	463	netfs_io_terminated_t term_func,
464	void *term_func_priv);	464	void *term_func_priv);
		465
		466	int (query_occupancy)(struct netfs_cache_resources cres,
		467	loff_t start, size_t len, size_t granularity,
		468	loff_t _data_start, size_t _data_len);
465	};	469	};
466		470
467	With a termination handler function pointer::	471	With a termination handler function pointer::
@@ -536,6 +540,18 @@ The methods defined in the table are: · 68 unmodified lines
536	indicating whether the termination is definitely happening in the caller's	540	indicating whether the termination is definitely happening in the caller's
537	context.	541	context.
538		542
		543	* ``query_occupancy()``
		544
		545	[Required] Called to find out where the next piece of data is within a
		546	particular region of the cache. The start and length of the region to be
		547	queried are passed in, along with the granularity to which the answer needs
		548	to be aligned. The function passes back the start and length of the data,
		549	if any, available within that region. Note that there may be a hole at the
		550	front.
		551
		552	It returns 0 if some data was found, -ENODATA if there was no usable data
		553	within the region or -ENOBUFS if there is no caching on this file.
		554
539	Note that these methods are passed a pointer to the cache resource structure,	555	Note that these methods are passed a pointer to the cache resource structure,
540	not the read request structure as they could be used in other situations where	556	not the read request structure as they could be used in other situations where
541	there isn't a read request structure as well, such as writing dirty data to the	557	there isn't a read request structure as well, such as writing dirty data to the

Documentation/gpu/todo.rst+0−24

@@ -300,30 +300,6 @@ Contact: Daniel Vetter, Noralf Tronnes · 299 unmodified lines
300		300
301	Level: Advanced	301	Level: Advanced
302		302
303	Garbage collect fbdev scrolling acceleration
304	--------------------------------------------
305
306	Scroll acceleration has been disabled in fbcon. Now it works as the old
307	SCROLL_REDRAW mode. A ton of code was removed in fbcon.c and the hook bmove was
308	removed from fbcon_ops.
309	Remaining tasks:
310
311	- a bunch of the hooks in fbcon_ops could be removed or simplified by calling
312	directly instead of the function table (with a switch on p->rotate)
313
314	- fb_copyarea is unused after this, and can be deleted from all drivers
315
316	- after that, fb_copyarea can be deleted from fb_ops in include/linux/fb.h as
317	well as cfb_copyarea
318
319	Note that not all acceleration code can be deleted, since clearing and cursor
320	support is still accelerated, which might be good candidates for further
321	deletion projects.
322
323	Contact: Daniel Vetter
324
325	Level: Intermediate
326
327	idr_init_base()	303	idr_init_base()
328	---------------	304	---------------
329		305

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

MAINTAINERS+18−4

@@ -10881,6 +10881,12 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git · 10880 unmodified lines
10881	F: drivers/ata/pata_arasan_cf.c	10881	F: drivers/ata/pata_arasan_cf.c
10882	F: include/linux/pata_arasan_cf_data.h	10882	F: include/linux/pata_arasan_cf_data.h
10883		10883
		10884	LIBATA PATA DRIVERS
		10885	R: Sergey Shtylyov <s.shtylyov@omp.ru>
		10886	L: linux-ide@vger.kernel.org
		10887	F: drivers/ata/ata_*.c
		10888	F: drivers/ata/pata_*.c
		10889
10884	LIBATA PATA FARADAY FTIDE010 AND GEMINI SATA BRIDGE DRIVERS	10890	LIBATA PATA FARADAY FTIDE010 AND GEMINI SATA BRIDGE DRIVERS
10885	M: Linus Walleij <linus.walleij@linaro.org>	10891	M: Linus Walleij <linus.walleij@linaro.org>
10886	L: linux-ide@vger.kernel.org	10892	L: linux-ide@vger.kernel.org
@@ -12401,7 +12407,7 @@ F: include/uapi/linux/membarrier.h · 1514 unmodified lines
12401	F: kernel/sched/membarrier.c	12407	F: kernel/sched/membarrier.c
12402		12408
12403	MEMBLOCK	12409	MEMBLOCK
12404	M: Mike Rapoport <rppt@linux.ibm.com>	12410	M: Mike Rapoport <rppt@kernel.org>
12405	L: linux-mm@kvack.org	12411	L: linux-mm@kvack.org
12406	S: Maintained	12412	S: Maintained
12407	F: Documentation/core-api/boot-time-mm.rst	12413	F: Documentation/core-api/boot-time-mm.rst
@@ -13299,8 +13305,8 @@ W: http://www.iptables.org/ · 891 unmodified lines
13299	W: http://www.nftables.org/	13305	W: http://www.nftables.org/
13300	Q: http://patchwork.ozlabs.org/project/netfilter-devel/list/	13306	Q: http://patchwork.ozlabs.org/project/netfilter-devel/list/
13301	C: irc://irc.libera.chat/netfilter	13307	C: irc://irc.libera.chat/netfilter
13302	T: git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git	13308	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf.git
13303	T: git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next.git	13309	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git
13304	F: include/linux/netfilter*	13310	F: include/linux/netfilter*
13305	F: include/linux/netfilter/	13311	F: include/linux/netfilter/
13306	F: include/net/netfilter/	13312	F: include/net/netfilter/
@@ -13567,7 +13573,7 @@ F: tools/testing/selftests/nci/ · 260 unmodified lines
13567		13573
13568	NFS, SUNRPC, AND LOCKD CLIENTS	13574	NFS, SUNRPC, AND LOCKD CLIENTS
13569	M: Trond Myklebust <trond.myklebust@hammerspace.com>	13575	M: Trond Myklebust <trond.myklebust@hammerspace.com>
13570	M: Anna Schumaker <anna.schumaker@netapp.com>	13576	M: Anna Schumaker <anna@kernel.org>
13571	L: linux-nfs@vger.kernel.org	13577	L: linux-nfs@vger.kernel.org
13572	S: Maintained	13578	S: Maintained
13573	W: http://client.linux-nfs.org	13579	W: http://client.linux-nfs.org
@@ -16469,6 +16475,14 @@ F: Documentation/devicetree/bindings/i2c/renesas,rmobile-iic.yaml · 2895 unmodified lines
16469	F: drivers/i2c/busses/i2c-rcar.c	16475	F: drivers/i2c/busses/i2c-rcar.c
16470	F: drivers/i2c/busses/i2c-sh_mobile.c	16476	F: drivers/i2c/busses/i2c-sh_mobile.c
16471		16477
		16478	RENESAS R-CAR SATA DRIVER
		16479	R: Sergey Shtylyov <s.shtylyov@omp.ru>
		16480	S: Supported
		16481	L: linux-ide@vger.kernel.org
		16482	L: linux-renesas-soc@vger.kernel.org
		16483	F: Documentation/devicetree/bindings/ata/renesas,rcar-sata.yaml
		16484	F: drivers/ata/sata_rcar.c
		16485
16472	RENESAS R-CAR THERMAL DRIVERS	16486	RENESAS R-CAR THERMAL DRIVERS
16473	M: Niklas Söderlund <niklas.soderlund@ragnatech.se>	16487	M: Niklas Söderlund <niklas.soderlund@ragnatech.se>
16474	L: linux-renesas-soc@vger.kernel.org	16488	L: linux-renesas-soc@vger.kernel.org

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 = -rc2	5	EXTRAVERSION = -rc3
6	NAME = Gobble Gobble	6	NAME = Gobble Gobble
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/crypto/blake2s-shash.c+2−2

@@ -13,12 +13,12 @@ · 12 unmodified lines
13	static int crypto_blake2s_update_arm(struct shash_desc *desc,	13	static int crypto_blake2s_update_arm(struct shash_desc *desc,
14	const u8 *in, unsigned int inlen)	14	const u8 *in, unsigned int inlen)
15	{	15	{
16	return crypto_blake2s_update(desc, in, inlen, blake2s_compress);	16	return crypto_blake2s_update(desc, in, inlen, false);
17	}	17	}
18		18
19	static int crypto_blake2s_final_arm(struct shash_desc desc, u8 out)	19	static int crypto_blake2s_final_arm(struct shash_desc desc, u8 out)
20	{	20	{
21	return crypto_blake2s_final(desc, out, blake2s_compress);	21	return crypto_blake2s_final(desc, out, false);
22	}	22	}
23		23
24	#define BLAKE2S_ALG(name, driver_name, digest_size) \	24	#define BLAKE2S_ALG(name, driver_name, digest_size) \

arch/arm64/Kconfig+16−0

@@ -680,6 +680,22 @@ config ARM64_ERRATUM_2051678 · 679 unmodified lines
680		680
681	If unsure, say Y.	681	If unsure, say Y.
682		682
		683	config ARM64_ERRATUM_2077057
		684	bool "Cortex-A510: 2077057: workaround software-step corrupting SPSR_EL2"
		685	help
		686	This option adds the workaround for ARM Cortex-A510 erratum 2077057.
		687	Affected Cortex-A510 may corrupt SPSR_EL2 when the a step exception is
		688	expected, but a Pointer Authentication trap is taken instead. The
		689	erratum causes SPSR_EL1 to be copied to SPSR_EL2, which could allow
		690	EL1 to cause a return to EL2 with a guest controlled ELR_EL2.
		691
		692	This can only happen when EL2 is stepping EL1.
		693
		694	When these conditions occur, the SPSR_EL2 value is unchanged from the
		695	previous guest entry, and can be restored from the in-memory copy.
		696
		697	If unsure, say Y.
		698
683	config ARM64_ERRATUM_2119858	699	config ARM64_ERRATUM_2119858
684	bool "Cortex-A710/X2: 2119858: workaround TRBE overwriting trace data in FILL mode"	700	bool "Cortex-A710/X2: 2119858: workaround TRBE overwriting trace data in FILL mode"
685	default y	701	default y

arch/arm64/kernel/cpu_errata.c+8−0

@@ -600,6 +600,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 599 unmodified lines
600	CAP_MIDR_RANGE_LIST(trbe_write_out_of_range_cpus),	600	CAP_MIDR_RANGE_LIST(trbe_write_out_of_range_cpus),
601	},	601	},
602	#endif	602	#endif
		603	#ifdef CONFIG_ARM64_ERRATUM_2077057
		604	{
		605	.desc = "ARM erratum 2077057",
		606	.capability = ARM64_WORKAROUND_2077057,
		607	.type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM,
		608	ERRATA_MIDR_REV_RANGE(MIDR_CORTEX_A510, 0, 0, 2),
		609	},
		610	#endif
603	#ifdef CONFIG_ARM64_ERRATUM_2064142	611	#ifdef CONFIG_ARM64_ERRATUM_2064142
604	{	612	{
605	.desc = "ARM erratum 2064142",	613	.desc = "ARM erratum 2064142",

arch/arm64/kvm/arm.c+33−18

 			xfer_to_guest_mode_work_pending();
 }
+/*
+ * Actually run the vCPU, entering an RCU extended quiescent state (EQS) while
+ * the vCPU is running.
+ *
+ * This must be noinstr as instrumentation may make use of RCU, and this is not
+ * safe during the EQS.
+ */
+static int noinstr kvm_arm_vcpu_enter_exit(struct kvm_vcpu *vcpu)
+{
+	int ret;
+	guest_state_enter_irqoff();
+	ret = kvm_call_hyp_ret(__kvm_vcpu_run, vcpu);
+	guest_state_exit_irqoff();
+	return ret;
+}
 /**
  * kvm_arch_vcpu_ioctl_run - the main VCPU run function to execute guest code
  * @vcpu:	The VCPU pointer
 		 * Enter the guest
 		 */
 		trace_kvm_entry(*vcpu_pc(vcpu));
-		guest_enter_irqoff();
+		guest_timing_enter_irqoff();
-		ret = kvm_call_hyp_ret(__kvm_vcpu_run, vcpu);
+		ret = kvm_arm_vcpu_enter_exit(vcpu);
 		vcpu->mode = OUTSIDE_GUEST_MODE;
 		vcpu->stat.exits++;
 		kvm_arch_vcpu_ctxsync_fp(vcpu);
 		/*
-		 * We may have taken a host interrupt in HYP mode (ie
+		 * We must ensure that any pending interrupts are taken before
-		 * while executing the guest). This interrupt is still
+		 * we exit guest timing so that timer ticks are accounted as
-		 * pending, as we haven't serviced it yet!
+		 * guest time. Transiently unmask interrupts so that any
+		 * pending interrupts are taken.
 		 *
-		 * We're now back in SVC mode, with interrupts
+		 * Per ARM DDI 0487G.b section D1.13.4, an ISB (or other
-		 * disabled.  Enabling the interrupts now will have
+		 * context synchronization event) is necessary to ensure that
-		 * the effect of taking the interrupt again, in SVC
+		 * pending interrupts are taken.
-		 * mode this time.
 		 */
 		local_irq_enable();
+		isb();
+		local_irq_disable();
+		guest_timing_exit_irqoff();
+		local_irq_enable();
-		/*
-		 * We do local_irq_enable() before calling guest_exit() so
-		 * that if a timer interrupt hits while running the guest we
-		 * account that tick as being spent in the guest.  We enable
-		 * preemption after calling guest_exit() so that if we get
-		 * preempted we make sure ticks after that is not counted as
-		 * guest time.
-		 */
-		guest_exit();
 		trace_kvm_exit(ret, kvm_vcpu_trap_get_class(vcpu), *vcpu_pc(vcpu));
 		/* Exit types that need handling before we can be preempted */

arch/arm64/kvm/handle_exit.c+8−0

@@ -228,6 +228,14 @@ int handle_exit(struct kvm_vcpu *vcpu, int exception_index) · 227 unmodified lines
228	{	228	{
229	struct kvm_run *run = vcpu->run;	229	struct kvm_run *run = vcpu->run;
230		230
		231	if (ARM_SERROR_PENDING(exception_index)) {
		232	/*
		233	* The SError is handled by handle_exit_early(). If the guest
		234	* survives it will re-execute the original instruction.
		235	*/
		236	return 1;
		237	}
		238
231	exception_index = ARM_EXCEPTION_CODE(exception_index);	239	exception_index = ARM_EXCEPTION_CODE(exception_index);
232		240
233	switch (exception_index) {	241	switch (exception_index) {

arch/arm64/kvm/hyp/include/hyp/switch.h+21−2

 	return false;
 }
+static inline void synchronize_vcpu_pstate(struct kvm_vcpu *vcpu, u64 *exit_code)
+{
+	/*
+	 * Check for the conditions of Cortex-A510's #2077057. When these occur
+	 * SPSR_EL2 can't be trusted, but isn't needed either as it is
+	 * unchanged from the value in vcpu_gp_regs(vcpu)->pstate.
+	 * Are we single-stepping the guest, and took a PAC exception from the
+	 * active-not-pending state?
+	 */
+	if (cpus_have_final_cap(ARM64_WORKAROUND_2077057)		&&
+	    vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP			&&
+	    *vcpu_cpsr(vcpu) & DBG_SPSR_SS				&&
+	    ESR_ELx_EC(read_sysreg_el2(SYS_ESR)) == ESR_ELx_EC_PAC)
+		write_sysreg_el2(*vcpu_cpsr(vcpu), SYS_SPSR);
+	vcpu->arch.ctxt.regs.pstate = read_sysreg_el2(SYS_SPSR);
+}
 /*
  * Return true when we were able to fixup the guest exit and should return to
  * the guest, false when we should restore the host state and return to the
 	 * Save PSTATE early so that we can evaluate the vcpu mode
 	 * early on.
 	 */
-	vcpu->arch.ctxt.regs.pstate = read_sysreg_el2(SYS_SPSR);
+	synchronize_vcpu_pstate(vcpu, exit_code);
 	/*
 	 * Check whether we want to repaint the state one way or
 	if (ARM_EXCEPTION_CODE(*exit_code) != ARM_EXCEPTION_IRQ)
 		vcpu->arch.fault.esr_el2 = read_sysreg_el2(SYS_ESR);
-	if (ARM_SERROR_PENDING(*exit_code)) {
+	if (ARM_SERROR_PENDING(*exit_code) &&
+	    ARM_EXCEPTION_CODE(*exit_code) != ARM_EXCEPTION_IRQ) {
 		u8 esr_ec = kvm_vcpu_trap_get_class(vcpu);
 		/*

arch/arm64/tools/cpucaps+3−2

 WORKAROUND_1463225
 WORKAROUND_1508412
 WORKAROUND_1542419
-WORKAROUND_2064142
-WORKAROUND_2038923
 WORKAROUND_1902691
+WORKAROUND_2038923
+WORKAROUND_2064142
+WORKAROUND_2077057
 WORKAROUND_TRBE_OVERWRITE_FILL_MODE
 WORKAROUND_TSB_FLUSH_FAILURE
 WORKAROUND_TRBE_WRITE_OUT_OF_RANGE

arch/mips/boot/dts/ingenic/ci20.dts+2−13

 		label = "HDMI OUT";
 		type = "a";
+		ddc-en-gpios = <&gpa 25 GPIO_ACTIVE_HIGH>;
 		port {
 			hdmi_con: endpoint {
 				remote-endpoint = <&dw_hdmi_out>;
 		gpio = <&gpf 14 GPIO_ACTIVE_LOW>;
 		enable-active-high;
 	};
-	hdmi_power: fixedregulator@3 {
-		compatible = "regulator-fixed";
-		regulator-name = "hdmi_power";
-		regulator-min-microvolt = <5000000>;
-		regulator-max-microvolt = <5000000>;
-		gpio = <&gpa 25 0>;
-		enable-active-high;
-	};
 };
 &ext {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pins_hdmi_ddc>;
-	hdmi-5v-supply = <&hdmi_power>;
 	ports {
 		#address-cells = <1>;
 		#size-cells = <0>;

arch/mips/kvm/mips.c+46−4

@@ -414,6 +414,24 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, · 413 unmodified lines
414	return -ENOIOCTLCMD;	414	return -ENOIOCTLCMD;
415	}	415	}
416		416
		417	/*
		418	* Actually run the vCPU, entering an RCU extended quiescent state (EQS) while
		419	* the vCPU is running.
		420	*
		421	* This must be noinstr as instrumentation may make use of RCU, and this is not
		422	* safe during the EQS.
		423	*/
		424	static int noinstr kvm_mips_vcpu_enter_exit(struct kvm_vcpu *vcpu)
		425	{
		426	int ret;
		427
		428	guest_state_enter_irqoff();
		429	ret = kvm_mips_callbacks->vcpu_run(vcpu);
		430	guest_state_exit_irqoff();
		431
		432	return ret;
		433	}
		434
417	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)	435	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
418	{	436	{
419	int r = -EINTR;	437	int r = -EINTR;
@@ -434,7 +452,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu) · 14 unmodified lines
434	lose_fpu(1);	452	lose_fpu(1);
435		453
436	local_irq_disable();	454	local_irq_disable();
437	guest_enter_irqoff();	455	guest_timing_enter_irqoff();
438	trace_kvm_enter(vcpu);	456	trace_kvm_enter(vcpu);
439		457
440	/*	458	/*
@@ -445,10 +463,23 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu) · 4 unmodified lines
445	*/	463	*/
446	smp_store_mb(vcpu->mode, IN_GUEST_MODE);	464	smp_store_mb(vcpu->mode, IN_GUEST_MODE);
447		465
448	r = kvm_mips_callbacks->vcpu_run(vcpu);	466	r = kvm_mips_vcpu_enter_exit(vcpu);
		467
		468	/*
		469	* We must ensure that any pending interrupts are taken before
		470	* we exit guest timing so that timer ticks are accounted as
		471	* guest time. Transiently unmask interrupts so that any
		472	* pending interrupts are taken.
		473	*
		474	* TODO: is there a barrier which ensures that pending interrupts are
		475	* recognised? Currently this just hopes that the CPU takes any pending
		476	* interrupts between the enable and disable.
		477	*/
		478	local_irq_enable();
		479	local_irq_disable();
449		480
450	trace_kvm_out(vcpu);	481	trace_kvm_out(vcpu);
451	guest_exit_irqoff();	482	guest_timing_exit_irqoff();
452	local_irq_enable();	483	local_irq_enable();
453		484
454	out:	485	out:
@@ -1168,7 +1199,7 @@ static void kvm_mips_set_c0_status(void) · 713 unmodified lines
1168	/*	1199	/*
1169	* Return value is in the form (errcode<<2 \| RESUME_FLAG_HOST \| RESUME_FLAG_NV)	1200	* Return value is in the form (errcode<<2 \| RESUME_FLAG_HOST \| RESUME_FLAG_NV)
1170	*/	1201	*/
1171	int kvm_mips_handle_exit(struct kvm_vcpu *vcpu)	1202	static int __kvm_mips_handle_exit(struct kvm_vcpu *vcpu)
1172	{	1203	{
1173	struct kvm_run *run = vcpu->run;	1204	struct kvm_run *run = vcpu->run;
1174	u32 cause = vcpu->arch.host_cp0_cause;	1205	u32 cause = vcpu->arch.host_cp0_cause;
@@ -1357,6 +1388,17 @@ int kvm_mips_handle_exit(struct kvm_vcpu *vcpu) · 182 unmodified lines
1357	return ret;	1388	return ret;
1358	}	1389	}
1359		1390
		1391	int noinstr kvm_mips_handle_exit(struct kvm_vcpu *vcpu)
		1392	{
		1393	int ret;
		1394
		1395	guest_state_exit_irqoff();
		1396	ret = __kvm_mips_handle_exit(vcpu);
		1397	guest_state_enter_irqoff();
		1398
		1399	return ret;
		1400	}
		1401
1360	/* Enable FPU for guest and restore context */	1402	/* Enable FPU for guest and restore context */
1361	void kvm_own_fpu(struct kvm_vcpu *vcpu)	1403	void kvm_own_fpu(struct kvm_vcpu *vcpu)
1362	{	1404	{

arch/riscv/kvm/vcpu.c+31−17

@@ -90,6 +90,7 @@ int kvm_arch_vcpu_precreate(struct kvm *kvm, unsigned int id) · 89 unmodified lines
90	int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu)	90	int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu)
91	{	91	{
92	struct kvm_cpu_context *cntx;	92	struct kvm_cpu_context *cntx;
		93	struct kvm_vcpu_csr *reset_csr = &vcpu->arch.guest_reset_csr;
93		94
94	/* Mark this VCPU never ran */	95	/* Mark this VCPU never ran */
95	vcpu->arch.ran_atleast_once = false;	96	vcpu->arch.ran_atleast_once = false;
@@ -106,6 +107,9 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu) · 10 unmodified lines
106	cntx->hstatus \|= HSTATUS_SPVP;	107	cntx->hstatus \|= HSTATUS_SPVP;
107	cntx->hstatus \|= HSTATUS_SPV;	108	cntx->hstatus \|= HSTATUS_SPV;
108		109
		110	/* By default, make CY, TM, and IR counters accessible in VU mode */
		111	reset_csr->scounteren = 0x7;
		112
109	/* Setup VCPU timer */	113	/* Setup VCPU timer */
110	kvm_riscv_vcpu_timer_init(vcpu);	114	kvm_riscv_vcpu_timer_init(vcpu);
111		115
@@ -699,6 +703,20 @@ static void kvm_riscv_update_hvip(struct kvm_vcpu *vcpu) · 587 unmodified lines
699	csr_write(CSR_HVIP, csr->hvip);	703	csr_write(CSR_HVIP, csr->hvip);
700	}	704	}
701		705
		706	/*
		707	* Actually run the vCPU, entering an RCU extended quiescent state (EQS) while
		708	* the vCPU is running.
		709	*
		710	* This must be noinstr as instrumentation may make use of RCU, and this is not
		711	* safe during the EQS.
		712	*/
		713	static void noinstr kvm_riscv_vcpu_enter_exit(struct kvm_vcpu *vcpu)
		714	{
		715	guest_state_enter_irqoff();
		716	__kvm_riscv_switch_to(&vcpu->arch);
		717	guest_state_exit_irqoff();
		718	}
		719
702	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)	720	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
703	{	721	{
704	int ret;	722	int ret;
@@ -790,9 +808,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu) · 85 unmodified lines
790	continue;	808	continue;
791	}	809	}
792		810
793	guest_enter_irqoff();	811	guest_timing_enter_irqoff();
794		812
795	__kvm_riscv_switch_to(&vcpu->arch);	813	kvm_riscv_vcpu_enter_exit(vcpu);
796		814
797	vcpu->mode = OUTSIDE_GUEST_MODE;	815	vcpu->mode = OUTSIDE_GUEST_MODE;
798	vcpu->stat.exits++;	816	vcpu->stat.exits++;
@@ -812,25 +830,21 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu) · 13 unmodified lines
812	kvm_riscv_vcpu_sync_interrupts(vcpu);	830	kvm_riscv_vcpu_sync_interrupts(vcpu);
813		831
814	/*	832	/*
815	* We may have taken a host interrupt in VS/VU-mode (i.e.	833	* We must ensure that any pending interrupts are taken before
816	* while executing the guest). This interrupt is still	834	* we exit guest timing so that timer ticks are accounted as
817	* pending, as we haven't serviced it yet!	835	* guest time. Transiently unmask interrupts so that any
		836	* pending interrupts are taken.
818	*	837	*
819	* We're now back in HS-mode with interrupts disabled	838	* There's no barrier which ensures that pending interrupts are
820	* so enabling the interrupts now will have the effect	839	* recognised, so we just hope that the CPU takes any pending
821	* of taking the interrupt again, in HS-mode this time.	840	* interrupts between the enable and disable.
822	*/	841	*/
823	local_irq_enable();	842	local_irq_enable();
		843	local_irq_disable();
824		844
825	/*	845	guest_timing_exit_irqoff();
826	* We do local_irq_enable() before calling guest_exit() so	846
827	* that if a timer interrupt hits while running the guest	847	local_irq_enable();
828	* we account that tick as being spent in the guest. We
829	* enable preemption after calling guest_exit() so that if
830	* we get preempted we make sure ticks after that is not
831	* counted as guest time.
832	*/
833	guest_exit();
834		848
835	preempt_enable();	849	preempt_enable();
836		850

arch/riscv/kvm/vcpu_sbi_base.c+2−1

 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/kvm_host.h>
+#include <linux/version.h>
 #include <asm/csr.h>
 #include <asm/sbi.h>
 #include <asm/kvm_vcpu_timer.h>
 		*out_val = KVM_SBI_IMPID;
 		break;
 	case SBI_EXT_BASE_GET_IMP_VERSION:
-		*out_val = 0;
+		*out_val = LINUX_VERSION_CODE;
 		break;
 	case SBI_EXT_BASE_PROBE_EXT:
 		if ((cp->a0 >= SBI_EXT_EXPERIMENTAL_START &&

arch/s390/kvm/kvm-s390.c+2−0

@@ -4667,6 +4667,8 @@ static long kvm_s390_guest_sida_op(struct kvm_vcpu *vcpu, · 4666 unmodified lines
4667	return -EINVAL;	4667	return -EINVAL;
4668	if (mop->size + mop->sida_offset > sida_size(vcpu->arch.sie_block))	4668	if (mop->size + mop->sida_offset > sida_size(vcpu->arch.sie_block))
4669	return -E2BIG;	4669	return -E2BIG;
		4670	if (!kvm_s390_pv_cpu_is_protected(vcpu))
		4671	return -EINVAL;
4670		4672
4671	switch (mop->op) {	4673	switch (mop->op) {
4672	case KVM_S390_MEMOP_SIDA_READ:	4674	case KVM_S390_MEMOP_SIDA_READ:

arch/x86/crypto/blake2s-shash.c+2−2

@@ -18,12 +18,12 @@ · 17 unmodified lines
18	static int crypto_blake2s_update_x86(struct shash_desc *desc,	18	static int crypto_blake2s_update_x86(struct shash_desc *desc,
19	const u8 *in, unsigned int inlen)	19	const u8 *in, unsigned int inlen)
20	{	20	{
21	return crypto_blake2s_update(desc, in, inlen, blake2s_compress);	21	return crypto_blake2s_update(desc, in, inlen, false);
22	}	22	}
23		23
24	static int crypto_blake2s_final_x86(struct shash_desc desc, u8 out)	24	static int crypto_blake2s_final_x86(struct shash_desc desc, u8 out)
25	{	25	{
26	return crypto_blake2s_final(desc, out, blake2s_compress);	26	return crypto_blake2s_final(desc, out, false);
27	}	27	}
28		28
29	#define BLAKE2S_ALG(name, driver_name, digest_size) \	29	#define BLAKE2S_ALG(name, driver_name, digest_size) \

arch/x86/events/intel/core.c+13−0

@@ -4703,6 +4703,19 @@ static __initconst const struct x86_pmu intel_pmu = { · 4702 unmodified lines
4703	.lbr_read = intel_pmu_lbr_read_64,	4703	.lbr_read = intel_pmu_lbr_read_64,
4704	.lbr_save = intel_pmu_lbr_save,	4704	.lbr_save = intel_pmu_lbr_save,
4705	.lbr_restore = intel_pmu_lbr_restore,	4705	.lbr_restore = intel_pmu_lbr_restore,
		4706
		4707	/*
		4708	* SMM has access to all 4 rings and while traditionally SMM code only
		4709	* ran in CPL0, 2021-era firmware is starting to make use of CPL3 in SMM.
		4710	*
		4711	* Since the EVENTSEL.{USR,OS} CPL filtering makes no distinction
		4712	* between SMM or not, this results in what should be pure userspace
		4713	* counters including SMM data.
		4714	*
		4715	* This is a clear privilege issue, therefore globally disable
		4716	* counting SMM by default.
		4717	*/
		4718	.attr_freeze_on_smi = 1,
4706	};	4719	};
4707		4720
4708	static __init void intel_clovertown_quirk(void)	4721	static __init void intel_clovertown_quirk(void)

arch/x86/events/intel/pt.c+3−2

 		 * means we are already losing data; need to let the decoder
 		 * know.
 		 */
-		if (!intel_pt_validate_hw_cap(PT_CAP_topa_multiple_entries) ||
+		if (!buf->single &&
-		    buf->output_off == pt_buffer_region_size(buf)) {
+		    (!intel_pt_validate_hw_cap(PT_CAP_topa_multiple_entries) ||
+		     buf->output_off == pt_buffer_region_size(buf))) {
 			perf_aux_output_flag(&pt->handle,
 			                     PERF_AUX_FLAG_TRUNCATED);
 			advance++;

arch/x86/include/asm/kvm-x86-ops.h+1−1

@@ -82,7 +82,7 @@ KVM_X86_OP_NULL(guest_apic_has_interrupt) · 81 unmodified lines
82	KVM_X86_OP(load_eoi_exitmap)	82	KVM_X86_OP(load_eoi_exitmap)
83	KVM_X86_OP(set_virtual_apic_mode)	83	KVM_X86_OP(set_virtual_apic_mode)
84	KVM_X86_OP_NULL(set_apic_access_page_addr)	84	KVM_X86_OP_NULL(set_apic_access_page_addr)
85	KVM_X86_OP(deliver_posted_interrupt)	85	KVM_X86_OP(deliver_interrupt)
86	KVM_X86_OP_NULL(sync_pir_to_irr)	86	KVM_X86_OP_NULL(sync_pir_to_irr)
87	KVM_X86_OP(set_tss_addr)	87	KVM_X86_OP(set_tss_addr)
88	KVM_X86_OP(set_identity_map_addr)	88	KVM_X86_OP(set_identity_map_addr)

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

 	void (*load_eoi_exitmap)(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap);
 	void (*set_virtual_apic_mode)(struct kvm_vcpu *vcpu);
 	void (*set_apic_access_page_addr)(struct kvm_vcpu *vcpu);
-	int (*deliver_posted_interrupt)(struct kvm_vcpu *vcpu, int vector);
+	void (*deliver_interrupt)(struct kvm_lapic *apic, int delivery_mode,
+				  int trig_mode, int vector);
 	int (*sync_pir_to_irr)(struct kvm_vcpu *vcpu);
 	int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
 	int (*set_identity_map_addr)(struct kvm *kvm, u64 ident_addr);

arch/x86/include/asm/xen/hypervisor.h+0−14

@@ -43,20 +43,6 @@ static inline uint32_t xen_cpuid_base(void) · 42 unmodified lines
43	return hypervisor_cpuid_base("XenVMMXenVMM", 2);	43	return hypervisor_cpuid_base("XenVMMXenVMM", 2);
44	}	44	}
45		45
46	#ifdef CONFIG_XEN
47	extern bool __init xen_hvm_need_lapic(void);
48
49	static inline bool __init xen_x2apic_para_available(void)
50	{
51	return xen_hvm_need_lapic();
52	}
53	#else
54	static inline bool __init xen_x2apic_para_available(void)
55	{
56	return (xen_cpuid_base() != 0);
57	}
58	#endif
59
60	struct pci_dev;	46	struct pci_dev;
61		47
62	#ifdef CONFIG_XEN_PV_DOM0	48	#ifdef CONFIG_XEN_PV_DOM0

arch/x86/kvm/cpuid.c+7−6

@@ -554,12 +554,13 @@ void kvm_set_cpu_caps(void) · 553 unmodified lines
554	);	554	);
555		555
556	kvm_cpu_cap_mask(CPUID_7_0_EBX,	556	kvm_cpu_cap_mask(CPUID_7_0_EBX,
557	F(FSGSBASE) \| F(SGX) \| F(BMI1) \| F(HLE) \| F(AVX2) \| F(SMEP) \|	557	F(FSGSBASE) \| F(SGX) \| F(BMI1) \| F(HLE) \| F(AVX2) \|
558	F(BMI2) \| F(ERMS) \| F(INVPCID) \| F(RTM) \| 0 /MPX/ \| F(RDSEED) \|	558	F(FDP_EXCPTN_ONLY) \| F(SMEP) \| F(BMI2) \| F(ERMS) \| F(INVPCID) \|
559	F(ADX) \| F(SMAP) \| F(AVX512IFMA) \| F(AVX512F) \| F(AVX512PF) \|	559	F(RTM) \| F(ZERO_FCS_FDS) \| 0 /MPX/ \| F(AVX512F) \|
560	F(AVX512ER) \| F(AVX512CD) \| F(CLFLUSHOPT) \| F(CLWB) \| F(AVX512DQ) \|	560	F(AVX512DQ) \| F(RDSEED) \| F(ADX) \| F(SMAP) \| F(AVX512IFMA) \|
561	F(SHA_NI) \| F(AVX512BW) \| F(AVX512VL) \| 0 /INTEL_PT/	561	F(CLFLUSHOPT) \| F(CLWB) \| 0 /INTEL_PT/ \| F(AVX512PF) \|
562	);	562	F(AVX512ER) \| F(AVX512CD) \| F(SHA_NI) \| F(AVX512BW) \|
		563	F(AVX512VL));
563		564
564	kvm_cpu_cap_mask(CPUID_7_ECX,	565	kvm_cpu_cap_mask(CPUID_7_ECX,
565	F(AVX512VBMI) \| F(LA57) \| F(PKU) \| 0 /OSPKE/ \| F(RDPID) \|	566	F(AVX512VBMI) \| F(LA57) \| F(PKU) \| 0 /OSPKE/ \| F(RDPID) \|

arch/x86/kvm/lapic.c+2−8

 						       apic->regs + APIC_TMR);
 		}
-		if (static_call(kvm_x86_deliver_posted_interrupt)(vcpu, vector)) {
+		static_call(kvm_x86_deliver_interrupt)(apic, delivery_mode,
-			kvm_lapic_set_irr(vector, apic);
+						       trig_mode, vector);
-			kvm_make_request(KVM_REQ_EVENT, vcpu);
-			kvm_vcpu_kick(vcpu);
-		} else {
-			trace_kvm_apicv_accept_irq(vcpu->vcpu_id, delivery_mode,
-						   trig_mode, vector);
-		}
 		break;
 	case APIC_DM_REMRD:

arch/x86/kvm/svm/svm.c+18−3

 		SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_INTR;
 }
+static void svm_deliver_interrupt(struct kvm_lapic *apic, int delivery_mode,
+				  int trig_mode, int vector)
+{
+	struct kvm_vcpu *vcpu = apic->vcpu;
+	if (svm_deliver_avic_intr(vcpu, vector)) {
+		kvm_lapic_set_irr(vector, apic);
+		kvm_make_request(KVM_REQ_EVENT, vcpu);
+		kvm_vcpu_kick(vcpu);
+	} else {
+		trace_kvm_apicv_accept_irq(vcpu->vcpu_id, delivery_mode,
+					   trig_mode, vector);
+	}
+}
 static void svm_update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
 {
 	struct vcpu_svm *svm = to_svm(vcpu);
 	struct vcpu_svm *svm = to_svm(vcpu);
 	unsigned long vmcb_pa = svm->current_vmcb->pa;
-	kvm_guest_enter_irqoff();
+	guest_state_enter_irqoff();
 	if (sev_es_guest(vcpu->kvm)) {
 		__svm_sev_es_vcpu_run(vmcb_pa);
 		vmload(__sme_page_pa(sd->save_area));
 	}
-	kvm_guest_exit_irqoff();
+	guest_state_exit_irqoff();
 }
 static __no_kcsan fastpath_t svm_vcpu_run(struct kvm_vcpu *vcpu)
 	.pmu_ops = &amd_pmu_ops,
 	.nested_ops = &svm_nested_ops,
-	.deliver_posted_interrupt = svm_deliver_avic_intr,
+	.deliver_interrupt = svm_deliver_interrupt,
 	.dy_apicv_has_pending_interrupt = svm_dy_apicv_has_pending_interrupt,
 	.update_pi_irte = svm_update_pi_irte,
 	.setup_mce = svm_setup_mce,

arch/x86/kvm/vmx/vmx.c+18−3

 	return 0;
 }
+static void vmx_deliver_interrupt(struct kvm_lapic *apic, int delivery_mode,
+				  int trig_mode, int vector)
+{
+	struct kvm_vcpu *vcpu = apic->vcpu;
+	if (vmx_deliver_posted_interrupt(vcpu, vector)) {
+		kvm_lapic_set_irr(vector, apic);
+		kvm_make_request(KVM_REQ_EVENT, vcpu);
+		kvm_vcpu_kick(vcpu);
+	} else {
+		trace_kvm_apicv_accept_irq(vcpu->vcpu_id, delivery_mode,
+					   trig_mode, vector);
+	}
+}
 /*
  * Set up the vmcs's constant host-state fields, i.e., host-state fields that
  * will not change in the lifetime of the guest.
 static noinstr void vmx_vcpu_enter_exit(struct kvm_vcpu *vcpu,
 					struct vcpu_vmx *vmx)
 {
-	kvm_guest_enter_irqoff();
+	guest_state_enter_irqoff();
 	/* L1D Flush includes CPU buffer clear to mitigate MDS */
 	if (static_branch_unlikely(&vmx_l1d_should_flush))
 	vcpu->arch.cr2 = native_read_cr2();
-	kvm_guest_exit_irqoff();
+	guest_state_exit_irqoff();
 }
 static fastpath_t vmx_vcpu_run(struct kvm_vcpu *vcpu)
 	.hwapic_isr_update = vmx_hwapic_isr_update,
 	.guest_apic_has_interrupt = vmx_guest_apic_has_interrupt,
 	.sync_pir_to_irr = vmx_sync_pir_to_irr,
-	.deliver_posted_interrupt = vmx_deliver_posted_interrupt,
+	.deliver_interrupt = vmx_deliver_interrupt,
 	.dy_apicv_has_pending_interrupt = pi_has_pending_interrupt,
 	.set_tss_addr = vmx_set_tss_addr,

arch/x86/kvm/x86.c+6−4

 u64 __read_mostly kvm_mce_cap_supported = MCG_CTL_P | MCG_SER_P;
 EXPORT_SYMBOL_GPL(kvm_mce_cap_supported);
+#define  ERR_PTR_USR(e)  ((void __user *)ERR_PTR(e))
 #define emul_to_vcpu(ctxt) \
 	((struct kvm_vcpu *)(ctxt)->vcpu)
 	void __user *uaddr = (void __user*)(unsigned long)attr->addr;
 	if ((u64)(unsigned long)uaddr != attr->addr)
-		return ERR_PTR(-EFAULT);
+		return ERR_PTR_USR(-EFAULT);
 	return uaddr;
 }
 		set_debugreg(0, 7);
 	}
+	guest_timing_enter_irqoff();
 	for (;;) {
 		/*
 		 * Assert that vCPU vs. VM APICv state is consistent.  An APICv
 	 * of accounting via context tracking, but the loss of accuracy is
 	 * acceptable for all known use cases.
 	 */
-	vtime_account_guest_exit();
+	guest_timing_exit_irqoff();
 	if (lapic_in_kernel(vcpu)) {
 		s64 delta = vcpu->arch.apic->lapic_timer.advance_expire_delta;
 	kvm_free_pit(kvm);
 }
-#define  ERR_PTR_USR(e)  ((void __user *)ERR_PTR(e))
 /**
  * __x86_set_memory_region: Setup KVM internal memory slot
  *

arch/x86/kvm/x86.h+0−45

@@ -10,51 +10,6 @@ · 9 unmodified lines
10		10
11	void kvm_spurious_fault(void);	11	void kvm_spurious_fault(void);
12		12
13	static __always_inline void kvm_guest_enter_irqoff(void)
14	{
15	/*
16	* VMENTER enables interrupts (host state), but the kernel state is
17	* interrupts disabled when this is invoked. Also tell RCU about
18	* it. This is the same logic as for exit_to_user_mode().
19	*
20	* This ensures that e.g. latency analysis on the host observes
21	* guest mode as interrupt enabled.
22	*
23	* guest_enter_irqoff() informs context tracking about the
24	* transition to guest mode and if enabled adjusts RCU state
25	* accordingly.
26	*/
27	instrumentation_begin();
28	trace_hardirqs_on_prepare();
29	lockdep_hardirqs_on_prepare(CALLER_ADDR0);
30	instrumentation_end();
31
32	guest_enter_irqoff();
33	lockdep_hardirqs_on(CALLER_ADDR0);
34	}
35
36	static __always_inline void kvm_guest_exit_irqoff(void)
37	{
38	/*
39	* VMEXIT disables interrupts (host state), but tracing and lockdep
40	* have them in state 'on' as recorded before entering guest mode.
41	* Same as enter_from_user_mode().
42	*
43	* context_tracking_guest_exit() restores host context and reinstates
44	* RCU if enabled and required.
45	*
46	* This needs to be done immediately after VM-Exit, before any code
47	* that might contain tracepoints or call out to the greater world,
48	* e.g. before x86_spec_ctrl_restore_host().
49	*/
50	lockdep_hardirqs_off(CALLER_ADDR0);
51	context_tracking_guest_exit();
52
53	instrumentation_begin();
54	trace_hardirqs_off_finish();
55	instrumentation_end();
56	}
57
58	#define KVM_NESTED_VMENTER_CONSISTENCY_CHECK(consistency_check) \	13	#define KVM_NESTED_VMENTER_CONSISTENCY_CHECK(consistency_check) \
59	({ \	14	({ \
60	bool failed = (consistency_check); \	15	bool failed = (consistency_check); \

arch/x86/xen/enlighten_hvm.c+4−9

 #include <xen/events.h>
 #include <xen/interface/memory.h>
+#include <asm/apic.h>
 #include <asm/cpu.h>
 #include <asm/smp.h>
 #include <asm/io_apic.h>
 }
 early_param("xen_no_vector_callback", xen_parse_no_vector_callback);
-bool __init xen_hvm_need_lapic(void)
+static __init bool xen_x2apic_available(void)
 {
-	if (xen_pv_domain())
+	return x2apic_supported();
-		return false;
-	if (!xen_hvm_domain())
-		return false;
-	if (xen_feature(XENFEAT_hvm_pirqs) && xen_have_vector_callback)
-		return false;
-	return true;
 }
 static __init void xen_hvm_guest_late_init(void)
 	.detect                 = xen_platform_hvm,
 	.type			= X86_HYPER_XEN_HVM,
 	.init.init_platform     = xen_hvm_guest_init,
-	.init.x2apic_available  = xen_x2apic_para_available,
+	.init.x2apic_available  = xen_x2apic_available,
 	.init.init_mem_mapping	= xen_hvm_init_mem_mapping,
 	.init.guest_late_init	= xen_hvm_guest_late_init,
 	.runtime.pin_vcpu       = xen_pin_vcpu,

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

@@ -1341,10 +1341,6 @@ asmlinkage __visible void __init xen_start_kernel(void) · 1340 unmodified lines
1341		1341
1342	xen_acpi_sleep_register();	1342	xen_acpi_sleep_register();
1343		1343
1344	/* Avoid searching for BIOS MP tables */
1345	x86_init.mpparse.find_smp_config = x86_init_noop;
1346	x86_init.mpparse.get_smp_config = x86_init_uint_noop;
1347
1348	xen_boot_params_init_edd();	1344	xen_boot_params_init_edd();
1349		1345
1350	#ifdef CONFIG_ACPI	1346	#ifdef CONFIG_ACPI

arch/x86/xen/smp_pv.c+6−20

@@ -148,28 +148,12 @@ int xen_smp_intr_init_pv(unsigned int cpu) · 147 unmodified lines
148	return rc;	148	return rc;
149	}	149	}
150		150
151	static void __init xen_fill_possible_map(void)	151	static void __init _get_smp_config(unsigned int early)
152	{
153	int i, rc;
154
155	if (xen_initial_domain())
156	return;
157
158	for (i = 0; i < nr_cpu_ids; i++) {
159	rc = HYPERVISOR_vcpu_op(VCPUOP_is_up, i, NULL);
160	if (rc >= 0) {
161	num_processors++;
162	set_cpu_possible(i, true);
163	}
164	}
165	}
166
167	static void __init xen_filter_cpu_maps(void)
168	{	152	{
169	int i, rc;	153	int i, rc;
170	unsigned int subtract = 0;	154	unsigned int subtract = 0;
171		155
172	if (!xen_initial_domain())	156	if (early)
173	return;	157	return;
174		158
175	num_processors = 0;	159	num_processors = 0;
@@ -210,7 +194,6 @@ static void __init xen_pv_smp_prepare_boot_cpu(void) · 34 unmodified lines
210	* sure the old memory can be recycled. */	194	* sure the old memory can be recycled. */
211	make_lowmem_page_readwrite(xen_initial_gdt);	195	make_lowmem_page_readwrite(xen_initial_gdt);
212		196
213	xen_filter_cpu_maps();
214	xen_setup_vcpu_info_placement();	197	xen_setup_vcpu_info_placement();
215		198
216	/*	199	/*
@@ -476,5 +459,8 @@ static const struct smp_ops xen_smp_ops __initconst = { · 259 unmodified lines
476	void __init xen_smp_init(void)	459	void __init xen_smp_init(void)
477	{	460	{
478	smp_ops = xen_smp_ops;	461	smp_ops = xen_smp_ops;
479	xen_fill_possible_map();	462
		463	/* Avoid searching for BIOS MP tables */
		464	x86_init.mpparse.find_smp_config = x86_init_noop;
		465	x86_init.mpparse.get_smp_config = _get_smp_config;
480	}	466	}

block/bio-integrity.c+1−1

@@ -373,7 +373,7 @@ void bio_integrity_advance(struct bio *bio, unsigned int bytes_done) · 372 unmodified lines
373	struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);	373	struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
374	unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9);	374	unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9);
375		375
376	bip->bip_iter.bi_sector += bytes_done >> 9;	376	bip->bip_iter.bi_sector += bio_integrity_intervals(bi, bytes_done >> 9);
377	bvec_iter_advance(bip->bip_vec, &bip->bip_iter, bytes);	377	bvec_iter_advance(bip->bip_vec, &bip->bip_iter, bytes);
378	}	378	}
379		379

block/fops.c+19−14

 {
 	struct block_device *bdev = iocb->ki_filp->private_data;
 	loff_t size = bdev_nr_bytes(bdev);
-	size_t count = iov_iter_count(to);
 	loff_t pos = iocb->ki_pos;
 	size_t shorted = 0;
 	ssize_t ret = 0;
+	size_t count;
-	if (unlikely(pos + count > size)) {
+	if (unlikely(pos + iov_iter_count(to) > size)) {
 		if (pos >= size)
 			return 0;
 		size -= pos;
-		if (count > size) {
+		shorted = iov_iter_count(to) - size;
-			shorted = count - size;
+		iov_iter_truncate(to, size);
-			iov_iter_truncate(to, size);
-		}
 	}
+	count = iov_iter_count(to);
+	if (!count)
+		goto reexpand; /* skip atime */
 	if (iocb->ki_flags & IOCB_DIRECT) {
 		struct address_space *mapping = iocb->ki_filp->f_mapping;
 		if (iocb->ki_flags & IOCB_NOWAIT) {
-			if (filemap_range_needs_writeback(mapping, iocb->ki_pos,
+			if (filemap_range_needs_writeback(mapping, pos,
-						iocb->ki_pos + count - 1))
+							  pos + count - 1)) {
-				return -EAGAIN;
+				ret = -EAGAIN;
+				goto reexpand;
+			}
 		} else {
-			ret = filemap_write_and_wait_range(mapping,
+			ret = filemap_write_and_wait_range(mapping, pos,
-						iocb->ki_pos,
+							   pos + count - 1);
-					        iocb->ki_pos + count - 1);
 			if (ret < 0)
-				return ret;
+				goto reexpand;
 		}
 		file_accessed(iocb->ki_filp);
 			iocb->ki_pos += ret;
 			count -= ret;
 		}
+		iov_iter_revert(to, count - iov_iter_count(to));
 		if (ret < 0 || !count)
-			return ret;
+			goto reexpand;
 	}
 	ret = filemap_read(iocb, to, ret);
+reexpand:
 	if (unlikely(shorted))
 		iov_iter_reexpand(to, iov_iter_count(to) + shorted);
 	return ret;

crypto/algapi.c+1−0

@@ -1324,3 +1324,4 @@ module_exit(crypto_algapi_exit); · 1323 unmodified lines
1324		1324
1325	MODULE_LICENSE("GPL");	1325	MODULE_LICENSE("GPL");
1326	MODULE_DESCRIPTION("Cryptographic algorithms API");	1326	MODULE_DESCRIPTION("Cryptographic algorithms API");
		1327	MODULE_SOFTDEP("pre: cryptomgr");

crypto/api.c+0−1

@@ -643,4 +643,3 @@ EXPORT_SYMBOL_GPL(crypto_req_done); · 642 unmodified lines
643		643
644	MODULE_DESCRIPTION("Cryptographic core API");	644	MODULE_DESCRIPTION("Cryptographic core API");
645	MODULE_LICENSE("GPL");	645	MODULE_LICENSE("GPL");
646	MODULE_SOFTDEP("pre: cryptomgr");

crypto/blake2s_generic.c+2−2

@@ -15,12 +15,12 @@ · 14 unmodified lines
15	static int crypto_blake2s_update_generic(struct shash_desc *desc,	15	static int crypto_blake2s_update_generic(struct shash_desc *desc,
16	const u8 *in, unsigned int inlen)	16	const u8 *in, unsigned int inlen)
17	{	17	{
18	return crypto_blake2s_update(desc, in, inlen, blake2s_compress_generic);	18	return crypto_blake2s_update(desc, in, inlen, true);
19	}	19	}
20		20
21	static int crypto_blake2s_final_generic(struct shash_desc desc, u8 out)	21	static int crypto_blake2s_final_generic(struct shash_desc desc, u8 out)
22	{	22	{
23	return crypto_blake2s_final(desc, out, blake2s_compress_generic);	23	return crypto_blake2s_final(desc, out, true);
24	}	24	}
25		25
26	#define BLAKE2S_ALG(name, driver_name, digest_size) \	26	#define BLAKE2S_ALG(name, driver_name, digest_size) \

drivers/acpi/Kconfig+1−0

@@ -11,6 +11,7 @@ menuconfig ACPI · 10 unmodified lines
11	depends on ARCH_SUPPORTS_ACPI	11	depends on ARCH_SUPPORTS_ACPI
12	select PNP	12	select PNP
13	select NLS	13	select NLS
		14	select CRC32
14	default y if X86	15	default y if X86
15	help	16	help
16	Advanced Configuration and Power Interface (ACPI) support for	17	Advanced Configuration and Power Interface (ACPI) support for

drivers/ata/libata-core.c+16−8

 {
 	struct ata_port *ap = dev->link->ap;
+	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)
+		return false;
 	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
 		return false;
 	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
 	struct ata_cpr_log *cpr_log = NULL;
 	u8 *desc, *buf = NULL;
-	if (!ata_identify_page_supported(dev,
+	if (ata_id_major_version(dev->id) < 11 ||
-				 ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
 		goto out;
 	/*
-	 * Read IDENTIFY DEVICE data log, page 0x47
+	 * Read the concurrent positioning ranges log (0x47). We can have at
-	 * (concurrent positioning ranges). We can have at most 255 32B range
+	 * most 255 32B range descriptors plus a 64B header.
-	 * descriptors plus a 64B header.
 	 */
 	buf_len = (64 + 255 * 32 + 511) & ~511;
 	buf = kzalloc(buf_len, GFP_KERNEL);
 	if (!buf)
 		goto out;
-	err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
+	err_mask = ata_read_log_page(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES,
-				     ATA_LOG_CONCURRENT_POSITIONING_RANGES,
+				     0, buf, buf_len >> 9);
-				     buf, buf_len >> 9);
 	if (err_mask)
 		goto out;
 	{ "WDC WD3000JD-*",		NULL,	ATA_HORKAGE_WD_BROKEN_LPM },
 	{ "WDC WD3200JD-*",		NULL,	ATA_HORKAGE_WD_BROKEN_LPM },
+	/*
+	 * This sata dom device goes on a walkabout when the ATA_LOG_DIRECTORY
+	 * log page is accessed. Ensure we never ask for this log page with
+	 * these devices.
+	 */
+	{ "SATADOM-ML 3ME",		NULL,	ATA_HORKAGE_NO_LOG_DIR },
 	/* End Marker */
 	{ }
 };

drivers/char/random.c+22−17

 	return arch_init;
 }
-static bool __init crng_init_try_arch_early(struct crng_state *crng)
+static bool __init crng_init_try_arch_early(void)
 {
 	int i;
 	bool arch_init = true;
 			rv = random_get_entropy();
 			arch_init = false;
 		}
-		crng->state[i] ^= rv;
+		primary_crng.state[i] ^= rv;
 	}
 	return arch_init;
 	crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
 }
-static void __init crng_initialize_primary(struct crng_state *crng)
+static void __init crng_initialize_primary(void)
 {
-	_extract_entropy(&crng->state[4], sizeof(u32) * 12);
+	_extract_entropy(&primary_crng.state[4], sizeof(u32) * 12);
-	if (crng_init_try_arch_early(crng) && trust_cpu && crng_init < 2) {
+	if (crng_init_try_arch_early() && trust_cpu && crng_init < 2) {
 		invalidate_batched_entropy();
 		numa_crng_init();
 		crng_init = 2;
 		pr_notice("crng init done (trusting CPU's manufacturer)\n");
 	}
-	crng->init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
+	primary_crng.init_time = jiffies - CRNG_RESEED_INTERVAL - 1;
 }
-static void crng_finalize_init(struct crng_state *crng)
+static void crng_finalize_init(void)
 {
-	if (crng != &primary_crng || crng_init >= 2)
-		return;
 	if (!system_wq) {
 		/* We can't call numa_crng_init until we have workqueues,
 		 * so mark this for processing later. */
 	invalidate_batched_entropy();
 	numa_crng_init();
 	crng_init = 2;
+	crng_need_final_init = false;
 	process_random_ready_list();
 	wake_up_interruptible(&crng_init_wait);
 	kill_fasync(&fasync, SIGIO, POLL_IN);
 	memzero_explicit(&buf, sizeof(buf));
 	WRITE_ONCE(crng->init_time, jiffies);
 	spin_unlock_irqrestore(&crng->lock, flags);
-	crng_finalize_init(crng);
+	if (crng == &primary_crng && crng_init < 2)
+		crng_finalize_init();
 }
 static void _extract_crng(struct crng_state *crng, u8 out[CHACHA_BLOCK_SIZE])
 {
 	init_std_data();
 	if (crng_need_final_init)
-		crng_finalize_init(&primary_crng);
+		crng_finalize_init();
-	crng_initialize_primary(&primary_crng);
+	crng_initialize_primary();
 	crng_global_init_time = jiffies;
 	if (ratelimit_disable) {
 		urandom_warning.interval = 0;
 		 */
 		if (!capable(CAP_SYS_ADMIN))
 			return -EPERM;
-		input_pool.entropy_count = 0;
+		if (xchg(&input_pool.entropy_count, 0) && random_write_wakeup_bits) {
+			wake_up_interruptible(&random_write_wait);
+			kill_fasync(&fasync, SIGIO, POLL_OUT);
+		}
 		return 0;
 	case RNDRESEEDCRNG:
 		if (!capable(CAP_SYS_ADMIN))
 			return;
 	}
-	/* Suspend writing if we're above the trickle threshold.
+	/* Throttle writing if we're above the trickle threshold.
 	 * We'll be woken up again once below random_write_wakeup_thresh,
-	 * or when the calling thread is about to terminate.
+	 * when the calling thread is about to terminate, or once
+	 * CRNG_RESEED_INTERVAL has lapsed.
 	 */
-	wait_event_interruptible(random_write_wait,
+	wait_event_interruptible_timeout(random_write_wait,
 			!system_wq || kthread_should_stop() ||
-			POOL_ENTROPY_BITS() <= random_write_wakeup_bits);
+			POOL_ENTROPY_BITS() <= random_write_wakeup_bits,
+			CRNG_RESEED_INTERVAL);
 	mix_pool_bytes(buffer, count);
 	credit_entropy_bits(entropy);
 }

drivers/crypto/marvell/octeontx2/otx2_cptpf_ucode.c+2−1

 	char engs_info[2 * OTX2_CPT_NAME_LENGTH];
 	struct otx2_cpt_eng_grp_info *grp;
 	struct otx2_cpt_engs_rsvd *engs;
-	u32 mask[4];
 	int i, j;
 	pr_debug("Engine groups global info");
 		for (j = 0; j < OTX2_CPT_MAX_ETYPES_PER_GRP; j++) {
 			engs = &grp->engs[j];
 			if (engs->type) {
+				u32 mask[5] = { };
 				get_engs_info(grp, engs_info,
 					      2 * OTX2_CPT_NAME_LENGTH, j);
 				pr_debug("Slot%d: %s", j, engs_info);

drivers/dma-buf/dma-heap.c+2−0

 #include <linux/xarray.h>
 #include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/nospec.h>
 #include <linux/uaccess.h>
 #include <linux/syscalls.h>
 #include <linux/dma-heap.h>
 	if (nr >= ARRAY_SIZE(dma_heap_ioctl_cmds))
 		return -EINVAL;
+	nr = array_index_nospec(nr, ARRAY_SIZE(dma_heap_ioctl_cmds));
 	/* Get the kernel ioctl cmd that matches */
 	kcmd = dma_heap_ioctl_cmds[nr];

drivers/edac/altera_edac.c+1−1

@@ -350,7 +350,7 @@ static int altr_sdram_probe(struct platform_device *pdev) · 349 unmodified lines
350	if (irq < 0) {	350	if (irq < 0) {
351	edac_printk(KERN_ERR, EDAC_MC,	351	edac_printk(KERN_ERR, EDAC_MC,
352	"No irq %d in DT\n", irq);	352	"No irq %d in DT\n", irq);
353	return -ENODEV;	353	return irq;
354	}	354	}
355		355
356	/* Arria10 has a 2nd IRQ */	356	/* Arria10 has a 2nd IRQ */

drivers/edac/xgene_edac.c+1−1

@@ -1919,7 +1919,7 @@ static int xgene_edac_probe(struct platform_device *pdev) · 1918 unmodified lines
1919	irq = platform_get_irq_optional(pdev, i);	1919	irq = platform_get_irq_optional(pdev, i);
1920	if (irq < 0) {	1920	if (irq < 0) {
1921	dev_err(&pdev->dev, "No IRQ resource\n");	1921	dev_err(&pdev->dev, "No IRQ resource\n");
1922	rc = -EINVAL;	1922	rc = irq;
1923	goto out_err;	1923	goto out_err;
1924	}	1924	}
1925	rc = devm_request_irq(&pdev->dev, irq,	1925	rc = devm_request_irq(&pdev->dev, irq,

drivers/gpu/drm/amd/amdgpu/amdgpu.h+8−2

 int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev);
 void amdgpu_acpi_get_backlight_caps(struct amdgpu_dm_backlight_caps *caps);
-bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev);
 void amdgpu_acpi_detect(void);
 #else
 static inline int amdgpu_acpi_init(struct amdgpu_device *adev) { return 0; }
 static inline void amdgpu_acpi_fini(struct amdgpu_device *adev) { }
-static inline bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev) { return false; }
 static inline void amdgpu_acpi_detect(void) { }
 static inline bool amdgpu_acpi_is_power_shift_control_supported(void) { return false; }
 static inline int amdgpu_acpi_power_shift_control(struct amdgpu_device *adev,
 						 enum amdgpu_ss ss_state) { return 0; }
 #endif
+#if defined(CONFIG_ACPI) && defined(CONFIG_SUSPEND)
+bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev);
+bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev);
+#else
+static inline bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev) { return false; }
+static inline bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev) { return false; }
+#endif
 int amdgpu_cs_find_mapping(struct amdgpu_cs_parser *parser,
 			   uint64_t addr, struct amdgpu_bo **bo,
 			   struct amdgpu_bo_va_mapping **mapping);

drivers/gpu/drm/amd/amdgpu/amdgpu_acpi.c+32−5

@@ -1031,6 +1031,20 @@ void amdgpu_acpi_detect(void) · 1030 unmodified lines
1031	}	1031	}
1032	}	1032	}
1033		1033
		1034	#if IS_ENABLED(CONFIG_SUSPEND)
		1035	/**
		1036	* amdgpu_acpi_is_s3_active
		1037	*
		1038	* @adev: amdgpu_device_pointer
		1039	*
		1040	* returns true if supported, false if not.
		1041	*/
		1042	bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev)
		1043	{
		1044	return !(adev->flags & AMD_IS_APU) \|\|
		1045	(pm_suspend_target_state == PM_SUSPEND_MEM);
		1046	}
		1047
1034	/**	1048	/**
1035	* amdgpu_acpi_is_s0ix_active	1049	* amdgpu_acpi_is_s0ix_active
1036	*	1050	*
@@ -1040,11 +1054,24 @@ void amdgpu_acpi_detect(void) · 3 unmodified lines
1040	*/	1054	*/
1041	bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev)	1055	bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev)
1042	{	1056	{
1043	#if IS_ENABLED(CONFIG_AMD_PMC) && IS_ENABLED(CONFIG_SUSPEND)	1057	if (!(adev->flags & AMD_IS_APU) \|\|
1044	if (acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0) {	1058	(pm_suspend_target_state != PM_SUSPEND_TO_IDLE))
1045	if (adev->flags & AMD_IS_APU)	1059	return false;
1046	return pm_suspend_target_state == PM_SUSPEND_TO_IDLE;	1060
		1061	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) {
		1062	dev_warn_once(adev->dev,
		1063	"Power consumption will be higher as BIOS has not been configured for suspend-to-idle.\n"
		1064	"To use suspend-to-idle change the sleep mode in BIOS setup.\n");
		1065	return false;
1047	}	1066	}
1048	#endif	1067
		1068	#if !IS_ENABLED(CONFIG_AMD_PMC)
		1069	dev_warn_once(adev->dev,
		1070	"Power consumption will be higher as the kernel has not been compiled with CONFIG_AMD_PMC.\n");
1049	return false;	1071	return false;
		1072	#else
		1073	return true;
		1074	#endif /* CONFIG_AMD_PMC */
1050	}	1075	}
		1076
		1077	#endif /* CONFIG_SUSPEND */

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+9−2

@@ -2246,13 +2246,20 @@ static void amdgpu_drv_delayed_reset_work_handler(struct work_struct *work) · 2245 unmodified lines
2246	static int amdgpu_pmops_prepare(struct device *dev)	2246	static int amdgpu_pmops_prepare(struct device *dev)
2247	{	2247	{
2248	struct drm_device *drm_dev = dev_get_drvdata(dev);	2248	struct drm_device *drm_dev = dev_get_drvdata(dev);
		2249	struct amdgpu_device *adev = drm_to_adev(drm_dev);
2249		2250
2250	/* Return a positive number here so	2251	/* Return a positive number here so
2251	* DPM_FLAG_SMART_SUSPEND works properly	2252	* DPM_FLAG_SMART_SUSPEND works properly
2252	*/	2253	*/
2253	if (amdgpu_device_supports_boco(drm_dev))	2254	if (amdgpu_device_supports_boco(drm_dev))
2254	return pm_runtime_suspended(dev) &&	2255	return pm_runtime_suspended(dev);
2255	pm_suspend_via_firmware();	2256
		2257	/* if we will not support s3 or s2i for the device
		2258	* then skip suspend
		2259	*/
		2260	if (!amdgpu_acpi_is_s0ix_active(adev) &&
		2261	!amdgpu_acpi_is_s3_active(adev))
		2262	return 1;
2256		2263
2257	return 0;	2264	return 0;
2258	}	2265	}

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

@@ -1904,7 +1904,7 @@ int amdgpu_copy_buffer(struct amdgpu_ring *ring, uint64_t src_offset, · 1903 unmodified lines
1904	unsigned i;	1904	unsigned i;
1905	int r;	1905	int r;
1906		1906
1907	if (direct_submit && !ring->sched.ready) {	1907	if (!direct_submit && !ring->sched.ready) {
1908	DRM_ERROR("Trying to move memory with ring turned off.\n");	1908	DRM_ERROR("Trying to move memory with ring turned off.\n");
1909	return -EINVAL;	1909	return -EINVAL;
1910	}	1910	}

drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c+3−0

@@ -1140,6 +1140,9 @@ static void gmc_v10_0_get_clockgating_state(void handle, u32 flags) · 1139 unmodified lines
1140	{	1140	{
1141	struct amdgpu_device adev = (struct amdgpu_device )handle;	1141	struct amdgpu_device adev = (struct amdgpu_device )handle;
1142		1142
		1143	if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 1, 3))
		1144	return;
		1145
1143	adev->mmhub.funcs->get_clockgating(adev, flags);	1146	adev->mmhub.funcs->get_clockgating(adev, flags);
1144		1147
1145	if (adev->ip_versions[ATHUB_HWIP][0] >= IP_VERSION(2, 1, 0))	1148	if (adev->ip_versions[ATHUB_HWIP][0] >= IP_VERSION(2, 1, 0))

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn301/vg_clk_mgr.c+8−8

@@ -570,32 +570,32 @@ static struct wm_table lpddr5_wm_table = { · 569 unmodified lines
570	.wm_inst = WM_A,	570	.wm_inst = WM_A,
571	.wm_type = WM_TYPE_PSTATE_CHG,	571	.wm_type = WM_TYPE_PSTATE_CHG,
572	.pstate_latency_us = 11.65333,	572	.pstate_latency_us = 11.65333,
573	.sr_exit_time_us = 7.95,	573	.sr_exit_time_us = 13.5,
574	.sr_enter_plus_exit_time_us = 9,	574	.sr_enter_plus_exit_time_us = 16.5,
575	.valid = true,	575	.valid = true,
576	},	576	},
577	{	577	{
578	.wm_inst = WM_B,	578	.wm_inst = WM_B,
579	.wm_type = WM_TYPE_PSTATE_CHG,	579	.wm_type = WM_TYPE_PSTATE_CHG,
580	.pstate_latency_us = 11.65333,	580	.pstate_latency_us = 11.65333,
581	.sr_exit_time_us = 9.82,	581	.sr_exit_time_us = 13.5,
582	.sr_enter_plus_exit_time_us = 11.196,	582	.sr_enter_plus_exit_time_us = 16.5,
583	.valid = true,	583	.valid = true,
584	},	584	},
585	{	585	{
586	.wm_inst = WM_C,	586	.wm_inst = WM_C,
587	.wm_type = WM_TYPE_PSTATE_CHG,	587	.wm_type = WM_TYPE_PSTATE_CHG,
588	.pstate_latency_us = 11.65333,	588	.pstate_latency_us = 11.65333,
589	.sr_exit_time_us = 9.89,	589	.sr_exit_time_us = 13.5,
590	.sr_enter_plus_exit_time_us = 11.24,	590	.sr_enter_plus_exit_time_us = 16.5,
591	.valid = true,	591	.valid = true,
592	},	592	},
593	{	593	{
594	.wm_inst = WM_D,	594	.wm_inst = WM_D,
595	.wm_type = WM_TYPE_PSTATE_CHG,	595	.wm_type = WM_TYPE_PSTATE_CHG,
596	.pstate_latency_us = 11.65333,	596	.pstate_latency_us = 11.65333,
597	.sr_exit_time_us = 9.748,	597	.sr_exit_time_us = 13.5,
598	.sr_enter_plus_exit_time_us = 11.102,	598	.sr_enter_plus_exit_time_us = 16.5,
599	.valid = true,	599	.valid = true,
600	},	600	},
601	}	601	}

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn31/dcn31_clk_mgr.c+10−10

@@ -329,38 +329,38 @@ static struct clk_bw_params dcn31_bw_params = { · 328 unmodified lines
329		329
330	};	330	};
331		331
332	static struct wm_table ddr4_wm_table = {	332	static struct wm_table ddr5_wm_table = {
333	.entries = {	333	.entries = {
334	{	334	{
335	.wm_inst = WM_A,	335	.wm_inst = WM_A,
336	.wm_type = WM_TYPE_PSTATE_CHG,	336	.wm_type = WM_TYPE_PSTATE_CHG,
337	.pstate_latency_us = 11.72,	337	.pstate_latency_us = 11.72,
338	.sr_exit_time_us = 6.09,	338	.sr_exit_time_us = 9,
339	.sr_enter_plus_exit_time_us = 7.14,	339	.sr_enter_plus_exit_time_us = 11,
340	.valid = true,	340	.valid = true,
341	},	341	},
342	{	342	{
343	.wm_inst = WM_B,	343	.wm_inst = WM_B,
344	.wm_type = WM_TYPE_PSTATE_CHG,	344	.wm_type = WM_TYPE_PSTATE_CHG,
345	.pstate_latency_us = 11.72,	345	.pstate_latency_us = 11.72,
346	.sr_exit_time_us = 10.12,	346	.sr_exit_time_us = 9,
347	.sr_enter_plus_exit_time_us = 11.48,	347	.sr_enter_plus_exit_time_us = 11,
348	.valid = true,	348	.valid = true,
349	},	349	},
350	{	350	{
351	.wm_inst = WM_C,	351	.wm_inst = WM_C,
352	.wm_type = WM_TYPE_PSTATE_CHG,	352	.wm_type = WM_TYPE_PSTATE_CHG,
353	.pstate_latency_us = 11.72,	353	.pstate_latency_us = 11.72,
354	.sr_exit_time_us = 10.12,	354	.sr_exit_time_us = 9,
355	.sr_enter_plus_exit_time_us = 11.48,	355	.sr_enter_plus_exit_time_us = 11,
356	.valid = true,	356	.valid = true,
357	},	357	},
358	{	358	{
359	.wm_inst = WM_D,	359	.wm_inst = WM_D,
360	.wm_type = WM_TYPE_PSTATE_CHG,	360	.wm_type = WM_TYPE_PSTATE_CHG,
361	.pstate_latency_us = 11.72,	361	.pstate_latency_us = 11.72,
362	.sr_exit_time_us = 10.12,	362	.sr_exit_time_us = 9,
363	.sr_enter_plus_exit_time_us = 11.48,	363	.sr_enter_plus_exit_time_us = 11,
364	.valid = true,	364	.valid = true,
365	},	365	},
366	}	366	}
@@ -687,7 +687,7 @@ void dcn31_clk_mgr_construct( · 320 unmodified lines
687	if (ctx->dc_bios->integrated_info->memory_type == LpDdr5MemType) {	687	if (ctx->dc_bios->integrated_info->memory_type == LpDdr5MemType) {
688	dcn31_bw_params.wm_table = lpddr5_wm_table;	688	dcn31_bw_params.wm_table = lpddr5_wm_table;
689	} else {	689	} else {
690	dcn31_bw_params.wm_table = ddr4_wm_table;	690	dcn31_bw_params.wm_table = ddr5_wm_table;
691	}	691	}
692	/* Saved clocks configured at boot for debug purposes */	692	/* Saved clocks configured at boot for debug purposes */
693	dcn31_dump_clk_registers(&clk_mgr->base.base.boot_snapshot, &clk_mgr->base.base, &log_info);	693	dcn31_dump_clk_registers(&clk_mgr->base.base.boot_snapshot, &clk_mgr->base.base, &log_info);

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

@@ -5597,6 +5597,26 @@ static bool retrieve_link_cap(struct dc_link *link) · 5596 unmodified lines
5597	dp_hw_fw_revision.ieee_fw_rev,	5597	dp_hw_fw_revision.ieee_fw_rev,
5598	sizeof(dp_hw_fw_revision.ieee_fw_rev));	5598	sizeof(dp_hw_fw_revision.ieee_fw_rev));
5599		5599
		5600	/* Quirk for Apple MBP 2018 15" Retina panels: wrong DP_MAX_LINK_RATE */
		5601	{
		5602	uint8_t str_mbp_2018[] = { 101, 68, 21, 103, 98, 97 };
		5603	uint8_t fwrev_mbp_2018[] = { 7, 4 };
		5604	uint8_t fwrev_mbp_2018_vega[] = { 8, 4 };
		5605
		5606	/* We also check for the firmware revision as 16,1 models have an
		5607	* identical device id and are incorrectly quirked otherwise.
		5608	*/
		5609	if ((link->dpcd_caps.sink_dev_id == 0x0010fa) &&
		5610	!memcmp(link->dpcd_caps.sink_dev_id_str, str_mbp_2018,
		5611	sizeof(str_mbp_2018)) &&
		5612	(!memcmp(link->dpcd_caps.sink_fw_revision, fwrev_mbp_2018,
		5613	sizeof(fwrev_mbp_2018)) \|\|
		5614	!memcmp(link->dpcd_caps.sink_fw_revision, fwrev_mbp_2018_vega,
		5615	sizeof(fwrev_mbp_2018_vega)))) {
		5616	link->reported_link_cap.link_rate = LINK_RATE_RBR2;
		5617	}
		5618	}
		5619
5600	memset(&link->dpcd_caps.dsc_caps, '\0',	5620	memset(&link->dpcd_caps.dsc_caps, '\0',
5601	sizeof(link->dpcd_caps.dsc_caps));	5621	sizeof(link->dpcd_caps.dsc_caps));
5602	memset(&link->dpcd_caps.fec_cap, '\0', sizeof(link->dpcd_caps.fec_cap));	5622	memset(&link->dpcd_caps.fec_cap, '\0', sizeof(link->dpcd_caps.fec_cap));

drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c+0−5

 			pipe_ctx->stream_res.stream_enc,
 			pipe_ctx->stream_res.tg->inst);
-	if (dc_is_embedded_signal(pipe_ctx->stream->signal) &&
-		pipe_ctx->stream_res.stream_enc->funcs->reset_fifo)
-		pipe_ctx->stream_res.stream_enc->funcs->reset_fifo(
-			pipe_ctx->stream_res.stream_enc);
 	if (dc_is_dp_signal(pipe_ctx->stream->signal))
 		dp_source_sequence_trace(link, DPCD_SOURCE_SEQ_AFTER_CONNECT_DIG_FE_OTG);

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c+0−15

@@ -902,19 +902,6 @@ void enc1_stream_encoder_stop_dp_info_packets( · 901 unmodified lines
902		902
903	}	903	}
904		904
905	void enc1_stream_encoder_reset_fifo(
906	struct stream_encoder *enc)
907	{
908	struct dcn10_stream_encoder *enc1 = DCN10STRENC_FROM_STRENC(enc);
909
910	/* set DIG_START to 0x1 to reset FIFO */
911	REG_UPDATE(DIG_FE_CNTL, DIG_START, 1);
912	udelay(100);
913
914	/* write 0 to take the FIFO out of reset */
915	REG_UPDATE(DIG_FE_CNTL, DIG_START, 0);
916	}
917
918	void enc1_stream_encoder_dp_blank(	905	void enc1_stream_encoder_dp_blank(
919	struct dc_link *link,	906	struct dc_link *link,
920	struct stream_encoder *enc)	907	struct stream_encoder *enc)
@@ -1600,8 +1587,6 @@ static const struct stream_encoder_funcs dcn10_str_enc_funcs = { · 679 unmodified lines
1600	enc1_stream_encoder_send_immediate_sdp_message,	1587	enc1_stream_encoder_send_immediate_sdp_message,
1601	.stop_dp_info_packets =	1588	.stop_dp_info_packets =
1602	enc1_stream_encoder_stop_dp_info_packets,	1589	enc1_stream_encoder_stop_dp_info_packets,
1603	.reset_fifo =
1604	enc1_stream_encoder_reset_fifo,
1605	.dp_blank =	1590	.dp_blank =
1606	enc1_stream_encoder_dp_blank,	1591	enc1_stream_encoder_dp_blank,
1607	.dp_unblank =	1592	.dp_unblank =

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.h+0−3

@@ -626,9 +626,6 @@ void enc1_stream_encoder_send_immediate_sdp_message( · 625 unmodified lines
626	void enc1_stream_encoder_stop_dp_info_packets(	626	void enc1_stream_encoder_stop_dp_info_packets(
627	struct stream_encoder *enc);	627	struct stream_encoder *enc);
628		628
629	void enc1_stream_encoder_reset_fifo(
630	struct stream_encoder *enc);
631
632	void enc1_stream_encoder_dp_blank(	629	void enc1_stream_encoder_dp_blank(
633	struct dc_link *link,	630	struct dc_link *link,
634	struct stream_encoder *enc);	631	struct stream_encoder *enc);

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_stream_encoder.c+0−2

 		enc1_stream_encoder_send_immediate_sdp_message,
 	.stop_dp_info_packets =
 		enc1_stream_encoder_stop_dp_info_packets,
-	.reset_fifo =
-		enc1_stream_encoder_reset_fifo,
 	.dp_blank =
 		enc1_stream_encoder_dp_blank,
 	.dp_unblank =

drivers/gpu/drm/amd/display/dc/dcn30/dcn30_dio_stream_encoder.c+0−2

 		enc3_stream_encoder_update_dp_info_packets,
 	.stop_dp_info_packets =
 		enc1_stream_encoder_stop_dp_info_packets,
-	.reset_fifo =
-		enc1_stream_encoder_reset_fifo,
 	.dp_blank =
 		enc1_stream_encoder_dp_blank,
 	.dp_unblank =

drivers/gpu/drm/amd/display/dc/inc/hw/stream_encoder.h+0−4

 	void (*stop_dp_info_packets)(
 		struct stream_encoder *enc);
-	void (*reset_fifo)(
-		struct stream_encoder *enc
-	);
 	void (*dp_blank)(
 		struct dc_link *link,
 		struct stream_encoder *enc);

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

 static int sienna_cichlid_enable_mgpu_fan_boost(struct smu_context *smu)
 {
-	struct smu_table_context *table_context = &smu->smu_table;
+	uint16_t *mgpu_fan_boost_limit_rpm;
-	PPTable_t *smc_pptable = table_context->driver_pptable;
+	GET_PPTABLE_MEMBER(MGpuFanBoostLimitRpm, &mgpu_fan_boost_limit_rpm);
 	/*
 	 * Skip the MGpuFanBoost setting for those ASICs
 	 * which do not support it
 	 */
-	if (!smc_pptable->MGpuFanBoostLimitRpm)
+	if (*mgpu_fan_boost_limit_rpm == 0)
 		return 0;
 	return smu_cmn_send_smc_msg_with_param(smu,

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

@@ -959,6 +959,9 @@ static int check_overlay_dst(struct intel_overlay *overlay, · 958 unmodified lines
959	const struct intel_crtc_state *pipe_config =	959	const struct intel_crtc_state *pipe_config =
960	overlay->crtc->config;	960	overlay->crtc->config;
961		961
		962	if (rec->dst_height == 0 \|\| rec->dst_width == 0)
		963	return -EINVAL;
		964
962	if (rec->dst_x < pipe_config->pipe_src_w &&	965	if (rec->dst_x < pipe_config->pipe_src_w &&
963	rec->dst_x + rec->dst_width <= pipe_config->pipe_src_w &&	966	rec->dst_x + rec->dst_width <= pipe_config->pipe_src_w &&
964	rec->dst_y < pipe_config->pipe_src_h &&	967	rec->dst_y < pipe_config->pipe_src_h &&

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

 static bool adl_tc_phy_status_complete(struct intel_digital_port *dig_port)
 {
 	struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
+	enum tc_port tc_port = intel_port_to_tc(i915, dig_port->base.port);
 	struct intel_uncore *uncore = &i915->uncore;
 	u32 val;
-	val = intel_uncore_read(uncore, TCSS_DDI_STATUS(dig_port->tc_phy_fia_idx));
+	val = intel_uncore_read(uncore, TCSS_DDI_STATUS(tc_port));
 	if (val == 0xffffffff) {
 		drm_dbg_kms(&i915->drm,
 			    "Port %s: PHY in TCCOLD, assuming not complete\n",

drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c+7−2

 				      timeout) < 0) {
 			i915_request_put(rq);
-			tl = intel_context_timeline_lock(ce);
+			/*
+			 * Error path, cannot use intel_context_timeline_lock as
+			 * that is user interruptable and this clean up step
+			 * must be done.
+			 */
+			mutex_lock(&ce->timeline->mutex);
 			intel_context_exit(ce);
-			intel_context_timeline_unlock(tl);
+			mutex_unlock(&ce->timeline->mutex);
 			if (nonblock)
 				return -EWOULDBLOCK;

drivers/gpu/drm/i915/gt/uc/intel_guc.h+5−0

 		 * context usage for overflows.
 		 */
 		struct delayed_work work;
+		/**
+		 * @shift: Right shift value for the gpm timestamp
+		 */
+		u32 shift;
 	} timestamp;
 #ifdef CONFIG_DRM_I915_SELFTEST

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c+97−17

@@ -1113,6 +1113,19 @@ __extend_last_switch(struct intel_guc guc, u64 prev_start, u32 new_start) · 1112 unmodified lines
1113	if (new_start == lower_32_bits(*prev_start))	1113	if (new_start == lower_32_bits(*prev_start))
1114	return;	1114	return;
1115		1115
		1116	/*
		1117	* When gt is unparked, we update the gt timestamp and start the ping
		1118	* worker that updates the gt_stamp every POLL_TIME_CLKS. As long as gt
		1119	* is unparked, all switched in contexts will have a start time that is
		1120	* within +/- POLL_TIME_CLKS of the most recent gt_stamp.
		1121	*
		1122	* If neither gt_stamp nor new_start has rolled over, then the
		1123	* gt_stamp_hi does not need to be adjusted, however if one of them has
		1124	* rolled over, we need to adjust gt_stamp_hi accordingly.
		1125	*
		1126	* The below conditions address the cases of new_start rollover and
		1127	* gt_stamp_last rollover respectively.
		1128	*/
1116	if (new_start < gt_stamp_last &&	1129	if (new_start < gt_stamp_last &&
1117	(new_start - gt_stamp_last) <= POLL_TIME_CLKS)	1130	(new_start - gt_stamp_last) <= POLL_TIME_CLKS)
1118	gt_stamp_hi++;	1131	gt_stamp_hi++;
@@ -1124,17 +1137,45 @@ __extend_last_switch(struct intel_guc guc, u64 prev_start, u32 new_start) · 5 unmodified lines
1124	*prev_start = ((u64)gt_stamp_hi << 32) \| new_start;	1137	*prev_start = ((u64)gt_stamp_hi << 32) \| new_start;
1125	}	1138	}
1126		1139
1127	static void guc_update_engine_gt_clks(struct intel_engine_cs *engine)	1140	/*
		1141	* GuC updates shared memory and KMD reads it. Since this is not synchronized,
		1142	* we run into a race where the value read is inconsistent. Sometimes the
		1143	* inconsistency is in reading the upper MSB bytes of the last_in value when
		1144	* this race occurs. 2 types of cases are seen - upper 8 bits are zero and upper
		1145	* 24 bits are zero. Since these are non-zero values, it is non-trivial to
		1146	* determine validity of these values. Instead we read the values multiple times
		1147	* until they are consistent. In test runs, 3 attempts results in consistent
		1148	* values. The upper bound is set to 6 attempts and may need to be tuned as per
		1149	* any new occurences.
		1150	*/
		1151	static void __get_engine_usage_record(struct intel_engine_cs *engine,
		1152	u32 last_in, u32 id, u32 *total)
1128	{	1153	{
1129	struct guc_engine_usage_record *rec = intel_guc_engine_usage(engine);	1154	struct guc_engine_usage_record *rec = intel_guc_engine_usage(engine);
		1155	int i = 0;
		1156
		1157	do {
		1158	*last_in = READ_ONCE(rec->last_switch_in_stamp);
		1159	*id = READ_ONCE(rec->current_context_index);
		1160	*total = READ_ONCE(rec->total_runtime);
		1161
		1162	if (READ_ONCE(rec->last_switch_in_stamp) == *last_in &&
		1163	READ_ONCE(rec->current_context_index) == *id &&
		1164	READ_ONCE(rec->total_runtime) == *total)
		1165	break;
		1166	} while (++i < 6);
		1167	}
		1168
		1169	static void guc_update_engine_gt_clks(struct intel_engine_cs *engine)
		1170	{
1130	struct intel_engine_guc_stats *stats = &engine->stats.guc;	1171	struct intel_engine_guc_stats *stats = &engine->stats.guc;
1131	struct intel_guc *guc = &engine->gt->uc.guc;	1172	struct intel_guc *guc = &engine->gt->uc.guc;
1132	u32 last_switch = rec->last_switch_in_stamp;	1173	u32 last_switch, ctx_id, total;
1133	u32 ctx_id = rec->current_context_index;
1134	u32 total = rec->total_runtime;
1135		1174
1136	lockdep_assert_held(&guc->timestamp.lock);	1175	lockdep_assert_held(&guc->timestamp.lock);
1137		1176
		1177	__get_engine_usage_record(engine, &last_switch, &ctx_id, &total);
		1178
1138	stats->running = ctx_id != ~0U && last_switch;	1179	stats->running = ctx_id != ~0U && last_switch;
1139	if (stats->running)	1180	if (stats->running)
1140	__extend_last_switch(guc, &stats->start_gt_clk, last_switch);	1181	__extend_last_switch(guc, &stats->start_gt_clk, last_switch);
@@ -1149,23 +1190,51 @@ static void guc_update_engine_gt_clks(struct intel_engine_cs *engine) · 8 unmodified lines
1149	}	1190	}
1150	}	1191	}
1151		1192
1152	static void guc_update_pm_timestamp(struct intel_guc *guc,	1193	static u32 gpm_timestamp_shift(struct intel_gt *gt)
1153	struct intel_engine_cs *engine,	1194	{
1154	ktime_t *now)	1195	intel_wakeref_t wakeref;
		1196	u32 reg, shift;
		1197
		1198	with_intel_runtime_pm(gt->uncore->rpm, wakeref)
		1199	reg = intel_uncore_read(gt->uncore, RPM_CONFIG0);
		1200
		1201	shift = (reg & GEN10_RPM_CONFIG0_CTC_SHIFT_PARAMETER_MASK) >>
		1202	GEN10_RPM_CONFIG0_CTC_SHIFT_PARAMETER_SHIFT;
		1203
		1204	return 3 - shift;
		1205	}
		1206
		1207	static u64 gpm_timestamp(struct intel_gt *gt)
		1208	{
		1209	u32 lo, hi, old_hi, loop = 0;
		1210
		1211	hi = intel_uncore_read(gt->uncore, MISC_STATUS1);
		1212	do {
		1213	lo = intel_uncore_read(gt->uncore, MISC_STATUS0);
		1214	old_hi = hi;
		1215	hi = intel_uncore_read(gt->uncore, MISC_STATUS1);
		1216	} while (old_hi != hi && loop++ < 2);
		1217
		1218	return ((u64)hi << 32) \| lo;
		1219	}
		1220
		1221	static void guc_update_pm_timestamp(struct intel_guc guc, ktime_t now)
1155	{	1222	{
1156	u32 gt_stamp_now, gt_stamp_hi;	1223	struct intel_gt *gt = guc_to_gt(guc);
		1224	u32 gt_stamp_lo, gt_stamp_hi;
		1225	u64 gpm_ts;
1157		1226
1158	lockdep_assert_held(&guc->timestamp.lock);	1227	lockdep_assert_held(&guc->timestamp.lock);
1159		1228
1160	gt_stamp_hi = upper_32_bits(guc->timestamp.gt_stamp);	1229	gt_stamp_hi = upper_32_bits(guc->timestamp.gt_stamp);
1161	gt_stamp_now = intel_uncore_read(engine->uncore,	1230	gpm_ts = gpm_timestamp(gt) >> guc->timestamp.shift;
1162	RING_TIMESTAMP(engine->mmio_base));	1231	gt_stamp_lo = lower_32_bits(gpm_ts);
1163	*now = ktime_get();	1232	*now = ktime_get();
1164		1233
1165	if (gt_stamp_now < lower_32_bits(guc->timestamp.gt_stamp))	1234	if (gt_stamp_lo < lower_32_bits(guc->timestamp.gt_stamp))
1166	gt_stamp_hi++;	1235	gt_stamp_hi++;
1167		1236
1168	guc->timestamp.gt_stamp = ((u64)gt_stamp_hi << 32) \| gt_stamp_now;	1237	guc->timestamp.gt_stamp = ((u64)gt_stamp_hi << 32) \| gt_stamp_lo;
1169	}	1238	}
1170		1239
1171	/*	1240	/*
@@ -1208,8 +1277,12 @@ static ktime_t guc_engine_busyness(struct intel_engine_cs engine, ktime_t now) · 36 unmodified lines
1208	if (!in_reset && intel_gt_pm_get_if_awake(gt)) {	1277	if (!in_reset && intel_gt_pm_get_if_awake(gt)) {
1209	stats_saved = *stats;	1278	stats_saved = *stats;
1210	gt_stamp_saved = guc->timestamp.gt_stamp;	1279	gt_stamp_saved = guc->timestamp.gt_stamp;
		1280	/*
		1281	* Update gt_clks, then gt timestamp to simplify the 'gt_stamp -
		1282	* start_gt_clk' calculation below for active engines.
		1283	*/
1211	guc_update_engine_gt_clks(engine);	1284	guc_update_engine_gt_clks(engine);
1212	guc_update_pm_timestamp(guc, engine, now);	1285	guc_update_pm_timestamp(guc, now);
1213	intel_gt_pm_put_async(gt);	1286	intel_gt_pm_put_async(gt);
1214	if (i915_reset_count(gpu_error) != reset_count) {	1287	if (i915_reset_count(gpu_error) != reset_count) {
1215	*stats = stats_saved;	1288	*stats = stats_saved;
@@ -1241,8 +1314,8 @@ static void __reset_guc_busyness_stats(struct intel_guc *guc) · 25 unmodified lines
1241		1314
1242	spin_lock_irqsave(&guc->timestamp.lock, flags);	1315	spin_lock_irqsave(&guc->timestamp.lock, flags);
1243		1316
		1317	guc_update_pm_timestamp(guc, &unused);
1244	for_each_engine(engine, gt, id) {	1318	for_each_engine(engine, gt, id) {
1245	guc_update_pm_timestamp(guc, engine, &unused);
1246	guc_update_engine_gt_clks(engine);	1319	guc_update_engine_gt_clks(engine);
1247	engine->stats.guc.prev_total = 0;	1320	engine->stats.guc.prev_total = 0;
1248	}	1321	}
@@ -1259,10 +1332,11 @@ static void __update_guc_busyness_stats(struct intel_guc *guc) · 10 unmodified lines
1259	ktime_t unused;	1332	ktime_t unused;
1260		1333
1261	spin_lock_irqsave(&guc->timestamp.lock, flags);	1334	spin_lock_irqsave(&guc->timestamp.lock, flags);
1262	for_each_engine(engine, gt, id) {	1335
1263	guc_update_pm_timestamp(guc, engine, &unused);	1336	guc_update_pm_timestamp(guc, &unused);
		1337	for_each_engine(engine, gt, id)
1264	guc_update_engine_gt_clks(engine);	1338	guc_update_engine_gt_clks(engine);
1265	}	1339
1266	spin_unlock_irqrestore(&guc->timestamp.lock, flags);	1340	spin_unlock_irqrestore(&guc->timestamp.lock, flags);
1267	}	1341	}
1268		1342
@@ -1335,10 +1409,15 @@ void intel_guc_busyness_park(struct intel_gt *gt) · 66 unmodified lines
1335	void intel_guc_busyness_unpark(struct intel_gt *gt)	1409	void intel_guc_busyness_unpark(struct intel_gt *gt)
1336	{	1410	{
1337	struct intel_guc *guc = &gt->uc.guc;	1411	struct intel_guc *guc = &gt->uc.guc;
		1412	unsigned long flags;
		1413	ktime_t unused;
1338		1414
1339	if (!guc_submission_initialized(guc))	1415	if (!guc_submission_initialized(guc))
1340	return;	1416	return;
1341		1417
		1418	spin_lock_irqsave(&guc->timestamp.lock, flags);
		1419	guc_update_pm_timestamp(guc, &unused);
		1420	spin_unlock_irqrestore(&guc->timestamp.lock, flags);
1342	mod_delayed_work(system_highpri_wq, &guc->timestamp.work,	1421	mod_delayed_work(system_highpri_wq, &guc->timestamp.work,
1343	guc->timestamp.ping_delay);	1422	guc->timestamp.ping_delay);
1344	}	1423	}
@@ -1783,6 +1862,7 @@ int intel_guc_submission_init(struct intel_guc *guc) · 438 unmodified lines
1783	spin_lock_init(&guc->timestamp.lock);	1862	spin_lock_init(&guc->timestamp.lock);
1784	INIT_DELAYED_WORK(&guc->timestamp.work, guc_timestamp_ping);	1863	INIT_DELAYED_WORK(&guc->timestamp.work, guc_timestamp_ping);
1785	guc->timestamp.ping_delay = (POLL_TIME_CLKS / gt->clock_frequency + 1) * HZ;	1864	guc->timestamp.ping_delay = (POLL_TIME_CLKS / gt->clock_frequency + 1) * HZ;
		1865	guc->timestamp.shift = gpm_timestamp_shift(gt);
1786		1866
1787	return 0;	1867	return 0;
1788	}	1868	}

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

@@ -1522,7 +1522,7 @@ capture_engine(struct intel_engine_cs *engine, · 1521 unmodified lines
1522	struct i915_request *rq = NULL;	1522	struct i915_request *rq = NULL;
1523	unsigned long flags;	1523	unsigned long flags;
1524		1524
1525	ee = intel_engine_coredump_alloc(engine, GFP_KERNEL);	1525	ee = intel_engine_coredump_alloc(engine, ALLOW_FAIL);
1526	if (!ee)	1526	if (!ee)
1527	return NULL;	1527	return NULL;
1528		1528

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

@@ -2684,7 +2684,8 @@ static inline bool i915_mmio_reg_valid(i915_reg_t reg) · 2683 unmodified lines
2684	#define RING_WAIT (1 << 11) /* gen3+, PRBx_CTL */	2684	#define RING_WAIT (1 << 11) /* gen3+, PRBx_CTL */
2685	#define RING_WAIT_SEMAPHORE (1 << 10) /* gen6+ */	2685	#define RING_WAIT_SEMAPHORE (1 << 10) /* gen6+ */
2686		2686
2687	#define GUCPMTIMESTAMP _MMIO(0xC3E8)	2687	#define MISC_STATUS0 _MMIO(0xA500)
		2688	#define MISC_STATUS1 _MMIO(0xA504)
2688		2689
2689	/* There are 16 64-bit CS General Purpose Registers per-engine on Gen8+ */	2690	/* There are 16 64-bit CS General Purpose Registers per-engine on Gen8+ */
2690	#define GEN8_RING_CS_GPR(base, n) _MMIO((base) + 0x600 + (n) * 8)	2691	#define GEN8_RING_CS_GPR(base, n) _MMIO((base) + 0x600 + (n) * 8)

drivers/gpu/drm/kmb/kmb_plane.c+0−6

 	case LAYER_1:
 		kmb->plane_status[plane_id].ctrl = LCD_CTRL_VL2_ENABLE;
 		break;
-	case LAYER_2:
-		kmb->plane_status[plane_id].ctrl = LCD_CTRL_GL1_ENABLE;
-		break;
-	case LAYER_3:
-		kmb->plane_status[plane_id].ctrl = LCD_CTRL_GL2_ENABLE;
-		break;
 	}
 	kmb->plane_status[plane_id].disable = true;

drivers/gpu/drm/mxsfb/mxsfb_kms.c+5−1

 		bridge_state =
 			drm_atomic_get_new_bridge_state(state,
 							mxsfb->bridge);
-		bus_format = bridge_state->input_bus_cfg.format;
+		if (!bridge_state)
+			bus_format = MEDIA_BUS_FMT_FIXED;
+		else
+			bus_format = bridge_state->input_bus_cfg.format;
 		if (bus_format == MEDIA_BUS_FMT_FIXED) {
 			dev_warn_once(drm->dev,
 				      "Bridge does not provide bus format, assuming MEDIA_BUS_FMT_RGB888_1X24.\n"

drivers/gpu/drm/nouveau/nvkm/subdev/bios/base.c+1−1

@@ -38,7 +38,7 @@ nvbios_addr(struct nvkm_bios bios, u32 addr, u8 size) · 37 unmodified lines
38	*addr += bios->imaged_addr;	38	*addr += bios->imaged_addr;
39	}	39	}
40		40
41	if (unlikely(*addr + size >= bios->size)) {	41	if (unlikely(*addr + size > bios->size)) {
42	nvkm_error(&bios->subdev, "OOB %d %08x %08x\n", size, p, *addr);	42	nvkm_error(&bios->subdev, "OOB %d %08x %08x\n", size, p, *addr);
43	return false;	43	return false;
44	}	44	}

drivers/infiniband/core/cm.c+1−1

@@ -3322,7 +3322,7 @@ static int cm_lap_handler(struct cm_work *work) · 3321 unmodified lines
3322	ret = cm_init_av_by_path(param->alternate_path, NULL, &alt_av);	3322	ret = cm_init_av_by_path(param->alternate_path, NULL, &alt_av);
3323	if (ret) {	3323	if (ret) {
3324	rdma_destroy_ah_attr(&ah_attr);	3324	rdma_destroy_ah_attr(&ah_attr);
3325	return -EINVAL;	3325	goto deref;
3326	}	3326	}
3327		3327
3328	spin_lock_irq(&cm_id_priv->lock);	3328	spin_lock_irq(&cm_id_priv->lock);

drivers/infiniband/core/cma.c+12−10

@@ -67,8 +67,8 @@ static const char * const cma_events[] = { · 66 unmodified lines
67	[RDMA_CM_EVENT_TIMEWAIT_EXIT] = "timewait exit",	67	[RDMA_CM_EVENT_TIMEWAIT_EXIT] = "timewait exit",
68	};	68	};
69		69
70	static void cma_set_mgid(struct rdma_id_private id_priv, struct sockaddr addr,	70	static void cma_iboe_set_mgid(struct sockaddr addr, union ib_gid mgid,
71	union ib_gid *mgid);	71	enum ib_gid_type gid_type);
72		72
73	const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event)	73	const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event)
74	{	74	{
@@ -1846,17 +1846,19 @@ static void destroy_mc(struct rdma_id_private *id_priv, · 1771 unmodified lines
1846	if (dev_addr->bound_dev_if)	1846	if (dev_addr->bound_dev_if)
1847	ndev = dev_get_by_index(dev_addr->net,	1847	ndev = dev_get_by_index(dev_addr->net,
1848	dev_addr->bound_dev_if);	1848	dev_addr->bound_dev_if);
1849	if (ndev) {	1849	if (ndev && !send_only) {
		1850	enum ib_gid_type gid_type;
1850	union ib_gid mgid;	1851	union ib_gid mgid;
1851		1852
1852	cma_set_mgid(id_priv, (struct sockaddr *)&mc->addr,	1853	gid_type = id_priv->cma_dev->default_gid_type
1853	&mgid);	1854	[id_priv->id.port_num -
1854		1855	rdma_start_port(
1855	if (!send_only)	1856	id_priv->cma_dev->device)];
1856	cma_igmp_send(ndev, &mgid, false);	1857	cma_iboe_set_mgid((struct sockaddr *)&mc->addr, &mgid,
1857		1858	gid_type);
1858	dev_put(ndev);	1859	cma_igmp_send(ndev, &mgid, false);
1859	}	1860	}
		1861	dev_put(ndev);
1860		1862
1861	cancel_work_sync(&mc->iboe_join.work);	1863	cancel_work_sync(&mc->iboe_join.work);
1862	}	1864	}

drivers/infiniband/core/ucma.c+23−11

 	u64			uid;
 	struct list_head	list;
+	struct list_head	mc_list;
 	struct work_struct	close_work;
 };
 	u64			uid;
 	u8			join_state;
+	struct list_head	list;
 	struct sockaddr_storage	addr;
 };
 	INIT_WORK(&ctx->close_work, ucma_close_id);
 	init_completion(&ctx->comp);
+	INIT_LIST_HEAD(&ctx->mc_list);
 	/* So list_del() will work if we don't do ucma_finish_ctx() */
 	INIT_LIST_HEAD(&ctx->list);
 	ctx->file = file;
 static void ucma_cleanup_multicast(struct ucma_context *ctx)
 {
-	struct ucma_multicast *mc;
+	struct ucma_multicast *mc, *tmp;
-	unsigned long index;
-	xa_for_each(&multicast_table, index, mc) {
+	xa_lock(&multicast_table);
-		if (mc->ctx != ctx)
+	list_for_each_entry_safe(mc, tmp, &ctx->mc_list, list) {
-			continue;
+		list_del(&mc->list);
 		/*
 		 * At this point mc->ctx->ref is 0 so the mc cannot leave the
 		 * lock on the reader and this is enough serialization
 		 */
-		xa_erase(&multicast_table, index);
+		__xa_erase(&multicast_table, mc->id);
 		kfree(mc);
 	}
+	xa_unlock(&multicast_table);
 }
 static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
 	mc->uid = cmd->uid;
 	memcpy(&mc->addr, addr, cmd->addr_size);
-	if (xa_alloc(&multicast_table, &mc->id, NULL, xa_limit_32b,
+	xa_lock(&multicast_table);
+	if (__xa_alloc(&multicast_table, &mc->id, NULL, xa_limit_32b,
 		     GFP_KERNEL)) {
 		ret = -ENOMEM;
 		goto err_free_mc;
 	}
+	list_add_tail(&mc->list, &ctx->mc_list);
+	xa_unlock(&multicast_table);
 	mutex_lock(&ctx->mutex);
 	ret = rdma_join_multicast(ctx->cm_id, (struct sockaddr *)&mc->addr,
 				  join_state, mc);
 	mutex_unlock(&ctx->mutex);
 	ucma_cleanup_mc_events(mc);
 err_xa_erase:
-	xa_erase(&multicast_table, mc->id);
+	xa_lock(&multicast_table);
+	list_del(&mc->list);
+	__xa_erase(&multicast_table, mc->id);
 err_free_mc:
+	xa_unlock(&multicast_table);
 	kfree(mc);
 err_put_ctx:
 	ucma_put_ctx(ctx);
 		mc = ERR_PTR(-EINVAL);
 	else if (!refcount_inc_not_zero(&mc->ctx->ref))
 		mc = ERR_PTR(-ENXIO);
-	else
-		__xa_erase(&multicast_table, mc->id);
-	xa_unlock(&multicast_table);
 	if (IS_ERR(mc)) {
+		xa_unlock(&multicast_table);
 		ret = PTR_ERR(mc);
 		goto out;
 	}
+	list_del(&mc->list);
+	__xa_erase(&multicast_table, mc->id);
+	xa_unlock(&multicast_table);
 	mutex_lock(&mc->ctx->mutex);
 	rdma_leave_multicast(mc->ctx->cm_id, (struct sockaddr *) &mc->addr);
 	mutex_unlock(&mc->ctx->mutex);

drivers/infiniband/hw/hfi1/ipoib.h+1−1

@@ -55,7 +55,7 @@ union hfi1_ipoib_flow { · 54 unmodified lines
55	*/	55	*/
56	struct ipoib_txreq {	56	struct ipoib_txreq {
57	struct sdma_txreq txreq;	57	struct sdma_txreq txreq;
58	struct hfi1_sdma_header sdma_hdr;	58	struct hfi1_sdma_header *sdma_hdr;
59	int sdma_status;	59	int sdma_status;
60	int complete;	60	int complete;
61	struct hfi1_ipoib_dev_priv *priv;	61	struct hfi1_ipoib_dev_priv *priv;

drivers/infiniband/hw/hfi1/ipoib_main.c+15−12

 	int ret;
 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
+	if (!dev->tstats)
+		return -ENOMEM;
 	ret = priv->netdev_ops->ndo_init(dev);
 	if (ret)
-		return ret;
+		goto out_ret;
 	ret = hfi1_netdev_add_data(priv->dd,
 				   qpn_from_mac(priv->netdev->dev_addr),
 				   dev);
 	if (ret < 0) {
 		priv->netdev_ops->ndo_uninit(dev);
-		return ret;
+		goto out_ret;
 	}
 	return 0;
+out_ret:
+	free_percpu(dev->tstats);
+	dev->tstats = NULL;
+	return ret;
 }
 static void hfi1_ipoib_dev_uninit(struct net_device *dev)
 {
 	struct hfi1_ipoib_dev_priv *priv = hfi1_ipoib_priv(dev);
+	free_percpu(dev->tstats);
+	dev->tstats = NULL;
 	hfi1_netdev_remove_data(priv->dd, qpn_from_mac(priv->netdev->dev_addr));
 	priv->netdev_ops->ndo_uninit(dev);
 	hfi1_ipoib_rxq_deinit(priv->netdev);
 	free_percpu(dev->tstats);
-}
+	dev->tstats = NULL;
-static void hfi1_ipoib_free_rdma_netdev(struct net_device *dev)
-{
-	hfi1_ipoib_netdev_dtor(dev);
-	free_netdev(dev);
 }
 static void hfi1_ipoib_set_id(struct net_device *dev, int id)
 	priv->port_num = port_num;
 	priv->netdev_ops = netdev->netdev_ops;
-	netdev->netdev_ops = &hfi1_ipoib_netdev_ops;
 	ib_query_pkey(device, port_num, priv->pkey_index, &priv->pkey);
 	rc = hfi1_ipoib_txreq_init(priv);
 	if (rc) {
 		dd_dev_err(dd, "IPoIB netdev TX init - failed(%d)\n", rc);
-		hfi1_ipoib_free_rdma_netdev(netdev);
 		return rc;
 	}
 	rc = hfi1_ipoib_rxq_init(netdev);
 	if (rc) {
 		dd_dev_err(dd, "IPoIB netdev RX init - failed(%d)\n", rc);
-		hfi1_ipoib_free_rdma_netdev(netdev);
+		hfi1_ipoib_txreq_deinit(priv);
 		return rc;
 	}
+	netdev->netdev_ops = &hfi1_ipoib_netdev_ops;
 	netdev->priv_destructor = hfi1_ipoib_netdev_dtor;
 	netdev->needs_free_netdev = true;

drivers/infiniband/hw/hfi1/ipoib_tx.c+26−12

 		dd_dev_warn(priv->dd,
 			    "%s: Status = 0x%x pbc 0x%llx txq = %d sde = %d\n",
 			    __func__, tx->sdma_status,
-			    le64_to_cpu(tx->sdma_hdr.pbc), tx->txq->q_idx,
+			    le64_to_cpu(tx->sdma_hdr->pbc), tx->txq->q_idx,
 			    tx->txq->sde->this_idx);
 	}
 {
 	struct hfi1_devdata *dd = txp->dd;
 	struct sdma_txreq *txreq = &tx->txreq;
-	struct hfi1_sdma_header *sdma_hdr = &tx->sdma_hdr;
+	struct hfi1_sdma_header *sdma_hdr = tx->sdma_hdr;
 	u16 pkt_bytes =
 		sizeof(sdma_hdr->pbc) + (txp->hdr_dwords << 2) + tx->skb->len;
 	int ret;
 					   struct ipoib_txparms *txp)
 {
 	struct hfi1_ipoib_dev_priv *priv = tx->txq->priv;
-	struct hfi1_sdma_header *sdma_hdr = &tx->sdma_hdr;
+	struct hfi1_sdma_header *sdma_hdr = tx->sdma_hdr;
 	struct sk_buff *skb = tx->skb;
 	struct hfi1_pportdata *ppd = ppd_from_ibp(txp->ibp);
 	struct rdma_ah_attr *ah_attr = txp->ah_attr;
 	if (likely(!ret)) {
 tx_ok:
 		trace_sdma_output_ibhdr(txq->priv->dd,
-					&tx->sdma_hdr.hdr,
+					&tx->sdma_hdr->hdr,
 					ib_is_sc5(txp->flow.sc5));
 		hfi1_ipoib_check_queue_depth(txq);
 		return NETDEV_TX_OK;
 	hfi1_ipoib_check_queue_depth(txq);
 	trace_sdma_output_ibhdr(txq->priv->dd,
-				&tx->sdma_hdr.hdr,
+				&tx->sdma_hdr->hdr,
 				ib_is_sc5(txp->flow.sc5));
 	if (!netdev_xmit_more())
 {
 	struct net_device *dev = priv->netdev;
 	u32 tx_ring_size, tx_item_size;
-	int i;
+	struct hfi1_ipoib_circ_buf *tx_ring;
+	int i, j;
 	/*
 	 * Ring holds 1 less than tx_ring_size
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct hfi1_ipoib_txq *txq = &priv->txqs[i];
+		struct ipoib_txreq *tx;
+		tx_ring = &txq->tx_ring;
 		iowait_init(&txq->wait,
 			    0,
 			    hfi1_ipoib_flush_txq,
 					     priv->dd->node);
 		txq->tx_ring.items =
-			kcalloc_node(tx_ring_size, tx_item_size,
+			kvzalloc_node(array_size(tx_ring_size, tx_item_size),
-				     GFP_KERNEL, priv->dd->node);
+				      GFP_KERNEL, priv->dd->node);
 		if (!txq->tx_ring.items)
 			goto free_txqs;
 		txq->tx_ring.max_items = tx_ring_size;
-		txq->tx_ring.shift = ilog2(tx_ring_size);
+		txq->tx_ring.shift = ilog2(tx_item_size);
 		txq->tx_ring.avail = hfi1_ipoib_ring_hwat(txq);
+		tx_ring = &txq->tx_ring;
+		for (j = 0; j < tx_ring_size; j++)
+			hfi1_txreq_from_idx(tx_ring, j)->sdma_hdr =
+				kzalloc_node(sizeof(*tx->sdma_hdr),
+					     GFP_KERNEL, priv->dd->node);
 		netif_tx_napi_add(dev, &txq->napi,
 				  hfi1_ipoib_poll_tx_ring,
 		struct hfi1_ipoib_txq *txq = &priv->txqs[i];
 		netif_napi_del(&txq->napi);
-		kfree(txq->tx_ring.items);
+		tx_ring = &txq->tx_ring;
+		for (j = 0; j < tx_ring_size; j++)
+			kfree(hfi1_txreq_from_idx(tx_ring, j)->sdma_hdr);
+		kvfree(tx_ring->items);
 	}
 	kfree(priv->txqs);
 void hfi1_ipoib_txreq_deinit(struct hfi1_ipoib_dev_priv *priv)
 {
-	int i;
+	int i, j;
 	for (i = 0; i < priv->netdev->num_tx_queues; i++) {
 		struct hfi1_ipoib_txq *txq = &priv->txqs[i];
+		struct hfi1_ipoib_circ_buf *tx_ring = &txq->tx_ring;
 		iowait_cancel_work(&txq->wait);
 		iowait_sdma_drain(&txq->wait);
 		hfi1_ipoib_drain_tx_list(txq);
 		netif_napi_del(&txq->napi);
 		hfi1_ipoib_drain_tx_ring(txq);
-		kfree(txq->tx_ring.items);
+		for (j = 0; j < tx_ring->max_items; j++)
+			kfree(hfi1_txreq_from_idx(tx_ring, j)->sdma_hdr);
+		kvfree(tx_ring->items);
 	}
 	kfree(priv->txqs);

drivers/infiniband/hw/mlx4/main.c+1−1

@@ -3237,7 +3237,7 @@ static void mlx4_ib_event(struct mlx4_dev dev, void ibdev_ptr, · 3236 unmodified lines
3237	case MLX4_DEV_EVENT_PORT_MGMT_CHANGE:	3237	case MLX4_DEV_EVENT_PORT_MGMT_CHANGE:
3238	ew = kmalloc(sizeof *ew, GFP_ATOMIC);	3238	ew = kmalloc(sizeof *ew, GFP_ATOMIC);
3239	if (!ew)	3239	if (!ew)
3240	break;	3240	return;
3241		3241
3242	INIT_WORK(&ew->work, handle_port_mgmt_change_event);	3242	INIT_WORK(&ew->work, handle_port_mgmt_change_event);
3243	memcpy(&ew->ib_eqe, eqe, sizeof *eqe);	3243	memcpy(&ew->ib_eqe, eqe, sizeof *eqe);

drivers/infiniband/sw/rdmavt/qp.c+2−0

 	case IB_WR_ATOMIC_FETCH_AND_ADD:
 		if (unlikely(!(qp->qp_access_flags & IB_ACCESS_REMOTE_ATOMIC)))
 			goto inv_err;
+		if (unlikely(wqe->atomic_wr.remote_addr & (sizeof(u64) - 1)))
+			goto inv_err;
 		if (unlikely(!rvt_rkey_ok(qp, &qp->r_sge.sge, sizeof(u64),
 					  wqe->atomic_wr.remote_addr,
 					  wqe->atomic_wr.rkey,

drivers/infiniband/sw/siw/siw.h+1−6

 	return &qp->orq[qp->orq_get % qp->attrs.orq_size];
 }
-static inline struct siw_sqe *orq_get_tail(struct siw_qp *qp)
-{
-	return &qp->orq[qp->orq_put % qp->attrs.orq_size];
-}
 static inline struct siw_sqe *orq_get_free(struct siw_qp *qp)
 {
-	struct siw_sqe *orq_e = orq_get_tail(qp);
+	struct siw_sqe *orq_e = &qp->orq[qp->orq_put % qp->attrs.orq_size];
 	if (READ_ONCE(orq_e->flags) == 0)
 		return orq_e;

drivers/infiniband/sw/siw/siw_qp_rx.c+11−9

@@ -1153,11 +1153,12 @@ static int siw_check_tx_fence(struct siw_qp *qp) · 1152 unmodified lines
1153		1153
1154	spin_lock_irqsave(&qp->orq_lock, flags);	1154	spin_lock_irqsave(&qp->orq_lock, flags);
1155		1155
1156	rreq = orq_get_current(qp);
1157
1158	/* free current orq entry */	1156	/* free current orq entry */
		1157	rreq = orq_get_current(qp);
1159	WRITE_ONCE(rreq->flags, 0);	1158	WRITE_ONCE(rreq->flags, 0);
1160		1159
		1160	qp->orq_get++;
		1161
1161	if (qp->tx_ctx.orq_fence) {	1162	if (qp->tx_ctx.orq_fence) {
1162	if (unlikely(tx_waiting->wr_status != SIW_WR_QUEUED)) {	1163	if (unlikely(tx_waiting->wr_status != SIW_WR_QUEUED)) {
1163	pr_warn("siw: [QP %u]: fence resume: bad status %d\n",	1164	pr_warn("siw: [QP %u]: fence resume: bad status %d\n",
@@ -1165,10 +1166,12 @@ static int siw_check_tx_fence(struct siw_qp *qp) · 1 unmodified line
1165	rv = -EPROTO;	1166	rv = -EPROTO;
1166	goto out;	1167	goto out;
1167	}	1168	}
1168	/* resume SQ processing */	1169	/* resume SQ processing, if possible */
1169	if (tx_waiting->sqe.opcode == SIW_OP_READ \|\|	1170	if (tx_waiting->sqe.opcode == SIW_OP_READ \|\|
1170	tx_waiting->sqe.opcode == SIW_OP_READ_LOCAL_INV) {	1171	tx_waiting->sqe.opcode == SIW_OP_READ_LOCAL_INV) {
1171	rreq = orq_get_tail(qp);	1172
		1173	/* SQ processing was stopped because of a full ORQ */
		1174	rreq = orq_get_free(qp);
1172	if (unlikely(!rreq)) {	1175	if (unlikely(!rreq)) {
1173	pr_warn("siw: [QP %u]: no ORQE\n", qp_id(qp));	1176	pr_warn("siw: [QP %u]: no ORQE\n", qp_id(qp));
1174	rv = -EPROTO;	1177	rv = -EPROTO;
@@ -1181,15 +1184,14 @@ static int siw_check_tx_fence(struct siw_qp *qp) · 6 unmodified lines
1181	resume_tx = 1;	1184	resume_tx = 1;
1182		1185
1183	} else if (siw_orq_empty(qp)) {	1186	} else if (siw_orq_empty(qp)) {
		1187	/*
		1188	* SQ processing was stopped by fenced work request.
		1189	* Resume since all previous Read's are now completed.
		1190	*/
1184	qp->tx_ctx.orq_fence = 0;	1191	qp->tx_ctx.orq_fence = 0;
1185	resume_tx = 1;	1192	resume_tx = 1;
1186	} else {
1187	pr_warn("siw: [QP %u]: fence resume: orq idx: %d:%d\n",
1188	qp_id(qp), qp->orq_get, qp->orq_put);
1189	rv = -EPROTO;
1190	}	1193	}
1191	}	1194	}
1192	qp->orq_get++;
1193	out:	1195	out:
1194	spin_unlock_irqrestore(&qp->orq_lock, flags);	1196	spin_unlock_irqrestore(&qp->orq_lock, flags);
1195		1197

drivers/infiniband/sw/siw/siw_verbs.c+2−1

@@ -313,7 +313,8 @@ int siw_create_qp(struct ib_qp ibqp, struct ib_qp_init_attr attrs, · 312 unmodified lines
313		313
314	if (atomic_inc_return(&sdev->num_qp) > SIW_MAX_QP) {	314	if (atomic_inc_return(&sdev->num_qp) > SIW_MAX_QP) {
315	siw_dbg(base_dev, "too many QP's\n");	315	siw_dbg(base_dev, "too many QP's\n");
316	return -ENOMEM;	316	rv = -ENOMEM;
		317	goto err_atomic;
317	}	318	}
318	if (attrs->qp_type != IB_QPT_RC) {	319	if (attrs->qp_type != IB_QPT_RC) {
319	siw_dbg(base_dev, "only RC QP's supported\n");	320	siw_dbg(base_dev, "only RC QP's supported\n");

drivers/input/touchscreen/wm97xx-core.c+3−9

@@ -615,10 +615,9 @@ static int wm97xx_register_touch(struct wm97xx *wm) · 614 unmodified lines
615	* extensions)	615	* extensions)
616	*/	616	*/
617	wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);	617	wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);
618	if (!wm->touch_dev) {	618	if (!wm->touch_dev)
619	ret = -ENOMEM;	619	return -ENOMEM;
620	goto touch_err;	620
621	}
622	platform_set_drvdata(wm->touch_dev, wm);	621	platform_set_drvdata(wm->touch_dev, wm);
623	wm->touch_dev->dev.parent = wm->dev;	622	wm->touch_dev->dev.parent = wm->dev;
624	wm->touch_dev->dev.platform_data = pdata;	623	wm->touch_dev->dev.platform_data = pdata;
@@ -629,9 +628,6 @@ static int wm97xx_register_touch(struct wm97xx *wm) · 4 unmodified lines
629	return 0;	628	return 0;
630	touch_reg_err:	629	touch_reg_err:
631	platform_device_put(wm->touch_dev);	630	platform_device_put(wm->touch_dev);
632	touch_err:
633	input_unregister_device(wm->input_dev);
634	wm->input_dev = NULL;
635		631
636	return ret;	632	return ret;
637	}	633	}
@@ -639,8 +635,6 @@ touch_err: · 1 unmodified line
639	static void wm97xx_unregister_touch(struct wm97xx *wm)	635	static void wm97xx_unregister_touch(struct wm97xx *wm)
640	{	636	{
641	platform_device_unregister(wm->touch_dev);	637	platform_device_unregister(wm->touch_dev);
642	input_unregister_device(wm->input_dev);
643	wm->input_dev = NULL;
644	}	638	}
645		639
646	static int _wm97xx_probe(struct wm97xx *wm)	640	static int _wm97xx_probe(struct wm97xx *wm)

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

 #include <linux/export.h>
 #include <linux/kmemleak.h>
 #include <linux/cc_platform.h>
+#include <linux/iopoll.h>
 #include <asm/pci-direct.h>
 #include <asm/iommu.h>
 #include <asm/apic.h>
 		status = readl(iommu->mmio_base + MMIO_STATUS_OFFSET);
 		if (status & (MMIO_STATUS_GALOG_RUN_MASK))
 			break;
+		udelay(10);
 	}
 	if (WARN_ON(i >= LOOP_TIMEOUT))

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

 					    fn, &intel_ir_domain_ops,
 					    iommu);
 	if (!iommu->ir_domain) {
-		irq_domain_free_fwnode(fn);
 		pr_err("IR%d: failed to allocate irqdomain\n", iommu->seq_id);
-		goto out_free_bitmap;
+		goto out_free_fwnode;
 	}
 	iommu->ir_msi_domain =
 		arch_create_remap_msi_irq_domain(iommu->ir_domain,
 		if (dmar_enable_qi(iommu)) {
 			pr_err("Failed to enable queued invalidation\n");
-			goto out_free_bitmap;
+			goto out_free_ir_domain;
 		}
 	}
 	return 0;
+out_free_ir_domain:
+	if (iommu->ir_msi_domain)
+		irq_domain_remove(iommu->ir_msi_domain);
+	iommu->ir_msi_domain = NULL;
+	irq_domain_remove(iommu->ir_domain);
+	iommu->ir_domain = NULL;
+out_free_fwnode:
+	irq_domain_free_fwnode(fn);
 out_free_bitmap:
 	bitmap_free(bitmap);
 out_free_pages:

drivers/iommu/ioasid.c+1−0

@@ -349,6 +349,7 @@ EXPORT_SYMBOL_GPL(ioasid_alloc); · 348 unmodified lines
349		349
350	/**	350	/**
351	* ioasid_get - obtain a reference to the IOASID	351	* ioasid_get - obtain a reference to the IOASID
		352	* @ioasid: the ID to get
352	*/	353	*/
353	void ioasid_get(ioasid_t ioasid)	354	void ioasid_get(ioasid_t ioasid)
354	{	355	{

drivers/iommu/iommu.c+19−14

@@ -207,9 +207,14 @@ static struct dev_iommu dev_iommu_get(struct device dev) · 206 unmodified lines
207		207
208	static void dev_iommu_free(struct device *dev)	208	static void dev_iommu_free(struct device *dev)
209	{	209	{
210	iommu_fwspec_free(dev);	210	struct dev_iommu *param = dev->iommu;
211	kfree(dev->iommu);	211
212	dev->iommu = NULL;	212	dev->iommu = NULL;
		213	if (param->fwspec) {
		214	fwnode_handle_put(param->fwspec->iommu_fwnode);
		215	kfree(param->fwspec);
		216	}
		217	kfree(param);
213	}	218	}
214		219
215	static int __iommu_probe_device(struct device dev, struct list_head group_list)	220	static int __iommu_probe_device(struct device dev, struct list_head group_list)
@@ -980,17 +985,6 @@ static int iommu_group_device_count(struct iommu_group *group) · 764 unmodified lines
980	return ret;	985	return ret;
981	}	986	}
982		987
983	/**
984	* iommu_group_for_each_dev - iterate over each device in the group
985	* @group: the group
986	* @data: caller opaque data to be passed to callback function
987	* @fn: caller supplied callback function
988	*
989	* This function is called by group users to iterate over group devices.
990	* Callers should hold a reference count to the group during callback.
991	* The group->mutex is held across callbacks, which will block calls to
992	* iommu_group_add/remove_device.
993	*/
994	static int __iommu_group_for_each_dev(struct iommu_group group, void data,	988	static int __iommu_group_for_each_dev(struct iommu_group group, void data,
995	int (fn)(struct device , void *))	989	int (fn)(struct device , void *))
996	{	990	{
@@ -1005,7 +999,17 @@ static int __iommu_group_for_each_dev(struct iommu_group group, void data, · 8 unmodified lines
1005	return ret;	999	return ret;
1006	}	1000	}
1007		1001
1008		1002	/**
		1003	* iommu_group_for_each_dev - iterate over each device in the group
		1004	* @group: the group
		1005	* @data: caller opaque data to be passed to callback function
		1006	* @fn: caller supplied callback function
		1007	*
		1008	* This function is called by group users to iterate over group devices.
		1009	* Callers should hold a reference count to the group during callback.
		1010	* The group->mutex is held across callbacks, which will block calls to
		1011	* iommu_group_add/remove_device.
		1012	*/
1009	int iommu_group_for_each_dev(struct iommu_group group, void data,	1013	int iommu_group_for_each_dev(struct iommu_group group, void data,
1010	int (fn)(struct device , void *))	1014	int (fn)(struct device , void *))
1011	{	1015	{
@@ -3032,6 +3036,7 @@ EXPORT_SYMBOL_GPL(iommu_aux_get_pasid); · 2020 unmodified lines
3032	* iommu_sva_bind_device() - Bind a process address space to a device	3036	* iommu_sva_bind_device() - Bind a process address space to a device
3033	* @dev: the device	3037	* @dev: the device
3034	* @mm: the mm to bind, caller must hold a reference to it	3038	* @mm: the mm to bind, caller must hold a reference to it
		3039	* @drvdata: opaque data pointer to pass to bind callback
3035	*	3040	*
3036	* Create a bond between device and address space, allowing the device to access	3041	* Create a bond between device and address space, allowing the device to access
3037	* the mm using the returned PASID. If a bond already exists between @device and	3042	* the mm using the returned PASID. If a bond already exists between @device and

drivers/iommu/omap-iommu.c+1−1

@@ -1085,7 +1085,7 @@ static __maybe_unused int omap_iommu_runtime_resume(struct device *dev) · 1084 unmodified lines
1085	}	1085	}
1086		1086
1087	/**	1087	/**
1088	* omap_iommu_suspend_prepare - prepare() dev_pm_ops implementation	1088	* omap_iommu_prepare - prepare() dev_pm_ops implementation
1089	* @dev: iommu device	1089	* @dev: iommu device
1090	*	1090	*
1091	* This function performs the necessary checks to determine if the IOMMU	1091	* This function performs the necessary checks to determine if the IOMMU

drivers/md/md.c+4−4

 		nowait = nowait && blk_queue_nowait(bdev_get_queue(rdev->bdev));
 	}
-	/* Set the NOWAIT flags if all underlying devices support it */
-	if (nowait)
-		blk_queue_flag_set(QUEUE_FLAG_NOWAIT, mddev->queue);
 	if (!bioset_initialized(&mddev->bio_set)) {
 		err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
 		if (err)
 		else
 			blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
 		blk_queue_flag_set(QUEUE_FLAG_IO_STAT, mddev->queue);
+		/* Set the NOWAIT flags if all underlying devices support it */
+		if (nowait)
+			blk_queue_flag_set(QUEUE_FLAG_NOWAIT, mddev->queue);
 	}
 	if (pers->sync_request) {
 		if (mddev->kobj.sd &&

drivers/mmc/core/sd.c+7−1

 		__res & __mask;						\
 	})
-#define SD_POWEROFF_NOTIFY_TIMEOUT_MS 2000
+#define SD_POWEROFF_NOTIFY_TIMEOUT_MS 1000
 #define SD_WRITE_EXTR_SINGLE_TIMEOUT_MS 1000
 struct sd_busy_data {
 		goto out;
 	}
+	/* Find out when the command is completed. */
+	err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
+				MMC_BUSY_EXTR_SINGLE);
+	if (err)
+		goto out;
 	cb_data.card = card;
 	cb_data.reg_buf = reg_buf;
 	err = __mmc_poll_for_busy(card->host, SD_POWEROFF_NOTIFY_TIMEOUT_MS,

drivers/mmc/host/moxart-mmc.c+1−1

 	if (!IS_ERR_OR_NULL(host->dma_chan_rx))
 		dma_release_channel(host->dma_chan_rx);
 	mmc_remove_host(mmc);
-	mmc_free_host(mmc);
 	writel(0, host->base + REG_INTERRUPT_MASK);
 	writel(0, host->base + REG_POWER_CONTROL);
 	writel(readl(host->base + REG_CLOCK_CONTROL) | CLK_OFF,
 	       host->base + REG_CLOCK_CONTROL);
+	mmc_free_host(mmc);
 	return 0;
 }

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

 static int esdhc_of_enable_dma(struct sdhci_host *host)
 {
+	int ret;
 	u32 value;
 	struct device *dev = mmc_dev(host->mmc);
 	if (of_device_is_compatible(dev->of_node, "fsl,ls1043a-esdhc") ||
-	    of_device_is_compatible(dev->of_node, "fsl,ls1046a-esdhc"))
+	    of_device_is_compatible(dev->of_node, "fsl,ls1046a-esdhc")) {
-		dma_set_mask_and_coherent(dev, DMA_BIT_MASK(40));
+		ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(40));
+		if (ret)
+			return ret;
+	}
 	value = sdhci_readl(host, ESDHC_DMA_SYSCTL);

drivers/mmc/host/sh_mmcif.c+3−0

@@ -405,6 +405,9 @@ static int sh_mmcif_dma_slave_config(struct sh_mmcif_host *host, · 404 unmodified lines
405	struct dma_slave_config cfg = { 0, };	405	struct dma_slave_config cfg = { 0, };
406		406
407	res = platform_get_resource(host->pd, IORESOURCE_MEM, 0);	407	res = platform_get_resource(host->pd, IORESOURCE_MEM, 0);
		408	if (!res)
		409	return -EINVAL;
		410
408	cfg.direction = direction;	411	cfg.direction = direction;
409		412
410	if (direction == DMA_DEV_TO_MEM) {	413	if (direction == DMA_DEV_TO_MEM) {

drivers/net/bonding/bond_3ad.c+2−1

 				if (port->aggregator &&
 				    port->aggregator->is_active &&
 				    !__port_is_enabled(port)) {
 					__enable_port(port);
+					*update_slave_arr = true;
 				}
 			}
 			break;
 			     port = port->next_port_in_aggregator) {
 				__enable_port(port);
 			}
+			*update_slave_arr = true;
 		}
 	}

drivers/net/dsa/bcm_sf2.c+5−2

 	get_device(&priv->master_mii_bus->dev);
 	priv->master_mii_dn = dn;
-	priv->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
+	priv->slave_mii_bus = mdiobus_alloc();
 	if (!priv->slave_mii_bus) {
 		of_node_put(dn);
 		return -ENOMEM;
 	}
 	err = mdiobus_register(priv->slave_mii_bus);
-	if (err && dn)
+	if (err && dn) {
+		mdiobus_free(priv->slave_mii_bus);
 		of_node_put(dn);
+	}
 	return err;
 }
 static void bcm_sf2_mdio_unregister(struct bcm_sf2_priv *priv)
 {
 	mdiobus_unregister(priv->slave_mii_bus);
+	mdiobus_free(priv->slave_mii_bus);
 	of_node_put(priv->master_mii_dn);
 }

drivers/net/dsa/lantiq_gswip.c+11−3

 static int gswip_mdio(struct gswip_priv *priv, struct device_node *mdio_np)
 {
 	struct dsa_switch *ds = priv->ds;
+	int err;
-	ds->slave_mii_bus = devm_mdiobus_alloc(priv->dev);
+	ds->slave_mii_bus = mdiobus_alloc();
 	if (!ds->slave_mii_bus)
 		return -ENOMEM;
 	ds->slave_mii_bus->parent = priv->dev;
 	ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
-	return of_mdiobus_register(ds->slave_mii_bus, mdio_np);
+	err = of_mdiobus_register(ds->slave_mii_bus, mdio_np);
+	if (err)
+		mdiobus_free(ds->slave_mii_bus);
+	return err;
 }
 static int gswip_pce_table_entry_read(struct gswip_priv *priv,
 	gswip_mdio_mask(priv, GSWIP_MDIO_GLOB_ENABLE, 0, GSWIP_MDIO_GLOB);
 	dsa_unregister_switch(priv->ds);
 mdio_bus:
-	if (mdio_np)
+	if (mdio_np) {
 		mdiobus_unregister(priv->ds->slave_mii_bus);
+		mdiobus_free(priv->ds->slave_mii_bus);
+	}
 put_mdio_node:
 	of_node_put(mdio_np);
 	for (i = 0; i < priv->num_gphy_fw; i++)
 	if (priv->ds->slave_mii_bus) {
 		mdiobus_unregister(priv->ds->slave_mii_bus);
+		mdiobus_free(priv->ds->slave_mii_bus);
 		of_node_put(priv->ds->slave_mii_bus->dev.of_node);
 	}

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

@@ -2074,7 +2074,7 @@ mt7530_setup_mdio(struct mt7530_priv *priv) · 2073 unmodified lines
2074	if (priv->irq)	2074	if (priv->irq)
2075	mt7530_setup_mdio_irq(priv);	2075	mt7530_setup_mdio_irq(priv);
2076		2076
2077	ret = mdiobus_register(bus);	2077	ret = devm_mdiobus_register(dev, bus);
2078	if (ret) {	2078	if (ret) {
2079	dev_err(dev, "failed to register MDIO bus: %d\n", ret);	2079	dev_err(dev, "failed to register MDIO bus: %d\n", ret);
2080	if (priv->irq)	2080	if (priv->irq)

drivers/net/dsa/mv88e6xxx/chip.c+10−5

 			return err;
 	}
-	bus = devm_mdiobus_alloc_size(chip->dev, sizeof(*mdio_bus));
+	bus = mdiobus_alloc_size(sizeof(*mdio_bus));
 	if (!bus)
 		return -ENOMEM;
 	if (!external) {
 		err = mv88e6xxx_g2_irq_mdio_setup(chip, bus);
 		if (err)
-			return err;
+			goto out;
 	}
 	err = of_mdiobus_register(bus, np);
 	if (err) {
 		dev_err(chip->dev, "Cannot register MDIO bus (%d)\n", err);
 		mv88e6xxx_g2_irq_mdio_free(chip, bus);
-		return err;
+		goto out;
 	}
 	if (external)
 		list_add(&mdio_bus->list, &chip->mdios);
 	return 0;
+out:
+	mdiobus_free(bus);
+	return err;
 }
 static void mv88e6xxx_mdios_unregister(struct mv88e6xxx_chip *chip)
 {
-	struct mv88e6xxx_mdio_bus *mdio_bus;
+	struct mv88e6xxx_mdio_bus *mdio_bus, *p;
 	struct mii_bus *bus;
-	list_for_each_entry(mdio_bus, &chip->mdios, list) {
+	list_for_each_entry_safe(mdio_bus, p, &chip->mdios, list) {
 		bus = mdio_bus->bus;
 		if (!mdio_bus->external)
 			mv88e6xxx_g2_irq_mdio_free(chip, bus);
 		mdiobus_unregister(bus);
+		mdiobus_free(bus);
 	}
 }

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

 		return PTR_ERR(hw);
 	}
-	bus = devm_mdiobus_alloc_size(dev, sizeof(*mdio_priv));
+	bus = mdiobus_alloc_size(sizeof(*mdio_priv));
 	if (!bus)
 		return -ENOMEM;
 	rc = mdiobus_register(bus);
 	if (rc < 0) {
 		dev_err(dev, "failed to register MDIO bus\n");
+		mdiobus_free(bus);
 		return rc;
 	}
 		lynx_pcs_destroy(phylink_pcs);
 	}
 	mdiobus_unregister(felix->imdio);
+	mdiobus_free(felix->imdio);
 }
 static void vsc9959_sched_speed_set(struct ocelot *ocelot, int port,

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

@@ -1029,7 +1029,7 @@ static int vsc9953_mdio_bus_alloc(struct ocelot *ocelot) · 1028 unmodified lines
1029	}	1029	}
1030		1030
1031	/* Needed in order to initialize the bus mutex lock */	1031	/* Needed in order to initialize the bus mutex lock */
1032	rc = of_mdiobus_register(bus, NULL);	1032	rc = devm_of_mdiobus_register(dev, bus, NULL);
1033	if (rc < 0) {	1033	if (rc < 0) {
1034	dev_err(dev, "failed to register MDIO bus\n");	1034	dev_err(dev, "failed to register MDIO bus\n");
1035	return rc;	1035	return rc;
@@ -1083,7 +1083,8 @@ static void vsc9953_mdio_bus_free(struct ocelot *ocelot) · 47 unmodified lines
1083	mdio_device_free(mdio_device);	1083	mdio_device_free(mdio_device);
1084	lynx_pcs_destroy(phylink_pcs);	1084	lynx_pcs_destroy(phylink_pcs);
1085	}	1085	}
1086	mdiobus_unregister(felix->imdio);	1086
		1087	/* mdiobus_unregister and mdiobus_free handled by devres */
1087	}	1088	}
1088		1089
1089	static const struct felix_info seville_info_vsc9953 = {	1090	static const struct felix_info seville_info_vsc9953 = {

drivers/net/dsa/qca/ar9331.c+1−2

 	if (!mnp)
 		return -ENODEV;
-	ret = of_mdiobus_register(mbus, mnp);
+	ret = devm_of_mdiobus_register(dev, mbus, mnp);
 	of_node_put(mnp);
 	if (ret)
 		return ret;
 	}
 	irq_domain_remove(priv->irqdomain);
-	mdiobus_unregister(priv->mbus);
 	dsa_unregister_switch(&priv->ds);
 	reset_control_assert(priv->sw_reset);

drivers/net/ethernet/amd/xgbe/xgbe-pci.c+3−0

@@ -425,6 +425,9 @@ static void xgbe_pci_remove(struct pci_dev *pdev) · 424 unmodified lines
425		425
426	pci_free_irq_vectors(pdata->pcidev);	426	pci_free_irq_vectors(pdata->pcidev);
427		427
		428	/* Disable all interrupts in the hardware */
		429	XP_IOWRITE(pdata, XP_INT_EN, 0x0);
		430
428	xgbe_free_pdata(pdata);	431	xgbe_free_pdata(pdata);
429	}	432	}
430		433

drivers/net/ethernet/cadence/macb_main.c+1−1

@@ -4765,7 +4765,7 @@ static int macb_probe(struct platform_device *pdev) · 4764 unmodified lines
4765		4765
4766	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	4766	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
4767	if (GEM_BFEXT(DAW64, gem_readl(bp, DCFG6))) {	4767	if (GEM_BFEXT(DAW64, gem_readl(bp, DCFG6))) {
4768	dma_set_mask(&pdev->dev, DMA_BIT_MASK(44));	4768	dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(44));
4769	bp->hw_dma_cap \|= HW_DMA_CAP_64B;	4769	bp->hw_dma_cap \|= HW_DMA_CAP_64B;
4770	}	4770	}
4771	#endif	4771	#endif

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c+2−2

 #ifdef CONFIG_DEBUG_FS
 	dpaa2_dbg_remove(priv);
 #endif
+	unregister_netdev(net_dev);
 	rtnl_lock();
 	dpaa2_eth_disconnect_mac(priv);
 	rtnl_unlock();
-	unregister_netdev(net_dev);
 	dpaa2_eth_dl_port_del(priv);
 	dpaa2_eth_dl_traps_unregister(priv);
 	dpaa2_eth_dl_free(priv);

drivers/net/ethernet/google/gve/gve_rx.c+1−0

@@ -609,6 +609,7 @@ static bool gve_rx(struct gve_rx_ring *rx, netdev_features_t feat, · 608 unmodified lines
609		609
610	*packet_size_bytes = skb->len + (skb->protocol ? ETH_HLEN : 0);	610	*packet_size_bytes = skb->len + (skb->protocol ? ETH_HLEN : 0);
611	*work_done = work_cnt;	611	*work_done = work_cnt;
		612	skb_record_rx_queue(skb, rx->q_num);
612	if (skb_is_nonlinear(skb))	613	if (skb_is_nonlinear(skb))
613	napi_gro_frags(napi);	614	napi_gro_frags(napi);
614	else	615	else

drivers/net/ethernet/ibm/ibmvnic.c+9−4

 					 struct ibmvnic_sub_crq_queue *tx_scrq);
 static void free_long_term_buff(struct ibmvnic_adapter *adapter,
 				struct ibmvnic_long_term_buff *ltb);
+static void ibmvnic_disable_irqs(struct ibmvnic_adapter *adapter);
 struct ibmvnic_stat {
 	char name[ETH_GSTRING_LEN];
 	rc = set_link_state(adapter, IBMVNIC_LOGICAL_LNK_UP);
 	if (rc) {
 		ibmvnic_napi_disable(adapter);
-		release_resources(adapter);
+		ibmvnic_disable_irqs(adapter);
 		return rc;
 	}
 		rc = init_resources(adapter);
 		if (rc) {
 			netdev_err(netdev, "failed to initialize resources\n");
-			release_resources(adapter);
-			release_rx_pools(adapter);
-			release_tx_pools(adapter);
 			goto out;
 		}
 	}
 		adapter->state = VNIC_OPEN;
 		rc = 0;
 	}
+	if (rc) {
+		release_resources(adapter);
+		release_rx_pools(adapter);
+		release_tx_pools(adapter);
+	}
 	return rc;
 }

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

 	ICE_FLAG_MDD_AUTO_RESET_VF,
 	ICE_FLAG_VF_VLAN_PRUNING,
 	ICE_FLAG_LINK_LENIENT_MODE_ENA,
+	ICE_FLAG_PLUG_AUX_DEV,
 	ICE_PF_FLAGS_NBITS		/* must be last */
 };
 	if (pf->hw.func_caps.common_cap.rdma && pf->num_rdma_msix) {
 		set_bit(ICE_FLAG_RDMA_ENA, pf->flags);
 		set_bit(ICE_FLAG_AUX_ENA, pf->flags);
-		ice_plug_aux_dev(pf);
+		set_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags);
 	}
 }

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

@@ -3381,7 +3381,8 @@ ice_cfg_phy_fec(struct ice_port_info pi, struct ice_aqc_set_phy_cfg_data cfg, · 3380 unmodified lines
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;
3383		3383
3384	if (ice_get_link_default_override(&tlv, pi))	3384	status = ice_get_link_default_override(&tlv, pi);
		3385	if (status)
3385	goto out;	3386	goto out;
3386		3387
3387	if (!(tlv.options & ICE_LINK_OVERRIDE_STRICT_MODE) &&	3388	if (!(tlv.options & ICE_LINK_OVERRIDE_STRICT_MODE) &&

drivers/net/ethernet/intel/ice/ice_lag.c+28−6

@@ -204,17 +204,39 @@ ice_lag_unlink(struct ice_lag *lag, · 203 unmodified lines
204	lag->upper_netdev = NULL;	204	lag->upper_netdev = NULL;
205	}	205	}
206		206
207	if (lag->peer_netdev) {	207	lag->peer_netdev = NULL;
208	dev_put(lag->peer_netdev);
209	lag->peer_netdev = NULL;
210	}
211
212	ice_set_sriov_cap(pf);	208	ice_set_sriov_cap(pf);
213	ice_set_rdma_cap(pf);	209	ice_set_rdma_cap(pf);
214	lag->bonded = false;	210	lag->bonded = false;
215	lag->role = ICE_LAG_NONE;	211	lag->role = ICE_LAG_NONE;
216	}	212	}
217		213
		214	/**
		215	* ice_lag_unregister - handle netdev unregister events
		216	* @lag: LAG info struct
		217	* @netdev: netdev reporting the event
		218	*/
		219	static void ice_lag_unregister(struct ice_lag lag, struct net_device netdev)
		220	{
		221	struct ice_pf *pf = lag->pf;
		222
		223	/* check to see if this event is for this netdev
		224	* check that we are in an aggregate
		225	*/
		226	if (netdev != lag->netdev \|\| !lag->bonded)
		227	return;
		228
		229	if (lag->upper_netdev) {
		230	dev_put(lag->upper_netdev);
		231	lag->upper_netdev = NULL;
		232	ice_set_sriov_cap(pf);
		233	ice_set_rdma_cap(pf);
		234	}
		235	/* perform some cleanup in case we come back */
		236	lag->bonded = false;
		237	lag->role = ICE_LAG_NONE;
		238	}
		239
218	/**	240	/**
219	* ice_lag_changeupper_event - handle LAG changeupper event	241	* ice_lag_changeupper_event - handle LAG changeupper event
220	* @lag: LAG info struct	242	* @lag: LAG info struct
@@ -307,7 +329,7 @@ ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, · 86 unmodified lines
307	ice_lag_info_event(lag, ptr);	329	ice_lag_info_event(lag, ptr);
308	break;	330	break;
309	case NETDEV_UNREGISTER:	331	case NETDEV_UNREGISTER:
310	ice_lag_unlink(lag, ptr);	332	ice_lag_unregister(lag, netdev);
311	break;	333	break;
312	default:	334	default:
313	break;	335	break;

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

@@ -570,6 +570,7 @@ struct ice_tx_ctx_desc { · 569 unmodified lines
570	(0x3FFFFULL << ICE_TXD_CTX_QW1_TSO_LEN_S)	570	(0x3FFFFULL << ICE_TXD_CTX_QW1_TSO_LEN_S)
571		571
572	#define ICE_TXD_CTX_QW1_MSS_S 50	572	#define ICE_TXD_CTX_QW1_MSS_S 50
		573	#define ICE_TXD_CTX_MIN_MSS 64
573		574
574	#define ICE_TXD_CTX_QW1_VSI_S 50	575	#define ICE_TXD_CTX_QW1_VSI_S 50
575	#define ICE_TXD_CTX_QW1_VSI_M (0x3FFULL << ICE_TXD_CTX_QW1_VSI_S)	576	#define ICE_TXD_CTX_QW1_VSI_M (0x3FFULL << ICE_TXD_CTX_QW1_VSI_S)

drivers/net/ethernet/intel/ice/ice_main.c+20−8

 		return;
 	}
+	if (test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags))
+		ice_plug_aux_dev(pf);
 	ice_clean_adminq_subtask(pf);
 	ice_check_media_subtask(pf);
 	ice_check_for_hang_subtask(pf);
 		   struct net_device __always_unused *netdev,
 		   netdev_features_t features)
 {
+	bool gso = skb_is_gso(skb);
 	size_t len;
 	/* No point in doing any of this if neither checksum nor GSO are
 	/* We cannot support GSO if the MSS is going to be less than
 	 * 64 bytes. If it is then we need to drop support for GSO.
 	 */
-	if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64))
+	if (gso && (skb_shinfo(skb)->gso_size < ICE_TXD_CTX_MIN_MSS))
 		features &= ~NETIF_F_GSO_MASK;
-	len = skb_network_header(skb) - skb->data;
+	len = skb_network_offset(skb);
 	if (len > ICE_TXD_MACLEN_MAX || len & 0x1)
 		goto out_rm_features;
-	len = skb_transport_header(skb) - skb_network_header(skb);
+	len = skb_network_header_len(skb);
 	if (len > ICE_TXD_IPLEN_MAX || len & 0x1)
 		goto out_rm_features;
 	if (skb->encapsulation) {
-		len = skb_inner_network_header(skb) - skb_transport_header(skb);
+		/* this must work for VXLAN frames AND IPIP/SIT frames, and in
-		if (len > ICE_TXD_L4LEN_MAX || len & 0x1)
+		 * the case of IPIP frames, the transport header pointer is
-			goto out_rm_features;
+		 * after the inner header! So check to make sure that this
+		 * is a GRE or UDP_TUNNEL frame before doing that math.
+		 */
+		if (gso && (skb_shinfo(skb)->gso_type &
+			    (SKB_GSO_GRE | SKB_GSO_UDP_TUNNEL))) {
+			len = skb_inner_network_header(skb) -
+			      skb_transport_header(skb);
+			if (len > ICE_TXD_L4LEN_MAX || len & 0x1)
+				goto out_rm_features;
+		}
-		len = skb_inner_transport_header(skb) -
+		len = skb_inner_network_header_len(skb);
-		      skb_inner_network_header(skb);
 		if (len > ICE_TXD_IPLEN_MAX || len & 0x1)
 			goto out_rm_features;
 	}

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c+7−6

@@ -1984,14 +1984,15 @@ static void ixgbevf_set_rx_buffer_len(struct ixgbevf_adapter *adapter, · 1983 unmodified lines
1984	if (adapter->flags & IXGBEVF_FLAGS_LEGACY_RX)	1984	if (adapter->flags & IXGBEVF_FLAGS_LEGACY_RX)
1985	return;	1985	return;
1986		1986
1987	set_ring_build_skb_enabled(rx_ring);	1987	if (PAGE_SIZE < 8192)
		1988	if (max_frame > IXGBEVF_MAX_FRAME_BUILD_SKB)
		1989	set_ring_uses_large_buffer(rx_ring);
1988		1990
1989	if (PAGE_SIZE < 8192) {	1991	/* 82599 can't rely on RXDCTL.RLPML to restrict the size of the frame */
1990	if (max_frame <= IXGBEVF_MAX_FRAME_BUILD_SKB)	1992	if (adapter->hw.mac.type == ixgbe_mac_82599_vf && !ring_uses_large_buffer(rx_ring))
1991	return;	1993	return;
1992		1994
1993	set_ring_uses_large_buffer(rx_ring);	1995	set_ring_build_skb_enabled(rx_ring);
1994	}
1995	}	1996	}
1996		1997
1997	/**	1998	/**

drivers/net/ethernet/litex/Kconfig+1−1

@@ -17,7 +17,7 @@ if NET_VENDOR_LITEX · 16 unmodified lines
17		17
18	config LITEX_LITEETH	18	config LITEX_LITEETH
19	tristate "LiteX Ethernet support"	19	tristate "LiteX Ethernet support"
20	depends on OF	20	depends on OF && HAS_IOMEM
21	help	21	help
22	If you wish to compile a kernel for hardware with a LiteX LiteEth	22	If you wish to compile a kernel for hardware with a LiteX LiteEth
23	device then you should answer Y to this.	23	device then you should answer Y to this.

drivers/net/ethernet/microchip/sparx5/sparx5_ethtool.c+1−1

@@ -1103,7 +1103,7 @@ void sparx5_get_stats64(struct net_device *ndev, · 1102 unmodified lines
1103	stats->tx_carrier_errors = portstats[spx5_stats_tx_csense_cnt];	1103	stats->tx_carrier_errors = portstats[spx5_stats_tx_csense_cnt];
1104	stats->tx_window_errors = portstats[spx5_stats_tx_late_coll_cnt];	1104	stats->tx_window_errors = portstats[spx5_stats_tx_late_coll_cnt];
1105	stats->rx_dropped = portstats[spx5_stats_ana_ac_port_stat_lsb_cnt];	1105	stats->rx_dropped = portstats[spx5_stats_ana_ac_port_stat_lsb_cnt];
1106	for (idx = 0; idx < 2 * SPX5_PRIOS; ++idx, ++stats)	1106	for (idx = 0; idx < 2 * SPX5_PRIOS; ++idx)
1107	stats->rx_dropped += portstats[spx5_stats_green_p0_rx_port_drop	1107	stats->rx_dropped += portstats[spx5_stats_green_p0_rx_port_drop
1108	+ idx];	1108	+ idx];
1109	stats->tx_dropped = portstats[spx5_stats_tx_local_drop];	1109	stats->tx_dropped = portstats[spx5_stats_tx_local_drop];

drivers/net/ethernet/mscc/ocelot.c+15−4

 ocelot_populate_ipv4_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
 {
 	trap->key_type = OCELOT_VCAP_KEY_IPV4;
+	trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
+	trap->key.ipv4.proto.mask[0] = 0xff;
 	trap->key.ipv4.dport.value = PTP_EV_PORT;
 	trap->key.ipv4.dport.mask = 0xffff;
 }
 ocelot_populate_ipv6_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
 {
 	trap->key_type = OCELOT_VCAP_KEY_IPV6;
+	trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
+	trap->key.ipv4.proto.mask[0] = 0xff;
 	trap->key.ipv6.dport.value = PTP_EV_PORT;
 	trap->key.ipv6.dport.mask = 0xffff;
 }
 ocelot_populate_ipv4_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
 {
 	trap->key_type = OCELOT_VCAP_KEY_IPV4;
+	trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
+	trap->key.ipv4.proto.mask[0] = 0xff;
 	trap->key.ipv4.dport.value = PTP_GEN_PORT;
 	trap->key.ipv4.dport.mask = 0xffff;
 }
 ocelot_populate_ipv6_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
 {
 	trap->key_type = OCELOT_VCAP_KEY_IPV6;
+	trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
+	trap->key.ipv4.proto.mask[0] = 0xff;
 	trap->key.ipv6.dport.value = PTP_GEN_PORT;
 	trap->key.ipv6.dport.mask = 0xffff;
 }
 }
 EXPORT_SYMBOL(ocelot_get_strings);
+/* Caller must hold &ocelot->stats_lock */
 static void ocelot_update_stats(struct ocelot *ocelot)
 {
 	int i, j;
-	mutex_lock(&ocelot->stats_lock);
 	for (i = 0; i < ocelot->num_phys_ports; i++) {
 		/* Configure the port to read the stats from */
 		ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(i), SYS_STAT_CFG);
 					      ~(u64)U32_MAX) + val;
 		}
 	}
-	mutex_unlock(&ocelot->stats_lock);
 }
 static void ocelot_check_stats_work(struct work_struct *work)
 	struct ocelot *ocelot = container_of(del_work, struct ocelot,
 					     stats_work);
+	mutex_lock(&ocelot->stats_lock);
 	ocelot_update_stats(ocelot);
+	mutex_unlock(&ocelot->stats_lock);
 	queue_delayed_work(ocelot->stats_queue, &ocelot->stats_work,
 			   OCELOT_STATS_CHECK_DELAY);
 {
 	int i;
+	mutex_lock(&ocelot->stats_lock);
 	/* check and update now */
 	ocelot_update_stats(ocelot);
 	/* Copy all counters */
 	for (i = 0; i < ocelot->num_stats; i++)
 		*data++ = ocelot->stats[port * ocelot->num_stats + i];
+	mutex_unlock(&ocelot->stats_lock);
 }
 EXPORT_SYMBOL(ocelot_get_ethtool_stats);

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

 	struct nfp_flower_repr_priv *repr_priv;
 	struct nfp_tun_offloaded_mac *entry;
 	struct nfp_repr *repr;
+	u16 nfp_mac_idx;
 	int ida_idx;
 	entry = nfp_tunnel_lookup_offloaded_macs(app, mac);
 		entry->bridge_count--;
 		if (!entry->bridge_count && entry->ref_count) {
-			u16 nfp_mac_idx;
 			nfp_mac_idx = entry->index & ~NFP_TUN_PRE_TUN_IDX_BIT;
 			if (__nfp_tunnel_offload_mac(app, mac, nfp_mac_idx,
 						     false)) {
 	/* If MAC is now used by 1 repr set the offloaded MAC index to port. */
 	if (entry->ref_count == 1 && list_is_singular(&entry->repr_list)) {
-		u16 nfp_mac_idx;
 		int port, err;
 		repr_priv = list_first_entry(&entry->repr_list,
 	WARN_ON_ONCE(rhashtable_remove_fast(&priv->tun.offloaded_macs,
 					    &entry->ht_node,
 					    offloaded_macs_params));
+	if (nfp_flower_is_supported_bridge(netdev))
+		nfp_mac_idx = entry->index & ~NFP_TUN_PRE_TUN_IDX_BIT;
+	else
+		nfp_mac_idx = entry->index;
 	/* If MAC has global ID then extract and free the ida entry. */
-	if (nfp_tunnel_is_mac_idx_global(entry->index)) {
+	if (nfp_tunnel_is_mac_idx_global(nfp_mac_idx)) {
 		ida_idx = nfp_tunnel_get_ida_from_global_mac_idx(entry->index);
 		ida_simple_remove(&priv->tun.mac_off_ids, ida_idx);
 	}

drivers/net/mdio/mdio-aspeed.c+1−0

@@ -148,6 +148,7 @@ static const struct of_device_id aspeed_mdio_of_match[] = { · 147 unmodified lines
148	{ .compatible = "aspeed,ast2600-mdio", },	148	{ .compatible = "aspeed,ast2600-mdio", },
149	{ },	149	{ },
150	};	150	};
		151	MODULE_DEVICE_TABLE(of, aspeed_mdio_of_match);
151		152
152	static struct platform_driver aspeed_mdio_driver = {	153	static struct platform_driver aspeed_mdio_driver = {
153	.driver = {	154	.driver = {

drivers/net/phy/marvell.c+9−8

 	else
 		mscr = 0;
-	return phy_modify_paged(phydev, MII_MARVELL_MSCR_PAGE,
+	return phy_modify_paged_changed(phydev, MII_MARVELL_MSCR_PAGE,
-				MII_88E1121_PHY_MSCR_REG,
+					MII_88E1121_PHY_MSCR_REG,
-				MII_88E1121_PHY_MSCR_DELAY_MASK, mscr);
+					MII_88E1121_PHY_MSCR_DELAY_MASK, mscr);
 }
 static int m88e1121_config_aneg(struct phy_device *phydev)
 			return err;
 	}
+	changed = err;
 	err = marvell_set_polarity(phydev, phydev->mdix_ctrl);
 	if (err < 0)
 		return err;
-	changed = err;
+	changed |= err;
 	err = genphy_config_aneg(phydev);
 	if (err < 0)
 {
 	int err;
-	err = genphy_soft_reset(phydev);
+	err = marvell_set_polarity(phydev, phydev->mdix_ctrl);
 	if (err < 0)
 		return err;
-	err = marvell_set_polarity(phydev, phydev->mdix_ctrl);
+	err = genphy_config_aneg(phydev);
 	if (err < 0)
 		return err;
-	err = genphy_config_aneg(phydev);
+	return genphy_soft_reset(phydev);
-	return 0;
 }
 static int m88e1118_config_init(struct phy_device *phydev)

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

 	{QMI_FIXED_INTF(0x413c, 0x81d7, 0)},	/* Dell Wireless 5821e */
 	{QMI_FIXED_INTF(0x413c, 0x81d7, 1)},	/* Dell Wireless 5821e preproduction config */
 	{QMI_FIXED_INTF(0x413c, 0x81e0, 0)},	/* Dell Wireless 5821e with eSIM support*/
+	{QMI_FIXED_INTF(0x413c, 0x81e4, 0)},	/* Dell Wireless 5829e with eSIM support*/
+	{QMI_FIXED_INTF(0x413c, 0x81e6, 0)},	/* Dell Wireless 5829e */
 	{QMI_FIXED_INTF(0x03f0, 0x4e1d, 8)},	/* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */
 	{QMI_FIXED_INTF(0x03f0, 0x9d1d, 1)},	/* HP lt4120 Snapdragon X5 LTE */
 	{QMI_QUIRK_SET_DTR(0x22de, 0x9051, 2)}, /* Hucom Wireless HM-211S/K */

drivers/net/veth.c+8−5

 {
 	/* Write ptr_ring before reading rx_notify_masked */
 	smp_mb();
-	if (!rq->rx_notify_masked) {
+	if (!READ_ONCE(rq->rx_notify_masked) &&
-		rq->rx_notify_masked = true;
+	    napi_schedule_prep(&rq->xdp_napi)) {
-		napi_schedule(&rq->xdp_napi);
+		WRITE_ONCE(rq->rx_notify_masked, true);
+		__napi_schedule(&rq->xdp_napi);
 	}
 }
 		/* Write rx_notify_masked before reading ptr_ring */
 		smp_store_mb(rq->rx_notify_masked, false);
 		if (unlikely(!__ptr_ring_empty(&rq->xdp_ring))) {
-			rq->rx_notify_masked = true;
+			if (napi_schedule_prep(&rq->xdp_napi)) {
-			napi_schedule(&rq->xdp_napi);
+				WRITE_ONCE(rq->rx_notify_masked, true);
+				__napi_schedule(&rq->xdp_napi);
+			}
 		}
 	}

drivers/nvme/host/core.c+8−1

@@ -4253,7 +4253,14 @@ static void nvme_async_event_work(struct work_struct *work) · 4252 unmodified lines
4253	container_of(work, struct nvme_ctrl, async_event_work);	4253	container_of(work, struct nvme_ctrl, async_event_work);
4254		4254
4255	nvme_aen_uevent(ctrl);	4255	nvme_aen_uevent(ctrl);
4256	ctrl->ops->submit_async_event(ctrl);	4256
		4257	/*
		4258	* The transport drivers must guarantee AER submission here is safe by
		4259	* flushing ctrl async_event_work after changing the controller state
		4260	* from LIVE and before freeing the admin queue.
		4261	*/
		4262	if (ctrl->state == NVME_CTRL_LIVE)
		4263	ctrl->ops->submit_async_event(ctrl);
4257	}	4264	}
4258		4265
4259	static bool nvme_ctrl_pp_status(struct nvme_ctrl *ctrl)	4266	static bool nvme_ctrl_pp_status(struct nvme_ctrl *ctrl)

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

@@ -170,6 +170,7 @@ nvmf_ctlr_matches_baseopts(struct nvme_ctrl *ctrl, · 169 unmodified lines
170	struct nvmf_ctrl_options *opts)	170	struct nvmf_ctrl_options *opts)
171	{	171	{
172	if (ctrl->state == NVME_CTRL_DELETING \|\|	172	if (ctrl->state == NVME_CTRL_DELETING \|\|
		173	ctrl->state == NVME_CTRL_DELETING_NOIO \|\|
173	ctrl->state == NVME_CTRL_DEAD \|\|	174	ctrl->state == NVME_CTRL_DEAD \|\|
174	strcmp(opts->subsysnqn, ctrl->opts->subsysnqn) \|\|	175	strcmp(opts->subsysnqn, ctrl->opts->subsysnqn) \|\|
175	strcmp(opts->host->nqn, ctrl->opts->host->nqn) \|\|	176	strcmp(opts->host->nqn, ctrl->opts->host->nqn) \|\|

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

@@ -1200,6 +1200,7 @@ static void nvme_rdma_error_recovery_work(struct work_struct *work) · 1199 unmodified lines
1200	struct nvme_rdma_ctrl, err_work);	1200	struct nvme_rdma_ctrl, err_work);
1201		1201
1202	nvme_stop_keep_alive(&ctrl->ctrl);	1202	nvme_stop_keep_alive(&ctrl->ctrl);
		1203	flush_work(&ctrl->ctrl.async_event_work);
1203	nvme_rdma_teardown_io_queues(ctrl, false);	1204	nvme_rdma_teardown_io_queues(ctrl, false);
1204	nvme_start_queues(&ctrl->ctrl);	1205	nvme_start_queues(&ctrl->ctrl);
1205	nvme_rdma_teardown_admin_queue(ctrl, false);	1206	nvme_rdma_teardown_admin_queue(ctrl, false);

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

@@ -2096,6 +2096,7 @@ static void nvme_tcp_error_recovery_work(struct work_struct *work) · 2095 unmodified lines
2096	struct nvme_ctrl *ctrl = &tcp_ctrl->ctrl;	2096	struct nvme_ctrl *ctrl = &tcp_ctrl->ctrl;
2097		2097
2098	nvme_stop_keep_alive(ctrl);	2098	nvme_stop_keep_alive(ctrl);
		2099	flush_work(&ctrl->async_event_work);
2099	nvme_tcp_teardown_io_queues(ctrl, false);	2100	nvme_tcp_teardown_io_queues(ctrl, false);
2100	/* unquiesce to fail fast pending requests */	2101	/* unquiesce to fail fast pending requests */
2101	nvme_start_queues(ctrl);	2102	nvme_start_queues(ctrl);

drivers/pci/controller/cadence/pci-j721e.c+42−43

 	const struct j721e_pcie_data *data;
 	struct cdns_pcie *cdns_pcie;
 	struct j721e_pcie *pcie;
-	struct cdns_pcie_rc *rc;
+	struct cdns_pcie_rc *rc = NULL;
-	struct cdns_pcie_ep *ep;
+	struct cdns_pcie_ep *ep = NULL;
 	struct gpio_desc *gpiod;
 	void __iomem *base;
 	struct clk *clk;
 	if (!pcie)
 		return -ENOMEM;
+	switch (mode) {
+	case PCI_MODE_RC:
+		if (!IS_ENABLED(CONFIG_PCIE_CADENCE_HOST))
+			return -ENODEV;
+		bridge = devm_pci_alloc_host_bridge(dev, sizeof(*rc));
+		if (!bridge)
+			return -ENOMEM;
+		if (!data->byte_access_allowed)
+			bridge->ops = &cdns_ti_pcie_host_ops;
+		rc = pci_host_bridge_priv(bridge);
+		rc->quirk_retrain_flag = data->quirk_retrain_flag;
+		rc->quirk_detect_quiet_flag = data->quirk_detect_quiet_flag;
+		cdns_pcie = &rc->pcie;
+		cdns_pcie->dev = dev;
+		cdns_pcie->ops = &j721e_pcie_ops;
+		pcie->cdns_pcie = cdns_pcie;
+		break;
+	case PCI_MODE_EP:
+		if (!IS_ENABLED(CONFIG_PCIE_CADENCE_EP))
+			return -ENODEV;
+		ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL);
+		if (!ep)
+			return -ENOMEM;
+		ep->quirk_detect_quiet_flag = data->quirk_detect_quiet_flag;
+		cdns_pcie = &ep->pcie;
+		cdns_pcie->dev = dev;
+		cdns_pcie->ops = &j721e_pcie_ops;
+		pcie->cdns_pcie = cdns_pcie;
+		break;
+	default:
+		dev_err(dev, "INVALID device type %d\n", mode);
+		return 0;
+	}
 	pcie->mode = mode;
 	pcie->linkdown_irq_regfield = data->linkdown_irq_regfield;
 	switch (mode) {
 	case PCI_MODE_RC:
-		if (!IS_ENABLED(CONFIG_PCIE_CADENCE_HOST)) {
-			ret = -ENODEV;
-			goto err_get_sync;
-		}
-		bridge = devm_pci_alloc_host_bridge(dev, sizeof(*rc));
-		if (!bridge) {
-			ret = -ENOMEM;
-			goto err_get_sync;
-		}
-		if (!data->byte_access_allowed)
-			bridge->ops = &cdns_ti_pcie_host_ops;
-		rc = pci_host_bridge_priv(bridge);
-		rc->quirk_retrain_flag = data->quirk_retrain_flag;
-		rc->quirk_detect_quiet_flag = data->quirk_detect_quiet_flag;
-		cdns_pcie = &rc->pcie;
-		cdns_pcie->dev = dev;
-		cdns_pcie->ops = &j721e_pcie_ops;
-		pcie->cdns_pcie = cdns_pcie;
 		gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
 		if (IS_ERR(gpiod)) {
 			ret = PTR_ERR(gpiod);
 		break;
 	case PCI_MODE_EP:
-		if (!IS_ENABLED(CONFIG_PCIE_CADENCE_EP)) {
-			ret = -ENODEV;
-			goto err_get_sync;
-		}
-		ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL);
-		if (!ep) {
-			ret = -ENOMEM;
-			goto err_get_sync;
-		}
-		ep->quirk_detect_quiet_flag = data->quirk_detect_quiet_flag;
-		cdns_pcie = &ep->pcie;
-		cdns_pcie->dev = dev;
-		cdns_pcie->ops = &j721e_pcie_ops;
-		pcie->cdns_pcie = cdns_pcie;
 		ret = cdns_pcie_init_phy(dev, cdns_pcie);
 		if (ret) {
 			dev_err(dev, "Failed to init phy\n");
 			goto err_pcie_setup;
 		break;
-	default:
-		dev_err(dev, "INVALID device type %d\n", mode);
 	}
 	return 0;

drivers/pci/controller/dwc/pcie-kirin.c+18−13

 	return 0;
 }
+struct kirin_pcie_data {
+	enum pcie_kirin_phy_type	phy_type;
+};
+static const struct kirin_pcie_data kirin_960_data = {
+	.phy_type = PCIE_KIRIN_INTERNAL_PHY,
+};
+static const struct kirin_pcie_data kirin_970_data = {
+	.phy_type = PCIE_KIRIN_EXTERNAL_PHY,
+};
 static const struct of_device_id kirin_pcie_match[] = {
-	{
+	{ .compatible = "hisilicon,kirin960-pcie", .data = &kirin_960_data },
-		.compatible = "hisilicon,kirin960-pcie",
+	{ .compatible = "hisilicon,kirin970-pcie", .data = &kirin_970_data },
-		.data = (void *)PCIE_KIRIN_INTERNAL_PHY
-	},
-	{
-		.compatible = "hisilicon,kirin970-pcie",
-		.data = (void *)PCIE_KIRIN_EXTERNAL_PHY
-	},
 	{},
 };
 static int kirin_pcie_probe(struct platform_device *pdev)
 {
-	enum pcie_kirin_phy_type phy_type;
 	struct device *dev = &pdev->dev;
+	const struct kirin_pcie_data *data;
 	struct kirin_pcie *kirin_pcie;
 	struct dw_pcie *pci;
 	int ret;
 		return -EINVAL;
 	}
-	phy_type = (long)of_device_get_match_data(dev);
+	data = of_device_get_match_data(dev);
-	if (!phy_type) {
+	if (!data) {
 		dev_err(dev, "OF data missing\n");
 		return -EINVAL;
 	}
 	kirin_pcie = devm_kzalloc(dev, sizeof(struct kirin_pcie), GFP_KERNEL);
 	if (!kirin_pcie)
 		return -ENOMEM;
 	pci->ops = &kirin_dw_pcie_ops;
 	pci->pp.ops = &kirin_pcie_host_ops;
 	kirin_pcie->pci = pci;
-	kirin_pcie->type = phy_type;
+	kirin_pcie->type = data->phy_type;
 	ret = kirin_pcie_get_resource(kirin_pcie, pdev);
 	if (ret)

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

@@ -1111,7 +1111,8 @@ const struct cpumask pci_irq_get_affinity(struct pci_dev dev, int nr) · 1110 unmodified lines
1111	if (!desc)	1111	if (!desc)
1112	return cpu_possible_mask;	1112	return cpu_possible_mask;
1113		1113
1114	if (WARN_ON_ONCE(!desc->affinity))	1114	/* MSI[X] interrupts can be allocated without affinity descriptor */
		1115	if (!desc->affinity)
1115	return NULL;	1116	return NULL;
1116		1117
1117	/*	1118	/*

drivers/scsi/bnx2fc/bnx2fc_fcoe.c+13−8

 static void bnx2fc_recv_frame(struct sk_buff *skb)
 {
-	u32 fr_len;
+	u64 crc_err;
+	u32 fr_len, fr_crc;
 	struct fc_lport *lport;
 	struct fcoe_rcv_info *fr;
 	struct fc_stats *stats;
 	skb_pull(skb, sizeof(struct fcoe_hdr));
 	fr_len = skb->len - sizeof(struct fcoe_crc_eof);
+	stats = per_cpu_ptr(lport->stats, get_cpu());
+	stats->RxFrames++;
+	stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
+	put_cpu();
 	fp = (struct fc_frame *)skb;
 	fc_frame_init(fp);
 	fr_dev(fp) = lport;
 		return;
 	}
-	stats = per_cpu_ptr(lport->stats, smp_processor_id());
+	fr_crc = le32_to_cpu(fr_crc(fp));
-	stats->RxFrames++;
-	stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
-	if (le32_to_cpu(fr_crc(fp)) !=
+	if (unlikely(fr_crc != ~crc32(~0, skb->data, fr_len))) {
-			~crc32(~0, skb->data, fr_len)) {
+		stats = per_cpu_ptr(lport->stats, get_cpu());
-		if (stats->InvalidCRCCount < 5)
+		crc_err = (stats->InvalidCRCCount++);
+		put_cpu();
+		if (crc_err < 5)
 			printk(KERN_WARNING PFX "dropping frame with "
 			       "CRC error\n");
-		stats->InvalidCRCCount++;
 		kfree_skb(skb);
 		return;
 	}

drivers/scsi/hisi_sas/hisi_sas_main.c+6−8

 			   struct hisi_sas_slot *slot,
 			   struct hisi_sas_dq *dq,
 			   struct hisi_sas_device *sas_dev,
-			   struct hisi_sas_internal_abort *abort,
+			   struct hisi_sas_internal_abort *abort)
-			   struct hisi_sas_tmf_task *tmf)
 {
 	struct hisi_sas_cmd_hdr *cmd_hdr_base;
 	int dlvry_queue_slot, dlvry_queue;
 	cmd_hdr_base = hisi_hba->cmd_hdr[dlvry_queue];
 	slot->cmd_hdr = &cmd_hdr_base[dlvry_queue_slot];
-	slot->tmf = tmf;
-	slot->is_internal = tmf;
 	task->lldd_task = slot;
 	memset(slot->cmd_hdr, 0, sizeof(struct hisi_sas_cmd_hdr));
 	slot->is_internal = tmf;
 	/* protect task_prep and start_delivery sequence */
-	hisi_sas_task_deliver(hisi_hba, slot, dq, sas_dev, NULL, tmf);
+	hisi_sas_task_deliver(hisi_hba, slot, dq, sas_dev, NULL);
 	return 0;
 	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
 	struct device *dev = hisi_hba->dev;
 	int s = sizeof(struct host_to_dev_fis);
+	struct hisi_sas_tmf_task tmf = {};
 	ata_for_each_link(link, ap, EDGE) {
 		int pmp = sata_srst_pmp(link);
 		hisi_sas_fill_ata_reset_cmd(link->device, 1, pmp, fis);
-		rc = hisi_sas_exec_internal_tmf_task(device, fis, s, NULL);
+		rc = hisi_sas_exec_internal_tmf_task(device, fis, s, &tmf);
 		if (rc != TMF_RESP_FUNC_COMPLETE)
 			break;
 	}
 			hisi_sas_fill_ata_reset_cmd(link->device, 0, pmp, fis);
 			rc = hisi_sas_exec_internal_tmf_task(device, fis,
-							     s, NULL);
+							     s, &tmf);
 			if (rc != TMF_RESP_FUNC_COMPLETE)
 				dev_err(dev, "ata disk %016llx de-reset failed\n",
 					SAS_ADDR(device->sas_addr));
 	slot->port = port;
 	slot->is_internal = true;
-	hisi_sas_task_deliver(hisi_hba, slot, dq, sas_dev, abort, NULL);
+	hisi_sas_task_deliver(hisi_hba, slot, dq, sas_dev, abort);
 	return 0;

drivers/scsi/pm8001/pm8001_hwi.c+0−18

 	u32 tag = le32_to_cpu(psataPayload->tag);
 	u32 port_id = le32_to_cpu(psataPayload->port_id);
 	u32 dev_id = le32_to_cpu(psataPayload->device_id);
-	unsigned long flags;
 	if (event)
 		pm8001_dbg(pm8001_ha, FAIL, "SATA EVENT 0x%x\n", event);
 		ts->resp = SAS_TASK_COMPLETE;
 		ts->stat = SAS_DATA_OVERRUN;
 		ts->residual = 0;
-		if (pm8001_dev)
-			atomic_dec(&pm8001_dev->running_req);
 		break;
 	case IO_XFER_ERROR_BREAK:
 		pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
 				IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
 			ts->resp = SAS_TASK_COMPLETE;
 			ts->stat = SAS_QUEUE_FULL;
-			pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
 			return;
 		}
 		break;
 		ts->stat = SAS_OPEN_TO;
 		break;
 	}
-	spin_lock_irqsave(&t->task_state_lock, flags);
-	t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
-	t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
-	t->task_state_flags |= SAS_TASK_STATE_DONE;
-	if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
-		spin_unlock_irqrestore(&t->task_state_lock, flags);
-		pm8001_dbg(pm8001_ha, FAIL,
-			   "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
-			   t, event, ts->resp, ts->stat);
-		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
-	} else {
-		spin_unlock_irqrestore(&t->task_state_lock, flags);
-		pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
-	}
 }
 /*See the comments for mpi_ssp_completion */

drivers/scsi/pm8001/pm8001_sas.c+5−0

 		res = -TMF_RESP_FUNC_FAILED;
 		/* Even TMF timed out, return direct. */
 		if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
+			struct pm8001_ccb_info *ccb = task->lldd_task;
 			pm8001_dbg(pm8001_ha, FAIL, "TMF task[%x]timeout.\n",
 				   tmf->tmf);
+			if (ccb)
+				ccb->task = NULL;
 			goto ex_err;
 		}

drivers/scsi/pm8001/pm80xx_hwi.c+3−28

 		pm8001_dbg(pm8001_ha, FAIL,
 			   "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
 			   t, status, ts->resp, ts->stat);
+		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
 		if (t->slow_task)
 			complete(&t->slow_task->completion);
-		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
 	} else {
 		spin_unlock_irqrestore(&t->task_state_lock, flags);
 		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
 		pm8001_dbg(pm8001_ha, FAIL,
 			   "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
 			   t, status, ts->resp, ts->stat);
+		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
 		if (t->slow_task)
 			complete(&t->slow_task->completion);
-		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
 	} else {
 		spin_unlock_irqrestore(&t->task_state_lock, flags);
 		spin_unlock_irqrestore(&circularQ->oq_lock,
 	u32 tag = le32_to_cpu(psataPayload->tag);
 	u32 port_id = le32_to_cpu(psataPayload->port_id);
 	u32 dev_id = le32_to_cpu(psataPayload->device_id);
-	unsigned long flags;
 	if (event)
 		pm8001_dbg(pm8001_ha, FAIL, "SATA EVENT 0x%x\n", event);
 		ts->resp = SAS_TASK_COMPLETE;
 		ts->stat = SAS_DATA_OVERRUN;
 		ts->residual = 0;
-		if (pm8001_dev)
-			atomic_dec(&pm8001_dev->running_req);
 		break;
 	case IO_XFER_ERROR_BREAK:
 		pm8001_dbg(pm8001_ha, IO, "IO_XFER_ERROR_BREAK\n");
 				IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
 			ts->resp = SAS_TASK_COMPLETE;
 			ts->stat = SAS_QUEUE_FULL;
-			spin_unlock_irqrestore(&circularQ->oq_lock,
-					circularQ->lock_flags);
-			pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
-			spin_lock_irqsave(&circularQ->oq_lock,
-					circularQ->lock_flags);
 			return;
 		}
 		break;
 		ts->stat = SAS_OPEN_TO;
 		break;
 	}
-	spin_lock_irqsave(&t->task_state_lock, flags);
-	t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
-	t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
-	t->task_state_flags |= SAS_TASK_STATE_DONE;
-	if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
-		spin_unlock_irqrestore(&t->task_state_lock, flags);
-		pm8001_dbg(pm8001_ha, FAIL,
-			   "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
-			   t, event, ts->resp, ts->stat);
-		pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
-	} else {
-		spin_unlock_irqrestore(&t->task_state_lock, flags);
-		spin_unlock_irqrestore(&circularQ->oq_lock,
-				circularQ->lock_flags);
-		pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
-		spin_lock_irqsave(&circularQ->oq_lock,
-				circularQ->lock_flags);
-	}
 }
 /*See the comments for mpi_ssp_completion */
 /**
  * process_one_iomb - process one outbound Queue memory block
  * @pm8001_ha: our hba card information
+ * @circularQ: outbound circular queue
  * @piomb: IO message buffer
  */
 static void process_one_iomb(struct pm8001_hba_info *pm8001_ha,

drivers/scsi/scsi_scan.c+50−5

@@ -214,6 +214,48 @@ static void scsi_unlock_floptical(struct scsi_device *sdev, · 213 unmodified lines
214	SCSI_TIMEOUT, 3, NULL);	214	SCSI_TIMEOUT, 3, NULL);
215	}	215	}
216		216
		217	static int scsi_realloc_sdev_budget_map(struct scsi_device *sdev,
		218	unsigned int depth)
		219	{
		220	int new_shift = sbitmap_calculate_shift(depth);
		221	bool need_alloc = !sdev->budget_map.map;
		222	bool need_free = false;
		223	int ret;
		224	struct sbitmap sb_backup;
		225
		226	/*
		227	* realloc if new shift is calculated, which is caused by setting
		228	* up one new default queue depth after calling ->slave_configure
		229	*/
		230	if (!need_alloc && new_shift != sdev->budget_map.shift)
		231	need_alloc = need_free = true;
		232
		233	if (!need_alloc)
		234	return 0;
		235
		236	/*
		237	* Request queue has to be frozen for reallocating budget map,
		238	* and here disk isn't added yet, so freezing is pretty fast
		239	*/
		240	if (need_free) {
		241	blk_mq_freeze_queue(sdev->request_queue);
		242	sb_backup = sdev->budget_map;
		243	}
		244	ret = sbitmap_init_node(&sdev->budget_map,
		245	scsi_device_max_queue_depth(sdev),
		246	new_shift, GFP_KERNEL,
		247	sdev->request_queue->node, false, true);
		248	if (need_free) {
		249	if (ret)
		250	sdev->budget_map = sb_backup;
		251	else
		252	sbitmap_free(&sb_backup);
		253	ret = 0;
		254	blk_mq_unfreeze_queue(sdev->request_queue);
		255	}
		256	return ret;
		257	}
		258
217	/**	259	/**
218	* scsi_alloc_sdev - allocate and setup a scsi_Device	260	* scsi_alloc_sdev - allocate and setup a scsi_Device
219	* @starget: which target to allocate a &scsi_device for	261	* @starget: which target to allocate a &scsi_device for
@@ -306,11 +348,7 @@ static struct scsi_device scsi_alloc_sdev(struct scsi_target starget, · 86 unmodified lines
306	* default device queue depth to figure out sbitmap shift	348	* default device queue depth to figure out sbitmap shift
307	* since we use this queue depth most of times.	349	* since we use this queue depth most of times.
308	*/	350	*/
309	if (sbitmap_init_node(&sdev->budget_map,	351	if (scsi_realloc_sdev_budget_map(sdev, depth)) {
310	scsi_device_max_queue_depth(sdev),
311	sbitmap_calculate_shift(depth),
312	GFP_KERNEL, sdev->request_queue->node,
313	false, true)) {
314	put_device(&starget->dev);	352	put_device(&starget->dev);
315	kfree(sdev);	353	kfree(sdev);
316	goto out;	354	goto out;
@@ -1017,6 +1055,13 @@ static int scsi_add_lun(struct scsi_device sdev, unsigned char inq_result, · 700 unmodified lines
1017	}	1055	}
1018	return SCSI_SCAN_NO_RESPONSE;	1056	return SCSI_SCAN_NO_RESPONSE;
1019	}	1057	}
		1058
		1059	/*
		1060	* The queue_depth is often changed in ->slave_configure.
		1061	* Set up budget map again since memory consumption of
		1062	* the map depends on actual queue depth.
		1063	*/
		1064	scsi_realloc_sdev_budget_map(sdev, sdev->queue_depth);
1020	}	1065	}
1021		1066
1022	if (sdev->scsi_level >= SCSI_3)	1067	if (sdev->scsi_level >= SCSI_3)

drivers/video/console/Kconfig+20−0

@@ -78,6 +78,26 @@ config FRAMEBUFFER_CONSOLE · 77 unmodified lines
78	help	78	help
79	Low-level framebuffer-based console driver.	79	Low-level framebuffer-based console driver.
80		80
		81	config FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
		82	bool "Enable legacy fbcon hardware acceleration code"
		83	depends on FRAMEBUFFER_CONSOLE
		84	default y if PARISC
		85	default n
		86	help
		87	This option enables the fbcon (framebuffer text-based) hardware
		88	acceleration for graphics drivers which were written for the fbdev
		89	graphics interface.
		90
		91	On modern machines, on mainstream machines (like x86-64) or when
		92	using a modern Linux distribution those fbdev drivers usually aren't used.
		93	So enabling this option wouldn't have any effect, which is why you want
		94	to disable this option on such newer machines.
		95
		96	If you compile this kernel for older machines which still require the
		97	fbdev drivers, you may want to say Y.
		98
		99	If unsure, select n.
		100
81	config FRAMEBUFFER_CONSOLE_DETECT_PRIMARY	101	config FRAMEBUFFER_CONSOLE_DETECT_PRIMARY
82	bool "Map the console to the primary display device"	102	bool "Map the console to the primary display device"
83	depends on FRAMEBUFFER_CONSOLE	103	depends on FRAMEBUFFER_CONSOLE

drivers/video/fbdev/core/bitblit.c+16−0

@@ -43,6 +43,21 @@ static void update_attr(u8 dst, u8 src, int attribute, · 42 unmodified lines
43	}	43	}
44	}	44	}
45		45
		46	static void bit_bmove(struct vc_data vc, struct fb_info info, int sy,
		47	int sx, int dy, int dx, int height, int width)
		48	{
		49	struct fb_copyarea area;
		50
		51	area.sx = sx * vc->vc_font.width;
		52	area.sy = sy * vc->vc_font.height;
		53	area.dx = dx * vc->vc_font.width;
		54	area.dy = dy * vc->vc_font.height;
		55	area.height = height * vc->vc_font.height;
		56	area.width = width * vc->vc_font.width;
		57
		58	info->fbops->fb_copyarea(info, &area);
		59	}
		60
46	static void bit_clear(struct vc_data vc, struct fb_info info, int sy,	61	static void bit_clear(struct vc_data vc, struct fb_info info, int sy,
47	int sx, int height, int width)	62	int sx, int height, int width)
48	{	63	{
@@ -378,6 +393,7 @@ static int bit_update_start(struct fb_info *info) · 329 unmodified lines
378		393
379	void fbcon_set_bitops(struct fbcon_ops *ops)	394	void fbcon_set_bitops(struct fbcon_ops *ops)
380	{	395	{
		396	ops->bmove = bit_bmove;
381	ops->clear = bit_clear;	397	ops->clear = bit_clear;
382	ops->putcs = bit_putcs;	398	ops->putcs = bit_putcs;
383	ops->clear_margins = bit_clear_margins;	399	ops->clear_margins = bit_clear_margins;

drivers/video/fbdev/core/fbcon.c+536−21

@@ -173,6 +173,8 @@ static void fbcon_putcs(struct vc_data vc, const unsigned short s, · 172 unmodified lines
173	int count, int ypos, int xpos);	173	int count, int ypos, int xpos);
174	static void fbcon_clear_margins(struct vc_data *vc, int bottom_only);	174	static void fbcon_clear_margins(struct vc_data *vc, int bottom_only);
175	static void fbcon_cursor(struct vc_data *vc, int mode);	175	static void fbcon_cursor(struct vc_data *vc, int mode);
		176	static void fbcon_bmove(struct vc_data *vc, int sy, int sx, int dy, int dx,
		177	int height, int width);
176	static int fbcon_switch(struct vc_data *vc);	178	static int fbcon_switch(struct vc_data *vc);
177	static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch);	179	static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch);
178	static void fbcon_set_palette(struct vc_data vc, const unsigned char table);	180	static void fbcon_set_palette(struct vc_data vc, const unsigned char table);
@@ -180,8 +182,16 @@ static void fbcon_set_palette(struct vc_data vc, const unsigned char table); · 1 unmodified line
180	/*	182	/*
181	* Internal routines	183	* Internal routines
182	*/	184	*/
		185	static __inline__ void ywrap_up(struct vc_data *vc, int count);
		186	static __inline__ void ywrap_down(struct vc_data *vc, int count);
		187	static __inline__ void ypan_up(struct vc_data *vc, int count);
		188	static __inline__ void ypan_down(struct vc_data *vc, int count);
		189	static void fbcon_bmove_rec(struct vc_data vc, struct fbcon_display p, int sy, int sx,
		190	int dy, int dx, int height, int width, u_int y_break);
183	static void fbcon_set_disp(struct fb_info info, struct fb_var_screeninfo var,	191	static void fbcon_set_disp(struct fb_info info, struct fb_var_screeninfo var,
184	int unit);	192	int unit);
		193	static void fbcon_redraw_move(struct vc_data vc, struct fbcon_display p,
		194	int line, int count, int dy);
185	static void fbcon_modechanged(struct fb_info *info);	195	static void fbcon_modechanged(struct fb_info *info);
186	static void fbcon_set_all_vcs(struct fb_info *info);	196	static void fbcon_set_all_vcs(struct fb_info *info);
187	static void fbcon_start(void);	197	static void fbcon_start(void);
@@ -1015,7 +1025,7 @@ static void fbcon_init(struct vc_data *vc, int init) · 827 unmodified lines
1015	struct vc_data svc = default_mode;	1025	struct vc_data svc = default_mode;
1016	struct fbcon_display t, p = &fb_display[vc->vc_num];	1026	struct fbcon_display t, p = &fb_display[vc->vc_num];
1017	int logo = 1, new_rows, new_cols, rows, cols;	1027	int logo = 1, new_rows, new_cols, rows, cols;
1018	int ret;	1028	int cap, ret;
1019		1029
1020	if (WARN_ON(info_idx == -1))	1030	if (WARN_ON(info_idx == -1))
1021	return;	1031	return;
@@ -1024,6 +1034,7 @@ static void fbcon_init(struct vc_data *vc, int init) · 2 unmodified lines
1024	con2fb_map[vc->vc_num] = info_idx;	1034	con2fb_map[vc->vc_num] = info_idx;
1025		1035
1026	info = registered_fb[con2fb_map[vc->vc_num]];	1036	info = registered_fb[con2fb_map[vc->vc_num]];
		1037	cap = info->flags;
1027		1038
1028	if (logo_shown < 0 && console_loglevel <= CONSOLE_LOGLEVEL_QUIET)	1039	if (logo_shown < 0 && console_loglevel <= CONSOLE_LOGLEVEL_QUIET)
1029	logo_shown = FBCON_LOGO_DONTSHOW;	1040	logo_shown = FBCON_LOGO_DONTSHOW;
@@ -1125,6 +1136,14 @@ static void fbcon_init(struct vc_data *vc, int init) · 95 unmodified lines
1125		1136
1126	ops->graphics = 0;	1137	ops->graphics = 0;
1127		1138
		1139	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
		1140	if ((cap & FBINFO_HWACCEL_COPYAREA) &&
		1141	!(cap & FBINFO_HWACCEL_DISABLED))
		1142	p->scrollmode = SCROLL_MOVE;
		1143	else /* default to something safe */
		1144	p->scrollmode = SCROLL_REDRAW;
		1145	#endif
		1146
1128	/*	1147	/*
1129	* ++guenther: console.c:vc_allocate() relies on initializing	1148	* ++guenther: console.c:vc_allocate() relies on initializing
1130	* vc_{cols,rows}, but we must not set those if we are only	1149	* vc_{cols,rows}, but we must not set those if we are only
@@ -1211,13 +1230,14 @@ finished: · 80 unmodified lines
1211	* This system is now divided into two levels because of complications	1230	* This system is now divided into two levels because of complications
1212	* caused by hardware scrolling. Top level functions:	1231	* caused by hardware scrolling. Top level functions:
1213	*	1232	*
1214	* fbcon_clear(), fbcon_putc(), fbcon_clear_margins()	1233	* fbcon_bmove(), fbcon_clear(), fbcon_putc(), fbcon_clear_margins()
1215	*	1234	*
1216	* handles y values in range [0, scr_height-1] that correspond to real	1235	* handles y values in range [0, scr_height-1] that correspond to real
1217	* screen positions. y_wrap shift means that first line of bitmap may be	1236	* screen positions. y_wrap shift means that first line of bitmap may be
1218	* anywhere on this display. These functions convert lineoffsets to	1237	* anywhere on this display. These functions convert lineoffsets to
1219	* bitmap offsets and deal with the wrap-around case by splitting blits.	1238	* bitmap offsets and deal with the wrap-around case by splitting blits.
1220	*	1239	*
		1240	* fbcon_bmove_physical_8() -- These functions fast implementations
1221	* fbcon_clear_physical_8() -- of original fbcon_XXX fns.	1241	* fbcon_clear_physical_8() -- of original fbcon_XXX fns.
1222	* fbcon_putc_physical_8() -- (font width != 8) may be added later	1242	* fbcon_putc_physical_8() -- (font width != 8) may be added later
1223	*	1243	*
@@ -1390,6 +1410,224 @@ static void fbcon_set_disp(struct fb_info info, struct fb_var_screeninfo var, · 166 unmodified lines
1390	}	1410	}
1391	}	1411	}
1392		1412
		1413	static __inline__ void ywrap_up(struct vc_data *vc, int count)
		1414	{
		1415	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1416	struct fbcon_ops *ops = info->fbcon_par;
		1417	struct fbcon_display *p = &fb_display[vc->vc_num];
		1418
		1419	p->yscroll += count;
		1420	if (p->yscroll >= p->vrows) /* Deal with wrap */
		1421	p->yscroll -= p->vrows;
		1422	ops->var.xoffset = 0;
		1423	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1424	ops->var.vmode \|= FB_VMODE_YWRAP;
		1425	ops->update_start(info);
		1426	scrollback_max += count;
		1427	if (scrollback_max > scrollback_phys_max)
		1428	scrollback_max = scrollback_phys_max;
		1429	scrollback_current = 0;
		1430	}
		1431
		1432	static __inline__ void ywrap_down(struct vc_data *vc, int count)
		1433	{
		1434	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1435	struct fbcon_ops *ops = info->fbcon_par;
		1436	struct fbcon_display *p = &fb_display[vc->vc_num];
		1437
		1438	p->yscroll -= count;
		1439	if (p->yscroll < 0) /* Deal with wrap */
		1440	p->yscroll += p->vrows;
		1441	ops->var.xoffset = 0;
		1442	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1443	ops->var.vmode \|= FB_VMODE_YWRAP;
		1444	ops->update_start(info);
		1445	scrollback_max -= count;
		1446	if (scrollback_max < 0)
		1447	scrollback_max = 0;
		1448	scrollback_current = 0;
		1449	}
		1450
		1451	static __inline__ void ypan_up(struct vc_data *vc, int count)
		1452	{
		1453	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1454	struct fbcon_display *p = &fb_display[vc->vc_num];
		1455	struct fbcon_ops *ops = info->fbcon_par;
		1456
		1457	p->yscroll += count;
		1458	if (p->yscroll > p->vrows - vc->vc_rows) {
		1459	ops->bmove(vc, info, p->vrows - vc->vc_rows,
		1460	0, 0, 0, vc->vc_rows, vc->vc_cols);
		1461	p->yscroll -= p->vrows - vc->vc_rows;
		1462	}
		1463
		1464	ops->var.xoffset = 0;
		1465	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1466	ops->var.vmode &= ~FB_VMODE_YWRAP;
		1467	ops->update_start(info);
		1468	fbcon_clear_margins(vc, 1);
		1469	scrollback_max += count;
		1470	if (scrollback_max > scrollback_phys_max)
		1471	scrollback_max = scrollback_phys_max;
		1472	scrollback_current = 0;
		1473	}
		1474
		1475	static __inline__ void ypan_up_redraw(struct vc_data *vc, int t, int count)
		1476	{
		1477	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1478	struct fbcon_ops *ops = info->fbcon_par;
		1479	struct fbcon_display *p = &fb_display[vc->vc_num];
		1480
		1481	p->yscroll += count;
		1482
		1483	if (p->yscroll > p->vrows - vc->vc_rows) {
		1484	p->yscroll -= p->vrows - vc->vc_rows;
		1485	fbcon_redraw_move(vc, p, t + count, vc->vc_rows - count, t);
		1486	}
		1487
		1488	ops->var.xoffset = 0;
		1489	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1490	ops->var.vmode &= ~FB_VMODE_YWRAP;
		1491	ops->update_start(info);
		1492	fbcon_clear_margins(vc, 1);
		1493	scrollback_max += count;
		1494	if (scrollback_max > scrollback_phys_max)
		1495	scrollback_max = scrollback_phys_max;
		1496	scrollback_current = 0;
		1497	}
		1498
		1499	static __inline__ void ypan_down(struct vc_data *vc, int count)
		1500	{
		1501	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1502	struct fbcon_display *p = &fb_display[vc->vc_num];
		1503	struct fbcon_ops *ops = info->fbcon_par;
		1504
		1505	p->yscroll -= count;
		1506	if (p->yscroll < 0) {
		1507	ops->bmove(vc, info, 0, 0, p->vrows - vc->vc_rows,
		1508	0, vc->vc_rows, vc->vc_cols);
		1509	p->yscroll += p->vrows - vc->vc_rows;
		1510	}
		1511
		1512	ops->var.xoffset = 0;
		1513	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1514	ops->var.vmode &= ~FB_VMODE_YWRAP;
		1515	ops->update_start(info);
		1516	fbcon_clear_margins(vc, 1);
		1517	scrollback_max -= count;
		1518	if (scrollback_max < 0)
		1519	scrollback_max = 0;
		1520	scrollback_current = 0;
		1521	}
		1522
		1523	static __inline__ void ypan_down_redraw(struct vc_data *vc, int t, int count)
		1524	{
		1525	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1526	struct fbcon_ops *ops = info->fbcon_par;
		1527	struct fbcon_display *p = &fb_display[vc->vc_num];
		1528
		1529	p->yscroll -= count;
		1530
		1531	if (p->yscroll < 0) {
		1532	p->yscroll += p->vrows - vc->vc_rows;
		1533	fbcon_redraw_move(vc, p, t, vc->vc_rows - count, t + count);
		1534	}
		1535
		1536	ops->var.xoffset = 0;
		1537	ops->var.yoffset = p->yscroll * vc->vc_font.height;
		1538	ops->var.vmode &= ~FB_VMODE_YWRAP;
		1539	ops->update_start(info);
		1540	fbcon_clear_margins(vc, 1);
		1541	scrollback_max -= count;
		1542	if (scrollback_max < 0)
		1543	scrollback_max = 0;
		1544	scrollback_current = 0;
		1545	}
		1546
		1547	static void fbcon_redraw_move(struct vc_data vc, struct fbcon_display p,
		1548	int line, int count, int dy)
		1549	{
		1550	unsigned short s = (unsigned short )
		1551	(vc->vc_origin + vc->vc_size_row * line);
		1552
		1553	while (count--) {
		1554	unsigned short *start = s;
		1555	unsigned short *le = advance_row(s, 1);
		1556	unsigned short c;
		1557	int x = 0;
		1558	unsigned short attr = 1;
		1559
		1560	do {
		1561	c = scr_readw(s);
		1562	if (attr != (c & 0xff00)) {
		1563	attr = c & 0xff00;
		1564	if (s > start) {
		1565	fbcon_putcs(vc, start, s - start,
		1566	dy, x);
		1567	x += s - start;
		1568	start = s;
		1569	}
		1570	}
		1571	console_conditional_schedule();
		1572	s++;
		1573	} while (s < le);
		1574	if (s > start)
		1575	fbcon_putcs(vc, start, s - start, dy, x);
		1576	console_conditional_schedule();
		1577	dy++;
		1578	}
		1579	}
		1580
		1581	static void fbcon_redraw_blit(struct vc_data vc, struct fb_info info,
		1582	struct fbcon_display *p, int line, int count, int ycount)
		1583	{
		1584	int offset = ycount * vc->vc_cols;
		1585	unsigned short d = (unsigned short )
		1586	(vc->vc_origin + vc->vc_size_row * line);
		1587	unsigned short *s = d + offset;
		1588	struct fbcon_ops *ops = info->fbcon_par;
		1589
		1590	while (count--) {
		1591	unsigned short *start = s;
		1592	unsigned short *le = advance_row(s, 1);
		1593	unsigned short c;
		1594	int x = 0;
		1595
		1596	do {
		1597	c = scr_readw(s);
		1598
		1599	if (c == scr_readw(d)) {
		1600	if (s > start) {
		1601	ops->bmove(vc, info, line + ycount, x,
		1602	line, x, 1, s-start);
		1603	x += s - start + 1;
		1604	start = s + 1;
		1605	} else {
		1606	x++;
		1607	start++;
		1608	}
		1609	}
		1610
		1611	scr_writew(c, d);
		1612	console_conditional_schedule();
		1613	s++;
		1614	d++;
		1615	} while (s < le);
		1616	if (s > start)
		1617	ops->bmove(vc, info, line + ycount, x, line, x, 1,
		1618	s-start);
		1619	console_conditional_schedule();
		1620	if (ycount > 0)
		1621	line++;
		1622	else {
		1623	line--;
		1624	/* NOTE: We subtract two lines from these pointers */
		1625	s -= vc->vc_size_row;
		1626	d -= vc->vc_size_row;
		1627	}
		1628	}
		1629	}
		1630
1393	static void fbcon_redraw(struct vc_data vc, struct fbcon_display p,	1631	static void fbcon_redraw(struct vc_data vc, struct fbcon_display p,
1394	int line, int count, int offset)	1632	int line, int count, int offset)
1395	{	1633	{
@@ -1450,6 +1688,7 @@ static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b, · 54 unmodified lines
1450	{	1688	{
1451	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];	1689	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
1452	struct fbcon_display *p = &fb_display[vc->vc_num];	1690	struct fbcon_display *p = &fb_display[vc->vc_num];
		1691	int scroll_partial = info->flags & FBINFO_PARTIAL_PAN_OK;
1453		1692
1454	if (fbcon_is_inactive(vc, info))	1693	if (fbcon_is_inactive(vc, info))
1455	return true;	1694	return true;
@@ -1466,32 +1705,291 @@ static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b, · 10 unmodified lines
1466	case SM_UP:	1705	case SM_UP:
1467	if (count > vc->vc_rows) /* Maximum realistic size */	1706	if (count > vc->vc_rows) /* Maximum realistic size */
1468	count = vc->vc_rows;	1707	count = vc->vc_rows;
1469	fbcon_redraw(vc, p, t, b - t - count,	1708	if (logo_shown >= 0)
1470	count * vc->vc_cols);	1709	goto redraw_up;
1471	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);	1710	switch (fb_scrollmode(p)) {
1472	scr_memsetw((unsigned short *) (vc->vc_origin +	1711	case SCROLL_MOVE:
1473	vc->vc_size_row *	1712	fbcon_redraw_blit(vc, info, p, t, b - t - count,
1474	(b - count)),	1713	count);
1475	vc->vc_video_erase_char,	1714	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
1476	vc->vc_size_row * count);	1715	scr_memsetw((unsigned short *) (vc->vc_origin +
1477	return true;	1716	vc->vc_size_row *
		1717	(b - count)),
		1718	vc->vc_video_erase_char,
		1719	vc->vc_size_row * count);
		1720	return true;
		1721
		1722	case SCROLL_WRAP_MOVE:
		1723	if (b - t - count > 3 * vc->vc_rows >> 2) {
		1724	if (t > 0)
		1725	fbcon_bmove(vc, 0, 0, count, 0, t,
		1726	vc->vc_cols);
		1727	ywrap_up(vc, count);
		1728	if (vc->vc_rows - b > 0)
		1729	fbcon_bmove(vc, b - count, 0, b, 0,
		1730	vc->vc_rows - b,
		1731	vc->vc_cols);
		1732	} else if (info->flags & FBINFO_READS_FAST)
		1733	fbcon_bmove(vc, t + count, 0, t, 0,
		1734	b - t - count, vc->vc_cols);
		1735	else
		1736	goto redraw_up;
		1737	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
		1738	break;
		1739
		1740	case SCROLL_PAN_REDRAW:
		1741	if ((p->yscroll + count <=
		1742	2 * (p->vrows - vc->vc_rows))
		1743	&& ((!scroll_partial && (b - t == vc->vc_rows))
		1744	\|\| (scroll_partial
		1745	&& (b - t - count >
		1746	3 * vc->vc_rows >> 2)))) {
		1747	if (t > 0)
		1748	fbcon_redraw_move(vc, p, 0, t, count);
		1749	ypan_up_redraw(vc, t, count);
		1750	if (vc->vc_rows - b > 0)
		1751	fbcon_redraw_move(vc, p, b,
		1752	vc->vc_rows - b, b);
		1753	} else
		1754	fbcon_redraw_move(vc, p, t + count, b - t - count, t);
		1755	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
		1756	break;
		1757
		1758	case SCROLL_PAN_MOVE:
		1759	if ((p->yscroll + count <=
		1760	2 * (p->vrows - vc->vc_rows))
		1761	&& ((!scroll_partial && (b - t == vc->vc_rows))
		1762	\|\| (scroll_partial
		1763	&& (b - t - count >
		1764	3 * vc->vc_rows >> 2)))) {
		1765	if (t > 0)
		1766	fbcon_bmove(vc, 0, 0, count, 0, t,
		1767	vc->vc_cols);
		1768	ypan_up(vc, count);
		1769	if (vc->vc_rows - b > 0)
		1770	fbcon_bmove(vc, b - count, 0, b, 0,
		1771	vc->vc_rows - b,
		1772	vc->vc_cols);
		1773	} else if (info->flags & FBINFO_READS_FAST)
		1774	fbcon_bmove(vc, t + count, 0, t, 0,
		1775	b - t - count, vc->vc_cols);
		1776	else
		1777	goto redraw_up;
		1778	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
		1779	break;
		1780
		1781	case SCROLL_REDRAW:
		1782	redraw_up:
		1783	fbcon_redraw(vc, p, t, b - t - count,
		1784	count * vc->vc_cols);
		1785	fbcon_clear(vc, b - count, 0, count, vc->vc_cols);
		1786	scr_memsetw((unsigned short *) (vc->vc_origin +
		1787	vc->vc_size_row *
		1788	(b - count)),
		1789	vc->vc_video_erase_char,
		1790	vc->vc_size_row * count);
		1791	return true;
		1792	}
		1793	break;
1478		1794
1479	case SM_DOWN:	1795	case SM_DOWN:
1480	if (count > vc->vc_rows) /* Maximum realistic size */	1796	if (count > vc->vc_rows) /* Maximum realistic size */
1481	count = vc->vc_rows;	1797	count = vc->vc_rows;
1482	fbcon_redraw(vc, p, b - 1, b - t - count,	1798	if (logo_shown >= 0)
1483	-count * vc->vc_cols);	1799	goto redraw_down;
1484	fbcon_clear(vc, t, 0, count, vc->vc_cols);	1800	switch (fb_scrollmode(p)) {
1485	scr_memsetw((unsigned short *) (vc->vc_origin +	1801	case SCROLL_MOVE:
1486	vc->vc_size_row *	1802	fbcon_redraw_blit(vc, info, p, b - 1, b - t - count,
1487	t),	1803	-count);
1488	vc->vc_video_erase_char,	1804	fbcon_clear(vc, t, 0, count, vc->vc_cols);
1489	vc->vc_size_row * count);	1805	scr_memsetw((unsigned short *) (vc->vc_origin +
1490	return true;	1806	vc->vc_size_row *
		1807	t),
		1808	vc->vc_video_erase_char,
		1809	vc->vc_size_row * count);
		1810	return true;
		1811
		1812	case SCROLL_WRAP_MOVE:
		1813	if (b - t - count > 3 * vc->vc_rows >> 2) {
		1814	if (vc->vc_rows - b > 0)
		1815	fbcon_bmove(vc, b, 0, b - count, 0,
		1816	vc->vc_rows - b,
		1817	vc->vc_cols);
		1818	ywrap_down(vc, count);
		1819	if (t > 0)
		1820	fbcon_bmove(vc, count, 0, 0, 0, t,
		1821	vc->vc_cols);
		1822	} else if (info->flags & FBINFO_READS_FAST)
		1823	fbcon_bmove(vc, t, 0, t + count, 0,
		1824	b - t - count, vc->vc_cols);
		1825	else
		1826	goto redraw_down;
		1827	fbcon_clear(vc, t, 0, count, vc->vc_cols);
		1828	break;
		1829
		1830	case SCROLL_PAN_MOVE:
		1831	if ((count - p->yscroll <= p->vrows - vc->vc_rows)
		1832	&& ((!scroll_partial && (b - t == vc->vc_rows))
		1833	\|\| (scroll_partial
		1834	&& (b - t - count >
		1835	3 * vc->vc_rows >> 2)))) {
		1836	if (vc->vc_rows - b > 0)
		1837	fbcon_bmove(vc, b, 0, b - count, 0,
		1838	vc->vc_rows - b,
		1839	vc->vc_cols);
		1840	ypan_down(vc, count);
		1841	if (t > 0)
		1842	fbcon_bmove(vc, count, 0, 0, 0, t,
		1843	vc->vc_cols);
		1844	} else if (info->flags & FBINFO_READS_FAST)
		1845	fbcon_bmove(vc, t, 0, t + count, 0,
		1846	b - t - count, vc->vc_cols);
		1847	else
		1848	goto redraw_down;
		1849	fbcon_clear(vc, t, 0, count, vc->vc_cols);
		1850	break;
		1851
		1852	case SCROLL_PAN_REDRAW:
		1853	if ((count - p->yscroll <= p->vrows - vc->vc_rows)
		1854	&& ((!scroll_partial && (b - t == vc->vc_rows))
		1855	\|\| (scroll_partial
		1856	&& (b - t - count >
		1857	3 * vc->vc_rows >> 2)))) {
		1858	if (vc->vc_rows - b > 0)
		1859	fbcon_redraw_move(vc, p, b, vc->vc_rows - b,
		1860	b - count);
		1861	ypan_down_redraw(vc, t, count);
		1862	if (t > 0)
		1863	fbcon_redraw_move(vc, p, count, t, 0);
		1864	} else
		1865	fbcon_redraw_move(vc, p, t, b - t - count, t + count);
		1866	fbcon_clear(vc, t, 0, count, vc->vc_cols);
		1867	break;
		1868
		1869	case SCROLL_REDRAW:
		1870	redraw_down:
		1871	fbcon_redraw(vc, p, b - 1, b - t - count,
		1872	-count * vc->vc_cols);
		1873	fbcon_clear(vc, t, 0, count, vc->vc_cols);
		1874	scr_memsetw((unsigned short *) (vc->vc_origin +
		1875	vc->vc_size_row *
		1876	t),
		1877	vc->vc_video_erase_char,
		1878	vc->vc_size_row * count);
		1879	return true;
		1880	}
1491	}	1881	}
1492	return false;	1882	return false;
1493	}	1883	}
1494		1884
		1885
		1886	static void fbcon_bmove(struct vc_data *vc, int sy, int sx, int dy, int dx,
		1887	int height, int width)
		1888	{
		1889	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1890	struct fbcon_display *p = &fb_display[vc->vc_num];
		1891
		1892	if (fbcon_is_inactive(vc, info))
		1893	return;
		1894
		1895	if (!width \|\| !height)
		1896	return;
		1897
		1898	/* Split blits that cross physical y_wrap case.
		1899	* Pathological case involves 4 blits, better to use recursive
		1900	* code rather than unrolled case
		1901	*
		1902	* Recursive invocations don't need to erase the cursor over and
		1903	* over again, so we use fbcon_bmove_rec()
		1904	*/
		1905	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, height, width,
		1906	p->vrows - p->yscroll);
		1907	}
		1908
		1909	static void fbcon_bmove_rec(struct vc_data vc, struct fbcon_display p, int sy, int sx,
		1910	int dy, int dx, int height, int width, u_int y_break)
		1911	{
		1912	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
		1913	struct fbcon_ops *ops = info->fbcon_par;
		1914	u_int b;
		1915
		1916	if (sy < y_break && sy + height > y_break) {
		1917	b = y_break - sy;
		1918	if (dy < sy) { /* Avoid trashing self */
		1919	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, b, width,
		1920	y_break);
		1921	fbcon_bmove_rec(vc, p, sy + b, sx, dy + b, dx,
		1922	height - b, width, y_break);
		1923	} else {
		1924	fbcon_bmove_rec(vc, p, sy + b, sx, dy + b, dx,
		1925	height - b, width, y_break);
		1926	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, b, width,
		1927	y_break);
		1928	}
		1929	return;
		1930	}
		1931
		1932	if (dy < y_break && dy + height > y_break) {
		1933	b = y_break - dy;
		1934	if (dy < sy) { /* Avoid trashing self */
		1935	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, b, width,
		1936	y_break);
		1937	fbcon_bmove_rec(vc, p, sy + b, sx, dy + b, dx,
		1938	height - b, width, y_break);
		1939	} else {
		1940	fbcon_bmove_rec(vc, p, sy + b, sx, dy + b, dx,
		1941	height - b, width, y_break);
		1942	fbcon_bmove_rec(vc, p, sy, sx, dy, dx, b, width,
		1943	y_break);
		1944	}
		1945	return;
		1946	}
		1947	ops->bmove(vc, info, real_y(p, sy), sx, real_y(p, dy), dx,
		1948	height, width);
		1949	}
		1950
		1951	static void updatescrollmode_accel(struct fbcon_display *p,
		1952	struct fb_info *info,
		1953	struct vc_data *vc)
		1954	{
		1955	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
		1956	struct fbcon_ops *ops = info->fbcon_par;
		1957	int cap = info->flags;
		1958	u16 t = 0;
		1959	int ypan = FBCON_SWAP(ops->rotate, info->fix.ypanstep,
		1960	info->fix.xpanstep);
		1961	int ywrap = FBCON_SWAP(ops->rotate, info->fix.ywrapstep, t);
		1962	int yres = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
		1963	int vyres = FBCON_SWAP(ops->rotate, info->var.yres_virtual,
		1964	info->var.xres_virtual);
		1965	int good_pan = (cap & FBINFO_HWACCEL_YPAN) &&
		1966	divides(ypan, vc->vc_font.height) && vyres > yres;
		1967	int good_wrap = (cap & FBINFO_HWACCEL_YWRAP) &&
		1968	divides(ywrap, vc->vc_font.height) &&
		1969	divides(vc->vc_font.height, vyres) &&
		1970	divides(vc->vc_font.height, yres);
		1971	int reading_fast = cap & FBINFO_READS_FAST;
		1972	int fast_copyarea = (cap & FBINFO_HWACCEL_COPYAREA) &&
		1973	!(cap & FBINFO_HWACCEL_DISABLED);
		1974	int fast_imageblit = (cap & FBINFO_HWACCEL_IMAGEBLIT) &&
		1975	!(cap & FBINFO_HWACCEL_DISABLED);
		1976
		1977	if (good_wrap \|\| good_pan) {
		1978	if (reading_fast \|\| fast_copyarea)
		1979	p->scrollmode = good_wrap ?
		1980	SCROLL_WRAP_MOVE : SCROLL_PAN_MOVE;
		1981	else
		1982	p->scrollmode = good_wrap ? SCROLL_REDRAW :
		1983	SCROLL_PAN_REDRAW;
		1984	} else {
		1985	if (reading_fast \|\| (fast_copyarea && !fast_imageblit))
		1986	p->scrollmode = SCROLL_MOVE;
		1987	else
		1988	p->scrollmode = SCROLL_REDRAW;
		1989	}
		1990	#endif
		1991	}
		1992
1495	static void updatescrollmode(struct fbcon_display *p,	1993	static void updatescrollmode(struct fbcon_display *p,
1496	struct fb_info *info,	1994	struct fb_info *info,
1497	struct vc_data *vc)	1995	struct vc_data *vc)
@@ -1507,6 +2005,9 @@ static void updatescrollmode(struct fbcon_display *p, · 9 unmodified lines
1507	p->vrows -= (yres - (fh * vc->vc_rows)) / fh;	2005	p->vrows -= (yres - (fh * vc->vc_rows)) / fh;
1508	if ((yres % fh) && (vyres % fh < yres % fh))	2006	if ((yres % fh) && (vyres % fh < yres % fh))
1509	p->vrows--;	2007	p->vrows--;
		2008
		2009	/* update scrollmode in case hardware acceleration is used */
		2010	updatescrollmode_accel(p, info, vc);
1510	}	2011	}
1511		2012
1512	#define PITCH(w) (((w) + 7) >> 3)	2013	#define PITCH(w) (((w) + 7) >> 3)
@@ -1664,7 +2165,21 @@ static int fbcon_switch(struct vc_data *vc) · 151 unmodified lines
1664		2165
1665	updatescrollmode(p, info, vc);	2166	updatescrollmode(p, info, vc);
1666		2167
1667	scrollback_phys_max = 0;	2168	switch (fb_scrollmode(p)) {
		2169	case SCROLL_WRAP_MOVE:
		2170	scrollback_phys_max = p->vrows - vc->vc_rows;
		2171	break;
		2172	case SCROLL_PAN_MOVE:
		2173	case SCROLL_PAN_REDRAW:
		2174	scrollback_phys_max = p->vrows - 2 * vc->vc_rows;
		2175	if (scrollback_phys_max < 0)
		2176	scrollback_phys_max = 0;
		2177	break;
		2178	default:
		2179	scrollback_phys_max = 0;
		2180	break;
		2181	}
		2182
1668	scrollback_max = 0;	2183	scrollback_max = 0;
1669	scrollback_current = 0;	2184	scrollback_current = 0;
1670		2185

drivers/video/fbdev/core/fbcon.h+72−0

@@ -29,6 +29,9 @@ struct fbcon_display { · 28 unmodified lines
29	/* Filled in by the low-level console driver */	29	/* Filled in by the low-level console driver */
30	const u_char *fontdata;	30	const u_char *fontdata;
31	int userfont; /* != 0 if fontdata kmalloc()ed */	31	int userfont; /* != 0 if fontdata kmalloc()ed */
		32	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
		33	u_short scrollmode; /* Scroll Method, use fb_scrollmode() */
		34	#endif
32	u_short inverse; /* != 0 text black on white as default */	35	u_short inverse; /* != 0 text black on white as default */
33	short yscroll; /* Hardware scrolling */	36	short yscroll; /* Hardware scrolling */
34	int vrows; /* number of virtual rows */	37	int vrows; /* number of virtual rows */
@@ -51,6 +54,8 @@ struct fbcon_display { · 16 unmodified lines
51	};	54	};
52		55
53	struct fbcon_ops {	56	struct fbcon_ops {
		57	void (bmove)(struct vc_data vc, struct fb_info *info, int sy,
		58	int sx, int dy, int dx, int height, int width);
54	void (clear)(struct vc_data vc, struct fb_info *info, int sy,	59	void (clear)(struct vc_data vc, struct fb_info *info, int sy,
55	int sx, int height, int width);	60	int sx, int height, int width);
56	void (putcs)(struct vc_data vc, struct fb_info *info,	61	void (putcs)(struct vc_data vc, struct fb_info *info,
@@ -149,6 +154,73 @@ static inline int attr_col_ec(int shift, struct vc_data *vc, · 92 unmodified lines
149	#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)	154	#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
150	#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)	155	#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
151		156
		157	/*
		158	* Scroll Method
		159	*/
		160
		161	/* There are several methods fbcon can use to move text around the screen:
		162	*
		163	* Operation Pan Wrap
		164	*---------------------------------------------
		165	* SCROLL_MOVE copyarea No No
		166	* SCROLL_PAN_MOVE copyarea Yes No
		167	* SCROLL_WRAP_MOVE copyarea No Yes
		168	* SCROLL_REDRAW imageblit No No
		169	* SCROLL_PAN_REDRAW imageblit Yes No
		170	* SCROLL_WRAP_REDRAW imageblit No Yes
		171	*
		172	* (SCROLL_WRAP_REDRAW is not implemented yet)
		173	*
		174	* In general, fbcon will choose the best scrolling
		175	* method based on the rule below:
		176	*
		177	* Pan/Wrap > accel imageblit > accel copyarea >
		178	* soft imageblit > (soft copyarea)
		179	*
		180	* Exception to the rule: Pan + accel copyarea is
		181	* preferred over Pan + accel imageblit.
		182	*
		183	* The above is typical for PCI/AGP cards. Unless
		184	* overridden, fbcon will never use soft copyarea.
		185	*
		186	* If you need to override the above rule, set the
		187	* appropriate flags in fb_info->flags. For example,
		188	* to prefer copyarea over imageblit, set
		189	* FBINFO_READS_FAST.
		190	*
		191	* Other notes:
		192	* + use the hardware engine to move the text
		193	* (hw-accelerated copyarea() and fillrect())
		194	* + use hardware-supported panning on a large virtual screen
		195	* + amifb can not only pan, but also wrap the display by N lines
		196	* (i.e. visible line i = physical line (i+N) % yres).
		197	* + read what's already rendered on the screen and
		198	* write it in a different place (this is cfb_copyarea())
		199	* + re-render the text to the screen
		200	*
		201	* Whether to use wrapping or panning can only be figured out at
		202	* runtime (when we know whether our font height is a multiple
		203	* of the pan/wrap step)
		204	*
		205	*/
		206
		207	#define SCROLL_MOVE 0x001
		208	#define SCROLL_PAN_MOVE 0x002
		209	#define SCROLL_WRAP_MOVE 0x003
		210	#define SCROLL_REDRAW 0x004
		211	#define SCROLL_PAN_REDRAW 0x005
		212
		213	static inline u_short fb_scrollmode(struct fbcon_display *fb)
		214	{
		215	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION
		216	return fb->scrollmode;
		217	#else
		218	/* hardcoded to SCROLL_REDRAW if acceleration was disabled. */
		219	return SCROLL_REDRAW;
		220	#endif
		221	}
		222
		223
152	#ifdef CONFIG_FB_TILEBLITTING	224	#ifdef CONFIG_FB_TILEBLITTING
153	extern void fbcon_set_tileops(struct vc_data vc, struct fb_info info);	225	extern void fbcon_set_tileops(struct vc_data vc, struct fb_info info);
154	#endif	226	#endif

drivers/video/fbdev/core/fbcon_ccw.c+24−4

 	}
 }
+static void ccw_bmove(struct vc_data *vc, struct fb_info *info, int sy,
+		     int sx, int dy, int dx, int height, int width)
+{
+	struct fbcon_ops *ops = info->fbcon_par;
+	struct fb_copyarea area;
+	u32 vyres = GETVYRES(ops->p, info);
+	area.sx = sy * vc->vc_font.height;
+	area.sy = vyres - ((sx + width) * vc->vc_font.width);
+	area.dx = dy * vc->vc_font.height;
+	area.dy = vyres - ((dx + width) * vc->vc_font.width);
+	area.width = height * vc->vc_font.height;
+	area.height  = width * vc->vc_font.width;
+	info->fbops->fb_copyarea(info, &area);
+}
 static void ccw_clear(struct vc_data *vc, struct fb_info *info, int sy,
 		     int sx, int height, int width)
 {
+	struct fbcon_ops *ops = info->fbcon_par;
 	struct fb_fillrect region;
 	int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
 	region.color = attr_bgcol_ec(bgshift,vc,info);
 	region.dx = sy * vc->vc_font.height;
 	u32 cnt, pitch, size;
 	u32 attribute = get_attribute(info, scr_readw(s));
 	u8 *dst, *buf = NULL;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;
 	int err = 1, dx, dy;
 	char *src;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 {
 	struct fbcon_ops *ops = info->fbcon_par;
 	u32 yoffset;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
 	int err;
 	yoffset = (vyres - info->var.yres) - ops->var.xoffset;
 void fbcon_rotate_ccw(struct fbcon_ops *ops)
 {
+	ops->bmove = ccw_bmove;
 	ops->clear = ccw_clear;
 	ops->putcs = ccw_putcs;
 	ops->clear_margins = ccw_clear_margins;

drivers/video/fbdev/core/fbcon_cw.c+24−4

 	}
 }
+static void cw_bmove(struct vc_data *vc, struct fb_info *info, int sy,
+		     int sx, int dy, int dx, int height, int width)
+{
+	struct fbcon_ops *ops = info->fbcon_par;
+	struct fb_copyarea area;
+	u32 vxres = GETVXRES(ops->p, info);
+	area.sx = vxres - ((sy + height) * vc->vc_font.height);
+	area.sy = sx * vc->vc_font.width;
+	area.dx = vxres - ((dy + height) * vc->vc_font.height);
+	area.dy = dx * vc->vc_font.width;
+	area.width = height * vc->vc_font.height;
+	area.height  = width * vc->vc_font.width;
+	info->fbops->fb_copyarea(info, &area);
+}
 static void cw_clear(struct vc_data *vc, struct fb_info *info, int sy,
 		     int sx, int height, int width)
 {
+	struct fbcon_ops *ops = info->fbcon_par;
 	struct fb_fillrect region;
 	int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	region.color = attr_bgcol_ec(bgshift,vc,info);
 	region.dx = vxres - ((sy + height) * vc->vc_font.height);
 	u32 cnt, pitch, size;
 	u32 attribute = get_attribute(info, scr_readw(s));
 	u8 *dst, *buf = NULL;
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;
 	int err = 1, dx, dy;
 	char *src;
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 static int cw_update_start(struct fb_info *info)
 {
 	struct fbcon_ops *ops = info->fbcon_par;
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	u32 xoffset;
 	int err;
 void fbcon_rotate_cw(struct fbcon_ops *ops)
 {
+	ops->bmove = cw_bmove;
 	ops->clear = cw_clear;
 	ops->putcs = cw_putcs;
 	ops->clear_margins = cw_clear_margins;

drivers/video/fbdev/core/fbcon_rotate.h+9−0

@@ -11,6 +11,15 @@ · 10 unmodified lines
11	#ifndef _FBCON_ROTATE_H	11	#ifndef _FBCON_ROTATE_H
12	#define _FBCON_ROTATE_H	12	#define _FBCON_ROTATE_H
13		13
		14	#define GETVYRES(s,i) ({ \
		15	(fb_scrollmode(s) == SCROLL_REDRAW \|\| fb_scrollmode(s) == SCROLL_MOVE) ? \
		16	(i)->var.yres : (i)->var.yres_virtual; })
		17
		18	#define GETVXRES(s,i) ({ \
		19	(fb_scrollmode(s) == SCROLL_REDRAW \|\| fb_scrollmode(s) == SCROLL_MOVE \|\| !(i)->fix.xpanstep) ? \
		20	(i)->var.xres : (i)->var.xres_virtual; })
		21
		22
14	static inline int pattern_test_bit(u32 x, u32 y, u32 pitch, const char *pat)	23	static inline int pattern_test_bit(u32 x, u32 y, u32 pitch, const char *pat)
15	{	24	{
16	u32 tmp = (y * pitch) + x, index = tmp / 8, bit = tmp % 8;	25	u32 tmp = (y * pitch) + x, index = tmp / 8, bit = tmp % 8;

drivers/video/fbdev/core/fbcon_ud.c+29−8

 	}
 }
+static void ud_bmove(struct vc_data *vc, struct fb_info *info, int sy,
+		     int sx, int dy, int dx, int height, int width)
+{
+	struct fbcon_ops *ops = info->fbcon_par;
+	struct fb_copyarea area;
+	u32 vyres = GETVYRES(ops->p, info);
+	u32 vxres = GETVXRES(ops->p, info);
+	area.sy = vyres - ((sy + height) * vc->vc_font.height);
+	area.sx = vxres - ((sx + width) * vc->vc_font.width);
+	area.dy = vyres - ((dy + height) * vc->vc_font.height);
+	area.dx = vxres - ((dx + width) * vc->vc_font.width);
+	area.height = height * vc->vc_font.height;
+	area.width  = width * vc->vc_font.width;
+	info->fbops->fb_copyarea(info, &area);
+}
 static void ud_clear(struct vc_data *vc, struct fb_info *info, int sy,
 		     int sx, int height, int width)
 {
+	struct fbcon_ops *ops = info->fbcon_par;
 	struct fb_fillrect region;
 	int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	region.color = attr_bgcol_ec(bgshift,vc,info);
 	region.dy = vyres - ((sy + height) * vc->vc_font.height);
 	u32 mod = vc->vc_font.width % 8, cnt, pitch, size;
 	u32 attribute = get_attribute(info, scr_readw(s));
 	u8 *dst, *buf = NULL;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;
 	int err = 1, dx, dy;
 	char *src;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	if (!ops->fontbuffer)
 		return;
 {
 	struct fbcon_ops *ops = info->fbcon_par;
 	int xoffset, yoffset;
-	u32 vyres = info->var.yres;
+	u32 vyres = GETVYRES(ops->p, info);
-	u32 vxres = info->var.xres;
+	u32 vxres = GETVXRES(ops->p, info);
 	int err;
 	xoffset = vxres - info->var.xres - ops->var.xoffset;
 void fbcon_rotate_ud(struct fbcon_ops *ops)
 {
+	ops->bmove = ud_bmove;
 	ops->clear = ud_clear;
 	ops->putcs = ud_putcs;
 	ops->clear_margins = ud_clear_margins;

drivers/video/fbdev/core/tileblit.c+16−0

@@ -16,6 +16,21 @@ · 15 unmodified lines
16	#include <asm/types.h>	16	#include <asm/types.h>
17	#include "fbcon.h"	17	#include "fbcon.h"
18		18
		19	static void tile_bmove(struct vc_data vc, struct fb_info info, int sy,
		20	int sx, int dy, int dx, int height, int width)
		21	{
		22	struct fb_tilearea area;
		23
		24	area.sx = sx;
		25	area.sy = sy;
		26	area.dx = dx;
		27	area.dy = dy;
		28	area.height = height;
		29	area.width = width;
		30
		31	info->tileops->fb_tilecopy(info, &area);
		32	}
		33
19	static void tile_clear(struct vc_data vc, struct fb_info info, int sy,	34	static void tile_clear(struct vc_data vc, struct fb_info info, int sy,
20	int sx, int height, int width)	35	int sx, int height, int width)
21	{	36	{
@@ -118,6 +133,7 @@ void fbcon_set_tileops(struct vc_data vc, struct fb_info info) · 96 unmodified lines
118	struct fb_tilemap map;	133	struct fb_tilemap map;
119	struct fbcon_ops *ops = info->fbcon_par;	134	struct fbcon_ops *ops = info->fbcon_par;
120		135
		136	ops->bmove = tile_bmove;
121	ops->clear = tile_clear;	137	ops->clear = tile_clear;
122	ops->putcs = tile_putcs;	138	ops->putcs = tile_putcs;
123	ops->clear_margins = tile_clear_margins;	139	ops->clear_margins = tile_clear_margins;

drivers/video/fbdev/skeletonfb.c+6−6

 }
 /**
- *      xxxfb_copyarea - OBSOLETE function.
+ *      xxxfb_copyarea - REQUIRED function. Can use generic routines if
+ *                       non acclerated hardware and packed pixel based.
  *                       Copies one area of the screen to another area.
- *                       Will be deleted in a future version
  *
  *      @info: frame buffer structure that represents a single frame buffer
  *      @area: Structure providing the data to copy the framebuffer contents
  *	       from one region to another.
  *
- *      This drawing operation copied a rectangular area from one area of the
+ *      This drawing operation copies a rectangular area from one area of the
  *	screen to another area.
  */
 void xxxfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
 	.fb_setcolreg	= xxxfb_setcolreg,
 	.fb_blank	= xxxfb_blank,
 	.fb_pan_display	= xxxfb_pan_display,
-	.fb_fillrect	= xxxfb_fillrect,	/* Needed !!!   */
+	.fb_fillrect	= xxxfb_fillrect, 	/* Needed !!! */
-	.fb_copyarea	= xxxfb_copyarea,	/* Obsolete     */
+	.fb_copyarea	= xxxfb_copyarea,	/* Needed !!! */
-	.fb_imageblit	= xxxfb_imageblit,	/* Needed !!!   */
+	.fb_imageblit	= xxxfb_imageblit,	/* Needed !!! */
 	.fb_cursor	= xxxfb_cursor,		/* Optional !!! */
 	.fb_sync	= xxxfb_sync,
 	.fb_ioctl	= xxxfb_ioctl,

fs/9p/fid.c+4−5

 		 dentry, dentry, from_kuid(&init_user_ns, uid),
 		 any);
 	ret = NULL;
-	if (d_inode(dentry))
-		ret = v9fs_fid_find_inode(d_inode(dentry), uid);
 	/* we'll recheck under lock if there's anything to look in */
-	if (!ret && dentry->d_fsdata) {
+	if (dentry->d_fsdata) {
 		struct hlist_head *h = (struct hlist_head *)&dentry->d_fsdata;
 		spin_lock(&dentry->d_lock);
 			}
 		}
 		spin_unlock(&dentry->d_lock);
+	} else {
+		if (dentry->d_inode)
+			ret = v9fs_fid_find_inode(dentry->d_inode, uid);
 	}
 	return ret;

fs/Kconfig+2−2

@@ -369,8 +369,8 @@ source "fs/ksmbd/Kconfig" · 368 unmodified lines
369		369
370	config SMBFS_COMMON	370	config SMBFS_COMMON
371	tristate	371	tristate
372	default y if CIFS=y	372	default y if CIFS=y \|\| SMB_SERVER=y
373	default m if CIFS=m	373	default m if CIFS=m \|\| SMB_SERVER=m
374		374
375	source "fs/coda/Kconfig"	375	source "fs/coda/Kconfig"
376	source "fs/afs/Kconfig"	376	source "fs/afs/Kconfig"

fs/binfmt_misc.c+1−5

 };
 MODULE_ALIAS_FS("binfmt_misc");
-static struct ctl_table_header *binfmt_misc_header;
 static int __init init_misc_binfmt(void)
 {
 	int err = register_filesystem(&bm_fs_type);
 	if (!err)
 		insert_binfmt(&misc_format);
-	binfmt_misc_header = register_sysctl_mount_point("fs/binfmt_misc");
+	return err;
-	return 0;
 }
 static void __exit exit_misc_binfmt(void)
 {
-	unregister_sysctl_table(binfmt_misc_header);
 	unregister_binfmt(&misc_format);
 	unregister_filesystem(&bm_fs_type);
 }

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

@@ -124,7 +124,16 @@ void btrfs_put_block_group(struct btrfs_block_group *cache) · 123 unmodified lines
124	{	124	{
125	if (refcount_dec_and_test(&cache->refs)) {	125	if (refcount_dec_and_test(&cache->refs)) {
126	WARN_ON(cache->pinned > 0);	126	WARN_ON(cache->pinned > 0);
127	WARN_ON(cache->reserved > 0);	127	/*
		128	* If there was a failure to cleanup a log tree, very likely due
		129	* to an IO failure on a writeback attempt of one or more of its
		130	* extent buffers, we could not do proper (and cheap) unaccounting
		131	* of their reserved space, so don't warn on reserved > 0 in that
		132	* case.
		133	*/
		134	if (!(cache->flags & BTRFS_BLOCK_GROUP_METADATA) \|\|
		135	!BTRFS_FS_LOG_CLEANUP_ERROR(cache->fs_info))
		136	WARN_ON(cache->reserved > 0);
128		137
129	/*	138	/*
130	* A block_group shouldn't be on the discard_list anymore.	139	* A block_group shouldn't be on the discard_list anymore.
@@ -2544,6 +2553,19 @@ int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, · 2413 unmodified lines
2544	int ret;	2553	int ret;
2545	bool dirty_bg_running;	2554	bool dirty_bg_running;
2546		2555
		2556	/*
		2557	* This can only happen when we are doing read-only scrub on read-only
		2558	* mount.
		2559	* In that case we should not start a new transaction on read-only fs.
		2560	* Thus here we skip all chunk allocations.
		2561	*/
		2562	if (sb_rdonly(fs_info->sb)) {
		2563	mutex_lock(&fs_info->ro_block_group_mutex);
		2564	ret = inc_block_group_ro(cache, 0);
		2565	mutex_unlock(&fs_info->ro_block_group_mutex);
		2566	return ret;
		2567	}
		2568
2547	do {	2569	do {
2548	trans = btrfs_join_transaction(root);	2570	trans = btrfs_join_transaction(root);
2549	if (IS_ERR(trans))	2571	if (IS_ERR(trans))
@@ -3974,9 +3996,22 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) · 1424 unmodified lines
3974	* important and indicates a real bug if this happens.	3996	* important and indicates a real bug if this happens.
3975	*/	3997	*/
3976	if (WARN_ON(space_info->bytes_pinned > 0 \|\|	3998	if (WARN_ON(space_info->bytes_pinned > 0 \|\|
3977	space_info->bytes_reserved > 0 \|\|
3978	space_info->bytes_may_use > 0))	3999	space_info->bytes_may_use > 0))
3979	btrfs_dump_space_info(info, space_info, 0, 0);	4000	btrfs_dump_space_info(info, space_info, 0, 0);
		4001
		4002	/*
		4003	* If there was a failure to cleanup a log tree, very likely due
		4004	* to an IO failure on a writeback attempt of one or more of its
		4005	* extent buffers, we could not do proper (and cheap) unaccounting
		4006	* of their reserved space, so don't warn on bytes_reserved > 0 in
		4007	* that case.
		4008	*/
		4009	if (!(space_info->flags & BTRFS_BLOCK_GROUP_METADATA) \|\|
		4010	!BTRFS_FS_LOG_CLEANUP_ERROR(info)) {
		4011	if (WARN_ON(space_info->bytes_reserved > 0))
		4012	btrfs_dump_space_info(info, space_info, 0, 0);
		4013	}
		4014
3980	WARN_ON(space_info->reclaim_size > 0);	4015	WARN_ON(space_info->reclaim_size > 0);
3981	list_del(&space_info->list);	4016	list_del(&space_info->list);
3982	btrfs_sysfs_remove_space_info(space_info);	4017	btrfs_sysfs_remove_space_info(space_info);

fs/btrfs/ctree.h+6−0

 	BTRFS_FS_STATE_DUMMY_FS_INFO,
 	BTRFS_FS_STATE_NO_CSUMS,
+	/* Indicates there was an error cleaning up a log tree. */
+	BTRFS_FS_STATE_LOG_CLEANUP_ERROR,
 };
 #define BTRFS_BACKREF_REV_MAX		256
 #define BTRFS_FS_ERROR(fs_info)	(unlikely(test_bit(BTRFS_FS_STATE_ERROR, \
 						   &(fs_info)->fs_state)))
+#define BTRFS_FS_LOG_CLEANUP_ERROR(fs_info)				\
+	(unlikely(test_bit(BTRFS_FS_STATE_LOG_CLEANUP_ERROR,		\
+			   &(fs_info)->fs_state)))
 __printf(5, 6)
 __cold

fs/btrfs/ioctl.c+2−5

 		goto fail;
 	}
-	spin_lock(&fs_info->trans_lock);
+	trans->pending_snapshot = pending_snapshot;
-	list_add(&pending_snapshot->list,
-		 &trans->transaction->pending_snapshots);
-	spin_unlock(&fs_info->trans_lock);
 	ret = btrfs_commit_transaction(trans);
 	if (ret)
 	struct block_device *bdev = NULL;
 	fmode_t mode;
 	int ret;
-	bool cancel;
+	bool cancel = false;
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;

fs/btrfs/qgroup.c+19−2

 	struct btrfs_trans_handle *trans = NULL;
 	int ret = 0;
+	/*
+	 * We need to have subvol_sem write locked, to prevent races between
+	 * concurrent tasks trying to disable quotas, because we will unlock
+	 * and relock qgroup_ioctl_lock across BTRFS_FS_QUOTA_ENABLED changes.
+	 */
+	lockdep_assert_held_write(&fs_info->subvol_sem);
 	mutex_lock(&fs_info->qgroup_ioctl_lock);
 	if (!fs_info->quota_root)
 		goto out;
+	/*
+	 * Request qgroup rescan worker to complete and wait for it. This wait
+	 * must be done before transaction start for quota disable since it may
+	 * deadlock with transaction by the qgroup rescan worker.
+	 */
+	clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
+	btrfs_qgroup_wait_for_completion(fs_info, false);
 	mutex_unlock(&fs_info->qgroup_ioctl_lock);
 	/*
 	if (IS_ERR(trans)) {
 		ret = PTR_ERR(trans);
 		trans = NULL;
+		set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
 		goto out;
 	}
 	if (!fs_info->quota_root)
 		goto out;
-	clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
-	btrfs_qgroup_wait_for_completion(fs_info, false);
 	spin_lock(&fs_info->qgroup_lock);
 	quota_root = fs_info->quota_root;
 	fs_info->quota_root = NULL;
 			btrfs_warn(fs_info,
 			"qgroup rescan init failed, qgroup is not enabled");
 			ret = -EINVAL;
+		} else if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) {
+			/* Quota disable is in progress */
+			ret = -EBUSY;
 		}
 		if (ret) {

fs/btrfs/transaction.c+24−0

@@ -2000,6 +2000,27 @@ static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) · 1999 unmodified lines
2000	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);	2000	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
2001	}	2001	}
2002		2002
		2003	/*
		2004	* Add a pending snapshot associated with the given transaction handle to the
		2005	* respective handle. This must be called after the transaction commit started
		2006	* and while holding fs_info->trans_lock.
		2007	* This serves to guarantee a caller of btrfs_commit_transaction() that it can
		2008	* safely free the pending snapshot pointer in case btrfs_commit_transaction()
		2009	* returns an error.
		2010	*/
		2011	static void add_pending_snapshot(struct btrfs_trans_handle *trans)
		2012	{
		2013	struct btrfs_transaction *cur_trans = trans->transaction;
		2014
		2015	if (!trans->pending_snapshot)
		2016	return;
		2017
		2018	lockdep_assert_held(&trans->fs_info->trans_lock);
		2019	ASSERT(cur_trans->state >= TRANS_STATE_COMMIT_START);
		2020
		2021	list_add(&trans->pending_snapshot->list, &cur_trans->pending_snapshots);
		2022	}
		2023
2003	int btrfs_commit_transaction(struct btrfs_trans_handle *trans)	2024	int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
2004	{	2025	{
2005	struct btrfs_fs_info *fs_info = trans->fs_info;	2026	struct btrfs_fs_info *fs_info = trans->fs_info;
@@ -2073,6 +2094,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) · 67 unmodified lines
2073	if (cur_trans->state >= TRANS_STATE_COMMIT_START) {	2094	if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
2074	enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED;	2095	enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED;
2075		2096
		2097	add_pending_snapshot(trans);
		2098
2076	spin_unlock(&fs_info->trans_lock);	2099	spin_unlock(&fs_info->trans_lock);
2077	refcount_inc(&cur_trans->use_count);	2100	refcount_inc(&cur_trans->use_count);
2078		2101
@@ -2163,6 +2186,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) · 84 unmodified lines
2163	* COMMIT_DOING so make sure to wait for num_writers to == 1 again.	2186	* COMMIT_DOING so make sure to wait for num_writers to == 1 again.
2164	*/	2187	*/
2165	spin_lock(&fs_info->trans_lock);	2188	spin_lock(&fs_info->trans_lock);
		2189	add_pending_snapshot(trans);
2166	cur_trans->state = TRANS_STATE_COMMIT_DOING;	2190	cur_trans->state = TRANS_STATE_COMMIT_DOING;
2167	spin_unlock(&fs_info->trans_lock);	2191	spin_unlock(&fs_info->trans_lock);
2168	wait_event(cur_trans->writer_wait,	2192	wait_event(cur_trans->writer_wait,

fs/btrfs/transaction.h+2−0

 	struct btrfs_transaction *transaction;
 	struct btrfs_block_rsv *block_rsv;
 	struct btrfs_block_rsv *orig_rsv;
+	/* Set by a task that wants to create a snapshot. */
+	struct btrfs_pending_snapshot *pending_snapshot;
 	refcount_t use_count;
 	unsigned int type;
 	/*

fs/btrfs/tree-checker.c+15−0

 			  struct btrfs_key *key, int slot)
 {
 	struct btrfs_dev_item *ditem;
+	const u32 item_size = btrfs_item_size(leaf, slot);
 	if (unlikely(key->objectid != BTRFS_DEV_ITEMS_OBJECTID)) {
 		dev_item_err(leaf, slot,
 			     key->objectid, BTRFS_DEV_ITEMS_OBJECTID);
 		return -EUCLEAN;
 	}
+	if (unlikely(item_size != sizeof(*ditem))) {
+		dev_item_err(leaf, slot, "invalid item size: has %u expect %zu",
+			     item_size, sizeof(*ditem));
+		return -EUCLEAN;
+	}
 	ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item);
 	if (unlikely(btrfs_device_id(leaf, ditem) != key->offset)) {
 		dev_item_err(leaf, slot,
 	struct btrfs_inode_item *iitem;
 	u64 super_gen = btrfs_super_generation(fs_info->super_copy);
 	u32 valid_mask = (S_IFMT | S_ISUID | S_ISGID | S_ISVTX | 0777);
+	const u32 item_size = btrfs_item_size(leaf, slot);
 	u32 mode;
 	int ret;
 	u32 flags;
 	if (unlikely(ret < 0))
 		return ret;
+	if (unlikely(item_size != sizeof(*iitem))) {
+		generic_err(leaf, slot, "invalid item size: has %u expect %zu",
+			    item_size, sizeof(*iitem));
+		return -EUCLEAN;
+	}
 	iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item);
 	/* Here we use super block generation + 1 to handle log tree */

fs/btrfs/tree-log.c+23−0

@@ -3414,6 +3414,29 @@ static void free_log_tree(struct btrfs_trans_handle *trans, · 3413 unmodified lines
3414	if (log->node) {	3414	if (log->node) {
3415	ret = walk_log_tree(trans, log, &wc);	3415	ret = walk_log_tree(trans, log, &wc);
3416	if (ret) {	3416	if (ret) {
		3417	/*
		3418	* We weren't able to traverse the entire log tree, the
		3419	* typical scenario is getting an -EIO when reading an
		3420	* extent buffer of the tree, due to a previous writeback
		3421	* failure of it.
		3422	*/
		3423	set_bit(BTRFS_FS_STATE_LOG_CLEANUP_ERROR,
		3424	&log->fs_info->fs_state);
		3425
		3426	/*
		3427	* Some extent buffers of the log tree may still be dirty
		3428	* and not yet written back to storage, because we may
		3429	* have updates to a log tree without syncing a log tree,
		3430	* such as during rename and link operations. So flush
		3431	* them out and wait for their writeback to complete, so
		3432	* that we properly cleanup their state and pages.
		3433	*/
		3434	btrfs_write_marked_extents(log->fs_info,
		3435	&log->dirty_log_pages,
		3436	EXTENT_DIRTY \| EXTENT_NEW);
		3437	btrfs_wait_tree_log_extents(log,
		3438	EXTENT_DIRTY \| EXTENT_NEW);
		3439
3417	if (trans)	3440	if (trans)
3418	btrfs_abort_transaction(trans, ret);	3441	btrfs_abort_transaction(trans, ret);
3419	else	3442	else

fs/cachefiles/io.c+59−0

@@ -191,6 +191,64 @@ presubmission_error: · 190 unmodified lines
191	return ret;	191	return ret;
192	}	192	}
193		193
		194	/*
		195	* Query the occupancy of the cache in a region, returning where the next chunk
		196	* of data starts and how long it is.
		197	*/
		198	static int cachefiles_query_occupancy(struct netfs_cache_resources *cres,
		199	loff_t start, size_t len, size_t granularity,
		200	loff_t _data_start, size_t _data_len)
		201	{
		202	struct cachefiles_object *object;
		203	struct file *file;
		204	loff_t off, off2;
		205
		206	*_data_start = -1;
		207	*_data_len = 0;
		208
		209	if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ))
		210	return -ENOBUFS;
		211
		212	object = cachefiles_cres_object(cres);
		213	file = cachefiles_cres_file(cres);
		214	granularity = max_t(size_t, object->volume->cache->bsize, granularity);
		215
		216	_enter("%pD,%li,%llx,%zx/%llx",
		217	file, file_inode(file)->i_ino, start, len,
		218	i_size_read(file_inode(file)));
		219
		220	off = cachefiles_inject_read_error();
		221	if (off == 0)
		222	off = vfs_llseek(file, start, SEEK_DATA);
		223	if (off == -ENXIO)
		224	return -ENODATA; /* Beyond EOF */
		225	if (off < 0 && off >= (loff_t)-MAX_ERRNO)
		226	return -ENOBUFS; /* Error. */
		227	if (round_up(off, granularity) >= start + len)
		228	return -ENODATA; /* No data in range */
		229
		230	off2 = cachefiles_inject_read_error();
		231	if (off2 == 0)
		232	off2 = vfs_llseek(file, off, SEEK_HOLE);
		233	if (off2 == -ENXIO)
		234	return -ENODATA; /* Beyond EOF */
		235	if (off2 < 0 && off2 >= (loff_t)-MAX_ERRNO)
		236	return -ENOBUFS; /* Error. */
		237
		238	/* Round away partial blocks */
		239	off = round_up(off, granularity);
		240	off2 = round_down(off2, granularity);
		241	if (off2 <= off)
		242	return -ENODATA;
		243
		244	*_data_start = off;
		245	if (off2 > start + len)
		246	*_data_len = len;
		247	else
		248	*_data_len = off2 - off;
		249	return 0;
		250	}
		251
194	/*	252	/*
195	* Handle completion of a write to the cache.	253	* Handle completion of a write to the cache.
196	*/	254	*/
@@ -545,6 +603,7 @@ static const struct netfs_cache_ops cachefiles_netfs_cache_ops = { · 348 unmodified lines
545	.write = cachefiles_write,	603	.write = cachefiles_write,
546	.prepare_read = cachefiles_prepare_read,	604	.prepare_read = cachefiles_prepare_read,
547	.prepare_write = cachefiles_prepare_write,	605	.prepare_write = cachefiles_prepare_write,
		606	.query_occupancy = cachefiles_query_occupancy,
548	};	607	};
549		608
550	/*	609	/*

fs/cifs/connect.c+16−7

 	mutex_unlock(&server->srv_mutex);
 }
-/**
+/*
  * Mark all sessions and tcons for reconnect.
  *
  * @server needs to be previously set to CifsNeedReconnect.
 		int i;
 		for (i = 1; i < chan_count; i++) {
-			/*
+			spin_unlock(&ses->chan_lock);
-			 * note: for now, we're okay accessing ses->chans
-			 * without chan_lock. But when chans can go away, we'll
-			 * need to introduce ref counting to make sure that chan
-			 * is not freed from under us.
-			 */
 			cifs_put_tcp_session(ses->chans[i].server, 0);
+			spin_lock(&ses->chan_lock);
 			ses->chans[i].server = NULL;
 		}
 	}
 		}
 	}
+	ctx->workstation_name = kstrdup(ses->workstation_name, GFP_KERNEL);
+	if (!ctx->workstation_name) {
+		cifs_dbg(FYI, "Unable to allocate memory for workstation_name\n");
+		rc = -ENOMEM;
+		kfree(ctx->username);
+		ctx->username = NULL;
+		kfree_sensitive(ctx->password);
+		ctx->password = NULL;
+		kfree(ctx->domainname);
+		ctx->domainname = NULL;
+		goto out_key_put;
+	}
 out_key_put:
 	up_read(&key->sem);
 	key_put(key);

fs/cifs/file.c+82−139

@@ -4269,8 +4269,6 @@ cifs_readv_complete(struct work_struct *work) · 4268 unmodified lines
4269	for (i = 0; i < rdata->nr_pages; i++) {	4269	for (i = 0; i < rdata->nr_pages; i++) {
4270	struct page *page = rdata->pages[i];	4270	struct page *page = rdata->pages[i];
4271		4271
4272	lru_cache_add(page);
4273
4274	if (rdata->result == 0 \|\|	4272	if (rdata->result == 0 \|\|
4275	(rdata->result == -EAGAIN && got_bytes)) {	4273	(rdata->result == -EAGAIN && got_bytes)) {
4276	flush_dcache_page(page);	4274	flush_dcache_page(page);
@@ -4278,12 +4276,12 @@ cifs_readv_complete(struct work_struct *work) · 1 unmodified line
4278	} else	4276	} else
4279	SetPageError(page);	4277	SetPageError(page);
4280		4278
4281	unlock_page(page);
4282
4283	if (rdata->result == 0 \|\|	4279	if (rdata->result == 0 \|\|
4284	(rdata->result == -EAGAIN && got_bytes))	4280	(rdata->result == -EAGAIN && got_bytes))
4285	cifs_readpage_to_fscache(rdata->mapping->host, page);	4281	cifs_readpage_to_fscache(rdata->mapping->host, page);
4286		4282
		4283	unlock_page(page);
		4284
4287	got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);	4285	got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4288		4286
4289	put_page(page);	4287	put_page(page);
@@ -4340,7 +4338,6 @@ readpages_fill_pages(struct TCP_Server_Info *server, · 50 unmodified lines
4340	* fill them until the writes are flushed.	4338	* fill them until the writes are flushed.
4341	*/	4339	*/
4342	zero_user(page, 0, PAGE_SIZE);	4340	zero_user(page, 0, PAGE_SIZE);
4343	lru_cache_add(page);
4344	flush_dcache_page(page);	4341	flush_dcache_page(page);
4345	SetPageUptodate(page);	4342	SetPageUptodate(page);
4346	unlock_page(page);	4343	unlock_page(page);
@@ -4350,7 +4347,6 @@ readpages_fill_pages(struct TCP_Server_Info *server, · 3 unmodified lines
4350	continue;	4347	continue;
4351	} else {	4348	} else {
4352	/* no need to hold page hostage */	4349	/* no need to hold page hostage */
4353	lru_cache_add(page);
4354	unlock_page(page);	4350	unlock_page(page);
4355	put_page(page);	4351	put_page(page);
4356	rdata->pages[i] = NULL;	4352	rdata->pages[i] = NULL;
@@ -4393,92 +4389,20 @@ cifs_readpages_copy_into_pages(struct TCP_Server_Info *server, · 36 unmodified lines
4393	return readpages_fill_pages(server, rdata, iter, iter->count);	4389	return readpages_fill_pages(server, rdata, iter, iter->count);
4394	}	4390	}
4395		4391
4396	static int	4392	static void cifs_readahead(struct readahead_control *ractl)
4397	readpages_get_pages(struct address_space mapping, struct list_head page_list,
4398	unsigned int rsize, struct list_head *tmplist,
4399	unsigned int nr_pages, loff_t offset, unsigned int *bytes)
4400	{
4401	struct page page, tpage;
4402	unsigned int expected_index;
4403	int rc;
4404	gfp_t gfp = readahead_gfp_mask(mapping);
4405
4406	INIT_LIST_HEAD(tmplist);
4407
4408	page = lru_to_page(page_list);
4409
4410	/*
4411	* Lock the page and put it in the cache. Since no one else
4412	* should have access to this page, we're safe to simply set
4413	* PG_locked without checking it first.
4414	*/
4415	__SetPageLocked(page);
4416	rc = add_to_page_cache_locked(page, mapping,
4417	page->index, gfp);
4418
4419	/* give up if we can't stick it in the cache */
4420	if (rc) {
4421	__ClearPageLocked(page);
4422	return rc;
4423	}
4424
4425	/* move first page to the tmplist */
4426	*offset = (loff_t)page->index << PAGE_SHIFT;
4427	*bytes = PAGE_SIZE;
4428	*nr_pages = 1;
4429	list_move_tail(&page->lru, tmplist);
4430
4431	/* now try and add more pages onto the request */
4432	expected_index = page->index + 1;
4433	list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4434	/* discontinuity ? */
4435	if (page->index != expected_index)
4436	break;
4437
4438	/* would this page push the read over the rsize? */
4439	if (*bytes + PAGE_SIZE > rsize)
4440	break;
4441
4442	__SetPageLocked(page);
4443	rc = add_to_page_cache_locked(page, mapping, page->index, gfp);
4444	if (rc) {
4445	__ClearPageLocked(page);
4446	break;
4447	}
4448	list_move_tail(&page->lru, tmplist);
4449	(*bytes) += PAGE_SIZE;
4450	expected_index++;
4451	(*nr_pages)++;
4452	}
4453	return rc;
4454	}
4455
4456	static int cifs_readpages(struct file file, struct address_space mapping,
4457	struct list_head *page_list, unsigned num_pages)
4458	{	4393	{
4459	int rc;	4394	int rc;
4460	int err = 0;	4395	struct cifsFileInfo *open_file = ractl->file->private_data;
4461	struct list_head tmplist;	4396	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(ractl->file);
4462	struct cifsFileInfo *open_file = file->private_data;
4463	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4464	struct TCP_Server_Info *server;	4397	struct TCP_Server_Info *server;
4465	pid_t pid;	4398	pid_t pid;
4466	unsigned int xid;	4399	unsigned int xid, nr_pages, last_batch_size = 0, cache_nr_pages = 0;
		4400	pgoff_t next_cached = ULONG_MAX;
		4401	bool caching = fscache_cookie_enabled(cifs_inode_cookie(ractl->mapping->host)) &&
		4402	cifs_inode_cookie(ractl->mapping->host)->cache_priv;
		4403	bool check_cache = caching;
4467		4404
4468	xid = get_xid();	4405	xid = get_xid();
4469	/*
4470	* Reads as many pages as possible from fscache. Returns -ENOBUFS
4471	* immediately if the cookie is negative
4472	*
4473	* After this point, every page in the list might have PG_fscache set,
4474	* so we will need to clean that up off of every page we don't use.
4475	*/
4476	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4477	&num_pages);
4478	if (rc == 0) {
4479	free_xid(xid);
4480	return rc;
4481	}
4482		4406
4483	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)	4407	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4484	pid = open_file->pid;	4408	pid = open_file->pid;
@@ -4489,39 +4413,73 @@ static int cifs_readpages(struct file file, struct address_space mapping, · 4 unmodified lines
4489	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);	4413	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4490		4414
4491	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",	4415	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4492	__func__, file, mapping, num_pages);	4416	__func__, ractl->file, ractl->mapping, readahead_count(ractl));
4493		4417
4494	/*	4418	/*
4495	* Start with the page at end of list and move it to private	4419	* Chop the readahead request up into rsize-sized read requests.
4496	* list. Do the same with any following pages until we hit
4497	* the rsize limit, hit an index discontinuity, or run out of
4498	* pages. Issue the async read and then start the loop again
4499	* until the list is empty.
4500	*
4501	* Note that list order is important. The page_list is in
4502	* the order of declining indexes. When we put the pages in
4503	* the rdata->pages, then we want them in increasing order.
4504	*/	4420	*/
4505	while (!list_empty(page_list) && !err) {	4421	while ((nr_pages = readahead_count(ractl) - last_batch_size)) {
4506	unsigned int i, nr_pages, bytes, rsize;	4422	unsigned int i, got, rsize;
4507	loff_t offset;	4423	struct page *page;
4508	struct page page, tpage;
4509	struct cifs_readdata *rdata;	4424	struct cifs_readdata *rdata;
4510	struct cifs_credits credits_on_stack;	4425	struct cifs_credits credits_on_stack;
4511	struct cifs_credits *credits = &credits_on_stack;	4426	struct cifs_credits *credits = &credits_on_stack;
		4427	pgoff_t index = readahead_index(ractl) + last_batch_size;
		4428
		4429	/*
		4430	* Find out if we have anything cached in the range of
		4431	* interest, and if so, where the next chunk of cached data is.
		4432	*/
		4433	if (caching) {
		4434	if (check_cache) {
		4435	rc = cifs_fscache_query_occupancy(
		4436	ractl->mapping->host, index, nr_pages,
		4437	&next_cached, &cache_nr_pages);
		4438	if (rc < 0)
		4439	caching = false;
		4440	check_cache = false;
		4441	}
		4442
		4443	if (index == next_cached) {
		4444	/*
		4445	* TODO: Send a whole batch of pages to be read
		4446	* by the cache.
		4447	*/
		4448	page = readahead_page(ractl);
		4449	last_batch_size = 1 << thp_order(page);
		4450	if (cifs_readpage_from_fscache(ractl->mapping->host,
		4451	page) < 0) {
		4452	/*
		4453	* TODO: Deal with cache read failure
		4454	* here, but for the moment, delegate
		4455	* that to readpage.
		4456	*/
		4457	caching = false;
		4458	}
		4459	unlock_page(page);
		4460	next_cached++;
		4461	cache_nr_pages--;
		4462	if (cache_nr_pages == 0)
		4463	check_cache = true;
		4464	continue;
		4465	}
		4466	}
4512		4467
4513	if (open_file->invalidHandle) {	4468	if (open_file->invalidHandle) {
4514	rc = cifs_reopen_file(open_file, true);	4469	rc = cifs_reopen_file(open_file, true);
4515	if (rc == -EAGAIN)	4470	if (rc) {
4516	continue;	4471	if (rc == -EAGAIN)
4517	else if (rc)	4472	continue;
4518	break;	4473	break;
		4474	}
4519	}	4475	}
4520		4476
4521	rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,	4477	rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4522	&rsize, credits);	4478	&rsize, credits);
4523	if (rc)	4479	if (rc)
4524	break;	4480	break;
		4481	nr_pages = min_t(size_t, rsize / PAGE_SIZE, readahead_count(ractl));
		4482	nr_pages = min_t(size_t, nr_pages, next_cached - index);
4525		4483
4526	/*	4484	/*
4527	* Give up immediately if rsize is too small to read an entire	4485	* Give up immediately if rsize is too small to read an entire
@@ -4529,16 +4487,7 @@ static int cifs_readpages(struct file file, struct address_space mapping, · 1 unmodified line
4529	* reach this point however since we set ra_pages to 0 when the	4487	* reach this point however since we set ra_pages to 0 when the
4530	* rsize is smaller than a cache page.	4488	* rsize is smaller than a cache page.
4531	*/	4489	*/
4532	if (unlikely(rsize < PAGE_SIZE)) {	4490	if (unlikely(!nr_pages)) {
4533	add_credits_and_wake_if(server, credits, 0);
4534	free_xid(xid);
4535	return 0;
4536	}
4537
4538	nr_pages = 0;
4539	err = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4540	&nr_pages, &offset, &bytes);
4541	if (!nr_pages) {
4542	add_credits_and_wake_if(server, credits, 0);	4491	add_credits_and_wake_if(server, credits, 0);
4543	break;	4492	break;
4544	}	4493	}
@@ -4546,36 +4495,31 @@ static int cifs_readpages(struct file file, struct address_space mapping, · 1 unmodified line
4546	rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);	4495	rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4547	if (!rdata) {	4496	if (!rdata) {
4548	/* best to give up if we're out of mem */	4497	/* best to give up if we're out of mem */
4549	list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4550	list_del(&page->lru);
4551	lru_cache_add(page);
4552	unlock_page(page);
4553	put_page(page);
4554	}
4555	rc = -ENOMEM;
4556	add_credits_and_wake_if(server, credits, 0);	4498	add_credits_and_wake_if(server, credits, 0);
4557	break;	4499	break;
4558	}	4500	}
4559		4501
4560	rdata->cfile = cifsFileInfo_get(open_file);	4502	got = __readahead_batch(ractl, rdata->pages, nr_pages);
4561	rdata->server = server;	4503	if (got != nr_pages) {
4562	rdata->mapping = mapping;	4504	pr_warn("__readahead_batch() returned %u/%u\n",
4563	rdata->offset = offset;	4505	got, nr_pages);
4564	rdata->bytes = bytes;	4506	nr_pages = got;
4565	rdata->pid = pid;	4507	}
4566	rdata->pagesz = PAGE_SIZE;	4508
4567	rdata->tailsz = PAGE_SIZE;	4509	rdata->nr_pages = nr_pages;
		4510	rdata->bytes = readahead_batch_length(ractl);
		4511	rdata->cfile = cifsFileInfo_get(open_file);
		4512	rdata->server = server;
		4513	rdata->mapping = ractl->mapping;
		4514	rdata->offset = readahead_pos(ractl);
		4515	rdata->pid = pid;
		4516	rdata->pagesz = PAGE_SIZE;
		4517	rdata->tailsz = PAGE_SIZE;
4568	rdata->read_into_pages = cifs_readpages_read_into_pages;	4518	rdata->read_into_pages = cifs_readpages_read_into_pages;
4569	rdata->copy_into_pages = cifs_readpages_copy_into_pages;	4519	rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4570	rdata->credits = credits_on_stack;	4520	rdata->credits = credits_on_stack;
4571
4572	list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4573	list_del(&page->lru);
4574	rdata->pages[rdata->nr_pages++] = page;
4575	}
4576		4521
4577	rc = adjust_credits(server, &rdata->credits, rdata->bytes);	4522	rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4578
4579	if (!rc) {	4523	if (!rc) {
4580	if (rdata->cfile->invalidHandle)	4524	if (rdata->cfile->invalidHandle)
4581	rc = -EAGAIN;	4525	rc = -EAGAIN;
@@ -4587,7 +4531,6 @@ static int cifs_readpages(struct file file, struct address_space mapping, · 5 unmodified lines
4587	add_credits_and_wake_if(server, &rdata->credits, 0);	4531	add_credits_and_wake_if(server, &rdata->credits, 0);
4588	for (i = 0; i < rdata->nr_pages; i++) {	4532	for (i = 0; i < rdata->nr_pages; i++) {
4589	page = rdata->pages[i];	4533	page = rdata->pages[i];
4590	lru_cache_add(page);
4591	unlock_page(page);	4534	unlock_page(page);
4592	put_page(page);	4535	put_page(page);
4593	}	4536	}
@@ -4597,10 +4540,10 @@ static int cifs_readpages(struct file file, struct address_space mapping, · 3 unmodified lines
4597	}	4540	}
4598		4541
4599	kref_put(&rdata->refcount, cifs_readdata_release);	4542	kref_put(&rdata->refcount, cifs_readdata_release);
		4543	last_batch_size = nr_pages;
4600	}	4544	}
4601		4545
4602	free_xid(xid);	4546	free_xid(xid);
4603	return rc;
4604	}	4547	}
4605		4548
4606	/*	4549	/*
@@ -4924,7 +4867,7 @@ oplock_break_done: · 317 unmodified lines
4924	* In the non-cached mode (mount with cache=none), we shunt off direct read and write requests	4867	* In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4925	* so this method should never be called.	4868	* so this method should never be called.
4926	*	4869	*
4927	* Direct IO is not yet supported in the cached mode.	4870	* Direct IO is not yet supported in the cached mode.
4928	*/	4871	*/
4929	static ssize_t	4872	static ssize_t
4930	cifs_direct_io(struct kiocb iocb, struct iov_iter iter)	4873	cifs_direct_io(struct kiocb iocb, struct iov_iter iter)
@@ -5006,7 +4949,7 @@ static int cifs_set_page_dirty(struct page *page) · 75 unmodified lines
5006		4949
5007	const struct address_space_operations cifs_addr_ops = {	4950	const struct address_space_operations cifs_addr_ops = {
5008	.readpage = cifs_readpage,	4951	.readpage = cifs_readpage,
5009	.readpages = cifs_readpages,	4952	.readahead = cifs_readahead,
5010	.writepage = cifs_writepage,	4953	.writepage = cifs_writepage,
5011	.writepages = cifs_writepages,	4954	.writepages = cifs_writepages,
5012	.write_begin = cifs_write_begin,	4955	.write_begin = cifs_write_begin,

fs/cifs/fscache.c+108−18

@@ -134,37 +134,127 @@ void cifs_fscache_release_inode_cookie(struct inode *inode) · 133 unmodified lines
134	}	134	}
135	}	135	}
136		136
		137	static inline void fscache_end_operation(struct netfs_cache_resources *cres)
		138	{
		139	const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
		140
		141	if (ops)
		142	ops->end_operation(cres);
		143	}
		144
137	/*	145	/*
138	* Retrieve a page from FS-Cache	146	* Fallback page reading interface.
139	*/	147	*/
140	int __cifs_readpage_from_fscache(struct inode inode, struct page page)	148	static int fscache_fallback_read_page(struct inode inode, struct page page)
141	{	149	{
142	cifs_dbg(FYI, "%s: (fsc:%p, p:%p, i:0x%p\n",	150	struct netfs_cache_resources cres;
143	__func__, CIFS_I(inode)->fscache, page, inode);	151	struct fscache_cookie *cookie = cifs_inode_cookie(inode);
144	return -ENOBUFS; // Needs conversion to using netfslib	152	struct iov_iter iter;
		153	struct bio_vec bvec[1];
		154	int ret;
		155
		156	memset(&cres, 0, sizeof(cres));
		157	bvec[0].bv_page = page;
		158	bvec[0].bv_offset = 0;
		159	bvec[0].bv_len = PAGE_SIZE;
		160	iov_iter_bvec(&iter, READ, bvec, ARRAY_SIZE(bvec), PAGE_SIZE);
		161
		162	ret = fscache_begin_read_operation(&cres, cookie);
		163	if (ret < 0)
		164	return ret;
		165
		166	ret = fscache_read(&cres, page_offset(page), &iter, NETFS_READ_HOLE_FAIL,
		167	NULL, NULL);
		168	fscache_end_operation(&cres);
		169	return ret;
145	}	170	}
146		171
147	/*	172	/*
148	* Retrieve a set of pages from FS-Cache	173	* Fallback page writing interface.
149	*/	174	*/
150	int __cifs_readpages_from_fscache(struct inode *inode,	175	static int fscache_fallback_write_page(struct inode inode, struct page page,
151	struct address_space *mapping,	176	bool no_space_allocated_yet)
152	struct list_head *pages,
153	unsigned *nr_pages)
154	{	177	{
155	cifs_dbg(FYI, "%s: (0x%p/%u/0x%p)\n",	178	struct netfs_cache_resources cres;
156	__func__, CIFS_I(inode)->fscache, *nr_pages, inode);	179	struct fscache_cookie *cookie = cifs_inode_cookie(inode);
157	return -ENOBUFS; // Needs conversion to using netfslib	180	struct iov_iter iter;
		181	struct bio_vec bvec[1];
		182	loff_t start = page_offset(page);
		183	size_t len = PAGE_SIZE;
		184	int ret;
		185
		186	memset(&cres, 0, sizeof(cres));
		187	bvec[0].bv_page = page;
		188	bvec[0].bv_offset = 0;
		189	bvec[0].bv_len = PAGE_SIZE;
		190	iov_iter_bvec(&iter, WRITE, bvec, ARRAY_SIZE(bvec), PAGE_SIZE);
		191
		192	ret = fscache_begin_write_operation(&cres, cookie);
		193	if (ret < 0)
		194	return ret;
		195
		196	ret = cres.ops->prepare_write(&cres, &start, &len, i_size_read(inode),
		197	no_space_allocated_yet);
		198	if (ret == 0)
		199	ret = fscache_write(&cres, page_offset(page), &iter, NULL, NULL);
		200	fscache_end_operation(&cres);
		201	return ret;
158	}	202	}
159		203
160	void __cifs_readpage_to_fscache(struct inode inode, struct page page)	204	/*
		205	* Retrieve a page from FS-Cache
		206	*/
		207	int __cifs_readpage_from_fscache(struct inode inode, struct page page)
161	{	208	{
162	struct cifsInodeInfo *cifsi = CIFS_I(inode);	209	int ret;
163		210
164	WARN_ON(!cifsi->fscache);	211	cifs_dbg(FYI, "%s: (fsc:%p, p:%p, i:0x%p\n",
		212	__func__, cifs_inode_cookie(inode), page, inode);
165		213
		214	ret = fscache_fallback_read_page(inode, page);
		215	if (ret < 0)
		216	return ret;
		217
		218	/* Read completed synchronously */
		219	SetPageUptodate(page);
		220	return 0;
		221	}
		222
		223	void __cifs_readpage_to_fscache(struct inode inode, struct page page)
		224	{
166	cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n",	225	cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n",
167	__func__, cifsi->fscache, page, inode);	226	__func__, cifs_inode_cookie(inode), page, inode);
		227
		228	fscache_fallback_write_page(inode, page, true);
		229	}
		230
		231	/*
		232	* Query the cache occupancy.
		233	*/
		234	int __cifs_fscache_query_occupancy(struct inode *inode,
		235	pgoff_t first, unsigned int nr_pages,
		236	pgoff_t *_data_first,
		237	unsigned int *_data_nr_pages)
		238	{
		239	struct netfs_cache_resources cres;
		240	struct fscache_cookie *cookie = cifs_inode_cookie(inode);
		241	loff_t start, data_start;
		242	size_t len, data_len;
		243	int ret;
168		244
169	// Needs conversion to using netfslib	245	ret = fscache_begin_read_operation(&cres, cookie);
		246	if (ret < 0)
		247	return ret;
		248
		249	start = first * PAGE_SIZE;
		250	len = nr_pages * PAGE_SIZE;
		251	ret = cres.ops->query_occupancy(&cres, start, len, PAGE_SIZE,
		252	&data_start, &data_len);
		253	if (ret == 0) {
		254	*_data_first = data_start / PAGE_SIZE;
		255	*_data_nr_pages = len / PAGE_SIZE;
		256	}
		257
		258	fscache_end_operation(&cres);
		259	return ret;
170	}	260	}

fs/cifs/fscache.h+49−30

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#ifndef _CIFS_FSCACHE_H	9	#ifndef _CIFS_FSCACHE_H
10	#define _CIFS_FSCACHE_H	10	#define _CIFS_FSCACHE_H
11		11
		12	#include <linux/swap.h>
12	#include <linux/fscache.h>	13	#include <linux/fscache.h>
13		14
14	#include "cifsglob.h"	15	#include "cifsglob.h"
@@ -58,14 +59,6 @@ void cifs_fscache_fill_coherency(struct inode *inode, · 43 unmodified lines
58	}	59	}
59		60
60		61
61	extern int cifs_fscache_release_page(struct page *page, gfp_t gfp);
62	extern int __cifs_readpage_from_fscache(struct inode , struct page );
63	extern int __cifs_readpages_from_fscache(struct inode *,
64	struct address_space *,
65	struct list_head *,
66	unsigned *);
67	extern void __cifs_readpage_to_fscache(struct inode , struct page );
68
69	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode)	62	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode)
70	{	63	{
71	return CIFS_I(inode)->fscache;	64	return CIFS_I(inode)->fscache;
@@ -80,33 +73,52 @@ static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags · 8 unmodified lines
80	i_size_read(inode), flags);	73	i_size_read(inode), flags);
81	}	74	}
82		75
83	static inline int cifs_readpage_from_fscache(struct inode *inode,	76	extern int __cifs_fscache_query_occupancy(struct inode *inode,
84	struct page *page)	77	pgoff_t first, unsigned int nr_pages,
85	{	78	pgoff_t *_data_first,
86	if (CIFS_I(inode)->fscache)	79	unsigned int *_data_nr_pages);
87	return __cifs_readpage_from_fscache(inode, page);
88		80
89	return -ENOBUFS;	81	static inline int cifs_fscache_query_occupancy(struct inode *inode,
		82	pgoff_t first, unsigned int nr_pages,
		83	pgoff_t *_data_first,
		84	unsigned int *_data_nr_pages)
		85	{
		86	if (!cifs_inode_cookie(inode))
		87	return -ENOBUFS;
		88	return __cifs_fscache_query_occupancy(inode, first, nr_pages,
		89	_data_first, _data_nr_pages);
90	}	90	}
91		91
92	static inline int cifs_readpages_from_fscache(struct inode *inode,	92	extern int __cifs_readpage_from_fscache(struct inode pinode, struct page ppage);
93	struct address_space *mapping,	93	extern void __cifs_readpage_to_fscache(struct inode pinode, struct page ppage);
94	struct list_head *pages,	94
95	unsigned *nr_pages)	95
		96	static inline int cifs_readpage_from_fscache(struct inode *inode,
		97	struct page *page)
96	{	98	{
97	if (CIFS_I(inode)->fscache)	99	if (cifs_inode_cookie(inode))
98	return __cifs_readpages_from_fscache(inode, mapping, pages,	100	return __cifs_readpage_from_fscache(inode, page);
99	nr_pages);
100	return -ENOBUFS;	101	return -ENOBUFS;
101	}	102	}
102		103
103	static inline void cifs_readpage_to_fscache(struct inode *inode,	104	static inline void cifs_readpage_to_fscache(struct inode *inode,
104	struct page *page)	105	struct page *page)
105	{	106	{
106	if (PageFsCache(page))	107	if (cifs_inode_cookie(inode))
107	__cifs_readpage_to_fscache(inode, page);	108	__cifs_readpage_to_fscache(inode, page);
108	}	109	}
109		110
		111	static inline int cifs_fscache_release_page(struct page *page, gfp_t gfp)
		112	{
		113	if (PageFsCache(page)) {
		114	if (current_is_kswapd() \|\| !(gfp & __GFP_FS))
		115	return false;
		116	wait_on_page_fscache(page);
		117	fscache_note_page_release(cifs_inode_cookie(page->mapping->host));
		118	}
		119	return true;
		120	}
		121
110	#else /* CONFIG_CIFS_FSCACHE */	122	#else /* CONFIG_CIFS_FSCACHE */
111	static inline	123	static inline
112	void cifs_fscache_fill_coherency(struct inode *inode,	124	void cifs_fscache_fill_coherency(struct inode *inode,
@@ -123,22 +135,29 @@ static inline void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool upd · 10 unmodified lines
123	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode) { return NULL; }	135	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode) { return NULL; }
124	static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags) {}	136	static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags) {}
125		137
126	static inline int	138	static inline int cifs_fscache_query_occupancy(struct inode *inode,
127	cifs_readpage_from_fscache(struct inode inode, struct page page)	139	pgoff_t first, unsigned int nr_pages,
		140	pgoff_t *_data_first,
		141	unsigned int *_data_nr_pages)
128	{	142	{
		143	*_data_first = ULONG_MAX;
		144	*_data_nr_pages = 0;
129	return -ENOBUFS;	145	return -ENOBUFS;
130	}	146	}
131		147
132	static inline int cifs_readpages_from_fscache(struct inode *inode,	148	static inline int
133	struct address_space *mapping,	149	cifs_readpage_from_fscache(struct inode inode, struct page page)
134	struct list_head *pages,
135	unsigned *nr_pages)
136	{	150	{
137	return -ENOBUFS;	151	return -ENOBUFS;
138	}	152	}
139		153
140	static inline void cifs_readpage_to_fscache(struct inode *inode,	154	static inline
141	struct page *page) {}	155	void cifs_readpage_to_fscache(struct inode inode, struct page page) {}
		156
		157	static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp)
		158	{
		159	return true; /* May release page */
		160	}
142		161
143	#endif /* CONFIG_CIFS_FSCACHE */	162	#endif /* CONFIG_CIFS_FSCACHE */
144		163

fs/cifs/inode.c+4−4

 static void
 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
 {
+	struct cifs_fscache_inode_coherency_data cd;
 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 	cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 	cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 		 __func__, cifs_i->uniqueid);
 	set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
+	/* Invalidate fscache cookie */
+	cifs_fscache_fill_coherency(&cifs_i->vfs_inode, &cd);
+	fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
 }
 /*
 int
 cifs_invalidate_mapping(struct inode *inode)
 {
-	struct cifs_fscache_inode_coherency_data cd;
-	struct cifsInodeInfo *cifsi = CIFS_I(inode);
 	int rc = 0;
 	if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
 				 __func__, inode);
 	}
-	cifs_fscache_fill_coherency(&cifsi->vfs_inode, &cd);
-	fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
 	return rc;
 }

fs/cifs/sess.c+5−1

 	else
 		sz += sizeof(__le16);
-	sz += sizeof(__le16) * strnlen(ses->workstation_name, CIFS_MAX_WORKSTATION_LEN);
+	if (ses->workstation_name)
+		sz += sizeof(__le16) * strnlen(ses->workstation_name,
+			CIFS_MAX_WORKSTATION_LEN);
+	else
+		sz += sizeof(__le16);
 	return sz;
 }

fs/erofs/data.c+4−4

 		return ret;
 	iomap->offset = map.m_la;
-	if (flags & IOMAP_DAX) {
+	if (flags & IOMAP_DAX)
 		iomap->dax_dev = mdev.m_daxdev;
-		iomap->offset += mdev.m_dax_part_off;
+	else
-	} else {
 		iomap->bdev = mdev.m_bdev;
-	}
 	iomap->length = map.m_llen;
 	iomap->flags = 0;
 	iomap->private = NULL;
 	} else {
 		iomap->type = IOMAP_MAPPED;
 		iomap->addr = mdev.m_pa;
+		if (flags & IOMAP_DAX)
+			iomap->addr += mdev.m_dax_part_off;
 	}
 	return 0;
 }

fs/erofs/zdata.c+56−57

 	return false;
 }
-static void z_erofs_decompressqueue_work(struct work_struct *work);
-static void z_erofs_decompress_kickoff(struct z_erofs_decompressqueue *io,
-				       bool sync, int bios)
-{
-	struct erofs_sb_info *const sbi = EROFS_SB(io->sb);
-	/* wake up the caller thread for sync decompression */
-	if (sync) {
-		unsigned long flags;
-		spin_lock_irqsave(&io->u.wait.lock, flags);
-		if (!atomic_add_return(bios, &io->pending_bios))
-			wake_up_locked(&io->u.wait);
-		spin_unlock_irqrestore(&io->u.wait.lock, flags);
-		return;
-	}
-	if (atomic_add_return(bios, &io->pending_bios))
-		return;
-	/* Use workqueue and sync decompression for atomic contexts only */
-	if (in_atomic() || irqs_disabled()) {
-		queue_work(z_erofs_workqueue, &io->u.work);
-		/* enable sync decompression for readahead */
-		if (sbi->opt.sync_decompress == EROFS_SYNC_DECOMPRESS_AUTO)
-			sbi->opt.sync_decompress = EROFS_SYNC_DECOMPRESS_FORCE_ON;
-		return;
-	}
-	z_erofs_decompressqueue_work(&io->u.work);
-}
 static bool z_erofs_page_is_invalidated(struct page *page)
 {
 	return !page->mapping && !z_erofs_is_shortlived_page(page);
 }
-static void z_erofs_decompressqueue_endio(struct bio *bio)
-{
-	tagptr1_t t = tagptr_init(tagptr1_t, bio->bi_private);
-	struct z_erofs_decompressqueue *q = tagptr_unfold_ptr(t);
-	blk_status_t err = bio->bi_status;
-	struct bio_vec *bvec;
-	struct bvec_iter_all iter_all;
-	bio_for_each_segment_all(bvec, bio, iter_all) {
-		struct page *page = bvec->bv_page;
-		DBG_BUGON(PageUptodate(page));
-		DBG_BUGON(z_erofs_page_is_invalidated(page));
-		if (err)
-			SetPageError(page);
-		if (erofs_page_is_managed(EROFS_SB(q->sb), page)) {
-			if (!err)
-				SetPageUptodate(page);
-			unlock_page(page);
-		}
-	}
-	z_erofs_decompress_kickoff(q, tagptr_unfold_tags(t), -1);
-	bio_put(bio);
-}
 static int z_erofs_decompress_pcluster(struct super_block *sb,
 				       struct z_erofs_pcluster *pcl,
 				       struct page **pagepool)
 	kvfree(bgq);
 }
+static void z_erofs_decompress_kickoff(struct z_erofs_decompressqueue *io,
+				       bool sync, int bios)
+{
+	struct erofs_sb_info *const sbi = EROFS_SB(io->sb);
+	/* wake up the caller thread for sync decompression */
+	if (sync) {
+		unsigned long flags;
+		spin_lock_irqsave(&io->u.wait.lock, flags);
+		if (!atomic_add_return(bios, &io->pending_bios))
+			wake_up_locked(&io->u.wait);
+		spin_unlock_irqrestore(&io->u.wait.lock, flags);
+		return;
+	}
+	if (atomic_add_return(bios, &io->pending_bios))
+		return;
+	/* Use workqueue and sync decompression for atomic contexts only */
+	if (in_atomic() || irqs_disabled()) {
+		queue_work(z_erofs_workqueue, &io->u.work);
+		/* enable sync decompression for readahead */
+		if (sbi->opt.sync_decompress == EROFS_SYNC_DECOMPRESS_AUTO)
+			sbi->opt.sync_decompress = EROFS_SYNC_DECOMPRESS_FORCE_ON;
+		return;
+	}
+	z_erofs_decompressqueue_work(&io->u.work);
+}
 static struct page *pickup_page_for_submission(struct z_erofs_pcluster *pcl,
 					       unsigned int nr,
 					       struct page **pagepool,
 	qtail[JQ_BYPASS] = &pcl->next;
 }
+static void z_erofs_decompressqueue_endio(struct bio *bio)
+{
+	tagptr1_t t = tagptr_init(tagptr1_t, bio->bi_private);
+	struct z_erofs_decompressqueue *q = tagptr_unfold_ptr(t);
+	blk_status_t err = bio->bi_status;
+	struct bio_vec *bvec;
+	struct bvec_iter_all iter_all;
+	bio_for_each_segment_all(bvec, bio, iter_all) {
+		struct page *page = bvec->bv_page;
+		DBG_BUGON(PageUptodate(page));
+		DBG_BUGON(z_erofs_page_is_invalidated(page));
+		if (err)
+			SetPageError(page);
+		if (erofs_page_is_managed(EROFS_SB(q->sb), page)) {
+			if (!err)
+				SetPageUptodate(page);
+			unlock_page(page);
+		}
+	}
+	z_erofs_decompress_kickoff(q, tagptr_unfold_tags(t), -1);
+	bio_put(bio);
+}
 static void z_erofs_submit_queue(struct super_block *sb,
 				 struct z_erofs_decompress_frontend *f,
 				 struct page **pagepool,

fs/erofs/zmap.c+7−0

@@ -630,6 +630,13 @@ static int z_erofs_do_map_blocks(struct inode *inode, · 629 unmodified lines
630	if (endoff >= m.clusterofs) {	630	if (endoff >= m.clusterofs) {
631	m.headtype = m.type;	631	m.headtype = m.type;
632	map->m_la = (m.lcn << lclusterbits) \| m.clusterofs;	632	map->m_la = (m.lcn << lclusterbits) \| m.clusterofs;
		633	/*
		634	* For ztailpacking files, in order to inline data more
		635	* effectively, special EOF lclusters are now supported
		636	* which can have three parts at most.
		637	*/
		638	if (ztailpacking && end > inode->i_size)
		639	end = inode->i_size;
633	break;	640	break;
634	}	641	}
635	/* m.lcn should be >= 1 if endoff < m.clusterofs */	642	/* m.lcn should be >= 1 if endoff < m.clusterofs */

fs/ext4/acl.c+4−4

@@ -139,7 +139,7 @@ fail: · 138 unmodified lines
139	/*	139	/*
140	* Inode operation get_posix_acl().	140	* Inode operation get_posix_acl().
141	*	141	*
142	* inode->i_mutex: don't care	142	* inode->i_rwsem: don't care
143	*/	143	*/
144	struct posix_acl *	144	struct posix_acl *
145	ext4_get_acl(struct inode *inode, int type, bool rcu)	145	ext4_get_acl(struct inode *inode, int type, bool rcu)
@@ -183,7 +183,7 @@ ext4_get_acl(struct inode *inode, int type, bool rcu) · 37 unmodified lines
183	/*	183	/*
184	* Set the access or default ACL of an inode.	184	* Set the access or default ACL of an inode.
185	*	185	*
186	* inode->i_mutex: down unless called from ext4_new_inode	186	* inode->i_rwsem: down unless called from ext4_new_inode
187	*/	187	*/
188	static int	188	static int
189	__ext4_set_acl(handle_t handle, struct inode inode, int type,	189	__ext4_set_acl(handle_t handle, struct inode inode, int type,
@@ -271,8 +271,8 @@ out_stop: · 81 unmodified lines
271	/*	271	/*
272	* Initialize the ACLs of a new inode. Called from ext4_new_inode.	272	* Initialize the ACLs of a new inode. Called from ext4_new_inode.
273	*	273	*
274	* dir->i_mutex: down	274	* dir->i_rwsem: down
275	* inode->i_mutex: up (access to inode is still exclusive)	275	* inode->i_rwsem: up (access to inode is still exclusive)
276	*/	276	*/
277	int	277	int
278	ext4_init_acl(handle_t handle, struct inode inode, struct inode *dir)	278	ext4_init_acl(handle_t handle, struct inode inode, struct inode *dir)

fs/ext4/ext4.h+9−8

 	/*
 	 * Extended attributes can be read independently of the main file
-	 * data. Taking i_mutex even when reading would cause contention
+	 * data. Taking i_rwsem even when reading would cause contention
 	 * between readers of EAs and writers of regular file data, so
 	 * instead we synchronize on xattr_sem when reading or changing
 	 * EAs.
 	spinlock_t s_fc_lock;
 	struct buffer_head *s_fc_bh;
 	struct ext4_fc_stats s_fc_stats;
+	tid_t s_fc_ineligible_tid;
 #ifdef CONFIG_EXT4_DEBUG
 	int s_fc_debug_max_replay;
 #endif
 enum {
 	EXT4_MF_MNTDIR_SAMPLED,
 	EXT4_MF_FS_ABORTED,	/* Fatal error detected */
-	EXT4_MF_FC_INELIGIBLE,	/* Fast commit ineligible */
+	EXT4_MF_FC_INELIGIBLE	/* Fast commit ineligible */
-	EXT4_MF_FC_COMMITTING	/* File system underoing a fast
-				 * commit.
-				 */
 };
 static inline void ext4_set_mount_flag(struct super_block *sb, int bit)
 			    struct dentry *dentry);
 void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
 void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
-void ext4_fc_mark_ineligible(struct super_block *sb, int reason);
+void ext4_fc_mark_ineligible(struct super_block *sb, int reason, handle_t *handle);
 void ext4_fc_start_update(struct inode *inode);
 void ext4_fc_stop_update(struct inode *inode);
 void ext4_fc_del(struct inode *inode);
 int ext4_fc_commit(journal_t *journal, tid_t commit_tid);
 int __init ext4_fc_init_dentry_cache(void);
 void ext4_fc_destroy_dentry_cache(void);
+int ext4_fc_record_regions(struct super_block *sb, int ino,
+			   ext4_lblk_t lblk, ext4_fsblk_t pblk,
+			   int len, int replay);
 /* mballoc.c */
 extern const struct seq_operations ext4_mb_seq_groups_ops;
 #define EXT4_FREECLUSTERS_WATERMARK 0
 #endif
-/* Update i_disksize. Requires i_mutex to avoid races with truncate */
+/* Update i_disksize. Requires i_rwsem to avoid races with truncate */
 static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
 {
 	WARN_ON_ONCE(S_ISREG(inode->i_mode) &&
 	up_write(&EXT4_I(inode)->i_data_sem);
 }
-/* Update i_size, i_disksize. Requires i_mutex to avoid races with truncate */
+/* Update i_size, i_disksize. Requires i_rwsem to avoid races with truncate */
 static inline int ext4_update_inode_size(struct inode *inode, loff_t newsize)
 {
 	int changed = 0;

fs/ext4/ext4_jbd2.h+1−1

@@ -491,7 +491,7 @@ static inline int ext4_free_data_revoke_credits(struct inode *inode, int blocks) · 490 unmodified lines
491	/*	491	/*
492	* This function controls whether or not we should try to go down the	492	* This function controls whether or not we should try to go down the
493	* dioread_nolock code paths, which makes it safe to avoid taking	493	* dioread_nolock code paths, which makes it safe to avoid taking
494	* i_mutex for direct I/O reads. This only works for extent-based	494	* i_rwsem for direct I/O reads. This only works for extent-based
495	* files, and it doesn't work if data journaling is enabled, since the	495	* files, and it doesn't work if data journaling is enabled, since the
496	* dioread_nolock code uses b_private to pass information back to the	496	* dioread_nolock code uses b_private to pass information back to the
497	* I/O completion handler, and this conflicts with the jbd's use of	497	* I/O completion handler, and this conflicts with the jbd's use of

fs/ext4/extents.c+10−6

 	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
 	 * moment, get_block can be called only for blocks inside i_size since
 	 * page cache has been already dropped and writes are blocked by
-	 * i_mutex. So we can safely drop the i_data_sem here.
+	 * i_rwsem. So we can safely drop the i_data_sem here.
 	 */
 	BUG_ON(EXT4_JOURNAL(inode) == NULL);
 	ext4_discard_preallocations(inode, 0);
 	flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
-	/* Wait all existing dio workers, newcomers will block on i_mutex */
+	/* Wait all existing dio workers, newcomers will block on i_rwsem */
 	inode_dio_wait(inode);
 	/* Preallocate the range including the unaligned edges */
 			goto out;
 	}
-	/* Wait all existing dio workers, newcomers will block on i_mutex */
+	/* Wait all existing dio workers, newcomers will block on i_rwsem */
 	inode_dio_wait(inode);
 	ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags);
 		ret = PTR_ERR(handle);
 		goto out_mmap;
 	}
-	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE);
+	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE, handle);
 	down_write(&EXT4_I(inode)->i_data_sem);
 	ext4_discard_preallocations(inode, 0);
 		ret = PTR_ERR(handle);
 		goto out_mmap;
 	}
-	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE);
+	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE, handle);
 	/* Expand file to avoid data loss if there is error while shifting */
 	inode->i_size += len;
  * stuff such as page-cache locking consistency, bh mapping consistency or
  * extent's data copying must be performed by caller.
  * Locking:
- * 		i_mutex is held for both inodes
+ *		i_rwsem is held for both inodes
  * 		i_data_sem is locked for write for both inodes
  * Assumptions:
  *		All pages from requested range are locked for both inodes
 					ext4_mb_mark_bb(inode->i_sb,
 							path[j].p_block, 1, 0);
+					ext4_fc_record_regions(inode->i_sb, inode->i_ino,
+							0, path[j].p_block, 1, 1);
 				}
 				ext4_ext_drop_refs(path);
 				kfree(path);
 			}
 			ext4_mb_mark_bb(inode->i_sb, map.m_pblk, map.m_len, 0);
+			ext4_fc_record_regions(inode->i_sb, inode->i_ino,
+					map.m_lblk, map.m_pblk, map.m_len, 1);
 		}
 		cur = cur + map.m_len;
 	}

fs/ext4/fast_commit.c+78−55

 }
 /*
- * Mark file system as fast commit ineligible. This means that next commit
+ * Mark file system as fast commit ineligible, and record latest
- * operation would result in a full jbd2 commit.
+ * ineligible transaction tid. This means until the recorded
+ * transaction, commit operation would result in a full jbd2 commit.
  */
-void ext4_fc_mark_ineligible(struct super_block *sb, int reason)
+void ext4_fc_mark_ineligible(struct super_block *sb, int reason, handle_t *handle)
 {
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	tid_t tid;
 	if (!test_opt2(sb, JOURNAL_FAST_COMMIT) ||
 	    (EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY))
 		return;
 	ext4_set_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
+	if (handle && !IS_ERR(handle))
+		tid = handle->h_transaction->t_tid;
+	else {
+		read_lock(&sbi->s_journal->j_state_lock);
+		tid = sbi->s_journal->j_running_transaction ?
+				sbi->s_journal->j_running_transaction->t_tid : 0;
+		read_unlock(&sbi->s_journal->j_state_lock);
+	}
+	spin_lock(&sbi->s_fc_lock);
+	if (sbi->s_fc_ineligible_tid < tid)
+		sbi->s_fc_ineligible_tid = tid;
+	spin_unlock(&sbi->s_fc_lock);
 	WARN_ON(reason >= EXT4_FC_REASON_MAX);
 	sbi->s_fc_stats.fc_ineligible_reason_count[reason]++;
 }
 	spin_lock(&sbi->s_fc_lock);
 	if (list_empty(&EXT4_I(inode)->i_fc_list))
 		list_add_tail(&EXT4_I(inode)->i_fc_list,
-				(ext4_test_mount_flag(inode->i_sb, EXT4_MF_FC_COMMITTING)) ?
+				(sbi->s_journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||
+				 sbi->s_journal->j_flags & JBD2_FAST_COMMIT_ONGOING) ?
 				&sbi->s_fc_q[FC_Q_STAGING] :
 				&sbi->s_fc_q[FC_Q_MAIN]);
 	spin_unlock(&sbi->s_fc_lock);
 	mutex_unlock(&ei->i_fc_lock);
 	node = kmem_cache_alloc(ext4_fc_dentry_cachep, GFP_NOFS);
 	if (!node) {
-		ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_NOMEM);
+		ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_NOMEM, NULL);
 		mutex_lock(&ei->i_fc_lock);
 		return -ENOMEM;
 	}
 		if (!node->fcd_name.name) {
 			kmem_cache_free(ext4_fc_dentry_cachep, node);
 			ext4_fc_mark_ineligible(inode->i_sb,
-				EXT4_FC_REASON_NOMEM);
+				EXT4_FC_REASON_NOMEM, NULL);
 			mutex_lock(&ei->i_fc_lock);
 			return -ENOMEM;
 		}
 	node->fcd_name.len = dentry->d_name.len;
 	spin_lock(&sbi->s_fc_lock);
-	if (ext4_test_mount_flag(inode->i_sb, EXT4_MF_FC_COMMITTING))
+	if (sbi->s_journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||
+		sbi->s_journal->j_flags & JBD2_FAST_COMMIT_ONGOING)
 		list_add_tail(&node->fcd_list,
 				&sbi->s_fc_dentry_q[FC_Q_STAGING]);
 	else
 	if (ext4_should_journal_data(inode)) {
 		ext4_fc_mark_ineligible(inode->i_sb,
-					EXT4_FC_REASON_INODE_JOURNAL_DATA);
+					EXT4_FC_REASON_INODE_JOURNAL_DATA, handle);
 		return;
 	}
 	int ret = 0;
 	spin_lock(&sbi->s_fc_lock);
-	ext4_set_mount_flag(sb, EXT4_MF_FC_COMMITTING);
 	list_for_each_entry(ei, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {
 		ext4_set_inode_state(&ei->vfs_inode, EXT4_STATE_FC_COMMITTING);
 		while (atomic_read(&ei->i_fc_updates)) {
  * Fast commit cleanup routine. This is called after every fast commit and
  * full commit. full is true if we are called after a full commit.
  */
-static void ext4_fc_cleanup(journal_t *journal, int full)
+static void ext4_fc_cleanup(journal_t *journal, int full, tid_t tid)
 {
 	struct super_block *sb = journal->j_private;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 		list_del_init(&iter->i_fc_list);
 		ext4_clear_inode_state(&iter->vfs_inode,
 				       EXT4_STATE_FC_COMMITTING);
-		ext4_fc_reset_inode(&iter->vfs_inode);
+		if (iter->i_sync_tid <= tid)
+			ext4_fc_reset_inode(&iter->vfs_inode);
 		/* Make sure EXT4_STATE_FC_COMMITTING bit is clear */
 		smp_mb();
 #if (BITS_PER_LONG < 64)
 	list_splice_init(&sbi->s_fc_q[FC_Q_STAGING],
 				&sbi->s_fc_q[FC_Q_MAIN]);
-	ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);
+	if (tid >= sbi->s_fc_ineligible_tid) {
-	ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
+		sbi->s_fc_ineligible_tid = 0;
+		ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
+	}
 	if (full)
 		sbi->s_fc_bytes = 0;
 		if (state->fc_modified_inodes[i] == ino)
 			return 0;
 	if (state->fc_modified_inodes_used == state->fc_modified_inodes_size) {
-		state->fc_modified_inodes_size +=
-			EXT4_FC_REPLAY_REALLOC_INCREMENT;
 		state->fc_modified_inodes = krealloc(
-					state->fc_modified_inodes, sizeof(int) *
+				state->fc_modified_inodes,
-					state->fc_modified_inodes_size,
+				sizeof(int) * (state->fc_modified_inodes_size +
-					GFP_KERNEL);
+				EXT4_FC_REPLAY_REALLOC_INCREMENT),
+				GFP_KERNEL);
 		if (!state->fc_modified_inodes)
 			return -ENOMEM;
+		state->fc_modified_inodes_size +=
+			EXT4_FC_REPLAY_REALLOC_INCREMENT;
 	}
 	state->fc_modified_inodes[state->fc_modified_inodes_used++] = ino;
 	return 0;
 	}
 	inode = NULL;
-	ext4_fc_record_modified_inode(sb, ino);
+	ret = ext4_fc_record_modified_inode(sb, ino);
+	if (ret)
+		goto out;
 	raw_fc_inode = (struct ext4_inode *)
 		(val + offsetof(struct ext4_fc_inode, fc_raw_inode));
 }
 /*
- * Record physical disk regions which are in use as per fast commit area. Our
+ * Record physical disk regions which are in use as per fast commit area,
- * simple replay phase allocator excludes these regions from allocation.
+ * and used by inodes during replay phase. Our simple replay phase
+ * allocator excludes these regions from allocation.
  */
-static int ext4_fc_record_regions(struct super_block *sb, int ino,
+int ext4_fc_record_regions(struct super_block *sb, int ino,
-		ext4_lblk_t lblk, ext4_fsblk_t pblk, int len)
+		ext4_lblk_t lblk, ext4_fsblk_t pblk, int len, int replay)
 {
 	struct ext4_fc_replay_state *state;
 	struct ext4_fc_alloc_region *region;
 	state = &EXT4_SB(sb)->s_fc_replay_state;
+	/*
+	 * during replay phase, the fc_regions_valid may not same as
+	 * fc_regions_used, update it when do new additions.
+	 */
+	if (replay && state->fc_regions_used != state->fc_regions_valid)
+		state->fc_regions_used = state->fc_regions_valid;
 	if (state->fc_regions_used == state->fc_regions_size) {
 		state->fc_regions_size +=
 			EXT4_FC_REPLAY_REALLOC_INCREMENT;
 	region->pblk = pblk;
 	region->len = len;
+	if (replay)
+		state->fc_regions_valid++;
 	return 0;
 }
 	}
 	ret = ext4_fc_record_modified_inode(sb, inode->i_ino);
+	if (ret)
+		goto out;
 	start = le32_to_cpu(ex->ee_block);
 	start_pblk = ext4_ext_pblock(ex);
 		map.m_pblk = 0;
 		ret = ext4_map_blocks(NULL, inode, &map, 0);
-		if (ret < 0) {
+		if (ret < 0)
-			iput(inode);
+			goto out;
-			return 0;
-		}
 		if (ret == 0) {
 			/* Range is not mapped */
 			path = ext4_find_extent(inode, cur, NULL, 0);
-			if (IS_ERR(path)) {
+			if (IS_ERR(path))
-				iput(inode);
+				goto out;
-				return 0;
-			}
 			memset(&newex, 0, sizeof(newex));
 			newex.ee_block = cpu_to_le32(cur);
 			ext4_ext_store_pblock(
 			up_write((&EXT4_I(inode)->i_data_sem));
 			ext4_ext_drop_refs(path);
 			kfree(path);
-			if (ret) {
+			if (ret)
-				iput(inode);
+				goto out;
-				return 0;
-			}
 			goto next;
 		}
 			ret = ext4_ext_replay_update_ex(inode, cur, map.m_len,
 					ext4_ext_is_unwritten(ex),
 					start_pblk + cur - start);
-			if (ret) {
+			if (ret)
-				iput(inode);
+				goto out;
-				return 0;
-			}
 			/*
 			 * Mark the old blocks as free since they aren't used
 			 * anymore. We maintain an array of all the modified
 			ext4_ext_is_unwritten(ex), map.m_pblk);
 		ret = ext4_ext_replay_update_ex(inode, cur, map.m_len,
 					ext4_ext_is_unwritten(ex), map.m_pblk);
-		if (ret) {
+		if (ret)
-			iput(inode);
+			goto out;
-			return 0;
-		}
 		/*
 		 * We may have split the extent tree while toggling the state.
 		 * Try to shrink the extent tree now.
 	}
 	ext4_ext_replay_shrink_inode(inode, i_size_read(inode) >>
 					sb->s_blocksize_bits);
+out:
 	iput(inode);
 	return 0;
 }
 	}
 	ret = ext4_fc_record_modified_inode(sb, inode->i_ino);
+	if (ret)
+		goto out;
 	jbd_debug(1, "DEL_RANGE, inode %ld, lblk %d, len %d\n",
 			inode->i_ino, le32_to_cpu(lrange.fc_lblk),
 		map.m_len = remaining;
 		ret = ext4_map_blocks(NULL, inode, &map, 0);
-		if (ret < 0) {
+		if (ret < 0)
-			iput(inode);
+			goto out;
-			return 0;
-		}
 		if (ret > 0) {
 			remaining -= ret;
 			cur += ret;
 	}
 	down_write(&EXT4_I(inode)->i_data_sem);
-	ret = ext4_ext_remove_space(inode, lrange.fc_lblk,
+	ret = ext4_ext_remove_space(inode, le32_to_cpu(lrange.fc_lblk),
-				lrange.fc_lblk + lrange.fc_len - 1);
+				le32_to_cpu(lrange.fc_lblk) +
+				le32_to_cpu(lrange.fc_len) - 1);
 	up_write(&EXT4_I(inode)->i_data_sem);
-	if (ret) {
+	if (ret)
-		iput(inode);
+		goto out;
-		return 0;
-	}
 	ext4_ext_replay_shrink_inode(inode,
 		i_size_read(inode) >> sb->s_blocksize_bits);
 	ext4_mark_inode_dirty(NULL, inode);
+out:
 	iput(inode);
 	return 0;
 }
 			ret = ext4_fc_record_regions(sb,
 				le32_to_cpu(ext.fc_ino),
 				le32_to_cpu(ex->ee_block), ext4_ext_pblock(ex),
-				ext4_ext_get_actual_len(ex));
+				ext4_ext_get_actual_len(ex), 0);
 			if (ret < 0)
 				break;
 			ret = JBD2_FC_REPLAY_CONTINUE;

fs/ext4/indirect.c+1−1

@@ -696,7 +696,7 @@ static int ext4_ind_trunc_restart_fn(handle_t handle, struct inode inode, · 695 unmodified lines
696	* Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this	696	* Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
697	* moment, get_block can be called only for blocks inside i_size since	697	* moment, get_block can be called only for blocks inside i_size since
698	* page cache has been already dropped and writes are blocked by	698	* page cache has been already dropped and writes are blocked by
699	* i_mutex. So we can safely drop the i_data_sem here.	699	* i_rwsem. So we can safely drop the i_data_sem here.
700	*/	700	*/
701	BUG_ON(EXT4_JOURNAL(inode) == NULL);	701	BUG_ON(EXT4_JOURNAL(inode) == NULL);
702	ext4_discard_preallocations(inode, 0);	702	ext4_discard_preallocations(inode, 0);

fs/ext4/inline.c+13−10

@@ -911,7 +911,7 @@ int ext4_da_write_inline_data_begin(struct address_space *mapping, · 910 unmodified lines
911	struct page **pagep,	911	struct page **pagep,
912	void **fsdata)	912	void **fsdata)
913	{	913	{
914	int ret, inline_size;	914	int ret;
915	handle_t *handle;	915	handle_t *handle;
916	struct page *page;	916	struct page *page;
917	struct ext4_iloc iloc;	917	struct ext4_iloc iloc;
@@ -928,14 +928,9 @@ retry_journal: · 10 unmodified lines
928	goto out;	928	goto out;
929	}	929	}
930		930
931	inline_size = ext4_get_max_inline_size(inode);	931	ret = ext4_prepare_inline_data(handle, inode, pos + len);
932		932	if (ret && ret != -ENOSPC)
933	ret = -ENOSPC;	933	goto out_journal;
934	if (inline_size >= pos + len) {
935	ret = ext4_prepare_inline_data(handle, inode, pos + len);
936	if (ret && ret != -ENOSPC)
937	goto out_journal;
938	}
939		934
940	/*	935	/*
941	* We cannot recurse into the filesystem as the transaction	936	* We cannot recurse into the filesystem as the transaction
@@ -1133,7 +1128,15 @@ static void ext4_restore_inline_data(handle_t handle, struct inode inode, · 191 unmodified lines
1133	struct ext4_iloc *iloc,	1128	struct ext4_iloc *iloc,
1134	void *buf, int inline_size)	1129	void *buf, int inline_size)
1135	{	1130	{
1136	ext4_create_inline_data(handle, inode, inline_size);	1131	int ret;
		1132
		1133	ret = ext4_create_inline_data(handle, inode, inline_size);
		1134	if (ret) {
		1135	ext4_msg(inode->i_sb, KERN_EMERG,
		1136	"error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)",
		1137	inode->i_ino, ret);
		1138	return;
		1139	}
1137	ext4_write_inline_data(inode, iloc, buf, 0, inline_size);	1140	ext4_write_inline_data(inode, iloc, buf, 0, inline_size);
1138	ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);	1141	ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1139	}	1142	}

fs/ext4/inode.c+6−6

@@ -338,7 +338,7 @@ stop_handle: · 337 unmodified lines
338	return;	338	return;
339	no_delete:	339	no_delete:
340	if (!list_empty(&EXT4_I(inode)->i_fc_list))	340	if (!list_empty(&EXT4_I(inode)->i_fc_list))
341	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_NOMEM);	341	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_NOMEM, NULL);
342	ext4_clear_inode(inode); /* We must guarantee clearing of inode... */	342	ext4_clear_inode(inode); /* We must guarantee clearing of inode... */
343	}	343	}
344		344
@@ -1224,7 +1224,7 @@ retry_journal: · 879 unmodified lines
1224	/*	1224	/*
1225	* __block_write_begin may have instantiated a few blocks	1225	* __block_write_begin may have instantiated a few blocks
1226	* outside i_size. Trim these off again. Don't need	1226	* outside i_size. Trim these off again. Don't need
1227	* i_size_read because we hold i_mutex.	1227	* i_size_read because we hold i_rwsem.
1228	*	1228	*
1229	* Add inode to orphan list in case we crash before	1229	* Add inode to orphan list in case we crash before
1230	* truncate finishes	1230	* truncate finishes
@@ -3979,7 +3979,7 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) · 2748 unmodified lines
3979		3979
3980	}	3980	}
3981		3981
3982	/* Wait all existing dio workers, newcomers will block on i_mutex */	3982	/* Wait all existing dio workers, newcomers will block on i_rwsem */
3983	inode_dio_wait(inode);	3983	inode_dio_wait(inode);
3984		3984
3985	/*	3985	/*
@@ -4129,7 +4129,7 @@ int ext4_truncate(struct inode *inode) · 143 unmodified lines
4129	/*	4129	/*
4130	* There is a possibility that we're either freeing the inode	4130	* There is a possibility that we're either freeing the inode
4131	* or it's a completely new inode. In those cases we might not	4131	* or it's a completely new inode. In those cases we might not
4132	* have i_mutex locked because it's not necessary.	4132	* have i_rwsem locked because it's not necessary.
4133	*/	4133	*/
4134	if (!(inode->i_state & (I_NEW\|I_FREEING)))	4134	if (!(inode->i_state & (I_NEW\|I_FREEING)))
4135	WARN_ON(!inode_is_locked(inode));	4135	WARN_ON(!inode_is_locked(inode));
@@ -5271,7 +5271,7 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode) · 1135 unmodified lines
5271	* transaction are already on disk (truncate waits for pages under	5271	* transaction are already on disk (truncate waits for pages under
5272	* writeback).	5272	* writeback).
5273	*	5273	*
5274	* Called with inode->i_mutex down.	5274	* Called with inode->i_rwsem down.
5275	*/	5275	*/
5276	int ext4_setattr(struct user_namespace mnt_userns, struct dentry dentry,	5276	int ext4_setattr(struct user_namespace mnt_userns, struct dentry dentry,
5277	struct iattr *attr)	5277	struct iattr *attr)
@@ -5983,7 +5983,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val) · 705 unmodified lines
5983	return PTR_ERR(handle);	5983	return PTR_ERR(handle);
5984		5984
5985	ext4_fc_mark_ineligible(inode->i_sb,	5985	ext4_fc_mark_ineligible(inode->i_sb,
5986	EXT4_FC_REASON_JOURNAL_FLAG_CHANGE);	5986	EXT4_FC_REASON_JOURNAL_FLAG_CHANGE, handle);
5987	err = ext4_mark_inode_dirty(handle, inode);	5987	err = ext4_mark_inode_dirty(handle, inode);
5988	ext4_handle_sync(handle);	5988	ext4_handle_sync(handle);
5989	ext4_journal_stop(handle);	5989	ext4_journal_stop(handle);

fs/ext4/ioctl.c+2−2

@@ -411,7 +411,7 @@ static long swap_inode_boot_loader(struct super_block *sb, · 410 unmodified lines
411	err = -EINVAL;	411	err = -EINVAL;
412	goto err_out;	412	goto err_out;
413	}	413	}
414	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_SWAP_BOOT);	414	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_SWAP_BOOT, handle);
415		415
416	/* Protect extent tree against block allocations via delalloc */	416	/* Protect extent tree against block allocations via delalloc */
417	ext4_double_down_write_data_sem(inode, inode_bl);	417	ext4_double_down_write_data_sem(inode, inode_bl);
@@ -1373,7 +1373,7 @@ mext_out: · 955 unmodified lines
1373		1373
1374	err = ext4_resize_fs(sb, n_blocks_count);	1374	err = ext4_resize_fs(sb, n_blocks_count);
1375	if (EXT4_SB(sb)->s_journal) {	1375	if (EXT4_SB(sb)->s_journal) {
1376	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE);	1376	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE, NULL);
1377	jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);	1377	jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
1378	err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);	1378	err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);
1379	jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);	1379	jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);

fs/ext4/mballoc.c+17−9

 	struct super_block *sb = ar->inode->i_sb;
 	ext4_group_t group;
 	ext4_grpblk_t blkoff;
-	int i = sb->s_blocksize;
+	ext4_grpblk_t max = EXT4_CLUSTERS_PER_GROUP(sb);
+	ext4_grpblk_t i = 0;
 	ext4_fsblk_t goal, block;
 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 		ext4_get_group_no_and_offset(sb,
 			max(ext4_group_first_block_no(sb, group), goal),
 			NULL, &blkoff);
-		i = mb_find_next_zero_bit(bitmap_bh->b_data, sb->s_blocksize,
+		while (1) {
+			i = mb_find_next_zero_bit(bitmap_bh->b_data, max,
 						blkoff);
+			if (i >= max)
+				break;
+			if (ext4_fc_replay_check_excluded(sb,
+				ext4_group_first_block_no(sb, group) + i)) {
+				blkoff = i + 1;
+			} else
+				break;
+		}
 		brelse(bitmap_bh);
-		if (i >= sb->s_blocksize)
+		if (i < max)
-			continue;
+			break;
-		if (ext4_fc_replay_check_excluded(sb,
-			ext4_group_first_block_no(sb, group) + i))
-			continue;
-		break;
 	}
-	if (group >= ext4_get_groups_count(sb) && i >= sb->s_blocksize)
+	if (group >= ext4_get_groups_count(sb) || i >= max) {
+		*errp = -ENOSPC;
 		return 0;
+	}
 	block = ext4_group_first_block_no(sb, group) + i;
 	ext4_mb_mark_bb(sb, block, 1, 1);

fs/ext4/migrate.c+1−1

@@ -485,7 +485,7 @@ int ext4_ext_migrate(struct inode *inode) · 484 unmodified lines
485	* when we add extents we extent the journal	485	* when we add extents we extent the journal
486	*/	486	*/
487	/*	487	/*
488	* Even though we take i_mutex we can still cause block	488	* Even though we take i_rwsem we can still cause block
489	* allocation via mmap write to holes. If we have allocated	489	* allocation via mmap write to holes. If we have allocated
490	* new blocks we fail migrate. New block allocation will	490	* new blocks we fail migrate. New block allocation will
491	* clear EXT4_STATE_EXT_MIGRATE flag. The flag is updated	491	* clear EXT4_STATE_EXT_MIGRATE flag. The flag is updated

fs/ext4/namei.c+2−2

@@ -3889,7 +3889,7 @@ static int ext4_rename(struct user_namespace mnt_userns, struct inode old_dir, · 3888 unmodified lines
3889	* dirents in directories.	3889	* dirents in directories.
3890	*/	3890	*/
3891	ext4_fc_mark_ineligible(old.inode->i_sb,	3891	ext4_fc_mark_ineligible(old.inode->i_sb,
3892	EXT4_FC_REASON_RENAME_DIR);	3892	EXT4_FC_REASON_RENAME_DIR, handle);
3893	} else {	3893	} else {
3894	if (new.inode)	3894	if (new.inode)
3895	ext4_fc_track_unlink(handle, new.dentry);	3895	ext4_fc_track_unlink(handle, new.dentry);
@@ -4049,7 +4049,7 @@ static int ext4_cross_rename(struct inode old_dir, struct dentry old_dentry, · 153 unmodified lines
4049	if (unlikely(retval))	4049	if (unlikely(retval))
4050	goto end_rename;	4050	goto end_rename;
4051	ext4_fc_mark_ineligible(new.inode->i_sb,	4051	ext4_fc_mark_ineligible(new.inode->i_sb,
4052	EXT4_FC_REASON_CROSS_RENAME);	4052	EXT4_FC_REASON_CROSS_RENAME, handle);
4053	if (old.dir_bh) {	4053	if (old.dir_bh) {
4054	retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);	4054	retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4055	if (retval)	4055	if (retval)

fs/ext4/orphan.c+2−2

@@ -93,7 +93,7 @@ static int ext4_orphan_file_add(handle_t handle, struct inode inode) · 92 unmodified lines
93	* At filesystem recovery time, we walk this list deleting unlinked	93	* At filesystem recovery time, we walk this list deleting unlinked
94	* inodes and truncating linked inodes in ext4_orphan_cleanup().	94	* inodes and truncating linked inodes in ext4_orphan_cleanup().
95	*	95	*
96	* Orphan list manipulation functions must be called under i_mutex unless	96	* Orphan list manipulation functions must be called under i_rwsem unless
97	* we are just creating the inode or deleting it.	97	* we are just creating the inode or deleting it.
98	*/	98	*/
99	int ext4_orphan_add(handle_t handle, struct inode inode)	99	int ext4_orphan_add(handle_t handle, struct inode inode)
@@ -119,7 +119,7 @@ int ext4_orphan_add(handle_t handle, struct inode inode) · 19 unmodified lines
119	/*	119	/*
120	* Orphan handling is only valid for files with data blocks	120	* Orphan handling is only valid for files with data blocks
121	* being truncated, or files being unlinked. Note that we either	121	* being truncated, or files being unlinked. Note that we either
122	* hold i_mutex, or the inode can not be referenced from outside,	122	* hold i_rwsem, or the inode can not be referenced from outside,
123	* so i_nlink should not be bumped due to race	123	* so i_nlink should not be bumped due to race
124	*/	124	*/
125	ASSERT((S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\|	125	ASSERT((S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\|

fs/ext4/super.c+2−2

@@ -5082,7 +5082,7 @@ static int __ext4_fill_super(struct fs_context fc, struct super_block sb) · 5081 unmodified lines
5082	INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);	5082	INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
5083	sbi->s_fc_bytes = 0;	5083	sbi->s_fc_bytes = 0;
5084	ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);	5084	ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
5085	ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);	5085	sbi->s_fc_ineligible_tid = 0;
5086	spin_lock_init(&sbi->s_fc_lock);	5086	spin_lock_init(&sbi->s_fc_lock);
5087	memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));	5087	memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
5088	sbi->s_fc_replay_state.fc_regions = NULL;	5088	sbi->s_fc_replay_state.fc_regions = NULL;
@@ -5540,7 +5540,7 @@ static int ext4_fill_super(struct super_block sb, struct fs_context fc) · 451 unmodified lines
5540		5540
5541	sbi = ext4_alloc_sbi(sb);	5541	sbi = ext4_alloc_sbi(sb);
5542	if (!sbi)	5542	if (!sbi)
5543	ret = -ENOMEM;	5543	return -ENOMEM;
5544		5544
5545	fc->s_fs_info = sbi;	5545	fc->s_fs_info = sbi;
5546		5546

fs/ext4/xattr.c+3−3

@@ -2408,7 +2408,7 @@ retry_inode: · 2407 unmodified lines
2408	if (IS_SYNC(inode))	2408	if (IS_SYNC(inode))
2409	ext4_handle_sync(handle);	2409	ext4_handle_sync(handle);
2410	}	2410	}
2411	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);	2411	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);
2412		2412
2413	cleanup:	2413	cleanup:
2414	brelse(is.iloc.bh);	2414	brelse(is.iloc.bh);
@@ -2486,7 +2486,7 @@ retry: · 71 unmodified lines
2486	if (error == 0)	2486	if (error == 0)
2487	error = error2;	2487	error = error2;
2488	}	2488	}
2489	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);	2489	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, NULL);
2490		2490
2491	return error;	2491	return error;
2492	}	2492	}
@@ -2920,7 +2920,7 @@ int ext4_xattr_delete_inode(handle_t handle, struct inode inode, · 427 unmodified lines
2920	error);	2920	error);
2921	goto cleanup;	2921	goto cleanup;
2922	}	2922	}
2923	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR);	2923	ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);
2924	}	2924	}
2925	error = 0;	2925	error = 0;
2926	cleanup:	2926	cleanup:

fs/file_table.c+2−0

 static int __init init_fs_stat_sysctls(void)
 {
 	register_sysctl_init("fs", fs_stat_sysctls);
+	if (IS_ENABLED(CONFIG_BINFMT_MISC))
+		register_sysctl_mount_point("fs/binfmt_misc");
 	return 0;
 }
 fs_initcall(init_fs_stat_sysctls);

fs/iomap/buffered-io.c+48−4

 #include "../internal.h"
+#define IOEND_BATCH_SIZE	4096
 /*
  * Structure allocated for each folio when block size < folio size
  * to track sub-folio uptodate status and I/O completions.
  * state, release holds on bios, and finally free up memory.  Do not use the
  * ioend after this.
  */
-static void
+static u32
 iomap_finish_ioend(struct iomap_ioend *ioend, int error)
 {
 	struct inode *inode = ioend->io_inode;
 	u64 start = bio->bi_iter.bi_sector;
 	loff_t offset = ioend->io_offset;
 	bool quiet = bio_flagged(bio, BIO_QUIET);
+	u32 folio_count = 0;
 	for (bio = &ioend->io_inline_bio; bio; bio = next) {
 		struct folio_iter fi;
 			next = bio->bi_private;
 		/* walk all folios in bio, ending page IO on them */
-		bio_for_each_folio_all(fi, bio)
+		bio_for_each_folio_all(fi, bio) {
 			iomap_finish_folio_write(inode, fi.folio, fi.length,
 					error);
+			folio_count++;
+		}
 		bio_put(bio);
 	}
 	/* The ioend has been freed by bio_put() */
 "%s: writeback error on inode %lu, offset %lld, sector %llu",
 			inode->i_sb->s_id, inode->i_ino, offset, start);
 	}
+	return folio_count;
 }
+/*
+ * Ioend completion routine for merged bios. This can only be called from task
+ * contexts as merged ioends can be of unbound length. Hence we have to break up
+ * the writeback completions into manageable chunks to avoid long scheduler
+ * holdoffs. We aim to keep scheduler holdoffs down below 10ms so that we get
+ * good batch processing throughput without creating adverse scheduler latency
+ * conditions.
+ */
 void
 iomap_finish_ioends(struct iomap_ioend *ioend, int error)
 {
 	struct list_head tmp;
+	u32 completions;
+	might_sleep();
 	list_replace_init(&ioend->io_list, &tmp);
-	iomap_finish_ioend(ioend, error);
+	completions = iomap_finish_ioend(ioend, error);
 	while (!list_empty(&tmp)) {
+		if (completions > IOEND_BATCH_SIZE * 8) {
+			cond_resched();
+			completions = 0;
+		}
 		ioend = list_first_entry(&tmp, struct iomap_ioend, io_list);
 		list_del_init(&ioend->io_list);
-		iomap_finish_ioend(ioend, error);
+		completions += iomap_finish_ioend(ioend, error);
 	}
 }
 EXPORT_SYMBOL_GPL(iomap_finish_ioends);
 		return false;
 	if (ioend->io_offset + ioend->io_size != next->io_offset)
 		return false;
+	/*
+	 * Do not merge physically discontiguous ioends. The filesystem
+	 * completion functions will have to iterate the physical
+	 * discontiguities even if we merge the ioends at a logical level, so
+	 * we don't gain anything by merging physical discontiguities here.
+	 *
+	 * We cannot use bio->bi_iter.bi_sector here as it is modified during
+	 * submission so does not point to the start sector of the bio at
+	 * completion.
+	 */
+	if (ioend->io_sector + (ioend->io_size >> 9) != next->io_sector)
+		return false;
 	return true;
 }
 	ioend->io_flags = wpc->iomap.flags;
 	ioend->io_inode = inode;
 	ioend->io_size = 0;
+	ioend->io_folios = 0;
 	ioend->io_offset = offset;
 	ioend->io_bio = bio;
+	ioend->io_sector = sector;
 	return ioend;
 }
 		return false;
 	if (sector != bio_end_sector(wpc->ioend->io_bio))
 		return false;
+	/*
+	 * Limit ioend bio chain lengths to minimise IO completion latency. This
+	 * also prevents long tight loops ending page writeback on all the
+	 * folios in the ioend.
+	 */
+	if (wpc->ioend->io_folios >= IOEND_BATCH_SIZE)
+		return false;
 	return true;
 }
 				 &submit_list);
 		count++;
 	}
+	if (count)
+		wpc->ioend->io_folios++;
 	WARN_ON_ONCE(!wpc->ioend && !list_empty(&submit_list));
 	WARN_ON_ONCE(!folio_test_locked(folio));

fs/jbd2/commit.c+4−17

 	stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
 					      stats.run.rs_locked);
-	spin_lock(&commit_transaction->t_handle_lock);
+	// waits for any t_updates to finish
-	while (atomic_read(&commit_transaction->t_updates)) {
+	jbd2_journal_wait_updates(journal);
-		DEFINE_WAIT(wait);
-		prepare_to_wait(&journal->j_wait_updates, &wait,
-					TASK_UNINTERRUPTIBLE);
-		if (atomic_read(&commit_transaction->t_updates)) {
-			spin_unlock(&commit_transaction->t_handle_lock);
-			write_unlock(&journal->j_state_lock);
-			schedule();
-			write_lock(&journal->j_state_lock);
-			spin_lock(&commit_transaction->t_handle_lock);
-		}
-		finish_wait(&journal->j_wait_updates, &wait);
-	}
-	spin_unlock(&commit_transaction->t_handle_lock);
 	commit_transaction->t_state = T_SWITCH;
 	write_unlock(&journal->j_state_lock);
 	commit_transaction->t_state = T_COMMIT_DFLUSH;
 	write_unlock(&journal->j_state_lock);
 	/*
 	 * If the journal is not located on the file system device,
 	 * then we must flush the file system device before we issue
 	 * the commit record
 	if (journal->j_commit_callback)
 		journal->j_commit_callback(journal, commit_transaction);
 	if (journal->j_fc_cleanup_callback)
-		journal->j_fc_cleanup_callback(journal, 1);
+		journal->j_fc_cleanup_callback(journal, 1, commit_transaction->t_tid);
 	trace_jbd2_end_commit(journal, commit_transaction);
 	jbd_debug(1, "JBD2: commit %d complete, head %d\n",

fs/jbd2/journal.c+5−1

 {
 	jbd2_journal_unlock_updates(journal);
 	if (journal->j_fc_cleanup_callback)
-		journal->j_fc_cleanup_callback(journal, 0);
+		journal->j_fc_cleanup_callback(journal, 0, tid);
 	write_lock(&journal->j_state_lock);
 	journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
 	if (fallback)
 /**
  * jbd2_journal_shrink_scan()
+ * @shrink: shrinker to work on
+ * @sc: reclaim request to process
  *
  * Scan the checkpointed buffer on the checkpoint list and release the
  * journal_head.
 /**
  * jbd2_journal_shrink_count()
+ * @shrink: shrinker to work on
+ * @sc: reclaim request to process
  *
  * Count the number of checkpoint buffers on the checkpoint list.
  */

fs/jbd2/transaction.c+32−21

 	}
 	/* OK, account for the buffers that this operation expects to
 	 * use and add the handle to the running transaction.
 	 */
 	update_t_max_wait(transaction, ts);
 	handle->h_transaction = transaction;
 }
 EXPORT_SYMBOL(jbd2_journal_restart);
+/*
+ * Waits for any outstanding t_updates to finish.
+ * This is called with write j_state_lock held.
+ */
+void jbd2_journal_wait_updates(journal_t *journal)
+{
+	transaction_t *commit_transaction = journal->j_running_transaction;
+	if (!commit_transaction)
+		return;
+	spin_lock(&commit_transaction->t_handle_lock);
+	while (atomic_read(&commit_transaction->t_updates)) {
+		DEFINE_WAIT(wait);
+		prepare_to_wait(&journal->j_wait_updates, &wait,
+					TASK_UNINTERRUPTIBLE);
+		if (atomic_read(&commit_transaction->t_updates)) {
+			spin_unlock(&commit_transaction->t_handle_lock);
+			write_unlock(&journal->j_state_lock);
+			schedule();
+			write_lock(&journal->j_state_lock);
+			spin_lock(&commit_transaction->t_handle_lock);
+		}
+		finish_wait(&journal->j_wait_updates, &wait);
+	}
+	spin_unlock(&commit_transaction->t_handle_lock);
+}
 /**
  * jbd2_journal_lock_updates () - establish a transaction barrier.
  * @journal:  Journal to establish a barrier on.
 		write_lock(&journal->j_state_lock);
 	}
-	/* Wait until there are no running updates */
+	/* Wait until there are no running t_updates */
-	while (1) {
+	jbd2_journal_wait_updates(journal);
-		transaction_t *transaction = journal->j_running_transaction;
-		if (!transaction)
-			break;
-		spin_lock(&transaction->t_handle_lock);
-		prepare_to_wait(&journal->j_wait_updates, &wait,
-				TASK_UNINTERRUPTIBLE);
-		if (!atomic_read(&transaction->t_updates)) {
-			spin_unlock(&transaction->t_handle_lock);
-			finish_wait(&journal->j_wait_updates, &wait);
-			break;
-		}
-		spin_unlock(&transaction->t_handle_lock);
-		write_unlock(&journal->j_state_lock);
-		schedule();
-		finish_wait(&journal->j_wait_updates, &wait);
-		write_lock(&journal->j_state_lock);
-	}
 	write_unlock(&journal->j_state_lock);
 	/*

fs/ksmbd/auth.c+27−0

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include "mgmt/user_config.h"	29	#include "mgmt/user_config.h"
30	#include "crypto_ctx.h"	30	#include "crypto_ctx.h"
31	#include "transport_ipc.h"	31	#include "transport_ipc.h"
		32	#include "../smbfs_common/arc4.h"
32		33
33	/*	34	/*
34	* Fixed format data defining GSS header and fixed string	35	* Fixed format data defining GSS header and fixed string
@@ -336,6 +337,29 @@ int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob, · 301 unmodified lines
336	nt_len - CIFS_ENCPWD_SIZE,	337	nt_len - CIFS_ENCPWD_SIZE,
337	domain_name, conn->ntlmssp.cryptkey);	338	domain_name, conn->ntlmssp.cryptkey);
338	kfree(domain_name);	339	kfree(domain_name);
		340
		341	/* The recovered secondary session key */
		342	if (conn->ntlmssp.client_flags & NTLMSSP_NEGOTIATE_KEY_XCH) {
		343	struct arc4_ctx *ctx_arc4;
		344	unsigned int sess_key_off, sess_key_len;
		345
		346	sess_key_off = le32_to_cpu(authblob->SessionKey.BufferOffset);
		347	sess_key_len = le16_to_cpu(authblob->SessionKey.Length);
		348
		349	if (blob_len < (u64)sess_key_off + sess_key_len)
		350	return -EINVAL;
		351
		352	ctx_arc4 = kmalloc(sizeof(*ctx_arc4), GFP_KERNEL);
		353	if (!ctx_arc4)
		354	return -ENOMEM;
		355
		356	cifs_arc4_setkey(ctx_arc4, sess->sess_key,
		357	SMB2_NTLMV2_SESSKEY_SIZE);
		358	cifs_arc4_crypt(ctx_arc4, sess->sess_key,
		359	(char *)authblob + sess_key_off, sess_key_len);
		360	kfree_sensitive(ctx_arc4);
		361	}
		362
339	return ret;	363	return ret;
340	}	364	}
341		365
@@ -408,6 +432,9 @@ ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob, · 66 unmodified lines
408	(cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))	432	(cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
409	flags \|= NTLMSSP_NEGOTIATE_EXTENDED_SEC;	433	flags \|= NTLMSSP_NEGOTIATE_EXTENDED_SEC;
410		434
		435	if (cflags & NTLMSSP_NEGOTIATE_KEY_XCH)
		436	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;
		437
411	chgblob->NegotiateFlags = cpu_to_le32(flags);	438	chgblob->NegotiateFlags = cpu_to_le32(flags);
412	len = strlen(ksmbd_netbios_name());	439	len = strlen(ksmbd_netbios_name());
413	name = kmalloc(2 + UNICODE_LEN(len), GFP_KERNEL);	440	name = kmalloc(2 + UNICODE_LEN(len), GFP_KERNEL);

fs/ksmbd/smb2pdu.c+35−10

@@ -2688,7 +2688,7 @@ int smb2_open(struct ksmbd_work *work) · 2687 unmodified lines
2688	(struct create_posix *)context;	2688	(struct create_posix *)context;
2689	if (le16_to_cpu(context->DataOffset) +	2689	if (le16_to_cpu(context->DataOffset) +
2690	le32_to_cpu(context->DataLength) <	2690	le32_to_cpu(context->DataLength) <
2691	sizeof(struct create_posix)) {	2691	sizeof(struct create_posix) - 4) {
2692	rc = -EINVAL;	2692	rc = -EINVAL;
2693	goto err_out1;	2693	goto err_out1;
2694	}	2694	}
@@ -3422,9 +3422,9 @@ static int smb2_populate_readdir_entry(struct ksmbd_conn *conn, int info_level, · 727 unmodified lines
3422	goto free_conv_name;	3422	goto free_conv_name;
3423	}	3423	}
3424		3424
3425	struct_sz = readdir_info_level_struct_sz(info_level);	3425	struct_sz = readdir_info_level_struct_sz(info_level) - 1 + conv_len;
3426	next_entry_offset = ALIGN(struct_sz - 1 + conv_len,	3426	next_entry_offset = ALIGN(struct_sz, KSMBD_DIR_INFO_ALIGNMENT);
3427	KSMBD_DIR_INFO_ALIGNMENT);	3427	d_info->last_entry_off_align = next_entry_offset - struct_sz;
3428		3428
3429	if (next_entry_offset > d_info->out_buf_len) {	3429	if (next_entry_offset > d_info->out_buf_len) {
3430	d_info->out_buf_len = 0;	3430	d_info->out_buf_len = 0;
@@ -3976,6 +3976,7 @@ int smb2_query_dir(struct ksmbd_work *work) · 545 unmodified lines
3976	((struct file_directory_info *)	3976	((struct file_directory_info *)
3977	((char *)rsp->Buffer + d_info.last_entry_offset))	3977	((char *)rsp->Buffer + d_info.last_entry_offset))
3978	->NextEntryOffset = 0;	3978	->NextEntryOffset = 0;
		3979	d_info.data_count -= d_info.last_entry_off_align;
3979		3980
3980	rsp->StructureSize = cpu_to_le16(9);	3981	rsp->StructureSize = cpu_to_le16(9);
3981	rsp->OutputBufferOffset = cpu_to_le16(72);	3982	rsp->OutputBufferOffset = cpu_to_le16(72);
@@ -6126,13 +6127,26 @@ static int smb2_set_remote_key_for_rdma(struct ksmbd_work *work, · 2144 unmodified lines
6126	__le16 ChannelInfoOffset,	6127	__le16 ChannelInfoOffset,
6127	__le16 ChannelInfoLength)	6128	__le16 ChannelInfoLength)
6128	{	6129	{
		6130	unsigned int i, ch_count;
		6131
6129	if (work->conn->dialect == SMB30_PROT_ID &&	6132	if (work->conn->dialect == SMB30_PROT_ID &&
6130	Channel != SMB2_CHANNEL_RDMA_V1)	6133	Channel != SMB2_CHANNEL_RDMA_V1)
6131	return -EINVAL;	6134	return -EINVAL;
6132		6135
6133	if (ChannelInfoOffset == 0 \|\|	6136	ch_count = le16_to_cpu(ChannelInfoLength) / sizeof(*desc);
6134	le16_to_cpu(ChannelInfoLength) < sizeof(*desc))	6137	if (ksmbd_debug_types & KSMBD_DEBUG_RDMA) {
		6138	for (i = 0; i < ch_count; i++) {
		6139	pr_info("RDMA r/w request %#x: token %#x, length %#x\n",
		6140	i,
		6141	le32_to_cpu(desc[i].token),
		6142	le32_to_cpu(desc[i].length));
		6143	}
		6144	}
		6145	if (ch_count != 1) {
		6146	ksmbd_debug(RDMA, "RDMA multiple buffer descriptors %d are not supported yet\n",
		6147	ch_count);
6135	return -EINVAL;	6148	return -EINVAL;
		6149	}
6136		6150
6137	work->need_invalidate_rkey =	6151	work->need_invalidate_rkey =
6138	(Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE);	6152	(Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE);
@@ -6185,9 +6199,15 @@ int smb2_read(struct ksmbd_work *work) · 46 unmodified lines
6185		6199
6186	if (req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE \|\|	6200	if (req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE \|\|
6187	req->Channel == SMB2_CHANNEL_RDMA_V1) {	6201	req->Channel == SMB2_CHANNEL_RDMA_V1) {
		6202	unsigned int ch_offset = le16_to_cpu(req->ReadChannelInfoOffset);
		6203
		6204	if (ch_offset < offsetof(struct smb2_read_req, Buffer)) {
		6205	err = -EINVAL;
		6206	goto out;
		6207	}
6188	err = smb2_set_remote_key_for_rdma(work,	6208	err = smb2_set_remote_key_for_rdma(work,
6189	(struct smb2_buffer_desc_v1 *)	6209	(struct smb2_buffer_desc_v1 *)
6190	&req->Buffer[0],	6210	((char *)req + ch_offset),
6191	req->Channel,	6211	req->Channel,
6192	req->ReadChannelInfoOffset,	6212	req->ReadChannelInfoOffset,
6193	req->ReadChannelInfoLength);	6213	req->ReadChannelInfoLength);
@@ -6428,11 +6448,16 @@ int smb2_write(struct ksmbd_work *work) · 234 unmodified lines
6428		6448
6429	if (req->Channel == SMB2_CHANNEL_RDMA_V1 \|\|	6449	if (req->Channel == SMB2_CHANNEL_RDMA_V1 \|\|
6430	req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE) {	6450	req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE) {
6431	if (req->Length != 0 \|\| req->DataOffset != 0)	6451	unsigned int ch_offset = le16_to_cpu(req->WriteChannelInfoOffset);
6432	return -EINVAL;	6452
		6453	if (req->Length != 0 \|\| req->DataOffset != 0 \|\|
		6454	ch_offset < offsetof(struct smb2_write_req, Buffer)) {
		6455	err = -EINVAL;
		6456	goto out;
		6457	}
6433	err = smb2_set_remote_key_for_rdma(work,	6458	err = smb2_set_remote_key_for_rdma(work,
6434	(struct smb2_buffer_desc_v1 *)	6459	(struct smb2_buffer_desc_v1 *)
6435	&req->Buffer[0],	6460	((char *)req + ch_offset),
6436	req->Channel,	6461	req->Channel,
6437	req->WriteChannelInfoOffset,	6462	req->WriteChannelInfoOffset,
6438	req->WriteChannelInfoLength);	6463	req->WriteChannelInfoLength);

fs/ksmbd/smb_common.c+4−1

 	for (i = 0; i < 2; i++) {
 		struct kstat kstat;
 		struct ksmbd_kstat ksmbd_kstat;
+		struct dentry *dentry;
 		if (!dir->dot_dotdot[i]) { /* fill dot entry info */
 			if (i == 0) {
 				d_info->name = ".";
 				d_info->name_len = 1;
+				dentry = dir->filp->f_path.dentry;
 			} else {
 				d_info->name = "..";
 				d_info->name_len = 2;
+				dentry = dir->filp->f_path.dentry->d_parent;
 			}
 			if (!match_pattern(d_info->name, d_info->name_len,
 			ksmbd_kstat.kstat = &kstat;
 			ksmbd_vfs_fill_dentry_attrs(work,
 						    user_ns,
-						    dir->filp->f_path.dentry->d_parent,
+						    dentry,
 						    &ksmbd_kstat);
 			rc = fn(conn, info_level, d_info, &ksmbd_kstat);
 			if (rc)

fs/ksmbd/transport_rdma.c+1−1

@@ -80,7 +80,7 @@ static int smb_direct_max_fragmented_recv_size = 1024 * 1024; · 79 unmodified lines
80	/* The maximum single-message size which can be received */	80	/* The maximum single-message size which can be received */
81	static int smb_direct_max_receive_size = 8192;	81	static int smb_direct_max_receive_size = 8192;
82		82
83	static int smb_direct_max_read_write_size = 1048512;	83	static int smb_direct_max_read_write_size = 524224;
84		84
85	static int smb_direct_max_outstanding_rw_ops = 8;	85	static int smb_direct_max_outstanding_rw_ops = 8;
86		86

fs/ksmbd/vfs.h+1−0

@@ -47,6 +47,7 @@ struct ksmbd_dir_info { · 46 unmodified lines
47	int last_entry_offset;	47	int last_entry_offset;
48	bool hide_dot_file;	48	bool hide_dot_file;
49	int flags;	49	int flags;
		50	int last_entry_off_align;
50	};	51	};
51		52
52	struct ksmbd_readdir_data {	53	struct ksmbd_readdir_data {

fs/nfs/client.c+1−1

 	INIT_LIST_HEAD(&clp->cl_superblocks);
 	clp->cl_rpcclient = ERR_PTR(-EINVAL);
+	clp->cl_flags = cl_init->init_flags;
 	clp->cl_proto = cl_init->proto;
 	clp->cl_nconnect = cl_init->nconnect;
 	clp->cl_max_connect = cl_init->max_connect ? cl_init->max_connect : 1;
 			list_add_tail(&new->cl_share_link,
 					&nn->nfs_client_list);
 			spin_unlock(&nn->nfs_client_lock);
-			new->cl_flags = cl_init->init_flags;
 			return rpc_ops->init_client(new, cl_init);
 		}

fs/nfs/dir.c+18−6

@@ -80,6 +80,7 @@ static struct nfs_open_dir_context alloc_nfs_open_dir_context(struct inode dir · 79 unmodified lines
80	ctx->dir_cookie = 0;	80	ctx->dir_cookie = 0;
81	ctx->dup_cookie = 0;	81	ctx->dup_cookie = 0;
82	ctx->page_index = 0;	82	ctx->page_index = 0;
		83	ctx->eof = false;
83	spin_lock(&dir->i_lock);	84	spin_lock(&dir->i_lock);
84	if (list_empty(&nfsi->open_files) &&	85	if (list_empty(&nfsi->open_files) &&
85	(nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))	86	(nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
@@ -168,6 +169,7 @@ struct nfs_readdir_descriptor { · 82 unmodified lines
168	unsigned int cache_entry_index;	169	unsigned int cache_entry_index;
169	signed char duped;	170	signed char duped;
170	bool plus;	171	bool plus;
		172	bool eob;
171	bool eof;	173	bool eof;
172	};	174	};
173		175
@@ -867,7 +869,8 @@ static int nfs_readdir_xdr_to_array(struct nfs_readdir_descriptor *desc, · 693 unmodified lines
867		869
868	status = nfs_readdir_page_filler(desc, entry, pages, pglen,	870	status = nfs_readdir_page_filler(desc, entry, pages, pglen,
869	arrays, narrays);	871	arrays, narrays);
870	} while (!status && nfs_readdir_page_needs_filling(page));	872	} while (!status && nfs_readdir_page_needs_filling(page) &&
		873	page_mapping(page));
871		874
872	nfs_readdir_free_pages(pages, array_size);	875	nfs_readdir_free_pages(pages, array_size);
873	out:	876	out:
@@ -988,7 +991,7 @@ static void nfs_do_filldir(struct nfs_readdir_descriptor *desc, · 114 unmodified lines
988	ent = &array->array[i];	991	ent = &array->array[i];
989	if (!dir_emit(desc->ctx, ent->name, ent->name_len,	992	if (!dir_emit(desc->ctx, ent->name, ent->name_len,
990	nfs_compat_user_ino64(ent->ino), ent->d_type)) {	993	nfs_compat_user_ino64(ent->ino), ent->d_type)) {
991	desc->eof = true;	994	desc->eob = true;
992	break;	995	break;
993	}	996	}
994	memcpy(desc->verf, verf, sizeof(desc->verf));	997	memcpy(desc->verf, verf, sizeof(desc->verf));
@@ -1004,7 +1007,7 @@ static void nfs_do_filldir(struct nfs_readdir_descriptor *desc, · 9 unmodified lines
1004	desc->duped = 1;	1007	desc->duped = 1;
1005	}	1008	}
1006	if (array->page_is_eof)	1009	if (array->page_is_eof)
1007	desc->eof = true;	1010	desc->eof = !desc->eob;
1008		1011
1009	kunmap(desc->page);	1012	kunmap(desc->page);
1010	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %llu\n",	1013	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %llu\n",
@@ -1041,12 +1044,13 @@ static int uncached_readdir(struct nfs_readdir_descriptor *desc) · 30 unmodified lines
1041	goto out;	1044	goto out;
1042		1045
1043	desc->page_index = 0;	1046	desc->page_index = 0;
		1047	desc->cache_entry_index = 0;
1044	desc->last_cookie = desc->dir_cookie;	1048	desc->last_cookie = desc->dir_cookie;
1045	desc->duped = 0;	1049	desc->duped = 0;
1046		1050
1047	status = nfs_readdir_xdr_to_array(desc, desc->verf, verf, arrays, sz);	1051	status = nfs_readdir_xdr_to_array(desc, desc->verf, verf, arrays, sz);
1048		1052
1049	for (i = 0; !desc->eof && i < sz && arrays[i]; i++) {	1053	for (i = 0; !desc->eob && i < sz && arrays[i]; i++) {
1050	desc->page = arrays[i];	1054	desc->page = arrays[i];
1051	nfs_do_filldir(desc, verf);	1055	nfs_do_filldir(desc, verf);
1052	}	1056	}
@@ -1105,9 +1109,15 @@ static int nfs_readdir(struct file file, struct dir_context ctx) · 52 unmodified lines
1105	desc->duped = dir_ctx->duped;	1109	desc->duped = dir_ctx->duped;
1106	page_index = dir_ctx->page_index;	1110	page_index = dir_ctx->page_index;
1107	desc->attr_gencount = dir_ctx->attr_gencount;	1111	desc->attr_gencount = dir_ctx->attr_gencount;
		1112	desc->eof = dir_ctx->eof;
1108	memcpy(desc->verf, dir_ctx->verf, sizeof(desc->verf));	1113	memcpy(desc->verf, dir_ctx->verf, sizeof(desc->verf));
1109	spin_unlock(&file->f_lock);	1114	spin_unlock(&file->f_lock);
1110		1115
		1116	if (desc->eof) {
		1117	res = 0;
		1118	goto out_free;
		1119	}
		1120
1111	if (test_and_clear_bit(NFS_INO_FORCE_READDIR, &nfsi->flags) &&	1121	if (test_and_clear_bit(NFS_INO_FORCE_READDIR, &nfsi->flags) &&
1112	list_is_singular(&nfsi->open_files))	1122	list_is_singular(&nfsi->open_files))
1113	invalidate_mapping_pages(inode->i_mapping, page_index + 1, -1);	1123	invalidate_mapping_pages(inode->i_mapping, page_index + 1, -1);
@@ -1141,7 +1151,7 @@ static int nfs_readdir(struct file file, struct dir_context ctx) · 27 unmodified lines
1141		1151
1142	nfs_do_filldir(desc, nfsi->cookieverf);	1152	nfs_do_filldir(desc, nfsi->cookieverf);
1143	nfs_readdir_page_unlock_and_put_cached(desc);	1153	nfs_readdir_page_unlock_and_put_cached(desc);
1144	} while (!desc->eof);	1154	} while (!desc->eob && !desc->eof);
1145		1155
1146	spin_lock(&file->f_lock);	1156	spin_lock(&file->f_lock);
1147	dir_ctx->dir_cookie = desc->dir_cookie;	1157	dir_ctx->dir_cookie = desc->dir_cookie;
@@ -1149,9 +1159,10 @@ static int nfs_readdir(struct file file, struct dir_context ctx) · 1 unmodified line
1149	dir_ctx->duped = desc->duped;	1159	dir_ctx->duped = desc->duped;
1150	dir_ctx->attr_gencount = desc->attr_gencount;	1160	dir_ctx->attr_gencount = desc->attr_gencount;
1151	dir_ctx->page_index = desc->page_index;	1161	dir_ctx->page_index = desc->page_index;
		1162	dir_ctx->eof = desc->eof;
1152	memcpy(dir_ctx->verf, desc->verf, sizeof(dir_ctx->verf));	1163	memcpy(dir_ctx->verf, desc->verf, sizeof(dir_ctx->verf));
1153	spin_unlock(&file->f_lock);	1164	spin_unlock(&file->f_lock);
1154		1165	out_free:
1155	kfree(desc);	1166	kfree(desc);
1156		1167
1157	out:	1168	out:
@@ -1193,6 +1204,7 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence) · 35 unmodified lines
1193	if (offset == 0)	1204	if (offset == 0)
1194	memset(dir_ctx->verf, 0, sizeof(dir_ctx->verf));	1205	memset(dir_ctx->verf, 0, sizeof(dir_ctx->verf));
1195	dir_ctx->duped = 0;	1206	dir_ctx->duped = 0;
		1207	dir_ctx->eof = false;
1196	}	1208	}
1197	spin_unlock(&filp->f_lock);	1209	spin_unlock(&filp->f_lock);
1198	return offset;	1210	return offset;

fs/nfs/nfs4proc.c+2−1

@@ -8032,7 +8032,8 @@ static int _nfs41_proc_get_locations(struct nfs_server *server, · 8031 unmodified lines
8032		8032
8033	/**	8033	/**
8034	* nfs4_proc_get_locations - discover locations for a migrated FSID	8034	* nfs4_proc_get_locations - discover locations for a migrated FSID
8035	* @inode: inode on FSID that is migrating	8035	* @server: pointer to nfs_server to process
		8036	* @fhandle: pointer to the kernel NFS client file handle
8036	* @locations: result of query	8037	* @locations: result of query
8037	* @page: buffer	8038	* @page: buffer
8038	* @cred: credential to use for this operation	8039	* @cred: credential to use for this operation

fs/nfsd/nfs3proc.c+11−8

 	unsigned int len;
 	int v;
-	argp->count = min_t(u32, argp->count, max_blocksize);
 	dprintk("nfsd: READ(3) %s %lu bytes at %Lu\n",
 				SVCFH_fmt(&argp->fh),
 				(unsigned long) argp->count,
 				(unsigned long long) argp->offset);
+	argp->count = min_t(u32, argp->count, max_blocksize);
+	if (argp->offset > (u64)OFFSET_MAX)
+		argp->offset = (u64)OFFSET_MAX;
+	if (argp->offset + argp->count > (u64)OFFSET_MAX)
+		argp->count = (u64)OFFSET_MAX - argp->offset;
 	v = 0;
 	len = argp->count;
 	resp->pages = rqstp->rq_next_page;
 				(unsigned long long) argp->offset,
 				argp->stable? " stable" : "");
+	resp->status = nfserr_fbig;
+	if (argp->offset > (u64)OFFSET_MAX ||
+	    argp->offset + argp->len > (u64)OFFSET_MAX)
+		return rpc_success;
 	fh_copy(&resp->fh, &argp->fh);
 	resp->committed = argp->stable;
 	nvecs = svc_fill_write_vector(rqstp, &argp->payload);
 				argp->count,
 				(unsigned long long) argp->offset);
-	if (argp->offset > NFS_OFFSET_MAX) {
-		resp->status = nfserr_inval;
-		goto out;
-	}
 	fh_copy(&resp->fh, &argp->fh);
 	resp->status = nfsd_commit(rqstp, &resp->fh, argp->offset,
 				   argp->count, resp->verf);
-out:
 	return rpc_success;
 }

fs/nfsd/nfs3xdr.c+2−2

@@ -254,7 +254,7 @@ svcxdr_decode_sattr3(struct svc_rqst rqstp, struct xdr_stream xdr, · 253 unmodified lines
254	if (xdr_stream_decode_u64(xdr, &newsize) < 0)	254	if (xdr_stream_decode_u64(xdr, &newsize) < 0)
255	return false;	255	return false;
256	iap->ia_valid \|= ATTR_SIZE;	256	iap->ia_valid \|= ATTR_SIZE;
257	iap->ia_size = min_t(u64, newsize, NFS_OFFSET_MAX);	257	iap->ia_size = newsize;
258	}	258	}
259	if (xdr_stream_decode_u32(xdr, &set_it) < 0)	259	if (xdr_stream_decode_u32(xdr, &set_it) < 0)
260	return false;	260	return false;
@@ -1060,7 +1060,7 @@ svcxdr_encode_entry3_common(struct nfsd3_readdirres resp, const char name, · 799 unmodified lines
1060	return false;	1060	return false;
1061	/* cookie */	1061	/* cookie */
1062	resp->cookie_offset = dirlist->len;	1062	resp->cookie_offset = dirlist->len;
1063	if (xdr_stream_encode_u64(xdr, NFS_OFFSET_MAX) < 0)	1063	if (xdr_stream_encode_u64(xdr, OFFSET_MAX) < 0)
1064	return false;	1064	return false;
1065		1065
1066	return true;	1066	return true;

fs/nfsd/nfs4proc.c+9−4

 	__be32 status;
 	read->rd_nf = NULL;
-	if (read->rd_offset >= OFFSET_MAX)
-		return nfserr_inval;
 	trace_nfsd_read_start(rqstp, &cstate->current_fh,
 			      read->rd_offset, read->rd_length);
+	read->rd_length = min_t(u32, read->rd_length, svc_max_payload(rqstp));
+	if (read->rd_offset > (u64)OFFSET_MAX)
+		read->rd_offset = (u64)OFFSET_MAX;
+	if (read->rd_offset + read->rd_length > (u64)OFFSET_MAX)
+		read->rd_length = (u64)OFFSET_MAX - read->rd_offset;
 	/*
 	 * If we do a zero copy read, then a client will see read data
 	 * that reflects the state of the file *after* performing the
 	unsigned long cnt;
 	int nvecs;
-	if (write->wr_offset >= OFFSET_MAX)
+	if (write->wr_offset > (u64)OFFSET_MAX ||
-		return nfserr_inval;
+	    write->wr_offset + write->wr_buflen > (u64)OFFSET_MAX)
+		return nfserr_fbig;
 	cnt = write->wr_buflen;
 	trace_nfsd_write_start(rqstp, &cstate->current_fh,

fs/nfsd/nfs4xdr.c+3−7

 	p = xdr_reserve_space(xdr, 3*4 + namlen);
 	if (!p)
 		goto fail;
-	p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
+	p = xdr_encode_hyper(p, OFFSET_MAX);        /* offset of next entry */
 	p = xdr_encode_array(p, name, namlen);      /* name length & name */
 	nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
 	}
 	xdr_commit_encode(xdr);
-	maxcount = svc_max_payload(resp->rqstp);
+	maxcount = min_t(unsigned long, read->rd_length,
-	maxcount = min_t(unsigned long, maxcount,
 			 (xdr->buf->buflen - xdr->buf->len));
-	maxcount = min_t(unsigned long, maxcount, read->rd_length);
 	if (file->f_op->splice_read &&
 	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
 		return nfserr_resource;
 	xdr_commit_encode(xdr);
-	maxcount = svc_max_payload(resp->rqstp);
+	maxcount = min_t(unsigned long, read->rd_length,
-	maxcount = min_t(unsigned long, maxcount,
 			 (xdr->buf->buflen - xdr->buf->len));
-	maxcount = min_t(unsigned long, maxcount, read->rd_length);
 	count    = maxcount;
 	eof = read->rd_offset >= i_size_read(file_inode(file));

fs/nfsd/trace.h+7−7

@@ -306,14 +306,14 @@ TRACE_EVENT(nfsd_export_update, · 305 unmodified lines
306	DECLARE_EVENT_CLASS(nfsd_io_class,	306	DECLARE_EVENT_CLASS(nfsd_io_class,
307	TP_PROTO(struct svc_rqst *rqstp,	307	TP_PROTO(struct svc_rqst *rqstp,
308	struct svc_fh *fhp,	308	struct svc_fh *fhp,
309	loff_t offset,	309	u64 offset,
310	unsigned long len),	310	u32 len),
311	TP_ARGS(rqstp, fhp, offset, len),	311	TP_ARGS(rqstp, fhp, offset, len),
312	TP_STRUCT__entry(	312	TP_STRUCT__entry(
313	__field(u32, xid)	313	__field(u32, xid)
314	__field(u32, fh_hash)	314	__field(u32, fh_hash)
315	__field(loff_t, offset)	315	__field(u64, offset)
316	__field(unsigned long, len)	316	__field(u32, len)
317	),	317	),
318	TP_fast_assign(	318	TP_fast_assign(
319	__entry->xid = be32_to_cpu(rqstp->rq_xid);	319	__entry->xid = be32_to_cpu(rqstp->rq_xid);
@@ -321,7 +321,7 @@ DECLARE_EVENT_CLASS(nfsd_io_class, · 1 unmodified line
321	__entry->offset = offset;	321	__entry->offset = offset;
322	__entry->len = len;	322	__entry->len = len;
323	),	323	),
324	TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld len=%lu",	324	TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
325	__entry->xid, __entry->fh_hash,	325	__entry->xid, __entry->fh_hash,
326	__entry->offset, __entry->len)	326	__entry->offset, __entry->len)
327	)	327	)
@@ -330,8 +330,8 @@ DECLARE_EVENT_CLASS(nfsd_io_class, · 2 unmodified lines
330	DEFINE_EVENT(nfsd_io_class, nfsd_##name, \	330	DEFINE_EVENT(nfsd_io_class, nfsd_##name, \
331	TP_PROTO(struct svc_rqst *rqstp, \	331	TP_PROTO(struct svc_rqst *rqstp, \
332	struct svc_fh *fhp, \	332	struct svc_fh *fhp, \
333	loff_t offset, \	333	u64 offset, \
334	unsigned long len), \	334	u32 len), \
335	TP_ARGS(rqstp, fhp, offset, len))	335	TP_ARGS(rqstp, fhp, offset, len))
336		336
337	DEFINE_NFSD_IO_EVENT(read_start);	337	DEFINE_NFSD_IO_EVENT(read_start);

fs/nfsd/vfs.c+40−17

 			.ia_size	= iap->ia_size,
 		};
+		host_err = -EFBIG;
+		if (iap->ia_size < 0)
+			goto out_unlock;
 		host_err = notify_change(&init_user_ns, dentry, &size_attr, NULL);
 		if (host_err)
 			goto out_unlock;
 }
 #ifdef CONFIG_NFSD_V3
-/*
+/**
- * Commit all pending writes to stable storage.
+ * nfsd_commit - Commit pending writes to stable storage
+ * @rqstp: RPC request being processed
+ * @fhp: NFS filehandle
+ * @offset: raw offset from beginning of file
+ * @count: raw count of bytes to sync
+ * @verf: filled in with the server's current write verifier
  *
- * Note: we only guarantee that data that lies within the range specified
+ * Note: we guarantee that data that lies within the range specified
- * by the 'offset' and 'count' parameters will be synced.
+ * by the 'offset' and 'count' parameters will be synced. The server
+ * is permitted to sync data that lies outside this range at the
+ * same time.
  *
  * Unfortunately we cannot lock the file to make sure we return full WCC
  * data to the client, as locking happens lower down in the filesystem.
+ *
+ * Return values:
+ *   An nfsstat value in network byte order.
  */
 __be32
-nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
+nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, u64 offset,
-               loff_t offset, unsigned long count, __be32 *verf)
+	    u32 count, __be32 *verf)
 {
+	u64			maxbytes;
+	loff_t			start, end;
 	struct nfsd_net		*nn;
 	struct nfsd_file	*nf;
-	loff_t			end = LLONG_MAX;
+	__be32			err;
-	__be32			err = nfserr_inval;
-	if (offset < 0)
-		goto out;
-	if (count != 0) {
-		end = offset + (loff_t)count - 1;
-		if (end < offset)
-			goto out;
-	}
 	err = nfsd_file_acquire(rqstp, fhp,
 			NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &nf);
 	if (err)
 		goto out;
+	/*
+	 * Convert the client-provided (offset, count) range to a
+	 * (start, end) range. If the client-provided range falls
+	 * outside the maximum file size of the underlying FS,
+	 * clamp the sync range appropriately.
+	 */
+	start = 0;
+	end = LLONG_MAX;
+	maxbytes = (u64)fhp->fh_dentry->d_sb->s_maxbytes;
+	if (offset < maxbytes) {
+		start = offset;
+		if (count && (offset + count - 1 < maxbytes))
+			end = offset + count - 1;
+	}
 	nn = net_generic(nf->nf_net, nfsd_net_id);
 	if (EX_ISSYNC(fhp->fh_export)) {
 		errseq_t since = READ_ONCE(nf->nf_file->f_wb_err);
 		int err2;
-		err2 = vfs_fsync_range(nf->nf_file, offset, end, 0);
+		err2 = vfs_fsync_range(nf->nf_file, start, end, 0);
 		switch (err2) {
 		case 0:
 			nfsd_copy_write_verifier(verf, nn);

fs/nfsd/vfs.h+2−2

@@ -74,8 +74,8 @@ __be32 do_nfsd_create(struct svc_rqst , struct svc_fh , · 73 unmodified lines
74	char name, int len, struct iattr attrs,	74	char name, int len, struct iattr attrs,
75	struct svc_fh *res, int createmode,	75	struct svc_fh *res, int createmode,
76	u32 verifier, bool truncp, bool *created);	76	u32 verifier, bool truncp, bool *created);
77	__be32 nfsd_commit(struct svc_rqst , struct svc_fh ,	77	__be32 nfsd_commit(struct svc_rqst rqst, struct svc_fh fhp,
78	loff_t, unsigned long, __be32 *verf);	78	u64 offset, u32 count, __be32 *verf);
79	#endif /* CONFIG_NFSD_V3 */	79	#endif /* CONFIG_NFSD_V3 */
80	#ifdef CONFIG_NFSD_V4	80	#ifdef CONFIG_NFSD_V4
81	__be32 nfsd_getxattr(struct svc_rqst rqstp, struct svc_fh fhp,	81	__be32 nfsd_getxattr(struct svc_rqst rqstp, struct svc_fh fhp,

fs/quota/dquot.c+8−3

 	/* This is not very clever (and fast) but currently I don't know about
 	 * any other simple way of getting quota data to disk and we must get
 	 * them there for userspace to be visible... */
-	if (sb->s_op->sync_fs)
+	if (sb->s_op->sync_fs) {
-		sb->s_op->sync_fs(sb, 1);
+		ret = sb->s_op->sync_fs(sb, 1);
-	sync_blockdev(sb->s_bdev);
+		if (ret)
+			return ret;
+	}
+	ret = sync_blockdev(sb->s_bdev);
+	if (ret)
+		return ret;
 	/*
 	 * Now when everything is written we can discard the pagecache so

fs/super.c+12−7

 		percpu_rwsem_acquire(sb->s_writers.rw_sem + level, 0, _THIS_IP_);
 }
-static void sb_freeze_unlock(struct super_block *sb)
+static void sb_freeze_unlock(struct super_block *sb, int level)
 {
-	int level;
+	for (level--; level >= 0; level--)
-	for (level = SB_FREEZE_LEVELS - 1; level >= 0; level--)
 		percpu_up_write(sb->s_writers.rw_sem + level);
 }
 	sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
 	/* All writers are done so after syncing there won't be dirty data */
-	sync_filesystem(sb);
+	ret = sync_filesystem(sb);
+	if (ret) {
+		sb->s_writers.frozen = SB_UNFROZEN;
+		sb_freeze_unlock(sb, SB_FREEZE_PAGEFAULT);
+		wake_up(&sb->s_writers.wait_unfrozen);
+		deactivate_locked_super(sb);
+		return ret;
+	}
 	/* Now wait for internal filesystem counter */
 	sb->s_writers.frozen = SB_FREEZE_FS;
 			printk(KERN_ERR
 				"VFS:Filesystem freeze failed\n");
 			sb->s_writers.frozen = SB_UNFROZEN;
-			sb_freeze_unlock(sb);
+			sb_freeze_unlock(sb, SB_FREEZE_FS);
 			wake_up(&sb->s_writers.wait_unfrozen);
 			deactivate_locked_super(sb);
 			return ret;
 	}
 	sb->s_writers.frozen = SB_UNFROZEN;
-	sb_freeze_unlock(sb);
+	sb_freeze_unlock(sb, SB_FREEZE_FS);
 out:
 	wake_up(&sb->s_writers.wait_unfrozen);
 	deactivate_locked_super(sb);

fs/sync.c+12−6

  */
 int sync_filesystem(struct super_block *sb)
 {
-	int ret;
+	int ret = 0;
 	/*
 	 * We need to be protected against the filesystem going from
 	 * at a time.
 	 */
 	writeback_inodes_sb(sb, WB_REASON_SYNC);
-	if (sb->s_op->sync_fs)
+	if (sb->s_op->sync_fs) {
-		sb->s_op->sync_fs(sb, 0);
+		ret = sb->s_op->sync_fs(sb, 0);
+		if (ret)
+			return ret;
+	}
 	ret = sync_blockdev_nowait(sb->s_bdev);
-	if (ret < 0)
+	if (ret)
 		return ret;
 	sync_inodes_sb(sb);
-	if (sb->s_op->sync_fs)
+	if (sb->s_op->sync_fs) {
-		sb->s_op->sync_fs(sb, 1);
+		ret = sb->s_op->sync_fs(sb, 1);
+		if (ret)
+			return ret;
+	}
 	return sync_blockdev(sb->s_bdev);
 }
 EXPORT_SYMBOL(sync_filesystem);

fs/xfs/xfs_aops.c+15−1

@@ -136,7 +136,20 @@ done: · 135 unmodified lines
136	memalloc_nofs_restore(nofs_flag);	136	memalloc_nofs_restore(nofs_flag);
137	}	137	}
138		138
139	/* Finish all pending io completions. */	139	/*
		140	* Finish all pending IO completions that require transactional modifications.
		141	*
		142	* We try to merge physical and logically contiguous ioends before completion to
		143	* minimise the number of transactions we need to perform during IO completion.
		144	* Both unwritten extent conversion and COW remapping need to iterate and modify
		145	* one physical extent at a time, so we gain nothing by merging physically
		146	* discontiguous extents here.
		147	*
		148	* The ioend chain length that we can be processing here is largely unbound in
		149	* length and we may have to perform significant amounts of work on each ioend
		150	* to complete it. Hence we have to be careful about holding the CPU for too
		151	* long in this loop.
		152	*/
140	void	153	void
141	xfs_end_io(	154	xfs_end_io(
142	struct work_struct *work)	155	struct work_struct *work)
@@ -157,6 +170,7 @@ xfs_end_io( · 14 unmodified lines
157	list_del_init(&ioend->io_list);	170	list_del_init(&ioend->io_list);
158	iomap_ioend_try_merge(ioend, &tmp);	171	iomap_ioend_try_merge(ioend, &tmp);
159	xfs_end_ioend(ioend);	172	xfs_end_ioend(ioend);
		173	cond_resched();
160	}	174	}
161	}	175	}
162		176

fs/xfs/xfs_bmap_util.c+3−6

@@ -850,9 +850,6 @@ xfs_alloc_file_space( · 849 unmodified lines
850	rblocks = 0;	850	rblocks = 0;
851	}	851	}
852		852
853	/*
854	* Allocate and setup the transaction.
855	*/
856	error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,	853	error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
857	dblocks, rblocks, false, &tp);	854	dblocks, rblocks, false, &tp);
858	if (error)	855	if (error)
@@ -869,9 +866,9 @@ xfs_alloc_file_space( · 10 unmodified lines
869	if (error)	866	if (error)
870	goto error;	867	goto error;
871		868
872	/*	869	ip->i_diflags \|= XFS_DIFLAG_PREALLOC;
873	* Complete the transaction	870	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
874	*/	871
875	error = xfs_trans_commit(tp);	872	error = xfs_trans_commit(tp);
876	xfs_iunlock(ip, XFS_ILOCK_EXCL);	873	xfs_iunlock(ip, XFS_ILOCK_EXCL);
877	if (error)	874	if (error)

fs/xfs/xfs_file.c+26−60

 	return !((pos | len) & mask);
 }
-int
-xfs_update_prealloc_flags(
-	struct xfs_inode	*ip,
-	enum xfs_prealloc_flags	flags)
-{
-	struct xfs_trans	*tp;
-	int			error;
-	error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
-			0, 0, 0, &tp);
-	if (error)
-		return error;
-	xfs_ilock(ip, XFS_ILOCK_EXCL);
-	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-	if (!(flags & XFS_PREALLOC_INVISIBLE)) {
-		VFS_I(ip)->i_mode &= ~S_ISUID;
-		if (VFS_I(ip)->i_mode & S_IXGRP)
-			VFS_I(ip)->i_mode &= ~S_ISGID;
-		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
-	}
-	if (flags & XFS_PREALLOC_SET)
-		ip->i_diflags |= XFS_DIFLAG_PREALLOC;
-	if (flags & XFS_PREALLOC_CLEAR)
-		ip->i_diflags &= ~XFS_DIFLAG_PREALLOC;
-	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-	if (flags & XFS_PREALLOC_SYNC)
-		xfs_trans_set_sync(tp);
-	return xfs_trans_commit(tp);
-}
 /*
  * Fsync operations on directories are much simpler than on regular files,
  * as there is no file data to flush, and thus also no need for explicit
 	return error;
 }
+/* Does this file, inode, or mount want synchronous writes? */
+static inline bool xfs_file_sync_writes(struct file *filp)
+{
+	struct xfs_inode	*ip = XFS_I(file_inode(filp));
+	if (xfs_has_wsync(ip->i_mount))
+		return true;
+	if (filp->f_flags & (__O_SYNC | O_DSYNC))
+		return true;
+	if (IS_SYNC(file_inode(filp)))
+		return true;
+	return false;
+}
 #define	XFS_FALLOC_FL_SUPPORTED						\
 		(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |		\
 		 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |	\
 	struct inode		*inode = file_inode(file);
 	struct xfs_inode	*ip = XFS_I(inode);
 	long			error;
-	enum xfs_prealloc_flags	flags = 0;
 	uint			iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
 	loff_t			new_size = 0;
 	bool			do_file_insert = false;
 			goto out_unlock;
 	}
+	error = file_modified(file);
+	if (error)
+		goto out_unlock;
 	if (mode & FALLOC_FL_PUNCH_HOLE) {
 		error = xfs_free_file_space(ip, offset, len);
 		if (error)
 		}
 		do_file_insert = true;
 	} else {
-		flags |= XFS_PREALLOC_SET;
 		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
 		    offset + len > i_size_read(inode)) {
 			new_size = offset + len;
 		}
 	}
-	if (file->f_flags & O_DSYNC)
-		flags |= XFS_PREALLOC_SYNC;
-	error = xfs_update_prealloc_flags(ip, flags);
-	if (error)
-		goto out_unlock;
 	/* Change file size if needed */
 	if (new_size) {
 		struct iattr iattr;
 	 * leave shifted extents past EOF and hence losing access to
 	 * the data that is contained within them.
 	 */
-	if (do_file_insert)
+	if (do_file_insert) {
 		error = xfs_insert_file_space(ip, offset, len);
+		if (error)
+			goto out_unlock;
+	}
+	if (xfs_file_sync_writes(file))
+		error = xfs_log_force_inode(ip);
 out_unlock:
 	xfs_iunlock(ip, iolock);
 	return ret;
 }
-/* Does this file, inode, or mount want synchronous writes? */
-static inline bool xfs_file_sync_writes(struct file *filp)
-{
-	struct xfs_inode	*ip = XFS_I(file_inode(filp));
-	if (xfs_has_wsync(ip->i_mount))
-		return true;
-	if (filp->f_flags & (__O_SYNC | O_DSYNC))
-		return true;
-	if (IS_SYNC(file_inode(filp)))
-		return true;
-	return false;
-}
 STATIC loff_t
 xfs_file_remap_range(
 	struct file		*file_in,

fs/xfs/xfs_inode.h+0−9

@@ -462,15 +462,6 @@ xfs_itruncate_extents( · 461 unmodified lines
462	}	462	}
463		463
464	/* from xfs_file.c */	464	/* from xfs_file.c */
465	enum xfs_prealloc_flags {
466	XFS_PREALLOC_SET = (1 << 1),
467	XFS_PREALLOC_CLEAR = (1 << 2),
468	XFS_PREALLOC_SYNC = (1 << 3),
469	XFS_PREALLOC_INVISIBLE = (1 << 4),
470	};
471
472	int xfs_update_prealloc_flags(struct xfs_inode *ip,
473	enum xfs_prealloc_flags flags);
474	int xfs_break_layouts(struct inode inode, uint iolock,	465	int xfs_break_layouts(struct inode inode, uint iolock,
475	enum layout_break_reason reason);	466	enum layout_break_reason reason);
476		467

fs/xfs/xfs_ioctl.c+1−1

@@ -1464,7 +1464,7 @@ xfs_ioc_getbmap( · 1463 unmodified lines
1464		1464
1465	if (bmx.bmv_count < 2)	1465	if (bmx.bmv_count < 2)
1466	return -EINVAL;	1466	return -EINVAL;
1467	if (bmx.bmv_count > ULONG_MAX / recsize)	1467	if (bmx.bmv_count >= INT_MAX / recsize)
1468	return -ENOMEM;	1468	return -ENOMEM;
1469		1469
1470	buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);	1470	buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);

fs/xfs/xfs_pnfs.c+39−3

@@ -70,6 +70,40 @@ xfs_fs_get_uuid( · 69 unmodified lines
70	return 0;	70	return 0;
71	}	71	}
72		72
		73	/*
		74	* We cannot use file based VFS helpers such as file_modified() to update
		75	* inode state as we modify the data/metadata in the inode here. Hence we have
		76	* to open code the timestamp updates and SUID/SGID stripping. We also need
		77	* to set the inode prealloc flag to ensure that the extents we allocate are not
		78	* removed if the inode is reclaimed from memory before xfs_fs_block_commit()
		79	* is from the client to indicate that data has been written and the file size
		80	* can be extended.
		81	*/
		82	static int
		83	xfs_fs_map_update_inode(
		84	struct xfs_inode *ip)
		85	{
		86	struct xfs_trans *tp;
		87	int error;
		88
		89	error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
		90	0, 0, 0, &tp);
		91	if (error)
		92	return error;
		93
		94	xfs_ilock(ip, XFS_ILOCK_EXCL);
		95	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
		96
		97	VFS_I(ip)->i_mode &= ~S_ISUID;
		98	if (VFS_I(ip)->i_mode & S_IXGRP)
		99	VFS_I(ip)->i_mode &= ~S_ISGID;
		100	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD \| XFS_ICHGTIME_CHG);
		101	ip->i_diflags \|= XFS_DIFLAG_PREALLOC;
		102
		103	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
		104	return xfs_trans_commit(tp);
		105	}
		106
73	/*	107	/*
74	* Get a layout for the pNFS client.	108	* Get a layout for the pNFS client.
75	*/	109	*/
@@ -164,10 +198,12 @@ xfs_fs_map_blocks( · 88 unmodified lines
164	* that the blocks allocated and handed out to the client are	198	* that the blocks allocated and handed out to the client are
165	* guaranteed to be present even after a server crash.	199	* guaranteed to be present even after a server crash.
166	*/	200	*/
167	error = xfs_update_prealloc_flags(ip,	201	error = xfs_fs_map_update_inode(ip);
168	XFS_PREALLOC_SET \| XFS_PREALLOC_SYNC);	202	if (!error)
		203	error = xfs_log_force_inode(ip);
169	if (error)	204	if (error)
170	goto out_unlock;	205	goto out_unlock;
		206
171	} else {	207	} else {
172	xfs_iunlock(ip, lock_flags);	208	xfs_iunlock(ip, lock_flags);
173	}	209	}
@@ -255,7 +291,7 @@ xfs_fs_commit_blocks( · 81 unmodified lines
255	length = end - start;	291	length = end - start;
256	if (!length)	292	if (!length)
257	continue;	293	continue;
258		294
259	/*	295	/*
260	* Make sure reads through the pagecache see the new data.	296	* Make sure reads through the pagecache see the new data.
261	*/	297	*/

fs/xfs/xfs_super.c+5−1

 	int			wait)
 {
 	struct xfs_mount	*mp = XFS_M(sb);
+	int			error;
 	trace_xfs_fs_sync_fs(mp, __return_address);
 	if (!wait)
 		return 0;
-	xfs_log_force(mp, XFS_LOG_SYNC);
+	error = xfs_log_force(mp, XFS_LOG_SYNC);
+	if (error)
+		return error;
 	if (laptop_mode) {
 		/*
 		 * The disk must be active because we're syncing.

include/crypto/internal/blake2s.h+25−15

 	state->f[0] = -1;
 }
-typedef void (*blake2s_compress_t)(struct blake2s_state *state,
-				   const u8 *block, size_t nblocks, u32 inc);
 /* Helper functions for BLAKE2s shared by the library and shash APIs */
-static inline void __blake2s_update(struct blake2s_state *state,
+static __always_inline void
-				    const u8 *in, size_t inlen,
+__blake2s_update(struct blake2s_state *state, const u8 *in, size_t inlen,
-				    blake2s_compress_t compress)
+		 bool force_generic)
 {
 	const size_t fill = BLAKE2S_BLOCK_SIZE - state->buflen;
 		return;
 	if (inlen > fill) {
 		memcpy(state->buf + state->buflen, in, fill);
-		(*compress)(state, state->buf, 1, BLAKE2S_BLOCK_SIZE);
+		if (force_generic)
+			blake2s_compress_generic(state, state->buf, 1,
+						 BLAKE2S_BLOCK_SIZE);
+		else
+			blake2s_compress(state, state->buf, 1,
+					 BLAKE2S_BLOCK_SIZE);
 		state->buflen = 0;
 		in += fill;
 		inlen -= fill;
 	if (inlen > BLAKE2S_BLOCK_SIZE) {
 		const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2S_BLOCK_SIZE);
 		/* Hash one less (full) block than strictly possible */
-		(*compress)(state, in, nblocks - 1, BLAKE2S_BLOCK_SIZE);
+		if (force_generic)
+			blake2s_compress_generic(state, in, nblocks - 1,
+						 BLAKE2S_BLOCK_SIZE);
+		else
+			blake2s_compress(state, in, nblocks - 1,
+					 BLAKE2S_BLOCK_SIZE);
 		in += BLAKE2S_BLOCK_SIZE * (nblocks - 1);
 		inlen -= BLAKE2S_BLOCK_SIZE * (nblocks - 1);
 	}
 	state->buflen += inlen;
 }
-static inline void __blake2s_final(struct blake2s_state *state, u8 *out,
+static __always_inline void
-				   blake2s_compress_t compress)
+__blake2s_final(struct blake2s_state *state, u8 *out, bool force_generic)
 {
 	blake2s_set_lastblock(state);
 	memset(state->buf + state->buflen, 0,
 	       BLAKE2S_BLOCK_SIZE - state->buflen); /* Padding */
-	(*compress)(state, state->buf, 1, state->buflen);
+	if (force_generic)
+		blake2s_compress_generic(state, state->buf, 1, state->buflen);
+	else
+		blake2s_compress(state, state->buf, 1, state->buflen);
 	cpu_to_le32_array(state->h, ARRAY_SIZE(state->h));
 	memcpy(out, state->h, state->outlen);
 }
 static inline int crypto_blake2s_update(struct shash_desc *desc,
 					const u8 *in, unsigned int inlen,
-					blake2s_compress_t compress)
+					bool force_generic)
 {
 	struct blake2s_state *state = shash_desc_ctx(desc);
-	__blake2s_update(state, in, inlen, compress);
+	__blake2s_update(state, in, inlen, force_generic);
 	return 0;
 }
 static inline int crypto_blake2s_final(struct shash_desc *desc, u8 *out,
-				       blake2s_compress_t compress)
+				       bool force_generic)
 {
 	struct blake2s_state *state = shash_desc_ctx(desc);
-	__blake2s_final(state, out, compress);
+	__blake2s_final(state, out, force_generic);
 	return 0;
 }

include/linux/ata.h+1−1

 	ATA_LOG_NCQ_NON_DATA	= 0x12,
 	ATA_LOG_NCQ_SEND_RECV	= 0x13,
 	ATA_LOG_IDENTIFY_DEVICE	= 0x30,
+	ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47,
 	/* Identify device log pages: */
 	ATA_LOG_SECURITY	  = 0x06,
 	ATA_LOG_SATA_SETTINGS	  = 0x08,
 	ATA_LOG_ZONED_INFORMATION = 0x09,
-	ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47,
 	/* Identify device SATA settings log:*/
 	ATA_LOG_DEVSLP_OFFSET	  = 0x30,

include/linux/ceph/libceph.h+1−0

@@ -35,6 +35,7 @@ · 34 unmodified lines
35	#define CEPH_OPT_TCP_NODELAY (1<<4) /* TCP_NODELAY on TCP sockets */	35	#define CEPH_OPT_TCP_NODELAY (1<<4) /* TCP_NODELAY on TCP sockets */
36	#define CEPH_OPT_NOMSGSIGN (1<<5) /* don't sign msgs (msgr1) */	36	#define CEPH_OPT_NOMSGSIGN (1<<5) /* don't sign msgs (msgr1) */
37	#define CEPH_OPT_ABORT_ON_FULL (1<<6) /* abort w/ ENOSPC when full */	37	#define CEPH_OPT_ABORT_ON_FULL (1<<6) /* abort w/ ENOSPC when full */
		38	#define CEPH_OPT_RXBOUNCE (1<<7) /* double-buffer read data */
38		39
39	#define CEPH_OPT_DEFAULT (CEPH_OPT_TCP_NODELAY)	40	#define CEPH_OPT_DEFAULT (CEPH_OPT_TCP_NODELAY)
40		41

include/linux/ceph/messenger.h+5−0

 	struct ceph_gcm_nonce in_gcm_nonce;
 	struct ceph_gcm_nonce out_gcm_nonce;
+	struct page **in_enc_pages;
+	int in_enc_page_cnt;
+	int in_enc_resid;
+	int in_enc_i;
 	struct page **out_enc_pages;
 	int out_enc_page_cnt;
 	int out_enc_resid;
 	struct ceph_msg *out_msg;        /* sending message (== tail of
 					    out_sent) */
+	struct page *bounce_page;
 	u32 in_front_crc, in_middle_crc, in_data_crc;  /* calculated crc */
 	struct timespec64 last_keepalive_ack; /* keepalive2 ack stamp */

include/linux/fb.h+1−1

@@ -262,7 +262,7 @@ struct fb_ops { · 261 unmodified lines
262		262
263	/* Draws a rectangle */	263	/* Draws a rectangle */
264	void (fb_fillrect) (struct fb_info info, const struct fb_fillrect *rect);	264	void (fb_fillrect) (struct fb_info info, const struct fb_fillrect *rect);
265	/* Copy data from area to another. Obsolete. */	265	/* Copy data from area to another */
266	void (fb_copyarea) (struct fb_info info, const struct fb_copyarea *region);	266	void (fb_copyarea) (struct fb_info info, const struct fb_copyarea *region);
267	/* Draws a image to the display */	267	/* Draws a image to the display */
268	void (fb_imageblit) (struct fb_info info, const struct fb_image *image);	268	void (fb_imageblit) (struct fb_info info, const struct fb_image *image);

include/linux/iomap.h+2−0

 	struct list_head	io_list;	/* next ioend in chain */
 	u16			io_type;
 	u16			io_flags;	/* IOMAP_F_* */
+	u32			io_folios;	/* folios added to ioend */
 	struct inode		*io_inode;	/* file being written to */
 	size_t			io_size;	/* size of the extent */
 	loff_t			io_offset;	/* offset in the file */
+	sector_t		io_sector;	/* start sector of ioend */
 	struct bio		*io_bio;	/* bio being built */
 	struct bio		io_inline_bio;	/* MUST BE LAST! */
 };

include/linux/jbd2.h+4−9

 	 */
 	unsigned long		t_log_start;
 	/*
 	 * Number of buffers on the t_buffers list [j_list_lock, no locks
 	 * needed for jbd2 thread]
 	 */
 	 * Clean-up after fast commit or full commit. JBD2 calls this function
 	 * after every commit operation.
 	 */
-	void (*j_fc_cleanup_callback)(struct journal_s *journal, int);
+	void (*j_fc_cleanup_callback)(struct journal_s *journal, int full, tid_t tid);
 	/**
 	 * @j_fc_replay_callback:
 extern bool __jbd2_journal_refile_buffer(struct journal_head *);
 extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
 extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
-extern void __journal_free_buffer(struct journal_head *bh);
 extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
-extern void __journal_clean_data_list(transaction_t *transaction);
 static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
 {
 	list_add_tail(&bh->b_assoc_buffers, head);
 					      struct buffer_head **bh_out,
 					      sector_t blocknr);
-/* Transaction locking */
-extern void		__wait_on_journal (journal_t *);
 /* Transaction cache support */
 extern void jbd2_journal_destroy_transaction_cache(void);
 extern int __init jbd2_journal_init_transaction_cache(void);
 extern void	 jbd2_journal_lock_updates (journal_t *);
 extern void	 jbd2_journal_unlock_updates (journal_t *);
+void jbd2_journal_wait_updates(journal_t *);
 extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
 				struct block_device *fs_dev,
 				unsigned long long start, int len, int bsize);
 #define BJ_Reserved	4	/* Buffer is reserved for access by journal */
 #define BJ_Types	5
-extern int jbd_blocks_per_page(struct inode *inode);
 /* JBD uses a CRC32 checksum */
 #define JBD_MAX_CHECKSUM_SIZE 4

include/linux/kvm_host.h+109−3

@@ -29,7 +29,9 @@ · 28 unmodified lines
29	#include <linux/refcount.h>	29	#include <linux/refcount.h>
30	#include <linux/nospec.h>	30	#include <linux/nospec.h>
31	#include <linux/notifier.h>	31	#include <linux/notifier.h>
		32	#include <linux/ftrace.h>
32	#include <linux/hashtable.h>	33	#include <linux/hashtable.h>
		34	#include <linux/instrumentation.h>
33	#include <linux/interval_tree.h>	35	#include <linux/interval_tree.h>
34	#include <linux/rbtree.h>	36	#include <linux/rbtree.h>
35	#include <linux/xarray.h>	37	#include <linux/xarray.h>
@@ -368,8 +370,11 @@ struct kvm_vcpu { · 332 unmodified lines
368	u64 last_used_slot_gen;	370	u64 last_used_slot_gen;
369	};	371	};
370		372
371	/* must be called with irqs disabled */	373	/*
372	static __always_inline void guest_enter_irqoff(void)	374	* Start accounting time towards a guest.
		375	* Must be called before entering guest context.
		376	*/
		377	static __always_inline void guest_timing_enter_irqoff(void)
373	{	378	{
374	/*	379	/*
375	* This is running in ioctl context so its safe to assume that it's the	380	* This is running in ioctl context so its safe to assume that it's the
@@ -378,7 +383,18 @@ static __always_inline void guest_enter_irqoff(void) · 2 unmodified lines
378	instrumentation_begin();	383	instrumentation_begin();
379	vtime_account_guest_enter();	384	vtime_account_guest_enter();
380	instrumentation_end();	385	instrumentation_end();
		386	}
381		387
		388	/*
		389	* Enter guest context and enter an RCU extended quiescent state.
		390	*
		391	* Between guest_context_enter_irqoff() and guest_context_exit_irqoff() it is
		392	* unsafe to use any code which may directly or indirectly use RCU, tracing
		393	* (including IRQ flag tracing), or lockdep. All code in this period must be
		394	* non-instrumentable.
		395	*/
		396	static __always_inline void guest_context_enter_irqoff(void)
		397	{
382	/*	398	/*
383	* KVM does not hold any references to rcu protected data when it	399	* KVM does not hold any references to rcu protected data when it
384	* switches CPU into a guest mode. In fact switching to a guest mode	400	* switches CPU into a guest mode. In fact switching to a guest mode
@@ -394,16 +410,79 @@ static __always_inline void guest_enter_irqoff(void) · 9 unmodified lines
394	}	410	}
395	}	411	}
396		412
397	static __always_inline void guest_exit_irqoff(void)	413	/*
		414	* Deprecated. Architectures should move to guest_timing_enter_irqoff() and
		415	* guest_state_enter_irqoff().
		416	*/
		417	static __always_inline void guest_enter_irqoff(void)
		418	{
		419	guest_timing_enter_irqoff();
		420	guest_context_enter_irqoff();
		421	}
		422
		423	/**
		424	* guest_state_enter_irqoff - Fixup state when entering a guest
		425	*
		426	* Entry to a guest will enable interrupts, but the kernel state is interrupts
		427	* disabled when this is invoked. Also tell RCU about it.
		428	*
		429	* 1) Trace interrupts on state
		430	* 2) Invoke context tracking if enabled to adjust RCU state
		431	* 3) Tell lockdep that interrupts are enabled
		432	*
		433	* Invoked from architecture specific code before entering a guest.
		434	* Must be called with interrupts disabled and the caller must be
		435	* non-instrumentable.
		436	* The caller has to invoke guest_timing_enter_irqoff() before this.
		437	*
		438	* Note: this is analogous to exit_to_user_mode().
		439	*/
		440	static __always_inline void guest_state_enter_irqoff(void)
		441	{
		442	instrumentation_begin();
		443	trace_hardirqs_on_prepare();
		444	lockdep_hardirqs_on_prepare(CALLER_ADDR0);
		445	instrumentation_end();
		446
		447	guest_context_enter_irqoff();
		448	lockdep_hardirqs_on(CALLER_ADDR0);
		449	}
		450
		451	/*
		452	* Exit guest context and exit an RCU extended quiescent state.
		453	*
		454	* Between guest_context_enter_irqoff() and guest_context_exit_irqoff() it is
		455	* unsafe to use any code which may directly or indirectly use RCU, tracing
		456	* (including IRQ flag tracing), or lockdep. All code in this period must be
		457	* non-instrumentable.
		458	*/
		459	static __always_inline void guest_context_exit_irqoff(void)
398	{	460	{
399	context_tracking_guest_exit();	461	context_tracking_guest_exit();
		462	}
400		463
		464	/*
		465	* Stop accounting time towards a guest.
		466	* Must be called after exiting guest context.
		467	*/
		468	static __always_inline void guest_timing_exit_irqoff(void)
		469	{
401	instrumentation_begin();	470	instrumentation_begin();
402	/* Flush the guest cputime we spent on the guest */	471	/* Flush the guest cputime we spent on the guest */
403	vtime_account_guest_exit();	472	vtime_account_guest_exit();
404	instrumentation_end();	473	instrumentation_end();
405	}	474	}
406		475
		476	/*
		477	* Deprecated. Architectures should move to guest_state_exit_irqoff() and
		478	* guest_timing_exit_irqoff().
		479	*/
		480	static __always_inline void guest_exit_irqoff(void)
		481	{
		482	guest_context_exit_irqoff();
		483	guest_timing_exit_irqoff();
		484	}
		485
407	static inline void guest_exit(void)	486	static inline void guest_exit(void)
408	{	487	{
409	unsigned long flags;	488	unsigned long flags;
@@ -413,6 +492,33 @@ static inline void guest_exit(void) · 3 unmodified lines
413	local_irq_restore(flags);	492	local_irq_restore(flags);
414	}	493	}
415		494
		495	/**
		496	* guest_state_exit_irqoff - Establish state when returning from guest mode
		497	*
		498	* Entry from a guest disables interrupts, but guest mode is traced as
		499	* interrupts enabled. Also with NO_HZ_FULL RCU might be idle.
		500	*
		501	* 1) Tell lockdep that interrupts are disabled
		502	* 2) Invoke context tracking if enabled to reactivate RCU
		503	* 3) Trace interrupts off state
		504	*
		505	* Invoked from architecture specific code after exiting a guest.
		506	* Must be invoked with interrupts disabled and the caller must be
		507	* non-instrumentable.
		508	* The caller has to invoke guest_timing_exit_irqoff() after this.
		509	*
		510	* Note: this is analogous to enter_from_user_mode().
		511	*/
		512	static __always_inline void guest_state_exit_irqoff(void)
		513	{
		514	lockdep_hardirqs_off(CALLER_ADDR0);
		515	guest_context_exit_irqoff();
		516
		517	instrumentation_begin();
		518	trace_hardirqs_off_finish();
		519	instrumentation_end();
		520	}
		521
416	static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)	522	static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
417	{	523	{
418	/*	524	/*

include/linux/libata.h+1−0

@@ -380,6 +380,7 @@ enum { · 379 unmodified lines
380	ATA_HORKAGE_MAX_TRIM_128M = (1 << 26), /* Limit max trim size to 128M */	380	ATA_HORKAGE_MAX_TRIM_128M = (1 << 26), /* Limit max trim size to 128M */
381	ATA_HORKAGE_NO_NCQ_ON_ATI = (1 << 27), /* Disable NCQ on ATI chipset */	381	ATA_HORKAGE_NO_NCQ_ON_ATI = (1 << 27), /* Disable NCQ on ATI chipset */
382	ATA_HORKAGE_NO_ID_DEV_LOG = (1 << 28), /* Identify device log missing */	382	ATA_HORKAGE_NO_ID_DEV_LOG = (1 << 28), /* Identify device log missing */
		383	ATA_HORKAGE_NO_LOG_DIR = (1 << 29), /* Do not read log directory */
383		384
384	/* DMA mask for user DMA control: User visible values; DO NOT	385	/* DMA mask for user DMA control: User visible values; DO NOT
385	renumber */	386	renumber */

include/linux/netfs.h+7−0

@@ -244,6 +244,13 @@ struct netfs_cache_ops { · 243 unmodified lines
244	int (prepare_write)(struct netfs_cache_resources cres,	244	int (prepare_write)(struct netfs_cache_resources cres,
245	loff_t _start, size_t _len, loff_t i_size,	245	loff_t _start, size_t _len, loff_t i_size,
246	bool no_space_allocated_yet);	246	bool no_space_allocated_yet);
		247
		248	/* Query the occupancy of the cache in a region, returning where the
		249	* next chunk of data starts and how long it is.
		250	*/
		251	int (query_occupancy)(struct netfs_cache_resources cres,
		252	loff_t start, size_t len, size_t granularity,
		253	loff_t _data_start, size_t _data_len);
247	};	254	};
248		255
249	struct readahead_control;	256	struct readahead_control;

include/linux/nfs.h+0−8

@@ -36,14 +36,6 @@ static inline void nfs_copy_fh(struct nfs_fh target, const struct nfs_fh sourc · 35 unmodified lines
36	memcpy(target->data, source->data, source->size);	36	memcpy(target->data, source->data, source->size);
37	}	37	}
38		38
39
40	/*
41	* This is really a general kernel constant, but since nothing like
42	* this is defined in the kernel headers, I have to do it here.
43	*/
44	#define NFS_OFFSET_MAX ((__s64)((~(__u64)0) >> 1))
45
46
47	enum nfs3_stable_how {	39	enum nfs3_stable_how {
48	NFS_UNSTABLE = 0,	40	NFS_UNSTABLE = 0,
49	NFS_DATA_SYNC = 1,	41	NFS_DATA_SYNC = 1,

include/linux/nfs_fs.h+1−0

@@ -107,6 +107,7 @@ struct nfs_open_dir_context { · 106 unmodified lines
107	__u64 dup_cookie;	107	__u64 dup_cookie;
108	pgoff_t page_index;	108	pgoff_t page_index;
109	signed char duped;	109	signed char duped;
		110	bool eof;
110	};	111	};
111		112
112	/*	113	/*

include/linux/page_table_check.h+19−0

@@ -26,6 +26,9 @@ void __page_table_check_pmd_set(struct mm_struct *mm, unsigned long addr, · 25 unmodified lines
26	pmd_t *pmdp, pmd_t pmd);	26	pmd_t *pmdp, pmd_t pmd);
27	void __page_table_check_pud_set(struct mm_struct *mm, unsigned long addr,	27	void __page_table_check_pud_set(struct mm_struct *mm, unsigned long addr,
28	pud_t *pudp, pud_t pud);	28	pud_t *pudp, pud_t pud);
		29	void __page_table_check_pte_clear_range(struct mm_struct *mm,
		30	unsigned long addr,
		31	pmd_t pmd);
29		32
30	static inline void page_table_check_alloc(struct page *page, unsigned int order)	33	static inline void page_table_check_alloc(struct page *page, unsigned int order)
31	{	34	{
@@ -100,6 +103,16 @@ static inline void page_table_check_pud_set(struct mm_struct *mm, · 68 unmodified lines
100	__page_table_check_pud_set(mm, addr, pudp, pud);	103	__page_table_check_pud_set(mm, addr, pudp, pud);
101	}	104	}
102		105
		106	static inline void page_table_check_pte_clear_range(struct mm_struct *mm,
		107	unsigned long addr,
		108	pmd_t pmd)
		109	{
		110	if (static_branch_likely(&page_table_check_disabled))
		111	return;
		112
		113	__page_table_check_pte_clear_range(mm, addr, pmd);
		114	}
		115
103	#else	116	#else
104		117
105	static inline void page_table_check_alloc(struct page *page, unsigned int order)	118	static inline void page_table_check_alloc(struct page *page, unsigned int order)
@@ -143,5 +156,11 @@ static inline void page_table_check_pud_set(struct mm_struct *mm, · 37 unmodified lines
143	{	156	{
144	}	157	}
145		158
		159	static inline void page_table_check_pte_clear_range(struct mm_struct *mm,
		160	unsigned long addr,
		161	pmd_t pmd)
		162	{
		163	}
		164
146	#endif /* CONFIG_PAGE_TABLE_CHECK */	165	#endif /* CONFIG_PAGE_TABLE_CHECK */
147	#endif /* __LINUX_PAGE_TABLE_CHECK_H */	166	#endif /* __LINUX_PAGE_TABLE_CHECK_H */

include/linux/pgtable.h+1−0

@@ -62,6 +62,7 @@ static inline unsigned long pte_index(unsigned long address) · 61 unmodified lines
62	{	62	{
63	return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);	63	return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
64	}	64	}
		65	#define pte_index pte_index
65		66
66	#ifndef pmd_index	67	#ifndef pmd_index
67	static inline unsigned long pmd_index(unsigned long address)	68	static inline unsigned long pmd_index(unsigned long address)

include/net/dst_metadata.h+13−1

@@ -123,8 +123,20 @@ static inline struct metadata_dst tun_dst_unclone(struct sk_buff skb) · 122 unmodified lines
123		123
124	memcpy(&new_md->u.tun_info, &md_dst->u.tun_info,	124	memcpy(&new_md->u.tun_info, &md_dst->u.tun_info,
125	sizeof(struct ip_tunnel_info) + md_size);	125	sizeof(struct ip_tunnel_info) + md_size);
		126	#ifdef CONFIG_DST_CACHE
		127	/* Unclone the dst cache if there is one */
		128	if (new_md->u.tun_info.dst_cache.cache) {
		129	int ret;
		130
		131	ret = dst_cache_init(&new_md->u.tun_info.dst_cache, GFP_ATOMIC);
		132	if (ret) {
		133	metadata_dst_free(new_md);
		134	return ERR_PTR(ret);
		135	}
		136	}
		137	#endif
		138
126	skb_dst_drop(skb);	139	skb_dst_drop(skb);
127	dst_hold(&new_md->dst);
128	skb_dst_set(skb, &new_md->dst);	140	skb_dst_set(skb, &new_md->dst);
129	return new_md;	141	return new_md;
130	}	142	}

include/sound/pcm.h+15−0

@@ -617,6 +617,7 @@ void snd_pcm_stream_unlock(struct snd_pcm_substream *substream); · 616 unmodified lines
617	void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);	617	void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);
618	void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);	618	void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);
619	unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);	619	unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);
		620	unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream);
620		621
621	/**	622	/**
622	* snd_pcm_stream_lock_irqsave - Lock the PCM stream	623	* snd_pcm_stream_lock_irqsave - Lock the PCM stream
@@ -635,6 +636,20 @@ unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream); · 12 unmodified lines
635	void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,	636	void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
636	unsigned long flags);	637	unsigned long flags);
637		638
		639	/**
		640	* snd_pcm_stream_lock_irqsave_nested - Single-nested PCM stream locking
		641	* @substream: PCM substream
		642	* @flags: irq flags
		643	*
		644	* This locks the PCM stream like snd_pcm_stream_lock_irqsave() but with
		645	* the single-depth lockdep subclass.
		646	*/
		647	#define snd_pcm_stream_lock_irqsave_nested(substream, flags) \
		648	do { \
		649	typecheck(unsigned long, flags); \
		650	flags = _snd_pcm_stream_lock_irqsave_nested(substream); \
		651	} while (0)
		652
638	/**	653	/**
639	* snd_pcm_group_for_each_entry - iterate over the linked substreams	654	* snd_pcm_group_for_each_entry - iterate over the linked substreams
640	* @s: the iterator	655	* @s: the iterator

include/uapi/linux/kvm.h+3−3

 #define KVM_S390_NORMAL_RESET	_IO(KVMIO,   0xc3)
 #define KVM_S390_CLEAR_RESET	_IO(KVMIO,   0xc4)
-/* Available with KVM_CAP_XSAVE2 */
-#define KVM_GET_XSAVE2		  _IOR(KVMIO,  0xcf, struct kvm_xsave)
 struct kvm_s390_pv_sec_parm {
 	__u64 origin;
 	__u64 length;
 #define KVM_GET_STATS_FD  _IO(KVMIO,  0xce)
+/* Available with KVM_CAP_XSAVE2 */
+#define KVM_GET_XSAVE2		  _IOR(KVMIO,  0xcf, struct kvm_xsave)
 #endif /* __LINUX_KVM_H */

include/uapi/linux/netfilter/nf_conntrack_common.h+1−1

@@ -106,7 +106,7 @@ enum ip_conntrack_status { · 105 unmodified lines
106	IPS_NAT_CLASH = IPS_UNTRACKED,	106	IPS_NAT_CLASH = IPS_UNTRACKED,
107	#endif	107	#endif
108		108
109	/* Conntrack got a helper explicitly attached via CT target. */	109	/* Conntrack got a helper explicitly attached (ruleset, ctnetlink). */
110	IPS_HELPER_BIT = 13,	110	IPS_HELPER_BIT = 13,
111	IPS_HELPER = (1 << IPS_HELPER_BIT),	111	IPS_HELPER = (1 << IPS_HELPER_BIT),
112		112

include/uapi/linux/perf_event.h+2−0

 	/*
 	 * User provided data if sigtrap=1, passed back to user via
 	 * siginfo_t::si_perf_data, e.g. to permit user to identify the event.
+	 * Note, siginfo_t::si_perf_data is long-sized, and sig_data will be
+	 * truncated accordingly on 32 bit architectures.
 	 */
 	__u64	sig_data;
 };

include/uapi/sound/asound.h+3−1

  *                                                                          *
  ****************************************************************************/
+#define AES_IEC958_STATUS_SIZE		24
 struct snd_aes_iec958 {
-	unsigned char status[24];	/* AES/IEC958 channel status bits */
+	unsigned char status[AES_IEC958_STATUS_SIZE]; /* AES/IEC958 channel status bits */
 	unsigned char subcode[147];	/* AES/IEC958 subcode bits */
 	unsigned char pad;		/* nothing */
 	unsigned char dig_subframe[4];	/* AES/IEC958 subframe bits */

include/uapi/xen/gntdev.h+7−1

 /*
  * Inserts the grant references into the mapping table of an instance
  * of gntdev. N.B. This does not perform the mapping, which is deferred
- * until mmap() is called with @index as the offset.
+ * until mmap() is called with @index as the offset. @index should be
+ * considered opaque to userspace, with one exception: if no grant
+ * references have ever been inserted into the mapping table of this
+ * instance, @index will be set to 0. This is necessary to use gntdev
+ * with userspace APIs that expect a file descriptor that can be
+ * mmap()'d at offset 0, such as Wayland. If @count is set to 0, this
+ * ioctl will fail.
  */
 #define IOCTL_GNTDEV_MAP_GRANT_REF \
 _IOC(_IOC_NONE, 'G', 0, sizeof(struct ioctl_gntdev_map_grant_ref))

include/xen/xenbus_dev.h+0−2

@@ -1,6 +1,4 @@
1	/******************************************************************************	1	/******************************************************************************
2	* evtchn.h
3	*
4	* Interface to /dev/xen/xenbus_backend.	2	* Interface to /dev/xen/xenbus_backend.
5	*	3	*
6	* Copyright (c) 2011 Bastian Blank <waldi@debian.org>	4	* Copyright (c) 2011 Bastian Blank <waldi@debian.org>

ipc/sem.c+2−2

 	 */
 	un = lookup_undo(ulp, semid);
 	if (un) {
+		spin_unlock(&ulp->lock);
 		kvfree(new);
 		goto success;
 	}
 	ipc_assert_locked_object(&sma->sem_perm);
 	list_add(&new->list_id, &sma->list_id);
 	un = new;
-success:
 	spin_unlock(&ulp->lock);
+success:
 	sem_unlock(sma, -1);
 out:
 	return un;

kernel/auditsc.c+1−1

@@ -185,7 +185,7 @@ static int audit_match_perm(struct audit_context *ctx, int mask) · 184 unmodified lines
185	case AUDITSC_EXECVE:	185	case AUDITSC_EXECVE:
186	return mask & AUDIT_PERM_EXEC;	186	return mask & AUDIT_PERM_EXEC;
187	case AUDITSC_OPENAT2:	187	case AUDITSC_OPENAT2:
188	return mask & ACC_MODE((u32)((struct open_how *)ctx->argv[2])->flags);	188	return mask & ACC_MODE((u32)ctx->openat2.flags);
189	default:	189	default:
190	return 0;	190	return 0;
191	}	191	}

kernel/events/core.c+16−0

 	return err;
 }
+/*
+ * Copy event-type-independent attributes that may be modified.
+ */
+static void perf_event_modify_copy_attr(struct perf_event_attr *to,
+					const struct perf_event_attr *from)
+{
+	to->sig_data = from->sig_data;
+}
 static int perf_event_modify_attr(struct perf_event *event,
 				  struct perf_event_attr *attr)
 {
 	WARN_ON_ONCE(event->ctx->parent_ctx);
 	mutex_lock(&event->child_mutex);
+	/*
+	 * Event-type-independent attributes must be copied before event-type
+	 * modification, which will validate that final attributes match the
+	 * source attributes after all relevant attributes have been copied.
+	 */
+	perf_event_modify_copy_attr(&event->attr, attr);
 	err = func(event, attr);
 	if (err)
 		goto out;
 	list_for_each_entry(child, &event->child_list, child_list) {
+		perf_event_modify_copy_attr(&child->attr, attr);
 		err = func(child, attr);
 		if (err)
 			goto out;

lib/crypto/blake2s.c+2−2

@@ -18,14 +18,14 @@ · 17 unmodified lines
18		18
19	void blake2s_update(struct blake2s_state state, const u8 in, size_t inlen)	19	void blake2s_update(struct blake2s_state state, const u8 in, size_t inlen)
20	{	20	{
21	__blake2s_update(state, in, inlen, blake2s_compress);	21	__blake2s_update(state, in, inlen, false);
22	}	22	}
23	EXPORT_SYMBOL(blake2s_update);	23	EXPORT_SYMBOL(blake2s_update);
24		24
25	void blake2s_final(struct blake2s_state state, u8 out)	25	void blake2s_final(struct blake2s_state state, u8 out)
26	{	26	{
27	WARN_ON(IS_ENABLED(DEBUG) && !out);	27	WARN_ON(IS_ENABLED(DEBUG) && !out);
28	__blake2s_final(state, out, blake2s_compress);	28	__blake2s_final(state, out, false);
29	memzero_explicit(state, sizeof(*state));	29	memzero_explicit(state, sizeof(*state));
30	}	30	}
31	EXPORT_SYMBOL(blake2s_final);	31	EXPORT_SYMBOL(blake2s_final);

mm/debug_vm_pgtable.c+2−0

@@ -171,6 +171,8 @@ static void __init pte_advanced_tests(struct pgtable_debug_args *args) · 170 unmodified lines
171	ptep_test_and_clear_young(args->vma, args->vaddr, args->ptep);	171	ptep_test_and_clear_young(args->vma, args->vaddr, args->ptep);
172	pte = ptep_get(args->ptep);	172	pte = ptep_get(args->ptep);
173	WARN_ON(pte_young(pte));	173	WARN_ON(pte_young(pte));
		174
		175	ptep_get_and_clear_full(args->mm, args->vaddr, args->ptep, 1);
174	}	176	}
175		177
176	static void __init pte_savedwrite_tests(struct pgtable_debug_args *args)	178	static void __init pte_savedwrite_tests(struct pgtable_debug_args *args)

mm/khugepaged.c+21−16

 #include <linux/hashtable.h>
 #include <linux/userfaultfd_k.h>
 #include <linux/page_idle.h>
+#include <linux/page_table_check.h>
 #include <linux/swapops.h>
 #include <linux/shmem_fs.h>
 	return 0;
 }
+static void collapse_and_free_pmd(struct mm_struct *mm, struct vm_area_struct *vma,
+				  unsigned long addr, pmd_t *pmdp)
+{
+	spinlock_t *ptl;
+	pmd_t pmd;
+	mmap_assert_write_locked(mm);
+	ptl = pmd_lock(vma->vm_mm, pmdp);
+	pmd = pmdp_collapse_flush(vma, addr, pmdp);
+	spin_unlock(ptl);
+	mm_dec_nr_ptes(mm);
+	page_table_check_pte_clear_range(mm, addr, pmd);
+	pte_free(mm, pmd_pgtable(pmd));
+}
 /**
  * collapse_pte_mapped_thp - Try to collapse a pte-mapped THP for mm at
  * address haddr.
 	struct vm_area_struct *vma = find_vma(mm, haddr);
 	struct page *hpage;
 	pte_t *start_pte, *pte;
-	pmd_t *pmd, _pmd;
+	pmd_t *pmd;
 	spinlock_t *ptl;
 	int count = 0;
 	int i;
 	}
 	/* step 4: collapse pmd */
-	ptl = pmd_lock(vma->vm_mm, pmd);
+	collapse_and_free_pmd(mm, vma, haddr, pmd);
-	_pmd = pmdp_collapse_flush(vma, haddr, pmd);
-	spin_unlock(ptl);
-	mm_dec_nr_ptes(mm);
-	pte_free(mm, pmd_pgtable(_pmd));
 drop_hpage:
 	unlock_page(hpage);
 	put_page(hpage);
 	struct vm_area_struct *vma;
 	struct mm_struct *mm;
 	unsigned long addr;
-	pmd_t *pmd, _pmd;
+	pmd_t *pmd;
 	i_mmap_lock_write(mapping);
 	vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
 		 * reverse order. Trylock is a way to avoid deadlock.
 		 */
 		if (mmap_write_trylock(mm)) {
-			if (!khugepaged_test_exit(mm)) {
+			if (!khugepaged_test_exit(mm))
-				spinlock_t *ptl = pmd_lock(mm, pmd);
+				collapse_and_free_pmd(mm, vma, addr, pmd);
-				/* assume page table is clear */
-				_pmd = pmdp_collapse_flush(vma, addr, pmd);
-				spin_unlock(ptl);
-				mm_dec_nr_ptes(mm);
-				pte_free(mm, pmd_pgtable(_pmd));
-			}
 			mmap_write_unlock(mm);
 		} else {
 			/* Try again later */

mm/kmemleak.c+7−6

 {
 	unsigned long flags;
 	struct kmemleak_object *object;
-	int i;
+	struct zone *zone;
+	int __maybe_unused i;
 	int new_leaks = 0;
 	jiffies_last_scan = jiffies;
 	 * Struct page scanning for each node.
 	 */
 	get_online_mems();
-	for_each_online_node(i) {
+	for_each_populated_zone(zone) {
-		unsigned long start_pfn = node_start_pfn(i);
+		unsigned long start_pfn = zone->zone_start_pfn;
-		unsigned long end_pfn = node_end_pfn(i);
+		unsigned long end_pfn = zone_end_pfn(zone);
 		unsigned long pfn;
 		for (pfn = start_pfn; pfn < end_pfn; pfn++) {
 			if (!page)
 				continue;
-			/* only scan pages belonging to this node */
+			/* only scan pages belonging to this zone */
-			if (page_to_nid(page) != i)
+			if (page_zone(page) != zone)
 				continue;
 			/* only scan if page is in use */
 			if (page_count(page) == 0)

mm/page_isolation.c+1−1

@@ -115,7 +115,7 @@ static void unset_migratetype_isolate(struct page *page, unsigned migratetype) · 114 unmodified lines
115	* onlining - just onlined memory won't immediately be considered for	115	* onlining - just onlined memory won't immediately be considered for
116	* allocation.	116	* allocation.
117	*/	117	*/
118	if (!isolated_page && PageBuddy(page)) {	118	if (!isolated_page) {
119	nr_pages = move_freepages_block(zone, page, migratetype, NULL);	119	nr_pages = move_freepages_block(zone, page, migratetype, NULL);
120	__mod_zone_freepage_state(zone, nr_pages, migratetype);	120	__mod_zone_freepage_state(zone, nr_pages, migratetype);
121	}	121	}

mm/page_table_check.c+27−28

 {
 	struct page_ext *page_ext;
 	struct page *page;
+	unsigned long i;
 	bool anon;
-	int i;
 	if (!pfn_valid(pfn))
 		return;
 {
 	struct page_ext *page_ext;
 	struct page *page;
+	unsigned long i;
 	bool anon;
-	int i;
 	if (!pfn_valid(pfn))
 		return;
 void __page_table_check_zero(struct page *page, unsigned int order)
 {
 	struct page_ext *page_ext = lookup_page_ext(page);
-	int i;
+	unsigned long i;
 	BUG_ON(!page_ext);
-	for (i = 0; i < (1 << order); i++) {
+	for (i = 0; i < (1ul << order); i++) {
 		struct page_table_check *ptc = get_page_table_check(page_ext);
 		BUG_ON(atomic_read(&ptc->anon_map_count));
 void __page_table_check_pte_set(struct mm_struct *mm, unsigned long addr,
 				pte_t *ptep, pte_t pte)
 {
-	pte_t old_pte;
 	if (&init_mm == mm)
 		return;
-	old_pte = *ptep;
+	__page_table_check_pte_clear(mm, addr, *ptep);
-	if (pte_user_accessible_page(old_pte)) {
-		page_table_check_clear(mm, addr, pte_pfn(old_pte),
-				       PAGE_SIZE >> PAGE_SHIFT);
-	}
 	if (pte_user_accessible_page(pte)) {
 		page_table_check_set(mm, addr, pte_pfn(pte),
 				     PAGE_SIZE >> PAGE_SHIFT,
 void __page_table_check_pmd_set(struct mm_struct *mm, unsigned long addr,
 				pmd_t *pmdp, pmd_t pmd)
 {
-	pmd_t old_pmd;
 	if (&init_mm == mm)
 		return;
-	old_pmd = *pmdp;
+	__page_table_check_pmd_clear(mm, addr, *pmdp);
-	if (pmd_user_accessible_page(old_pmd)) {
-		page_table_check_clear(mm, addr, pmd_pfn(old_pmd),
-				       PMD_PAGE_SIZE >> PAGE_SHIFT);
-	}
 	if (pmd_user_accessible_page(pmd)) {
 		page_table_check_set(mm, addr, pmd_pfn(pmd),
 				     PMD_PAGE_SIZE >> PAGE_SHIFT,
 void __page_table_check_pud_set(struct mm_struct *mm, unsigned long addr,
 				pud_t *pudp, pud_t pud)
 {
-	pud_t old_pud;
 	if (&init_mm == mm)
 		return;
-	old_pud = *pudp;
+	__page_table_check_pud_clear(mm, addr, *pudp);
-	if (pud_user_accessible_page(old_pud)) {
-		page_table_check_clear(mm, addr, pud_pfn(old_pud),
-				       PUD_PAGE_SIZE >> PAGE_SHIFT);
-	}
 	if (pud_user_accessible_page(pud)) {
 		page_table_check_set(mm, addr, pud_pfn(pud),
 				     PUD_PAGE_SIZE >> PAGE_SHIFT,
 	}
 }
 EXPORT_SYMBOL(__page_table_check_pud_set);
+void __page_table_check_pte_clear_range(struct mm_struct *mm,
+					unsigned long addr,
+					pmd_t pmd)
+{
+	if (&init_mm == mm)
+		return;
+	if (!pmd_bad(pmd) && !pmd_leaf(pmd)) {
+		pte_t *ptep = pte_offset_map(&pmd, addr);
+		unsigned long i;
+		pte_unmap(ptep);
+		for (i = 0; i < PTRS_PER_PTE; i++) {
+			__page_table_check_pte_clear(mm, addr, *ptep);
+			addr += PAGE_SIZE;
+			ptep++;
+		}
+	}
+}

net/8021q/vlan.h+1−1

 				   u32 skb_prio, u16 vlan_prio);
 int vlan_dev_set_egress_priority(const struct net_device *dev,
 				 u32 skb_prio, u16 vlan_prio);
+void vlan_dev_free_egress_priority(const struct net_device *dev);
 int vlan_dev_change_flags(const struct net_device *dev, u32 flag, u32 mask);
 void vlan_dev_get_realdev_name(const struct net_device *dev, char *result,
 			       size_t size);
 void vlan_setup(struct net_device *dev);
 int register_vlan_dev(struct net_device *dev, struct netlink_ext_ack *extack);
 void unregister_vlan_dev(struct net_device *dev, struct list_head *head);
-void vlan_dev_uninit(struct net_device *dev);
 bool vlan_dev_inherit_address(struct net_device *dev,
 			      struct net_device *real_dev);

net/8021q/vlan_dev.c+11−4

 }
 /* Note: this function might be called multiple times for the same device. */
-void vlan_dev_uninit(struct net_device *dev)
+void vlan_dev_free_egress_priority(const struct net_device *dev)
 {
 	struct vlan_priority_tci_mapping *pm;
 	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
 	}
 }
+static void vlan_dev_uninit(struct net_device *dev)
+{
+	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
+	vlan_dev_free_egress_priority(dev);
+	/* Get rid of the vlan's reference to real_dev */
+	dev_put_track(vlan->real_dev, &vlan->dev_tracker);
+}
 static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
 	netdev_features_t features)
 {
 	free_percpu(vlan->vlan_pcpu_stats);
 	vlan->vlan_pcpu_stats = NULL;
-	/* Get rid of the vlan's reference to real_dev */
-	dev_put_track(vlan->real_dev, &vlan->dev_tracker);
 }
 void vlan_setup(struct net_device *dev)

net/8021q/vlan_netlink.c+4−3

 		return -EINVAL;
 	err = vlan_changelink(dev, tb, data, extack);
-	if (!err)
-		err = register_vlan_dev(dev, extack);
 	if (err)
-		vlan_dev_uninit(dev);
+		return err;
+	err = register_vlan_dev(dev, extack);
+	if (err)
+		vlan_dev_free_egress_priority(dev);
 	return err;
 }

net/ax25/af_ax25.c+5−2

 			spin_unlock_bh(&ax25_list_lock);
 			lock_sock(sk);
 			s->ax25_dev = NULL;
+			dev_put_track(ax25_dev->dev, &ax25_dev->dev_tracker);
 			ax25_dev_put(ax25_dev);
-			release_sock(sk);
 			ax25_disconnect(s, ENETUNREACH);
+			release_sock(sk);
 			spin_lock_bh(&ax25_list_lock);
 			sock_put(sk);
 			/* The entry could have been deleted from the
 		}
 	}
-	if (ax25_dev != NULL)
+	if (ax25_dev) {
 		ax25_fillin_cb(ax25, ax25_dev);
+		dev_hold_track(ax25_dev->dev, &ax25_dev->dev_tracker, GFP_ATOMIC);
+	}
 done:
 	ax25_cb_add(ax25);

net/can/isotp.c+22−7

 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/spinlock.h>
 #include <linux/hrtimer.h>
 #include <linux/wait.h>
 #include <linux/uio.h>
 	struct tpcon rx, tx;
 	struct list_head notifier;
 	wait_queue_head_t wait;
+	spinlock_t rx_lock; /* protect single thread state machine */
 };
 static LIST_HEAD(isotp_notifier_list);
 	n_pci_type = cf->data[ae] & 0xF0;
+	/* Make sure the state changes and data structures stay consistent at
+	 * CAN frame reception time. This locking is not needed in real world
+	 * use cases but the inconsistency can be triggered with syzkaller.
+	 */
+	spin_lock(&so->rx_lock);
 	if (so->opt.flags & CAN_ISOTP_HALF_DUPLEX) {
 		/* check rx/tx path half duplex expectations */
 		if ((so->tx.state != ISOTP_IDLE && n_pci_type != N_PCI_FC) ||
 		    (so->rx.state != ISOTP_IDLE && n_pci_type == N_PCI_FC))
-			return;
+			goto out_unlock;
 	}
 	switch (n_pci_type) {
 		isotp_rcv_cf(sk, cf, ae, skb);
 		break;
 	}
+out_unlock:
+	spin_unlock(&so->rx_lock);
 }
 static void isotp_fill_dataframe(struct canfd_frame *cf, struct isotp_sock *so,
 	if (!size || size > MAX_MSG_LENGTH) {
 		err = -EINVAL;
-		goto err_out;
+		goto err_out_drop;
 	}
 	/* take care of a potential SF_DL ESC offset for TX_DL > 8 */
 	if ((so->opt.flags & CAN_ISOTP_SF_BROADCAST) &&
 	    (size > so->tx.ll_dl - SF_PCI_SZ4 - ae - off)) {
 		err = -EINVAL;
-		goto err_out;
+		goto err_out_drop;
 	}
 	err = memcpy_from_msg(so->tx.buf, msg, size);
 	if (err < 0)
-		goto err_out;
+		goto err_out_drop;
 	dev = dev_get_by_index(sock_net(sk), so->ifindex);
 	if (!dev) {
 		err = -ENXIO;
-		goto err_out;
+		goto err_out_drop;
 	}
 	skb = sock_alloc_send_skb(sk, so->ll.mtu + sizeof(struct can_skb_priv),
 				  msg->msg_flags & MSG_DONTWAIT, &err);
 	if (!skb) {
 		dev_put(dev);
-		goto err_out;
+		goto err_out_drop;
 	}
 	can_skb_reserve(skb);
 	if (err) {
 		pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
 			       __func__, ERR_PTR(err));
-		goto err_out;
+		goto err_out_drop;
 	}
 	if (wait_tx_done) {
 	return size;
+err_out_drop:
+	/* drop this PDU and unlock a potential wait queue */
+	old_state = ISOTP_IDLE;
 err_out:
 	so->tx.state = old_state;
 	if (so->tx.state == ISOTP_IDLE)
 	so->txtimer.function = isotp_tx_timer_handler;
 	init_waitqueue_head(&so->wait);
+	spin_lock_init(&so->rx_lock);
 	spin_lock(&isotp_notifier_lock);
 	list_add_tail(&so->notifier, &isotp_notifier_list);

net/ceph/ceph_common.c+7−0

 	Opt_cephx_sign_messages,
 	Opt_tcp_nodelay,
 	Opt_abort_on_full,
+	Opt_rxbounce,
 };
 enum {
 	fsparam_u32	("osdkeepalive",		Opt_osdkeepalivetimeout),
 	fsparam_enum	("read_from_replica",		Opt_read_from_replica,
 			 ceph_param_read_from_replica),
+	fsparam_flag	("rxbounce",			Opt_rxbounce),
 	fsparam_enum	("ms_mode",			Opt_ms_mode,
 			 ceph_param_ms_mode),
 	fsparam_string	("secret",			Opt_secret),
 	case Opt_abort_on_full:
 		opt->flags |= CEPH_OPT_ABORT_ON_FULL;
 		break;
+	case Opt_rxbounce:
+		opt->flags |= CEPH_OPT_RXBOUNCE;
+		break;
 	default:
 		BUG();
 		seq_puts(m, "notcp_nodelay,");
 	if (show_all && (opt->flags & CEPH_OPT_ABORT_ON_FULL))
 		seq_puts(m, "abort_on_full,");
+	if (opt->flags & CEPH_OPT_RXBOUNCE)
+		seq_puts(m, "rxbounce,");
 	if (opt->mount_timeout != CEPH_MOUNT_TIMEOUT_DEFAULT)
 		seq_printf(m, "mount_timeout=%d,",

net/ceph/messenger.c+4−0

 		ceph_msg_put(con->out_msg);
 		con->out_msg = NULL;
 	}
+	if (con->bounce_page) {
+		__free_page(con->bounce_page);
+		con->bounce_page = NULL;
+	}
 	if (ceph_msgr2(from_msgr(con->msgr)))
 		ceph_con_v2_reset_protocol(con);

net/ceph/messenger_v1.c+48−6

@@ -992,8 +992,7 @@ static int read_partial_message_section(struct ceph_connection *con, · 991 unmodified lines
992		992
993	static int read_partial_msg_data(struct ceph_connection *con)	993	static int read_partial_msg_data(struct ceph_connection *con)
994	{	994	{
995	struct ceph_msg *msg = con->in_msg;	995	struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;
996	struct ceph_msg_data_cursor *cursor = &msg->cursor;
997	bool do_datacrc = !ceph_test_opt(from_msgr(con->msgr), NOCRC);	996	bool do_datacrc = !ceph_test_opt(from_msgr(con->msgr), NOCRC);
998	struct page *page;	997	struct page *page;
999	size_t page_offset;	998	size_t page_offset;
@@ -1001,9 +1000,6 @@ static int read_partial_msg_data(struct ceph_connection *con) · 1 unmodified line
1001	u32 crc = 0;	1000	u32 crc = 0;
1002	int ret;	1001	int ret;
1003		1002
1004	if (!msg->num_data_items)
1005	return -EIO;
1006
1007	if (do_datacrc)	1003	if (do_datacrc)
1008	crc = con->in_data_crc;	1004	crc = con->in_data_crc;
1009	while (cursor->total_resid) {	1005	while (cursor->total_resid) {
@@ -1031,6 +1027,46 @@ static int read_partial_msg_data(struct ceph_connection *con) · 21 unmodified lines
1031	return 1; /* must return > 0 to indicate success */	1027	return 1; /* must return > 0 to indicate success */
1032	}	1028	}
1033		1029
		1030	static int read_partial_msg_data_bounce(struct ceph_connection *con)
		1031	{
		1032	struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;
		1033	struct page *page;
		1034	size_t off, len;
		1035	u32 crc;
		1036	int ret;
		1037
		1038	if (unlikely(!con->bounce_page)) {
		1039	con->bounce_page = alloc_page(GFP_NOIO);
		1040	if (!con->bounce_page) {
		1041	pr_err("failed to allocate bounce page\n");
		1042	return -ENOMEM;
		1043	}
		1044	}
		1045
		1046	crc = con->in_data_crc;
		1047	while (cursor->total_resid) {
		1048	if (!cursor->resid) {
		1049	ceph_msg_data_advance(cursor, 0);
		1050	continue;
		1051	}
		1052
		1053	page = ceph_msg_data_next(cursor, &off, &len, NULL);
		1054	ret = ceph_tcp_recvpage(con->sock, con->bounce_page, 0, len);
		1055	if (ret <= 0) {
		1056	con->in_data_crc = crc;
		1057	return ret;
		1058	}
		1059
		1060	crc = crc32c(crc, page_address(con->bounce_page), ret);
		1061	memcpy_to_page(page, off, page_address(con->bounce_page), ret);
		1062
		1063	ceph_msg_data_advance(cursor, ret);
		1064	}
		1065	con->in_data_crc = crc;
		1066
		1067	return 1; /* must return > 0 to indicate success */
		1068	}
		1069
1034	/*	1070	/*
1035	* read (part of) a message.	1071	* read (part of) a message.
1036	*/	1072	*/
@@ -1141,7 +1177,13 @@ static int read_partial_message(struct ceph_connection *con) · 104 unmodified lines
1141		1177
1142	/* (page) data */	1178	/* (page) data */
1143	if (data_len) {	1179	if (data_len) {
1144	ret = read_partial_msg_data(con);	1180	if (!m->num_data_items)
		1181	return -EIO;
		1182
		1183	if (ceph_test_opt(from_msgr(con->msgr), RXBOUNCE))
		1184	ret = read_partial_msg_data_bounce(con);
		1185	else
		1186	ret = read_partial_msg_data(con);
1145	if (ret <= 0)	1187	if (ret <= 0)
1146	return ret;	1188	return ret;
1147	}	1189	}

net/ceph/messenger_v2.c+186−64

@@ -57,8 +57,9 @@ · 56 unmodified lines
57	#define IN_S_HANDLE_CONTROL_REMAINDER 3	57	#define IN_S_HANDLE_CONTROL_REMAINDER 3
58	#define IN_S_PREPARE_READ_DATA 4	58	#define IN_S_PREPARE_READ_DATA 4
59	#define IN_S_PREPARE_READ_DATA_CONT 5	59	#define IN_S_PREPARE_READ_DATA_CONT 5
60	#define IN_S_HANDLE_EPILOGUE 6	60	#define IN_S_PREPARE_READ_ENC_PAGE 6
61	#define IN_S_FINISH_SKIP 7	61	#define IN_S_HANDLE_EPILOGUE 7
		62	#define IN_S_FINISH_SKIP 8
62		63
63	#define OUT_S_QUEUE_DATA 1	64	#define OUT_S_QUEUE_DATA 1
64	#define OUT_S_QUEUE_DATA_CONT 2	65	#define OUT_S_QUEUE_DATA_CONT 2
@@ -1032,22 +1033,41 @@ static int decrypt_control_remainder(struct ceph_connection *con) · 967 unmodified lines
1032	padded_len(rem_len) + CEPH_GCM_TAG_LEN);	1033	padded_len(rem_len) + CEPH_GCM_TAG_LEN);
1033	}	1034	}
1034		1035
1035	static int decrypt_message(struct ceph_connection *con)	1036	static int decrypt_tail(struct ceph_connection *con)
1036	{	1037	{
		1038	struct sg_table enc_sgt = {};
1037	struct sg_table sgt = {};	1039	struct sg_table sgt = {};
		1040	int tail_len;
1038	int ret;	1041	int ret;
1039		1042
		1043	tail_len = tail_onwire_len(con->in_msg, true);
		1044	ret = sg_alloc_table_from_pages(&enc_sgt, con->v2.in_enc_pages,
		1045	con->v2.in_enc_page_cnt, 0, tail_len,
		1046	GFP_NOIO);
		1047	if (ret)
		1048	goto out;
		1049
1040	ret = setup_message_sgs(&sgt, con->in_msg, FRONT_PAD(con->v2.in_buf),	1050	ret = setup_message_sgs(&sgt, con->in_msg, FRONT_PAD(con->v2.in_buf),
1041	MIDDLE_PAD(con->v2.in_buf), DATA_PAD(con->v2.in_buf),	1051	MIDDLE_PAD(con->v2.in_buf), DATA_PAD(con->v2.in_buf),
1042	con->v2.in_buf, true);	1052	con->v2.in_buf, true);
1043	if (ret)	1053	if (ret)
1044	goto out;	1054	goto out;
1045		1055
1046	ret = gcm_crypt(con, false, sgt.sgl, sgt.sgl,	1056	dout("%s con %p msg %p enc_page_cnt %d sg_cnt %d\n", __func__, con,
1047	tail_onwire_len(con->in_msg, true));	1057	con->in_msg, con->v2.in_enc_page_cnt, sgt.orig_nents);
		1058	ret = gcm_crypt(con, false, enc_sgt.sgl, sgt.sgl, tail_len);
		1059	if (ret)
		1060	goto out;
		1061
		1062	WARN_ON(!con->v2.in_enc_page_cnt);
		1063	ceph_release_page_vector(con->v2.in_enc_pages,
		1064	con->v2.in_enc_page_cnt);
		1065	con->v2.in_enc_pages = NULL;
		1066	con->v2.in_enc_page_cnt = 0;
1048		1067
1049	out:	1068	out:
1050	sg_free_table(&sgt);	1069	sg_free_table(&sgt);
		1070	sg_free_table(&enc_sgt);
1051	return ret;	1071	return ret;
1052	}	1072	}
1053		1073
@@ -1733,54 +1753,157 @@ static int prepare_read_control_remainder(struct ceph_connection *con) · 679 unmodified lines
1733	return 0;	1753	return 0;
1734	}	1754	}
1735		1755
1736	static void prepare_read_data(struct ceph_connection *con)	1756	static int prepare_read_data(struct ceph_connection *con)
1737	{	1757	{
1738	struct bio_vec bv;	1758	struct bio_vec bv;
1739		1759
1740	if (!con_secure(con))	1760	con->in_data_crc = -1;
1741	con->in_data_crc = -1;
1742	ceph_msg_data_cursor_init(&con->v2.in_cursor, con->in_msg,	1761	ceph_msg_data_cursor_init(&con->v2.in_cursor, con->in_msg,
1743	data_len(con->in_msg));	1762	data_len(con->in_msg));
1744		1763
1745	get_bvec_at(&con->v2.in_cursor, &bv);	1764	get_bvec_at(&con->v2.in_cursor, &bv);
1746	set_in_bvec(con, &bv);	1765	if (ceph_test_opt(from_msgr(con->msgr), RXBOUNCE)) {
		1766	if (unlikely(!con->bounce_page)) {
		1767	con->bounce_page = alloc_page(GFP_NOIO);
		1768	if (!con->bounce_page) {
		1769	pr_err("failed to allocate bounce page\n");
		1770	return -ENOMEM;
		1771	}
		1772	}
		1773
		1774	bv.bv_page = con->bounce_page;
		1775	bv.bv_offset = 0;
		1776	set_in_bvec(con, &bv);
		1777	} else {
		1778	set_in_bvec(con, &bv);
		1779	}
1747	con->v2.in_state = IN_S_PREPARE_READ_DATA_CONT;	1780	con->v2.in_state = IN_S_PREPARE_READ_DATA_CONT;
		1781	return 0;
1748	}	1782	}
1749		1783
1750	static void prepare_read_data_cont(struct ceph_connection *con)	1784	static void prepare_read_data_cont(struct ceph_connection *con)
1751	{	1785	{
1752	struct bio_vec bv;	1786	struct bio_vec bv;
1753		1787
1754	if (!con_secure(con))	1788	if (ceph_test_opt(from_msgr(con->msgr), RXBOUNCE)) {
		1789	con->in_data_crc = crc32c(con->in_data_crc,
		1790	page_address(con->bounce_page),
		1791	con->v2.in_bvec.bv_len);
		1792
		1793	get_bvec_at(&con->v2.in_cursor, &bv);
		1794	memcpy_to_page(bv.bv_page, bv.bv_offset,
		1795	page_address(con->bounce_page),
		1796	con->v2.in_bvec.bv_len);
		1797	} else {
1755	con->in_data_crc = ceph_crc32c_page(con->in_data_crc,	1798	con->in_data_crc = ceph_crc32c_page(con->in_data_crc,
1756	con->v2.in_bvec.bv_page,	1799	con->v2.in_bvec.bv_page,
1757	con->v2.in_bvec.bv_offset,	1800	con->v2.in_bvec.bv_offset,
1758	con->v2.in_bvec.bv_len);	1801	con->v2.in_bvec.bv_len);
		1802	}
1759		1803
1760	ceph_msg_data_advance(&con->v2.in_cursor, con->v2.in_bvec.bv_len);	1804	ceph_msg_data_advance(&con->v2.in_cursor, con->v2.in_bvec.bv_len);
1761	if (con->v2.in_cursor.total_resid) {	1805	if (con->v2.in_cursor.total_resid) {
1762	get_bvec_at(&con->v2.in_cursor, &bv);	1806	get_bvec_at(&con->v2.in_cursor, &bv);
1763	set_in_bvec(con, &bv);	1807	if (ceph_test_opt(from_msgr(con->msgr), RXBOUNCE)) {
		1808	bv.bv_page = con->bounce_page;
		1809	bv.bv_offset = 0;
		1810	set_in_bvec(con, &bv);
		1811	} else {
		1812	set_in_bvec(con, &bv);
		1813	}
1764	WARN_ON(con->v2.in_state != IN_S_PREPARE_READ_DATA_CONT);	1814	WARN_ON(con->v2.in_state != IN_S_PREPARE_READ_DATA_CONT);
1765	return;	1815	return;
1766	}	1816	}
1767		1817
1768	/*	1818	/*
1769	* We've read all data. Prepare to read data padding (if any)	1819	* We've read all data. Prepare to read epilogue.
1770	* and epilogue.
1771	*/	1820	*/
1772	reset_in_kvecs(con);	1821	reset_in_kvecs(con);
1773	if (con_secure(con)) {	1822	add_in_kvec(con, con->v2.in_buf, CEPH_EPILOGUE_PLAIN_LEN);
1774	if (need_padding(data_len(con->in_msg)))	1823	con->v2.in_state = IN_S_HANDLE_EPILOGUE;
1775	add_in_kvec(con, DATA_PAD(con->v2.in_buf),	1824	}
1776	padding_len(data_len(con->in_msg)));	1825
1777	add_in_kvec(con, con->v2.in_buf, CEPH_EPILOGUE_SECURE_LEN);	1826	static int prepare_read_tail_plain(struct ceph_connection *con)
		1827	{
		1828	struct ceph_msg *msg = con->in_msg;
		1829
		1830	if (!front_len(msg) && !middle_len(msg)) {
		1831	WARN_ON(!data_len(msg));
		1832	return prepare_read_data(con);
		1833	}
		1834
		1835	reset_in_kvecs(con);
		1836	if (front_len(msg)) {
		1837	add_in_kvec(con, msg->front.iov_base, front_len(msg));
		1838	WARN_ON(msg->front.iov_len != front_len(msg));
		1839	}
		1840	if (middle_len(msg)) {
		1841	add_in_kvec(con, msg->middle->vec.iov_base, middle_len(msg));
		1842	WARN_ON(msg->middle->vec.iov_len != middle_len(msg));
		1843	}
		1844
		1845	if (data_len(msg)) {
		1846	con->v2.in_state = IN_S_PREPARE_READ_DATA;
1778	} else {	1847	} else {
1779	add_in_kvec(con, con->v2.in_buf, CEPH_EPILOGUE_PLAIN_LEN);	1848	add_in_kvec(con, con->v2.in_buf, CEPH_EPILOGUE_PLAIN_LEN);
		1849	con->v2.in_state = IN_S_HANDLE_EPILOGUE;
1780	}	1850	}
		1851	return 0;
		1852	}
		1853
		1854	static void prepare_read_enc_page(struct ceph_connection *con)
		1855	{
		1856	struct bio_vec bv;
		1857
		1858	dout("%s con %p i %d resid %d\n", __func__, con, con->v2.in_enc_i,
		1859	con->v2.in_enc_resid);
		1860	WARN_ON(!con->v2.in_enc_resid);
		1861
		1862	bv.bv_page = con->v2.in_enc_pages[con->v2.in_enc_i];
		1863	bv.bv_offset = 0;
		1864	bv.bv_len = min(con->v2.in_enc_resid, (int)PAGE_SIZE);
		1865
		1866	set_in_bvec(con, &bv);
		1867	con->v2.in_enc_i++;
		1868	con->v2.in_enc_resid -= bv.bv_len;
		1869
		1870	if (con->v2.in_enc_resid) {
		1871	con->v2.in_state = IN_S_PREPARE_READ_ENC_PAGE;
		1872	return;
		1873	}
		1874
		1875	/*
		1876	* We are set to read the last piece of ciphertext (ending
		1877	* with epilogue) + auth tag.
		1878	*/
		1879	WARN_ON(con->v2.in_enc_i != con->v2.in_enc_page_cnt);
1781	con->v2.in_state = IN_S_HANDLE_EPILOGUE;	1880	con->v2.in_state = IN_S_HANDLE_EPILOGUE;
1782	}	1881	}
1783		1882
		1883	static int prepare_read_tail_secure(struct ceph_connection *con)
		1884	{
		1885	struct page **enc_pages;
		1886	int enc_page_cnt;
		1887	int tail_len;
		1888
		1889	tail_len = tail_onwire_len(con->in_msg, true);
		1890	WARN_ON(!tail_len);
		1891
		1892	enc_page_cnt = calc_pages_for(0, tail_len);
		1893	enc_pages = ceph_alloc_page_vector(enc_page_cnt, GFP_NOIO);
		1894	if (IS_ERR(enc_pages))
		1895	return PTR_ERR(enc_pages);
		1896
		1897	WARN_ON(con->v2.in_enc_pages \|\| con->v2.in_enc_page_cnt);
		1898	con->v2.in_enc_pages = enc_pages;
		1899	con->v2.in_enc_page_cnt = enc_page_cnt;
		1900	con->v2.in_enc_resid = tail_len;
		1901	con->v2.in_enc_i = 0;
		1902
		1903	prepare_read_enc_page(con);
		1904	return 0;
		1905	}
		1906
1784	static void __finish_skip(struct ceph_connection *con)	1907	static void __finish_skip(struct ceph_connection *con)
1785	{	1908	{
1786	con->in_seq++;	1909	con->in_seq++;
@@ -2589,47 +2712,26 @@ static int __handle_control(struct ceph_connection con, void p) · 802 unmodified lines
2589	}	2712	}
2590		2713
2591	msg = con->in_msg; /* set in process_message_header() */	2714	msg = con->in_msg; /* set in process_message_header() */
2592	if (!front_len(msg) && !middle_len(msg)) {
2593	if (!data_len(msg))
2594	return process_message(con);
2595
2596	prepare_read_data(con);
2597	return 0;
2598	}
2599
2600	reset_in_kvecs(con);
2601	if (front_len(msg)) {	2715	if (front_len(msg)) {
2602	WARN_ON(front_len(msg) > msg->front_alloc_len);	2716	WARN_ON(front_len(msg) > msg->front_alloc_len);
2603	add_in_kvec(con, msg->front.iov_base, front_len(msg));
2604	msg->front.iov_len = front_len(msg);	2717	msg->front.iov_len = front_len(msg);
2605
2606	if (con_secure(con) && need_padding(front_len(msg)))
2607	add_in_kvec(con, FRONT_PAD(con->v2.in_buf),
2608	padding_len(front_len(msg)));
2609	} else {	2718	} else {
2610	msg->front.iov_len = 0;	2719	msg->front.iov_len = 0;
2611	}	2720	}
2612	if (middle_len(msg)) {	2721	if (middle_len(msg)) {
2613	WARN_ON(middle_len(msg) > msg->middle->alloc_len);	2722	WARN_ON(middle_len(msg) > msg->middle->alloc_len);
2614	add_in_kvec(con, msg->middle->vec.iov_base, middle_len(msg));
2615	msg->middle->vec.iov_len = middle_len(msg);	2723	msg->middle->vec.iov_len = middle_len(msg);
2616
2617	if (con_secure(con) && need_padding(middle_len(msg)))
2618	add_in_kvec(con, MIDDLE_PAD(con->v2.in_buf),
2619	padding_len(middle_len(msg)));
2620	} else if (msg->middle) {	2724	} else if (msg->middle) {
2621	msg->middle->vec.iov_len = 0;	2725	msg->middle->vec.iov_len = 0;
2622	}	2726	}
2623		2727
2624	if (data_len(msg)) {	2728	if (!front_len(msg) && !middle_len(msg) && !data_len(msg))
2625	con->v2.in_state = IN_S_PREPARE_READ_DATA;	2729	return process_message(con);
2626	} else {	2730
2627	add_in_kvec(con, con->v2.in_buf,	2731	if (con_secure(con))
2628	con_secure(con) ? CEPH_EPILOGUE_SECURE_LEN :	2732	return prepare_read_tail_secure(con);
2629	CEPH_EPILOGUE_PLAIN_LEN);	2733
2630	con->v2.in_state = IN_S_HANDLE_EPILOGUE;	2734	return prepare_read_tail_plain(con);
2631	}
2632	return 0;
2633	}	2735	}
2634		2736
2635	static int handle_preamble(struct ceph_connection *con)	2737	static int handle_preamble(struct ceph_connection *con)
@@ -2717,7 +2819,7 @@ static int handle_epilogue(struct ceph_connection *con) · 81 unmodified lines
2717	int ret;	2819	int ret;
2718		2820
2719	if (con_secure(con)) {	2821	if (con_secure(con)) {
2720	ret = decrypt_message(con);	2822	ret = decrypt_tail(con);
2721	if (ret) {	2823	if (ret) {
2722	if (ret == -EBADMSG)	2824	if (ret == -EBADMSG)
2723	con->error_msg = "integrity error, bad epilogue auth tag";	2825	con->error_msg = "integrity error, bad epilogue auth tag";
@@ -2785,13 +2887,16 @@ static int populate_in_iter(struct ceph_connection *con) · 61 unmodified lines
2785	ret = handle_control_remainder(con);	2887	ret = handle_control_remainder(con);
2786	break;	2888	break;
2787	case IN_S_PREPARE_READ_DATA:	2889	case IN_S_PREPARE_READ_DATA:
2788	prepare_read_data(con);	2890	ret = prepare_read_data(con);
2789	ret = 0;
2790	break;	2891	break;
2791	case IN_S_PREPARE_READ_DATA_CONT:	2892	case IN_S_PREPARE_READ_DATA_CONT:
2792	prepare_read_data_cont(con);	2893	prepare_read_data_cont(con);
2793	ret = 0;	2894	ret = 0;
2794	break;	2895	break;
		2896	case IN_S_PREPARE_READ_ENC_PAGE:
		2897	prepare_read_enc_page(con);
		2898	ret = 0;
		2899	break;
2795	case IN_S_HANDLE_EPILOGUE:	2900	case IN_S_HANDLE_EPILOGUE:
2796	ret = handle_epilogue(con);	2901	ret = handle_epilogue(con);
2797	break;	2902	break;
@@ -3326,20 +3431,16 @@ void ceph_con_v2_revoke(struct ceph_connection *con) · 528 unmodified lines
3326		3431
3327	static void revoke_at_prepare_read_data(struct ceph_connection *con)	3432	static void revoke_at_prepare_read_data(struct ceph_connection *con)
3328	{	3433	{
3329	int remaining; /* data + [data padding] + epilogue */	3434	int remaining;
3330	int resid;	3435	int resid;
3331		3436
		3437	WARN_ON(con_secure(con));
3332	WARN_ON(!data_len(con->in_msg));	3438	WARN_ON(!data_len(con->in_msg));
3333	WARN_ON(!iov_iter_is_kvec(&con->v2.in_iter));	3439	WARN_ON(!iov_iter_is_kvec(&con->v2.in_iter));
3334	resid = iov_iter_count(&con->v2.in_iter);	3440	resid = iov_iter_count(&con->v2.in_iter);
3335	WARN_ON(!resid);	3441	WARN_ON(!resid);
3336		3442
3337	if (con_secure(con))	3443	remaining = data_len(con->in_msg) + CEPH_EPILOGUE_PLAIN_LEN;
3338	remaining = padded_len(data_len(con->in_msg)) +
3339	CEPH_EPILOGUE_SECURE_LEN;
3340	else
3341	remaining = data_len(con->in_msg) + CEPH_EPILOGUE_PLAIN_LEN;
3342
3343	dout("%s con %p resid %d remaining %d\n", __func__, con, resid,	3444	dout("%s con %p resid %d remaining %d\n", __func__, con, resid,
3344	remaining);	3445	remaining);
3345	con->v2.in_iter.count -= resid;	3446	con->v2.in_iter.count -= resid;
@@ -3350,8 +3451,9 @@ static void revoke_at_prepare_read_data(struct ceph_connection *con) · 4 unmodified lines
3350	static void revoke_at_prepare_read_data_cont(struct ceph_connection *con)	3451	static void revoke_at_prepare_read_data_cont(struct ceph_connection *con)
3351	{	3452	{
3352	int recved, resid; /* current piece of data */	3453	int recved, resid; /* current piece of data */
3353	int remaining; /* [data padding] + epilogue */	3454	int remaining;
3354		3455
		3456	WARN_ON(con_secure(con));
3355	WARN_ON(!data_len(con->in_msg));	3457	WARN_ON(!data_len(con->in_msg));
3356	WARN_ON(!iov_iter_is_bvec(&con->v2.in_iter));	3458	WARN_ON(!iov_iter_is_bvec(&con->v2.in_iter));
3357	resid = iov_iter_count(&con->v2.in_iter);	3459	resid = iov_iter_count(&con->v2.in_iter);
@@ -3363,12 +3465,7 @@ static void revoke_at_prepare_read_data_cont(struct ceph_connection *con) · 5 unmodified lines
3363	ceph_msg_data_advance(&con->v2.in_cursor, recved);	3465	ceph_msg_data_advance(&con->v2.in_cursor, recved);
3364	WARN_ON(resid > con->v2.in_cursor.total_resid);	3466	WARN_ON(resid > con->v2.in_cursor.total_resid);
3365		3467
3366	if (con_secure(con))	3468	remaining = CEPH_EPILOGUE_PLAIN_LEN;
3367	remaining = padding_len(data_len(con->in_msg)) +
3368	CEPH_EPILOGUE_SECURE_LEN;
3369	else
3370	remaining = CEPH_EPILOGUE_PLAIN_LEN;
3371
3372	dout("%s con %p total_resid %zu remaining %d\n", __func__, con,	3469	dout("%s con %p total_resid %zu remaining %d\n", __func__, con,
3373	con->v2.in_cursor.total_resid, remaining);	3470	con->v2.in_cursor.total_resid, remaining);
3374	con->v2.in_iter.count -= resid;	3471	con->v2.in_iter.count -= resid;
@@ -3376,11 +3473,26 @@ static void revoke_at_prepare_read_data_cont(struct ceph_connection *con) · 1 unmodified line
3376	con->v2.in_state = IN_S_FINISH_SKIP;	3473	con->v2.in_state = IN_S_FINISH_SKIP;
3377	}	3474	}
3378		3475
		3476	static void revoke_at_prepare_read_enc_page(struct ceph_connection *con)
		3477	{
		3478	int resid; /* current enc page (not necessarily data) */
		3479
		3480	WARN_ON(!con_secure(con));
		3481	WARN_ON(!iov_iter_is_bvec(&con->v2.in_iter));
		3482	resid = iov_iter_count(&con->v2.in_iter);
		3483	WARN_ON(!resid \|\| resid > con->v2.in_bvec.bv_len);
		3484
		3485	dout("%s con %p resid %d enc_resid %d\n", __func__, con, resid,
		3486	con->v2.in_enc_resid);
		3487	con->v2.in_iter.count -= resid;
		3488	set_in_skip(con, resid + con->v2.in_enc_resid);
		3489	con->v2.in_state = IN_S_FINISH_SKIP;
		3490	}
		3491
3379	static void revoke_at_handle_epilogue(struct ceph_connection *con)	3492	static void revoke_at_handle_epilogue(struct ceph_connection *con)
3380	{	3493	{
3381	int resid;	3494	int resid;
3382		3495
3383	WARN_ON(!iov_iter_is_kvec(&con->v2.in_iter));
3384	resid = iov_iter_count(&con->v2.in_iter);	3496	resid = iov_iter_count(&con->v2.in_iter);
3385	WARN_ON(!resid);	3497	WARN_ON(!resid);
3386		3498
@@ -3399,6 +3511,9 @@ void ceph_con_v2_revoke_incoming(struct ceph_connection *con) · 12 unmodified lines
3399	case IN_S_PREPARE_READ_DATA_CONT:	3511	case IN_S_PREPARE_READ_DATA_CONT:
3400	revoke_at_prepare_read_data_cont(con);	3512	revoke_at_prepare_read_data_cont(con);
3401	break;	3513	break;
		3514	case IN_S_PREPARE_READ_ENC_PAGE:
		3515	revoke_at_prepare_read_enc_page(con);
		3516	break;
3402	case IN_S_HANDLE_EPILOGUE:	3517	case IN_S_HANDLE_EPILOGUE:
3403	revoke_at_handle_epilogue(con);	3518	revoke_at_handle_epilogue(con);
3404	break;	3519	break;
@@ -3432,6 +3547,13 @@ void ceph_con_v2_reset_protocol(struct ceph_connection *con) · 27 unmodified lines
3432	clear_out_sign_kvecs(con);	3547	clear_out_sign_kvecs(con);
3433	free_conn_bufs(con);	3548	free_conn_bufs(con);
3434		3549
		3550	if (con->v2.in_enc_pages) {
		3551	WARN_ON(!con->v2.in_enc_page_cnt);
		3552	ceph_release_page_vector(con->v2.in_enc_pages,
		3553	con->v2.in_enc_page_cnt);
		3554	con->v2.in_enc_pages = NULL;
		3555	con->v2.in_enc_page_cnt = 0;
		3556	}
3435	if (con->v2.out_enc_pages) {	3557	if (con->v2.out_enc_pages) {
3436	WARN_ON(!con->v2.out_enc_page_cnt);	3558	WARN_ON(!con->v2.out_enc_page_cnt);
3437	ceph_release_page_vector(con->v2.out_enc_pages,	3559	ceph_release_page_vector(con->v2.out_enc_pages,

net/core/skbuff.c+1−1

@@ -681,7 +681,7 @@ exit: · 680 unmodified lines
681	* while trying to recycle fragments on __skb_frag_unref() we need	681	* while trying to recycle fragments on __skb_frag_unref() we need
682	* to make one SKB responsible for triggering the recycle path.	682	* to make one SKB responsible for triggering the recycle path.
683	* So disable the recycling bit if an SKB is cloned and we have	683	* So disable the recycling bit if an SKB is cloned and we have
684	* additional references to to the fragmented part of the SKB.	684	* additional references to the fragmented part of the SKB.
685	* Eventually the last SKB will have the recycling bit set and it's	685	* Eventually the last SKB will have the recycling bit set and it's
686	* dataref set to 0, which will trigger the recycling	686	* dataref set to 0, which will trigger the recycling
687	*/	687	*/

net/dsa/dsa2.c+6−19

@@ -1784,7 +1784,6 @@ EXPORT_SYMBOL_GPL(dsa_unregister_switch); · 1783 unmodified lines
1784	void dsa_switch_shutdown(struct dsa_switch *ds)	1784	void dsa_switch_shutdown(struct dsa_switch *ds)
1785	{	1785	{
1786	struct net_device master, slave_dev;	1786	struct net_device master, slave_dev;
1787	LIST_HEAD(unregister_list);
1788	struct dsa_port *dp;	1787	struct dsa_port *dp;
1789		1788
1790	mutex_lock(&dsa2_mutex);	1789	mutex_lock(&dsa2_mutex);
@@ -1795,25 +1794,13 @@ void dsa_switch_shutdown(struct dsa_switch *ds) · 4 unmodified lines
1795	slave_dev = dp->slave;	1794	slave_dev = dp->slave;
1796		1795
1797	netdev_upper_dev_unlink(master, slave_dev);	1796	netdev_upper_dev_unlink(master, slave_dev);
1798	/* Just unlinking ourselves as uppers of the master is not
1799	* sufficient. When the master net device unregisters, that will
1800	* also call dev_close, which we will catch as NETDEV_GOING_DOWN
1801	* and trigger a dev_close on our own devices (dsa_slave_close).
1802	* In turn, that will call dev_mc_unsync on the master's net
1803	* device. If the master is also a DSA switch port, this will
1804	* trigger dsa_slave_set_rx_mode which will call dev_mc_sync on
1805	* its own master. Lockdep will complain about the fact that
1806	* all cascaded masters have the same dsa_master_addr_list_lock_key,
1807	* which it normally would not do if the cascaded masters would
1808	* be in a proper upper/lower relationship, which we've just
1809	* destroyed.
1810	* To suppress the lockdep warnings, let's actually unregister
1811	* the DSA slave interfaces too, to avoid the nonsensical
1812	* multicast address list synchronization on shutdown.
1813	*/
1814	unregister_netdevice_queue(slave_dev, &unregister_list);
1815	}	1797	}
1816	unregister_netdevice_many(&unregister_list);	1798
		1799	/* Disconnect from further netdevice notifiers on the master,
		1800	* since netdev_uses_dsa() will now return false.
		1801	*/
		1802	dsa_switch_for_each_cpu_port(dp, ds)
		1803	dp->master->dsa_ptr = NULL;
1817		1804
1818	rtnl_unlock();	1805	rtnl_unlock();
1819	mutex_unlock(&dsa2_mutex);	1806	mutex_unlock(&dsa2_mutex);

net/ipv4/ipmr.c+2−0

 	return 0;
 err2:
+	rtnl_lock();
 	ipmr_free_table(mrt);
+	rtnl_unlock();
 err1:
 	fib_rules_unregister(ops);
 	return err;

net/ipv4/tcp.c+19−14

 	}
 }
+/* skb changing from pure zc to mixed, must charge zc */
+static int tcp_downgrade_zcopy_pure(struct sock *sk, struct sk_buff *skb)
+{
+	if (unlikely(skb_zcopy_pure(skb))) {
+		u32 extra = skb->truesize -
+			    SKB_TRUESIZE(skb_end_offset(skb));
+		if (!sk_wmem_schedule(sk, extra))
+			return -ENOMEM;
+		sk_mem_charge(sk, extra);
+		skb_shinfo(skb)->flags &= ~SKBFL_PURE_ZEROCOPY;
+	}
+	return 0;
+}
 static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
 				      struct page *page, int offset, size_t *size)
 {
 		tcp_mark_push(tp, skb);
 		goto new_segment;
 	}
-	if (!sk_wmem_schedule(sk, copy))
+	if (tcp_downgrade_zcopy_pure(sk, skb) || !sk_wmem_schedule(sk, copy))
 		return NULL;
 	if (can_coalesce) {
 			copy = min_t(int, copy, pfrag->size - pfrag->offset);
-			/* skb changing from pure zc to mixed, must charge zc */
+			if (tcp_downgrade_zcopy_pure(sk, skb) ||
-			if (unlikely(skb_zcopy_pure(skb))) {
+			    !sk_wmem_schedule(sk, copy))
-				u32 extra = skb->truesize -
-					    SKB_TRUESIZE(skb_end_offset(skb));
-				if (!sk_wmem_schedule(sk, extra))
-					goto wait_for_space;
-				sk_mem_charge(sk, extra);
-				skb_shinfo(skb)->flags &= ~SKBFL_PURE_ZEROCOPY;
-			}
-			if (!sk_wmem_schedule(sk, copy))
 				goto wait_for_space;
 			err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,

net/ipv6/ip6mr.c+2−0

 	return 0;
 err2:
+	rtnl_lock();
 	ip6mr_free_table(mrt);
+	rtnl_unlock();
 err1:
 	fib_rules_unregister(ops);
 	return err;

net/mpls/af_mpls.c+1−1

 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 	struct mpls_dev *mdev;
 	unsigned int flags;
+	int err;
 	if (event == NETDEV_REGISTER) {
 		mdev = mpls_add_dev(dev);
 		return NOTIFY_OK;
 	switch (event) {
-		int err;
 	case NETDEV_DOWN:
 		err = mpls_ifdown(dev, event);

net/mptcp/pm_netlink.c+6−2

 static int mptcp_pm_nl_create_listen_socket(struct sock *sk,
 					    struct mptcp_pm_addr_entry *entry)
 {
+	int addrlen = sizeof(struct sockaddr_in);
 	struct sockaddr_storage addr;
 	struct mptcp_sock *msk;
 	struct socket *ssock;
 	}
 	mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family);
-	err = kernel_bind(ssock, (struct sockaddr *)&addr,
+#if IS_ENABLED(CONFIG_MPTCP_IPV6)
-			  sizeof(struct sockaddr_in));
+	if (entry->addr.family == AF_INET6)
+		addrlen = sizeof(struct sockaddr_in6);
+#endif
+	err = kernel_bind(ssock, (struct sockaddr *)&addr, addrlen);
 	if (err) {
 		pr_warn("kernel_bind error, err=%d", err);
 		goto out;

net/netfilter/nf_conntrack_netlink.c+2−1

@@ -2321,7 +2321,8 @@ ctnetlink_create_conntrack(struct net *net, · 2320 unmodified lines
2321	if (helper->from_nlattr)	2321	if (helper->from_nlattr)
2322	helper->from_nlattr(helpinfo, ct);	2322	helper->from_nlattr(helpinfo, ct);
2323		2323
2324	/* not in hash table yet so not strictly necessary */	2324	/* disable helper auto-assignment for this entry */
		2325	ct->status \|= IPS_HELPER;
2325	RCU_INIT_POINTER(help->helper, helper);	2326	RCU_INIT_POINTER(help->helper, helper);
2326	}	2327	}
2327	} else {	2328	} else {

net/netfilter/nf_conntrack_proto_sctp.c+9−0

@@ -489,6 +489,15 @@ int nf_conntrack_sctp_packet(struct nf_conn *ct, · 488 unmodified lines
489	pr_debug("Setting vtag %x for dir %d\n",	489	pr_debug("Setting vtag %x for dir %d\n",
490	ih->init_tag, !dir);	490	ih->init_tag, !dir);
491	ct->proto.sctp.vtag[!dir] = ih->init_tag;	491	ct->proto.sctp.vtag[!dir] = ih->init_tag;
		492
		493	/* don't renew timeout on init retransmit so
		494	* port reuse by client or NAT middlebox cannot
		495	* keep entry alive indefinitely (incl. nat info).
		496	*/
		497	if (new_state == SCTP_CONNTRACK_CLOSED &&
		498	old_state == SCTP_CONNTRACK_CLOSED &&
		499	nf_ct_is_confirmed(ct))
		500	ignore = true;
492	}	501	}
493		502
494	ct->proto.sctp.state = new_state;	503	ct->proto.sctp.state = new_state;

net/netfilter/nf_conntrack_proto_tcp.c+41−18

@@ -446,6 +446,32 @@ static void tcp_sack(const struct sk_buff *skb, unsigned int dataoff, · 445 unmodified lines
446	}	446	}
447	}	447	}
448		448
		449	static void tcp_init_sender(struct ip_ct_tcp_state *sender,
		450	struct ip_ct_tcp_state *receiver,
		451	const struct sk_buff *skb,
		452	unsigned int dataoff,
		453	const struct tcphdr *tcph,
		454	u32 end, u32 win)
		455	{
		456	/* SYN-ACK in reply to a SYN
		457	* or SYN from reply direction in simultaneous open.
		458	*/
		459	sender->td_end =
		460	sender->td_maxend = end;
		461	sender->td_maxwin = (win == 0 ? 1 : win);
		462
		463	tcp_options(skb, dataoff, tcph, sender);
		464	/* RFC 1323:
		465	* Both sides must send the Window Scale option
		466	* to enable window scaling in either direction.
		467	*/
		468	if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE &&
		469	receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE)) {
		470	sender->td_scale = 0;
		471	receiver->td_scale = 0;
		472	}
		473	}
		474
449	static bool tcp_in_window(struct nf_conn *ct,	475	static bool tcp_in_window(struct nf_conn *ct,
450	enum ip_conntrack_dir dir,	476	enum ip_conntrack_dir dir,
451	unsigned int index,	477	unsigned int index,
@@ -499,24 +525,9 @@ static bool tcp_in_window(struct nf_conn *ct, · 47 unmodified lines
499	* Initialize sender data.	525	* Initialize sender data.
500	*/	526	*/
501	if (tcph->syn) {	527	if (tcph->syn) {
502	/*	528	tcp_init_sender(sender, receiver,
503	* SYN-ACK in reply to a SYN	529	skb, dataoff, tcph,
504	* or SYN from reply direction in simultaneous open.	530	end, win);
505	*/
506	sender->td_end =
507	sender->td_maxend = end;
508	sender->td_maxwin = (win == 0 ? 1 : win);
509
510	tcp_options(skb, dataoff, tcph, sender);
511	/*
512	* RFC 1323:
513	* Both sides must send the Window Scale option
514	* to enable window scaling in either direction.
515	*/
516	if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE
517	&& receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE))
518	sender->td_scale =
519	receiver->td_scale = 0;
520	if (!tcph->ack)	531	if (!tcph->ack)
521	/* Simultaneous open */	532	/* Simultaneous open */
522	return true;	533	return true;
@@ -560,6 +571,18 @@ static bool tcp_in_window(struct nf_conn *ct, · 37 unmodified lines
560	sender->td_maxwin = (win == 0 ? 1 : win);	571	sender->td_maxwin = (win == 0 ? 1 : win);
561		572
562	tcp_options(skb, dataoff, tcph, sender);	573	tcp_options(skb, dataoff, tcph, sender);
		574	} else if (tcph->syn && dir == IP_CT_DIR_REPLY &&
		575	state->state == TCP_CONNTRACK_SYN_SENT) {
		576	/* Retransmitted syn-ack, or syn (simultaneous open).
		577	*
		578	* Re-init state for this direction, just like for the first
		579	* syn(-ack) reply, it might differ in seq, ack or tcp options.
		580	*/
		581	tcp_init_sender(sender, receiver,
		582	skb, dataoff, tcph,
		583	end, win);
		584	if (!tcph->ack)
		585	return true;
563	}	586	}
564		587
565	if (!(tcph->ack)) {	588	if (!(tcph->ack)) {

net/netfilter/nft_exthdr.c+1−1

@@ -167,7 +167,7 @@ nft_tcp_header_pointer(const struct nft_pktinfo *pkt, · 166 unmodified lines
167	{	167	{
168	struct tcphdr *tcph;	168	struct tcphdr *tcph;
169		169
170	if (pkt->tprot != IPPROTO_TCP)	170	if (pkt->tprot != IPPROTO_TCP \|\| pkt->fragoff)
171	return NULL;	171	return NULL;
172		172
173	tcph = skb_header_pointer(pkt->skb, nft_thoff(pkt), sizeof(*tcph), buffer);	173	tcph = skb_header_pointer(pkt->skb, nft_thoff(pkt), sizeof(*tcph), buffer);

net/netfilter/nft_payload.c+5−4

 {
 	unsigned int thoff = nft_thoff(pkt);
-	if (!(pkt->flags & NFT_PKTINFO_L4PROTO))
+	if (!(pkt->flags & NFT_PKTINFO_L4PROTO) || pkt->fragoff)
 		return -1;
 	switch (pkt->tprot) {
 		offset = skb_network_offset(skb);
 		break;
 	case NFT_PAYLOAD_TRANSPORT_HEADER:
-		if (!(pkt->flags & NFT_PKTINFO_L4PROTO))
+		if (!(pkt->flags & NFT_PKTINFO_L4PROTO) || pkt->fragoff)
 			goto err;
 		offset = nft_thoff(pkt);
 		break;
 		offset = skb_network_offset(skb);
 		break;
 	case NFT_PAYLOAD_TRANSPORT_HEADER:
-		if (!(pkt->flags & NFT_PKTINFO_L4PROTO))
+		if (!(pkt->flags & NFT_PKTINFO_L4PROTO) || pkt->fragoff)
 			goto err;
 		offset = nft_thoff(pkt);
 		break;
 	if (priv->csum_type == NFT_PAYLOAD_CSUM_SCTP &&
 	    pkt->tprot == IPPROTO_SCTP &&
 	    skb->ip_summed != CHECKSUM_PARTIAL) {
-		if (nft_payload_csum_sctp(skb, nft_thoff(pkt)))
+		if (pkt->fragoff == 0 &&
+		    nft_payload_csum_sctp(skb, nft_thoff(pkt)))
 			goto err;
 	}

net/smc/smc_pnet.c+5−3

 	new_pe->type = SMC_PNET_ETH;
 	memcpy(new_pe->pnet_name, pnet_name, SMC_MAX_PNETID_LEN);
 	strncpy(new_pe->eth_name, eth_name, IFNAMSIZ);
-	new_pe->ndev = ndev;
-	if (ndev)
-		netdev_tracker_alloc(ndev, &new_pe->dev_tracker, GFP_KERNEL);
 	rc = -EEXIST;
 	new_netdev = true;
 	write_lock(&pnettable->lock);
 		}
 	}
 	if (new_netdev) {
+		if (ndev) {
+			new_pe->ndev = ndev;
+			netdev_tracker_alloc(ndev, &new_pe->dev_tracker,
+					     GFP_ATOMIC);
+		}
 		list_add_tail(&new_pe->list, &pnettable->pnetlist);
 		write_unlock(&pnettable->lock);
 	} else {

net/sunrpc/sysfs.c+4−1

 	}
 	sock = container_of(xprt, struct sock_xprt, xprt);
-	if (kernel_getsockname(sock->sock, (struct sockaddr *)&saddr) < 0)
+	mutex_lock(&sock->recv_mutex);
+	if (sock->sock == NULL ||
+	    kernel_getsockname(sock->sock, (struct sockaddr *)&saddr) < 0)
 		goto out;
 	ret = sprintf(buf, "%pISc\n", &saddr);
 out:
+	mutex_unlock(&sock->recv_mutex);
 	xprt_put(xprt);
 	return ret + 1;
 }

net/sunrpc/xprtrdma/verbs.c+3−0

 					      IB_POLL_WORKQUEUE);
 	if (IS_ERR(ep->re_attr.send_cq)) {
 		rc = PTR_ERR(ep->re_attr.send_cq);
+		ep->re_attr.send_cq = NULL;
 		goto out_destroy;
 	}
 					      IB_POLL_WORKQUEUE);
 	if (IS_ERR(ep->re_attr.recv_cq)) {
 		rc = PTR_ERR(ep->re_attr.recv_cq);
+		ep->re_attr.recv_cq = NULL;
 		goto out_destroy;
 	}
 	ep->re_receive_count = 0;
 	ep->re_pd = ib_alloc_pd(device, 0);
 	if (IS_ERR(ep->re_pd)) {
 		rc = PTR_ERR(ep->re_pd);
+		ep->re_pd = NULL;
 		goto out_destroy;
 	}

net/sunrpc/xprtsock.c+6−1

 unsigned short get_srcport(struct rpc_xprt *xprt)
 {
 	struct sock_xprt *sock = container_of(xprt, struct sock_xprt, xprt);
-	return xs_sock_getport(sock->sock);
+	unsigned short ret = 0;
+	mutex_lock(&sock->recv_mutex);
+	if (sock->sock)
+		ret = xs_sock_getport(sock->sock);
+	mutex_unlock(&sock->recv_mutex);
+	return ret;
 }
 EXPORT_SYMBOL(get_srcport);

net/tipc/link.c+7−2

@@ -2200,7 +2200,7 @@ static int tipc_link_proto_rcv(struct tipc_link l, struct sk_buff skb, · 2199 unmodified lines
2200	struct tipc_msg *hdr = buf_msg(skb);	2200	struct tipc_msg *hdr = buf_msg(skb);
2201	struct tipc_gap_ack_blks *ga = NULL;	2201	struct tipc_gap_ack_blks *ga = NULL;
2202	bool reply = msg_probe(hdr), retransmitted = false;	2202	bool reply = msg_probe(hdr), retransmitted = false;
2203	u16 dlen = msg_data_sz(hdr), glen = 0;	2203	u32 dlen = msg_data_sz(hdr), glen = 0;
2204	u16 peers_snd_nxt = msg_next_sent(hdr);	2204	u16 peers_snd_nxt = msg_next_sent(hdr);
2205	u16 peers_tol = msg_link_tolerance(hdr);	2205	u16 peers_tol = msg_link_tolerance(hdr);
2206	u16 peers_prio = msg_linkprio(hdr);	2206	u16 peers_prio = msg_linkprio(hdr);
@@ -2214,6 +2214,10 @@ static int tipc_link_proto_rcv(struct tipc_link l, struct sk_buff skb, · 7 unmodified lines
2214	void *data;	2214	void *data;
2215		2215
2216	trace_tipc_proto_rcv(skb, false, l->name);	2216	trace_tipc_proto_rcv(skb, false, l->name);
		2217
		2218	if (dlen > U16_MAX)
		2219	goto exit;
		2220
2217	if (tipc_link_is_blocked(l) \|\| !xmitq)	2221	if (tipc_link_is_blocked(l) \|\| !xmitq)
2218	goto exit;	2222	goto exit;
2219		2223
@@ -2309,7 +2313,8 @@ static int tipc_link_proto_rcv(struct tipc_link l, struct sk_buff skb, · 89 unmodified lines
2309		2313
2310	/* Receive Gap ACK blocks from peer if any */	2314	/* Receive Gap ACK blocks from peer if any */
2311	glen = tipc_get_gap_ack_blks(&ga, l, hdr, true);	2315	glen = tipc_get_gap_ack_blks(&ga, l, hdr, true);
2312		2316	if(glen > dlen)
		2317	break;
2313	tipc_mon_rcv(l->net, data + glen, dlen - glen, l->addr,	2318	tipc_mon_rcv(l->net, data + glen, dlen - glen, l->addr,
2314	&l->mon_state, l->bearer_id);	2319	&l->mon_state, l->bearer_id);
2315		2320

net/tipc/monitor.c+2−0

@@ -496,6 +496,8 @@ void tipc_mon_rcv(struct net net, void data, u16 dlen, u32 addr, · 495 unmodified lines
496	state->probing = false;	496	state->probing = false;
497		497
498	/* Sanity check received domain record */	498	/* Sanity check received domain record */
		499	if (new_member_cnt > MAX_MON_DOMAIN)
		500	return;
499	if (dlen < dom_rec_len(arrv_dom, 0))	501	if (dlen < dom_rec_len(arrv_dom, 0))
500	return;	502	return;
501	if (dlen != dom_rec_len(arrv_dom, new_member_cnt))	503	if (dlen != dom_rec_len(arrv_dom, new_member_cnt))

net/tipc/name_distr.c+1−1

@@ -313,7 +313,7 @@ static bool tipc_update_nametbl(struct net net, struct distr_item i, · 312 unmodified lines
313	pr_warn_ratelimited("Failed to remove binding %u,%u from %u\n",	313	pr_warn_ratelimited("Failed to remove binding %u,%u from %u\n",
314	ua.sr.type, ua.sr.lower, node);	314	ua.sr.type, ua.sr.lower, node);
315	} else {	315	} else {
316	pr_warn("Unrecognized name table message received\n");	316	pr_warn_ratelimited("Unknown name table message received\n");
317	}	317	}
318	return false;	318	return false;
319	}	319	}

security/integrity/digsig_asymmetric.c+9−6

 	pk = asymmetric_key_public_key(key);
 	pks.pkey_algo = pk->pkey_algo;
-	if (!strcmp(pk->pkey_algo, "rsa"))
+	if (!strcmp(pk->pkey_algo, "rsa")) {
 		pks.encoding = "pkcs1";
-	else if (!strncmp(pk->pkey_algo, "ecdsa-", 6))
+	} else if (!strncmp(pk->pkey_algo, "ecdsa-", 6)) {
 		/* edcsa-nist-p192 etc. */
 		pks.encoding = "x962";
-	else if (!strcmp(pk->pkey_algo, "ecrdsa") ||
+	} else if (!strcmp(pk->pkey_algo, "ecrdsa") ||
-		   !strcmp(pk->pkey_algo, "sm2"))
+		   !strcmp(pk->pkey_algo, "sm2")) {
 		pks.encoding = "raw";
-	else
+	} else {
-		return -ENOPKG;
+		ret = -ENOPKG;
+		goto out;
+	}
 	pks.digest = (u8 *)data;
 	pks.digest_size = datalen;
 	pks.s = hdr->sig;
 	pks.s_size = siglen;
 	ret = verify_signature(key, &pks);
+out:
 	key_put(key);
 	pr_debug("%s() = %d\n", __func__, ret);
 	return ret;

security/integrity/ima/ima_fs.c+1−1

 	return 0;
 out:
+	securityfs_remove(ima_policy);
 	securityfs_remove(violations);
 	securityfs_remove(runtime_measurements_count);
 	securityfs_remove(ascii_runtime_measurements);
 	securityfs_remove(binary_runtime_measurements);
 	securityfs_remove(ima_symlink);
 	securityfs_remove(ima_dir);
-	securityfs_remove(ima_policy);
 	return -1;
 }

security/integrity/ima/ima_policy.c+8−0

@@ -1967,6 +1967,14 @@ int ima_policy_show(struct seq_file m, void v) · 1966 unmodified lines
1967		1967
1968	rcu_read_lock();	1968	rcu_read_lock();
1969		1969
		1970	/* Do not print rules with inactive LSM labels */
		1971	for (i = 0; i < MAX_LSM_RULES; i++) {
		1972	if (entry->lsm[i].args_p && !entry->lsm[i].rule) {
		1973	rcu_read_unlock();
		1974	return 0;
		1975	}
		1976	}
		1977
1970	if (entry->action & MEASURE)	1978	if (entry->action & MEASURE)
1971	seq_puts(m, pt(Opt_measure));	1979	seq_puts(m, pt(Opt_measure));
1972	if (entry->action & DONT_MEASURE)	1980	if (entry->action & DONT_MEASURE)

security/integrity/ima/ima_template.c+7−3

 static LIST_HEAD(defined_templates);
 static DEFINE_SPINLOCK(template_list);
+static int template_setup_done;
 static const struct ima_template_field supported_fields[] = {
 	{.field_id = "d", .field_init = ima_eventdigest_init,
 	struct ima_template_desc *template_desc;
 	int template_len = strlen(str);
-	if (ima_template)
+	if (template_setup_done)
 		return 1;
-	ima_init_template_list();
+	if (!ima_template)
+		ima_init_template_list();
 	/*
 	 * Verify that a template with the supplied name exists.
 	}
 	ima_template = template_desc;
+	template_setup_done = 1;
 	return 1;
 }
 __setup("ima_template=", ima_template_setup);
 {
 	int num_templates = ARRAY_SIZE(builtin_templates);
-	if (ima_template)
+	if (template_setup_done)
 		return 1;
 	if (template_desc_init_fields(str, NULL, NULL) < 0) {
 	builtin_templates[num_templates - 1].fmt = str;
 	ima_template = builtin_templates + num_templates - 1;
+	template_setup_done = 1;
 	return 1;
 }

security/integrity/integrity_audit.c+2−0

@@ -45,6 +45,8 @@ void integrity_audit_message(int audit_msgno, struct inode *inode, · 44 unmodified lines
45	return;	45	return;
46		46
47	ab = audit_log_start(audit_context(), GFP_KERNEL, audit_msgno);	47	ab = audit_log_start(audit_context(), GFP_KERNEL, audit_msgno);
		48	if (!ab)
		49	return;
48	audit_log_format(ab, "pid=%d uid=%u auid=%u ses=%u",	50	audit_log_format(ab, "pid=%d uid=%u auid=%u ses=%u",
49	task_pid_nr(current),	51	task_pid_nr(current),
50	from_kuid(&init_user_ns, current_uid()),	52	from_kuid(&init_user_ns, current_uid()),

sound/core/pcm_native.c+13−0

@@ -172,6 +172,19 @@ unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream) · 171 unmodified lines
172	}	172	}
173	EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave);	173	EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave);
174		174
		175	unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream)
		176	{
		177	unsigned long flags = 0;
		178	if (substream->pcm->nonatomic)
		179	mutex_lock_nested(&substream->self_group.mutex,
		180	SINGLE_DEPTH_NESTING);
		181	else
		182	spin_lock_irqsave_nested(&substream->self_group.lock, flags,
		183	SINGLE_DEPTH_NESTING);
		184	return flags;
		185	}
		186	EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave_nested);
		187
175	/**	188	/**
176	* snd_pcm_stream_unlock_irqrestore - Unlock the PCM stream	189	* snd_pcm_stream_unlock_irqrestore - Unlock the PCM stream
177	* @substream: PCM substream	190	* @substream: PCM substream

sound/hda/intel-sdw-acpi.c+3−4

 static int
 sdw_intel_scan_controller(struct sdw_intel_acpi_info *info)
 {
-	struct acpi_device *adev;
+	struct acpi_device *adev = acpi_fetch_acpi_dev(info->handle);
 	int ret, i;
 	u8 count;
-	if (acpi_bus_get_device(info->handle, &adev))
+	if (!adev)
 		return -EINVAL;
 	/* Found controller, find links supported */
 				     void *cdata, void **return_value)
 {
 	struct sdw_intel_acpi_info *info = cdata;
-	struct acpi_device *adev;
 	acpi_status status;
 	u64 adr;
 	if (ACPI_FAILURE(status))
 		return AE_OK; /* keep going */
-	if (acpi_bus_get_device(handle, &adev)) {
+	if (!acpi_fetch_acpi_dev(handle)) {
 		pr_err("%s: Couldn't find ACPI handle\n", __func__);
 		return AE_NOT_FOUND;
 	}

sound/pci/hda/hda_auto_parser.c+1−1

@@ -981,7 +981,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec, · 980 unmodified lines
981	int id = HDA_FIXUP_ID_NOT_SET;	981	int id = HDA_FIXUP_ID_NOT_SET;
982	const char *name = NULL;	982	const char *name = NULL;
983	const char *type = NULL;	983	const char *type = NULL;
984	int vendor, device;	984	unsigned int vendor, device;
985		985
986	if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)	986	if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
987	return;	987	return;

sound/pci/hda/hda_codec.c+4−0

@@ -3000,6 +3000,10 @@ void snd_hda_codec_shutdown(struct hda_codec *codec) · 2999 unmodified lines
3000	{	3000	{
3001	struct hda_pcm *cpcm;	3001	struct hda_pcm *cpcm;
3002		3002
		3003	/* Skip the shutdown if codec is not registered */
		3004	if (!codec->registered)
		3005	return;
		3006
3003	list_for_each_entry(cpcm, &codec->pcm_list_head, list)	3007	list_for_each_entry(cpcm, &codec->pcm_list_head, list)
3004	snd_pcm_suspend_all(cpcm->pcm);	3008	snd_pcm_suspend_all(cpcm->pcm);
3005		3009

sound/pci/hda/hda_generic.c+15−2

 	free_kctls(spec);
 	snd_array_free(&spec->paths);
 	snd_array_free(&spec->loopback_list);
+#ifdef CONFIG_SND_HDA_GENERIC_LEDS
+	if (spec->led_cdevs[LED_AUDIO_MUTE])
+		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);
+	if (spec->led_cdevs[LED_AUDIO_MICMUTE])
+		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);
+#endif
 }
 /*
 						enum led_brightness),
 				bool micmute)
 {
+	struct hda_gen_spec *spec = codec->spec;
 	struct led_classdev *cdev;
+	int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;
+	int err;
 	cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
 	if (!cdev)
 	cdev->max_brightness = 1;
 	cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
 	cdev->brightness_set_blocking = callback;
-	cdev->brightness = ledtrig_audio_get(micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE);
+	cdev->brightness = ledtrig_audio_get(idx);
 	cdev->flags = LED_CORE_SUSPENDRESUME;
-	return devm_led_classdev_register(&codec->core.dev, cdev);
+	err = led_classdev_register(&codec->core.dev, cdev);
+	if (err < 0)
+		return err;
+	spec->led_cdevs[idx] = cdev;
+	return 0;
 }
 /**

sound/pci/hda/hda_generic.h+3−0

@@ -294,6 +294,9 @@ struct hda_gen_spec { · 293 unmodified lines
294	struct hda_jack_callback *cb);	294	struct hda_jack_callback *cb);
295	void (mic_autoswitch_hook)(struct hda_codec codec,	295	void (mic_autoswitch_hook)(struct hda_codec codec,
296	struct hda_jack_callback *cb);	296	struct hda_jack_callback *cb);
		297
		298	/* leds */
		299	struct led_classdev *led_cdevs[NUM_AUDIO_LEDS];
297	};	300	};
298		301
299	/* values for add_stereo_mix_input flag */	302	/* values for add_stereo_mix_input flag */

sound/pci/hda/patch_realtek.c+55−12

 	unsigned int gpio_mic_led_mask;
 	struct alc_coef_led mute_led_coef;
 	struct alc_coef_led mic_led_coef;
+	struct mutex coef_mutex;
 	hda_nid_t headset_mic_pin;
 	hda_nid_t headphone_mic_pin;
  * COEF access helper functions
  */
-static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
-			       unsigned int coef_idx)
+				 unsigned int coef_idx)
 {
 	unsigned int val;
 	return val;
 }
+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);
+	val = __alc_read_coefex_idx(codec, nid, coef_idx);
+	mutex_unlock(&spec->coef_mutex);
+	return val;
+}
 #define alc_read_coef_idx(codec, coef_idx) \
 	alc_read_coefex_idx(codec, 0x20, coef_idx)
-static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
-				 unsigned int coef_idx, unsigned int coef_val)
+				   unsigned int coef_idx, unsigned int coef_val)
 {
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_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;
+	mutex_lock(&spec->coef_mutex);
+	__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
+	mutex_unlock(&spec->coef_mutex);
+}
 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
+static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+				    unsigned int coef_idx, unsigned int mask,
+				    unsigned int bits_set)
+{
+	unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
+	if (val != -1)
+		__alc_write_coefex_idx(codec, nid, coef_idx,
+				       (val & ~mask) | bits_set);
+}
 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 				  unsigned int coef_idx, unsigned int mask,
 				  unsigned int bits_set)
 {
-	unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
+	struct alc_spec *spec = codec->spec;
-	if (val != -1)
+	mutex_lock(&spec->coef_mutex);
-		alc_write_coefex_idx(codec, nid, coef_idx,
+	__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
-				     (val & ~mask) | bits_set);
+	mutex_unlock(&spec->coef_mutex);
 }
 #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;
+	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_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 		else
-			alc_update_coefex_idx(codec, fw->nid, fw->idx,
+			__alc_update_coefex_idx(codec, fw->nid, fw->idx,
-					      fw->mask, fw->val);
+						fw->mask, fw->val);
 	}
+	mutex_unlock(&spec->coef_mutex);
 }
 /*
 	codec->spdif_status_reset = 1;
 	codec->forced_resume = 1;
 	codec->patch_ops = alc_patch_ops;
+	mutex_init(&spec->coef_mutex);
 	err = alc_codec_rename_from_preset(codec);
 	if (err < 0) {
 {
 	static const hda_nid_t conn1[] = { 0x0c };
 	static const struct coef_fw gb_x570_coefs[] = {
+		WRITE_COEF(0x07, 0x03c0),
 		WRITE_COEF(0x1a, 0x01c1),
 		WRITE_COEF(0x1b, 0x0202),
 		WRITE_COEF(0x43, 0x3005),
 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
 	SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
-	SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950),
+	SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
+	SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
 	SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
 	SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
 	SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
 	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
 	{.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
 	{.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
+	{.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
 	{.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
 	{}
 };
 	SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
 	SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
 	SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
+	SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),

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

@@ -303,11 +303,11 @@ static const struct snd_soc_dapm_route rt1019_map_lr[] = { · 302 unmodified lines
303		303
304	static struct snd_soc_codec_conf rt1019_conf[] = {	304	static struct snd_soc_codec_conf rt1019_conf[] = {
305	{	305	{
306	.dlc = COMP_CODEC_CONF("i2c-10EC1019:00"),	306	.dlc = COMP_CODEC_CONF("i2c-10EC1019:01"),
307	.name_prefix = "Left",	307	.name_prefix = "Left",
308	},	308	},
309	{	309	{
310	.dlc = COMP_CODEC_CONF("i2c-10EC1019:01"),	310	.dlc = COMP_CODEC_CONF("i2c-10EC1019:00"),
311	.name_prefix = "Right",	311	.name_prefix = "Right",
312	},	312	},
313	};	313	};

sound/soc/codecs/cpcap.c+2−0

@@ -1667,6 +1667,8 @@ static int cpcap_codec_probe(struct platform_device *pdev) · 1666 unmodified lines
1667	{	1667	{
1668	struct device_node *codec_node =	1668	struct device_node *codec_node =
1669	of_get_child_by_name(pdev->dev.parent->of_node, "audio-codec");	1669	of_get_child_by_name(pdev->dev.parent->of_node, "audio-codec");
		1670	if (!codec_node)
		1671	return -ENODEV;
1670		1672
1671	pdev->dev.of_node = codec_node;	1673	pdev->dev.of_node = codec_node;
1672		1674

sound/soc/codecs/hdmi-codec.c+1−1

@@ -277,7 +277,7 @@ struct hdmi_codec_priv { · 276 unmodified lines
277	bool busy;	277	bool busy;
278	struct snd_soc_jack *jack;	278	struct snd_soc_jack *jack;
279	unsigned int jack_status;	279	unsigned int jack_status;
280	u8 iec_status[5];	280	u8 iec_status[AES_IEC958_STATUS_SIZE];
281	};	281	};
282		282
283	static const struct snd_soc_dapm_widget hdmi_widgets[] = {	283	static const struct snd_soc_dapm_widget hdmi_widgets[] = {

sound/soc/codecs/lpass-rx-macro.c+4−4

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

@@ -64,7 +64,8 @@ static int speaker_gain_control_put(struct snd_kcontrol *kcontrol, · 63 unmodified lines
64	struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);	64	struct snd_soc_component *c = snd_soc_kcontrol_component(kcontrol);
65	struct max9759 *priv = snd_soc_component_get_drvdata(c);	65	struct max9759 *priv = snd_soc_component_get_drvdata(c);
66		66
67	if (ucontrol->value.integer.value[0] > 3)	67	if (ucontrol->value.integer.value[0] < 0 \|\|
		68	ucontrol->value.integer.value[0] > 3)
68	return -EINVAL;	69	return -EINVAL;
69		70
70	priv->gain = ucontrol->value.integer.value[0];	71	priv->gain = ucontrol->value.integer.value[0];

sound/soc/codecs/rt5682-i2c.c+4−11

@@ -59,18 +59,12 @@ static void rt5682_jd_check_handler(struct work_struct *work) · 58 unmodified lines
59	struct rt5682_priv *rt5682 = container_of(work, struct rt5682_priv,	59	struct rt5682_priv *rt5682 = container_of(work, struct rt5682_priv,
60	jd_check_work.work);	60	jd_check_work.work);
61		61
62	if (snd_soc_component_read(rt5682->component, RT5682_AJD1_CTRL)	62	if (snd_soc_component_read(rt5682->component, RT5682_AJD1_CTRL) & RT5682_JDH_RS_MASK)
63	& RT5682_JDH_RS_MASK) {
64	/* jack out */	63	/* jack out */
65	rt5682->jack_type = rt5682_headset_detect(rt5682->component, 0);	64	mod_delayed_work(system_power_efficient_wq,
66		65	&rt5682->jack_detect_work, 0);
67	snd_soc_jack_report(rt5682->hs_jack, rt5682->jack_type,	66	else
68	SND_JACK_HEADSET \|
69	SND_JACK_BTN_0 \| SND_JACK_BTN_1 \|
70	SND_JACK_BTN_2 \| SND_JACK_BTN_3);
71	} else {
72	schedule_delayed_work(&rt5682->jd_check_work, 500);	67	schedule_delayed_work(&rt5682->jd_check_work, 500);
73	}
74	}	68	}
75		69
76	static irqreturn_t rt5682_irq(int irq, void *data)	70	static irqreturn_t rt5682_irq(int irq, void *data)
@@ -198,7 +192,6 @@ static int rt5682_i2c_probe(struct i2c_client *i2c, · 121 unmodified lines
198	}	192	}
199		193
200	mutex_init(&rt5682->calibrate_mutex);	194	mutex_init(&rt5682->calibrate_mutex);
201	mutex_init(&rt5682->jdet_mutex);
202	rt5682_calibrate(rt5682);	195	rt5682_calibrate(rt5682);
203		196
204	rt5682_apply_patch_list(rt5682, &i2c->dev);	197	rt5682_apply_patch_list(rt5682, &i2c->dev);

sound/soc/codecs/rt5682.c+8−16

  *
  * Returns detect status.
  */
-int rt5682_headset_detect(struct snd_soc_component *component, int jack_insert)
+static int rt5682_headset_detect(struct snd_soc_component *component, int jack_insert)
 {
 	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);
 	struct snd_soc_dapm_context *dapm = &component->dapm;
 	unsigned int val, count;
 	if (jack_insert) {
-		snd_soc_dapm_mutex_lock(dapm);
 		snd_soc_component_update_bits(component, RT5682_PWR_ANLG_1,
 			RT5682_PWR_VREF2 | RT5682_PWR_MB,
 			RT5682_PWR_VREF2 | RT5682_PWR_MB);
 		snd_soc_component_update_bits(component, RT5682_MICBIAS_2,
 			RT5682_PWR_CLK25M_MASK | RT5682_PWR_CLK1M_MASK,
 			RT5682_PWR_CLK25M_PU | RT5682_PWR_CLK1M_PU);
-		snd_soc_dapm_mutex_unlock(dapm);
 	} else {
 		rt5682_enable_push_button_irq(component, false);
 		snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1,
 	dev_dbg(component->dev, "jack_type = %d\n", rt5682->jack_type);
 	return rt5682->jack_type;
 }
-EXPORT_SYMBOL_GPL(rt5682_headset_detect);
 static int rt5682_set_jack_detect(struct snd_soc_component *component,
 		struct snd_soc_jack *hs_jack, void *data)
 {
 	struct rt5682_priv *rt5682 =
 		container_of(work, struct rt5682_priv, jack_detect_work.work);
+	struct snd_soc_dapm_context *dapm;
 	int val, btn_type;
 	while (!rt5682->component)
 	while (!rt5682->component->card->instantiated)
 		usleep_range(10000, 15000);
-	mutex_lock(&rt5682->jdet_mutex);
+	dapm = snd_soc_component_get_dapm(rt5682->component);
+	snd_soc_dapm_mutex_lock(dapm);
 	mutex_lock(&rt5682->calibrate_mutex);
 	val = snd_soc_component_read(rt5682->component, RT5682_AJD1_CTRL)
 		rt5682->irq_work_delay_time = 50;
 	}
+	mutex_unlock(&rt5682->calibrate_mutex);
+	snd_soc_dapm_mutex_unlock(dapm);
 	snd_soc_jack_report(rt5682->hs_jack, rt5682->jack_type,
 		SND_JACK_HEADSET |
 		SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 		else
 			cancel_delayed_work_sync(&rt5682->jd_check_work);
 	}
-	mutex_unlock(&rt5682->calibrate_mutex);
-	mutex_unlock(&rt5682->jdet_mutex);
 }
 EXPORT_SYMBOL_GPL(rt5682_jack_detect_handler);
 {
 	struct snd_soc_component *component =
 		snd_soc_dapm_to_component(w->dapm);
-	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);
 	switch (event) {
 	case SND_SOC_DAPM_PRE_PMU:
 			RT5682_DEPOP_1, 0x60, 0x60);
 		snd_soc_component_update_bits(component,
 			RT5682_DAC_ADC_DIG_VOL1, 0x00c0, 0x0080);
-		mutex_lock(&rt5682->jdet_mutex);
 		snd_soc_component_update_bits(component, RT5682_HP_CTRL_2,
 			RT5682_HP_C2_DAC_L_EN | RT5682_HP_C2_DAC_R_EN,
 			RT5682_HP_C2_DAC_L_EN | RT5682_HP_C2_DAC_R_EN);
 		usleep_range(5000, 10000);
 		snd_soc_component_update_bits(component, RT5682_CHARGE_PUMP_1,
 			RT5682_CP_SW_SIZE_MASK, RT5682_CP_SW_SIZE_L);
-		mutex_unlock(&rt5682->jdet_mutex);
 		break;
 	case SND_SOC_DAPM_POST_PMD:

sound/soc/codecs/rt5682.h+0−2

 	int jack_type;
 	int irq_work_delay_time;
-	struct mutex jdet_mutex;
 };
 extern const char *rt5682_supply_names[RT5682_NUM_SUPPLIES];
 void rt5682_apply_patch_list(struct rt5682_priv *rt5682, struct device *dev);
-int rt5682_headset_detect(struct snd_soc_component *component, int jack_insert);
 void rt5682_jack_detect_handler(struct work_struct *work);
 bool rt5682_volatile_register(struct device *dev, unsigned int reg);

sound/soc/codecs/wcd938x.c+17−14

 	return 0;
 }
-static int wcd938x_connect_port(struct wcd938x_sdw_priv *wcd, u8 ch_id, u8 enable)
+static int wcd938x_connect_port(struct wcd938x_sdw_priv *wcd, u8 port_num, u8 ch_id, u8 enable)
 {
-	u8 port_num;
-	port_num = wcd->ch_info[ch_id].port_num;
 	return wcd938x_sdw_connect_port(&wcd->ch_info[ch_id],
-					&wcd->port_config[port_num],
+					&wcd->port_config[port_num - 1],
 					enable);
 }
 				      WCD938X_EAR_GAIN_MASK,
 				      ucontrol->value.integer.value[0]);
-	return 0;
+	return 1;
 }
 static int wcd938x_get_compander(struct snd_kcontrol *kcontrol,
 	struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 	struct wcd938x_sdw_priv *wcd;
 	int value = ucontrol->value.integer.value[0];
+	int portidx;
 	struct soc_mixer_control *mc;
 	bool hphr;
 	else
 		wcd938x->comp1_enable = value;
+	portidx = wcd->ch_info[mc->reg].port_num;
 	if (value)
-		wcd938x_connect_port(wcd, mc->reg, true);
+		wcd938x_connect_port(wcd, portidx, mc->reg, true);
 	else
-		wcd938x_connect_port(wcd, mc->reg, false);
+		wcd938x_connect_port(wcd, portidx, mc->reg, false);
-	return 0;
+	return 1;
 }
 static int wcd938x_ldoh_get(struct snd_kcontrol *kcontrol,
 	struct wcd938x_sdw_priv *wcd;
 	struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
 	int dai_id = mixer->shift;
-	int portidx = mixer->reg;
+	int portidx, ch_idx = mixer->reg;
 	wcd = wcd938x->sdw_priv[dai_id];
+	portidx = wcd->ch_info[ch_idx].port_num;
 	ucontrol->value.integer.value[0] = wcd->port_enable[portidx];
 	struct wcd938x_sdw_priv *wcd;
 	struct soc_mixer_control *mixer =
 		(struct soc_mixer_control *)kcontrol->private_value;
-	int portidx = mixer->reg;
+	int ch_idx = mixer->reg;
+	int portidx;
 	int dai_id = mixer->shift;
 	bool enable;
 	wcd = wcd938x->sdw_priv[dai_id];
+	portidx = wcd->ch_info[ch_idx].port_num;
 	if (ucontrol->value.integer.value[0])
 		enable = true;
 	else
 	wcd->port_enable[portidx] = enable;
-	wcd938x_connect_port(wcd, portidx, enable);
+	wcd938x_connect_port(wcd, portidx, ch_idx, enable);
-	return 0;
+	return 1;
 }

sound/soc/fsl/pcm030-audio-fabric.c+8−3

 		dev_err(&op->dev, "platform_device_alloc() failed\n");
 	ret = platform_device_add(pdata->codec_device);
-	if (ret)
+	if (ret) {
 		dev_err(&op->dev, "platform_device_add() failed: %d\n", ret);
+		platform_device_put(pdata->codec_device);
+	}
 	ret = snd_soc_register_card(card);
-	if (ret)
+	if (ret) {
 		dev_err(&op->dev, "snd_soc_register_card() failed: %d\n", ret);
+		platform_device_del(pdata->codec_device);
+		platform_device_put(pdata->codec_device);
+	}
 	platform_set_drvdata(op, pdata);
 	return ret;
 }
 static int pcm030_fabric_remove(struct platform_device *op)

sound/soc/generic/simple-card.c+25−1

@@ -28,6 +28,30 @@ static const struct snd_soc_ops simple_ops = { · 27 unmodified lines
28	.hw_params = asoc_simple_hw_params,	28	.hw_params = asoc_simple_hw_params,
29	};	29	};
30		30
		31	static int asoc_simple_parse_platform(struct device_node *node,
		32	struct snd_soc_dai_link_component *dlc)
		33	{
		34	struct of_phandle_args args;
		35	int ret;
		36
		37	if (!node)
		38	return 0;
		39
		40	/*
		41	* Get node via "sound-dai = <&phandle port>"
		42	* it will be used as xxx_of_node on soc_bind_dai_link()
		43	*/
		44	ret = of_parse_phandle_with_args(node, DAI, CELL, 0, &args);
		45	if (ret)
		46	return ret;
		47
		48	/* dai_name is not required and may not exist for plat component */
		49
		50	dlc->of_node = args.np;
		51
		52	return 0;
		53	}
		54
31	static int asoc_simple_parse_dai(struct device_node *node,	55	static int asoc_simple_parse_dai(struct device_node *node,
32	struct snd_soc_dai_link_component *dlc,	56	struct snd_soc_dai_link_component *dlc,
33	int *is_single_link)	57	int *is_single_link)
@@ -289,7 +313,7 @@ static int simple_dai_link_of(struct asoc_simple_priv *priv, · 255 unmodified lines
289	if (ret < 0)	313	if (ret < 0)
290	goto dai_link_of_err;	314	goto dai_link_of_err;
291		315
292	ret = asoc_simple_parse_dai(plat, platforms, NULL);	316	ret = asoc_simple_parse_platform(plat, platforms);
293	if (ret < 0)	317	if (ret < 0)
294	goto dai_link_of_err;	318	goto dai_link_of_err;
295		319

sound/soc/mediatek/Kconfig+1−1

@@ -216,7 +216,7 @@ config SND_SOC_MT8195_MT6359_RT1019_RT5682 · 215 unmodified lines
216		216
217	config SND_SOC_MT8195_MT6359_RT1011_RT5682	217	config SND_SOC_MT8195_MT6359_RT1011_RT5682
218	tristate "ASoC Audio driver for MT8195 with MT6359 RT1011 RT5682 codec"	218	tristate "ASoC Audio driver for MT8195 with MT6359 RT1011 RT5682 codec"
219	depends on I2C	219	depends on I2C && GPIOLIB
220	depends on SND_SOC_MT8195 && MTK_PMIC_WRAP	220	depends on SND_SOC_MT8195 && MTK_PMIC_WRAP
221	select SND_SOC_MT6359	221	select SND_SOC_MT6359
222	select SND_SOC_RT1011	222	select SND_SOC_RT1011

sound/soc/qcom/qdsp6/q6apm-dai.c+5−2

 	struct snd_pcm_runtime *runtime = substream->runtime;
 	struct q6apm_dai_rtd *prtd = runtime->private_data;
-	q6apm_graph_stop(prtd->graph);
+	if (prtd->state) { /* only stop graph that is started */
-	q6apm_unmap_memory_regions(prtd->graph, substream->stream);
+		q6apm_graph_stop(prtd->graph);
+		q6apm_unmap_memory_regions(prtd->graph, substream->stream);
+	}
 	q6apm_graph_close(prtd->graph);
 	prtd->graph = NULL;
 	kfree(prtd);

sound/soc/soc-acpi.c+2−5

 static acpi_status snd_soc_acpi_find_package(acpi_handle handle, u32 level,
 					     void *context, void **ret)
 {
-	struct acpi_device *adev;
+	struct acpi_device *adev = acpi_fetch_acpi_dev(handle);
 	acpi_status status;
 	struct snd_soc_acpi_package_context *pkg_ctx = context;
 	pkg_ctx->data_valid = false;
-	if (acpi_bus_get_device(handle, &adev))
+	if (adev && adev->status.present && adev->status.functional) {
-		return AE_OK;
-	if (adev->status.present && adev->status.functional) {
 		struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 		union acpi_object  *myobj = NULL;

sound/soc/soc-ops.c+26−3

 	if (sign_bit)
 		mask = BIT(sign_bit + 1) - 1;
-	val = ((ucontrol->value.integer.value[0] + min) & mask);
+	if (ucontrol->value.integer.value[0] < 0)
+		return -EINVAL;
+	val = ucontrol->value.integer.value[0];
+	if (mc->platform_max && val > mc->platform_max)
+		return -EINVAL;
+	if (val > max - min)
+		return -EINVAL;
+	val = (val + min) & mask;
 	if (invert)
 		val = max - val;
 	val_mask = mask << shift;
 	val = val << shift;
 	if (snd_soc_volsw_is_stereo(mc)) {
-		val2 = ((ucontrol->value.integer.value[1] + min) & mask);
+		if (ucontrol->value.integer.value[1] < 0)
+			return -EINVAL;
+		val2 = ucontrol->value.integer.value[1];
+		if (mc->platform_max && val2 > mc->platform_max)
+			return -EINVAL;
+		if (val2 > max - min)
+			return -EINVAL;
+		val2 = (val2 + min) & mask;
 		if (invert)
 			val2 = max - val2;
 		if (reg == reg2) {
 	int err = 0;
 	unsigned int val, val_mask;
+	if (ucontrol->value.integer.value[0] < 0)
+		return -EINVAL;
+	val = ucontrol->value.integer.value[0];
+	if (mc->platform_max && val > mc->platform_max)
+		return -EINVAL;
+	if (val > max - min)
+		return -EINVAL;
 	val_mask = mask << shift;
-	val = (ucontrol->value.integer.value[0] + min) & mask;
+	val = (val + min) & mask;
 	val = val << shift;
 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
 	long val = ucontrol->value.integer.value[0];
 	unsigned int i;
+	if (val < mc->min || val > mc->max)
+		return -EINVAL;
 	if (invert)
 		val = max - val;
 	val &= mask;

sound/soc/soc-pcm.c+12−6

 	snd_pcm_stream_lock_irq(snd_soc_dpcm_get_substream(rtd, stream));
 }
-#define snd_soc_dpcm_stream_lock_irqsave(rtd, stream, flags) \
+#define snd_soc_dpcm_stream_lock_irqsave_nested(rtd, stream, flags) \
-	snd_pcm_stream_lock_irqsave(snd_soc_dpcm_get_substream(rtd, stream), flags)
+	snd_pcm_stream_lock_irqsave_nested(snd_soc_dpcm_get_substream(rtd, stream), flags)
 static inline void snd_soc_dpcm_stream_unlock_irq(struct snd_soc_pcm_runtime *rtd,
 						  int stream)
 void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
 {
 	struct snd_soc_dpcm *dpcm, *d;
+	LIST_HEAD(deleted_dpcms);
 	snd_soc_dpcm_mutex_assert_held(fe);
 		/* BEs still alive need new FE */
 		dpcm_be_reparent(fe, dpcm->be, stream);
-		dpcm_remove_debugfs_state(dpcm);
 		list_del(&dpcm->list_be);
+		list_move(&dpcm->list_fe, &deleted_dpcms);
+	}
+	snd_soc_dpcm_stream_unlock_irq(fe, stream);
+	while (!list_empty(&deleted_dpcms)) {
+		dpcm = list_first_entry(&deleted_dpcms, struct snd_soc_dpcm,
+					list_fe);
 		list_del(&dpcm->list_fe);
+		dpcm_remove_debugfs_state(dpcm);
 		kfree(dpcm);
 	}
-	snd_soc_dpcm_stream_unlock_irq(fe, stream);
 }
 /* get BE for DAI widget and stream */
 		be = dpcm->be;
 		be_substream = snd_soc_dpcm_get_substream(be, stream);
-		snd_soc_dpcm_stream_lock_irqsave(be, stream, flags);
+		snd_soc_dpcm_stream_lock_irqsave_nested(be, stream, flags);
 		/* is this op for this BE ? */
 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))

sound/soc/xilinx/xlnx_formatter_pcm.c+24−3

@@ -37,6 +37,7 @@ · 36 unmodified lines
37	#define XLNX_AUD_XFER_COUNT 0x28	37	#define XLNX_AUD_XFER_COUNT 0x28
38	#define XLNX_AUD_CH_STS_START 0x2C	38	#define XLNX_AUD_CH_STS_START 0x2C
39	#define XLNX_BYTES_PER_CH 0x44	39	#define XLNX_BYTES_PER_CH 0x44
		40	#define XLNX_AUD_ALIGN_BYTES 64
40		41
41	#define AUD_STS_IOC_IRQ_MASK BIT(31)	42	#define AUD_STS_IOC_IRQ_MASK BIT(31)
42	#define AUD_STS_CH_STS_MASK BIT(29)	43	#define AUD_STS_CH_STS_MASK BIT(29)
@@ -368,12 +369,32 @@ static int xlnx_formatter_pcm_open(struct snd_soc_component *component, · 325 unmodified lines
368	snd_soc_set_runtime_hwparams(substream, &xlnx_pcm_hardware);	369	snd_soc_set_runtime_hwparams(substream, &xlnx_pcm_hardware);
369	runtime->private_data = stream_data;	370	runtime->private_data = stream_data;
370		371
371	/* Resize the period size divisible by 64 */	372	/* Resize the period bytes as divisible by 64 */
372	err = snd_pcm_hw_constraint_step(runtime, 0,	373	err = snd_pcm_hw_constraint_step(runtime, 0,
373	SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64);	374	SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
		375	XLNX_AUD_ALIGN_BYTES);
374	if (err) {	376	if (err) {
375	dev_err(component->dev,	377	dev_err(component->dev,
376	"unable to set constraint on period bytes\n");	378	"Unable to set constraint on period bytes\n");
		379	return err;
		380	}
		381
		382	/* Resize the buffer bytes as divisible by 64 */
		383	err = snd_pcm_hw_constraint_step(runtime, 0,
		384	SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
		385	XLNX_AUD_ALIGN_BYTES);
		386	if (err) {
		387	dev_err(component->dev,
		388	"Unable to set constraint on buffer bytes\n");
		389	return err;
		390	}
		391
		392	/* Set periods as integer multiple */
		393	err = snd_pcm_hw_constraint_integer(runtime,
		394	SNDRV_PCM_HW_PARAM_PERIODS);
		395	if (err < 0) {
		396	dev_err(component->dev,
		397	"Unable to set constraint on periods to be integer\n");
377	return err;	398	return err;
378	}	399	}
379		400

sound/usb/mixer.c+4−0

@@ -1527,6 +1527,10 @@ error: · 1526 unmodified lines
1527	usb_audio_err(chip,	1527	usb_audio_err(chip,
1528	"cannot get connectors status: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",	1528	"cannot get connectors status: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
1529	UAC_GET_CUR, validx, idx, cval->val_type);	1529	UAC_GET_CUR, validx, idx, cval->val_type);
		1530
		1531	if (val)
		1532	*val = 0;
		1533
1530	return filter_error(cval, ret);	1534	return filter_error(cval, ret);
1531	}	1535	}
1532		1536

sound/usb/quirks-table.h+1−1

@@ -84,7 +84,7 @@ · 83 unmodified lines
84	* combination.	84	* combination.
85	*/	85	*/
86	{	86	{
87	USB_DEVICE(0x041e, 0x4095),	87	USB_AUDIO_DEVICE(0x041e, 0x4095),
88	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {	88	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
89	.ifnum = QUIRK_ANY_INTERFACE,	89	.ifnum = QUIRK_ANY_INTERFACE,
90	.type = QUIRK_COMPOSITE,	90	.type = QUIRK_COMPOSITE,

tools/arch/x86/include/asm/cpufeatures.h+2−0

 /* Intel-defined CPU features, CPUID level 0x00000007:1 (EAX), word 12 */
 #define X86_FEATURE_AVX_VNNI		(12*32+ 4) /* AVX VNNI instructions */
 #define X86_FEATURE_AVX512_BF16		(12*32+ 5) /* AVX512 BFLOAT16 instructions */
+#define X86_FEATURE_AMX_BF16		(18*32+22) /* AMX bf16 Support */
 #define X86_FEATURE_AMX_TILE		(18*32+24) /* AMX tile Support */
+#define X86_FEATURE_AMX_INT8		(18*32+25) /* AMX int8 Support */
 /* AMD-defined CPU features, CPUID level 0x80000008 (EBX), word 13 */
 #define X86_FEATURE_CLZERO		(13*32+ 0) /* CLZERO instruction */

tools/include/uapi/linux/kvm.h+3−3

 #define KVM_S390_NORMAL_RESET	_IO(KVMIO,   0xc3)
 #define KVM_S390_CLEAR_RESET	_IO(KVMIO,   0xc4)
-/* Available with KVM_CAP_XSAVE2 */
-#define KVM_GET_XSAVE2		  _IOR(KVMIO,  0xcf, struct kvm_xsave)
 struct kvm_s390_pv_sec_parm {
 	__u64 origin;
 	__u64 length;
 #define KVM_GET_STATS_FD  _IO(KVMIO,  0xce)
+/* Available with KVM_CAP_XSAVE2 */
+#define KVM_GET_XSAVE2		  _IOR(KVMIO,  0xcf, struct kvm_xsave)
 #endif /* __LINUX_KVM_H */

tools/include/uapi/linux/perf_event.h+3−3

@@ -1332,9 +1332,9 @@ union perf_mem_data_src { · 1331 unmodified lines
1332		1332
1333	/* hop level */	1333	/* hop level */
1334	#define PERF_MEM_HOPS_0 0x01 /* remote core, same node */	1334	#define PERF_MEM_HOPS_0 0x01 /* remote core, same node */
1335	#define PERF_MEM_HOPS_1 0x02 /* remote node, same socket */	1335	#define PERF_MEM_HOPS_1 0x02 /* remote node, same socket */
1336	#define PERF_MEM_HOPS_2 0x03 /* remote socket, same board */	1336	#define PERF_MEM_HOPS_2 0x03 /* remote socket, same board */
1337	#define PERF_MEM_HOPS_3 0x04 /* remote board */	1337	#define PERF_MEM_HOPS_3 0x04 /* remote board */
1338	/* 5-7 available */	1338	/* 5-7 available */
1339	#define PERF_MEM_HOPS_SHIFT 43	1339	#define PERF_MEM_HOPS_SHIFT 43
1340		1340

tools/include/uapi/linux/prctl.h+3−0

@@ -272,4 +272,7 @@ struct prctl_mm_map { · 271 unmodified lines
272	# define PR_SCHED_CORE_SCOPE_THREAD_GROUP 1	272	# define PR_SCHED_CORE_SCOPE_THREAD_GROUP 1
273	# define PR_SCHED_CORE_SCOPE_PROCESS_GROUP 2	273	# define PR_SCHED_CORE_SCOPE_PROCESS_GROUP 2
274		274
		275	#define PR_SET_VMA 0x53564d41
		276	# define PR_SET_VMA_ANON_NAME 0
		277
275	#endif /* _LINUX_PRCTL_H */	278	#endif /* _LINUX_PRCTL_H */

tools/include/uapi/sound/asound.h+9−2

tools/lib/perf/mmap.c+98−0

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <internal/lib.h>	13	#include <internal/lib.h>
14	#include <linux/kernel.h>	14	#include <linux/kernel.h>
15	#include <linux/math64.h>	15	#include <linux/math64.h>
		16	#include <linux/stringify.h>
16	#include "internal.h"	17	#include "internal.h"
17		18
18	void perf_mmap__init(struct perf_mmap map, struct perf_mmap prev,	19	void perf_mmap__init(struct perf_mmap map, struct perf_mmap prev,
@@ -294,6 +295,103 @@ static u64 read_timestamp(void) · 275 unmodified lines
294		295
295	return low \| ((u64)high) << 32;	296	return low \| ((u64)high) << 32;
296	}	297	}
		298	#elif defined(__aarch64__)
		299	#define read_sysreg(r) ({ \
		300	u64 __val; \
		301	asm volatile("mrs %0, " __stringify(r) : "=r" (__val)); \
		302	__val; \
		303	})
		304
		305	static u64 read_pmccntr(void)
		306	{
		307	return read_sysreg(pmccntr_el0);
		308	}
		309
		310	#define PMEVCNTR_READ(idx) \
		311	static u64 read_pmevcntr_##idx(void) { \
		312	return read_sysreg(pmevcntr##idx##_el0); \
		313	}
		314
		315	PMEVCNTR_READ(0);
		316	PMEVCNTR_READ(1);
		317	PMEVCNTR_READ(2);
		318	PMEVCNTR_READ(3);
		319	PMEVCNTR_READ(4);
		320	PMEVCNTR_READ(5);
		321	PMEVCNTR_READ(6);
		322	PMEVCNTR_READ(7);
		323	PMEVCNTR_READ(8);
		324	PMEVCNTR_READ(9);
		325	PMEVCNTR_READ(10);
		326	PMEVCNTR_READ(11);
		327	PMEVCNTR_READ(12);
		328	PMEVCNTR_READ(13);
		329	PMEVCNTR_READ(14);
		330	PMEVCNTR_READ(15);
		331	PMEVCNTR_READ(16);
		332	PMEVCNTR_READ(17);
		333	PMEVCNTR_READ(18);
		334	PMEVCNTR_READ(19);
		335	PMEVCNTR_READ(20);
		336	PMEVCNTR_READ(21);
		337	PMEVCNTR_READ(22);
		338	PMEVCNTR_READ(23);
		339	PMEVCNTR_READ(24);
		340	PMEVCNTR_READ(25);
		341	PMEVCNTR_READ(26);
		342	PMEVCNTR_READ(27);
		343	PMEVCNTR_READ(28);
		344	PMEVCNTR_READ(29);
		345	PMEVCNTR_READ(30);
		346
		347	/*
		348	* Read a value direct from PMEVCNTR<idx>
		349	*/
		350	static u64 read_perf_counter(unsigned int counter)
		351	{
		352	static u64 (* const read_f[])(void) = {
		353	read_pmevcntr_0,
		354	read_pmevcntr_1,
		355	read_pmevcntr_2,
		356	read_pmevcntr_3,
		357	read_pmevcntr_4,
		358	read_pmevcntr_5,
		359	read_pmevcntr_6,
		360	read_pmevcntr_7,
		361	read_pmevcntr_8,
		362	read_pmevcntr_9,
		363	read_pmevcntr_10,
		364	read_pmevcntr_11,
		365	read_pmevcntr_13,
		366	read_pmevcntr_12,
		367	read_pmevcntr_14,
		368	read_pmevcntr_15,
		369	read_pmevcntr_16,
		370	read_pmevcntr_17,
		371	read_pmevcntr_18,
		372	read_pmevcntr_19,
		373	read_pmevcntr_20,
		374	read_pmevcntr_21,
		375	read_pmevcntr_22,
		376	read_pmevcntr_23,
		377	read_pmevcntr_24,
		378	read_pmevcntr_25,
		379	read_pmevcntr_26,
		380	read_pmevcntr_27,
		381	read_pmevcntr_28,
		382	read_pmevcntr_29,
		383	read_pmevcntr_30,
		384	read_pmccntr
		385	};
		386
		387	if (counter < ARRAY_SIZE(read_f))
		388	return (read_f[counter])();
		389
		390	return 0;
		391	}
		392
		393	static u64 read_timestamp(void) { return read_sysreg(cntvct_el0); }
		394
297	#else	395	#else
298	static u64 read_perf_counter(unsigned int counter __maybe_unused) { return 0; }	396	static u64 read_perf_counter(unsigned int counter __maybe_unused) { return 0; }
299	static u64 read_timestamp(void) { return 0; }	397	static u64 read_timestamp(void) { return 0; }

tools/lib/perf/tests/test-evsel.c+4−1

 	struct perf_event_attr attr = {
 		.type	= PERF_TYPE_HARDWARE,
 		.config	= event,
+#ifdef __aarch64__
+		.config1 = 0x2,		/* Request user access */
+#endif
 	};
 	int err, i;
 	pc = perf_evsel__mmap_base(evsel, 0, 0);
 	__T("failed to get mmapped address", pc);
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
 	__T("userspace counter access not supported", pc->cap_user_rdpmc);
 	__T("userspace counter access not enabled", pc->index);
 	__T("userspace counter width not set", pc->pmc_width >= 32);

tools/objtool/check.c+1−1

@@ -2854,7 +2854,7 @@ static inline bool func_uaccess_safe(struct symbol *func) · 2853 unmodified lines
2854		2854
2855	static inline const char call_dest_name(struct instruction insn)	2855	static inline const char call_dest_name(struct instruction insn)
2856	{	2856	{
2857	static char pvname[16];	2857	static char pvname[19];
2858	struct reloc *rel;	2858	struct reloc *rel;
2859	int idx;	2859	int idx;
2860		2860

tools/perf/builtin-ftrace.c+24−21

 int cmd_ftrace(int argc, const char **argv)
 {
 	int ret;
+	int (*cmd_func)(struct perf_ftrace *) = NULL;
 	struct perf_ftrace ftrace = {
 		.tracer = DEFAULT_TRACER,
 		.target = { .uid = UINT_MAX, },
 		goto out_delete_filters;
 	}
+	switch (subcmd) {
+	case PERF_FTRACE_TRACE:
+		if (!argc && target__none(&ftrace.target))
+			ftrace.target.system_wide = true;
+		cmd_func = __cmd_ftrace;
+		break;
+	case PERF_FTRACE_LATENCY:
+		if (list_empty(&ftrace.filters)) {
+			pr_err("Should provide a function to measure\n");
+			parse_options_usage(ftrace_usage, options, "T", 1);
+			ret = -EINVAL;
+			goto out_delete_filters;
+		}
+		cmd_func = __cmd_latency;
+		break;
+	case PERF_FTRACE_NONE:
+	default:
+		pr_err("Invalid subcommand\n");
+		ret = -EINVAL;
+		goto out_delete_filters;
+	}
 	ret = target__validate(&ftrace.target);
 	if (ret) {
 		char errbuf[512];
 			goto out_delete_evlist;
 	}
-	switch (subcmd) {
+	ret = cmd_func(&ftrace);
-	case PERF_FTRACE_TRACE:
-		if (!argc && target__none(&ftrace.target))
-			ftrace.target.system_wide = true;
-		ret = __cmd_ftrace(&ftrace);
-		break;
-	case PERF_FTRACE_LATENCY:
-		if (list_empty(&ftrace.filters)) {
-			pr_err("Should provide a function to measure\n");
-			parse_options_usage(ftrace_usage, options, "T", 1);
-			ret = -EINVAL;
-			goto out_delete_evlist;
-		}
-		ret = __cmd_latency(&ftrace);
-		break;
-	case PERF_FTRACE_NONE:
-	default:
-		pr_err("Invalid subcommand\n");
-		ret = -EINVAL;
-		break;
-	}
 out_delete_evlist:
 	evlist__delete(ftrace.evlist);

tools/perf/trace/beauty/prctl_option.sh+1−1

@@ -4,7 +4,7 @@ · 3 unmodified lines
4	[ $# -eq 1 ] && header_dir=$1 \|\| header_dir=tools/include/uapi/linux/	4	[ $# -eq 1 ] && header_dir=$1 \|\| header_dir=tools/include/uapi/linux/
5		5
6	printf "static const char *prctl_options[] = {\n"	6	printf "static const char *prctl_options[] = {\n"
7	regex='^#define[[:space:]]+PR_(\w+)[[:space:]]([[:xdigit:]]+).'	7	regex='^#define[[:space:]]{1}PR_(\w+)[[:space:]]([[:xdigit:]]+)([[:space:]]\/.*)?$'
8	egrep $regex ${header_dir}/prctl.h \| grep -v PR_SET_PTRACER \| \	8	egrep $regex ${header_dir}/prctl.h \| grep -v PR_SET_PTRACER \| \
9	sed -r "s/$regex/\2 \1/g" \| \	9	sed -r "s/$regex/\2 \1/g" \| \
10	sort -n \| xargs printf "\t[%s] = \"%s\",\n"	10	sort -n \| xargs printf "\t[%s] = \"%s\",\n"

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

@@ -2036,6 +2036,7 @@ static int symbol__disassemble(struct symbol sym, struct annotate_args args) · 2035 unmodified lines
2036	memset(&objdump_process, 0, sizeof(objdump_process));	2036	memset(&objdump_process, 0, sizeof(objdump_process));
2037	objdump_process.argv = objdump_argv;	2037	objdump_process.argv = objdump_argv;
2038	objdump_process.out = -1;	2038	objdump_process.out = -1;
		2039	objdump_process.err = -1;
2039	if (start_command(&objdump_process)) {	2040	if (start_command(&objdump_process)) {
2040	pr_err("Failure starting to run %s\n", command);	2041	pr_err("Failure starting to run %s\n", command);
2041	err = -1;	2042	err = -1;

tools/perf/util/bpf_counter_cgroup.c+1−1

@@ -266,7 +266,7 @@ static int bperf_cgrp__read(struct evsel *evsel) · 265 unmodified lines
266	idx = evsel->core.idx;	266	idx = evsel->core.idx;
267	err = bpf_map_lookup_elem(reading_map_fd, &idx, values);	267	err = bpf_map_lookup_elem(reading_map_fd, &idx, values);
268	if (err) {	268	if (err) {
269	pr_err("bpf map lookup falied: idx=%u, event=%s, cgrp=%s\n",	269	pr_err("bpf map lookup failed: idx=%u, event=%s, cgrp=%s\n",
270	idx, evsel__name(evsel), evsel->cgrp->name);	270	idx, evsel__name(evsel), evsel->cgrp->name);
271	goto out;	271	goto out;
272	}	272	}

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

 	ams->addr = ip;
 	ams->al_addr = al.addr;
+	ams->al_level = al.level;
 	ams->ms.maps = al.maps;
 	ams->ms.sym = al.sym;
 	ams->ms.map = al.map;
 	ams->addr = addr;
 	ams->al_addr = al.addr;
+	ams->al_level = al.level;
 	ams->ms.maps = al.maps;
 	ams->ms.sym = al.sym;
 	ams->ms.map = al.map;

tools/perf/util/map_symbol.h+1−0

@@ -18,6 +18,7 @@ struct addr_map_symbol { · 17 unmodified lines
18	struct map_symbol ms;	18	struct map_symbol ms;
19	u64 addr;	19	u64 addr;
20	u64 al_addr;	20	u64 al_addr;
		21	char al_level;
21	u64 phys_addr;	22	u64 phys_addr;
22	u64 data_page_size;	23	u64 data_page_size;
23	};	24	};

tools/perf/util/perf_event_attr_fprintf.c+1−1

@@ -52,7 +52,7 @@ static void __p_branch_sample_type(char *buf, size_t size, u64 value) · 51 unmodified lines
52	bit_name(ABORT_TX), bit_name(IN_TX), bit_name(NO_TX),	52	bit_name(ABORT_TX), bit_name(IN_TX), bit_name(NO_TX),
53	bit_name(COND), bit_name(CALL_STACK), bit_name(IND_JUMP),	53	bit_name(COND), bit_name(CALL_STACK), bit_name(IND_JUMP),
54	bit_name(CALL), bit_name(NO_FLAGS), bit_name(NO_CYCLES),	54	bit_name(CALL), bit_name(NO_FLAGS), bit_name(NO_CYCLES),
55	bit_name(HW_INDEX),	55	bit_name(TYPE_SAVE), bit_name(HW_INDEX),
56	{ .name = NULL, }	56	{ .name = NULL, }
57	};	57	};
58	#undef bit_name	58	#undef bit_name

tools/perf/util/session.c+2−1

 			++evlist->stats.nr_unknown_id;
 			return 0;
 		}
-		dump_sample(evsel, event, sample, perf_env__arch(machine->env));
 		if (machine == NULL) {
 			++evlist->stats.nr_unprocessable_samples;
+			dump_sample(evsel, event, sample, perf_env__arch(NULL));
 			return 0;
 		}
+		dump_sample(evsel, event, sample, perf_env__arch(machine->env));
 		return evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
 	case PERF_RECORD_MMAP:
 		return tool->mmap(tool, event, sample, machine);

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

@@ -915,7 +915,7 @@ static int hist_entry__sym_from_snprintf(struct hist_entry he, char bf, · 914 unmodified lines
915	struct addr_map_symbol *from = &he->branch_info->from;	915	struct addr_map_symbol *from = &he->branch_info->from;
916		916
917	return _hist_entry__sym_snprintf(&from->ms, from->al_addr,	917	return _hist_entry__sym_snprintf(&from->ms, from->al_addr,
918	he->level, bf, size, width);	918	from->al_level, bf, size, width);
919	}	919	}
920		920
921	return repsep_snprintf(bf, size, "%-.s", width, width, "N/A");	921	return repsep_snprintf(bf, size, "%-.s", width, width, "N/A");
@@ -928,7 +928,7 @@ static int hist_entry__sym_to_snprintf(struct hist_entry he, char bf, · 6 unmodified lines
928	struct addr_map_symbol *to = &he->branch_info->to;	928	struct addr_map_symbol *to = &he->branch_info->to;
929		929
930	return _hist_entry__sym_snprintf(&to->ms, to->al_addr,	930	return _hist_entry__sym_snprintf(&to->ms, to->al_addr,
931	he->level, bf, size, width);	931	to->al_level, bf, size, width);
932	}	932	}
933		933
934	return repsep_snprintf(bf, size, "%-.s", width, width, "N/A");	934	return repsep_snprintf(bf, size, "%-.s", width, width, "N/A");

tools/perf/util/stat-display.c+10−9

@@ -585,15 +585,16 @@ static void collect_all_aliases(struct perf_stat_config config, struct evsel c · 584 unmodified lines
585		585
586	alias = list_prepare_entry(counter, &(evlist->core.entries), core.node);	586	alias = list_prepare_entry(counter, &(evlist->core.entries), core.node);
587	list_for_each_entry_continue (alias, &evlist->core.entries, core.node) {	587	list_for_each_entry_continue (alias, &evlist->core.entries, core.node) {
588	if (strcmp(evsel__name(alias), evsel__name(counter)) \|\|	588	/* Merge events with the same name, etc. but on different PMUs. */
589	alias->scale != counter->scale \|\|	589	if (!strcmp(evsel__name(alias), evsel__name(counter)) &&
590	alias->cgrp != counter->cgrp \|\|	590	alias->scale == counter->scale &&
591	strcmp(alias->unit, counter->unit) \|\|	591	alias->cgrp == counter->cgrp &&
592	evsel__is_clock(alias) != evsel__is_clock(counter) \|\|	592	!strcmp(alias->unit, counter->unit) &&
593	!strcmp(alias->pmu_name, counter->pmu_name))	593	evsel__is_clock(alias) == evsel__is_clock(counter) &&
594	break;	594	strcmp(alias->pmu_name, counter->pmu_name)) {
595	alias->merged_stat = true;	595	alias->merged_stat = true;
596	cb(config, alias, data, false);	596	cb(config, alias, data, false);
		597	}
597	}	598	}
598	}	599	}
599		600

tools/perf/util/synthetic-events.c+19−0

@@ -1784,6 +1784,25 @@ int __machine__synthesize_threads(struct machine machine, struct perf_tool too · 1783 unmodified lines
1784	perf_event__handler_t process, bool needs_mmap,	1784	perf_event__handler_t process, bool needs_mmap,
1785	bool data_mmap, unsigned int nr_threads_synthesize)	1785	bool data_mmap, unsigned int nr_threads_synthesize)
1786	{	1786	{
		1787	/*
		1788	* When perf runs in non-root PID namespace, and the namespace's proc FS
		1789	* is not mounted, nsinfo__is_in_root_namespace() returns false.
		1790	* In this case, the proc FS is coming for the parent namespace, thus
		1791	* perf tool will wrongly gather process info from its parent PID
		1792	* namespace.
		1793	*
		1794	* To avoid the confusion that the perf tool runs in a child PID
		1795	* namespace but it synthesizes thread info from its parent PID
		1796	* namespace, returns failure with warning.
		1797	*/
		1798	if (!nsinfo__is_in_root_namespace()) {
		1799	pr_err("Perf runs in non-root PID namespace but it tries to ");
		1800	pr_err("gather process info from its parent PID namespace.\n");
		1801	pr_err("Please mount the proc file system properly, e.g. ");
		1802	pr_err("add the option '--mount-proc' for unshare command.\n");
		1803	return -EPERM;
		1804	}
		1805
1787	if (target__has_task(target))	1806	if (target__has_task(target))
1788	return perf_event__synthesize_thread_map(tool, threads, process, machine,	1807	return perf_event__synthesize_thread_map(tool, threads, process, machine,
1789	needs_mmap, data_mmap);	1808	needs_mmap, data_mmap);

tools/testing/kunit/run_checks.py+1−1

@@ -61,7 +61,7 @@ def main(argv: Sequence[str]) -> None: · 60 unmodified lines
61	elif isinstance(ex, subprocess.CalledProcessError):	61	elif isinstance(ex, subprocess.CalledProcessError):
62	print(f'{name}: FAILED')	62	print(f'{name}: FAILED')
63	else:	63	else:
64	print('{name}: unexpected exception: {ex}')	64	print(f'{name}: unexpected exception: {ex}')
65	continue	65	continue
66		66
67	output = ex.output	67	output = ex.output

tools/testing/selftests/clone3/clone3.c+0−2

@@ -126,8 +126,6 @@ static void test_clone3(uint64_t flags, size_t size, int expected, · 125 unmodified lines
126		126
127	int main(int argc, char *argv[])	127	int main(int argc, char *argv[])
128	{	128	{
129	pid_t pid;
130
131	uid_t uid = getuid();	129	uid_t uid = getuid();
132		130
133	ksft_print_header();	131	ksft_print_header();

tools/testing/selftests/ir/ir_loopback.c+10−0

@@ -29,6 +29,16 @@ · 28 unmodified lines
29	#define SYSFS_PATH_MAX 256	29	#define SYSFS_PATH_MAX 256
30	#define DNAME_PATH_MAX 256	30	#define DNAME_PATH_MAX 256
31		31
		32	/*
		33	* Support ancient lirc.h which does not have these values. Can be removed
		34	* once RHEL 8 is no longer a relevant testing platform.
		35	*/
		36	#if RC_PROTO_MAX < 26
		37	#define RC_PROTO_RCMM12 24
		38	#define RC_PROTO_RCMM24 25
		39	#define RC_PROTO_RCMM32 26
		40	#endif
		41
32	static const struct {	42	static const struct {
33	enum rc_proto proto;	43	enum rc_proto proto;
34	const char *name;	44	const char *name;

tools/testing/selftests/net/mptcp/mptcp_join.sh+1−0

@@ -1299,6 +1299,7 @@ signal_address_tests() · 1298 unmodified lines
1299	pm_nl_add_endpoint $ns2 10.0.3.2 flags signal	1299	pm_nl_add_endpoint $ns2 10.0.3.2 flags signal
1300	pm_nl_add_endpoint $ns2 10.0.4.2 flags signal	1300	pm_nl_add_endpoint $ns2 10.0.4.2 flags signal
1301	run_tests $ns1 $ns2 10.0.1.1	1301	run_tests $ns1 $ns2 10.0.1.1
		1302	chk_join_nr "signal addresses race test" 3 3 3
1302		1303
1303	# the server will not signal the address terminating	1304	# the server will not signal the address terminating
1304	# the MPC subflow	1305	# the MPC subflow

tools/testing/selftests/perf_events/sigtrap_threads.c+9−8

 } ctx;
 /* Unique value to check si_perf_data is correctly set from perf_event_attr::sig_data. */
-#define TEST_SIG_DATA(addr) (~(unsigned long)(addr))
+#define TEST_SIG_DATA(addr, id) (~(unsigned long)(addr) + id)
-static struct perf_event_attr make_event_attr(bool enabled, volatile void *addr)
+static struct perf_event_attr make_event_attr(bool enabled, volatile void *addr,
+					      unsigned long id)
 {
 	struct perf_event_attr attr = {
 		.type		= PERF_TYPE_BREAKPOINT,
 		.inherit_thread = 1, /* ... but only cloned with CLONE_THREAD. */
 		.remove_on_exec = 1, /* Required by sigtrap. */
 		.sigtrap	= 1, /* Request synchronous SIGTRAP on event. */
-		.sig_data	= TEST_SIG_DATA(addr),
+		.sig_data	= TEST_SIG_DATA(addr, id),
 	};
 	return attr;
 }
 FIXTURE_SETUP(sigtrap_threads)
 {
-	struct perf_event_attr attr = make_event_attr(false, &ctx.iterate_on);
+	struct perf_event_attr attr = make_event_attr(false, &ctx.iterate_on, 0);
 	struct sigaction action = {};
 	int i;
 	EXPECT_EQ(ctx.tids_want_signal, 0);
 	EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 	EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
-	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on));
+	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 0));
 	/* Check enabled for parent. */
 	ctx.iterate_on = 0;
 /* Test that modification propagates to all inherited events. */
 TEST_F(sigtrap_threads, modify_and_enable_event)
 {
-	struct perf_event_attr new_attr = make_event_attr(true, &ctx.iterate_on);
+	struct perf_event_attr new_attr = make_event_attr(true, &ctx.iterate_on, 42);
 	EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &new_attr), 0);
 	run_test_threads(_metadata, self);
 	EXPECT_EQ(ctx.tids_want_signal, 0);
 	EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 	EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
-	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on));
+	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 42));
 	/* Check enabled for parent. */
 	ctx.iterate_on = 0;
 	EXPECT_EQ(ctx.tids_want_signal, 0);
 	EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 	EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
-	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on));
+	EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 0));
 }
 TEST_HARNESS_MAIN

tools/testing/selftests/pidfd/pidfd.h+10−3

 #define PIDFD_SKIP 3
 #define PIDFD_XFAIL 4
-int wait_for_pid(pid_t pid)
+static inline int wait_for_pid(pid_t pid)
 {
 	int status, ret;
 		if (errno == EINTR)
 			goto again;
+		ksft_print_msg("waitpid returned -1, errno=%d\n", errno);
 		return -1;
 	}
-	if (!WIFEXITED(status))
+	if (!WIFEXITED(status)) {
+		ksft_print_msg(
+		       "waitpid !WIFEXITED, WIFSIGNALED=%d, WTERMSIG=%d\n",
+		       WIFSIGNALED(status), WTERMSIG(status));
 		return -1;
+	}
-	return WEXITSTATUS(status);
+	ret = WEXITSTATUS(status);
+	ksft_print_msg("waitpid WEXITSTATUS=%d\n", ret);
+	return ret;
 }
 static inline int sys_pidfd_open(pid_t pid, unsigned int flags)

tools/testing/selftests/pidfd/pidfd_fdinfo_test.c+18−4

 #include <string.h>
 #include <syscall.h>
 #include <sys/wait.h>
+#include <sys/mman.h>
 #include "pidfd.h"
 #include "../kselftest.h"
 	return err->code;
 }
+#define CHILD_STACK_SIZE 8192
 struct child {
+	char *stack;
 	pid_t pid;
 	int   fd;
 };
 				struct error *err)
 {
 	static int flags = CLONE_PIDFD | CLONE_NEWPID | CLONE_NEWNS | SIGCHLD;
-	size_t stack_size = 1024;
-	char *stack[1024] = { 0 };
 	struct child ret;
 	if (!(flags & CLONE_NEWUSER) && geteuid() != 0)
 		flags |= CLONE_NEWUSER;
+	ret.stack = mmap(NULL, CHILD_STACK_SIZE, PROT_READ | PROT_WRITE,
+			 MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+	if (ret.stack == MAP_FAILED) {
+		error_set(err, -1, "mmap of stack failed (errno %d)", errno);
+		return ret;
+	}
 #ifdef __ia64__
-	ret.pid = __clone2(fn, stack, stack_size, flags, args, &ret.fd);
+	ret.pid = __clone2(fn, ret.stack, CHILD_STACK_SIZE, flags, args, &ret.fd);
 #else
-	ret.pid = clone(fn, stack + stack_size, flags, args, &ret.fd);
+	ret.pid = clone(fn, ret.stack + CHILD_STACK_SIZE, flags, args, &ret.fd);
 #endif
 	if (ret.pid < 0) {
 	else if (r > 0)
 		error_set(err, r, "child %d reported: %d", child->pid, r);
+	if (munmap(child->stack, CHILD_STACK_SIZE)) {
+		error_set(err, -1, "munmap of child stack failed (errno %d)", errno);
+		r = -1;
+	}
 	return r;
 }

tools/testing/selftests/pidfd/pidfd_test.c+3−3

 {
 	int pid, pidfd = 0;
 	int status, ret;
-	pthread_t t1;
 	time_t prog_start = time(NULL);
 	const char *test_name = "pidfd_poll check for premature notification on child thread exec";
 	 */
 	*child_exit_secs = time(NULL);
 	syscall(SYS_exit, 0);
+	/* Never reached, but appeases compiler thinking we should return. */
+	exit(0);
 }
 static void test_pidfd_poll_leader_exit(int use_waitpid)
 {
 	int pid, pidfd = 0;
-	int status, ret;
+	int status, ret = 0;
-	time_t prog_start = time(NULL);
 	const char *test_name = "pidfd_poll check for premature notification on non-empty"
 				"group leader exit";

tools/testing/selftests/pidfd/pidfd_wait.c+2−3

 TEST(wait_simple)
 {
-	int pidfd = -1, status = 0;
+	int pidfd = -1;
 	pid_t parent_tid = -1;
 	struct clone_args args = {
 		.parent_tid = ptr_to_u64(&parent_tid),
 		.flags = CLONE_PIDFD | CLONE_PARENT_SETTID,
 		.exit_signal = SIGCHLD,
 	};
-	int ret;
 	pid_t pid;
 	siginfo_t info = {
 		.si_signo = 0,
 TEST(wait_states)
 {
-	int pidfd = -1, status = 0;
+	int pidfd = -1;
 	pid_t parent_tid = -1;
 	struct clone_args args = {
 		.parent_tid = ptr_to_u64(&parent_tid),

tools/testing/selftests/vm/userfaultfd.c+7−2

 static int userfaultfd_stress(void)
 {
 	void *area;
+	char *tmp_area;
 	unsigned long nr;
 	struct uffdio_register uffdio_register;
 	struct uffd_stats uffd_stats[nr_cpus];
 					    count_verify[nr], nr);
 		/* prepare next bounce */
-		swap(area_src, area_dst);
+		tmp_area = area_src;
+		area_src = area_dst;
+		area_dst = tmp_area;
-		swap(area_src_alias, area_dst_alias);
+		tmp_area = area_src_alias;
+		area_src_alias = area_dst_alias;
+		area_dst_alias = tmp_area;
 		uffd_stats_report(uffd_stats, nr_cpus);
 	}

@@ -115,6 +115,7 @@ Code Seq# Include File Comments · 114 unmodified lines
115	'B' 00-1F linux/cciss_ioctl.h conflict!	115	'B' 00-1F linux/cciss_ioctl.h conflict!
116	'B' 00-0F include/linux/pmu.h conflict!	116	'B' 00-0F include/linux/pmu.h conflict!
117	'B' C0-FF advanced bbus <mailto:maassen@uni-freiburg.de>	117	'B' C0-FF advanced bbus <mailto:maassen@uni-freiburg.de>
		118	'B' 00-0F xen/xenbus_dev.h conflict!
118	'C' all linux/soundcard.h conflict!	119	'C' all linux/soundcard.h conflict!
119	'C' 01-2F linux/capi.h conflict!	120	'C' 01-2F linux/capi.h conflict!
120	'C' F0-FF drivers/net/wan/cosa.h conflict!	121	'C' F0-FF drivers/net/wan/cosa.h conflict!
@@ -134,6 +135,7 @@ Code Seq# Include File Comments · 13 unmodified lines
134	'F' 80-8F linux/arcfb.h conflict!	135	'F' 80-8F linux/arcfb.h conflict!
135	'F' DD video/sstfb.h conflict!	136	'F' DD video/sstfb.h conflict!
136	'G' 00-3F drivers/misc/sgi-gru/grulib.h conflict!	137	'G' 00-3F drivers/misc/sgi-gru/grulib.h conflict!
		138	'G' 00-0F xen/gntalloc.h, xen/gntdev.h conflict!
137	'H' 00-7F linux/hiddev.h conflict!	139	'H' 00-7F linux/hiddev.h conflict!
138	'H' 00-0F linux/hidraw.h conflict!	140	'H' 00-0F linux/hidraw.h conflict!
139	'H' 01 linux/mei.h conflict!	141	'H' 01 linux/mei.h conflict!
@@ -176,6 +178,7 @@ Code Seq# Include File Comments · 36 unmodified lines
176	'P' 60-6F sound/sscape_ioctl.h conflict!	178	'P' 60-6F sound/sscape_ioctl.h conflict!
177	'P' 00-0F drivers/usb/class/usblp.c conflict!	179	'P' 00-0F drivers/usb/class/usblp.c conflict!
178	'P' 01-09 drivers/misc/pci_endpoint_test.c conflict!	180	'P' 01-09 drivers/misc/pci_endpoint_test.c conflict!
		181	'P' 00-0F xen/privcmd.h conflict!
179	'Q' all linux/soundcard.h	182	'Q' all linux/soundcard.h
180	'R' 00-1F linux/random.h conflict!	183	'R' 00-1F linux/random.h conflict!
181	'R' 01 linux/rfkill.h conflict!	184	'R' 01 linux/rfkill.h conflict!

@@ -2688,8 +2688,8 @@ static uint32_t get_iir_band_coeff(struct snd_soc_component *component, · 2687 unmodified lines
2688	int reg, b2_reg;	2688	int reg, b2_reg;
2689		2689
2690	/* Address does not automatically update if reading */	2690	/* Address does not automatically update if reading */
2691	reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B1_CTL + 16 * iir_idx;	2691	reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B1_CTL + 0x80 * iir_idx;
2692	b2_reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B2_CTL + 16 * iir_idx;	2692	b2_reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B2_CTL + 0x80 * iir_idx;
2693		2693
2694	snd_soc_component_write(component, reg,	2694	snd_soc_component_write(component, reg,
2695	((band_idx * BAND_MAX + coeff_idx) *	2695	((band_idx * BAND_MAX + coeff_idx) *
@@ -2718,7 +2718,7 @@ static uint32_t get_iir_band_coeff(struct snd_soc_component *component, · 22 unmodified lines
2718	static void set_iir_band_coeff(struct snd_soc_component *component,	2718	static void set_iir_band_coeff(struct snd_soc_component *component,
2719	int iir_idx, int band_idx, uint32_t value)	2719	int iir_idx, int band_idx, uint32_t value)
2720	{	2720	{
2721	int reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B2_CTL + 16 * iir_idx;	2721	int reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B2_CTL + 0x80 * iir_idx;
2722		2722
2723	snd_soc_component_write(component, reg, (value & 0xFF));	2723	snd_soc_component_write(component, reg, (value & 0xFF));
2724	snd_soc_component_write(component, reg, (value >> 8) & 0xFF);	2724	snd_soc_component_write(component, reg, (value >> 8) & 0xFF);
@@ -2739,7 +2739,7 @@ static int rx_macro_put_iir_band_audio_mixer( · 14 unmodified lines
2739	int iir_idx = ctl->iir_idx;	2739	int iir_idx = ctl->iir_idx;
2740	int band_idx = ctl->band_idx;	2740	int band_idx = ctl->band_idx;
2741	u32 coeff[BAND_MAX];	2741	u32 coeff[BAND_MAX];
2742	int reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B1_CTL + 16 * iir_idx;	2742	int reg = CDC_RX_SIDETONE_IIR0_IIR_COEF_B1_CTL + 0x80 * iir_idx;
2743		2743
2744	memcpy(&coeff[0], ucontrol->value.bytes.data, params->max);	2744	memcpy(&coeff[0], ucontrol->value.bytes.data, params->max);
2745		2745

@@ -56,8 +56,10 @@ · 55 unmodified lines
56	* *	56	* *
57	****************************************************************************/	57	****************************************************************************/
58		58
		59	#define AES_IEC958_STATUS_SIZE 24
		60
59	struct snd_aes_iec958 {	61	struct snd_aes_iec958 {
60	unsigned char status[24]; /* AES/IEC958 channel status bits */	62	unsigned char status[AES_IEC958_STATUS_SIZE]; /* AES/IEC958 channel status bits */
61	unsigned char subcode[147]; /* AES/IEC958 subcode bits */	63	unsigned char subcode[147]; /* AES/IEC958 subcode bits */
62	unsigned char pad; /* nothing */	64	unsigned char pad; /* nothing */
63	unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */	65	unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */
@@ -202,6 +204,11 @@ typedef int __bitwise snd_pcm_format_t; · 138 unmodified lines
202	#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */	204	#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */
203	#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */	205	#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */
204	#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */	206	#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */
		207	/*
		208	* For S32/U32 formats, 'msbits' hardware parameter is often used to deliver information about the
		209	* available bit count in most significant bit. It's for the case of so-called 'left-justified' or
		210	* `right-padding` sample which has less width than 32 bit.
		211	*/
205	#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10)	212	#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10)
206	#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11)	213	#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11)
207	#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12)	214	#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12)
@@ -300,7 +307,7 @@ typedef int __bitwise snd_pcm_subformat_t; · 92 unmodified lines
300	#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 /* report estimated link audio time */	307	#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 /* report estimated link audio time */
301	#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 /* report synchronized audio/system time */	308	#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 /* report synchronized audio/system time */
302	#define SNDRV_PCM_INFO_EXPLICIT_SYNC 0x10000000 /* needs explicit sync of pointers and data */	309	#define SNDRV_PCM_INFO_EXPLICIT_SYNC 0x10000000 /* needs explicit sync of pointers and data */
303		310	#define SNDRV_PCM_INFO_NO_REWINDS 0x20000000 /* hardware can only support monotonic changes of appl_ptr */
304	#define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 /* internal kernel flag - trigger in drain */	311	#define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 /* internal kernel flag - trigger in drain */
305	#define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 /* internal kernel flag - FIFO size is in frames */	312	#define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 /* internal kernel flag - FIFO size is in frames */
306		313