lael-labs/linux

Documentation/dev-tools/kcov.rst+5−5

@@ -251,11 +251,11 @@ selectively from different subsystems. · 250 unmodified lines
251	.. code-block:: c	251	.. code-block:: c
252		252
253	struct kcov_remote_arg {	253	struct kcov_remote_arg {
254	unsigned trace_mode;	254	__u32 trace_mode;
255	unsigned area_size;	255	__u32 area_size;
256	unsigned num_handles;	256	__u32 num_handles;
257	uint64_t common_handle;	257	__aligned_u64 common_handle;
258	uint64_t handles[0];	258	__aligned_u64 handles[0];
259	};	259	};
260		260
261	#define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)	261	#define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)

Documentation/dev-tools/kunit/start.rst+5−8

 For more information on this wrapper (also called kunit_tool) checkout the
 :doc:`kunit-tool` page.
-Creating a kunitconfig
+Creating a .kunitconfig
-======================
+=======================
 The Python script is a thin wrapper around Kbuild. As such, it needs to be
-configured with a ``kunitconfig`` file. This file essentially contains the
+configured with a ``.kunitconfig`` file. This file essentially contains the
 regular Kernel config, with the specific test targets as well.
 .. code-block:: bash
-	git clone -b master https://kunit.googlesource.com/kunitconfig $PATH_TO_KUNITCONFIG_REPO
 	cd $PATH_TO_LINUX_REPO
-	ln -s $PATH_TO_KUNIT_CONFIG_REPO/kunitconfig kunitconfig
+	cp arch/um/configs/kunit_defconfig .kunitconfig
-You may want to add kunitconfig to your local gitignore.
 Verifying KUnit Works
 ---------------------
 	obj-$(CONFIG_MISC_EXAMPLE_TEST) += example-test.o
-Now add it to your ``kunitconfig``:
+Now add it to your ``.kunitconfig``:
 .. code-block:: none

Documentation/devicetree/bindings/i2c/i2c-at91.txt+4−2

 - dma-names: should contain "tx" and "rx".
 - atmel,fifo-size: maximum number of data the RX and TX FIFOs can store for FIFO
   capable I2C controllers.
-- i2c-sda-hold-time-ns: TWD hold time, only available for "atmel,sama5d4-i2c"
+- i2c-sda-hold-time-ns: TWD hold time, only available for:
-  and "atmel,sama5d2-i2c".
+	"atmel,sama5d4-i2c",
+	"atmel,sama5d2-i2c",
+	"microchip,sam9x60-i2c".
 - Child nodes conforming to i2c bus binding
 Examples :

Documentation/devicetree/bindings/spi/spi-controller.yaml+2−2

@@ -111,7 +111,7 @@ patternProperties: · 110 unmodified lines
111	spi-rx-bus-width:	111	spi-rx-bus-width:
112	allOf:	112	allOf:
113	- $ref: /schemas/types.yaml#/definitions/uint32	113	- $ref: /schemas/types.yaml#/definitions/uint32
114	- enum: [ 1, 2, 4 ]	114	- enum: [ 1, 2, 4, 8 ]
115	- default: 1	115	- default: 1
116	description:	116	description:
117	Bus width to the SPI bus used for MISO.	117	Bus width to the SPI bus used for MISO.
@@ -123,7 +123,7 @@ patternProperties: · 5 unmodified lines
123	spi-tx-bus-width:	123	spi-tx-bus-width:
124	allOf:	124	allOf:
125	- $ref: /schemas/types.yaml#/definitions/uint32	125	- $ref: /schemas/types.yaml#/definitions/uint32
126	- enum: [ 1, 2, 4 ]	126	- enum: [ 1, 2, 4, 8 ]
127	- default: 1	127	- default: 1
128	description:	128	description:
129	Bus width to the SPI bus used for MOSI.	129	Bus width to the SPI bus used for MOSI.

Documentation/features/debug/gcov-profile-all/arch-support.txt+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	\| openrisc: \| TODO \|	23	\| openrisc: \| TODO \|
24	\| parisc: \| TODO \|	24	\| parisc: \| TODO \|
25	\| powerpc: \| ok \|	25	\| powerpc: \| ok \|
26	\| riscv: \| TODO \|	26	\| riscv: \| ok \|
27	\| s390: \| ok \|	27	\| s390: \| ok \|
28	\| sh: \| ok \|	28	\| sh: \| ok \|
29	\| sparc: \| TODO \|	29	\| sparc: \| TODO \|

Documentation/networking/dsa/sja1105.rst+0−6

@@ -230,12 +230,6 @@ simultaneously on two ports. The driver checks the consistency of the schedules · 229 unmodified lines
230	against this restriction and errors out when appropriate. Schedule analysis is	230	against this restriction and errors out when appropriate. Schedule analysis is
231	needed to avoid this, which is outside the scope of the document.	231	needed to avoid this, which is outside the scope of the document.
232		232
233	At the moment, the time-aware scheduler can only be triggered based on a
234	standalone clock and not based on PTP time. This means the base-time argument
235	from tc-taprio is ignored and the schedule starts right away. It also means it
236	is more difficult to phase-align the scheduler with the other devices in the
237	network.
238
239	Device Tree bindings and board design	233	Device Tree bindings and board design
240	=====================================	234	=====================================
241		235

Documentation/networking/ip-sysctl.txt+1−1

@@ -603,7 +603,7 @@ tcp_synack_retries - INTEGER · 602 unmodified lines
603	with the current initial RTO of 1second. With this the final timeout	603	with the current initial RTO of 1second. With this the final timeout
604	for a passive TCP connection will happen after 63seconds.	604	for a passive TCP connection will happen after 63seconds.
605		605
606	tcp_syncookies - BOOLEAN	606	tcp_syncookies - INTEGER
607	Only valid when the kernel was compiled with CONFIG_SYN_COOKIES	607	Only valid when the kernel was compiled with CONFIG_SYN_COOKIES
608	Send out syncookies when the syn backlog queue of a socket	608	Send out syncookies when the syn backlog queue of a socket
609	overflows. This is to prevent against the common 'SYN flood attack'	609	overflows. This is to prevent against the common 'SYN flood attack'

Documentation/networking/netdev-FAQ.rst+2−2

@@ -34,8 +34,8 @@ the names, the ``net`` tree is for fixes to existing code already in the · 33 unmodified lines
34	mainline tree from Linus, and ``net-next`` is where the new code goes	34	mainline tree from Linus, and ``net-next`` is where the new code goes
35	for the future release. You can find the trees here:	35	for the future release. You can find the trees here:
36		36
37	- https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git	37	- https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
38	- https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git	38	- https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
39		39
40	Q: How often do changes from these trees make it to the mainline Linus tree?	40	Q: How often do changes from these trees make it to the mainline Linus tree?
41	----------------------------------------------------------------------------	41	----------------------------------------------------------------------------

Documentation/process/index.rst+1−0

@@ -60,6 +60,7 @@ lack of a better place. · 59 unmodified lines
60	volatile-considered-harmful	60	volatile-considered-harmful
61	botching-up-ioctls	61	botching-up-ioctls
62	clang-format	62	clang-format
		63	../riscv/patch-acceptance
63		64
64	.. only:: subproject and html	65	.. only:: subproject and html
65		66

Documentation/riscv/index.rst+1−0

@@ -7,6 +7,7 @@ RISC-V architecture · 6 unmodified lines
7		7
8	boot-image-header	8	boot-image-header
9	pmu	9	pmu
		10	patch-acceptance
10		11
11	.. only:: subproject and html	12	.. only:: subproject and html
12		13

Documentation/riscv/patch-acceptance.rst+35−0

@@ -0,0 +1,35 @@
	1	.. SPDX-License-Identifier: GPL-2.0
	2
	3	arch/riscv maintenance guidelines for developers
	4	================================================
	5
	6	Overview
	7	--------
	8	The RISC-V instruction set architecture is developed in the open:
	9	in-progress drafts are available for all to review and to experiment
	10	with implementations. New module or extension drafts can change
	11	during the development process - sometimes in ways that are
	12	incompatible with previous drafts. This flexibility can present a
	13	challenge for RISC-V Linux maintenance. Linux maintainers disapprove
	14	of churn, and the Linux development process prefers well-reviewed and
	15	tested code over experimental code. We wish to extend these same
	16	principles to the RISC-V-related code that will be accepted for
	17	inclusion in the kernel.
	18
	19	Submit Checklist Addendum
	20	-------------------------
	21	We'll only accept patches for new modules or extensions if the
	22	specifications for those modules or extensions are listed as being
	23	"Frozen" or "Ratified" by the RISC-V Foundation. (Developers may, of
	24	course, maintain their own Linux kernel trees that contain code for
	25	any draft extensions that they wish.)
	26
	27	Additionally, the RISC-V specification allows implementors to create
	28	their own custom extensions. These custom extensions aren't required
	29	to go through any review or ratification process by the RISC-V
	30	Foundation. To avoid the maintenance complexity and potential
	31	performance impact of adding kernel code for implementor-specific
	32	RISC-V extensions, we'll only to accept patches for extensions that
	33	have been officially frozen or ratified by the RISC-V Foundation.
	34	(Implementors, may, of course, maintain their own Linux kernel trees
	35	containing code for any custom extensions that they wish.)

MAINTAINERS+9−8

@@ -771,6 +771,8 @@ F: drivers/thermal/thermal_mmio.c · 770 unmodified lines
771		771
772	AMAZON ETHERNET DRIVERS	772	AMAZON ETHERNET DRIVERS
773	M: Netanel Belgazal <netanel@amazon.com>	773	M: Netanel Belgazal <netanel@amazon.com>
		774	M: Arthur Kiyanovski <akiyano@amazon.com>
		775	R: Guy Tzalik <gtzalik@amazon.com>
774	R: Saeed Bishara <saeedb@amazon.com>	776	R: Saeed Bishara <saeedb@amazon.com>
775	R: Zorik Machulsky <zorik@amazon.com>	777	R: Zorik Machulsky <zorik@amazon.com>
776	L: netdev@vger.kernel.org	778	L: netdev@vger.kernel.org
@@ -7034,6 +7036,7 @@ L: linux-acpi@vger.kernel.org · 6257 unmodified lines
7034	S: Maintained	7036	S: Maintained
7035	F: Documentation/firmware-guide/acpi/gpio-properties.rst	7037	F: Documentation/firmware-guide/acpi/gpio-properties.rst
7036	F: drivers/gpio/gpiolib-acpi.c	7038	F: drivers/gpio/gpiolib-acpi.c
		7039	F: drivers/gpio/gpiolib-acpi.h
7037		7040
7038	GPIO IR Transmitter	7041	GPIO IR Transmitter
7039	M: Sean Young <sean@mess.org>	7042	M: Sean Young <sean@mess.org>
@@ -11457,8 +11460,8 @@ M: "David S. Miller" <davem@davemloft.net> · 4417 unmodified lines
11457	L: netdev@vger.kernel.org	11460	L: netdev@vger.kernel.org
11458	W: http://www.linuxfoundation.org/en/Net	11461	W: http://www.linuxfoundation.org/en/Net
11459	Q: http://patchwork.ozlabs.org/project/netdev/list/	11462	Q: http://patchwork.ozlabs.org/project/netdev/list/
11460	T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git	11463	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
11461	T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git	11464	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
11462	S: Odd Fixes	11465	S: Odd Fixes
11463	F: Documentation/devicetree/bindings/net/	11466	F: Documentation/devicetree/bindings/net/
11464	F: drivers/net/	11467	F: drivers/net/
@@ -11499,8 +11502,8 @@ M: "David S. Miller" <davem@davemloft.net> · 34 unmodified lines
11499	L: netdev@vger.kernel.org	11502	L: netdev@vger.kernel.org
11500	W: http://www.linuxfoundation.org/en/Net	11503	W: http://www.linuxfoundation.org/en/Net
11501	Q: http://patchwork.ozlabs.org/project/netdev/list/	11504	Q: http://patchwork.ozlabs.org/project/netdev/list/
11502	T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git	11505	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
11503	T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git	11506	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
11504	B: mailto:netdev@vger.kernel.org	11507	B: mailto:netdev@vger.kernel.org
11505	S: Maintained	11508	S: Maintained
11506	F: net/	11509	F: net/
@@ -11545,7 +11548,7 @@ M: "David S. Miller" <davem@davemloft.net> · 38 unmodified lines
11545	M: Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>	11548	M: Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
11546	M: Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>	11549	M: Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>
11547	L: netdev@vger.kernel.org	11550	L: netdev@vger.kernel.org
11548	T: git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git	11551	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
11549	S: Maintained	11552	S: Maintained
11550	F: net/ipv4/	11553	F: net/ipv4/
11551	F: net/ipv6/	11554	F: net/ipv6/
@@ -13676,7 +13679,6 @@ F: drivers/net/ethernet/qualcomm/emac/ · 2124 unmodified lines
13676		13679
13677	QUALCOMM ETHQOS ETHERNET DRIVER	13680	QUALCOMM ETHQOS ETHERNET DRIVER
13678	M: Vinod Koul <vkoul@kernel.org>	13681	M: Vinod Koul <vkoul@kernel.org>
13679	M: Niklas Cassel <niklas.cassel@linaro.org>
13680	L: netdev@vger.kernel.org	13682	L: netdev@vger.kernel.org
13681	S: Maintained	13683	S: Maintained
13682	F: drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c	13684	F: drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c
@@ -14118,6 +14120,7 @@ M: Paul Walmsley <paul.walmsley@sifive.com> · 435 unmodified lines
14118	M: Palmer Dabbelt <palmer@dabbelt.com>	14120	M: Palmer Dabbelt <palmer@dabbelt.com>
14119	M: Albert Ou <aou@eecs.berkeley.edu>	14121	M: Albert Ou <aou@eecs.berkeley.edu>
14120	L: linux-riscv@lists.infradead.org	14122	L: linux-riscv@lists.infradead.org
		14123	P: Documentation/riscv/patch-acceptance.rst
14121	T: git git://git.kernel.org/pub/scm/linux/kernel/git/riscv/linux.git	14124	T: git git://git.kernel.org/pub/scm/linux/kernel/git/riscv/linux.git
14122	S: Supported	14125	S: Supported
14123	F: arch/riscv/	14126	F: arch/riscv/
@@ -14545,8 +14548,6 @@ F: include/linux/platform_data/spi-s3c64xx.h · 421 unmodified lines
14545		14548
14546	SAMSUNG SXGBE DRIVERS	14549	SAMSUNG SXGBE DRIVERS
14547	M: Byungho An <bh74.an@samsung.com>	14550	M: Byungho An <bh74.an@samsung.com>
14548	M: Girish K S <ks.giri@samsung.com>
14549	M: Vipul Pandya <vipul.pandya@samsung.com>
14550	S: Supported	14551	S: Supported
14551	L: netdev@vger.kernel.org	14552	L: netdev@vger.kernel.org
14552	F: drivers/net/ethernet/samsung/sxgbe/	14553	F: drivers/net/ethernet/samsung/sxgbe/

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 5	3	PATCHLEVEL = 5
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc3	5	EXTRAVERSION = -rc6
6	NAME = Kleptomaniac Octopus	6	NAME = Kleptomaniac Octopus
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arc/include/asm/entry-arcv2.h+4−4

@@ -162,7 +162,7 @@ · 161 unmodified lines
162	#endif	162	#endif
163		163
164	#ifdef CONFIG_ARC_HAS_ACCL_REGS	164	#ifdef CONFIG_ARC_HAS_ACCL_REGS
165	ST2 r58, r59, PT_sp + 12	165	ST2 r58, r59, PT_r58
166	#endif	166	#endif
167		167
168	.endm	168	.endm
@@ -172,8 +172,8 @@ · 3 unmodified lines
172		172
173	LD2 gp, fp, PT_r26 ; gp (r26), fp (r27)	173	LD2 gp, fp, PT_r26 ; gp (r26), fp (r27)
174		174
175	ld r12, [sp, PT_sp + 4]	175	ld r12, [sp, PT_r12]
176	ld r30, [sp, PT_sp + 8]	176	ld r30, [sp, PT_r30]
177		177
178	; Restore SP (into AUX_USER_SP) only if returning to U mode	178	; Restore SP (into AUX_USER_SP) only if returning to U mode
179	; - for K mode, it will be implicitly restored as stack is unwound	179	; - for K mode, it will be implicitly restored as stack is unwound
@@ -190,7 +190,7 @@ · 10 unmodified lines
190	#endif	190	#endif
191		191
192	#ifdef CONFIG_ARC_HAS_ACCL_REGS	192	#ifdef CONFIG_ARC_HAS_ACCL_REGS
193	LD2 r58, r59, PT_sp + 12	193	LD2 r58, r59, PT_r58
194	#endif	194	#endif
195	.endm	195	.endm
196		196

arch/arc/include/asm/hugepage.h+0−1

@@ -8,7 +8,6 @@ · 7 unmodified lines
8	#define _ASM_ARC_HUGEPAGE_H	8	#define _ASM_ARC_HUGEPAGE_H
9		9
10	#include <linux/types.h>	10	#include <linux/types.h>
11	#define __ARCH_USE_5LEVEL_HACK
12	#include <asm-generic/pgtable-nopmd.h>	11	#include <asm-generic/pgtable-nopmd.h>
13		12
14	static inline pte_t pmd_pte(pmd_t pmd)	13	static inline pte_t pmd_pte(pmd_t pmd)

arch/arc/kernel/asm-offsets.c+9−1

@@ -66,7 +66,15 @@ int main(void) · 65 unmodified lines
66		66
67	DEFINE(SZ_CALLEE_REGS, sizeof(struct callee_regs));	67	DEFINE(SZ_CALLEE_REGS, sizeof(struct callee_regs));
68	DEFINE(SZ_PT_REGS, sizeof(struct pt_regs));	68	DEFINE(SZ_PT_REGS, sizeof(struct pt_regs));
69	DEFINE(PT_user_r25, offsetof(struct pt_regs, user_r25));	69
		70	#ifdef CONFIG_ISA_ARCV2
		71	OFFSET(PT_r12, pt_regs, r12);
		72	OFFSET(PT_r30, pt_regs, r30);
		73	#endif
		74	#ifdef CONFIG_ARC_HAS_ACCL_REGS
		75	OFFSET(PT_r58, pt_regs, r58);
		76	OFFSET(PT_r59, pt_regs, r59);
		77	#endif
70		78
71	return 0;	79	return 0;
72	}	80	}

arch/arc/plat-eznps/Kconfig+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	menuconfig ARC_PLAT_EZNPS	7	menuconfig ARC_PLAT_EZNPS
8	bool "\"EZchip\" ARC dev platform"	8	bool "\"EZchip\" ARC dev platform"
9	select CPU_BIG_ENDIAN	9	select CPU_BIG_ENDIAN
10	select CLKSRC_NPS	10	select CLKSRC_NPS if !PHYS_ADDR_T_64BIT
11	select EZNPS_GIC	11	select EZNPS_GIC
12	select EZCHIP_NPS_MANAGEMENT_ENET if ETHERNET	12	select EZCHIP_NPS_MANAGEMENT_ENET if ETHERNET
13	help	13	help

arch/arm/Kconfig+1−0

@@ -72,6 +72,7 @@ config ARM · 71 unmodified lines
72	select HAVE_ARM_SMCCC if CPU_V7	72	select HAVE_ARM_SMCCC if CPU_V7
73	select HAVE_EBPF_JIT if !CPU_ENDIAN_BE32	73	select HAVE_EBPF_JIT if !CPU_ENDIAN_BE32
74	select HAVE_CONTEXT_TRACKING	74	select HAVE_CONTEXT_TRACKING
		75	select HAVE_COPY_THREAD_TLS
75	select HAVE_C_RECORDMCOUNT	76	select HAVE_C_RECORDMCOUNT
76	select HAVE_DEBUG_KMEMLEAK	77	select HAVE_DEBUG_KMEMLEAK
77	select HAVE_DMA_CONTIGUOUS if MMU	78	select HAVE_DMA_CONTIGUOUS if MMU

arch/arm/kernel/process.c+3−3

@@ -226,8 +226,8 @@ void release_thread(struct task_struct *dead_task) · 225 unmodified lines
226	asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");	226	asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
227		227
228	int	228	int
229	copy_thread(unsigned long clone_flags, unsigned long stack_start,	229	copy_thread_tls(unsigned long clone_flags, unsigned long stack_start,
230	unsigned long stk_sz, struct task_struct *p)	230	unsigned long stk_sz, struct task_struct *p, unsigned long tls)
231	{	231	{
232	struct thread_info *thread = task_thread_info(p);	232	struct thread_info *thread = task_thread_info(p);
233	struct pt_regs *childregs = task_pt_regs(p);	233	struct pt_regs *childregs = task_pt_regs(p);
@@ -261,7 +261,7 @@ copy_thread(unsigned long clone_flags, unsigned long stack_start, · 27 unmodified lines
261	clear_ptrace_hw_breakpoint(p);	261	clear_ptrace_hw_breakpoint(p);
262		262
263	if (clone_flags & CLONE_SETTLS)	263	if (clone_flags & CLONE_SETTLS)
264	thread->tp_value[0] = childregs->ARM_r3;	264	thread->tp_value[0] = tls;
265	thread->tp_value[1] = get_tpuser();	265	thread->tp_value[1] = get_tpuser();
266		266
267	thread_notify(THREAD_NOTIFY_COPY, thread);	267	thread_notify(THREAD_NOTIFY_COPY, thread);

arch/arm64/Kconfig+1−0

@@ -138,6 +138,7 @@ config ARM64 · 137 unmodified lines
138	select HAVE_CMPXCHG_DOUBLE	138	select HAVE_CMPXCHG_DOUBLE
139	select HAVE_CMPXCHG_LOCAL	139	select HAVE_CMPXCHG_LOCAL
140	select HAVE_CONTEXT_TRACKING	140	select HAVE_CONTEXT_TRACKING
		141	select HAVE_COPY_THREAD_TLS
141	select HAVE_DEBUG_BUGVERBOSE	142	select HAVE_DEBUG_BUGVERBOSE
142	select HAVE_DEBUG_KMEMLEAK	143	select HAVE_DEBUG_KMEMLEAK
143	select HAVE_DMA_CONTIGUOUS	144	select HAVE_DMA_CONTIGUOUS

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

 #define PAGE_SHARED_EXEC	__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN | PTE_WRITE)
 #define PAGE_READONLY		__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN | PTE_UXN)
 #define PAGE_READONLY_EXEC	__pgprot(_PAGE_DEFAULT | PTE_USER | PTE_RDONLY | PTE_NG | PTE_PXN)
-#define PAGE_EXECONLY		__pgprot(_PAGE_DEFAULT | PTE_RDONLY | PTE_NG | PTE_PXN)
 #define __P000  PAGE_NONE
 #define __P001  PAGE_READONLY
 #define __P010  PAGE_READONLY
 #define __P011  PAGE_READONLY
-#define __P100  PAGE_EXECONLY
+#define __P100  PAGE_READONLY_EXEC
 #define __P101  PAGE_READONLY_EXEC
 #define __P110  PAGE_READONLY_EXEC
 #define __P111  PAGE_READONLY_EXEC
 #define __S001  PAGE_READONLY
 #define __S010  PAGE_SHARED
 #define __S011  PAGE_SHARED
-#define __S100  PAGE_EXECONLY
+#define __S100  PAGE_READONLY_EXEC
 #define __S101  PAGE_READONLY_EXEC
 #define __S110  PAGE_SHARED_EXEC
 #define __S111  PAGE_SHARED_EXEC

arch/arm64/include/asm/pgtable.h+3−7

 #define pte_dirty(pte)		(pte_sw_dirty(pte) || pte_hw_dirty(pte))
 #define pte_valid(pte)		(!!(pte_val(pte) & PTE_VALID))
-/*
- * Execute-only user mappings do not have the PTE_USER bit set. All valid
- * kernel mappings have the PTE_UXN bit set.
- */
 #define pte_valid_not_user(pte) \
-	((pte_val(pte) & (PTE_VALID | PTE_USER | PTE_UXN)) == (PTE_VALID | PTE_UXN))
+	((pte_val(pte) & (PTE_VALID | PTE_USER)) == PTE_VALID)
 #define pte_valid_young(pte) \
 	((pte_val(pte) & (PTE_VALID | PTE_AF)) == (PTE_VALID | PTE_AF))
 #define pte_valid_user(pte) \
 /*
  * p??_access_permitted() is true for valid user mappings (subject to the
- * write permission check) other than user execute-only which do not have the
+ * write permission check). PROT_NONE mappings do not have the PTE_VALID bit
- * PTE_USER bit set. PROT_NONE mappings do not have the PTE_VALID bit set.
+ * set.
  */
 #define pte_access_permitted(pte, write) \
 	(pte_valid_user(pte) && (!(write) || pte_write(pte)))

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

@@ -42,7 +42,6 @@ · 41 unmodified lines
42	#endif	42	#endif
43		43
44	#define __ARCH_WANT_SYS_CLONE	44	#define __ARCH_WANT_SYS_CLONE
45	#define __ARCH_WANT_SYS_CLONE3
46		45
47	#ifndef __COMPAT_SYSCALL_NR	46	#ifndef __COMPAT_SYSCALL_NR
48	#include <uapi/asm/unistd.h>	47	#include <uapi/asm/unistd.h>

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

@@ -19,5 +19,6 @@ · 18 unmodified lines
19	#define __ARCH_WANT_NEW_STAT	19	#define __ARCH_WANT_NEW_STAT
20	#define __ARCH_WANT_SET_GET_RLIMIT	20	#define __ARCH_WANT_SET_GET_RLIMIT
21	#define __ARCH_WANT_TIME32_SYSCALLS	21	#define __ARCH_WANT_TIME32_SYSCALLS
		22	#define __ARCH_WANT_SYS_CLONE3
22		23
23	#include <asm-generic/unistd.h>	24	#include <asm-generic/unistd.h>

arch/arm64/kernel/process.c+5−5

@@ -360,8 +360,8 @@ int arch_dup_task_struct(struct task_struct dst, struct task_struct src) · 359 unmodified lines
360		360
361	asmlinkage void ret_from_fork(void) asm("ret_from_fork");	361	asmlinkage void ret_from_fork(void) asm("ret_from_fork");
362		362
363	int copy_thread(unsigned long clone_flags, unsigned long stack_start,	363	int copy_thread_tls(unsigned long clone_flags, unsigned long stack_start,
364	unsigned long stk_sz, struct task_struct *p)	364	unsigned long stk_sz, struct task_struct *p, unsigned long tls)
365	{	365	{
366	struct pt_regs *childregs = task_pt_regs(p);	366	struct pt_regs *childregs = task_pt_regs(p);
367		367
@@ -394,11 +394,11 @@ int copy_thread(unsigned long clone_flags, unsigned long stack_start, · 26 unmodified lines
394	}	394	}
395		395
396	/*	396	/*
397	* If a TLS pointer was passed to clone (4th argument), use it	397	* If a TLS pointer was passed to clone, use it for the new
398	* for the new thread.	398	* thread.
399	*/	399	*/
400	if (clone_flags & CLONE_SETTLS)	400	if (clone_flags & CLONE_SETTLS)
401	p->thread.uw.tp_value = childregs->regs[3];	401	p->thread.uw.tp_value = tls;
402	} else {	402	} else {
403	memset(childregs, 0, sizeof(struct pt_regs));	403	memset(childregs, 0, sizeof(struct pt_regs));
404	childregs->pstate = PSR_MODE_EL1h;	404	childregs->pstate = PSR_MODE_EL1h;

arch/arm64/mm/fault.c+1−1

@@ -445,7 +445,7 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr, · 444 unmodified lines
445	const struct fault_info *inf;	445	const struct fault_info *inf;
446	struct mm_struct *mm = current->mm;	446	struct mm_struct *mm = current->mm;
447	vm_fault_t fault, major = 0;	447	vm_fault_t fault, major = 0;
448	unsigned long vm_flags = VM_READ \| VM_WRITE;	448	unsigned long vm_flags = VM_READ \| VM_WRITE \| VM_EXEC;
449	unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY \| FAULT_FLAG_KILLABLE;	449	unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY \| FAULT_FLAG_KILLABLE;
450		450
451	if (kprobe_page_fault(regs, esr))	451	if (kprobe_page_fault(regs, esr))

arch/arm64/mm/mmu.c+1−3

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct zone *zone;
 	/*
 	 * FIXME: Cleanup page tables (also in arch_add_memory() in case
 	 * unplug. ARCH_ENABLE_MEMORY_HOTREMOVE must not be
 	 * unlocked yet.
 	 */
-	zone = page_zone(pfn_to_page(start_pfn));
+	__remove_pages(start_pfn, nr_pages, altmap);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
 }
 #endif

arch/hexagon/include/asm/atomic.h+4−4

@@ -91,7 +91,7 @@ static inline void atomic_##op(int i, atomic_t *v) \ · 90 unmodified lines
91	"1: %0 = memw_locked(%1);\n" \	91	"1: %0 = memw_locked(%1);\n" \
92	" %0 = "#op "(%0,%2);\n" \	92	" %0 = "#op "(%0,%2);\n" \
93	" memw_locked(%1,P3)=%0;\n" \	93	" memw_locked(%1,P3)=%0;\n" \
94	" if !P3 jump 1b;\n" \	94	" if (!P3) jump 1b;\n" \
95	: "=&r" (output) \	95	: "=&r" (output) \
96	: "r" (&v->counter), "r" (i) \	96	: "r" (&v->counter), "r" (i) \
97	: "memory", "p3" \	97	: "memory", "p3" \
@@ -107,7 +107,7 @@ static inline int atomic_##op##_return(int i, atomic_t *v) \ · 9 unmodified lines
107	"1: %0 = memw_locked(%1);\n" \	107	"1: %0 = memw_locked(%1);\n" \
108	" %0 = "#op "(%0,%2);\n" \	108	" %0 = "#op "(%0,%2);\n" \
109	" memw_locked(%1,P3)=%0;\n" \	109	" memw_locked(%1,P3)=%0;\n" \
110	" if !P3 jump 1b;\n" \	110	" if (!P3) jump 1b;\n" \
111	: "=&r" (output) \	111	: "=&r" (output) \
112	: "r" (&v->counter), "r" (i) \	112	: "r" (&v->counter), "r" (i) \
113	: "memory", "p3" \	113	: "memory", "p3" \
@@ -124,7 +124,7 @@ static inline int atomic_fetch_##op(int i, atomic_t *v) \ · 10 unmodified lines
124	"1: %0 = memw_locked(%2);\n" \	124	"1: %0 = memw_locked(%2);\n" \
125	" %1 = "#op "(%0,%3);\n" \	125	" %1 = "#op "(%0,%3);\n" \
126	" memw_locked(%2,P3)=%1;\n" \	126	" memw_locked(%2,P3)=%1;\n" \
127	" if !P3 jump 1b;\n" \	127	" if (!P3) jump 1b;\n" \
128	: "=&r" (output), "=&r" (val) \	128	: "=&r" (output), "=&r" (val) \
129	: "r" (&v->counter), "r" (i) \	129	: "r" (&v->counter), "r" (i) \
130	: "memory", "p3" \	130	: "memory", "p3" \
@@ -173,7 +173,7 @@ static inline int atomic_fetch_add_unless(atomic_t *v, int a, int u) · 42 unmodified lines
173	" }"	173	" }"
174	" memw_locked(%2, p3) = %1;"	174	" memw_locked(%2, p3) = %1;"
175	" {"	175	" {"
176	" if !p3 jump 1b;"	176	" if (!p3) jump 1b;"
177	" }"	177	" }"
178	"2:"	178	"2:"
179	: "=&r" (__oldval), "=&r" (tmp)	179	: "=&r" (__oldval), "=&r" (tmp)

arch/hexagon/include/asm/bitops.h+4−4

@@ -38,7 +38,7 @@ static inline int test_and_clear_bit(int nr, volatile void *addr) · 37 unmodified lines
38	"1: R12 = memw_locked(R10);\n"	38	"1: R12 = memw_locked(R10);\n"
39	" { P0 = tstbit(R12,R11); R12 = clrbit(R12,R11); }\n"	39	" { P0 = tstbit(R12,R11); R12 = clrbit(R12,R11); }\n"
40	" memw_locked(R10,P1) = R12;\n"	40	" memw_locked(R10,P1) = R12;\n"
41	" {if !P1 jump 1b; %0 = mux(P0,#1,#0);}\n"	41	" {if (!P1) jump 1b; %0 = mux(P0,#1,#0);}\n"
42	: "=&r" (oldval)	42	: "=&r" (oldval)
43	: "r" (addr), "r" (nr)	43	: "r" (addr), "r" (nr)
44	: "r10", "r11", "r12", "p0", "p1", "memory"	44	: "r10", "r11", "r12", "p0", "p1", "memory"
@@ -62,7 +62,7 @@ static inline int test_and_set_bit(int nr, volatile void *addr) · 17 unmodified lines
62	"1: R12 = memw_locked(R10);\n"	62	"1: R12 = memw_locked(R10);\n"
63	" { P0 = tstbit(R12,R11); R12 = setbit(R12,R11); }\n"	63	" { P0 = tstbit(R12,R11); R12 = setbit(R12,R11); }\n"
64	" memw_locked(R10,P1) = R12;\n"	64	" memw_locked(R10,P1) = R12;\n"
65	" {if !P1 jump 1b; %0 = mux(P0,#1,#0);}\n"	65	" {if (!P1) jump 1b; %0 = mux(P0,#1,#0);}\n"
66	: "=&r" (oldval)	66	: "=&r" (oldval)
67	: "r" (addr), "r" (nr)	67	: "r" (addr), "r" (nr)
68	: "r10", "r11", "r12", "p0", "p1", "memory"	68	: "r10", "r11", "r12", "p0", "p1", "memory"
@@ -88,7 +88,7 @@ static inline int test_and_change_bit(int nr, volatile void *addr) · 19 unmodified lines
88	"1: R12 = memw_locked(R10);\n"	88	"1: R12 = memw_locked(R10);\n"
89	" { P0 = tstbit(R12,R11); R12 = togglebit(R12,R11); }\n"	89	" { P0 = tstbit(R12,R11); R12 = togglebit(R12,R11); }\n"
90	" memw_locked(R10,P1) = R12;\n"	90	" memw_locked(R10,P1) = R12;\n"
91	" {if !P1 jump 1b; %0 = mux(P0,#1,#0);}\n"	91	" {if (!P1) jump 1b; %0 = mux(P0,#1,#0);}\n"
92	: "=&r" (oldval)	92	: "=&r" (oldval)
93	: "r" (addr), "r" (nr)	93	: "r" (addr), "r" (nr)
94	: "r10", "r11", "r12", "p0", "p1", "memory"	94	: "r10", "r11", "r12", "p0", "p1", "memory"
@@ -223,7 +223,7 @@ static inline int ffs(int x) · 128 unmodified lines
223	int r;	223	int r;
224		224
225	asm("{ P0 = cmp.eq(%1,#0); %0 = ct0(%1);}\n"	225	asm("{ P0 = cmp.eq(%1,#0); %0 = ct0(%1);}\n"
226	"{ if P0 %0 = #0; if !P0 %0 = add(%0,#1);}\n"	226	"{ if (P0) %0 = #0; if (!P0) %0 = add(%0,#1);}\n"
227	: "=&r" (r)	227	: "=&r" (r)
228	: "r" (x)	228	: "r" (x)
229	: "p0");	229	: "p0");

arch/hexagon/include/asm/cmpxchg.h+1−1

@@ -30,7 +30,7 @@ static inline unsigned long __xchg(unsigned long x, volatile void *ptr, · 29 unmodified lines
30	__asm__ __volatile__ (	30	__asm__ __volatile__ (
31	"1: %0 = memw_locked(%1);\n" /* load into retval */	31	"1: %0 = memw_locked(%1);\n" /* load into retval */
32	" memw_locked(%1,P0) = %2;\n" /* store into memory */	32	" memw_locked(%1,P0) = %2;\n" /* store into memory */
33	" if !P0 jump 1b;\n"	33	" if (!P0) jump 1b;\n"
34	: "=&r" (retval)	34	: "=&r" (retval)
35	: "r" (ptr), "r" (x)	35	: "r" (ptr), "r" (x)
36	: "memory", "p0"	36	: "memory", "p0"

arch/hexagon/include/asm/futex.h+3−3

@@ -16,7 +16,7 @@ · 15 unmodified lines
16	/* For example: %1 = %4 */ \	16	/* For example: %1 = %4 */ \
17	insn \	17	insn \
18	"2: memw_locked(%3,p2) = %1;\n" \	18	"2: memw_locked(%3,p2) = %1;\n" \
19	" if !p2 jump 1b;\n" \	19	" if (!p2) jump 1b;\n" \
20	" %1 = #0;\n" \	20	" %1 = #0;\n" \
21	"3:\n" \	21	"3:\n" \
22	".section .fixup,\"ax\"\n" \	22	".section .fixup,\"ax\"\n" \
@@ -84,10 +84,10 @@ futex_atomic_cmpxchg_inatomic(u32 uval, u32 __user uaddr, u32 oldval, · 61 unmodified lines
84	"1: %1 = memw_locked(%3)\n"	84	"1: %1 = memw_locked(%3)\n"
85	" {\n"	85	" {\n"
86	" p2 = cmp.eq(%1,%4)\n"	86	" p2 = cmp.eq(%1,%4)\n"
87	" if !p2.new jump:NT 3f\n"	87	" if (!p2.new) jump:NT 3f\n"
88	" }\n"	88	" }\n"
89	"2: memw_locked(%3,p2) = %5\n"	89	"2: memw_locked(%3,p2) = %5\n"
90	" if !p2 jump 1b\n"	90	" if (!p2) jump 1b\n"
91	"3:\n"	91	"3:\n"
92	".section .fixup,\"ax\"\n"	92	".section .fixup,\"ax\"\n"
93	"4: %0 = #%6\n"	93	"4: %0 = #%6\n"

arch/hexagon/include/asm/io.h+1−0

@@ -173,6 +173,7 @@ static inline void writel(u32 data, volatile void __iomem *addr) · 172 unmodified lines
173		173
174	void __iomem *ioremap(unsigned long phys_addr, unsigned long size);	174	void __iomem *ioremap(unsigned long phys_addr, unsigned long size);
175	#define ioremap_nocache ioremap	175	#define ioremap_nocache ioremap
		176	#define ioremap_uc(X, Y) ioremap((X), (Y))
176		177
177		178
178	#define __raw_writel writel	179	#define __raw_writel writel

arch/hexagon/include/asm/spinlock.h+10−10

@@ -30,9 +30,9 @@ static inline void arch_read_lock(arch_rwlock_t *lock) · 29 unmodified lines
30	__asm__ __volatile__(	30	__asm__ __volatile__(
31	"1: R6 = memw_locked(%0);\n"	31	"1: R6 = memw_locked(%0);\n"
32	" { P3 = cmp.ge(R6,#0); R6 = add(R6,#1);}\n"	32	" { P3 = cmp.ge(R6,#0); R6 = add(R6,#1);}\n"
33	" { if !P3 jump 1b; }\n"	33	" { if (!P3) jump 1b; }\n"
34	" memw_locked(%0,P3) = R6;\n"	34	" memw_locked(%0,P3) = R6;\n"
35	" { if !P3 jump 1b; }\n"	35	" { if (!P3) jump 1b; }\n"
36	:	36	:
37	: "r" (&lock->lock)	37	: "r" (&lock->lock)
38	: "memory", "r6", "p3"	38	: "memory", "r6", "p3"
@@ -46,7 +46,7 @@ static inline void arch_read_unlock(arch_rwlock_t *lock) · 7 unmodified lines
46	"1: R6 = memw_locked(%0);\n"	46	"1: R6 = memw_locked(%0);\n"
47	" R6 = add(R6,#-1);\n"	47	" R6 = add(R6,#-1);\n"
48	" memw_locked(%0,P3) = R6\n"	48	" memw_locked(%0,P3) = R6\n"
49	" if !P3 jump 1b;\n"	49	" if (!P3) jump 1b;\n"
50	:	50	:
51	: "r" (&lock->lock)	51	: "r" (&lock->lock)
52	: "memory", "r6", "p3"	52	: "memory", "r6", "p3"
@@ -61,7 +61,7 @@ static inline int arch_read_trylock(arch_rwlock_t *lock) · 8 unmodified lines
61	__asm__ __volatile__(	61	__asm__ __volatile__(
62	" R6 = memw_locked(%1);\n"	62	" R6 = memw_locked(%1);\n"
63	" { %0 = #0; P3 = cmp.ge(R6,#0); R6 = add(R6,#1);}\n"	63	" { %0 = #0; P3 = cmp.ge(R6,#0); R6 = add(R6,#1);}\n"
64	" { if !P3 jump 1f; }\n"	64	" { if (!P3) jump 1f; }\n"
65	" memw_locked(%1,P3) = R6;\n"	65	" memw_locked(%1,P3) = R6;\n"
66	" { %0 = P3 }\n"	66	" { %0 = P3 }\n"
67	"1:\n"	67	"1:\n"
@@ -78,9 +78,9 @@ static inline void arch_write_lock(arch_rwlock_t *lock) · 10 unmodified lines
78	__asm__ __volatile__(	78	__asm__ __volatile__(
79	"1: R6 = memw_locked(%0)\n"	79	"1: R6 = memw_locked(%0)\n"
80	" { P3 = cmp.eq(R6,#0); R6 = #-1;}\n"	80	" { P3 = cmp.eq(R6,#0); R6 = #-1;}\n"
81	" { if !P3 jump 1b; }\n"	81	" { if (!P3) jump 1b; }\n"
82	" memw_locked(%0,P3) = R6;\n"	82	" memw_locked(%0,P3) = R6;\n"
83	" { if !P3 jump 1b; }\n"	83	" { if (!P3) jump 1b; }\n"
84	:	84	:
85	: "r" (&lock->lock)	85	: "r" (&lock->lock)
86	: "memory", "r6", "p3"	86	: "memory", "r6", "p3"
@@ -94,7 +94,7 @@ static inline int arch_write_trylock(arch_rwlock_t *lock) · 7 unmodified lines
94	__asm__ __volatile__(	94	__asm__ __volatile__(
95	" R6 = memw_locked(%1)\n"	95	" R6 = memw_locked(%1)\n"
96	" { %0 = #0; P3 = cmp.eq(R6,#0); R6 = #-1;}\n"	96	" { %0 = #0; P3 = cmp.eq(R6,#0); R6 = #-1;}\n"
97	" { if !P3 jump 1f; }\n"	97	" { if (!P3) jump 1f; }\n"
98	" memw_locked(%1,P3) = R6;\n"	98	" memw_locked(%1,P3) = R6;\n"
99	" %0 = P3;\n"	99	" %0 = P3;\n"
100	"1:\n"	100	"1:\n"
@@ -117,9 +117,9 @@ static inline void arch_spin_lock(arch_spinlock_t *lock) · 16 unmodified lines
117	__asm__ __volatile__(	117	__asm__ __volatile__(
118	"1: R6 = memw_locked(%0);\n"	118	"1: R6 = memw_locked(%0);\n"
119	" P3 = cmp.eq(R6,#0);\n"	119	" P3 = cmp.eq(R6,#0);\n"
120	" { if !P3 jump 1b; R6 = #1; }\n"	120	" { if (!P3) jump 1b; R6 = #1; }\n"
121	" memw_locked(%0,P3) = R6;\n"	121	" memw_locked(%0,P3) = R6;\n"
122	" { if !P3 jump 1b; }\n"	122	" { if (!P3) jump 1b; }\n"
123	:	123	:
124	: "r" (&lock->lock)	124	: "r" (&lock->lock)
125	: "memory", "r6", "p3"	125	: "memory", "r6", "p3"
@@ -139,7 +139,7 @@ static inline unsigned int arch_spin_trylock(arch_spinlock_t *lock) · 13 unmodified lines
139	__asm__ __volatile__(	139	__asm__ __volatile__(
140	" R6 = memw_locked(%1);\n"	140	" R6 = memw_locked(%1);\n"
141	" P3 = cmp.eq(R6,#0);\n"	141	" P3 = cmp.eq(R6,#0);\n"
142	" { if !P3 jump 1f; R6 = #1; %0 = #0; }\n"	142	" { if (!P3) jump 1f; R6 = #1; %0 = #0; }\n"
143	" memw_locked(%1,P3) = R6;\n"	143	" memw_locked(%1,P3) = R6;\n"
144	" %0 = P3;\n"	144	" %0 = P3;\n"
145	"1:\n"	145	"1:\n"

arch/hexagon/kernel/stacktrace.c+1−3

 #include <linux/thread_info.h>
 #include <linux/module.h>
-register unsigned long current_frame_pointer asm("r30");
 struct stackframe {
 	unsigned long fp;
 	unsigned long rets;
 	low = (unsigned long)task_stack_page(current);
 	high = low + THREAD_SIZE;
-	fp = current_frame_pointer;
+	fp = (unsigned long)__builtin_frame_address(0);
 	while (fp >= low && fp <= (high - sizeof(*frame))) {
 		frame = (struct stackframe *)fp;

arch/hexagon/kernel/vm_entry.S+1−1

@@ -369,7 +369,7 @@ ret_from_fork: · 368 unmodified lines
369	R26.L = #LO(do_work_pending);	369	R26.L = #LO(do_work_pending);
370	R0 = #VM_INT_DISABLE;	370	R0 = #VM_INT_DISABLE;
371	}	371	}
372	if P0 jump check_work_pending	372	if (P0) jump check_work_pending
373	{	373	{
374	R0 = R25;	374	R0 = R25;
375	callr R24	375	callr R24

arch/ia64/mm/init.c+1−3

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct zone *zone;
-	zone = page_zone(pfn_to_page(start_pfn));
+	__remove_pages(start_pfn, nr_pages, altmap);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
 }
 #endif

arch/mips/Kconfig+1−1

@@ -47,7 +47,7 @@ config MIPS · 46 unmodified lines
47	select HAVE_ARCH_TRACEHOOK	47	select HAVE_ARCH_TRACEHOOK
48	select HAVE_ARCH_TRANSPARENT_HUGEPAGE if CPU_SUPPORTS_HUGEPAGES	48	select HAVE_ARCH_TRANSPARENT_HUGEPAGE if CPU_SUPPORTS_HUGEPAGES
49	select HAVE_ASM_MODVERSIONS	49	select HAVE_ASM_MODVERSIONS
50	select HAVE_EBPF_JIT if (!CPU_MICROMIPS)	50	select HAVE_EBPF_JIT if 64BIT && !CPU_MICROMIPS && TARGET_ISA_REV >= 2
51	select HAVE_CONTEXT_TRACKING	51	select HAVE_CONTEXT_TRACKING
52	select HAVE_COPY_THREAD_TLS	52	select HAVE_COPY_THREAD_TLS
53	select HAVE_C_RECORDMCOUNT	53	select HAVE_C_RECORDMCOUNT

arch/mips/boot/compressed/Makefile+3−0

@@ -29,6 +29,9 @@ KBUILD_AFLAGS := $(KBUILD_AFLAGS) -D__ASSEMBLY__ \ · 28 unmodified lines
29	-DBOOT_HEAP_SIZE=$(BOOT_HEAP_SIZE) \	29	-DBOOT_HEAP_SIZE=$(BOOT_HEAP_SIZE) \
30	-DKERNEL_ENTRY=$(VMLINUX_ENTRY_ADDRESS)	30	-DKERNEL_ENTRY=$(VMLINUX_ENTRY_ADDRESS)
31		31
		32	# Prevents link failures: __sanitizer_cov_trace_pc() is not linked in.
		33	KCOV_INSTRUMENT := n
		34
32	# decompressor objects (linked with vmlinuz)	35	# decompressor objects (linked with vmlinuz)
33	vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o	36	vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o
34		37

arch/mips/include/asm/cpu-type.h+2−1

@@ -15,7 +15,8 @@ · 14 unmodified lines
15	static inline int __pure __get_cpu_type(const int cpu_type)	15	static inline int __pure __get_cpu_type(const int cpu_type)
16	{	16	{
17	switch (cpu_type) {	17	switch (cpu_type) {
18	#if defined(CONFIG_SYS_HAS_CPU_LOONGSON2EF)	18	#if defined(CONFIG_SYS_HAS_CPU_LOONGSON2E) \|\| \
		19	defined(CONFIG_SYS_HAS_CPU_LOONGSON2F)
19	case CPU_LOONGSON2EF:	20	case CPU_LOONGSON2EF:
20	#endif	21	#endif
21		22

arch/mips/include/asm/thread_info.h+19−1

@@ -49,8 +49,26 @@ struct thread_info { · 48 unmodified lines
49	.addr_limit = KERNEL_DS, \	49	.addr_limit = KERNEL_DS, \
50	}	50	}
51		51
52	/* How to get the thread information struct from C. */	52	/*
		53	* A pointer to the struct thread_info for the currently executing thread is
		54	* held in register $28/$gp.
		55	*
		56	* We declare __current_thread_info as a global register variable rather than a
		57	* local register variable within current_thread_info() because clang doesn't
		58	* support explicit local register variables.
		59	*
		60	* When building the VDSO we take care not to declare the global register
		61	* variable because this causes GCC to not preserve the value of $28/$gp in
		62	* functions that change its value (which is common in the PIC VDSO when
		63	* accessing the GOT). Since the VDSO shouldn't be accessing
		64	* __current_thread_info anyway we declare it extern in order to cause a link
		65	* failure if it's referenced.
		66	*/
		67	#ifdef __VDSO__
		68	extern struct thread_info *__current_thread_info;
		69	#else
53	register struct thread_info *__current_thread_info __asm__("$28");	70	register struct thread_info *__current_thread_info __asm__("$28");
		71	#endif
54		72
55	static inline struct thread_info *current_thread_info(void)	73	static inline struct thread_info *current_thread_info(void)
56	{	74	{

arch/mips/include/asm/vdso/gettimeofday.h+0−13

@@ -26,8 +26,6 @@ · 25 unmodified lines
26		26
27	#define __VDSO_USE_SYSCALL ULLONG_MAX	27	#define __VDSO_USE_SYSCALL ULLONG_MAX
28		28
29	#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
30
31	static __always_inline long gettimeofday_fallback(	29	static __always_inline long gettimeofday_fallback(
32	struct __kernel_old_timeval *_tv,	30	struct __kernel_old_timeval *_tv,
33	struct timezone *_tz)	31	struct timezone *_tz)
@@ -48,17 +46,6 @@ static __always_inline long gettimeofday_fallback( · 14 unmodified lines
48	return error ? -ret : ret;	46	return error ? -ret : ret;
49	}	47	}
50		48
51	#else
52
53	static __always_inline long gettimeofday_fallback(
54	struct __kernel_old_timeval *_tv,
55	struct timezone *_tz)
56	{
57	return -1;
58	}
59
60	#endif
61
62	static __always_inline long clock_gettime_fallback(	49	static __always_inline long clock_gettime_fallback(
63	clockid_t _clkid,	50	clockid_t _clkid,
64	struct __kernel_timespec *_ts)	51	struct __kernel_timespec *_ts)

arch/mips/kernel/cacheinfo.c+26−1

@@ -50,6 +50,25 @@ static int __init_cache_level(unsigned int cpu) · 49 unmodified lines
50	return 0;	50	return 0;
51	}	51	}
52		52
		53	static void fill_cpumask_siblings(int cpu, cpumask_t *cpu_map)
		54	{
		55	int cpu1;
		56
		57	for_each_possible_cpu(cpu1)
		58	if (cpus_are_siblings(cpu, cpu1))
		59	cpumask_set_cpu(cpu1, cpu_map);
		60	}
		61
		62	static void fill_cpumask_cluster(int cpu, cpumask_t *cpu_map)
		63	{
		64	int cpu1;
		65	int cluster = cpu_cluster(&cpu_data[cpu]);
		66
		67	for_each_possible_cpu(cpu1)
		68	if (cpu_cluster(&cpu_data[cpu1]) == cluster)
		69	cpumask_set_cpu(cpu1, cpu_map);
		70	}
		71
53	static int __populate_cache_leaves(unsigned int cpu)	72	static int __populate_cache_leaves(unsigned int cpu)
54	{	73	{
55	struct cpuinfo_mips *c = &current_cpu_data;	74	struct cpuinfo_mips *c = &current_cpu_data;
@@ -57,14 +76,20 @@ static int __populate_cache_leaves(unsigned int cpu) · 1 unmodified line
57	struct cacheinfo *this_leaf = this_cpu_ci->info_list;	76	struct cacheinfo *this_leaf = this_cpu_ci->info_list;
58		77
59	if (c->icache.waysize) {	78	if (c->icache.waysize) {
		79	/* L1 caches are per core */
		80	fill_cpumask_siblings(cpu, &this_leaf->shared_cpu_map);
60	populate_cache(dcache, this_leaf, 1, CACHE_TYPE_DATA);	81	populate_cache(dcache, this_leaf, 1, CACHE_TYPE_DATA);
		82	fill_cpumask_siblings(cpu, &this_leaf->shared_cpu_map);
61	populate_cache(icache, this_leaf, 1, CACHE_TYPE_INST);	83	populate_cache(icache, this_leaf, 1, CACHE_TYPE_INST);
62	} else {	84	} else {
63	populate_cache(dcache, this_leaf, 1, CACHE_TYPE_UNIFIED);	85	populate_cache(dcache, this_leaf, 1, CACHE_TYPE_UNIFIED);
64	}	86	}
65		87
66	if (c->scache.waysize)	88	if (c->scache.waysize) {
		89	/* L2 cache is per cluster */
		90	fill_cpumask_cluster(cpu, &this_leaf->shared_cpu_map);
67	populate_cache(scache, this_leaf, 2, CACHE_TYPE_UNIFIED);	91	populate_cache(scache, this_leaf, 2, CACHE_TYPE_UNIFIED);
		92	}
68		93
69	if (c->tcache.waysize)	94	if (c->tcache.waysize)
70	populate_cache(tcache, this_leaf, 3, CACHE_TYPE_UNIFIED);	95	populate_cache(tcache, this_leaf, 3, CACHE_TYPE_UNIFIED);

arch/mips/net/ebpf_jit.c+1−1

@@ -1804,7 +1804,7 @@ struct bpf_prog bpf_int_jit_compile(struct bpf_prog prog) · 1803 unmodified lines
1804	unsigned int image_size;	1804	unsigned int image_size;
1805	u8 *image_ptr;	1805	u8 *image_ptr;
1806		1806
1807	if (!prog->jit_requested \|\| MIPS_ISA_REV < 2)	1807	if (!prog->jit_requested)
1808	return prog;	1808	return prog;
1809		1809
1810	tmp = bpf_jit_blind_constants(prog);	1810	tmp = bpf_jit_blind_constants(prog);

arch/mips/vdso/vgettimeofday.c+20−0

 	return __cvdso_clock_gettime32(clock, ts);
 }
+#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
+/*
+ * This is behind the ifdef so that we don't provide the symbol when there's no
+ * possibility of there being a usable clocksource, because there's nothing we
+ * can do without it. When libc fails the symbol lookup it should fall back on
+ * the standard syscall path.
+ */
 int __vdso_gettimeofday(struct __kernel_old_timeval *tv,
 			struct timezone *tz)
 {
 	return __cvdso_gettimeofday(tv, tz);
 }
+#endif /* CONFIG_MIPS_CLOCK_VSYSCALL */
 int __vdso_clock_getres(clockid_t clock_id,
 			struct old_timespec32 *res)
 {
 	return __cvdso_clock_gettime(clock, ts);
 }
+#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
+/*
+ * This is behind the ifdef so that we don't provide the symbol when there's no
+ * possibility of there being a usable clocksource, because there's nothing we
+ * can do without it. When libc fails the symbol lookup it should fall back on
+ * the standard syscall path.
+ */
 int __vdso_gettimeofday(struct __kernel_old_timeval *tv,
 			struct timezone *tz)
 {
 	return __cvdso_gettimeofday(tv, tz);
 }
+#endif /* CONFIG_MIPS_CLOCK_VSYSCALL */
 int __vdso_clock_getres(clockid_t clock_id,
 			struct __kernel_timespec *res)
 {

arch/parisc/Kconfig+1−0

@@ -62,6 +62,7 @@ config PARISC · 61 unmodified lines
62	select HAVE_FTRACE_MCOUNT_RECORD if HAVE_DYNAMIC_FTRACE	62	select HAVE_FTRACE_MCOUNT_RECORD if HAVE_DYNAMIC_FTRACE
63	select HAVE_KPROBES_ON_FTRACE	63	select HAVE_KPROBES_ON_FTRACE
64	select HAVE_DYNAMIC_FTRACE_WITH_REGS	64	select HAVE_DYNAMIC_FTRACE_WITH_REGS
		65	select HAVE_COPY_THREAD_TLS
65		66
66	help	67	help
67	The PA-RISC microprocessor is designed by Hewlett-Packard and used	68	The PA-RISC microprocessor is designed by Hewlett-Packard and used

arch/parisc/kernel/process.c+4−4

@@ -208,8 +208,8 @@ arch_initcall(parisc_idle_init); · 207 unmodified lines
208	* Copy architecture-specific thread state	208	* Copy architecture-specific thread state
209	*/	209	*/
210	int	210	int
211	copy_thread(unsigned long clone_flags, unsigned long usp,	211	copy_thread_tls(unsigned long clone_flags, unsigned long usp,
212	unsigned long kthread_arg, struct task_struct *p)	212	unsigned long kthread_arg, struct task_struct *p, unsigned long tls)
213	{	213	{
214	struct pt_regs *cregs = &(p->thread.regs);	214	struct pt_regs *cregs = &(p->thread.regs);
215	void *stack = task_stack_page(p);	215	void *stack = task_stack_page(p);
@@ -254,9 +254,9 @@ copy_thread(unsigned long clone_flags, unsigned long usp, · 38 unmodified lines
254	cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;	254	cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
255	cregs->kpc = (unsigned long) &child_return;	255	cregs->kpc = (unsigned long) &child_return;
256		256
257	/* Setup thread TLS area from the 4th parameter in clone */	257	/* Setup thread TLS area */
258	if (clone_flags & CLONE_SETTLS)	258	if (clone_flags & CLONE_SETTLS)
259	cregs->cr27 = cregs->gr[23];	259	cregs->cr27 = tls;
260	}	260	}
261		261
262	return 0;	262	return 0;

arch/powerpc/include/asm/spinlock.h+1−0

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	*	15	*
16	* (the type definitions are in asm/spinlock_types.h)	16	* (the type definitions are in asm/spinlock_types.h)
17	*/	17	*/
		18	#include <linux/jump_label.h>
18	#include <linux/irqflags.h>	19	#include <linux/irqflags.h>
19	#ifdef CONFIG_PPC64	20	#ifdef CONFIG_PPC64
20	#include <asm/paca.h>	21	#include <asm/paca.h>

arch/powerpc/mm/mem.c+1−2

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct page *page = pfn_to_page(start_pfn) + vmem_altmap_offset(altmap);
 	int ret;
-	__remove_pages(page_zone(page), start_pfn, nr_pages, altmap);
+	__remove_pages(start_pfn, nr_pages, altmap);
 	/* Remove htab bolted mappings for this section of memory */
 	start = (unsigned long)__va(start);

arch/powerpc/mm/slice.c+2−2

@@ -50,7 +50,7 @@ static void slice_print_mask(const char label, const struct slice_mask mask) { · 49 unmodified lines
50		50
51	#endif	51	#endif
52		52
53	static inline bool slice_addr_is_low(unsigned long addr)	53	static inline notrace bool slice_addr_is_low(unsigned long addr)
54	{	54	{
55	u64 tmp = (u64)addr;	55	u64 tmp = (u64)addr;
56		56
@@ -659,7 +659,7 @@ unsigned long arch_get_unmapped_area_topdown(struct file *filp, · 602 unmodified lines
659	mm_ctx_user_psize(&current->mm->context), 1);	659	mm_ctx_user_psize(&current->mm->context), 1);
660	}	660	}
661		661
662	unsigned int get_slice_psize(struct mm_struct *mm, unsigned long addr)	662	unsigned int notrace get_slice_psize(struct mm_struct *mm, unsigned long addr)
663	{	663	{
664	unsigned char *psizes;	664	unsigned char *psizes;
665	int index, mask_index;	665	int index, mask_index;

arch/riscv/Kconfig+2−0

@@ -64,6 +64,8 @@ config RISCV · 63 unmodified lines
64	select SPARSEMEM_STATIC if 32BIT	64	select SPARSEMEM_STATIC if 32BIT
65	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU	65	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU
66	select HAVE_ARCH_MMAP_RND_BITS if MMU	66	select HAVE_ARCH_MMAP_RND_BITS if MMU
		67	select ARCH_HAS_GCOV_PROFILE_ALL
		68	select HAVE_COPY_THREAD_TLS
67		69
68	config ARCH_MMAP_RND_BITS_MIN	70	config ARCH_MMAP_RND_BITS_MIN
69	default 18 if 64BIT	71	default 18 if 64BIT

arch/riscv/boot/dts/sifive/fu540-c000.dtsi+15−0

 			reg = <1>;
 			riscv,isa = "rv64imafdc";
 			tlb-split;
+			next-level-cache = <&l2cache>;
 			cpu1_intc: interrupt-controller {
 				#interrupt-cells = <1>;
 				compatible = "riscv,cpu-intc";
 			reg = <2>;
 			riscv,isa = "rv64imafdc";
 			tlb-split;
+			next-level-cache = <&l2cache>;
 			cpu2_intc: interrupt-controller {
 				#interrupt-cells = <1>;
 				compatible = "riscv,cpu-intc";
 			reg = <3>;
 			riscv,isa = "rv64imafdc";
 			tlb-split;
+			next-level-cache = <&l2cache>;
 			cpu3_intc: interrupt-controller {
 				#interrupt-cells = <1>;
 				compatible = "riscv,cpu-intc";
 			reg = <4>;
 			riscv,isa = "rv64imafdc";
 			tlb-split;
+			next-level-cache = <&l2cache>;
 			cpu4_intc: interrupt-controller {
 				#interrupt-cells = <1>;
 				compatible = "riscv,cpu-intc";
 			#pwm-cells = <3>;
 			status = "disabled";
 		};
+		l2cache: cache-controller@2010000 {
+			compatible = "sifive,fu540-c000-ccache", "cache";
+			cache-block-size = <64>;
+			cache-level = <2>;
+			cache-sets = <1024>;
+			cache-size = <2097152>;
+			cache-unified;
+			interrupt-parent = <&plic0>;
+			interrupts = <1 2 3>;
+			reg = <0x0 0x2010000 0x0 0x1000>;
+		};
 	};
 };

arch/riscv/include/asm/csr.h+9−9

@@ -116,9 +116,9 @@ · 115 unmodified lines
116	# define SR_PIE SR_MPIE	116	# define SR_PIE SR_MPIE
117	# define SR_PP SR_MPP	117	# define SR_PP SR_MPP
118		118
119	# define IRQ_SOFT IRQ_M_SOFT	119	# define RV_IRQ_SOFT IRQ_M_SOFT
120	# define IRQ_TIMER IRQ_M_TIMER	120	# define RV_IRQ_TIMER IRQ_M_TIMER
121	# define IRQ_EXT IRQ_M_EXT	121	# define RV_IRQ_EXT IRQ_M_EXT
122	#else /* CONFIG_RISCV_M_MODE */	122	#else /* CONFIG_RISCV_M_MODE */
123	# define CSR_STATUS CSR_SSTATUS	123	# define CSR_STATUS CSR_SSTATUS
124	# define CSR_IE CSR_SIE	124	# define CSR_IE CSR_SIE
@@ -133,15 +133,15 @@ · 8 unmodified lines
133	# define SR_PIE SR_SPIE	133	# define SR_PIE SR_SPIE
134	# define SR_PP SR_SPP	134	# define SR_PP SR_SPP
135		135
136	# define IRQ_SOFT IRQ_S_SOFT	136	# define RV_IRQ_SOFT IRQ_S_SOFT
137	# define IRQ_TIMER IRQ_S_TIMER	137	# define RV_IRQ_TIMER IRQ_S_TIMER
138	# define IRQ_EXT IRQ_S_EXT	138	# define RV_IRQ_EXT IRQ_S_EXT
139	#endif /* CONFIG_RISCV_M_MODE */	139	#endif /* CONFIG_RISCV_M_MODE */
140		140
141	/* IE/IP (Supervisor/Machine Interrupt Enable/Pending) flags */	141	/* IE/IP (Supervisor/Machine Interrupt Enable/Pending) flags */
142	#define IE_SIE (_AC(0x1, UL) << IRQ_SOFT)	142	#define IE_SIE (_AC(0x1, UL) << RV_IRQ_SOFT)
143	#define IE_TIE (_AC(0x1, UL) << IRQ_TIMER)	143	#define IE_TIE (_AC(0x1, UL) << RV_IRQ_TIMER)
144	#define IE_EIE (_AC(0x1, UL) << IRQ_EXT)	144	#define IE_EIE (_AC(0x1, UL) << RV_IRQ_EXT)
145		145
146	#ifndef __ASSEMBLY__	146	#ifndef __ASSEMBLY__
147		147

arch/riscv/kernel/entry.S+1−0

@@ -246,6 +246,7 @@ check_syscall_nr: · 245 unmodified lines
246	*/	246	*/
247	li t1, -1	247	li t1, -1
248	beq a7, t1, ret_from_syscall_rejected	248	beq a7, t1, ret_from_syscall_rejected
		249	blt a7, t1, 1f
249	/* Call syscall */	250	/* Call syscall */
250	la s0, sys_call_table	251	la s0, sys_call_table
251	slli t0, a7, RISCV_LGPTR	252	slli t0, a7, RISCV_LGPTR

arch/riscv/kernel/ftrace.c+1−1

@@ -142,7 +142,7 @@ void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr, · 141 unmodified lines
142	*/	142	*/
143	old = *parent;	143	old = *parent;
144		144
145	if (function_graph_enter(old, self_addr, frame_pointer, parent))	145	if (!function_graph_enter(old, self_addr, frame_pointer, parent))
146	*parent = return_hooker;	146	*parent = return_hooker;
147	}	147	}
148		148

arch/riscv/kernel/head.S+1−1

@@ -251,7 +251,7 @@ ENTRY(reset_regs) · 250 unmodified lines
251	#ifdef CONFIG_FPU	251	#ifdef CONFIG_FPU
252	csrr t0, CSR_MISA	252	csrr t0, CSR_MISA
253	andi t0, t0, (COMPAT_HWCAP_ISA_F \| COMPAT_HWCAP_ISA_D)	253	andi t0, t0, (COMPAT_HWCAP_ISA_F \| COMPAT_HWCAP_ISA_D)
254	bnez t0, .Lreset_regs_done	254	beqz t0, .Lreset_regs_done
255		255
256	li t1, SR_FS	256	li t1, SR_FS
257	csrs CSR_STATUS, t1	257	csrs CSR_STATUS, t1

arch/riscv/kernel/irq.c+3−3

@@ -23,11 +23,11 @@ asmlinkage __visible void __irq_entry do_IRQ(struct pt_regs *regs) · 22 unmodified lines
23		23
24	irq_enter();	24	irq_enter();
25	switch (regs->cause & ~CAUSE_IRQ_FLAG) {	25	switch (regs->cause & ~CAUSE_IRQ_FLAG) {
26	case IRQ_TIMER:	26	case RV_IRQ_TIMER:
27	riscv_timer_interrupt();	27	riscv_timer_interrupt();
28	break;	28	break;
29	#ifdef CONFIG_SMP	29	#ifdef CONFIG_SMP
30	case IRQ_SOFT:	30	case RV_IRQ_SOFT:
31	/*	31	/*
32	* We only use software interrupts to pass IPIs, so if a non-SMP	32	* We only use software interrupts to pass IPIs, so if a non-SMP
33	* system gets one, then we don't know what to do.	33	* system gets one, then we don't know what to do.
@@ -35,7 +35,7 @@ asmlinkage __visible void __irq_entry do_IRQ(struct pt_regs *regs) · 1 unmodified line
35	riscv_software_interrupt();	35	riscv_software_interrupt();
36	break;	36	break;
37	#endif	37	#endif
38	case IRQ_EXT:	38	case RV_IRQ_EXT:
39	handle_arch_irq(regs);	39	handle_arch_irq(regs);
40	break;	40	break;
41	default:	41	default:

arch/riscv/kernel/process.c+3−3

@@ -99,8 +99,8 @@ int arch_dup_task_struct(struct task_struct dst, struct task_struct src) · 98 unmodified lines
99	return 0;	99	return 0;
100	}	100	}
101		101
102	int copy_thread(unsigned long clone_flags, unsigned long usp,	102	int copy_thread_tls(unsigned long clone_flags, unsigned long usp,
103	unsigned long arg, struct task_struct *p)	103	unsigned long arg, struct task_struct *p, unsigned long tls)
104	{	104	{
105	struct pt_regs *childregs = task_pt_regs(p);	105	struct pt_regs *childregs = task_pt_regs(p);
106		106
@@ -121,7 +121,7 @@ int copy_thread(unsigned long clone_flags, unsigned long usp, · 14 unmodified lines
121	if (usp) /* User fork */	121	if (usp) /* User fork */
122	childregs->sp = usp;	122	childregs->sp = usp;
123	if (clone_flags & CLONE_SETTLS)	123	if (clone_flags & CLONE_SETTLS)
124	childregs->tp = childregs->a5;	124	childregs->tp = tls;
125	childregs->a0 = 0; /* Return value of fork() */	125	childregs->a0 = 0; /* Return value of fork() */
126	p->thread.ra = (unsigned long)ret_from_fork;	126	p->thread.ra = (unsigned long)ret_from_fork;
127	}	127	}

arch/riscv/kernel/riscv_ksyms.c+0−3

 /*
  * Assembly functions that may be used (directly or indirectly) by modules
  */
-EXPORT_SYMBOL(__clear_user);
-EXPORT_SYMBOL(__asm_copy_to_user);
-EXPORT_SYMBOL(__asm_copy_from_user);
 EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memcpy);

arch/riscv/lib/uaccess.S+4−0

 #include <linux/linkage.h>
+#include <asm-generic/export.h>
 #include <asm/asm.h>
 #include <asm/csr.h>
 	j 3b
 ENDPROC(__asm_copy_to_user)
 ENDPROC(__asm_copy_from_user)
+EXPORT_SYMBOL(__asm_copy_to_user)
+EXPORT_SYMBOL(__asm_copy_from_user)
 ENTRY(__clear_user)
 	bltu a0, a3, 5b
 	j 3b
 ENDPROC(__clear_user)
+EXPORT_SYMBOL(__clear_user)
 	.section .fixup,"ax"
 	.balign 4

arch/riscv/mm/cacheflush.c+1−0

@@ -22,6 +22,7 @@ void flush_icache_all(void) · 21 unmodified lines
22	else	22	else
23	on_each_cpu(ipi_remote_fence_i, NULL, 1);	23	on_each_cpu(ipi_remote_fence_i, NULL, 1);
24	}	24	}
		25	EXPORT_SYMBOL(flush_icache_all);
25		26
26	/*	27	/*
27	* Performs an icache flush for the given MM context. RISC-V has no direct	28	* Performs an icache flush for the given MM context. RISC-V has no direct

arch/riscv/mm/init.c+6−6

@@ -99,13 +99,13 @@ static void __init setup_initrd(void) · 98 unmodified lines
99	pr_info("initrd not found or empty");	99	pr_info("initrd not found or empty");
100	goto disable;	100	goto disable;
101	}	101	}
102	if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {	102	if (__pa_symbol(initrd_end) > PFN_PHYS(max_low_pfn)) {
103	pr_err("initrd extends beyond end of memory");	103	pr_err("initrd extends beyond end of memory");
104	goto disable;	104	goto disable;
105	}	105	}
106		106
107	size = initrd_end - initrd_start;	107	size = initrd_end - initrd_start;
108	memblock_reserve(__pa(initrd_start), size);	108	memblock_reserve(__pa_symbol(initrd_start), size);
109	initrd_below_start_ok = 1;	109	initrd_below_start_ok = 1;
110		110
111	pr_info("Initial ramdisk at: 0x%p (%lu bytes)\n",	111	pr_info("Initial ramdisk at: 0x%p (%lu bytes)\n",
@@ -124,8 +124,8 @@ void __init setup_bootmem(void) · 12 unmodified lines
124	{	124	{
125	struct memblock_region *reg;	125	struct memblock_region *reg;
126	phys_addr_t mem_size = 0;	126	phys_addr_t mem_size = 0;
127	phys_addr_t vmlinux_end = __pa(&_end);	127	phys_addr_t vmlinux_end = __pa_symbol(&_end);
128	phys_addr_t vmlinux_start = __pa(&_start);	128	phys_addr_t vmlinux_start = __pa_symbol(&_start);
129		129
130	/* Find the memory region containing the kernel */	130	/* Find the memory region containing the kernel */
131	for_each_memblock(memory, reg) {	131	for_each_memblock(memory, reg) {
@@ -445,7 +445,7 @@ static void __init setup_vm_final(void) · 313 unmodified lines
445		445
446	/* Setup swapper PGD for fixmap */	446	/* Setup swapper PGD for fixmap */
447	create_pgd_mapping(swapper_pg_dir, FIXADDR_START,	447	create_pgd_mapping(swapper_pg_dir, FIXADDR_START,
448	__pa(fixmap_pgd_next),	448	__pa_symbol(fixmap_pgd_next),
449	PGDIR_SIZE, PAGE_TABLE);	449	PGDIR_SIZE, PAGE_TABLE);
450		450
451	/* Map all memory banks */	451	/* Map all memory banks */
@@ -474,7 +474,7 @@ static void __init setup_vm_final(void) · 22 unmodified lines
474	clear_fixmap(FIX_PMD);	474	clear_fixmap(FIX_PMD);
475		475
476	/* Move to swapper page table */	476	/* Move to swapper page table */
477	csr_write(CSR_SATP, PFN_DOWN(__pa(swapper_pg_dir)) \| SATP_MODE);	477	csr_write(CSR_SATP, PFN_DOWN(__pa_symbol(swapper_pg_dir)) \| SATP_MODE);
478	local_flush_tlb_all();	478	local_flush_tlb_all();
479	}	479	}
480	#else	480	#else

arch/s390/mm/init.c+1−3

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct zone *zone;
-	zone = page_zone(pfn_to_page(start_pfn));
+	__remove_pages(start_pfn, nr_pages, altmap);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
 	vmem_remove_mapping(start, size);
 }
 #endif /* CONFIG_MEMORY_HOTPLUG */

arch/sh/mm/init.c+1−3

 {
 	unsigned long start_pfn = PFN_DOWN(start);
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct zone *zone;
-	zone = page_zone(pfn_to_page(start_pfn));
+	__remove_pages(start_pfn, nr_pages, altmap);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
 }
 #endif /* CONFIG_MEMORY_HOTPLUG */

arch/um/Kconfig+1−0

@@ -14,6 +14,7 @@ config UML · 13 unmodified lines
14	select HAVE_FUTEX_CMPXCHG if FUTEX	14	select HAVE_FUTEX_CMPXCHG if FUTEX
15	select HAVE_DEBUG_KMEMLEAK	15	select HAVE_DEBUG_KMEMLEAK
16	select HAVE_DEBUG_BUGVERBOSE	16	select HAVE_DEBUG_BUGVERBOSE
		17	select HAVE_COPY_THREAD_TLS
17	select GENERIC_IRQ_SHOW	18	select GENERIC_IRQ_SHOW
18	select GENERIC_CPU_DEVICES	19	select GENERIC_CPU_DEVICES
19	select GENERIC_CLOCKEVENTS	20	select GENERIC_CLOCKEVENTS

arch/um/include/asm/ptrace-generic.h+1−1

@@ -36,7 +36,7 @@ extern long subarch_ptrace(struct task_struct *child, long request, · 35 unmodified lines
36	extern unsigned long getreg(struct task_struct *child, int regno);	36	extern unsigned long getreg(struct task_struct *child, int regno);
37	extern int putreg(struct task_struct *child, int regno, unsigned long value);	37	extern int putreg(struct task_struct *child, int regno, unsigned long value);
38		38
39	extern int arch_copy_tls(struct task_struct *new);	39	extern int arch_set_tls(struct task_struct *new, unsigned long tls);
40	extern void clear_flushed_tls(struct task_struct *task);	40	extern void clear_flushed_tls(struct task_struct *task);
41	extern int syscall_trace_enter(struct pt_regs *regs);	41	extern int syscall_trace_enter(struct pt_regs *regs);
42	extern void syscall_trace_leave(struct pt_regs *regs);	42	extern void syscall_trace_leave(struct pt_regs *regs);

arch/um/kernel/process.c+3−3

@@ -153,8 +153,8 @@ void fork_handler(void) · 152 unmodified lines
153	userspace(&current->thread.regs.regs, current_thread_info()->aux_fp_regs);	153	userspace(&current->thread.regs.regs, current_thread_info()->aux_fp_regs);
154	}	154	}
155		155
156	int copy_thread(unsigned long clone_flags, unsigned long sp,	156	int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
157	unsigned long arg, struct task_struct * p)	157	unsigned long arg, struct task_struct * p, unsigned long tls)
158	{	158	{
159	void (*handler)(void);	159	void (*handler)(void);
160	int kthread = current->flags & PF_KTHREAD;	160	int kthread = current->flags & PF_KTHREAD;
@@ -188,7 +188,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp, · 27 unmodified lines
188	* Set a new TLS for the child thread?	188	* Set a new TLS for the child thread?
189	*/	189	*/
190	if (clone_flags & CLONE_SETTLS)	190	if (clone_flags & CLONE_SETTLS)
191	ret = arch_copy_tls(p);	191	ret = arch_set_tls(p, tls);
192	}	192	}
193		193
194	return ret;	194	return ret;

arch/x86/mm/init_32.c+1−3

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct zone *zone;
-	zone = page_zone(pfn_to_page(start_pfn));
+	__remove_pages(start_pfn, nr_pages, altmap);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
 }
 #endif

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

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct page *page = pfn_to_page(start_pfn) + vmem_altmap_offset(altmap);
-	struct zone *zone = page_zone(page);
-	__remove_pages(zone, start_pfn, nr_pages, altmap);
+	__remove_pages(start_pfn, nr_pages, altmap);
 	kernel_physical_mapping_remove(start, start + size);
 }
 #endif /* CONFIG_MEMORY_HOTPLUG */

arch/x86/um/tls_32.c+2−4

 	return 0;
 }
-int arch_copy_tls(struct task_struct *new)
+int arch_set_tls(struct task_struct *new, unsigned long tls)
 {
 	struct user_desc info;
 	int idx, ret = -EFAULT;
-	if (copy_from_user(&info,
+	if (copy_from_user(&info, (void __user *) tls, sizeof(info)))
-			   (void __user *) UPT_SI(&new->thread.regs.regs),
-			   sizeof(info)))
 		goto out;
 	ret = -EINVAL;

arch/x86/um/tls_64.c+3−4

 {
 }
-int arch_copy_tls(struct task_struct *t)
+int arch_set_tls(struct task_struct *t, unsigned long tls)
 {
 	/*
 	 * If CLONE_SETTLS is set, we need to save the thread id
-	 * (which is argument 5, child_tid, of clone) so it can be set
+	 * so it can be set during context switches.
-	 * during context switches.
 	 */
-	t->thread.arch.fs = t->thread.regs.regs.gp[R8 / sizeof(long)];
+	t->thread.arch.fs = tls;
 	return 0;
 }

arch/xtensa/Kconfig+1−0

@@ -24,6 +24,7 @@ config XTENSA · 23 unmodified lines
24	select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL	24	select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL
25	select HAVE_ARCH_KASAN if MMU && !XIP_KERNEL	25	select HAVE_ARCH_KASAN if MMU && !XIP_KERNEL
26	select HAVE_ARCH_TRACEHOOK	26	select HAVE_ARCH_TRACEHOOK
		27	select HAVE_COPY_THREAD_TLS
27	select HAVE_DEBUG_KMEMLEAK	28	select HAVE_DEBUG_KMEMLEAK
28	select HAVE_DMA_CONTIGUOUS	29	select HAVE_DMA_CONTIGUOUS
29	select HAVE_EXIT_THREAD	30	select HAVE_EXIT_THREAD

arch/xtensa/kernel/process.c+4−4

  * involved.  Much simpler to just not copy those live frames across.
  */
-int copy_thread(unsigned long clone_flags, unsigned long usp_thread_fn,
+int copy_thread_tls(unsigned long clone_flags, unsigned long usp_thread_fn,
-		unsigned long thread_fn_arg, struct task_struct *p)
+		unsigned long thread_fn_arg, struct task_struct *p,
+		unsigned long tls)
 {
 	struct pt_regs *childregs = task_pt_regs(p);
 		childregs->syscall = regs->syscall;
-		/* The thread pointer is passed in the '4th argument' (= a5) */
 		if (clone_flags & CLONE_SETTLS)
-			childregs->threadptr = childregs->areg[5];
+			childregs->threadptr = tls;
 	} else {
 		p->thread.ra = MAKE_RA_FOR_CALL(
 				(unsigned long)ret_from_kernel_thread, 1);

block/bio.c+49−0

@@ -538,6 +538,55 @@ void zero_fill_bio_iter(struct bio *bio, struct bvec_iter start) · 537 unmodified lines
538	}	538	}
539	EXPORT_SYMBOL(zero_fill_bio_iter);	539	EXPORT_SYMBOL(zero_fill_bio_iter);
540		540
		541	/**
		542	* bio_truncate - truncate the bio to small size of @new_size
		543	* @bio: the bio to be truncated
		544	* @new_size: new size for truncating the bio
		545	*
		546	* Description:
		547	* Truncate the bio to new size of @new_size. If bio_op(bio) is
		548	* REQ_OP_READ, zero the truncated part. This function should only
		549	* be used for handling corner cases, such as bio eod.
		550	*/
		551	void bio_truncate(struct bio *bio, unsigned new_size)
		552	{
		553	struct bio_vec bv;
		554	struct bvec_iter iter;
		555	unsigned int done = 0;
		556	bool truncated = false;
		557
		558	if (new_size >= bio->bi_iter.bi_size)
		559	return;
		560
		561	if (bio_op(bio) != REQ_OP_READ)
		562	goto exit;
		563
		564	bio_for_each_segment(bv, bio, iter) {
		565	if (done + bv.bv_len > new_size) {
		566	unsigned offset;
		567
		568	if (!truncated)
		569	offset = new_size - done;
		570	else
		571	offset = 0;
		572	zero_user(bv.bv_page, offset, bv.bv_len - offset);
		573	truncated = true;
		574	}
		575	done += bv.bv_len;
		576	}
		577
		578	exit:
		579	/*
		580	* Don't touch bvec table here and make it really immutable, since
		581	* fs bio user has to retrieve all pages via bio_for_each_segment_all
		582	* in its .end_bio() callback.
		583	*
		584	* It is enough to truncate bio by updating .bi_size since we can make
		585	* correct bvec with the updated .bi_size for drivers.
		586	*/
		587	bio->bi_iter.bi_size = new_size;
		588	}
		589
541	/**	590	/**
542	* bio_put - release a reference to a bio	591	* bio_put - release a reference to a bio
543	* @bio: bio to release reference to	592	* @bio: bio to release reference to

block/blk-merge.c+9−9

 	return sectors & (lbs - 1);
 }
-static unsigned get_max_segment_size(const struct request_queue *q,
+static inline unsigned get_max_segment_size(const struct request_queue *q,
-				     unsigned offset)
+					    struct page *start_page,
+					    unsigned long offset)
 {
 	unsigned long mask = queue_segment_boundary(q);
-	/* default segment boundary mask means no boundary limit */
+	offset = mask & (page_to_phys(start_page) + offset);
-	if (mask == BLK_SEG_BOUNDARY_MASK)
+	return min_t(unsigned long, mask - offset + 1,
-		return queue_max_segment_size(q);
-	return min_t(unsigned long, mask - (mask & offset) + 1,
 		     queue_max_segment_size(q));
 }
 	unsigned seg_size = 0;
 	while (len && *nsegs < max_segs) {
-		seg_size = get_max_segment_size(q, bv->bv_offset + total_len);
+		seg_size = get_max_segment_size(q, bv->bv_page,
+						bv->bv_offset + total_len);
 		seg_size = min(seg_size, len);
 		(*nsegs)++;
 	while (nbytes > 0) {
 		unsigned offset = bvec->bv_offset + total;
-		unsigned len = min(get_max_segment_size(q, offset), nbytes);
+		unsigned len = min(get_max_segment_size(q, bvec->bv_page,
+					offset), nbytes);
 		struct page *page = bvec->bv_page;
 		/*

block/compat_ioctl.c+16−0

 #include <linux/compat.h>
 #include <linux/elevator.h>
 #include <linux/hdreg.h>
+#include <linux/pr.h>
 #include <linux/slab.h>
 #include <linux/syscalls.h>
 #include <linux/types.h>
 	 * but we call blkdev_ioctl, which gets the lock for us
 	 */
 	case BLKRRPART:
+	case BLKREPORTZONE:
+	case BLKRESETZONE:
+	case BLKOPENZONE:
+	case BLKCLOSEZONE:
+	case BLKFINISHZONE:
+	case BLKGETZONESZ:
+	case BLKGETNRZONES:
 		return blkdev_ioctl(bdev, mode, cmd,
 				(unsigned long)compat_ptr(arg));
 	case BLKBSZSET_32:
 	case BLKTRACETEARDOWN: /* compatible */
 		ret = blk_trace_ioctl(bdev, cmd, compat_ptr(arg));
 		return ret;
+	case IOC_PR_REGISTER:
+	case IOC_PR_RESERVE:
+	case IOC_PR_RELEASE:
+	case IOC_PR_PREEMPT:
+	case IOC_PR_PREEMPT_ABORT:
+	case IOC_PR_CLEAR:
+		return blkdev_ioctl(bdev, mode, cmd,
+				(unsigned long)compat_ptr(arg));
 	default:
 		if (disk->fops->compat_ioctl)
 			ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);

drivers/ata/ahci_brcm.c+94−39

@@ -76,8 +76,7 @@ enum brcm_ahci_version { · 75 unmodified lines
76	};	76	};
77		77
78	enum brcm_ahci_quirks {	78	enum brcm_ahci_quirks {
79	BRCM_AHCI_QUIRK_NO_NCQ = BIT(0),	79	BRCM_AHCI_QUIRK_SKIP_PHY_ENABLE = BIT(0),
80	BRCM_AHCI_QUIRK_SKIP_PHY_ENABLE = BIT(1),
81	};	80	};
82		81
83	struct brcm_ahci_priv {	82	struct brcm_ahci_priv {
@@ -213,19 +212,12 @@ static void brcm_sata_phys_disable(struct brcm_ahci_priv *priv) · 129 unmodified lines
213	brcm_sata_phy_disable(priv, i);	212	brcm_sata_phy_disable(priv, i);
214	}	213	}
215		214
216	static u32 brcm_ahci_get_portmask(struct platform_device *pdev,	215	static u32 brcm_ahci_get_portmask(struct ahci_host_priv *hpriv,
217	struct brcm_ahci_priv *priv)	216	struct brcm_ahci_priv *priv)
218	{	217	{
219	void __iomem *ahci;
220	struct resource *res;
221	u32 impl;	218	u32 impl;
222		219
223	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ahci");	220	impl = readl(hpriv->mmio + HOST_PORTS_IMPL);
224	ahci = devm_ioremap_resource(&pdev->dev, res);
225	if (IS_ERR(ahci))
226	return 0;
227
228	impl = readl(ahci + HOST_PORTS_IMPL);
229		221
230	if (fls(impl) > SATA_TOP_MAX_PHYS)	222	if (fls(impl) > SATA_TOP_MAX_PHYS)
231	dev_warn(priv->dev, "warning: more ports than PHYs (%#x)\n",	223	dev_warn(priv->dev, "warning: more ports than PHYs (%#x)\n",
@@ -233,9 +225,6 @@ static u32 brcm_ahci_get_portmask(struct platform_device *pdev, · 1 unmodified line
233	else if (!impl)	225	else if (!impl)
234	dev_info(priv->dev, "no ports found\n");	226	dev_info(priv->dev, "no ports found\n");
235		227
236	devm_iounmap(&pdev->dev, ahci);
237	devm_release_mem_region(&pdev->dev, res->start, resource_size(res));
238
239	return impl;	228	return impl;
240	}	229	}
241		230
@@ -285,6 +274,13 @@ static unsigned int brcm_ahci_read_id(struct ata_device *dev, · 43 unmodified lines
285	/* Perform the SATA PHY reset sequence */	274	/* Perform the SATA PHY reset sequence */
286	brcm_sata_phy_disable(priv, ap->port_no);	275	brcm_sata_phy_disable(priv, ap->port_no);
287		276
		277	/* Reset the SATA clock */
		278	ahci_platform_disable_clks(hpriv);
		279	msleep(10);
		280
		281	ahci_platform_enable_clks(hpriv);
		282	msleep(10);
		283
288	/* Bring the PHY back on */	284	/* Bring the PHY back on */
289	brcm_sata_phy_enable(priv, ap->port_no);	285	brcm_sata_phy_enable(priv, ap->port_no);
290		286
@@ -347,11 +343,10 @@ static int brcm_ahci_suspend(struct device *dev) · 56 unmodified lines
347	struct ata_host *host = dev_get_drvdata(dev);	343	struct ata_host *host = dev_get_drvdata(dev);
348	struct ahci_host_priv *hpriv = host->private_data;	344	struct ahci_host_priv *hpriv = host->private_data;
349	struct brcm_ahci_priv *priv = hpriv->plat_data;	345	struct brcm_ahci_priv *priv = hpriv->plat_data;
350	int ret;
351		346
352	ret = ahci_platform_suspend(dev);
353	brcm_sata_phys_disable(priv);	347	brcm_sata_phys_disable(priv);
354	return ret;	348
		349	return ahci_platform_suspend(dev);
355	}	350	}
356		351
357	static int brcm_ahci_resume(struct device *dev)	352	static int brcm_ahci_resume(struct device *dev)
@@ -359,11 +354,44 @@ static int brcm_ahci_resume(struct device *dev) · 1 unmodified line
359	struct ata_host *host = dev_get_drvdata(dev);	354	struct ata_host *host = dev_get_drvdata(dev);
360	struct ahci_host_priv *hpriv = host->private_data;	355	struct ahci_host_priv *hpriv = host->private_data;
361	struct brcm_ahci_priv *priv = hpriv->plat_data;	356	struct brcm_ahci_priv *priv = hpriv->plat_data;
		357	int ret;
		358
		359	/* Make sure clocks are turned on before re-configuration */
		360	ret = ahci_platform_enable_clks(hpriv);
		361	if (ret)
		362	return ret;
362		363
363	brcm_sata_init(priv);	364	brcm_sata_init(priv);
364	brcm_sata_phys_enable(priv);	365	brcm_sata_phys_enable(priv);
365	brcm_sata_alpm_init(hpriv);	366	brcm_sata_alpm_init(hpriv);
366	return ahci_platform_resume(dev);	367
		368	/* Since we had to enable clocks earlier on, we cannot use
		369	* ahci_platform_resume() as-is since a second call to
		370	* ahci_platform_enable_resources() would bump up the resources
		371	* (regulators, clocks, PHYs) count artificially so we copy the part
		372	* after ahci_platform_enable_resources().
		373	*/
		374	ret = ahci_platform_enable_phys(hpriv);
		375	if (ret)
		376	goto out_disable_phys;
		377
		378	ret = ahci_platform_resume_host(dev);
		379	if (ret)
		380	goto out_disable_platform_phys;
		381
		382	/* We resumed so update PM runtime state */
		383	pm_runtime_disable(dev);
		384	pm_runtime_set_active(dev);
		385	pm_runtime_enable(dev);
		386
		387	return 0;
		388
		389	out_disable_platform_phys:
		390	ahci_platform_disable_phys(hpriv);
		391	out_disable_phys:
		392	brcm_sata_phys_disable(priv);
		393	ahci_platform_disable_clks(hpriv);
		394	return ret;
367	}	395	}
368	#endif	396	#endif
369		397
@@ -410,44 +438,71 @@ static int brcm_ahci_probe(struct platform_device *pdev) · 40 unmodified lines
410	if (!IS_ERR_OR_NULL(priv->rcdev))	438	if (!IS_ERR_OR_NULL(priv->rcdev))
411	reset_control_deassert(priv->rcdev);	439	reset_control_deassert(priv->rcdev);
412		440
413	if ((priv->version == BRCM_SATA_BCM7425) \|\|	441	hpriv = ahci_platform_get_resources(pdev, 0);
414	(priv->version == BRCM_SATA_NSP)) {	442	if (IS_ERR(hpriv)) {
415	priv->quirks \|= BRCM_AHCI_QUIRK_NO_NCQ;	443	ret = PTR_ERR(hpriv);
		444	goto out_reset;
		445	}
		446
		447	hpriv->plat_data = priv;
		448	hpriv->flags = AHCI_HFLAG_WAKE_BEFORE_STOP \| AHCI_HFLAG_NO_WRITE_TO_RO;
		449
		450	switch (priv->version) {
		451	case BRCM_SATA_BCM7425:
		452	hpriv->flags \|= AHCI_HFLAG_DELAY_ENGINE;
		453	/* fall through */
		454	case BRCM_SATA_NSP:
		455	hpriv->flags \|= AHCI_HFLAG_NO_NCQ;
416	priv->quirks \|= BRCM_AHCI_QUIRK_SKIP_PHY_ENABLE;	456	priv->quirks \|= BRCM_AHCI_QUIRK_SKIP_PHY_ENABLE;
		457	break;
		458	default:
		459	break;
417	}	460	}
418		461
		462	ret = ahci_platform_enable_clks(hpriv);
		463	if (ret)
		464	goto out_reset;
		465
		466	/* Must be first so as to configure endianness including that
		467	* of the standard AHCI register space.
		468	*/
419	brcm_sata_init(priv);	469	brcm_sata_init(priv);
420		470
421	priv->port_mask = brcm_ahci_get_portmask(pdev, priv);	471	/* Initializes priv->port_mask which is used below */
422	if (!priv->port_mask)	472	priv->port_mask = brcm_ahci_get_portmask(hpriv, priv);
423	return -ENODEV;	473	if (!priv->port_mask) {
		474	ret = -ENODEV;
		475	goto out_disable_clks;
		476	}
424		477
		478	/* Must be done before ahci_platform_enable_phys() */
425	brcm_sata_phys_enable(priv);	479	brcm_sata_phys_enable(priv);
426		480
427	hpriv = ahci_platform_get_resources(pdev, 0);
428	if (IS_ERR(hpriv))
429	return PTR_ERR(hpriv);
430	hpriv->plat_data = priv;
431	hpriv->flags = AHCI_HFLAG_WAKE_BEFORE_STOP;
432
433	brcm_sata_alpm_init(hpriv);	481	brcm_sata_alpm_init(hpriv);
434		482
435	ret = ahci_platform_enable_resources(hpriv);	483	ret = ahci_platform_enable_phys(hpriv);
436	if (ret)	484	if (ret)
437	return ret;	485	goto out_disable_phys;
438
439	if (priv->quirks & BRCM_AHCI_QUIRK_NO_NCQ)
440	hpriv->flags \|= AHCI_HFLAG_NO_NCQ;
441	hpriv->flags \|= AHCI_HFLAG_NO_WRITE_TO_RO;
442		486
443	ret = ahci_platform_init_host(pdev, hpriv, &ahci_brcm_port_info,	487	ret = ahci_platform_init_host(pdev, hpriv, &ahci_brcm_port_info,
444	&ahci_platform_sht);	488	&ahci_platform_sht);
445	if (ret)	489	if (ret)
446	return ret;	490	goto out_disable_platform_phys;
447		491
448	dev_info(dev, "Broadcom AHCI SATA3 registered\n");	492	dev_info(dev, "Broadcom AHCI SATA3 registered\n");
449		493
450	return 0;	494	return 0;
		495
		496	out_disable_platform_phys:
		497	ahci_platform_disable_phys(hpriv);
		498	out_disable_phys:
		499	brcm_sata_phys_disable(priv);
		500	out_disable_clks:
		501	ahci_platform_disable_clks(hpriv);
		502	out_reset:
		503	if (!IS_ERR_OR_NULL(priv->rcdev))
		504	reset_control_assert(priv->rcdev);
		505	return ret;
451	}	506	}
452		507
453	static int brcm_ahci_remove(struct platform_device *pdev)	508	static int brcm_ahci_remove(struct platform_device *pdev)
@@ -457,12 +512,12 @@ static int brcm_ahci_remove(struct platform_device *pdev) · 3 unmodified lines
457	struct brcm_ahci_priv *priv = hpriv->plat_data;	512	struct brcm_ahci_priv *priv = hpriv->plat_data;
458	int ret;	513	int ret;
459		514
		515	brcm_sata_phys_disable(priv);
		516
460	ret = ata_platform_remove_one(pdev);	517	ret = ata_platform_remove_one(pdev);
461	if (ret)	518	if (ret)
462	return ret;	519	return ret;
463		520
464	brcm_sata_phys_disable(priv);
465
466	return 0;	521	return 0;
467	}	522	}
468		523

drivers/ata/libahci_platform.c+4−2

  * RETURNS:
  * 0 on success otherwise a negative error code
  */
-static int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
+int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
 {
 	int rc, i;
 	}
 	return rc;
 }
+EXPORT_SYMBOL_GPL(ahci_platform_enable_phys);
 /**
  * ahci_platform_disable_phys - Disable PHYs
  *
  * This function disables all PHYs found in hpriv->phys.
  */
-static void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
+void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
 {
 	int i;
 		phy_exit(hpriv->phys[i]);
 	}
 }
+EXPORT_SYMBOL_GPL(ahci_platform_disable_phys);
 /**
  * ahci_platform_enable_clks - Enable platform clocks

drivers/ata/libata-core.c+24−0

@@ -5328,6 +5328,30 @@ void ata_qc_complete(struct ata_queued_cmd *qc) · 5327 unmodified lines
5328	}	5328	}
5329	}	5329	}
5330		5330
		5331	/**
		5332	* ata_qc_get_active - get bitmask of active qcs
		5333	* @ap: port in question
		5334	*
		5335	* LOCKING:
		5336	* spin_lock_irqsave(host lock)
		5337	*
		5338	* RETURNS:
		5339	* Bitmask of active qcs
		5340	*/
		5341	u64 ata_qc_get_active(struct ata_port *ap)
		5342	{
		5343	u64 qc_active = ap->qc_active;
		5344
		5345	/* ATA_TAG_INTERNAL is sent to hw as tag 0 */
		5346	if (qc_active & (1ULL << ATA_TAG_INTERNAL)) {
		5347	qc_active \|= (1 << 0);
		5348	qc_active &= ~(1ULL << ATA_TAG_INTERNAL);
		5349	}
		5350
		5351	return qc_active;
		5352	}
		5353	EXPORT_SYMBOL_GPL(ata_qc_get_active);
		5354
5331	/**	5355	/**
5332	* ata_qc_complete_multiple - Complete multiple qcs successfully	5356	* ata_qc_complete_multiple - Complete multiple qcs successfully
5333	* @ap: port in question	5357	* @ap: port in question

drivers/ata/sata_fsl.c+1−1

@@ -1280,7 +1280,7 @@ static void sata_fsl_host_intr(struct ata_port *ap) · 1279 unmodified lines
1280	i, ioread32(hcr_base + CC),	1280	i, ioread32(hcr_base + CC),
1281	ioread32(hcr_base + CA));	1281	ioread32(hcr_base + CA));
1282	}	1282	}
1283	ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);	1283	ata_qc_complete_multiple(ap, ata_qc_get_active(ap) ^ done_mask);
1284	return;	1284	return;
1285		1285
1286	} else if ((ap->qc_active & (1ULL << ATA_TAG_INTERNAL))) {	1286	} else if ((ap->qc_active & (1ULL << ATA_TAG_INTERNAL))) {

drivers/ata/sata_mv.c+1−1

@@ -2829,7 +2829,7 @@ static void mv_process_crpb_entries(struct ata_port ap, struct mv_port_priv pp · 2828 unmodified lines
2829	}	2829	}
2830		2830
2831	if (work_done) {	2831	if (work_done) {
2832	ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);	2832	ata_qc_complete_multiple(ap, ata_qc_get_active(ap) ^ done_mask);
2833		2833
2834	/* Update the software queue position index in hardware */	2834	/* Update the software queue position index in hardware */
2835	writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) \|	2835	writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) \|

drivers/ata/sata_nv.c+1−1

@@ -984,7 +984,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance) · 983 unmodified lines
984	check_commands = 0;	984	check_commands = 0;
985	check_commands &= ~(1 << pos);	985	check_commands &= ~(1 << pos);
986	}	986	}
987	ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);	987	ata_qc_complete_multiple(ap, ata_qc_get_active(ap) ^ done_mask);
988	}	988	}
989	}	989	}
990		990

drivers/atm/eni.c+2−2

@@ -374,7 +374,7 @@ static int do_rx_dma(struct atm_vcc vcc,struct sk_buff skb, · 373 unmodified lines
374	here = (eni_vcc->descr+skip) & (eni_vcc->words-1);	374	here = (eni_vcc->descr+skip) & (eni_vcc->words-1);
375	dma[j++] = (here << MID_DMA_COUNT_SHIFT) \| (vcc->vci	375	dma[j++] = (here << MID_DMA_COUNT_SHIFT) \| (vcc->vci
376	<< MID_DMA_VCI_SHIFT) \| MID_DT_JK;	376	<< MID_DMA_VCI_SHIFT) \| MID_DT_JK;
377	j++;	377	dma[j++] = 0;
378	}	378	}
379	here = (eni_vcc->descr+size+skip) & (eni_vcc->words-1);	379	here = (eni_vcc->descr+size+skip) & (eni_vcc->words-1);
380	if (!eff) size += skip;	380	if (!eff) size += skip;
@@ -447,7 +447,7 @@ static int do_rx_dma(struct atm_vcc vcc,struct sk_buff skb, · 66 unmodified lines
447	if (size != eff) {	447	if (size != eff) {
448	dma[j++] = (here << MID_DMA_COUNT_SHIFT) \|	448	dma[j++] = (here << MID_DMA_COUNT_SHIFT) \|
449	(vcc->vci << MID_DMA_VCI_SHIFT) \| MID_DT_JK;	449	(vcc->vci << MID_DMA_VCI_SHIFT) \| MID_DT_JK;
450	j++;	450	dma[j++] = 0;
451	}	451	}
452	if (!j \|\| j > 2*RX_DMA_BUF) {	452	if (!j \|\| j > 2*RX_DMA_BUF) {
453	printk(KERN_CRIT DEV_LABEL "!j or j too big!!!\n");	453	printk(KERN_CRIT DEV_LABEL "!j or j too big!!!\n");

drivers/block/null_blk_zoned.c+4−1

 		if (zone->cond == BLK_ZONE_COND_FULL)
 			return BLK_STS_IOERR;
-		zone->cond = BLK_ZONE_COND_CLOSED;
+		if (zone->wp == zone->start)
+			zone->cond = BLK_ZONE_COND_EMPTY;
+		else
+			zone->cond = BLK_ZONE_COND_CLOSED;
 		break;
 	case REQ_OP_ZONE_FINISH:
 		if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)

drivers/block/pktcdvd.c+1−1

@@ -2707,7 +2707,7 @@ static const struct block_device_operations pktcdvd_ops = { · 2706 unmodified lines
2707	.release = pkt_close,	2707	.release = pkt_close,
2708	.ioctl = pkt_ioctl,	2708	.ioctl = pkt_ioctl,
2709	#ifdef CONFIG_COMPAT	2709	#ifdef CONFIG_COMPAT
2710	.ioctl = pkt_compat_ioctl,	2710	.compat_ioctl = pkt_compat_ioctl,
2711	#endif	2711	#endif
2712	.check_events = pkt_check_events,	2712	.check_events = pkt_check_events,
2713	};	2713	};

drivers/char/agp/isoch.c+1−8

 	unsigned int cdev = 0;
 	u32 mnistat, tnistat, tstatus, mcmd;
 	u16 tnicmd, mnicmd;
-	u8 mcapndx;
 	u32 tot_bw = 0, tot_n = 0, tot_rq = 0, y_max, rq_isoch, rq_async;
 	u32 step, rem, rem_isoch, rem_async;
 	int ret = 0;
 		cur = list_entry(pos, struct agp_3_5_dev, list);
 		dev = cur->dev;
-		mcapndx = cur->capndx;
 		pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat);
 		master[cdev].maxbw = (mnistat >> 16) & 0xff;
 		cur = master[cdev].dev;
 		dev = cur->dev;
-		mcapndx = cur->capndx;
 		master[cdev].rq += (cdev == ndevs - 1)
 		              ? (rem_async + rem_isoch) : step;
 {
 	struct pci_dev *td = bridge->dev, *dev = NULL;
 	u8 mcapndx;
-	u32 isoch, arqsz;
+	u32 isoch;
 	u32 tstatus, mstatus, ncapid;
 	u32 mmajor;
 	u16 mpstat;
 	if (isoch == 0)	/* isoch xfers not available, bail out. */
 		return -ENODEV;
-	arqsz     = (tstatus >> 13) & 0x7;
 	/*
 	 * Allocate a head for our AGP 3.5 device list
 	 * (multiple AGP v3 devices are allowed behind a single bridge).

drivers/char/tpm/tpm-dev-common.c+1−1

@@ -130,7 +130,7 @@ ssize_t tpm_common_read(struct file file, char __user buf, · 129 unmodified lines
130	priv->response_read = true;	130	priv->response_read = true;
131		131
132	ret_size = min_t(ssize_t, size, priv->response_length);	132	ret_size = min_t(ssize_t, size, priv->response_length);
133	if (!ret_size) {	133	if (ret_size <= 0) {
134	priv->response_length = 0;	134	priv->response_length = 0;
135	goto out;	135	goto out;
136	}	136	}

drivers/char/tpm/tpm-dev.h+1−1

@@ -14,7 +14,7 @@ struct file_priv { · 13 unmodified lines
14	struct work_struct timeout_work;	14	struct work_struct timeout_work;
15	struct work_struct async_work;	15	struct work_struct async_work;
16	wait_queue_head_t async_wait;	16	wait_queue_head_t async_wait;
17	size_t response_length;	17	ssize_t response_length;
18	bool response_read;	18	bool response_read;
19	bool command_enqueued;	19	bool command_enqueued;
20		20

drivers/char/tpm/tpm_tis_core.c+15−19

 	if (wait_startup(chip, 0) != 0) {
 		rc = -ENODEV;
-		goto err_start;
+		goto out_err;
 	}
 	/* Take control of the TPM's interrupt hardware and shut it off */
 	rc = tpm_tis_read32(priv, TPM_INT_ENABLE(priv->locality), &intmask);
 	if (rc < 0)
-		goto err_start;
+		goto out_err;
 	intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT |
 		   TPM_INTF_DATA_AVAIL_INT | TPM_INTF_STS_VALID_INT;
 	rc = tpm_chip_start(chip);
 	if (rc)
-		goto err_start;
+		goto out_err;
 	rc = tpm2_probe(chip);
+	tpm_chip_stop(chip);
 	if (rc)
-		goto err_probe;
+		goto out_err;
 	rc = tpm_tis_read32(priv, TPM_DID_VID(0), &vendor);
 	if (rc < 0)
-		goto err_probe;
+		goto out_err;
 	priv->manufacturer_id = vendor;
 	rc = tpm_tis_read8(priv, TPM_RID(0), &rid);
 	if (rc < 0)
-		goto err_probe;
+		goto out_err;
 	dev_info(dev, "%s TPM (device-id 0x%X, rev-id %d)\n",
 		 (chip->flags & TPM_CHIP_FLAG_TPM2) ? "2.0" : "1.2",
 	probe = probe_itpm(chip);
 	if (probe < 0) {
 		rc = -ENODEV;
-		goto err_probe;
+		goto out_err;
 	}
 	/* Figure out the capabilities */
 	rc = tpm_tis_read32(priv, TPM_INTF_CAPS(priv->locality), &intfcaps);
 	if (rc < 0)
-		goto err_probe;
+		goto out_err;
 	dev_dbg(dev, "TPM interface capabilities (0x%x):\n",
 		intfcaps);
 		if (tpm_get_timeouts(chip)) {
 			dev_err(dev, "Could not get TPM timeouts and durations\n");
 			rc = -ENODEV;
-			goto err_probe;
+			goto out_err;
 		}
-		chip->flags |= TPM_CHIP_FLAG_IRQ;
 		if (irq) {
 			tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
 						 irq);
 		}
 	}
-	tpm_chip_stop(chip);
 	rc = tpm_chip_register(chip);
 	if (rc)
-		goto err_start;
+		goto out_err;
-	return 0;
-err_probe:
+	if (chip->ops->clk_enable != NULL)
-	tpm_chip_stop(chip);
+		chip->ops->clk_enable(chip, false);
-err_start:
+	return 0;
+out_err:
 	if ((chip->ops != NULL) && (chip->ops->clk_enable != NULL))
 		chip->ops->clk_enable(chip, false);

drivers/clocksource/timer-riscv.c+1−1

@@ -56,7 +56,7 @@ static unsigned long long riscv_clocksource_rdtime(struct clocksource *cs) · 55 unmodified lines
56	return get_cycles64();	56	return get_cycles64();
57	}	57	}
58		58
59	static u64 riscv_sched_clock(void)	59	static u64 notrace riscv_sched_clock(void)
60	{	60	{
61	return get_cycles64();	61	return get_cycles64();
62	}	62	}

drivers/cpufreq/cpufreq-dt-platdev.c+2−0

@@ -121,6 +121,8 @@ static const struct of_device_id blacklist[] __initconst = { · 120 unmodified lines
121	{ .compatible = "mediatek,mt8176", },	121	{ .compatible = "mediatek,mt8176", },
122	{ .compatible = "mediatek,mt8183", },	122	{ .compatible = "mediatek,mt8183", },
123		123
		124	{ .compatible = "nvidia,tegra20", },
		125	{ .compatible = "nvidia,tegra30", },
124	{ .compatible = "nvidia,tegra124", },	126	{ .compatible = "nvidia,tegra124", },
125	{ .compatible = "nvidia,tegra210", },	127	{ .compatible = "nvidia,tegra210", },
126		128

drivers/devfreq/Kconfig+1−4

 	select DEVFREQ_GOV_PASSIVE
 	select DEVFREQ_EVENT_EXYNOS_PPMU
 	select PM_DEVFREQ_EVENT
-	select PM_OPP
 	help
 	  This adds the common DEVFREQ driver for Exynos Memory bus. Exynos
 	  Memory bus has one more group of memory bus (e.g, MIF and INT block).
 		ARCH_TEGRA_132_SOC || ARCH_TEGRA_124_SOC || \
 		ARCH_TEGRA_210_SOC || \
 		COMPILE_TEST
-	select PM_OPP
+	depends on COMMON_CLK
 	help
 	  This adds the DEVFREQ driver for the Tegra family of SoCs.
 	  It reads ACTMON counters of memory controllers and adjusts the
 	depends on (TEGRA_MC && TEGRA20_EMC) || COMPILE_TEST
 	depends on COMMON_CLK
 	select DEVFREQ_GOV_SIMPLE_ONDEMAND
-	select PM_OPP
 	help
 	  This adds the DEVFREQ driver for the Tegra20 family of SoCs.
 	  It reads Memory Controller counters and adjusts the operating
 	select DEVFREQ_EVENT_ROCKCHIP_DFI
 	select DEVFREQ_GOV_SIMPLE_ONDEMAND
 	select PM_DEVFREQ_EVENT
-	select PM_OPP
 	help
           This adds the DEVFREQ driver for the RK3399 DMC(Dynamic Memory Controller).
           It sets the frequency for the memory controller and reads the usage counts

drivers/dma/dma-jz4780.c+2−1

@@ -999,7 +999,8 @@ static const struct jz4780_dma_soc_data jz4740_dma_soc_data = { · 998 unmodified lines
999	static const struct jz4780_dma_soc_data jz4725b_dma_soc_data = {	999	static const struct jz4780_dma_soc_data jz4725b_dma_soc_data = {
1000	.nb_channels = 6,	1000	.nb_channels = 6,
1001	.transfer_ord_max = 5,	1001	.transfer_ord_max = 5,
1002	.flags = JZ_SOC_DATA_PER_CHAN_PM \| JZ_SOC_DATA_NO_DCKES_DCKEC,	1002	.flags = JZ_SOC_DATA_PER_CHAN_PM \| JZ_SOC_DATA_NO_DCKES_DCKEC \|
		1003	JZ_SOC_DATA_BREAK_LINKS,
1003	};	1004	};
1004		1005
1005	static const struct jz4780_dma_soc_data jz4770_dma_soc_data = {	1006	static const struct jz4780_dma_soc_data jz4770_dma_soc_data = {

drivers/dma/ioat/dma.c+2−1

 		descs->virt = dma_alloc_coherent(to_dev(ioat_chan),
 						 SZ_2M, &descs->hw, flags);
-		if (!descs->virt && (i > 0)) {
+		if (!descs->virt) {
 			int idx;
 			for (idx = 0; idx < i; idx++) {
+				descs = &ioat_chan->descs[idx];
 				dma_free_coherent(to_dev(ioat_chan), SZ_2M,
 						  descs->virt, descs->hw);
 				descs->virt = NULL;

drivers/dma/k3dma.c+9−3

 			c = p->vchan;
 			if (c && (tc1 & BIT(i))) {
 				spin_lock_irqsave(&c->vc.lock, flags);
-				vchan_cookie_complete(&p->ds_run->vd);
+				if (p->ds_run != NULL) {
-				p->ds_done = p->ds_run;
+					vchan_cookie_complete(&p->ds_run->vd);
-				p->ds_run = NULL;
+					p->ds_done = p->ds_run;
+					p->ds_run = NULL;
+				}
 				spin_unlock_irqrestore(&c->vc.lock, flags);
 			}
 			if (c && (tc2 & BIT(i))) {
 	if (BIT(c->phy->idx) & k3_dma_get_chan_stat(d))
 		return -EAGAIN;
+	/* Avoid losing track of  ds_run if a transaction is in flight */
+	if (c->phy->ds_run)
+		return -EAGAIN;
 	if (vd) {
 		struct k3_dma_desc_sw *ds =
 			container_of(vd, struct k3_dma_desc_sw, vd);

drivers/dma/virt-dma.c+1−2

@@ -104,9 +104,8 @@ static void vchan_complete(unsigned long arg) · 103 unmodified lines
104	dmaengine_desc_get_callback(&vd->tx, &cb);	104	dmaengine_desc_get_callback(&vd->tx, &cb);
105		105
106	list_del(&vd->node);	106	list_del(&vd->node);
107	vchan_vdesc_fini(vd);
108
109	dmaengine_desc_callback_invoke(&cb, &vd->tx_result);	107	dmaengine_desc_callback_invoke(&cb, &vd->tx_result);
		108	vchan_vdesc_fini(vd);
110	}	109	}
111	}	110	}
112		111

drivers/edac/sifive_edac.c+1−1

@@ -10,7 +10,7 @@ · 9 unmodified lines
10	#include <linux/edac.h>	10	#include <linux/edac.h>
11	#include <linux/platform_device.h>	11	#include <linux/platform_device.h>
12	#include "edac_module.h"	12	#include "edac_module.h"
13	#include <asm/sifive_l2_cache.h>	13	#include <soc/sifive/sifive_l2_cache.h>
14		14
15	#define DRVNAME "sifive_edac"	15	#define DRVNAME "sifive_edac"
16		16

drivers/firmware/broadcom/tee_bnxt_fw.c+0−1

@@ -215,7 +215,6 @@ static int tee_bnxt_fw_probe(struct device *dev) · 214 unmodified lines
215	fw_shm_pool = tee_shm_alloc(pvt_data.ctx, MAX_SHM_MEM_SZ,	215	fw_shm_pool = tee_shm_alloc(pvt_data.ctx, MAX_SHM_MEM_SZ,
216	TEE_SHM_MAPPED \| TEE_SHM_DMA_BUF);	216	TEE_SHM_MAPPED \| TEE_SHM_DMA_BUF);
217	if (IS_ERR(fw_shm_pool)) {	217	if (IS_ERR(fw_shm_pool)) {
218	tee_client_close_context(pvt_data.ctx);
219	dev_err(pvt_data.dev, "tee_shm_alloc failed\n");	218	dev_err(pvt_data.dev, "tee_shm_alloc failed\n");
220	err = PTR_ERR(fw_shm_pool);	219	err = PTR_ERR(fw_shm_pool);
221	goto out_sess;	220	goto out_sess;

drivers/gpio/Kconfig+3−2

 config GPIO_TEGRA186
 	tristate "NVIDIA Tegra186 GPIO support"
-	default ARCH_TEGRA_186_SOC
+	default ARCH_TEGRA_186_SOC || ARCH_TEGRA_194_SOC
-	depends on ARCH_TEGRA_186_SOC || COMPILE_TEST
+	depends on ARCH_TEGRA_186_SOC || ARCH_TEGRA_194_SOC || COMPILE_TEST
 	depends on OF_GPIO
 	select GPIOLIB_IRQCHIP
 	select IRQ_DOMAIN_HIERARCHY
 config GPIO_MAX77620
 	tristate "GPIO support for PMIC MAX77620 and MAX20024"
 	depends on MFD_MAX77620
+	select GPIOLIB_IRQCHIP
 	help
 	  GPIO driver for MAX77620 and MAX20024 PMIC from Maxim Semiconductor.
 	  MAX77620 PMIC has 8 pins that can be configured as GPIOs. The

drivers/gpio/gpio-aspeed-sgpio.c+1−1

@@ -107,7 +107,7 @@ static void __iomem bank_reg(struct aspeed_sgpio gpio, · 106 unmodified lines
107	return gpio->base + bank->irq_regs + GPIO_IRQ_STATUS;	107	return gpio->base + bank->irq_regs + GPIO_IRQ_STATUS;
108	default:	108	default:
109	/* acturally if code runs to here, it's an error case */	109	/* acturally if code runs to here, it's an error case */
110	BUG_ON(1);	110	BUG();
111	}	111	}
112	}	112	}
113		113

drivers/gpio/gpio-mockup.c+7−4

 	mutex_lock(&chip->lock);
 	if (test_bit(FLAG_REQUESTED, &desc->flags) &&
-		!test_bit(FLAG_IS_OUT, &desc->flags)) {
+	    !test_bit(FLAG_IS_OUT, &desc->flags)) {
 		curr = __gpio_mockup_get(chip, offset);
 		if (curr == value)
 			goto out;
 		irq_type = irq_get_trigger_type(irq);
 		if ((value == 1 && (irq_type & IRQ_TYPE_EDGE_RISING)) ||
-			(value == 0 && (irq_type & IRQ_TYPE_EDGE_FALLING)))
+		    (value == 0 && (irq_type & IRQ_TYPE_EDGE_FALLING)))
 			irq_sim_fire(sim, offset);
 	}
 	int direction;
 	mutex_lock(&chip->lock);
-	direction = !chip->lines[offset].dir;
+	direction = chip->lines[offset].dir;
 	mutex_unlock(&chip->lock);
 	return direction;
 	struct gpio_chip *gc;
 	struct device *dev;
 	const char *name;
-	int rv, base;
+	int rv, base, i;
 	u16 ngpio;
 	dev = &pdev->dev;
 	if (!chip->lines)
 		return -ENOMEM;
+	for (i = 0; i < gc->ngpio; i++)
+		chip->lines[i].dir = GPIO_LINE_DIRECTION_IN;
 	if (device_property_read_bool(dev, "named-gpio-lines")) {
 		rv = gpio_mockup_name_lines(dev, chip);
 		if (rv)

drivers/gpio/gpio-mpc8xxx.c+1−0

@@ -346,6 +346,7 @@ static int mpc8xxx_probe(struct platform_device *pdev) · 345 unmodified lines
346	return -ENOMEM;	346	return -ENOMEM;
347		347
348	gc = &mpc8xxx_gc->gc;	348	gc = &mpc8xxx_gc->gc;
		349	gc->parent = &pdev->dev;
349		350
350	if (of_property_read_bool(np, "little-endian")) {	351	if (of_property_read_bool(np, "little-endian")) {
351	ret = bgpio_init(gc, &pdev->dev, 4,	352	ret = bgpio_init(gc, &pdev->dev, 4,

drivers/gpio/gpio-pca953x.c+10−16

 {
 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 	struct pca953x_chip *chip = gpiochip_get_data(gc);
+	irq_hw_number_t hwirq = irqd_to_hwirq(d);
-	chip->irq_mask[d->hwirq / BANK_SZ] &= ~BIT(d->hwirq % BANK_SZ);
+	clear_bit(hwirq, chip->irq_mask);
 }
 static void pca953x_irq_unmask(struct irq_data *d)
 {
 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 	struct pca953x_chip *chip = gpiochip_get_data(gc);
+	irq_hw_number_t hwirq = irqd_to_hwirq(d);
-	chip->irq_mask[d->hwirq / BANK_SZ] |= BIT(d->hwirq % BANK_SZ);
+	set_bit(hwirq, chip->irq_mask);
 }
 static int pca953x_irq_set_wake(struct irq_data *d, unsigned int on)
 {
 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 	struct pca953x_chip *chip = gpiochip_get_data(gc);
-	int bank_nb = d->hwirq / BANK_SZ;
+	irq_hw_number_t hwirq = irqd_to_hwirq(d);
-	u8 mask = BIT(d->hwirq % BANK_SZ);
 	if (!(type & IRQ_TYPE_EDGE_BOTH)) {
 		dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
 		return -EINVAL;
 	}
-	if (type & IRQ_TYPE_EDGE_FALLING)
+	assign_bit(hwirq, chip->irq_trig_fall, type & IRQ_TYPE_EDGE_FALLING);
-		chip->irq_trig_fall[bank_nb] |= mask;
+	assign_bit(hwirq, chip->irq_trig_raise, type & IRQ_TYPE_EDGE_RISING);
-	else
-		chip->irq_trig_fall[bank_nb] &= ~mask;
-	if (type & IRQ_TYPE_EDGE_RISING)
-		chip->irq_trig_raise[bank_nb] |= mask;
-	else
-		chip->irq_trig_raise[bank_nb] &= ~mask;
 	return 0;
 }
 {
 	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 	struct pca953x_chip *chip = gpiochip_get_data(gc);
-	u8 mask = BIT(d->hwirq % BANK_SZ);
+	irq_hw_number_t hwirq = irqd_to_hwirq(d);
-	chip->irq_trig_raise[d->hwirq / BANK_SZ] &= ~mask;
+	clear_bit(hwirq, chip->irq_trig_raise);
-	chip->irq_trig_fall[d->hwirq / BANK_SZ] &= ~mask;
+	clear_bit(hwirq, chip->irq_trig_fall);
 }
 static bool pca953x_irq_pending(struct pca953x_chip *chip, unsigned long *pending)

drivers/gpio/gpio-xgs-iproc.c+1−1

@@ -280,7 +280,7 @@ static int iproc_gpio_probe(struct platform_device *pdev) · 279 unmodified lines
280	return 0;	280	return 0;
281	}	281	}
282		282
283	static int __exit iproc_gpio_remove(struct platform_device *pdev)	283	static int iproc_gpio_remove(struct platform_device *pdev)
284	{	284	{
285	struct iproc_gpio_chip *chip;	285	struct iproc_gpio_chip *chip;
286		286

drivers/gpio/gpio-xtensa.c+3−4

@@ -44,15 +44,14 @@ static inline unsigned long enable_cp(unsigned long *cpenable) · 43 unmodified lines
44	unsigned long flags;	44	unsigned long flags;
45		45
46	local_irq_save(flags);	46	local_irq_save(flags);
47	RSR_CPENABLE(*cpenable);	47	*cpenable = xtensa_get_sr(cpenable);
48	WSR_CPENABLE(*cpenable \| BIT(XCHAL_CP_ID_XTIOP));	48	xtensa_set_sr(*cpenable \| BIT(XCHAL_CP_ID_XTIOP), cpenable);
49
50	return flags;	49	return flags;
51	}	50	}
52		51
53	static inline void disable_cp(unsigned long flags, unsigned long cpenable)	52	static inline void disable_cp(unsigned long flags, unsigned long cpenable)
54	{	53	{
55	WSR_CPENABLE(cpenable);	54	xtensa_set_sr(cpenable, cpenable);
56	local_irq_restore(flags);	55	local_irq_restore(flags);
57	}	56	}
58		57

drivers/gpio/gpio-zynq.c+5−3

 	unsigned int bank_num;
 	for (bank_num = 0; bank_num < gpio->p_data->max_bank; bank_num++) {
+		writel_relaxed(ZYNQ_GPIO_IXR_DISABLE_ALL, gpio->base_addr +
+				ZYNQ_GPIO_INTDIS_OFFSET(bank_num));
 		writel_relaxed(gpio->context.datalsw[bank_num],
 			       gpio->base_addr +
 			       ZYNQ_GPIO_DATA_LSW_OFFSET(bank_num));
 		writel_relaxed(gpio->context.dirm[bank_num],
 			       gpio->base_addr +
 			       ZYNQ_GPIO_DIRM_OFFSET(bank_num));
-		writel_relaxed(gpio->context.int_en[bank_num],
-			       gpio->base_addr +
-			       ZYNQ_GPIO_INTEN_OFFSET(bank_num));
 		writel_relaxed(gpio->context.int_type[bank_num],
 			       gpio->base_addr +
 			       ZYNQ_GPIO_INTTYPE_OFFSET(bank_num));
 		writel_relaxed(gpio->context.int_any[bank_num],
 			       gpio->base_addr +
 			       ZYNQ_GPIO_INTANY_OFFSET(bank_num));
+		writel_relaxed(~(gpio->context.int_en[bank_num]),
+			       gpio->base_addr +
+			       ZYNQ_GPIO_INTEN_OFFSET(bank_num));
 	}
 }

drivers/gpio/gpiolib-acpi.c+46−5

 #include "gpiolib.h"
 #include "gpiolib-acpi.h"
+#define QUIRK_NO_EDGE_EVENTS_ON_BOOT		0x01l
+#define QUIRK_NO_WAKEUP				0x02l
 static int run_edge_events_on_boot = -1;
 module_param(run_edge_events_on_boot, int, 0444);
 MODULE_PARM_DESC(run_edge_events_on_boot,
 		 "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto");
+static int honor_wakeup = -1;
+module_param(honor_wakeup, int, 0444);
+MODULE_PARM_DESC(honor_wakeup,
+		 "Honor the ACPI wake-capable flag: 0=no, 1=yes, -1=auto");
 /**
  * struct acpi_gpio_event - ACPI GPIO event handler data
  *
 	event->handle = evt_handle;
 	event->handler = handler;
 	event->irq = irq;
-	event->irq_is_wake = agpio->wake_capable == ACPI_WAKE_CAPABLE;
+	event->irq_is_wake = honor_wakeup && agpio->wake_capable == ACPI_WAKE_CAPABLE;
 	event->pin = pin;
 	event->desc = desc;
 /* We must use _sync so that this runs after the first deferred_probe run */
 late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);
-static const struct dmi_system_id run_edge_events_on_boot_blacklist[] = {
+static const struct dmi_system_id gpiolib_acpi_quirks[] = {
 	{
 		/*
 		 * The Minix Neo Z83-4 has a micro-USB-B id-pin handler for
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),
-		}
+		},
+		.driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT,
 	},
 	{
 		/*
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"),
-		}
+		},
+		.driver_data = (void *)QUIRK_NO_EDGE_EVENTS_ON_BOOT,
+	},
+	{
+		/*
+		 * Various HP X2 10 Cherry Trail models use an external
+		 * embedded-controller connected via I2C + an ACPI GPIO
+		 * event handler. The embedded controller generates various
+		 * spurious wakeup events when suspended. So disable wakeup
+		 * for its handler (it uses the only ACPI GPIO event handler).
+		 * This breaks wakeup when opening the lid, the user needs
+		 * to press the power-button to wakeup the system. The
+		 * alternative is suspend simply not working, which is worse.
+		 */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),
+		},
+		.driver_data = (void *)QUIRK_NO_WAKEUP,
 	},
 	{} /* Terminating entry */
 };
 static int acpi_gpio_setup_params(void)
 {
+	const struct dmi_system_id *id;
+	long quirks = 0;
+	id = dmi_first_match(gpiolib_acpi_quirks);
+	if (id)
+		quirks = (long)id->driver_data;
 	if (run_edge_events_on_boot < 0) {
-		if (dmi_check_system(run_edge_events_on_boot_blacklist))
+		if (quirks & QUIRK_NO_EDGE_EVENTS_ON_BOOT)
 			run_edge_events_on_boot = 0;
 		else
 			run_edge_events_on_boot = 1;
 	}
+	if (honor_wakeup < 0) {
+		if (quirks & QUIRK_NO_WAKEUP)
+			honor_wakeup = 0;
+		else
+			honor_wakeup = 1;
+	}
 	return 0;
 }

drivers/gpio/gpiolib.c+11−2

 	chip = gpiod_to_chip(desc);
 	offset = gpio_chip_hwgpio(desc);
+	/*
+	 * Open drain emulation using input mode may incorrectly report
+	 * input here, fix that up.
+	 */
+	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) &&
+	    test_bit(FLAG_IS_OUT, &desc->flags))
+		return 0;
 	if (!chip->get_direction)
 		return -ENOTSUPP;
 		if (chip->ngpio <= p->chip_hwnum) {
 			dev_err(dev,
-				"requested GPIO %d is out of range [0..%d] for chip %s\n",
+				"requested GPIO %u (%u) is out of range [0..%u] for chip %s\n",
-				idx, chip->ngpio, chip->label);
+				idx, p->chip_hwnum, chip->ngpio - 1,
+				chip->label);
 			return ERR_PTR(-EINVAL);
 		}

drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c+11−1

@@ -613,7 +613,17 @@ static bool amdgpu_atpx_detect(void) · 612 unmodified lines
613	bool d3_supported = false;	613	bool d3_supported = false;
614	struct pci_dev *parent_pdev;	614	struct pci_dev *parent_pdev;
615		615
616	while ((pdev = pci_get_class(PCI_BASE_CLASS_DISPLAY << 16, pdev)) != NULL) {	616	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
		617	vga_count++;
		618
		619	has_atpx \|= (amdgpu_atpx_pci_probe_handle(pdev) == true);
		620
		621	parent_pdev = pci_upstream_bridge(pdev);
		622	d3_supported \|= parent_pdev && parent_pdev->bridge_d3;
		623	amdgpu_atpx_get_quirks(pdev);
		624	}
		625
		626	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) {
617	vga_count++;	627	vga_count++;
618		628
619	has_atpx \|= (amdgpu_atpx_pci_probe_handle(pdev) == true);	629	has_atpx \|= (amdgpu_atpx_pci_probe_handle(pdev) == true);

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+4−3

 int amdgpu_mcbp = 0;
 int amdgpu_discovery = -1;
 int amdgpu_mes = 0;
-int amdgpu_noretry = 1;
+int amdgpu_noretry;
 int amdgpu_force_asic_type = -1;
 struct amdgpu_mgpu_info mgpu_info = {
 module_param_named(mes, amdgpu_mes, int, 0444);
 MODULE_PARM_DESC(noretry,
-	"Disable retry faults (0 = retry enabled, 1 = retry disabled (default))");
+	"Disable retry faults (0 = retry enabled (default), 1 = retry disabled)");
 module_param_named(noretry, amdgpu_noretry, int, 0644);
 /**
 	.driver_features =
 	    DRIVER_USE_AGP | DRIVER_ATOMIC |
 	    DRIVER_GEM |
-	    DRIVER_RENDER | DRIVER_MODESET | DRIVER_SYNCOBJ,
+	    DRIVER_RENDER | DRIVER_MODESET | DRIVER_SYNCOBJ |
+	    DRIVER_SYNCOBJ_TIMELINE,
 	.load = amdgpu_driver_load_kms,
 	.open = amdgpu_driver_open_kms,
 	.postclose = amdgpu_driver_postclose_kms,

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

@@ -1488,7 +1488,7 @@ out: · 1487 unmodified lines
1488		1488
1489	/* Start rlc autoload after psp recieved all the gfx firmware */	1489	/* Start rlc autoload after psp recieved all the gfx firmware */
1490	if (psp->autoload_supported && ucode->ucode_id == (amdgpu_sriov_vf(adev) ?	1490	if (psp->autoload_supported && ucode->ucode_id == (amdgpu_sriov_vf(adev) ?
1491	AMDGPU_UCODE_ID_CP_MEC2 : AMDGPU_UCODE_ID_RLC_RESTORE_LIST_SRM_MEM)) {	1491	AMDGPU_UCODE_ID_CP_MEC2 : AMDGPU_UCODE_ID_RLC_G)) {
1492	ret = psp_rlc_autoload(psp);	1492	ret = psp_rlc_autoload(psp);
1493	if (ret) {	1493	if (ret) {
1494	DRM_ERROR("Failed to start rlc autoload\n");	1494	DRM_ERROR("Failed to start rlc autoload\n");

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

 	AMDGPU_UCODE_ID_CP_MEC2_JT,
 	AMDGPU_UCODE_ID_CP_MES,
 	AMDGPU_UCODE_ID_CP_MES_DATA,
-	AMDGPU_UCODE_ID_RLC_G,
 	AMDGPU_UCODE_ID_RLC_RESTORE_LIST_CNTL,
 	AMDGPU_UCODE_ID_RLC_RESTORE_LIST_GPM_MEM,
 	AMDGPU_UCODE_ID_RLC_RESTORE_LIST_SRM_MEM,
+	AMDGPU_UCODE_ID_RLC_G,
 	AMDGPU_UCODE_ID_STORAGE,
 	AMDGPU_UCODE_ID_SMC,
 	AMDGPU_UCODE_ID_UVD,

drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c+4−11

 	case CHIP_VEGA20:
 		break;
 	case CHIP_RAVEN:
-		/* Disable GFXOFF on original raven.  There are combinations
+		if (!(adev->rev_id >= 0x8 ||
-		 * of sbios and platforms that are not stable.
+		      adev->pdev->device == 0x15d8) &&
-		 */
+		    (adev->pm.fw_version < 0x41e2b || /* not raven1 fresh */
-		if (!(adev->rev_id >= 0x8 || adev->pdev->device == 0x15d8))
+		     !adev->gfx.rlc.is_rlc_v2_1)) /* without rlc save restore ucodes */
-			adev->pm.pp_feature &= ~PP_GFXOFF_MASK;
-		else if (!(adev->rev_id >= 0x8 || adev->pdev->device == 0x15d8)
-			 &&((adev->gfx.rlc_fw_version != 106 &&
-			     adev->gfx.rlc_fw_version < 531) ||
-			    (adev->gfx.rlc_fw_version == 53815) ||
-			    (adev->gfx.rlc_feature_version < 1) ||
-			    !adev->gfx.rlc.is_rlc_v2_1))
 			adev->pm.pp_feature &= ~PP_GFXOFF_MASK;
 		if (adev->pm.pp_feature & PP_GFXOFF_MASK)

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

@@ -3356,27 +3356,21 @@ get_output_color_space(const struct dc_crtc_timing *dc_crtc_timing) · 3355 unmodified lines
3356	return color_space;	3356	return color_space;
3357	}	3357	}
3358		3358
3359	static void reduce_mode_colour_depth(struct dc_crtc_timing *timing_out)	3359	static bool adjust_colour_depth_from_display_info(
3360	{	3360	struct dc_crtc_timing *timing_out,
3361	if (timing_out->display_color_depth <= COLOR_DEPTH_888)	3361	const struct drm_display_info *info)
3362	return;
3363
3364	timing_out->display_color_depth--;
3365	}
3366
3367	static void adjust_colour_depth_from_display_info(struct dc_crtc_timing *timing_out,
3368	const struct drm_display_info *info)
3369	{	3362	{
		3363	enum dc_color_depth depth = timing_out->display_color_depth;
3370	int normalized_clk;	3364	int normalized_clk;
3371	if (timing_out->display_color_depth <= COLOR_DEPTH_888)
3372	return;
3373	do {	3365	do {
3374	normalized_clk = timing_out->pix_clk_100hz / 10;	3366	normalized_clk = timing_out->pix_clk_100hz / 10;
3375	/* YCbCr 4:2:0 requires additional adjustment of 1/2 */	3367	/* YCbCr 4:2:0 requires additional adjustment of 1/2 */
3376	if (timing_out->pixel_encoding == PIXEL_ENCODING_YCBCR420)	3368	if (timing_out->pixel_encoding == PIXEL_ENCODING_YCBCR420)
3377	normalized_clk /= 2;	3369	normalized_clk /= 2;
3378	/* Adjusting pix clock following on HDMI spec based on colour depth */	3370	/* Adjusting pix clock following on HDMI spec based on colour depth */
3379	switch (timing_out->display_color_depth) {	3371	switch (depth) {
		3372	case COLOR_DEPTH_888:
		3373	break;
3380	case COLOR_DEPTH_101010:	3374	case COLOR_DEPTH_101010:
3381	normalized_clk = (normalized_clk * 30) / 24;	3375	normalized_clk = (normalized_clk * 30) / 24;
3382	break;	3376	break;
@@ -3387,14 +3381,15 @@ static void adjust_colour_depth_from_display_info(struct dc_crtc_timing *timing_ · 4 unmodified lines
3387	normalized_clk = (normalized_clk * 48) / 24;	3381	normalized_clk = (normalized_clk * 48) / 24;
3388	break;	3382	break;
3389	default:	3383	default:
3390	return;	3384	/* The above depths are the only ones valid for HDMI. */
		3385	return false;
3391	}	3386	}
3392	if (normalized_clk <= info->max_tmds_clock)	3387	if (normalized_clk <= info->max_tmds_clock) {
3393	return;	3388	timing_out->display_color_depth = depth;
3394	reduce_mode_colour_depth(timing_out);	3389	return true;
3395		3390	}
3396	} while (timing_out->display_color_depth > COLOR_DEPTH_888);	3391	} while (--depth > COLOR_DEPTH_666);
3397		3392	return false;
3398	}	3393	}
3399		3394
3400	static void fill_stream_properties_from_drm_display_mode(	3395	static void fill_stream_properties_from_drm_display_mode(
@@ -3474,8 +3469,14 @@ static void fill_stream_properties_from_drm_display_mode( · 73 unmodified lines
3474		3469
3475	stream->out_transfer_func->type = TF_TYPE_PREDEFINED;	3470	stream->out_transfer_func->type = TF_TYPE_PREDEFINED;
3476	stream->out_transfer_func->tf = TRANSFER_FUNCTION_SRGB;	3471	stream->out_transfer_func->tf = TRANSFER_FUNCTION_SRGB;
3477	if (stream->signal == SIGNAL_TYPE_HDMI_TYPE_A)	3472	if (stream->signal == SIGNAL_TYPE_HDMI_TYPE_A) {
3478	adjust_colour_depth_from_display_info(timing_out, info);	3473	if (!adjust_colour_depth_from_display_info(timing_out, info) &&
		3474	drm_mode_is_420_also(info, mode_in) &&
		3475	timing_out->pixel_encoding != PIXEL_ENCODING_YCBCR420) {
		3476	timing_out->pixel_encoding = PIXEL_ENCODING_YCBCR420;
		3477	adjust_colour_depth_from_display_info(timing_out, info);
		3478	}
		3479	}
3479	}	3480	}
3480		3481
3481	static void fill_audio_info(struct audio_info *audio_info,	3482	static void fill_audio_info(struct audio_info *audio_info,

drivers/gpu/drm/amd/powerplay/amdgpu_smu.c+1−0

@@ -866,6 +866,7 @@ static int smu_sw_init(void *handle) · 865 unmodified lines
866	smu->smu_baco.platform_support = false;	866	smu->smu_baco.platform_support = false;
867		867
868	mutex_init(&smu->sensor_lock);	868	mutex_init(&smu->sensor_lock);
		869	mutex_init(&smu->metrics_lock);
869		870
870	smu->watermarks_bitmap = 0;	871	smu->watermarks_bitmap = 0;
871	smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;	872	smu->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;

drivers/gpu/drm/amd/powerplay/arcturus_ppt.c+3−0

 	struct smu_table_context *smu_table= &smu->smu_table;
 	int ret = 0;
+	mutex_lock(&smu->metrics_lock);
 	if (!smu_table->metrics_time ||
 	     time_after(jiffies, smu_table->metrics_time + HZ / 1000)) {
 		ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
 				(void *)smu_table->metrics_table, false);
 		if (ret) {
 			pr_info("Failed to export SMU metrics table!\n");
+			mutex_unlock(&smu->metrics_lock);
 			return ret;
 		}
 		smu_table->metrics_time = jiffies;
 	}
 	memcpy(metrics_table, smu_table->metrics_table, sizeof(SmuMetrics_t));
+	mutex_unlock(&smu->metrics_lock);
 	return ret;
 }

drivers/gpu/drm/amd/powerplay/inc/amdgpu_smu.h+1−0

@@ -349,6 +349,7 @@ struct smu_context · 348 unmodified lines
349	const struct pptable_funcs *ppt_funcs;	349	const struct pptable_funcs *ppt_funcs;
350	struct mutex mutex;	350	struct mutex mutex;
351	struct mutex sensor_lock;	351	struct mutex sensor_lock;
		352	struct mutex metrics_lock;
352	uint64_t pool_size;	353	uint64_t pool_size;
353		354
354	struct smu_table_context smu_table;	355	struct smu_table_context smu_table;

drivers/gpu/drm/amd/powerplay/navi10_ppt.c+3−0

 	struct smu_table_context *smu_table= &smu->smu_table;
 	int ret = 0;
+	mutex_lock(&smu->metrics_lock);
 	if (!smu_table->metrics_time || time_after(jiffies, smu_table->metrics_time + msecs_to_jiffies(100))) {
 		ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
 				(void *)smu_table->metrics_table, false);
 		if (ret) {
 			pr_info("Failed to export SMU metrics table!\n");
+			mutex_unlock(&smu->metrics_lock);
 			return ret;
 		}
 		smu_table->metrics_time = jiffies;
 	}
 	memcpy(metrics_table, smu_table->metrics_table, sizeof(SmuMetrics_t));
+	mutex_unlock(&smu->metrics_lock);
 	return ret;
 }

drivers/gpu/drm/amd/powerplay/vega20_ppt.c+3−0

 	struct smu_table_context *smu_table= &smu->smu_table;
 	int ret = 0;
+	mutex_lock(&smu->metrics_lock);
 	if (!smu_table->metrics_time || time_after(jiffies, smu_table->metrics_time + HZ / 1000)) {
 		ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
 				(void *)smu_table->metrics_table, false);
 		if (ret) {
 			pr_info("Failed to export SMU metrics table!\n");
+			mutex_unlock(&smu->metrics_lock);
 			return ret;
 		}
 		smu_table->metrics_time = jiffies;
 	}
 	memcpy(metrics_table, smu_table->metrics_table, sizeof(SmuMetrics_t));
+	mutex_unlock(&smu->metrics_lock);
 	return ret;
 }

drivers/gpu/drm/arm/malidp_mw.c+1−1

@@ -56,7 +56,7 @@ malidp_mw_connector_mode_valid(struct drm_connector *connector, · 55 unmodified lines
56	return MODE_OK;	56	return MODE_OK;
57	}	57	}
58		58
59	const struct drm_connector_helper_funcs malidp_mw_connector_helper_funcs = {	59	static const struct drm_connector_helper_funcs malidp_mw_connector_helper_funcs = {
60	.get_modes = malidp_mw_connector_get_modes,	60	.get_modes = malidp_mw_connector_get_modes,
61	.mode_valid = malidp_mw_connector_mode_valid,	61	.mode_valid = malidp_mw_connector_mode_valid,
62	};	62	};

drivers/gpu/drm/drm_dp_mst_topology.c+1−1

@@ -393,7 +393,7 @@ drm_dp_encode_sideband_req(const struct drm_dp_sideband_msg_req_body *req, · 392 unmodified lines
393	memcpy(&buf[idx], req->u.i2c_read.transactions[i].bytes, req->u.i2c_read.transactions[i].num_bytes);	393	memcpy(&buf[idx], req->u.i2c_read.transactions[i].bytes, req->u.i2c_read.transactions[i].num_bytes);
394	idx += req->u.i2c_read.transactions[i].num_bytes;	394	idx += req->u.i2c_read.transactions[i].num_bytes;
395		395
396	buf[idx] = (req->u.i2c_read.transactions[i].no_stop_bit & 0x1) << 5;	396	buf[idx] = (req->u.i2c_read.transactions[i].no_stop_bit & 0x1) << 4;
397	buf[idx] \|= (req->u.i2c_read.transactions[i].i2c_transaction_delay & 0xf);	397	buf[idx] \|= (req->u.i2c_read.transactions[i].i2c_transaction_delay & 0xf);
398	idx++;	398	idx++;
399	}	399	}

drivers/gpu/drm/drm_fb_helper.c+6−1

 	 * Changes struct fb_var_screeninfo are currently not pushed back
 	 * to KMS, hence fail if different settings are requested.
 	 */
-	if (var->bits_per_pixel != fb->format->cpp[0] * 8 ||
+	if (var->bits_per_pixel > fb->format->cpp[0] * 8 ||
 	    var->xres > fb->width || var->yres > fb->height ||
 	    var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
 		DRM_DEBUG("fb requested width/height/bpp can't fit in current fb "
 		drm_fb_helper_fill_pixel_fmt(var, fb->format->depth);
 	}
+	/*
+	 * Likewise, bits_per_pixel should be rounded up to a supported value.
+	 */
+	var->bits_per_pixel = fb->format->cpp[0] * 8;
 	/*
 	 * drm fbdev emulation doesn't support changing the pixel format at all,
 	 * so reject all pixel format changing requests.

drivers/gpu/drm/i915/display/intel_audio.c+2−2

@@ -856,7 +856,7 @@ static unsigned long i915_audio_component_get_power(struct device *kdev) · 855 unmodified lines
856	}	856	}
857		857
858	/* Force CDCLK to 2BCLK as long as we need audio powered. /	858	/* Force CDCLK to 2BCLK as long as we need audio powered. /
859	if (INTEL_GEN(dev_priv) >= 10 \|\| IS_GEMINILAKE(dev_priv))	859	if (IS_GEMINILAKE(dev_priv))
860	glk_force_audio_cdclk(dev_priv, true);	860	glk_force_audio_cdclk(dev_priv, true);
861		861
862	if (INTEL_GEN(dev_priv) >= 10 \|\| IS_GEMINILAKE(dev_priv))	862	if (INTEL_GEN(dev_priv) >= 10 \|\| IS_GEMINILAKE(dev_priv))
@@ -875,7 +875,7 @@ static void i915_audio_component_put_power(struct device *kdev, · 12 unmodified lines
875		875
876	/* Stop forcing CDCLK to 2BCLK if no need for audio to be powered. /	876	/* Stop forcing CDCLK to 2BCLK if no need for audio to be powered. /
877	if (--dev_priv->audio_power_refcount == 0)	877	if (--dev_priv->audio_power_refcount == 0)
878	if (INTEL_GEN(dev_priv) >= 10 \|\| IS_GEMINILAKE(dev_priv))	878	if (IS_GEMINILAKE(dev_priv))
879	glk_force_audio_cdclk(dev_priv, false);	879	glk_force_audio_cdclk(dev_priv, false);
880		880
881	intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO, cookie);	881	intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO, cookie);

drivers/gpu/drm/i915/display/intel_display.c+2−7

 {
 	struct intel_crtc *crtc = to_intel_crtc(old_crtc_state->base.crtc);
 	struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
-	i915_reg_t reg;
-	u32 trans_ddi_func_ctl2_val;
 	if (old_crtc_state->master_transcoder == INVALID_TRANSCODER)
 		return;
 	DRM_DEBUG_KMS("Disabling Transcoder Port Sync on Slave Transcoder %s\n",
 		      transcoder_name(old_crtc_state->cpu_transcoder));
-	reg = TRANS_DDI_FUNC_CTL2(old_crtc_state->cpu_transcoder);
+	I915_WRITE(TRANS_DDI_FUNC_CTL2(old_crtc_state->cpu_transcoder), 0);
-	trans_ddi_func_ctl2_val = ~(PORT_SYNC_MODE_ENABLE |
-				    PORT_SYNC_MODE_MASTER_SELECT_MASK);
-	I915_WRITE(reg, trans_ddi_func_ctl2_val);
 }
 static void intel_fdi_normal_train(struct intel_crtc *crtc)
 		return ret;
 	fb_obj_bump_render_priority(obj);
-	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_DIRTYFB);
+	i915_gem_object_flush_frontbuffer(obj, ORIGIN_DIRTYFB);
 	if (!new_plane_state->base.fence) { /* implicit fencing */
 		struct dma_fence *fence;

drivers/gpu/drm/i915/display/intel_frontbuffer.c+6−10

 		vma->display_alignment = I915_GTT_MIN_ALIGNMENT;
 	spin_unlock(&obj->vma.lock);
-	obj->frontbuffer = NULL;
+	RCU_INIT_POINTER(obj->frontbuffer, NULL);
 	spin_unlock(&to_i915(obj->base.dev)->fb_tracking.lock);
 	i915_gem_object_put(obj);
-	kfree(front);
+	kfree_rcu(front, rcu);
 }
 struct intel_frontbuffer *
 	struct drm_i915_private *i915 = to_i915(obj->base.dev);
 	struct intel_frontbuffer *front;
-	spin_lock(&i915->fb_tracking.lock);
+	front = __intel_frontbuffer_get(obj);
-	front = obj->frontbuffer;
-	if (front)
-		kref_get(&front->ref);
-	spin_unlock(&i915->fb_tracking.lock);
 	if (front)
 		return front;
 			 i915_active_may_sleep(frontbuffer_retire));
 	spin_lock(&i915->fb_tracking.lock);
-	if (obj->frontbuffer) {
+	if (rcu_access_pointer(obj->frontbuffer)) {
 		kfree(front);
-		front = obj->frontbuffer;
+		front = rcu_dereference_protected(obj->frontbuffer, true);
 		kref_get(&front->ref);
 	} else {
 		i915_gem_object_get(obj);
-		obj->frontbuffer = front;
+		rcu_assign_pointer(obj->frontbuffer, front);
 	}
 	spin_unlock(&i915->fb_tracking.lock);

drivers/gpu/drm/i915/display/intel_frontbuffer.h+31−3

@@ -27,10 +27,10 @@ · 26 unmodified lines
27	#include <linux/atomic.h>	27	#include <linux/atomic.h>
28	#include <linux/kref.h>	28	#include <linux/kref.h>
29		29
		30	#include "gem/i915_gem_object_types.h"
30	#include "i915_active.h"	31	#include "i915_active.h"
31		32
32	struct drm_i915_private;	33	struct drm_i915_private;
33	struct drm_i915_gem_object;
34		34
35	enum fb_op_origin {	35	enum fb_op_origin {
36	ORIGIN_GTT,	36	ORIGIN_GTT,
@@ -45,6 +45,7 @@ struct intel_frontbuffer { · 8 unmodified lines
45	atomic_t bits;	45	atomic_t bits;
46	struct i915_active write;	46	struct i915_active write;
47	struct drm_i915_gem_object *obj;	47	struct drm_i915_gem_object *obj;
		48	struct rcu_head rcu;
48	};	49	};
49		50
50	void intel_frontbuffer_flip_prepare(struct drm_i915_private *i915,	51	void intel_frontbuffer_flip_prepare(struct drm_i915_private *i915,
@@ -54,6 +55,35 @@ void intel_frontbuffer_flip_complete(struct drm_i915_private *i915, · 3 unmodified lines
54	void intel_frontbuffer_flip(struct drm_i915_private *i915,	55	void intel_frontbuffer_flip(struct drm_i915_private *i915,
55	unsigned frontbuffer_bits);	56	unsigned frontbuffer_bits);
56		57
		58	void intel_frontbuffer_put(struct intel_frontbuffer *front);
		59
		60	static inline struct intel_frontbuffer *
		61	__intel_frontbuffer_get(const struct drm_i915_gem_object *obj)
		62	{
		63	struct intel_frontbuffer *front;
		64
		65	if (likely(!rcu_access_pointer(obj->frontbuffer)))
		66	return NULL;
		67
		68	rcu_read_lock();
		69	do {
		70	front = rcu_dereference(obj->frontbuffer);
		71	if (!front)
		72	break;
		73
		74	if (unlikely(!kref_get_unless_zero(&front->ref)))
		75	continue;
		76
		77	if (likely(front == rcu_access_pointer(obj->frontbuffer)))
		78	break;
		79
		80	intel_frontbuffer_put(front);
		81	} while (1);
		82	rcu_read_unlock();
		83
		84	return front;
		85	}
		86
57	struct intel_frontbuffer *	87	struct intel_frontbuffer *
58	intel_frontbuffer_get(struct drm_i915_gem_object *obj);	88	intel_frontbuffer_get(struct drm_i915_gem_object *obj);
59		89
@@ -119,6 +149,4 @@ void intel_frontbuffer_track(struct intel_frontbuffer *old, · 59 unmodified lines
119	struct intel_frontbuffer *new,	149	struct intel_frontbuffer *new,
120	unsigned int frontbuffer_bits);	150	unsigned int frontbuffer_bits);
121		151
122	void intel_frontbuffer_put(struct intel_frontbuffer *front);
123
124	#endif /* __INTEL_FRONTBUFFER_H__ */	152	#endif /* __INTEL_FRONTBUFFER_H__ */

drivers/gpu/drm/i915/display/intel_overlay.c+13−4

 				       struct i915_vma *vma)
 {
 	enum pipe pipe = overlay->crtc->pipe;
+	struct intel_frontbuffer *from = NULL, *to = NULL;
 	WARN_ON(overlay->old_vma);
-	intel_frontbuffer_track(overlay->vma ? overlay->vma->obj->frontbuffer : NULL,
+	if (overlay->vma)
-				vma ? vma->obj->frontbuffer : NULL,
+		from = intel_frontbuffer_get(overlay->vma->obj);
-				INTEL_FRONTBUFFER_OVERLAY(pipe));
+	if (vma)
+		to = intel_frontbuffer_get(vma->obj);
+	intel_frontbuffer_track(from, to, INTEL_FRONTBUFFER_OVERLAY(pipe));
+	if (to)
+		intel_frontbuffer_put(to);
+	if (from)
+		intel_frontbuffer_put(from);
 	intel_frontbuffer_flip_prepare(overlay->i915,
 				       INTEL_FRONTBUFFER_OVERLAY(pipe));
 		ret = PTR_ERR(vma);
 		goto out_pin_section;
 	}
-	intel_frontbuffer_flush(new_bo->frontbuffer, ORIGIN_DIRTYFB);
+	i915_gem_object_flush_frontbuffer(new_bo, ORIGIN_DIRTYFB);
 	if (!overlay->active) {
 		u32 oconfig;

drivers/gpu/drm/i915/gem/i915_gem_clflush.c+2−1

@@ -20,7 +20,8 @@ static void __do_clflush(struct drm_i915_gem_object *obj) · 19 unmodified lines
20	{	20	{
21	GEM_BUG_ON(!i915_gem_object_has_pages(obj));	21	GEM_BUG_ON(!i915_gem_object_has_pages(obj));
22	drm_clflush_sg(obj->mm.pages);	22	drm_clflush_sg(obj->mm.pages);
23	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_CPU);	23
		24	i915_gem_object_flush_frontbuffer(obj, ORIGIN_CPU);
24	}	25	}
25		26
26	static int clflush_work(struct dma_fence_work *base)	27	static int clflush_work(struct dma_fence_work *base)

drivers/gpu/drm/i915/gem/i915_gem_domain.c+2−2

@@ -664,7 +664,7 @@ i915_gem_set_domain_ioctl(struct drm_device dev, void data, · 663 unmodified lines
664	i915_gem_object_unlock(obj);	664	i915_gem_object_unlock(obj);
665		665
666	if (write_domain)	666	if (write_domain)
667	intel_frontbuffer_invalidate(obj->frontbuffer, ORIGIN_CPU);	667	i915_gem_object_invalidate_frontbuffer(obj, ORIGIN_CPU);
668		668
669	out_unpin:	669	out_unpin:
670	i915_gem_object_unpin_pages(obj);	670	i915_gem_object_unpin_pages(obj);
@@ -784,7 +784,7 @@ int i915_gem_object_prepare_write(struct drm_i915_gem_object *obj, · 113 unmodified lines
784	}	784	}
785		785
786	out:	786	out:
787	intel_frontbuffer_invalidate(obj->frontbuffer, ORIGIN_CPU);	787	i915_gem_object_invalidate_frontbuffer(obj, ORIGIN_CPU);
788	obj->mm.dirty = true;	788	obj->mm.dirty = true;
789	/* return with the pages pinned */	789	/* return with the pages pinned */
790	return 0;	790	return 0;

drivers/gpu/drm/i915/gem/i915_gem_object.c+25−1

@@ -280,7 +280,7 @@ i915_gem_object_flush_write_domain(struct drm_i915_gem_object *obj, · 279 unmodified lines
280	for_each_ggtt_vma(vma, obj)	280	for_each_ggtt_vma(vma, obj)
281	intel_gt_flush_ggtt_writes(vma->vm->gt);	281	intel_gt_flush_ggtt_writes(vma->vm->gt);
282		282
283	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_CPU);	283	i915_gem_object_flush_frontbuffer(obj, ORIGIN_CPU);
284		284
285	for_each_ggtt_vma(vma, obj) {	285	for_each_ggtt_vma(vma, obj) {
286	if (vma->iomap)	286	if (vma->iomap)
@@ -308,6 +308,30 @@ i915_gem_object_flush_write_domain(struct drm_i915_gem_object *obj, · 21 unmodified lines
308	obj->write_domain = 0;	308	obj->write_domain = 0;
309	}	309	}
310		310
		311	void __i915_gem_object_flush_frontbuffer(struct drm_i915_gem_object *obj,
		312	enum fb_op_origin origin)
		313	{
		314	struct intel_frontbuffer *front;
		315
		316	front = __intel_frontbuffer_get(obj);
		317	if (front) {
		318	intel_frontbuffer_flush(front, origin);
		319	intel_frontbuffer_put(front);
		320	}
		321	}
		322
		323	void __i915_gem_object_invalidate_frontbuffer(struct drm_i915_gem_object *obj,
		324	enum fb_op_origin origin)
		325	{
		326	struct intel_frontbuffer *front;
		327
		328	front = __intel_frontbuffer_get(obj);
		329	if (front) {
		330	intel_frontbuffer_invalidate(front, origin);
		331	intel_frontbuffer_put(front);
		332	}
		333	}
		334
311	void i915_gem_init__objects(struct drm_i915_private *i915)	335	void i915_gem_init__objects(struct drm_i915_private *i915)
312	{	336	{
313	INIT_WORK(&i915->mm.free_work, __i915_gem_free_work);	337	INIT_WORK(&i915->mm.free_work, __i915_gem_free_work);

drivers/gpu/drm/i915/gem/i915_gem_object.h+22−1

@@ -13,8 +13,8 @@ · 12 unmodified lines
13		13
14	#include <drm/i915_drm.h>	14	#include <drm/i915_drm.h>
15		15
		16	#include "display/intel_frontbuffer.h"
16	#include "i915_gem_object_types.h"	17	#include "i915_gem_object_types.h"
17
18	#include "i915_gem_gtt.h"	18	#include "i915_gem_gtt.h"
19		19
20	void i915_gem_init__objects(struct drm_i915_private *i915);	20	void i915_gem_init__objects(struct drm_i915_private *i915);
@@ -463,4 +463,25 @@ int i915_gem_object_wait_priority(struct drm_i915_gem_object *obj, · 442 unmodified lines
463	unsigned int flags,	463	unsigned int flags,
464	const struct i915_sched_attr *attr);	464	const struct i915_sched_attr *attr);
465		465
		466	void __i915_gem_object_flush_frontbuffer(struct drm_i915_gem_object *obj,
		467	enum fb_op_origin origin);
		468	void __i915_gem_object_invalidate_frontbuffer(struct drm_i915_gem_object *obj,
		469	enum fb_op_origin origin);
		470
		471	static inline void
		472	i915_gem_object_flush_frontbuffer(struct drm_i915_gem_object *obj,
		473	enum fb_op_origin origin)
		474	{
		475	if (unlikely(rcu_access_pointer(obj->frontbuffer)))
		476	__i915_gem_object_flush_frontbuffer(obj, origin);
		477	}
		478
		479	static inline void
		480	i915_gem_object_invalidate_frontbuffer(struct drm_i915_gem_object *obj,
		481	enum fb_op_origin origin)
		482	{
		483	if (unlikely(rcu_access_pointer(obj->frontbuffer)))
		484	__i915_gem_object_invalidate_frontbuffer(obj, origin);
		485	}
		486
466	#endif	487	#endif

drivers/gpu/drm/i915/gem/i915_gem_object_types.h+1−1

@@ -150,7 +150,7 @@ struct drm_i915_gem_object { · 149 unmodified lines
150	*/	150	*/
151	u16 write_domain;	151	u16 write_domain;
152		152
153	struct intel_frontbuffer *frontbuffer;	153	struct intel_frontbuffer __rcu *frontbuffer;
154		154
155	/** Current tiling stride for the object, if it's tiled. */	155	/** Current tiling stride for the object, if it's tiled. */
156	unsigned int tiling_and_stride;	156	unsigned int tiling_and_stride;

drivers/gpu/drm/i915/gt/intel_gt_pm.c+2−1

@@ -94,8 +94,9 @@ static int __gt_park(struct intel_wakeref *wf) · 93 unmodified lines
94	intel_uncore_forcewake_put(&i915->uncore, FORCEWAKE_ALL);	94	intel_uncore_forcewake_put(&i915->uncore, FORCEWAKE_ALL);
95	}	95	}
96		96
		97	/* Defer dropping the display power well for 100ms, it's slow! */
97	GEM_BUG_ON(!wakeref);	98	GEM_BUG_ON(!wakeref);
98	intel_display_power_put(i915, POWER_DOMAIN_GT_IRQ, wakeref);	99	intel_display_power_put_async(i915, POWER_DOMAIN_GT_IRQ, wakeref);
99		100
100	i915_globals_park();	101	i915_globals_park();
101		102

drivers/gpu/drm/i915/gt/intel_lrc.c+2−0

 	ve->base.gt = siblings[0]->gt;
 	ve->base.uncore = siblings[0]->uncore;
 	ve->base.id = -1;
 	ve->base.class = OTHER_CLASS;
 	ve->base.uabi_class = I915_ENGINE_CLASS_INVALID;
 	ve->base.instance = I915_ENGINE_CLASS_INVALID_VIRTUAL;
+	ve->base.uabi_instance = I915_ENGINE_CLASS_INVALID_VIRTUAL;
 	/*
 	 * The decision on whether to submit a request using semaphores

drivers/gpu/drm/i915/gt/intel_ring_submission.c+11−20

@@ -1413,14 +1413,6 @@ static inline int mi_set_context(struct i915_request *rq, u32 flags) · 1412 unmodified lines
1413	int len;	1413	int len;
1414	u32 *cs;	1414	u32 *cs;
1415		1415
1416	flags \|= MI_MM_SPACE_GTT;
1417	if (IS_HASWELL(i915))
1418	/* These flags are for resource streamer on HSW+ */
1419	flags \|= HSW_MI_RS_SAVE_STATE_EN \| HSW_MI_RS_RESTORE_STATE_EN;
1420	else
1421	/* We need to save the extended state for powersaving modes */
1422	flags \|= MI_SAVE_EXT_STATE_EN \| MI_RESTORE_EXT_STATE_EN;
1423
1424	len = 4;	1416	len = 4;
1425	if (IS_GEN(i915, 7))	1417	if (IS_GEN(i915, 7))
1426	len += 2 + (num_engines ? 4 * num_engines + 6 : 0);	1418	len += 2 + (num_engines ? 4 * num_engines + 6 : 0);
@@ -1589,22 +1581,21 @@ static int switch_context(struct i915_request *rq) · 162 unmodified lines
1589	}	1581	}
1590		1582
1591	if (ce->state) {	1583	if (ce->state) {
1592	u32 hw_flags;	1584	u32 flags;
1593		1585
1594	GEM_BUG_ON(rq->engine->id != RCS0);	1586	GEM_BUG_ON(rq->engine->id != RCS0);
1595		1587
1596	/*	1588	/* For resource streamer on HSW+ and power context elsewhere */
1597	* The kernel context(s) is treated as pure scratch and is not	1589	BUILD_BUG_ON(HSW_MI_RS_SAVE_STATE_EN != MI_SAVE_EXT_STATE_EN);
1598	* expected to retain any state (as we sacrifice it during	1590	BUILD_BUG_ON(HSW_MI_RS_RESTORE_STATE_EN != MI_RESTORE_EXT_STATE_EN);
1599	* suspend and on resume it may be corrupted). This is ok,	1591
1600	* as nothing actually executes using the kernel context; it	1592	flags = MI_SAVE_EXT_STATE_EN \| MI_MM_SPACE_GTT;
1601	* is purely used for flushing user contexts.	1593	if (!i915_gem_context_is_kernel(rq->gem_context))
1602	*/	1594	flags \|= MI_RESTORE_EXT_STATE_EN;
1603	hw_flags = 0;	1595	else
1604	if (i915_gem_context_is_kernel(rq->gem_context))	1596	flags \|= MI_RESTORE_INHIBIT;
1605	hw_flags = MI_RESTORE_INHIBIT;
1606		1597
1607	ret = mi_set_context(rq, hw_flags);	1598	ret = mi_set_context(rq, flags);
1608	if (ret)	1599	if (ret)
1609	return ret;	1600	return ret;
1610	}	1601	}

drivers/gpu/drm/i915/i915_drv.h+4−2

 	(IS_BROADWELL(dev_priv) || IS_GEN(dev_priv, 9))
 /* WaRsDisableCoarsePowerGating:skl,cnl */
-#define NEEDS_WaRsDisableCoarsePowerGating(dev_priv) \
+#define NEEDS_WaRsDisableCoarsePowerGating(dev_priv)			\
-	(IS_CANNONLAKE(dev_priv) || IS_GEN(dev_priv, 9))
+	(IS_CANNONLAKE(dev_priv) ||					\
+	 IS_SKL_GT3(dev_priv) ||					\
+	 IS_SKL_GT4(dev_priv))
 #define HAS_GMBUS_IRQ(dev_priv) (INTEL_GEN(dev_priv) >= 4)
 #define HAS_GMBUS_BURST_READ(dev_priv) (INTEL_GEN(dev_priv) >= 10 || \

drivers/gpu/drm/i915/i915_gem.c+5−5

@@ -161,7 +161,7 @@ i915_gem_phys_pwrite(struct drm_i915_gem_object *obj, · 160 unmodified lines
161	* We manually control the domain here and pretend that it	161	* We manually control the domain here and pretend that it
162	* remains coherent i.e. in the GTT domain, like shmem_pwrite.	162	* remains coherent i.e. in the GTT domain, like shmem_pwrite.
163	*/	163	*/
164	intel_frontbuffer_invalidate(obj->frontbuffer, ORIGIN_CPU);	164	i915_gem_object_invalidate_frontbuffer(obj, ORIGIN_CPU);
165		165
166	if (copy_from_user(vaddr, user_data, args->size))	166	if (copy_from_user(vaddr, user_data, args->size))
167	return -EFAULT;	167	return -EFAULT;
@@ -169,7 +169,7 @@ i915_gem_phys_pwrite(struct drm_i915_gem_object *obj, · 1 unmodified line
169	drm_clflush_virt_range(vaddr, args->size);	169	drm_clflush_virt_range(vaddr, args->size);
170	intel_gt_chipset_flush(&to_i915(obj->base.dev)->gt);	170	intel_gt_chipset_flush(&to_i915(obj->base.dev)->gt);
171		171
172	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_CPU);	172	i915_gem_object_flush_frontbuffer(obj, ORIGIN_CPU);
173	return 0;	173	return 0;
174	}	174	}
175		175
@@ -589,7 +589,7 @@ i915_gem_gtt_pwrite_fast(struct drm_i915_gem_object *obj, · 413 unmodified lines
589	goto out_unpin;	589	goto out_unpin;
590	}	590	}
591		591
592	intel_frontbuffer_invalidate(obj->frontbuffer, ORIGIN_CPU);	592	i915_gem_object_invalidate_frontbuffer(obj, ORIGIN_CPU);
593		593
594	user_data = u64_to_user_ptr(args->data_ptr);	594	user_data = u64_to_user_ptr(args->data_ptr);
595	offset = args->offset;	595	offset = args->offset;
@@ -631,7 +631,7 @@ i915_gem_gtt_pwrite_fast(struct drm_i915_gem_object *obj, · 35 unmodified lines
631	user_data += page_length;	631	user_data += page_length;
632	offset += page_length;	632	offset += page_length;
633	}	633	}
634	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_CPU);	634	i915_gem_object_flush_frontbuffer(obj, ORIGIN_CPU);
635		635
636	i915_gem_object_unlock_fence(obj, fence);	636	i915_gem_object_unlock_fence(obj, fence);
637	out_unpin:	637	out_unpin:
@@ -721,7 +721,7 @@ i915_gem_shmem_pwrite(struct drm_i915_gem_object *obj, · 83 unmodified lines
721	offset = 0;	721	offset = 0;
722	}	722	}
723		723
724	intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_CPU);	724	i915_gem_object_flush_frontbuffer(obj, ORIGIN_CPU);
725	i915_gem_object_unlock_fence(obj, fence);	725	i915_gem_object_unlock_fence(obj, fence);
726		726
727	return ret;	727	return ret;

drivers/gpu/drm/i915/i915_pmu.c+20−53

 	return ktime_to_ns(ktime_sub(ktime_get(), kt));
 }
-static u64 __pmu_estimate_rc6(struct i915_pmu *pmu)
-{
-	u64 val;
-	/*
-	 * We think we are runtime suspended.
-	 *
-	 * Report the delta from when the device was suspended to now,
-	 * on top of the last known real value, as the approximated RC6
-	 * counter value.
-	 */
-	val = ktime_since(pmu->sleep_last);
-	val += pmu->sample[__I915_SAMPLE_RC6].cur;
-	pmu->sample[__I915_SAMPLE_RC6_ESTIMATED].cur = val;
-	return val;
-}
-static u64 __pmu_update_rc6(struct i915_pmu *pmu, u64 val)
-{
-	/*
-	 * If we are coming back from being runtime suspended we must
-	 * be careful not to report a larger value than returned
-	 * previously.
-	 */
-	if (val >= pmu->sample[__I915_SAMPLE_RC6_ESTIMATED].cur) {
-		pmu->sample[__I915_SAMPLE_RC6_ESTIMATED].cur = 0;
-		pmu->sample[__I915_SAMPLE_RC6].cur = val;
-	} else {
-		val = pmu->sample[__I915_SAMPLE_RC6_ESTIMATED].cur;
-	}
-	return val;
-}
 static u64 get_rc6(struct intel_gt *gt)
 {
 	struct drm_i915_private *i915 = gt->i915;
 	struct i915_pmu *pmu = &i915->pmu;
 	unsigned long flags;
+	bool awake = false;
 	u64 val;
-	val = 0;
 	if (intel_gt_pm_get_if_awake(gt)) {
 		val = __get_rc6(gt);
 		intel_gt_pm_put_async(gt);
+		awake = true;
 	}
 	spin_lock_irqsave(&pmu->lock, flags);
-	if (val)
+	if (awake) {
-		val = __pmu_update_rc6(pmu, val);
+		pmu->sample[__I915_SAMPLE_RC6].cur = val;
+	} else {
+		/*
+		 * We think we are runtime suspended.
+		 *
+		 * Report the delta from when the device was suspended to now,
+		 * on top of the last known real value, as the approximated RC6
+		 * counter value.
+		 */
+		val = ktime_since(pmu->sleep_last);
+		val += pmu->sample[__I915_SAMPLE_RC6].cur;
+	}
+	if (val < pmu->sample[__I915_SAMPLE_RC6_LAST_REPORTED].cur)
+		val = pmu->sample[__I915_SAMPLE_RC6_LAST_REPORTED].cur;
 	else
-		val = __pmu_estimate_rc6(pmu);
+		pmu->sample[__I915_SAMPLE_RC6_LAST_REPORTED].cur = val;
 	spin_unlock_irqrestore(&pmu->lock, flags);
 	struct i915_pmu *pmu = &i915->pmu;
 	if (pmu->enable & config_enabled_mask(I915_PMU_RC6_RESIDENCY))
-		__pmu_update_rc6(pmu, __get_rc6(&i915->gt));
+		pmu->sample[__I915_SAMPLE_RC6].cur = __get_rc6(&i915->gt);
 	pmu->sleep_last = ktime_get();
 }
-static void unpark_rc6(struct drm_i915_private *i915)
-{
-	struct i915_pmu *pmu = &i915->pmu;
-	/* Estimate how long we slept and accumulate that into rc6 counters */
-	if (pmu->enable & config_enabled_mask(I915_PMU_RC6_RESIDENCY))
-		__pmu_estimate_rc6(pmu);
-}
 #else
 static u64 get_rc6(struct intel_gt *gt)
 }
 static void park_rc6(struct drm_i915_private *i915) {}
-static void unpark_rc6(struct drm_i915_private *i915) {}
 #endif
 	 */
 	__i915_pmu_maybe_start_timer(pmu);
-	unpark_rc6(i915);
 	spin_unlock_irq(&pmu->lock);
 }

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

@@ -18,7 +18,7 @@ enum { · 17 unmodified lines
18	__I915_SAMPLE_FREQ_ACT = 0,	18	__I915_SAMPLE_FREQ_ACT = 0,
19	__I915_SAMPLE_FREQ_REQ,	19	__I915_SAMPLE_FREQ_REQ,
20	__I915_SAMPLE_RC6,	20	__I915_SAMPLE_RC6,
21	__I915_SAMPLE_RC6_ESTIMATED,	21	__I915_SAMPLE_RC6_LAST_REPORTED,
22	__I915_NUM_PMU_SAMPLERS	22	__I915_NUM_PMU_SAMPLERS
23	};	23	};
24		24

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

 #define  CPSSUNIT_CLKGATE_DIS		REG_BIT(9)
 #define UNSLICE_UNIT_LEVEL_CLKGATE	_MMIO(0x9434)
-#define  VFUNIT_CLKGATE_DIS		(1 << 20)
+#define   VFUNIT_CLKGATE_DIS		REG_BIT(20)
+#define   HSUNIT_CLKGATE_DIS		REG_BIT(8)
+#define   VSUNIT_CLKGATE_DIS		REG_BIT(3)
+#define UNSLICE_UNIT_LEVEL_CLKGATE2	_MMIO(0x94e4)
+#define   VSUNIT_CLKGATE_DIS_TGL	REG_BIT(19)
+#define   PSDUNIT_CLKGATE_DIS		REG_BIT(5)
 #define INF_UNIT_LEVEL_CLKGATE		_MMIO(0x9560)
 #define   CGPSF_CLKGATE_DIS		(1 << 3)

drivers/gpu/drm/i915/i915_vma.c+8−2

@@ -1104,8 +1104,14 @@ int i915_vma_move_to_active(struct i915_vma *vma, · 1103 unmodified lines
1104	return err;	1104	return err;
1105		1105
1106	if (flags & EXEC_OBJECT_WRITE) {	1106	if (flags & EXEC_OBJECT_WRITE) {
1107	if (intel_frontbuffer_invalidate(obj->frontbuffer, ORIGIN_CS))	1107	struct intel_frontbuffer *front;
1108	i915_active_add_request(&obj->frontbuffer->write, rq);	1108
		1109	front = __intel_frontbuffer_get(obj);
		1110	if (unlikely(front)) {
		1111	if (intel_frontbuffer_invalidate(front, ORIGIN_CS))
		1112	i915_active_add_request(&front->write, rq);
		1113	intel_frontbuffer_put(front);
		1114	}
1109		1115
1110	dma_resv_add_excl_fence(vma->resv, &rq->fence);	1116	dma_resv_add_excl_fence(vma->resv, &rq->fence);
1111	obj->write_domain = I915_GEM_DOMAIN_RENDER;	1117	obj->write_domain = I915_GEM_DOMAIN_RENDER;

drivers/gpu/drm/i915/intel_pm.c+11−0

@@ -6565,6 +6565,17 @@ static void icl_init_clock_gating(struct drm_i915_private *dev_priv) · 6564 unmodified lines
6565	/* WaEnable32PlaneMode:icl */	6565	/* WaEnable32PlaneMode:icl */
6566	I915_WRITE(GEN9_CSFE_CHICKEN1_RCS,	6566	I915_WRITE(GEN9_CSFE_CHICKEN1_RCS,
6567	_MASKED_BIT_ENABLE(GEN11_ENABLE_32_PLANE_MODE));	6567	_MASKED_BIT_ENABLE(GEN11_ENABLE_32_PLANE_MODE));
		6568
		6569	/*
		6570	* Wa_1408615072:icl,ehl (vsunit)
		6571	* Wa_1407596294:icl,ehl (hsunit)
		6572	*/
		6573	intel_uncore_rmw(&dev_priv->uncore, UNSLICE_UNIT_LEVEL_CLKGATE,
		6574	0, VSUNIT_CLKGATE_DIS \| HSUNIT_CLKGATE_DIS);
		6575
		6576	/* Wa_1407352427:icl,ehl */
		6577	intel_uncore_rmw(&dev_priv->uncore, UNSLICE_UNIT_LEVEL_CLKGATE2,
		6578	0, PSDUNIT_CLKGATE_DIS);
6568	}	6579	}
6569		6580
6570	static void tgl_init_clock_gating(struct drm_i915_private *dev_priv)	6581	static void tgl_init_clock_gating(struct drm_i915_private *dev_priv)

drivers/gpu/drm/mediatek/mtk_drm_crtc.c+12−6

 	struct mtk_drm_crtc *mtk_crtc = to_mtk_crtc(crtc);
 	struct mtk_ddp_comp *comp;
 	int i, count = 0;
+	unsigned int local_index = plane - mtk_crtc->planes;
 	for (i = 0; i < mtk_crtc->ddp_comp_nr; i++) {
 		comp = mtk_crtc->ddp_comp[i];
-		if (plane->index < (count + mtk_ddp_comp_layer_nr(comp))) {
+		if (local_index < (count + mtk_ddp_comp_layer_nr(comp))) {
-			*local_layer = plane->index - count;
+			*local_layer = local_index - count;
 			return comp;
 		}
 		count += mtk_ddp_comp_layer_nr(comp);
 		plane_state = to_mtk_plane_state(plane->state);
 		comp = mtk_drm_ddp_comp_for_plane(crtc, plane, &local_layer);
-		mtk_ddp_comp_layer_config(comp, local_layer, plane_state);
+		if (comp)
+			mtk_ddp_comp_layer_config(comp, local_layer,
+						  plane_state);
 	}
 	return 0;
 			comp = mtk_drm_ddp_comp_for_plane(crtc, plane,
 							  &local_layer);
-			mtk_ddp_comp_layer_config(comp, local_layer,
+			if (comp)
-						  plane_state);
+				mtk_ddp_comp_layer_config(comp, local_layer,
+							  plane_state);
 			plane_state->pending.config = false;
 		}
 		mtk_crtc->pending_planes = false;
 	struct mtk_ddp_comp *comp;
 	comp = mtk_drm_ddp_comp_for_plane(crtc, plane, &local_layer);
-	return mtk_ddp_comp_layer_check(comp, local_layer, state);
+	if (comp)
+		return mtk_ddp_comp_layer_check(comp, local_layer, state);
+	return 0;
 }
 static void mtk_drm_crtc_atomic_enable(struct drm_crtc *crtc,

drivers/gpu/drm/mediatek/mtk_dsi.c+38−29

@@ -230,28 +230,25 @@ static void mtk_dsi_mask(struct mtk_dsi *dsi, u32 offset, u32 mask, u32 data) · 229 unmodified lines
230	static void mtk_dsi_phy_timconfig(struct mtk_dsi *dsi)	230	static void mtk_dsi_phy_timconfig(struct mtk_dsi *dsi)
231	{	231	{
232	u32 timcon0, timcon1, timcon2, timcon3;	232	u32 timcon0, timcon1, timcon2, timcon3;
233	u32 ui, cycle_time;	233	u32 data_rate_mhz = DIV_ROUND_UP(dsi->data_rate, 1000000);
234	struct mtk_phy_timing *timing = &dsi->phy_timing;	234	struct mtk_phy_timing *timing = &dsi->phy_timing;
235		235
236	ui = DIV_ROUND_UP(1000000000, dsi->data_rate);	236	timing->lpx = (60 * data_rate_mhz / (8 * 1000)) + 1;
237	cycle_time = div_u64(8000000000ULL, dsi->data_rate);	237	timing->da_hs_prepare = (80 * data_rate_mhz + 4 * 1000) / 8000;
		238	timing->da_hs_zero = (170 * data_rate_mhz + 10 * 1000) / 8000 + 1 -
		239	timing->da_hs_prepare;
		240	timing->da_hs_trail = timing->da_hs_prepare + 1;
238		241
239	timing->lpx = NS_TO_CYCLE(60, cycle_time);	242	timing->ta_go = 4 * timing->lpx - 2;
240	timing->da_hs_prepare = NS_TO_CYCLE(50 + 5 * ui, cycle_time);	243	timing->ta_sure = timing->lpx + 2;
241	timing->da_hs_zero = NS_TO_CYCLE(110 + 6 * ui, cycle_time);	244	timing->ta_get = 4 * timing->lpx;
242	timing->da_hs_trail = NS_TO_CYCLE(77 + 4 * ui, cycle_time);	245	timing->da_hs_exit = 2 * timing->lpx + 1;
243		246
244	timing->ta_go = 4 * timing->lpx;	247	timing->clk_hs_prepare = 70 * data_rate_mhz / (8 * 1000);
245	timing->ta_sure = 3 * timing->lpx / 2;	248	timing->clk_hs_post = timing->clk_hs_prepare + 8;
246	timing->ta_get = 5 * timing->lpx;	249	timing->clk_hs_trail = timing->clk_hs_prepare;
247	timing->da_hs_exit = 2 * timing->lpx;	250	timing->clk_hs_zero = timing->clk_hs_trail * 4;
248		251	timing->clk_hs_exit = 2 * timing->clk_hs_trail;
249	timing->clk_hs_zero = NS_TO_CYCLE(336, cycle_time);
250	timing->clk_hs_trail = NS_TO_CYCLE(100, cycle_time) + 10;
251
252	timing->clk_hs_prepare = NS_TO_CYCLE(64, cycle_time);
253	timing->clk_hs_post = NS_TO_CYCLE(80 + 52 * ui, cycle_time);
254	timing->clk_hs_exit = 2 * timing->lpx;
255		252
256	timcon0 = timing->lpx \| timing->da_hs_prepare << 8 \|	253	timcon0 = timing->lpx \| timing->da_hs_prepare << 8 \|
257	timing->da_hs_zero << 16 \| timing->da_hs_trail << 24;	254	timing->da_hs_zero << 16 \| timing->da_hs_trail << 24;
@@ -482,27 +479,39 @@ static void mtk_dsi_config_vdo_timing(struct mtk_dsi *dsi) · 224 unmodified lines
482	dsi_tmp_buf_bpp - 10);	479	dsi_tmp_buf_bpp - 10);
483		480
484	data_phy_cycles = timing->lpx + timing->da_hs_prepare +	481	data_phy_cycles = timing->lpx + timing->da_hs_prepare +
485	timing->da_hs_zero + timing->da_hs_exit + 2;	482	timing->da_hs_zero + timing->da_hs_exit + 3;
486		483
487	if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_BURST) {	484	if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_BURST) {
488	if (vm->hfront_porch * dsi_tmp_buf_bpp >	485	if ((vm->hfront_porch + vm->hback_porch) * dsi_tmp_buf_bpp >
489	data_phy_cycles * dsi->lanes + 18) {	486	data_phy_cycles * dsi->lanes + 18) {
490	horizontal_frontporch_byte = vm->hfront_porch *	487	horizontal_frontporch_byte =
491	dsi_tmp_buf_bpp -	488	vm->hfront_porch * dsi_tmp_buf_bpp -
492	data_phy_cycles *	489	(data_phy_cycles * dsi->lanes + 18) *
493	dsi->lanes - 18;	490	vm->hfront_porch /
		491	(vm->hfront_porch + vm->hback_porch);
		492
		493	horizontal_backporch_byte =
		494	horizontal_backporch_byte -
		495	(data_phy_cycles * dsi->lanes + 18) *
		496	vm->hback_porch /
		497	(vm->hfront_porch + vm->hback_porch);
494	} else {	498	} else {
495	DRM_WARN("HFP less than d-phy, FPS will under 60Hz\n");	499	DRM_WARN("HFP less than d-phy, FPS will under 60Hz\n");
496	horizontal_frontporch_byte = vm->hfront_porch *	500	horizontal_frontporch_byte = vm->hfront_porch *
497	dsi_tmp_buf_bpp;	501	dsi_tmp_buf_bpp;
498	}	502	}
499	} else {	503	} else {
500	if (vm->hfront_porch * dsi_tmp_buf_bpp >	504	if ((vm->hfront_porch + vm->hback_porch) * dsi_tmp_buf_bpp >
501	data_phy_cycles * dsi->lanes + 12) {	505	data_phy_cycles * dsi->lanes + 12) {
502	horizontal_frontporch_byte = vm->hfront_porch *	506	horizontal_frontporch_byte =
503	dsi_tmp_buf_bpp -	507	vm->hfront_porch * dsi_tmp_buf_bpp -
504	data_phy_cycles *	508	(data_phy_cycles * dsi->lanes + 12) *
505	dsi->lanes - 12;	509	vm->hfront_porch /
		510	(vm->hfront_porch + vm->hback_porch);
		511	horizontal_backporch_byte = horizontal_backporch_byte -
		512	(data_phy_cycles * dsi->lanes + 12) *
		513	vm->hback_porch /
		514	(vm->hfront_porch + vm->hback_porch);
506	} else {	515	} else {
507	DRM_WARN("HFP less than d-phy, FPS will under 60Hz\n");	516	DRM_WARN("HFP less than d-phy, FPS will under 60Hz\n");
508	horizontal_frontporch_byte = vm->hfront_porch *	517	horizontal_frontporch_byte = vm->hfront_porch *

drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c+0−2

@@ -685,8 +685,6 @@ static void sun4i_hdmi_unbind(struct device dev, struct device master, · 684 unmodified lines
685	struct sun4i_hdmi *hdmi = dev_get_drvdata(dev);	685	struct sun4i_hdmi *hdmi = dev_get_drvdata(dev);
686		686
687	cec_unregister_adapter(hdmi->cec_adap);	687	cec_unregister_adapter(hdmi->cec_adap);
688	drm_connector_cleanup(&hdmi->connector);
689	drm_encoder_cleanup(&hdmi->encoder);
690	i2c_del_adapter(hdmi->i2c);	688	i2c_del_adapter(hdmi->i2c);
691	i2c_put_adapter(hdmi->ddc_i2c);	689	i2c_put_adapter(hdmi->ddc_i2c);
692	clk_disable_unprepare(hdmi->mod_clk);	690	clk_disable_unprepare(hdmi->mod_clk);

drivers/gpu/drm/sun4i/sun4i_tcon.c+12−3

 	WARN_ON(!tcon->quirks->has_channel_0);
-	tcon->dclk_min_div = 1;
+	tcon->dclk_min_div = tcon->quirks->dclk_min_div;
 	tcon->dclk_max_div = 127;
 	sun4i_tcon0_mode_set_common(tcon, mode);
 static const struct sun4i_tcon_quirks sun4i_a10_quirks = {
 	.has_channel_0		= true,
 	.has_channel_1		= true,
+	.dclk_min_div		= 4,
 	.set_mux		= sun4i_a10_tcon_set_mux,
 };
 static const struct sun4i_tcon_quirks sun5i_a13_quirks = {
 	.has_channel_0		= true,
 	.has_channel_1		= true,
+	.dclk_min_div		= 4,
 	.set_mux		= sun5i_a13_tcon_set_mux,
 };
 	.has_channel_1		= true,
 	.has_lvds_alt		= true,
 	.needs_de_be_mux	= true,
+	.dclk_min_div		= 1,
 	.set_mux		= sun6i_tcon_set_mux,
 };
 	.has_channel_0		= true,
 	.has_channel_1		= true,
 	.needs_de_be_mux	= true,
+	.dclk_min_div		= 1,
 };
 static const struct sun4i_tcon_quirks sun7i_a20_quirks = {
 	.has_channel_0		= true,
 	.has_channel_1		= true,
+	.dclk_min_div		= 4,
 	/* Same display pipeline structure as A10 */
 	.set_mux		= sun4i_a10_tcon_set_mux,
 };
 static const struct sun4i_tcon_quirks sun8i_a33_quirks = {
 	.has_channel_0		= true,
 	.has_lvds_alt		= true,
+	.dclk_min_div		= 1,
 };
 static const struct sun4i_tcon_quirks sun8i_a83t_lcd_quirks = {
 	.supports_lvds		= true,
 	.has_channel_0		= true,
+	.dclk_min_div		= 1,
 };
 static const struct sun4i_tcon_quirks sun8i_a83t_tv_quirks = {
 static const struct sun4i_tcon_quirks sun8i_v3s_quirks = {
 	.has_channel_0		= true,
+	.dclk_min_div		= 1,
 };
 static const struct sun4i_tcon_quirks sun9i_a80_tcon_lcd_quirks = {
-	.has_channel_0	= true,
+	.has_channel_0		= true,
-	.needs_edp_reset = true,
+	.needs_edp_reset	= true,
+	.dclk_min_div		= 1,
 };
 static const struct sun4i_tcon_quirks sun9i_a80_tcon_tv_quirks = {

drivers/gpu/drm/sun4i/sun4i_tcon.h+1−0

@@ -224,6 +224,7 @@ struct sun4i_tcon_quirks { · 223 unmodified lines
224	bool needs_de_be_mux; /* sun6i needs mux to select backend */	224	bool needs_de_be_mux; /* sun6i needs mux to select backend */
225	bool needs_edp_reset; /* a80 edp reset needed for tcon0 access */	225	bool needs_edp_reset; /* a80 edp reset needed for tcon0 access */
226	bool supports_lvds; /* Does the TCON support an LVDS output? */	226	bool supports_lvds; /* Does the TCON support an LVDS output? */
		227	u8 dclk_min_div; /* minimum divider for TCON0 DCLK */
227		228
228	/* callback to handle tcon muxing options */	229	/* callback to handle tcon muxing options */
229	int (set_mux)(struct sun4i_tcon , const struct drm_encoder *);	230	int (set_mux)(struct sun4i_tcon , const struct drm_encoder *);

drivers/hid/hid-asus.c+2−1

 		      struct hid_usage *usage, __s32 value)
 {
 	if ((usage->hid & HID_USAGE_PAGE) == 0xff310000 &&
-	    (usage->hid & HID_USAGE) != 0x00 && !usage->type) {
+	    (usage->hid & HID_USAGE) != 0x00 &&
+	    (usage->hid & HID_USAGE) != 0xff && !usage->type) {
 		hid_warn(hdev, "Unmapped Asus vendor usagepage code 0x%02x\n",
 			 usage->hid & HID_USAGE);
 	}

drivers/hid/hid-core.c+6−0

 	offset = report->size;
 	report->size += parser->global.report_size * parser->global.report_count;
+	/* Total size check: Allow for possible report index byte */
+	if (report->size > (HID_MAX_BUFFER_SIZE - 1) << 3) {
+		hid_err(parser->device, "report is too long\n");
+		return -1;
+	}
 	if (!parser->local.usage_index) /* Ignore padding fields */
 		return 0;

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

 #define USB_VENDOR_ID_ITE               0x048d
 #define USB_DEVICE_ID_ITE_LENOVO_YOGA   0x8386
 #define USB_DEVICE_ID_ITE_LENOVO_YOGA2  0x8350
+#define I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720	0x837a
 #define USB_DEVICE_ID_ITE_LENOVO_YOGA900	0x8396
 #define USB_DEVICE_ID_ITE8595		0x8595
 #define USB_DEVICE_ID_LG_MULTITOUCH	0x0064
 #define USB_DEVICE_ID_LG_MELFAS_MT	0x6007
 #define I2C_DEVICE_ID_LG_8001		0x8001
+#define I2C_DEVICE_ID_LG_7010		0x7010
 #define USB_VENDOR_ID_LOGITECH		0x046d
 #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e
 #define USB_DEVICE_ID_SYNAPTICS_LTS2	0x1d10
 #define USB_DEVICE_ID_SYNAPTICS_HD	0x0ac3
 #define USB_DEVICE_ID_SYNAPTICS_QUAD_HD	0x1ac3
+#define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5_012	0x2968
 #define USB_DEVICE_ID_SYNAPTICS_TP_V103	0x5710
 #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5	0x81a7

drivers/hid/hid-input.c+12−4

 	}
 mapped:
-	if (device->driver->input_mapped && device->driver->input_mapped(device,
+	if (device->driver->input_mapped &&
-				hidinput, field, usage, &bit, &max) < 0)
+	    device->driver->input_mapped(device, hidinput, field, usage,
-		goto ignore;
+					 &bit, &max) < 0) {
+		/*
+		 * The driver indicated that no further generic handling
+		 * of the usage is desired.
+		 */
+		return;
+	}
 	set_bit(usage->type, input->evbit);
 		set_bit(MSC_SCAN, input->mscbit);
 	}
-ignore:
 	return;
+ignore:
+	usage->type = 0;
+	usage->code = 0;
 }
 static void hidinput_handle_scroll(struct hid_usage *usage,

drivers/hid/hid-ite.c+3−0

 static const struct hid_device_id ite_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE8595) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_258A, USB_DEVICE_ID_258A_6A88) },
+	/* ITE8595 USB kbd ctlr, with Synaptics touchpad connected to it. */
+	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS,
+			 USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5_012) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, ite_devices);

drivers/hid/hid-multitouch.c+4−1

 		tool = MT_TOOL_DIAL;
 	else if (unlikely(!confidence_state)) {
 		tool = MT_TOOL_PALM;
-		if (!active &&
+		if (!active && mt &&
 		    input_mt_is_active(&mt->slots[slotnum])) {
 			/*
 			 * The non-confidence was reported for
 	{ .driver_data = MT_CLS_LG,
 		HID_USB_DEVICE(USB_VENDOR_ID_LG,
 			USB_DEVICE_ID_LG_MELFAS_MT) },
+	{ .driver_data = MT_CLS_LG,
+		HID_DEVICE(BUS_I2C, HID_GROUP_GENERIC,
+			USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_7010) },
 	/* MosArt panels */
 	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,

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

@@ -174,6 +174,7 @@ static const struct hid_device_id hid_quirks[] = { · 173 unmodified lines
174	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET), HID_QUIRK_MULTI_INPUT },	174	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET), HID_QUIRK_MULTI_INPUT },
175	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS), HID_QUIRK_NOGET \| HID_QUIRK_MULTI_INPUT },	175	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS), HID_QUIRK_NOGET \| HID_QUIRK_MULTI_INPUT },
176	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD), HID_QUIRK_NOGET \| HID_QUIRK_MULTI_INPUT },	176	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD), HID_QUIRK_NOGET \| HID_QUIRK_MULTI_INPUT },
		177	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE), HID_QUIRK_MULTI_INPUT },
177		178
178	{ 0 }	179	{ 0 }
179	};	180	};

drivers/hid/hid-steam.c+4−0

 	if (steam->quirks & STEAM_QUIRK_WIRELESS) {
 		hid_info(hdev, "Steam wireless receiver connected");
+		/* If using a wireless adaptor ask for connection status */
+		steam->connected = false;
 		steam_request_conn_status(steam);
 	} else {
+		/* A wired connection is always present */
+		steam->connected = true;
 		ret = steam_register(steam);
 		if (ret) {
 			hid_err(hdev,

drivers/hid/hidraw.c+4−3

 static __poll_t hidraw_poll(struct file *file, poll_table *wait)
 {
 	struct hidraw_list *list = file->private_data;
+	__poll_t mask = EPOLLOUT | EPOLLWRNORM; /* hidraw is always writable */
 	poll_wait(file, &list->hidraw->wait, wait);
 	if (list->head != list->tail)
-		return EPOLLIN | EPOLLRDNORM | EPOLLOUT;
+		mask |= EPOLLIN | EPOLLRDNORM;
 	if (!list->hidraw->exist)
-		return EPOLLERR | EPOLLHUP;
+		mask |= EPOLLERR | EPOLLHUP;
-	return 0;
+	return mask;
 }
 static int hidraw_open(struct inode *inode, struct file *file)

drivers/hid/i2c-hid/i2c-hid-core.c+13−3

 #define I2C_HID_QUIRK_NO_IRQ_AFTER_RESET	BIT(1)
 #define I2C_HID_QUIRK_BOGUS_IRQ			BIT(4)
 #define I2C_HID_QUIRK_RESET_ON_RESUME		BIT(5)
+#define I2C_HID_QUIRK_BAD_INPUT_SIZE		BIT(6)
 /* flags */
 #define I2C_HID_STARTED		0
 		 I2C_HID_QUIRK_BOGUS_IRQ },
 	{ USB_VENDOR_ID_ALPS_JP, HID_ANY_ID,
 		 I2C_HID_QUIRK_RESET_ON_RESUME },
+	{ USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720,
+		I2C_HID_QUIRK_BAD_INPUT_SIZE },
 	{ 0, 0 }
 };
 	}
 	if ((ret_size > size) || (ret_size < 2)) {
-		dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
+		if (ihid->quirks & I2C_HID_QUIRK_BAD_INPUT_SIZE) {
-			__func__, size, ret_size);
+			ihid->inbuf[0] = size & 0xff;
-		return;
+			ihid->inbuf[1] = size >> 8;
+			ret_size = size;
+		} else {
+			dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
+				__func__, size, ret_size);
+			return;
+		}
 	}
 	i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);

drivers/hid/intel-ish-hid/ipc/hw-ish.h+2−0

 #define ICL_MOBILE_DEVICE_ID	0x34FC
 #define SPT_H_DEVICE_ID		0xA135
 #define CML_LP_DEVICE_ID	0x02FC
+#define CMP_H_DEVICE_ID		0x06FC
 #define EHL_Ax_DEVICE_ID	0x4BB3
+#define TGL_LP_DEVICE_ID	0xA0FC
 #define	REVISION_ID_CHT_A0	0x6
 #define	REVISION_ID_CHT_Ax_SI	0x0

drivers/hid/intel-ish-hid/ipc/pci-ish.c+2−0

 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, ICL_MOBILE_DEVICE_ID)},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, SPT_H_DEVICE_ID)},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, CML_LP_DEVICE_ID)},
+	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, CMP_H_DEVICE_ID)},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, EHL_Ax_DEVICE_ID)},
+	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, TGL_LP_DEVICE_ID)},
 	{0, }
 };
 MODULE_DEVICE_TABLE(pci, ish_pci_tbl);

drivers/hid/uhid.c+3−2

 static __poll_t uhid_char_poll(struct file *file, poll_table *wait)
 {
 	struct uhid_device *uhid = file->private_data;
+	__poll_t mask = EPOLLOUT | EPOLLWRNORM; /* uhid is always writable */
 	poll_wait(file, &uhid->waitq, wait);
 	if (uhid->head != uhid->tail)
-		return EPOLLIN | EPOLLRDNORM;
+		mask |= EPOLLIN | EPOLLRDNORM;
-	return 0;
+	return mask;
 }
 static const struct file_operations uhid_fops = {

drivers/hid/usbhid/hiddev.c+42−55

 	return 0;
 }
+static int __hiddev_open(struct hiddev *hiddev, struct file *file)
+{
+	struct hiddev_list *list;
+	int error;
+	lockdep_assert_held(&hiddev->existancelock);
+	list = vzalloc(sizeof(*list));
+	if (!list)
+		return -ENOMEM;
+	mutex_init(&list->thread_lock);
+	list->hiddev = hiddev;
+	if (!hiddev->open++) {
+		error = hid_hw_power(hiddev->hid, PM_HINT_FULLON);
+		if (error < 0)
+			goto err_drop_count;
+		error = hid_hw_open(hiddev->hid);
+		if (error < 0)
+			goto err_normal_power;
+	}
+	spin_lock_irq(&hiddev->list_lock);
+	list_add_tail(&list->node, &hiddev->list);
+	spin_unlock_irq(&hiddev->list_lock);
+	file->private_data = list;
+	return 0;
+err_normal_power:
+	hid_hw_power(hiddev->hid, PM_HINT_NORMAL);
+err_drop_count:
+	hiddev->open--;
+	vfree(list);
+	return error;
+}
 /*
  * open file op
  */
 static int hiddev_open(struct inode *inode, struct file *file)
 {
-	struct hiddev_list *list;
 	struct usb_interface *intf;
 	struct hid_device *hid;
 	struct hiddev *hiddev;
 	intf = usbhid_find_interface(iminor(inode));
 	if (!intf)
 		return -ENODEV;
 	hid = usb_get_intfdata(intf);
 	hiddev = hid->hiddev;
-	if (!(list = vzalloc(sizeof(struct hiddev_list))))
-		return -ENOMEM;
-	mutex_init(&list->thread_lock);
-	list->hiddev = hiddev;
-	file->private_data = list;
-	/*
-	 * no need for locking because the USB major number
-	 * is shared which usbcore guards against disconnect
-	 */
-	if (list->hiddev->exist) {
-		if (!list->hiddev->open++) {
-			res = hid_hw_open(hiddev->hid);
-			if (res < 0)
-				goto bail;
-		}
-	} else {
-		res = -ENODEV;
-		goto bail;
-	}
-	spin_lock_irq(&list->hiddev->list_lock);
-	list_add_tail(&list->node, &hiddev->list);
-	spin_unlock_irq(&list->hiddev->list_lock);
 	mutex_lock(&hiddev->existancelock);
-	/*
+	res = hiddev->exist ? __hiddev_open(hiddev, file) : -ENODEV;
-	 * recheck exist with existance lock held to
-	 * avoid opening a disconnected device
-	 */
-	if (!list->hiddev->exist) {
-		res = -ENODEV;
-		goto bail_unlock;
-	}
-	if (!list->hiddev->open++)
-		if (list->hiddev->exist) {
-			struct hid_device *hid = hiddev->hid;
-			res = hid_hw_power(hid, PM_HINT_FULLON);
-			if (res < 0)
-				goto bail_unlock;
-			res = hid_hw_open(hid);
-			if (res < 0)
-				goto bail_normal_power;
-		}
-	mutex_unlock(&hiddev->existancelock);
-	return 0;
-bail_normal_power:
-	hid_hw_power(hid, PM_HINT_NORMAL);
-bail_unlock:
 	mutex_unlock(&hiddev->existancelock);
-	spin_lock_irq(&list->hiddev->list_lock);
-	list_del(&list->node);
-	spin_unlock_irq(&list->hiddev->list_lock);
-bail:
-	file->private_data = NULL;
-	vfree(list);
 	return res;
 }

drivers/hid/wacom_wac.c+4−2

 		    (hdev->product == 0x34d || hdev->product == 0x34e ||  /* MobileStudio Pro */
 		     hdev->product == 0x357 || hdev->product == 0x358 ||  /* Intuos Pro 2 */
 		     hdev->product == 0x392 ||				  /* Intuos Pro 2 */
-		     hdev->product == 0x398 || hdev->product == 0x399)) { /* MobileStudio Pro */
+		     hdev->product == 0x398 || hdev->product == 0x399 ||  /* MobileStudio Pro */
+		     hdev->product == 0x3AA)) {				  /* MobileStudio Pro */
 			value = (field->logical_maximum - value);
 			if (hdev->product == 0x357 || hdev->product == 0x358 ||
 			    hdev->product == 0x392)
 				value = wacom_offset_rotation(input, usage, value, 3, 16);
 			else if (hdev->product == 0x34d || hdev->product == 0x34e ||
-				 hdev->product == 0x398 || hdev->product == 0x399)
+				 hdev->product == 0x398 || hdev->product == 0x399 ||
+				 hdev->product == 0x3AA)
 				value = wacom_offset_rotation(input, usage, value, 1, 2);
 		}
 		else {

drivers/i2c/busses/i2c-at91-core.c+1−1

@@ -174,7 +174,7 @@ static struct at91_twi_pdata sama5d2_config = { · 173 unmodified lines
174		174
175	static struct at91_twi_pdata sam9x60_config = {	175	static struct at91_twi_pdata sam9x60_config = {
176	.clk_max_div = 7,	176	.clk_max_div = 7,
177	.clk_offset = 4,	177	.clk_offset = 3,
178	.has_unre_flag = true,	178	.has_unre_flag = true,
179	.has_alt_cmd = true,	179	.has_alt_cmd = true,
180	.has_hold_field = true,	180	.has_hold_field = true,

drivers/i2c/busses/i2c-bcm2835.c+8−9

 	struct i2c_adapter adapter;
 	struct completion completion;
 	struct i2c_msg *curr_msg;
+	struct clk *bus_clk;
 	int num_msgs;
 	u32 msg_err;
 	u8 *msg_buf;
 	struct resource *mem, *irq;
 	int ret;
 	struct i2c_adapter *adap;
-	struct clk *bus_clk;
 	struct clk *mclk;
 	u32 bus_clk_rate;
 		return PTR_ERR(mclk);
 	}
-	bus_clk = bcm2835_i2c_register_div(&pdev->dev, mclk, i2c_dev);
+	i2c_dev->bus_clk = bcm2835_i2c_register_div(&pdev->dev, mclk, i2c_dev);
-	if (IS_ERR(bus_clk)) {
+	if (IS_ERR(i2c_dev->bus_clk)) {
 		dev_err(&pdev->dev, "Could not register clock\n");
-		return PTR_ERR(bus_clk);
+		return PTR_ERR(i2c_dev->bus_clk);
 	}
 	ret = of_property_read_u32(pdev->dev.of_node, "clock-frequency",
 		bus_clk_rate = 100000;
 	}
-	ret = clk_set_rate_exclusive(bus_clk, bus_clk_rate);
+	ret = clk_set_rate_exclusive(i2c_dev->bus_clk, bus_clk_rate);
 	if (ret < 0) {
 		dev_err(&pdev->dev, "Could not set clock frequency\n");
 		return ret;
 	}
-	ret = clk_prepare_enable(bus_clk);
+	ret = clk_prepare_enable(i2c_dev->bus_clk);
 	if (ret) {
 		dev_err(&pdev->dev, "Couldn't prepare clock");
 		return ret;
 static int bcm2835_i2c_remove(struct platform_device *pdev)
 {
 	struct bcm2835_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
-	struct clk *bus_clk = devm_clk_get(i2c_dev->dev, "div");
-	clk_rate_exclusive_put(bus_clk);
+	clk_rate_exclusive_put(i2c_dev->bus_clk);
-	clk_disable_unprepare(bus_clk);
+	clk_disable_unprepare(i2c_dev->bus_clk);
 	free_irq(i2c_dev->irq, i2c_dev);
 	i2c_del_adapter(&i2c_dev->adapter);

drivers/i2c/i2c-core-base.c+10−3

 	 * If we can set SDA, we will always create a STOP to ensure additional
 	 * pulses will do no harm. This is achieved by letting SDA follow SCL
 	 * half a cycle later. Check the 'incomplete_write_byte' fault injector
-	 * for details.
+	 * for details. Note that we must honour tsu:sto, 4us, but lets use 5us
+	 * here for simplicity.
 	 */
 	bri->set_scl(adap, scl);
-	ndelay(RECOVERY_NDELAY / 2);
+	ndelay(RECOVERY_NDELAY);
 	if (bri->set_sda)
 		bri->set_sda(adap, scl);
 	ndelay(RECOVERY_NDELAY / 2);
 		scl = !scl;
 		bri->set_scl(adap, scl);
 		/* Creating STOP again, see above */
-		ndelay(RECOVERY_NDELAY / 2);
+		if (scl)  {
+			/* Honour minimum tsu:sto */
+			ndelay(RECOVERY_NDELAY);
+		} else {
+			/* Honour minimum tf and thd:dat */
+			ndelay(RECOVERY_NDELAY / 2);
+		}
 		if (bri->set_sda)
 			bri->set_sda(adap, scl);
 		ndelay(RECOVERY_NDELAY / 2);

drivers/infiniband/hw/bnxt_re/ib_verbs.c+3−1

 	int rc;
 	rc = bnxt_qplib_free_mrw(&rdev->qplib_res, &mr->qplib_mr);
-	if (rc)
+	if (rc) {
 		dev_err(rdev_to_dev(rdev), "Dereg MR failed: %#x\n", rc);
+		return rc;
+	}
 	if (mr->pages) {
 		rc = bnxt_qplib_free_fast_reg_page_list(&rdev->qplib_res,

drivers/infiniband/hw/bnxt_re/qplib_fp.c+6−6

 			/* Add qp to flush list of the CQ */
 			bnxt_qplib_add_flush_qp(qp);
 		} else {
+			/* Before we complete, do WA 9060 */
+			if (do_wa9060(qp, cq, cq_cons, sw_sq_cons,
+				      cqe_sq_cons)) {
+				*lib_qp = qp;
+				goto out;
+			}
 			if (swq->flags & SQ_SEND_FLAGS_SIGNAL_COMP) {
-				/* Before we complete, do WA 9060 */
-				if (do_wa9060(qp, cq, cq_cons, sw_sq_cons,
-					      cqe_sq_cons)) {
-					*lib_qp = qp;
-					goto out;
-				}
 				cqe->status = CQ_REQ_STATUS_OK;
 				cqe++;
 				(*budget)--;

drivers/infiniband/hw/hfi1/iowait.c+3−1

 void iowait_cancel_work(struct iowait *w)
 {
 	cancel_work_sync(&iowait_get_ib_work(w)->iowork);
-	cancel_work_sync(&iowait_get_tid_work(w)->iowork);
+	/* Make sure that the iowork for TID RDMA is used */
+	if (iowait_get_tid_work(w)->iowork.func)
+		cancel_work_sync(&iowait_get_tid_work(w)->iowork);
 }
 /**

drivers/infiniband/hw/hfi1/tid_rdma.c+9−0

@@ -4633,6 +4633,15 @@ void hfi1_rc_rcv_tid_rdma_ack(struct hfi1_packet *packet) · 4632 unmodified lines
4633	*/	4633	*/
4634	fpsn = full_flow_psn(flow, flow->flow_state.spsn);	4634	fpsn = full_flow_psn(flow, flow->flow_state.spsn);
4635	req->r_ack_psn = psn;	4635	req->r_ack_psn = psn;
		4636	/*
		4637	* If resync_psn points to the last flow PSN for a
		4638	* segment and the new segment (likely from a new
		4639	* request) starts with a new generation number, we
		4640	* need to adjust resync_psn accordingly.
		4641	*/
		4642	if (flow->flow_state.generation !=
		4643	(resync_psn >> HFI1_KDETH_BTH_SEQ_SHIFT))
		4644	resync_psn = mask_psn(fpsn - 1);
4636	flow->resync_npkts +=	4645	flow->resync_npkts +=
4637	delta_psn(mask_psn(resync_psn + 1), fpsn);	4646	delta_psn(mask_psn(resync_psn + 1), fpsn);
4638	/*	4647	/*

drivers/infiniband/hw/i40iw/i40iw_verbs.c+6−8

 static int i40iw_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
 {
 	struct i40iw_ucontext *ucontext;
-	u64 db_addr_offset;
+	u64 db_addr_offset, push_offset, pfn;
-	u64 push_offset;
 	ucontext = to_ucontext(context);
 	if (ucontext->iwdev->sc_dev.is_pf) {
 	if (vma->vm_pgoff == (db_addr_offset >> PAGE_SHIFT)) {
 		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-		vma->vm_private_data = ucontext;
 	} else {
 		if ((vma->vm_pgoff - (push_offset >> PAGE_SHIFT)) % 2)
 			vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 			vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 	}
-	if (io_remap_pfn_range(vma, vma->vm_start,
+	pfn = vma->vm_pgoff +
-			       vma->vm_pgoff + (pci_resource_start(ucontext->iwdev->ldev->pcidev, 0) >> PAGE_SHIFT),
+	      (pci_resource_start(ucontext->iwdev->ldev->pcidev, 0) >>
-			       PAGE_SIZE, vma->vm_page_prot))
+	       PAGE_SHIFT);
-		return -EAGAIN;
-	return 0;
+	return rdma_user_mmap_io(context, vma, pfn, PAGE_SIZE,
+				 vma->vm_page_prot, NULL);
 }
 /**

drivers/input/evdev.c+7−7

@@ -224,13 +224,13 @@ static void __pass_event(struct evdev_client *client, · 223 unmodified lines
224	*/	224	*/
225	client->tail = (client->head - 2) & (client->bufsize - 1);	225	client->tail = (client->head - 2) & (client->bufsize - 1);
226		226
227	client->buffer[client->tail].input_event_sec =	227	client->buffer[client->tail] = (struct input_event) {
228	event->input_event_sec;	228	.input_event_sec = event->input_event_sec,
229	client->buffer[client->tail].input_event_usec =	229	.input_event_usec = event->input_event_usec,
230	event->input_event_usec;	230	.type = EV_SYN,
231	client->buffer[client->tail].type = EV_SYN;	231	.code = SYN_DROPPED,
232	client->buffer[client->tail].code = SYN_DROPPED;	232	.value = 0,
233	client->buffer[client->tail].value = 0;	233	};
234		234
235	client->packet_head = client->tail;	235	client->packet_head = client->tail;
236	}	236	}

drivers/input/input.c+16−10

@@ -878,16 +878,18 @@ static int input_default_setkeycode(struct input_dev *dev, · 877 unmodified lines
878	}	878	}
879	}	879	}
880		880
881	__clear_bit(*old_keycode, dev->keybit);	881	if (*old_keycode <= KEY_MAX) {
882	__set_bit(ke->keycode, dev->keybit);	882	__clear_bit(*old_keycode, dev->keybit);
883		883	for (i = 0; i < dev->keycodemax; i++) {
884	for (i = 0; i < dev->keycodemax; i++) {	884	if (input_fetch_keycode(dev, i) == *old_keycode) {
885	if (input_fetch_keycode(dev, i) == *old_keycode) {	885	__set_bit(*old_keycode, dev->keybit);
886	__set_bit(*old_keycode, dev->keybit);	886	/* Setting the bit twice is useless, so break */
887	break; /* Setting the bit twice is useless, so break */	887	break;
		888	}
888	}	889	}
889	}	890	}
890		891
		892	__set_bit(ke->keycode, dev->keybit);
891	return 0;	893	return 0;
892	}	894	}
893		895
@@ -943,9 +945,13 @@ int input_set_keycode(struct input_dev *dev, · 49 unmodified lines
943	* Simulate keyup event if keycode is not present	945	* Simulate keyup event if keycode is not present
944	* in the keymap anymore	946	* in the keymap anymore
945	*/	947	*/
946	if (test_bit(EV_KEY, dev->evbit) &&	948	if (old_keycode > KEY_MAX) {
947	!is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&	949	dev_warn(dev->dev.parent ?: &dev->dev,
948	__test_and_clear_bit(old_keycode, dev->key)) {	950	"%s: got too big old keycode %#x\n",
		951	__func__, old_keycode);
		952	} else if (test_bit(EV_KEY, dev->evbit) &&
		953	!is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
		954	__test_and_clear_bit(old_keycode, dev->key)) {
949	struct input_value vals[] = {	955	struct input_value vals[] = {
950	{ EV_KEY, old_keycode, 0 },	956	{ EV_KEY, old_keycode, 0 },
951	input_value_sync	957	input_value_sync

drivers/input/keyboard/imx_sc_key.c+7−1

 		return;
 	}
-	state = (bool)msg.state;
+	/*
+	 * The response data from SCU firmware is 4 bytes,
+	 * but ONLY the first byte is the key state, other
+	 * 3 bytes could be some dirty data, so we should
+	 * ONLY take the first byte as key state.
+	 */
+	state = (bool)(msg.state & 0xff);
 	if (state ^ priv->keystate) {
 		priv->keystate = state;

drivers/input/misc/uinput.c+12−7

@@ -74,12 +74,16 @@ static int uinput_dev_event(struct input_dev *dev, · 73 unmodified lines
74	struct uinput_device *udev = input_get_drvdata(dev);	74	struct uinput_device *udev = input_get_drvdata(dev);
75	struct timespec64 ts;	75	struct timespec64 ts;
76		76
77	udev->buff[udev->head].type = type;
78	udev->buff[udev->head].code = code;
79	udev->buff[udev->head].value = value;
80	ktime_get_ts64(&ts);	77	ktime_get_ts64(&ts);
81	udev->buff[udev->head].input_event_sec = ts.tv_sec;	78
82	udev->buff[udev->head].input_event_usec = ts.tv_nsec / NSEC_PER_USEC;	79	udev->buff[udev->head] = (struct input_event) {
		80	.input_event_sec = ts.tv_sec,
		81	.input_event_usec = ts.tv_nsec / NSEC_PER_USEC,
		82	.type = type,
		83	.code = code,
		84	.value = value,
		85	};
		86
83	udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE;	87	udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE;
84		88
85	wake_up_interruptible(&udev->waitq);	89	wake_up_interruptible(&udev->waitq);
@@ -689,13 +693,14 @@ static ssize_t uinput_read(struct file file, char __user buffer, · 603 unmodified lines
689	static __poll_t uinput_poll(struct file file, poll_table wait)	693	static __poll_t uinput_poll(struct file file, poll_table wait)
690	{	694	{
691	struct uinput_device *udev = file->private_data;	695	struct uinput_device *udev = file->private_data;
		696	__poll_t mask = EPOLLOUT \| EPOLLWRNORM; /* uinput is always writable */
692		697
693	poll_wait(file, &udev->waitq, wait);	698	poll_wait(file, &udev->waitq, wait);
694		699
695	if (udev->head != udev->tail)	700	if (udev->head != udev->tail)
696	return EPOLLIN \| EPOLLRDNORM;	701	mask \|= EPOLLIN \| EPOLLRDNORM;
697		702
698	return EPOLLOUT \| EPOLLWRNORM;	703	return mask;
699	}	704	}
700		705
701	static int uinput_release(struct inode inode, struct file file)	706	static int uinput_release(struct inode inode, struct file file)

drivers/iommu/dma-iommu.c+0−3

 {
 	struct device *dev = msi_desc_to_dev(desc);
 	struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
-	struct iommu_dma_cookie *cookie;
 	struct iommu_dma_msi_page *msi_page;
 	static DEFINE_MUTEX(msi_prepare_lock); /* see below */
 		return 0;
 	}
-	cookie = domain->iova_cookie;
 	/*
 	 * In fact the whole prepare operation should already be serialised by
 	 * irq_domain_mutex further up the callchain, but that's pretty subtle

drivers/iommu/intel-iommu.c+18−4

 	group = iommu_group_get_for_dev(dev);
-	if (IS_ERR(group))
+	if (IS_ERR(group)) {
-		return PTR_ERR(group);
+		ret = PTR_ERR(group);
+		goto unlink;
+	}
 	iommu_group_put(group);
 				if (!get_private_domain_for_dev(dev)) {
 					dev_warn(dev,
 						 "Failed to get a private domain.\n");
-					return -ENOMEM;
+					ret = -ENOMEM;
+					goto unlink;
 				}
 				dev_info(dev,
 	}
 	return 0;
+unlink:
+	iommu_device_unlink(&iommu->iommu, dev);
+	return ret;
 }
 static void intel_iommu_remove_device(struct device *dev)
 	WARN_ON_ONCE(!reserve_iova(&dmar_domain->iovad, start, end));
 }
+static struct iommu_group *intel_iommu_device_group(struct device *dev)
+{
+	if (dev_is_pci(dev))
+		return pci_device_group(dev);
+	return generic_device_group(dev);
+}
 #ifdef CONFIG_INTEL_IOMMU_SVM
 struct intel_iommu *intel_svm_device_to_iommu(struct device *dev)
 {
 	.get_resv_regions	= intel_iommu_get_resv_regions,
 	.put_resv_regions	= intel_iommu_put_resv_regions,
 	.apply_resv_region	= intel_iommu_apply_resv_region,
-	.device_group		= pci_device_group,
+	.device_group		= intel_iommu_device_group,
 	.dev_has_feat		= intel_iommu_dev_has_feat,
 	.dev_feat_enabled	= intel_iommu_dev_feat_enabled,
 	.dev_enable_feat	= intel_iommu_dev_enable_feat,

drivers/iommu/iommu.c+1−0

@@ -751,6 +751,7 @@ err_put_group: · 750 unmodified lines
751	mutex_unlock(&group->mutex);	751	mutex_unlock(&group->mutex);
752	dev->iommu_group = NULL;	752	dev->iommu_group = NULL;
753	kobject_put(group->devices_kobj);	753	kobject_put(group->devices_kobj);
		754	sysfs_remove_link(group->devices_kobj, device->name);
754	err_free_name:	755	err_free_name:
755	kfree(device->name);	756	kfree(device->name);
756	err_remove_link:	757	err_remove_link:

drivers/irqchip/irq-sifive-plic.c+1−1

@@ -256,7 +256,7 @@ static int __init plic_init(struct device_node *node, · 255 unmodified lines
256	* Skip contexts other than external interrupts for our	256	* Skip contexts other than external interrupts for our
257	* privilege level.	257	* privilege level.
258	*/	258	*/
259	if (parent.args[0] != IRQ_EXT)	259	if (parent.args[0] != RV_IRQ_EXT)
260	continue;	260	continue;
261		261
262	hartid = plic_find_hart_id(parent.np);	262	hartid = plic_find_hart_id(parent.np);

drivers/media/cec/cec-adap.c+27−13

 	} else {
 		list_del_init(&data->list);
 		if (!(data->msg.tx_status & CEC_TX_STATUS_OK))
-			data->adap->transmit_queue_sz--;
+			if (!WARN_ON(!data->adap->transmit_queue_sz))
+				data->adap->transmit_queue_sz--;
 	}
 	if (data->msg.tx_status & CEC_TX_STATUS_OK) {
 		 * need to do anything special in that case.
 		 */
 	}
+	/*
+	 * If something went wrong and this counter isn't what it should
+	 * be, then this will reset it back to 0. Warn if it is not 0,
+	 * since it indicates a bug, either in this framework or in a
+	 * CEC driver.
+	 */
+	if (WARN_ON(adap->transmit_queue_sz))
+		adap->transmit_queue_sz = 0;
 }
 /*
 		bool timeout = false;
 		u8 attempts;
-		if (adap->transmitting) {
+		if (adap->transmit_in_progress) {
 			int err;
 			/*
 			goto unlock;
 		}
-		if (adap->transmitting && timeout) {
+		if (adap->transmit_in_progress && timeout) {
 			/*
 			 * If we timeout, then log that. Normally this does
 			 * not happen and it is an indication of a faulty CEC
 			 * so much traffic on the bus that the adapter was
 			 * unable to transmit for CEC_XFER_TIMEOUT_MS (2.1s).
 			 */
-			pr_warn("cec-%s: message %*ph timed out\n", adap->name,
+			if (adap->transmitting) {
-				adap->transmitting->msg.len,
+				pr_warn("cec-%s: message %*ph timed out\n", adap->name,
-				adap->transmitting->msg.msg);
+					adap->transmitting->msg.len,
+					adap->transmitting->msg.msg);
+				/* Just give up on this. */
+				cec_data_cancel(adap->transmitting,
+						CEC_TX_STATUS_TIMEOUT);
+			} else {
+				pr_warn("cec-%s: transmit timed out\n", adap->name);
+			}
 			adap->transmit_in_progress = false;
 			adap->tx_timeouts++;
-			/* Just give up on this. */
-			cec_data_cancel(adap->transmitting,
-					CEC_TX_STATUS_TIMEOUT);
 			goto unlock;
 		}
 		data = list_first_entry(&adap->transmit_queue,
 					struct cec_data, list);
 		list_del_init(&data->list);
-		adap->transmit_queue_sz--;
+		if (!WARN_ON(!data->adap->transmit_queue_sz))
+			adap->transmit_queue_sz--;
 		/* Make this the current transmitting message */
 		adap->transmitting = data;
 			valid_la = false;
 		else if (!cec_msg_is_broadcast(msg) && !(dir_fl & DIRECTED))
 			valid_la = false;
-		else if (cec_msg_is_broadcast(msg) && !(dir_fl & BCAST1_4))
+		else if (cec_msg_is_broadcast(msg) && !(dir_fl & BCAST))
 			valid_la = false;
 		else if (cec_msg_is_broadcast(msg) &&
-			 adap->log_addrs.cec_version >= CEC_OP_CEC_VERSION_2_0 &&
+			 adap->log_addrs.cec_version < CEC_OP_CEC_VERSION_2_0 &&
-			 !(dir_fl & BCAST2_0))
+			 !(dir_fl & BCAST1_4))
 			valid_la = false;
 	}
 	if (valid_la && min_len) {

drivers/media/usb/pulse8-cec/pulse8-cec.c+13−4

 	unsigned int vers;
 	struct completion cmd_done;
 	struct work_struct work;
+	u8 work_result;
 	struct delayed_work ping_eeprom_work;
 	struct cec_msg rx_msg;
 	u8 data[DATA_SIZE];
 {
 	struct pulse8 *pulse8 =
 		container_of(work, struct pulse8, work);
+	u8 result = pulse8->work_result;
-	switch (pulse8->data[0] & 0x3f) {
+	pulse8->work_result = 0;
+	switch (result & 0x3f) {
 	case MSGCODE_FRAME_DATA:
 		cec_received_msg(pulse8->adap, &pulse8->rx_msg);
 		break;
 		pulse8->escape = false;
 	} else if (data == MSGEND) {
 		struct cec_msg *msg = &pulse8->rx_msg;
+		u8 msgcode = pulse8->buf[0];
 		if (debug)
 			dev_info(pulse8->dev, "received: %*ph\n",
 				 pulse8->idx, pulse8->buf);
-		pulse8->data[0] = pulse8->buf[0];
+		switch (msgcode & 0x3f) {
-		switch (pulse8->buf[0] & 0x3f) {
 		case MSGCODE_FRAME_START:
 			msg->len = 1;
 			msg->msg[0] = pulse8->buf[1];
 			if (msg->len == CEC_MAX_MSG_SIZE)
 				break;
 			msg->msg[msg->len++] = pulse8->buf[1];
-			if (pulse8->buf[0] & MSGCODE_FRAME_EOM)
+			if (msgcode & MSGCODE_FRAME_EOM) {
+				WARN_ON(pulse8->work_result);
+				pulse8->work_result = msgcode;
 				schedule_work(&pulse8->work);
+				break;
+			}
 			break;
 		case MSGCODE_TRANSMIT_SUCCEEDED:
 		case MSGCODE_TRANSMIT_FAILED_LINE:
 		case MSGCODE_TRANSMIT_FAILED_ACK:
 		case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
 		case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
+			WARN_ON(pulse8->work_result);
+			pulse8->work_result = msgcode;
 			schedule_work(&pulse8->work);
 			break;
 		case MSGCODE_HIGH_ERROR:

drivers/mtd/nand/onenand/omap2.c+8−6

 	unsigned long timeout;
 	u32 syscfg;
-	if (state == FL_RESETING || state == FL_PREPARING_ERASE ||
+	if (state == FL_RESETTING || state == FL_PREPARING_ERASE ||
 	    state == FL_VERIFYING_ERASE) {
 		int i = 21;
 		unsigned int intr_flags = ONENAND_INT_MASTER;
 		switch (state) {
-		case FL_RESETING:
+		case FL_RESETTING:
 			intr_flags |= ONENAND_INT_RESET;
 			break;
 		case FL_PREPARING_ERASE:
 	struct dma_async_tx_descriptor *tx;
 	dma_cookie_t cookie;
-	tx = dmaengine_prep_dma_memcpy(c->dma_chan, dst, src, count, 0);
+	tx = dmaengine_prep_dma_memcpy(c->dma_chan, dst, src, count,
+				       DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
 	if (!tx) {
 		dev_err(&c->pdev->dev, "Failed to prepare DMA memcpy\n");
 		return -EIO;
 	 * context fallback to PIO mode.
 	 */
 	if (!virt_addr_valid(buf) || bram_offset & 3 || (size_t)buf & 3 ||
-	    count < 384 || in_interrupt() || oops_in_progress )
+	    count < 384 || in_interrupt() || oops_in_progress)
 		goto out_copy;
 	xtra = count & 3;
 	 * context fallback to PIO mode.
 	 */
 	if (!virt_addr_valid(buf) || bram_offset & 3 || (size_t)buf & 3 ||
-	    count < 384 || in_interrupt() || oops_in_progress )
+	    count < 384 || in_interrupt() || oops_in_progress)
 		goto out_copy;
 	dma_src = dma_map_single(dev, buf, count, DMA_TO_DEVICE);
 		 c->gpmc_cs, c->phys_base, c->onenand.base,
 		 c->dma_chan ? "DMA" : "PIO");
-	if ((r = onenand_scan(&c->mtd, 1)) < 0)
+	r = onenand_scan(&c->mtd, 1);
+	if (r < 0)
 		goto err_release_dma;
 	freq = omap2_onenand_get_freq(c->onenand.version_id);

drivers/mtd/nand/onenand/onenand_base.c+7−7

@@ -2853,7 +2853,7 @@ static int onenand_otp_write_oob_nolock(struct mtd_info *mtd, loff_t to, · 2852 unmodified lines
2853		2853
2854	/* Exit OTP access mode */	2854	/* Exit OTP access mode */
2855	this->command(mtd, ONENAND_CMD_RESET, 0, 0);	2855	this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2856	this->wait(mtd, FL_RESETING);	2856	this->wait(mtd, FL_RESETTING);
2857		2857
2858	status = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);	2858	status = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
2859	status &= 0x60;	2859	status &= 0x60;
@@ -2924,7 +2924,7 @@ static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len, · 64 unmodified lines
2924		2924
2925	/* Exit OTP access mode */	2925	/* Exit OTP access mode */
2926	this->command(mtd, ONENAND_CMD_RESET, 0, 0);	2926	this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2927	this->wait(mtd, FL_RESETING);	2927	this->wait(mtd, FL_RESETTING);
2928		2928
2929	return ret;	2929	return ret;
2930	}	2930	}
@@ -2968,7 +2968,7 @@ static int do_otp_write(struct mtd_info *mtd, loff_t to, size_t len, · 37 unmodified lines
2968		2968
2969	/* Exit OTP access mode */	2969	/* Exit OTP access mode */
2970	this->command(mtd, ONENAND_CMD_RESET, 0, 0);	2970	this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2971	this->wait(mtd, FL_RESETING);	2971	this->wait(mtd, FL_RESETTING);
2972		2972
2973	return ret;	2973	return ret;
2974	}	2974	}
@@ -3008,7 +3008,7 @@ static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len, · 33 unmodified lines
3008		3008
3009	/* Exit OTP access mode */	3009	/* Exit OTP access mode */
3010	this->command(mtd, ONENAND_CMD_RESET, 0, 0);	3010	this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3011	this->wait(mtd, FL_RESETING);	3011	this->wait(mtd, FL_RESETTING);
3012	} else {	3012	} else {
3013	ops.mode = MTD_OPS_PLACE_OOB;	3013	ops.mode = MTD_OPS_PLACE_OOB;
3014	ops.ooblen = len;	3014	ops.ooblen = len;
@@ -3413,7 +3413,7 @@ static int flexonenand_get_boundary(struct mtd_info *mtd) · 398 unmodified lines
3413	this->boundary[die] = bdry & FLEXONENAND_PI_MASK;	3413	this->boundary[die] = bdry & FLEXONENAND_PI_MASK;
3414		3414
3415	this->command(mtd, ONENAND_CMD_RESET, 0, 0);	3415	this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3416	this->wait(mtd, FL_RESETING);	3416	this->wait(mtd, FL_RESETTING);
3417		3417
3418	printk(KERN_INFO "Die %d boundary: %d%s\n", die,	3418	printk(KERN_INFO "Die %d boundary: %d%s\n", die,
3419	this->boundary[die], locked ? "(Locked)" : "(Unlocked)");	3419	this->boundary[die], locked ? "(Locked)" : "(Unlocked)");
@@ -3635,7 +3635,7 @@ static int flexonenand_set_boundary(struct mtd_info *mtd, int die, · 215 unmodified lines
3635	ret = this->wait(mtd, FL_WRITING);	3635	ret = this->wait(mtd, FL_WRITING);
3636	out:	3636	out:
3637	this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);	3637	this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
3638	this->wait(mtd, FL_RESETING);	3638	this->wait(mtd, FL_RESETTING);
3639	if (!ret)	3639	if (!ret)
3640	/* Recalculate device size on boundary change*/	3640	/* Recalculate device size on boundary change*/
3641	flexonenand_get_size(mtd);	3641	flexonenand_get_size(mtd);
@@ -3671,7 +3671,7 @@ static int onenand_chip_probe(struct mtd_info *mtd) · 29 unmodified lines
3671	/* Reset OneNAND to read default register values */	3671	/* Reset OneNAND to read default register values */
3672	this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);	3672	this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);
3673	/* Wait reset */	3673	/* Wait reset */
3674	this->wait(mtd, FL_RESETING);	3674	this->wait(mtd, FL_RESETTING);
3675		3675
3676	/* Restore system configuration 1 */	3676	/* Restore system configuration 1 */
3677	this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);	3677	this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);

drivers/mtd/nand/onenand/samsung_mtd.c+4−4

 normal:
 	if (count != mtd->writesize) {
 		/* Copy the bufferram to memory to prevent unaligned access */
-		memcpy(this->page_buf, p, mtd->writesize);
+		memcpy_fromio(this->page_buf, p, mtd->writesize);
-		p = this->page_buf + offset;
+		memcpy(buffer, this->page_buf + offset, count);
+	} else {
+		memcpy_fromio(buffer, p, count);
 	}
-	memcpy(buffer, p, count);
 	return 0;
 }

drivers/mtd/nand/raw/cadence-nand-controller.c+6−7

 /* Prepare CDMA descriptor. */
 static void
 cadence_nand_cdma_desc_prepare(struct cdns_nand_ctrl *cdns_ctrl,
-			       char nf_mem, u32 flash_ptr, char *mem_ptr,
+			       char nf_mem, u32 flash_ptr, dma_addr_t mem_ptr,
-			       char *ctrl_data_ptr, u16 ctype)
+				   dma_addr_t ctrl_data_ptr, u16 ctype)
 {
 	struct cadence_nand_cdma_desc *cdma_desc = cdns_ctrl->cdma_desc;
 	cdma_desc->command_flags |= CDMA_CF_DMA_MASTER;
 	cdma_desc->command_flags  |= CDMA_CF_INT;
-	cdma_desc->memory_pointer = (uintptr_t)mem_ptr;
+	cdma_desc->memory_pointer = mem_ptr;
 	cdma_desc->status = 0;
 	cdma_desc->sync_flag_pointer = 0;
 	cdma_desc->sync_arguments = 0;
 	cdma_desc->command_type = ctype;
-	cdma_desc->ctrl_data_ptr = (uintptr_t)ctrl_data_ptr;
+	cdma_desc->ctrl_data_ptr = ctrl_data_ptr;
 }
 static u8 cadence_nand_check_desc_error(struct cdns_nand_ctrl *cdns_ctrl,
 	}
 	cadence_nand_cdma_desc_prepare(cdns_ctrl, chip_nr, page,
-				       (void *)dma_buf, (void *)dma_ctrl_dat,
+				       dma_buf, dma_ctrl_dat, ctype);
-				       ctype);
 	status = cadence_nand_cdma_send_and_wait(cdns_ctrl, thread_nr);
 	cadence_nand_cdma_desc_prepare(cdns_ctrl,
 				       cdns_chip->cs[chip->cur_cs],
-				       page, NULL, NULL,
+				       page, 0, 0,
 				       CDMA_CT_ERASE);
 	status = cadence_nand_cdma_send_and_wait(cdns_ctrl, thread_nr);
 	if (status) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c+36−2

@@ -37,6 +37,7 @@ · 36 unmodified lines
37	/* Max ECC buffer length */	37	/* Max ECC buffer length */
38	#define FMC2_MAX_ECC_BUF_LEN (FMC2_BCHDSRS_LEN * FMC2_MAX_SG)	38	#define FMC2_MAX_ECC_BUF_LEN (FMC2_BCHDSRS_LEN * FMC2_MAX_SG)
39		39
		40	#define FMC2_TIMEOUT_US 1000
40	#define FMC2_TIMEOUT_MS 1000	41	#define FMC2_TIMEOUT_MS 1000
41		42
42	/* Timings */	43	/* Timings */
@@ -53,6 +54,8 @@ · 10 unmodified lines
53	#define FMC2_PMEM 0x88	54	#define FMC2_PMEM 0x88
54	#define FMC2_PATT 0x8c	55	#define FMC2_PATT 0x8c
55	#define FMC2_HECCR 0x94	56	#define FMC2_HECCR 0x94
		57	#define FMC2_ISR 0x184
		58	#define FMC2_ICR 0x188
56	#define FMC2_CSQCR 0x200	59	#define FMC2_CSQCR 0x200
57	#define FMC2_CSQCFGR1 0x204	60	#define FMC2_CSQCFGR1 0x204
58	#define FMC2_CSQCFGR2 0x208	61	#define FMC2_CSQCFGR2 0x208
@@ -118,6 +121,12 @@ · 59 unmodified lines
118	#define FMC2_PATT_ATTHIZ(x) (((x) & 0xff) << 24)	121	#define FMC2_PATT_ATTHIZ(x) (((x) & 0xff) << 24)
119	#define FMC2_PATT_DEFAULT 0x0a0a0a0a	122	#define FMC2_PATT_DEFAULT 0x0a0a0a0a
120		123
		124	/* Register: FMC2_ISR */
		125	#define FMC2_ISR_IHLF BIT(1)
		126
		127	/* Register: FMC2_ICR */
		128	#define FMC2_ICR_CIHLF BIT(1)
		129
121	/* Register: FMC2_CSQCR */	130	/* Register: FMC2_CSQCR */
122	#define FMC2_CSQCR_CSQSTART BIT(0)	131	#define FMC2_CSQCR_CSQSTART BIT(0)
123		132
@@ -1322,6 +1331,31 @@ static void stm32_fmc2_write_data(struct nand_chip chip, const void buf, · 1198 unmodified lines
1322	stm32_fmc2_set_buswidth_16(fmc2, true);	1331	stm32_fmc2_set_buswidth_16(fmc2, true);
1323	}	1332	}
1324		1333
		1334	static int stm32_fmc2_waitrdy(struct nand_chip *chip, unsigned long timeout_ms)
		1335	{
		1336	struct stm32_fmc2_nfc *fmc2 = to_stm32_nfc(chip->controller);
		1337	const struct nand_sdr_timings *timings;
		1338	u32 isr, sr;
		1339
		1340	/* Check if there is no pending requests to the NAND flash */
		1341	if (readl_relaxed_poll_timeout_atomic(fmc2->io_base + FMC2_SR, sr,
		1342	sr & FMC2_SR_NWRF, 1,
		1343	FMC2_TIMEOUT_US))
		1344	dev_warn(fmc2->dev, "Waitrdy timeout\n");
		1345
		1346	/* Wait tWB before R/B# signal is low */
		1347	timings = nand_get_sdr_timings(&chip->data_interface);
		1348	ndelay(PSEC_TO_NSEC(timings->tWB_max));
		1349
		1350	/* R/B# signal is low, clear high level flag */
		1351	writel_relaxed(FMC2_ICR_CIHLF, fmc2->io_base + FMC2_ICR);
		1352
		1353	/* Wait R/B# signal is high */
		1354	return readl_relaxed_poll_timeout_atomic(fmc2->io_base + FMC2_ISR,
		1355	isr, isr & FMC2_ISR_IHLF,
		1356	5, 1000 * timeout_ms);
		1357	}
		1358
1325	static int stm32_fmc2_exec_op(struct nand_chip *chip,	1359	static int stm32_fmc2_exec_op(struct nand_chip *chip,
1326	const struct nand_operation *op,	1360	const struct nand_operation *op,
1327	bool check_only)	1361	bool check_only)
@@ -1366,8 +1400,8 @@ static int stm32_fmc2_exec_op(struct nand_chip *chip, · 38 unmodified lines
1366	break;	1400	break;
1367		1401
1368	case NAND_OP_WAITRDY_INSTR:	1402	case NAND_OP_WAITRDY_INSTR:
1369	ret = nand_soft_waitrdy(chip,	1403	ret = stm32_fmc2_waitrdy(chip,
1370	instr->ctx.waitrdy.timeout_ms);	1404	instr->ctx.waitrdy.timeout_ms);
1371	break;	1405	break;
1372	}	1406	}
1373	}	1407	}

drivers/mtd/sm_ftl.c+2−1

@@ -247,7 +247,8 @@ static int sm_read_sector(struct sm_ftl *ftl, · 246 unmodified lines
247		247
248	/* FTL can contain -1 entries that are by default filled with bits */	248	/* FTL can contain -1 entries that are by default filled with bits */
249	if (block == -1) {	249	if (block == -1) {
250	memset(buffer, 0xFF, SM_SECTOR_SIZE);	250	if (buffer)
		251	memset(buffer, 0xFF, SM_SECTOR_SIZE);
251	return 0;	252	return 0;
252	}	253	}
253		254

drivers/mtd/spi-nor/spi-nor.c+1−0

@@ -4596,6 +4596,7 @@ static void sst_set_default_init(struct spi_nor *nor) · 4595 unmodified lines
4596	static void st_micron_set_default_init(struct spi_nor *nor)	4596	static void st_micron_set_default_init(struct spi_nor *nor)
4597	{	4597	{
4598	nor->flags \|= SNOR_F_HAS_LOCK;	4598	nor->flags \|= SNOR_F_HAS_LOCK;
		4599	nor->flags &= ~SNOR_F_HAS_16BIT_SR;
4599	nor->params.quad_enable = NULL;	4600	nor->params.quad_enable = NULL;
4600	nor->params.set_4byte = st_micron_set_4byte;	4601	nor->params.set_4byte = st_micron_set_4byte;
4601	}	4602	}

drivers/net/can/m_can/tcan4x5x.c+53−10

@@ -102,6 +102,7 @@ · 101 unmodified lines
102	#define TCAN4X5X_MODE_NORMAL BIT(7)	102	#define TCAN4X5X_MODE_NORMAL BIT(7)
103		103
104	#define TCAN4X5X_DISABLE_WAKE_MSK (BIT(31) \| BIT(30))	104	#define TCAN4X5X_DISABLE_WAKE_MSK (BIT(31) \| BIT(30))
		105	#define TCAN4X5X_DISABLE_INH_MSK BIT(9)
105		106
106	#define TCAN4X5X_SW_RESET BIT(2)	107	#define TCAN4X5X_SW_RESET BIT(2)
107		108
@@ -166,6 +167,28 @@ static void tcan4x5x_check_wake(struct tcan4x5x_priv *priv) · 58 unmodified lines
166	}	167	}
167	}	168	}
168		169
		170	static int tcan4x5x_reset(struct tcan4x5x_priv *priv)
		171	{
		172	int ret = 0;
		173
		174	if (priv->reset_gpio) {
		175	gpiod_set_value(priv->reset_gpio, 1);
		176
		177	/* tpulse_width minimum 30us */
		178	usleep_range(30, 100);
		179	gpiod_set_value(priv->reset_gpio, 0);
		180	} else {
		181	ret = regmap_write(priv->regmap, TCAN4X5X_CONFIG,
		182	TCAN4X5X_SW_RESET);
		183	if (ret)
		184	return ret;
		185	}
		186
		187	usleep_range(700, 1000);
		188
		189	return ret;
		190	}
		191
169	static int regmap_spi_gather_write(void context, const void reg,	192	static int regmap_spi_gather_write(void context, const void reg,
170	size_t reg_len, const void *val,	193	size_t reg_len, const void *val,
171	size_t val_len)	194	size_t val_len)
@@ -348,14 +371,23 @@ static int tcan4x5x_disable_wake(struct m_can_classdev *cdev) · 176 unmodified lines
348	TCAN4X5X_DISABLE_WAKE_MSK, 0x00);	371	TCAN4X5X_DISABLE_WAKE_MSK, 0x00);
349	}	372	}
350		373
		374	static int tcan4x5x_disable_state(struct m_can_classdev *cdev)
		375	{
		376	struct tcan4x5x_priv *tcan4x5x = cdev->device_data;
		377
		378	return regmap_update_bits(tcan4x5x->regmap, TCAN4X5X_CONFIG,
		379	TCAN4X5X_DISABLE_INH_MSK, 0x01);
		380	}
		381
351	static int tcan4x5x_parse_config(struct m_can_classdev *cdev)	382	static int tcan4x5x_parse_config(struct m_can_classdev *cdev)
352	{	383	{
353	struct tcan4x5x_priv *tcan4x5x = cdev->device_data;	384	struct tcan4x5x_priv *tcan4x5x = cdev->device_data;
		385	int ret;
354		386
355	tcan4x5x->device_wake_gpio = devm_gpiod_get(cdev->dev, "device-wake",	387	tcan4x5x->device_wake_gpio = devm_gpiod_get(cdev->dev, "device-wake",
356	GPIOD_OUT_HIGH);	388	GPIOD_OUT_HIGH);
357	if (IS_ERR(tcan4x5x->device_wake_gpio)) {	389	if (IS_ERR(tcan4x5x->device_wake_gpio)) {
358	if (PTR_ERR(tcan4x5x->power) == -EPROBE_DEFER)	390	if (PTR_ERR(tcan4x5x->device_wake_gpio) == -EPROBE_DEFER)
359	return -EPROBE_DEFER;	391	return -EPROBE_DEFER;
360		392
361	tcan4x5x_disable_wake(cdev);	393	tcan4x5x_disable_wake(cdev);
@@ -366,18 +398,17 @@ static int tcan4x5x_parse_config(struct m_can_classdev *cdev) · 4 unmodified lines
366	if (IS_ERR(tcan4x5x->reset_gpio))	398	if (IS_ERR(tcan4x5x->reset_gpio))
367	tcan4x5x->reset_gpio = NULL;	399	tcan4x5x->reset_gpio = NULL;
368		400
369	usleep_range(700, 1000);	401	ret = tcan4x5x_reset(tcan4x5x);
		402	if (ret)
		403	return ret;
370		404
371	tcan4x5x->device_state_gpio = devm_gpiod_get_optional(cdev->dev,	405	tcan4x5x->device_state_gpio = devm_gpiod_get_optional(cdev->dev,
372	"device-state",	406	"device-state",
373	GPIOD_IN);	407	GPIOD_IN);
374	if (IS_ERR(tcan4x5x->device_state_gpio))	408	if (IS_ERR(tcan4x5x->device_state_gpio)) {
375	tcan4x5x->device_state_gpio = NULL;	409	tcan4x5x->device_state_gpio = NULL;
376		410	tcan4x5x_disable_state(cdev);
377	tcan4x5x->power = devm_regulator_get_optional(cdev->dev,	411	}
378	"vsup");
379	if (PTR_ERR(tcan4x5x->power) == -EPROBE_DEFER)
380	return -EPROBE_DEFER;
381		412
382	return 0;	413	return 0;
383	}	414	}
@@ -412,6 +443,12 @@ static int tcan4x5x_can_probe(struct spi_device *spi) · 28 unmodified lines
412	if (!priv)	443	if (!priv)
413	return -ENOMEM;	444	return -ENOMEM;
414		445
		446	priv->power = devm_regulator_get_optional(&spi->dev, "vsup");
		447	if (PTR_ERR(priv->power) == -EPROBE_DEFER)
		448	return -EPROBE_DEFER;
		449	else
		450	priv->power = NULL;
		451
415	mcan_class->device_data = priv;	452	mcan_class->device_data = priv;
416		453
417	m_can_class_get_clocks(mcan_class);	454	m_can_class_get_clocks(mcan_class);
@@ -451,11 +488,17 @@ static int tcan4x5x_can_probe(struct spi_device *spi) · 33 unmodified lines
451	priv->regmap = devm_regmap_init(&spi->dev, &tcan4x5x_bus,	488	priv->regmap = devm_regmap_init(&spi->dev, &tcan4x5x_bus,
452	&spi->dev, &tcan4x5x_regmap);	489	&spi->dev, &tcan4x5x_regmap);
453		490
454	ret = tcan4x5x_parse_config(mcan_class);	491	ret = tcan4x5x_power_enable(priv->power, 1);
455	if (ret)	492	if (ret)
456	goto out_clk;	493	goto out_clk;
457		494
458	tcan4x5x_power_enable(priv->power, 1);	495	ret = tcan4x5x_parse_config(mcan_class);
		496	if (ret)
		497	goto out_power;
		498
		499	ret = tcan4x5x_init(mcan_class);
		500	if (ret)
		501	goto out_power;
459		502
460	ret = m_can_class_register(mcan_class);	503	ret = m_can_class_register(mcan_class);
461	if (ret)	504	if (ret)

drivers/net/can/mscan/mscan.c+10−11

 	struct net_device *dev = napi->dev;
 	struct mscan_regs __iomem *regs = priv->reg_base;
 	struct net_device_stats *stats = &dev->stats;
-	int npackets = 0;
+	int work_done = 0;
-	int ret = 1;
 	struct sk_buff *skb;
 	struct can_frame *frame;
 	u8 canrflg;
-	while (npackets < quota) {
+	while (work_done < quota) {
 		canrflg = in_8(&regs->canrflg);
 		if (!(canrflg & (MSCAN_RXF | MSCAN_ERR_IF)))
 			break;
 		stats->rx_packets++;
 		stats->rx_bytes += frame->can_dlc;
-		npackets++;
+		work_done++;
 		netif_receive_skb(skb);
 	}
-	if (!(in_8(&regs->canrflg) & (MSCAN_RXF | MSCAN_ERR_IF))) {
+	if (work_done < quota) {
-		napi_complete(&priv->napi);
+		if (likely(napi_complete_done(&priv->napi, work_done))) {
-		clear_bit(F_RX_PROGRESS, &priv->flags);
+			clear_bit(F_RX_PROGRESS, &priv->flags);
-		if (priv->can.state < CAN_STATE_BUS_OFF)
+			if (priv->can.state < CAN_STATE_BUS_OFF)
-			out_8(&regs->canrier, priv->shadow_canrier);
+				out_8(&regs->canrier, priv->shadow_canrier);
-		ret = 0;
+		}
 	}
-	return ret;
+	return work_done;
 }
 static irqreturn_t mscan_isr(int irq, void *dev_id)

drivers/net/can/usb/gs_usb.c+2−2

@@ -918,7 +918,7 @@ static int gs_usb_probe(struct usb_interface *intf, · 917 unmodified lines
918	GS_USB_BREQ_HOST_FORMAT,	918	GS_USB_BREQ_HOST_FORMAT,
919	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,	919	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,
920	1,	920	1,
921	intf->altsetting[0].desc.bInterfaceNumber,	921	intf->cur_altsetting->desc.bInterfaceNumber,
922	hconf,	922	hconf,
923	sizeof(*hconf),	923	sizeof(*hconf),
924	1000);	924	1000);
@@ -941,7 +941,7 @@ static int gs_usb_probe(struct usb_interface *intf, · 16 unmodified lines
941	GS_USB_BREQ_DEVICE_CONFIG,	941	GS_USB_BREQ_DEVICE_CONFIG,
942	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,	942	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,
943	1,	943	1,
944	intf->altsetting[0].desc.bInterfaceNumber,	944	intf->cur_altsetting->desc.bInterfaceNumber,
945	dconf,	945	dconf,
946	sizeof(*dconf),	946	sizeof(*dconf),
947	1000);	947	1000);

drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c+1−1

@@ -1590,7 +1590,7 @@ static int kvaser_usb_hydra_setup_endpoints(struct kvaser_usb *dev) · 1589 unmodified lines
1590	struct usb_endpoint_descriptor *ep;	1590	struct usb_endpoint_descriptor *ep;
1591	int i;	1591	int i;
1592		1592
1593	iface_desc = &dev->intf->altsetting[0];	1593	iface_desc = dev->intf->cur_altsetting;
1594		1594
1595	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {	1595	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1596	ep = &iface_desc->endpoint[i].desc;	1596	ep = &iface_desc->endpoint[i].desc;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c+1−1

@@ -1310,7 +1310,7 @@ static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev) · 1309 unmodified lines
1310	struct usb_endpoint_descriptor *endpoint;	1310	struct usb_endpoint_descriptor *endpoint;
1311	int i;	1311	int i;
1312		1312
1313	iface_desc = &dev->intf->altsetting[0];	1313	iface_desc = dev->intf->cur_altsetting;
1314		1314
1315	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {	1315	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1316	endpoint = &iface_desc->endpoint[i].desc;	1316	endpoint = &iface_desc->endpoint[i].desc;

drivers/net/dsa/bcm_sf2_cfp.c+3−3

@@ -358,7 +358,7 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port, · 357 unmodified lines
358	return -EINVAL;	358	return -EINVAL;
359	}	359	}
360		360
361	ip_frag = be32_to_cpu(fs->m_ext.data[0]);	361	ip_frag = !!(be32_to_cpu(fs->h_ext.data[0]) & 1);
362		362
363	/* Locate the first rule available */	363	/* Locate the first rule available */
364	if (fs->location == RX_CLS_LOC_ANY)	364	if (fs->location == RX_CLS_LOC_ANY)
@@ -569,7 +569,7 @@ static int bcm_sf2_cfp_rule_cmp(struct bcm_sf2_priv *priv, int port, · 204 unmodified lines
569		569
570	if (rule->fs.flow_type != fs->flow_type \|\|	570	if (rule->fs.flow_type != fs->flow_type \|\|
571	rule->fs.ring_cookie != fs->ring_cookie \|\|	571	rule->fs.ring_cookie != fs->ring_cookie \|\|
572	rule->fs.m_ext.data[0] != fs->m_ext.data[0])	572	rule->fs.h_ext.data[0] != fs->h_ext.data[0])
573	continue;	573	continue;
574		574
575	switch (fs->flow_type & ~FLOW_EXT) {	575	switch (fs->flow_type & ~FLOW_EXT) {
@@ -621,7 +621,7 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, · 45 unmodified lines
621	return -EINVAL;	621	return -EINVAL;
622	}	622	}
623		623
624	ip_frag = be32_to_cpu(fs->m_ext.data[0]);	624	ip_frag = !!(be32_to_cpu(fs->h_ext.data[0]) & 1);
625		625
626	layout = &udf_tcpip6_layout;	626	layout = &udf_tcpip6_layout;
627	slice_num = bcm_sf2_get_slice_number(layout, 0);	627	slice_num = bcm_sf2_get_slice_number(layout, 0);

drivers/net/dsa/mv88e6xxx/global1.c+5−0

 {
 	u16 ptr = MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST;
+	/* Use the default high priority for management frames sent to
+	 * the CPU.
+	 */
+	port |= MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST_MGMTPRI;
 	return mv88e6390_g1_monitor_write(chip, ptr, port);
 }

drivers/net/dsa/mv88e6xxx/global1.h+1−0

@@ -211,6 +211,7 @@ · 210 unmodified lines
211	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_INGRESS_DEST 0x2000	211	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_INGRESS_DEST 0x2000
212	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_EGRESS_DEST 0x2100	212	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_EGRESS_DEST 0x2100
213	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST 0x3000	213	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST 0x3000
		214	#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST_MGMTPRI 0x00e0
214	#define MV88E6390_G1_MONITOR_MGMT_CTL_DATA_MASK 0x00ff	215	#define MV88E6390_G1_MONITOR_MGMT_CTL_DATA_MASK 0x00ff
215		216
216	/* Offset 0x1C: Global Control 2 */	217	/* Offset 0x1C: Global Control 2 */

drivers/net/dsa/mv88e6xxx/port.c+6−6

@@ -393,7 +393,7 @@ phy_interface_t mv88e6390x_port_max_speed_mode(int port) · 392 unmodified lines
393	}	393	}
394		394
395	static int mv88e6xxx_port_set_cmode(struct mv88e6xxx_chip *chip, int port,	395	static int mv88e6xxx_port_set_cmode(struct mv88e6xxx_chip *chip, int port,
396	phy_interface_t mode)	396	phy_interface_t mode, bool force)
397	{	397	{
398	u8 lane;	398	u8 lane;
399	u16 cmode;	399	u16 cmode;
@@ -427,8 +427,8 @@ static int mv88e6xxx_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 27 unmodified lines
427	cmode = 0;	427	cmode = 0;
428	}	428	}
429		429
430	/* cmode doesn't change, nothing to do for us */	430	/* cmode doesn't change, nothing to do for us unless forced */
431	if (cmode == chip->ports[port].cmode)	431	if (cmode == chip->ports[port].cmode && !force)
432	return 0;	432	return 0;
433		433
434	lane = mv88e6xxx_serdes_get_lane(chip, port);	434	lane = mv88e6xxx_serdes_get_lane(chip, port);
@@ -484,7 +484,7 @@ int mv88e6390x_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 49 unmodified lines
484	if (port != 9 && port != 10)	484	if (port != 9 && port != 10)
485	return -EOPNOTSUPP;	485	return -EOPNOTSUPP;
486		486
487	return mv88e6xxx_port_set_cmode(chip, port, mode);	487	return mv88e6xxx_port_set_cmode(chip, port, mode, false);
488	}	488	}
489		489
490	int mv88e6390_port_set_cmode(struct mv88e6xxx_chip *chip, int port,	490	int mv88e6390_port_set_cmode(struct mv88e6xxx_chip *chip, int port,
@@ -504,7 +504,7 @@ int mv88e6390_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 13 unmodified lines
504	break;	504	break;
505	}	505	}
506		506
507	return mv88e6xxx_port_set_cmode(chip, port, mode);	507	return mv88e6xxx_port_set_cmode(chip, port, mode, false);
508	}	508	}
509		509
510	static int mv88e6341_port_set_cmode_writable(struct mv88e6xxx_chip *chip,	510	static int mv88e6341_port_set_cmode_writable(struct mv88e6xxx_chip *chip,
@@ -555,7 +555,7 @@ int mv88e6341_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 44 unmodified lines
555	if (err)	555	if (err)
556	return err;	556	return err;
557		557
558	return mv88e6xxx_port_set_cmode(chip, port, mode);	558	return mv88e6xxx_port_set_cmode(chip, port, mode, true);
559	}	559	}
560		560
561	int mv88e6185_port_get_cmode(struct mv88e6xxx_chip chip, int port, u8 cmode)	561	int mv88e6185_port_get_cmode(struct mv88e6xxx_chip chip, int port, u8 cmode)

drivers/net/dsa/sja1105/sja1105_main.c+5−5

 	if (enabled) {
 		/* Enable VLAN filtering. */
-		tpid  = ETH_P_8021AD;
+		tpid  = ETH_P_8021Q;
-		tpid2 = ETH_P_8021Q;
+		tpid2 = ETH_P_8021AD;
 	} else {
 		/* Disable VLAN filtering. */
 		tpid  = ETH_P_SJA1105;
 	table = &priv->static_config.tables[BLK_IDX_GENERAL_PARAMS];
 	general_params = table->entries;
-	/* EtherType used to identify outer tagged (S-tag) VLAN traffic */
-	general_params->tpid = tpid;
 	/* EtherType used to identify inner tagged (C-tag) VLAN traffic */
+	general_params->tpid = tpid;
+	/* EtherType used to identify outer tagged (S-tag) VLAN traffic */
 	general_params->tpid2 = tpid2;
 	/* When VLAN filtering is on, we need to at least be able to
 	 * decode management traffic through the "backup plan".
 	if (!clone)
 		goto out;
-	sja1105_ptp_txtstamp_skb(ds, slot, clone);
+	sja1105_ptp_txtstamp_skb(ds, port, clone);
 out:
 	mutex_unlock(&priv->mgmt_lock);

drivers/net/dsa/sja1105/sja1105_ptp.c+3−3

@@ -234,7 +234,7 @@ int sja1105_ptp_commit(struct dsa_switch ds, struct sja1105_ptp_cmd cmd, · 233 unmodified lines
234	if (rw == SPI_WRITE)	234	if (rw == SPI_WRITE)
235	priv->info->ptp_cmd_packing(buf, cmd, PACK);	235	priv->info->ptp_cmd_packing(buf, cmd, PACK);
236		236
237	rc = sja1105_xfer_buf(priv, SPI_WRITE, regs->ptp_control, buf,	237	rc = sja1105_xfer_buf(priv, rw, regs->ptp_control, buf,
238	SJA1105_SIZE_PTP_CMD);	238	SJA1105_SIZE_PTP_CMD);
239		239
240	if (rw == SPI_READ)	240	if (rw == SPI_READ)
@@ -659,7 +659,7 @@ void sja1105_ptp_clock_unregister(struct dsa_switch *ds) · 418 unmodified lines
659	ptp_data->clock = NULL;	659	ptp_data->clock = NULL;
660	}	660	}
661		661
662	void sja1105_ptp_txtstamp_skb(struct dsa_switch *ds, int slot,	662	void sja1105_ptp_txtstamp_skb(struct dsa_switch *ds, int port,
663	struct sk_buff *skb)	663	struct sk_buff *skb)
664	{	664	{
665	struct sja1105_private *priv = ds->priv;	665	struct sja1105_private *priv = ds->priv;
@@ -679,7 +679,7 @@ void sja1105_ptp_txtstamp_skb(struct dsa_switch *ds, int slot, · 13 unmodified lines
679	goto out;	679	goto out;
680	}	680	}
681		681
682	rc = sja1105_ptpegr_ts_poll(ds, slot, &ts);	682	rc = sja1105_ptpegr_ts_poll(ds, port, &ts);
683	if (rc < 0) {	683	if (rc < 0) {
684	dev_err(ds->dev, "timed out polling for tstamp\n");	684	dev_err(ds->dev, "timed out polling for tstamp\n");
685	kfree_skb(skb);	685	kfree_skb(skb);

drivers/net/dsa/sja1105/sja1105_static_config.c+5−2

 	return size;
 }
+/* TPID and TPID2 are intentionally reversed so that semantic
+ * compatibility with E/T is kept.
+ */
 static size_t
 sja1105pqrs_general_params_entry_packing(void *buf, void *entry_ptr,
 					 enum packing_op op)
 	sja1105_packing(buf, &entry->mirr_port,   141, 139, size, op);
 	sja1105_packing(buf, &entry->vlmarker,    138, 107, size, op);
 	sja1105_packing(buf, &entry->vlmask,      106,  75, size, op);
-	sja1105_packing(buf, &entry->tpid,         74,  59, size, op);
+	sja1105_packing(buf, &entry->tpid2,        74,  59, size, op);
 	sja1105_packing(buf, &entry->ignore2stf,   58,  58, size, op);
-	sja1105_packing(buf, &entry->tpid2,        57,  42, size, op);
+	sja1105_packing(buf, &entry->tpid,         57,  42, size, op);
 	sja1105_packing(buf, &entry->queue_ts,     41,  41, size, op);
 	sja1105_packing(buf, &entry->egrmirrvid,   40,  29, size, op);
 	sja1105_packing(buf, &entry->egrmirrpcp,   28,  26, size, op);

drivers/net/dsa/sja1105/sja1105_tas.c+0−5

 	if (admin->cycle_time_extension)
 		return -ENOTSUPP;
-	if (!ns_to_sja1105_delta(admin->base_time)) {
-		dev_err(ds->dev, "A base time of zero is not hardware-allowed\n");
-		return -ERANGE;
-	}
 	for (i = 0; i < admin->num_entries; i++) {
 		s64 delta_ns = admin->entries[i].interval;
 		s64 delta_cycles = ns_to_sja1105_delta(delta_ns);

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

 	if (err < 0)
 		goto err_exit;
+	aq_nic_set_loopback(self);
 	err = self->aq_hw_ops->hw_start(self->aq_hw);
 	if (err < 0)
 		goto err_exit;
 	INIT_WORK(&self->service_task, aq_nic_service_task);
-	aq_nic_set_loopback(self);
 	timer_setup(&self->service_timer, aq_nic_service_timer_cb, 0);
 	aq_nic_service_timer_cb(&self->service_timer);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c+0−3

 	.rx_extract_ts           = hw_atl_b0_rx_extract_ts,
 	.extract_hwts            = hw_atl_b0_extract_hwts,
 	.hw_set_offload          = hw_atl_b0_hw_offload_set,
-	.hw_get_hw_stats         = hw_atl_utils_get_hw_stats,
-	.hw_get_fw_version       = hw_atl_utils_get_fw_version,
-	.hw_set_offload          = hw_atl_b0_hw_offload_set,
 	.hw_set_loopback         = hw_atl_b0_set_loopback,
 	.hw_set_fc               = hw_atl_b0_set_fc,
 };

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c+1−3

@@ -667,9 +667,7 @@ int hw_atl_utils_mpi_get_link_status(struct aq_hw_s *self) · 666 unmodified lines
667	u32 speed;	667	u32 speed;
668		668
669	mpi_state = hw_atl_utils_mpi_get_state(self);	669	mpi_state = hw_atl_utils_mpi_get_state(self);
670	speed = mpi_state & (FW2X_RATE_100M \| FW2X_RATE_1G \|	670	speed = mpi_state >> HW_ATL_MPI_SPEED_SHIFT;
671	FW2X_RATE_2G5 \| FW2X_RATE_5G \|
672	FW2X_RATE_10G);
673		671
674	if (!speed) {	672	if (!speed) {
675	link_status->mbps = 0U;	673	link_status->mbps = 0U;

drivers/net/ethernet/broadcom/b44.c+6−3

 	int ethaddr_bytes = ETH_ALEN;
 	memset(ppattern + offset, 0xff, magicsync);
-	for (j = 0; j < magicsync; j++)
+	for (j = 0; j < magicsync; j++) {
-		set_bit(len++, (unsigned long *) pmask);
+		pmask[len >> 3] |= BIT(len & 7);
+		len++;
+	}
 	for (j = 0; j < B44_MAX_PATTERNS; j++) {
 		if ((B44_PATTERN_SIZE - len) >= ETH_ALEN)
 		for (k = 0; k< ethaddr_bytes; k++) {
 			ppattern[offset + magicsync +
 				(j * ETH_ALEN) + k] = macaddr[k];
-			set_bit(len++, (unsigned long *) pmask);
+			pmask[len >> 3] |= BIT(len & 7);
+			len++;
 		}
 	}
 	return len - 1;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h+4−1

 	((MAX_MAC_CREDIT_E2 - GET_NUM_VFS_PER_PATH(bp) * VF_MAC_CREDIT_CNT) / \
 	 func_num + GET_NUM_VFS_PER_PF(bp) * VF_MAC_CREDIT_CNT)
+#define BNX2X_VFS_VLAN_CREDIT(bp)	\
+	(GET_NUM_VFS_PER_PATH(bp) * VF_VLAN_CREDIT_CNT)
 #define PF_VLAN_CREDIT_E2(bp, func_num)					 \
-	((MAX_MAC_CREDIT_E2 - GET_NUM_VFS_PER_PATH(bp) * VF_VLAN_CREDIT_CNT) / \
+	((MAX_VLAN_CREDIT_E2 - 1 - BNX2X_VFS_VLAN_CREDIT(bp)) /	\
 	 func_num + GET_NUM_VFS_PER_PF(bp) * VF_VLAN_CREDIT_CNT)
 #endif /* BNX2X_SP_VERBS */

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

 	mgmt->rate = 0;
 	mgmt->hw.init = &init;
-	*tx_clk = clk_register(NULL, &mgmt->hw);
+	*tx_clk = devm_clk_register(&pdev->dev, &mgmt->hw);
 	if (IS_ERR(*tx_clk))
 		return PTR_ERR(*tx_clk);
 err_disable_clocks:
 	clk_disable_unprepare(tx_clk);
-	clk_unregister(tx_clk);
 	clk_disable_unprepare(hclk);
 	clk_disable_unprepare(pclk);
 	clk_disable_unprepare(rx_clk);
 		pm_runtime_dont_use_autosuspend(&pdev->dev);
 		if (!pm_runtime_suspended(&pdev->dev)) {
 			clk_disable_unprepare(bp->tx_clk);
-			clk_unregister(bp->tx_clk);
 			clk_disable_unprepare(bp->hclk);
 			clk_disable_unprepare(bp->pclk);
 			clk_disable_unprepare(bp->rx_clk);

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h+1−0

@@ -504,6 +504,7 @@ struct link_config { · 503 unmodified lines
504		504
505	enum cc_pause requested_fc; /* flow control user has requested */	505	enum cc_pause requested_fc; /* flow control user has requested */
506	enum cc_pause fc; /* actual link flow control */	506	enum cc_pause fc; /* actual link flow control */
		507	enum cc_pause advertised_fc; /* actual advertised flow control */
507		508
508	enum cc_fec requested_fec; /* Forward Error Correction: */	509	enum cc_fec requested_fec; /* Forward Error Correction: */
509	enum cc_fec fec; /* requested and actual in use */	510	enum cc_fec fec; /* requested and actual in use */

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

@@ -807,8 +807,8 @@ static void get_pauseparam(struct net_device *dev, · 806 unmodified lines
807	struct port_info *p = netdev_priv(dev);	807	struct port_info *p = netdev_priv(dev);
808		808
809	epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;	809	epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
810	epause->rx_pause = (p->link_cfg.fc & PAUSE_RX) != 0;	810	epause->rx_pause = (p->link_cfg.advertised_fc & PAUSE_RX) != 0;
811	epause->tx_pause = (p->link_cfg.fc & PAUSE_TX) != 0;	811	epause->tx_pause = (p->link_cfg.advertised_fc & PAUSE_TX) != 0;
812	}	812	}
813		813
814	static int set_pauseparam(struct net_device *dev,	814	static int set_pauseparam(struct net_device *dev,

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c+13−8

 		if (cc_pause & PAUSE_TX)
 			fw_pause |= FW_PORT_CAP32_802_3_PAUSE;
 		else
-			fw_pause |= FW_PORT_CAP32_802_3_ASM_DIR;
+			fw_pause |= FW_PORT_CAP32_802_3_ASM_DIR |
+				    FW_PORT_CAP32_802_3_PAUSE;
 	} else if (cc_pause & PAUSE_TX) {
 		fw_pause |= FW_PORT_CAP32_802_3_ASM_DIR;
 	}
 void t4_handle_get_port_info(struct port_info *pi, const __be64 *rpl)
 {
 	const struct fw_port_cmd *cmd = (const void *)rpl;
-	int action = FW_PORT_CMD_ACTION_G(be32_to_cpu(cmd->action_to_len16));
+	fw_port_cap32_t pcaps, acaps, lpacaps, linkattr;
-	struct adapter *adapter = pi->adapter;
 	struct link_config *lc = &pi->link_cfg;
-	int link_ok, linkdnrc;
+	struct adapter *adapter = pi->adapter;
-	enum fw_port_type port_type;
+	unsigned int speed, fc, fec, adv_fc;
 	enum fw_port_module_type mod_type;
-	unsigned int speed, fc, fec;
+	int action, link_ok, linkdnrc;
-	fw_port_cap32_t pcaps, acaps, lpacaps, linkattr;
+	enum fw_port_type port_type;
 	/* Extract the various fields from the Port Information message.
 	 */
+	action = FW_PORT_CMD_ACTION_G(be32_to_cpu(cmd->action_to_len16));
 	switch (action) {
 	case FW_PORT_ACTION_GET_PORT_INFO: {
 		u32 lstatus = be32_to_cpu(cmd->u.info.lstatus_to_modtype);
 	}
 	fec = fwcap_to_cc_fec(acaps);
+	adv_fc = fwcap_to_cc_pause(acaps);
 	fc = fwcap_to_cc_pause(linkattr);
 	speed = fwcap_to_speed(linkattr);
 	}
 	if (link_ok != lc->link_ok || speed != lc->speed ||
-	    fc != lc->fc || fec != lc->fec) {	/* something changed */
+	    fc != lc->fc || adv_fc != lc->advertised_fc ||
+	    fec != lc->fec) {
+		/* something changed */
 		if (!link_ok && lc->link_ok) {
 			lc->link_down_rc = linkdnrc;
 			dev_warn_ratelimited(adapter->pdev_dev,
 		}
 		lc->link_ok = link_ok;
 		lc->speed = speed;
+		lc->advertised_fc = adv_fc;
 		lc->fc = fc;
 		lc->fec = fec;

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c+2−2

@@ -1690,8 +1690,8 @@ static void cxgb4vf_get_pauseparam(struct net_device *dev, · 1689 unmodified lines
1690	struct port_info *pi = netdev_priv(dev);	1690	struct port_info *pi = netdev_priv(dev);
1691		1691
1692	pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;	1692	pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
1693	pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0;	1693	pauseparam->rx_pause = (pi->link_cfg.advertised_fc & PAUSE_RX) != 0;
1694	pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0;	1694	pauseparam->tx_pause = (pi->link_cfg.advertised_fc & PAUSE_TX) != 0;
1695	}	1695	}
1696		1696
1697	/*	1697	/*

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_common.h+1−0

@@ -135,6 +135,7 @@ struct link_config { · 134 unmodified lines
135		135
136	enum cc_pause requested_fc; /* flow control user has requested */	136	enum cc_pause requested_fc; /* flow control user has requested */
137	enum cc_pause fc; /* actual link flow control */	137	enum cc_pause fc; /* actual link flow control */
		138	enum cc_pause advertised_fc; /* actual advertised flow control */
138		139
139	enum cc_fec auto_fec; /* Forward Error Correction: */	140	enum cc_fec auto_fec; /* Forward Error Correction: */
140	enum cc_fec requested_fec; /* "automatic" (IEEE 802.3), */	141	enum cc_fec requested_fec; /* "automatic" (IEEE 802.3), */

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c+11−7

 static void t4vf_handle_get_port_info(struct port_info *pi,
 				      const struct fw_port_cmd *cmd)
 {
-	int action = FW_PORT_CMD_ACTION_G(be32_to_cpu(cmd->action_to_len16));
+	fw_port_cap32_t pcaps, acaps, lpacaps, linkattr;
-	struct adapter *adapter = pi->adapter;
 	struct link_config *lc = &pi->link_cfg;
-	int link_ok, linkdnrc;
+	struct adapter *adapter = pi->adapter;
-	enum fw_port_type port_type;
+	unsigned int speed, fc, fec, adv_fc;
 	enum fw_port_module_type mod_type;
-	unsigned int speed, fc, fec;
+	int action, link_ok, linkdnrc;
-	fw_port_cap32_t pcaps, acaps, lpacaps, linkattr;
+	enum fw_port_type port_type;
 	/* Extract the various fields from the Port Information message. */
+	action = FW_PORT_CMD_ACTION_G(be32_to_cpu(cmd->action_to_len16));
 	switch (action) {
 	case FW_PORT_ACTION_GET_PORT_INFO: {
 		u32 lstatus = be32_to_cpu(cmd->u.info.lstatus_to_modtype);
 	}
 	fec = fwcap_to_cc_fec(acaps);
+	adv_fc = fwcap_to_cc_pause(acaps);
 	fc = fwcap_to_cc_pause(linkattr);
 	speed = fwcap_to_speed(linkattr);
 	}
 	if (link_ok != lc->link_ok || speed != lc->speed ||
-	    fc != lc->fc || fec != lc->fec) {	/* something changed */
+	    fc != lc->fc || adv_fc != lc->advertised_fc ||
+	    fec != lc->fec) {
+		/* something changed */
 		if (!link_ok && lc->link_ok) {
 			lc->link_down_rc = linkdnrc;
 			dev_warn_ratelimited(adapter->pdev_dev,
 		}
 		lc->link_ok = link_ok;
 		lc->speed = speed;
+		lc->advertised_fc = adv_fc;
 		lc->fc = fc;
 		lc->fec = fec;

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c+20−19

 	int page_offset;
 	unsigned int sz;
 	int *count_ptr;
-	int i;
+	int i, j;
 	vaddr = phys_to_virt(addr);
 	WARN_ON(!IS_ALIGNED((unsigned long)vaddr, SMP_CACHE_BYTES));
 		WARN_ON(!IS_ALIGNED((unsigned long)sg_vaddr,
 				    SMP_CACHE_BYTES));
+		dma_unmap_page(priv->rx_dma_dev, sg_addr,
+			       DPAA_BP_RAW_SIZE, DMA_FROM_DEVICE);
 		/* We may use multiple Rx pools */
 		dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
 		if (!dpaa_bp)
 			goto free_buffers;
-		count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
-		dma_unmap_page(priv->rx_dma_dev, sg_addr,
-			       DPAA_BP_RAW_SIZE, DMA_FROM_DEVICE);
 		if (!skb) {
 			sz = dpaa_bp->size +
 				SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 			skb_add_rx_frag(skb, i - 1, head_page, frag_off,
 					frag_len, dpaa_bp->size);
 		}
 		/* Update the pool count for the current {cpu x bpool} */
+		count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
 		(*count_ptr)--;
 		if (qm_sg_entry_is_final(&sgt[i]))
 	return skb;
 free_buffers:
-	/* compensate sw bpool counter changes */
-	for (i--; i >= 0; i--) {
-		dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
-		if (dpaa_bp) {
-			count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
-			(*count_ptr)++;
-		}
-	}
 	/* free all the SG entries */
-	for (i = 0; i < DPAA_SGT_MAX_ENTRIES ; i++) {
+	for (j = 0; j < DPAA_SGT_MAX_ENTRIES ; j++) {
-		sg_addr = qm_sg_addr(&sgt[i]);
+		sg_addr = qm_sg_addr(&sgt[j]);
 		sg_vaddr = phys_to_virt(sg_addr);
+		/* all pages 0..i were unmaped */
+		if (j > i)
+			dma_unmap_page(priv->rx_dma_dev, qm_sg_addr(&sgt[j]),
+				       DPAA_BP_RAW_SIZE, DMA_FROM_DEVICE);
 		free_pages((unsigned long)sg_vaddr, 0);
-		dpaa_bp = dpaa_bpid2pool(sgt[i].bpid);
+		/* counters 0..i-1 were decremented */
-		if (dpaa_bp) {
+		if (j >= i) {
-			count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
+			dpaa_bp = dpaa_bpid2pool(sgt[j].bpid);
-			(*count_ptr)--;
+			if (dpaa_bp) {
+				count_ptr = this_cpu_ptr(dpaa_bp->percpu_count);
+				(*count_ptr)--;
+			}
 		}
-		if (qm_sg_entry_is_final(&sgt[i]))
+		if (qm_sg_entry_is_final(&sgt[j]))
 			break;
 	}
 	/* free the SGT fragment */

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

 {
 	struct fec_enet_private *fep = netdev_priv(ndev);
 	u32 __iomem *theregs = (u32 __iomem *)fep->hwp;
+	struct device *dev = &fep->pdev->dev;
 	u32 *buf = (u32 *)regbuf;
 	u32 i, off;
+	int ret;
+	ret = pm_runtime_get_sync(dev);
+	if (ret < 0)
+		return;
 	regs->version = fec_enet_register_version;
 		off >>= 2;
 		buf[off] = readl(&theregs[off]);
 	}
+	pm_runtime_mark_last_busy(dev);
+	pm_runtime_put_autosuspend(dev);
 }
 static int fec_enet_get_ts_info(struct net_device *ndev,

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

@@ -418,8 +418,6 @@ bool gve_clean_rx_done(struct gve_rx_ring *rx, int budget, · 417 unmodified lines
418	rx->cnt = cnt;	418	rx->cnt = cnt;
419	rx->fill_cnt += work_done;	419	rx->fill_cnt += work_done;
420		420
421	/* restock desc ring slots */
422	dma_wmb(); /* Ensure descs are visible before ringing doorbell */
423	gve_rx_write_doorbell(priv, rx);	421	gve_rx_write_doorbell(priv, rx);
424	return gve_rx_work_pending(rx);	422	return gve_rx_work_pending(rx);
425	}	423	}

drivers/net/ethernet/google/gve/gve_tx.c+0−6

 		 * may have added descriptors without ringing the doorbell.
 		 */
-		/* Ensure tx descs from a prior gve_tx are visible before
-		 * ringing doorbell.
-		 */
-		dma_wmb();
 		gve_tx_put_doorbell(priv, tx->q_resources, tx->req);
 		return NETDEV_TX_BUSY;
 	}
 	if (!netif_xmit_stopped(tx->netdev_txq) && netdev_xmit_more())
 		return NETDEV_TX_OK;
-	/* Ensure tx descs are visible before ringing doorbell */
-	dma_wmb();
 	gve_tx_put_doorbell(priv, tx->q_resources, tx->req);
 	return NETDEV_TX_OK;
 }

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

@@ -122,6 +122,22 @@ enum { · 121 unmodified lines
122	#endif	122	#endif
123	};	123	};
124		124
		125	#define MLX5E_TTC_NUM_GROUPS 3
		126	#define MLX5E_TTC_GROUP1_SIZE (BIT(3) + MLX5E_NUM_TUNNEL_TT)
		127	#define MLX5E_TTC_GROUP2_SIZE BIT(1)
		128	#define MLX5E_TTC_GROUP3_SIZE BIT(0)
		129	#define MLX5E_TTC_TABLE_SIZE (MLX5E_TTC_GROUP1_SIZE +\
		130	MLX5E_TTC_GROUP2_SIZE +\
		131	MLX5E_TTC_GROUP3_SIZE)
		132
		133	#define MLX5E_INNER_TTC_NUM_GROUPS 3
		134	#define MLX5E_INNER_TTC_GROUP1_SIZE BIT(3)
		135	#define MLX5E_INNER_TTC_GROUP2_SIZE BIT(1)
		136	#define MLX5E_INNER_TTC_GROUP3_SIZE BIT(0)
		137	#define MLX5E_INNER_TTC_TABLE_SIZE (MLX5E_INNER_TTC_GROUP1_SIZE +\
		138	MLX5E_INNER_TTC_GROUP2_SIZE +\
		139	MLX5E_INNER_TTC_GROUP3_SIZE)
		140
125	#ifdef CONFIG_MLX5_EN_RXNFC	141	#ifdef CONFIG_MLX5_EN_RXNFC
126		142
127	struct mlx5e_ethtool_table {	143	struct mlx5e_ethtool_table {

drivers/net/ethernet/mellanox/mlx5/core/en/health.c+4−3

@@ -197,9 +197,10 @@ int mlx5e_health_report(struct mlx5e_priv *priv, · 196 unmodified lines
197	struct devlink_health_reporter reporter, char err_str,	197	struct devlink_health_reporter reporter, char err_str,
198	struct mlx5e_err_ctx *err_ctx)	198	struct mlx5e_err_ctx *err_ctx)
199	{	199	{
200	if (!reporter) {	200	netdev_err(priv->netdev, err_str);
201	netdev_err(priv->netdev, err_str);	201
		202	if (!reporter)
202	return err_ctx->recover(&err_ctx->ctx);	203	return err_ctx->recover(&err_ctx->ctx);
203	}	204
204	return devlink_health_report(reporter, err_str, err_ctx);	205	return devlink_health_report(reporter, err_str, err_ctx);
205	}	206	}

drivers/net/ethernet/mellanox/mlx5/core/en_fs.c+0−16

@@ -904,22 +904,6 @@ del_rules: · 903 unmodified lines
904	return err;	904	return err;
905	}	905	}
906		906
907	#define MLX5E_TTC_NUM_GROUPS 3
908	#define MLX5E_TTC_GROUP1_SIZE (BIT(3) + MLX5E_NUM_TUNNEL_TT)
909	#define MLX5E_TTC_GROUP2_SIZE BIT(1)
910	#define MLX5E_TTC_GROUP3_SIZE BIT(0)
911	#define MLX5E_TTC_TABLE_SIZE (MLX5E_TTC_GROUP1_SIZE +\
912	MLX5E_TTC_GROUP2_SIZE +\
913	MLX5E_TTC_GROUP3_SIZE)
914
915	#define MLX5E_INNER_TTC_NUM_GROUPS 3
916	#define MLX5E_INNER_TTC_GROUP1_SIZE BIT(3)
917	#define MLX5E_INNER_TTC_GROUP2_SIZE BIT(1)
918	#define MLX5E_INNER_TTC_GROUP3_SIZE BIT(0)
919	#define MLX5E_INNER_TTC_TABLE_SIZE (MLX5E_INNER_TTC_GROUP1_SIZE +\
920	MLX5E_INNER_TTC_GROUP2_SIZE +\
921	MLX5E_INNER_TTC_GROUP3_SIZE)
922
923	static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc,	907	static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc,
924	bool use_ipv)	908	bool use_ipv)
925	{	909	{

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

@@ -592,7 +592,7 @@ static void mlx5e_hairpin_set_ttc_params(struct mlx5e_hairpin *hp, · 591 unmodified lines
592	for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++)	592	for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++)
593	ttc_params->indir_tirn[tt] = hp->indir_tirn[tt];	593	ttc_params->indir_tirn[tt] = hp->indir_tirn[tt];
594		594
595	ft_attr->max_fte = MLX5E_NUM_TT;	595	ft_attr->max_fte = MLX5E_TTC_TABLE_SIZE;
596	ft_attr->level = MLX5E_TC_TTC_FT_LEVEL;	596	ft_attr->level = MLX5E_TC_TTC_FT_LEVEL;
597	ft_attr->prio = MLX5E_TC_PRIO;	597	ft_attr->prio = MLX5E_TC_PRIO;
598	}	598	}
@@ -2999,6 +2999,25 @@ static struct ip_tunnel_info dup_tun_info(const struct ip_tunnel_info tun_info · 2400 unmodified lines
2999	return kmemdup(tun_info, tun_size, GFP_KERNEL);	2999	return kmemdup(tun_info, tun_size, GFP_KERNEL);
3000	}	3000	}
3001		3001
		3002	static bool is_duplicated_encap_entry(struct mlx5e_priv *priv,
		3003	struct mlx5e_tc_flow *flow,
		3004	int out_index,
		3005	struct mlx5e_encap_entry *e,
		3006	struct netlink_ext_ack *extack)
		3007	{
		3008	int i;
		3009
		3010	for (i = 0; i < out_index; i++) {
		3011	if (flow->encaps[i].e != e)
		3012	continue;
		3013	NL_SET_ERR_MSG_MOD(extack, "can't duplicate encap action");
		3014	netdev_err(priv->netdev, "can't duplicate encap action\n");
		3015	return true;
		3016	}
		3017
		3018	return false;
		3019	}
		3020
3002	static int mlx5e_attach_encap(struct mlx5e_priv *priv,	3021	static int mlx5e_attach_encap(struct mlx5e_priv *priv,
3003	struct mlx5e_tc_flow *flow,	3022	struct mlx5e_tc_flow *flow,
3004	struct net_device *mirred_dev,	3023	struct net_device *mirred_dev,
@@ -3034,6 +3053,12 @@ static int mlx5e_attach_encap(struct mlx5e_priv *priv, · 29 unmodified lines
3034		3053
3035	/* must verify if encap is valid or not */	3054	/* must verify if encap is valid or not */
3036	if (e) {	3055	if (e) {
		3056	/* Check that entry was not already attached to this flow */
		3057	if (is_duplicated_encap_entry(priv, flow, out_index, e, extack)) {
		3058	err = -EOPNOTSUPP;
		3059	goto out_err;
		3060	}
		3061
3037	mutex_unlock(&esw->offloads.encap_tbl_lock);	3062	mutex_unlock(&esw->offloads.encap_tbl_lock);
3038	wait_for_completion(&e->res_ready);	3063	wait_for_completion(&e->res_ready);
3039		3064
@@ -3220,6 +3245,26 @@ bool mlx5e_is_valid_eswitch_fwd_dev(struct mlx5e_priv *priv, · 180 unmodified lines
3220	same_hw_devs(priv, netdev_priv(out_dev));	3245	same_hw_devs(priv, netdev_priv(out_dev));
3221	}	3246	}
3222		3247
		3248	static bool is_duplicated_output_device(struct net_device *dev,
		3249	struct net_device *out_dev,
		3250	int *ifindexes, int if_count,
		3251	struct netlink_ext_ack *extack)
		3252	{
		3253	int i;
		3254
		3255	for (i = 0; i < if_count; i++) {
		3256	if (ifindexes[i] == out_dev->ifindex) {
		3257	NL_SET_ERR_MSG_MOD(extack,
		3258	"can't duplicate output to same device");
		3259	netdev_err(dev, "can't duplicate output to same device: %s\n",
		3260	out_dev->name);
		3261	return true;
		3262	}
		3263	}
		3264
		3265	return false;
		3266	}
		3267
3223	static int parse_tc_fdb_actions(struct mlx5e_priv *priv,	3268	static int parse_tc_fdb_actions(struct mlx5e_priv *priv,
3224	struct flow_action *flow_action,	3269	struct flow_action *flow_action,
3225	struct mlx5e_tc_flow *flow,	3270	struct mlx5e_tc_flow *flow,
@@ -3231,11 +3276,12 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, · 5 unmodified lines
3231	struct mlx5e_tc_flow_parse_attr *parse_attr = attr->parse_attr;	3276	struct mlx5e_tc_flow_parse_attr *parse_attr = attr->parse_attr;
3232	struct mlx5e_rep_priv *rpriv = priv->ppriv;	3277	struct mlx5e_rep_priv *rpriv = priv->ppriv;
3233	const struct ip_tunnel_info *info = NULL;	3278	const struct ip_tunnel_info *info = NULL;
		3279	int ifindexes[MLX5_MAX_FLOW_FWD_VPORTS];
3234	bool ft_flow = mlx5e_is_ft_flow(flow);	3280	bool ft_flow = mlx5e_is_ft_flow(flow);
3235	const struct flow_action_entry *act;	3281	const struct flow_action_entry *act;
		3282	int err, i, if_count = 0;
3236	bool encap = false;	3283	bool encap = false;
3237	u32 action = 0;	3284	u32 action = 0;
3238	int err, i;
3239		3285
3240	if (!flow_action_has_entries(flow_action))	3286	if (!flow_action_has_entries(flow_action))
3241	return -EINVAL;	3287	return -EINVAL;
@@ -3312,6 +3358,16 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, · 70 unmodified lines
3312	struct net_device *uplink_dev = mlx5_eswitch_uplink_get_proto_dev(esw, REP_ETH);	3358	struct net_device *uplink_dev = mlx5_eswitch_uplink_get_proto_dev(esw, REP_ETH);
3313	struct net_device *uplink_upper;	3359	struct net_device *uplink_upper;
3314		3360
		3361	if (is_duplicated_output_device(priv->netdev,
		3362	out_dev,
		3363	ifindexes,
		3364	if_count,
		3365	extack))
		3366	return -EOPNOTSUPP;
		3367
		3368	ifindexes[if_count] = out_dev->ifindex;
		3369	if_count++;
		3370
3315	rcu_read_lock();	3371	rcu_read_lock();
3316	uplink_upper =	3372	uplink_upper =
3317	netdev_master_upper_dev_get_rcu(uplink_dev);	3373	netdev_master_upper_dev_get_rcu(uplink_dev);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c+15−55

@@ -531,16 +531,9 @@ static void del_hw_fte(struct fs_node *node) · 530 unmodified lines
531	}	531	}
532	}	532	}
533		533
534	static void del_sw_fte_rcu(struct rcu_head *head)
535	{
536	struct fs_fte *fte = container_of(head, struct fs_fte, rcu);
537	struct mlx5_flow_steering *steering = get_steering(&fte->node);
538
539	kmem_cache_free(steering->ftes_cache, fte);
540	}
541
542	static void del_sw_fte(struct fs_node *node)	534	static void del_sw_fte(struct fs_node *node)
543	{	535	{
		536	struct mlx5_flow_steering *steering = get_steering(node);
544	struct mlx5_flow_group *fg;	537	struct mlx5_flow_group *fg;
545	struct fs_fte *fte;	538	struct fs_fte *fte;
546	int err;	539	int err;
@@ -553,8 +546,7 @@ static void del_sw_fte(struct fs_node *node) · 6 unmodified lines
553	rhash_fte);	546	rhash_fte);
554	WARN_ON(err);	547	WARN_ON(err);
555	ida_simple_remove(&fg->fte_allocator, fte->index - fg->start_index);	548	ida_simple_remove(&fg->fte_allocator, fte->index - fg->start_index);
556		549	kmem_cache_free(steering->ftes_cache, fte);
557	call_rcu(&fte->rcu, del_sw_fte_rcu);
558	}	550	}
559		551
560	static void del_hw_flow_group(struct fs_node *node)	552	static void del_hw_flow_group(struct fs_node *node)
@@ -1633,47 +1625,22 @@ static u64 matched_fgs_get_version(struct list_head *match_head) · 1072 unmodified lines
1633	}	1625	}
1634		1626
1635	static struct fs_fte *	1627	static struct fs_fte *
1636	lookup_fte_for_write_locked(struct mlx5_flow_group g, const u32 match_value)	1628	lookup_fte_locked(struct mlx5_flow_group *g,
		1629	const u32 *match_value,
		1630	bool take_write)
1637	{	1631	{
1638	struct fs_fte *fte_tmp;	1632	struct fs_fte *fte_tmp;
1639		1633
1640	nested_down_write_ref_node(&g->node, FS_LOCK_PARENT);	1634	if (take_write)
1641		1635	nested_down_write_ref_node(&g->node, FS_LOCK_PARENT);
1642	fte_tmp = rhashtable_lookup_fast(&g->ftes_hash, match_value, rhash_fte);	1636	else
1643	if (!fte_tmp \|\| !tree_get_node(&fte_tmp->node)) {	1637	nested_down_read_ref_node(&g->node, FS_LOCK_PARENT);
1644	fte_tmp = NULL;	1638	fte_tmp = rhashtable_lookup_fast(&g->ftes_hash, match_value,
1645	goto out;	1639	rhash_fte);
1646	}
1647
1648	if (!fte_tmp->node.active) {
1649	tree_put_node(&fte_tmp->node, false);
1650	fte_tmp = NULL;
1651	goto out;
1652	}
1653	nested_down_write_ref_node(&fte_tmp->node, FS_LOCK_CHILD);
1654
1655	out:
1656	up_write_ref_node(&g->node, false);
1657	return fte_tmp;
1658	}
1659
1660	static struct fs_fte *
1661	lookup_fte_for_read_locked(struct mlx5_flow_group g, const u32 match_value)
1662	{
1663	struct fs_fte *fte_tmp;
1664
1665	if (!tree_get_node(&g->node))
1666	return NULL;
1667
1668	rcu_read_lock();
1669	fte_tmp = rhashtable_lookup(&g->ftes_hash, match_value, rhash_fte);
1670	if (!fte_tmp \|\| !tree_get_node(&fte_tmp->node)) {	1640	if (!fte_tmp \|\| !tree_get_node(&fte_tmp->node)) {
1671	rcu_read_unlock();
1672	fte_tmp = NULL;	1641	fte_tmp = NULL;
1673	goto out;	1642	goto out;
1674	}	1643	}
1675	rcu_read_unlock();
1676
1677	if (!fte_tmp->node.active) {	1644	if (!fte_tmp->node.active) {
1678	tree_put_node(&fte_tmp->node, false);	1645	tree_put_node(&fte_tmp->node, false);
1679	fte_tmp = NULL;	1646	fte_tmp = NULL;
@@ -1681,19 +1648,12 @@ lookup_fte_for_read_locked(struct mlx5_flow_group g, const u32 match_value) · 1 unmodified line
1681	}	1648	}
1682		1649
1683	nested_down_write_ref_node(&fte_tmp->node, FS_LOCK_CHILD);	1650	nested_down_write_ref_node(&fte_tmp->node, FS_LOCK_CHILD);
1684
1685	out:	1651	out:
1686	tree_put_node(&g->node, false);	1652	if (take_write)
1687	return fte_tmp;	1653	up_write_ref_node(&g->node, false);
1688	}
1689
1690	static struct fs_fte *
1691	lookup_fte_locked(struct mlx5_flow_group g, const u32 match_value, bool write)
1692	{
1693	if (write)
1694	return lookup_fte_for_write_locked(g, match_value);
1695	else	1654	else
1696	return lookup_fte_for_read_locked(g, match_value);	1655	up_read_ref_node(&g->node);
		1656	return fte_tmp;
1697	}	1657	}
1698		1658
1699	static struct mlx5_flow_handle *	1659	static struct mlx5_flow_handle *

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

@@ -203,7 +203,6 @@ struct fs_fte { · 202 unmodified lines
203	enum fs_fte_status status;	203	enum fs_fte_status status;
204	struct mlx5_fc *counter;	204	struct mlx5_fc *counter;
205	struct rhash_head hash;	205	struct rhash_head hash;
206	struct rcu_head rcu;
207	int modify_mask;	206	int modify_mask;
208	};	207	};
209		208

drivers/net/ethernet/mellanox/mlx5/core/main.c+9−7

 	if (err)
 		goto err_load;
+	if (boot) {
+		err = mlx5_devlink_register(priv_to_devlink(dev), dev->device);
+		if (err)
+			goto err_devlink_reg;
+	}
 	if (mlx5_device_registered(dev)) {
 		mlx5_attach_device(dev);
 	} else {
 	return err;
 err_reg_dev:
+	if (boot)
+		mlx5_devlink_unregister(priv_to_devlink(dev));
+err_devlink_reg:
 	mlx5_unload(dev);
 err_load:
 	if (boot)
 	request_module_nowait(MLX5_IB_MOD);
-	err = mlx5_devlink_register(devlink, &pdev->dev);
-	if (err)
-		goto clean_load;
 	err = mlx5_crdump_enable(dev);
 	if (err)
 		dev_err(&pdev->dev, "mlx5_crdump_enable failed with error code %d\n", err);
 	pci_save_state(pdev);
 	return 0;
-clean_load:
-	mlx5_unload_one(dev, true);
 err_load_one:
 	mlx5_pci_close(dev);
 pci_init_err:

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c+4−1

 	/* We need to copy the refcount since this ste
 	 * may have been traversed several times
 	 */
-	refcount_set(&new_ste->refcount, refcount_read(&cur_ste->refcount));
+	new_ste->refcount = cur_ste->refcount;
 	/* Link old STEs rule_mem list to the new ste */
 	mlx5dr_rule_update_rule_member(cur_ste, new_ste);
 	if (!rule_mem)
 		return -ENOMEM;
+	INIT_LIST_HEAD(&rule_mem->list);
+	INIT_LIST_HEAD(&rule_mem->use_ste_list);
 	rule_mem->ste = ste;
 	list_add_tail(&rule_mem->list, &nic_rule->rule_members_list);

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

@@ -348,7 +348,7 @@ static void dr_ste_replace(struct mlx5dr_ste dst, struct mlx5dr_ste src) · 347 unmodified lines
348	if (dst->next_htbl)	348	if (dst->next_htbl)
349	dst->next_htbl->pointing_ste = dst;	349	dst->next_htbl->pointing_ste = dst;
350		350
351	refcount_set(&dst->refcount, refcount_read(&src->refcount));	351	dst->refcount = src->refcount;
352		352
353	INIT_LIST_HEAD(&dst->rule_list);	353	INIT_LIST_HEAD(&dst->rule_list);
354	list_splice_tail_init(&src->rule_list, &dst->rule_list);	354	list_splice_tail_init(&src->rule_list, &dst->rule_list);
@@ -565,7 +565,7 @@ bool mlx5dr_ste_is_not_valid_entry(u8 *p_hw_ste) · 210 unmodified lines
565		565
566	bool mlx5dr_ste_not_used_ste(struct mlx5dr_ste *ste)	566	bool mlx5dr_ste_not_used_ste(struct mlx5dr_ste *ste)
567	{	567	{
568	return !refcount_read(&ste->refcount);	568	return !ste->refcount;
569	}	569	}
570		570
571	/* Init one ste as a pattern for ste data array */	571	/* Init one ste as a pattern for ste data array */
@@ -689,14 +689,14 @@ struct mlx5dr_ste_htbl mlx5dr_ste_htbl_alloc(struct mlx5dr_icm_pool pool, · 117 unmodified lines
689	htbl->ste_arr = chunk->ste_arr;	689	htbl->ste_arr = chunk->ste_arr;
690	htbl->hw_ste_arr = chunk->hw_ste_arr;	690	htbl->hw_ste_arr = chunk->hw_ste_arr;
691	htbl->miss_list = chunk->miss_list;	691	htbl->miss_list = chunk->miss_list;
692	refcount_set(&htbl->refcount, 0);	692	htbl->refcount = 0;
693		693
694	for (i = 0; i < chunk->num_of_entries; i++) {	694	for (i = 0; i < chunk->num_of_entries; i++) {
695	struct mlx5dr_ste *ste = &htbl->ste_arr[i];	695	struct mlx5dr_ste *ste = &htbl->ste_arr[i];
696		696
697	ste->hw_ste = htbl->hw_ste_arr + i * DR_STE_SIZE_REDUCED;	697	ste->hw_ste = htbl->hw_ste_arr + i * DR_STE_SIZE_REDUCED;
698	ste->htbl = htbl;	698	ste->htbl = htbl;
699	refcount_set(&ste->refcount, 0);	699	ste->refcount = 0;
700	INIT_LIST_HEAD(&ste->miss_list_node);	700	INIT_LIST_HEAD(&ste->miss_list_node);
701	INIT_LIST_HEAD(&htbl->miss_list[i]);	701	INIT_LIST_HEAD(&htbl->miss_list[i]);
702	INIT_LIST_HEAD(&ste->rule_list);	702	INIT_LIST_HEAD(&ste->rule_list);
@@ -713,7 +713,7 @@ out_free_htbl: · 10 unmodified lines
713		713
714	int mlx5dr_ste_htbl_free(struct mlx5dr_ste_htbl *htbl)	714	int mlx5dr_ste_htbl_free(struct mlx5dr_ste_htbl *htbl)
715	{	715	{
716	if (refcount_read(&htbl->refcount))	716	if (htbl->refcount)
717	return -EBUSY;	717	return -EBUSY;
718		718
719	mlx5dr_icm_free_chunk(htbl->chunk);	719	mlx5dr_icm_free_chunk(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h+8−6

 struct mlx5dr_ste {
 	u8 *hw_ste;
 	/* refcount: indicates the num of rules that using this ste */
-	refcount_t refcount;
+	u32 refcount;
 	/* attached to the miss_list head at each htbl entry */
 	struct list_head miss_list_node;
 struct mlx5dr_ste_htbl {
 	u8 lu_type;
 	u16 byte_mask;
-	refcount_t refcount;
+	u32 refcount;
 	struct mlx5dr_icm_chunk *chunk;
 	struct mlx5dr_ste *ste_arr;
 	u8 *hw_ste_arr;
 static inline void mlx5dr_htbl_put(struct mlx5dr_ste_htbl *htbl)
 {
-	if (refcount_dec_and_test(&htbl->refcount))
+	htbl->refcount--;
+	if (!htbl->refcount)
 		mlx5dr_ste_htbl_free(htbl);
 }
 static inline void mlx5dr_htbl_get(struct mlx5dr_ste_htbl *htbl)
 {
-	refcount_inc(&htbl->refcount);
+	htbl->refcount++;
 }
 /* STE utils */
 				  struct mlx5dr_matcher *matcher,
 				  struct mlx5dr_matcher_rx_tx *nic_matcher)
 {
-	if (refcount_dec_and_test(&ste->refcount))
+	ste->refcount--;
+	if (!ste->refcount)
 		mlx5dr_ste_free(ste, matcher, nic_matcher);
 }
 /* initial as 0, increased only when ste appears in a new rule */
 static inline void mlx5dr_ste_get(struct mlx5dr_ste *ste)
 {
-	refcount_inc(&ste->refcount);
+	ste->refcount++;
 }
 void mlx5dr_ste_set_hit_addr_by_next_htbl(u8 *hw_ste,

drivers/net/ethernet/mellanox/mlxfw/mlxfw_mfa2.c+4−3

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/netlink.h>
+#include <linux/vmalloc.h>
 #include <linux/xz.h>
 #include "mlxfw_mfa2.h"
 #include "mlxfw_mfa2_file.h"
 	comp_size = be32_to_cpu(comp->size);
 	comp_buf_size = comp_size + mlxfw_mfa2_comp_magic_len;
-	comp_data = kmalloc(sizeof(*comp_data) + comp_buf_size, GFP_KERNEL);
+	comp_data = vzalloc(sizeof(*comp_data) + comp_buf_size);
 	if (!comp_data)
 		return ERR_PTR(-ENOMEM);
 	comp_data->comp.data_size = comp_size;
 	comp_data->comp.data = comp_data->buff + mlxfw_mfa2_comp_magic_len;
 	return &comp_data->comp;
 err_out:
-	kfree(comp_data);
+	vfree(comp_data);
 	return ERR_PTR(err);
 }
 	const struct mlxfw_mfa2_comp_data *comp_data;
 	comp_data = container_of(comp, struct mlxfw_mfa2_comp_data, comp);
-	kfree(comp_data);
+	vfree(comp_data);
 }
 void mlxfw_mfa2_file_fini(struct mlxfw_mfa2_file *mfa2_file)

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

@@ -5472,6 +5472,7 @@ enum mlxsw_reg_htgt_trap_group { · 5471 unmodified lines
5472	MLXSW_REG_HTGT_TRAP_GROUP_SP_LBERROR,	5472	MLXSW_REG_HTGT_TRAP_GROUP_SP_LBERROR,
5473	MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP0,	5473	MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP0,
5474	MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP1,	5474	MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP1,
		5475	MLXSW_REG_HTGT_TRAP_GROUP_SP_VRRP,
5475		5476
5476	__MLXSW_REG_HTGT_TRAP_GROUP_MAX,	5477	__MLXSW_REG_HTGT_TRAP_GROUP_MAX,
5477	MLXSW_REG_HTGT_TRAP_GROUP_MAX = __MLXSW_REG_HTGT_TRAP_GROUP_MAX - 1	5478	MLXSW_REG_HTGT_TRAP_GROUP_MAX = __MLXSW_REG_HTGT_TRAP_GROUP_MAX - 1

drivers/net/ethernet/mellanox/mlxsw/spectrum.c+7−2

 	MLXSW_SP_RXL_MARK(ROUTER_ALERT_IPV6, TRAP_TO_CPU, ROUTER_EXP, false),
 	MLXSW_SP_RXL_MARK(IPIP_DECAP_ERROR, TRAP_TO_CPU, ROUTER_EXP, false),
 	MLXSW_SP_RXL_MARK(DECAP_ECN0, TRAP_TO_CPU, ROUTER_EXP, false),
-	MLXSW_SP_RXL_MARK(IPV4_VRRP, TRAP_TO_CPU, ROUTER_EXP, false),
+	MLXSW_SP_RXL_MARK(IPV4_VRRP, TRAP_TO_CPU, VRRP, false),
-	MLXSW_SP_RXL_MARK(IPV6_VRRP, TRAP_TO_CPU, ROUTER_EXP, false),
+	MLXSW_SP_RXL_MARK(IPV6_VRRP, TRAP_TO_CPU, VRRP, false),
 	/* PKT Sample trap */
 	MLXSW_RXL(mlxsw_sp_rx_listener_sample_func, PKT_SAMPLE, MIRROR_TO_CPU,
 		  false, SP_IP2ME, DISCARD),
 			rate = 19 * 1024;
 			burst_size = 12;
 			break;
+		case MLXSW_REG_HTGT_TRAP_GROUP_SP_VRRP:
+			rate = 360;
+			burst_size = 7;
+			break;
 		default:
 			continue;
 		}
 		case MLXSW_REG_HTGT_TRAP_GROUP_SP_OSPF:
 		case MLXSW_REG_HTGT_TRAP_GROUP_SP_PIM:
 		case MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP0:
+		case MLXSW_REG_HTGT_TRAP_GROUP_SP_VRRP:
 			priority = 5;
 			tc = 5;
 			break;

drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c+7−0

@@ -651,6 +651,13 @@ mlxsw_sp_qdisc_prio_graft(struct mlxsw_sp_port *mlxsw_sp_port, · 650 unmodified lines
651	mlxsw_sp_port->tclass_qdiscs[tclass_num].handle == p->child_handle)	651	mlxsw_sp_port->tclass_qdiscs[tclass_num].handle == p->child_handle)
652	return 0;	652	return 0;
653		653
		654	if (!p->child_handle) {
		655	/* This is an invisible FIFO replacing the original Qdisc.
		656	* Ignore it--the original Qdisc's destroy will follow.
		657	*/
		658	return 0;
		659	}
		660
654	/* See if the grafted qdisc is already offloaded on any tclass. If so,	661	/* See if the grafted qdisc is already offloaded on any tclass. If so,
655	* unoffload it.	662	* unoffload it.
656	*/	663	*/

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+3−0

 	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
 		rif = mlxsw_sp->router->rifs[i];
+		if (rif && rif->ops &&
+		    rif->ops->type == MLXSW_SP_RIF_TYPE_IPIP_LB)
+			continue;
 		if (rif && rif->dev && rif->dev != dev &&
 		    !ether_addr_equal_masked(rif->dev->dev_addr, dev_addr,
 					     mlxsw_sp->mac_mask)) {

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c+1−1

@@ -2296,7 +2296,7 @@ __setup("sxgbeeth=", sxgbe_cmdline_opt); · 2295 unmodified lines
2296		2296
2297		2297
2298		2298
2299	MODULE_DESCRIPTION("SAMSUNG 10G/2.5G/1G Ethernet PLATFORM driver");	2299	MODULE_DESCRIPTION("Samsung 10G/2.5G/1G Ethernet PLATFORM driver");
2300		2300
2301	MODULE_PARM_DESC(debug, "Message Level (-1: default, 0: no output, 16: all)");	2301	MODULE_PARM_DESC(debug, "Message Level (-1: default, 0: no output, 16: all)");
2302	MODULE_PARM_DESC(eee_timer, "EEE-LPI Default LS timer value");	2302	MODULE_PARM_DESC(eee_timer, "EEE-LPI Default LS timer value");

drivers/net/ethernet/stmicro/stmmac/dwmac-meson8b.c+11−3

 	struct device *dev = dwmac->dev;
 	const char *parent_name, *mux_parent_names[MUX_CLK_NUM_PARENTS];
 	struct meson8b_dwmac_clk_configs *clk_configs;
+	static const struct clk_div_table div_table[] = {
+		{ .div = 2, .val = 2, },
+		{ .div = 3, .val = 3, },
+		{ .div = 4, .val = 4, },
+		{ .div = 5, .val = 5, },
+		{ .div = 6, .val = 6, },
+		{ .div = 7, .val = 7, },
+	};
 	clk_configs = devm_kzalloc(dev, sizeof(*clk_configs), GFP_KERNEL);
 	if (!clk_configs)
 	clk_configs->m250_div.reg = dwmac->regs + PRG_ETH0;
 	clk_configs->m250_div.shift = PRG_ETH0_CLK_M250_DIV_SHIFT;
 	clk_configs->m250_div.width = PRG_ETH0_CLK_M250_DIV_WIDTH;
-	clk_configs->m250_div.flags = CLK_DIVIDER_ONE_BASED |
+	clk_configs->m250_div.table = div_table;
-				CLK_DIVIDER_ALLOW_ZERO |
+	clk_configs->m250_div.flags = CLK_DIVIDER_ALLOW_ZERO |
-				CLK_DIVIDER_ROUND_CLOSEST;
+				      CLK_DIVIDER_ROUND_CLOSEST;
 	clk = meson8b_dwmac_register_clk(dwmac, "m250_div", &parent_name, 1,
 					 &clk_divider_ops,
 					 &clk_configs->m250_div.hw);

drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c+3−0

 		/* default */
 		break;
 	case PHY_INTERFACE_MODE_RGMII:
+	case PHY_INTERFACE_MODE_RGMII_ID:
+	case PHY_INTERFACE_MODE_RGMII_RXID:
+	case PHY_INTERFACE_MODE_RGMII_TXID:
 		reg |= SYSCON_EPIT | SYSCON_ETCS_INT_GMII;
 		break;
 	case PHY_INTERFACE_MODE_RMII:

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

@@ -44,7 +44,7 @@ static int sun7i_gmac_init(struct platform_device pdev, void priv) · 43 unmodified lines
44	* rate, which then uses the auto-reparenting feature of the	44	* rate, which then uses the auto-reparenting feature of the
45	* clock driver, and enabling/disabling the clock.	45	* clock driver, and enabling/disabling the clock.
46	*/	46	*/
47	if (gmac->interface == PHY_INTERFACE_MODE_RGMII) {	47	if (phy_interface_mode_is_rgmii(gmac->interface)) {
48	clk_set_rate(gmac->tx_clk, SUN7I_GMAC_GMII_RGMII_RATE);	48	clk_set_rate(gmac->tx_clk, SUN7I_GMAC_GMII_RGMII_RATE);
49	clk_prepare_enable(gmac->tx_clk);	49	clk_prepare_enable(gmac->tx_clk);
50	gmac->clk_enabled = 1;	50	gmac->clk_enabled = 1;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+32−0

@@ -106,6 +106,7 @@ MODULE_PARM_DESC(chain_mode, "To use chain instead of ring mode"); · 105 unmodified lines
106	static irqreturn_t stmmac_interrupt(int irq, void *dev_id);	106	static irqreturn_t stmmac_interrupt(int irq, void *dev_id);
107		107
108	#ifdef CONFIG_DEBUG_FS	108	#ifdef CONFIG_DEBUG_FS
		109	static const struct net_device_ops stmmac_netdev_ops;
109	static void stmmac_init_fs(struct net_device *dev);	110	static void stmmac_init_fs(struct net_device *dev);
110	static void stmmac_exit_fs(struct net_device *dev);	111	static void stmmac_exit_fs(struct net_device *dev);
111	#endif	112	#endif
@@ -4256,6 +4257,34 @@ static int stmmac_dma_cap_show(struct seq_file seq, void v) · 4144 unmodified lines
4256	}	4257	}
4257	DEFINE_SHOW_ATTRIBUTE(stmmac_dma_cap);	4258	DEFINE_SHOW_ATTRIBUTE(stmmac_dma_cap);
4258		4259
		4260	/* Use network device events to rename debugfs file entries.
		4261	*/
		4262	static int stmmac_device_event(struct notifier_block *unused,
		4263	unsigned long event, void *ptr)
		4264	{
		4265	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
		4266	struct stmmac_priv *priv = netdev_priv(dev);
		4267
		4268	if (dev->netdev_ops != &stmmac_netdev_ops)
		4269	goto done;
		4270
		4271	switch (event) {
		4272	case NETDEV_CHANGENAME:
		4273	if (priv->dbgfs_dir)
		4274	priv->dbgfs_dir = debugfs_rename(stmmac_fs_dir,
		4275	priv->dbgfs_dir,
		4276	stmmac_fs_dir,
		4277	dev->name);
		4278	break;
		4279	}
		4280	done:
		4281	return NOTIFY_DONE;
		4282	}
		4283
		4284	static struct notifier_block stmmac_notifier = {
		4285	.notifier_call = stmmac_device_event,
		4286	};
		4287
4259	static void stmmac_init_fs(struct net_device *dev)	4288	static void stmmac_init_fs(struct net_device *dev)
4260	{	4289	{
4261	struct stmmac_priv *priv = netdev_priv(dev);	4290	struct stmmac_priv *priv = netdev_priv(dev);
@@ -4270,12 +4299,15 @@ static void stmmac_init_fs(struct net_device *dev) · 8 unmodified lines
4270	/* Entry to report the DMA HW features */	4299	/* Entry to report the DMA HW features */
4271	debugfs_create_file("dma_cap", 0444, priv->dbgfs_dir, dev,	4300	debugfs_create_file("dma_cap", 0444, priv->dbgfs_dir, dev,
4272	&stmmac_dma_cap_fops);	4301	&stmmac_dma_cap_fops);
		4302
		4303	register_netdevice_notifier(&stmmac_notifier);
4273	}	4304	}
4274		4305
4275	static void stmmac_exit_fs(struct net_device *dev)	4306	static void stmmac_exit_fs(struct net_device *dev)
4276	{	4307	{
4277	struct stmmac_priv *priv = netdev_priv(dev);	4308	struct stmmac_priv *priv = netdev_priv(dev);
4278		4309
		4310	unregister_netdevice_notifier(&stmmac_notifier);
4279	debugfs_remove_recursive(priv->dbgfs_dir);	4311	debugfs_remove_recursive(priv->dbgfs_dir);
4280	}	4312	}
4281	#endif /* CONFIG_DEBUG_FS */	4313	#endif /* CONFIG_DEBUG_FS */

drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c+1−1

@@ -320,7 +320,7 @@ out: · 319 unmodified lines
320	static int stmmac_dt_phy(struct plat_stmmacenet_data *plat,	320	static int stmmac_dt_phy(struct plat_stmmacenet_data *plat,
321	struct device_node np, struct device dev)	321	struct device_node np, struct device dev)
322	{	322	{
323	bool mdio = false;	323	bool mdio = !of_phy_is_fixed_link(np);
324	static const struct of_device_id need_mdio_ids[] = {	324	static const struct of_device_id need_mdio_ids[] = {
325	{ .compatible = "snps,dwc-qos-ethernet-4.10" },	325	{ .compatible = "snps,dwc-qos-ethernet-4.10" },
326	{},	326	{},

drivers/net/gtp.c+4−3

 		mtu = dst_mtu(&rt->dst);
 	}
-	rt->dst.ops->update_pmtu(&rt->dst, NULL, skb, mtu);
+	rt->dst.ops->update_pmtu(&rt->dst, NULL, skb, mtu, false);
 	if (!skb_is_gso(skb) && (iph->frag_off & htons(IP_DF)) &&
 	    mtu < ntohs(iph->tot_len)) {
 	lock_sock(sock->sk);
 	if (sock->sk->sk_user_data) {
 		sk = ERR_PTR(-EBUSY);
-		goto out_sock;
+		goto out_rel_sock;
 	}
 	sk = sock->sk;
 	setup_udp_tunnel_sock(sock_net(sock->sk), sock, &tuncfg);
-out_sock:
+out_rel_sock:
 	release_sock(sock->sk);
+out_sock:
 	sockfd_put(sock);
 	return sk;
 }

drivers/net/macvlan.c+1−1

@@ -259,7 +259,7 @@ static void macvlan_broadcast(struct sk_buff *skb, · 258 unmodified lines
259	struct net_device *src,	259	struct net_device *src,
260	enum macvlan_mode mode)	260	enum macvlan_mode mode)
261	{	261	{
262	const struct ethhdr *eth = eth_hdr(skb);	262	const struct ethhdr *eth = skb_eth_hdr(skb);
263	const struct macvlan_dev *vlan;	263	const struct macvlan_dev *vlan;
264	struct sk_buff *nskb;	264	struct sk_buff *nskb;
265	unsigned int i;	265	unsigned int i;

drivers/net/phy/aquantia_main.c+2−0

 	.config_intr	= aqr_config_intr,
 	.ack_interrupt	= aqr_ack_interrupt,
 	.read_status	= aqr_read_status,
+	.suspend	= aqr107_suspend,
+	.resume		= aqr107_resume,
 },
 {
 	PHY_ID_MATCH_MODEL(PHY_ID_AQR106),

drivers/net/phy/phylink.c+3−0

@@ -566,6 +566,9 @@ static int phylink_register_sfp(struct phylink *pl, · 565 unmodified lines
566	struct sfp_bus *bus;	566	struct sfp_bus *bus;
567	int ret;	567	int ret;
568		568
		569	if (!fwnode)
		570	return 0;
		571
569	bus = sfp_bus_find_fwnode(fwnode);	572	bus = sfp_bus_find_fwnode(fwnode);
570	if (IS_ERR(bus)) {	573	if (IS_ERR(bus)) {
571	ret = PTR_ERR(bus);	574	ret = PTR_ERR(bus);

drivers/net/usb/lan78xx.c+3−6

 	return 0;
 }
-static int lan78xx_linearize(struct sk_buff *skb)
-{
-	return skb_linearize(skb);
-}
 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
 				       struct sk_buff *skb, gfp_t flags)
 {
 		return NULL;
 	}
-	if (lan78xx_linearize(skb) < 0)
+	if (skb_linearize(skb)) {
+		dev_kfree_skb_any(skb);
 		return NULL;
+	}
 	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;

drivers/net/vxlan.c+2−2

@@ -2541,7 +2541,7 @@ static void vxlan_xmit_one(struct sk_buff skb, struct net_device dev, · 2540 unmodified lines
2541	ndst = &rt->dst;	2541	ndst = &rt->dst;
2542	skb_tunnel_check_pmtu(skb, ndst, VXLAN_HEADROOM);	2542	skb_tunnel_check_pmtu(skb, ndst, VXLAN_HEADROOM);
2543		2543
2544	tos = ip_tunnel_ecn_encap(tos, old_iph, skb);	2544	tos = ip_tunnel_ecn_encap(RT_TOS(tos), old_iph, skb);
2545	ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);	2545	ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
2546	err = vxlan_build_skb(skb, ndst, sizeof(struct iphdr),	2546	err = vxlan_build_skb(skb, ndst, sizeof(struct iphdr),
2547	vni, md, flags, udp_sum);	2547	vni, md, flags, udp_sum);
@@ -2581,7 +2581,7 @@ static void vxlan_xmit_one(struct sk_buff skb, struct net_device dev, · 33 unmodified lines
2581		2581
2582	skb_tunnel_check_pmtu(skb, ndst, VXLAN6_HEADROOM);	2582	skb_tunnel_check_pmtu(skb, ndst, VXLAN6_HEADROOM);
2583		2583
2584	tos = ip_tunnel_ecn_encap(tos, old_iph, skb);	2584	tos = ip_tunnel_ecn_encap(RT_TOS(tos), old_iph, skb);
2585	ttl = ttl ? : ip6_dst_hoplimit(ndst);	2585	ttl = ttl ? : ip6_dst_hoplimit(ndst);
2586	skb_scrub_packet(skb, xnet);	2586	skb_scrub_packet(skb, xnet);
2587	err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),	2587	err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),

drivers/net/wan/sdla.c+1−1

@@ -708,7 +708,7 @@ static netdev_tx_t sdla_transmit(struct sk_buff *skb, · 707 unmodified lines
708		708
709	spin_lock_irqsave(&sdla_lock, flags);	709	spin_lock_irqsave(&sdla_lock, flags);
710	SDLA_WINDOW(dev, addr);	710	SDLA_WINDOW(dev, addr);
711	pbuf = (void *)(((int) dev->mem_start) + (addr & SDLA_ADDR_MASK));	711	pbuf = (void *)(dev->mem_start + (addr & SDLA_ADDR_MASK));
712	__sdla_write(dev, pbuf->buf_addr, skb->data, skb->len);	712	__sdla_write(dev, pbuf->buf_addr, skb->data, skb->len);
713	SDLA_WINDOW(dev, addr);	713	SDLA_WINDOW(dev, addr);
714	pbuf->opp_flag = 1;	714	pbuf->opp_flag = 1;

drivers/nvme/host/core.c+2−0

 	case NVME_SC_CAP_EXCEEDED:
 		return BLK_STS_NOSPC;
 	case NVME_SC_LBA_RANGE:
+	case NVME_SC_CMD_INTERRUPTED:
+	case NVME_SC_NS_NOT_READY:
 		return BLK_STS_TARGET;
 	case NVME_SC_BAD_ATTRIBUTES:
 	case NVME_SC_ONCS_NOT_SUPPORTED:

drivers/nvme/target/admin-cmd.c+11−1

 	return len;
 }
+static u32 nvmet_feat_data_len(struct nvmet_req *req, u32 cdw10)
+{
+	switch (cdw10 & 0xff) {
+	case NVME_FEAT_HOST_ID:
+		return sizeof(req->sq->ctrl->hostid);
+	default:
+		return 0;
+	}
+}
 u64 nvmet_get_log_page_offset(struct nvme_command *cmd)
 {
 	return le64_to_cpu(cmd->get_log_page.lpo);
 	u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
 	u16 status = 0;
-	if (!nvmet_check_data_len(req, 0))
+	if (!nvmet_check_data_len(req, nvmet_feat_data_len(req, cdw10)))
 		return;
 	switch (cdw10 & 0xff) {

drivers/phy/motorola/phy-cpcap-usb.c+90−38

@@ -115,7 +115,7 @@ struct cpcap_usb_ints_state { · 114 unmodified lines
115	enum cpcap_gpio_mode {	115	enum cpcap_gpio_mode {
116	CPCAP_DM_DP,	116	CPCAP_DM_DP,
117	CPCAP_MDM_RX_TX,	117	CPCAP_MDM_RX_TX,
118	CPCAP_UNKNOWN,	118	CPCAP_UNKNOWN_DISABLED, /* Seems to disable USB lines */
119	CPCAP_OTG_DM_DP,	119	CPCAP_OTG_DM_DP,
120	};	120	};
121		121
@@ -134,6 +134,8 @@ struct cpcap_phy_ddata { · 12 unmodified lines
134	struct iio_channel *id;	134	struct iio_channel *id;
135	struct regulator *vusb;	135	struct regulator *vusb;
136	atomic_t active;	136	atomic_t active;
		137	unsigned int vbus_provider:1;
		138	unsigned int docked:1;
137	};	139	};
138		140
139	static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)	141	static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
@@ -207,6 +209,19 @@ static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata, · 67 unmodified lines
207	static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);	209	static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
208	static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);	210	static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);
209		211
		212	static void cpcap_usb_try_musb_mailbox(struct cpcap_phy_ddata *ddata,
		213	enum musb_vbus_id_status status)
		214	{
		215	int error;
		216
		217	error = musb_mailbox(status);
		218	if (!error)
		219	return;
		220
		221	dev_dbg(ddata->dev, "%s: musb_mailbox failed: %i\n",
		222	__func__, error);
		223	}
		224
210	static void cpcap_usb_detect(struct work_struct *work)	225	static void cpcap_usb_detect(struct work_struct *work)
211	{	226	{
212	struct cpcap_phy_ddata *ddata;	227	struct cpcap_phy_ddata *ddata;
@@ -220,16 +235,66 @@ static void cpcap_usb_detect(struct work_struct *work) · 7 unmodified lines
220	if (error)	235	if (error)
221	return;	236	return;
222		237
223	if (s.id_ground) {	238	vbus = cpcap_usb_vbus_valid(ddata);
224	dev_dbg(ddata->dev, "id ground, USB host mode\n");	239
		240	/* We need to kick the VBUS as USB A-host */
		241	if (s.id_ground && ddata->vbus_provider) {
		242	dev_dbg(ddata->dev, "still in USB A-host mode, kicking VBUS\n");
		243
		244	cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
		245
		246	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
		247	CPCAP_BIT_VBUSSTBY_EN \|
		248	CPCAP_BIT_VBUSEN_SPI,
		249	CPCAP_BIT_VBUSEN_SPI);
		250	if (error)
		251	goto out_err;
		252
		253	return;
		254	}
		255
		256	if (vbus && s.id_ground && ddata->docked) {
		257	dev_dbg(ddata->dev, "still docked as A-host, signal ID down\n");
		258
		259	cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
		260
		261	return;
		262	}
		263
		264	/* No VBUS needed with docks */
		265	if (vbus && s.id_ground && !ddata->vbus_provider) {
		266	dev_dbg(ddata->dev, "connected to a dock\n");
		267
		268	ddata->docked = true;
		269
225	error = cpcap_usb_set_usb_mode(ddata);	270	error = cpcap_usb_set_usb_mode(ddata);
226	if (error)	271	if (error)
227	goto out_err;	272	goto out_err;
228		273
229	error = musb_mailbox(MUSB_ID_GROUND);	274	cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
		275
		276	/*
		277	* Force check state again after musb has reoriented,
		278	* otherwise devices won't enumerate after loading PHY
		279	* driver.
		280	*/
		281	schedule_delayed_work(&ddata->detect_work,
		282	msecs_to_jiffies(1000));
		283
		284	return;
		285	}
		286
		287	if (s.id_ground && !ddata->docked) {
		288	dev_dbg(ddata->dev, "id ground, USB host mode\n");
		289
		290	ddata->vbus_provider = true;
		291
		292	error = cpcap_usb_set_usb_mode(ddata);
230	if (error)	293	if (error)
231	goto out_err;	294	goto out_err;
232		295
		296	cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
		297
233	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,	298	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
234	CPCAP_BIT_VBUSSTBY_EN \|	299	CPCAP_BIT_VBUSSTBY_EN \|
235	CPCAP_BIT_VBUSEN_SPI,	300	CPCAP_BIT_VBUSEN_SPI,
@@ -248,43 +313,26 @@ static void cpcap_usb_detect(struct work_struct *work) · 12 unmodified lines
248		313
249	vbus = cpcap_usb_vbus_valid(ddata);	314	vbus = cpcap_usb_vbus_valid(ddata);
250		315
		316	/* Otherwise assume we're connected to a USB host */
251	if (vbus) {	317	if (vbus) {
252	/* Are we connected to a docking station with vbus? */
253	if (s.id_ground) {
254	dev_dbg(ddata->dev, "connected to a dock\n");
255
256	/* No VBUS needed with docks */
257	error = cpcap_usb_set_usb_mode(ddata);
258	if (error)
259	goto out_err;
260	error = musb_mailbox(MUSB_ID_GROUND);
261	if (error)
262	goto out_err;
263
264	return;
265	}
266
267	/* Otherwise assume we're connected to a USB host */
268	dev_dbg(ddata->dev, "connected to USB host\n");	318	dev_dbg(ddata->dev, "connected to USB host\n");
269	error = cpcap_usb_set_usb_mode(ddata);	319	error = cpcap_usb_set_usb_mode(ddata);
270	if (error)	320	if (error)
271	goto out_err;	321	goto out_err;
272	error = musb_mailbox(MUSB_VBUS_VALID);	322	cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_VALID);
273	if (error)
274	goto out_err;
275		323
276	return;	324	return;
277	}	325	}
278		326
		327	ddata->vbus_provider = false;
		328	ddata->docked = false;
		329	cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
		330
279	/* Default to debug UART mode */	331	/* Default to debug UART mode */
280	error = cpcap_usb_set_uart_mode(ddata);	332	error = cpcap_usb_set_uart_mode(ddata);
281	if (error)	333	if (error)
282	goto out_err;	334	goto out_err;
283		335
284	error = musb_mailbox(MUSB_VBUS_OFF);
285	if (error)
286	goto out_err;
287
288	dev_dbg(ddata->dev, "set UART mode\n");	336	dev_dbg(ddata->dev, "set UART mode\n");
289		337
290	return;	338	return;
@@ -376,7 +424,8 @@ static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata) · 85 unmodified lines
376	{	424	{
377	int error;	425	int error;
378		426
379	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);	427	/* Disable lines to prevent glitches from waking up mdm6600 */
		428	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
380	if (error)	429	if (error)
381	goto out_err;	430	goto out_err;
382		431
@@ -403,6 +452,11 @@ static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata) · 20 unmodified lines
403	if (error)	452	if (error)
404	goto out_err;	453	goto out_err;
405		454
		455	/* Enable UART mode */
		456	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
		457	if (error)
		458	goto out_err;
		459
406	return 0;	460	return 0;
407		461
408	out_err:	462	out_err:
@@ -415,7 +469,8 @@ static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata) · 6 unmodified lines
415	{	469	{
416	int error;	470	int error;
417		471
418	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);	472	/* Disable lines to prevent glitches from waking up mdm6600 */
		473	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
419	if (error)	474	if (error)
420	return error;	475	return error;
421		476
@@ -434,12 +489,6 @@ static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata) · 12 unmodified lines
434	if (error)	489	if (error)
435	goto out_err;	490	goto out_err;
436		491
437	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
438	CPCAP_BIT_USBXCVREN,
439	CPCAP_BIT_USBXCVREN);
440	if (error)
441	goto out_err;
442
443	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,	492	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
444	CPCAP_BIT_PU_SPI \|	493	CPCAP_BIT_PU_SPI \|
445	CPCAP_BIT_DMPD_SPI \|	494	CPCAP_BIT_DMPD_SPI \|
@@ -455,6 +504,11 @@ static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata) · 9 unmodified lines
455	if (error)	504	if (error)
456	goto out_err;	505	goto out_err;
457		506
		507	/* Enable USB mode */
		508	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
		509	if (error)
		510	goto out_err;
		511
458	return 0;	512	return 0;
459		513
460	out_err:	514	out_err:
@@ -649,9 +703,7 @@ static int cpcap_usb_phy_remove(struct platform_device *pdev) · 188 unmodified lines
649	if (error)	703	if (error)
650	dev_err(ddata->dev, "could not set UART mode\n");	704	dev_err(ddata->dev, "could not set UART mode\n");
651		705
652	error = musb_mailbox(MUSB_VBUS_OFF);	706	cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
653	if (error)
654	dev_err(ddata->dev, "could not set mailbox\n");
655		707
656	usb_remove_phy(&ddata->phy);	708	usb_remove_phy(&ddata->phy);
657	cancel_delayed_work_sync(&ddata->detect_work);	709	cancel_delayed_work_sync(&ddata->detect_work);

drivers/phy/motorola/phy-mapphone-mdm6600.c+3−8

 	struct phy_mdm6600 *ddata;
 	struct device *dev;
 	DECLARE_BITMAP(values, PHY_MDM6600_NR_STATUS_LINES);
-	int error, i, val = 0;
+	int error;
 	ddata = container_of(work, struct phy_mdm6600, status_work.work);
 	dev = ddata->dev;
 	if (error)
 		return;
-	for (i = 0; i < PHY_MDM6600_NR_STATUS_LINES; i++) {
+	ddata->status = values[0] & ((1 << PHY_MDM6600_NR_STATUS_LINES) - 1);
-		val |= test_bit(i, values) << i;
-		dev_dbg(ddata->dev, "XXX %s: i: %i values[i]: %i val: %i\n",
-			__func__, i, test_bit(i, values), val);
-	}
-	ddata->status = values[0];
 	dev_info(dev, "modem status: %i %s\n",
 		 ddata->status,
-		 phy_mdm6600_status_name[ddata->status & 7]);
+		 phy_mdm6600_status_name[ddata->status]);
 	complete(&ddata->ack);
 }

drivers/phy/qualcomm/phy-qcom-qmp.c+1−1

@@ -66,7 +66,7 @@ · 65 unmodified lines
66	/* QPHY_V3_PCS_MISC_CLAMP_ENABLE register bits */	66	/* QPHY_V3_PCS_MISC_CLAMP_ENABLE register bits */
67	#define CLAMP_EN BIT(0) /* enables i/o clamp_n */	67	#define CLAMP_EN BIT(0) /* enables i/o clamp_n */
68		68
69	#define PHY_INIT_COMPLETE_TIMEOUT 1000	69	#define PHY_INIT_COMPLETE_TIMEOUT 10000
70	#define POWER_DOWN_DELAY_US_MIN 10	70	#define POWER_DOWN_DELAY_US_MIN 10
71	#define POWER_DOWN_DELAY_US_MAX 11	71	#define POWER_DOWN_DELAY_US_MAX 11
72		72

drivers/phy/rockchip/phy-rockchip-inno-hdmi.c+4−0

 {
 	const struct pre_pll_config *cfg = pre_pll_cfg_table;
+	rate = (rate / 1000) * 1000;
 	for (; cfg->pixclock != 0; cfg++)
 		if (cfg->pixclock == rate && !cfg->fracdiv)
 			break;
 {
 	const struct pre_pll_config *cfg = pre_pll_cfg_table;
+	rate = (rate / 1000) * 1000;
 	for (; cfg->pixclock != 0; cfg++)
 		if (cfg->pixclock == rate)
 			break;

drivers/pinctrl/cirrus/Kconfig+1−0

@@ -2,6 +2,7 @@ · 1 unmodified line
2	config PINCTRL_LOCHNAGAR	2	config PINCTRL_LOCHNAGAR
3	tristate "Cirrus Logic Lochnagar pinctrl driver"	3	tristate "Cirrus Logic Lochnagar pinctrl driver"
4	depends on MFD_LOCHNAGAR	4	depends on MFD_LOCHNAGAR
		5	select GPIOLIB
5	select PINMUX	6	select PINMUX
6	select PINCONF	7	select PINCONF
7	select GENERIC_PINCONF	8	select GENERIC_PINCONF

drivers/pinctrl/meson/pinctrl-meson.c+1−0

@@ -441,6 +441,7 @@ static int meson_pinconf_get_drive_strength(struct meson_pinctrl *pc, · 440 unmodified lines
441	return ret;	441	return ret;
442		442
443	meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);	443	meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);
		444	bit = bit << 1;
444		445
445	ret = regmap_read(pc->reg_ds, reg, &val);	446	ret = regmap_read(pc->reg_ds, reg, &val);
446	if (ret)	447	if (ret)

drivers/platform/mips/Kconfig+1−1

@@ -18,7 +18,7 @@ if MIPS_PLATFORM_DEVICES · 17 unmodified lines
18		18
19	config CPU_HWMON	19	config CPU_HWMON
20	tristate "Loongson-3 CPU HWMon Driver"	20	tristate "Loongson-3 CPU HWMon Driver"
21	depends on CONFIG_MACH_LOONGSON64	21	depends on MACH_LOONGSON64
22	select HWMON	22	select HWMON
23	default y	23	default y
24	help	24	help

drivers/powercap/intel_rapl_common.c+3−0

@@ -1295,6 +1295,9 @@ struct rapl_package rapl_add_package(int cpu, struct rapl_if_priv priv) · 1294 unmodified lines
1295	struct cpuinfo_x86 *c = &cpu_data(cpu);	1295	struct cpuinfo_x86 *c = &cpu_data(cpu);
1296	int ret;	1296	int ret;
1297		1297
		1298	if (!rapl_defaults)
		1299	return ERR_PTR(-ENODEV);
		1300
1298	rp = kzalloc(sizeof(struct rapl_package), GFP_KERNEL);	1301	rp = kzalloc(sizeof(struct rapl_package), GFP_KERNEL);
1299	if (!rp)	1302	if (!rp)
1300	return ERR_PTR(-ENOMEM);	1303	return ERR_PTR(-ENOMEM);

drivers/ptp/ptp_clock.c+14−17

 	.read		= ptp_read,
 };
-static void delete_ptp_clock(struct posix_clock *pc)
+static void ptp_clock_release(struct device *dev)
 {
-	struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock);
+	struct ptp_clock *ptp = container_of(dev, struct ptp_clock, dev);
 	mutex_destroy(&ptp->tsevq_mux);
 	mutex_destroy(&ptp->pincfg_mux);
 	}
 	ptp->clock.ops = ptp_clock_ops;
-	ptp->clock.release = delete_ptp_clock;
 	ptp->info = info;
 	ptp->devid = MKDEV(major, index);
 	ptp->index = index;
 	if (err)
 		goto no_pin_groups;
-	/* Create a new device in our class. */
-	ptp->dev = device_create_with_groups(ptp_class, parent, ptp->devid,
-					     ptp, ptp->pin_attr_groups,
-					     "ptp%d", ptp->index);
-	if (IS_ERR(ptp->dev)) {
-		err = PTR_ERR(ptp->dev);
-		goto no_device;
-	}
 	/* Register a new PPS source. */
 	if (info->pps) {
 		struct pps_source_info pps;
 		}
 	}
-	/* Create a posix clock. */
+	/* Initialize a new device of our class in our clock structure. */
-	err = posix_clock_register(&ptp->clock, ptp->devid);
+	device_initialize(&ptp->dev);
+	ptp->dev.devt = ptp->devid;
+	ptp->dev.class = ptp_class;
+	ptp->dev.parent = parent;
+	ptp->dev.groups = ptp->pin_attr_groups;
+	ptp->dev.release = ptp_clock_release;
+	dev_set_drvdata(&ptp->dev, ptp);
+	dev_set_name(&ptp->dev, "ptp%d", ptp->index);
+	/* Create a posix clock and link it to the device. */
+	err = posix_clock_register(&ptp->clock, &ptp->dev);
 	if (err) {
 		pr_err("failed to create posix clock\n");
 		goto no_clock;
 	if (ptp->pps_source)
 		pps_unregister_source(ptp->pps_source);
 no_pps:
-	device_destroy(ptp_class, ptp->devid);
-no_device:
 	ptp_cleanup_pin_groups(ptp);
 no_pin_groups:
 	if (ptp->kworker)
 	if (ptp->pps_source)
 		pps_unregister_source(ptp->pps_source);
-	device_destroy(ptp_class, ptp->devid);
 	ptp_cleanup_pin_groups(ptp);
 	posix_clock_unregister(&ptp->clock);

drivers/ptp/ptp_private.h+1−1

@@ -28,7 +28,7 @@ struct timestamp_event_queue { · 27 unmodified lines
28		28
29	struct ptp_clock {	29	struct ptp_clock {
30	struct posix_clock clock;	30	struct posix_clock clock;
31	struct device *dev;	31	struct device dev;
32	struct ptp_clock_info *info;	32	struct ptp_clock_info *info;
33	dev_t devid;	33	dev_t devid;
34	int index; /* index into clocks.map */	34	int index; /* index into clocks.map */

drivers/regulator/axp20x-regulator.c+7−4

 		int i;
 		for (i = 0; i < rate_count; i++) {
-			if (ramp <= slew_rates[i])
+			if (ramp > slew_rates[i])
-				cfg = AXP20X_DCDC2_LDO3_V_RAMP_LDO3_RATE(i);
-			else
 				break;
+			if (id == AXP20X_DCDC2)
+				cfg = AXP20X_DCDC2_LDO3_V_RAMP_DCDC2_RATE(i);
+			else
+				cfg = AXP20X_DCDC2_LDO3_V_RAMP_LDO3_RATE(i);
 		}
 		if (cfg == 0xff) {
 		 AXP22X_PWR_OUT_CTRL2, AXP22X_PWR_OUT_ELDO1_MASK),
 	AXP_DESC(AXP22X, ELDO2, "eldo2", "eldoin", 700, 3300, 100,
 		 AXP22X_ELDO2_V_OUT, AXP22X_ELDO2_V_OUT_MASK,
-		 AXP22X_PWR_OUT_CTRL2, AXP22X_PWR_OUT_ELDO1_MASK),
+		 AXP22X_PWR_OUT_CTRL2, AXP22X_PWR_OUT_ELDO2_MASK),
 	AXP_DESC(AXP22X, ELDO3, "eldo3", "eldoin", 700, 3300, 100,
 		 AXP22X_ELDO3_V_OUT, AXP22X_ELDO3_V_OUT_MASK,
 		 AXP22X_PWR_OUT_CTRL2, AXP22X_PWR_OUT_ELDO3_MASK),

drivers/regulator/bd70528-regulator.c+0−1

@@ -101,7 +101,6 @@ static const struct regulator_ops bd70528_ldo_ops = { · 100 unmodified lines
101	.set_voltage_sel = regulator_set_voltage_sel_regmap,	101	.set_voltage_sel = regulator_set_voltage_sel_regmap,
102	.get_voltage_sel = regulator_get_voltage_sel_regmap,	102	.get_voltage_sel = regulator_get_voltage_sel_regmap,
103	.set_voltage_time_sel = regulator_set_voltage_time_sel,	103	.set_voltage_time_sel = regulator_set_voltage_time_sel,
104	.set_ramp_delay = bd70528_set_ramp_delay,
105	};	104	};
106		105
107	static const struct regulator_ops bd70528_led_ops = {	106	static const struct regulator_ops bd70528_led_ops = {

drivers/rtc/rtc-mc146818-lib.c+1−14

@@ -172,20 +172,7 @@ int mc146818_set_time(struct rtc_time *time) · 171 unmodified lines
172	save_control = CMOS_READ(RTC_CONTROL);	172	save_control = CMOS_READ(RTC_CONTROL);
173	CMOS_WRITE((save_control\|RTC_SET), RTC_CONTROL);	173	CMOS_WRITE((save_control\|RTC_SET), RTC_CONTROL);
174	save_freq_select = CMOS_READ(RTC_FREQ_SELECT);	174	save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
175		175	CMOS_WRITE((save_freq_select\|RTC_DIV_RESET2), RTC_FREQ_SELECT);
176	#ifdef CONFIG_X86
177	if ((boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
178	boot_cpu_data.x86 == 0x17) \|\|
179	boot_cpu_data.x86_vendor == X86_VENDOR_HYGON) {
180	CMOS_WRITE((save_freq_select & (~RTC_DIV_RESET2)),
181	RTC_FREQ_SELECT);
182	save_freq_select &= ~RTC_DIV_RESET2;
183	} else
184	CMOS_WRITE((save_freq_select \| RTC_DIV_RESET2),
185	RTC_FREQ_SELECT);
186	#else
187	CMOS_WRITE((save_freq_select \| RTC_DIV_RESET2), RTC_FREQ_SELECT);
188	#endif
189		176
190	#ifdef CONFIG_MACH_DECSTATION	177	#ifdef CONFIG_MACH_DECSTATION
191	CMOS_WRITE(real_yrs, RTC_DEC_YEAR);	178	CMOS_WRITE(real_yrs, RTC_DEC_YEAR);

drivers/rtc/rtc-mt6397.c+25−14

 		irqen = irqsta & ~RTC_IRQ_EN_AL;
 		mutex_lock(&rtc->lock);
 		if (regmap_write(rtc->regmap, rtc->addr_base + RTC_IRQ_EN,
-				 irqen) < 0)
+				 irqen) == 0)
 			mtk_rtc_write_trigger(rtc);
 		mutex_unlock(&rtc->lock);
 	alm->pending = !!(pdn2 & RTC_PDN2_PWRON_ALARM);
 	mutex_unlock(&rtc->lock);
-	tm->tm_sec = data[RTC_OFFSET_SEC];
+	tm->tm_sec = data[RTC_OFFSET_SEC] & RTC_AL_SEC_MASK;
-	tm->tm_min = data[RTC_OFFSET_MIN];
+	tm->tm_min = data[RTC_OFFSET_MIN] & RTC_AL_MIN_MASK;
-	tm->tm_hour = data[RTC_OFFSET_HOUR];
+	tm->tm_hour = data[RTC_OFFSET_HOUR] & RTC_AL_HOU_MASK;
-	tm->tm_mday = data[RTC_OFFSET_DOM];
+	tm->tm_mday = data[RTC_OFFSET_DOM] & RTC_AL_DOM_MASK;
-	tm->tm_mon = data[RTC_OFFSET_MTH];
+	tm->tm_mon = data[RTC_OFFSET_MTH] & RTC_AL_MTH_MASK;
-	tm->tm_year = data[RTC_OFFSET_YEAR];
+	tm->tm_year = data[RTC_OFFSET_YEAR] & RTC_AL_YEA_MASK;
 	tm->tm_year += RTC_MIN_YEAR_OFFSET;
 	tm->tm_mon--;
 	tm->tm_year -= RTC_MIN_YEAR_OFFSET;
 	tm->tm_mon++;
-	data[RTC_OFFSET_SEC] = tm->tm_sec;
-	data[RTC_OFFSET_MIN] = tm->tm_min;
-	data[RTC_OFFSET_HOUR] = tm->tm_hour;
-	data[RTC_OFFSET_DOM] = tm->tm_mday;
-	data[RTC_OFFSET_MTH] = tm->tm_mon;
-	data[RTC_OFFSET_YEAR] = tm->tm_year;
 	mutex_lock(&rtc->lock);
+	ret = regmap_bulk_read(rtc->regmap, rtc->addr_base + RTC_AL_SEC,
+			       data, RTC_OFFSET_COUNT);
+	if (ret < 0)
+		goto exit;
+	data[RTC_OFFSET_SEC] = ((data[RTC_OFFSET_SEC] & ~(RTC_AL_SEC_MASK)) |
+				(tm->tm_sec & RTC_AL_SEC_MASK));
+	data[RTC_OFFSET_MIN] = ((data[RTC_OFFSET_MIN] & ~(RTC_AL_MIN_MASK)) |
+				(tm->tm_min & RTC_AL_MIN_MASK));
+	data[RTC_OFFSET_HOUR] = ((data[RTC_OFFSET_HOUR] & ~(RTC_AL_HOU_MASK)) |
+				(tm->tm_hour & RTC_AL_HOU_MASK));
+	data[RTC_OFFSET_DOM] = ((data[RTC_OFFSET_DOM] & ~(RTC_AL_DOM_MASK)) |
+				(tm->tm_mday & RTC_AL_DOM_MASK));
+	data[RTC_OFFSET_MTH] = ((data[RTC_OFFSET_MTH] & ~(RTC_AL_MTH_MASK)) |
+				(tm->tm_mon & RTC_AL_MTH_MASK));
+	data[RTC_OFFSET_YEAR] = ((data[RTC_OFFSET_YEAR] & ~(RTC_AL_YEA_MASK)) |
+				(tm->tm_year & RTC_AL_YEA_MASK));
 	if (alm->enabled) {
 		ret = regmap_bulk_write(rtc->regmap,
 					rtc->addr_base + RTC_AL_SEC,

drivers/rtc/rtc-sun6i.c+16−0

@@ -379,6 +379,22 @@ static void __init sun50i_h6_rtc_clk_init(struct device_node *node) · 378 unmodified lines
379	CLK_OF_DECLARE_DRIVER(sun50i_h6_rtc_clk, "allwinner,sun50i-h6-rtc",	379	CLK_OF_DECLARE_DRIVER(sun50i_h6_rtc_clk, "allwinner,sun50i-h6-rtc",
380	sun50i_h6_rtc_clk_init);	380	sun50i_h6_rtc_clk_init);
381		381
		382	/*
		383	* The R40 user manual is self-conflicting on whether the prescaler is
		384	* fixed or configurable. The clock diagram shows it as fixed, but there
		385	* is also a configurable divider in the RTC block.
		386	*/
		387	static const struct sun6i_rtc_clk_data sun8i_r40_rtc_data = {
		388	.rc_osc_rate = 16000000,
		389	.fixed_prescaler = 512,
		390	};
		391	static void __init sun8i_r40_rtc_clk_init(struct device_node *node)
		392	{
		393	sun6i_rtc_clk_init(node, &sun8i_r40_rtc_data);
		394	}
		395	CLK_OF_DECLARE_DRIVER(sun8i_r40_rtc_clk, "allwinner,sun8i-r40-rtc",
		396	sun8i_r40_rtc_clk_init);
		397
382	static const struct sun6i_rtc_clk_data sun8i_v3_rtc_data = {	398	static const struct sun6i_rtc_clk_data sun8i_v3_rtc_data = {
383	.rc_osc_rate = 32000,	399	.rc_osc_rate = 32000,
384	.has_out_clk = 1,	400	.has_out_clk = 1,

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

 	rc = qeth_cm_enable(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "2err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_cm_setup(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "3err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_ulp_enable(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "4err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_ulp_setup(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "5err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_alloc_qdio_queues(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "5err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_qdio_establish(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "6err%d", rc);
 		qeth_free_qdio_queues(card);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_qdio_activate(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "7err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	rc = qeth_dm_act(card);
 	if (rc) {
 		QETH_CARD_TEXT_(card, 2, "8err%d", rc);
-		goto out_qdio;
+		return rc;
 	}
 	return 0;
-out_qdio:
-	qeth_qdio_clear_card(card, !IS_IQD(card));
-	qdio_free(CARD_DDEV(card));
-	return rc;
 }
 void qeth_print_status_message(struct qeth_card *card)
 			goto out;
 		}
-		if (card->state != CARD_STATE_DOWN) {
-			rc = -1;
-			goto out;
-		}
 		qeth_free_qdio_queues(card);
 		card->options.cq = cq;
 		rc = 0;
 	}
 	if (qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
 		rc = qeth_query_setdiagass(card);
-		if (rc < 0) {
+		if (rc)
 			QETH_CARD_TEXT_(card, 2, "8err%d", rc);
-			goto out;
-		}
 	}
 	if (!qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP) ||

drivers/s390/net/qeth_l2_main.c+5−5

 		card->state = CARD_STATE_HARDSETUP;
 	}
 	if (card->state == CARD_STATE_HARDSETUP) {
-		qeth_qdio_clear_card(card, 0);
 		qeth_drain_output_queues(card);
 		qeth_clear_working_pool_list(card);
 		card->state = CARD_STATE_DOWN;
 	}
+	qeth_qdio_clear_card(card, 0);
 	flush_workqueue(card->event_wq);
 	card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
 	card->info.promisc_mode = 0;
 /* check if VNICC is currently enabled */
 bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
 {
-	/* if everything is turned off, VNICC is not active */
+	if (!card->options.vnicc.sup_chars)
-	if (!card->options.vnicc.cur_chars)
 		return false;
 	/* default values are only OK if rx_bcast was not enabled by user
 	 * or the card is offline.
 	/* enforce assumed default values and recover settings, if changed  */
 	error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
 					       timeout);
-	chars_tmp = card->options.vnicc.wanted_chars ^ QETH_VNICC_DEFAULT;
+	/* Change chars, if necessary  */
-	chars_tmp |= QETH_VNICC_BRIDGE_INVISIBLE;
+	chars_tmp = card->options.vnicc.wanted_chars ^
+		    card->options.vnicc.cur_chars;
 	chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
 	for_each_set_bit(i, &chars_tmp, chars_len) {
 		vnicc = BIT(i);

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

 		card->state = CARD_STATE_HARDSETUP;
 	}
 	if (card->state == CARD_STATE_HARDSETUP) {
-		qeth_qdio_clear_card(card, 0);
 		qeth_drain_output_queues(card);
 		qeth_clear_working_pool_list(card);
 		card->state = CARD_STATE_DOWN;
 	}
+	qeth_qdio_clear_card(card, 0);
 	flush_workqueue(card->event_wq);
 	card->info.promisc_mode = 0;
 }

drivers/s390/net/qeth_l3_sys.c+28−12

@@ -242,21 +242,33 @@ static ssize_t qeth_l3_dev_hsuid_store(struct device *dev, · 241 unmodified lines
242	struct device_attribute attr, const char buf, size_t count)	242	struct device_attribute attr, const char buf, size_t count)
243	{	243	{
244	struct qeth_card *card = dev_get_drvdata(dev);	244	struct qeth_card *card = dev_get_drvdata(dev);
		245	int rc = 0;
245	char *tmp;	246	char *tmp;
246	int rc;
247		247
248	if (!IS_IQD(card))	248	if (!IS_IQD(card))
249	return -EPERM;	249	return -EPERM;
250	if (card->state != CARD_STATE_DOWN)	250
251	return -EPERM;	251	mutex_lock(&card->conf_mutex);
252	if (card->options.sniffer)	252	if (card->state != CARD_STATE_DOWN) {
253	return -EPERM;	253	rc = -EPERM;
254	if (card->options.cq == QETH_CQ_NOTAVAILABLE)	254	goto out;
255	return -EPERM;	255	}
		256
		257	if (card->options.sniffer) {
		258	rc = -EPERM;
		259	goto out;
		260	}
		261
		262	if (card->options.cq == QETH_CQ_NOTAVAILABLE) {
		263	rc = -EPERM;
		264	goto out;
		265	}
256		266
257	tmp = strsep((char **)&buf, "\n");	267	tmp = strsep((char **)&buf, "\n");
258	if (strlen(tmp) > 8)	268	if (strlen(tmp) > 8) {
259	return -EINVAL;	269	rc = -EINVAL;
		270	goto out;
		271	}
260		272
261	if (card->options.hsuid[0])	273	if (card->options.hsuid[0])
262	/* delete old ip address */	274	/* delete old ip address */
@@ -267,11 +279,13 @@ static ssize_t qeth_l3_dev_hsuid_store(struct device *dev, · 4 unmodified lines
267	card->options.hsuid[0] = '\0';	279	card->options.hsuid[0] = '\0';
268	memcpy(card->dev->perm_addr, card->options.hsuid, 9);	280	memcpy(card->dev->perm_addr, card->options.hsuid, 9);
269	qeth_configure_cq(card, QETH_CQ_DISABLED);	281	qeth_configure_cq(card, QETH_CQ_DISABLED);
270	return count;	282	goto out;
271	}	283	}
272		284
273	if (qeth_configure_cq(card, QETH_CQ_ENABLED))	285	if (qeth_configure_cq(card, QETH_CQ_ENABLED)) {
274	return -EPERM;	286	rc = -EPERM;
		287	goto out;
		288	}
275		289
276	snprintf(card->options.hsuid, sizeof(card->options.hsuid),	290	snprintf(card->options.hsuid, sizeof(card->options.hsuid),
277	"%-8s", tmp);	291	"%-8s", tmp);
@@ -280,6 +294,8 @@ static ssize_t qeth_l3_dev_hsuid_store(struct device *dev, · 2 unmodified lines
280		294
281	rc = qeth_l3_modify_hsuid(card, true);	295	rc = qeth_l3_modify_hsuid(card, true);
282		296
		297	out:
		298	mutex_unlock(&card->conf_mutex);
283	return rc ? rc : count;	299	return rc ? rc : count;
284	}	300	}
285		301

drivers/scsi/cxgbi/libcxgbi.c+2−1

 		"cdev 0x%p, p# %u.\n", cdev, cdev->nports);
 	cxgbi_hbas_remove(cdev);
 	cxgbi_device_portmap_cleanup(cdev);
-	cxgbi_ppm_release(cdev->cdev2ppm(cdev));
+	if (cdev->cdev2ppm)
+		cxgbi_ppm_release(cdev->cdev2ppm(cdev));
 	if (cdev->pmap.max_connect)
 		cxgbi_free_big_mem(cdev->pmap.port_csk);
 	kfree(cdev);

drivers/scsi/lpfc/lpfc_debugfs.c+1−2

@@ -5385,7 +5385,6 @@ static const struct file_operations lpfc_debugfs_ras_log = { · 5384 unmodified lines
5385	.read = lpfc_debugfs_read,	5385	.read = lpfc_debugfs_read,
5386	.release = lpfc_debugfs_ras_log_release,	5386	.release = lpfc_debugfs_ras_log_release,
5387	};	5387	};
5388	#endif
5389		5388
5390	#undef lpfc_debugfs_op_dumpHBASlim	5389	#undef lpfc_debugfs_op_dumpHBASlim
5391	static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {	5390	static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {
@@ -5557,7 +5556,7 @@ static const struct file_operations lpfc_idiag_op_extAcc = { · 165 unmodified lines
5557	.write = lpfc_idiag_extacc_write,	5556	.write = lpfc_idiag_extacc_write,
5558	.release = lpfc_idiag_cmd_release,	5557	.release = lpfc_idiag_cmd_release,
5559	};	5558	};
5560		5559	#endif
5561		5560
5562	/* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command	5561	/* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command
5563	* @phba: Pointer to HBA context object.	5562	* @phba: Pointer to HBA context object.

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

@@ -5883,7 +5883,7 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba) · 5882 unmodified lines
5883	break;	5883	break;
5884	default:	5884	default:
5885	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5885	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5886	"1804 Invalid asynchrous event code: "	5886	"1804 Invalid asynchronous event code: "
5887	"x%x\n", bf_get(lpfc_trailer_code,	5887	"x%x\n", bf_get(lpfc_trailer_code,
5888	&cq_event->cqe.mcqe_cmpl));	5888	&cq_event->cqe.mcqe_cmpl));
5889	break;	5889	break;

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

@@ -8555,7 +8555,7 @@ lpfc_sli4_async_mbox_unblock(struct lpfc_hba *phba) · 8554 unmodified lines
8555	psli->sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;	8555	psli->sli_flag &= ~LPFC_SLI_ASYNC_MBX_BLK;
8556	spin_unlock_irq(&phba->hbalock);	8556	spin_unlock_irq(&phba->hbalock);
8557		8557
8558	/* wake up worker thread to post asynchronlous mailbox command */	8558	/* wake up worker thread to post asynchronous mailbox command */
8559	lpfc_worker_wake_up(phba);	8559	lpfc_worker_wake_up(phba);
8560	}	8560	}
8561		8561
@@ -8823,7 +8823,7 @@ lpfc_sli_issue_mbox_s4(struct lpfc_hba phba, LPFC_MBOXQ_t mboxq, · 261 unmodified lines
8823	return rc;	8823	return rc;
8824	}	8824	}
8825		8825
8826	/* Now, interrupt mode asynchrous mailbox command */	8826	/* Now, interrupt mode asynchronous mailbox command */
8827	rc = lpfc_mbox_cmd_check(phba, mboxq);	8827	rc = lpfc_mbox_cmd_check(phba, mboxq);
8828	if (rc) {	8828	if (rc) {
8829	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX \| LOG_SLI,	8829	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX \| LOG_SLI,
@@ -13112,11 +13112,11 @@ lpfc_cq_event_setup(struct lpfc_hba phba, void entry, int size) · 4282 unmodified lines
13112	}	13112	}
13113		13113
13114	/**	13114	/**
13115	* lpfc_sli4_sp_handle_async_event - Handle an asynchroous event	13115	* lpfc_sli4_sp_handle_async_event - Handle an asynchronous event
13116	* @phba: Pointer to HBA context object.	13116	* @phba: Pointer to HBA context object.
13117	* @cqe: Pointer to mailbox completion queue entry.	13117	* @cqe: Pointer to mailbox completion queue entry.
13118	*	13118	*
13119	* This routine process a mailbox completion queue entry with asynchrous	13119	* This routine process a mailbox completion queue entry with asynchronous
13120	* event.	13120	* event.
13121	*	13121	*
13122	* Return: true if work posted to worker thread, otherwise false.	13122	* Return: true if work posted to worker thread, otherwise false.
@@ -13270,7 +13270,7 @@ out_no_mqe_complete: · 147 unmodified lines
13270	* @cqe: Pointer to mailbox completion queue entry.	13270	* @cqe: Pointer to mailbox completion queue entry.
13271	*	13271	*
13272	* This routine process a mailbox completion queue entry, it invokes the	13272	* This routine process a mailbox completion queue entry, it invokes the
13273	* proper mailbox complete handling or asynchrous event handling routine	13273	* proper mailbox complete handling or asynchronous event handling routine
13274	* according to the MCQE's async bit.	13274	* according to the MCQE's async bit.
13275	*	13275	*
13276	* Return: true if work posted to worker thread, otherwise false.	13276	* Return: true if work posted to worker thread, otherwise false.

drivers/scsi/mpt3sas/mpt3sas_base.c+0−1

@@ -5248,7 +5248,6 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 5247 unmodified lines
5248	&ct->chain_buffer_dma);	5248	&ct->chain_buffer_dma);
5249	if (!ct->chain_buffer) {	5249	if (!ct->chain_buffer) {
5250	ioc_err(ioc, "chain_lookup: pci_pool_alloc failed\n");	5250	ioc_err(ioc, "chain_lookup: pci_pool_alloc failed\n");
5251	_base_release_memory_pools(ioc);
5252	goto out;	5251	goto out;
5253	}	5252	}
5254	}	5253	}

drivers/soc/sifive/sifive_l2_cache.c+1−1

@@ -9,7 +9,7 @@ · 8 unmodified lines
9	#include <linux/interrupt.h>	9	#include <linux/interrupt.h>
10	#include <linux/of_irq.h>	10	#include <linux/of_irq.h>
11	#include <linux/of_address.h>	11	#include <linux/of_address.h>
12	#include <asm/sifive_l2_cache.h>	12	#include <soc/sifive/sifive_l2_cache.h>
13		13
14	#define SIFIVE_L2_DIRECCFIX_LOW 0x100	14	#define SIFIVE_L2_DIRECCFIX_LOW 0x100
15	#define SIFIVE_L2_DIRECCFIX_HIGH 0x104	15	#define SIFIVE_L2_DIRECCFIX_HIGH 0x104

drivers/spi/spi-dw.c+12−3

@@ -172,9 +172,11 @@ static inline u32 rx_max(struct dw_spi *dws) · 171 unmodified lines
172		172
173	static void dw_writer(struct dw_spi *dws)	173	static void dw_writer(struct dw_spi *dws)
174	{	174	{
175	u32 max = tx_max(dws);	175	u32 max;
176	u16 txw = 0;	176	u16 txw = 0;
177		177
		178	spin_lock(&dws->buf_lock);
		179	max = tx_max(dws);
178	while (max--) {	180	while (max--) {
179	/* Set the tx word if the transfer's original "tx" is not null */	181	/* Set the tx word if the transfer's original "tx" is not null */
180	if (dws->tx_end - dws->len) {	182	if (dws->tx_end - dws->len) {
@@ -186,13 +188,16 @@ static void dw_writer(struct dw_spi *dws) · 5 unmodified lines
186	dw_write_io_reg(dws, DW_SPI_DR, txw);	188	dw_write_io_reg(dws, DW_SPI_DR, txw);
187	dws->tx += dws->n_bytes;	189	dws->tx += dws->n_bytes;
188	}	190	}
		191	spin_unlock(&dws->buf_lock);
189	}	192	}
190		193
191	static void dw_reader(struct dw_spi *dws)	194	static void dw_reader(struct dw_spi *dws)
192	{	195	{
193	u32 max = rx_max(dws);	196	u32 max;
194	u16 rxw;	197	u16 rxw;
195		198
		199	spin_lock(&dws->buf_lock);
		200	max = rx_max(dws);
196	while (max--) {	201	while (max--) {
197	rxw = dw_read_io_reg(dws, DW_SPI_DR);	202	rxw = dw_read_io_reg(dws, DW_SPI_DR);
198	/* Care rx only if the transfer's original "rx" is not null */	203	/* Care rx only if the transfer's original "rx" is not null */
@@ -204,6 +209,7 @@ static void dw_reader(struct dw_spi *dws) · 5 unmodified lines
204	}	209	}
205	dws->rx += dws->n_bytes;	210	dws->rx += dws->n_bytes;
206	}	211	}
		212	spin_unlock(&dws->buf_lock);
207	}	213	}
208		214
209	static void int_error_stop(struct dw_spi dws, const char msg)	215	static void int_error_stop(struct dw_spi dws, const char msg)
@@ -276,18 +282,20 @@ static int dw_spi_transfer_one(struct spi_controller *master, · 66 unmodified lines
276	{	282	{
277	struct dw_spi *dws = spi_controller_get_devdata(master);	283	struct dw_spi *dws = spi_controller_get_devdata(master);
278	struct chip_data *chip = spi_get_ctldata(spi);	284	struct chip_data *chip = spi_get_ctldata(spi);
		285	unsigned long flags;
279	u8 imask = 0;	286	u8 imask = 0;
280	u16 txlevel = 0;	287	u16 txlevel = 0;
281	u32 cr0;	288	u32 cr0;
282	int ret;	289	int ret;
283		290
284	dws->dma_mapped = 0;	291	dws->dma_mapped = 0;
285		292	spin_lock_irqsave(&dws->buf_lock, flags);
286	dws->tx = (void *)transfer->tx_buf;	293	dws->tx = (void *)transfer->tx_buf;
287	dws->tx_end = dws->tx + transfer->len;	294	dws->tx_end = dws->tx + transfer->len;
288	dws->rx = transfer->rx_buf;	295	dws->rx = transfer->rx_buf;
289	dws->rx_end = dws->rx + transfer->len;	296	dws->rx_end = dws->rx + transfer->len;
290	dws->len = transfer->len;	297	dws->len = transfer->len;
		298	spin_unlock_irqrestore(&dws->buf_lock, flags);
291		299
292	spi_enable_chip(dws, 0);	300	spi_enable_chip(dws, 0);
293		301
@@ -471,6 +479,7 @@ int dw_spi_add_host(struct device dev, struct dw_spi dws) · 177 unmodified lines
471	dws->type = SSI_MOTO_SPI;	479	dws->type = SSI_MOTO_SPI;
472	dws->dma_inited = 0;	480	dws->dma_inited = 0;
473	dws->dma_addr = (dma_addr_t)(dws->paddr + DW_SPI_DR);	481	dws->dma_addr = (dma_addr_t)(dws->paddr + DW_SPI_DR);
		482	spin_lock_init(&dws->buf_lock);
474		483
475	spi_controller_set_devdata(master, dws);	484	spi_controller_set_devdata(master, dws);
476		485

drivers/spi/spi-dw.h+1−0

@@ -119,6 +119,7 @@ struct dw_spi { · 118 unmodified lines
119	size_t len;	119	size_t len;
120	void *tx;	120	void *tx;
121	void *tx_end;	121	void *tx_end;
		122	spinlock_t buf_lock;
122	void *rx;	123	void *rx;
123	void *rx_end;	124	void *rx_end;
124	int dma_mapped;	125	int dma_mapped;

drivers/spi/spi-fsl-dspi.c+10−14

 	struct spi_transfer			*cur_transfer;
 	struct spi_message			*cur_msg;
 	struct chip_data			*cur_chip;
+	size_t					progress;
 	size_t					len;
 	const void				*tx;
 	void					*rx;
 	dspi->tx_cmd |= SPI_PUSHR_CMD_CTCNT;
 	if (dspi->devtype_data->xspi_mode && dspi->bits_per_word > 16) {
-		/* Write two TX FIFO entries first, and then the corresponding
+		/* Write the CMD FIFO entry first, and then the two
-		 * CMD FIFO entry.
+		 * corresponding TX FIFO entries.
 		 */
 		u32 data = dspi_pop_tx(dspi);
-		if (dspi->cur_chip->ctar_val & SPI_CTAR_LSBFE) {
-			/* LSB */
-			tx_fifo_write(dspi, data & 0xFFFF);
-			tx_fifo_write(dspi, data >> 16);
-		} else {
-			/* MSB */
-			tx_fifo_write(dspi, data >> 16);
-			tx_fifo_write(dspi, data & 0xFFFF);
-		}
 		cmd_fifo_write(dspi);
+		tx_fifo_write(dspi, data & 0xFFFF);
+		tx_fifo_write(dspi, data >> 16);
 	} else {
 		/* Write one entry to both TX FIFO and CMD FIFO
 		 * simultaneously.
 	u32 spi_tcr;
 	spi_take_timestamp_post(dspi->ctlr, dspi->cur_transfer,
-				dspi->tx - dspi->bytes_per_word, !dspi->irq);
+				dspi->progress, !dspi->irq);
 	/* Get transfer counter (in number of SPI transfers). It was
 	 * reset to 0 when transfer(s) were started.
 	spi_tcnt = SPI_TCR_GET_TCNT(spi_tcr);
 	/* Update total number of bytes that were transferred */
 	msg->actual_length += spi_tcnt * dspi->bytes_per_word;
+	dspi->progress += spi_tcnt;
 	trans_mode = dspi->devtype_data->trans_mode;
 	if (trans_mode == DSPI_EOQ_MODE)
 		return 0;
 	spi_take_timestamp_pre(dspi->ctlr, dspi->cur_transfer,
-			       dspi->tx, !dspi->irq);
+			       dspi->progress, !dspi->irq);
 	if (trans_mode == DSPI_EOQ_MODE)
 		dspi_eoq_write(dspi);
 		dspi->rx = transfer->rx_buf;
 		dspi->rx_end = dspi->rx + transfer->len;
 		dspi->len = transfer->len;
+		dspi->progress = 0;
 		/* Validated transfer specific frame size (defaults applied) */
 		dspi->bits_per_word = transfer->bits_per_word;
 		if (transfer->bits_per_word <= 8)
 				     SPI_CTARE_DTCP(1));
 		spi_take_timestamp_pre(dspi->ctlr, dspi->cur_transfer,
-				       dspi->tx, !dspi->irq);
+				       dspi->progress, !dspi->irq);
 		trans_mode = dspi->devtype_data->trans_mode;
 		switch (trans_mode) {

drivers/spi/spi-uniphier.c+19−12

 	}
 }
-static void uniphier_spi_fill_tx_fifo(struct uniphier_spi_priv *priv)
+static void uniphier_spi_set_fifo_threshold(struct uniphier_spi_priv *priv,
+					    unsigned int threshold)
 {
-	unsigned int fifo_threshold, fill_bytes;
 	u32 val;
-	fifo_threshold = DIV_ROUND_UP(priv->rx_bytes,
-				bytes_per_word(priv->bits_per_word));
-	fifo_threshold = min(fifo_threshold, SSI_FIFO_DEPTH);
-	fill_bytes = fifo_threshold - (priv->rx_bytes - priv->tx_bytes);
-	/* set fifo threshold */
 	val = readl(priv->base + SSI_FC);
 	val &= ~(SSI_FC_TXFTH_MASK | SSI_FC_RXFTH_MASK);
-	val |= FIELD_PREP(SSI_FC_TXFTH_MASK, fifo_threshold);
+	val |= FIELD_PREP(SSI_FC_TXFTH_MASK, SSI_FIFO_DEPTH - threshold);
-	val |= FIELD_PREP(SSI_FC_RXFTH_MASK, fifo_threshold);
+	val |= FIELD_PREP(SSI_FC_RXFTH_MASK, threshold);
 	writel(val, priv->base + SSI_FC);
+}
+static void uniphier_spi_fill_tx_fifo(struct uniphier_spi_priv *priv)
+{
+	unsigned int fifo_threshold, fill_words;
+	unsigned int bpw = bytes_per_word(priv->bits_per_word);
+	fifo_threshold = DIV_ROUND_UP(priv->rx_bytes, bpw);
+	fifo_threshold = min(fifo_threshold, SSI_FIFO_DEPTH);
+	uniphier_spi_set_fifo_threshold(priv, fifo_threshold);
+	fill_words = fifo_threshold -
+		DIV_ROUND_UP(priv->rx_bytes - priv->tx_bytes, bpw);
-	while (fill_bytes--)
+	while (fill_words--)
 		uniphier_spi_send(priv);
 }

drivers/spi/spi.c+8−14

  *			    advances its @tx buffer pointer monotonically.
  * @ctlr: Pointer to the spi_controller structure of the driver
  * @xfer: Pointer to the transfer being timestamped
- * @tx: Pointer to the current word within the xfer->tx_buf that the driver is
+ * @progress: How many words (not bytes) have been transferred so far
- *	preparing to transmit right now.
  * @irqs_off: If true, will disable IRQs and preemption for the duration of the
  *	      transfer, for less jitter in time measurement. Only compatible
  *	      with PIO drivers. If true, must follow up with
  */
 void spi_take_timestamp_pre(struct spi_controller *ctlr,
 			    struct spi_transfer *xfer,
-			    const void *tx, bool irqs_off)
+			    size_t progress, bool irqs_off)
 {
-	u8 bytes_per_word = DIV_ROUND_UP(xfer->bits_per_word, 8);
 	if (!xfer->ptp_sts)
 		return;
 	if (xfer->timestamped_pre)
 		return;
-	if (tx < (xfer->tx_buf + xfer->ptp_sts_word_pre * bytes_per_word))
+	if (progress < xfer->ptp_sts_word_pre)
 		return;
 	/* Capture the resolution of the timestamp */
-	xfer->ptp_sts_word_pre = (tx - xfer->tx_buf) / bytes_per_word;
+	xfer->ptp_sts_word_pre = progress;
 	xfer->timestamped_pre = true;
  *			     timestamped.
  * @ctlr: Pointer to the spi_controller structure of the driver
  * @xfer: Pointer to the transfer being timestamped
- * @tx: Pointer to the current word within the xfer->tx_buf that the driver has
+ * @progress: How many words (not bytes) have been transferred so far
- *	just transmitted.
  * @irqs_off: If true, will re-enable IRQs and preemption for the local CPU.
  */
 void spi_take_timestamp_post(struct spi_controller *ctlr,
 			     struct spi_transfer *xfer,
-			     const void *tx, bool irqs_off)
+			     size_t progress, bool irqs_off)
 {
-	u8 bytes_per_word = DIV_ROUND_UP(xfer->bits_per_word, 8);
 	if (!xfer->ptp_sts)
 		return;
 	if (xfer->timestamped_post)
 		return;
-	if (tx < (xfer->tx_buf + xfer->ptp_sts_word_post * bytes_per_word))
+	if (progress < xfer->ptp_sts_word_post)
 		return;
 	ptp_read_system_postts(xfer->ptp_sts);
 	}
 	/* Capture the resolution of the timestamp */
-	xfer->ptp_sts_word_post = (tx - xfer->tx_buf) / bytes_per_word;
+	xfer->ptp_sts_word_post = progress;
 	xfer->timestamped_post = true;
 }

drivers/staging/comedi/drivers/adv_pci1710.c+2−2

@@ -46,8 +46,8 @@ · 45 unmodified lines
46	#define PCI171X_RANGE_UNI BIT(4)	46	#define PCI171X_RANGE_UNI BIT(4)
47	#define PCI171X_RANGE_GAIN(x) (((x) & 0x7) << 0)	47	#define PCI171X_RANGE_GAIN(x) (((x) & 0x7) << 0)
48	#define PCI171X_MUX_REG 0x04 /* W: A/D multiplexor control */	48	#define PCI171X_MUX_REG 0x04 /* W: A/D multiplexor control */
49	#define PCI171X_MUX_CHANH(x) (((x) & 0xf) << 8)	49	#define PCI171X_MUX_CHANH(x) (((x) & 0xff) << 8)
50	#define PCI171X_MUX_CHANL(x) (((x) & 0xf) << 0)	50	#define PCI171X_MUX_CHANL(x) (((x) & 0xff) << 0)
51	#define PCI171X_MUX_CHAN(x) (PCI171X_MUX_CHANH(x) \| PCI171X_MUX_CHANL(x))	51	#define PCI171X_MUX_CHAN(x) (PCI171X_MUX_CHANH(x) \| PCI171X_MUX_CHANL(x))
52	#define PCI171X_STATUS_REG 0x06 /* R: status register */	52	#define PCI171X_STATUS_REG 0x06 /* R: status register */
53	#define PCI171X_STATUS_IRQ BIT(11) /* 1=IRQ occurred */	53	#define PCI171X_STATUS_IRQ BIT(11) /* 1=IRQ occurred */

drivers/staging/media/ipu3/include/intel-ipu3.h+1−1

@@ -449,7 +449,7 @@ struct ipu3_uapi_awb_fr_config_s { · 448 unmodified lines
449	__u16 reserved1;	449	__u16 reserved1;
450	__u32 bayer_sign;	450	__u32 bayer_sign;
451	__u8 bayer_nf;	451	__u8 bayer_nf;
452	__u8 reserved2[3];	452	__u8 reserved2[7];
453	} __attribute__((aligned(32))) __packed;	453	} __attribute__((aligned(32))) __packed;
454		454
455	/**	455	/**

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

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

drivers/staging/vt6656/baseband.c+2−2

@@ -449,8 +449,8 @@ int vnt_vt3184_init(struct vnt_private *priv) · 448 unmodified lines
449		449
450	memcpy(array, addr, length);	450	memcpy(array, addr, length);
451		451
452	ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,	452	ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
453	MESSAGE_REQUEST_BBREG, length, array);	453	MESSAGE_REQUEST_BBREG, length, array);
454	if (ret)	454	if (ret)
455	goto end;	455	goto end;
456		456

drivers/staging/vt6656/card.c+1−1

@@ -719,7 +719,7 @@ end: · 718 unmodified lines
719	*/	719	*/
720	int vnt_radio_power_on(struct vnt_private *priv)	720	int vnt_radio_power_on(struct vnt_private *priv)
721	{	721	{
722	int ret = true;	722	int ret = 0;
723		723
724	vnt_exit_deep_sleep(priv);	724	vnt_exit_deep_sleep(priv);
725		725

drivers/staging/vt6656/device.h+1−0

@@ -259,6 +259,7 @@ struct vnt_private { · 258 unmodified lines
259	u8 mac_hw;	259	u8 mac_hw;
260	/* netdev */	260	/* netdev */
261	struct usb_device *usb;	261	struct usb_device *usb;
		262	struct usb_interface *intf;
262		263
263	u64 tsf_time;	264	u64 tsf_time;
264	u8 rx_rate;	265	u8 rx_rate;

drivers/staging/vt6656/main_usb.c+2−1

 int vnt_init(struct vnt_private *priv)
 {
-	if (!(vnt_init_registers(priv)))
+	if (vnt_init_registers(priv))
 		return -EAGAIN;
 	SET_IEEE80211_PERM_ADDR(priv->hw, priv->permanent_net_addr);
 	priv = hw->priv;
 	priv->hw = hw;
 	priv->usb = udev;
+	priv->intf = intf;
 	vnt_set_options(priv);

drivers/staging/vt6656/usbpipe.c+23−2

@@ -59,7 +59,9 @@ int vnt_control_out(struct vnt_private *priv, u8 request, u16 value, · 58 unmodified lines
59		59
60	kfree(usb_buffer);	60	kfree(usb_buffer);
61		61
62	if (ret >= 0 && ret < (int)length)	62	if (ret == (int)length)
		63	ret = 0;
		64	else
63	ret = -EIO;	65	ret = -EIO;
64		66
65	end_unlock:	67	end_unlock:
@@ -74,6 +76,23 @@ int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data) · 8 unmodified lines
74	reg_off, reg, sizeof(u8), &data);	76	reg_off, reg, sizeof(u8), &data);
75	}	77	}
76		78
		79	int vnt_control_out_blocks(struct vnt_private *priv,
		80	u16 block, u8 reg, u16 length, u8 *data)
		81	{
		82	int ret = 0, i;
		83
		84	for (i = 0; i < length; i += block) {
		85	u16 len = min_t(int, length - i, block);
		86
		87	ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE,
		88	i, reg, len, data + i);
		89	if (ret)
		90	goto end;
		91	}
		92	end:
		93	return ret;
		94	}
		95
77	int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,	96	int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
78	u16 index, u16 length, u8 *buffer)	97	u16 index, u16 length, u8 *buffer)
79	{	98	{
@@ -103,7 +122,9 @@ int vnt_control_in(struct vnt_private *priv, u8 request, u16 value, · 23 unmodified lines
103		122
104	kfree(usb_buffer);	123	kfree(usb_buffer);
105		124
106	if (ret >= 0 && ret < (int)length)	125	if (ret == (int)length)
		126	ret = 0;
		127	else
107	ret = -EIO;	128	ret = -EIO;
108		129
109	end_unlock:	130	end_unlock:

drivers/staging/vt6656/usbpipe.h+5−0

 #include "device.h"
+#define VNT_REG_BLOCK_SIZE	64
 int vnt_control_out(struct vnt_private *priv, u8 request, u16 value,
 		    u16 index, u16 length, u8 *buffer);
 int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
 int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 ref_off, u8 data);
 int vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data);
+int vnt_control_out_blocks(struct vnt_private *priv,
+			   u16 block, u8 reg, u16 len, u8 *data);
 int vnt_start_interrupt_urb(struct vnt_private *priv);
 int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb);
 int vnt_tx_context(struct vnt_private *priv,

drivers/staging/vt6656/wcmd.c+1−0

@@ -99,6 +99,7 @@ void vnt_run_command(struct work_struct *work) · 98 unmodified lines
99	if (vnt_init(priv)) {	99	if (vnt_init(priv)) {
100	/* If fail all ends TODO retry */	100	/* If fail all ends TODO retry */
101	dev_err(&priv->usb->dev, "failed to start\n");	101	dev_err(&priv->usb->dev, "failed to start\n");
		102	usb_set_intfdata(priv->intf, NULL);
102	ieee80211_free_hw(priv->hw);	103	ieee80211_free_hw(priv->hw);
103	return;	104	return;
104	}	105	}

drivers/target/target_core_iblock.c+3−1

@@ -646,7 +646,9 @@ iblock_alloc_bip(struct se_cmd cmd, struct bio bio, · 645 unmodified lines
646	}	646	}
647		647
648	bip->bip_iter.bi_size = bio_integrity_bytes(bi, bio_sectors(bio));	648	bip->bip_iter.bi_size = bio_integrity_bytes(bi, bio_sectors(bio));
649	bip_set_seed(bip, bio->bi_iter.bi_sector);	649	/* virtual start sector must be in integrity interval units */
		650	bip_set_seed(bip, bio->bi_iter.bi_sector >>
		651	(bi->interval_exp - SECTOR_SHIFT));
650		652
651	pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,	653	pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,
652	(unsigned long long)bip->bip_iter.bi_sector);	654	(unsigned long long)bip->bip_iter.bi_sector);

drivers/thermal/qcom/tsens.c+3−0

 	irq = platform_get_irq_byname(pdev, "uplow");
 	if (irq < 0) {
 		ret = irq;
+		/* For old DTs with no IRQ defined */
+		if (irq == -ENXIO)
+			ret = 0;
 		goto err_put_device;
 	}

drivers/tty/serdev/core.c+10−0

 	return AE_OK;
 }
+static const struct acpi_device_id serdev_acpi_devices_blacklist[] = {
+	{ "INT3511", 0 },
+	{ "INT3512", 0 },
+	{ },
+};
 static acpi_status acpi_serdev_add_device(acpi_handle handle, u32 level,
 					  void *data, void **return_value)
 {
 	if (acpi_device_enumerated(adev))
 		return AE_OK;
+	/* Skip if black listed */
+	if (!acpi_match_device_ids(adev, serdev_acpi_devices_blacklist))
+		return AE_OK;
 	if (acpi_serdev_check_resources(ctrl, adev))
 		return AE_OK;

drivers/tty/tty_port.c+1−2

@@ -89,8 +89,7 @@ void tty_port_link_device(struct tty_port *port, · 88 unmodified lines
89	{	89	{
90	if (WARN_ON(index >= driver->num))	90	if (WARN_ON(index >= driver->num))
91	return;	91	return;
92	if (!driver->ports[index])	92	driver->ports[index] = port;
93	driver->ports[index] = port;
94	}	93	}
95	EXPORT_SYMBOL_GPL(tty_port_link_device);	94	EXPORT_SYMBOL_GPL(tty_port_link_device);
96		95

drivers/usb/cdns3/gadget.c+5−9

  */
 static irqreturn_t cdns3_device_irq_handler(int irq, void *data)
 {
-	struct cdns3_device *priv_dev;
+	struct cdns3_device *priv_dev = data;
-	struct cdns3 *cdns = data;
 	irqreturn_t ret = IRQ_NONE;
 	u32 reg;
-	priv_dev = cdns->gadget_dev;
 	/* check USB device interrupt */
 	reg = readl(&priv_dev->regs->usb_ists);
 	if (reg) {
  */
 static irqreturn_t cdns3_device_thread_irq_handler(int irq, void *data)
 {
-	struct cdns3_device *priv_dev;
+	struct cdns3_device *priv_dev = data;
-	struct cdns3 *cdns = data;
 	irqreturn_t ret = IRQ_NONE;
 	unsigned long flags;
 	int bit;
 	u32 reg;
-	priv_dev = cdns->gadget_dev;
 	spin_lock_irqsave(&priv_dev->lock, flags);
 	reg = readl(&priv_dev->regs->usb_ists);
 	priv_dev = cdns->gadget_dev;
-	devm_free_irq(cdns->dev, cdns->dev_irq, cdns);
+	devm_free_irq(cdns->dev, cdns->dev_irq, priv_dev);
 	pm_runtime_mark_last_busy(cdns->dev);
 	pm_runtime_put_autosuspend(cdns->dev);
 	ret = devm_request_threaded_irq(cdns->dev, cdns->dev_irq,
 					cdns3_device_irq_handler,
 					cdns3_device_thread_irq_handler,
-					IRQF_SHARED, dev_name(cdns->dev), cdns);
+					IRQF_SHARED, dev_name(cdns->dev),
+					cdns->gadget_dev);
 	if (ret)
 		goto err0;

drivers/usb/chipidea/host.c+3−1

 struct ehci_ci_priv {
 	struct regulator *reg_vbus;
+	bool enabled;
 };
 static int ehci_ci_portpower(struct usb_hcd *hcd, int portnum, bool enable)
 	int ret = 0;
 	int port = HCS_N_PORTS(ehci->hcs_params);
-	if (priv->reg_vbus) {
+	if (priv->reg_vbus && enable != priv->enabled) {
 		if (port > 1) {
 			dev_warn(dev,
 				"Not support multi-port regulator control\n");
 				enable ? "enable" : "disable", ret);
 			return ret;
 		}
+		priv->enabled = enable;
 	}
 	if (enable && (ci->platdata->phy_mode == USBPHY_INTERFACE_MODE_HSIC)) {

drivers/usb/core/config.c+66−16

@@ -203,9 +203,58 @@ static const unsigned short super_speed_maxpacket_maxes[4] = { · 202 unmodified lines
203	[USB_ENDPOINT_XFER_INT] = 1024,	203	[USB_ENDPOINT_XFER_INT] = 1024,
204	};	204	};
205		205
206	static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,	206	static bool endpoint_is_duplicate(struct usb_endpoint_descriptor *e1,
207	int asnum, struct usb_host_interface *ifp, int num_ep,	207	struct usb_endpoint_descriptor *e2)
208	unsigned char *buffer, int size)	208	{
		209	if (e1->bEndpointAddress == e2->bEndpointAddress)
		210	return true;
		211
		212	if (usb_endpoint_xfer_control(e1) \|\| usb_endpoint_xfer_control(e2)) {
		213	if (usb_endpoint_num(e1) == usb_endpoint_num(e2))
		214	return true;
		215	}
		216
		217	return false;
		218	}
		219
		220	/*
		221	* Check for duplicate endpoint addresses in other interfaces and in the
		222	* altsetting currently being parsed.
		223	*/
		224	static bool config_endpoint_is_duplicate(struct usb_host_config *config,
		225	int inum, int asnum, struct usb_endpoint_descriptor *d)
		226	{
		227	struct usb_endpoint_descriptor *epd;
		228	struct usb_interface_cache *intfc;
		229	struct usb_host_interface *alt;
		230	int i, j, k;
		231
		232	for (i = 0; i < config->desc.bNumInterfaces; ++i) {
		233	intfc = config->intf_cache[i];
		234
		235	for (j = 0; j < intfc->num_altsetting; ++j) {
		236	alt = &intfc->altsetting[j];
		237
		238	if (alt->desc.bInterfaceNumber == inum &&
		239	alt->desc.bAlternateSetting != asnum)
		240	continue;
		241
		242	for (k = 0; k < alt->desc.bNumEndpoints; ++k) {
		243	epd = &alt->endpoint[k].desc;
		244
		245	if (endpoint_is_duplicate(epd, d))
		246	return true;
		247	}
		248	}
		249	}
		250
		251	return false;
		252	}
		253
		254	static int usb_parse_endpoint(struct device *ddev, int cfgno,
		255	struct usb_host_config *config, int inum, int asnum,
		256	struct usb_host_interface *ifp, int num_ep,
		257	unsigned char *buffer, int size)
209	{	258	{
210	unsigned char *buffer0 = buffer;	259	unsigned char *buffer0 = buffer;
211	struct usb_endpoint_descriptor *d;	260	struct usb_endpoint_descriptor *d;
@@ -242,13 +291,10 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, · 30 unmodified lines
242	goto skip_to_next_endpoint_or_interface_descriptor;	291	goto skip_to_next_endpoint_or_interface_descriptor;
243		292
244	/* Check for duplicate endpoint addresses */	293	/* Check for duplicate endpoint addresses */
245	for (i = 0; i < ifp->desc.bNumEndpoints; ++i) {	294	if (config_endpoint_is_duplicate(config, inum, asnum, d)) {
246	if (ifp->endpoint[i].desc.bEndpointAddress ==	295	dev_warn(ddev, "config %d interface %d altsetting %d has a duplicate endpoint with address 0x%X, skipping\n",
247	d->bEndpointAddress) {	296	cfgno, inum, asnum, d->bEndpointAddress);
248	dev_warn(ddev, "config %d interface %d altsetting %d has a duplicate endpoint with address 0x%X, skipping\n",	297	goto skip_to_next_endpoint_or_interface_descriptor;
249	cfgno, inum, asnum, d->bEndpointAddress);
250	goto skip_to_next_endpoint_or_interface_descriptor;
251	}
252	}	298	}
253		299
254	endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints];	300	endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints];
@@ -346,12 +392,16 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, · 91 unmodified lines
346	endpoint->desc.wMaxPacketSize = cpu_to_le16(8);	392	endpoint->desc.wMaxPacketSize = cpu_to_le16(8);
347	}	393	}
348		394
349	/* Validate the wMaxPacketSize field */	395	/*
		396	* Validate the wMaxPacketSize field.
		397	* Some devices have isochronous endpoints in altsetting 0;
		398	* the USB-2 spec requires such endpoints to have wMaxPacketSize = 0
		399	* (see the end of section 5.6.3), so don't warn about them.
		400	*/
350	maxp = usb_endpoint_maxp(&endpoint->desc);	401	maxp = usb_endpoint_maxp(&endpoint->desc);
351	if (maxp == 0) {	402	if (maxp == 0 && !(usb_endpoint_xfer_isoc(d) && asnum == 0)) {
352	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has wMaxPacketSize 0, skipping\n",	403	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has invalid wMaxPacketSize 0\n",
353	cfgno, inum, asnum, d->bEndpointAddress);	404	cfgno, inum, asnum, d->bEndpointAddress);
354	goto skip_to_next_endpoint_or_interface_descriptor;
355	}	405	}
356		406
357	/* Find the highest legal maxpacket size for this endpoint */	407	/* Find the highest legal maxpacket size for this endpoint */
@@ -522,8 +572,8 @@ static int usb_parse_interface(struct device *ddev, int cfgno, · 164 unmodified lines
522	if (((struct usb_descriptor_header *) buffer)->bDescriptorType	572	if (((struct usb_descriptor_header *) buffer)->bDescriptorType
523	== USB_DT_INTERFACE)	573	== USB_DT_INTERFACE)
524	break;	574	break;
525	retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt,	575	retval = usb_parse_endpoint(ddev, cfgno, config, inum, asnum,
526	num_ep, buffer, size);	576	alt, num_ep, buffer, size);
527	if (retval < 0)	577	if (retval < 0)
528	return retval;	578	return retval;
529	++n;	579	++n;

drivers/usb/core/hub.c+1−1

@@ -2692,7 +2692,7 @@ static unsigned hub_is_wusb(struct usb_hub *hub) · 2691 unmodified lines
2692	#define SET_ADDRESS_TRIES 2	2692	#define SET_ADDRESS_TRIES 2
2693	#define GET_DESCRIPTOR_TRIES 2	2693	#define GET_DESCRIPTOR_TRIES 2
2694	#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))	2694	#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
2695	#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)scheme)	2695	#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)(scheme))
2696		2696
2697	#define HUB_ROOT_RESET_TIME 60 /* times are in msec */	2697	#define HUB_ROOT_RESET_TIME 60 /* times are in msec */
2698	#define HUB_SHORT_RESET_TIME 10	2698	#define HUB_SHORT_RESET_TIME 10

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

@@ -2467,6 +2467,13 @@ static int dwc3_gadget_ep_reclaim_trb_linear(struct dwc3_ep *dep, · 2466 unmodified lines
2467		2467
2468	static bool dwc3_gadget_ep_request_completed(struct dwc3_request *req)	2468	static bool dwc3_gadget_ep_request_completed(struct dwc3_request *req)
2469	{	2469	{
		2470	/*
		2471	* For OUT direction, host may send less than the setup
		2472	* length. Return true for all OUT requests.
		2473	*/
		2474	if (!req->direction)
		2475	return true;
		2476
2470	return req->request.actual == req->request.length;	2477	return req->request.actual == req->request.length;
2471	}	2478	}
2472		2479

drivers/usb/gadget/udc/Kconfig+1−0

@@ -445,6 +445,7 @@ config USB_TEGRA_XUDC · 444 unmodified lines
445	tristate "NVIDIA Tegra Superspeed USB 3.0 Device Controller"	445	tristate "NVIDIA Tegra Superspeed USB 3.0 Device Controller"
446	depends on ARCH_TEGRA \|\| COMPILE_TEST	446	depends on ARCH_TEGRA \|\| COMPILE_TEST
447	depends on PHY_TEGRA_XUSB	447	depends on PHY_TEGRA_XUSB
		448	select USB_ROLE_SWITCH
448	help	449	help
449	Enables NVIDIA Tegra USB 3.0 device mode controller driver.	450	Enables NVIDIA Tegra USB 3.0 device mode controller driver.
450		451

drivers/usb/host/ohci-da8xx.c+6−2

 	}
 	da8xx_ohci->oc_gpio = devm_gpiod_get_optional(dev, "oc", GPIOD_IN);
-	if (IS_ERR(da8xx_ohci->oc_gpio))
+	if (IS_ERR(da8xx_ohci->oc_gpio)) {
+		error = PTR_ERR(da8xx_ohci->oc_gpio);
 		goto err;
+	}
 	if (da8xx_ohci->oc_gpio) {
 		oc_irq = gpiod_to_irq(da8xx_ohci->oc_gpio);
-		if (oc_irq < 0)
+		if (oc_irq < 0) {
+			error = oc_irq;
 			goto err;
+		}
 		error = devm_request_threaded_irq(dev, oc_irq, NULL,
 				ohci_da8xx_oc_thread, IRQF_TRIGGER_RISING |

drivers/usb/musb/jz4740.c+5−2

 static int jz4740_musb_init(struct musb *musb)
 {
 	struct device *dev = musb->controller->parent;
+	int err;
 	if (dev->of_node)
 		musb->xceiv = devm_usb_get_phy_by_phandle(dev, "phys", 0);
 	else
 		musb->xceiv = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
 	if (IS_ERR(musb->xceiv)) {
-		dev_err(dev, "No transceiver configured\n");
+		err = PTR_ERR(musb->xceiv);
-		return PTR_ERR(musb->xceiv);
+		if (err != -EPROBE_DEFER)
+			dev_err(dev, "No transceiver configured: %d", err);
+		return err;
 	}
 	/* Silicon does not implement ConfigData register.

drivers/usb/musb/musb_core.c+11−0

 #define MUSB_QUIRK_B_INVALID_VBUS_91	(MUSB_DEVCTL_BDEVICE | \
 					 (2 << MUSB_DEVCTL_VBUS_SHIFT) | \
 					 MUSB_DEVCTL_SESSION)
+#define MUSB_QUIRK_B_DISCONNECT_99	(MUSB_DEVCTL_BDEVICE | \
+					 (3 << MUSB_DEVCTL_VBUS_SHIFT) | \
+					 MUSB_DEVCTL_SESSION)
 #define MUSB_QUIRK_A_DISCONNECT_19	((3 << MUSB_DEVCTL_VBUS_SHIFT) | \
 					 MUSB_DEVCTL_SESSION)
 	s = MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV |
 		MUSB_DEVCTL_HR;
 	switch (devctl & ~s) {
+	case MUSB_QUIRK_B_DISCONNECT_99:
+		musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
+		schedule_delayed_work(&musb->irq_work,
+				      msecs_to_jiffies(1000));
+		break;
 	case MUSB_QUIRK_B_INVALID_VBUS_91:
 		if (musb->quirk_retries && !musb->flush_irq_work) {
 			musb_dbg(musb,
 	musb_disable_interrupts(musb);
 	musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+	/* MUSB_POWER_SOFTCONN might be already set, JZ4740 does this. */
+	musb_writeb(musb->mregs, MUSB_POWER, 0);
 	/* Init IRQ workqueue before request_irq */
 	INIT_DELAYED_WORK(&musb->irq_work, musb_irq_work);
 	INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);

drivers/usb/musb/musbhsdma.c+1−1

@@ -425,7 +425,7 @@ struct dma_controller musbhs_dma_controller_create(struct musb musb, · 424 unmodified lines
425	controller->controller.channel_abort = dma_channel_abort;	425	controller->controller.channel_abort = dma_channel_abort;
426		426
427	if (request_irq(irq, dma_controller_irq, 0,	427	if (request_irq(irq, dma_controller_irq, 0,
428	dev_name(musb->controller), &controller->controller)) {	428	dev_name(musb->controller), controller)) {
429	dev_err(dev, "request_irq %d failed!\n", irq);	429	dev_err(dev, "request_irq %d failed!\n", irq);
430	musb_dma_controller_destroy(&controller->controller);	430	musb_dma_controller_destroy(&controller->controller);
431		431

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

 /* Interface must have two endpoints */
 #define NUMEP2		BIT(16)
+/* Device needs ZLP */
+#define ZLP		BIT(17)
 static const struct usb_device_id option_ids[] = {
 	{ USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
 	  .driver_info = NCTRL(0) | RSVD(3) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1102, 0xff),	/* Telit ME910 (ECM) */
 	  .driver_info = NCTRL(0) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110a, 0xff),	/* Telit ME910G1 */
+	  .driver_info = NCTRL(0) | RSVD(3) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910),
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910_USBCFG4),
 	  .driver_info = NCTRL(0) | RSVD(1) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1901, 0xff),	/* Telit LN940 (MBIM) */
 	  .driver_info = NCTRL(0) },
+	{ USB_DEVICE(TELIT_VENDOR_ID, 0x9010),				/* Telit SBL FN980 flashing device */
+	  .driver_info = NCTRL(0) | ZLP },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0002, 0xff, 0xff, 0xff),
 	  .driver_info = RSVD(1) },
 	if (!(device_flags & NCTRL(iface_desc->bInterfaceNumber)))
 		data->use_send_setup = 1;
+	if (device_flags & ZLP)
+		data->use_zlp = 1;
 	spin_lock_init(&data->susp_lock);
 	usb_set_serial_data(serial, data);

drivers/usb/serial/usb-wwan.h+1−0

@@ -38,6 +38,7 @@ struct usb_wwan_intf_private { · 37 unmodified lines
38	spinlock_t susp_lock;	38	spinlock_t susp_lock;
39	unsigned int suspended:1;	39	unsigned int suspended:1;
40	unsigned int use_send_setup:1;	40	unsigned int use_send_setup:1;
		41	unsigned int use_zlp:1;
41	int in_flight;	42	int in_flight;
42	unsigned int open_ports;	43	unsigned int open_ports;
43	void *private;	44	void *private;

drivers/usb/serial/usb_wwan.c+4−0

 				      void (*callback) (struct urb *))
 {
 	struct usb_serial *serial = port->serial;
+	struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 	struct urb *urb;
 	urb = usb_alloc_urb(0, GFP_KERNEL);	/* No ISO */
 			  usb_sndbulkpipe(serial->dev, endpoint) | dir,
 			  buf, len, callback, ctx);
+	if (intfdata->use_zlp && dir == USB_DIR_OUT)
+		urb->transfer_flags |= URB_ZERO_PACKET;
 	return urb;
 }

drivers/usb/typec/tcpm/tcpci.c+15−5

 	if (status & TCPC_ALERT_RX_STATUS) {
 		struct pd_message msg;
-		unsigned int cnt;
+		unsigned int cnt, payload_cnt;
 		u16 header;
 		regmap_read(tcpci->regmap, TCPC_RX_BYTE_CNT, &cnt);
+		/*
+		 * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14
+		 * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is
+		 * defined in table 4-36 as one greater than the number of
+		 * bytes received. And that number includes the header. So:
+		 */
+		if (cnt > 3)
+			payload_cnt = cnt - (1 + sizeof(msg.header));
+		else
+			payload_cnt = 0;
 		tcpci_read16(tcpci, TCPC_RX_HDR, &header);
 		msg.header = cpu_to_le16(header);
-		if (WARN_ON(cnt > sizeof(msg.payload)))
+		if (WARN_ON(payload_cnt > sizeof(msg.payload)))
-			cnt = sizeof(msg.payload);
+			payload_cnt = sizeof(msg.payload);
-		if (cnt > 0)
+		if (payload_cnt > 0)
 			regmap_raw_read(tcpci->regmap, TCPC_RX_DATA,
-					&msg.payload, cnt);
+					&msg.payload, payload_cnt);
 		/* Read complete, clear RX status alert bit */
 		tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS);

drivers/usb/typec/ucsi/ucsi.h+9−9

drivers/watchdog/Kconfig+2−0

 config MAX77620_WATCHDOG
 	tristate "Maxim Max77620 Watchdog Timer"
 	depends on MFD_MAX77620 || COMPILE_TEST
+	select WATCHDOG_CORE
 	help
 	 This is the driver for the Max77620 watchdog timer.
 	 Say 'Y' here to enable the watchdog timer support for
 config TQMX86_WDT
 	tristate "TQ-Systems TQMX86 Watchdog Timer"
 	depends on X86
+	select WATCHDOG_CORE
 	help
 	This is the driver for the hardware watchdog timer in the TQMX86 IO
 	controller found on some of their ComExpress Modules.

drivers/watchdog/imx7ulp_wdt.c+1−1

@@ -112,7 +112,7 @@ static int imx7ulp_wdt_restart(struct watchdog_device *wdog, · 111 unmodified lines
112	{	112	{
113	struct imx7ulp_wdt_device *wdt = watchdog_get_drvdata(wdog);	113	struct imx7ulp_wdt_device *wdt = watchdog_get_drvdata(wdog);
114		114
115	imx7ulp_wdt_enable(wdt->base, true);	115	imx7ulp_wdt_enable(wdog, true);
116	imx7ulp_wdt_set_timeout(&wdt->wdd, 1);	116	imx7ulp_wdt_set_timeout(&wdt->wdd, 1);
117		117
118	/* wait for wdog to fire */	118	/* wait for wdog to fire */

drivers/watchdog/orion_wdt.c+2−2

@@ -602,7 +602,7 @@ static int orion_wdt_probe(struct platform_device *pdev) · 601 unmodified lines
602	set_bit(WDOG_HW_RUNNING, &dev->wdt.status);	602	set_bit(WDOG_HW_RUNNING, &dev->wdt.status);
603		603
604	/* Request the IRQ only after the watchdog is disabled */	604	/* Request the IRQ only after the watchdog is disabled */
605	irq = platform_get_irq(pdev, 0);	605	irq = platform_get_irq_optional(pdev, 0);
606	if (irq > 0) {	606	if (irq > 0) {
607	/*	607	/*
608	* Not all supported platforms specify an interrupt for the	608	* Not all supported platforms specify an interrupt for the
@@ -617,7 +617,7 @@ static int orion_wdt_probe(struct platform_device *pdev) · 8 unmodified lines
617	}	617	}
618		618
619	/* Optional 2nd interrupt for pretimeout */	619	/* Optional 2nd interrupt for pretimeout */
620	irq = platform_get_irq(pdev, 1);	620	irq = platform_get_irq_optional(pdev, 1);
621	if (irq > 0) {	621	if (irq > 0) {
622	orion_wdt_info.options \|= WDIOF_PRETIMEOUT;	622	orion_wdt_info.options \|= WDIOF_PRETIMEOUT;
623	ret = devm_request_irq(&pdev->dev, irq, orion_wdt_pre_irq,	623	ret = devm_request_irq(&pdev->dev, irq, orion_wdt_pre_irq,

drivers/watchdog/rn5t618_wdt.c+1−0

@@ -188,6 +188,7 @@ static struct platform_driver rn5t618_wdt_driver = { · 187 unmodified lines
188		188
189	module_platform_driver(rn5t618_wdt_driver);	189	module_platform_driver(rn5t618_wdt_driver);
190		190
		191	MODULE_ALIAS("platform:rn5t618-wdt");
191	MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");	192	MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");
192	MODULE_DESCRIPTION("RN5T618 watchdog driver");	193	MODULE_DESCRIPTION("RN5T618 watchdog driver");
193	MODULE_LICENSE("GPL v2");	194	MODULE_LICENSE("GPL v2");

drivers/watchdog/w83627hf_wdt.c+1−1

@@ -420,7 +420,7 @@ static int wdt_find(int addr) · 419 unmodified lines
420	cr_wdt_csr = NCT6102D_WDT_CSR;	420	cr_wdt_csr = NCT6102D_WDT_CSR;
421	break;	421	break;
422	case NCT6116_ID:	422	case NCT6116_ID:
423	ret = nct6102;	423	ret = nct6116;
424	cr_wdt_timeout = NCT6102D_WDT_TIMEOUT;	424	cr_wdt_timeout = NCT6102D_WDT_TIMEOUT;
425	cr_wdt_control = NCT6102D_WDT_CONTROL;	425	cr_wdt_control = NCT6102D_WDT_CONTROL;
426	cr_wdt_csr = NCT6102D_WDT_CSR;	426	cr_wdt_csr = NCT6102D_WDT_CSR;

fs/btrfs/compression.c+6−1

 	if (blkcg_css) {
 		bio->bi_opf |= REQ_CGROUP_PUNT;
-		bio_associate_blkg_from_css(bio, blkcg_css);
+		kthread_associate_blkcg(blkcg_css);
 	}
 	refcount_set(&cb->pending_bios, 1);
 			bio->bi_opf = REQ_OP_WRITE | write_flags;
 			bio->bi_private = cb;
 			bio->bi_end_io = end_compressed_bio_write;
+			if (blkcg_css)
+				bio->bi_opf |= REQ_CGROUP_PUNT;
 			bio_add_page(bio, page, PAGE_SIZE, 0);
 		}
 		if (bytes_left < PAGE_SIZE) {
 		bio_endio(bio);
 	}
+	if (blkcg_css)
+		kthread_associate_blkcg(NULL);
 	return 0;
 }

fs/btrfs/inode.c+3−3

@@ -1479,10 +1479,10 @@ next_slot: · 1478 unmodified lines
1479	disk_num_bytes =	1479	disk_num_bytes =
1480	btrfs_file_extent_disk_num_bytes(leaf, fi);	1480	btrfs_file_extent_disk_num_bytes(leaf, fi);
1481	/*	1481	/*
1482	* If extent we got ends before our range starts, skip	1482	* If the extent we got ends before our current offset,
1483	* to next extent	1483	* skip to the next extent.
1484	*/	1484	*/
1485	if (extent_end <= start) {	1485	if (extent_end <= cur_offset) {
1486	path->slots[0]++;	1486	path->slots[0]++;
1487	goto next_slot;	1487	goto next_slot;
1488	}	1488	}

fs/buffer.c+5−28

  * errors, this only handles the "we need to be able to
  * do IO at the final sector" case.
  */
-void guard_bio_eod(int op, struct bio *bio)
+void guard_bio_eod(struct bio *bio)
 {
 	sector_t maxsector;
-	struct bio_vec *bvec = bio_last_bvec_all(bio);
-	unsigned truncated_bytes;
 	struct hd_struct *part;
 	rcu_read_lock();
 	if (likely((bio->bi_iter.bi_size >> 9) <= maxsector))
 		return;
-	/* Uhhuh. We've got a bio that straddles the device size! */
+	bio_truncate(bio, maxsector << 9);
-	truncated_bytes = bio->bi_iter.bi_size - (maxsector << 9);
-	/*
-	 * The bio contains more than one segment which spans EOD, just return
-	 * and let IO layer turn it into an EIO
-	 */
-	if (truncated_bytes > bvec->bv_len)
-		return;
-	/* Truncate the bio.. */
-	bio->bi_iter.bi_size -= truncated_bytes;
-	bvec->bv_len -= truncated_bytes;
-	/* ..and clear the end of the buffer for reads */
-	if (op == REQ_OP_READ) {
-		struct bio_vec bv;
-		mp_bvec_last_segment(bvec, &bv);
-		zero_user(bv.bv_page, bv.bv_offset + bv.bv_len,
-				truncated_bytes);
-	}
 }
 static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
 	bio->bi_end_io = end_bio_bh_io_sync;
 	bio->bi_private = bh;
-	/* Take care of bh's that straddle the end of the device */
-	guard_bio_eod(op, bio);
 	if (buffer_meta(bh))
 		op_flags |= REQ_META;
 	if (buffer_prio(bh))
 		op_flags |= REQ_PRIO;
 	bio_set_op_attrs(bio, op, op_flags);
+	/* Take care of bh's that straddle the end of the device */
+	guard_bio_eod(bio);
 	if (wbc) {
 		wbc_init_bio(wbc, bio);
 		wbc_account_cgroup_owner(wbc, bh->b_page, bh->b_size);

fs/char_dev.c+1−1

@@ -352,7 +352,7 @@ static struct kobject cdev_get(struct cdev p) · 351 unmodified lines
352		352
353	if (owner && !try_module_get(owner))	353	if (owner && !try_module_get(owner))
354	return NULL;	354	return NULL;
355	kobj = kobject_get(&p->kobj);	355	kobj = kobject_get_unless_zero(&p->kobj);
356	if (!kobj)	356	if (!kobj)
357	module_put(owner);	357	module_put(owner);
358	return kobj;	358	return kobj;

fs/cifs/cifsglob.h+1−0

@@ -1693,6 +1693,7 @@ struct cifs_fattr { · 1692 unmodified lines
1693	struct timespec64 cf_atime;	1693	struct timespec64 cf_atime;
1694	struct timespec64 cf_mtime;	1694	struct timespec64 cf_mtime;
1695	struct timespec64 cf_ctime;	1695	struct timespec64 cf_ctime;
		1696	u32 cf_cifstag;
1696	};	1697	};
1697		1698
1698	static inline void free_dfs_info_param(struct dfs_info3_param *param)	1699	static inline void free_dfs_info_param(struct dfs_info3_param *param)

fs/cifs/readdir.c+54−9

@@ -139,6 +139,28 @@ retry: · 138 unmodified lines
139	dput(dentry);	139	dput(dentry);
140	}	140	}
141		141
		142	static bool reparse_file_needs_reval(const struct cifs_fattr *fattr)
		143	{
		144	if (!(fattr->cf_cifsattrs & ATTR_REPARSE))
		145	return false;
		146	/*
		147	* The DFS tags should be only intepreted by server side as per
		148	* MS-FSCC 2.1.2.1, but let's include them anyway.
		149	*
		150	* Besides, if cf_cifstag is unset (0), then we still need it to be
		151	* revalidated to know exactly what reparse point it is.
		152	*/
		153	switch (fattr->cf_cifstag) {
		154	case IO_REPARSE_TAG_DFS:
		155	case IO_REPARSE_TAG_DFSR:
		156	case IO_REPARSE_TAG_SYMLINK:
		157	case IO_REPARSE_TAG_NFS:
		158	case 0:
		159	return true;
		160	}
		161	return false;
		162	}
		163
142	static void	164	static void
143	cifs_fill_common_info(struct cifs_fattr fattr, struct cifs_sb_info cifs_sb)	165	cifs_fill_common_info(struct cifs_fattr fattr, struct cifs_sb_info cifs_sb)
144	{	166	{
@@ -158,7 +180,7 @@ cifs_fill_common_info(struct cifs_fattr fattr, struct cifs_sb_info cifs_sb) · 13 unmodified lines
158	* is a symbolic link, DFS referral or a reparse point with a direct	180	* is a symbolic link, DFS referral or a reparse point with a direct
159	* access like junctions, deduplicated files, NFS symlinks.	181	* access like junctions, deduplicated files, NFS symlinks.
160	*/	182	*/
161	if (fattr->cf_cifsattrs & ATTR_REPARSE)	183	if (reparse_file_needs_reval(fattr))
162	fattr->cf_flags \|= CIFS_FATTR_NEED_REVAL;	184	fattr->cf_flags \|= CIFS_FATTR_NEED_REVAL;
163		185
164	/* non-unix readdir doesn't provide nlink */	186	/* non-unix readdir doesn't provide nlink */
@@ -194,19 +216,37 @@ cifs_fill_common_info(struct cifs_fattr fattr, struct cifs_sb_info cifs_sb) · 29 unmodified lines
194	}	216	}
195	}	217	}
196		218
		219	static void __dir_info_to_fattr(struct cifs_fattr fattr, const void info)
		220	{
		221	const FILE_DIRECTORY_INFO *fi = info;
		222
		223	memset(fattr, 0, sizeof(*fattr));
		224	fattr->cf_cifsattrs = le32_to_cpu(fi->ExtFileAttributes);
		225	fattr->cf_eof = le64_to_cpu(fi->EndOfFile);
		226	fattr->cf_bytes = le64_to_cpu(fi->AllocationSize);
		227	fattr->cf_createtime = le64_to_cpu(fi->CreationTime);
		228	fattr->cf_atime = cifs_NTtimeToUnix(fi->LastAccessTime);
		229	fattr->cf_ctime = cifs_NTtimeToUnix(fi->ChangeTime);
		230	fattr->cf_mtime = cifs_NTtimeToUnix(fi->LastWriteTime);
		231	}
		232
197	void	233	void
198	cifs_dir_info_to_fattr(struct cifs_fattr fattr, FILE_DIRECTORY_INFO info,	234	cifs_dir_info_to_fattr(struct cifs_fattr fattr, FILE_DIRECTORY_INFO info,
199	struct cifs_sb_info *cifs_sb)	235	struct cifs_sb_info *cifs_sb)
200	{	236	{
201	memset(fattr, 0, sizeof(*fattr));	237	__dir_info_to_fattr(fattr, info);
202	fattr->cf_cifsattrs = le32_to_cpu(info->ExtFileAttributes);	238	cifs_fill_common_info(fattr, cifs_sb);
203	fattr->cf_eof = le64_to_cpu(info->EndOfFile);	239	}
204	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
205	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
206	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
207	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
208	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
209		240
		241	static void cifs_fulldir_info_to_fattr(struct cifs_fattr *fattr,
		242	SEARCH_ID_FULL_DIR_INFO *info,
		243	struct cifs_sb_info *cifs_sb)
		244	{
		245	__dir_info_to_fattr(fattr, info);
		246
		247	/* See MS-FSCC 2.4.18 FileIdFullDirectoryInformation */
		248	if (fattr->cf_cifsattrs & ATTR_REPARSE)
		249	fattr->cf_cifstag = le32_to_cpu(info->EaSize);
210	cifs_fill_common_info(fattr, cifs_sb);	250	cifs_fill_common_info(fattr, cifs_sb);
211	}	251	}
212		252
@@ -755,6 +795,11 @@ static int cifs_filldir(char find_entry, struct file file, · 542 unmodified lines
755	(FIND_FILE_STANDARD_INFO *)find_entry,	795	(FIND_FILE_STANDARD_INFO *)find_entry,
756	cifs_sb);	796	cifs_sb);
757	break;	797	break;
		798	case SMB_FIND_FILE_ID_FULL_DIR_INFO:
		799	cifs_fulldir_info_to_fattr(&fattr,
		800	(SEARCH_ID_FULL_DIR_INFO *)find_entry,
		801	cifs_sb);
		802	break;
758	default:	803	default:
759	cifs_dir_info_to_fattr(&fattr,	804	cifs_dir_info_to_fattr(&fattr,
760	(FILE_DIRECTORY_INFO *)find_entry,	805	(FILE_DIRECTORY_INFO *)find_entry,

fs/cifs/smb2file.c+1−1

@@ -67,7 +67,7 @@ smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms, · 66 unmodified lines
67	goto out;	67	goto out;
68		68
69		69
70	if (oparms->tcon->use_resilient) {	70	if (oparms->tcon->use_resilient) {
71	/* default timeout is 0, servers pick default (120 seconds) */	71	/* default timeout is 0, servers pick default (120 seconds) */
72	nr_ioctl_req.Timeout =	72	nr_ioctl_req.Timeout =
73	cpu_to_le32(oparms->tcon->handle_timeout);	73	cpu_to_le32(oparms->tcon->handle_timeout);

fs/direct-io.c+2−0

@@ -39,6 +39,8 @@ · 38 unmodified lines
39	#include <linux/atomic.h>	39	#include <linux/atomic.h>
40	#include <linux/prefetch.h>	40	#include <linux/prefetch.h>
41		41
		42	#include "internal.h"
		43
42	/*	44	/*
43	* How many user pages to map in one call to get_user_pages(). This determines	45	* How many user pages to map in one call to get_user_pages(). This determines
44	* the size of a structure in the slab cache	46	* the size of a structure in the slab cache

fs/file.c+6−1

 	return ksys_dup3(oldfd, newfd, 0);
 }
-SYSCALL_DEFINE1(dup, unsigned int, fildes)
+int ksys_dup(unsigned int fildes)
 {
 	int ret = -EBADF;
 	struct file *file = fget_raw(fildes);
 	return ret;
 }
+SYSCALL_DEFINE1(dup, unsigned int, fildes)
+{
+	return ksys_dup(fildes);
+}
 int f_dupfd(unsigned int from, struct file *file, unsigned flags)
 {
 	int err;

fs/hugetlbfs/inode.c+3−1

 	/* other hstates are optional */
 	i = 0;
 	for_each_hstate(h) {
-		if (i == default_hstate_idx)
+		if (i == default_hstate_idx) {
+			i++;
 			continue;
+		}
 		mnt = mount_one_hugetlbfs(h);
 		if (IS_ERR(mnt))

fs/internal.h+1−1

@@ -38,7 +38,7 @@ static inline int __sync_blockdev(struct block_device *bdev, int wait) · 37 unmodified lines
38	/*	38	/*
39	* buffer.c	39	* buffer.c
40	*/	40	*/
41	extern void guard_bio_eod(int rw, struct bio *bio);	41	extern void guard_bio_eod(struct bio *bio);
42	extern int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,	42	extern int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
43	get_block_t get_block, struct iomap iomap);	43	get_block_t get_block, struct iomap iomap);
44		44

fs/io-wq.c+2−8

 	struct io_wqe_acct acct[2];
 	struct hlist_nulls_head free_list;
-	struct hlist_nulls_head busy_list;
 	struct list_head all_list;
 	struct io_wq *wq;
 	if (worker->flags & IO_WORKER_F_FREE) {
 		worker->flags &= ~IO_WORKER_F_FREE;
 		hlist_nulls_del_init_rcu(&worker->nulls_node);
-		hlist_nulls_add_head_rcu(&worker->nulls_node, &wqe->busy_list);
 	}
 	/*
 {
 	if (!(worker->flags & IO_WORKER_F_FREE)) {
 		worker->flags |= IO_WORKER_F_FREE;
-		hlist_nulls_del_init_rcu(&worker->nulls_node);
 		hlist_nulls_add_head_rcu(&worker->nulls_node, &wqe->free_list);
 	}
 		if (signal_pending(current))
 			flush_signals(current);
+		cond_resched();
 		spin_lock_irq(&worker->lock);
 		worker->cur_work = work;
 		spin_unlock_irq(&worker->lock);
 	set_bit(IO_WQ_BIT_CANCEL, &wq->state);
-	/*
-	 * Browse both lists, as there's a gap between handing work off
-	 * to a worker and the worker putting itself on the busy_list
-	 */
 	rcu_read_lock();
 	for_each_node(node) {
 		struct io_wqe *wqe = wq->wqes[node];
 		spin_lock_init(&wqe->lock);
 		INIT_WQ_LIST(&wqe->work_list);
 		INIT_HLIST_NULLS_HEAD(&wqe->free_list, 0);
-		INIT_HLIST_NULLS_HEAD(&wqe->busy_list, 1);
 		INIT_LIST_HEAD(&wqe->all_list);
 	}

fs/io_uring.c+355−347

@@ -330,6 +330,26 @@ struct io_timeout { · 329 unmodified lines
330	struct file *file;	330	struct file *file;
331	u64 addr;	331	u64 addr;
332	int flags;	332	int flags;
		333	unsigned count;
		334	};
		335
		336	struct io_rw {
		337	/* NOTE: kiocb has the file as the first member, so don't do it here */
		338	struct kiocb kiocb;
		339	u64 addr;
		340	u64 len;
		341	};
		342
		343	struct io_connect {
		344	struct file *file;
		345	struct sockaddr __user *addr;
		346	int addr_len;
		347	};
		348
		349	struct io_sr_msg {
		350	struct file *file;
		351	struct user_msghdr __user *msg;
		352	int msg_flags;
333	};	353	};
334		354
335	struct io_async_connect {	355	struct io_async_connect {
@@ -351,7 +371,6 @@ struct io_async_rw { · 15 unmodified lines
351	};	371	};
352		372
353	struct io_async_ctx {	373	struct io_async_ctx {
354	struct io_uring_sqe sqe;
355	union {	374	union {
356	struct io_async_rw rw;	375	struct io_async_rw rw;
357	struct io_async_msghdr msg;	376	struct io_async_msghdr msg;
@@ -369,15 +388,16 @@ struct io_async_ctx { · 11 unmodified lines
369	struct io_kiocb {	388	struct io_kiocb {
370	union {	389	union {
371	struct file *file;	390	struct file *file;
372	struct kiocb rw;	391	struct io_rw rw;
373	struct io_poll_iocb poll;	392	struct io_poll_iocb poll;
374	struct io_accept accept;	393	struct io_accept accept;
375	struct io_sync sync;	394	struct io_sync sync;
376	struct io_cancel cancel;	395	struct io_cancel cancel;
377	struct io_timeout timeout;	396	struct io_timeout timeout;
		397	struct io_connect connect;
		398	struct io_sr_msg sr_msg;
378	};	399	};
379		400
380	const struct io_uring_sqe *sqe;
381	struct io_async_ctx *io;	401	struct io_async_ctx *io;
382	struct file *ring_file;	402	struct file *ring_file;
383	int ring_fd;	403	int ring_fd;
@@ -411,7 +431,6 @@ struct io_kiocb { · 27 unmodified lines
411	#define REQ_F_INFLIGHT 16384 /* on inflight list */	431	#define REQ_F_INFLIGHT 16384 /* on inflight list */
412	#define REQ_F_COMP_LOCKED 32768 /* completion under lock */	432	#define REQ_F_COMP_LOCKED 32768 /* completion under lock */
413	#define REQ_F_HARDLINK 65536 /* doesn't sever on completion < 0 */	433	#define REQ_F_HARDLINK 65536 /* doesn't sever on completion < 0 */
414	#define REQ_F_PREPPED 131072 /* request already opcode prepared */
415	u64 user_data;	434	u64 user_data;
416	u32 result;	435	u32 result;
417	u32 sequence;	436	u32 sequence;
@@ -609,33 +628,31 @@ static inline bool io_prep_async_work(struct io_kiocb *req, · 191 unmodified lines
609	{	628	{
610	bool do_hashed = false;	629	bool do_hashed = false;
611		630
612	if (req->sqe) {	631	switch (req->opcode) {
613	switch (req->opcode) {	632	case IORING_OP_WRITEV:
614	case IORING_OP_WRITEV:	633	case IORING_OP_WRITE_FIXED:
615	case IORING_OP_WRITE_FIXED:	634	/* only regular files should be hashed for writes */
616	/* only regular files should be hashed for writes */	635	if (req->flags & REQ_F_ISREG)
617	if (req->flags & REQ_F_ISREG)	636	do_hashed = true;
618	do_hashed = true;	637	/* fall-through */
619	/* fall-through */	638	case IORING_OP_READV:
620	case IORING_OP_READV:	639	case IORING_OP_READ_FIXED:
621	case IORING_OP_READ_FIXED:	640	case IORING_OP_SENDMSG:
622	case IORING_OP_SENDMSG:	641	case IORING_OP_RECVMSG:
623	case IORING_OP_RECVMSG:	642	case IORING_OP_ACCEPT:
624	case IORING_OP_ACCEPT:	643	case IORING_OP_POLL_ADD:
625	case IORING_OP_POLL_ADD:	644	case IORING_OP_CONNECT:
626	case IORING_OP_CONNECT:	645	/*
627	/*	646	* We know REQ_F_ISREG is not set on some of these
628	* We know REQ_F_ISREG is not set on some of these	647	* opcodes, but this enables us to keep the check in
629	* opcodes, but this enables us to keep the check in	648	* just one place.
630	* just one place.	649	*/
631	*/	650	if (!(req->flags & REQ_F_ISREG))
632	if (!(req->flags & REQ_F_ISREG))	651	req->work.flags \|= IO_WQ_WORK_UNBOUND;
633	req->work.flags \|= IO_WQ_WORK_UNBOUND;	652	break;
634	break;
635	}
636	if (io_req_needs_user(req))
637	req->work.flags \|= IO_WQ_WORK_NEEDS_USER;
638	}	653	}
		654	if (io_req_needs_user(req))
		655	req->work.flags \|= IO_WQ_WORK_NEEDS_USER;
639		656
640	*link = io_prep_linked_timeout(req);	657	*link = io_prep_linked_timeout(req);
641	return do_hashed;	658	return do_hashed;
@@ -1180,7 +1197,7 @@ static int io_do_iopoll(struct io_ring_ctx ctx, unsigned int nr_events, · 538 unmodified lines
1180		1197
1181	ret = 0;	1198	ret = 0;
1182	list_for_each_entry_safe(req, tmp, &ctx->poll_list, list) {	1199	list_for_each_entry_safe(req, tmp, &ctx->poll_list, list) {
1183	struct kiocb *kiocb = &req->rw;	1200	struct kiocb *kiocb = &req->rw.kiocb;
1184		1201
1185	/*	1202	/*
1186	* Move completed entries to our local list. If we find a	1203	* Move completed entries to our local list. If we find a
@@ -1335,7 +1352,7 @@ static inline void req_set_fail_links(struct io_kiocb *req) · 148 unmodified lines
1335		1352
1336	static void io_complete_rw_common(struct kiocb *kiocb, long res)	1353	static void io_complete_rw_common(struct kiocb *kiocb, long res)
1337	{	1354	{
1338	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	1355	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1339		1356
1340	if (kiocb->ki_flags & IOCB_WRITE)	1357	if (kiocb->ki_flags & IOCB_WRITE)
1341	kiocb_end_write(req);	1358	kiocb_end_write(req);
@@ -1347,7 +1364,7 @@ static void io_complete_rw_common(struct kiocb *kiocb, long res) · 5 unmodified lines
1347		1364
1348	static void io_complete_rw(struct kiocb *kiocb, long res, long res2)	1365	static void io_complete_rw(struct kiocb *kiocb, long res, long res2)
1349	{	1366	{
1350	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	1367	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1351		1368
1352	io_complete_rw_common(kiocb, res);	1369	io_complete_rw_common(kiocb, res);
1353	io_put_req(req);	1370	io_put_req(req);
@@ -1355,7 +1372,7 @@ static void io_complete_rw(struct kiocb *kiocb, long res, long res2) · 1 unmodified line
1355		1372
1356	static struct io_kiocb __io_complete_rw(struct kiocb kiocb, long res)	1373	static struct io_kiocb __io_complete_rw(struct kiocb kiocb, long res)
1357	{	1374	{
1358	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	1375	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1359	struct io_kiocb *nxt = NULL;	1376	struct io_kiocb *nxt = NULL;
1360		1377
1361	io_complete_rw_common(kiocb, res);	1378	io_complete_rw_common(kiocb, res);
@@ -1366,7 +1383,7 @@ static struct io_kiocb __io_complete_rw(struct kiocb kiocb, long res) · 4 unmodified lines
1366		1383
1367	static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2)	1384	static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2)
1368	{	1385	{
1369	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	1386	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1370		1387
1371	if (kiocb->ki_flags & IOCB_WRITE)	1388	if (kiocb->ki_flags & IOCB_WRITE)
1372	kiocb_end_write(req);	1389	kiocb_end_write(req);
@@ -1400,7 +1417,7 @@ static void io_iopoll_req_issued(struct io_kiocb *req) · 27 unmodified lines
1400		1417
1401	list_req = list_first_entry(&ctx->poll_list, struct io_kiocb,	1418	list_req = list_first_entry(&ctx->poll_list, struct io_kiocb,
1402	list);	1419	list);
1403	if (list_req->rw.ki_filp != req->rw.ki_filp)	1420	if (list_req->file != req->file)
1404	ctx->poll_multi_file = true;	1421	ctx->poll_multi_file = true;
1405	}	1422	}
1406		1423
@@ -1471,11 +1488,11 @@ static bool io_file_supports_async(struct file *file) · 64 unmodified lines
1471	return false;	1488	return false;
1472	}	1489	}
1473		1490
1474	static int io_prep_rw(struct io_kiocb *req, bool force_nonblock)	1491	static int io_prep_rw(struct io_kiocb req, const struct io_uring_sqe sqe,
		1492	bool force_nonblock)
1475	{	1493	{
1476	const struct io_uring_sqe *sqe = req->sqe;
1477	struct io_ring_ctx *ctx = req->ctx;	1494	struct io_ring_ctx *ctx = req->ctx;
1478	struct kiocb *kiocb = &req->rw;	1495	struct kiocb *kiocb = &req->rw.kiocb;
1479	unsigned ioprio;	1496	unsigned ioprio;
1480	int ret;	1497	int ret;
1481		1498
@@ -1524,6 +1541,12 @@ static int io_prep_rw(struct io_kiocb *req, bool force_nonblock) · 42 unmodified lines
1524	return -EINVAL;	1541	return -EINVAL;
1525	kiocb->ki_complete = io_complete_rw;	1542	kiocb->ki_complete = io_complete_rw;
1526	}	1543	}
		1544
		1545	req->rw.addr = READ_ONCE(sqe->addr);
		1546	req->rw.len = READ_ONCE(sqe->len);
		1547	/* we own ->private, reuse it for the buffer index */
		1548	req->rw.kiocb.private = (void *) (unsigned long)
		1549	READ_ONCE(sqe->buf_index);
1527	return 0;	1550	return 0;
1528	}	1551	}
1529		1552
@@ -1557,11 +1580,11 @@ static void kiocb_done(struct kiocb kiocb, ssize_t ret, struct io_kiocb *nxt, · 27 unmodified lines
1557	io_rw_done(kiocb, ret);	1580	io_rw_done(kiocb, ret);
1558	}	1581	}
1559		1582
1560	static ssize_t io_import_fixed(struct io_ring_ctx *ctx, int rw,	1583	static ssize_t io_import_fixed(struct io_kiocb *req, int rw,
1561	const struct io_uring_sqe *sqe,
1562	struct iov_iter *iter)	1584	struct iov_iter *iter)
1563	{	1585	{
1564	size_t len = READ_ONCE(sqe->len);	1586	struct io_ring_ctx *ctx = req->ctx;
		1587	size_t len = req->rw.len;
1565	struct io_mapped_ubuf *imu;	1588	struct io_mapped_ubuf *imu;
1566	unsigned index, buf_index;	1589	unsigned index, buf_index;
1567	size_t offset;	1590	size_t offset;
@@ -1571,13 +1594,13 @@ static ssize_t io_import_fixed(struct io_ring_ctx *ctx, int rw, · 3 unmodified lines
1571	if (unlikely(!ctx->user_bufs))	1594	if (unlikely(!ctx->user_bufs))
1572	return -EFAULT;	1595	return -EFAULT;
1573		1596
1574	buf_index = READ_ONCE(sqe->buf_index);	1597	buf_index = (unsigned long) req->rw.kiocb.private;
1575	if (unlikely(buf_index >= ctx->nr_user_bufs))	1598	if (unlikely(buf_index >= ctx->nr_user_bufs))
1576	return -EFAULT;	1599	return -EFAULT;
1577		1600
1578	index = array_index_nospec(buf_index, ctx->nr_user_bufs);	1601	index = array_index_nospec(buf_index, ctx->nr_user_bufs);
1579	imu = &ctx->user_bufs[index];	1602	imu = &ctx->user_bufs[index];
1580	buf_addr = READ_ONCE(sqe->addr);	1603	buf_addr = req->rw.addr;
1581		1604
1582	/* overflow */	1605	/* overflow */
1583	if (buf_addr + len < buf_addr)	1606	if (buf_addr + len < buf_addr)
@@ -1634,25 +1657,20 @@ static ssize_t io_import_fixed(struct io_ring_ctx *ctx, int rw, · 50 unmodified lines
1634	static ssize_t io_import_iovec(int rw, struct io_kiocb *req,	1657	static ssize_t io_import_iovec(int rw, struct io_kiocb *req,
1635	struct iovec *iovec, struct iov_iter iter)	1658	struct iovec *iovec, struct iov_iter iter)
1636	{	1659	{
1637	const struct io_uring_sqe *sqe = req->sqe;	1660	void __user *buf = u64_to_user_ptr(req->rw.addr);
1638	void __user *buf = u64_to_user_ptr(READ_ONCE(sqe->addr));	1661	size_t sqe_len = req->rw.len;
1639	size_t sqe_len = READ_ONCE(sqe->len);
1640	u8 opcode;	1662	u8 opcode;
1641		1663
1642	/*
1643	* We're reading ->opcode for the second time, but the first read
1644	* doesn't care whether it's _FIXED or not, so it doesn't matter
1645	* whether ->opcode changes concurrently. The first read does care
1646	* about whether it is a READ or a WRITE, so we don't trust this read
1647	* for that purpose and instead let the caller pass in the read/write
1648	* flag.
1649	*/
1650	opcode = req->opcode;	1664	opcode = req->opcode;
1651	if (opcode == IORING_OP_READ_FIXED \|\| opcode == IORING_OP_WRITE_FIXED) {	1665	if (opcode == IORING_OP_READ_FIXED \|\| opcode == IORING_OP_WRITE_FIXED) {
1652	*iovec = NULL;	1666	*iovec = NULL;
1653	return io_import_fixed(req->ctx, rw, sqe, iter);	1667	return io_import_fixed(req, rw, iter);
1654	}	1668	}
1655		1669
		1670	/* buffer index only valid with fixed read/write */
		1671	if (req->rw.kiocb.private)
		1672	return -EINVAL;
		1673
1656	if (req->io) {	1674	if (req->io) {
1657	struct io_async_rw *iorw = &req->io->rw;	1675	struct io_async_rw *iorw = &req->io->rw;
1658		1676
@@ -1750,13 +1768,7 @@ static void io_req_map_rw(struct io_kiocb *req, ssize_t io_size, · 91 unmodified lines
1750	static int io_alloc_async_ctx(struct io_kiocb *req)	1768	static int io_alloc_async_ctx(struct io_kiocb *req)
1751	{	1769	{
1752	req->io = kmalloc(sizeof(*req->io), GFP_KERNEL);	1770	req->io = kmalloc(sizeof(*req->io), GFP_KERNEL);
1753	if (req->io) {	1771	return req->io == NULL;
1754	memcpy(&req->io->sqe, req->sqe, sizeof(req->io->sqe));
1755	req->sqe = &req->io->sqe;
1756	return 0;
1757	}
1758
1759	return 1;
1760	}	1772	}
1761		1773
1762	static void io_rw_async(struct io_wq_work **workptr)	1774	static void io_rw_async(struct io_wq_work **workptr)
@@ -1782,46 +1794,52 @@ static int io_setup_async_rw(struct io_kiocb *req, ssize_t io_size, · 19 unmodified lines
1782	return 0;	1794	return 0;
1783	}	1795	}
1784		1796
1785	static int io_read_prep(struct io_kiocb req, struct iovec *iovec,	1797	static int io_read_prep(struct io_kiocb req, const struct io_uring_sqe sqe,
1786	struct iov_iter *iter, bool force_nonblock)	1798	bool force_nonblock)
1787	{	1799	{
		1800	struct io_async_ctx *io;
		1801	struct iov_iter iter;
1788	ssize_t ret;	1802	ssize_t ret;
1789		1803
1790	ret = io_prep_rw(req, force_nonblock);	1804	ret = io_prep_rw(req, sqe, force_nonblock);
1791	if (ret)	1805	if (ret)
1792	return ret;	1806	return ret;
1793		1807
1794	if (unlikely(!(req->file->f_mode & FMODE_READ)))	1808	if (unlikely(!(req->file->f_mode & FMODE_READ)))
1795	return -EBADF;	1809	return -EBADF;
1796		1810
1797	return io_import_iovec(READ, req, iovec, iter);	1811	if (!req->io)
		1812	return 0;
		1813
		1814	io = req->io;
		1815	io->rw.iov = io->rw.fast_iov;
		1816	req->io = NULL;
		1817	ret = io_import_iovec(READ, req, &io->rw.iov, &iter);
		1818	req->io = io;
		1819	if (ret < 0)
		1820	return ret;
		1821
		1822	io_req_map_rw(req, ret, io->rw.iov, io->rw.fast_iov, &iter);
		1823	return 0;
1798	}	1824	}
1799		1825
1800	static int io_read(struct io_kiocb req, struct io_kiocb *nxt,	1826	static int io_read(struct io_kiocb req, struct io_kiocb *nxt,
1801	bool force_nonblock)	1827	bool force_nonblock)
1802	{	1828	{
1803	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;	1829	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1804	struct kiocb *kiocb = &req->rw;	1830	struct kiocb *kiocb = &req->rw.kiocb;
1805	struct iov_iter iter;	1831	struct iov_iter iter;
1806	struct file *file;
1807	size_t iov_count;	1832	size_t iov_count;
1808	ssize_t io_size, ret;	1833	ssize_t io_size, ret;
1809		1834
1810	if (!req->io) {	1835	ret = io_import_iovec(READ, req, &iovec, &iter);
1811	ret = io_read_prep(req, &iovec, &iter, force_nonblock);	1836	if (ret < 0)
1812	if (ret < 0)	1837	return ret;
1813	return ret;
1814	} else {
1815	ret = io_import_iovec(READ, req, &iovec, &iter);
1816	if (ret < 0)
1817	return ret;
1818	}
1819		1838
1820	/* Ensure we clear previously set non-block flag */	1839	/* Ensure we clear previously set non-block flag */
1821	if (!force_nonblock)	1840	if (!force_nonblock)
1822	req->rw.ki_flags &= ~IOCB_NOWAIT;	1841	req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
1823		1842
1824	file = req->file;
1825	io_size = ret;	1843	io_size = ret;
1826	if (req->flags & REQ_F_LINK)	1844	if (req->flags & REQ_F_LINK)
1827	req->result = io_size;	1845	req->result = io_size;
@@ -1830,33 +1848,21 @@ static int io_read(struct io_kiocb req, struct io_kiocb *nxt, · 2 unmodified lines
1830	* If the file doesn't support async, mark it as REQ_F_MUST_PUNT so	1848	* If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
1831	* we know to async punt it even if it was opened O_NONBLOCK	1849	* we know to async punt it even if it was opened O_NONBLOCK
1832	*/	1850	*/
1833	if (force_nonblock && !io_file_supports_async(file)) {	1851	if (force_nonblock && !io_file_supports_async(req->file)) {
1834	req->flags \|= REQ_F_MUST_PUNT;	1852	req->flags \|= REQ_F_MUST_PUNT;
1835	goto copy_iov;	1853	goto copy_iov;
1836	}	1854	}
1837		1855
1838	iov_count = iov_iter_count(&iter);	1856	iov_count = iov_iter_count(&iter);
1839	ret = rw_verify_area(READ, file, &kiocb->ki_pos, iov_count);	1857	ret = rw_verify_area(READ, req->file, &kiocb->ki_pos, iov_count);
1840	if (!ret) {	1858	if (!ret) {
1841	ssize_t ret2;	1859	ssize_t ret2;
1842		1860
1843	if (file->f_op->read_iter)	1861	if (req->file->f_op->read_iter)
1844	ret2 = call_read_iter(file, kiocb, &iter);	1862	ret2 = call_read_iter(req->file, kiocb, &iter);
1845	else	1863	else
1846	ret2 = loop_rw_iter(READ, file, kiocb, &iter);	1864	ret2 = loop_rw_iter(READ, req->file, kiocb, &iter);
1847		1865
1848	/*
1849	* In case of a short read, punt to async. This can happen
1850	* if we have data partially cached. Alternatively we can
1851	* return the short read, in which case the application will
1852	* need to issue another SQE and wait for it. That SQE will
1853	* need async punt anyway, so it's more efficient to do it
1854	* here.
1855	*/
1856	if (force_nonblock && !(req->flags & REQ_F_NOWAIT) &&
1857	(req->flags & REQ_F_ISREG) &&
1858	ret2 > 0 && ret2 < io_size)
1859	ret2 = -EAGAIN;
1860	/* Catch -EAGAIN return for forced non-blocking submission */	1866	/* Catch -EAGAIN return for forced non-blocking submission */
1861	if (!force_nonblock \|\| ret2 != -EAGAIN) {	1867	if (!force_nonblock \|\| ret2 != -EAGAIN) {
1862	kiocb_done(kiocb, ret2, nxt, req->in_async);	1868	kiocb_done(kiocb, ret2, nxt, req->in_async);
@@ -1875,46 +1881,52 @@ out_free: · 12 unmodified lines
1875	return ret;	1881	return ret;
1876	}	1882	}
1877		1883
1878	static int io_write_prep(struct io_kiocb req, struct iovec *iovec,	1884	static int io_write_prep(struct io_kiocb req, const struct io_uring_sqe sqe,
1879	struct iov_iter *iter, bool force_nonblock)	1885	bool force_nonblock)
1880	{	1886	{
		1887	struct io_async_ctx *io;
		1888	struct iov_iter iter;
1881	ssize_t ret;	1889	ssize_t ret;
1882		1890
1883	ret = io_prep_rw(req, force_nonblock);	1891	ret = io_prep_rw(req, sqe, force_nonblock);
1884	if (ret)	1892	if (ret)
1885	return ret;	1893	return ret;
1886		1894
1887	if (unlikely(!(req->file->f_mode & FMODE_WRITE)))	1895	if (unlikely(!(req->file->f_mode & FMODE_WRITE)))
1888	return -EBADF;	1896	return -EBADF;
1889		1897
1890	return io_import_iovec(WRITE, req, iovec, iter);	1898	if (!req->io)
		1899	return 0;
		1900
		1901	io = req->io;
		1902	io->rw.iov = io->rw.fast_iov;
		1903	req->io = NULL;
		1904	ret = io_import_iovec(WRITE, req, &io->rw.iov, &iter);
		1905	req->io = io;
		1906	if (ret < 0)
		1907	return ret;
		1908
		1909	io_req_map_rw(req, ret, io->rw.iov, io->rw.fast_iov, &iter);
		1910	return 0;
1891	}	1911	}
1892		1912
1893	static int io_write(struct io_kiocb req, struct io_kiocb *nxt,	1913	static int io_write(struct io_kiocb req, struct io_kiocb *nxt,
1894	bool force_nonblock)	1914	bool force_nonblock)
1895	{	1915	{
1896	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;	1916	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1897	struct kiocb *kiocb = &req->rw;	1917	struct kiocb *kiocb = &req->rw.kiocb;
1898	struct iov_iter iter;	1918	struct iov_iter iter;
1899	struct file *file;
1900	size_t iov_count;	1919	size_t iov_count;
1901	ssize_t ret, io_size;	1920	ssize_t ret, io_size;
1902		1921
1903	if (!req->io) {	1922	ret = io_import_iovec(WRITE, req, &iovec, &iter);
1904	ret = io_write_prep(req, &iovec, &iter, force_nonblock);	1923	if (ret < 0)
1905	if (ret < 0)	1924	return ret;
1906	return ret;
1907	} else {
1908	ret = io_import_iovec(WRITE, req, &iovec, &iter);
1909	if (ret < 0)
1910	return ret;
1911	}
1912		1925
1913	/* Ensure we clear previously set non-block flag */	1926	/* Ensure we clear previously set non-block flag */
1914	if (!force_nonblock)	1927	if (!force_nonblock)
1915	req->rw.ki_flags &= ~IOCB_NOWAIT;	1928	req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
1916		1929
1917	file = kiocb->ki_filp;
1918	io_size = ret;	1930	io_size = ret;
1919	if (req->flags & REQ_F_LINK)	1931	if (req->flags & REQ_F_LINK)
1920	req->result = io_size;	1932	req->result = io_size;
@@ -1934,7 +1946,7 @@ static int io_write(struct io_kiocb req, struct io_kiocb *nxt, · 13 unmodified lines
1934	goto copy_iov;	1946	goto copy_iov;
1935		1947
1936	iov_count = iov_iter_count(&iter);	1948	iov_count = iov_iter_count(&iter);
1937	ret = rw_verify_area(WRITE, file, &kiocb->ki_pos, iov_count);	1949	ret = rw_verify_area(WRITE, req->file, &kiocb->ki_pos, iov_count);
1938	if (!ret) {	1950	if (!ret) {
1939	ssize_t ret2;	1951	ssize_t ret2;
1940		1952
@@ -1946,17 +1958,17 @@ static int io_write(struct io_kiocb req, struct io_kiocb *nxt, · 5 unmodified lines
1946	* we return to userspace.	1958	* we return to userspace.
1947	*/	1959	*/
1948	if (req->flags & REQ_F_ISREG) {	1960	if (req->flags & REQ_F_ISREG) {
1949	__sb_start_write(file_inode(file)->i_sb,	1961	__sb_start_write(file_inode(req->file)->i_sb,
1950	SB_FREEZE_WRITE, true);	1962	SB_FREEZE_WRITE, true);
1951	__sb_writers_release(file_inode(file)->i_sb,	1963	__sb_writers_release(file_inode(req->file)->i_sb,
1952	SB_FREEZE_WRITE);	1964	SB_FREEZE_WRITE);
1953	}	1965	}
1954	kiocb->ki_flags \|= IOCB_WRITE;	1966	kiocb->ki_flags \|= IOCB_WRITE;
1955		1967
1956	if (file->f_op->write_iter)	1968	if (req->file->f_op->write_iter)
1957	ret2 = call_write_iter(file, kiocb, &iter);	1969	ret2 = call_write_iter(req->file, kiocb, &iter);
1958	else	1970	else
1959	ret2 = loop_rw_iter(WRITE, file, kiocb, &iter);	1971	ret2 = loop_rw_iter(WRITE, req->file, kiocb, &iter);
1960	if (!force_nonblock \|\| ret2 != -EAGAIN) {	1972	if (!force_nonblock \|\| ret2 != -EAGAIN) {
1961	kiocb_done(kiocb, ret2, nxt, req->in_async);	1973	kiocb_done(kiocb, ret2, nxt, req->in_async);
1962	} else {	1974	} else {
@@ -1989,13 +2001,10 @@ static int io_nop(struct io_kiocb *req) · 26 unmodified lines
1989	return 0;	2001	return 0;
1990	}	2002	}
1991		2003
1992	static int io_prep_fsync(struct io_kiocb *req)	2004	static int io_prep_fsync(struct io_kiocb req, const struct io_uring_sqe sqe)
1993	{	2005	{
1994	const struct io_uring_sqe *sqe = req->sqe;
1995	struct io_ring_ctx *ctx = req->ctx;	2006	struct io_ring_ctx *ctx = req->ctx;
1996		2007
1997	if (req->flags & REQ_F_PREPPED)
1998	return 0;
1999	if (!req->file)	2008	if (!req->file)
2000	return -EBADF;	2009	return -EBADF;
2001		2010
@@ -2010,7 +2019,6 @@ static int io_prep_fsync(struct io_kiocb *req) · 8 unmodified lines
2010		2019
2011	req->sync.off = READ_ONCE(sqe->off);	2020	req->sync.off = READ_ONCE(sqe->off);
2012	req->sync.len = READ_ONCE(sqe->len);	2021	req->sync.len = READ_ONCE(sqe->len);
2013	req->flags \|= REQ_F_PREPPED;
2014	return 0;	2022	return 0;
2015	}	2023	}
2016		2024
@@ -2036,7 +2044,7 @@ static void io_fsync_finish(struct io_wq_work **workptr) · 19 unmodified lines
2036	if (io_req_cancelled(req))	2044	if (io_req_cancelled(req))
2037	return;	2045	return;
2038		2046
2039	ret = vfs_fsync_range(req->rw.ki_filp, req->sync.off,	2047	ret = vfs_fsync_range(req->file, req->sync.off,
2040	end > 0 ? end : LLONG_MAX,	2048	end > 0 ? end : LLONG_MAX,
2041	req->sync.flags & IORING_FSYNC_DATASYNC);	2049	req->sync.flags & IORING_FSYNC_DATASYNC);
2042	if (ret < 0)	2050	if (ret < 0)
@@ -2051,11 +2059,6 @@ static int io_fsync(struct io_kiocb req, struct io_kiocb *nxt, · 8 unmodified lines
2051	bool force_nonblock)	2059	bool force_nonblock)
2052	{	2060	{
2053	struct io_wq_work work, old_work;	2061	struct io_wq_work work, old_work;
2054	int ret;
2055
2056	ret = io_prep_fsync(req);
2057	if (ret)
2058	return ret;
2059		2062
2060	/* fsync always requires a blocking context */	2063	/* fsync always requires a blocking context */
2061	if (force_nonblock) {	2064	if (force_nonblock) {
@@ -2071,13 +2074,10 @@ static int io_fsync(struct io_kiocb req, struct io_kiocb *nxt, · 9 unmodified lines
2071	return 0;	2074	return 0;
2072	}	2075	}
2073		2076
2074	static int io_prep_sfr(struct io_kiocb *req)	2077	static int io_prep_sfr(struct io_kiocb req, const struct io_uring_sqe sqe)
2075	{	2078	{
2076	const struct io_uring_sqe *sqe = req->sqe;
2077	struct io_ring_ctx *ctx = req->ctx;	2079	struct io_ring_ctx *ctx = req->ctx;
2078		2080
2079	if (req->flags & REQ_F_PREPPED)
2080	return 0;
2081	if (!req->file)	2081	if (!req->file)
2082	return -EBADF;	2082	return -EBADF;
2083		2083
@@ -2089,7 +2089,6 @@ static int io_prep_sfr(struct io_kiocb *req) · 5 unmodified lines
2089	req->sync.off = READ_ONCE(sqe->off);	2089	req->sync.off = READ_ONCE(sqe->off);
2090	req->sync.len = READ_ONCE(sqe->len);	2090	req->sync.len = READ_ONCE(sqe->len);
2091	req->sync.flags = READ_ONCE(sqe->sync_range_flags);	2091	req->sync.flags = READ_ONCE(sqe->sync_range_flags);
2092	req->flags \|= REQ_F_PREPPED;
2093	return 0;	2092	return 0;
2094	}	2093	}
2095		2094
@@ -2102,7 +2101,7 @@ static void io_sync_file_range_finish(struct io_wq_work **workptr) · 6 unmodified lines
2102	if (io_req_cancelled(req))	2101	if (io_req_cancelled(req))
2103	return;	2102	return;
2104		2103
2105	ret = sync_file_range(req->rw.ki_filp, req->sync.off, req->sync.len,	2104	ret = sync_file_range(req->file, req->sync.off, req->sync.len,
2106	req->sync.flags);	2105	req->sync.flags);
2107	if (ret < 0)	2106	if (ret < 0)
2108	req_set_fail_links(req);	2107	req_set_fail_links(req);
@@ -2116,11 +2115,6 @@ static int io_sync_file_range(struct io_kiocb req, struct io_kiocb *nxt, · 7 unmodified lines
2116	bool force_nonblock)	2115	bool force_nonblock)
2117	{	2116	{
2118	struct io_wq_work work, old_work;	2117	struct io_wq_work work, old_work;
2119	int ret;
2120
2121	ret = io_prep_sfr(req);
2122	if (ret)
2123	return ret;
2124		2118
2125	/* sync_file_range always requires a blocking context */	2119	/* sync_file_range always requires a blocking context */
2126	if (force_nonblock) {	2120	if (force_nonblock) {
@@ -2149,19 +2143,23 @@ static void io_sendrecv_async(struct io_wq_work **workptr) · 22 unmodified lines
2149	}	2143	}
2150	#endif	2144	#endif
2151		2145
2152	static int io_sendmsg_prep(struct io_kiocb req, struct io_async_ctx io)	2146	static int io_sendmsg_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
2153	{	2147	{
2154	#if defined(CONFIG_NET)	2148	#if defined(CONFIG_NET)
2155	const struct io_uring_sqe *sqe = req->sqe;	2149	struct io_sr_msg *sr = &req->sr_msg;
2156	struct user_msghdr __user *msg;	2150	struct io_async_ctx *io = req->io;
2157	unsigned flags;	2151
		2152	sr->msg_flags = READ_ONCE(sqe->msg_flags);
		2153	sr->msg = u64_to_user_ptr(READ_ONCE(sqe->addr));
		2154
		2155	if (!io)
		2156	return 0;
2158		2157
2159	flags = READ_ONCE(sqe->msg_flags);
2160	msg = (struct user_msghdr __user *)(unsigned long) READ_ONCE(sqe->addr);
2161	io->msg.iov = io->msg.fast_iov;	2158	io->msg.iov = io->msg.fast_iov;
2162	return sendmsg_copy_msghdr(&io->msg.msg, msg, flags, &io->msg.iov);	2159	return sendmsg_copy_msghdr(&io->msg.msg, sr->msg, sr->msg_flags,
		2160	&io->msg.iov);
2163	#else	2161	#else
2164	return 0;	2162	return -EOPNOTSUPP;
2165	#endif	2163	#endif
2166	}	2164	}
2167		2165
@@ -2169,7 +2167,6 @@ static int io_sendmsg(struct io_kiocb req, struct io_kiocb *nxt, · 1 unmodified line
2169	bool force_nonblock)	2167	bool force_nonblock)
2170	{	2168	{
2171	#if defined(CONFIG_NET)	2169	#if defined(CONFIG_NET)
2172	const struct io_uring_sqe *sqe = req->sqe;
2173	struct io_async_msghdr *kmsg = NULL;	2170	struct io_async_msghdr *kmsg = NULL;
2174	struct socket *sock;	2171	struct socket *sock;
2175	int ret;	2172	int ret;
@@ -2183,12 +2180,6 @@ static int io_sendmsg(struct io_kiocb req, struct io_kiocb *nxt, · 7 unmodified lines
2183	struct sockaddr_storage addr;	2180	struct sockaddr_storage addr;
2184	unsigned flags;	2181	unsigned flags;
2185		2182
2186	flags = READ_ONCE(sqe->msg_flags);
2187	if (flags & MSG_DONTWAIT)
2188	req->flags \|= REQ_F_NOWAIT;
2189	else if (force_nonblock)
2190	flags \|= MSG_DONTWAIT;
2191
2192	if (req->io) {	2183	if (req->io) {
2193	kmsg = &req->io->msg;	2184	kmsg = &req->io->msg;
2194	kmsg->msg.msg_name = &addr;	2185	kmsg->msg.msg_name = &addr;
@@ -2197,13 +2188,24 @@ static int io_sendmsg(struct io_kiocb req, struct io_kiocb *nxt, · 2 unmodified lines
2197	kmsg->iov = kmsg->fast_iov;	2188	kmsg->iov = kmsg->fast_iov;
2198	kmsg->msg.msg_iter.iov = kmsg->iov;	2189	kmsg->msg.msg_iter.iov = kmsg->iov;
2199	} else {	2190	} else {
		2191	struct io_sr_msg *sr = &req->sr_msg;
		2192
2200	kmsg = &io.msg;	2193	kmsg = &io.msg;
2201	kmsg->msg.msg_name = &addr;	2194	kmsg->msg.msg_name = &addr;
2202	ret = io_sendmsg_prep(req, &io);	2195
		2196	io.msg.iov = io.msg.fast_iov;
		2197	ret = sendmsg_copy_msghdr(&io.msg.msg, sr->msg,
		2198	sr->msg_flags, &io.msg.iov);
2203	if (ret)	2199	if (ret)
2204	goto out;	2200	return ret;
2205	}	2201	}
2206		2202
		2203	flags = req->sr_msg.msg_flags;
		2204	if (flags & MSG_DONTWAIT)
		2205	req->flags \|= REQ_F_NOWAIT;
		2206	else if (force_nonblock)
		2207	flags \|= MSG_DONTWAIT;
		2208
2207	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);	2209	ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
2208	if (force_nonblock && ret == -EAGAIN) {	2210	if (force_nonblock && ret == -EAGAIN) {
2209	if (req->io)	2211	if (req->io)
@@ -2218,7 +2220,6 @@ static int io_sendmsg(struct io_kiocb req, struct io_kiocb *nxt, · 8 unmodified lines
2218	ret = -EINTR;	2220	ret = -EINTR;
2219	}	2221	}
2220		2222
2221	out:
2222	if (!io_wq_current_is_worker() && kmsg && kmsg->iov != kmsg->fast_iov)	2223	if (!io_wq_current_is_worker() && kmsg && kmsg->iov != kmsg->fast_iov)
2223	kfree(kmsg->iov);	2224	kfree(kmsg->iov);
2224	io_cqring_add_event(req, ret);	2225	io_cqring_add_event(req, ret);
@@ -2231,20 +2232,24 @@ out: · 6 unmodified lines
2231	#endif	2232	#endif
2232	}	2233	}
2233		2234
2234	static int io_recvmsg_prep(struct io_kiocb req, struct io_async_ctx io)	2235	static int io_recvmsg_prep(struct io_kiocb *req,
		2236	const struct io_uring_sqe *sqe)
2235	{	2237	{
2236	#if defined(CONFIG_NET)	2238	#if defined(CONFIG_NET)
2237	const struct io_uring_sqe *sqe = req->sqe;	2239	struct io_sr_msg *sr = &req->sr_msg;
2238	struct user_msghdr __user *msg;	2240	struct io_async_ctx *io = req->io;
2239	unsigned flags;	2241
		2242	sr->msg_flags = READ_ONCE(sqe->msg_flags);
		2243	sr->msg = u64_to_user_ptr(READ_ONCE(sqe->addr));
		2244
		2245	if (!io)
		2246	return 0;
2240		2247
2241	flags = READ_ONCE(sqe->msg_flags);
2242	msg = (struct user_msghdr __user *)(unsigned long) READ_ONCE(sqe->addr);
2243	io->msg.iov = io->msg.fast_iov;	2248	io->msg.iov = io->msg.fast_iov;
2244	return recvmsg_copy_msghdr(&io->msg.msg, msg, flags, &io->msg.uaddr,	2249	return recvmsg_copy_msghdr(&io->msg.msg, sr->msg, sr->msg_flags,
2245	&io->msg.iov);	2250	&io->msg.uaddr, &io->msg.iov);
2246	#else	2251	#else
2247	return 0;	2252	return -EOPNOTSUPP;
2248	#endif	2253	#endif
2249	}	2254	}
2250		2255
@@ -2252,7 +2257,6 @@ static int io_recvmsg(struct io_kiocb req, struct io_kiocb *nxt, · 1 unmodified line
2252	bool force_nonblock)	2257	bool force_nonblock)
2253	{	2258	{
2254	#if defined(CONFIG_NET)	2259	#if defined(CONFIG_NET)
2255	const struct io_uring_sqe *sqe = req->sqe;
2256	struct io_async_msghdr *kmsg = NULL;	2260	struct io_async_msghdr *kmsg = NULL;
2257	struct socket *sock;	2261	struct socket *sock;
2258	int ret;	2262	int ret;
@@ -2262,19 +2266,10 @@ static int io_recvmsg(struct io_kiocb req, struct io_kiocb *nxt, · 3 unmodified lines
2262		2266
2263	sock = sock_from_file(req->file, &ret);	2267	sock = sock_from_file(req->file, &ret);
2264	if (sock) {	2268	if (sock) {
2265	struct user_msghdr __user *msg;
2266	struct io_async_ctx io;	2269	struct io_async_ctx io;
2267	struct sockaddr_storage addr;	2270	struct sockaddr_storage addr;
2268	unsigned flags;	2271	unsigned flags;
2269		2272
2270	flags = READ_ONCE(sqe->msg_flags);
2271	if (flags & MSG_DONTWAIT)
2272	req->flags \|= REQ_F_NOWAIT;
2273	else if (force_nonblock)
2274	flags \|= MSG_DONTWAIT;
2275
2276	msg = (struct user_msghdr __user *) (unsigned long)
2277	READ_ONCE(sqe->addr);
2278	if (req->io) {	2273	if (req->io) {
2279	kmsg = &req->io->msg;	2274	kmsg = &req->io->msg;
2280	kmsg->msg.msg_name = &addr;	2275	kmsg->msg.msg_name = &addr;
@@ -2283,14 +2278,27 @@ static int io_recvmsg(struct io_kiocb req, struct io_kiocb *nxt, · 2 unmodified lines
2283	kmsg->iov = kmsg->fast_iov;	2278	kmsg->iov = kmsg->fast_iov;
2284	kmsg->msg.msg_iter.iov = kmsg->iov;	2279	kmsg->msg.msg_iter.iov = kmsg->iov;
2285	} else {	2280	} else {
		2281	struct io_sr_msg *sr = &req->sr_msg;
		2282
2286	kmsg = &io.msg;	2283	kmsg = &io.msg;
2287	kmsg->msg.msg_name = &addr;	2284	kmsg->msg.msg_name = &addr;
2288	ret = io_recvmsg_prep(req, &io);	2285
		2286	io.msg.iov = io.msg.fast_iov;
		2287	ret = recvmsg_copy_msghdr(&io.msg.msg, sr->msg,
		2288	sr->msg_flags, &io.msg.uaddr,
		2289	&io.msg.iov);
2289	if (ret)	2290	if (ret)
2290	goto out;	2291	return ret;
2291	}	2292	}
2292		2293
2293	ret = __sys_recvmsg_sock(sock, &kmsg->msg, msg, kmsg->uaddr, flags);	2294	flags = req->sr_msg.msg_flags;
		2295	if (flags & MSG_DONTWAIT)
		2296	req->flags \|= REQ_F_NOWAIT;
		2297	else if (force_nonblock)
		2298	flags \|= MSG_DONTWAIT;
		2299
		2300	ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.msg,
		2301	kmsg->uaddr, flags);
2294	if (force_nonblock && ret == -EAGAIN) {	2302	if (force_nonblock && ret == -EAGAIN) {
2295	if (req->io)	2303	if (req->io)
2296	return -EAGAIN;	2304	return -EAGAIN;
@@ -2304,7 +2312,6 @@ static int io_recvmsg(struct io_kiocb req, struct io_kiocb *nxt, · 7 unmodified lines
2304	ret = -EINTR;	2312	ret = -EINTR;
2305	}	2313	}
2306		2314
2307	out:
2308	if (!io_wq_current_is_worker() && kmsg && kmsg->iov != kmsg->fast_iov)	2315	if (!io_wq_current_is_worker() && kmsg && kmsg->iov != kmsg->fast_iov)
2309	kfree(kmsg->iov);	2316	kfree(kmsg->iov);
2310	io_cqring_add_event(req, ret);	2317	io_cqring_add_event(req, ret);
@@ -2317,25 +2324,19 @@ out: · 6 unmodified lines
2317	#endif	2324	#endif
2318	}	2325	}
2319		2326
2320	static int io_accept_prep(struct io_kiocb *req)	2327	static int io_accept_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
2321	{	2328	{
2322	#if defined(CONFIG_NET)	2329	#if defined(CONFIG_NET)
2323	const struct io_uring_sqe *sqe = req->sqe;
2324	struct io_accept *accept = &req->accept;	2330	struct io_accept *accept = &req->accept;
2325		2331
2326	if (req->flags & REQ_F_PREPPED)
2327	return 0;
2328
2329	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL\|IORING_SETUP_SQPOLL)))	2332	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL\|IORING_SETUP_SQPOLL)))
2330	return -EINVAL;	2333	return -EINVAL;
2331	if (sqe->ioprio \|\| sqe->len \|\| sqe->buf_index)	2334	if (sqe->ioprio \|\| sqe->len \|\| sqe->buf_index)
2332	return -EINVAL;	2335	return -EINVAL;
2333		2336
2334	accept->addr = (struct sockaddr __user *)	2337	accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
2335	(unsigned long) READ_ONCE(sqe->addr);	2338	accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
2336	accept->addr_len = (int __user *) (unsigned long) READ_ONCE(sqe->addr2);
2337	accept->flags = READ_ONCE(sqe->accept_flags);	2339	accept->flags = READ_ONCE(sqe->accept_flags);
2338	req->flags \|= REQ_F_PREPPED;
2339	return 0;	2340	return 0;
2340	#else	2341	#else
2341	return -EOPNOTSUPP;	2342	return -EOPNOTSUPP;
@@ -2383,10 +2384,6 @@ static int io_accept(struct io_kiocb req, struct io_kiocb *nxt, · 41 unmodified lines
2383	#if defined(CONFIG_NET)	2384	#if defined(CONFIG_NET)
2384	int ret;	2385	int ret;
2385		2386
2386	ret = io_accept_prep(req);
2387	if (ret)
2388	return ret;
2389
2390	ret = __io_accept(req, nxt, force_nonblock);	2387	ret = __io_accept(req, nxt, force_nonblock);
2391	if (ret == -EAGAIN && force_nonblock) {	2388	if (ret == -EAGAIN && force_nonblock) {
2392	req->work.func = io_accept_finish;	2389	req->work.func = io_accept_finish;
@@ -2400,18 +2397,27 @@ static int io_accept(struct io_kiocb req, struct io_kiocb *nxt, · 7 unmodified lines
2400	#endif	2397	#endif
2401	}	2398	}
2402		2399
2403	static int io_connect_prep(struct io_kiocb req, struct io_async_ctx io)	2400	static int io_connect_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
2404	{	2401	{
2405	#if defined(CONFIG_NET)	2402	#if defined(CONFIG_NET)
2406	const struct io_uring_sqe *sqe = req->sqe;	2403	struct io_connect *conn = &req->connect;
2407	struct sockaddr __user *addr;	2404	struct io_async_ctx *io = req->io;
2408	int addr_len;
2409		2405
2410	addr = (struct sockaddr __user *) (unsigned long) READ_ONCE(sqe->addr);	2406	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL\|IORING_SETUP_SQPOLL)))
2411	addr_len = READ_ONCE(sqe->addr2);	2407	return -EINVAL;
2412	return move_addr_to_kernel(addr, addr_len, &io->connect.address);	2408	if (sqe->ioprio \|\| sqe->len \|\| sqe->buf_index \|\| sqe->rw_flags)
		2409	return -EINVAL;
		2410
		2411	conn->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
		2412	conn->addr_len = READ_ONCE(sqe->addr2);
		2413
		2414	if (!io)
		2415	return 0;
		2416
		2417	return move_addr_to_kernel(conn->addr, conn->addr_len,
		2418	&io->connect.address);
2413	#else	2419	#else
2414	return 0;	2420	return -EOPNOTSUPP;
2415	#endif	2421	#endif
2416	}	2422	}
2417		2423
@@ -2419,30 +2425,25 @@ static int io_connect(struct io_kiocb req, struct io_kiocb *nxt, · 1 unmodified line
2419	bool force_nonblock)	2425	bool force_nonblock)
2420	{	2426	{
2421	#if defined(CONFIG_NET)	2427	#if defined(CONFIG_NET)
2422	const struct io_uring_sqe *sqe = req->sqe;
2423	struct io_async_ctx __io, *io;	2428	struct io_async_ctx __io, *io;
2424	unsigned file_flags;	2429	unsigned file_flags;
2425	int addr_len, ret;	2430	int ret;
2426
2427	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL\|IORING_SETUP_SQPOLL)))
2428	return -EINVAL;
2429	if (sqe->ioprio \|\| sqe->len \|\| sqe->buf_index \|\| sqe->rw_flags)
2430	return -EINVAL;
2431
2432	addr_len = READ_ONCE(sqe->addr2);
2433	file_flags = force_nonblock ? O_NONBLOCK : 0;
2434		2431
2435	if (req->io) {	2432	if (req->io) {
2436	io = req->io;	2433	io = req->io;
2437	} else {	2434	} else {
2438	ret = io_connect_prep(req, &__io);	2435	ret = move_addr_to_kernel(req->connect.addr,
		2436	req->connect.addr_len,
		2437	&__io.connect.address);
2439	if (ret)	2438	if (ret)
2440	goto out;	2439	goto out;
2441	io = &__io;	2440	io = &__io;
2442	}	2441	}
2443		2442
2444	ret = __sys_connect_file(req->file, &io->connect.address, addr_len,	2443	file_flags = force_nonblock ? O_NONBLOCK : 0;
2445	file_flags);	2444
		2445	ret = __sys_connect_file(req->file, &io->connect.address,
		2446	req->connect.addr_len, file_flags);
2446	if ((ret == -EAGAIN \|\| ret == -EINPROGRESS) && force_nonblock) {	2447	if ((ret == -EAGAIN \|\| ret == -EINPROGRESS) && force_nonblock) {
2447	if (req->io)	2448	if (req->io)
2448	return -EAGAIN;	2449	return -EAGAIN;
@@ -2513,12 +2514,9 @@ static int io_poll_cancel(struct io_ring_ctx *ctx, __u64 sqe_addr) · 64 unmodified lines
2513	return -ENOENT;	2514	return -ENOENT;
2514	}	2515	}
2515		2516
2516	static int io_poll_remove_prep(struct io_kiocb *req)	2517	static int io_poll_remove_prep(struct io_kiocb *req,
		2518	const struct io_uring_sqe *sqe)
2517	{	2519	{
2518	const struct io_uring_sqe *sqe = req->sqe;
2519
2520	if (req->flags & REQ_F_PREPPED)
2521	return 0;
2522	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))	2520	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
2523	return -EINVAL;	2521	return -EINVAL;
2524	if (sqe->ioprio \|\| sqe->off \|\| sqe->len \|\| sqe->buf_index \|\|	2522	if (sqe->ioprio \|\| sqe->off \|\| sqe->len \|\| sqe->buf_index \|\|
@@ -2526,7 +2524,6 @@ static int io_poll_remove_prep(struct io_kiocb *req) · 1 unmodified line
2526	return -EINVAL;	2524	return -EINVAL;
2527		2525
2528	req->poll.addr = READ_ONCE(sqe->addr);	2526	req->poll.addr = READ_ONCE(sqe->addr);
2529	req->flags \|= REQ_F_PREPPED;
2530	return 0;	2527	return 0;
2531	}	2528	}
2532		2529
@@ -2540,10 +2537,6 @@ static int io_poll_remove(struct io_kiocb *req) · 7 unmodified lines
2540	u64 addr;	2537	u64 addr;
2541	int ret;	2538	int ret;
2542		2539
2543	ret = io_poll_remove_prep(req);
2544	if (ret)
2545	return ret;
2546
2547	addr = req->poll.addr;	2540	addr = req->poll.addr;
2548	spin_lock_irq(&ctx->completion_lock);	2541	spin_lock_irq(&ctx->completion_lock);
2549	ret = io_poll_cancel(ctx, addr);	2542	ret = io_poll_cancel(ctx, addr);
@@ -2681,14 +2674,11 @@ static void io_poll_req_insert(struct io_kiocb *req) · 131 unmodified lines
2681	hlist_add_head(&req->hash_node, list);	2674	hlist_add_head(&req->hash_node, list);
2682	}	2675	}
2683		2676
2684	static int io_poll_add_prep(struct io_kiocb *req)	2677	static int io_poll_add_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
2685	{	2678	{
2686	const struct io_uring_sqe *sqe = req->sqe;
2687	struct io_poll_iocb *poll = &req->poll;	2679	struct io_poll_iocb *poll = &req->poll;
2688	u16 events;	2680	u16 events;
2689		2681
2690	if (req->flags & REQ_F_PREPPED)
2691	return 0;
2692	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))	2682	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
2693	return -EINVAL;	2683	return -EINVAL;
2694	if (sqe->addr \|\| sqe->ioprio \|\| sqe->off \|\| sqe->len \|\| sqe->buf_index)	2684	if (sqe->addr \|\| sqe->ioprio \|\| sqe->off \|\| sqe->len \|\| sqe->buf_index)
@@ -2696,7 +2686,6 @@ static int io_poll_add_prep(struct io_kiocb *req) · 1 unmodified line
2696	if (!poll->file)	2686	if (!poll->file)
2697	return -EBADF;	2687	return -EBADF;
2698		2688
2699	req->flags \|= REQ_F_PREPPED;
2700	events = READ_ONCE(sqe->poll_events);	2689	events = READ_ONCE(sqe->poll_events);
2701	poll->events = demangle_poll(events) \| EPOLLERR \| EPOLLHUP;	2690	poll->events = demangle_poll(events) \| EPOLLERR \| EPOLLHUP;
2702	return 0;	2691	return 0;
@@ -2709,11 +2698,6 @@ static int io_poll_add(struct io_kiocb req, struct io_kiocb *nxt) · 6 unmodified lines
2709	struct io_poll_table ipt;	2698	struct io_poll_table ipt;
2710	bool cancel = false;	2699	bool cancel = false;
2711	__poll_t mask;	2700	__poll_t mask;
2712	int ret;
2713
2714	ret = io_poll_add_prep(req);
2715	if (ret)
2716	return ret;
2717		2701
2718	INIT_IO_WORK(&req->work, io_poll_complete_work);	2702	INIT_IO_WORK(&req->work, io_poll_complete_work);
2719	INIT_HLIST_NODE(&req->hash_node);	2703	INIT_HLIST_NODE(&req->hash_node);
@@ -2832,12 +2816,9 @@ static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data) · 112 unmodified lines
2832	return 0;	2816	return 0;
2833	}	2817	}
2834		2818
2835	static int io_timeout_remove_prep(struct io_kiocb *req)	2819	static int io_timeout_remove_prep(struct io_kiocb *req,
		2820	const struct io_uring_sqe *sqe)
2836	{	2821	{
2837	const struct io_uring_sqe *sqe = req->sqe;
2838
2839	if (req->flags & REQ_F_PREPPED)
2840	return 0;
2841	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))	2822	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
2842	return -EINVAL;	2823	return -EINVAL;
2843	if (sqe->flags \|\| sqe->ioprio \|\| sqe->buf_index \|\| sqe->len)	2824	if (sqe->flags \|\| sqe->ioprio \|\| sqe->buf_index \|\| sqe->len)
@@ -2848,7 +2829,6 @@ static int io_timeout_remove_prep(struct io_kiocb *req) · 4 unmodified lines
2848	if (req->timeout.flags)	2829	if (req->timeout.flags)
2849	return -EINVAL;	2830	return -EINVAL;
2850		2831
2851	req->flags \|= REQ_F_PREPPED;
2852	return 0;	2832	return 0;
2853	}	2833	}
2854		2834
@@ -2860,10 +2840,6 @@ static int io_timeout_remove(struct io_kiocb *req) · 5 unmodified lines
2860	struct io_ring_ctx *ctx = req->ctx;	2840	struct io_ring_ctx *ctx = req->ctx;
2861	int ret;	2841	int ret;
2862		2842
2863	ret = io_timeout_remove_prep(req);
2864	if (ret)
2865	return ret;
2866
2867	spin_lock_irq(&ctx->completion_lock);	2843	spin_lock_irq(&ctx->completion_lock);
2868	ret = io_timeout_cancel(ctx, req->timeout.addr);	2844	ret = io_timeout_cancel(ctx, req->timeout.addr);
2869		2845
@@ -2877,10 +2853,9 @@ static int io_timeout_remove(struct io_kiocb *req) · 7 unmodified lines
2877	return 0;	2853	return 0;
2878	}	2854	}
2879		2855
2880	static int io_timeout_prep(struct io_kiocb req, struct io_async_ctx io,	2856	static int io_timeout_prep(struct io_kiocb req, const struct io_uring_sqe sqe,
2881	bool is_timeout_link)	2857	bool is_timeout_link)
2882	{	2858	{
2883	const struct io_uring_sqe *sqe = req->sqe;
2884	struct io_timeout_data *data;	2859	struct io_timeout_data *data;
2885	unsigned flags;	2860	unsigned flags;
2886		2861
@@ -2894,7 +2869,12 @@ static int io_timeout_prep(struct io_kiocb req, struct io_async_ctx io, · 7 unmodified lines
2894	if (flags & ~IORING_TIMEOUT_ABS)	2869	if (flags & ~IORING_TIMEOUT_ABS)
2895	return -EINVAL;	2870	return -EINVAL;
2896		2871
2897	data = &io->timeout;	2872	req->timeout.count = READ_ONCE(sqe->off);
		2873
		2874	if (!req->io && io_alloc_async_ctx(req))
		2875	return -ENOMEM;
		2876
		2877	data = &req->io->timeout;
2898	data->req = req;	2878	data->req = req;
2899	req->flags \|= REQ_F_TIMEOUT;	2879	req->flags \|= REQ_F_TIMEOUT;
2900		2880
@@ -2912,21 +2892,12 @@ static int io_timeout_prep(struct io_kiocb req, struct io_async_ctx io, · 11 unmodified lines
2912		2892
2913	static int io_timeout(struct io_kiocb *req)	2893	static int io_timeout(struct io_kiocb *req)
2914	{	2894	{
2915	const struct io_uring_sqe *sqe = req->sqe;
2916	unsigned count;	2895	unsigned count;
2917	struct io_ring_ctx *ctx = req->ctx;	2896	struct io_ring_ctx *ctx = req->ctx;
2918	struct io_timeout_data *data;	2897	struct io_timeout_data *data;
2919	struct list_head *entry;	2898	struct list_head *entry;
2920	unsigned span = 0;	2899	unsigned span = 0;
2921	int ret;
2922		2900
2923	if (!req->io) {
2924	if (io_alloc_async_ctx(req))
2925	return -ENOMEM;
2926	ret = io_timeout_prep(req, req->io, false);
2927	if (ret)
2928	return ret;
2929	}
2930	data = &req->io->timeout;	2901	data = &req->io->timeout;
2931		2902
2932	/*	2903	/*
@@ -2934,7 +2905,7 @@ static int io_timeout(struct io_kiocb *req) · 1 unmodified line
2934	* timeout event to be satisfied. If it isn't set, then this is	2905	* timeout event to be satisfied. If it isn't set, then this is
2935	* a pure timeout request, sequence isn't used.	2906	* a pure timeout request, sequence isn't used.
2936	*/	2907	*/
2937	count = READ_ONCE(sqe->off);	2908	count = req->timeout.count;
2938	if (!count) {	2909	if (!count) {
2939	req->flags \|= REQ_F_TIMEOUT_NOSEQ;	2910	req->flags \|= REQ_F_TIMEOUT_NOSEQ;
2940	spin_lock_irq(&ctx->completion_lock);	2911	spin_lock_irq(&ctx->completion_lock);
@@ -3052,19 +3023,15 @@ done: · 111 unmodified lines
3052	io_put_req_find_next(req, nxt);	3023	io_put_req_find_next(req, nxt);
3053	}	3024	}
3054		3025
3055	static int io_async_cancel_prep(struct io_kiocb *req)	3026	static int io_async_cancel_prep(struct io_kiocb *req,
		3027	const struct io_uring_sqe *sqe)
3056	{	3028	{
3057	const struct io_uring_sqe *sqe = req->sqe;
3058
3059	if (req->flags & REQ_F_PREPPED)
3060	return 0;
3061	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))	3029	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3062	return -EINVAL;	3030	return -EINVAL;
3063	if (sqe->flags \|\| sqe->ioprio \|\| sqe->off \|\| sqe->len \|\|	3031	if (sqe->flags \|\| sqe->ioprio \|\| sqe->off \|\| sqe->len \|\|
3064	sqe->cancel_flags)	3032	sqe->cancel_flags)
3065	return -EINVAL;	3033	return -EINVAL;
3066		3034
3067	req->flags \|= REQ_F_PREPPED;
3068	req->cancel.addr = READ_ONCE(sqe->addr);	3035	req->cancel.addr = READ_ONCE(sqe->addr);
3069	return 0;	3036	return 0;
3070	}	3037	}
@@ -3072,21 +3039,14 @@ static int io_async_cancel_prep(struct io_kiocb *req) · 1 unmodified line
3072	static int io_async_cancel(struct io_kiocb req, struct io_kiocb *nxt)	3039	static int io_async_cancel(struct io_kiocb req, struct io_kiocb *nxt)
3073	{	3040	{
3074	struct io_ring_ctx *ctx = req->ctx;	3041	struct io_ring_ctx *ctx = req->ctx;
3075	int ret;
3076
3077	ret = io_async_cancel_prep(req);
3078	if (ret)
3079	return ret;
3080		3042
3081	io_async_find_and_cancel(ctx, req, req->cancel.addr, nxt, 0);	3043	io_async_find_and_cancel(ctx, req, req->cancel.addr, nxt, 0);
3082	return 0;	3044	return 0;
3083	}	3045	}
3084		3046
3085	static int io_req_defer_prep(struct io_kiocb *req)	3047	static int io_req_defer_prep(struct io_kiocb *req,
		3048	const struct io_uring_sqe *sqe)
3086	{	3049	{
3087	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
3088	struct io_async_ctx *io = req->io;
3089	struct iov_iter iter;
3090	ssize_t ret = 0;	3050	ssize_t ret = 0;
3091		3051
3092	switch (req->opcode) {	3052	switch (req->opcode) {
@@ -3094,61 +3054,47 @@ static int io_req_defer_prep(struct io_kiocb *req) · 1 unmodified line
3094	break;	3054	break;
3095	case IORING_OP_READV:	3055	case IORING_OP_READV:
3096	case IORING_OP_READ_FIXED:	3056	case IORING_OP_READ_FIXED:
3097	/* ensure prep does right import */	3057	ret = io_read_prep(req, sqe, true);
3098	req->io = NULL;
3099	ret = io_read_prep(req, &iovec, &iter, true);
3100	req->io = io;
3101	if (ret < 0)
3102	break;
3103	io_req_map_rw(req, ret, iovec, inline_vecs, &iter);
3104	ret = 0;
3105	break;	3058	break;
3106	case IORING_OP_WRITEV:	3059	case IORING_OP_WRITEV:
3107	case IORING_OP_WRITE_FIXED:	3060	case IORING_OP_WRITE_FIXED:
3108	/* ensure prep does right import */	3061	ret = io_write_prep(req, sqe, true);
3109	req->io = NULL;
3110	ret = io_write_prep(req, &iovec, &iter, true);
3111	req->io = io;
3112	if (ret < 0)
3113	break;
3114	io_req_map_rw(req, ret, iovec, inline_vecs, &iter);
3115	ret = 0;
3116	break;	3062	break;
3117	case IORING_OP_POLL_ADD:	3063	case IORING_OP_POLL_ADD:
3118	ret = io_poll_add_prep(req);	3064	ret = io_poll_add_prep(req, sqe);
3119	break;	3065	break;
3120	case IORING_OP_POLL_REMOVE:	3066	case IORING_OP_POLL_REMOVE:
3121	ret = io_poll_remove_prep(req);	3067	ret = io_poll_remove_prep(req, sqe);
3122	break;	3068	break;
3123	case IORING_OP_FSYNC:	3069	case IORING_OP_FSYNC:
3124	ret = io_prep_fsync(req);	3070	ret = io_prep_fsync(req, sqe);
3125	break;	3071	break;
3126	case IORING_OP_SYNC_FILE_RANGE:	3072	case IORING_OP_SYNC_FILE_RANGE:
3127	ret = io_prep_sfr(req);	3073	ret = io_prep_sfr(req, sqe);
3128	break;	3074	break;
3129	case IORING_OP_SENDMSG:	3075	case IORING_OP_SENDMSG:
3130	ret = io_sendmsg_prep(req, io);	3076	ret = io_sendmsg_prep(req, sqe);
3131	break;	3077	break;
3132	case IORING_OP_RECVMSG:	3078	case IORING_OP_RECVMSG:
3133	ret = io_recvmsg_prep(req, io);	3079	ret = io_recvmsg_prep(req, sqe);
3134	break;	3080	break;
3135	case IORING_OP_CONNECT:	3081	case IORING_OP_CONNECT:
3136	ret = io_connect_prep(req, io);	3082	ret = io_connect_prep(req, sqe);
3137	break;	3083	break;
3138	case IORING_OP_TIMEOUT:	3084	case IORING_OP_TIMEOUT:
3139	ret = io_timeout_prep(req, io, false);	3085	ret = io_timeout_prep(req, sqe, false);
3140	break;	3086	break;
3141	case IORING_OP_TIMEOUT_REMOVE:	3087	case IORING_OP_TIMEOUT_REMOVE:
3142	ret = io_timeout_remove_prep(req);	3088	ret = io_timeout_remove_prep(req, sqe);
3143	break;	3089	break;
3144	case IORING_OP_ASYNC_CANCEL:	3090	case IORING_OP_ASYNC_CANCEL:
3145	ret = io_async_cancel_prep(req);	3091	ret = io_async_cancel_prep(req, sqe);
3146	break;	3092	break;
3147	case IORING_OP_LINK_TIMEOUT:	3093	case IORING_OP_LINK_TIMEOUT:
3148	ret = io_timeout_prep(req, io, true);	3094	ret = io_timeout_prep(req, sqe, true);
3149	break;	3095	break;
3150	case IORING_OP_ACCEPT:	3096	case IORING_OP_ACCEPT:
3151	ret = io_accept_prep(req);	3097	ret = io_accept_prep(req, sqe);
3152	break;	3098	break;
3153	default:	3099	default:
3154	printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",	3100	printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
@@ -3160,7 +3106,7 @@ static int io_req_defer_prep(struct io_kiocb *req) · 5 unmodified lines
3160	return ret;	3106	return ret;
3161	}	3107	}
3162		3108
3163	static int io_req_defer(struct io_kiocb *req)	3109	static int io_req_defer(struct io_kiocb req, const struct io_uring_sqe sqe)
3164	{	3110	{
3165	struct io_ring_ctx *ctx = req->ctx;	3111	struct io_ring_ctx *ctx = req->ctx;
3166	int ret;	3112	int ret;
@@ -3169,10 +3115,10 @@ static int io_req_defer(struct io_kiocb *req) · 2 unmodified lines
3169	if (!req_need_defer(req) && list_empty(&ctx->defer_list))	3115	if (!req_need_defer(req) && list_empty(&ctx->defer_list))
3170	return 0;	3116	return 0;
3171		3117
3172	if (io_alloc_async_ctx(req))	3118	if (!req->io && io_alloc_async_ctx(req))
3173	return -EAGAIN;	3119	return -EAGAIN;
3174		3120
3175	ret = io_req_defer_prep(req);	3121	ret = io_req_defer_prep(req, sqe);
3176	if (ret < 0)	3122	if (ret < 0)
3177	return ret;	3123	return ret;
3178		3124
@@ -3188,9 +3134,8 @@ static int io_req_defer(struct io_kiocb *req) · 9 unmodified lines
3188	return -EIOCBQUEUED;	3134	return -EIOCBQUEUED;
3189	}	3135	}
3190		3136
3191	__attribute__((nonnull))	3137	static int io_issue_sqe(struct io_kiocb req, const struct io_uring_sqe sqe,
3192	static int io_issue_sqe(struct io_kiocb req, struct io_kiocb *nxt,	3138	struct io_kiocb **nxt, bool force_nonblock)
3193	bool force_nonblock)
3194	{	3139	{
3195	struct io_ring_ctx *ctx = req->ctx;	3140	struct io_ring_ctx *ctx = req->ctx;
3196	int ret;	3141	int ret;
@@ -3200,52 +3145,109 @@ static int io_issue_sqe(struct io_kiocb req, struct io_kiocb *nxt, · 3 unmodified lines
3200	ret = io_nop(req);	3145	ret = io_nop(req);
3201	break;	3146	break;
3202	case IORING_OP_READV:	3147	case IORING_OP_READV:
3203	if (unlikely(req->sqe->buf_index))
3204	return -EINVAL;
3205	ret = io_read(req, nxt, force_nonblock);
3206	break;
3207	case IORING_OP_WRITEV:
3208	if (unlikely(req->sqe->buf_index))
3209	return -EINVAL;
3210	ret = io_write(req, nxt, force_nonblock);
3211	break;
3212	case IORING_OP_READ_FIXED:	3148	case IORING_OP_READ_FIXED:
		3149	if (sqe) {
		3150	ret = io_read_prep(req, sqe, force_nonblock);
		3151	if (ret < 0)
		3152	break;
		3153	}
3213	ret = io_read(req, nxt, force_nonblock);	3154	ret = io_read(req, nxt, force_nonblock);
3214	break;	3155	break;
		3156	case IORING_OP_WRITEV:
3215	case IORING_OP_WRITE_FIXED:	3157	case IORING_OP_WRITE_FIXED:
		3158	if (sqe) {
		3159	ret = io_write_prep(req, sqe, force_nonblock);
		3160	if (ret < 0)
		3161	break;
		3162	}
3216	ret = io_write(req, nxt, force_nonblock);	3163	ret = io_write(req, nxt, force_nonblock);
3217	break;	3164	break;
3218	case IORING_OP_FSYNC:	3165	case IORING_OP_FSYNC:
		3166	if (sqe) {
		3167	ret = io_prep_fsync(req, sqe);
		3168	if (ret < 0)
		3169	break;
		3170	}
3219	ret = io_fsync(req, nxt, force_nonblock);	3171	ret = io_fsync(req, nxt, force_nonblock);
3220	break;	3172	break;
3221	case IORING_OP_POLL_ADD:	3173	case IORING_OP_POLL_ADD:
		3174	if (sqe) {
		3175	ret = io_poll_add_prep(req, sqe);
		3176	if (ret)
		3177	break;
		3178	}
3222	ret = io_poll_add(req, nxt);	3179	ret = io_poll_add(req, nxt);
3223	break;	3180	break;
3224	case IORING_OP_POLL_REMOVE:	3181	case IORING_OP_POLL_REMOVE:
		3182	if (sqe) {
		3183	ret = io_poll_remove_prep(req, sqe);
		3184	if (ret < 0)
		3185	break;
		3186	}
3225	ret = io_poll_remove(req);	3187	ret = io_poll_remove(req);
3226	break;	3188	break;
3227	case IORING_OP_SYNC_FILE_RANGE:	3189	case IORING_OP_SYNC_FILE_RANGE:
		3190	if (sqe) {
		3191	ret = io_prep_sfr(req, sqe);
		3192	if (ret < 0)
		3193	break;
		3194	}
3228	ret = io_sync_file_range(req, nxt, force_nonblock);	3195	ret = io_sync_file_range(req, nxt, force_nonblock);
3229	break;	3196	break;
3230	case IORING_OP_SENDMSG:	3197	case IORING_OP_SENDMSG:
		3198	if (sqe) {
		3199	ret = io_sendmsg_prep(req, sqe);
		3200	if (ret < 0)
		3201	break;
		3202	}
3231	ret = io_sendmsg(req, nxt, force_nonblock);	3203	ret = io_sendmsg(req, nxt, force_nonblock);
3232	break;	3204	break;
3233	case IORING_OP_RECVMSG:	3205	case IORING_OP_RECVMSG:
		3206	if (sqe) {
		3207	ret = io_recvmsg_prep(req, sqe);
		3208	if (ret)
		3209	break;
		3210	}
3234	ret = io_recvmsg(req, nxt, force_nonblock);	3211	ret = io_recvmsg(req, nxt, force_nonblock);
3235	break;	3212	break;
3236	case IORING_OP_TIMEOUT:	3213	case IORING_OP_TIMEOUT:
		3214	if (sqe) {
		3215	ret = io_timeout_prep(req, sqe, false);
		3216	if (ret)
		3217	break;
		3218	}
3237	ret = io_timeout(req);	3219	ret = io_timeout(req);
3238	break;	3220	break;
3239	case IORING_OP_TIMEOUT_REMOVE:	3221	case IORING_OP_TIMEOUT_REMOVE:
		3222	if (sqe) {
		3223	ret = io_timeout_remove_prep(req, sqe);
		3224	if (ret)
		3225	break;
		3226	}
3240	ret = io_timeout_remove(req);	3227	ret = io_timeout_remove(req);
3241	break;	3228	break;
3242	case IORING_OP_ACCEPT:	3229	case IORING_OP_ACCEPT:
		3230	if (sqe) {
		3231	ret = io_accept_prep(req, sqe);
		3232	if (ret)
		3233	break;
		3234	}
3243	ret = io_accept(req, nxt, force_nonblock);	3235	ret = io_accept(req, nxt, force_nonblock);
3244	break;	3236	break;
3245	case IORING_OP_CONNECT:	3237	case IORING_OP_CONNECT:
		3238	if (sqe) {
		3239	ret = io_connect_prep(req, sqe);
		3240	if (ret)
		3241	break;
		3242	}
3246	ret = io_connect(req, nxt, force_nonblock);	3243	ret = io_connect(req, nxt, force_nonblock);
3247	break;	3244	break;
3248	case IORING_OP_ASYNC_CANCEL:	3245	case IORING_OP_ASYNC_CANCEL:
		3246	if (sqe) {
		3247	ret = io_async_cancel_prep(req, sqe);
		3248	if (ret)
		3249	break;
		3250	}
3249	ret = io_async_cancel(req, nxt);	3251	ret = io_async_cancel(req, nxt);
3250	break;	3252	break;
3251	default:	3253	default:
@@ -3289,7 +3291,7 @@ static void io_wq_submit_work(struct io_wq_work **workptr) · 37 unmodified lines
3289	req->has_user = (work->flags & IO_WQ_WORK_HAS_MM) != 0;	3291	req->has_user = (work->flags & IO_WQ_WORK_HAS_MM) != 0;
3290	req->in_async = true;	3292	req->in_async = true;
3291	do {	3293	do {
3292	ret = io_issue_sqe(req, &nxt, false);	3294	ret = io_issue_sqe(req, NULL, &nxt, false);
3293	/*	3295	/*
3294	* We can get EAGAIN for polled IO even though we're	3296	* We can get EAGAIN for polled IO even though we're
3295	* forcing a sync submission from here, since we can't	3297	* forcing a sync submission from here, since we can't
@@ -3355,14 +3357,15 @@ static inline struct file io_file_from_index(struct io_ring_ctx ctx, · 59 unmodified lines
3355	return table->files[index & IORING_FILE_TABLE_MASK];	3357	return table->files[index & IORING_FILE_TABLE_MASK];
3356	}	3358	}
3357		3359
3358	static int io_req_set_file(struct io_submit_state state, struct io_kiocb req)	3360	static int io_req_set_file(struct io_submit_state state, struct io_kiocb req,
		3361	const struct io_uring_sqe *sqe)
3359	{	3362	{
3360	struct io_ring_ctx *ctx = req->ctx;	3363	struct io_ring_ctx *ctx = req->ctx;
3361	unsigned flags;	3364	unsigned flags;
3362	int fd, ret;	3365	int fd, ret;
3363		3366
3364	flags = READ_ONCE(req->sqe->flags);	3367	flags = READ_ONCE(sqe->flags);
3365	fd = READ_ONCE(req->sqe->fd);	3368	fd = READ_ONCE(sqe->fd);
3366		3369
3367	if (flags & IOSQE_IO_DRAIN)	3370	if (flags & IOSQE_IO_DRAIN)
3368	req->flags \|= REQ_F_IO_DRAIN;	3371	req->flags \|= REQ_F_IO_DRAIN;
@@ -3494,7 +3497,7 @@ static struct io_kiocb io_prep_linked_timeout(struct io_kiocb req) · 125 unmodified lines
3494	return nxt;	3497	return nxt;
3495	}	3498	}
3496		3499
3497	static void __io_queue_sqe(struct io_kiocb *req)	3500	static void __io_queue_sqe(struct io_kiocb req, const struct io_uring_sqe sqe)
3498	{	3501	{
3499	struct io_kiocb *linked_timeout;	3502	struct io_kiocb *linked_timeout;
3500	struct io_kiocb *nxt = NULL;	3503	struct io_kiocb *nxt = NULL;
@@ -3503,7 +3506,7 @@ static void __io_queue_sqe(struct io_kiocb *req) · 2 unmodified lines
3503	again:	3506	again:
3504	linked_timeout = io_prep_linked_timeout(req);	3507	linked_timeout = io_prep_linked_timeout(req);
3505		3508
3506	ret = io_issue_sqe(req, &nxt, true);	3509	ret = io_issue_sqe(req, sqe, &nxt, true);
3507		3510
3508	/*	3511	/*
3509	* We async punt it if the file wasn't marked NOWAIT, or if the file	3512	* We async punt it if the file wasn't marked NOWAIT, or if the file
@@ -3550,7 +3553,7 @@ done_req: · 40 unmodified lines
3550	}	3553	}
3551	}	3554	}
3552		3555
3553	static void io_queue_sqe(struct io_kiocb *req)	3556	static void io_queue_sqe(struct io_kiocb req, const struct io_uring_sqe sqe)
3554	{	3557	{
3555	int ret;	3558	int ret;
3556		3559
@@ -3560,7 +3563,7 @@ static void io_queue_sqe(struct io_kiocb *req) · 3 unmodified lines
3560	}	3563	}
3561	req->ctx->drain_next = (req->flags & REQ_F_DRAIN_LINK);	3564	req->ctx->drain_next = (req->flags & REQ_F_DRAIN_LINK);
3562		3565
3563	ret = io_req_defer(req);	3566	ret = io_req_defer(req, sqe);
3564	if (ret) {	3567	if (ret) {
3565	if (ret != -EIOCBQUEUED) {	3568	if (ret != -EIOCBQUEUED) {
3566	io_cqring_add_event(req, ret);	3569	io_cqring_add_event(req, ret);
@@ -3568,7 +3571,7 @@ static void io_queue_sqe(struct io_kiocb *req) · 1 unmodified line
3568	io_double_put_req(req);	3571	io_double_put_req(req);
3569	}	3572	}
3570	} else	3573	} else
3571	__io_queue_sqe(req);	3574	__io_queue_sqe(req, sqe);
3572	}	3575	}
3573		3576
3574	static inline void io_queue_link_head(struct io_kiocb *req)	3577	static inline void io_queue_link_head(struct io_kiocb *req)
@@ -3577,25 +3580,25 @@ static inline void io_queue_link_head(struct io_kiocb *req) · 2 unmodified lines
3577	io_cqring_add_event(req, -ECANCELED);	3580	io_cqring_add_event(req, -ECANCELED);
3578	io_double_put_req(req);	3581	io_double_put_req(req);
3579	} else	3582	} else
3580	io_queue_sqe(req);	3583	io_queue_sqe(req, NULL);
3581	}	3584	}
3582		3585
3583	#define SQE_VALID_FLAGS (IOSQE_FIXED_FILE\|IOSQE_IO_DRAIN\|IOSQE_IO_LINK\| \	3586	#define SQE_VALID_FLAGS (IOSQE_FIXED_FILE\|IOSQE_IO_DRAIN\|IOSQE_IO_LINK\| \
3584	IOSQE_IO_HARDLINK)	3587	IOSQE_IO_HARDLINK)
3585		3588
3586	static bool io_submit_sqe(struct io_kiocb req, struct io_submit_state state,	3589	static bool io_submit_sqe(struct io_kiocb req, const struct io_uring_sqe sqe,
3587	struct io_kiocb **link)	3590	struct io_submit_state state, struct io_kiocb *link)
3588	{	3591	{
3589	struct io_ring_ctx *ctx = req->ctx;	3592	struct io_ring_ctx *ctx = req->ctx;
3590	int ret;	3593	int ret;
3591		3594
3592	/* enforce forwards compatibility on users */	3595	/* enforce forwards compatibility on users */
3593	if (unlikely(req->sqe->flags & ~SQE_VALID_FLAGS)) {	3596	if (unlikely(sqe->flags & ~SQE_VALID_FLAGS)) {
3594	ret = -EINVAL;	3597	ret = -EINVAL;
3595	goto err_req;	3598	goto err_req;
3596	}	3599	}
3597		3600
3598	ret = io_req_set_file(state, req);	3601	ret = io_req_set_file(state, req, sqe);
3599	if (unlikely(ret)) {	3602	if (unlikely(ret)) {
3600	err_req:	3603	err_req:
3601	io_cqring_add_event(req, ret);	3604	io_cqring_add_event(req, ret);
@@ -3613,10 +3616,10 @@ err_req: · 11 unmodified lines
3613	if (*link) {	3616	if (*link) {
3614	struct io_kiocb prev = link;	3617	struct io_kiocb prev = link;
3615		3618
3616	if (req->sqe->flags & IOSQE_IO_DRAIN)	3619	if (sqe->flags & IOSQE_IO_DRAIN)
3617	(*link)->flags \|= REQ_F_DRAIN_LINK \| REQ_F_IO_DRAIN;	3620	(*link)->flags \|= REQ_F_DRAIN_LINK \| REQ_F_IO_DRAIN;
3618		3621
3619	if (req->sqe->flags & IOSQE_IO_HARDLINK)	3622	if (sqe->flags & IOSQE_IO_HARDLINK)
3620	req->flags \|= REQ_F_HARDLINK;	3623	req->flags \|= REQ_F_HARDLINK;
3621		3624
3622	if (io_alloc_async_ctx(req)) {	3625	if (io_alloc_async_ctx(req)) {
@@ -3624,7 +3627,7 @@ err_req: · 1 unmodified line
3624	goto err_req;	3627	goto err_req;
3625	}	3628	}
3626		3629
3627	ret = io_req_defer_prep(req);	3630	ret = io_req_defer_prep(req, sqe);
3628	if (ret) {	3631	if (ret) {
3629	/* fail even hard links since we don't submit */	3632	/* fail even hard links since we don't submit */
3630	prev->flags \|= REQ_F_FAIL_LINK;	3633	prev->flags \|= REQ_F_FAIL_LINK;
@@ -3632,15 +3635,18 @@ err_req: · 1 unmodified line
3632	}	3635	}
3633	trace_io_uring_link(ctx, req, prev);	3636	trace_io_uring_link(ctx, req, prev);
3634	list_add_tail(&req->link_list, &prev->link_list);	3637	list_add_tail(&req->link_list, &prev->link_list);
3635	} else if (req->sqe->flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {	3638	} else if (sqe->flags & (IOSQE_IO_LINK\|IOSQE_IO_HARDLINK)) {
3636	req->flags \|= REQ_F_LINK;	3639	req->flags \|= REQ_F_LINK;
3637	if (req->sqe->flags & IOSQE_IO_HARDLINK)	3640	if (sqe->flags & IOSQE_IO_HARDLINK)
3638	req->flags \|= REQ_F_HARDLINK;	3641	req->flags \|= REQ_F_HARDLINK;
3639		3642
3640	INIT_LIST_HEAD(&req->link_list);	3643	INIT_LIST_HEAD(&req->link_list);
		3644	ret = io_req_defer_prep(req, sqe);
		3645	if (ret)
		3646	req->flags \|= REQ_F_FAIL_LINK;
3641	*link = req;	3647	*link = req;
3642	} else {	3648	} else {
3643	io_queue_sqe(req);	3649	io_queue_sqe(req, sqe);
3644	}	3650	}
3645		3651
3646	return true;	3652	return true;
@@ -3685,14 +3691,15 @@ static void io_commit_sqring(struct io_ring_ctx *ctx) · 38 unmodified lines
3685	}	3691	}
3686		3692
3687	/*	3693	/*
3688	* Fetch an sqe, if one is available. Note that req->sqe will point to memory	3694	* Fetch an sqe, if one is available. Note that sqe_ptr will point to memory
3689	* that is mapped by userspace. This means that care needs to be taken to	3695	* that is mapped by userspace. This means that care needs to be taken to
3690	* ensure that reads are stable, as we cannot rely on userspace always	3696	* ensure that reads are stable, as we cannot rely on userspace always
3691	* being a good citizen. If members of the sqe are validated and then later	3697	* being a good citizen. If members of the sqe are validated and then later
3692	* used, it's important that those reads are done through READ_ONCE() to	3698	* used, it's important that those reads are done through READ_ONCE() to
3693	* prevent a re-load down the line.	3699	* prevent a re-load down the line.
3694	*/	3700	*/
3695	static bool io_get_sqring(struct io_ring_ctx ctx, struct io_kiocb req)	3701	static bool io_get_sqring(struct io_ring_ctx ctx, struct io_kiocb req,
		3702	const struct io_uring_sqe **sqe_ptr)
3696	{	3703	{
3697	struct io_rings *rings = ctx->rings;	3704	struct io_rings *rings = ctx->rings;
3698	u32 *sq_array = ctx->sq_array;	3705	u32 *sq_array = ctx->sq_array;
@@ -3719,9 +3726,9 @@ static bool io_get_sqring(struct io_ring_ctx ctx, struct io_kiocb req) · 20 unmodified lines
3719	* link list.	3726	* link list.
3720	*/	3727	*/
3721	req->sequence = ctx->cached_sq_head;	3728	req->sequence = ctx->cached_sq_head;
3722	req->sqe = &ctx->sq_sqes[head];	3729	*sqe_ptr = &ctx->sq_sqes[head];
3723	req->opcode = READ_ONCE(req->sqe->opcode);	3730	req->opcode = READ_ONCE((*sqe_ptr)->opcode);
3724	req->user_data = READ_ONCE(req->sqe->user_data);	3731	req->user_data = READ_ONCE((*sqe_ptr)->user_data);
3725	ctx->cached_sq_head++;	3732	ctx->cached_sq_head++;
3726	return true;	3733	return true;
3727	}	3734	}
@@ -3753,6 +3760,7 @@ static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr, · 25 unmodified lines
3753	}	3760	}
3754		3761
3755	for (i = 0; i < nr; i++) {	3762	for (i = 0; i < nr; i++) {
		3763	const struct io_uring_sqe *sqe;
3756	struct io_kiocb *req;	3764	struct io_kiocb *req;
3757	unsigned int sqe_flags;	3765	unsigned int sqe_flags;
3758		3766
@@ -3762,7 +3770,7 @@ static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr, · 3 unmodified lines
3762	submitted = -EAGAIN;	3770	submitted = -EAGAIN;
3763	break;	3771	break;
3764	}	3772	}
3765	if (!io_get_sqring(ctx, req)) {	3773	if (!io_get_sqring(ctx, req, &sqe)) {
3766	__io_free_req(req);	3774	__io_free_req(req);
3767	break;	3775	break;
3768	}	3776	}
@@ -3776,7 +3784,7 @@ static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr, · 7 unmodified lines
3776	}	3784	}
3777		3785
3778	submitted++;	3786	submitted++;
3779	sqe_flags = req->sqe->flags;	3787	sqe_flags = sqe->flags;
3780		3788
3781	req->ring_file = ring_file;	3789	req->ring_file = ring_file;
3782	req->ring_fd = ring_fd;	3790	req->ring_fd = ring_fd;
@@ -3784,7 +3792,7 @@ static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr, · 1 unmodified line
3784	req->in_async = async;	3792	req->in_async = async;
3785	req->needs_fixed_file = async;	3793	req->needs_fixed_file = async;
3786	trace_io_uring_submit_sqe(ctx, req->user_data, true, async);	3794	trace_io_uring_submit_sqe(ctx, req->user_data, true, async);
3787	if (!io_submit_sqe(req, statep, &link))	3795	if (!io_submit_sqe(req, sqe, statep, &link))
3788	break;	3796	break;
3789	/*	3797	/*
3790	* If previous wasn't linked and we have a linked command,	3798	* If previous wasn't linked and we have a linked command,
@@ -4702,7 +4710,7 @@ static int io_copy_iov(struct io_ring_ctx ctx, struct iovec dst, · 911 unmodified lines
4702	if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))	4710	if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
4703	return -EFAULT;	4711	return -EFAULT;
4704		4712
4705	dst->iov_base = (void __user *) (unsigned long) ciov.iov_base;	4713	dst->iov_base = u64_to_user_ptr((u64)ciov.iov_base);
4706	dst->iov_len = ciov.iov_len;	4714	dst->iov_len = ciov.iov_len;
4707	return 0;	4715	return 0;
4708	}	4716	}

fs/locks.c+1−1

@@ -2853,7 +2853,7 @@ static void lock_get_status(struct seq_file f, struct file_lock fl, · 2852 unmodified lines
2853	}	2853	}
2854	if (inode) {	2854	if (inode) {
2855	/* userspace relies on this representation of dev_t */	2855	/* userspace relies on this representation of dev_t */
2856	seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,	2856	seq_printf(f, "%d %02x:%02x:%lu ", fl_pid,
2857	MAJOR(inode->i_sb->s_dev),	2857	MAJOR(inode->i_sb->s_dev),
2858	MINOR(inode->i_sb->s_dev), inode->i_ino);	2858	MINOR(inode->i_sb->s_dev), inode->i_ino);
2859	} else {	2859	} else {

fs/mpage.c+1−1

@@ -62,7 +62,7 @@ static struct bio mpage_bio_submit(int op, int op_flags, struct bio bio) · 61 unmodified lines
62	{	62	{
63	bio->bi_end_io = mpage_end_io;	63	bio->bi_end_io = mpage_end_io;
64	bio_set_op_attrs(bio, op, op_flags);	64	bio_set_op_attrs(bio, op, op_flags);
65	guard_bio_eod(op, bio);	65	guard_bio_eod(bio);
66	submit_bio(bio);	66	submit_bio(bio);
67	return NULL;	67	return NULL;
68	}	68	}

fs/namespace.c+1−1

@@ -1728,7 +1728,7 @@ static bool is_mnt_ns_file(struct dentry *dentry) · 1727 unmodified lines
1728	dentry->d_fsdata == &mntns_operations;	1728	dentry->d_fsdata == &mntns_operations;
1729	}	1729	}
1730		1730
1731	struct mnt_namespace to_mnt_ns(struct ns_common ns)	1731	static struct mnt_namespace to_mnt_ns(struct ns_common ns)
1732	{	1732	{
1733	return container_of(ns, struct mnt_namespace, ns);	1733	return container_of(ns, struct mnt_namespace, ns);
1734	}	1734	}

fs/nsfs.c+3−0

 #include <linux/pseudo_fs.h>
 #include <linux/file.h>
 #include <linux/fs.h>
+#include <linux/proc_fs.h>
 #include <linux/proc_ns.h>
 #include <linux/magic.h>
 #include <linux/ktime.h>
 #include <linux/nsfs.h>
 #include <linux/uaccess.h>
+#include "internal.h"
 static struct vfsmount *nsfs_mnt;
 static long ns_ioctl(struct file *filp, unsigned int ioctl,

fs/ocfs2/dlmglue.c+1−0

@@ -3282,6 +3282,7 @@ static void ocfs2_dlm_init_debug(struct ocfs2_super *osb) · 3281 unmodified lines
3282		3282
3283	debugfs_create_u32("locking_filter", 0600, osb->osb_debug_root,	3283	debugfs_create_u32("locking_filter", 0600, osb->osb_debug_root,
3284	&dlm_debug->d_filter_secs);	3284	&dlm_debug->d_filter_secs);
		3285	ocfs2_get_dlm_debug(dlm_debug);
3285	}	3286	}
3286		3287
3287	static void ocfs2_dlm_shutdown_debug(struct ocfs2_super *osb)	3288	static void ocfs2_dlm_shutdown_debug(struct ocfs2_super *osb)

fs/ocfs2/journal.c+8−0

@@ -1066,6 +1066,14 @@ int ocfs2_journal_load(struct ocfs2_journal *journal, int local, int replayed) · 1065 unmodified lines
1066		1066
1067	ocfs2_clear_journal_error(osb->sb, journal->j_journal, osb->slot_num);	1067	ocfs2_clear_journal_error(osb->sb, journal->j_journal, osb->slot_num);
1068		1068
		1069	if (replayed) {
		1070	jbd2_journal_lock_updates(journal->j_journal);
		1071	status = jbd2_journal_flush(journal->j_journal);
		1072	jbd2_journal_unlock_updates(journal->j_journal);
		1073	if (status < 0)
		1074	mlog_errno(status);
		1075	}
		1076
1069	status = ocfs2_journal_toggle_dirty(osb, 1, replayed);	1077	status = ocfs2_journal_toggle_dirty(osb, 1, replayed);
1070	if (status < 0) {	1078	if (status < 0) {
1071	mlog_errno(status);	1079	mlog_errno(status);

fs/posix_acl.c+5−2

 /**
  * posix_acl_update_mode  -  update mode in set_acl
+ * @inode: target inode
+ * @mode_p: mode (pointer) for update
+ * @acl: acl pointer
  *
  * Update the file mode when setting an ACL: compute the new file permission
  * bits based on the ACL.  In addition, if the ACL is equivalent to the new
- * file mode, set *acl to NULL to indicate that no ACL should be set.
+ * file mode, set *@acl to NULL to indicate that no ACL should be set.
  *
- * As with chmod, clear the setgit bit if the caller is not in the owning group
+ * As with chmod, clear the setgid bit if the caller is not in the owning group
  * or capable of CAP_FSETID (see inode_change_ok).
  *
  * Called from set_acl inode operations.

fs/pstore/ram.c+13−0

 	prz = cxt->dprzs[cxt->dump_write_cnt];
+	/*
+	 * Since this is a new crash dump, we need to reset the buffer in
+	 * case it still has an old dump present. Without this, the new dump
+	 * will get appended, which would seriously confuse anything trying
+	 * to check dump file contents. Specifically, ramoops_read_kmsg_hdr()
+	 * expects to find a dump header in the beginning of buffer data, so
+	 * we must to reset the buffer values, in order to ensure that the
+	 * header will be written to the beginning of the buffer.
+	 */
+	persistent_ram_zap(prz);
 	/* Build header and append record contents. */
 	hlen = ramoops_write_kmsg_hdr(prz, record);
 	if (!hlen)
 		prz_ar[i] = persistent_ram_new(*paddr, zone_sz, sig,
 					       &cxt->ecc_info,
 					       cxt->memtype, flags, label);
+		kfree(label);
 		if (IS_ERR(prz_ar[i])) {
 			err = PTR_ERR(prz_ar[i]);
 			dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
 	label = kasprintf(GFP_KERNEL, "ramoops:%s", name);
 	*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info,
 				  cxt->memtype, PRZ_FLAG_ZAP_OLD, label);
+	kfree(label);
 	if (IS_ERR(*prz)) {
 		int err = PTR_ERR(*prz);

fs/pstore/ram_core.c+1−1

@@ -574,7 +574,7 @@ struct persistent_ram_zone *persistent_ram_new(phys_addr_t start, size_t size, · 573 unmodified lines
574	/* Initialize general buffer state. */	574	/* Initialize general buffer state. */
575	raw_spin_lock_init(&prz->buffer_lock);	575	raw_spin_lock_init(&prz->buffer_lock);
576	prz->flags = flags;	576	prz->flags = flags;
577	prz->label = label;	577	prz->label = kstrdup(label, GFP_KERNEL);
578		578
579	ret = persistent_ram_buffer_map(start, size, prz, memtype);	579	ret = persistent_ram_buffer_map(start, size, prz, memtype);
580	if (ret)	580	if (ret)

include/linux/ahci_platform.h+2−0

@@ -19,6 +19,8 @@ struct ahci_host_priv; · 18 unmodified lines
19	struct platform_device;	19	struct platform_device;
20	struct scsi_host_template;	20	struct scsi_host_template;
21		21
		22	int ahci_platform_enable_phys(struct ahci_host_priv *hpriv);
		23	void ahci_platform_disable_phys(struct ahci_host_priv *hpriv);
22	int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);	24	int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);
23	void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);	25	void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);
24	int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);	26	int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);

include/linux/bio.h+1−0

@@ -470,6 +470,7 @@ extern struct bio bio_copy_user_iov(struct request_queue , · 469 unmodified lines
470	gfp_t);	470	gfp_t);
471	extern int bio_uncopy_user(struct bio *);	471	extern int bio_uncopy_user(struct bio *);
472	void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);	472	void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);
		473	void bio_truncate(struct bio *bio, unsigned new_size);
473		474
474	static inline void zero_fill_bio(struct bio *bio)	475	static inline void zero_fill_bio(struct bio *bio)
475	{	476	{

include/linux/bvec.h+0−22

@@ -153,26 +153,4 @@ static inline void bvec_advance(const struct bio_vec *bvec, · 152 unmodified lines
153	}	153	}
154	}	154	}
155		155
156	/*
157	* Get the last single-page segment from the multi-page bvec and store it
158	* in @seg
159	*/
160	static inline void mp_bvec_last_segment(const struct bio_vec *bvec,
161	struct bio_vec *seg)
162	{
163	unsigned total = bvec->bv_offset + bvec->bv_len;
164	unsigned last_page = (total - 1) / PAGE_SIZE;
165
166	seg->bv_page = bvec->bv_page + last_page;
167
168	/* the whole segment is inside the last page */
169	if (bvec->bv_offset >= last_page * PAGE_SIZE) {
170	seg->bv_offset = bvec->bv_offset % PAGE_SIZE;
171	seg->bv_len = bvec->bv_len;
172	} else {
173	seg->bv_offset = 0;
174	seg->bv_len = total - last_page * PAGE_SIZE;
175	}
176	}
177
178	#endif /* __LINUX_BVEC_ITER_H */	156	#endif /* __LINUX_BVEC_ITER_H */

include/linux/can/dev.h+34−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <linux/can/error.h>	18	#include <linux/can/error.h>
19	#include <linux/can/led.h>	19	#include <linux/can/led.h>
20	#include <linux/can/netlink.h>	20	#include <linux/can/netlink.h>
		21	#include <linux/can/skb.h>
21	#include <linux/netdevice.h>	22	#include <linux/netdevice.h>
22		23
23	/*	24	/*
@@ -91,6 +92,36 @@ struct can_priv { · 67 unmodified lines
91	#define get_can_dlc(i) (min_t(__u8, (i), CAN_MAX_DLC))	92	#define get_can_dlc(i) (min_t(__u8, (i), CAN_MAX_DLC))
92	#define get_canfd_dlc(i) (min_t(__u8, (i), CANFD_MAX_DLC))	93	#define get_canfd_dlc(i) (min_t(__u8, (i), CANFD_MAX_DLC))
93		94
		95	/* Check for outgoing skbs that have not been created by the CAN subsystem */
		96	static inline bool can_skb_headroom_valid(struct net_device *dev,
		97	struct sk_buff *skb)
		98	{
		99	/* af_packet creates a headroom of HH_DATA_MOD bytes which is fine */
		100	if (WARN_ON_ONCE(skb_headroom(skb) < sizeof(struct can_skb_priv)))
		101	return false;
		102
		103	/* af_packet does not apply CAN skb specific settings */
		104	if (skb->ip_summed == CHECKSUM_NONE) {
		105	/* init headroom */
		106	can_skb_prv(skb)->ifindex = dev->ifindex;
		107	can_skb_prv(skb)->skbcnt = 0;
		108
		109	skb->ip_summed = CHECKSUM_UNNECESSARY;
		110
		111	/* preform proper loopback on capable devices */
		112	if (dev->flags & IFF_ECHO)
		113	skb->pkt_type = PACKET_LOOPBACK;
		114	else
		115	skb->pkt_type = PACKET_HOST;
		116
		117	skb_reset_mac_header(skb);
		118	skb_reset_network_header(skb);
		119	skb_reset_transport_header(skb);
		120	}
		121
		122	return true;
		123	}
		124
94	/* Drop a given socketbuffer if it does not contain a valid CAN frame. */	125	/* Drop a given socketbuffer if it does not contain a valid CAN frame. */
95	static inline bool can_dropped_invalid_skb(struct net_device *dev,	126	static inline bool can_dropped_invalid_skb(struct net_device *dev,
96	struct sk_buff *skb)	127	struct sk_buff *skb)
@@ -108,6 +139,9 @@ static inline bool can_dropped_invalid_skb(struct net_device *dev, · 11 unmodified lines
108	} else	139	} else
109	goto inval_skb;	140	goto inval_skb;
110		141
		142	if (!can_skb_headroom_valid(dev, skb))
		143	goto inval_skb;
		144
111	return false;	145	return false;
112		146
113	inval_skb:	147	inval_skb:

include/linux/dmaengine.h+4−1

 static inline int dmaengine_desc_set_reuse(struct dma_async_tx_descriptor *tx)
 {
 	struct dma_slave_caps caps;
+	int ret;
-	dma_get_slave_caps(tx->chan, &caps);
+	ret = dma_get_slave_caps(tx->chan, &caps);
+	if (ret)
+		return ret;
 	if (caps.descriptor_reuse) {
 		tx->flags |= DMA_CTRL_REUSE;

include/linux/if_ether.h+8−0

@@ -24,6 +24,14 @@ static inline struct ethhdr eth_hdr(const struct sk_buff skb) · 23 unmodified lines
24	return (struct ethhdr *)skb_mac_header(skb);	24	return (struct ethhdr *)skb_mac_header(skb);
25	}	25	}
26		26
		27	/* Prefer this version in TX path, instead of
		28	* skb_reset_mac_header() + eth_hdr()
		29	*/
		30	static inline struct ethhdr skb_eth_hdr(const struct sk_buff skb)
		31	{
		32	return (struct ethhdr *)skb->data;
		33	}
		34
27	static inline struct ethhdr inner_eth_hdr(const struct sk_buff skb)	35	static inline struct ethhdr inner_eth_hdr(const struct sk_buff skb)
28	{	36	{
29	return (struct ethhdr *)skb_inner_mac_header(skb);	37	return (struct ethhdr *)skb_inner_mac_header(skb);

include/linux/kernel.h+0−9

@@ -79,15 +79,6 @@ · 78 unmodified lines
79	*/	79	*/
80	#define round_down(x, y) ((x) & ~__round_mask(x, y))	80	#define round_down(x, y) ((x) & ~__round_mask(x, y))
81		81
82	/**
83	* FIELD_SIZEOF - get the size of a struct's field
84	* @t: the target struct
85	* @f: the target struct's field
86	* Return: the size of @f in the struct definition without having a
87	* declared instance of @t.
88	*/
89	#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
90
91	#define typeof_member(T, m) typeof(((T*)0)->m)	82	#define typeof_member(T, m) typeof(((T*)0)->m)
92		83
93	#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP	84	#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP

include/linux/libata.h+1−0

@@ -1175,6 +1175,7 @@ extern unsigned int ata_do_dev_read_id(struct ata_device *dev, · 1174 unmodified lines
1175	struct ata_taskfile tf, u16 id);	1175	struct ata_taskfile tf, u16 id);
1176	extern void ata_qc_complete(struct ata_queued_cmd *qc);	1176	extern void ata_qc_complete(struct ata_queued_cmd *qc);
1177	extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);	1177	extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);
		1178	extern u64 ata_qc_get_active(struct ata_port *ap);
1178	extern void ata_scsi_simulate(struct ata_device dev, struct scsi_cmnd cmd);	1179	extern void ata_scsi_simulate(struct ata_device dev, struct scsi_cmnd cmd);
1179	extern int ata_std_bios_param(struct scsi_device *sdev,	1180	extern int ata_std_bios_param(struct scsi_device *sdev,
1180	struct block_device *bdev,	1181	struct block_device *bdev,

include/linux/memory_hotplug.h+5−2

 extern void arch_remove_memory(int nid, u64 start, u64 size,
 			       struct vmem_altmap *altmap);
-extern void __remove_pages(struct zone *zone, unsigned long start_pfn,
+extern void __remove_pages(unsigned long start_pfn, unsigned long nr_pages,
-			   unsigned long nr_pages, struct vmem_altmap *altmap);
+			   struct vmem_altmap *altmap);
 /* reasonably generic interface to expand the physical pages */
 extern int __add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
 extern int add_memory_resource(int nid, struct resource *resource);
 extern void move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
 		unsigned long nr_pages, struct vmem_altmap *altmap);
+extern void remove_pfn_range_from_zone(struct zone *zone,
+				       unsigned long start_pfn,
+				       unsigned long nr_pages);
 extern bool is_memblock_offlined(struct memory_block *mem);
 extern int sparse_add_section(int nid, unsigned long pfn,
 		unsigned long nr_pages, struct vmem_altmap *altmap);

include/linux/mfd/mt6397/rtc.h+8−0

@@ -46,6 +46,14 @@ · 45 unmodified lines
46		46
47	#define RTC_AL_SEC 0x0018	47	#define RTC_AL_SEC 0x0018
48		48
		49	#define RTC_AL_SEC_MASK 0x003f
		50	#define RTC_AL_MIN_MASK 0x003f
		51	#define RTC_AL_HOU_MASK 0x001f
		52	#define RTC_AL_DOM_MASK 0x001f
		53	#define RTC_AL_DOW_MASK 0x0007
		54	#define RTC_AL_MTH_MASK 0x000f
		55	#define RTC_AL_YEA_MASK 0x007f
		56
49	#define RTC_PDN2 0x002e	57	#define RTC_PDN2 0x002e
50	#define RTC_PDN2_PWRON_ALARM BIT(4)	58	#define RTC_PDN2_PWRON_ALARM BIT(4)
51		59

include/linux/mtd/flashchip.h+1−1

@@ -40,7 +40,7 @@ typedef enum { · 39 unmodified lines
40	FL_READING,	40	FL_READING,
41	FL_CACHEDPRG,	41	FL_CACHEDPRG,
42	/* These 4 come from onenand_state_t, which has been unified here */	42	/* These 4 come from onenand_state_t, which has been unified here */
43	FL_RESETING,	43	FL_RESETTING,
44	FL_OTPING,	44	FL_OTPING,
45	FL_PREPARING_ERASE,	45	FL_PREPARING_ERASE,
46	FL_VERIFYING_ERASE,	46	FL_VERIFYING_ERASE,

include/linux/of_mdio.h+1−1

@@ -55,7 +55,7 @@ static inline int of_mdio_parse_addr(struct device *dev, · 54 unmodified lines
55	}	55	}
56		56
57	#else /* CONFIG_OF_MDIO */	57	#else /* CONFIG_OF_MDIO */
58	static bool of_mdiobus_child_is_phy(struct device_node *child)	58	static inline bool of_mdiobus_child_is_phy(struct device_node *child)
59	{	59	{
60	return false;	60	return false;
61	}	61	}

include/linux/posix-clock.h+11−8

  *
  * @ops:     Functional interface to the clock
  * @cdev:    Character device instance for this clock
- * @kref:    Reference count.
+ * @dev:     Pointer to the clock's device.
  * @rwsem:   Protects the 'zombie' field from concurrent access.
  * @zombie:  If 'zombie' is true, then the hardware has disappeared.
- * @release: A function to free the structure when the reference count reaches
- *           zero. May be NULL if structure is statically allocated.
  *
  * Drivers should embed their struct posix_clock within a private
  * structure, obtaining a reference to it during callbacks using
  * container_of().
+ *
+ * Drivers should supply an initialized but not exposed struct device
+ * to posix_clock_register(). It is used to manage lifetime of the
+ * driver's private structure. It's 'release' field should be set to
+ * a release function for this private structure.
  */
 struct posix_clock {
 	struct posix_clock_operations ops;
 	struct cdev cdev;
-	struct kref kref;
+	struct device *dev;
 	struct rw_semaphore rwsem;
 	bool zombie;
-	void (*release)(struct posix_clock *clk);
 };
 /**
  * posix_clock_register() - register a new clock
- * @clk:   Pointer to the clock. Caller must provide 'ops' and 'release'
+ * @clk:   Pointer to the clock. Caller must provide 'ops' field
- * @devid: Allocated device id
+ * @dev:   Pointer to the initialized device. Caller must provide
+ *         'release' field
  *
  * A clock driver calls this function to register itself with the
  * clock device subsystem. If 'clk' points to dynamically allocated
  *
  * Returns zero on success, non-zero otherwise.
  */
-int posix_clock_register(struct posix_clock *clk, dev_t devid);
+int posix_clock_register(struct posix_clock *clk, struct device *dev);
 /**
  * posix_clock_unregister() - unregister a clock

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

@@ -689,10 +689,10 @@ extern void spi_finalize_current_transfer(struct spi_controller *ctlr); · 688 unmodified lines
689	/* Helper calls for driver to timestamp transfer */	689	/* Helper calls for driver to timestamp transfer */
690	void spi_take_timestamp_pre(struct spi_controller *ctlr,	690	void spi_take_timestamp_pre(struct spi_controller *ctlr,
691	struct spi_transfer *xfer,	691	struct spi_transfer *xfer,
692	const void *tx, bool irqs_off);	692	size_t progress, bool irqs_off);
693	void spi_take_timestamp_post(struct spi_controller *ctlr,	693	void spi_take_timestamp_post(struct spi_controller *ctlr,
694	struct spi_transfer *xfer,	694	struct spi_transfer *xfer,
695	const void *tx, bool irqs_off);	695	size_t progress, bool irqs_off);
696		696
697	/* the spi driver core manages memory for the spi_controller classdev */	697	/* the spi driver core manages memory for the spi_controller classdev */
698	extern struct spi_controller __spi_alloc_controller(struct device host,	698	extern struct spi_controller __spi_alloc_controller(struct device host,

include/linux/sxgbe_platform.h+1−1

@@ -1,6 +1,6 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */	1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*	2	/*
3	* 10G controller driver for Samsung EXYNOS SoCs	3	* 10G controller driver for Samsung Exynos SoCs
4	*	4	*
5	* Copyright (C) 2013 Samsung Electronics Co., Ltd.	5	* Copyright (C) 2013 Samsung Electronics Co., Ltd.
6	* http://www.samsung.com	6	* http://www.samsung.com

include/linux/syscalls.h+1−0

@@ -1232,6 +1232,7 @@ asmlinkage long sys_ni_syscall(void); · 1231 unmodified lines
1232	*/	1232	*/
1233		1233
1234	int ksys_umount(char __user *name, int flags);	1234	int ksys_umount(char __user *name, int flags);
		1235	int ksys_dup(unsigned int fildes);
1235	int ksys_chroot(const char __user *filename);	1236	int ksys_chroot(const char __user *filename);
1236	ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count);	1237	ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count);
1237	int ksys_chdir(const char __user *filename);	1238	int ksys_chdir(const char __user *filename);

include/net/dst.h+11−2

 	struct dst_entry *dst = skb_dst(skb);
 	if (dst && dst->ops->update_pmtu)
-		dst->ops->update_pmtu(dst, NULL, skb, mtu);
+		dst->ops->update_pmtu(dst, NULL, skb, mtu, true);
+}
+/* update dst pmtu but not do neighbor confirm */
+static inline void skb_dst_update_pmtu_no_confirm(struct sk_buff *skb, u32 mtu)
+{
+	struct dst_entry *dst = skb_dst(skb);
+	if (dst && dst->ops->update_pmtu)
+		dst->ops->update_pmtu(dst, NULL, skb, mtu, false);
 }
 static inline void skb_tunnel_check_pmtu(struct sk_buff *skb,
 	u32 encap_mtu = dst_mtu(encap_dst);
 	if (skb->len > encap_mtu - headroom)
-		skb_dst_update_pmtu(skb, encap_mtu - headroom);
+		skb_dst_update_pmtu_no_confirm(skb, encap_mtu - headroom);
 }
 #endif /* _NET_DST_H */

include/net/dst_ops.h+2−1

 	struct dst_entry *	(*negative_advice)(struct dst_entry *);
 	void			(*link_failure)(struct sk_buff *);
 	void			(*update_pmtu)(struct dst_entry *dst, struct sock *sk,
-					       struct sk_buff *skb, u32 mtu);
+					       struct sk_buff *skb, u32 mtu,
+					       bool confirm_neigh);
 	void			(*redirect)(struct dst_entry *dst, struct sock *sk,
 					    struct sk_buff *skb);
 	int			(*local_out)(struct net *net, struct sock *sk, struct sk_buff *skb);

include/net/netfilter/nf_flow_table.h+6−0

 };
 #define NF_FLOW_TIMEOUT (30 * HZ)
+#define nf_flowtable_time_stamp	(u32)jiffies
+static inline __s32 nf_flow_timeout_delta(unsigned int timeout)
+{
+	return (__s32)(timeout - nf_flowtable_time_stamp);
+}
 struct nf_flow_route {
 	struct {

include/net/sch_generic.h+5−0

 	int			(*delete)(struct tcf_proto *tp, void *arg,
 					  bool *last, bool rtnl_held,
 					  struct netlink_ext_ack *);
+	bool			(*delete_empty)(struct tcf_proto *tp);
 	void			(*walk)(struct tcf_proto *tp,
 					struct tcf_walker *arg, bool rtnl_held);
 	int			(*reoffload)(struct tcf_proto *tp, bool add,
 	int			flags;
 };
+/* Classifiers setting TCF_PROTO_OPS_DOIT_UNLOCKED in tcf_proto_ops->flags
+ * are expected to implement tcf_proto_ops->delete_empty(), otherwise race
+ * conditions can occur when filters are inserted/deleted simultaneously.
+ */
 enum tcf_proto_ops_flags {
 	TCF_PROTO_OPS_DOIT_UNLOCKED = 1,
 };

include/soc/sifive/sifive_l2_cache.hrenamed from arch/riscv/include/asm/sifive_l2_cache.h+3−3

@@ -4,8 +4,8 @@ · 3 unmodified lines
4	*	4	*
5	*/	5	*/
6		6
7	#ifndef _ASM_RISCV_SIFIVE_L2_CACHE_H	7	#ifndef __SOC_SIFIVE_L2_CACHE_H
8	#define _ASM_RISCV_SIFIVE_L2_CACHE_H	8	#define __SOC_SIFIVE_L2_CACHE_H
9		9
10	extern int register_sifive_l2_error_notifier(struct notifier_block *nb);	10	extern int register_sifive_l2_error_notifier(struct notifier_block *nb);
11	extern int unregister_sifive_l2_error_notifier(struct notifier_block *nb);	11	extern int unregister_sifive_l2_error_notifier(struct notifier_block *nb);
@@ -13,4 +13,4 @@ extern int unregister_sifive_l2_error_notifier(struct notifier_block *nb); · 1 unmodified line
13	#define SIFIVE_L2_ERR_TYPE_CE 0	13	#define SIFIVE_L2_ERR_TYPE_CE 0
14	#define SIFIVE_L2_ERR_TYPE_UE 1	14	#define SIFIVE_L2_ERR_TYPE_UE 1
15		15
16	#endif /* _ASM_RISCV_SIFIVE_L2_CACHE_H */	16	#endif /* __SOC_SIFIVE_L2_CACHE_H */

include/trace/events/preemptirq.h+4−4

@@ -18,13 +18,13 @@ DECLARE_EVENT_CLASS(preemptirq_template, · 17 unmodified lines
18	TP_ARGS(ip, parent_ip),	18	TP_ARGS(ip, parent_ip),
19		19
20	TP_STRUCT__entry(	20	TP_STRUCT__entry(
21	__field(u32, caller_offs)	21	__field(s32, caller_offs)
22	__field(u32, parent_offs)	22	__field(s32, parent_offs)
23	),	23	),
24		24
25	TP_fast_assign(	25	TP_fast_assign(
26	__entry->caller_offs = (u32)(ip - (unsigned long)_stext);	26	__entry->caller_offs = (s32)(ip - (unsigned long)_stext);
27	__entry->parent_offs = (u32)(parent_ip - (unsigned long)_stext);	27	__entry->parent_offs = (s32)(parent_ip - (unsigned long)_stext);
28	),	28	),
29		29
30	TP_printk("caller=%pS parent=%pS",	30	TP_printk("caller=%pS parent=%pS",

include/uapi/linux/input.h+1−0

@@ -34,6 +34,7 @@ struct input_event { · 33 unmodified lines
34	__kernel_ulong_t __sec;	34	__kernel_ulong_t __sec;
35	#if defined(__sparc__) && defined(__arch64__)	35	#if defined(__sparc__) && defined(__arch64__)
36	unsigned int __usec;	36	unsigned int __usec;
		37	unsigned int __pad;
37	#else	38	#else
38	__kernel_ulong_t __usec;	39	__kernel_ulong_t __usec;
39	#endif	40	#endif

include/uapi/linux/kcov.h+5−5

@@ -9,11 +9,11 @@ · 8 unmodified lines
9	* and the comment before kcov_remote_start() for usage details.	9	* and the comment before kcov_remote_start() for usage details.
10	*/	10	*/
11	struct kcov_remote_arg {	11	struct kcov_remote_arg {
12	unsigned int trace_mode; /* KCOV_TRACE_PC or KCOV_TRACE_CMP */	12	__u32 trace_mode; /* KCOV_TRACE_PC or KCOV_TRACE_CMP */
13	unsigned int area_size; /* Length of coverage buffer in words */	13	__u32 area_size; /* Length of coverage buffer in words */
14	unsigned int num_handles; /* Size of handles array */	14	__u32 num_handles; /* Size of handles array */
15	__u64 common_handle;	15	__aligned_u64 common_handle;
16	__u64 handles[0];	16	__aligned_u64 handles[0];
17	};	17	};
18		18
19	#define KCOV_REMOTE_MAX_HANDLES 0x100	19	#define KCOV_REMOTE_MAX_HANDLES 0x100

init/main.c+6−20

@@ -93,7 +93,6 @@ · 92 unmodified lines
93	#include <linux/rodata_test.h>	93	#include <linux/rodata_test.h>
94	#include <linux/jump_label.h>	94	#include <linux/jump_label.h>
95	#include <linux/mem_encrypt.h>	95	#include <linux/mem_encrypt.h>
96	#include <linux/file.h>
97		96
98	#include <asm/io.h>	97	#include <asm/io.h>
99	#include <asm/bugs.h>	98	#include <asm/bugs.h>
@@ -1158,26 +1157,13 @@ static int __ref kernel_init(void *unused) · 1058 unmodified lines
1158		1157
1159	void console_on_rootfs(void)	1158	void console_on_rootfs(void)
1160	{	1159	{
1161	struct file *file;	1160	/* Open the /dev/console as stdin, this should never fail */
1162	unsigned int i;	1161	if (ksys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
1163		1162	pr_err("Warning: unable to open an initial console.\n");
1164	/* Open /dev/console in kernelspace, this should never fail */
1165	file = filp_open("/dev/console", O_RDWR, 0);
1166	if (IS_ERR(file))
1167	goto err_out;
1168
1169	/* create stdin/stdout/stderr, this should never fail */
1170	for (i = 0; i < 3; i++) {
1171	if (f_dupfd(i, file, 0) != i)
1172	goto err_out;
1173	}
1174
1175	return;
1176		1163
1177	err_out:	1164	/* create stdout/stderr */
1178	/* no panic -- this might not be fatal */	1165	(void) ksys_dup(0);
1179	pr_err("Warning: unable to open an initial console.\n");	1166	(void) ksys_dup(0);
1180	return;
1181	}	1167	}
1182		1168
1183	static noinline void __init kernel_init_freeable(void)	1169	static noinline void __init kernel_init_freeable(void)

kernel/bpf/cgroup.c+9−2

  */
 static void cgroup_bpf_release(struct work_struct *work)
 {
-	struct cgroup *cgrp = container_of(work, struct cgroup,
+	struct cgroup *p, *cgrp = container_of(work, struct cgroup,
-					   bpf.release_work);
+					       bpf.release_work);
 	enum bpf_cgroup_storage_type stype;
 	struct bpf_prog_array *old_array;
 	unsigned int type;
 	mutex_unlock(&cgroup_mutex);
+	for (p = cgroup_parent(cgrp); p; p = cgroup_parent(p))
+		cgroup_bpf_put(p);
 	percpu_ref_exit(&cgrp->bpf.refcnt);
 	cgroup_put(cgrp);
 }
  */
 #define	NR ARRAY_SIZE(cgrp->bpf.effective)
 	struct bpf_prog_array *arrays[NR] = {};
+	struct cgroup *p;
 	int ret, i;
 	ret = percpu_ref_init(&cgrp->bpf.refcnt, cgroup_bpf_release_fn, 0,
 	if (ret)
 		return ret;
+	for (p = cgroup_parent(cgrp); p; p = cgroup_parent(p))
+		cgroup_bpf_get(p);
 	for (i = 0; i < NR; i++)
 		INIT_LIST_HEAD(&cgrp->bpf.progs[i]);

kernel/bpf/verifier.c+29−23

 	BPF_REG_0, BPF_REG_1, BPF_REG_2, BPF_REG_3, BPF_REG_4, BPF_REG_5
 };
-static void __mark_reg_not_init(struct bpf_reg_state *reg);
+static void __mark_reg_not_init(const struct bpf_verifier_env *env,
+				struct bpf_reg_state *reg);
 /* Mark the unknown part of a register (variable offset or scalar value) as
  * known to have the value @imm.
 		verbose(env, "mark_reg_known_zero(regs, %u)\n", regno);
 		/* Something bad happened, let's kill all regs */
 		for (regno = 0; regno < MAX_BPF_REG; regno++)
-			__mark_reg_not_init(regs + regno);
+			__mark_reg_not_init(env, regs + regno);
 		return;
 	}
 	__mark_reg_known_zero(regs + regno);
 }
 /* Mark a register as having a completely unknown (scalar) value. */
-static void __mark_reg_unknown(struct bpf_reg_state *reg)
+static void __mark_reg_unknown(const struct bpf_verifier_env *env,
+			       struct bpf_reg_state *reg)
 {
 	/*
 	 * Clear type, id, off, and union(map_ptr, range) and
 	reg->type = SCALAR_VALUE;
 	reg->var_off = tnum_unknown;
 	reg->frameno = 0;
+	reg->precise = env->subprog_cnt > 1 || !env->allow_ptr_leaks ?
+		       true : false;
 	__mark_reg_unbounded(reg);
 }
 		verbose(env, "mark_reg_unknown(regs, %u)\n", regno);
 		/* Something bad happened, let's kill all regs except FP */
 		for (regno = 0; regno < BPF_REG_FP; regno++)
-			__mark_reg_not_init(regs + regno);
+			__mark_reg_not_init(env, regs + regno);
 		return;
 	}
-	regs += regno;
+	__mark_reg_unknown(env, regs + regno);
-	__mark_reg_unknown(regs);
-	/* constant backtracking is enabled for root without bpf2bpf calls */
-	regs->precise = env->subprog_cnt > 1 || !env->allow_ptr_leaks ?
-			true : false;
 }
-static void __mark_reg_not_init(struct bpf_reg_state *reg)
+static void __mark_reg_not_init(const struct bpf_verifier_env *env,
+				struct bpf_reg_state *reg)
 {
-	__mark_reg_unknown(reg);
+	__mark_reg_unknown(env, reg);
 	reg->type = NOT_INIT;
 }
 		verbose(env, "mark_reg_not_init(regs, %u)\n", regno);
 		/* Something bad happened, let's kill all regs except FP */
 		for (regno = 0; regno < BPF_REG_FP; regno++)
-			__mark_reg_not_init(regs + regno);
+			__mark_reg_not_init(env, regs + regno);
 		return;
 	}
-	__mark_reg_not_init(regs + regno);
+	__mark_reg_not_init(env, regs + regno);
 }
 #define DEF_NOT_SUBREG	(0)
 		}
 		if (state->stack[spi].slot_type[0] == STACK_SPILL &&
 		    state->stack[spi].spilled_ptr.type == SCALAR_VALUE) {
-			__mark_reg_unknown(&state->stack[spi].spilled_ptr);
+			__mark_reg_unknown(env, &state->stack[spi].spilled_ptr);
 			for (j = 0; j < BPF_REG_SIZE; j++)
 				state->stack[spi].slot_type[j] = STACK_MISC;
 			goto mark;
 		if (!reg)
 			continue;
 		if (reg_is_pkt_pointer_any(reg))
-			__mark_reg_unknown(reg);
+			__mark_reg_unknown(env, reg);
 	}
 }
 		if (!reg)
 			continue;
 		if (reg->ref_obj_id == ref_obj_id)
-			__mark_reg_unknown(reg);
+			__mark_reg_unknown(env, reg);
 	}
 }
 		/* Taint dst register if offset had invalid bounds derived from
 		 * e.g. dead branches.
 		 */
-		__mark_reg_unknown(dst_reg);
+		__mark_reg_unknown(env, dst_reg);
 		return 0;
 	}
 		/* Taint dst register if offset had invalid bounds derived from
 		 * e.g. dead branches.
 		 */
-		__mark_reg_unknown(dst_reg);
+		__mark_reg_unknown(env, dst_reg);
 		return 0;
 	}
 	if (!src_known &&
 	    opcode != BPF_ADD && opcode != BPF_SUB && opcode != BPF_AND) {
-		__mark_reg_unknown(dst_reg);
+		__mark_reg_unknown(env, dst_reg);
 		return 0;
 	}
 static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn)
 {
 	struct bpf_reg_state *regs = cur_regs(env);
+	static const int ctx_reg = BPF_REG_6;
 	u8 mode = BPF_MODE(insn->code);
 	int i, err;
 	}
 	/* check whether implicit source operand (register R6) is readable */
-	err = check_reg_arg(env, BPF_REG_6, SRC_OP);
+	err = check_reg_arg(env, ctx_reg, SRC_OP);
 	if (err)
 		return err;
 		return -EINVAL;
 	}
-	if (regs[BPF_REG_6].type != PTR_TO_CTX) {
+	if (regs[ctx_reg].type != PTR_TO_CTX) {
 		verbose(env,
 			"at the time of BPF_LD_ABS|IND R6 != pointer to skb\n");
 		return -EINVAL;
 			return err;
 	}
+	err = check_ctx_reg(env, &regs[ctx_reg], ctx_reg);
+	if (err < 0)
+		return err;
 	/* reset caller saved regs to unreadable */
 	for (i = 0; i < CALLER_SAVED_REGS; i++) {
 		mark_reg_not_init(env, regs, caller_saved[i]);
 			/* since the register is unused, clear its state
 			 * to make further comparison simpler
 			 */
-			__mark_reg_not_init(&st->regs[i]);
+			__mark_reg_not_init(env, &st->regs[i]);
 	}
 	for (i = 0; i < st->allocated_stack / BPF_REG_SIZE; i++) {
 		/* liveness must not touch this stack slot anymore */
 		st->stack[i].spilled_ptr.live |= REG_LIVE_DONE;
 		if (!(live & REG_LIVE_READ)) {
-			__mark_reg_not_init(&st->stack[i].spilled_ptr);
+			__mark_reg_not_init(env, &st->stack[i].spilled_ptr);
 			for (j = 0; j < BPF_REG_SIZE; j++)
 				st->stack[i].slot_type[j] = STACK_INVALID;
 		}

kernel/cred.c+3−3

@@ -223,7 +223,7 @@ struct cred *cred_alloc_blank(void) · 222 unmodified lines
223	new->magic = CRED_MAGIC;	223	new->magic = CRED_MAGIC;
224	#endif	224	#endif
225		225
226	if (security_cred_alloc_blank(new, GFP_KERNEL) < 0)	226	if (security_cred_alloc_blank(new, GFP_KERNEL_ACCOUNT) < 0)
227	goto error;	227	goto error;
228		228
229	return new;	229	return new;
@@ -282,7 +282,7 @@ struct cred *prepare_creds(void) · 52 unmodified lines
282	new->security = NULL;	282	new->security = NULL;
283	#endif	283	#endif
284		284
285	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)	285	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
286	goto error;	286	goto error;
287	validate_creds(new);	287	validate_creds(new);
288	return new;	288	return new;
@@ -715,7 +715,7 @@ struct cred prepare_kernel_cred(struct task_struct daemon) · 426 unmodified lines
715	#ifdef CONFIG_SECURITY	715	#ifdef CONFIG_SECURITY
716	new->security = NULL;	716	new->security = NULL;
717	#endif	717	#endif
718	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)	718	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
719	goto error;	719	goto error;
720		720
721	put_cred(old);	721	put_cred(old);

kernel/exit.c+8−4

 	}
 	write_unlock_irq(&tasklist_lock);
-	if (unlikely(pid_ns == &init_pid_ns)) {
-		panic("Attempted to kill init! exitcode=0x%08x\n",
-			father->signal->group_exit_code ?: father->exit_code);
-	}
 	list_for_each_entry_safe(p, n, dead, ptrace_entry) {
 		list_del_init(&p->ptrace_entry);
 	acct_update_integrals(tsk);
 	group_dead = atomic_dec_and_test(&tsk->signal->live);
 	if (group_dead) {
+		/*
+		 * If the last thread of global init has exited, panic
+		 * immediately to get a useable coredump.
+		 */
+		if (unlikely(is_global_init(tsk)))
+			panic("Attempted to kill init! exitcode=0x%08x\n",
+				tsk->signal->group_exit_code ?: (int)code);
 #ifdef CONFIG_POSIX_TIMERS
 		hrtimer_cancel(&tsk->signal->real_timer);
 		exit_itimers(tsk->signal);

kernel/fork.c+10−0

@@ -2578,6 +2578,16 @@ SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, · 2577 unmodified lines
2578	#endif	2578	#endif
2579		2579
2580	#ifdef __ARCH_WANT_SYS_CLONE3	2580	#ifdef __ARCH_WANT_SYS_CLONE3
		2581
		2582	/*
		2583	* copy_thread implementations handle CLONE_SETTLS by reading the TLS value from
		2584	* the registers containing the syscall arguments for clone. This doesn't work
		2585	* with clone3 since the TLS value is passed in clone_args instead.
		2586	*/
		2587	#ifndef CONFIG_HAVE_COPY_THREAD_TLS
		2588	#error clone3 requires copy_thread_tls support in arch
		2589	#endif
		2590
2581	noinline static int copy_clone_args_from_user(struct kernel_clone_args *kargs,	2591	noinline static int copy_clone_args_from_user(struct kernel_clone_args *kargs,
2582	struct clone_args __user *uargs,	2592	struct clone_args __user *uargs,
2583	size_t usize)	2593	size_t usize)

kernel/seccomp.c+7−0

@@ -1026,6 +1026,13 @@ static long seccomp_notify_recv(struct seccomp_filter *filter, · 1025 unmodified lines
1026	struct seccomp_notif unotif;	1026	struct seccomp_notif unotif;
1027	ssize_t ret;	1027	ssize_t ret;
1028		1028
		1029	/* Verify that we're not given garbage to keep struct extensible. */
		1030	ret = check_zeroed_user(buf, sizeof(unotif));
		1031	if (ret < 0)
		1032	return ret;
		1033	if (!ret)
		1034	return -EINVAL;
		1035
1029	memset(&unotif, 0, sizeof(unotif));	1036	memset(&unotif, 0, sizeof(unotif));
1030		1037
1031	ret = down_interruptible(&filter->notif->request);	1038	ret = down_interruptible(&filter->notif->request);

kernel/taskstats.c+19−11

@@ -554,25 +554,33 @@ static int taskstats_user_cmd(struct sk_buff skb, struct genl_info info) · 553 unmodified lines
554	static struct taskstats taskstats_tgid_alloc(struct task_struct tsk)	554	static struct taskstats taskstats_tgid_alloc(struct task_struct tsk)
555	{	555	{
556	struct signal_struct *sig = tsk->signal;	556	struct signal_struct *sig = tsk->signal;
557	struct taskstats *stats;	557	struct taskstats stats_new, stats;
558		558
559	if (sig->stats \|\| thread_group_empty(tsk))	559	/* Pairs with smp_store_release() below. */
560	goto ret;	560	stats = smp_load_acquire(&sig->stats);
		561	if (stats \|\| thread_group_empty(tsk))
		562	return stats;
561		563
562	/* No problem if kmem_cache_zalloc() fails */	564	/* No problem if kmem_cache_zalloc() fails */
563	stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);	565	stats_new = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
564		566
565	spin_lock_irq(&tsk->sighand->siglock);	567	spin_lock_irq(&tsk->sighand->siglock);
566	if (!sig->stats) {	568	stats = sig->stats;
567	sig->stats = stats;	569	if (!stats) {
568	stats = NULL;	570	/*
		571	* Pairs with smp_store_release() above and order the
		572	* kmem_cache_zalloc().
		573	*/
		574	smp_store_release(&sig->stats, stats_new);
		575	stats = stats_new;
		576	stats_new = NULL;
569	}	577	}
570	spin_unlock_irq(&tsk->sighand->siglock);	578	spin_unlock_irq(&tsk->sighand->siglock);
571		579
572	if (stats)	580	if (stats_new)
573	kmem_cache_free(taskstats_cache, stats);	581	kmem_cache_free(taskstats_cache, stats_new);
574	ret:	582
575	return sig->stats;	583	return stats;
576	}	584	}
577		585
578	/* Send pid data out on exit */	586	/* Send pid data out on exit */

kernel/time/posix-clock.c+13−18

 #include "posix-timers.h"
-static void delete_clock(struct kref *kref);
 /*
  * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
  */
 		err = 0;
 	if (!err) {
-		kref_get(&clk->kref);
+		get_device(clk->dev);
 		fp->private_data = clk;
 	}
 out:
 	if (clk->ops.release)
 		err = clk->ops.release(clk);
-	kref_put(&clk->kref, delete_clock);
+	put_device(clk->dev);
 	fp->private_data = NULL;
 #endif
 };
-int posix_clock_register(struct posix_clock *clk, dev_t devid)
+int posix_clock_register(struct posix_clock *clk, struct device *dev)
 {
 	int err;
-	kref_init(&clk->kref);
 	init_rwsem(&clk->rwsem);
 	cdev_init(&clk->cdev, &posix_clock_file_operations);
+	err = cdev_device_add(&clk->cdev, dev);
+	if (err) {
+		pr_err("%s unable to add device %d:%d\n",
+			dev_name(dev), MAJOR(dev->devt), MINOR(dev->devt));
+		return err;
+	}
 	clk->cdev.owner = clk->ops.owner;
-	err = cdev_add(&clk->cdev, devid, 1);
+	clk->dev = dev;
-	return err;
+	return 0;
 }
 EXPORT_SYMBOL_GPL(posix_clock_register);
-static void delete_clock(struct kref *kref)
-{
-	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
-	if (clk->release)
-		clk->release(clk);
-}
 void posix_clock_unregister(struct posix_clock *clk)
 {
-	cdev_del(&clk->cdev);
+	cdev_device_del(&clk->cdev, clk->dev);
 	down_write(&clk->rwsem);
 	clk->zombie = true;
 	up_write(&clk->rwsem);
-	kref_put(&clk->kref, delete_clock);
+	put_device(clk->dev);
 }
 EXPORT_SYMBOL_GPL(posix_clock_unregister);

kernel/trace/fgraph.c+14−0

@@ -96,6 +96,20 @@ ftrace_push_return_trace(unsigned long ret, unsigned long func, · 95 unmodified lines
96	return 0;	96	return 0;
97	}	97	}
98		98
		99	/*
		100	* Not all archs define MCOUNT_INSN_SIZE which is used to look for direct
		101	* functions. But those archs currently don't support direct functions
		102	* anyway, and ftrace_find_rec_direct() is just a stub for them.
		103	* Define MCOUNT_INSN_SIZE to keep those archs compiling.
		104	*/
		105	#ifndef MCOUNT_INSN_SIZE
		106	/* Make sure this only works without direct calls */
		107	# ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
		108	# error MCOUNT_INSN_SIZE not defined with direct calls enabled
		109	# endif
		110	# define MCOUNT_INSN_SIZE 0
		111	#endif
		112
99	int function_graph_enter(unsigned long ret, unsigned long func,	113	int function_graph_enter(unsigned long ret, unsigned long func,
100	unsigned long frame_pointer, unsigned long *retp)	114	unsigned long frame_pointer, unsigned long *retp)
101	{	115	{

kernel/trace/ftrace.c+3−3

 	}
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
-	avg = rec->time;
+	avg = div64_ul(rec->time, rec->counter);
-	do_div(avg, rec->counter);
 	if (tracing_thresh && (avg < tracing_thresh))
 		goto out;
 #endif
 		 * Divide only 1000 for ns^2 -> us^2 conversion.
 		 * trace_print_graph_duration will divide 1000 again.
 		 */
-		do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+		stddev = div64_ul(stddev,
+				  rec->counter * (rec->counter - 1) * 1000);
 	}
 	trace_seq_init(&s);

kernel/trace/trace_events_inject.c+1−1

@@ -195,7 +195,7 @@ static int parse_entry(char str, struct trace_event_call call, void **pentry) · 194 unmodified lines
195	unsigned long irq_flags;	195	unsigned long irq_flags;
196	void *entry = NULL;	196	void *entry = NULL;
197	int entry_size;	197	int entry_size;
198	u64 val;	198	u64 val = 0;
199	int len;	199	int len;
200		200
201	entry = trace_alloc_entry(call, &entry_size);	201	entry = trace_alloc_entry(call, &entry_size);

kernel/trace/trace_sched_wakeup.c+3−1

 	if (ret) {
 		pr_info("wakeup trace: Couldn't activate tracepoint"
 			" probe to kernel_sched_migrate_task\n");
-		return;
+		goto fail_deprobe_sched_switch;
 	}
 	wakeup_reset(tr);
 		printk(KERN_ERR "failed to start wakeup tracer\n");
 	return;
+fail_deprobe_sched_switch:
+	unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
 fail_deprobe_wake_new:
 	unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
 fail_deprobe:

kernel/trace/trace_seq.c+1−1

@@ -381,7 +381,7 @@ int trace_seq_hex_dump(struct trace_seq s, const char prefix_str, · 380 unmodified lines
381	int prefix_type, int rowsize, int groupsize,	381	int prefix_type, int rowsize, int groupsize,
382	const void *buf, size_t len, bool ascii)	382	const void *buf, size_t len, bool ascii)
383	{	383	{
384	unsigned int save_len = s->seq.len;	384	unsigned int save_len = s->seq.len;
385		385
386	if (s->full)	386	if (s->full)
387	return 0;	387	return 0;

kernel/trace/trace_stack.c+5−0

 	local_irq_restore(flags);
 }
+/* Some archs may not define MCOUNT_INSN_SIZE */
+#ifndef MCOUNT_INSN_SIZE
+# define MCOUNT_INSN_SIZE 0
+#endif
 static void
 stack_trace_call(unsigned long ip, unsigned long parent_ip,
 		 struct ftrace_ops *op, struct pt_regs *pt_regs)

mm/gup_benchmark.c+6−2

 	unsigned long i, nr_pages, addr, next;
 	int nr;
 	struct page **pages;
+	int ret = 0;
 	if (gup->size > ULONG_MAX)
 		return -EINVAL;
 					    NULL);
 			break;
 		default:
-			return -1;
+			kvfree(pages);
+			ret = -EINVAL;
+			goto out;
 		}
 		if (nr <= 0)
 	gup->put_delta_usec = ktime_us_delta(end_time, start_time);
 	kvfree(pages);
-	return 0;
+out:
+	return ret;
 }
 static long gup_benchmark_ioctl(struct file *filep, unsigned int cmd,

mm/hugetlb.c+50−1

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#include <linux/swapops.h>	27	#include <linux/swapops.h>
28	#include <linux/jhash.h>	28	#include <linux/jhash.h>
29	#include <linux/numa.h>	29	#include <linux/numa.h>
		30	#include <linux/llist.h>
30		31
31	#include <asm/page.h>	32	#include <asm/page.h>
32	#include <asm/pgtable.h>	33	#include <asm/pgtable.h>
@@ -1136,7 +1137,7 @@ static inline void ClearPageHugeTemporary(struct page *page) · 1103 unmodified lines
1136	page[2].mapping = NULL;	1137	page[2].mapping = NULL;
1137	}	1138	}
1138		1139
1139	void free_huge_page(struct page *page)	1140	static void __free_huge_page(struct page *page)
1140	{	1141	{
1141	/*	1142	/*
1142	* Can't pass hstate in here because it is called from the	1143	* Can't pass hstate in here because it is called from the
@@ -1199,6 +1200,54 @@ void free_huge_page(struct page *page) · 56 unmodified lines
1199	spin_unlock(&hugetlb_lock);	1200	spin_unlock(&hugetlb_lock);
1200	}	1201	}
1201		1202
		1203	/*
		1204	* As free_huge_page() can be called from a non-task context, we have
		1205	* to defer the actual freeing in a workqueue to prevent potential
		1206	* hugetlb_lock deadlock.
		1207	*
		1208	* free_hpage_workfn() locklessly retrieves the linked list of pages to
		1209	* be freed and frees them one-by-one. As the page->mapping pointer is
		1210	* going to be cleared in __free_huge_page() anyway, it is reused as the
		1211	* llist_node structure of a lockless linked list of huge pages to be freed.
		1212	*/
		1213	static LLIST_HEAD(hpage_freelist);
		1214
		1215	static void free_hpage_workfn(struct work_struct *work)
		1216	{
		1217	struct llist_node *node;
		1218	struct page *page;
		1219
		1220	node = llist_del_all(&hpage_freelist);
		1221
		1222	while (node) {
		1223	page = container_of((struct address_space **)node,
		1224	struct page, mapping);
		1225	node = node->next;
		1226	__free_huge_page(page);
		1227	}
		1228	}
		1229	static DECLARE_WORK(free_hpage_work, free_hpage_workfn);
		1230
		1231	void free_huge_page(struct page *page)
		1232	{
		1233	/*
		1234	* Defer freeing if in non-task context to avoid hugetlb_lock deadlock.
		1235	*/
		1236	if (!in_task()) {
		1237	/*
		1238	* Only call schedule_work() if hpage_freelist is previously
		1239	* empty. Otherwise, schedule_work() had been called but the
		1240	* workfn hasn't retrieved the list yet.
		1241	*/
		1242	if (llist_add((struct llist_node *)&page->mapping,
		1243	&hpage_freelist))
		1244	schedule_work(&free_hpage_work);
		1245	return;
		1246	}
		1247
		1248	__free_huge_page(page);
		1249	}
		1250
1202	static void prep_new_huge_page(struct hstate h, struct page page, int nid)	1251	static void prep_new_huge_page(struct hstate h, struct page page, int nid)
1203	{	1252	{
1204	INIT_LIST_HEAD(&page->lru);	1253	INIT_LIST_HEAD(&page->lru);

mm/memory_hotplug.c+16−15

 	pgdat->node_spanned_pages = node_end_pfn - node_start_pfn;
 }
-static void __remove_zone(struct zone *zone, unsigned long start_pfn,
+void __ref remove_pfn_range_from_zone(struct zone *zone,
-		unsigned long nr_pages)
+				      unsigned long start_pfn,
+				      unsigned long nr_pages)
 {
 	struct pglist_data *pgdat = zone->zone_pgdat;
 	unsigned long flags;
 		return;
 #endif
+	clear_zone_contiguous(zone);
 	pgdat_resize_lock(zone->zone_pgdat, &flags);
 	shrink_zone_span(zone, start_pfn, start_pfn + nr_pages);
 	update_pgdat_span(pgdat);
 	pgdat_resize_unlock(zone->zone_pgdat, &flags);
+	set_zone_contiguous(zone);
 }
-static void __remove_section(struct zone *zone, unsigned long pfn,
+static void __remove_section(unsigned long pfn, unsigned long nr_pages,
-		unsigned long nr_pages, unsigned long map_offset,
+			     unsigned long map_offset,
-		struct vmem_altmap *altmap)
+			     struct vmem_altmap *altmap)
 {
 	struct mem_section *ms = __nr_to_section(pfn_to_section_nr(pfn));
 	if (WARN_ON_ONCE(!valid_section(ms)))
 		return;
-	__remove_zone(zone, pfn, nr_pages);
 	sparse_remove_section(ms, pfn, nr_pages, map_offset, altmap);
 }
 /**
- * __remove_pages() - remove sections of pages from a zone
+ * __remove_pages() - remove sections of pages
- * @zone: zone from which pages need to be removed
  * @pfn: starting pageframe (must be aligned to start of a section)
  * @nr_pages: number of pages to remove (must be multiple of section size)
  * @altmap: alternative device page map or %NULL if default memmap is used
  * sure that pages are marked reserved and zones are adjust properly by
  * calling offline_pages().
  */
-void __remove_pages(struct zone *zone, unsigned long pfn,
+void __remove_pages(unsigned long pfn, unsigned long nr_pages,
-		    unsigned long nr_pages, struct vmem_altmap *altmap)
+		    struct vmem_altmap *altmap)
 {
 	unsigned long map_offset = 0;
 	unsigned long nr, start_sec, end_sec;
 	map_offset = vmem_altmap_offset(altmap);
-	clear_zone_contiguous(zone);
 	if (check_pfn_span(pfn, nr_pages, "remove"))
 		return;
 		cond_resched();
 		pfns = min(nr_pages, PAGES_PER_SECTION
 				- (pfn & ~PAGE_SECTION_MASK));
-		__remove_section(zone, pfn, pfns, map_offset, altmap);
+		__remove_section(pfn, pfns, map_offset, altmap);
 		pfn += pfns;
 		nr_pages -= pfns;
 		map_offset = 0;
 	}
-	set_zone_contiguous(zone);
 }
 int set_online_page_callback(online_page_callback_t callback)
 		 (unsigned long long) pfn << PAGE_SHIFT,
 		 (((unsigned long long) pfn + nr_pages) << PAGE_SHIFT) - 1);
 	memory_notify(MEM_CANCEL_ONLINE, &arg);
+	remove_pfn_range_from_zone(zone, pfn, nr_pages);
 	mem_hotplug_done();
 	return ret;
 }
 	writeback_set_ratelimit();
 	memory_notify(MEM_OFFLINE, &arg);
+	remove_pfn_range_from_zone(zone, start_pfn, nr_pages);
 	mem_hotplug_done();
 	return 0;

mm/memremap.c+1−1

@@ -120,7 +120,7 @@ void memunmap_pages(struct dev_pagemap *pgmap) · 119 unmodified lines
120		120
121	mem_hotplug_begin();	121	mem_hotplug_begin();
122	if (pgmap->type == MEMORY_DEVICE_PRIVATE) {	122	if (pgmap->type == MEMORY_DEVICE_PRIVATE) {
123	__remove_pages(page_zone(first_page), PHYS_PFN(res->start),	123	__remove_pages(PHYS_PFN(res->start),
124	PHYS_PFN(resource_size(res)), NULL);	124	PHYS_PFN(resource_size(res)), NULL);
125	} else {	125	} else {
126	arch_remove_memory(nid, res->start, resource_size(res),	126	arch_remove_memory(nid, res->start, resource_size(res),

mm/migrate.c+17−6

@@ -1512,9 +1512,11 @@ static int do_move_pages_to_node(struct mm_struct *mm, · 1511 unmodified lines
1512	/*	1512	/*
1513	* Resolves the given address to a struct page, isolates it from the LRU and	1513	* Resolves the given address to a struct page, isolates it from the LRU and
1514	* puts it to the given pagelist.	1514	* puts it to the given pagelist.
1515	* Returns -errno if the page cannot be found/isolated or 0 when it has been	1515	* Returns:
1516	* queued or the page doesn't need to be migrated because it is already on	1516	* errno - if the page cannot be found/isolated
1517	* the target node	1517	* 0 - when it doesn't have to be migrated because it is already on the
		1518	* target node
		1519	* 1 - when it has been queued
1518	*/	1520	*/
1519	static int add_page_for_migration(struct mm_struct *mm, unsigned long addr,	1521	static int add_page_for_migration(struct mm_struct *mm, unsigned long addr,
1520	int node, struct list_head *pagelist, bool migrate_all)	1522	int node, struct list_head *pagelist, bool migrate_all)
@@ -1553,7 +1555,7 @@ static int add_page_for_migration(struct mm_struct *mm, unsigned long addr, · 32 unmodified lines
1553	if (PageHuge(page)) {	1555	if (PageHuge(page)) {
1554	if (PageHead(page)) {	1556	if (PageHead(page)) {
1555	isolate_huge_page(page, pagelist);	1557	isolate_huge_page(page, pagelist);
1556	err = 0;	1558	err = 1;
1557	}	1559	}
1558	} else {	1560	} else {
1559	struct page *head;	1561	struct page *head;
@@ -1563,7 +1565,7 @@ static int add_page_for_migration(struct mm_struct *mm, unsigned long addr, · 3 unmodified lines
1563	if (err)	1565	if (err)
1564	goto out_putpage;	1566	goto out_putpage;
1565		1567
1566	err = 0;	1568	err = 1;
1567	list_add_tail(&head->lru, pagelist);	1569	list_add_tail(&head->lru, pagelist);
1568	mod_node_page_state(page_pgdat(head),	1570	mod_node_page_state(page_pgdat(head),
1569	NR_ISOLATED_ANON + page_is_file_cache(head),	1571	NR_ISOLATED_ANON + page_is_file_cache(head),
@@ -1640,8 +1642,17 @@ static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes, · 70 unmodified lines
1640	*/	1642	*/
1641	err = add_page_for_migration(mm, addr, current_node,	1643	err = add_page_for_migration(mm, addr, current_node,
1642	&pagelist, flags & MPOL_MF_MOVE_ALL);	1644	&pagelist, flags & MPOL_MF_MOVE_ALL);
1643	if (!err)	1645
		1646	if (!err) {
		1647	/* The page is already on the target node */
		1648	err = store_status(status, i, current_node, 1);
		1649	if (err)
		1650	goto out_flush;
1644	continue;	1651	continue;
		1652	} else if (err > 0) {
		1653	/* The page is successfully queued for migration */
		1654	continue;
		1655	}
1645		1656
1646	err = store_status(status, i, err, 1);	1657	err = store_status(status, i, err, 1);
1647	if (err)	1658	if (err)

mm/mmap.c+0−6

  * MAP_PRIVATE	r: (no) no	r: (yes) yes	r: (no) yes	r: (no) yes
  *		w: (no) no	w: (no) no	w: (copy) copy	w: (no) no
  *		x: (no) no	x: (no) yes	x: (no) yes	x: (yes) yes
- *
- * On arm64, PROT_EXEC has the following behaviour for both MAP_SHARED and
- * MAP_PRIVATE:
- *								r: (no) no
- *								w: (no) no
- *								x: (yes) yes
  */
 pgprot_t protection_map[16] __ro_after_init = {
 	__P000, __P001, __P010, __P011, __P100, __P101, __P110, __P111,

mm/oom_kill.c+1−1

@@ -890,7 +890,7 @@ static void __oom_kill_process(struct task_struct victim, const char message) · 889 unmodified lines
890	K(get_mm_counter(mm, MM_FILEPAGES)),	890	K(get_mm_counter(mm, MM_FILEPAGES)),
891	K(get_mm_counter(mm, MM_SHMEMPAGES)),	891	K(get_mm_counter(mm, MM_SHMEMPAGES)),
892	from_kuid(&init_user_ns, task_uid(victim)),	892	from_kuid(&init_user_ns, task_uid(victim)),
893	mm_pgtables_bytes(mm), victim->signal->oom_score_adj);	893	mm_pgtables_bytes(mm) >> 10, victim->signal->oom_score_adj);
894	task_unlock(victim);	894	task_unlock(victim);
895		895
896	/*	896	/*

mm/zsmalloc.c+5−0

 		zs_pool_dec_isolated(pool);
 	}
+	if (page_zone(newpage) != page_zone(page)) {
+		dec_zone_page_state(page, NR_ZSPAGES);
+		inc_zone_page_state(newpage, NR_ZSPAGES);
+	}
 	reset_page(page);
 	put_page(page);
 	page = newpage;

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

@@ -126,6 +126,7 @@ int vlan_check_real_dev(struct net_device *real_dev, · 125 unmodified lines
126	void vlan_setup(struct net_device *dev);	126	void vlan_setup(struct net_device *dev);
127	int register_vlan_dev(struct net_device dev, struct netlink_ext_ack extack);	127	int register_vlan_dev(struct net_device dev, struct netlink_ext_ack extack);
128	void unregister_vlan_dev(struct net_device dev, struct list_head head);	128	void unregister_vlan_dev(struct net_device dev, struct list_head head);
		129	void vlan_dev_uninit(struct net_device *dev);
129	bool vlan_dev_inherit_address(struct net_device *dev,	130	bool vlan_dev_inherit_address(struct net_device *dev,
130	struct net_device *real_dev);	131	struct net_device *real_dev);
131		132

net/8021q/vlan_dev.c+2−1

@@ -586,7 +586,8 @@ static int vlan_dev_init(struct net_device *dev) · 585 unmodified lines
586	return 0;	586	return 0;
587	}	587	}
588		588
589	static void vlan_dev_uninit(struct net_device *dev)	589	/* Note: this function might be called multiple times for the same device. */
		590	void vlan_dev_uninit(struct net_device *dev)
590	{	591	{
591	struct vlan_priority_tci_mapping *pm;	592	struct vlan_priority_tci_mapping *pm;
592	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	593	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);

net/8021q/vlan_netlink.c+12−7

@@ -108,11 +108,13 @@ static int vlan_changelink(struct net_device dev, struct nlattr tb[], · 107 unmodified lines
108	struct ifla_vlan_flags *flags;	108	struct ifla_vlan_flags *flags;
109	struct ifla_vlan_qos_mapping *m;	109	struct ifla_vlan_qos_mapping *m;
110	struct nlattr *attr;	110	struct nlattr *attr;
111	int rem;	111	int rem, err;
112		112
113	if (data[IFLA_VLAN_FLAGS]) {	113	if (data[IFLA_VLAN_FLAGS]) {
114	flags = nla_data(data[IFLA_VLAN_FLAGS]);	114	flags = nla_data(data[IFLA_VLAN_FLAGS]);
115	vlan_dev_change_flags(dev, flags->flags, flags->mask);	115	err = vlan_dev_change_flags(dev, flags->flags, flags->mask);
		116	if (err)
		117	return err;
116	}	118	}
117	if (data[IFLA_VLAN_INGRESS_QOS]) {	119	if (data[IFLA_VLAN_INGRESS_QOS]) {
118	nla_for_each_nested(attr, data[IFLA_VLAN_INGRESS_QOS], rem) {	120	nla_for_each_nested(attr, data[IFLA_VLAN_INGRESS_QOS], rem) {
@@ -123,7 +125,9 @@ static int vlan_changelink(struct net_device dev, struct nlattr tb[], · 4 unmodified lines
123	if (data[IFLA_VLAN_EGRESS_QOS]) {	125	if (data[IFLA_VLAN_EGRESS_QOS]) {
124	nla_for_each_nested(attr, data[IFLA_VLAN_EGRESS_QOS], rem) {	126	nla_for_each_nested(attr, data[IFLA_VLAN_EGRESS_QOS], rem) {
125	m = nla_data(attr);	127	m = nla_data(attr);
126	vlan_dev_set_egress_priority(dev, m->from, m->to);	128	err = vlan_dev_set_egress_priority(dev, m->from, m->to);
		129	if (err)
		130	return err;
127	}	131	}
128	}	132	}
129	return 0;	133	return 0;
@@ -179,10 +183,11 @@ static int vlan_newlink(struct net src_net, struct net_device dev, · 49 unmodified lines
179	return -EINVAL;	183	return -EINVAL;
180		184
181	err = vlan_changelink(dev, tb, data, extack);	185	err = vlan_changelink(dev, tb, data, extack);
182	if (err < 0)	186	if (!err)
183	return err;	187	err = register_vlan_dev(dev, extack);
184		188	if (err)
185	return register_vlan_dev(dev, extack);	189	vlan_dev_uninit(dev);
		190	return err;
186	}	191	}
187		192
188	static inline size_t vlan_qos_map_size(unsigned int n)	193	static inline size_t vlan_qos_map_size(unsigned int n)

net/bridge/br_nf_core.c+2−1

@@ -22,7 +22,8 @@ · 21 unmodified lines
22	#endif	22	#endif
23		23
24	static void fake_update_pmtu(struct dst_entry dst, struct sock sk,	24	static void fake_update_pmtu(struct dst_entry dst, struct sock sk,
25	struct sk_buff *skb, u32 mtu)	25	struct sk_buff *skb, u32 mtu,
		26	bool confirm_neigh)
26	{	27	{
27	}	28	}
28		29

net/bridge/netfilter/ebtables.c+16−17

 }
 static int ebt_buf_add(struct ebt_entries_buf_state *state,
-		       void *data, unsigned int sz)
+		       const void *data, unsigned int sz)
 {
 	if (state->buf_kern_start == NULL)
 		goto count_only;
 	EBT_COMPAT_TARGET,
 };
-static int compat_mtw_from_user(struct compat_ebt_entry_mwt *mwt,
+static int compat_mtw_from_user(const struct compat_ebt_entry_mwt *mwt,
 				enum compat_mwt compat_mwt,
 				struct ebt_entries_buf_state *state,
 				const unsigned char *base)
 /* return size of all matches, watchers or target, including necessary
  * alignment and padding.
  */
-static int ebt_size_mwt(struct compat_ebt_entry_mwt *match32,
+static int ebt_size_mwt(const struct compat_ebt_entry_mwt *match32,
 			unsigned int size_left, enum compat_mwt type,
 			struct ebt_entries_buf_state *state, const void *base)
 {
+	const char *buf = (const char *)match32;
 	int growth = 0;
-	char *buf;
 	if (size_left == 0)
 		return 0;
-	buf = (char *) match32;
+	do {
-	while (size_left >= sizeof(*match32)) {
 		struct ebt_entry_match *match_kern;
 		int ret;
+		if (size_left < sizeof(*match32))
+			return -EINVAL;
 		match_kern = (struct ebt_entry_match *) state->buf_kern_start;
 		if (match_kern) {
 			char *tmp;
 		if (match_kern)
 			match_kern->match_size = ret;
-		/* rule should have no remaining data after target */
-		if (type == EBT_COMPAT_TARGET && size_left)
-			return -EINVAL;
 		match32 = (struct compat_ebt_entry_mwt *) buf;
-	}
+	} while (size_left);
 	return growth;
 }
 /* called for all ebt_entry structures. */
-static int size_entry_mwt(struct ebt_entry *entry, const unsigned char *base,
+static int size_entry_mwt(const struct ebt_entry *entry, const unsigned char *base,
 			  unsigned int *total,
 			  struct ebt_entries_buf_state *state)
 {
-	unsigned int i, j, startoff, new_offset = 0;
+	unsigned int i, j, startoff, next_expected_off, new_offset = 0;
 	/* stores match/watchers/targets & offset of next struct ebt_entry: */
 	unsigned int offsets[4];
 	unsigned int *offsets_update = NULL;
 			return ret;
 	}
-	startoff = state->buf_user_offset - startoff;
+	next_expected_off = state->buf_user_offset - startoff;
+	if (next_expected_off != entry->next_offset)
+		return -EINVAL;
-	if (WARN_ON(*total < startoff))
+	if (*total < entry->next_offset)
 		return -EINVAL;
-	*total -= startoff;
+	*total -= entry->next_offset;
 	return 0;
 }

net/decnet/dn_route.c+4−2

 static struct dst_entry *dn_dst_negative_advice(struct dst_entry *);
 static void dn_dst_link_failure(struct sk_buff *);
 static void dn_dst_update_pmtu(struct dst_entry *dst, struct sock *sk,
-			       struct sk_buff *skb , u32 mtu);
+			       struct sk_buff *skb , u32 mtu,
+			       bool confirm_neigh);
 static void dn_dst_redirect(struct dst_entry *dst, struct sock *sk,
 			    struct sk_buff *skb);
 static struct neighbour *dn_dst_neigh_lookup(const struct dst_entry *dst,
  * advertise to the other end).
  */
 static void dn_dst_update_pmtu(struct dst_entry *dst, struct sock *sk,
-			       struct sk_buff *skb, u32 mtu)
+			       struct sk_buff *skb, u32 mtu,
+			       bool confirm_neigh)
 {
 	struct dn_route *rt = (struct dn_route *) dst;
 	struct neighbour *n = rt->n;

net/hsr/hsr_debugfs.c+40−12

 #include "hsr_main.h"
 #include "hsr_framereg.h"
+static struct dentry *hsr_debugfs_root_dir;
 static void print_mac_address(struct seq_file *sfp, unsigned char *mac)
 {
 	seq_printf(sfp, "%02x:%02x:%02x:%02x:%02x:%02x:",
 	return single_open(filp, hsr_node_table_show, inode->i_private);
 }
+void hsr_debugfs_rename(struct net_device *dev)
+{
+	struct hsr_priv *priv = netdev_priv(dev);
+	struct dentry *d;
+	d = debugfs_rename(hsr_debugfs_root_dir, priv->node_tbl_root,
+			   hsr_debugfs_root_dir, dev->name);
+	if (IS_ERR(d))
+		netdev_warn(dev, "failed to rename\n");
+	else
+		priv->node_tbl_root = d;
+}
 static const struct file_operations hsr_fops = {
-	.owner	= THIS_MODULE,
 	.open	= hsr_node_table_open,
 	.read	= seq_read,
 	.llseek = seq_lseek,
  * When debugfs is configured this routine sets up the node_table file per
  * hsr device for dumping the node_table entries
  */
-int hsr_debugfs_init(struct hsr_priv *priv, struct net_device *hsr_dev)
+void hsr_debugfs_init(struct hsr_priv *priv, struct net_device *hsr_dev)
 {
-	int rc = -1;
 	struct dentry *de = NULL;
-	de = debugfs_create_dir(hsr_dev->name, NULL);
+	de = debugfs_create_dir(hsr_dev->name, hsr_debugfs_root_dir);
-	if (!de) {
+	if (IS_ERR(de)) {
-		pr_err("Cannot create hsr debugfs root\n");
+		pr_err("Cannot create hsr debugfs directory\n");
-		return rc;
+		return;
 	}
 	priv->node_tbl_root = de;
 	de = debugfs_create_file("node_table", S_IFREG | 0444,
 				 priv->node_tbl_root, priv,
 				 &hsr_fops);
-	if (!de) {
+	if (IS_ERR(de)) {
-		pr_err("Cannot create hsr node_table directory\n");
+		pr_err("Cannot create hsr node_table file\n");
-		return rc;
+		debugfs_remove(priv->node_tbl_root);
+		priv->node_tbl_root = NULL;
+		return;
 	}
 	priv->node_tbl_file = de;
-	return 0;
 }
 /* hsr_debugfs_term - Tear down debugfs intrastructure
 	debugfs_remove(priv->node_tbl_root);
 	priv->node_tbl_root = NULL;
 }
+void hsr_debugfs_create_root(void)
+{
+	hsr_debugfs_root_dir = debugfs_create_dir("hsr", NULL);
+	if (IS_ERR(hsr_debugfs_root_dir)) {
+		pr_err("Cannot create hsr debugfs root directory\n");
+		hsr_debugfs_root_dir = NULL;
+	}
+}
+void hsr_debugfs_remove_root(void)
+{
+	/* debugfs_remove() internally checks NULL and ERROR */
+	debugfs_remove(hsr_debugfs_root_dir);
+}

net/hsr/hsr_device.c+16−12

 			    skb->dev->dev_addr, skb->len) <= 0)
 		goto out;
 	skb_reset_mac_header(skb);
+	skb_reset_network_header(skb);
+	skb_reset_transport_header(skb);
 	if (hsr_ver > 0) {
 		hsr_tag = skb_put(skb, sizeof(struct hsr_tag));
 	del_timer_sync(&hsr->prune_timer);
 	del_timer_sync(&hsr->announce_timer);
-	hsr_del_self_node(&hsr->self_node_db);
+	hsr_del_self_node(hsr);
 	hsr_del_nodes(&hsr->node_db);
 }
 	INIT_LIST_HEAD(&hsr->ports);
 	INIT_LIST_HEAD(&hsr->node_db);
 	INIT_LIST_HEAD(&hsr->self_node_db);
+	spin_lock_init(&hsr->list_lock);
 	ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr);
 	/* Make sure we recognize frames from ourselves in hsr_rcv() */
-	res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
+	res = hsr_create_self_node(hsr, hsr_dev->dev_addr,
 				   slave[1]->dev_addr);
 	if (res < 0)
 		return res;
 	res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER);
 	if (res)
-		goto err_add_port;
+		goto err_add_master;
 	res = register_netdevice(hsr_dev);
 	if (res)
-		goto fail;
+		goto err_unregister;
 	res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A);
 	if (res)
-		goto fail;
+		goto err_add_slaves;
 	res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B);
 	if (res)
-		goto fail;
+		goto err_add_slaves;
+	hsr_debugfs_init(hsr, hsr_dev);
 	mod_timer(&hsr->prune_timer, jiffies + msecs_to_jiffies(PRUNE_PERIOD));
-	res = hsr_debugfs_init(hsr, hsr_dev);
-	if (res)
-		goto fail;
 	return 0;
-fail:
+err_add_slaves:
+	unregister_netdevice(hsr_dev);
+err_unregister:
 	list_for_each_entry_safe(port, tmp, &hsr->ports, port_list)
 		hsr_del_port(port);
-err_add_port:
+err_add_master:
-	hsr_del_self_node(&hsr->self_node_db);
+	hsr_del_self_node(hsr);
 	return res;
 }

net/hsr/hsr_framereg.c+46−27

 /* Helper for device init; the self_node_db is used in hsr_rcv() to recognize
  * frames from self that's been looped over the HSR ring.
  */
-int hsr_create_self_node(struct list_head *self_node_db,
+int hsr_create_self_node(struct hsr_priv *hsr,
 			 unsigned char addr_a[ETH_ALEN],
 			 unsigned char addr_b[ETH_ALEN])
 {
+	struct list_head *self_node_db = &hsr->self_node_db;
 	struct hsr_node *node, *oldnode;
 	node = kmalloc(sizeof(*node), GFP_KERNEL);
 	ether_addr_copy(node->macaddress_A, addr_a);
 	ether_addr_copy(node->macaddress_B, addr_b);
-	rcu_read_lock();
+	spin_lock_bh(&hsr->list_lock);
 	oldnode = list_first_or_null_rcu(self_node_db,
 					 struct hsr_node, mac_list);
 	if (oldnode) {
 		list_replace_rcu(&oldnode->mac_list, &node->mac_list);
-		rcu_read_unlock();
+		spin_unlock_bh(&hsr->list_lock);
-		synchronize_rcu();
+		kfree_rcu(oldnode, rcu_head);
-		kfree(oldnode);
 	} else {
-		rcu_read_unlock();
 		list_add_tail_rcu(&node->mac_list, self_node_db);
+		spin_unlock_bh(&hsr->list_lock);
 	}
 	return 0;
 }
-void hsr_del_self_node(struct list_head *self_node_db)
+void hsr_del_self_node(struct hsr_priv *hsr)
 {
+	struct list_head *self_node_db = &hsr->self_node_db;
 	struct hsr_node *node;
-	rcu_read_lock();
+	spin_lock_bh(&hsr->list_lock);
 	node = list_first_or_null_rcu(self_node_db, struct hsr_node, mac_list);
-	rcu_read_unlock();
 	if (node) {
 		list_del_rcu(&node->mac_list);
-		kfree(node);
+		kfree_rcu(node, rcu_head);
 	}
+	spin_unlock_bh(&hsr->list_lock);
 }
 void hsr_del_nodes(struct list_head *node_db)
  * seq_out is used to initialize filtering of outgoing duplicate frames
  * originating from the newly added node.
  */
-struct hsr_node *hsr_add_node(struct list_head *node_db, unsigned char addr[],
+static struct hsr_node *hsr_add_node(struct hsr_priv *hsr,
-			      u16 seq_out)
+				     struct list_head *node_db,
+				     unsigned char addr[],
+				     u16 seq_out)
 {
-	struct hsr_node *node;
+	struct hsr_node *new_node, *node;
 	unsigned long now;
 	int i;
-	node = kzalloc(sizeof(*node), GFP_ATOMIC);
+	new_node = kzalloc(sizeof(*new_node), GFP_ATOMIC);
-	if (!node)
+	if (!new_node)
 		return NULL;
-	ether_addr_copy(node->macaddress_A, addr);
+	ether_addr_copy(new_node->macaddress_A, addr);
 	/* We are only interested in time diffs here, so use current jiffies
 	 * as initialization. (0 could trigger an spurious ring error warning).
 	 */
 	now = jiffies;
 	for (i = 0; i < HSR_PT_PORTS; i++)
-		node->time_in[i] = now;
+		new_node->time_in[i] = now;
 	for (i = 0; i < HSR_PT_PORTS; i++)
-		node->seq_out[i] = seq_out;
+		new_node->seq_out[i] = seq_out;
-	list_add_tail_rcu(&node->mac_list, node_db);
+	spin_lock_bh(&hsr->list_lock);
+	list_for_each_entry_rcu(node, node_db, mac_list) {
+		if (ether_addr_equal(node->macaddress_A, addr))
+			goto out;
+		if (ether_addr_equal(node->macaddress_B, addr))
+			goto out;
+	}
+	list_add_tail_rcu(&new_node->mac_list, node_db);
+	spin_unlock_bh(&hsr->list_lock);
+	return new_node;
+out:
+	spin_unlock_bh(&hsr->list_lock);
+	kfree(new_node);
 	return node;
 }
 			      bool is_sup)
 {
 	struct list_head *node_db = &port->hsr->node_db;
+	struct hsr_priv *hsr = port->hsr;
 	struct hsr_node *node;
 	struct ethhdr *ethhdr;
 	u16 seq_out;
 		seq_out = HSR_SEQNR_START;
 	}
-	return hsr_add_node(node_db, ethhdr->h_source, seq_out);
+	return hsr_add_node(hsr, node_db, ethhdr->h_source, seq_out);
 }
 /* Use the Supervision frame's info about an eventual macaddress_B for merging
 void hsr_handle_sup_frame(struct sk_buff *skb, struct hsr_node *node_curr,
 			  struct hsr_port *port_rcv)
 {
-	struct ethhdr *ethhdr;
+	struct hsr_priv *hsr = port_rcv->hsr;
-	struct hsr_node *node_real;
 	struct hsr_sup_payload *hsr_sp;
+	struct hsr_node *node_real;
 	struct list_head *node_db;
+	struct ethhdr *ethhdr;
 	int i;
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	node_real = find_node_by_addr_A(node_db, hsr_sp->macaddress_A);
 	if (!node_real)
 		/* No frame received from AddrA of this node yet */
-		node_real = hsr_add_node(node_db, hsr_sp->macaddress_A,
+		node_real = hsr_add_node(hsr, node_db, hsr_sp->macaddress_A,
 					 HSR_SEQNR_START - 1);
 	if (!node_real)
 		goto done; /* No mem */
 	}
 	node_real->addr_B_port = port_rcv->type;
+	spin_lock_bh(&hsr->list_lock);
 	list_del_rcu(&node_curr->mac_list);
+	spin_unlock_bh(&hsr->list_lock);
 	kfree_rcu(node_curr, rcu_head);
 done:
 {
 	struct hsr_priv *hsr = from_timer(hsr, t, prune_timer);
 	struct hsr_node *node;
+	struct hsr_node *tmp;
 	struct hsr_port *port;
 	unsigned long timestamp;
 	unsigned long time_a, time_b;
-	rcu_read_lock();
+	spin_lock_bh(&hsr->list_lock);
-	list_for_each_entry_rcu(node, &hsr->node_db, mac_list) {
+	list_for_each_entry_safe(node, tmp, &hsr->node_db, mac_list) {
 		/* Don't prune own node. Neither time_in[HSR_PT_SLAVE_A]
 		 * nor time_in[HSR_PT_SLAVE_B], will ever be updated for
 		 * the master port. Thus the master node will be repeatedly
 			kfree_rcu(node, rcu_head);
 		}
 	}
-	rcu_read_unlock();
+	spin_unlock_bh(&hsr->list_lock);
 	/* Restart timer */
 	mod_timer(&hsr->prune_timer,

net/hsr/hsr_framereg.h+2−4

 struct hsr_node;
-void hsr_del_self_node(struct list_head *self_node_db);
+void hsr_del_self_node(struct hsr_priv *hsr);
 void hsr_del_nodes(struct list_head *node_db);
-struct hsr_node *hsr_add_node(struct list_head *node_db, unsigned char addr[],
-			      u16 seq_out);
 struct hsr_node *hsr_get_node(struct hsr_port *port, struct sk_buff *skb,
 			      bool is_sup);
 void hsr_handle_sup_frame(struct sk_buff *skb, struct hsr_node *node_curr,
 void hsr_prune_nodes(struct timer_list *t);
-int hsr_create_self_node(struct list_head *self_node_db,
+int hsr_create_self_node(struct hsr_priv *hsr,
 			 unsigned char addr_a[ETH_ALEN],
 			 unsigned char addr_b[ETH_ALEN]);

net/hsr/hsr_main.c+6−1

 	case NETDEV_CHANGE:	/* Link (carrier) state changes */
 		hsr_check_carrier_and_operstate(hsr);
 		break;
+	case NETDEV_CHANGENAME:
+		if (is_hsr_master(dev))
+			hsr_debugfs_rename(dev);
+		break;
 	case NETDEV_CHANGEADDR:
 		if (port->type == HSR_PT_MASTER) {
 			/* This should not happen since there's no
 		/* Make sure we recognize frames from ourselves in hsr_rcv() */
 		port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
-		res = hsr_create_self_node(&hsr->self_node_db,
+		res = hsr_create_self_node(hsr,
 					   master->dev->dev_addr,
 					   port ?
 						port->dev->dev_addr :
 {
 	unregister_netdevice_notifier(&hsr_nb);
 	hsr_netlink_exit();
+	hsr_debugfs_remove_root();
 }
 module_init(hsr_init);

net/hsr/hsr_main.h+15−7

@@ -160,8 +160,9 @@ struct hsr_priv { · 159 unmodified lines
160	int announce_count;	160	int announce_count;
161	u16 sequence_nr;	161	u16 sequence_nr;
162	u16 sup_sequence_nr; /* For HSRv1 separate seq_nr for supervision */	162	u16 sup_sequence_nr; /* For HSRv1 separate seq_nr for supervision */
163	u8 prot_version; /* Indicate if HSRv0 or HSRv1. */	163	u8 prot_version; /* Indicate if HSRv0 or HSRv1. */
164	spinlock_t seqnr_lock; /* locking for sequence_nr */	164	spinlock_t seqnr_lock; /* locking for sequence_nr */
		165	spinlock_t list_lock; /* locking for node list */
165	unsigned char sup_multicast_addr[ETH_ALEN];	166	unsigned char sup_multicast_addr[ETH_ALEN];
166	#ifdef CONFIG_DEBUG_FS	167	#ifdef CONFIG_DEBUG_FS
167	struct dentry *node_tbl_root;	168	struct dentry *node_tbl_root;
@@ -184,17 +185,24 @@ static inline u16 hsr_get_skb_sequence_nr(struct sk_buff *skb) · 16 unmodified lines
184	}	185	}
185		186
186	#if IS_ENABLED(CONFIG_DEBUG_FS)	187	#if IS_ENABLED(CONFIG_DEBUG_FS)
187	int hsr_debugfs_init(struct hsr_priv priv, struct net_device hsr_dev);	188	void hsr_debugfs_rename(struct net_device *dev);
		189	void hsr_debugfs_init(struct hsr_priv priv, struct net_device hsr_dev);
188	void hsr_debugfs_term(struct hsr_priv *priv);	190	void hsr_debugfs_term(struct hsr_priv *priv);
		191	void hsr_debugfs_create_root(void);
		192	void hsr_debugfs_remove_root(void);
189	#else	193	#else
190	static inline int hsr_debugfs_init(struct hsr_priv *priv,	194	static inline void void hsr_debugfs_rename(struct net_device *dev)
191	struct net_device *hsr_dev)
192	{	195	{
193	return 0;
194	}	196	}
195		197	static inline void hsr_debugfs_init(struct hsr_priv *priv,
		198	struct net_device *hsr_dev)
		199	{}
196	static inline void hsr_debugfs_term(struct hsr_priv *priv)	200	static inline void hsr_debugfs_term(struct hsr_priv *priv)
197	{}	201	{}
		202	static inline void hsr_debugfs_create_root(void)
		203	{}
		204	static inline void hsr_debugfs_remove_root(void)
		205	{}
198	#endif	206	#endif
199		207
200	#endif /* __HSR_PRIVATE_H */	208	#endif /* __HSR_PRIVATE_H */

net/hsr/hsr_netlink.c+1−0

@@ -476,6 +476,7 @@ int __init hsr_netlink_init(void) · 475 unmodified lines
476	if (rc)	476	if (rc)
477	goto fail_genl_register_family;	477	goto fail_genl_register_family;
478		478
		479	hsr_debugfs_create_root();
479	return 0;	480	return 0;
480		481
481	fail_genl_register_family:	482	fail_genl_register_family:

net/ipv4/inet_connection_sock.c+1−1

@@ -1086,7 +1086,7 @@ struct dst_entry inet_csk_update_pmtu(struct sock sk, u32 mtu) · 1085 unmodified lines
1086	if (!dst)	1086	if (!dst)
1087	goto out;	1087	goto out;
1088	}	1088	}
1089	dst->ops->update_pmtu(dst, sk, NULL, mtu);	1089	dst->ops->update_pmtu(dst, sk, NULL, mtu, true);
1090		1090
1091	dst = __sk_dst_check(sk, 0);	1091	dst = __sk_dst_check(sk, 0);
1092	if (!dst)	1092	if (!dst)

net/ipv4/ip_tunnel.c+1−1

@@ -505,7 +505,7 @@ static int tnl_update_pmtu(struct net_device dev, struct sk_buff skb, · 504 unmodified lines
505	mtu = skb_valid_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;	505	mtu = skb_valid_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
506		506
507	if (skb_valid_dst(skb))	507	if (skb_valid_dst(skb))
508	skb_dst_update_pmtu(skb, mtu);	508	skb_dst_update_pmtu_no_confirm(skb, mtu);
509		509
510	if (skb->protocol == htons(ETH_P_IP)) {	510	if (skb->protocol == htons(ETH_P_IP)) {
511	if (!skb_is_gso(skb) &&	511	if (!skb_is_gso(skb) &&

net/ipv4/ip_vti.c+1−1

@@ -214,7 +214,7 @@ static netdev_tx_t vti_xmit(struct sk_buff skb, struct net_device dev, · 213 unmodified lines
214		214
215	mtu = dst_mtu(dst);	215	mtu = dst_mtu(dst);
216	if (skb->len > mtu) {	216	if (skb->len > mtu) {
217	skb_dst_update_pmtu(skb, mtu);	217	skb_dst_update_pmtu_no_confirm(skb, mtu);
218	if (skb->protocol == htons(ETH_P_IP)) {	218	if (skb->protocol == htons(ETH_P_IP)) {
219	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,	219	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
220	htonl(mtu));	220	htonl(mtu));

net/ipv4/netfilter/arp_tables.c+16−11

 	return 1;
 }
-static inline int check_target(struct arpt_entry *e, const char *name)
+static int check_target(struct arpt_entry *e, struct net *net, const char *name)
 {
 	struct xt_entry_target *t = arpt_get_target(e);
 	struct xt_tgchk_param par = {
+		.net       = net,
 		.table     = name,
 		.entryinfo = e,
 		.target    = t->u.kernel.target,
 	return xt_check_target(&par, t->u.target_size - sizeof(*t), 0, false);
 }
-static inline int
+static int
-find_check_entry(struct arpt_entry *e, const char *name, unsigned int size,
+find_check_entry(struct arpt_entry *e, struct net *net, const char *name,
+		 unsigned int size,
 		 struct xt_percpu_counter_alloc_state *alloc_state)
 {
 	struct xt_entry_target *t;
 	}
 	t->u.kernel.target = target;
-	ret = check_target(e, name);
+	ret = check_target(e, net, name);
 	if (ret)
 		goto err;
 	return 0;
 /* Checks and translates the user-supplied table segment (held in
  * newinfo).
  */
-static int translate_table(struct xt_table_info *newinfo, void *entry0,
+static int translate_table(struct net *net,
+			   struct xt_table_info *newinfo,
+			   void *entry0,
 			   const struct arpt_replace *repl)
 {
 	struct xt_percpu_counter_alloc_state alloc_state = { 0 };
 	/* Finally, each sanity check must pass */
 	i = 0;
 	xt_entry_foreach(iter, entry0, newinfo->size) {
-		ret = find_check_entry(iter, repl->name, repl->size,
+		ret = find_check_entry(iter, net, repl->name, repl->size,
 				       &alloc_state);
 		if (ret != 0)
 			break;
 		goto free_newinfo;
 	}
-	ret = translate_table(newinfo, loc_cpu_entry, &tmp);
+	ret = translate_table(net, newinfo, loc_cpu_entry, &tmp);
 	if (ret != 0)
 		goto free_newinfo;
 	}
 }
-static int translate_compat_table(struct xt_table_info **pinfo,
+static int translate_compat_table(struct net *net,
+				  struct xt_table_info **pinfo,
 				  void **pentry0,
 				  const struct compat_arpt_replace *compatr)
 {
 	repl.num_counters = 0;
 	repl.counters = NULL;
 	repl.size = newinfo->size;
-	ret = translate_table(newinfo, entry1, &repl);
+	ret = translate_table(net, newinfo, entry1, &repl);
 	if (ret)
 		goto free_newinfo;
 		goto free_newinfo;
 	}
-	ret = translate_compat_table(&newinfo, &loc_cpu_entry, &tmp);
+	ret = translate_compat_table(net, &newinfo, &loc_cpu_entry, &tmp);
 	if (ret != 0)
 		goto free_newinfo;
 	loc_cpu_entry = newinfo->entries;
 	memcpy(loc_cpu_entry, repl->entries, repl->size);
-	ret = translate_table(newinfo, loc_cpu_entry, repl);
+	ret = translate_table(net, newinfo, loc_cpu_entry, repl);
 	if (ret != 0)
 		goto out_free;

net/ipv4/route.c+6−3

 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
 static void		 ipv4_link_failure(struct sk_buff *skb);
 static void		 ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
-					   struct sk_buff *skb, u32 mtu);
+					   struct sk_buff *skb, u32 mtu,
+					   bool confirm_neigh);
 static void		 ip_do_redirect(struct dst_entry *dst, struct sock *sk,
 					struct sk_buff *skb);
 static void		ipv4_dst_destroy(struct dst_entry *dst);
 }
 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
-			      struct sk_buff *skb, u32 mtu)
+			      struct sk_buff *skb, u32 mtu,
+			      bool confirm_neigh)
 {
 	struct rtable *rt = (struct rtable *) dst;
 	struct flowi4 fl4;
 }
 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
-					  struct sk_buff *skb, u32 mtu)
+					  struct sk_buff *skb, u32 mtu,
+					  bool confirm_neigh)
 {
 }

net/ipv4/tcp_input.c+4−1

 		}
 		/* Ignore very old stuff early */
-		if (!after(sp[used_sacks].end_seq, prior_snd_una))
+		if (!after(sp[used_sacks].end_seq, prior_snd_una)) {
+			if (i == 0)
+				first_sack_index = -1;
 			continue;
+		}
 		used_sacks++;
 	}

net/ipv4/tcp_output.c+3−0

@@ -72,6 +72,9 @@ static void tcp_event_new_data_sent(struct sock sk, struct sk_buff skb) · 71 unmodified lines
72	__skb_unlink(skb, &sk->sk_write_queue);	72	__skb_unlink(skb, &sk->sk_write_queue);
73	tcp_rbtree_insert(&sk->tcp_rtx_queue, skb);	73	tcp_rbtree_insert(&sk->tcp_rtx_queue, skb);
74		74
		75	if (tp->highest_sack == NULL)
		76	tp->highest_sack = skb;
		77
75	tp->packets_out += tcp_skb_pcount(skb);	78	tp->packets_out += tcp_skb_pcount(skb);
76	if (!prior_packets \|\| icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)	79	if (!prior_packets \|\| icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
77	tcp_rearm_rto(sk);	80	tcp_rearm_rto(sk);

net/ipv4/udp.c+1−1

@@ -1475,7 +1475,7 @@ int __udp_enqueue_schedule_skb(struct sock sk, struct sk_buff skb) · 1474 unmodified lines
1475	* queue contains some other skb	1475	* queue contains some other skb
1476	*/	1476	*/
1477	rmem = atomic_add_return(size, &sk->sk_rmem_alloc);	1477	rmem = atomic_add_return(size, &sk->sk_rmem_alloc);
1478	if (rmem > (size + sk->sk_rcvbuf))	1478	if (rmem > (size + (unsigned int)sk->sk_rcvbuf))
1479	goto uncharge_drop;	1479	goto uncharge_drop;
1480		1480
1481	spin_lock(&list->lock);	1481	spin_lock(&list->lock);

net/ipv4/xfrm4_policy.c+3−2

 }
 static void xfrm4_update_pmtu(struct dst_entry *dst, struct sock *sk,
-			      struct sk_buff *skb, u32 mtu)
+			      struct sk_buff *skb, u32 mtu,
+			      bool confirm_neigh)
 {
 	struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
 	struct dst_entry *path = xdst->route;
-	path->ops->update_pmtu(path, sk, skb, mtu);
+	path->ops->update_pmtu(path, sk, skb, mtu, confirm_neigh);
 }
 static void xfrm4_redirect(struct dst_entry *dst, struct sock *sk,

net/ipv6/inet6_connection_sock.c+1−1

@@ -146,7 +146,7 @@ struct dst_entry inet6_csk_update_pmtu(struct sock sk, u32 mtu) · 145 unmodified lines
146		146
147	if (IS_ERR(dst))	147	if (IS_ERR(dst))
148	return NULL;	148	return NULL;
149	dst->ops->update_pmtu(dst, sk, NULL, mtu);	149	dst->ops->update_pmtu(dst, sk, NULL, mtu, true);
150		150
151	dst = inet6_csk_route_socket(sk, &fl6);	151	dst = inet6_csk_route_socket(sk, &fl6);
152	return IS_ERR(dst) ? NULL : dst;	152	return IS_ERR(dst) ? NULL : dst;

net/ipv6/ip6_gre.c+1−1

@@ -1040,7 +1040,7 @@ static netdev_tx_t ip6erspan_tunnel_xmit(struct sk_buff *skb, · 1039 unmodified lines
1040		1040
1041	/* TooBig packet may have updated dst->dev's mtu */	1041	/* TooBig packet may have updated dst->dev's mtu */
1042	if (!t->parms.collect_md && dst && dst_mtu(dst) > dst->dev->mtu)	1042	if (!t->parms.collect_md && dst && dst_mtu(dst) > dst->dev->mtu)
1043	dst->ops->update_pmtu(dst, NULL, skb, dst->dev->mtu);	1043	dst->ops->update_pmtu(dst, NULL, skb, dst->dev->mtu, false);
1044		1044
1045	err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,	1045	err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
1046	NEXTHDR_GRE);	1046	NEXTHDR_GRE);

net/ipv6/ip6_tunnel.c+2−2

@@ -640,7 +640,7 @@ ip4ip6_err(struct sk_buff skb, struct inet6_skb_parm opt, · 639 unmodified lines
640	if (rel_info > dst_mtu(skb_dst(skb2)))	640	if (rel_info > dst_mtu(skb_dst(skb2)))
641	goto out;	641	goto out;
642		642
643	skb_dst_update_pmtu(skb2, rel_info);	643	skb_dst_update_pmtu_no_confirm(skb2, rel_info);
644	}	644	}
645		645
646	icmp_send(skb2, rel_type, rel_code, htonl(rel_info));	646	icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
@@ -1132,7 +1132,7 @@ route_lookup: · 485 unmodified lines
1132	mtu = max(mtu, skb->protocol == htons(ETH_P_IPV6) ?	1132	mtu = max(mtu, skb->protocol == htons(ETH_P_IPV6) ?
1133	IPV6_MIN_MTU : IPV4_MIN_MTU);	1133	IPV6_MIN_MTU : IPV4_MIN_MTU);
1134		1134
1135	skb_dst_update_pmtu(skb, mtu);	1135	skb_dst_update_pmtu_no_confirm(skb, mtu);
1136	if (skb->len - t->tun_hlen - eth_hlen > mtu && !skb_is_gso(skb)) {	1136	if (skb->len - t->tun_hlen - eth_hlen > mtu && !skb_is_gso(skb)) {
1137	*pmtu = mtu;	1137	*pmtu = mtu;
1138	err = -EMSGSIZE;	1138	err = -EMSGSIZE;

net/ipv6/ip6_vti.c+1−1

@@ -479,7 +479,7 @@ vti6_xmit(struct sk_buff skb, struct net_device dev, struct flowi *fl) · 478 unmodified lines
479		479
480	mtu = dst_mtu(dst);	480	mtu = dst_mtu(dst);
481	if (skb->len > mtu) {	481	if (skb->len > mtu) {
482	skb_dst_update_pmtu(skb, mtu);	482	skb_dst_update_pmtu_no_confirm(skb, mtu);
483		483
484	if (skb->protocol == htons(ETH_P_IPV6)) {	484	if (skb->protocol == htons(ETH_P_IPV6)) {
485	if (mtu < IPV6_MIN_MTU)	485	if (mtu < IPV6_MIN_MTU)

net/ipv6/route.c+15−7

@@ -95,7 +95,8 @@ static int ip6_pkt_prohibit(struct sk_buff *skb); · 94 unmodified lines
95	static int ip6_pkt_prohibit_out(struct net net, struct sock sk, struct sk_buff *skb);	95	static int ip6_pkt_prohibit_out(struct net net, struct sock sk, struct sk_buff *skb);
96	static void ip6_link_failure(struct sk_buff *skb);	96	static void ip6_link_failure(struct sk_buff *skb);
97	static void ip6_rt_update_pmtu(struct dst_entry dst, struct sock sk,	97	static void ip6_rt_update_pmtu(struct dst_entry dst, struct sock sk,
98	struct sk_buff *skb, u32 mtu);	98	struct sk_buff *skb, u32 mtu,
		99	bool confirm_neigh);
99	static void rt6_do_redirect(struct dst_entry dst, struct sock sk,	100	static void rt6_do_redirect(struct dst_entry dst, struct sock sk,
100	struct sk_buff *skb);	101	struct sk_buff *skb);
101	static int rt6_score_route(const struct fib6_nh *nh, u32 fib6_flags, int oif,	102	static int rt6_score_route(const struct fib6_nh *nh, u32 fib6_flags, int oif,
@@ -264,7 +265,8 @@ static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst) · 162 unmodified lines
264	}	265	}
265		266
266	static void ip6_rt_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,	267	static void ip6_rt_blackhole_update_pmtu(struct dst_entry dst, struct sock sk,
267	struct sk_buff *skb, u32 mtu)	268	struct sk_buff *skb, u32 mtu,
		269	bool confirm_neigh)
268	{	270	{
269	}	271	}
270		272
@@ -2692,7 +2694,8 @@ static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt) · 2421 unmodified lines
2692	}	2694	}
2693		2695
2694	static void __ip6_rt_update_pmtu(struct dst_entry dst, const struct sock sk,	2696	static void __ip6_rt_update_pmtu(struct dst_entry dst, const struct sock sk,
2695	const struct ipv6hdr *iph, u32 mtu)	2697	const struct ipv6hdr *iph, u32 mtu,
		2698	bool confirm_neigh)
2696	{	2699	{
2697	const struct in6_addr daddr, saddr;	2700	const struct in6_addr daddr, saddr;
2698	struct rt6_info rt6 = (struct rt6_info )dst;	2701	struct rt6_info rt6 = (struct rt6_info )dst;
@@ -2710,7 +2713,10 @@ static void __ip6_rt_update_pmtu(struct dst_entry dst, const struct sock sk, · 11 unmodified lines
2710	daddr = NULL;	2713	daddr = NULL;
2711	saddr = NULL;	2714	saddr = NULL;
2712	}	2715	}
2713	dst_confirm_neigh(dst, daddr);	2716
		2717	if (confirm_neigh)
		2718	dst_confirm_neigh(dst, daddr);
		2719
2714	mtu = max_t(u32, mtu, IPV6_MIN_MTU);	2720	mtu = max_t(u32, mtu, IPV6_MIN_MTU);
2715	if (mtu >= dst_mtu(dst))	2721	if (mtu >= dst_mtu(dst))
2716	return;	2722	return;
@@ -2764,9 +2770,11 @@ out_unlock: · 47 unmodified lines
2764	}	2770	}
2765		2771
2766	static void ip6_rt_update_pmtu(struct dst_entry dst, struct sock sk,	2772	static void ip6_rt_update_pmtu(struct dst_entry dst, struct sock sk,
2767	struct sk_buff *skb, u32 mtu)	2773	struct sk_buff *skb, u32 mtu,
		2774	bool confirm_neigh)
2768	{	2775	{
2769	__ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);	2776	__ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu,
		2777	confirm_neigh);
2770	}	2778	}
2771		2779
2772	void ip6_update_pmtu(struct sk_buff skb, struct net net, __be32 mtu,	2780	void ip6_update_pmtu(struct sk_buff skb, struct net net, __be32 mtu,
@@ -2785,7 +2793,7 @@ void ip6_update_pmtu(struct sk_buff skb, struct net net, __be32 mtu, · 12 unmodified lines
2785		2793
2786	dst = ip6_route_output(net, NULL, &fl6);	2794	dst = ip6_route_output(net, NULL, &fl6);
2787	if (!dst->error)	2795	if (!dst->error)
2788	__ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));	2796	__ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu), true);
2789	dst_release(dst);	2797	dst_release(dst);
2790	}	2798	}
2791	EXPORT_SYMBOL_GPL(ip6_update_pmtu);	2799	EXPORT_SYMBOL_GPL(ip6_update_pmtu);

net/ipv6/sit.c+1−1

@@ -944,7 +944,7 @@ static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb, · 943 unmodified lines
944	}	944	}
945		945
946	if (tunnel->parms.iph.daddr)	946	if (tunnel->parms.iph.daddr)
947	skb_dst_update_pmtu(skb, mtu);	947	skb_dst_update_pmtu_no_confirm(skb, mtu);
948		948
949	if (skb->len > mtu && !skb_is_gso(skb)) {	949	if (skb->len > mtu && !skb_is_gso(skb)) {
950	icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);	950	icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);

net/ipv6/xfrm6_policy.c+3−2

 }
 static void xfrm6_update_pmtu(struct dst_entry *dst, struct sock *sk,
-			      struct sk_buff *skb, u32 mtu)
+			      struct sk_buff *skb, u32 mtu,
+			      bool confirm_neigh)
 {
 	struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
 	struct dst_entry *path = xdst->route;
-	path->ops->update_pmtu(path, sk, skb, mtu);
+	path->ops->update_pmtu(path, sk, skb, mtu, confirm_neigh);
 }
 static void xfrm6_redirect(struct dst_entry *dst, struct sock *sk,

net/netfilter/ipset/ip_set_core.c+2−1

 	struct ip_set *set;
 	struct nlattr *tb[IPSET_ATTR_ADT_MAX + 1] = {};
 	int ret = 0;
+	u32 lineno;
 	if (unlikely(protocol_min_failed(attr) ||
 		     !attr[IPSET_ATTR_SETNAME] ||
 		return -IPSET_ERR_PROTOCOL;
 	rcu_read_lock_bh();
-	ret = set->variant->uadt(set, tb, IPSET_TEST, NULL, 0, 0);
+	ret = set->variant->uadt(set, tb, IPSET_TEST, &lineno, 0, 0);
 	rcu_read_unlock_bh();
 	/* Userspace can't trigger element to be re-added */
 	if (ret == -EAGAIN)

net/netfilter/ipvs/ip_vs_xmit.c+1−1

@@ -208,7 +208,7 @@ static inline void maybe_update_pmtu(int skb_af, struct sk_buff *skb, int mtu) · 207 unmodified lines
208	struct rtable *ort = skb_rtable(skb);	208	struct rtable *ort = skb_rtable(skb);
209		209
210	if (!skb->dev && sk && sk_fullsock(sk))	210	if (!skb->dev && sk && sk_fullsock(sk))
211	ort->dst.ops->update_pmtu(&ort->dst, sk, NULL, mtu);	211	ort->dst.ops->update_pmtu(&ort->dst, sk, NULL, mtu, true);
212	}	212	}
213		213
214	static inline bool ensure_mtu_is_adequate(struct netns_ipvs *ipvs, int skb_af,	214	static inline bool ensure_mtu_is_adequate(struct netns_ipvs *ipvs, int skb_af,

net/netfilter/nf_conntrack_proto_dccp.c+3−0

@@ -677,6 +677,9 @@ static int dccp_timeout_nlattr_to_obj(struct nlattr *tb[], · 676 unmodified lines
677	unsigned int *timeouts = data;	677	unsigned int *timeouts = data;
678	int i;	678	int i;
679		679
		680	if (!timeouts)
		681	timeouts = dn->dccp_timeout;
		682
680	/* set default DCCP timeouts. */	683	/* set default DCCP timeouts. */
681	for (i=0; i<CT_DCCP_MAX; i++)	684	for (i=0; i<CT_DCCP_MAX; i++)
682	timeouts[i] = dn->dccp_timeout[i];	685	timeouts[i] = dn->dccp_timeout[i];

net/netfilter/nf_conntrack_proto_sctp.c+3−0

@@ -594,6 +594,9 @@ static int sctp_timeout_nlattr_to_obj(struct nlattr *tb[], · 593 unmodified lines
594	struct nf_sctp_net *sn = nf_sctp_pernet(net);	594	struct nf_sctp_net *sn = nf_sctp_pernet(net);
595	int i;	595	int i;
596		596
		597	if (!timeouts)
		598	timeouts = sn->timeouts;
		599
597	/* set default SCTP timeouts. */	600	/* set default SCTP timeouts. */
598	for (i=0; i<SCTP_CONNTRACK_MAX; i++)	601	for (i=0; i<SCTP_CONNTRACK_MAX; i++)
599	timeouts[i] = sn->timeouts[i];	602	timeouts[i] = sn->timeouts[i];

net/netfilter/nf_flow_table_core.c+1−6

 #define NF_FLOWTABLE_TCP_PICKUP_TIMEOUT	(120 * HZ)
 #define NF_FLOWTABLE_UDP_PICKUP_TIMEOUT	(30 * HZ)
-static inline __s32 nf_flow_timeout_delta(unsigned int timeout)
-{
-	return (__s32)(timeout - (u32)jiffies);
-}
 static void flow_offload_fixup_ct_timeout(struct nf_conn *ct)
 {
 	const struct nf_conntrack_l4proto *l4proto;
 {
 	int err;
-	flow->timeout = (u32)jiffies + NF_FLOW_TIMEOUT;
+	flow->timeout = nf_flowtable_time_stamp + NF_FLOW_TIMEOUT;
 	err = rhashtable_insert_fast(&flow_table->rhashtable,
 				     &flow->tuplehash[0].node,

net/netfilter/nf_flow_table_ip.c+2−2

@@ -280,7 +280,7 @@ nf_flow_offload_ip_hook(void priv, struct sk_buff skb, · 279 unmodified lines
280	if (nf_flow_nat_ip(flow, skb, thoff, dir) < 0)	280	if (nf_flow_nat_ip(flow, skb, thoff, dir) < 0)
281	return NF_DROP;	281	return NF_DROP;
282		282
283	flow->timeout = (u32)jiffies + NF_FLOW_TIMEOUT;	283	flow->timeout = nf_flowtable_time_stamp + NF_FLOW_TIMEOUT;
284	iph = ip_hdr(skb);	284	iph = ip_hdr(skb);
285	ip_decrease_ttl(iph);	285	ip_decrease_ttl(iph);
286	skb->tstamp = 0;	286	skb->tstamp = 0;
@@ -509,7 +509,7 @@ nf_flow_offload_ipv6_hook(void priv, struct sk_buff skb, · 222 unmodified lines
509	if (nf_flow_nat_ipv6(flow, skb, dir) < 0)	509	if (nf_flow_nat_ipv6(flow, skb, dir) < 0)
510	return NF_DROP;	510	return NF_DROP;
511		511
512	flow->timeout = (u32)jiffies + NF_FLOW_TIMEOUT;	512	flow->timeout = nf_flowtable_time_stamp + NF_FLOW_TIMEOUT;
513	ip6h = ipv6_hdr(skb);	513	ip6h = ipv6_hdr(skb);
514	ip6h->hop_limit--;	514	ip6h->hop_limit--;
515	skb->tstamp = 0;	515	skb->tstamp = 0;

net/netfilter/nf_flow_table_offload.c+37−15

@@ -88,7 +88,7 @@ static int nf_flow_rule_match(struct nf_flow_match *match, · 87 unmodified lines
88	switch (tuple->l4proto) {	88	switch (tuple->l4proto) {
89	case IPPROTO_TCP:	89	case IPPROTO_TCP:
90	key->tcp.flags = 0;	90	key->tcp.flags = 0;
91	mask->tcp.flags = TCP_FLAG_RST \| TCP_FLAG_FIN;	91	mask->tcp.flags = cpu_to_be16(be32_to_cpu(TCP_FLAG_RST \| TCP_FLAG_FIN) >> 16);
92	match->dissector.used_keys \|= BIT(FLOW_DISSECTOR_KEY_TCP);	92	match->dissector.used_keys \|= BIT(FLOW_DISSECTOR_KEY_TCP);
93	break;	93	break;
94	case IPPROTO_UDP:	94	case IPPROTO_UDP:
@@ -166,24 +166,38 @@ static int flow_offload_eth_dst(struct net *net, · 71 unmodified lines
166	enum flow_offload_tuple_dir dir,	166	enum flow_offload_tuple_dir dir,
167	struct nf_flow_rule *flow_rule)	167	struct nf_flow_rule *flow_rule)
168	{	168	{
169	const struct flow_offload_tuple *tuple = &flow->tuplehash[dir].tuple;
170	struct flow_action_entry *entry0 = flow_action_entry_next(flow_rule);	169	struct flow_action_entry *entry0 = flow_action_entry_next(flow_rule);
171	struct flow_action_entry *entry1 = flow_action_entry_next(flow_rule);	170	struct flow_action_entry *entry1 = flow_action_entry_next(flow_rule);
		171	const void *daddr = &flow->tuplehash[!dir].tuple.src_v4;
		172	const struct dst_entry *dst_cache;
		173	unsigned char ha[ETH_ALEN];
172	struct neighbour *n;	174	struct neighbour *n;
173	u32 mask, val;	175	u32 mask, val;
		176	u8 nud_state;
174	u16 val16;	177	u16 val16;
175		178
176	n = dst_neigh_lookup(tuple->dst_cache, &tuple->dst_v4);	179	dst_cache = flow->tuplehash[dir].tuple.dst_cache;
		180	n = dst_neigh_lookup(dst_cache, daddr);
177	if (!n)	181	if (!n)
178	return -ENOENT;	182	return -ENOENT;
179		183
		184	read_lock_bh(&n->lock);
		185	nud_state = n->nud_state;
		186	ether_addr_copy(ha, n->ha);
		187	read_unlock_bh(&n->lock);
		188
		189	if (!(nud_state & NUD_VALID)) {
		190	neigh_release(n);
		191	return -ENOENT;
		192	}
		193
180	mask = ~0xffffffff;	194	mask = ~0xffffffff;
181	memcpy(&val, n->ha, 4);	195	memcpy(&val, ha, 4);
182	flow_offload_mangle(entry0, FLOW_ACT_MANGLE_HDR_TYPE_ETH, 0,	196	flow_offload_mangle(entry0, FLOW_ACT_MANGLE_HDR_TYPE_ETH, 0,
183	&val, &mask);	197	&val, &mask);
184		198
185	mask = ~0x0000ffff;	199	mask = ~0x0000ffff;
186	memcpy(&val16, n->ha + 4, 2);	200	memcpy(&val16, ha + 4, 2);
187	val = val16;	201	val = val16;
188	flow_offload_mangle(entry1, FLOW_ACT_MANGLE_HDR_TYPE_ETH, 4,	202	flow_offload_mangle(entry1, FLOW_ACT_MANGLE_HDR_TYPE_ETH, 4,
189	&val, &mask);	203	&val, &mask);
@@ -335,22 +349,26 @@ static void flow_offload_port_snat(struct net *net, · 145 unmodified lines
335	struct nf_flow_rule *flow_rule)	349	struct nf_flow_rule *flow_rule)
336	{	350	{
337	struct flow_action_entry *entry = flow_action_entry_next(flow_rule);	351	struct flow_action_entry *entry = flow_action_entry_next(flow_rule);
338	u32 mask = ~htonl(0xffff0000), port;	352	u32 mask, port;
339	u32 offset;	353	u32 offset;
340		354
341	switch (dir) {	355	switch (dir) {
342	case FLOW_OFFLOAD_DIR_ORIGINAL:	356	case FLOW_OFFLOAD_DIR_ORIGINAL:
343	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY].tuple.dst_port);	357	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY].tuple.dst_port);
344	offset = 0; /* offsetof(struct tcphdr, source); */	358	offset = 0; /* offsetof(struct tcphdr, source); */
		359	port = htonl(port << 16);
		360	mask = ~htonl(0xffff0000);
345	break;	361	break;
346	case FLOW_OFFLOAD_DIR_REPLY:	362	case FLOW_OFFLOAD_DIR_REPLY:
347	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL].tuple.src_port);	363	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL].tuple.src_port);
348	offset = 0; /* offsetof(struct tcphdr, dest); */	364	offset = 0; /* offsetof(struct tcphdr, dest); */
		365	port = htonl(port);
		366	mask = ~htonl(0xffff);
349	break;	367	break;
350	default:	368	default:
351	return;	369	return;
352	}	370	}
353	port = htonl(port << 16);	371
354	flow_offload_mangle(entry, flow_offload_l4proto(flow), offset,	372	flow_offload_mangle(entry, flow_offload_l4proto(flow), offset,
355	&port, &mask);	373	&port, &mask);
356	}	374	}
@@ -361,22 +379,26 @@ static void flow_offload_port_dnat(struct net *net, · 4 unmodified lines
361	struct nf_flow_rule *flow_rule)	379	struct nf_flow_rule *flow_rule)
362	{	380	{
363	struct flow_action_entry *entry = flow_action_entry_next(flow_rule);	381	struct flow_action_entry *entry = flow_action_entry_next(flow_rule);
364	u32 mask = ~htonl(0xffff), port;	382	u32 mask, port;
365	u32 offset;	383	u32 offset;
366		384
367	switch (dir) {	385	switch (dir) {
368	case FLOW_OFFLOAD_DIR_ORIGINAL:	386	case FLOW_OFFLOAD_DIR_ORIGINAL:
369	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY].tuple.dst_port);	387	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY].tuple.src_port);
370	offset = 0; /* offsetof(struct tcphdr, source); */	388	offset = 0; /* offsetof(struct tcphdr, dest); */
		389	port = htonl(port);
		390	mask = ~htonl(0xffff);
371	break;	391	break;
372	case FLOW_OFFLOAD_DIR_REPLY:	392	case FLOW_OFFLOAD_DIR_REPLY:
373	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL].tuple.src_port);	393	port = ntohs(flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL].tuple.dst_port);
374	offset = 0; /* offsetof(struct tcphdr, dest); */	394	offset = 0; /* offsetof(struct tcphdr, source); */
		395	port = htonl(port << 16);
		396	mask = ~htonl(0xffff0000);
375	break;	397	break;
376	default:	398	default:
377	return;	399	return;
378	}	400	}
379	port = htonl(port);	401
380	flow_offload_mangle(entry, flow_offload_l4proto(flow), offset,	402	flow_offload_mangle(entry, flow_offload_l4proto(flow), offset,
381	&port, &mask);	403	&port, &mask);
382	}	404	}
@@ -759,9 +781,9 @@ void nf_flow_offload_stats(struct nf_flowtable *flowtable, · 376 unmodified lines
759	struct flow_offload *flow)	781	struct flow_offload *flow)
760	{	782	{
761	struct flow_offload_work *offload;	783	struct flow_offload_work *offload;
762	s64 delta;	784	__s32 delta;
763		785
764	delta = flow->timeout - jiffies;	786	delta = nf_flow_timeout_delta(flow->timeout);
765	if ((delta >= (9 * NF_FLOW_TIMEOUT) / 10) \|\|	787	if ((delta >= (9 * NF_FLOW_TIMEOUT) / 10) \|\|
766	flow->flags & FLOW_OFFLOAD_HW_DYING)	788	flow->flags & FLOW_OFFLOAD_HW_DYING)
767	return;	789	return;

net/netfilter/nf_tables_api.c+6−2

 	return ERR_PTR(-ENOENT);
 }
+/* Only called from error and netdev event paths. */
 static void nft_unregister_flowtable_hook(struct net *net,
 					  struct nft_flowtable *flowtable,
 					  struct nft_hook *hook)
 	struct nft_hook *hook;
 	list_for_each_entry(hook, &flowtable->hook_list, list)
-		nft_unregister_flowtable_hook(net, flowtable, hook);
+		nf_unregister_net_hook(net, &hook->ops);
 }
 static int nft_register_flowtable_net_hooks(struct net *net,
 {
 	struct nft_hook *hook, *next;
+	flowtable->data.type->free(&flowtable->data);
 	list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
+		flowtable->data.type->setup(&flowtable->data, hook->ops.dev,
+					    FLOW_BLOCK_UNBIND);
 		list_del_rcu(&hook->list);
 		kfree(hook);
 	}
 	kfree(flowtable->name);
-	flowtable->data.type->free(&flowtable->data);
 	module_put(flowtable->data.type->owner);
 	kfree(flowtable);
 }
 		if (hook->ops.dev != dev)
 			continue;
+		/* flow_offload_netdev_event() cleans up entries for us. */
 		nft_unregister_flowtable_hook(dev_net(dev), flowtable, hook);
 		list_del_rcu(&hook->list);
 		kfree_rcu(hook, rcu);

net/netfilter/nft_flow_offload.c+0−3

@@ -200,9 +200,6 @@ static void nft_flow_offload_activate(const struct nft_ctx *ctx, · 199 unmodified lines
200	static void nft_flow_offload_destroy(const struct nft_ctx *ctx,	200	static void nft_flow_offload_destroy(const struct nft_ctx *ctx,
201	const struct nft_expr *expr)	201	const struct nft_expr *expr)
202	{	202	{
203	struct nft_flow_offload *priv = nft_expr_priv(expr);
204
205	priv->flowtable->use--;
206	nf_ct_netns_put(ctx->net, ctx->family);	203	nf_ct_netns_put(ctx->net, ctx->family);
207	}	204	}
208		205

net/netfilter/nft_tproxy.c+2−2

@@ -50,7 +50,7 @@ static void nft_tproxy_eval_v4(const struct nft_expr *expr, · 49 unmodified lines
50	taddr = nf_tproxy_laddr4(skb, taddr, iph->daddr);	50	taddr = nf_tproxy_laddr4(skb, taddr, iph->daddr);
51		51
52	if (priv->sreg_port)	52	if (priv->sreg_port)
53	tport = regs->data[priv->sreg_port];	53	tport = nft_reg_load16(&regs->data[priv->sreg_port]);
54	if (!tport)	54	if (!tport)
55	tport = hp->dest;	55	tport = hp->dest;
56		56
@@ -117,7 +117,7 @@ static void nft_tproxy_eval_v6(const struct nft_expr *expr, · 60 unmodified lines
117	taddr = *nf_tproxy_laddr6(skb, &taddr, &iph->daddr);	117	taddr = *nf_tproxy_laddr6(skb, &taddr, &iph->daddr);
118		118
119	if (priv->sreg_port)	119	if (priv->sreg_port)
120	tport = regs->data[priv->sreg_port];	120	tport = nft_reg_load16(&regs->data[priv->sreg_port]);
121	if (!tport)	121	if (!tport)
122	tport = hp->dest;	122	tport = hp->dest;
123		123

net/qrtr/qrtr.c+1−1

@@ -196,7 +196,7 @@ static int qrtr_node_enqueue(struct qrtr_node node, struct sk_buff skb, · 195 unmodified lines
196	hdr->size = cpu_to_le32(len);	196	hdr->size = cpu_to_le32(len);
197	hdr->confirm_rx = 0;	197	hdr->confirm_rx = 0;
198		198
199	skb_put_padto(skb, ALIGN(len, 4));	199	skb_put_padto(skb, ALIGN(len, 4) + sizeof(*hdr));
200		200
201	mutex_lock(&node->ep_lock);	201	mutex_lock(&node->ep_lock);
202	if (node->ep)	202	if (node->ep)

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

 struct rxrpc_security {
 	const char		*name;		/* name of this service */
 	u8			security_index;	/* security type provided */
+	u32			no_key_abort;	/* Abort code indicating no key */
 	/* Initialise a security service */
 	int (*init)(void);
 struct rxrpc_connection *rxrpc_find_service_conn_rcu(struct rxrpc_peer *,
 						     struct sk_buff *);
 struct rxrpc_connection *rxrpc_prealloc_service_connection(struct rxrpc_net *, gfp_t);
-void rxrpc_new_incoming_connection(struct rxrpc_sock *,
+void rxrpc_new_incoming_connection(struct rxrpc_sock *, struct rxrpc_connection *,
-				   struct rxrpc_connection *, struct sk_buff *);
+				   const struct rxrpc_security *, struct key *,
+				   struct sk_buff *);
 void rxrpc_unpublish_service_conn(struct rxrpc_connection *);
 /*
 int __init rxrpc_init_security(void);
 void rxrpc_exit_security(void);
 int rxrpc_init_client_conn_security(struct rxrpc_connection *);
-int rxrpc_init_server_conn_security(struct rxrpc_connection *);
+bool rxrpc_look_up_server_security(struct rxrpc_local *, struct rxrpc_sock *,
+				   const struct rxrpc_security **, struct key **,
+				   struct sk_buff *);
 /*
  * sendmsg.c

net/rxrpc/call_accept.c+37−23

 	kfree(b);
 }
+/*
+ * Ping the other end to fill our RTT cache and to retrieve the rwind
+ * and MTU parameters.
+ */
+static void rxrpc_send_ping(struct rxrpc_call *call, struct sk_buff *skb)
+{
+	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
+	ktime_t now = skb->tstamp;
+	if (call->peer->rtt_usage < 3 ||
+	    ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now))
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,
+				  true, true,
+				  rxrpc_propose_ack_ping_for_params);
+}
 /*
  * Allocate a new incoming call from the prealloc pool, along with a connection
  * and a peer as necessary.
 						    struct rxrpc_local *local,
 						    struct rxrpc_peer *peer,
 						    struct rxrpc_connection *conn,
+						    const struct rxrpc_security *sec,
+						    struct key *key,
 						    struct sk_buff *skb)
 {
 	struct rxrpc_backlog *b = rx->backlog;
 		conn->params.local = rxrpc_get_local(local);
 		conn->params.peer = peer;
 		rxrpc_see_connection(conn);
-		rxrpc_new_incoming_connection(rx, conn, skb);
+		rxrpc_new_incoming_connection(rx, conn, sec, key, skb);
 	} else {
 		rxrpc_get_connection(conn);
 	}
 					   struct sk_buff *skb)
 {
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
+	const struct rxrpc_security *sec = NULL;
 	struct rxrpc_connection *conn;
 	struct rxrpc_peer *peer = NULL;
-	struct rxrpc_call *call;
+	struct rxrpc_call *call = NULL;
+	struct key *key = NULL;
 	_enter("");
 				  sp->hdr.seq, RX_INVALID_OPERATION, ESHUTDOWN);
 		skb->mark = RXRPC_SKB_MARK_REJECT_ABORT;
 		skb->priority = RX_INVALID_OPERATION;
-		_leave(" = NULL [close]");
+		goto no_call;
-		call = NULL;
-		goto out;
 	}
 	/* The peer, connection and call may all have sprung into existence due
 	 */
 	conn = rxrpc_find_connection_rcu(local, skb, &peer);
-	call = rxrpc_alloc_incoming_call(rx, local, peer, conn, skb);
+	if (!conn && !rxrpc_look_up_server_security(local, rx, &sec, &key, skb))
+		goto no_call;
+	call = rxrpc_alloc_incoming_call(rx, local, peer, conn, sec, key, skb);
+	key_put(key);
 	if (!call) {
 		skb->mark = RXRPC_SKB_MARK_REJECT_BUSY;
-		_leave(" = NULL [busy]");
+		goto no_call;
-		call = NULL;
-		goto out;
 	}
 	trace_rxrpc_receive(call, rxrpc_receive_incoming,
 			    sp->hdr.serial, sp->hdr.seq);
-	/* Lock the call to prevent rxrpc_kernel_send/recv_data() and
-	 * sendmsg()/recvmsg() inconveniently stealing the mutex once the
-	 * notification is generated.
-	 *
-	 * The BUG should never happen because the kernel should be well
-	 * behaved enough not to access the call before the first notification
-	 * event and userspace is prevented from doing so until the state is
-	 * appropriate.
-	 */
-	if (!mutex_trylock(&call->user_mutex))
-		BUG();
 	/* Make the call live. */
 	rxrpc_incoming_call(rx, call, skb);
 	conn = call->conn;
 		BUG();
 	}
 	spin_unlock(&conn->state_lock);
+	spin_unlock(&rx->incoming_lock);
+	rxrpc_send_ping(call, skb);
 	if (call->state == RXRPC_CALL_SERVER_ACCEPTING)
 		rxrpc_notify_socket(call);
 	rxrpc_put_call(call, rxrpc_call_put);
 	_leave(" = %p{%d}", call, call->debug_id);
-out:
-	spin_unlock(&rx->incoming_lock);
 	return call;
+no_call:
+	spin_unlock(&rx->incoming_lock);
+	_leave(" = NULL [%u]", skb->mark);
+	return NULL;
 }
 /*

net/rxrpc/conn_event.c+1−15

@@ -376,21 +376,7 @@ static void rxrpc_secure_connection(struct rxrpc_connection *conn) · 375 unmodified lines
376	_enter("{%d}", conn->debug_id);	376	_enter("{%d}", conn->debug_id);
377		377
378	ASSERT(conn->security_ix != 0);	378	ASSERT(conn->security_ix != 0);
379		379	ASSERT(conn->server_key);
380	if (!conn->params.key) {
381	_debug("set up security");
382	ret = rxrpc_init_server_conn_security(conn);
383	switch (ret) {
384	case 0:
385	break;
386	case -ENOENT:
387	abort_code = RX_CALL_DEAD;
388	goto abort;
389	default:
390	abort_code = RXKADNOAUTH;
391	goto abort;
392	}
393	}
394		380
395	if (conn->security->issue_challenge(conn) < 0) {	381	if (conn->security->issue_challenge(conn) < 0) {
396	abort_code = RX_CALL_DEAD;	382	abort_code = RX_CALL_DEAD;

net/rxrpc/conn_service.c+4−0

  */
 void rxrpc_new_incoming_connection(struct rxrpc_sock *rx,
 				   struct rxrpc_connection *conn,
+				   const struct rxrpc_security *sec,
+				   struct key *key,
 				   struct sk_buff *skb)
 {
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 	conn->service_id	= sp->hdr.serviceId;
 	conn->security_ix	= sp->hdr.securityIndex;
 	conn->out_clientflag	= 0;
+	conn->security		= sec;
+	conn->server_key	= key_get(key);
 	if (conn->security_ix)
 		conn->state	= RXRPC_CONN_SERVICE_UNSECURED;
 	else

net/rxrpc/input.c+0−18

@@ -192,22 +192,6 @@ send_extra_data: · 191 unmodified lines
192	goto out_no_clear_ca;	192	goto out_no_clear_ca;
193	}	193	}
194		194
195	/*
196	* Ping the other end to fill our RTT cache and to retrieve the rwind
197	* and MTU parameters.
198	*/
199	static void rxrpc_send_ping(struct rxrpc_call call, struct sk_buff skb)
200	{
201	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
202	ktime_t now = skb->tstamp;
203
204	if (call->peer->rtt_usage < 3 \|\|
205	ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now))
206	rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,
207	true, true,
208	rxrpc_propose_ack_ping_for_params);
209	}
210
211	/*	195	/*
212	* Apply a hard ACK by advancing the Tx window.	196	* Apply a hard ACK by advancing the Tx window.
213	*/	197	*/
@@ -1396,8 +1380,6 @@ int rxrpc_input_packet(struct sock udp_sk, struct sk_buff skb) · 1182 unmodified lines
1396	call = rxrpc_new_incoming_call(local, rx, skb);	1380	call = rxrpc_new_incoming_call(local, rx, skb);
1397	if (!call)	1381	if (!call)
1398	goto reject_packet;	1382	goto reject_packet;
1399	rxrpc_send_ping(call, skb);
1400	mutex_unlock(&call->user_mutex);
1401	}	1383	}
1402		1384
1403	/* Process a call packet; this either discards or passes on the ref	1385	/* Process a call packet; this either discards or passes on the ref

net/rxrpc/rxkad.c+3−2

 	u32 serial;
 	int ret;
-	_enter("{%d,%x}", conn->debug_id, key_serial(conn->params.key));
+	_enter("{%d,%x}", conn->debug_id, key_serial(conn->server_key));
-	ret = key_validate(conn->params.key);
+	ret = key_validate(conn->server_key);
 	if (ret < 0)
 		return ret;
 const struct rxrpc_security rxkad = {
 	.name				= "rxkad",
 	.security_index			= RXRPC_SECURITY_RXKAD,
+	.no_key_abort			= RXKADUNKNOWNKEY,
 	.init				= rxkad_init,
 	.exit				= rxkad_exit,
 	.init_connection_security	= rxkad_init_connection_security,

net/rxrpc/security.c+33−37

@@ -101,62 +101,58 @@ int rxrpc_init_client_conn_security(struct rxrpc_connection *conn) · 100 unmodified lines
101	}	101	}
102		102
103	/*	103	/*
104	* initialise the security on a server connection	104	* Find the security key for a server connection.
105	*/	105	*/
106	int rxrpc_init_server_conn_security(struct rxrpc_connection *conn)	106	bool rxrpc_look_up_server_security(struct rxrpc_local local, struct rxrpc_sock rx,
		107	const struct rxrpc_security **_sec,
		108	struct key **_key,
		109	struct sk_buff *skb)
107	{	110	{
108	const struct rxrpc_security *sec;	111	const struct rxrpc_security *sec;
109	struct rxrpc_local *local = conn->params.local;	112	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
110	struct rxrpc_sock *rx;	113	key_ref_t kref = NULL;
111	struct key *key;
112	key_ref_t kref;
113	char kdesc[5 + 1 + 3 + 1];	114	char kdesc[5 + 1 + 3 + 1];
114		115
115	_enter("");	116	_enter("");
116		117
117	sprintf(kdesc, "%u:%u", conn->service_id, conn->security_ix);	118	sprintf(kdesc, "%u:%u", sp->hdr.serviceId, sp->hdr.securityIndex);
118		119
119	sec = rxrpc_security_lookup(conn->security_ix);	120	sec = rxrpc_security_lookup(sp->hdr.securityIndex);
120	if (!sec) {	121	if (!sec) {
121	_leave(" = -ENOKEY [lookup]");	122	trace_rxrpc_abort(0, "SVS",
122	return -ENOKEY;	123	sp->hdr.cid, sp->hdr.callNumber, sp->hdr.seq,
		124	RX_INVALID_OPERATION, EKEYREJECTED);
		125	skb->mark = RXRPC_SKB_MARK_REJECT_ABORT;
		126	skb->priority = RX_INVALID_OPERATION;
		127	return false;
123	}	128	}
124		129
125	/* find the service */	130	if (sp->hdr.securityIndex == RXRPC_SECURITY_NONE)
126	read_lock(&local->services_lock);	131	goto out;
127	rx = rcu_dereference_protected(local->service,
128	lockdep_is_held(&local->services_lock));
129	if (rx && (rx->srx.srx_service == conn->service_id \|\|
130	rx->second_service == conn->service_id))
131	goto found_service;
132		132
133	/* the service appears to have died */
134	read_unlock(&local->services_lock);
135	_leave(" = -ENOENT");
136	return -ENOENT;
137
138	found_service:
139	if (!rx->securities) {	133	if (!rx->securities) {
140	read_unlock(&local->services_lock);	134	trace_rxrpc_abort(0, "SVR",
141	_leave(" = -ENOKEY");	135	sp->hdr.cid, sp->hdr.callNumber, sp->hdr.seq,
142	return -ENOKEY;	136	RX_INVALID_OPERATION, EKEYREJECTED);
		137	skb->mark = RXRPC_SKB_MARK_REJECT_ABORT;
		138	skb->priority = RX_INVALID_OPERATION;
		139	return false;
143	}	140	}
144		141
145	/* look through the service's keyring */	142	/* look through the service's keyring */
146	kref = keyring_search(make_key_ref(rx->securities, 1UL),	143	kref = keyring_search(make_key_ref(rx->securities, 1UL),
147	&key_type_rxrpc_s, kdesc, true);	144	&key_type_rxrpc_s, kdesc, true);
148	if (IS_ERR(kref)) {	145	if (IS_ERR(kref)) {
149	read_unlock(&local->services_lock);	146	trace_rxrpc_abort(0, "SVK",
150	_leave(" = %ld [search]", PTR_ERR(kref));	147	sp->hdr.cid, sp->hdr.callNumber, sp->hdr.seq,
151	return PTR_ERR(kref);	148	sec->no_key_abort, EKEYREJECTED);
		149	skb->mark = RXRPC_SKB_MARK_REJECT_ABORT;
		150	skb->priority = sec->no_key_abort;
		151	return false;
152	}	152	}
153		153
154	key = key_ref_to_ptr(kref);	154	out:
155	read_unlock(&local->services_lock);	155	*_sec = sec;
156		156	*_key = key_ref_to_ptr(kref);
157	conn->server_key = key;	157	return true;
158	conn->security = sec;
159
160	_leave(" = 0");
161	return 0;
162	}	158	}

net/sched/act_mirred.c+12−10

@@ -219,8 +219,10 @@ static int tcf_mirred_act(struct sk_buff skb, const struct tc_action a, · 218 unmodified lines
219	bool use_reinsert;	219	bool use_reinsert;
220	bool want_ingress;	220	bool want_ingress;
221	bool is_redirect;	221	bool is_redirect;
		222	bool expects_nh;
222	int m_eaction;	223	int m_eaction;
223	int mac_len;	224	int mac_len;
		225	bool at_nh;
224		226
225	rec_level = __this_cpu_inc_return(mirred_rec_level);	227	rec_level = __this_cpu_inc_return(mirred_rec_level);
226	if (unlikely(rec_level > MIRRED_RECURSION_LIMIT)) {	228	if (unlikely(rec_level > MIRRED_RECURSION_LIMIT)) {
@@ -261,19 +263,19 @@ static int tcf_mirred_act(struct sk_buff skb, const struct tc_action a, · 34 unmodified lines
261	goto out;	263	goto out;
262	}	264	}
263		265
264	/* If action's target direction differs than filter's direction,
265	* and devices expect a mac header on xmit, then mac push/pull is
266	* needed.
267	*/
268	want_ingress = tcf_mirred_act_wants_ingress(m_eaction);	266	want_ingress = tcf_mirred_act_wants_ingress(m_eaction);
269	if (skb_at_tc_ingress(skb) != want_ingress && m_mac_header_xmit) {	267
270	if (!skb_at_tc_ingress(skb)) {	268	expects_nh = want_ingress \|\| !m_mac_header_xmit;
271	/* caught at egress, act ingress: pull mac */	269	at_nh = skb->data == skb_network_header(skb);
272	mac_len = skb_network_header(skb) - skb_mac_header(skb);	270	if (at_nh != expects_nh) {
		271	mac_len = skb_at_tc_ingress(skb) ? skb->mac_len :
		272	skb_network_header(skb) - skb_mac_header(skb);
		273	if (expects_nh) {
		274	/* target device/action expect data at nh */
273	skb_pull_rcsum(skb2, mac_len);	275	skb_pull_rcsum(skb2, mac_len);
274	} else {	276	} else {
275	/* caught at ingress, act egress: push mac */	277	/* target device/action expect data at mac */
276	skb_push_rcsum(skb2, skb->mac_len);	278	skb_push_rcsum(skb2, mac_len);
277	}	279	}
278	}	280	}
279		281

net/sched/cls_api.c+5−26

@@ -308,33 +308,12 @@ static void tcf_proto_put(struct tcf_proto *tp, bool rtnl_held, · 307 unmodified lines
308	tcf_proto_destroy(tp, rtnl_held, true, extack);	308	tcf_proto_destroy(tp, rtnl_held, true, extack);
309	}	309	}
310		310
311	static int walker_check_empty(struct tcf_proto tp, void fh,	311	static bool tcf_proto_check_delete(struct tcf_proto *tp)
312	struct tcf_walker *arg)
313	{	312	{
314	if (fh) {	313	if (tp->ops->delete_empty)
315	arg->nonempty = true;	314	return tp->ops->delete_empty(tp);
316	return -1;
317	}
318	return 0;
319	}
320
321	static bool tcf_proto_is_empty(struct tcf_proto *tp, bool rtnl_held)
322	{
323	struct tcf_walker walker = { .fn = walker_check_empty, };
324
325	if (tp->ops->walk) {
326	tp->ops->walk(tp, &walker, rtnl_held);
327	return !walker.nonempty;
328	}
329	return true;
330	}
331		315
332	static bool tcf_proto_check_delete(struct tcf_proto *tp, bool rtnl_held)	316	tp->deleting = true;
333	{
334	spin_lock(&tp->lock);
335	if (tcf_proto_is_empty(tp, rtnl_held))
336	tp->deleting = true;
337	spin_unlock(&tp->lock);
338	return tp->deleting;	317	return tp->deleting;
339	}	318	}
340		319
@@ -1751,7 +1730,7 @@ static void tcf_chain_tp_delete_empty(struct tcf_chain *chain, · 1410 unmodified lines
1751	* concurrently.	1730	* concurrently.
1752	* Mark tp for deletion if it is empty.	1731	* Mark tp for deletion if it is empty.
1753	*/	1732	*/
1754	if (!tp_iter \|\| !tcf_proto_check_delete(tp, rtnl_held)) {	1733	if (!tp_iter \|\| !tcf_proto_check_delete(tp)) {
1755	mutex_unlock(&chain->filter_chain_lock);	1734	mutex_unlock(&chain->filter_chain_lock);
1756	return;	1735	return;
1757	}	1736	}

net/sched/cls_flower.c+12−0

 		f->res.class = cl;
 }
+static bool fl_delete_empty(struct tcf_proto *tp)
+{
+	struct cls_fl_head *head = fl_head_dereference(tp);
+	spin_lock(&tp->lock);
+	tp->deleting = idr_is_empty(&head->handle_idr);
+	spin_unlock(&tp->lock);
+	return tp->deleting;
+}
 static struct tcf_proto_ops cls_fl_ops __read_mostly = {
 	.kind		= "flower",
 	.classify	= fl_classify,
 	.put		= fl_put,
 	.change		= fl_change,
 	.delete		= fl_delete,
+	.delete_empty	= fl_delete_empty,
 	.walk		= fl_walk,
 	.reoffload	= fl_reoffload,
 	.hw_add		= fl_hw_add,

net/sched/cls_u32.c+0−25

@@ -1108,33 +1108,10 @@ erridr: · 1107 unmodified lines
1108	return err;	1108	return err;
1109	}	1109	}
1110		1110
1111	static bool u32_hnode_empty(struct tc_u_hnode ht, bool non_root_ht)
1112	{
1113	int i;
1114
1115	if (!ht)
1116	return true;
1117	if (!ht->is_root) {
1118	*non_root_ht = true;
1119	return false;
1120	}
1121	if (*non_root_ht)
1122	return false;
1123	if (ht->refcnt < 2)
1124	return true;
1125
1126	for (i = 0; i <= ht->divisor; i++) {
1127	if (rtnl_dereference(ht->ht[i]))
1128	return false;
1129	}
1130	return true;
1131	}
1132
1133	static void u32_walk(struct tcf_proto tp, struct tcf_walker arg,	1111	static void u32_walk(struct tcf_proto tp, struct tcf_walker arg,
1134	bool rtnl_held)	1112	bool rtnl_held)
1135	{	1113	{
1136	struct tc_u_common *tp_c = tp->data;	1114	struct tc_u_common *tp_c = tp->data;
1137	bool non_root_ht = false;
1138	struct tc_u_hnode *ht;	1115	struct tc_u_hnode *ht;
1139	struct tc_u_knode *n;	1116	struct tc_u_knode *n;
1140	unsigned int h;	1117	unsigned int h;
@@ -1147,8 +1124,6 @@ static void u32_walk(struct tcf_proto tp, struct tcf_walker arg, · 6 unmodified lines
1147	ht = rtnl_dereference(ht->next)) {	1124	ht = rtnl_dereference(ht->next)) {
1148	if (ht->prio != tp->prio)	1125	if (ht->prio != tp->prio)
1149	continue;	1126	continue;
1150	if (u32_hnode_empty(ht, &non_root_ht))
1151	return;
1152	if (arg->count >= arg->skip) {	1127	if (arg->count >= arg->skip) {
1153	if (arg->fn(tp, ht, arg) < 0) {	1128	if (arg->fn(tp, ht, arg) < 0) {
1154	arg->stop = 1;	1129	arg->stop = 1;

net/sched/sch_cake.c+1−1

@@ -1769,7 +1769,7 @@ static s32 cake_enqueue(struct sk_buff skb, struct Qdisc sch, · 1768 unmodified lines
1769	q->avg_window_begin));	1769	q->avg_window_begin));
1770	u64 b = q->avg_window_bytes * (u64)NSEC_PER_SEC;	1770	u64 b = q->avg_window_bytes * (u64)NSEC_PER_SEC;
1771		1771
1772	do_div(b, window_interval);	1772	b = div64_u64(b, window_interval);
1773	q->avg_peak_bandwidth =	1773	q->avg_peak_bandwidth =
1774	cake_ewma(q->avg_peak_bandwidth, b,	1774	cake_ewma(q->avg_peak_bandwidth, b,
1775	b > q->avg_peak_bandwidth ? 2 : 8);	1775	b > q->avg_peak_bandwidth ? 2 : 8);

net/sched/sch_fq.c+12−11

 				     f->socket_hash != sk->sk_hash)) {
 				f->credit = q->initial_quantum;
 				f->socket_hash = sk->sk_hash;
+				if (q->rate_enable)
+					smp_store_release(&sk->sk_pacing_status,
+							  SK_PACING_FQ);
 				if (fq_flow_is_throttled(f))
 					fq_flow_unset_throttled(q, f);
 				f->time_next_packet = 0ULL;
 	fq_flow_set_detached(f);
 	f->sk = sk;
-	if (skb->sk == sk)
+	if (skb->sk == sk) {
 		f->socket_hash = sk->sk_hash;
+		if (q->rate_enable)
+			smp_store_release(&sk->sk_pacing_status,
+					  SK_PACING_FQ);
+	}
 	f->credit = q->initial_quantum;
 	rb_link_node(&f->fq_node, parent, p);
 	f->qlen++;
 	qdisc_qstats_backlog_inc(sch, skb);
 	if (fq_flow_is_detached(f)) {
-		struct sock *sk = skb->sk;
 		fq_flow_add_tail(&q->new_flows, f);
 		if (time_after(jiffies, f->age + q->flow_refill_delay))
 			f->credit = max_t(u32, f->credit, q->quantum);
-		if (sk && q->rate_enable) {
-			if (unlikely(smp_load_acquire(&sk->sk_pacing_status) !=
-				     SK_PACING_FQ))
-				smp_store_release(&sk->sk_pacing_status,
-						  SK_PACING_FQ);
-		}
 		q->inactive_flows--;
 	}
 	if (tb[TCA_FQ_QUANTUM]) {
 		u32 quantum = nla_get_u32(tb[TCA_FQ_QUANTUM]);
-		if (quantum > 0)
+		if (quantum > 0 && quantum <= (1 << 20)) {
 			q->quantum = quantum;
-		else
+		} else {
+			NL_SET_ERR_MSG_MOD(extack, "invalid quantum");
 			err = -EINVAL;
+		}
 	}
 	if (tb[TCA_FQ_INITIAL_QUANTUM])

net/sched/sch_prio.c+8−2

 	struct tc_prio_qopt_offload graft_offload;
 	unsigned long band = arg - 1;
-	if (new == NULL)
+	if (!new) {
-		new = &noop_qdisc;
+		new = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
+					TC_H_MAKE(sch->handle, arg), extack);
+		if (!new)
+			new = &noop_qdisc;
+		else
+			qdisc_hash_add(new, true);
+	}
 	*old = qdisc_replace(sch, new, &q->queues[band]);

net/sctp/sm_sideeffect.c+18−10

 			/* Generate an INIT ACK chunk.  */
 			new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
 						     0);
-			if (!new_obj)
+			if (!new_obj) {
-				goto nomem;
+				error = -ENOMEM;
+				break;
+			}
 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
 					SCTP_CHUNK(new_obj));
 			if (!new_obj) {
 				if (cmd->obj.chunk)
 					sctp_chunk_free(cmd->obj.chunk);
-				goto nomem;
+				error = -ENOMEM;
+				break;
 			}
 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
 					SCTP_CHUNK(new_obj));
 			/* Generate a SHUTDOWN chunk.  */
 			new_obj = sctp_make_shutdown(asoc, chunk);
-			if (!new_obj)
+			if (!new_obj) {
-				goto nomem;
+				error = -ENOMEM;
+				break;
+			}
 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
 					SCTP_CHUNK(new_obj));
 			break;
 			break;
 		}
-		if (error)
+		if (error) {
+			cmd = sctp_next_cmd(commands);
+			while (cmd) {
+				if (cmd->verb == SCTP_CMD_REPLY)
+					sctp_chunk_free(cmd->obj.chunk);
+				cmd = sctp_next_cmd(commands);
+			}
 			break;
+		}
 	}
-out:
 	/* If this is in response to a received chunk, wait until
 	 * we are done with the packet to open the queue so that we don't
 	 * send multiple packets in response to a single request.
 		sp->data_ready_signalled = 0;
 	return error;
-nomem:
-	error = -ENOMEM;
-	goto out;
 }

net/sctp/stream.c+15−15

@@ -84,10 +84,8 @@ static int sctp_stream_alloc_out(struct sctp_stream *stream, __u16 outcnt, · 83 unmodified lines
84	return 0;	84	return 0;
85		85
86	ret = genradix_prealloc(&stream->out, outcnt, gfp);	86	ret = genradix_prealloc(&stream->out, outcnt, gfp);
87	if (ret) {	87	if (ret)
88	genradix_free(&stream->out);
89	return ret;	88	return ret;
90	}
91		89
92	stream->outcnt = outcnt;	90	stream->outcnt = outcnt;
93	return 0;	91	return 0;
@@ -102,10 +100,8 @@ static int sctp_stream_alloc_in(struct sctp_stream *stream, __u16 incnt, · 8 unmodified lines
102	return 0;	100	return 0;
103		101
104	ret = genradix_prealloc(&stream->in, incnt, gfp);	102	ret = genradix_prealloc(&stream->in, incnt, gfp);
105	if (ret) {	103	if (ret)
106	genradix_free(&stream->in);
107	return ret;	104	return ret;
108	}
109		105
110	stream->incnt = incnt;	106	stream->incnt = incnt;
111	return 0;	107	return 0;
@@ -123,7 +119,7 @@ int sctp_stream_init(struct sctp_stream *stream, __u16 outcnt, __u16 incnt, · 11 unmodified lines
123	* a new one with new outcnt to save memory if needed.	119	* a new one with new outcnt to save memory if needed.
124	*/	120	*/
125	if (outcnt == stream->outcnt)	121	if (outcnt == stream->outcnt)
126	goto in;	122	goto handle_in;
127		123
128	/* Filter out chunks queued on streams that won't exist anymore */	124	/* Filter out chunks queued on streams that won't exist anymore */
129	sched->unsched_all(stream);	125	sched->unsched_all(stream);
@@ -132,24 +128,28 @@ int sctp_stream_init(struct sctp_stream *stream, __u16 outcnt, __u16 incnt, · 2 unmodified lines
132		128
133	ret = sctp_stream_alloc_out(stream, outcnt, gfp);	129	ret = sctp_stream_alloc_out(stream, outcnt, gfp);
134	if (ret)	130	if (ret)
135	goto out;	131	goto out_err;
136		132
137	for (i = 0; i < stream->outcnt; i++)	133	for (i = 0; i < stream->outcnt; i++)
138	SCTP_SO(stream, i)->state = SCTP_STREAM_OPEN;	134	SCTP_SO(stream, i)->state = SCTP_STREAM_OPEN;
139		135
140	in:	136	handle_in:
141	sctp_stream_interleave_init(stream);	137	sctp_stream_interleave_init(stream);
142	if (!incnt)	138	if (!incnt)
143	goto out;	139	goto out;
144		140
145	ret = sctp_stream_alloc_in(stream, incnt, gfp);	141	ret = sctp_stream_alloc_in(stream, incnt, gfp);
146	if (ret) {	142	if (ret)
147	sched->free(stream);	143	goto in_err;
148	genradix_free(&stream->out);	144
149	stream->outcnt = 0;	145	goto out;
150	goto out;
151	}
152		146
		147	in_err:
		148	sched->free(stream);
		149	genradix_free(&stream->in);
		150	out_err:
		151	genradix_free(&stream->out);
		152	stream->outcnt = 0;
153	out:	153	out:
154	return ret;	154	return ret;
155	}	155	}

net/sctp/transport.c+1−1

@@ -263,7 +263,7 @@ bool sctp_transport_update_pmtu(struct sctp_transport *t, u32 pmtu) · 262 unmodified lines
263		263
264	pf->af->from_sk(&addr, sk);	264	pf->af->from_sk(&addr, sk);
265	pf->to_sk_daddr(&t->ipaddr, sk);	265	pf->to_sk_daddr(&t->ipaddr, sk);
266	dst->ops->update_pmtu(dst, sk, NULL, pmtu);	266	dst->ops->update_pmtu(dst, sk, NULL, pmtu, true);
267	pf->to_sk_daddr(&addr, sk);	267	pf->to_sk_daddr(&addr, sk);
268		268
269	dst = sctp_transport_dst_check(t);	269	dst = sctp_transport_dst_check(t);

net/tipc/Makefile+1−3

@@ -9,7 +9,7 @@ tipc-y += addr.o bcast.o bearer.o \ · 8 unmodified lines
9	core.o link.o discover.o msg.o \	9	core.o link.o discover.o msg.o \
10	name_distr.o subscr.o monitor.o name_table.o net.o \	10	name_distr.o subscr.o monitor.o name_table.o net.o \
11	netlink.o netlink_compat.o node.o socket.o eth_media.o \	11	netlink.o netlink_compat.o node.o socket.o eth_media.o \
12	topsrv.o socket.o group.o trace.o	12	topsrv.o group.o trace.o
13		13
14	CFLAGS_trace.o += -I$(src)	14	CFLAGS_trace.o += -I$(src)
15		15
@@ -20,5 +20,3 @@ tipc-$(CONFIG_TIPC_CRYPTO) += crypto.o · 4 unmodified lines
20		20
21		21
22	obj-$(CONFIG_TIPC_DIAG) += diag.o	22	obj-$(CONFIG_TIPC_DIAG) += diag.o
23
24	tipc_diag-y := diag.o

net/tipc/netlink_compat.c+2−2

@@ -204,8 +204,8 @@ static int __tipc_nl_compat_dumpit(struct tipc_nl_compat_cmd_dump *cmd, · 203 unmodified lines
204	return -ENOMEM;	204	return -ENOMEM;
205	}	205	}
206		206
207	attrbuf = kmalloc_array(tipc_genl_family.maxattr + 1,	207	attrbuf = kcalloc(tipc_genl_family.maxattr + 1,
208	sizeof(struct nlattr *), GFP_KERNEL);	208	sizeof(struct nlattr *), GFP_KERNEL);
209	if (!attrbuf) {	209	if (!attrbuf) {
210	err = -ENOMEM;	210	err = -ENOMEM;
211	goto err_out;	211	goto err_out;

net/tipc/socket.c+34−23

  *
  * Caller must hold socket lock
  */
-static void tsk_rej_rx_queue(struct sock *sk)
+static void tsk_rej_rx_queue(struct sock *sk, int error)
 {
 	struct sk_buff *skb;
 	while ((skb = __skb_dequeue(&sk->sk_receive_queue)))
-		tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT);
+		tipc_sk_respond(sk, skb, error);
 }
 static bool tipc_sk_connected(struct sock *sk)
 	/* Remove pending SYN */
 	__skb_queue_purge(&sk->sk_write_queue);
-	/* Reject all unreceived messages, except on an active connection
+	/* Remove partially received buffer if any */
-	 * (which disconnects locally & sends a 'FIN+' to peer).
+	skb = skb_peek(&sk->sk_receive_queue);
-	 */
+	if (skb && TIPC_SKB_CB(skb)->bytes_read) {
-	while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
+		__skb_unlink(skb, &sk->sk_receive_queue);
-		if (TIPC_SKB_CB(skb)->bytes_read) {
+		kfree_skb(skb);
-			kfree_skb(skb);
-			continue;
-		}
-		if (!tipc_sk_type_connectionless(sk) &&
-		    sk->sk_state != TIPC_DISCONNECTING) {
-			tipc_set_sk_state(sk, TIPC_DISCONNECTING);
-			tipc_node_remove_conn(net, dnode, tsk->portid);
-		}
-		tipc_sk_respond(sk, skb, error);
 	}
-	if (tipc_sk_type_connectionless(sk))
+	/* Reject all unreceived messages if connectionless */
+	if (tipc_sk_type_connectionless(sk)) {
+		tsk_rej_rx_queue(sk, error);
 		return;
+	}
-	if (sk->sk_state != TIPC_DISCONNECTING) {
+	switch (sk->sk_state) {
+	case TIPC_CONNECTING:
+	case TIPC_ESTABLISHED:
+		tipc_set_sk_state(sk, TIPC_DISCONNECTING);
+		tipc_node_remove_conn(net, dnode, tsk->portid);
+		/* Send a FIN+/- to its peer */
+		skb = __skb_dequeue(&sk->sk_receive_queue);
+		if (skb) {
+			__skb_queue_purge(&sk->sk_receive_queue);
+			tipc_sk_respond(sk, skb, error);
+			break;
+		}
 		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE,
 				      TIPC_CONN_MSG, SHORT_H_SIZE, 0, dnode,
 				      tsk_own_node(tsk), tsk_peer_port(tsk),
 				      tsk->portid, error);
 		if (skb)
 			tipc_node_xmit_skb(net, skb, dnode, tsk->portid);
-		tipc_node_remove_conn(net, dnode, tsk->portid);
+		break;
-		tipc_set_sk_state(sk, TIPC_DISCONNECTING);
+	case TIPC_LISTEN:
+		/* Reject all SYN messages */
+		tsk_rej_rx_queue(sk, error);
+		break;
+	default:
+		__skb_queue_purge(&sk->sk_receive_queue);
+		break;
 	}
 }
 			return sock_intr_errno(*timeo_p);
 		add_wait_queue(sk_sleep(sk), &wait);
-		done = sk_wait_event(sk, timeo_p,
+		done = sk_wait_event(sk, timeo_p, tipc_sk_connected(sk),
-				     sk->sk_state != TIPC_CONNECTING, &wait);
+				     &wait);
 		remove_wait_queue(sk_sleep(sk), &wait);
 	} while (!done);
 	return 0;
 	 * Reject any stray messages received by new socket
 	 * before the socket lock was taken (very, very unlikely)
 	 */
-	tsk_rej_rx_queue(new_sk);
+	tsk_rej_rx_queue(new_sk, TIPC_ERR_NO_PORT);
 	/* Connect new socket to it's peer */
 	tipc_sk_finish_conn(new_tsock, msg_origport(msg), msg_orignode(msg));

samples/seccomp/user-trap.c+2−2

 		req = malloc(sizes.seccomp_notif);
 		if (!req)
 			goto out_close;
-		memset(req, 0, sizeof(*req));
 		resp = malloc(sizes.seccomp_notif_resp);
 		if (!resp)
 			goto out_req;
-		memset(resp, 0, sizeof(*resp));
+		memset(resp, 0, sizes.seccomp_notif_resp);
 		while (1) {
+			memset(req, 0, sizes.seccomp_notif);
 			if (ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, req)) {
 				perror("ioctl recv");
 				goto out_resp;

scripts/gcc-plugins/Kconfig+4−5

 	  An arch should select this symbol if it supports building with
 	  GCC plugins.
-config GCC_PLUGINS
+menuconfig GCC_PLUGINS
-	bool
+	bool "GCC plugins"
 	depends on HAVE_GCC_PLUGINS
 	depends on PLUGIN_HOSTCC != ""
 	default y
 	  See Documentation/core-api/gcc-plugins.rst for details.
-menu "GCC plugins"
+if GCC_PLUGINS
-	depends on GCC_PLUGINS
 config GCC_PLUGIN_CYC_COMPLEXITY
 	bool "Compute the cyclomatic complexity of a function" if EXPERT
 	bool
 	depends on GCC_PLUGINS && ARM
-endmenu
+endif

scripts/package/mkdebian+1−1

@@ -136,7 +136,7 @@ mkdir -p debian/source/ · 135 unmodified lines
136	echo "1.0" > debian/source/format	136	echo "1.0" > debian/source/format
137		137
138	echo $debarch > debian/arch	138	echo $debarch > debian/arch
139	extra_build_depends=", $(if_enabled_echo CONFIG_UNWINDER_ORC libelf-dev)"	139	extra_build_depends=", $(if_enabled_echo CONFIG_UNWINDER_ORC libelf-dev:native)"
140	extra_build_depends="$extra_build_depends, $(if_enabled_echo CONFIG_SYSTEM_TRUSTED_KEYRING libssl-dev:native)"	140	extra_build_depends="$extra_build_depends, $(if_enabled_echo CONFIG_SYSTEM_TRUSTED_KEYRING libssl-dev:native)"
141		141
142	# Generate a simple changelog template	142	# Generate a simple changelog template

security/apparmor/apparmorfs.c+1−1

@@ -623,7 +623,7 @@ static __poll_t ns_revision_poll(struct file file, poll_table pt) · 622 unmodified lines
623		623
624	void __aa_bump_ns_revision(struct aa_ns *ns)	624	void __aa_bump_ns_revision(struct aa_ns *ns)
625	{	625	{
626	ns->revision++;	626	WRITE_ONCE(ns->revision, ns->revision + 1);
627	wake_up_interruptible(&ns->wait);	627	wake_up_interruptible(&ns->wait);
628	}	628	}
629		629

security/apparmor/domain.c+43−39

@@ -317,6 +317,7 @@ static int aa_xattrs_match(const struct linux_binprm *bprm, · 316 unmodified lines
317		317
318	if (!bprm \|\| !profile->xattr_count)	318	if (!bprm \|\| !profile->xattr_count)
319	return 0;	319	return 0;
		320	might_sleep();
320		321
321	/* transition from exec match to xattr set */	322	/* transition from exec match to xattr set */
322	state = aa_dfa_null_transition(profile->xmatch, state);	323	state = aa_dfa_null_transition(profile->xmatch, state);
@@ -361,10 +362,11 @@ out: · 38 unmodified lines
361	}	362	}
362		363
363	/**	364	/**
364	* __attach_match_ - find an attachment match	365	* find_attach - do attachment search for unconfined processes
365	* @bprm - binprm structure of transitioning task	366	* @bprm - binprm structure of transitioning task
366	* @name - to match against (NOT NULL)	367	* @ns: the current namespace (NOT NULL)
367	* @head - profile list to walk (NOT NULL)	368	* @head - profile list to walk (NOT NULL)
		369	* @name - to match against (NOT NULL)
368	* @info - info message if there was an error (NOT NULL)	370	* @info - info message if there was an error (NOT NULL)
369	*	371	*
370	* Do a linear search on the profiles in the list. There is a matching	372	* Do a linear search on the profiles in the list. There is a matching
@@ -374,12 +376,11 @@ out: · 3 unmodified lines
374	*	376	*
375	* Requires: @head not be shared or have appropriate locks held	377	* Requires: @head not be shared or have appropriate locks held
376	*	378	*
377	* Returns: profile or NULL if no match found	379	* Returns: label or NULL if no match found
378	*/	380	*/
379	static struct aa_profile __attach_match(const struct linux_binprm bprm,	381	static struct aa_label find_attach(const struct linux_binprm bprm,
380	const char *name,	382	struct aa_ns ns, struct list_head head,
381	struct list_head *head,	383	const char name, const char *info)
382	const char **info)
383	{	384	{
384	int candidate_len = 0, candidate_xattrs = 0;	385	int candidate_len = 0, candidate_xattrs = 0;
385	bool conflict = false;	386	bool conflict = false;
@@ -388,6 +389,8 @@ static struct aa_profile __attach_match(const struct linux_binprm bprm, · 2 unmodified lines
388	AA_BUG(!name);	389	AA_BUG(!name);
389	AA_BUG(!head);	390	AA_BUG(!head);
390		391
		392	rcu_read_lock();
		393	restart:
391	list_for_each_entry_rcu(profile, head, base.list) {	394	list_for_each_entry_rcu(profile, head, base.list) {
392	if (profile->label.flags & FLAG_NULL &&	395	if (profile->label.flags & FLAG_NULL &&
393	&profile->label == ns_unconfined(profile->ns))	396	&profile->label == ns_unconfined(profile->ns))
@@ -413,16 +416,32 @@ static struct aa_profile __attach_match(const struct linux_binprm bprm, · 19 unmodified lines
413	perm = dfa_user_allow(profile->xmatch, state);	416	perm = dfa_user_allow(profile->xmatch, state);
414	/* any accepting state means a valid match. */	417	/* any accepting state means a valid match. */
415	if (perm & MAY_EXEC) {	418	if (perm & MAY_EXEC) {
416	int ret;	419	int ret = 0;
417		420
418	if (count < candidate_len)	421	if (count < candidate_len)
419	continue;	422	continue;
420		423
421	ret = aa_xattrs_match(bprm, profile, state);	424	if (bprm && profile->xattr_count) {
422	/* Fail matching if the xattrs don't match */	425	long rev = READ_ONCE(ns->revision);
423	if (ret < 0)	426
424	continue;	427	if (!aa_get_profile_not0(profile))
425		428	goto restart;
		429	rcu_read_unlock();
		430	ret = aa_xattrs_match(bprm, profile,
		431	state);
		432	rcu_read_lock();
		433	aa_put_profile(profile);
		434	if (rev !=
		435	READ_ONCE(ns->revision))
		436	/* policy changed */
		437	goto restart;
		438	/*
		439	* Fail matching if the xattrs don't
		440	* match
		441	*/
		442	if (ret < 0)
		443	continue;
		444	}
426	/*	445	/*
427	* TODO: allow for more flexible best match	446	* TODO: allow for more flexible best match
428	*	447	*
@@ -445,43 +464,28 @@ static struct aa_profile __attach_match(const struct linux_binprm bprm, · 16 unmodified lines
445	candidate_xattrs = ret;	464	candidate_xattrs = ret;
446	conflict = false;	465	conflict = false;
447	}	466	}
448	} else if (!strcmp(profile->base.name, name))	467	} else if (!strcmp(profile->base.name, name)) {
449	/*	468	/*
450	* old exact non-re match, without conditionals such	469	* old exact non-re match, without conditionals such
451	* as xattrs. no more searching required	470	* as xattrs. no more searching required
452	*/	471	*/
453	return profile;	472	candidate = profile;
		473	goto out;
		474	}
454	}	475	}
455		476
456	if (conflict) {	477	if (!candidate \|\| conflict) {
457	*info = "conflicting profile attachments";	478	if (conflict)
		479	*info = "conflicting profile attachments";
		480	rcu_read_unlock();
458	return NULL;	481	return NULL;
459	}	482	}
460		483
461	return candidate;	484	out:
462	}	485	candidate = aa_get_newest_profile(candidate);
463
464	/**
465	* find_attach - do attachment search for unconfined processes
466	* @bprm - binprm structure of transitioning task
467	* @ns: the current namespace (NOT NULL)
468	* @list: list to search (NOT NULL)
469	* @name: the executable name to match against (NOT NULL)
470	* @info: info message if there was an error
471	*
472	* Returns: label or NULL if no match found
473	*/
474	static struct aa_label find_attach(const struct linux_binprm bprm,
475	struct aa_ns ns, struct list_head list,
476	const char name, const char *info)
477	{
478	struct aa_profile *profile;
479
480	rcu_read_lock();
481	profile = aa_get_profile(__attach_match(bprm, name, list, info));
482	rcu_read_unlock();	486	rcu_read_unlock();
483		487
484	return profile ? &profile->label : NULL;	488	return &candidate->label;
485	}	489	}
486		490
487	static const char next_name(int xtype, const char name)	491	static const char next_name(int xtype, const char name)

security/apparmor/file.c+8−4

 	fctx = file_ctx(file);
 	rcu_read_lock();
-	flabel  = aa_get_newest_label(rcu_dereference(fctx->label));
+	flabel  = rcu_dereference(fctx->label);
-	rcu_read_unlock();
 	AA_BUG(!flabel);
 	/* revalidate access, if task is unconfined, or the cached cred
 	 */
 	denied = request & ~fctx->allow;
 	if (unconfined(label) || unconfined(flabel) ||
-	    (!denied && aa_label_is_subset(flabel, label)))
+	    (!denied && aa_label_is_subset(flabel, label))) {
+		rcu_read_unlock();
 		goto done;
+	}
+	flabel  = aa_get_newest_label(flabel);
+	rcu_read_unlock();
 	/* TODO: label cross check */
 	if (file->f_path.mnt && path_mediated_fs(file->f_path.dentry))
 	else if (S_ISSOCK(file_inode(file)->i_mode))
 		error = __file_sock_perm(op, label, flabel, file, request,
 					 denied);
-done:
 	aa_put_label(flabel);
+done:
 	return error;
 }

security/apparmor/mount.c+1−1

@@ -442,7 +442,7 @@ int aa_bind_mount(struct aa_label label, const struct path path, · 441 unmodified lines
442	buffer = aa_get_buffer(false);	442	buffer = aa_get_buffer(false);
443	old_buffer = aa_get_buffer(false);	443	old_buffer = aa_get_buffer(false);
444	error = -ENOMEM;	444	error = -ENOMEM;
445	if (!buffer \|\| old_buffer)	445	if (!buffer \|\| !old_buffer)
446	goto out;	446	goto out;
447		447
448	error = fn_for_each_confined(label, profile,	448	error = fn_for_each_confined(label, profile,

security/apparmor/policy.c+2−2

 	if (!name) {
 		/* remove namespace - can only happen if fqname[0] == ':' */
 		mutex_lock_nested(&ns->parent->lock, ns->level);
-		__aa_remove_ns(ns);
 		__aa_bump_ns_revision(ns);
+		__aa_remove_ns(ns);
 		mutex_unlock(&ns->parent->lock);
 	} else {
 		/* remove profile */
 			goto fail_ns_lock;
 		}
 		name = profile->base.hname;
+		__aa_bump_ns_revision(ns);
 		__remove_profile(profile);
 		__aa_labelset_update_subtree(ns);
-		__aa_bump_ns_revision(ns);
 		mutex_unlock(&ns->lock);
 	}

security/tomoyo/common.c+6−3

 	exe = tomoyo_get_exe();
 	if (!exe)
 		return false;
-	list_for_each_entry_rcu(ptr, &tomoyo_kernel_namespace.policy_list[TOMOYO_ID_MANAGER], head.list) {
+	list_for_each_entry_rcu(ptr, &tomoyo_kernel_namespace.policy_list[TOMOYO_ID_MANAGER], head.list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (!ptr->head.is_deleted &&
 		    (!tomoyo_pathcmp(domainname, ptr->manager) ||
 		     !strcmp(exe, ptr->manager->name))) {
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		return -EINTR;
 	/* Is there an active domain? */
-	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
+	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		/* Never delete tomoyo_kernel_domain */
 		if (domain == &tomoyo_kernel_domain)
 			continue;
 	tomoyo_policy_loaded = true;
 	pr_info("TOMOYO: 2.6.0\n");
-	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
+	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		const u8 profile = domain->profile;
 		struct tomoyo_policy_namespace *ns = domain->ns;

security/tomoyo/domain.c+10−5

 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		return -ENOMEM;
-	list_for_each_entry_rcu(entry, list, list) {
+	list_for_each_entry_rcu(entry, list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (entry->is_deleted == TOMOYO_GC_IN_PROGRESS)
 			continue;
 		if (!check_duplicate(entry, new_entry))
 	}
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		goto out;
-	list_for_each_entry_rcu(entry, list, list) {
+	list_for_each_entry_rcu(entry, list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (entry->is_deleted == TOMOYO_GC_IN_PROGRESS)
 			continue;
 		if (!tomoyo_same_acl_head(entry, new_entry) ||
 	u16 i = 0;
 retry:
-	list_for_each_entry_rcu(ptr, list, list) {
+	list_for_each_entry_rcu(ptr, list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (ptr->is_deleted || ptr->type != r->param_type)
 			continue;
 		if (!check_entry(r, ptr))
 {
 	const struct tomoyo_transition_control *ptr;
-	list_for_each_entry_rcu(ptr, list, head.list) {
+	list_for_each_entry_rcu(ptr, list, head.list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (ptr->head.is_deleted || ptr->type != type)
 			continue;
 		if (ptr->domainname) {
 		/* Check 'aggregator' directive. */
 		candidate = &exename;
-		list_for_each_entry_rcu(ptr, list, head.list) {
+		list_for_each_entry_rcu(ptr, list, head.list,
+					srcu_read_lock_held(&tomoyo_ss)) {
 			if (ptr->head.is_deleted ||
 			    !tomoyo_path_matches_pattern(&exename,
 							 ptr->original_name))

security/tomoyo/group.c+6−3

 {
 	struct tomoyo_path_group *member;
-	list_for_each_entry_rcu(member, &group->member_list, head.list) {
+	list_for_each_entry_rcu(member, &group->member_list, head.list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (member->head.is_deleted)
 			continue;
 		if (!tomoyo_path_matches_pattern(pathname, member->member_name))
 	struct tomoyo_number_group *member;
 	bool matched = false;
-	list_for_each_entry_rcu(member, &group->member_list, head.list) {
+	list_for_each_entry_rcu(member, &group->member_list, head.list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (member->head.is_deleted)
 			continue;
 		if (min > member->number.values[1] ||
 	bool matched = false;
 	const u8 size = is_ipv6 ? 16 : 4;
-	list_for_each_entry_rcu(member, &group->member_list, head.list) {
+	list_for_each_entry_rcu(member, &group->member_list, head.list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (member->head.is_deleted)
 			continue;
 		if (member->address.is_ipv6 != is_ipv6)

security/tomoyo/realpath.c+1−31

@@ -217,31 +217,6 @@ out: · 216 unmodified lines
217	return ERR_PTR(-ENOMEM);	217	return ERR_PTR(-ENOMEM);
218	}	218	}
219		219
220	/**
221	* tomoyo_get_socket_name - Get the name of a socket.
222	*
223	* @path: Pointer to "struct path".
224	* @buffer: Pointer to buffer to return value in.
225	* @buflen: Sizeof @buffer.
226	*
227	* Returns the buffer.
228	*/
229	static char tomoyo_get_socket_name(const struct path path, char * const buffer,
230	const int buflen)
231	{
232	struct inode *inode = d_backing_inode(path->dentry);
233	struct socket *sock = inode ? SOCKET_I(inode) : NULL;
234	struct sock *sk = sock ? sock->sk : NULL;
235
236	if (sk) {
237	snprintf(buffer, buflen, "socket:[family=%u:type=%u:protocol=%u]",
238	sk->sk_family, sk->sk_type, sk->sk_protocol);
239	} else {
240	snprintf(buffer, buflen, "socket:[unknown]");
241	}
242	return buffer;
243	}
244
245	/**	220	/**
246	* tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.	221	* tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
247	*	222	*
@@ -279,12 +254,7 @@ char tomoyo_realpath_from_path(const struct path path) · 31 unmodified lines
279	break;	254	break;
280	/* To make sure that pos is '\0' terminated. */	255	/* To make sure that pos is '\0' terminated. */
281	buf[buf_len - 1] = '\0';	256	buf[buf_len - 1] = '\0';
282	/* Get better name for socket. */	257	/* For "pipe:[\$]" and "socket:[\$]". */
283	if (sb->s_magic == SOCKFS_MAGIC) {
284	pos = tomoyo_get_socket_name(path, buf, buf_len - 1);
285	goto encode;
286	}
287	/* For "pipe:[\$]". */
288	if (dentry->d_op && dentry->d_op->d_dname) {	258	if (dentry->d_op && dentry->d_op->d_dname) {
289	pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);	259	pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
290	goto encode;	260	goto encode;

security/tomoyo/util.c+4−2

 	name.name = domainname;
 	tomoyo_fill_path_info(&name);
-	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
+	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		if (!domain->is_deleted &&
 		    !tomoyo_pathcmp(&name, domain->domainname))
 			return domain;
 		return false;
 	if (!domain)
 		return true;
-	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
+	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list,
+				srcu_read_lock_held(&tomoyo_ss)) {
 		u16 perm;
 		u8 i;

sound/hda/hdac_regmap.c+0−1

@@ -363,7 +363,6 @@ static const struct regmap_config hda_regmap_cfg = { · 362 unmodified lines
363	.reg_write = hda_reg_write,	363	.reg_write = hda_reg_write,
364	.use_single_read = true,	364	.use_single_read = true,
365	.use_single_write = true,	365	.use_single_write = true,
366	.disable_locking = true,
367	};	366	};
368		367
369	/**	368	/**

sound/pci/hda/hda_intel.c+16−5

 /* quirks for old Intel chipsets */
 #define AZX_DCAPS_INTEL_ICH \
-	(AZX_DCAPS_OLD_SSYNC | AZX_DCAPS_NO_ALIGN_BUFSIZE)
+	(AZX_DCAPS_OLD_SSYNC | AZX_DCAPS_NO_ALIGN_BUFSIZE |\
+	 AZX_DCAPS_SYNC_WRITE)
 /* quirks for Intel PCH */
 #define AZX_DCAPS_INTEL_PCH_BASE \
 	(AZX_DCAPS_NO_ALIGN_BUFSIZE | AZX_DCAPS_COUNT_LPIB_DELAY |\
-	 AZX_DCAPS_SNOOP_TYPE(SCH))
+	 AZX_DCAPS_SNOOP_TYPE(SCH) | AZX_DCAPS_SYNC_WRITE)
 /* PCH up to IVB; no runtime PM; bind with i915 gfx */
 #define AZX_DCAPS_INTEL_PCH_NOPM \
 #define AZX_DCAPS_INTEL_HASWELL \
 	(/*AZX_DCAPS_ALIGN_BUFSIZE |*/ AZX_DCAPS_COUNT_LPIB_DELAY |\
 	 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_COMPONENT |\
-	 AZX_DCAPS_SNOOP_TYPE(SCH))
+	 AZX_DCAPS_SNOOP_TYPE(SCH) | AZX_DCAPS_SYNC_WRITE)
 /* Broadwell HDMI can't use position buffer reliably, force to use LPIB */
 #define AZX_DCAPS_INTEL_BROADWELL \
 	(/*AZX_DCAPS_ALIGN_BUFSIZE |*/ AZX_DCAPS_POSFIX_LPIB |\
 	 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_COMPONENT |\
-	 AZX_DCAPS_SNOOP_TYPE(SCH))
+	 AZX_DCAPS_SNOOP_TYPE(SCH) | AZX_DCAPS_SYNC_WRITE)
 #define AZX_DCAPS_INTEL_BAYTRAIL \
 	(AZX_DCAPS_INTEL_PCH_BASE | AZX_DCAPS_I915_COMPONENT)
 	acpi_handle dhandle, atpx_handle;
 	acpi_status status;
-	while ((pdev = pci_get_class(PCI_BASE_CLASS_DISPLAY << 16, pdev)) != NULL) {
+	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
+		dhandle = ACPI_HANDLE(&pdev->dev);
+		if (dhandle) {
+			status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);
+			if (!ACPI_FAILURE(status)) {
+				pci_dev_put(pdev);
+				return true;
+			}
+		}
+	}
+	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) {
 		dhandle = ACPI_HANDLE(&pdev->dev);
 		if (dhandle) {
 			status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);

sound/pci/hda/patch_realtek.c+36−13

 	case 0x10ec0672:
 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 		break;
+	case 0x10ec0222:
 	case 0x10ec0623:
 		alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 		break;
 		break;
 	case 0x10ec0899:
 	case 0x10ec0900:
+	case 0x10ec0b00:
 	case 0x10ec1168:
 	case 0x10ec1220:
 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 	struct alc_spec *spec = codec->spec;
 	switch (codec->core.vendor_id) {
+	case 0x10ec0283:
 	case 0x10ec0286:
 	case 0x10ec0288:
 	case 0x10ec0298:
 	case 0x10ec0882:
 	case 0x10ec0885:
 	case 0x10ec0900:
+	case 0x10ec0b00:
 	case 0x10ec1220:
 		break;
 	default:
 	ALC256_FIXUP_ASUS_HEADSET_MIC,
 	ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
 	ALC299_FIXUP_PREDATOR_SPK,
-	ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC,
 	ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
-	ALC294_FIXUP_ASUS_INTSPK_GPIO,
+	ALC289_FIXUP_DELL_SPK2,
+	ALC289_FIXUP_DUAL_SPK,
+	ALC294_FIXUP_SPK2_TO_DAC1,
+	ALC294_FIXUP_ASUS_DUAL_SPK,
 };
 static const struct hda_fixup alc269_fixups[] = {
 			{ }
 		}
 	},
-	[ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC] = {
+	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
-			{ 0x14, 0x411111f0 }, /* disable confusing internal speaker */
+			{ 0x19, 0x04a11040 },
-			{ 0x19, 0x04a11150 }, /* use as headset mic, without its own jack detect */
+			{ 0x21, 0x04211020 },
 			{ }
 		},
 		.chained = true,
-		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
+		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
 	},
-	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
+	[ALC289_FIXUP_DELL_SPK2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
-			{ 0x19, 0x04a11040 },
+			{ 0x17, 0x90170130 }, /* bass spk */
-			{ 0x21, 0x04211020 },
 			{ }
 		},
 		.chained = true,
-		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
+		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
 	},
-	[ALC294_FIXUP_ASUS_INTSPK_GPIO] = {
+	[ALC289_FIXUP_DUAL_SPK] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc285_fixup_speaker2_to_dac1,
+		.chained = true,
+		.chain_id = ALC289_FIXUP_DELL_SPK2
+	},
+	[ALC294_FIXUP_SPK2_TO_DAC1] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc285_fixup_speaker2_to_dac1,
+		.chained = true,
+		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
+	},
+	[ALC294_FIXUP_ASUS_DUAL_SPK] = {
 		.type = HDA_FIXUP_FUNC,
 		/* The GPIO must be pulled to initialize the AMP */
 		.v.func = alc_fixup_gpio4,
 		.chained = true,
-		.chain_id = ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC
+		.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
 	},
 };
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
+	SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
+	SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
-	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_INTSPK_GPIO),
+	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
 	SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
 	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
+	SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Yoga 7th", ALC285_FIXUP_SPEAKER2_TO_DAC1),
 	SND_PCI_QUIRK(0x17aa, 0x2293, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_SPEAKER2_TO_DAC1),
 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
+	HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
 	{} /* terminator */

sound/pci/ice1712/ice1724.c+6−3

 	unsigned long flags;
 	unsigned char mclk_change;
 	unsigned int i, old_rate;
+	bool call_set_rate = false;
 	if (rate > ice->hw_rates->list[ice->hw_rates->count - 1])
 		return -EINVAL;
 		 * setting clock rate for internal clock mode */
 		old_rate = ice->get_rate(ice);
 		if (force || (old_rate != rate))
-			ice->set_rate(ice, rate);
+			call_set_rate = true;
 		else if (rate == ice->cur_rate) {
 			spin_unlock_irqrestore(&ice->reg_lock, flags);
 			return 0;
 	}
 	ice->cur_rate = rate;
+	spin_unlock_irqrestore(&ice->reg_lock, flags);
+	if (call_set_rate)
+		ice->set_rate(ice, rate);
 	/* setting master clock */
 	mclk_change = ice->set_mclk(ice, rate);
-	spin_unlock_irqrestore(&ice->reg_lock, flags);
 	if (mclk_change && ice->gpio.i2s_mclk_changed)
 		ice->gpio.i2s_mclk_changed(ice);
 	if (ice->gpio.set_pro_rate)

sound/soc/fsl/fsl_audmix.c+8−1

 					      ARRAY_SIZE(fsl_audmix_dai));
 	if (ret) {
 		dev_err(dev, "failed to register ASoC DAI\n");
-		return ret;
+		goto err_disable_pm;
 	}
 	priv->pdev = platform_device_register_data(dev, mdrv, 0, NULL, 0);
 	if (IS_ERR(priv->pdev)) {
 		ret = PTR_ERR(priv->pdev);
 		dev_err(dev, "failed to register platform %s: %d\n", mdrv, ret);
+		goto err_disable_pm;
 	}
+	return 0;
+err_disable_pm:
+	pm_runtime_disable(dev);
 	return ret;
 }
 {
 	struct fsl_audmix *priv = dev_get_drvdata(&pdev->dev);
+	pm_runtime_disable(&pdev->dev);
 	if (priv->pdev)
 		platform_device_unregister(priv->pdev);

sound/soc/intel/boards/cml_rt1011_rt5682.c+0−1

@@ -11,7 +11,6 @@ · 10 unmodified lines
11	#include <linux/clk.h>	11	#include <linux/clk.h>
12	#include <linux/dmi.h>	12	#include <linux/dmi.h>
13	#include <linux/slab.h>	13	#include <linux/slab.h>
14	#include <asm/cpu_device_id.h>
15	#include <linux/acpi.h>	14	#include <linux/acpi.h>
16	#include <sound/core.h>	15	#include <sound/core.h>
17	#include <sound/jack.h>	16	#include <sound/jack.h>

sound/soc/soc-core.c+8−6

 		goto free_rtd;
 	rtd->dev = dev;
+	INIT_LIST_HEAD(&rtd->list);
+	INIT_LIST_HEAD(&rtd->component_list);
+	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
+	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
+	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
+	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
 	dev_set_drvdata(dev, rtd);
 	INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
 	/*
 	 * rtd remaining settings
 	 */
-	INIT_LIST_HEAD(&rtd->component_list);
-	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
-	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
-	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
-	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
 	rtd->card = card;
 	rtd->dai_link = dai_link;
 	if (!rtd->dai_link->ops)
 			/* convert non BE into BE */
 			dai_link->no_pcm = 1;
+			dai_link->dpcm_playback = 1;
+			dai_link->dpcm_capture = 1;
 			/* override any BE fixups */
 			dai_link->be_hw_params_fixup =

sound/soc/soc-topology.c+3−3

 	if (dobj->ops && dobj->ops->link_unload)
 		dobj->ops->link_unload(comp, dobj);
+	list_del(&dobj->list);
+	snd_soc_remove_dai_link(comp->card, link);
 	kfree(link->name);
 	kfree(link->stream_name);
 	kfree(link->cpus->dai_name);
-	list_del(&dobj->list);
-	snd_soc_remove_dai_link(comp->card, link);
 	kfree(link);
 }

sound/soc/sof/imx/imx8.c+4−1

 	priv->pd_dev = devm_kmalloc_array(&pdev->dev, priv->num_domains,
 					  sizeof(*priv->pd_dev), GFP_KERNEL);
-	if (!priv)
+	if (!priv->pd_dev)
 		return -ENOMEM;
 	priv->link = devm_kmalloc_array(&pdev->dev, priv->num_domains,
 	}
 	sdev->mailbox_bar = SOF_FW_BLK_TYPE_SRAM;
+	/* set default mailbox offset for FW ready message */
+	sdev->dsp_box.offset = MBOX_OFFSET;
 	return 0;
 exit_pdev_unregister:

sound/soc/sof/intel/hda-dai.c+9−2

 		link_dev = hda_link_stream_assign(bus, substream);
 		if (!link_dev)
 			return -EBUSY;
+		snd_soc_dai_set_dma_data(dai, substream, (void *)link_dev);
 	}
 	stream_tag = hdac_stream(link_dev)->stream_tag;
 	if (ret < 0)
 		return ret;
-	snd_soc_dai_set_dma_data(dai, substream, (void *)link_dev);
 	link = snd_hdac_ext_bus_get_link(bus, codec_dai->component->name);
 	if (!link)
 		return -EINVAL;
 	bus = hstream->bus;
 	rtd = snd_pcm_substream_chip(substream);
 	link_dev = snd_soc_dai_get_dma_data(dai, substream);
+	if (!link_dev) {
+		dev_dbg(dai->dev,
+			"%s: link_dev is not assigned\n", __func__);
+		return -EINVAL;
+	}
 	hda_stream = hstream_to_sof_hda_stream(link_dev);
 	/* free the link DMA channel in the FW */

sound/soc/sof/ipc.c+3−0

@@ -826,6 +826,9 @@ void snd_sof_ipc_free(struct snd_sof_dev *sdev) · 825 unmodified lines
826	{	826	{
827	struct snd_sof_ipc *ipc = sdev->ipc;	827	struct snd_sof_ipc *ipc = sdev->ipc;
828		828
		829	if (!ipc)
		830	return;
		831
829	/* disable sending of ipc's */	832	/* disable sending of ipc's */
830	mutex_lock(&ipc->tx_mutex);	833	mutex_lock(&ipc->tx_mutex);
831	ipc->disable_ipc_tx = true;	834	ipc->disable_ipc_tx = true;

sound/soc/stm/stm32_spdifrx.c+26−14

 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/of_platform.h>
-#include <linux/pinctrl/consumer.h>
 #include <linux/regmap.h>
 #include <linux/reset.h>
  * @slave_config: dma slave channel runtime config pointer
  * @phys_addr: SPDIFRX registers physical base address
  * @lock: synchronization enabling lock
+ * @irq_lock: prevent race condition with IRQ on stream state
  * @cs: channel status buffer
  * @ub: user data buffer
  * @irq: SPDIFRX interrupt line
 	struct dma_slave_config slave_config;
 	dma_addr_t phys_addr;
 	spinlock_t lock;  /* Sync enabling lock */
+	spinlock_t irq_lock; /* Prevent race condition on stream state */
 	unsigned char cs[SPDIFRX_CS_BYTES_NB];
 	unsigned char ub[SPDIFRX_UB_BYTES_NB];
 	int irq;
 static int stm32_spdifrx_start_sync(struct stm32_spdifrx_data *spdifrx)
 {
 	int cr, cr_mask, imr, ret;
+	unsigned long flags;
 	/* Enable IRQs */
 	imr = SPDIFRX_IMR_IFEIE | SPDIFRX_IMR_SYNCDIE | SPDIFRX_IMR_PERRIE;
 	if (ret)
 		return ret;
-	spin_lock(&spdifrx->lock);
+	spin_lock_irqsave(&spdifrx->lock, flags);
 	spdifrx->refcount++;
 				"Failed to start synchronization\n");
 	}
-	spin_unlock(&spdifrx->lock);
+	spin_unlock_irqrestore(&spdifrx->lock, flags);
 	return ret;
 }
 static void stm32_spdifrx_stop(struct stm32_spdifrx_data *spdifrx)
 {
 	int cr, cr_mask, reg;
+	unsigned long flags;
-	spin_lock(&spdifrx->lock);
+	spin_lock_irqsave(&spdifrx->lock, flags);
 	if (--spdifrx->refcount) {
-		spin_unlock(&spdifrx->lock);
+		spin_unlock_irqrestore(&spdifrx->lock, flags);
 		return;
 	}
 	regmap_read(spdifrx->regmap, STM32_SPDIFRX_DR, &reg);
 	regmap_read(spdifrx->regmap, STM32_SPDIFRX_CSR, &reg);
-	spin_unlock(&spdifrx->lock);
+	spin_unlock_irqrestore(&spdifrx->lock, flags);
 }
 static int stm32_spdifrx_dma_ctrl_register(struct device *dev,
 	memset(spdifrx->cs, 0, SPDIFRX_CS_BYTES_NB);
 	memset(spdifrx->ub, 0, SPDIFRX_UB_BYTES_NB);
-	pinctrl_pm_select_default_state(&spdifrx->pdev->dev);
 	ret = stm32_spdifrx_dma_ctrl_start(spdifrx);
 	if (ret < 0)
 		return ret;
 end:
 	clk_disable_unprepare(spdifrx->kclk);
-	pinctrl_pm_select_sleep_state(&spdifrx->pdev->dev);
 	return ret;
 }
 static irqreturn_t stm32_spdifrx_isr(int irq, void *devid)
 {
 	struct stm32_spdifrx_data *spdifrx = (struct stm32_spdifrx_data *)devid;
-	struct snd_pcm_substream *substream = spdifrx->substream;
 	struct platform_device *pdev = spdifrx->pdev;
 	unsigned int cr, mask, sr, imr;
 	unsigned int flags, sync_state;
 			return IRQ_HANDLED;
 		}
-		if (substream)
+		spin_lock(&spdifrx->irq_lock);
-			snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
+		if (spdifrx->substream)
+			snd_pcm_stop(spdifrx->substream,
+				     SNDRV_PCM_STATE_DISCONNECTED);
+		spin_unlock(&spdifrx->irq_lock);
 		return IRQ_HANDLED;
 	}
-	if (err_xrun && substream)
+	spin_lock(&spdifrx->irq_lock);
-		snd_pcm_stop_xrun(substream);
+	if (err_xrun && spdifrx->substream)
+		snd_pcm_stop_xrun(spdifrx->substream);
+	spin_unlock(&spdifrx->irq_lock);
 	return IRQ_HANDLED;
 }
 				 struct snd_soc_dai *cpu_dai)
 {
 	struct stm32_spdifrx_data *spdifrx = snd_soc_dai_get_drvdata(cpu_dai);
+	unsigned long flags;
 	int ret;
+	spin_lock_irqsave(&spdifrx->irq_lock, flags);
 	spdifrx->substream = substream;
+	spin_unlock_irqrestore(&spdifrx->irq_lock, flags);
 	ret = clk_prepare_enable(spdifrx->kclk);
 	if (ret)
 				   struct snd_soc_dai *cpu_dai)
 {
 	struct stm32_spdifrx_data *spdifrx = snd_soc_dai_get_drvdata(cpu_dai);
+	unsigned long flags;
+	spin_lock_irqsave(&spdifrx->irq_lock, flags);
 	spdifrx->substream = NULL;
+	spin_unlock_irqrestore(&spdifrx->irq_lock, flags);
 	clk_disable_unprepare(spdifrx->kclk);
 }
 	spdifrx->pdev = pdev;
 	init_completion(&spdifrx->cs_completion);
 	spin_lock_init(&spdifrx->lock);
+	spin_lock_init(&spdifrx->irq_lock);
 	platform_set_drvdata(pdev, spdifrx);

sound/usb/card.h+1−0

@@ -145,6 +145,7 @@ struct snd_usb_substream { · 144 unmodified lines
145	struct snd_usb_endpoint *sync_endpoint;	145	struct snd_usb_endpoint *sync_endpoint;
146	unsigned long flags;	146	unsigned long flags;
147	bool need_setup_ep; /* (re)configure EP at prepare? */	147	bool need_setup_ep; /* (re)configure EP at prepare? */
		148	bool need_setup_fmt; /* (re)configure fmt after resume? */
148	unsigned int speed; /* USB_SPEED_XXX */	149	unsigned int speed; /* USB_SPEED_XXX */
149		150
150	u64 formats; /* format bitmasks (all or'ed) */	151	u64 formats; /* format bitmasks (all or'ed) */

sound/usb/pcm.c+21−4

 	if (WARN_ON(!iface))
 		return -EINVAL;
 	alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
-	altsd = get_iface_desc(alts);
+	if (WARN_ON(!alts))
-	if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
 		return -EINVAL;
+	altsd = get_iface_desc(alts);
-	if (fmt == subs->cur_audiofmt)
+	if (fmt == subs->cur_audiofmt && !subs->need_setup_fmt)
 		return 0;
 	/* close the old interface */
-	if (subs->interface >= 0 && subs->interface != fmt->iface) {
+	if (subs->interface >= 0 && (subs->interface != fmt->iface || subs->need_setup_fmt)) {
 		if (!subs->stream->chip->keep_iface) {
 			err = usb_set_interface(subs->dev, subs->interface, 0);
 			if (err < 0) {
 		subs->altset_idx = 0;
 	}
+	if (subs->need_setup_fmt)
+		subs->need_setup_fmt = false;
 	/* set interface */
 	if (iface->cur_altsetting != alts) {
 		err = snd_usb_select_mode_quirk(subs, fmt);
 		subs->data_endpoint->retire_data_urb = retire_playback_urb;
 		subs->running = 0;
 		return 0;
+	case SNDRV_PCM_TRIGGER_SUSPEND:
+		if (subs->stream->chip->setup_fmt_after_resume_quirk) {
+			stop_endpoints(subs, true);
+			subs->need_setup_fmt = true;
+			return 0;
+		}
+		break;
 	}
 	return -EINVAL;
 		subs->data_endpoint->retire_data_urb = retire_capture_urb;
 		subs->running = 1;
 		return 0;
+	case SNDRV_PCM_TRIGGER_SUSPEND:
+		if (subs->stream->chip->setup_fmt_after_resume_quirk) {
+			stop_endpoints(subs, true);
+			subs->need_setup_fmt = true;
+			return 0;
+		}
+		break;
 	}
 	return -EINVAL;

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

 		.vendor_name = "Dell",
 		.product_name = "WD19 Dock",
 		.profile_name = "Dell-WD15-Dock",
-		.ifnum = QUIRK_NO_INTERFACE
+		.ifnum = QUIRK_ANY_INTERFACE,
+		.type = QUIRK_SETUP_FMT_AFTER_RESUME
 	}
 },
 /* MOTU Microbook II */

sound/usb/quirks.c+12−0

 	return snd_usb_create_mixer(chip, quirk->ifnum, 0);
 }
+static int setup_fmt_after_resume_quirk(struct snd_usb_audio *chip,
+				       struct usb_interface *iface,
+				       struct usb_driver *driver,
+				       const struct snd_usb_audio_quirk *quirk)
+{
+	chip->setup_fmt_after_resume_quirk = 1;
+	return 1;	/* Continue with creating streams and mixer */
+}
 /*
  * audio-interface quirks
  *
 		[QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
 		[QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
 		[QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
+		[QUIRK_SETUP_FMT_AFTER_RESUME] = setup_fmt_after_resume_quirk,
 	};
 	if (quirk->type < QUIRK_TYPE_COUNT) {
 	case USB_ID(0x04D8, 0xFEEA): /* Benchmark DAC1 Pre */
 	case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
 	case USB_ID(0x05A3, 0x9420): /* ELP HD USB Camera */
+	case USB_ID(0x05a7, 0x1020): /* Bose Companion 5 */
 	case USB_ID(0x074D, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
 	case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
 	case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */

sound/usb/usbaudio.h+2−1

@@ -33,7 +33,7 @@ struct snd_usb_audio { · 32 unmodified lines
33	wait_queue_head_t shutdown_wait;	33	wait_queue_head_t shutdown_wait;
34	unsigned int txfr_quirk:1; /* Subframe boundaries on transfers */	34	unsigned int txfr_quirk:1; /* Subframe boundaries on transfers */
35	unsigned int tx_length_quirk:1; /* Put length specifier in transfers */	35	unsigned int tx_length_quirk:1; /* Put length specifier in transfers */
36		36	unsigned int setup_fmt_after_resume_quirk:1; /* setup the format to interface after resume */
37	int num_interfaces;	37	int num_interfaces;
38	int num_suspended_intf;	38	int num_suspended_intf;
39	int sample_rate_read_error;	39	int sample_rate_read_error;
@@ -98,6 +98,7 @@ enum quirk_type { · 58 unmodified lines
98	QUIRK_AUDIO_EDIROL_UAXX,	98	QUIRK_AUDIO_EDIROL_UAXX,
99	QUIRK_AUDIO_ALIGN_TRANSFER,	99	QUIRK_AUDIO_ALIGN_TRANSFER,
100	QUIRK_AUDIO_STANDARD_MIXER,	100	QUIRK_AUDIO_STANDARD_MIXER,
		101	QUIRK_SETUP_FMT_AFTER_RESUME,
101		102
102	QUIRK_TYPE_COUNT	103	QUIRK_TYPE_COUNT
103	};	104	};

tools/lib/bpf/Makefile+8−7

 BPF_IN_SHARED	:= $(SHARED_OBJDIR)libbpf-in.o
 BPF_IN_STATIC	:= $(STATIC_OBJDIR)libbpf-in.o
 VERSION_SCRIPT	:= libbpf.map
+BPF_HELPER_DEFS	:= $(OUTPUT)bpf_helper_defs.h
 LIB_TARGET	:= $(addprefix $(OUTPUT),$(LIB_TARGET))
 LIB_FILE	:= $(addprefix $(OUTPUT),$(LIB_FILE))
 all_cmd: $(CMD_TARGETS) check
-$(BPF_IN_SHARED): force elfdep bpfdep bpf_helper_defs.h
+$(BPF_IN_SHARED): force elfdep bpfdep $(BPF_HELPER_DEFS)
 	@(test -f ../../include/uapi/linux/bpf.h -a -f ../../../include/uapi/linux/bpf.h && ( \
 	(diff -B ../../include/uapi/linux/bpf.h ../../../include/uapi/linux/bpf.h >/dev/null) || \
 	echo "Warning: Kernel ABI header at 'tools/include/uapi/linux/bpf.h' differs from latest version at 'include/uapi/linux/bpf.h'" >&2 )) || true
 	echo "Warning: Kernel ABI header at 'tools/include/uapi/linux/if_xdp.h' differs from latest version at 'include/uapi/linux/if_xdp.h'" >&2 )) || true
 	$(Q)$(MAKE) $(build)=libbpf OUTPUT=$(SHARED_OBJDIR) CFLAGS="$(CFLAGS) $(SHLIB_FLAGS)"
-$(BPF_IN_STATIC): force elfdep bpfdep bpf_helper_defs.h
+$(BPF_IN_STATIC): force elfdep bpfdep $(BPF_HELPER_DEFS)
 	$(Q)$(MAKE) $(build)=libbpf OUTPUT=$(STATIC_OBJDIR)
-bpf_helper_defs.h: $(srctree)/tools/include/uapi/linux/bpf.h
+$(BPF_HELPER_DEFS): $(srctree)/tools/include/uapi/linux/bpf.h
 	$(Q)$(srctree)/scripts/bpf_helpers_doc.py --header 		\
-		--file $(srctree)/tools/include/uapi/linux/bpf.h > bpf_helper_defs.h
+		--file $(srctree)/tools/include/uapi/linux/bpf.h > $(BPF_HELPER_DEFS)
 $(OUTPUT)libbpf.so: $(OUTPUT)libbpf.so.$(LIBBPF_VERSION)
 		$(call do_install_mkdir,$(libdir_SQ)); \
 		cp -fpR $(LIB_FILE) $(DESTDIR)$(libdir_SQ)
-install_headers: bpf_helper_defs.h
+install_headers: $(BPF_HELPER_DEFS)
 	$(call QUIET_INSTALL, headers) \
 		$(call do_install,bpf.h,$(prefix)/include/bpf,644); \
 		$(call do_install,libbpf.h,$(prefix)/include/bpf,644); \
 		$(call do_install,libbpf_util.h,$(prefix)/include/bpf,644); \
 		$(call do_install,xsk.h,$(prefix)/include/bpf,644); \
 		$(call do_install,bpf_helpers.h,$(prefix)/include/bpf,644); \
-		$(call do_install,bpf_helper_defs.h,$(prefix)/include/bpf,644); \
+		$(call do_install,$(BPF_HELPER_DEFS),$(prefix)/include/bpf,644); \
 		$(call do_install,bpf_tracing.h,$(prefix)/include/bpf,644); \
 		$(call do_install,bpf_endian.h,$(prefix)/include/bpf,644); \
 		$(call do_install,bpf_core_read.h,$(prefix)/include/bpf,644);
 clean:
 	$(call QUIET_CLEAN, libbpf) $(RM) -rf $(CMD_TARGETS) \
 		*.o *~ *.a *.so *.so.$(LIBBPF_MAJOR_VERSION) .*.d .*.cmd \
-		*.pc LIBBPF-CFLAGS bpf_helper_defs.h \
+		*.pc LIBBPF-CFLAGS $(BPF_HELPER_DEFS) \
 		$(SHARED_OBJDIR) $(STATIC_OBJDIR)
 	$(call QUIET_CLEAN, core-gen) $(RM) $(OUTPUT)FEATURE-DUMP.libbpf

tools/testing/kunit/kunit.py+11−7

 	TEST_FAILURE = auto()
 def create_default_kunitconfig():
-	if not os.path.exists(kunit_kernel.KUNITCONFIG_PATH):
+	if not os.path.exists(kunit_kernel.kunitconfig_path):
 		shutil.copyfile('arch/um/configs/kunit_defconfig',
-				kunit_kernel.KUNITCONFIG_PATH)
+				kunit_kernel.kunitconfig_path)
 def run_tests(linux: kunit_kernel.LinuxSourceTree,
 	      request: KunitRequest) -> KunitResult:
-	if request.defconfig:
-		create_default_kunitconfig()
 	config_start = time.time()
 	success = linux.build_reconfig(request.build_dir)
 	config_end = time.time()
 	run_parser.add_argument('--build_dir',
 				help='As in the make command, it specifies the build '
 				'directory.',
-				type=str, default=None, metavar='build_dir')
+				type=str, default='', metavar='build_dir')
 	run_parser.add_argument('--defconfig',
-				help='Uses a default kunitconfig.',
+				help='Uses a default .kunitconfig.',
 				action='store_true')
 	cli_args = parser.parse_args(argv)
 	if cli_args.subcommand == 'run':
+		if cli_args.build_dir:
+			if not os.path.exists(cli_args.build_dir):
+				os.mkdir(cli_args.build_dir)
+			kunit_kernel.kunitconfig_path = os.path.join(
+				cli_args.build_dir,
+				kunit_kernel.kunitconfig_path)
 		if cli_args.defconfig:
 			create_default_kunitconfig()

tools/testing/kunit/kunit_kernel.py+5−5

@@ -14,7 +14,7 @@ import os · 13 unmodified lines
14	import kunit_config	14	import kunit_config
15		15
16	KCONFIG_PATH = '.config'	16	KCONFIG_PATH = '.config'
17	KUNITCONFIG_PATH = 'kunitconfig'	17	kunitconfig_path = '.kunitconfig'
18		18
19	class ConfigError(Exception):	19	class ConfigError(Exception):
20	"""Represents an error trying to configure the Linux kernel."""	20	"""Represents an error trying to configure the Linux kernel."""
@@ -82,7 +82,7 @@ class LinuxSourceTree(object): · 61 unmodified lines
82		82
83	def __init__(self):	83	def __init__(self):
84	self._kconfig = kunit_config.Kconfig()	84	self._kconfig = kunit_config.Kconfig()
85	self._kconfig.read_from_file(KUNITCONFIG_PATH)	85	self._kconfig.read_from_file(kunitconfig_path)
86	self._ops = LinuxSourceTreeOperations()	86	self._ops = LinuxSourceTreeOperations()
87		87
88	def clean(self):	88	def clean(self):
@@ -111,7 +111,7 @@ class LinuxSourceTree(object): · 22 unmodified lines
111	return True	111	return True
112		112
113	def build_reconfig(self, build_dir):	113	def build_reconfig(self, build_dir):
114	"""Creates a new .config if it is not a subset of the kunitconfig."""	114	"""Creates a new .config if it is not a subset of the .kunitconfig."""
115	kconfig_path = get_kconfig_path(build_dir)	115	kconfig_path = get_kconfig_path(build_dir)
116	if os.path.exists(kconfig_path):	116	if os.path.exists(kconfig_path):
117	existing_kconfig = kunit_config.Kconfig()	117	existing_kconfig = kunit_config.Kconfig()
@@ -140,10 +140,10 @@ class LinuxSourceTree(object): · 22 unmodified lines
140	return False	140	return False
141	return True	141	return True
142		142
143	def run_kernel(self, args=[], timeout=None, build_dir=None):	143	def run_kernel(self, args=[], timeout=None, build_dir=''):
144	args.extend(['mem=256M'])	144	args.extend(['mem=256M'])
145	process = self._ops.linux_bin(args, timeout, build_dir)	145	process = self._ops.linux_bin(args, timeout, build_dir)
146	with open('test.log', 'w') as f:	146	with open(os.path.join(build_dir, 'test.log'), 'w') as f:
147	for line in process.stdout:	147	for line in process.stdout:
148	f.write(line.rstrip().decode('ascii') + '\n')	148	f.write(line.rstrip().decode('ascii') + '\n')
149	yield line.rstrip().decode('ascii')	149	yield line.rstrip().decode('ascii')

tools/testing/kunit/kunit_tool_test.py+9−1

 		kunit.main(['run'], self.linux_source_mock)
 		assert self.linux_source_mock.build_reconfig.call_count == 1
 		assert self.linux_source_mock.run_kernel.call_count == 1
+		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=300)
 		self.print_mock.assert_any_call(StrContains('Testing complete.'))
 	def test_run_passes_args_fail(self):
 		timeout = 3453
 		kunit.main(['run', '--timeout', str(timeout)], self.linux_source_mock)
 		assert self.linux_source_mock.build_reconfig.call_count == 1
-		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir=None, timeout=timeout)
+		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=timeout)
+		self.print_mock.assert_any_call(StrContains('Testing complete.'))
+	def test_run_builddir(self):
+		build_dir = '.kunit'
+		kunit.main(['run', '--build_dir', build_dir], self.linux_source_mock)
+		assert self.linux_source_mock.build_reconfig.call_count == 1
+		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir=build_dir, timeout=300)
 		self.print_mock.assert_any_call(StrContains('Testing complete.'))
 if __name__ == '__main__':

tools/testing/selftests/bpf/.gitignore+1−0

@@ -40,3 +40,4 @@ xdping · 39 unmodified lines
40	test_cpp	40	test_cpp
41	/no_alu32	41	/no_alu32
42	/bpf_gcc	42	/bpf_gcc
		43	bpf_helper_defs.h

tools/testing/selftests/bpf/Makefile+3−3

@@ -120,9 +120,9 @@ force: · 119 unmodified lines
120	$(BPFOBJ): force	120	$(BPFOBJ): force
121	$(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/	121	$(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/
122		122
123	BPF_HELPERS := $(BPFDIR)/bpf_helper_defs.h $(wildcard $(BPFDIR)/bpf_*.h)	123	BPF_HELPERS := $(OUTPUT)/bpf_helper_defs.h $(wildcard $(BPFDIR)/bpf_*.h)
124	$(BPFDIR)/bpf_helper_defs.h:	124	$(OUTPUT)/bpf_helper_defs.h:
125	$(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/ bpf_helper_defs.h	125	$(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/ $(OUTPUT)/bpf_helper_defs.h
126		126
127	# Get Clang's default includes on this system, as opposed to those seen by	127	# Get Clang's default includes on this system, as opposed to those seen by
128	# '-target bpf'. This fixes "missing" files on some architectures/distros,	128	# '-target bpf'. This fixes "missing" files on some architectures/distros,

tools/testing/selftests/filesystems/epoll/Makefile+1−1

@@ -1,7 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	CFLAGS += -I../../../../../usr/include/	3	CFLAGS += -I../../../../../usr/include/
4	LDFLAGS += -lpthread	4	LDLIBS += -lpthread
5	TEST_GEN_PROGS := epoll_wakeup_test	5	TEST_GEN_PROGS := epoll_wakeup_test
6		6
7	include ../../lib.mk	7	include ../../lib.mk

tools/testing/selftests/firmware/fw_lib.sh+6−0

 check_mods()
 {
+	local uid=$(id -u)
+	if [ $uid -ne 0 ]; then
+		echo "skip all tests: must be run as root" >&2
+		exit $ksft_skip
+	fi
 	trap "test_modprobe" EXIT
 	if [ ! -d $DIR ]; then
 		modprobe test_firmware

tools/testing/selftests/livepatch/functions.sh+14−1

 MAX_RETRIES=600
 RETRY_INTERVAL=".1"	# seconds
+# Kselftest framework requirement - SKIP code is 4
+ksft_skip=4
 # log(msg) - write message to kernel log
 #	msg - insightful words
 function log() {
 function skip() {
 	log "SKIP: $1"
 	echo "SKIP: $1" >&2
-	exit 4
+	exit $ksft_skip
+}
+# root test
+function is_root() {
+	uid=$(id -u)
+	if [ $uid -ne 0 ]; then
+		echo "skip all tests: must be run as root" >&2
+		exit $ksft_skip
+	fi
 }
 # die(msg) - game over, man
 #		 for verbose livepatching output and turn on
 #		 the ftrace_enabled sysctl.
 function setup_config() {
+	is_root
 	push_config
 	set_dynamic_debug
 	set_ftrace_enabled 1

tools/testing/selftests/livepatch/test-state.sh+1−2

@@ -8,8 +8,7 @@ MOD_LIVEPATCH=test_klp_state · 7 unmodified lines
8	MOD_LIVEPATCH2=test_klp_state2	8	MOD_LIVEPATCH2=test_klp_state2
9	MOD_LIVEPATCH3=test_klp_state3	9	MOD_LIVEPATCH3=test_klp_state3
10		10
11	set_dynamic_debug	11	setup_config
12
13		12
14	# TEST: Loading and removing a module that modifies the system state	13	# TEST: Loading and removing a module that modifies the system state
15		14

tools/testing/selftests/net/forwarding/loopback.sh+8−0

 #!/bin/bash
 # SPDX-License-Identifier: GPL-2.0
+# Kselftest framework requirement - SKIP code is 4.
+ksft_skip=4
 ALL_TESTS="loopback_test"
 NUM_NETIFS=2
 source tc_common.sh
 	h1_create
 	h2_create
+	if ethtool -k $h1 | grep loopback | grep -q fixed; then
+		log_test "SKIP: dev $h1 does not support loopback feature"
+		exit $ksft_skip
+	fi
 }
 cleanup()

tools/testing/selftests/netfilter/nft_flowtable.sh+34−5

 	return 0
 }
-test_tcp_forwarding()
+test_tcp_forwarding_ip()
 {
 	local nsa=$1
 	local nsb=$2
+	local dstip=$3
+	local dstport=$4
 	local lret=0
 	ip netns exec $nsb nc -w 5 -l -p 12345 < "$ns2in" > "$ns2out" &
 	lpid=$!
 	sleep 1
-	ip netns exec $nsa nc -w 4 10.0.2.99 12345 < "$ns1in" > "$ns1out" &
+	ip netns exec $nsa nc -w 4 "$dstip" "$dstport" < "$ns1in" > "$ns1out" &
 	cpid=$!
 	sleep 3
 	return $lret
 }
+test_tcp_forwarding()
+{
+	test_tcp_forwarding_ip "$1" "$2" 10.0.2.99 12345
+	return $?
+}
+test_tcp_forwarding_nat()
+{
+	local lret
+	test_tcp_forwarding_ip "$1" "$2" 10.0.2.99 12345
+	lret=$?
+	if [ $lret -eq 0 ] ; then
+		test_tcp_forwarding_ip "$1" "$2" 10.6.6.6 1666
+		lret=$?
+	fi
+	return $lret
+}
 make_file "$ns1in" "ns1"
 make_file "$ns2in" "ns2"
 # Same, but with NAT enabled.
 ip netns exec nsr1 nft -f - <<EOF
 table ip nat {
+   chain prerouting {
+      type nat hook prerouting priority 0; policy accept;
+      meta iif "veth0" ip daddr 10.6.6.6 tcp dport 1666 counter dnat ip to 10.0.2.99:12345
+   }
    chain postrouting {
       type nat hook postrouting priority 0; policy accept;
-      meta oifname "veth1" masquerade
+      meta oifname "veth1" counter masquerade
    }
 }
 EOF
-test_tcp_forwarding ns1 ns2
+test_tcp_forwarding_nat ns1 ns2
 if [ $? -eq 0 ] ;then
 	echo "PASS: flow offloaded for ns1/ns2 with NAT"
 ip netns exec ns1 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null
 ip netns exec ns2 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null
-test_tcp_forwarding ns1 ns2
+test_tcp_forwarding_nat ns1 ns2
 if [ $? -eq 0 ] ;then
 	echo "PASS: flow offloaded for ns1/ns2 with NAT and pmtu discovery"
 else

tools/testing/selftests/rseq/param_test.c+10−8

 #include <errno.h>
 #include <stddef.h>
-static inline pid_t gettid(void)
+static inline pid_t rseq_gettid(void)
 {
 	return syscall(__NR_gettid);
 }
 		rseq_percpu_unlock(&data->lock, cpu);
 #ifndef BENCHMARK
 		if (i != 0 && !(i % (reps / 10)))
-			printf_verbose("tid %d: count %lld\n", (int) gettid(), i);
+			printf_verbose("tid %d: count %lld\n",
+				       (int) rseq_gettid(), i);
 #endif
 	}
 	printf_verbose("tid %d: number of rseq abort: %d, signals delivered: %u\n",
-		       (int) gettid(), nr_abort, signals_delivered);
+		       (int) rseq_gettid(), nr_abort, signals_delivered);
 	if (!opt_disable_rseq && thread_data->reg &&
 	    rseq_unregister_current_thread())
 		abort();
 		} while (rseq_unlikely(ret));
 #ifndef BENCHMARK
 		if (i != 0 && !(i % (reps / 10)))
-			printf_verbose("tid %d: count %lld\n", (int) gettid(), i);
+			printf_verbose("tid %d: count %lld\n",
+				       (int) rseq_gettid(), i);
 #endif
 	}
 	printf_verbose("tid %d: number of rseq abort: %d, signals delivered: %u\n",
-		       (int) gettid(), nr_abort, signals_delivered);
+		       (int) rseq_gettid(), nr_abort, signals_delivered);
 	if (!opt_disable_rseq && thread_data->reg &&
 	    rseq_unregister_current_thread())
 		abort();
 	}
 	printf_verbose("tid %d: number of rseq abort: %d, signals delivered: %u\n",
-		       (int) gettid(), nr_abort, signals_delivered);
+		       (int) rseq_gettid(), nr_abort, signals_delivered);
 	if (!opt_disable_rseq && rseq_unregister_current_thread())
 		abort();
 	}
 	printf_verbose("tid %d: number of rseq abort: %d, signals delivered: %u\n",
-		       (int) gettid(), nr_abort, signals_delivered);
+		       (int) rseq_gettid(), nr_abort, signals_delivered);
 	if (!opt_disable_rseq && rseq_unregister_current_thread())
 		abort();
 	}
 	printf_verbose("tid %d: number of rseq abort: %d, signals delivered: %u\n",
-		       (int) gettid(), nr_abort, signals_delivered);
+		       (int) rseq_gettid(), nr_abort, signals_delivered);
 	if (!opt_disable_rseq && rseq_unregister_current_thread())
 		abort();

tools/testing/selftests/rseq/rseq.h+7−5

 /*
  * rseq_prepare_unload() should be invoked by each thread executing a rseq
  * critical section at least once between their last critical section and
- * library unload of the library defining the rseq critical section
+ * library unload of the library defining the rseq critical section (struct
- * (struct rseq_cs). This also applies to use of rseq in code generated by
+ * rseq_cs) or the code referred to by the struct rseq_cs start_ip and
- * JIT: rseq_prepare_unload() should be invoked at least once by each
+ * post_commit_offset fields. This also applies to use of rseq in code
- * thread executing a rseq critical section before reclaim of the memory
+ * generated by JIT: rseq_prepare_unload() should be invoked at least once by
- * holding the struct rseq_cs.
+ * each thread executing a rseq critical section before reclaim of the memory
+ * holding the struct rseq_cs or reclaim of the code pointed to by struct
+ * rseq_cs start_ip and post_commit_offset fields.
  */
 static inline void rseq_prepare_unload(void)
 {

tools/testing/selftests/rseq/settings+1−0

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

tools/testing/selftests/seccomp/seccomp_bpf.c+14−1

 	EXPECT_GT(poll(&pollfd, 1, -1), 0);
 	EXPECT_EQ(pollfd.revents, POLLIN);
-	EXPECT_EQ(ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req), 0);
+	/* Test that we can't pass garbage to the kernel. */
+	memset(&req, 0, sizeof(req));
+	req.pid = -1;
+	errno = 0;
+	ret = ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req);
+	EXPECT_EQ(-1, ret);
+	EXPECT_EQ(EINVAL, errno);
+	if (ret) {
+		req.pid = 0;
+		EXPECT_EQ(ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req), 0);
+	}
 	pollfd.fd = listener;
 	pollfd.events = POLLIN | POLLOUT;
 	close(sk_pair[1]);
+	memset(&req, 0, sizeof(req));
 	EXPECT_EQ(ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req), 0);
 	EXPECT_EQ(kill(pid, SIGUSR1), 0);
 	EXPECT_EQ(ioctl(listener, SECCOMP_IOCTL_NOTIF_SEND, &resp), -1);
 	EXPECT_EQ(errno, ENOENT);
+	memset(&req, 0, sizeof(req));
 	EXPECT_EQ(ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req), 0);
 	resp.id = req.id;

usr/gen_initramfs_list.sh+1−1

@@ -128,7 +128,7 @@ parse() { · 127 unmodified lines
128	str="${ftype} ${name} ${location} ${str}"	128	str="${ftype} ${name} ${location} ${str}"
129	;;	129	;;
130	"nod")	130	"nod")
131	local dev=`LC_ALL=C ls -l "${location}"`	131	local dev="`LC_ALL=C ls -l "${location}"`"
132	local maj=`field 5 ${dev}`	132	local maj=`field 5 ${dev}`
133	local min=`field 6 ${dev}`	133	local min=`field 6 ${dev}`
134	maj=${maj%,}	134	maj=${maj%,}

@@ -99,15 +99,15 @@ void ucsi_connector_change(struct ucsi *ucsi, u8 num); · 98 unmodified lines
99	#define UCSI_ENABLE_NTFY_CMD_COMPLETE BIT(16)	99	#define UCSI_ENABLE_NTFY_CMD_COMPLETE BIT(16)
100	#define UCSI_ENABLE_NTFY_EXT_PWR_SRC_CHANGE BIT(17)	100	#define UCSI_ENABLE_NTFY_EXT_PWR_SRC_CHANGE BIT(17)
101	#define UCSI_ENABLE_NTFY_PWR_OPMODE_CHANGE BIT(18)	101	#define UCSI_ENABLE_NTFY_PWR_OPMODE_CHANGE BIT(18)
102	#define UCSI_ENABLE_NTFY_CAP_CHANGE BIT(19)	102	#define UCSI_ENABLE_NTFY_CAP_CHANGE BIT(21)
103	#define UCSI_ENABLE_NTFY_PWR_LEVEL_CHANGE BIT(20)	103	#define UCSI_ENABLE_NTFY_PWR_LEVEL_CHANGE BIT(22)
104	#define UCSI_ENABLE_NTFY_PD_RESET_COMPLETE BIT(21)	104	#define UCSI_ENABLE_NTFY_PD_RESET_COMPLETE BIT(23)
105	#define UCSI_ENABLE_NTFY_CAM_CHANGE BIT(22)	105	#define UCSI_ENABLE_NTFY_CAM_CHANGE BIT(24)
106	#define UCSI_ENABLE_NTFY_BAT_STATUS_CHANGE BIT(23)	106	#define UCSI_ENABLE_NTFY_BAT_STATUS_CHANGE BIT(25)
107	#define UCSI_ENABLE_NTFY_PARTNER_CHANGE BIT(24)	107	#define UCSI_ENABLE_NTFY_PARTNER_CHANGE BIT(27)
108	#define UCSI_ENABLE_NTFY_PWR_DIR_CHANGE BIT(25)	108	#define UCSI_ENABLE_NTFY_PWR_DIR_CHANGE BIT(28)
109	#define UCSI_ENABLE_NTFY_CONNECTOR_CHANGE BIT(26)	109	#define UCSI_ENABLE_NTFY_CONNECTOR_CHANGE BIT(30)
110	#define UCSI_ENABLE_NTFY_ERROR BIT(27)	110	#define UCSI_ENABLE_NTFY_ERROR BIT(31)
111	#define UCSI_ENABLE_NTFY_ALL 0xdbe70000	111	#define UCSI_ENABLE_NTFY_ALL 0xdbe70000
112		112
113	/* SET_UOR command bits */	113	/* SET_UOR command bits */