lael-labs/linux

Documentation/devicetree/bindings/net/davinci_emac.txt+2−0

@@ -20,6 +20,8 @@ Required properties: · 19 unmodified lines
20	Optional properties:	20	Optional properties:
21	- phy-handle: See ethernet.txt file in the same directory.	21	- phy-handle: See ethernet.txt file in the same directory.
22	If absent, davinci_emac driver defaults to 100/FULL.	22	If absent, davinci_emac driver defaults to 100/FULL.
		23	- nvmem-cells: phandle, reference to an nvmem node for the MAC address
		24	- nvmem-cell-names: string, should be "mac-address" if nvmem is to be used
23	- ti,davinci-rmii-en: 1 byte, 1 means use RMII	25	- ti,davinci-rmii-en: 1 byte, 1 means use RMII
24	- ti,davinci-no-bd-ram: boolean, does EMAC have BD RAM?	26	- ti,davinci-no-bd-ram: boolean, does EMAC have BD RAM?
25		27

Documentation/devicetree/bindings/net/ethernet.txt+2−3

   the boot program; should be used in cases where the MAC address assigned to
   the device by the boot program is different from the "local-mac-address"
   property;
-- nvmem-cells: phandle, reference to an nvmem node for the MAC address;
-- nvmem-cell-names: string, should be "mac-address" if nvmem is to be used;
 - max-speed: number, specifies maximum speed in Mbit/s supported by the device;
 - max-frame-size: number, maximum transfer unit (IEEE defined MTU), rather than
   the maximum frame size (there's contradiction in the Devicetree
   Specification).
 - phy-mode: string, operation mode of the PHY interface. This is now a de-facto
   standard property; supported values are:
-  * "internal"
+  * "internal" (Internal means there is not a standard bus between the MAC and
+     the PHY, something proprietary is being used to embed the PHY in the MAC.)
   * "mii"
   * "gmii"
   * "sgmii"

Documentation/devicetree/bindings/net/macb.txt+4−0

@@ -26,6 +26,10 @@ Required properties: · 25 unmodified lines
26	Optional elements: 'tsu_clk'	26	Optional elements: 'tsu_clk'
27	- clocks: Phandles to input clocks.	27	- clocks: Phandles to input clocks.
28		28
		29	Optional properties:
		30	- nvmem-cells: phandle, reference to an nvmem node for the MAC address
		31	- nvmem-cell-names: string, should be "mac-address" if nvmem is to be used
		32
29	Optional properties for PHY child node:	33	Optional properties for PHY child node:
30	- reset-gpios : Should specify the gpio for phy reset	34	- reset-gpios : Should specify the gpio for phy reset
31	- magic-packet : If present, indicates that the hardware supports waking	35	- magic-packet : If present, indicates that the hardware supports waking

Documentation/media/uapi/rc/rc-tables.rst+2−2

@@ -623,7 +623,7 @@ the remote via /dev/input/event devices. · 622 unmodified lines
623		623
624	- .. row 78	624	- .. row 78
625		625
626	- ``KEY_SCREEN``	626	- ``KEY_ASPECT_RATIO``
627		627
628	- Select screen aspect ratio	628	- Select screen aspect ratio
629		629
@@ -631,7 +631,7 @@ the remote via /dev/input/event devices. · 1 unmodified line
631		631
632	- .. row 79	632	- .. row 79
633		633
634	- ``KEY_ZOOM``	634	- ``KEY_FULL_SCREEN``
635		635
636	- Put device into zoom/full screen mode	636	- Put device into zoom/full screen mode
637		637

Documentation/networking/decnet.txt+0−2

@@ -22,8 +22,6 @@ you'll need the following options as well... · 21 unmodified lines
22	CONFIG_DECNET_ROUTER (to be able to add/delete routes)	22	CONFIG_DECNET_ROUTER (to be able to add/delete routes)
23	CONFIG_NETFILTER (will be required for the DECnet routing daemon)	23	CONFIG_NETFILTER (will be required for the DECnet routing daemon)
24		24
25	CONFIG_DECNET_ROUTE_FWMARK is optional
26
27	Don't turn on SIOCGIFCONF support for DECnet unless you are really sure	25	Don't turn on SIOCGIFCONF support for DECnet unless you are really sure
28	that you need it, in general you won't and it can cause ifconfig to	26	that you need it, in general you won't and it can cause ifconfig to
29	malfunction.	27	malfunction.

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

@@ -427,6 +427,7 @@ tcp_min_rtt_wlen - INTEGER · 426 unmodified lines
427	minimum RTT when it is moved to a longer path (e.g., due to traffic	427	minimum RTT when it is moved to a longer path (e.g., due to traffic
428	engineering). A longer window makes the filter more resistant to RTT	428	engineering). A longer window makes the filter more resistant to RTT
429	inflations such as transient congestion. The unit is seconds.	429	inflations such as transient congestion. The unit is seconds.
		430	Possible values: 0 - 86400 (1 day)
430	Default: 300	431	Default: 300
431		432
432	tcp_moderate_rcvbuf - BOOLEAN	433	tcp_moderate_rcvbuf - BOOLEAN

MAINTAINERS+2−1

@@ -3124,6 +3124,7 @@ F: drivers/cpufreq/bmips-cpufreq.c · 3123 unmodified lines
3124	BROADCOM BMIPS MIPS ARCHITECTURE	3124	BROADCOM BMIPS MIPS ARCHITECTURE
3125	M: Kevin Cernekee <cernekee@gmail.com>	3125	M: Kevin Cernekee <cernekee@gmail.com>
3126	M: Florian Fainelli <f.fainelli@gmail.com>	3126	M: Florian Fainelli <f.fainelli@gmail.com>
		3127	L: bcm-kernel-feedback-list@broadcom.com
3127	L: linux-mips@vger.kernel.org	3128	L: linux-mips@vger.kernel.org
3128	T: git git://github.com/broadcom/stblinux.git	3129	T: git git://github.com/broadcom/stblinux.git
3129	S: Maintained	3130	S: Maintained
@@ -7336,7 +7337,6 @@ F: Documentation/devicetree/bindings/i3c/ · 4206 unmodified lines
7336	F: Documentation/driver-api/i3c	7337	F: Documentation/driver-api/i3c
7337	F: drivers/i3c/	7338	F: drivers/i3c/
7338	F: include/linux/i3c/	7339	F: include/linux/i3c/
7339	F: include/dt-bindings/i3c/
7340		7340
7341	I3C DRIVER FOR SYNOPSYS DESIGNWARE	7341	I3C DRIVER FOR SYNOPSYS DESIGNWARE
7342	M: Vitor Soares <vitor.soares@synopsys.com>	7342	M: Vitor Soares <vitor.soares@synopsys.com>
@@ -8711,6 +8711,7 @@ F: scripts/leaking_addresses.pl · 1368 unmodified lines
8711	LED SUBSYSTEM	8711	LED SUBSYSTEM
8712	M: Jacek Anaszewski <jacek.anaszewski@gmail.com>	8712	M: Jacek Anaszewski <jacek.anaszewski@gmail.com>
8713	M: Pavel Machek <pavel@ucw.cz>	8713	M: Pavel Machek <pavel@ucw.cz>
		8714	R: Dan Murphy <dmurphy@ti.com>
8714	L: linux-leds@vger.kernel.org	8715	L: linux-leds@vger.kernel.org
8715	T: git git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds.git	8716	T: git git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds.git
8716	S: Maintained	8717	S: Maintained

Makefile+1−1

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

arch/alpha/kernel/syscalls/syscall.tbl+4−0

@@ -463,3 +463,7 @@ · 462 unmodified lines
463	532 common getppid sys_getppid	463	532 common getppid sys_getppid
464	# all other architectures have common numbers for new syscall, alpha	464	# all other architectures have common numbers for new syscall, alpha
465	# is the exception.	465	# is the exception.
		466	534 common pidfd_send_signal sys_pidfd_send_signal
		467	535 common io_uring_setup sys_io_uring_setup
		468	536 common io_uring_enter sys_io_uring_enter
		469	537 common io_uring_register sys_io_uring_register

arch/arm/tools/syscall.tbl+4−0

@@ -437,3 +437,7 @@ · 436 unmodified lines
437	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait	437	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
438	422 common futex_time64 sys_futex	438	422 common futex_time64 sys_futex
439	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval	439	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
		440	424 common pidfd_send_signal sys_pidfd_send_signal
		441	425 common io_uring_setup sys_io_uring_setup
		442	426 common io_uring_enter sys_io_uring_enter
		443	427 common io_uring_register sys_io_uring_register

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

@@ -50,7 +50,7 @@ do { \ · 49 unmodified lines
50	static inline int	50	static inline int
51	arch_futex_atomic_op_inuser(int op, int oparg, int oval, u32 __user _uaddr)	51	arch_futex_atomic_op_inuser(int op, int oparg, int oval, u32 __user _uaddr)
52	{	52	{
53	int oldval, ret, tmp;	53	int oldval = 0, ret, tmp;
54	u32 __user *uaddr = __uaccess_mask_ptr(_uaddr);	54	u32 __user *uaddr = __uaccess_mask_ptr(_uaddr);
55		55
56	pagefault_disable();	56	pagefault_disable();

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

@@ -44,7 +44,7 @@ · 43 unmodified lines
44	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)	44	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)
45	#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800)	45	#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800)
46		46
47	#define __NR_compat_syscalls 424	47	#define __NR_compat_syscalls 428
48	#endif	48	#endif
49		49
50	#define __ARCH_WANT_SYS_CLONE	50	#define __ARCH_WANT_SYS_CLONE

arch/arm64/include/asm/unistd32.h+8−0

@@ -866,6 +866,14 @@ __SYSCALL(__NR_rt_sigtimedwait_time64, compat_sys_rt_sigtimedwait_time64) · 865 unmodified lines
866	__SYSCALL(__NR_futex_time64, sys_futex)	866	__SYSCALL(__NR_futex_time64, sys_futex)
867	#define __NR_sched_rr_get_interval_time64 423	867	#define __NR_sched_rr_get_interval_time64 423
868	__SYSCALL(__NR_sched_rr_get_interval_time64, sys_sched_rr_get_interval)	868	__SYSCALL(__NR_sched_rr_get_interval_time64, sys_sched_rr_get_interval)
		869	#define __NR_pidfd_send_signal 424
		870	__SYSCALL(__NR_pidfd_send_signal, sys_pidfd_send_signal)
		871	#define __NR_io_uring_setup 425
		872	__SYSCALL(__NR_io_uring_setup, sys_io_uring_setup)
		873	#define __NR_io_uring_enter 426
		874	__SYSCALL(__NR_io_uring_enter, sys_io_uring_enter)
		875	#define __NR_io_uring_register 427
		876	__SYSCALL(__NR_io_uring_register, sys_io_uring_register)
869		877
870	/*	878	/*
871	* Please add new compat syscalls above this comment and update	879	* Please add new compat syscalls above this comment and update

arch/ia64/kernel/syscalls/syscall.tbl+4−0

@@ -344,3 +344,7 @@ · 343 unmodified lines
344	332 common pkey_free sys_pkey_free	344	332 common pkey_free sys_pkey_free
345	333 common rseq sys_rseq	345	333 common rseq sys_rseq
346	# 334 through 423 are reserved to sync up with other architectures	346	# 334 through 423 are reserved to sync up with other architectures
		347	424 common pidfd_send_signal sys_pidfd_send_signal
		348	425 common io_uring_setup sys_io_uring_setup
		349	426 common io_uring_enter sys_io_uring_enter
		350	427 common io_uring_register sys_io_uring_register

arch/m68k/kernel/syscalls/syscall.tbl+4−0

@@ -423,3 +423,7 @@ · 422 unmodified lines
423	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait	423	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
424	422 common futex_time64 sys_futex	424	422 common futex_time64 sys_futex
425	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval	425	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
		426	424 common pidfd_send_signal sys_pidfd_send_signal
		427	425 common io_uring_setup sys_io_uring_setup
		428	426 common io_uring_enter sys_io_uring_enter
		429	427 common io_uring_register sys_io_uring_register

arch/microblaze/kernel/syscalls/syscall.tbl+4−0

@@ -429,3 +429,7 @@ · 428 unmodified lines
429	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait	429	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
430	422 common futex_time64 sys_futex	430	422 common futex_time64 sys_futex
431	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval	431	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
		432	424 common pidfd_send_signal sys_pidfd_send_signal
		433	425 common io_uring_setup sys_io_uring_setup
		434	426 common io_uring_enter sys_io_uring_enter
		435	427 common io_uring_register sys_io_uring_register

arch/mips/ath79/setup.c+0−6

 	return ath79_sys_type;
 }
-int get_c0_perfcount_int(void)
-{
-	return ATH79_MISC_IRQ(5);
-}
-EXPORT_SYMBOL_GPL(get_c0_perfcount_int);
 unsigned int get_c0_compare_int(void)
 {
 	return CP0_LEGACY_COMPARE_IRQ;

arch/mips/kernel/scall64-o32.S+1−1

@@ -125,7 +125,7 @@ trace_a_syscall: · 124 unmodified lines
125	subu t1, v0, __NR_O32_Linux	125	subu t1, v0, __NR_O32_Linux
126	move a1, v0	126	move a1, v0
127	bnez t1, 1f /* __NR_syscall at offset 0 */	127	bnez t1, 1f /* __NR_syscall at offset 0 */
128	lw a1, PT_R4(sp) /* Arg1 for __NR_syscall case */	128	ld a1, PT_R4(sp) /* Arg1 for __NR_syscall case */
129	.set pop	129	.set pop
130		130
131	1: jal syscall_trace_enter	131	1: jal syscall_trace_enter

arch/mips/kernel/syscalls/syscall_n32.tbl+4−0

@@ -362,3 +362,7 @@ · 361 unmodified lines
362	421 n32 rt_sigtimedwait_time64 compat_sys_rt_sigtimedwait_time64	362	421 n32 rt_sigtimedwait_time64 compat_sys_rt_sigtimedwait_time64
363	422 n32 futex_time64 sys_futex	363	422 n32 futex_time64 sys_futex
364	423 n32 sched_rr_get_interval_time64 sys_sched_rr_get_interval	364	423 n32 sched_rr_get_interval_time64 sys_sched_rr_get_interval
		365	424 n32 pidfd_send_signal sys_pidfd_send_signal
		366	425 n32 io_uring_setup sys_io_uring_setup
		367	426 n32 io_uring_enter sys_io_uring_enter
		368	427 n32 io_uring_register sys_io_uring_register

arch/mips/kernel/syscalls/syscall_n64.tbl+4−0

@@ -338,3 +338,7 @@ · 337 unmodified lines
338	327 n64 rseq sys_rseq	338	327 n64 rseq sys_rseq
339	328 n64 io_pgetevents sys_io_pgetevents	339	328 n64 io_pgetevents sys_io_pgetevents
340	# 329 through 423 are reserved to sync up with other architectures	340	# 329 through 423 are reserved to sync up with other architectures
		341	424 n64 pidfd_send_signal sys_pidfd_send_signal
		342	425 n64 io_uring_setup sys_io_uring_setup
		343	426 n64 io_uring_enter sys_io_uring_enter
		344	427 n64 io_uring_register sys_io_uring_register

arch/mips/kernel/syscalls/syscall_o32.tbl+4−0

@@ -411,3 +411,7 @@ · 410 unmodified lines
411	421 o32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64	411	421 o32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64
412	422 o32 futex_time64 sys_futex sys_futex	412	422 o32 futex_time64 sys_futex sys_futex
413	423 o32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval	413	423 o32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval
		414	424 o32 pidfd_send_signal sys_pidfd_send_signal
		415	425 o32 io_uring_setup sys_io_uring_setup
		416	426 o32 io_uring_enter sys_io_uring_enter
		417	427 o32 io_uring_register sys_io_uring_register

arch/parisc/kernel/syscalls/syscall.tbl+4−0

@@ -420,3 +420,7 @@ · 419 unmodified lines
420	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64	420	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64
421	422 32 futex_time64 sys_futex sys_futex	421	422 32 futex_time64 sys_futex sys_futex
422	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval	422	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval
		423	424 common pidfd_send_signal sys_pidfd_send_signal
		424	425 common io_uring_setup sys_io_uring_setup
		425	426 common io_uring_enter sys_io_uring_enter
		426	427 common io_uring_register sys_io_uring_register

arch/powerpc/kernel/syscalls/syscall.tbl+4−0

@@ -505,3 +505,7 @@ · 504 unmodified lines
505	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64	505	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64
506	422 32 futex_time64 sys_futex sys_futex	506	422 32 futex_time64 sys_futex sys_futex
507	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval	507	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval
		508	424 common pidfd_send_signal sys_pidfd_send_signal
		509	425 common io_uring_setup sys_io_uring_setup
		510	426 common io_uring_enter sys_io_uring_enter
		511	427 common io_uring_register sys_io_uring_register

arch/s390/boot/mem_detect.c+1−1

@@ -25,7 +25,7 @@ static void *mem_detect_alloc_extended(void) · 24 unmodified lines
25	{	25	{
26	unsigned long offset = ALIGN(mem_safe_offset(), sizeof(u64));	26	unsigned long offset = ALIGN(mem_safe_offset(), sizeof(u64));
27		27
28	if (IS_ENABLED(BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE &&	28	if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE &&
29	INITRD_START < offset + ENTRIES_EXTENDED_MAX)	29	INITRD_START < offset + ENTRIES_EXTENDED_MAX)
30	offset = ALIGN(INITRD_START + INITRD_SIZE, sizeof(u64));	30	offset = ALIGN(INITRD_START + INITRD_SIZE, sizeof(u64));
31		31

arch/s390/kernel/fpu.c+1−1

@@ -23,7 +23,7 @@ void __kernel_fpu_begin(struct kernel_fpu *state, u32 flags) · 22 unmodified lines
23		23
24	if (flags & KERNEL_FPC)	24	if (flags & KERNEL_FPC)
25	/* Save floating point control */	25	/* Save floating point control */
26	asm volatile("stfpc %0" : "=m" (state->fpc));	26	asm volatile("stfpc %0" : "=Q" (state->fpc));
27		27
28	if (!MACHINE_HAS_VX) {	28	if (!MACHINE_HAS_VX) {
29	if (flags & KERNEL_VXR_V0V7) {	29	if (flags & KERNEL_VXR_V0V7) {

arch/s390/kernel/syscalls/syscall.tbl+4−0

@@ -426,3 +426,7 @@ · 425 unmodified lines
426	421 32 rt_sigtimedwait_time64 - compat_sys_rt_sigtimedwait_time64	426	421 32 rt_sigtimedwait_time64 - compat_sys_rt_sigtimedwait_time64
427	422 32 futex_time64 - sys_futex	427	422 32 futex_time64 - sys_futex
428	423 32 sched_rr_get_interval_time64 - sys_sched_rr_get_interval	428	423 32 sched_rr_get_interval_time64 - sys_sched_rr_get_interval
		429	424 common pidfd_send_signal sys_pidfd_send_signal sys_pidfd_send_signal
		430	425 common io_uring_setup sys_io_uring_setup sys_io_uring_setup
		431	426 common io_uring_enter sys_io_uring_enter sys_io_uring_enter
		432	427 common io_uring_register sys_io_uring_register sys_io_uring_register

arch/s390/kernel/vtime.c+4−4

@@ -37,7 +37,7 @@ static inline u64 get_vtimer(void) · 36 unmodified lines
37	{	37	{
38	u64 timer;	38	u64 timer;
39		39
40	asm volatile("stpt %0" : "=m" (timer));	40	asm volatile("stpt %0" : "=Q" (timer));
41	return timer;	41	return timer;
42	}	42	}
43		43
@@ -48,7 +48,7 @@ static inline void set_vtimer(u64 expires) · 4 unmodified lines
48	asm volatile(	48	asm volatile(
49	" stpt %0\n" /* Store current cpu timer value */	49	" stpt %0\n" /* Store current cpu timer value */
50	" spt %1" /* Set new value imm. afterwards */	50	" spt %1" /* Set new value imm. afterwards */
51	: "=m" (timer) : "m" (expires));	51	: "=Q" (timer) : "Q" (expires));
52	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;	52	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
53	S390_lowcore.last_update_timer = expires;	53	S390_lowcore.last_update_timer = expires;
54	}	54	}
@@ -135,8 +135,8 @@ static int do_account_vtime(struct task_struct *tsk) · 80 unmodified lines
135	#else	135	#else
136	" stck %1" /* Store current tod clock value */	136	" stck %1" /* Store current tod clock value */
137	#endif	137	#endif
138	: "=m" (S390_lowcore.last_update_timer),	138	: "=Q" (S390_lowcore.last_update_timer),
139	"=m" (S390_lowcore.last_update_clock));	139	"=Q" (S390_lowcore.last_update_clock));
140	clock = S390_lowcore.last_update_clock - clock;	140	clock = S390_lowcore.last_update_clock - clock;
141	timer -= S390_lowcore.last_update_timer;	141	timer -= S390_lowcore.last_update_timer;
142		142

arch/sh/kernel/syscalls/syscall.tbl+4−0

@@ -426,3 +426,7 @@ · 425 unmodified lines
426	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait	426	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
427	422 common futex_time64 sys_futex	427	422 common futex_time64 sys_futex
428	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval	428	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
		429	424 common pidfd_send_signal sys_pidfd_send_signal
		430	425 common io_uring_setup sys_io_uring_setup
		431	426 common io_uring_enter sys_io_uring_enter
		432	427 common io_uring_register sys_io_uring_register

arch/sparc/kernel/syscalls/syscall.tbl+4−0

@@ -469,3 +469,7 @@ · 468 unmodified lines
469	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64	469	421 32 rt_sigtimedwait_time64 sys_rt_sigtimedwait compat_sys_rt_sigtimedwait_time64
470	422 32 futex_time64 sys_futex sys_futex	470	422 32 futex_time64 sys_futex sys_futex
471	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval	471	423 32 sched_rr_get_interval_time64 sys_sched_rr_get_interval sys_sched_rr_get_interval
		472	424 common pidfd_send_signal sys_pidfd_send_signal
		473	425 common io_uring_setup sys_io_uring_setup
		474	426 common io_uring_enter sys_io_uring_enter
		475	427 common io_uring_register sys_io_uring_register

arch/x86/Kconfig+1−1

@@ -1499,7 +1499,7 @@ config X86_CPA_STATISTICS · 1498 unmodified lines
1499	depends on DEBUG_FS	1499	depends on DEBUG_FS
1500	---help---	1500	---help---
1501	Expose statistics about the Change Page Attribute mechanims, which	1501	Expose statistics about the Change Page Attribute mechanims, which
1502	helps to determine the effectivness of preserving large and huge	1502	helps to determine the effectiveness of preserving large and huge
1503	page mappings when mapping protections are changed.	1503	page mappings when mapping protections are changed.
1504		1504
1505	config ARCH_HAS_MEM_ENCRYPT	1505	config ARCH_HAS_MEM_ENCRYPT

arch/x86/crypto/poly1305-avx2-x86_64.S+10−4

 	vpaddq		t2,t1,t1
 	vmovq		t1x,d4
+	# Now do a partial reduction mod (2^130)-5, carrying h0 -> h1 -> h2 ->
+	# h3 -> h4 -> h0 -> h1 to get h0,h2,h3,h4 < 2^26 and h1 < 2^26 + a small
+	# amount.  Careful: we must not assume the carry bits 'd0 >> 26',
+	# 'd1 >> 26', 'd2 >> 26', 'd3 >> 26', and '(d4 >> 26) * 5' fit in 32-bit
+	# integers.  It's true in a single-block implementation, but not here.
 	# d1 += d0 >> 26
 	mov		d0,%rax
 	shr		$26,%rax
 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx

arch/x86/crypto/poly1305-sse2-x86_64.S+14−8

 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx
 	paddq		t2,t1
 	movq		t1,d4
+	# Now do a partial reduction mod (2^130)-5, carrying h0 -> h1 -> h2 ->
+	# h3 -> h4 -> h0 -> h1 to get h0,h2,h3,h4 < 2^26 and h1 < 2^26 + a small
+	# amount.  Careful: we must not assume the carry bits 'd0 >> 26',
+	# 'd1 >> 26', 'd2 >> 26', 'd3 >> 26', and '(d4 >> 26) * 5' fit in 32-bit
+	# integers.  It's true in a single-block implementation, but not here.
 	# d1 += d0 >> 26
 	mov		d0,%rax
 	shr		$26,%rax
 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx

arch/x86/events/amd/core.c+26−9

 };
 /*
- * AMD Performance Monitor K7 and later.
+ * AMD Performance Monitor K7 and later, up to and including Family 16h:
  */
 static const u64 amd_perfmon_event_map[PERF_COUNT_HW_MAX] =
 {
-  [PERF_COUNT_HW_CPU_CYCLES]			= 0x0076,
+	[PERF_COUNT_HW_CPU_CYCLES]		= 0x0076,
-  [PERF_COUNT_HW_INSTRUCTIONS]			= 0x00c0,
+	[PERF_COUNT_HW_INSTRUCTIONS]		= 0x00c0,
-  [PERF_COUNT_HW_CACHE_REFERENCES]		= 0x077d,
+	[PERF_COUNT_HW_CACHE_REFERENCES]	= 0x077d,
-  [PERF_COUNT_HW_CACHE_MISSES]			= 0x077e,
+	[PERF_COUNT_HW_CACHE_MISSES]		= 0x077e,
-  [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]		= 0x00c2,
+	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS]	= 0x00c2,
-  [PERF_COUNT_HW_BRANCH_MISSES]			= 0x00c3,
+	[PERF_COUNT_HW_BRANCH_MISSES]		= 0x00c3,
-  [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND]	= 0x00d0, /* "Decoder empty" event */
+	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND]	= 0x00d0, /* "Decoder empty" event */
-  [PERF_COUNT_HW_STALLED_CYCLES_BACKEND]	= 0x00d1, /* "Dispatch stalls" event */
+	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND]	= 0x00d1, /* "Dispatch stalls" event */
+};
+/*
+ * AMD Performance Monitor Family 17h and later:
+ */
+static const u64 amd_f17h_perfmon_event_map[PERF_COUNT_HW_MAX] =
+{
+	[PERF_COUNT_HW_CPU_CYCLES]		= 0x0076,
+	[PERF_COUNT_HW_INSTRUCTIONS]		= 0x00c0,
+	[PERF_COUNT_HW_CACHE_REFERENCES]	= 0xff60,
+	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS]	= 0x00c2,
+	[PERF_COUNT_HW_BRANCH_MISSES]		= 0x00c3,
+	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND]	= 0x0287,
+	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND]	= 0x0187,
 };
 static u64 amd_pmu_event_map(int hw_event)
 {
+	if (boot_cpu_data.x86 >= 0x17)
+		return amd_f17h_perfmon_event_map[hw_event];
 	return amd_perfmon_event_map[hw_event];
 }

arch/x86/events/intel/core.c+1−1

@@ -3131,7 +3131,7 @@ static unsigned long intel_pmu_large_pebs_flags(struct perf_event *event) · 3130 unmodified lines
3131	flags &= ~PERF_SAMPLE_TIME;	3131	flags &= ~PERF_SAMPLE_TIME;
3132	if (!event->attr.exclude_kernel)	3132	if (!event->attr.exclude_kernel)
3133	flags &= ~PERF_SAMPLE_REGS_USER;	3133	flags &= ~PERF_SAMPLE_REGS_USER;
3134	if (event->attr.sample_regs_user & ~PEBS_REGS)	3134	if (event->attr.sample_regs_user & ~PEBS_GP_REGS)
3135	flags &= ~(PERF_SAMPLE_REGS_USER \| PERF_SAMPLE_REGS_INTR);	3135	flags &= ~(PERF_SAMPLE_REGS_USER \| PERF_SAMPLE_REGS_INTR);
3136	return flags;	3136	return flags;
3137	}	3137	}

arch/x86/events/perf_event.h+19−19

@@ -96,25 +96,25 @@ struct amd_nb { · 95 unmodified lines
96	PERF_SAMPLE_REGS_INTR \| PERF_SAMPLE_REGS_USER \| \	96	PERF_SAMPLE_REGS_INTR \| PERF_SAMPLE_REGS_USER \| \
97	PERF_SAMPLE_PERIOD)	97	PERF_SAMPLE_PERIOD)
98		98
99	#define PEBS_REGS \	99	#define PEBS_GP_REGS \
100	(PERF_REG_X86_AX \| \	100	((1ULL << PERF_REG_X86_AX) \| \
101	PERF_REG_X86_BX \| \	101	(1ULL << PERF_REG_X86_BX) \| \
102	PERF_REG_X86_CX \| \	102	(1ULL << PERF_REG_X86_CX) \| \
103	PERF_REG_X86_DX \| \	103	(1ULL << PERF_REG_X86_DX) \| \
104	PERF_REG_X86_DI \| \	104	(1ULL << PERF_REG_X86_DI) \| \
105	PERF_REG_X86_SI \| \	105	(1ULL << PERF_REG_X86_SI) \| \
106	PERF_REG_X86_SP \| \	106	(1ULL << PERF_REG_X86_SP) \| \
107	PERF_REG_X86_BP \| \	107	(1ULL << PERF_REG_X86_BP) \| \
108	PERF_REG_X86_IP \| \	108	(1ULL << PERF_REG_X86_IP) \| \
109	PERF_REG_X86_FLAGS \| \	109	(1ULL << PERF_REG_X86_FLAGS) \| \
110	PERF_REG_X86_R8 \| \	110	(1ULL << PERF_REG_X86_R8) \| \
111	PERF_REG_X86_R9 \| \	111	(1ULL << PERF_REG_X86_R9) \| \
112	PERF_REG_X86_R10 \| \	112	(1ULL << PERF_REG_X86_R10) \| \
113	PERF_REG_X86_R11 \| \	113	(1ULL << PERF_REG_X86_R11) \| \
114	PERF_REG_X86_R12 \| \	114	(1ULL << PERF_REG_X86_R12) \| \
115	PERF_REG_X86_R13 \| \	115	(1ULL << PERF_REG_X86_R13) \| \
116	PERF_REG_X86_R14 \| \	116	(1ULL << PERF_REG_X86_R14) \| \
117	PERF_REG_X86_R15)	117	(1ULL << PERF_REG_X86_R15))
118		118
119	/*	119	/*
120	* Per register state.	120	* Per register state.

arch/x86/kernel/cpu/bugs.c+3−3

@@ -275,7 +275,7 @@ static const struct { · 274 unmodified lines
275	const char *option;	275	const char *option;
276	enum spectre_v2_user_cmd cmd;	276	enum spectre_v2_user_cmd cmd;
277	bool secure;	277	bool secure;
278	} v2_user_options[] __initdata = {	278	} v2_user_options[] __initconst = {
279	{ "auto", SPECTRE_V2_USER_CMD_AUTO, false },	279	{ "auto", SPECTRE_V2_USER_CMD_AUTO, false },
280	{ "off", SPECTRE_V2_USER_CMD_NONE, false },	280	{ "off", SPECTRE_V2_USER_CMD_NONE, false },
281	{ "on", SPECTRE_V2_USER_CMD_FORCE, true },	281	{ "on", SPECTRE_V2_USER_CMD_FORCE, true },
@@ -419,7 +419,7 @@ static const struct { · 137 unmodified lines
419	const char *option;	419	const char *option;
420	enum spectre_v2_mitigation_cmd cmd;	420	enum spectre_v2_mitigation_cmd cmd;
421	bool secure;	421	bool secure;
422	} mitigation_options[] __initdata = {	422	} mitigation_options[] __initconst = {
423	{ "off", SPECTRE_V2_CMD_NONE, false },	423	{ "off", SPECTRE_V2_CMD_NONE, false },
424	{ "on", SPECTRE_V2_CMD_FORCE, true },	424	{ "on", SPECTRE_V2_CMD_FORCE, true },
425	{ "retpoline", SPECTRE_V2_CMD_RETPOLINE, false },	425	{ "retpoline", SPECTRE_V2_CMD_RETPOLINE, false },
@@ -658,7 +658,7 @@ static const char * const ssb_strings[] = { · 232 unmodified lines
658	static const struct {	658	static const struct {
659	const char *option;	659	const char *option;
660	enum ssb_mitigation_cmd cmd;	660	enum ssb_mitigation_cmd cmd;
661	} ssb_mitigation_options[] __initdata = {	661	} ssb_mitigation_options[] __initconst = {
662	{ "auto", SPEC_STORE_BYPASS_CMD_AUTO }, /* Platform decides */	662	{ "auto", SPEC_STORE_BYPASS_CMD_AUTO }, /* Platform decides */
663	{ "on", SPEC_STORE_BYPASS_CMD_ON }, /* Disable Speculative Store Bypass */	663	{ "on", SPEC_STORE_BYPASS_CMD_ON }, /* Disable Speculative Store Bypass */
664	{ "off", SPEC_STORE_BYPASS_CMD_NONE }, /* Don't touch Speculative Store Bypass */	664	{ "off", SPEC_STORE_BYPASS_CMD_NONE }, /* Don't touch Speculative Store Bypass */

arch/x86/kernel/cpu/intel.c+2−2

@@ -611,8 +611,8 @@ static void init_intel_energy_perf(struct cpuinfo_x86 *c) · 610 unmodified lines
611	if ((epb & 0xF) != ENERGY_PERF_BIAS_PERFORMANCE)	611	if ((epb & 0xF) != ENERGY_PERF_BIAS_PERFORMANCE)
612	return;	612	return;
613		613
614	pr_warn_once("ENERGY_PERF_BIAS: Set to 'normal', was 'performance'\n");	614	pr_info_once("ENERGY_PERF_BIAS: Set to 'normal', was 'performance'\n");
615	pr_warn_once("ENERGY_PERF_BIAS: View and update with x86_energy_perf_policy(8)\n");	615	pr_info_once("ENERGY_PERF_BIAS: View and update with x86_energy_perf_policy(8)\n");
616	epb = (epb & ~0xF) \| ENERGY_PERF_BIAS_NORMAL;	616	epb = (epb & ~0xF) \| ENERGY_PERF_BIAS_NORMAL;
617	wrmsrl(MSR_IA32_ENERGY_PERF_BIAS, epb);	617	wrmsrl(MSR_IA32_ENERGY_PERF_BIAS, epb);
618	}	618	}

arch/x86/kernel/cpu/resctrl/rdtgroup.c+2−1

 			rdt_last_cmd_puts("Failed to initialize allocations\n");
 			return ret;
 		}
-		rdtgrp->mode = RDT_MODE_SHAREABLE;
 	}
+	rdtgrp->mode = RDT_MODE_SHAREABLE;
 	return 0;
 }

arch/x86/kernel/kprobes/core.c+46−2

 	unsigned long *sara = stack_addr(regs);
 	ri->ret_addr = (kprobe_opcode_t *) *sara;
+	ri->fp = sara;
 	/* Replace the return addr with trampoline addr */
 	*sara = (unsigned long) &kretprobe_trampoline;
 NOKPROBE_SYMBOL(kretprobe_trampoline);
 STACK_FRAME_NON_STANDARD(kretprobe_trampoline);
+static struct kprobe kretprobe_kprobe = {
+	.addr = (void *)kretprobe_trampoline,
+};
 /*
  * Called from kretprobe_trampoline
  */
 static __used void *trampoline_handler(struct pt_regs *regs)
 {
+	struct kprobe_ctlblk *kcb;
 	struct kretprobe_instance *ri = NULL;
 	struct hlist_head *head, empty_rp;
 	struct hlist_node *tmp;
 	unsigned long flags, orig_ret_address = 0;
 	unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline;
 	kprobe_opcode_t *correct_ret_addr = NULL;
+	void *frame_pointer;
+	bool skipped = false;
+	preempt_disable();
+	/*
+	 * Set a dummy kprobe for avoiding kretprobe recursion.
+	 * Since kretprobe never run in kprobe handler, kprobe must not
+	 * be running at this point.
+	 */
+	kcb = get_kprobe_ctlblk();
+	__this_cpu_write(current_kprobe, &kretprobe_kprobe);
+	kcb->kprobe_status = KPROBE_HIT_ACTIVE;
 	INIT_HLIST_HEAD(&empty_rp);
 	kretprobe_hash_lock(current, &head, &flags);
 	/* fixup registers */
 #ifdef CONFIG_X86_64
 	regs->cs = __KERNEL_CS;
+	/* On x86-64, we use pt_regs->sp for return address holder. */
+	frame_pointer = &regs->sp;
 #else
 	regs->cs = __KERNEL_CS | get_kernel_rpl();
 	regs->gs = 0;
+	/* On x86-32, we use pt_regs->flags for return address holder. */
+	frame_pointer = &regs->flags;
 #endif
 	regs->ip = trampoline_address;
 	regs->orig_ax = ~0UL;
 		if (ri->task != current)
 			/* another task is sharing our hash bucket */
 			continue;
+		/*
+		 * Return probes must be pushed on this hash list correct
+		 * order (same as return order) so that it can be poped
+		 * correctly. However, if we find it is pushed it incorrect
+		 * order, this means we find a function which should not be
+		 * probed, because the wrong order entry is pushed on the
+		 * path of processing other kretprobe itself.
+		 */
+		if (ri->fp != frame_pointer) {
+			if (!skipped)
+				pr_warn("kretprobe is stacked incorrectly. Trying to fixup.\n");
+			skipped = true;
+			continue;
+		}
 		orig_ret_address = (unsigned long)ri->ret_addr;
+		if (skipped)
+			pr_warn("%ps must be blacklisted because of incorrect kretprobe order\n",
+				ri->rp->kp.addr);
 		if (orig_ret_address != trampoline_address)
 			/*
 		if (ri->task != current)
 			/* another task is sharing our hash bucket */
 			continue;
+		if (ri->fp != frame_pointer)
+			continue;
 		orig_ret_address = (unsigned long)ri->ret_addr;
 		if (ri->rp && ri->rp->handler) {
 			__this_cpu_write(current_kprobe, &ri->rp->kp);
-			get_kprobe_ctlblk()->kprobe_status = KPROBE_HIT_ACTIVE;
 			ri->ret_addr = correct_ret_addr;
 			ri->rp->handler(ri, regs);
-			__this_cpu_write(current_kprobe, NULL);
+			__this_cpu_write(current_kprobe, &kretprobe_kprobe);
 		}
 		recycle_rp_inst(ri, &empty_rp);
 	kretprobe_hash_unlock(current, &flags);
+	__this_cpu_write(current_kprobe, NULL);
+	preempt_enable();
 	hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
 		hlist_del(&ri->hlist);
 		kfree(ri);

arch/x86/kernel/process.c+6−2

 	u64 msr = x86_spec_ctrl_base;
 	bool updmsr = false;
+	lockdep_assert_irqs_disabled();
 	/*
 	 * If TIF_SSBD is different, select the proper mitigation
 	 * method. Note that if SSBD mitigation is disabled or permanentely
 void speculation_ctrl_update(unsigned long tif)
 {
+	unsigned long flags;
 	/* Forced update. Make sure all relevant TIF flags are different */
-	preempt_disable();
+	local_irq_save(flags);
 	__speculation_ctrl_update(~tif, tif);
-	preempt_enable();
+	local_irq_restore(flags);
 }
 /* Called from seccomp/prctl update */

arch/x86/kernel/reboot.c+21−0

@@ -81,6 +81,19 @@ static int __init set_bios_reboot(const struct dmi_system_id *d) · 80 unmodified lines
81	return 0;	81	return 0;
82	}	82	}
83		83
		84	/*
		85	* Some machines don't handle the default ACPI reboot method and
		86	* require the EFI reboot method:
		87	*/
		88	static int __init set_efi_reboot(const struct dmi_system_id *d)
		89	{
		90	if (reboot_type != BOOT_EFI && !efi_runtime_disabled()) {
		91	reboot_type = BOOT_EFI;
		92	pr_info("%s series board detected. Selecting EFI-method for reboot.\n", d->ident);
		93	}
		94	return 0;
		95	}
		96
84	void __noreturn machine_real_restart(unsigned int type)	97	void __noreturn machine_real_restart(unsigned int type)
85	{	98	{
86	local_irq_disable();	99	local_irq_disable();
@@ -166,6 +179,14 @@ static const struct dmi_system_id reboot_dmi_table[] __initconst = { · 79 unmodified lines
166	DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),	179	DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),
167	},	180	},
168	},	181	},
		182	{ /* Handle reboot issue on Acer TravelMate X514-51T */
		183	.callback = set_efi_reboot,
		184	.ident = "Acer TravelMate X514-51T",
		185	.matches = {
		186	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
		187	DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate X514-51T"),
		188	},
		189	},
169		190
170	/* Apple */	191	/* Apple */
171	{ /* Handle problems with rebooting on Apple MacBook5 */	192	{ /* Handle problems with rebooting on Apple MacBook5 */

arch/x86/kernel/vmlinux.lds.S+1−1

@@ -362,7 +362,7 @@ SECTIONS · 361 unmodified lines
362	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {	362	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
363	__bss_start = .;	363	__bss_start = .;
364	*(.bss..page_aligned)	364	*(.bss..page_aligned)
365	*(.bss)	365	*(BSS_MAIN)
366	BSS_DECRYPTED	366	BSS_DECRYPTED
367	. = ALIGN(PAGE_SIZE);	367	. = ALIGN(PAGE_SIZE);
368	__bss_stop = .;	368	__bss_stop = .;

arch/x86/mm/dump_pagetables.c+2−1

@@ -259,7 +259,8 @@ static void note_wx(struct pg_state *st) · 258 unmodified lines
259	#endif	259	#endif
260	/* Account the WX pages */	260	/* Account the WX pages */
261	st->wx_pages += npages;	261	st->wx_pages += npages;
262	WARN_ONCE(1, "x86/mm: Found insecure W+X mapping at address %pS\n",	262	WARN_ONCE(__supported_pte_mask & _PAGE_NX,
		263	"x86/mm: Found insecure W+X mapping at address %pS\n",
263	(void *)st->start_address);	264	(void *)st->start_address);
264	}	265	}
265		266

arch/x86/mm/ioremap.c+1−1

@@ -825,7 +825,7 @@ void __init __early_set_fixmap(enum fixed_addresses idx, · 824 unmodified lines
825	pte = early_ioremap_pte(addr);	825	pte = early_ioremap_pte(addr);
826		826
827	/* Sanitize 'prot' against any unsupported bits: */	827	/* Sanitize 'prot' against any unsupported bits: */
828	pgprot_val(flags) &= __default_kernel_pte_mask;	828	pgprot_val(flags) &= __supported_pte_mask;
829		829
830	if (pgprot_val(flags))	830	if (pgprot_val(flags))
831	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));	831	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));

arch/x86/mm/kaslr.c+1−1

@@ -94,7 +94,7 @@ void __init kernel_randomize_memory(void) · 93 unmodified lines
94	if (!kaslr_memory_enabled())	94	if (!kaslr_memory_enabled())
95	return;	95	return;
96		96
97	kaslr_regions[0].size_tb = 1 << (__PHYSICAL_MASK_SHIFT - TB_SHIFT);	97	kaslr_regions[0].size_tb = 1 << (MAX_PHYSMEM_BITS - TB_SHIFT);
98	kaslr_regions[1].size_tb = VMALLOC_SIZE_TB;	98	kaslr_regions[1].size_tb = VMALLOC_SIZE_TB;
99		99
100	/*	100	/*

arch/x86/mm/tlb.c+1−1

@@ -728,7 +728,7 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, · 727 unmodified lines
728	{	728	{
729	int cpu;	729	int cpu;
730		730
731	struct flush_tlb_info info __aligned(SMP_CACHE_BYTES) = {	731	struct flush_tlb_info info = {
732	.mm = mm,	732	.mm = mm,
733	.stride_shift = stride_shift,	733	.stride_shift = stride_shift,
734	.freed_tables = freed_tables,	734	.freed_tables = freed_tables,

arch/xtensa/kernel/syscalls/syscall.tbl+4−0

@@ -394,3 +394,7 @@ · 393 unmodified lines
394	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait	394	421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
395	422 common futex_time64 sys_futex	395	422 common futex_time64 sys_futex
396	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval	396	423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
		397	424 common pidfd_send_signal sys_pidfd_send_signal
		398	425 common io_uring_setup sys_io_uring_setup
		399	426 common io_uring_enter sys_io_uring_enter
		400	427 common io_uring_register sys_io_uring_register

block/bfq-iosched.c+7−1

 	return min_shallow;
 }
-static int bfq_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int index)
+static void bfq_depth_updated(struct blk_mq_hw_ctx *hctx)
 {
 	struct bfq_data *bfqd = hctx->queue->elevator->elevator_data;
 	struct blk_mq_tags *tags = hctx->sched_tags;
 	min_shallow = bfq_update_depths(bfqd, &tags->bitmap_tags);
 	sbitmap_queue_min_shallow_depth(&tags->bitmap_tags, min_shallow);
+}
+static int bfq_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int index)
+{
+	bfq_depth_updated(hctx);
 	return 0;
 }
 		.requests_merged	= bfq_requests_merged,
 		.request_merged		= bfq_request_merged,
 		.has_work		= bfq_has_work,
+		.depth_updated		= bfq_depth_updated,
 		.init_hctx		= bfq_init_hctx,
 		.init_sched		= bfq_init_queue,
 		.exit_sched		= bfq_exit_queue,

block/blk-mq.c+2−0

@@ -3135,6 +3135,8 @@ int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr) · 3134 unmodified lines
3135	}	3135	}
3136	if (ret)	3136	if (ret)
3137	break;	3137	break;
		3138	if (q->elevator && q->elevator->type->ops.depth_updated)
		3139	q->elevator->type->ops.depth_updated(hctx);
3138	}	3140	}
3139		3141
3140	if (!ret)	3142	if (!ret)

crypto/testmgr.h+43−1

@@ -5634,7 +5634,49 @@ static const struct hash_testvec poly1305_tv_template[] = { · 5633 unmodified lines
5634	.psize = 80,	5634	.psize = 80,
5635	.digest = "\x13\x00\x00\x00\x00\x00\x00\x00"	5635	.digest = "\x13\x00\x00\x00\x00\x00\x00\x00"
5636	"\x00\x00\x00\x00\x00\x00\x00\x00",	5636	"\x00\x00\x00\x00\x00\x00\x00\x00",
5637	},	5637	}, { /* Regression test for overflow in AVX2 implementation */
		5638	.plaintext = "\xff\xff\xff\xff\xff\xff\xff\xff"
		5639	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5640	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5641	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5642	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5643	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5644	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5645	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5646	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5647	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5648	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5649	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5650	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5651	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5652	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5653	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5654	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5655	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5656	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5657	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5658	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5659	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5660	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5661	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5662	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5663	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5664	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5665	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5666	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5667	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5668	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5669	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5670	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5671	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5672	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5673	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5674	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5675	"\xff\xff\xff\xff",
		5676	.psize = 300,
		5677	.digest = "\xfb\x5e\x96\xd8\x61\xd5\xc7\xc8"
		5678	"\x78\xe5\x87\xcc\x2d\x5a\x22\xe1",
		5679	}
5638	};	5680	};
5639		5681
5640	/* NHPoly1305 test vectors from https://github.com/google/adiantum */	5682	/* NHPoly1305 test vectors from https://github.com/google/adiantum */

drivers/atm/firestream.c+1−1

@@ -1646,7 +1646,7 @@ static irqreturn_t fs_irq (int irq, void *dev_id) · 1645 unmodified lines
1646	}	1646	}
1647		1647
1648	if (status & ISR_TBRQ_W) {	1648	if (status & ISR_TBRQ_W) {
1649	fs_dprintk (FS_DEBUG_IRQ, "Data tramsitted!\n");	1649	fs_dprintk (FS_DEBUG_IRQ, "Data transmitted!\n");
1650	process_txdone_queue (dev, &dev->tx_relq);	1650	process_txdone_queue (dev, &dev->tx_relq);
1651	}	1651	}
1652		1652

drivers/base/memory.c+1−1

@@ -506,7 +506,7 @@ static ssize_t probe_store(struct device dev, struct device_attribute attr, · 505 unmodified lines
506		506
507	ret = lock_device_hotplug_sysfs();	507	ret = lock_device_hotplug_sysfs();
508	if (ret)	508	if (ret)
509	goto out;	509	return ret;
510		510
511	nid = memory_add_physaddr_to_nid(phys_addr);	511	nid = memory_add_physaddr_to_nid(phys_addr);
512	ret = __add_memory(nid, phys_addr,	512	ret = __add_memory(nid, phys_addr,

drivers/clocksource/Kconfig+1−0

@@ -145,6 +145,7 @@ config VT8500_TIMER · 144 unmodified lines
145	config NPCM7XX_TIMER	145	config NPCM7XX_TIMER
146	bool "NPCM7xx timer driver" if COMPILE_TEST	146	bool "NPCM7xx timer driver" if COMPILE_TEST
147	depends on HAS_IOMEM	147	depends on HAS_IOMEM
		148	select TIMER_OF
148	select CLKSRC_MMIO	149	select CLKSRC_MMIO
149	help	150	help
150	Enable 24-bit TIMER0 and TIMER1 counters in the NPCM7xx architecture,	151	Enable 24-bit TIMER0 and TIMER1 counters in the NPCM7xx architecture,

drivers/clocksource/arm_arch_timer.c+1−4

  * published by the Free Software Foundation.
  */
-#define pr_fmt(fmt)	"arm_arch_timer: " fmt
+#define pr_fmt(fmt) 	"arch_timer: " fmt
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <clocksource/arm_arch_timer.h>
-#undef pr_fmt
-#define pr_fmt(fmt) "arch_timer: " fmt
 #define CNTTIDR		0x08
 #define CNTTIDR_VIRT(n)	(BIT(1) << ((n) * 4))

drivers/clocksource/timer-oxnas-rps.c+1−1

@@ -296,4 +296,4 @@ err_alloc: · 295 unmodified lines
296	TIMER_OF_DECLARE(ox810se_rps,	296	TIMER_OF_DECLARE(ox810se_rps,
297	"oxsemi,ox810se-rps-timer", oxnas_rps_timer_init);	297	"oxsemi,ox810se-rps-timer", oxnas_rps_timer_init);
298	TIMER_OF_DECLARE(ox820_rps,	298	TIMER_OF_DECLARE(ox820_rps,
299	"oxsemi,ox820se-rps-timer", oxnas_rps_timer_init);	299	"oxsemi,ox820-rps-timer", oxnas_rps_timer_init);

drivers/clocksource/timer-ti-dm.c+0−28

@@ -585,34 +585,6 @@ static int omap_dm_timer_set_load(struct omap_dm_timer *timer, int autoreload, · 584 unmodified lines
585	return 0;	585	return 0;
586	}	586	}
587		587
588	/* Optimized set_load which removes costly spin wait in timer_start */
589	static int omap_dm_timer_set_load_start(struct omap_dm_timer *timer,
590	int autoreload, unsigned int load)
591	{
592	u32 l;
593
594	if (unlikely(!timer))
595	return -EINVAL;
596
597	omap_dm_timer_enable(timer);
598
599	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
600	if (autoreload) {
601	l \|= OMAP_TIMER_CTRL_AR;
602	omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
603	} else {
604	l &= ~OMAP_TIMER_CTRL_AR;
605	}
606	l \|= OMAP_TIMER_CTRL_ST;
607
608	__omap_dm_timer_load_start(timer, l, load, timer->posted);
609
610	/* Save the context */
611	timer->context.tclr = l;
612	timer->context.tldr = load;
613	timer->context.tcrr = load;
614	return 0;
615	}
616	static int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,	588	static int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,
617	unsigned int match)	589	unsigned int match)
618	{	590	{

drivers/extcon/Kconfig+1−1

@@ -116,7 +116,7 @@ config EXTCON_PALMAS · 115 unmodified lines
116		116
117	config EXTCON_PTN5150	117	config EXTCON_PTN5150
118	tristate "NXP PTN5150 CC LOGIC USB EXTCON support"	118	tristate "NXP PTN5150 CC LOGIC USB EXTCON support"
119	depends on I2C && GPIOLIB \|\| COMPILE_TEST	119	depends on I2C && (GPIOLIB \|\| COMPILE_TEST)
120	select REGMAP_I2C	120	select REGMAP_I2C
121	help	121	help
122	Say Y here to enable support for USB peripheral and USB host	122	Say Y here to enable support for USB peripheral and USB host

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

@@ -3165,6 +3165,7 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev) · 3164 unmodified lines
3165		3165
3166	/* No need to recover an evicted BO */	3166	/* No need to recover an evicted BO */
3167	if (shadow->tbo.mem.mem_type != TTM_PL_TT \|\|	3167	if (shadow->tbo.mem.mem_type != TTM_PL_TT \|\|
		3168	shadow->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET \|\|
3168	shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)	3169	shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)
3169	continue;	3170	continue;
3170		3171

drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c+1−0

@@ -182,6 +182,7 @@ static void mmhub_v1_0_init_cache_regs(struct amdgpu_device *adev) · 181 unmodified lines
182	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL3,	182	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL3,
183	L2_CACHE_BIGK_FRAGMENT_SIZE, 6);	183	L2_CACHE_BIGK_FRAGMENT_SIZE, 6);
184	}	184	}
		185	WREG32_SOC15(MMHUB, 0, mmVM_L2_CNTL3, tmp);
185		186
186	tmp = mmVM_L2_CNTL4_DEFAULT;	187	tmp = mmVM_L2_CNTL4_DEFAULT;
187	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL4, VMC_TAP_PDE_REQUEST_PHYSICAL, 0);	188	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL4, VMC_TAP_PDE_REQUEST_PHYSICAL, 0);

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

@@ -1377,6 +1377,11 @@ static enum surface_update_type det_surface_update(const struct dc *dc, · 1376 unmodified lines
1377	return UPDATE_TYPE_FULL;	1377	return UPDATE_TYPE_FULL;
1378	}	1378	}
1379		1379
		1380	if (u->surface->force_full_update) {
		1381	update_flags->bits.full_update = 1;
		1382	return UPDATE_TYPE_FULL;
		1383	}
		1384
1380	type = get_plane_info_update_type(u);	1385	type = get_plane_info_update_type(u);
1381	elevate_update_type(&overall_type, type);	1386	elevate_update_type(&overall_type, type);
1382		1387
@@ -1802,6 +1807,14 @@ void dc_commit_updates_for_stream(struct dc *dc, · 419 unmodified lines
1802	}	1807	}
1803		1808
1804	dc_resource_state_copy_construct(state, context);	1809	dc_resource_state_copy_construct(state, context);
		1810
		1811	for (i = 0; i < dc->res_pool->pipe_count; i++) {
		1812	struct pipe_ctx *new_pipe = &context->res_ctx.pipe_ctx[i];
		1813	struct pipe_ctx *old_pipe = &dc->current_state->res_ctx.pipe_ctx[i];
		1814
		1815	if (new_pipe->plane_state && new_pipe->plane_state != old_pipe->plane_state)
		1816	new_pipe->plane_state->force_full_update = true;
		1817	}
1805	}	1818	}
1806		1819
1807		1820
@@ -1838,6 +1851,12 @@ void dc_commit_updates_for_stream(struct dc *dc, · 30 unmodified lines
1838	dc->current_state = context;	1851	dc->current_state = context;
1839	dc_release_state(old);	1852	dc_release_state(old);
1840		1853
		1854	for (i = 0; i < dc->res_pool->pipe_count; i++) {
		1855	struct pipe_ctx *pipe_ctx = &context->res_ctx.pipe_ctx[i];
		1856
		1857	if (pipe_ctx->plane_state && pipe_ctx->stream == stream)
		1858	pipe_ctx->plane_state->force_full_update = false;
		1859	}
1841	}	1860	}
1842	/let's use current_state to update watermark etc/	1861	/let's use current_state to update watermark etc/
1843	if (update_type >= UPDATE_TYPE_FULL)	1862	if (update_type >= UPDATE_TYPE_FULL)

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

@@ -503,6 +503,9 @@ struct dc_plane_state { · 502 unmodified lines
503	struct dc_plane_status status;	503	struct dc_plane_status status;
504	struct dc_context *ctx;	504	struct dc_context *ctx;
505		505
		506	/* HACK: Workaround for forcing full reprogramming under some conditions */
		507	bool force_full_update;
		508
506	/* private to dc_surface.c */	509	/* private to dc_surface.c */
507	enum dc_irq_source irq_source;	510	enum dc_irq_source irq_source;
508	struct kref refcount;	511	struct kref refcount;

drivers/gpu/drm/amd/display/dc/dce/dce_aux.c+6−3

 				1,
 				0);
 	}
+	REG_UPDATE(AUX_INTERRUPT_CONTROL, AUX_SW_DONE_ACK, 1);
+	REG_WAIT(AUX_SW_STATUS, AUX_SW_DONE, 0,
+				10, aux110->timeout_period/10);
 	/* set the delay and the number of bytes to write */
 	/* The length include
 		}
 	}
-	REG_UPDATE(AUX_INTERRUPT_CONTROL, AUX_SW_DONE_ACK, 1);
-	REG_WAIT(AUX_SW_STATUS, AUX_SW_DONE, 0,
-				10, aux110->timeout_period/10);
 	REG_UPDATE(AUX_SW_CONTROL, AUX_SW_GO, 1);
 }

drivers/gpu/drm/amd/display/dc/dce/dce_aux.h+3−3

@@ -71,11 +71,11 @@ enum { /* This is the timeout as defined in DP 1.2a, · 70 unmodified lines
71	* at most within ~240usec. That means,	71	* at most within ~240usec. That means,
72	* increasing this timeout will not affect normal operation,	72	* increasing this timeout will not affect normal operation,
73	* and we'll timeout after	73	* and we'll timeout after
74	* SW_AUX_TIMEOUT_PERIOD_MULTIPLIER * AUX_TIMEOUT_PERIOD = 1600usec.	74	* SW_AUX_TIMEOUT_PERIOD_MULTIPLIER * AUX_TIMEOUT_PERIOD = 2400usec.
75	* This timeout is especially important for	75	* This timeout is especially important for
76	* resume from S3 and CTS.	76	* converters, resume from S3, and CTS.
77	*/	77	*/
78	SW_AUX_TIMEOUT_PERIOD_MULTIPLIER = 4	78	SW_AUX_TIMEOUT_PERIOD_MULTIPLIER = 6
79	};	79	};
80		80
81	struct dce_aux {	81	struct dce_aux {

drivers/gpu/drm/i915/intel_fbdev.c+5−7

 				    bool *enabled, int width, int height)
 {
 	struct drm_i915_private *dev_priv = to_i915(fb_helper->dev);
+	unsigned long conn_configured, conn_seq, mask;
 	unsigned int count = min(fb_helper->connector_count, BITS_PER_LONG);
-	unsigned long conn_configured, conn_seq;
 	int i, j;
 	bool *save_enabled;
 	bool fallback = true, ret = true;
 		drm_modeset_backoff(&ctx);
 	memcpy(save_enabled, enabled, count);
-	conn_seq = GENMASK(count - 1, 0);
+	mask = GENMASK(count - 1, 0);
 	conn_configured = 0;
 retry:
+	conn_seq = conn_configured;
 	for (i = 0; i < count; i++) {
 		struct drm_fb_helper_connector *fb_conn;
 		struct drm_connector *connector;
 		if (conn_configured & BIT(i))
 			continue;
-		/* First pass, only consider tiled connectors */
+		if (conn_seq == 0 && !connector->has_tile)
-		if (conn_seq == GENMASK(count - 1, 0) && !connector->has_tile)
 			continue;
 		if (connector->status == connector_status_connected)
 		conn_configured |= BIT(i);
 	}
-	if (conn_configured != conn_seq) { /* repeat until no more are found */
+	if ((conn_configured & mask) != mask && conn_configured != conn_seq)
-		conn_seq = conn_configured;
 		goto retry;
-	}
 	/*
 	 * If the BIOS didn't enable everything it could, fall back to have the

drivers/gpu/drm/tegra/hdmi.c+9−3

 	hdmi->dvi = !tegra_output_is_hdmi(output);
 	if (!hdmi->dvi) {
-		err = tegra_hdmi_setup_audio(hdmi);
+		/*
-		if (err < 0)
+		 * Make sure that the audio format has been configured before
-			hdmi->dvi = true;
+		 * enabling audio, otherwise we may try to divide by zero.
+		*/
+		if (hdmi->format.sample_rate > 0) {
+			err = tegra_hdmi_setup_audio(hdmi);
+			if (err < 0)
+				hdmi->dvi = true;
+		}
 	}
 	if (hdmi->config->has_hda)

drivers/gpu/drm/ttm/ttm_bo.c+3−1

 		reservation_object_add_shared_fence(bo->resv, fence);
 		ret = reservation_object_reserve_shared(bo->resv, 1);
-		if (unlikely(ret))
+		if (unlikely(ret)) {
+			dma_fence_put(fence);
 			return ret;
+		}
 		dma_fence_put(bo->moving);
 		bo->moving = fence;

drivers/gpu/drm/ttm/ttm_page_alloc.c+7−6

 			}
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
-			if (!(flags & TTM_PAGE_FLAG_DMA32)) {
+			if (!(flags & TTM_PAGE_FLAG_DMA32) &&
-				for (j = 0; j < HPAGE_PMD_NR; ++j)
+			    (npages - i) >= HPAGE_PMD_NR) {
-					if (p++ != pages[i + j])
+				for (j = 1; j < HPAGE_PMD_NR; ++j)
+					if (++p != pages[i + j])
 					    break;
 				if (j == HPAGE_PMD_NR)
 		unsigned max_size, n2free;
 		spin_lock_irqsave(&huge->lock, irq_flags);
-		while (i < npages) {
+		while ((npages - i) >= HPAGE_PMD_NR) {
 			struct page *p = pages[i];
 			unsigned j;
 			if (!p)
 				break;
-			for (j = 0; j < HPAGE_PMD_NR; ++j)
+			for (j = 1; j < HPAGE_PMD_NR; ++j)
-				if (p++ != pages[i + j])
+				if (++p != pages[i + j])
 				    break;
 			if (j != HPAGE_PMD_NR)

drivers/gpu/drm/virtio/virtgpu_drv.c+4−0

 #if defined(CONFIG_DEBUG_FS)
 	.debugfs_init = virtio_gpu_debugfs_init,
 #endif
+	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
+	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
 	.gem_prime_export = drm_gem_prime_export,
 	.gem_prime_import = drm_gem_prime_import,
 	.gem_prime_pin = virtgpu_gem_prime_pin,
 	.gem_prime_unpin = virtgpu_gem_prime_unpin,
+	.gem_prime_get_sg_table = virtgpu_gem_prime_get_sg_table,
+	.gem_prime_import_sg_table = virtgpu_gem_prime_import_sg_table,
 	.gem_prime_vmap = virtgpu_gem_prime_vmap,
 	.gem_prime_vunmap = virtgpu_gem_prime_vunmap,
 	.gem_prime_mmap = virtgpu_gem_prime_mmap,

drivers/gpu/drm/virtio/virtgpu_drv.h+4−0

 /* virtgpu_prime.c */
 int virtgpu_gem_prime_pin(struct drm_gem_object *obj);
 void virtgpu_gem_prime_unpin(struct drm_gem_object *obj);
+struct sg_table *virtgpu_gem_prime_get_sg_table(struct drm_gem_object *obj);
+struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
+	struct drm_device *dev, struct dma_buf_attachment *attach,
+	struct sg_table *sgt);
 void *virtgpu_gem_prime_vmap(struct drm_gem_object *obj);
 void virtgpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
 int virtgpu_gem_prime_mmap(struct drm_gem_object *obj,

drivers/gpu/drm/virtio/virtgpu_prime.c+12−0

@@ -39,6 +39,18 @@ void virtgpu_gem_prime_unpin(struct drm_gem_object *obj) · 38 unmodified lines
39	WARN_ONCE(1, "not implemented");	39	WARN_ONCE(1, "not implemented");
40	}	40	}
41		41
		42	struct sg_table virtgpu_gem_prime_get_sg_table(struct drm_gem_object obj)
		43	{
		44	return ERR_PTR(-ENODEV);
		45	}
		46
		47	struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
		48	struct drm_device dev, struct dma_buf_attachment attach,
		49	struct sg_table *table)
		50	{
		51	return ERR_PTR(-ENODEV);
		52	}
		53
42	void virtgpu_gem_prime_vmap(struct drm_gem_object obj)	54	void virtgpu_gem_prime_vmap(struct drm_gem_object obj)
43	{	55	{
44	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);	56	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);

drivers/gpu/host1x/hw/channel_hw.c+6−2

 static void host1x_channel_set_streamid(struct host1x_channel *channel)
 {
-#if IS_ENABLED(CONFIG_IOMMU_API) &&  HOST1X_HW >= 6
+#if HOST1X_HW >= 6
+	u32 sid = 0x7f;
+#ifdef CONFIG_IOMMU_API
 	struct iommu_fwspec *spec = dev_iommu_fwspec_get(channel->dev->parent);
-	u32 sid = spec ? spec->ids[0] & 0xffff : 0x7f;
+	if (spec)
+		sid = spec->ids[0] & 0xffff;
+#endif
 	host1x_ch_writel(channel, sid, HOST1X_CHANNEL_SMMU_STREAMID);
 #endif

drivers/hid/hid-input.c+16−1

 			break;
 		}
+		if ((usage->hid & 0xf0) == 0xb0) {	/* SC - Display */
+			switch (usage->hid & 0xf) {
+			case 0x05: map_key_clear(KEY_SWITCHVIDEOMODE); break;
+			default: goto ignore;
+			}
+			break;
+		}
 		/*
 		 * Some lazy vendors declare 255 usages for System Control,
 		 * leading to the creation of ABS_X|Y axis and too many others.
 		case 0x06a: map_key_clear(KEY_GREEN);		break;
 		case 0x06b: map_key_clear(KEY_BLUE);		break;
 		case 0x06c: map_key_clear(KEY_YELLOW);		break;
-		case 0x06d: map_key_clear(KEY_ZOOM);		break;
+		case 0x06d: map_key_clear(KEY_ASPECT_RATIO);	break;
 		case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);		break;
 		case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);		break;
 		case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);		break;
 		case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);		break;
+		case 0x079: map_key_clear(KEY_KBDILLUMUP);	break;
+		case 0x07a: map_key_clear(KEY_KBDILLUMDOWN);	break;
+		case 0x07c: map_key_clear(KEY_KBDILLUMTOGGLE);	break;
 		case 0x082: map_key_clear(KEY_VIDEO_NEXT);	break;
 		case 0x083: map_key_clear(KEY_LAST);		break;
 		case 0x084: map_key_clear(KEY_ENTER);		break;
 		case 0x22d: map_key_clear(KEY_ZOOMIN);		break;
 		case 0x22e: map_key_clear(KEY_ZOOMOUT);		break;
 		case 0x22f: map_key_clear(KEY_ZOOMRESET);	break;
+		case 0x232: map_key_clear(KEY_FULL_SCREEN);	break;
 		case 0x233: map_key_clear(KEY_SCROLLUP);	break;
 		case 0x234: map_key_clear(KEY_SCROLLDOWN);	break;
 		case 0x238: /* AC Pan */
 		case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);	break;
 		case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);	break;
+		case 0x29f: map_key_clear(KEY_SCALE);		break;
 		default: map_key_clear(KEY_UNKNOWN);
 		}
 		break;

drivers/i3c/master.c+2−3

 {
 	struct i3c_dev_boardinfo *boardinfo;
 	struct device *dev = &master->dev;
-	struct i3c_device_info info = { };
 	enum i3c_addr_slot_status addrstatus;
 	u32 init_dyn_addr = 0;
 	boardinfo->pid = ((u64)reg[1] << 32) | reg[2];
-	if ((info.pid & GENMASK_ULL(63, 48)) ||
+	if ((boardinfo->pid & GENMASK_ULL(63, 48)) ||
-	    I3C_PID_RND_LOWER_32BITS(info.pid))
+	    I3C_PID_RND_LOWER_32BITS(boardinfo->pid))
 		return -EINVAL;
 	boardinfo->init_dyn_addr = init_dyn_addr;

drivers/i3c/master/dw-i3c-master.c+1−1

@@ -300,7 +300,7 @@ to_dw_i3c_master(struct i3c_master_controller *master) · 299 unmodified lines
300		300
301	static void dw_i3c_master_disable(struct dw_i3c_master *master)	301	static void dw_i3c_master_disable(struct dw_i3c_master *master)
302	{	302	{
303	writel(readl(master->regs + DEVICE_CTRL) & DEV_CTRL_ENABLE,	303	writel(readl(master->regs + DEVICE_CTRL) & ~DEV_CTRL_ENABLE,
304	master->regs + DEVICE_CTRL);	304	master->regs + DEVICE_CTRL);
305	}	305	}
306		306

drivers/iio/accel/kxcjk-1013.c+2−0

@@ -1437,6 +1437,8 @@ static int kxcjk1013_resume(struct device *dev) · 1436 unmodified lines
1437		1437
1438	mutex_lock(&data->mutex);	1438	mutex_lock(&data->mutex);
1439	ret = kxcjk1013_set_mode(data, OPERATION);	1439	ret = kxcjk1013_set_mode(data, OPERATION);
		1440	if (ret == 0)
		1441	ret = kxcjk1013_set_range(data, data->range);
1440	mutex_unlock(&data->mutex);	1442	mutex_unlock(&data->mutex);
1441		1443
1442	return ret;	1444	return ret;

drivers/iio/adc/ad_sigma_delta.c+1−0

@@ -121,6 +121,7 @@ static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta, · 120 unmodified lines
121	if (sigma_delta->info->has_registers) {	121	if (sigma_delta->info->has_registers) {
122	data[0] = reg << sigma_delta->info->addr_shift;	122	data[0] = reg << sigma_delta->info->addr_shift;
123	data[0] \|= sigma_delta->info->read_mask;	123	data[0] \|= sigma_delta->info->read_mask;
		124	data[0] \|= sigma_delta->comm;
124	spi_message_add_tail(&t[0], &m);	125	spi_message_add_tail(&t[0], &m);
125	}	126	}
126	spi_message_add_tail(&t[1], &m);	127	spi_message_add_tail(&t[1], &m);

drivers/iio/adc/at91_adc.c+17−11

 		ret = wait_event_interruptible_timeout(st->wq_data_avail,
 						       st->done,
 						       msecs_to_jiffies(1000));
-		if (ret == 0)
-			ret = -ETIMEDOUT;
-		if (ret < 0) {
-			mutex_unlock(&st->lock);
-			return ret;
-		}
-		*val = st->last_value;
+		/* Disable interrupts, regardless if adc conversion was
+		 * successful or not
+		 */
 		at91_adc_writel(st, AT91_ADC_CHDR,
 				AT91_ADC_CH(chan->channel));
 		at91_adc_writel(st, AT91_ADC_IDR, BIT(chan->channel));
-		st->last_value = 0;
+		if (ret > 0) {
-		st->done = false;
+			/* a valid conversion took place */
+			*val = st->last_value;
+			st->last_value = 0;
+			st->done = false;
+			ret = IIO_VAL_INT;
+		} else if (ret == 0) {
+			/* conversion timeout */
+			dev_err(&idev->dev, "ADC Channel %d timeout.\n",
+				chan->channel);
+			ret = -ETIMEDOUT;
+		}
 		mutex_unlock(&st->lock);
-		return IIO_VAL_INT;
+		return ret;
 	case IIO_CHAN_INFO_SCALE:
 		*val = st->vref_mv;

drivers/iio/adc/xilinx-xadc-core.c+2−1

 err_free_irq:
 	free_irq(xadc->irq, indio_dev);
+	cancel_delayed_work_sync(&xadc->zynq_unmask_work);
 err_clk_disable_unprepare:
 	clk_disable_unprepare(xadc->clk);
 err_free_samplerate_trigger:
 		iio_triggered_buffer_cleanup(indio_dev);
 	}
 	free_irq(xadc->irq, indio_dev);
+	cancel_delayed_work_sync(&xadc->zynq_unmask_work);
 	clk_disable_unprepare(xadc->clk);
-	cancel_delayed_work(&xadc->zynq_unmask_work);
 	kfree(xadc->data);
 	kfree(indio_dev->channels);

drivers/iio/chemical/Kconfig+14−0

@@ -64,6 +64,7 @@ config IAQCORE · 63 unmodified lines
64	config PMS7003	64	config PMS7003
65	tristate "Plantower PMS7003 particulate matter sensor"	65	tristate "Plantower PMS7003 particulate matter sensor"
66	depends on SERIAL_DEV_BUS	66	depends on SERIAL_DEV_BUS
		67	select IIO_TRIGGERED_BUFFER
67	help	68	help
68	Say Y here to build support for the Plantower PMS7003 particulate	69	Say Y here to build support for the Plantower PMS7003 particulate
69	matter sensor.	70	matter sensor.
@@ -71,6 +72,19 @@ config PMS7003 · 1 unmodified line
71	To compile this driver as a module, choose M here: the module will	72	To compile this driver as a module, choose M here: the module will
72	be called pms7003.	73	be called pms7003.
73		74
		75	config SENSIRION_SGP30
		76	tristate "Sensirion SGPxx gas sensors"
		77	depends on I2C
		78	select CRC8
		79	help
		80	Say Y here to build I2C interface support for the following
		81	Sensirion SGP gas sensors:
		82	* SGP30 gas sensor
		83	* SGPC3 low power gas sensor
		84
		85	To compile this driver as module, choose M here: the
		86	module will be called sgp30.
		87
74	config SPS30	88	config SPS30
75	tristate "SPS30 particulate matter sensor"	89	tristate "SPS30 particulate matter sensor"
76	depends on I2C	90	depends on I2C

drivers/iio/chemical/bme680.h+2−4

 #ifndef BME680_H_
 #define BME680_H_
-#define BME680_REG_CHIP_I2C_ID			0xD0
+#define BME680_REG_CHIP_ID			0xD0
-#define BME680_REG_CHIP_SPI_ID			0x50
 #define   BME680_CHIP_ID_VAL			0x61
-#define BME680_REG_SOFT_RESET_I2C		0xE0
+#define BME680_REG_SOFT_RESET			0xE0
-#define BME680_REG_SOFT_RESET_SPI		0x60
 #define   BME680_CMD_SOFTRESET			0xB6
 #define BME680_REG_STATUS			0x73
 #define   BME680_SPI_MEM_PAGE_BIT		BIT(4)

drivers/iio/chemical/bme680_core.c+45−9

 	s32 t_fine;
 };
+static const struct regmap_range bme680_volatile_ranges[] = {
+	regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB),
+	regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS),
+	regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG),
+};
+static const struct regmap_access_table bme680_volatile_table = {
+	.yes_ranges	= bme680_volatile_ranges,
+	.n_yes_ranges	= ARRAY_SIZE(bme680_volatile_ranges),
+};
 const struct regmap_config bme680_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
+	.max_register = 0xef,
+	.volatile_table = &bme680_volatile_table,
+	.cache_type = REGCACHE_RBTREE,
 };
 EXPORT_SYMBOL(bme680_regmap_config);
 	s64 var1, var2, var3;
 	s16 calc_temp;
+	/* If the calibration is invalid, attempt to reload it */
+	if (!calib->par_t2)
+		bme680_read_calib(data, calib);
 	var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
 	var2 = (var1 * calib->par_t2) >> 11;
 	var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
 	return ret;
 }
-static int bme680_read_temp(struct bme680_data *data,
+static int bme680_read_temp(struct bme680_data *data, int *val)
-			    int *val, int *val2)
 {
 	struct device *dev = regmap_get_device(data->regmap);
 	int ret;
 	 * compensate_press/compensate_humid to get compensated
 	 * pressure/humidity readings.
 	 */
-	if (val && val2) {
+	if (val) {
-		*val = comp_temp;
+		*val = comp_temp * 10; /* Centidegrees to millidegrees */
-		*val2 = 100;
+		return IIO_VAL_INT;
-		return IIO_VAL_FRACTIONAL;
 	}
 	return ret;
 	s32 adc_press;
 	/* Read and compensate temperature to get a reading of t_fine */
-	ret = bme680_read_temp(data, NULL, NULL);
+	ret = bme680_read_temp(data, NULL);
 	if (ret < 0)
 		return ret;
 	u32 comp_humidity;
 	/* Read and compensate temperature to get a reading of t_fine */
-	ret = bme680_read_temp(data, NULL, NULL);
+	ret = bme680_read_temp(data, NULL);
 	if (ret < 0)
 		return ret;
 	case IIO_CHAN_INFO_PROCESSED:
 		switch (chan->type) {
 		case IIO_TEMP:
-			return bme680_read_temp(data, val, val2);
+			return bme680_read_temp(data, val);
 		case IIO_PRESSURE:
 			return bme680_read_press(data, val, val2);
 		case IIO_HUMIDITYRELATIVE:
 {
 	struct iio_dev *indio_dev;
 	struct bme680_data *data;
+	unsigned int val;
 	int ret;
+	ret = regmap_write(regmap, BME680_REG_SOFT_RESET,
+			   BME680_CMD_SOFTRESET);
+	if (ret < 0) {
+		dev_err(dev, "Failed to reset chip\n");
+		return ret;
+	}
+	ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val);
+	if (ret < 0) {
+		dev_err(dev, "Error reading chip ID\n");
+		return ret;
+	}
+	if (val != BME680_CHIP_ID_VAL) {
+		dev_err(dev, "Wrong chip ID, got %x expected %x\n",
+				val, BME680_CHIP_ID_VAL);
+		return -ENODEV;
+	}
 	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 	if (!indio_dev)
 		return -ENOMEM;

drivers/iio/chemical/bme680_i2c.c+0−21

@@ -23,8 +23,6 @@ static int bme680_i2c_probe(struct i2c_client *client, · 22 unmodified lines
23	{	23	{
24	struct regmap *regmap;	24	struct regmap *regmap;
25	const char *name = NULL;	25	const char *name = NULL;
26	unsigned int val;
27	int ret;
28		26
29	regmap = devm_regmap_init_i2c(client, &bme680_regmap_config);	27	regmap = devm_regmap_init_i2c(client, &bme680_regmap_config);
30	if (IS_ERR(regmap)) {	28	if (IS_ERR(regmap)) {
@@ -33,25 +31,6 @@ static int bme680_i2c_probe(struct i2c_client *client, · 2 unmodified lines
33	return PTR_ERR(regmap);	31	return PTR_ERR(regmap);
34	}	32	}
35		33
36	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_I2C,
37	BME680_CMD_SOFTRESET);
38	if (ret < 0) {
39	dev_err(&client->dev, "Failed to reset chip\n");
40	return ret;
41	}
42
43	ret = regmap_read(regmap, BME680_REG_CHIP_I2C_ID, &val);
44	if (ret < 0) {
45	dev_err(&client->dev, "Error reading I2C chip ID\n");
46	return ret;
47	}
48
49	if (val != BME680_CHIP_ID_VAL) {
50	dev_err(&client->dev, "Wrong chip ID, got %x expected %x\n",
51	val, BME680_CHIP_ID_VAL);
52	return -ENODEV;
53	}
54
55	if (id)	34	if (id)
56	name = id->name;	35	name = id->name;
57		36

drivers/iio/chemical/bme680_spi.c+78−37

 #include "bme680.h"
+struct bme680_spi_bus_context {
+	struct spi_device *spi;
+	u8 current_page;
+};
+/*
+ * In SPI mode there are only 7 address bits, a "page" register determines
+ * which part of the 8-bit range is active. This function looks at the address
+ * and writes the page selection bit if needed
+ */
+static int bme680_regmap_spi_select_page(
+	struct bme680_spi_bus_context *ctx, u8 reg)
+{
+	struct spi_device *spi = ctx->spi;
+	int ret;
+	u8 buf[2];
+	u8 page = (reg & 0x80) ? 0 : 1; /* Page "1" is low range */
+	if (page == ctx->current_page)
+		return 0;
+	/*
+	 * Data sheet claims we're only allowed to change bit 4, so we must do
+	 * a read-modify-write on each and every page select
+	 */
+	buf[0] = BME680_REG_STATUS;
+	ret = spi_write_then_read(spi, buf, 1, buf + 1, 1);
+	if (ret < 0) {
+		dev_err(&spi->dev, "failed to set page %u\n", page);
+		return ret;
+	}
+	buf[0] = BME680_REG_STATUS;
+	if (page)
+		buf[1] |= BME680_SPI_MEM_PAGE_BIT;
+	else
+		buf[1] &= ~BME680_SPI_MEM_PAGE_BIT;
+	ret = spi_write(spi, buf, 2);
+	if (ret < 0) {
+		dev_err(&spi->dev, "failed to set page %u\n", page);
+		return ret;
+	}
+	ctx->current_page = page;
+	return 0;
+}
 static int bme680_regmap_spi_write(void *context, const void *data,
 				   size_t count)
 {
-	struct spi_device *spi = context;
+	struct bme680_spi_bus_context *ctx = context;
+	struct spi_device *spi = ctx->spi;
+	int ret;
 	u8 buf[2];
 	memcpy(buf, data, 2);
+	ret = bme680_regmap_spi_select_page(ctx, buf[0]);
+	if (ret)
+		return ret;
 	/*
 	 * The SPI register address (= full register address without bit 7)
 	 * and the write command (bit7 = RW = '0')
 	 */
 	buf[0] &= ~0x80;
-	return spi_write_then_read(spi, buf, 2, NULL, 0);
+	return spi_write(spi, buf, 2);
 }
 static int bme680_regmap_spi_read(void *context, const void *reg,
 				  size_t reg_size, void *val, size_t val_size)
 {
-	struct spi_device *spi = context;
+	struct bme680_spi_bus_context *ctx = context;
+	struct spi_device *spi = ctx->spi;
+	int ret;
+	u8 addr = *(const u8 *)reg;
+	ret = bme680_regmap_spi_select_page(ctx, addr);
+	if (ret)
+		return ret;
-	return spi_write_then_read(spi, reg, reg_size, val, val_size);
+	addr |= 0x80; /* bit7 = RW = '1' */
+	return spi_write_then_read(spi, &addr, 1, val, val_size);
 }
 static struct regmap_bus bme680_regmap_bus = {
 static int bme680_spi_probe(struct spi_device *spi)
 {
 	const struct spi_device_id *id = spi_get_device_id(spi);
+	struct bme680_spi_bus_context *bus_context;
 	struct regmap *regmap;
-	unsigned int val;
 	int ret;
 	spi->bits_per_word = 8;
 		return ret;
 	}
+	bus_context = devm_kzalloc(&spi->dev, sizeof(*bus_context), GFP_KERNEL);
+	if (!bus_context)
+		return -ENOMEM;
+	bus_context->spi = spi;
+	bus_context->current_page = 0xff; /* Undefined on warm boot */
 	regmap = devm_regmap_init(&spi->dev, &bme680_regmap_bus,
-				  &spi->dev, &bme680_regmap_config);
+				  bus_context, &bme680_regmap_config);
 	if (IS_ERR(regmap)) {
 		dev_err(&spi->dev, "Failed to register spi regmap %d\n",
 				(int)PTR_ERR(regmap));
 		return PTR_ERR(regmap);
 	}
-	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_SPI,
-			   BME680_CMD_SOFTRESET);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Failed to reset chip\n");
-		return ret;
-	}
-	/* after power-on reset, Page 0(0x80-0xFF) of spi_mem_page is active */
-	ret = regmap_read(regmap, BME680_REG_CHIP_SPI_ID, &val);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Error reading SPI chip ID\n");
-		return ret;
-	}
-	if (val != BME680_CHIP_ID_VAL) {
-		dev_err(&spi->dev, "Wrong chip ID, got %x expected %x\n",
-				val, BME680_CHIP_ID_VAL);
-		return -ENODEV;
-	}
-	/*
-	 * select Page 1 of spi_mem_page to enable access to
-	 * to registers from address 0x00 to 0x7F.
-	 */
-	ret = regmap_write_bits(regmap, BME680_REG_STATUS,
-				BME680_SPI_MEM_PAGE_BIT,
-				BME680_SPI_MEM_PAGE_1_VAL);
-	if (ret < 0) {
-		dev_err(&spi->dev, "failed to set page 1 of spi_mem_page\n");
-		return ret;
-	}
 	return bme680_core_probe(&spi->dev, regmap, id->name);
 }

drivers/iio/common/cros_ec_sensors/cros_ec_sensors.c+4−3

 			 * Do not use IIO_DEGREE_TO_RAD to avoid precision
 			 * loss. Round to the nearest integer.
 			 */
-			*val = div_s64(val64 * 314159 + 9000000ULL, 1000);
+			*val = 0;
-			*val2 = 18000 << (CROS_EC_SENSOR_BITS - 1);
+			*val2 = div_s64(val64 * 3141592653ULL,
-			ret = IIO_VAL_FRACTIONAL;
+					180 << (CROS_EC_SENSOR_BITS - 1));
+			ret = IIO_VAL_INT_PLUS_NANO;
 			break;
 		case MOTIONSENSE_TYPE_MAG:
 			/*

drivers/iio/dac/mcp4725.c+1−0

@@ -92,6 +92,7 @@ static ssize_t mcp4725_store_eeprom(struct device *dev, · 91 unmodified lines
92		92
93	inoutbuf[0] = 0x60; /* write EEPROM */	93	inoutbuf[0] = 0x60; /* write EEPROM */
94	inoutbuf[0] \|= data->ref_mode << 3;	94	inoutbuf[0] \|= data->ref_mode << 3;
		95	inoutbuf[0] \|= data->powerdown ? ((data->powerdown_mode + 1) << 1) : 0;
95	inoutbuf[1] = data->dac_value >> 4;	96	inoutbuf[1] = data->dac_value >> 4;
96	inoutbuf[2] = (data->dac_value & 0xf) << 4;	97	inoutbuf[2] = (data->dac_value & 0xf) << 4;
97		98

drivers/iio/gyro/bmg160_core.c+3−3

 	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 		return bmg160_get_filter(data, val);
 	case IIO_CHAN_INFO_SCALE:
-		*val = 0;
 		switch (chan->type) {
 		case IIO_TEMP:
-			*val2 = 500000;
+			*val = 500;
-			return IIO_VAL_INT_PLUS_MICRO;
+			return IIO_VAL_INT;
 		case IIO_ANGL_VEL:
 		{
 			int i;
 			for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 				if (bmg160_scale_table[i].dps_range ==
 							data->dps_range) {
+					*val = 0;
 					*val2 = bmg160_scale_table[i].scale;
 					return IIO_VAL_INT_PLUS_MICRO;
 				}

drivers/iio/gyro/mpu3050-core.c+5−3

 #include "mpu3050.h"
-#define MPU3050_CHIP_ID		0x69
+#define MPU3050_CHIP_ID		0x68
+#define MPU3050_CHIP_ID_MASK	0x7E
 /*
  * Register map: anything suffixed *_H is a big-endian high byte and always
 		goto err_power_down;
 	}
-	if (val != MPU3050_CHIP_ID) {
+	if ((val & MPU3050_CHIP_ID_MASK) != MPU3050_CHIP_ID) {
-		dev_err(dev, "unsupported chip id %02x\n", (u8)val);
+		dev_err(dev, "unsupported chip id %02x\n",
+				(u8)(val & MPU3050_CHIP_ID_MASK));
 		ret = -ENODEV;
 		goto err_power_down;
 	}

drivers/iio/industrialio-buffer.c+2−3

 	const unsigned long *mask;
 	unsigned long *trialmask;
-	trialmask = kmalloc_array(BITS_TO_LONGS(indio_dev->masklength),
+	trialmask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
-				  sizeof(*trialmask),
+			    sizeof(*trialmask), GFP_KERNEL);
-				  GFP_KERNEL);
 	if (trialmask == NULL)
 		return -ENOMEM;
 	if (!indio_dev->masklength) {

drivers/iio/industrialio-core.c+2−2

  **/
 void iio_device_unregister(struct iio_dev *indio_dev)
 {
-	mutex_lock(&indio_dev->info_exist_lock);
 	cdev_device_del(&indio_dev->chrdev, &indio_dev->dev);
+	mutex_lock(&indio_dev->info_exist_lock);
 	iio_device_unregister_debugfs(indio_dev);
 	iio_disable_all_buffers(indio_dev);

drivers/infiniband/core/uverbs_main.c+3−0

 		 * will only be one mm, so no big deal.
 		 */
 		down_write(&mm->mmap_sem);
+		if (!mmget_still_valid(mm))
+			goto skip_mm;
 		mutex_lock(&ufile->umap_lock);
 		list_for_each_entry_safe (priv, next_priv, &ufile->umaps,
 					  list) {
 			vma->vm_flags &= ~(VM_SHARED | VM_MAYSHARE);
 		}
 		mutex_unlock(&ufile->umap_lock);
+	skip_mm:
 		up_write(&mm->mmap_sem);
 		mmput(mm);
 	}

drivers/input/keyboard/snvs_pwrkey.c+3−3

 		return error;
 	}
+	pdata->input = input;
+	platform_set_drvdata(pdev, pdata);
 	error = devm_request_irq(&pdev->dev, pdata->irq,
 			       imx_snvs_pwrkey_interrupt,
 			       0, pdev->name, pdev);
 		return error;
 	}
-	pdata->input = input;
-	platform_set_drvdata(pdev, pdata);
 	device_init_wakeup(&pdev->dev, pdata->wakeup);
 	return 0;

drivers/input/mouse/elan_i2c_core.c+25−0

@@ -1339,21 +1339,46 @@ static const struct acpi_device_id elan_acpi_id[] = { · 1338 unmodified lines
1339	{ "ELAN0600", 0 },	1339	{ "ELAN0600", 0 },
1340	{ "ELAN0601", 0 },	1340	{ "ELAN0601", 0 },
1341	{ "ELAN0602", 0 },	1341	{ "ELAN0602", 0 },
		1342	{ "ELAN0603", 0 },
		1343	{ "ELAN0604", 0 },
1342	{ "ELAN0605", 0 },	1344	{ "ELAN0605", 0 },
		1345	{ "ELAN0606", 0 },
		1346	{ "ELAN0607", 0 },
1343	{ "ELAN0608", 0 },	1347	{ "ELAN0608", 0 },
1344	{ "ELAN0609", 0 },	1348	{ "ELAN0609", 0 },
1345	{ "ELAN060B", 0 },	1349	{ "ELAN060B", 0 },
1346	{ "ELAN060C", 0 },	1350	{ "ELAN060C", 0 },
		1351	{ "ELAN060F", 0 },
		1352	{ "ELAN0610", 0 },
1347	{ "ELAN0611", 0 },	1353	{ "ELAN0611", 0 },
1348	{ "ELAN0612", 0 },	1354	{ "ELAN0612", 0 },
		1355	{ "ELAN0615", 0 },
		1356	{ "ELAN0616", 0 },
1349	{ "ELAN0617", 0 },	1357	{ "ELAN0617", 0 },
1350	{ "ELAN0618", 0 },	1358	{ "ELAN0618", 0 },
		1359	{ "ELAN0619", 0 },
		1360	{ "ELAN061A", 0 },
		1361	{ "ELAN061B", 0 },
1351	{ "ELAN061C", 0 },	1362	{ "ELAN061C", 0 },
1352	{ "ELAN061D", 0 },	1363	{ "ELAN061D", 0 },
1353	{ "ELAN061E", 0 },	1364	{ "ELAN061E", 0 },
		1365	{ "ELAN061F", 0 },
1354	{ "ELAN0620", 0 },	1366	{ "ELAN0620", 0 },
1355	{ "ELAN0621", 0 },	1367	{ "ELAN0621", 0 },
1356	{ "ELAN0622", 0 },	1368	{ "ELAN0622", 0 },
		1369	{ "ELAN0623", 0 },
		1370	{ "ELAN0624", 0 },
		1371	{ "ELAN0625", 0 },
		1372	{ "ELAN0626", 0 },
		1373	{ "ELAN0627", 0 },
		1374	{ "ELAN0628", 0 },
		1375	{ "ELAN0629", 0 },
		1376	{ "ELAN062A", 0 },
		1377	{ "ELAN062B", 0 },
		1378	{ "ELAN062C", 0 },
		1379	{ "ELAN062D", 0 },
		1380	{ "ELAN0631", 0 },
		1381	{ "ELAN0632", 0 },
1357	{ "ELAN1000", 0 },	1382	{ "ELAN1000", 0 },
1358	{ }	1383	{ }
1359	};	1384	};

drivers/irqchip/irq-ath79-misc.c+11−0

 #define AR71XX_RESET_REG_MISC_INT_ENABLE	4
 #define ATH79_MISC_IRQ_COUNT			32
+#define ATH79_MISC_PERF_IRQ			5
+static int ath79_perfcount_irq;
+int get_c0_perfcount_int(void)
+{
+	return ath79_perfcount_irq;
+}
+EXPORT_SYMBOL_GPL(get_c0_perfcount_int);
 static void ath79_misc_irq_handler(struct irq_desc *desc)
 {
 {
 	void __iomem *base = domain->host_data;
+	ath79_perfcount_irq = irq_create_mapping(domain, ATH79_MISC_PERF_IRQ);
 	/* Disable and clear all interrupts */
 	__raw_writel(0, base + AR71XX_RESET_REG_MISC_INT_ENABLE);
 	__raw_writel(0, base + AR71XX_RESET_REG_MISC_INT_STATUS);

drivers/misc/fastrpc.c+6−1

 	struct fastrpc_session_ctx *sess;
 	struct device *dev = &pdev->dev;
 	int i, sessions = 0;
+	int rc;
 	cctx = dev_get_drvdata(dev->parent);
 	if (!cctx)
 	}
 	cctx->sesscount++;
 	spin_unlock(&cctx->lock);
-	dma_set_mask(dev, DMA_BIT_MASK(32));
+	rc = dma_set_mask(dev, DMA_BIT_MASK(32));
+	if (rc) {
+		dev_err(dev, "32-bit DMA enable failed\n");
+		return rc;
+	}
 	return 0;
 }

drivers/misc/habanalabs/goya/goya.c+4−5

 	/*
 	 * Workaround for H2 #HW-23 bug
-	 * Set DMA max outstanding read requests to 240 on DMA CH 1. Set it
+	 * Set DMA max outstanding read requests to 240 on DMA CH 1.
-	 * to 16 on KMD DMA
+	 * This limitation is still large enough to not affect Gen4 bandwidth.
-	 * We need to limit only these DMAs because the user can only read
+	 * We need to only limit that DMA channel because the user can only read
 	 * from Host using DMA CH 1
 	 */
-	WREG32(mmDMA_CH_0_CFG0, 0x0fff0010);
 	WREG32(mmDMA_CH_1_CFG0, 0x0fff00F0);
 	goya->hw_cap_initialized |= HW_CAP_GOLDEN;
 	 * WA for HW-23.
 	 * We can't allow user to read from Host using QMANs other than 1.
 	 */
-	if (parser->hw_queue_id > GOYA_QUEUE_ID_DMA_1 &&
+	if (parser->hw_queue_id != GOYA_QUEUE_ID_DMA_1 &&
 		hl_mem_area_inside_range(le64_to_cpu(user_dma_pkt->src_addr),
 				le32_to_cpu(user_dma_pkt->tsize),
 				hdev->asic_prop.va_space_host_start_address,

drivers/net/ethernet/atheros/atlx/atl1.c+2−2

drivers/net/ethernet/atheros/atlx/atl1.h+1−1

@@ -681,7 +681,7 @@ struct atl1_sft_stats { · 680 unmodified lines
681	u64 scc; /* packets TX after a single collision */	681	u64 scc; /* packets TX after a single collision */
682	u64 mcc; /* packets TX after multiple collisions */	682	u64 mcc; /* packets TX after multiple collisions */
683	u64 latecol; /* TX packets w/ late collisions */	683	u64 latecol; /* TX packets w/ late collisions */
684	u64 tx_underun; /* TX packets aborted due to TX FIFO underrun	684	u64 tx_underrun; /* TX packets aborted due to TX FIFO underrun
685	* or TRD FIFO underrun */	685	* or TRD FIFO underrun */
686	u64 tx_trunc; /* TX packets truncated due to size > MTU */	686	u64 tx_trunc; /* TX packets truncated due to size > MTU */
687	u64 rx_pause; /* num Pause packets received. */	687	u64 rx_pause; /* num Pause packets received. */

drivers/net/ethernet/atheros/atlx/atl2.c+1−1

@@ -553,7 +553,7 @@ static void atl2_intr_tx(struct atl2_adapter *adapter) · 552 unmodified lines
553	netdev->stats.tx_aborted_errors++;	553	netdev->stats.tx_aborted_errors++;
554	if (txs->late_col)	554	if (txs->late_col)
555	netdev->stats.tx_window_errors++;	555	netdev->stats.tx_window_errors++;
556	if (txs->underun)	556	if (txs->underrun)
557	netdev->stats.tx_fifo_errors++;	557	netdev->stats.tx_fifo_errors++;
558	} while (1);	558	} while (1);
559		559

drivers/net/ethernet/atheros/atlx/atl2.h+1−1

@@ -260,7 +260,7 @@ struct tx_pkt_status { · 259 unmodified lines
260	unsigned multi_col:1;	260	unsigned multi_col:1;
261	unsigned late_col:1;	261	unsigned late_col:1;
262	unsigned abort_col:1;	262	unsigned abort_col:1;
263	unsigned underun:1; /* current packet is aborted	263	unsigned underrun:1; /* current packet is aborted
264	* due to txram underrun */	264	* due to txram underrun */
265	unsigned:3; /* reserved */	265	unsigned:3; /* reserved */
266	unsigned update:1; /* always 1'b1 in tx_status_buf */	266	unsigned update:1; /* always 1'b1 in tx_status_buf */

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c+22−2

 #include <linux/bpf_trace.h>
 #include "en/xdp.h"
+int mlx5e_xdp_max_mtu(struct mlx5e_params *params)
+{
+	int hr = NET_IP_ALIGN + XDP_PACKET_HEADROOM;
+	/* Let S := SKB_DATA_ALIGN(sizeof(struct skb_shared_info)).
+	 * The condition checked in mlx5e_rx_is_linear_skb is:
+	 *   SKB_DATA_ALIGN(sw_mtu + hard_mtu + hr) + S <= PAGE_SIZE         (1)
+	 *   (Note that hw_mtu == sw_mtu + hard_mtu.)
+	 * What is returned from this function is:
+	 *   max_mtu = PAGE_SIZE - S - hr - hard_mtu                         (2)
+	 * After assigning sw_mtu := max_mtu, the left side of (1) turns to
+	 * SKB_DATA_ALIGN(PAGE_SIZE - S) + S, which is equal to PAGE_SIZE,
+	 * because both PAGE_SIZE and S are already aligned. Any number greater
+	 * than max_mtu would make the left side of (1) greater than PAGE_SIZE,
+	 * so max_mtu is the maximum MTU allowed.
+	 */
+	return MLX5E_HW2SW_MTU(params, SKB_MAX_HEAD(hr));
+}
 static inline bool
 mlx5e_xmit_xdp_buff(struct mlx5e_xdpsq *sq, struct mlx5e_dma_info *di,
 		    struct xdp_buff *xdp)
 					mlx5e_xdpi_fifo_pop(xdpi_fifo);
 				if (is_redirect) {
-					xdp_return_frame(xdpi.xdpf);
 					dma_unmap_single(sq->pdev, xdpi.dma_addr,
 							 xdpi.xdpf->len, DMA_TO_DEVICE);
+					xdp_return_frame(xdpi.xdpf);
 				} else {
 					/* Recycle RX page */
 					mlx5e_page_release(rq, &xdpi.di, true);
 				mlx5e_xdpi_fifo_pop(xdpi_fifo);
 			if (is_redirect) {
-				xdp_return_frame(xdpi.xdpf);
 				dma_unmap_single(sq->pdev, xdpi.dma_addr,
 						 xdpi.xdpf->len, DMA_TO_DEVICE);
+				xdp_return_frame(xdpi.xdpf);
 			} else {
 				/* Recycle RX page */
 				mlx5e_page_release(rq, &xdpi.di, false);

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

 #include "en.h"
-#define MLX5E_XDP_MAX_MTU ((int)(PAGE_SIZE - \
-				 MLX5_SKB_FRAG_SZ(XDP_PACKET_HEADROOM)))
 #define MLX5E_XDP_MIN_INLINE (ETH_HLEN + VLAN_HLEN)
 #define MLX5E_XDP_TX_EMPTY_DS_COUNT \
 	(sizeof(struct mlx5e_tx_wqe) / MLX5_SEND_WQE_DS)
 #define MLX5E_XDP_TX_DS_COUNT (MLX5E_XDP_TX_EMPTY_DS_COUNT + 1 /* SG DS */)
+int mlx5e_xdp_max_mtu(struct mlx5e_params *params);
 bool mlx5e_xdp_handle(struct mlx5e_rq *rq, struct mlx5e_dma_info *di,
 		      void *va, u16 *rx_headroom, u32 *len);
 bool mlx5e_poll_xdpsq_cq(struct mlx5e_cq *cq, struct mlx5e_rq *rq);

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

@@ -1586,7 +1586,7 @@ static int mlx5e_get_module_info(struct net_device *netdev, · 1585 unmodified lines
1586	break;	1586	break;
1587	case MLX5_MODULE_ID_SFP:	1587	case MLX5_MODULE_ID_SFP:
1588	modinfo->type = ETH_MODULE_SFF_8472;	1588	modinfo->type = ETH_MODULE_SFF_8472;
1589	modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;	1589	modinfo->eeprom_len = MLX5_EEPROM_PAGE_LENGTH;
1590	break;	1590	break;
1591	default:	1591	default:
1592	netdev_err(priv->netdev, "%s: cable type not recognized:0x%x\n",	1592	netdev_err(priv->netdev, "%s: cable type not recognized:0x%x\n",

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

 	if (params->xdp_prog &&
 	    !mlx5e_rx_is_linear_skb(&new_channels.params)) {
 		netdev_err(netdev, "MTU(%d) > %d is not allowed while XDP enabled\n",
-			   new_mtu, MLX5E_XDP_MAX_MTU);
+			   new_mtu, mlx5e_xdp_max_mtu(params));
 		err = -EINVAL;
 		goto out;
 	}
 	if (!mlx5e_rx_is_linear_skb(&new_channels.params)) {
 		netdev_warn(netdev, "XDP is not allowed with MTU(%d) > %d\n",
-			    new_channels.params.sw_mtu, MLX5E_XDP_MAX_MTU);
+			    new_channels.params.sw_mtu,
+			    mlx5e_xdp_max_mtu(&new_channels.params));
 		return -EINVAL;
 	}

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

 		size -= offset + size - MLX5_EEPROM_PAGE_LENGTH;
 	i2c_addr = MLX5_I2C_ADDR_LOW;
-	if (offset >= MLX5_EEPROM_PAGE_LENGTH) {
-		i2c_addr = MLX5_I2C_ADDR_HIGH;
-		offset -= MLX5_EEPROM_PAGE_LENGTH;
-	}
 	MLX5_SET(mcia_reg, in, l, 0);
 	MLX5_SET(mcia_reg, in, module, module_num);

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

@@ -27,7 +27,7 @@ · 26 unmodified lines
27		27
28	#define MLXSW_PCI_SW_RESET 0xF0010	28	#define MLXSW_PCI_SW_RESET 0xF0010
29	#define MLXSW_PCI_SW_RESET_RST_BIT BIT(0)	29	#define MLXSW_PCI_SW_RESET_RST_BIT BIT(0)
30	#define MLXSW_PCI_SW_RESET_TIMEOUT_MSECS 13000	30	#define MLXSW_PCI_SW_RESET_TIMEOUT_MSECS 20000
31	#define MLXSW_PCI_SW_RESET_WAIT_MSECS 100	31	#define MLXSW_PCI_SW_RESET_WAIT_MSECS 100
32	#define MLXSW_PCI_FW_READY 0xA1844	32	#define MLXSW_PCI_FW_READY 0xA1844
33	#define MLXSW_PCI_FW_READY_MASK 0xFFFF	33	#define MLXSW_PCI_FW_READY_MASK 0xFFFF

drivers/net/ethernet/mellanox/mlxsw/spectrum.c+3−3

 	if (err)
 		return err;
+	mlxsw_sp_port->link.autoneg = autoneg;
 	if (!netif_running(dev))
 		return 0;
-	mlxsw_sp_port->link.autoneg = autoneg;
 	mlxsw_sp_port_admin_status_set(mlxsw_sp_port, false);
 	mlxsw_sp_port_admin_status_set(mlxsw_sp_port, true);
 		err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
 					    MLXSW_REG_QEEC_HIERARCY_TC,
 					    i + 8, i,
-					    false, 0);
+					    true, 100);
 		if (err)
 			return err;
 	}

drivers/net/ethernet/netronome/nfp/abm/cls.c+2−2

@@ -39,7 +39,7 @@ nfp_abm_u32_check_knode(struct nfp_abm abm, struct tc_cls_u32_knode knode, · 38 unmodified lines
39	}	39	}
40	if (knode->sel->off \|\| knode->sel->offshift \|\| knode->sel->offmask \|\|	40	if (knode->sel->off \|\| knode->sel->offshift \|\| knode->sel->offmask \|\|
41	knode->sel->offoff \|\| knode->fshift) {	41	knode->sel->offoff \|\| knode->fshift) {
42	NL_SET_ERR_MSG_MOD(extack, "variable offseting not supported");	42	NL_SET_ERR_MSG_MOD(extack, "variable offsetting not supported");
43	return false;	43	return false;
44	}	44	}
45	if (knode->sel->hoff \|\| knode->sel->hmask) {	45	if (knode->sel->hoff \|\| knode->sel->hmask) {
@@ -78,7 +78,7 @@ nfp_abm_u32_check_knode(struct nfp_abm abm, struct tc_cls_u32_knode knode, · 32 unmodified lines
78		78
79	k = &knode->sel->keys[0];	79	k = &knode->sel->keys[0];
80	if (k->offmask) {	80	if (k->offmask) {
81	NL_SET_ERR_MSG_MOD(extack, "offset mask - variable offseting not supported");	81	NL_SET_ERR_MSG_MOD(extack, "offset mask - variable offsetting not supported");
82	return false;	82	return false;
83	}	83	}
84	if (k->off) {	84	if (k->off) {

drivers/net/ethernet/socionext/netsec.c+7−4

 }
 static void *netsec_alloc_rx_data(struct netsec_priv *priv,
-				  dma_addr_t *dma_handle, u16 *desc_len)
+				  dma_addr_t *dma_handle, u16 *desc_len,
+				  bool napi)
 {
 	size_t total_len = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 	size_t payload_len = NETSEC_RX_BUF_SZ;
 	total_len += SKB_DATA_ALIGN(payload_len + NETSEC_SKB_PAD);
-	buf = napi_alloc_frag(total_len);
+	buf = napi ? napi_alloc_frag(total_len) : netdev_alloc_frag(total_len);
 	if (!buf)
 		return NULL;
 		/* allocate a fresh buffer and map it to the hardware.
 		 * This will eventually replace the old buffer in the hardware
 		 */
-		buf_addr = netsec_alloc_rx_data(priv, &dma_handle, &desc_len);
+		buf_addr = netsec_alloc_rx_data(priv, &dma_handle, &desc_len,
+						true);
 		if (unlikely(!buf_addr))
 			break;
 		void *buf;
 		u16 len;
-		buf = netsec_alloc_rx_data(priv, &dma_handle, &len);
+		buf = netsec_alloc_rx_data(priv, &dma_handle, &len,
+					   false);
 		if (!buf) {
 			netsec_uninit_pkt_dring(priv, NETSEC_RING_RX);
 			goto err_out;

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

@@ -140,7 +140,7 @@ static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode, · 139 unmodified lines
140	p->des0 \|= cpu_to_le32(RDES0_OWN);	140	p->des0 \|= cpu_to_le32(RDES0_OWN);
141		141
142	bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1);	142	bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1);
143	p->des1 \|= cpu_to_le32(bfsize & RDES1_BUFFER1_SIZE_MASK);	143	p->des1 \|= cpu_to_le32(bfsize1 & RDES1_BUFFER1_SIZE_MASK);
144		144
145	if (mode == STMMAC_CHAIN_MODE)	145	if (mode == STMMAC_CHAIN_MODE)
146	ndesc_rx_set_on_chain(p, end);	146	ndesc_rx_set_on_chain(p, end);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+2−2

 	u32 chan;
 	int ret;
-	stmmac_check_ether_addr(priv);
 	if (priv->hw->pcs != STMMAC_PCS_RGMII &&
 	    priv->hw->pcs != STMMAC_PCS_TBI &&
 	    priv->hw->pcs != STMMAC_PCS_RTBI) {
 	if (ret)
 		goto error_hw_init;
+	stmmac_check_ether_addr(priv);
 	/* Configure real RX and TX queues */
 	netif_set_real_num_rx_queues(ndev, priv->plat->rx_queues_to_use);
 	netif_set_real_num_tx_queues(ndev, priv->plat->tx_queues_to_use);

drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c+6−2

 		},
 		.driver_data = (void *)&galileo_stmmac_dmi_data,
 	},
+	/*
+	 * There are 2 types of SIMATIC IOT2000: IOT20202 and IOT2040.
+	 * The asset tag "6ES7647-0AA00-0YA2" is only for IOT2020 which
+	 * has only one pci network device while other asset tags are
+	 * for IOT2040 which has two.
+	 */
 	{
 		.matches = {
 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 	{
 		.matches = {
 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
-			DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
-					"6ES7647-0AA00-1YA2"),
 		},
 		.driver_data = (void *)&iot2040_stmmac_dmi_data,
 	},

drivers/net/phy/spi_ks8995.c+9−0

 };
 MODULE_DEVICE_TABLE(spi, ks8995_id);
+static const struct of_device_id ks8895_spi_of_match[] = {
+        { .compatible = "micrel,ks8995" },
+        { .compatible = "micrel,ksz8864" },
+        { .compatible = "micrel,ksz8795" },
+        { },
+ };
+MODULE_DEVICE_TABLE(of, ks8895_spi_of_match);
 static inline u8 get_chip_id(u8 val)
 {
 	return (val >> ID1_CHIPID_S) & ID1_CHIPID_M;
 static struct spi_driver ks8995_driver = {
 	.driver = {
 		.name	    = "spi-ks8995",
+		.of_match_table = of_match_ptr(ks8895_spi_of_match),
 	},
 	.probe	  = ks8995_probe,
 	.remove	  = ks8995_remove,

drivers/net/team/team.c+7−0

@@ -1154,6 +1154,13 @@ static int team_port_add(struct team team, struct net_device port_dev, · 1153 unmodified lines
1154	return -EINVAL;	1154	return -EINVAL;
1155	}	1155	}
1156		1156
		1157	if (netdev_has_upper_dev(dev, port_dev)) {
		1158	NL_SET_ERR_MSG(extack, "Device is already an upper device of the team interface");
		1159	netdev_err(dev, "Device %s is already an upper device of the team interface\n",
		1160	portname);
		1161	return -EBUSY;
		1162	}
		1163
1157	if (port_dev->features & NETIF_F_VLAN_CHALLENGED &&	1164	if (port_dev->features & NETIF_F_VLAN_CHALLENGED &&
1158	vlan_uses_dev(dev)) {	1165	vlan_uses_dev(dev)) {
1159	NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up");	1166	NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up");

drivers/net/vrf.c+2−0

 	.ndo_init		= vrf_dev_init,
 	.ndo_uninit		= vrf_dev_uninit,
 	.ndo_start_xmit		= vrf_xmit,
+	.ndo_set_mac_address	= eth_mac_addr,
 	.ndo_get_stats64	= vrf_get_stats64,
 	.ndo_add_slave		= vrf_add_slave,
 	.ndo_del_slave		= vrf_del_slave,
 	/* default to no qdisc; user can add if desired */
 	dev->priv_flags |= IFF_NO_QUEUE;
 	dev->priv_flags |= IFF_NO_RX_HANDLER;
+	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 	/* VRF devices do not care about MTU, but if the MTU is set
 	 * too low then the ipv4 and ipv6 protocols are disabled

drivers/nfc/st95hf/core.c+7−0

 };
 MODULE_DEVICE_TABLE(spi, st95hf_id);
+static const struct of_device_id st95hf_spi_of_match[] = {
+        { .compatible = "st,st95hf" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, st95hf_spi_of_match);
 static int st95hf_probe(struct spi_device *nfc_spi_dev)
 {
 	int ret;
 	.driver = {
 		.name = "st95hf",
 		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(st95hf_spi_of_match),
 	},
 	.id_table = st95hf_id,
 	.probe = st95hf_probe,

drivers/of/of_net.c+0−1

@@ -7,7 +7,6 @@ · 6 unmodified lines
7	*/	7	*/
8	#include <linux/etherdevice.h>	8	#include <linux/etherdevice.h>
9	#include <linux/kernel.h>	9	#include <linux/kernel.h>
10	#include <linux/nvmem-consumer.h>
11	#include <linux/of_net.h>	10	#include <linux/of_net.h>
12	#include <linux/phy.h>	11	#include <linux/phy.h>
13	#include <linux/export.h>	12	#include <linux/export.h>

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

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* Power supply driver for the goldfish emulator	3	* Power supply driver for the goldfish emulator
4	*	4	*

drivers/s390/block/dasd_eckd.c+3−3

@@ -2004,14 +2004,14 @@ static int dasd_eckd_end_analysis(struct dasd_block *block) · 2003 unmodified lines
2004	blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);	2004	blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
2005		2005
2006	raw:	2006	raw:
2007	block->blocks = (private->real_cyl *	2007	block->blocks = ((unsigned long) private->real_cyl *
2008	private->rdc_data.trk_per_cyl *	2008	private->rdc_data.trk_per_cyl *
2009	blk_per_trk);	2009	blk_per_trk);
2010		2010
2011	dev_info(&device->cdev->dev,	2011	dev_info(&device->cdev->dev,
2012	"DASD with %d KB/block, %d KB total size, %d KB/track, "	2012	"DASD with %u KB/block, %lu KB total size, %u KB/track, "
2013	"%s\n", (block->bp_block >> 10),	2013	"%s\n", (block->bp_block >> 10),
2014	((private->real_cyl *	2014	(((unsigned long) private->real_cyl *
2015	private->rdc_data.trk_per_cyl *	2015	private->rdc_data.trk_per_cyl *
2016	blk_per_trk * (block->bp_block >> 9)) >> 1),	2016	blk_per_trk * (block->bp_block >> 9)) >> 1),
2017	((blk_per_trk * block->bp_block) >> 10),	2017	((blk_per_trk * block->bp_block) >> 10),

drivers/s390/char/con3270.c+1−1

@@ -629,7 +629,7 @@ con3270_init(void) · 628 unmodified lines
629	(void (*)(unsigned long)) con3270_read_tasklet,	629	(void (*)(unsigned long)) con3270_read_tasklet,
630	(unsigned long) condev->read);	630	(unsigned long) condev->read);
631		631
632	raw3270_add_view(&condev->view, &con3270_fn, 1);	632	raw3270_add_view(&condev->view, &con3270_fn, 1, RAW3270_VIEW_LOCK_IRQ);
633		633
634	INIT_LIST_HEAD(&condev->freemem);	634	INIT_LIST_HEAD(&condev->freemem);
635	for (i = 0; i < CON3270_STRING_PAGES; i++) {	635	for (i = 0; i < CON3270_STRING_PAGES; i++) {

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

@@ -463,7 +463,8 @@ fs3270_open(struct inode inode, struct file filp) · 462 unmodified lines
463		463
464	init_waitqueue_head(&fp->wait);	464	init_waitqueue_head(&fp->wait);
465	fp->fs_pid = get_pid(task_pid(current));	465	fp->fs_pid = get_pid(task_pid(current));
466	rc = raw3270_add_view(&fp->view, &fs3270_fn, minor);	466	rc = raw3270_add_view(&fp->view, &fs3270_fn, minor,
		467	RAW3270_VIEW_LOCK_BH);
467	if (rc) {	468	if (rc) {
468	fs3270_free_view(&fp->view);	469	fs3270_free_view(&fp->view);
469	goto out;	470	goto out;

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

  * Add view to device with minor "minor".
  */
 int
-raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
+raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
 {
 	unsigned long flags;
 	struct raw3270 *rp;
 		view->cols = rp->cols;
 		view->ascebc = rp->ascebc;
 		spin_lock_init(&view->lock);
+		lockdep_set_subclass(&view->lock, subclass);
 		list_add(&view->list, &rp->view_list);
 		rc = 0;
 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);

drivers/s390/char/raw3270.h+3−1

 struct raw3270_view {
 	struct list_head list;
 	spinlock_t lock;
+#define RAW3270_VIEW_LOCK_IRQ	0
+#define RAW3270_VIEW_LOCK_BH	1
 	atomic_t ref_count;
 	struct raw3270 *dev;
 	struct raw3270_fn *fn;
 	unsigned char *ascebc;		/* ascii -> ebcdic table */
 };
-int raw3270_add_view(struct raw3270_view *, struct raw3270_fn *, int);
+int raw3270_add_view(struct raw3270_view *, struct raw3270_fn *, int, int);
 int raw3270_activate_view(struct raw3270_view *);
 void raw3270_del_view(struct raw3270_view *);
 void raw3270_deactivate_view(struct raw3270_view *);

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

@@ -980,7 +980,8 @@ static int tty3270_install(struct tty_driver driver, struct tty_struct tty) · 979 unmodified lines
980	return PTR_ERR(tp);	980	return PTR_ERR(tp);
981		981
982	rc = raw3270_add_view(&tp->view, &tty3270_fn,	982	rc = raw3270_add_view(&tp->view, &tty3270_fn,
983	tty->index + RAW3270_FIRSTMINOR);	983	tty->index + RAW3270_FIRSTMINOR,
		984	RAW3270_VIEW_LOCK_BH);
984	if (rc) {	985	if (rc) {
985	tty3270_free_view(tp);	986	tty3270_free_view(tp);
986	return rc;	987	return rc;

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

 	__ap_flush_queue(aq);
 	/* set REMOVE state to prevent new messages are queued in */
 	aq->state = AP_STATE_REMOVE;
-	del_timer_sync(&aq->timeout);
 	spin_unlock_bh(&aq->lock);
+	del_timer_sync(&aq->timeout);
 }
 void ap_queue_remove(struct ap_queue *aq)

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

@@ -51,7 +51,8 @@ static debug_info_t *debug_info; · 50 unmodified lines
51		51
52	static void __init pkey_debug_init(void)	52	static void __init pkey_debug_init(void)
53	{	53	{
54	debug_info = debug_register("pkey", 1, 1, 4 * sizeof(long));	54	/* 5 arguments per dbf entry (including the format string ptr) */
		55	debug_info = debug_register("pkey", 1, 1, 5 * sizeof(long));
55	debug_register_view(debug_info, &debug_sprintf_view);	56	debug_register_view(debug_info, &debug_sprintf_view);
56	debug_set_level(debug_info, 3);	57	debug_set_level(debug_info, 3);
57	}	58	}

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

@@ -1595,6 +1595,7 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev) · 1594 unmodified lines
1595	if (priv->channel[direction] == NULL) {	1595	if (priv->channel[direction] == NULL) {
1596	if (direction == CTCM_WRITE)	1596	if (direction == CTCM_WRITE)
1597	channel_free(priv->channel[CTCM_READ]);	1597	channel_free(priv->channel[CTCM_READ]);
		1598	result = -ENODEV;
1598	goto out_dev;	1599	goto out_dev;
1599	}	1600	}
1600	priv->channel[direction]->netdev = dev;	1601	priv->channel[direction]->netdev = dev;

drivers/scsi/aic7xxx/aic7770_osm.c+1−0

@@ -91,6 +91,7 @@ aic7770_probe(struct device *dev) · 90 unmodified lines
91	ahc = ahc_alloc(&aic7xxx_driver_template, name);	91	ahc = ahc_alloc(&aic7xxx_driver_template, name);
92	if (ahc == NULL)	92	if (ahc == NULL)
93	return (ENOMEM);	93	return (ENOMEM);
		94	ahc->dev = dev;
94	error = aic7770_config(ahc, aic7770_ident_table + edev->id.driver_data,	95	error = aic7770_config(ahc, aic7770_ident_table + edev->id.driver_data,
95	eisaBase);	96	eisaBase);
96	if (error != 0) {	97	if (error != 0) {

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

@@ -943,6 +943,7 @@ struct ahc_softc { · 942 unmodified lines
943	* Platform specific device information.	943	* Platform specific device information.
944	*/	944	*/
945	ahc_dev_softc_t dev_softc;	945	ahc_dev_softc_t dev_softc;
		946	struct device *dev;
946		947
947	/*	948	/*
948	* Bus specific device information.	949	* Bus specific device information.

drivers/scsi/aic7xxx/aic7xxx_osm.c+4−6

 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr,
 		 int flags, bus_dmamap_t *mapp)
 {
-	*vaddr = pci_alloc_consistent(ahc->dev_softc,
+	/* XXX: check if we really need the GFP_ATOMIC and unwind this mess! */
-				      dmat->maxsize, mapp);
+	*vaddr = dma_alloc_coherent(ahc->dev, dmat->maxsize, mapp, GFP_ATOMIC);
 	if (*vaddr == NULL)
 		return ENOMEM;
 	return 0;
 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat,
 		void* vaddr, bus_dmamap_t map)
 {
-	pci_free_consistent(ahc->dev_softc, dmat->maxsize,
+	dma_free_coherent(ahc->dev, dmat->maxsize, vaddr, map);
-			    vaddr, map);
 }
 int
 	host->transportt = ahc_linux_transport_template;
-	retval = scsi_add_host(host,
+	retval = scsi_add_host(host, ahc->dev);
-			(ahc->dev_softc ? &ahc->dev_softc->dev : NULL));
 	if (retval) {
 		printk(KERN_WARNING "aic7xxx: scsi_add_host failed\n");
 		scsi_host_put(host);

drivers/scsi/aic7xxx/aic7xxx_osm_pci.c+1−0

@@ -250,6 +250,7 @@ ahc_linux_pci_dev_probe(struct pci_dev pdev, const struct pci_device_id ent) · 249 unmodified lines
250	}	250	}
251	}	251	}
252	ahc->dev_softc = pci;	252	ahc->dev_softc = pci;
		253	ahc->dev = &pci->dev;
253	error = ahc_pci_config(ahc, entry);	254	error = ahc_pci_config(ahc, entry);
254	if (error != 0) {	255	if (error != 0) {
255	ahc_free(ahc);	256	ahc_free(ahc);

drivers/scsi/libfc/fc_rport.c+0−1

@@ -2162,7 +2162,6 @@ static void fc_rport_recv_logo_req(struct fc_lport lport, struct fc_frame fp) · 2161 unmodified lines
2162	FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",	2162	FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
2163	fc_rport_state(rdata));	2163	fc_rport_state(rdata));
2164		2164
2165	rdata->flags &= ~FC_RP_STARTED;
2166	fc_rport_enter_delete(rdata, RPORT_EV_STOP);	2165	fc_rport_enter_delete(rdata, RPORT_EV_STOP);
2167	mutex_unlock(&rdata->rp_mutex);	2166	mutex_unlock(&rdata->rp_mutex);
2168	kref_put(&rdata->kref, fc_rport_destroy);	2167	kref_put(&rdata->kref, fc_rport_destroy);

drivers/scsi/scsi_lib.c+5−1

 			ret = BLK_STS_DEV_RESOURCE;
 		break;
 	default:
+		if (unlikely(!scsi_device_online(sdev)))
+			scsi_req(req)->result = DID_NO_CONNECT << 16;
+		else
+			scsi_req(req)->result = DID_ERROR << 16;
 		/*
-		 * Make sure to release all allocated ressources when
+		 * Make sure to release all allocated resources when
 		 * we hit an error, as we will never see this command
 		 * again.
 		 */

drivers/staging/comedi/drivers/ni_usb6501.c+4−6

 	size = usb_endpoint_maxp(devpriv->ep_tx);
 	devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
-	if (!devpriv->usb_tx_buf) {
+	if (!devpriv->usb_tx_buf)
-		kfree(devpriv->usb_rx_buf);
 		return -ENOMEM;
-	}
 	return 0;
 }
 	if (!devpriv)
 		return -ENOMEM;
+	mutex_init(&devpriv->mut);
+	usb_set_intfdata(intf, devpriv);
 	ret = ni6501_find_endpoints(dev);
 	if (ret)
 		return ret;
 	if (ret)
 		return ret;
-	mutex_init(&devpriv->mut);
-	usb_set_intfdata(intf, devpriv);
 	ret = comedi_alloc_subdevices(dev, 2);
 	if (ret)
 		return ret;

drivers/staging/comedi/drivers/vmk80xx.c+3−5

 	size = usb_endpoint_maxp(devpriv->ep_tx);
 	devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
-	if (!devpriv->usb_tx_buf) {
+	if (!devpriv->usb_tx_buf)
-		kfree(devpriv->usb_rx_buf);
 		return -ENOMEM;
-	}
 	return 0;
 }
 	devpriv->model = board->model;
+	sema_init(&devpriv->limit_sem, 8);
 	ret = vmk80xx_find_usb_endpoints(dev);
 	if (ret)
 		return ret;
 	if (ret)
 		return ret;
-	sema_init(&devpriv->limit_sem, 8);
 	usb_set_intfdata(intf, devpriv);
 	if (devpriv->model == VMK8055_MODEL)

drivers/staging/erofs/data.c+1−1

@@ -298,7 +298,7 @@ submit_bio_retry: · 297 unmodified lines
298	*last_block = current_block;	298	*last_block = current_block;
299		299
300	/* shift in advance in case of it followed by too many gaps */	300	/* shift in advance in case of it followed by too many gaps */
301	if (unlikely(bio->bi_vcnt >= bio->bi_max_vecs)) {	301	if (bio->bi_iter.bi_size >= bio->bi_max_vecs * PAGE_SIZE) {
302	/* err should reassign to 0 after submitting */	302	/* err should reassign to 0 after submitting */
303	err = 0;	303	err = 0;
304	goto submit_bio_out;	304	goto submit_bio_out;

drivers/staging/iio/adc/ad7192.c+4−4

@@ -109,10 +109,10 @@ · 108 unmodified lines
109	#define AD7192_CH_AIN3 BIT(6) /* AIN3 - AINCOM */	109	#define AD7192_CH_AIN3 BIT(6) /* AIN3 - AINCOM */
110	#define AD7192_CH_AIN4 BIT(7) /* AIN4 - AINCOM */	110	#define AD7192_CH_AIN4 BIT(7) /* AIN4 - AINCOM */
111		111
112	#define AD7193_CH_AIN1P_AIN2M 0x000 /* AIN1(+) - AIN2(-) */	112	#define AD7193_CH_AIN1P_AIN2M 0x001 /* AIN1(+) - AIN2(-) */
113	#define AD7193_CH_AIN3P_AIN4M 0x001 /* AIN3(+) - AIN4(-) */	113	#define AD7193_CH_AIN3P_AIN4M 0x002 /* AIN3(+) - AIN4(-) */
114	#define AD7193_CH_AIN5P_AIN6M 0x002 /* AIN5(+) - AIN6(-) */	114	#define AD7193_CH_AIN5P_AIN6M 0x004 /* AIN5(+) - AIN6(-) */
115	#define AD7193_CH_AIN7P_AIN8M 0x004 /* AIN7(+) - AIN8(-) */	115	#define AD7193_CH_AIN7P_AIN8M 0x008 /* AIN7(+) - AIN8(-) */
116	#define AD7193_CH_TEMP 0x100 /* Temp senseor */	116	#define AD7193_CH_TEMP 0x100 /* Temp senseor */
117	#define AD7193_CH_AIN2P_AIN2M 0x200 /* AIN2(+) - AIN2(-) */	117	#define AD7193_CH_AIN2P_AIN2M 0x200 /* AIN2(+) - AIN2(-) */
118	#define AD7193_CH_AIN1 0x401 /* AIN1 - AINCOM */	118	#define AD7193_CH_AIN1 0x401 /* AIN1 - AINCOM */

drivers/staging/iio/meter/ade7854.c+1−1

@@ -269,7 +269,7 @@ static IIO_DEV_ATTR_VPEAK(0644, · 268 unmodified lines
269	static IIO_DEV_ATTR_IPEAK(0644,	269	static IIO_DEV_ATTR_IPEAK(0644,
270	ade7854_read_32bit,	270	ade7854_read_32bit,
271	ade7854_write_32bit,	271	ade7854_write_32bit,
272	ADE7854_VPEAK);	272	ADE7854_IPEAK);
273	static IIO_DEV_ATTR_APHCAL(0644,	273	static IIO_DEV_ATTR_APHCAL(0644,
274	ade7854_read_16bit,	274	ade7854_read_16bit,
275	ade7854_write_16bit,	275	ade7854_write_16bit,

drivers/staging/most/core.c+1−1

@@ -1431,7 +1431,7 @@ int most_register_interface(struct most_interface *iface) · 1430 unmodified lines
1431		1431
1432	INIT_LIST_HEAD(&iface->p->channel_list);	1432	INIT_LIST_HEAD(&iface->p->channel_list);
1433	iface->p->dev_id = id;	1433	iface->p->dev_id = id;
1434	snprintf(iface->p->name, STRING_SIZE, "mdev%d", id);	1434	strcpy(iface->p->name, iface->description);
1435	iface->dev.init_name = iface->p->name;	1435	iface->dev.init_name = iface->p->name;
1436	iface->dev.bus = &mc.bus;	1436	iface->dev.bus = &mc.bus;
1437	iface->dev.parent = &mc.dev;	1437	iface->dev.parent = &mc.dev;

drivers/tty/serial/sc16is7xx.c+3−1

 #endif
 	return ret;
+#ifdef CONFIG_SERIAL_SC16IS7XX_SPI
 err_spi:
+#endif
 #ifdef CONFIG_SERIAL_SC16IS7XX_I2C
 	i2c_del_driver(&sc16is7xx_i2c_uart_driver);
-#endif
 err_i2c:
+#endif
 	uart_unregister_driver(&sc16is7xx_uart);
 	return ret;
 }

drivers/tty/serial/sh-sci.c+4−2

 			 * center of the last stop bit in sampling clocks.
 			 */
 			int last_stop = bits * 2 - 1;
-			int deviation = min_err * srr * last_stop / 2 / baud;
+			int deviation = DIV_ROUND_CLOSEST(min_err * last_stop *
+							  (int)(srr + 1),
+							  2 * (int)baud);
 			if (abs(deviation) >= 2) {
 				/* At least two sampling clocks off at the
 				 * last stop bit; we can increase the error
 				 * margin by shifting the sampling point.
 				 */
-				int shift = min(-8, max(7, deviation / 2));
+				int shift = clamp(deviation / 2, -8, 7);
 				hssrr |= (shift << HSCIF_SRHP_SHIFT) &
 					 HSCIF_SRHP_MASK;

drivers/tty/vt/vt.c+2−1

@@ -1520,7 +1520,8 @@ static void csi_J(struct vc_data *vc, int vpar) · 1519 unmodified lines
1520	return;	1520	return;
1521	}	1521	}
1522	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);	1522	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1523	update_region(vc, (unsigned long) start, count);	1523	if (con_should_update(vc))
		1524	do_update_region(vc, (unsigned long) start, count);
1524	vc->vc_need_wrap = 0;	1525	vc->vc_need_wrap = 0;
1525	}	1526	}
1526		1527

fs/afs/callback.c+1−2

@@ -203,8 +203,7 @@ void afs_put_cb_interest(struct afs_net net, struct afs_cb_interest cbi) · 202 unmodified lines
203	*/	203	*/
204	void afs_init_callback_state(struct afs_server *server)	204	void afs_init_callback_state(struct afs_server *server)
205	{	205	{
206	if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))	206	server->cb_s_break++;
207	server->cb_s_break++;
208	}	207	}
209		208
210	/*	209	/*

fs/afs/cmservice.c+1−1

@@ -34,7 +34,7 @@ static void SRXAFSCB_TellMeAboutYourself(struct work_struct *); · 33 unmodified lines
34	static int afs_deliver_yfs_cb_callback(struct afs_call *);	34	static int afs_deliver_yfs_cb_callback(struct afs_call *);
35		35
36	#define CM_NAME(name) \	36	#define CM_NAME(name) \
37	const char afs_SRXCB##name##_name[] __tracepoint_string = \	37	char afs_SRXCB##name##_name[] __tracepoint_string = \
38	"CB." #name	38	"CB." #name
39		39
40	/*	40	/*

fs/afs/inode.c+1−3

 	set_nlink(inode, 2);
 	inode->i_uid		= GLOBAL_ROOT_UID;
 	inode->i_gid		= GLOBAL_ROOT_GID;
-	inode->i_ctime.tv_sec	= get_seconds();
+	inode->i_ctime = inode->i_atime = inode->i_mtime = current_time(inode);
-	inode->i_ctime.tv_nsec	= 0;
-	inode->i_atime		= inode->i_mtime = inode->i_ctime;
 	inode->i_blocks		= 0;
 	inode_set_iversion_raw(inode, 0);
 	inode->i_generation	= 0;

fs/afs/internal.h+1−3

 	time64_t		put_time;	/* Time at which last put */
 	time64_t		update_at;	/* Time at which to next update the record */
 	unsigned long		flags;
-#define AFS_SERVER_FL_NEW	0		/* New server, don't inc cb_s_break */
 #define AFS_SERVER_FL_NOT_READY	1		/* The record is not ready for use */
 #define AFS_SERVER_FL_NOT_FOUND	2		/* VL server says no such server */
 #define AFS_SERVER_FL_VL_FAIL	3		/* Failed to access VL server */
 static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
 {
-	return vnode->cb_break + vnode->cb_s_break + vnode->cb_v_break;
+	return vnode->cb_break + vnode->cb_v_break;
 }
 static inline bool afs_cb_is_broken(unsigned int cb_break,
 				    const struct afs_cb_interest *cbi)
 {
 	return !cbi || cb_break != (vnode->cb_break +
-				    cbi->server->cb_s_break +
 				    vnode->volume->cb_v_break);
 }

fs/afs/rxrpc.c+5−1

 		case -ENODATA:
 		case -EBADMSG:
 		case -EMSGSIZE:
-		default:
 			abort_code = RXGEN_CC_UNMARSHAL;
 			if (state != AFS_CALL_CL_AWAIT_REPLY)
 				abort_code = RXGEN_SS_UNMARSHAL;
 			rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
 						abort_code, ret, "KUM");
 			goto local_abort;
+		default:
+			abort_code = RX_USER_ABORT;
+			rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+						abort_code, ret, "KER");
+			goto local_abort;
 		}
 	}

fs/afs/server.c+0−1

@@ -226,7 +226,6 @@ static struct afs_server afs_alloc_server(struct afs_net net, · 225 unmodified lines
226	RCU_INIT_POINTER(server->addresses, alist);	226	RCU_INIT_POINTER(server->addresses, alist);
227	server->addr_version = alist->version;	227	server->addr_version = alist->version;
228	server->uuid = *uuid;	228	server->uuid = *uuid;
229	server->flags = (1UL << AFS_SERVER_FL_NEW);
230	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;	229	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
231	rwlock_init(&server->fs_lock);	230	rwlock_init(&server->fs_lock);
232	INIT_HLIST_HEAD(&server->cb_volumes);	231	INIT_HLIST_HEAD(&server->cb_volumes);

fs/afs/write.c+1−0

@@ -264,6 +264,7 @@ static void afs_kill_pages(struct address_space *mapping, · 263 unmodified lines
264	first = page->index + 1;	264	first = page->index + 1;
265	lock_page(page);	265	lock_page(page);
266	generic_error_remove_page(mapping, page);	266	generic_error_remove_page(mapping, page);
		267	unlock_page(page);
267	}	268	}
268		269
269	__pagevec_release(&pv);	270	__pagevec_release(&pv);

fs/cifs/cifsglob.h+2−0

 }
 struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
+void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr);
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
 #define CIFS_CACHE_READ_FLG	1
 #endif /* CONFIG_CIFS_ACL */
 void cifs_oplock_break(struct work_struct *work);
+void cifs_queue_oplock_break(struct cifsFileInfo *cfile);
 extern const struct slow_work_ops cifs_oplock_break_ops;
 extern struct workqueue_struct *cifsiod_wq;

fs/cifs/file.c+25−5

 	return cifs_file;
 }
-/*
+/**
- * Release a reference on the file private data. This may involve closing
+ * cifsFileInfo_put - release a reference of file priv data
- * the filehandle out on the server. Must be called without holding
+ *
- * tcon->open_file_lock and cifs_file->file_info_lock.
+ * Always potentially wait for oplock handler. See _cifsFileInfo_put().
  */
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
+{
+	_cifsFileInfo_put(cifs_file, true);
+}
+/**
+ * _cifsFileInfo_put - release a reference of file priv data
+ *
+ * This may involve closing the filehandle @cifs_file out on the
+ * server. Must be called without holding tcon->open_file_lock and
+ * cifs_file->file_info_lock.
+ *
+ * If @wait_for_oplock_handler is true and we are releasing the last
+ * reference, wait for any running oplock break handler of the file
+ * and cancel any pending one. If calling this function from the
+ * oplock break handler, you need to pass false.
+ *
+ */
+void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
 {
 	struct inode *inode = d_inode(cifs_file->dentry);
 	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 	spin_unlock(&tcon->open_file_lock);
-	oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
+	oplock_break_cancelled = wait_oplock_handler ?
+		cancel_work_sync(&cifs_file->oplock_break) : false;
 	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 		struct TCP_Server_Info *server = tcon->ses->server;
 							     cinode);
 		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
 	}
+	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
 	cifs_done_oplock_break(cinode);
 }

fs/cifs/misc.c+23−2

@@ -501,8 +501,7 @@ is_valid_oplock_break(char buffer, struct TCP_Server_Info srv) · 500 unmodified lines
501	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	501	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
502	&pCifsInode->flags);	502	&pCifsInode->flags);
503		503
504	queue_work(cifsoplockd_wq,	504	cifs_queue_oplock_break(netfile);
505	&netfile->oplock_break);
506	netfile->oplock_break_cancelled = false;	505	netfile->oplock_break_cancelled = false;
507		506
508	spin_unlock(&tcon->open_file_lock);	507	spin_unlock(&tcon->open_file_lock);
@@ -607,6 +606,28 @@ void cifs_put_writer(struct cifsInodeInfo *cinode) · 98 unmodified lines
607	spin_unlock(&cinode->writers_lock);	606	spin_unlock(&cinode->writers_lock);
608	}	607	}
609		608
		609	/**
		610	* cifs_queue_oplock_break - queue the oplock break handler for cfile
		611	*
		612	* This function is called from the demultiplex thread when it
		613	* receives an oplock break for @cfile.
		614	*
		615	* Assumes the tcon->open_file_lock is held.
		616	* Assumes cfile->file_info_lock is NOT held.
		617	*/
		618	void cifs_queue_oplock_break(struct cifsFileInfo *cfile)
		619	{
		620	/*
		621	* Bump the handle refcount now while we hold the
		622	* open_file_lock to enforce the validity of it for the oplock
		623	* break handler. The matching put is done at the end of the
		624	* handler.
		625	*/
		626	cifsFileInfo_get(cfile);
		627
		628	queue_work(cifsoplockd_wq, &cfile->oplock_break);
		629	}
		630
610	void cifs_done_oplock_break(struct cifsInodeInfo *cinode)	631	void cifs_done_oplock_break(struct cifsInodeInfo *cinode)
611	{	632	{
612	clear_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);	633	clear_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);

fs/cifs/smb2misc.c+3−3

@@ -555,7 +555,7 @@ smb2_tcon_has_lease(struct cifs_tcon tcon, struct smb2_lease_break rsp, · 554 unmodified lines
555	clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	555	clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
556	&cinode->flags);	556	&cinode->flags);
557		557
558	queue_work(cifsoplockd_wq, &cfile->oplock_break);	558	cifs_queue_oplock_break(cfile);
559	kfree(lw);	559	kfree(lw);
560	return true;	560	return true;
561	}	561	}
@@ -712,8 +712,8 @@ smb2_is_valid_oplock_break(char buffer, struct TCP_Server_Info server) · 150 unmodified lines
712	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	712	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
713	&cinode->flags);	713	&cinode->flags);
714	spin_unlock(&cfile->file_info_lock);	714	spin_unlock(&cfile->file_info_lock);
715	queue_work(cifsoplockd_wq,	715
716	&cfile->oplock_break);	716	cifs_queue_oplock_break(cfile);
717		717
718	spin_unlock(&tcon->open_file_lock);	718	spin_unlock(&tcon->open_file_lock);
719	spin_unlock(&cifs_tcp_ses_lock);	719	spin_unlock(&cifs_tcp_ses_lock);

fs/cifs/smb2ops.c+2−0

@@ -2389,6 +2389,8 @@ smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, · 2388 unmodified lines
2389		2389
2390	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_iov,	2390	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_iov,
2391	&resp_buftype);	2391	&resp_buftype);
		2392	if (!rc)
		2393	SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
2392	if (!rc \|\| !err_iov.iov_base) {	2394	if (!rc \|\| !err_iov.iov_base) {
2393	rc = -ENOENT;	2395	rc = -ENOENT;
2394	goto free_path;	2396	goto free_path;

fs/cifs/smb2pdu.c+7−4

 		} else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID)) {
 			/* ops set to 3.0 by default for default so update */
 			ses->server->ops = &smb21_operations;
-		} else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID))
+			ses->server->vals = &smb21_values;
+		} else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) {
 			ses->server->ops = &smb311_operations;
+			ses->server->vals = &smb311_values;
+		}
 	} else if (le16_to_cpu(rsp->DialectRevision) !=
 				ses->server->vals->protocol_id) {
 		/* if requested single dialect ensure returned dialect matched */
 	rqst.rq_nvec = 1;
 	rc = cifs_send_recv(xid, ses, &rqst, &resp_buftype, flags, &rsp_iov);
-	cifs_small_buf_release(req);
 	rsp = (struct smb2_read_rsp *)rsp_iov.iov_base;
 	if (rc) {
 				    io_parms->tcon->tid, ses->Suid,
 				    io_parms->offset, io_parms->length);
+	cifs_small_buf_release(req);
 	*nbytes = le32_to_cpu(rsp->DataLength);
 	if ((*nbytes > CIFS_MAX_MSGSIZE) ||
 	    (*nbytes > io_parms->length)) {
 	rc = cifs_send_recv(xid, io_parms->tcon->ses, &rqst,
 			    &resp_buftype, flags, &rsp_iov);
-	cifs_small_buf_release(req);
 	rsp = (struct smb2_write_rsp *)rsp_iov.iov_base;
 	if (rc) {
 				     io_parms->offset, *nbytes);
 	}
+	cifs_small_buf_release(req);
 	free_rsp_buf(resp_buftype, rsp);
 	return rc;
 }

fs/io_uring.c+30−11

 	tail = ctx->cached_cq_tail;
 	/* See comment at the top of the file */
 	smp_rmb();
-	if (tail + 1 == READ_ONCE(ring->r.head))
+	if (tail - READ_ONCE(ring->r.head) == ring->ring_entries)
 		return NULL;
 	ctx->cached_cq_tail++;
 		list_add_tail(&req->list, &ctx->poll_list);
 }
-static void io_file_put(struct io_submit_state *state, struct file *file)
+static void io_file_put(struct io_submit_state *state)
 {
-	if (!state) {
+	if (state->file) {
-		fput(file);
-	} else if (state->file) {
 		int diff = state->has_refs - state->used_refs;
 		if (diff)
 			state->ios_left--;
 			return state->file;
 		}
-		io_file_put(state, NULL);
+		io_file_put(state);
 	}
 	state->file = fget_many(fd, state->ios_left);
 	if (!state->file)
 static void io_submit_state_end(struct io_submit_state *state)
 {
 	blk_finish_plug(&state->plug);
-	io_file_put(state, NULL);
+	io_file_put(state);
 	if (state->free_reqs)
 		kmem_cache_free_bulk(req_cachep, state->free_reqs,
 					&state->reqs[state->cur_req]);
 		unuse_mm(cur_mm);
 		mmput(cur_mm);
 	}
+	if (kthread_should_park())
+		kthread_parkme();
 	return 0;
 }
 	if (ctx->sqo_thread) {
 		ctx->sqo_stop = 1;
 		mb();
+		kthread_park(ctx->sqo_thread);
 		kthread_stop(ctx->sqo_thread);
 		ctx->sqo_thread = NULL;
 	}
 	mmgrab(current->mm);
 	ctx->sqo_mm = current->mm;
-	ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
-	if (!ctx->sq_thread_idle)
-		ctx->sq_thread_idle = HZ;
 	ret = -EINVAL;
 	if (!cpu_possible(p->sq_thread_cpu))
 		goto err;
 		if (!capable(CAP_SYS_ADMIN))
 			goto err;
+		ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
+		if (!ctx->sq_thread_idle)
+			ctx->sq_thread_idle = HZ;
 		if (p->flags & IORING_SETUP_SQ_AFF) {
 			int cpu;
 			cpu = array_index_nospec(p->sq_thread_cpu, NR_CPUS);
+			ret = -EINVAL;
+			if (!cpu_possible(p->sq_thread_cpu))
+				goto err;
 			ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
 							ctx, cpu,
 							"io_uring-sq");
 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
 			       void __user *arg, unsigned nr_args)
+	__releases(ctx->uring_lock)
+	__acquires(ctx->uring_lock)
 {
 	int ret;
 	percpu_ref_kill(&ctx->refs);
+	/*
+	 * Drop uring mutex before waiting for references to exit. If another
+	 * thread is currently inside io_uring_enter() it might need to grab
+	 * the uring_lock to make progress. If we hold it here across the drain
+	 * wait, then we can deadlock. It's safe to drop the mutex here, since
+	 * no new references will come in after we've killed the percpu ref.
+	 */
+	mutex_unlock(&ctx->uring_lock);
 	wait_for_completion(&ctx->ctx_done);
+	mutex_lock(&ctx->uring_lock);
 	switch (opcode) {
 	case IORING_REGISTER_BUFFERS:

fs/nfsd/nfs3proc.c+15−2

 	struct nfsd3_readdirargs *argp = rqstp->rq_argp;
 	struct nfsd3_readdirres  *resp = rqstp->rq_resp;
 	__be32		nfserr;
-	int		count;
+	int		count = 0;
+	struct page	**p;
+	caddr_t		page_addr = NULL;
 	dprintk("nfsd: READDIR(3)  %s %d bytes at %d\n",
 				SVCFH_fmt(&argp->fh),
 	nfserr = nfsd_readdir(rqstp, &resp->fh, (loff_t*) &argp->cookie,
 					&resp->common, nfs3svc_encode_entry);
 	memcpy(resp->verf, argp->verf, 8);
-	resp->count = resp->buffer - argp->buffer;
+	count = 0;
+	for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) {
+		page_addr = page_address(*p);
+		if (((caddr_t)resp->buffer >= page_addr) &&
+		    ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) {
+			count += (caddr_t)resp->buffer - page_addr;
+			break;
+		}
+		count += PAGE_SIZE;
+	}
+	resp->count = count >> 2;
 	if (resp->offset) {
 		loff_t offset = argp->cookie;

fs/nfsd/nfs3xdr.c+9−2

@@ -573,6 +573,7 @@ int · 572 unmodified lines
573	nfs3svc_decode_readdirargs(struct svc_rqst rqstp, __be32 p)	573	nfs3svc_decode_readdirargs(struct svc_rqst rqstp, __be32 p)
574	{	574	{
575	struct nfsd3_readdirargs *args = rqstp->rq_argp;	575	struct nfsd3_readdirargs *args = rqstp->rq_argp;
		576	int len;
576	u32 max_blocksize = svc_max_payload(rqstp);	577	u32 max_blocksize = svc_max_payload(rqstp);
577		578
578	p = decode_fh(p, &args->fh);	579	p = decode_fh(p, &args->fh);
@@ -582,8 +583,14 @@ nfs3svc_decode_readdirargs(struct svc_rqst rqstp, __be32 p) · 3 unmodified lines
582	args->verf = p; p += 2;	583	args->verf = p; p += 2;
583	args->dircount = ~0;	584	args->dircount = ~0;
584	args->count = ntohl(*p++);	585	args->count = ntohl(*p++);
585	args->count = min_t(u32, args->count, max_blocksize);	586	len = args->count = min_t(u32, args->count, max_blocksize);
586	args->buffer = page_address(*(rqstp->rq_next_page++));	587
		588	while (len > 0) {
		589	struct page p = (rqstp->rq_next_page++);
		590	if (!args->buffer)
		591	args->buffer = page_address(p);
		592	len -= PAGE_SIZE;
		593	}
587		594
588	return xdr_argsize_check(rqstp, p);	595	return xdr_argsize_check(rqstp, p);
589	}	596	}

fs/nfsd/nfs4callback.c+7−1

 	cb->cb_seq_status = 1;
 	cb->cb_status = 0;
 	if (minorversion) {
-		if (!nfsd41_cb_get_slot(clp, task))
+		if (!cb->cb_holds_slot && !nfsd41_cb_get_slot(clp, task))
 			return;
+		cb->cb_holds_slot = true;
 	}
 	rpc_call_start(task);
 }
 		return true;
 	}
+	if (!cb->cb_holds_slot)
+		goto need_restart;
 	switch (cb->cb_seq_status) {
 	case 0:
 		/*
 			cb->cb_seq_status);
 	}
+	cb->cb_holds_slot = false;
 	clear_bit(0, &clp->cl_cb_slot_busy);
 	rpc_wake_up_next(&clp->cl_cb_waitq);
 	dprintk("%s: freed slot, new seqid=%d\n", __func__,
 	cb->cb_seq_status = 1;
 	cb->cb_status = 0;
 	cb->cb_need_restart = false;
+	cb->cb_holds_slot = false;
 }
 void nfsd4_run_cb(struct nfsd4_callback *cb)

fs/nfsd/nfs4state.c+10−2

 static void
 free_blocked_lock(struct nfsd4_blocked_lock *nbl)
 {
+	locks_delete_block(&nbl->nbl_lock);
 	locks_release_private(&nbl->nbl_lock);
 	kfree(nbl);
 }
 		nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
 					nbl_lru);
 		list_del_init(&nbl->nbl_lru);
-		locks_delete_block(&nbl->nbl_lock);
 		free_blocked_lock(nbl);
 	}
 }
+static void
+nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb)
+{
+	struct nfsd4_blocked_lock	*nbl = container_of(cb,
+						struct nfsd4_blocked_lock, nbl_cb);
+	locks_delete_block(&nbl->nbl_lock);
+}
 static int
 nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
 {
 }
 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
+	.prepare	= nfsd4_cb_notify_lock_prepare,
 	.done		= nfsd4_cb_notify_lock_done,
 	.release	= nfsd4_cb_notify_lock_release,
 };
 		nbl = list_first_entry(&reaplist,
 					struct nfsd4_blocked_lock, nbl_lru);
 		list_del_init(&nbl->nbl_lru);
-		locks_delete_block(&nbl->nbl_lock);
 		free_blocked_lock(nbl);
 	}
 out:

fs/nfsd/state.h+1−0

@@ -70,6 +70,7 @@ struct nfsd4_callback { · 69 unmodified lines
70	int cb_seq_status;	70	int cb_seq_status;
71	int cb_status;	71	int cb_status;
72	bool cb_need_restart;	72	bool cb_need_restart;
		73	bool cb_holds_slot;
73	};	74	};
74		75
75	struct nfsd4_callback_ops {	76	struct nfsd4_callback_ops {

fs/proc/task_mmu.c+18−0

@@ -1143,6 +1143,24 @@ static ssize_t clear_refs_write(struct file file, const char __user buf, · 1142 unmodified lines
1143	count = -EINTR;	1143	count = -EINTR;
1144	goto out_mm;	1144	goto out_mm;
1145	}	1145	}
		1146	/*
		1147	* Avoid to modify vma->vm_flags
		1148	* without locked ops while the
		1149	* coredump reads the vm_flags.
		1150	*/
		1151	if (!mmget_still_valid(mm)) {
		1152	/*
		1153	* Silently return "count"
		1154	* like if get_task_mm()
		1155	* failed. FIXME: should this
		1156	* function have returned
		1157	* -ESRCH if get_task_mm()
		1158	* failed like if
		1159	* get_proc_task() fails?
		1160	*/
		1161	up_write(&mm->mmap_sem);
		1162	goto out_mm;
		1163	}
1146	for (vma = mm->mmap; vma; vma = vma->vm_next) {	1164	for (vma = mm->mmap; vma; vma = vma->vm_next) {
1147	vma->vm_flags &= ~VM_SOFTDIRTY;	1165	vma->vm_flags &= ~VM_SOFTDIRTY;
1148	vma_set_page_prot(vma);	1166	vma_set_page_prot(vma);

fs/userfaultfd.c+9−0

 		/* the various vma->vm_userfaultfd_ctx still points to it */
 		down_write(&mm->mmap_sem);
+		/* no task can run (and in turn coredump) yet */
+		VM_WARN_ON(!mmget_still_valid(mm));
 		for (vma = mm->mmap; vma; vma = vma->vm_next)
 			if (vma->vm_userfaultfd_ctx.ctx == release_new_ctx) {
 				vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
 	 * taking the mmap_sem for writing.
 	 */
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto skip_mm;
 	prev = NULL;
 	for (vma = mm->mmap; vma; vma = vma->vm_next) {
 		cond_resched();
 		vma->vm_flags = new_flags;
 		vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
 	}
+skip_mm:
 	up_write(&mm->mmap_sem);
 	mmput(mm);
 wakeup:
 		goto out;
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto out_unlock;
 	vma = find_vma_prev(mm, start, &prev);
 	if (!vma)
 		goto out_unlock;
 		goto out;
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto out_unlock;
 	vma = find_vma_prev(mm, start, &prev);
 	if (!vma)
 		goto out_unlock;

include/linux/blkdev.h+0−1

@@ -548,7 +548,6 @@ struct request_queue { · 547 unmodified lines
548	struct rcu_head rcu_head;	548	struct rcu_head rcu_head;
549	wait_queue_head_t mq_freeze_wq;	549	wait_queue_head_t mq_freeze_wq;
550	struct percpu_ref q_usage_counter;	550	struct percpu_ref q_usage_counter;
551	struct list_head all_q_node;
552		551
553	struct blk_mq_tag_set *tag_set;	552	struct blk_mq_tag_set *tag_set;
554	struct list_head tag_set_list;	553	struct list_head tag_set_list;

include/linux/bvec.h+3−2

 		bv->bv_page = nth_page(bv->bv_page, 1);
 		bv->bv_offset = 0;
 	} else {
-		bv->bv_page = bvec->bv_page;
+		bv->bv_page = bvec_nth_page(bvec->bv_page, bvec->bv_offset /
-		bv->bv_offset = bvec->bv_offset;
+					    PAGE_SIZE);
+		bv->bv_offset = bvec->bv_offset & ~PAGE_MASK;
 	}
 	bv->bv_len = min_t(unsigned int, PAGE_SIZE - bv->bv_offset,
 			   bvec->bv_len - iter_all->done);

include/linux/efi.h+6−1

 			   struct screen_info *si, efi_guid_t *proto,
 			   unsigned long size);
-bool efi_runtime_disabled(void);
+#ifdef CONFIG_EFI
+extern bool efi_runtime_disabled(void);
+#else
+static inline bool efi_runtime_disabled(void) { return true; }
+#endif
 extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
 extern unsigned long efi_call_virt_save_flags(void);

include/linux/elevator.h+1−0

@@ -31,6 +31,7 @@ struct elevator_mq_ops { · 30 unmodified lines
31	void (exit_sched)(struct elevator_queue );	31	void (exit_sched)(struct elevator_queue );
32	int (init_hctx)(struct blk_mq_hw_ctx , unsigned int);	32	int (init_hctx)(struct blk_mq_hw_ctx , unsigned int);
33	void (exit_hctx)(struct blk_mq_hw_ctx , unsigned int);	33	void (exit_hctx)(struct blk_mq_hw_ctx , unsigned int);
		34	void (depth_updated)(struct blk_mq_hw_ctx );
34		35
35	bool (allow_merge)(struct request_queue , struct request , struct bio );	36	bool (allow_merge)(struct request_queue , struct request , struct bio );
36	bool (bio_merge)(struct blk_mq_hw_ctx , struct bio *);	37	bool (bio_merge)(struct blk_mq_hw_ctx , struct bio *);

include/linux/etherdevice.h+12−0

@@ -448,6 +448,18 @@ static inline void eth_addr_dec(u8 *addr) · 447 unmodified lines
448	u64_to_ether_addr(u, addr);	448	u64_to_ether_addr(u, addr);
449	}	449	}
450		450
		451	/**
		452	* eth_addr_inc() - Increment the given MAC address.
		453	* @addr: Pointer to a six-byte array containing Ethernet address to increment.
		454	*/
		455	static inline void eth_addr_inc(u8 *addr)
		456	{
		457	u64 u = ether_addr_to_u64(addr);
		458
		459	u++;
		460	u64_to_ether_addr(u, addr);
		461	}
		462
451	/**	463	/**
452	* is_etherdev_addr - Tell if given Ethernet address belongs to the device.	464	* is_etherdev_addr - Tell if given Ethernet address belongs to the device.
453	* @dev: Pointer to a device structure	465	* @dev: Pointer to a device structure

include/linux/kprobes.h+1−0

@@ -173,6 +173,7 @@ struct kretprobe_instance { · 172 unmodified lines
173	struct kretprobe *rp;	173	struct kretprobe *rp;
174	kprobe_opcode_t *ret_addr;	174	kprobe_opcode_t *ret_addr;
175	struct task_struct *task;	175	struct task_struct *task;
		176	void *fp;
176	char data[0];	177	char data[0];
177	};	178	};
178		179

include/linux/sched/mm.h+21−0

@@ -49,6 +49,27 @@ static inline void mmdrop(struct mm_struct *mm) · 48 unmodified lines
49	__mmdrop(mm);	49	__mmdrop(mm);
50	}	50	}
51		51
		52	/*
		53	* This has to be called after a get_task_mm()/mmget_not_zero()
		54	* followed by taking the mmap_sem for writing before modifying the
		55	* vmas or anything the coredump pretends not to change from under it.
		56	*
		57	* NOTE: find_extend_vma() called from GUP context is the only place
		58	* that can modify the "mm" (notably the vm_start/end) under mmap_sem
		59	* for reading and outside the context of the process, so it is also
		60	* the only case that holds the mmap_sem for reading that must call
		61	* this function. Generally if the mmap_sem is hold for reading
		62	* there's no need of this check after get_task_mm()/mmget_not_zero().
		63	*
		64	* This function can be obsoleted and the check can be removed, after
		65	* the coredump code will hold the mmap_sem for writing before
		66	* invoking the ->core_dump methods.
		67	*/
		68	static inline bool mmget_still_valid(struct mm_struct *mm)
		69	{
		70	return likely(!mm->core_state);
		71	}
		72
52	/**	73	/**
53	* mmget() - Pin the address space associated with a &struct mm_struct.	74	* mmget() - Pin the address space associated with a &struct mm_struct.
54	* @mm: The address space to pin.	75	* @mm: The address space to pin.

include/linux/shmem_fs.h+1−0

@@ -21,6 +21,7 @@ struct shmem_inode_info { · 20 unmodified lines
21	struct list_head swaplist; /* chain of maybes on swap */	21	struct list_head swaplist; /* chain of maybes on swap */
22	struct shared_policy policy; /* NUMA memory alloc policy */	22	struct shared_policy policy; /* NUMA memory alloc policy */
23	struct simple_xattrs xattrs; /* list of xattrs */	23	struct simple_xattrs xattrs; /* list of xattrs */
		24	atomic_t stop_eviction; /* hold when working on inode */
24	struct inode vfs_inode;	25	struct inode vfs_inode;
25	};	26	};
26		27

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

@@ -316,6 +316,8 @@ struct nf_conn nf_ct_tmpl_alloc(struct net net, · 315 unmodified lines
316	gfp_t flags);	316	gfp_t flags);
317	void nf_ct_tmpl_free(struct nf_conn *tmpl);	317	void nf_ct_tmpl_free(struct nf_conn *tmpl);
318		318
		319	u32 nf_ct_get_id(const struct nf_conn *ct);
		320
319	static inline void	321	static inline void
320	nf_ct_set(struct sk_buff skb, struct nf_conn ct, enum ip_conntrack_info info)	322	nf_ct_set(struct sk_buff skb, struct nf_conn ct, enum ip_conntrack_info info)
321	{	323	{

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

 bool nf_conntrack_invert_icmpv6_tuple(struct nf_conntrack_tuple *tuple,
 				      const struct nf_conntrack_tuple *orig);
+int nf_conntrack_inet_error(struct nf_conn *tmpl, struct sk_buff *skb,
+			    unsigned int dataoff,
+			    const struct nf_hook_state *state,
+			    u8 l4proto,
+			    union nf_inet_addr *outer_daddr);
 int nf_conntrack_icmpv4_error(struct nf_conn *tmpl,
 			      struct sk_buff *skb,
 			      unsigned int dataoff,

include/uapi/linux/input-event-codes.h+4−2

 #define KEY_TITLE		0x171
 #define KEY_SUBTITLE		0x172
 #define KEY_ANGLE		0x173
-#define KEY_ZOOM		0x174
+#define KEY_FULL_SCREEN		0x174	/* AC View Toggle */
+#define KEY_ZOOM		KEY_FULL_SCREEN
 #define KEY_MODE		0x175
 #define KEY_KEYBOARD		0x176
-#define KEY_SCREEN		0x177
+#define KEY_ASPECT_RATIO	0x177	/* HUTRR37: Aspect */
+#define KEY_SCREEN		KEY_ASPECT_RATIO
 #define KEY_PC			0x178	/* Media Select Computer */
 #define KEY_TV			0x179	/* Media Select TV */
 #define KEY_TV2			0x17a	/* Media Select Cable */

init/main.c+2−2

 	page_alloc_init();
 	pr_notice("Kernel command line: %s\n", boot_command_line);
+	/* parameters may set static keys */
+	jump_label_init();
 	parse_early_param();
 	after_dashes = parse_args("Booting kernel",
 				  static_command_line, __start___param,
 		parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
 			   NULL, set_init_arg);
-	jump_label_init();
 	/*
 	 * These use large bootmem allocations and must precede
 	 * kmem_cache_init()

kernel/events/core.c+21−16

@@ -9077,26 +9077,29 @@ static void perf_event_addr_filters_apply(struct perf_event *event) · 9076 unmodified lines
9077	if (task == TASK_TOMBSTONE)	9077	if (task == TASK_TOMBSTONE)
9078	return;	9078	return;
9079		9079
9080	if (!ifh->nr_file_filters)	9080	if (ifh->nr_file_filters) {
9081	return;	9081	mm = get_task_mm(event->ctx->task);
9082		9082	if (!mm)
9083	mm = get_task_mm(event->ctx->task);	9083	goto restart;
9084	if (!mm)
9085	goto restart;
9086		9084
9087	down_read(&mm->mmap_sem);	9085	down_read(&mm->mmap_sem);
		9086	}
9088		9087
9089	raw_spin_lock_irqsave(&ifh->lock, flags);	9088	raw_spin_lock_irqsave(&ifh->lock, flags);
9090	list_for_each_entry(filter, &ifh->list, entry) {	9089	list_for_each_entry(filter, &ifh->list, entry) {
9091	event->addr_filter_ranges[count].start = 0;	9090	if (filter->path.dentry) {
9092	event->addr_filter_ranges[count].size = 0;	9091	/*
		9092	* Adjust base offset if the filter is associated to a
		9093	* binary that needs to be mapped:
		9094	*/
		9095	event->addr_filter_ranges[count].start = 0;
		9096	event->addr_filter_ranges[count].size = 0;
9093		9097
9094	/*
9095	* Adjust base offset if the filter is associated to a binary
9096	* that needs to be mapped:
9097	*/
9098	if (filter->path.dentry)
9099	perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);	9098	perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);
		9099	} else {
		9100	event->addr_filter_ranges[count].start = filter->offset;
		9101	event->addr_filter_ranges[count].size = filter->size;
		9102	}
9100		9103
9101	count++;	9104	count++;
9102	}	9105	}
@@ -9104,9 +9107,11 @@ static void perf_event_addr_filters_apply(struct perf_event *event) · 1 unmodified line
9104	event->addr_filters_gen++;	9107	event->addr_filters_gen++;
9105	raw_spin_unlock_irqrestore(&ifh->lock, flags);	9108	raw_spin_unlock_irqrestore(&ifh->lock, flags);
9106		9109
9107	up_read(&mm->mmap_sem);	9110	if (ifh->nr_file_filters) {
		9111	up_read(&mm->mmap_sem);
9108		9112
9109	mmput(mm);	9113	mmput(mm);
		9114	}
9110		9115
9111	restart:	9116	restart:
9112	perf_event_stop(event, 1);	9117	perf_event_stop(event, 1);

kernel/events/ring_buffer.c+15−18

@@ -455,24 +455,21 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size) · 454 unmodified lines
455	rb->aux_head += size;	455	rb->aux_head += size;
456	}	456	}
457		457
458	if (size \|\| handle->aux_flags) {	458	/*
459	/*	459	* Only send RECORD_AUX if we have something useful to communicate
460	* Only send RECORD_AUX if we have something useful to communicate	460	*
461	*	461	* Note: the OVERWRITE records by themselves are not considered
462	* Note: the OVERWRITE records by themselves are not considered	462	* useful, as they don't communicate any new information,
463	* useful, as they don't communicate any new information,	463	* aside from the short-lived offset, that becomes history at
464	* aside from the short-lived offset, that becomes history at	464	* the next event sched-in and therefore isn't useful.
465	* the next event sched-in and therefore isn't useful.	465	* The userspace that needs to copy out AUX data in overwrite
466	* The userspace that needs to copy out AUX data in overwrite	466	* mode should know to use user_page::aux_head for the actual
467	* mode should know to use user_page::aux_head for the actual	467	* offset. So, from now on we don't output AUX records that
468	* offset. So, from now on we don't output AUX records that	468	* have only OVERWRITE flag set.
469	* have only OVERWRITE flag set.	469	*/
470	*/	470	if (size \|\| (handle->aux_flags & ~(u64)PERF_AUX_FLAG_OVERWRITE))
471		471	perf_event_aux_event(handle->event, aux_head, size,
472	if (handle->aux_flags & ~(u64)PERF_AUX_FLAG_OVERWRITE)	472	handle->aux_flags);
473	perf_event_aux_event(handle->event, aux_head, size,
474	handle->aux_flags);
475	}
476		473
477	rb->user_page->aux_head = rb->aux_head;	474	rb->user_page->aux_head = rb->aux_head;
478	if (rb_need_aux_wakeup(rb))	475	if (rb_need_aux_wakeup(rb))

kernel/kprobes.c+2−4

 static int reuse_unused_kprobe(struct kprobe *ap)
 {
 	struct optimized_kprobe *op;
-	int ret;
 	/*
 	 * Unused kprobe MUST be on the way of delayed unoptimizing (means
 	/* Enable the probe again */
 	ap->flags &= ~KPROBE_FLAG_DISABLED;
 	/* Optimize it again (remove from op->list) */
-	ret = kprobe_optready(ap);
+	if (!kprobe_optready(ap))
-	if (ret)
+		return -EINVAL;
-		return ret;
 	optimize_kprobe(ap);
 	return 0;

kernel/locking/lockdep.c+5−4

@@ -4907,8 +4907,9 @@ void lockdep_unregister_key(struct lock_class_key *key) · 4906 unmodified lines
4907	return;	4907	return;
4908		4908
4909	raw_local_irq_save(flags);	4909	raw_local_irq_save(flags);
4910	arch_spin_lock(&lockdep_lock);	4910	if (!graph_lock())
4911	current->lockdep_recursion = 1;	4911	goto out_irq;
		4912
4912	pf = get_pending_free();	4913	pf = get_pending_free();
4913	hlist_for_each_entry_rcu(k, hash_head, hash_entry) {	4914	hlist_for_each_entry_rcu(k, hash_head, hash_entry) {
4914	if (k == key) {	4915	if (k == key) {
@@ -4920,8 +4921,8 @@ void lockdep_unregister_key(struct lock_class_key *key) · 5 unmodified lines
4920	WARN_ON_ONCE(!found);	4921	WARN_ON_ONCE(!found);
4921	__lockdep_free_key_range(pf, key, 1);	4922	__lockdep_free_key_range(pf, key, 1);
4922	call_rcu_zapped(pf);	4923	call_rcu_zapped(pf);
4923	current->lockdep_recursion = 0;	4924	graph_unlock();
4924	arch_spin_unlock(&lockdep_lock);	4925	out_irq:
4925	raw_local_irq_restore(flags);	4926	raw_local_irq_restore(flags);
4926		4927
4927	/* Wait until is_dynamic_key() has finished accessing k->hash_entry. */	4928	/* Wait until is_dynamic_key() has finished accessing k->hash_entry. */

kernel/sched/deadline.c+1−2

 	if (dl_entity_is_special(dl_se))
 		return;
-	WARN_ON(hrtimer_active(&dl_se->inactive_timer));
 	WARN_ON(dl_se->dl_non_contending);
 	zerolag_time = dl_se->deadline -
 	 * If the "0-lag time" already passed, decrease the active
 	 * utilization now, instead of starting a timer
 	 */
-	if (zerolag_time < 0) {
+	if ((zerolag_time < 0) || hrtimer_active(&dl_se->inactive_timer)) {
 		if (dl_task(p))
 			sub_running_bw(dl_se, dl_rq);
 		if (!dl_task(p) || p->state == TASK_DEAD) {

kernel/sched/fair.c+25−0

@@ -4885,6 +4885,8 @@ static enum hrtimer_restart sched_cfs_slack_timer(struct hrtimer *timer) · 4884 unmodified lines
4885	return HRTIMER_NORESTART;	4885	return HRTIMER_NORESTART;
4886	}	4886	}
4887		4887
		4888	extern const u64 max_cfs_quota_period;
		4889
4888	static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)	4890	static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
4889	{	4891	{
4890	struct cfs_bandwidth *cfs_b =	4892	struct cfs_bandwidth *cfs_b =
@@ -4892,6 +4894,7 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer) · 1 unmodified line
4892	unsigned long flags;	4894	unsigned long flags;
4893	int overrun;	4895	int overrun;
4894	int idle = 0;	4896	int idle = 0;
		4897	int count = 0;
4895		4898
4896	raw_spin_lock_irqsave(&cfs_b->lock, flags);	4899	raw_spin_lock_irqsave(&cfs_b->lock, flags);
4897	for (;;) {	4900	for (;;) {
@@ -4899,6 +4902,28 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer) · 1 unmodified line
4899	if (!overrun)	4902	if (!overrun)
4900	break;	4903	break;
4901		4904
		4905	if (++count > 3) {
		4906	u64 new, old = ktime_to_ns(cfs_b->period);
		4907
		4908	new = (old * 147) / 128; /* ~115% */
		4909	new = min(new, max_cfs_quota_period);
		4910
		4911	cfs_b->period = ns_to_ktime(new);
		4912
		4913	/* since max is 1s, this is limited to 1e9^2, which fits in u64 */
		4914	cfs_b->quota *= new;
		4915	cfs_b->quota = div64_u64(cfs_b->quota, old);
		4916
		4917	pr_warn_ratelimited(
		4918	"cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us %lld, cfs_quota_us = %lld)\n",
		4919	smp_processor_id(),
		4920	div_u64(new, NSEC_PER_USEC),
		4921	div_u64(cfs_b->quota, NSEC_PER_USEC));
		4922
		4923	/* reset count so we don't come right back in here */
		4924	count = 0;
		4925	}
		4926
4902	idle = do_sched_cfs_period_timer(cfs_b, overrun, flags);	4927	idle = do_sched_cfs_period_timer(cfs_b, overrun, flags);
4903	}	4928	}
4904	if (idle)	4929	if (idle)

kernel/signal.c+1−1

@@ -3581,7 +3581,7 @@ SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig, · 3580 unmodified lines
3581	if (flags)	3581	if (flags)
3582	return -EINVAL;	3582	return -EINVAL;
3583		3583
3584	f = fdget_raw(pidfd);	3584	f = fdget(pidfd);
3585	if (!f.file)	3585	if (!f.file)
3586	return -EBADF;	3586	return -EBADF;
3587		3587

kernel/time/sched_clock.c+2−2

@@ -272,7 +272,7 @@ static u64 notrace suspended_sched_clock_read(void) · 271 unmodified lines
272	return cd.read_data[seq & 1].epoch_cyc;	272	return cd.read_data[seq & 1].epoch_cyc;
273	}	273	}
274		274
275	static int sched_clock_suspend(void)	275	int sched_clock_suspend(void)
276	{	276	{
277	struct clock_read_data *rd = &cd.read_data[0];	277	struct clock_read_data *rd = &cd.read_data[0];
278		278
@@ -283,7 +283,7 @@ static int sched_clock_suspend(void) · 4 unmodified lines
283	return 0;	283	return 0;
284	}	284	}
285		285
286	static void sched_clock_resume(void)	286	void sched_clock_resume(void)
287	{	287	{
288	struct clock_read_data *rd = &cd.read_data[0];	288	struct clock_read_data *rd = &cd.read_data[0];
289		289

kernel/time/tick-common.c+2−0

 		trace_suspend_resume(TPS("timekeeping_freeze"),
 				     smp_processor_id(), true);
 		system_state = SYSTEM_SUSPEND;
+		sched_clock_suspend();
 		timekeeping_suspend();
 	} else {
 		tick_suspend_local();
 	if (tick_freeze_depth == num_online_cpus()) {
 		timekeeping_resume();
+		sched_clock_resume();
 		system_state = SYSTEM_RUNNING;
 		trace_suspend_resume(TPS("timekeeping_freeze"),
 				     smp_processor_id(), false);

kernel/time/timekeeping.h+7−0

@@ -14,6 +14,13 @@ extern u64 timekeeping_max_deferment(void); · 13 unmodified lines
14	extern void timekeeping_warp_clock(void);	14	extern void timekeeping_warp_clock(void);
15	extern int timekeeping_suspend(void);	15	extern int timekeeping_suspend(void);
16	extern void timekeeping_resume(void);	16	extern void timekeeping_resume(void);
		17	#ifdef CONFIG_GENERIC_SCHED_CLOCK
		18	extern int sched_clock_suspend(void);
		19	extern void sched_clock_resume(void);
		20	#else
		21	static inline int sched_clock_suspend(void) { return 0; }
		22	static inline void sched_clock_resume(void) { }
		23	#endif
17		24
18	extern void do_timer(unsigned long ticks);	25	extern void do_timer(unsigned long ticks);
19	extern void update_wall_time(void);	26	extern void update_wall_time(void);

kernel/trace/ftrace.c+5−1

 #include <linux/list.h>
 #include <linux/hash.h>
 #include <linux/rcupdate.h>
+#include <linux/kprobes.h>
 #include <trace/events/sched.h>
 	tr->ops->func = ftrace_stub;
 }
-static inline void
+static nokprobe_inline void
 __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
 		       struct ftrace_ops *ignored, struct pt_regs *regs)
 {
 {
 	__ftrace_ops_list_func(ip, parent_ip, NULL, regs);
 }
+NOKPROBE_SYMBOL(ftrace_ops_list_func);
 #else
 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
 {
 	__ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
 }
+NOKPROBE_SYMBOL(ftrace_ops_no_ops);
 #endif
 /*
 	preempt_enable_notrace();
 	trace_clear_recursion(bit);
 }
+NOKPROBE_SYMBOL(ftrace_ops_assist_func);
 /**
  * ftrace_ops_get_func - get the function a trampoline should call

kernel/watchdog_hld.c+2−1

@@ -135,7 +135,8 @@ static void watchdog_overflow_callback(struct perf_event *event, · 134 unmodified lines
135	if (__this_cpu_read(hard_watchdog_warn) == true)	135	if (__this_cpu_read(hard_watchdog_warn) == true)
136	return;	136	return;
137		137
138	pr_emerg("Watchdog detected hard LOCKUP on cpu %d", this_cpu);	138	pr_emerg("Watchdog detected hard LOCKUP on cpu %d\n",
		139	this_cpu);
139	print_modules();	140	print_modules();
140	print_irqtrace_events(current);	141	print_irqtrace_events(current);
141	if (regs)	142	if (regs)

lib/Kconfig.debug+3−3

@@ -761,9 +761,9 @@ endmenu # "Memory Debugging" · 760 unmodified lines
761	config ARCH_HAS_KCOV	761	config ARCH_HAS_KCOV
762	bool	762	bool
763	help	763	help
764	KCOV does not have any arch-specific code, but currently it is enabled	764	An architecture should select this when it can successfully
765	only for x86_64. KCOV requires testing on other archs, and most likely	765	build and run with CONFIG_KCOV. This typically requires
766	disabling of instrumentation for some early boot code.	766	disabling instrumentation for some early boot code.
767		767
768	config CC_HAS_SANCOV_TRACE_PC	768	config CC_HAS_SANCOV_TRACE_PC
769	def_bool $(cc-option,-fsanitize-coverage=trace-pc)	769	def_bool $(cc-option,-fsanitize-coverage=trace-pc)

mm/kmemleak.c+2−0

 /*
  * Scan a large memory block in MAX_SCAN_SIZE chunks to reduce the latency.
  */
+#ifdef CONFIG_SMP
 static void scan_large_block(void *start, void *end)
 {
 	void *next;
 		cond_resched();
 	}
 }
+#endif
 /*
  * Scan a memory block corresponding to a kmemleak_object. A condition is

mm/mmap.c+6−1

 #include <linux/moduleparam.h>
 #include <linux/pkeys.h>
 #include <linux/oom.h>
+#include <linux/sched/mm.h>
 #include <linux/uaccess.h>
 #include <asm/cacheflush.h>
 	vma = find_vma_prev(mm, addr, &prev);
 	if (vma && (vma->vm_start <= addr))
 		return vma;
-	if (!prev || expand_stack(prev, addr))
+	/* don't alter vm_end if the coredump is running */
+	if (!prev || !mmget_still_valid(mm) || expand_stack(prev, addr))
 		return NULL;
 	if (prev->vm_flags & VM_LOCKED)
 		populate_vma_page_range(prev, addr, prev->vm_end, NULL);
 		return vma;
 	if (!(vma->vm_flags & VM_GROWSDOWN))
 		return NULL;
+	/* don't alter vm_start if the coredump is running */
+	if (!mmget_still_valid(mm))
+		return NULL;
 	start = vma->vm_start;
 	if (expand_stack(vma, addr))
 		return NULL;

mm/page_alloc.c+18−12

 bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
 			 int migratetype, int flags)
 {
-	unsigned long pfn, iter, found;
+	unsigned long found;
+	unsigned long iter = 0;
+	unsigned long pfn = page_to_pfn(page);
+	const char *reason = "unmovable page";
 	/*
 	 * TODO we could make this much more efficient by not checking every
 	 * can still lead to having bootmem allocations in zone_movable.
 	 */
-	/*
+	if (is_migrate_cma_page(page)) {
-	 * CMA allocations (alloc_contig_range) really need to mark isolate
+		/*
-	 * CMA pageblocks even when they are not movable in fact so consider
+		 * CMA allocations (alloc_contig_range) really need to mark
-	 * them movable here.
+		 * isolate CMA pageblocks even when they are not movable in fact
-	 */
+		 * so consider them movable here.
-	if (is_migrate_cma(migratetype) &&
+		 */
-			is_migrate_cma(get_pageblock_migratetype(page)))
+		if (is_migrate_cma(migratetype))
-		return false;
+			return false;
+		reason = "CMA page";
+		goto unmovable;
+	}
-	pfn = page_to_pfn(page);
+	for (found = 0; iter < pageblock_nr_pages; iter++) {
-	for (found = 0, iter = 0; iter < pageblock_nr_pages; iter++) {
 		unsigned long check = pfn + iter;
 		if (!pfn_valid_within(check))
 unmovable:
 	WARN_ON_ONCE(zone_idx(zone) == ZONE_MOVABLE);
 	if (flags & REPORT_FAILURE)
-		dump_page(pfn_to_page(pfn+iter), "unmovable page");
+		dump_page(pfn_to_page(pfn + iter), reason);
 	return true;
 }

mm/percpu.c+4−4

@@ -2567,8 +2567,8 @@ int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size, · 2566 unmodified lines
2567	ai->groups[group].base_offset = areas[group] - base;	2567	ai->groups[group].base_offset = areas[group] - base;
2568	}	2568	}
2569		2569
2570	pr_info("Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n",	2570	pr_info("Embedded %zu pages/cpu s%zu r%zu d%zu u%zu\n",
2571	PFN_DOWN(size_sum), base, ai->static_size, ai->reserved_size,	2571	PFN_DOWN(size_sum), ai->static_size, ai->reserved_size,
2572	ai->dyn_size, ai->unit_size);	2572	ai->dyn_size, ai->unit_size);
2573		2573
2574	rc = pcpu_setup_first_chunk(ai, base);	2574	rc = pcpu_setup_first_chunk(ai, base);
@@ -2692,8 +2692,8 @@ int __init pcpu_page_first_chunk(size_t reserved_size, · 117 unmodified lines
2692	}	2692	}
2693		2693
2694	/* we're ready, commit */	2694	/* we're ready, commit */
2695	pr_info("%d %s pages/cpu @%p s%zu r%zu d%zu\n",	2695	pr_info("%d %s pages/cpu s%zu r%zu d%zu\n",
2696	unit_pages, psize_str, vm.addr, ai->static_size,	2696	unit_pages, psize_str, ai->static_size,
2697	ai->reserved_size, ai->dyn_size);	2697	ai->reserved_size, ai->dyn_size);
2698		2698
2699	rc = pcpu_setup_first_chunk(ai, vm.addr);	2699	rc = pcpu_setup_first_chunk(ai, vm.addr);

mm/shmem.c+27−31

@@ -1081,9 +1081,14 @@ static void shmem_evict_inode(struct inode *inode) · 1080 unmodified lines
1081	}	1081	}
1082	spin_unlock(&sbinfo->shrinklist_lock);	1082	spin_unlock(&sbinfo->shrinklist_lock);
1083	}	1083	}
1084	if (!list_empty(&info->swaplist)) {	1084	while (!list_empty(&info->swaplist)) {
		1085	/* Wait while shmem_unuse() is scanning this inode... */
		1086	wait_var_event(&info->stop_eviction,
		1087	!atomic_read(&info->stop_eviction));
1085	mutex_lock(&shmem_swaplist_mutex);	1088	mutex_lock(&shmem_swaplist_mutex);
1086	list_del_init(&info->swaplist);	1089	/* ...but beware of the race if we peeked too early */
		1090	if (!atomic_read(&info->stop_eviction))
		1091	list_del_init(&info->swaplist);
1087	mutex_unlock(&shmem_swaplist_mutex);	1092	mutex_unlock(&shmem_swaplist_mutex);
1088	}	1093	}
1089	}	1094	}
@@ -1099,10 +1104,11 @@ extern struct swap_info_struct *swap_info[]; · 9 unmodified lines
1099	static int shmem_find_swap_entries(struct address_space *mapping,	1104	static int shmem_find_swap_entries(struct address_space *mapping,
1100	pgoff_t start, unsigned int nr_entries,	1105	pgoff_t start, unsigned int nr_entries,
1101	struct page *entries, pgoff_t indices,	1106	struct page *entries, pgoff_t indices,
1102	bool frontswap)	1107	unsigned int type, bool frontswap)
1103	{	1108	{
1104	XA_STATE(xas, &mapping->i_pages, start);	1109	XA_STATE(xas, &mapping->i_pages, start);
1105	struct page *page;	1110	struct page *page;
		1111	swp_entry_t entry;
1106	unsigned int ret = 0;	1112	unsigned int ret = 0;
1107		1113
1108	if (!nr_entries)	1114	if (!nr_entries)
@@ -1116,13 +1122,12 @@ static int shmem_find_swap_entries(struct address_space *mapping, · 7 unmodified lines
1116	if (!xa_is_value(page))	1122	if (!xa_is_value(page))
1117	continue;	1123	continue;
1118		1124
1119	if (frontswap) {	1125	entry = radix_to_swp_entry(page);
1120	swp_entry_t entry = radix_to_swp_entry(page);	1126	if (swp_type(entry) != type)
1121		1127	continue;
1122	if (!frontswap_test(swap_info[swp_type(entry)],	1128	if (frontswap &&
1123	swp_offset(entry)))	1129	!frontswap_test(swap_info[type], swp_offset(entry)))
1124	continue;	1130	continue;
1125	}
1126		1131
1127	indices[ret] = xas.xa_index;	1132	indices[ret] = xas.xa_index;
1128	entries[ret] = page;	1133	entries[ret] = page;
@@ -1194,7 +1199,7 @@ static int shmem_unuse_inode(struct inode *inode, unsigned int type, · 65 unmodified lines
1194		1199
1195	pvec.nr = shmem_find_swap_entries(mapping, start, nr_entries,	1200	pvec.nr = shmem_find_swap_entries(mapping, start, nr_entries,
1196	pvec.pages, indices,	1201	pvec.pages, indices,
1197	frontswap);	1202	type, frontswap);
1198	if (pvec.nr == 0) {	1203	if (pvec.nr == 0) {
1199	ret = 0;	1204	ret = 0;
1200	break;	1205	break;
@@ -1227,36 +1232,27 @@ int shmem_unuse(unsigned int type, bool frontswap, · 26 unmodified lines
1227	unsigned long *fs_pages_to_unuse)	1232	unsigned long *fs_pages_to_unuse)
1228	{	1233	{
1229	struct shmem_inode_info info, next;	1234	struct shmem_inode_info info, next;
1230	struct inode *inode;
1231	struct inode *prev_inode = NULL;
1232	int error = 0;	1235	int error = 0;
1233		1236
1234	if (list_empty(&shmem_swaplist))	1237	if (list_empty(&shmem_swaplist))
1235	return 0;	1238	return 0;
1236		1239
1237	mutex_lock(&shmem_swaplist_mutex);	1240	mutex_lock(&shmem_swaplist_mutex);
1238
1239	/*
1240	* The extra refcount on the inode is necessary to safely dereference
1241	* p->next after re-acquiring the lock. New shmem inodes with swap
1242	* get added to the end of the list and we will scan them all.
1243	*/
1244	list_for_each_entry_safe(info, next, &shmem_swaplist, swaplist) {	1241	list_for_each_entry_safe(info, next, &shmem_swaplist, swaplist) {
1245	if (!info->swapped) {	1242	if (!info->swapped) {
1246	list_del_init(&info->swaplist);	1243	list_del_init(&info->swaplist);
1247	continue;	1244	continue;
1248	}	1245	}
1249		1246	/*
1250	inode = igrab(&info->vfs_inode);	1247	* Drop the swaplist mutex while searching the inode for swap;
1251	if (!inode)	1248	* but before doing so, make sure shmem_evict_inode() will not
1252	continue;	1249	* remove placeholder inode from swaplist, nor let it be freed
1253		1250	* (igrab() would protect from unlink, but not from unmount).
		1251	*/
		1252	atomic_inc(&info->stop_eviction);
1254	mutex_unlock(&shmem_swaplist_mutex);	1253	mutex_unlock(&shmem_swaplist_mutex);
1255	if (prev_inode)
1256	iput(prev_inode);
1257	prev_inode = inode;
1258		1254
1259	error = shmem_unuse_inode(inode, type, frontswap,	1255	error = shmem_unuse_inode(&info->vfs_inode, type, frontswap,
1260	fs_pages_to_unuse);	1256	fs_pages_to_unuse);
1261	cond_resched();	1257	cond_resched();
1262		1258
@@ -1264,14 +1260,13 @@ int shmem_unuse(unsigned int type, bool frontswap, · 1 unmodified line
1264	next = list_next_entry(info, swaplist);	1260	next = list_next_entry(info, swaplist);
1265	if (!info->swapped)	1261	if (!info->swapped)
1266	list_del_init(&info->swaplist);	1262	list_del_init(&info->swaplist);
		1263	if (atomic_dec_and_test(&info->stop_eviction))
		1264	wake_up_var(&info->stop_eviction);
1267	if (error)	1265	if (error)
1268	break;	1266	break;
1269	}	1267	}
1270	mutex_unlock(&shmem_swaplist_mutex);	1268	mutex_unlock(&shmem_swaplist_mutex);
1271		1269
1272	if (prev_inode)
1273	iput(prev_inode);
1274
1275	return error;	1270	return error;
1276	}	1271	}
1277		1272
@@ -2238,6 +2233,7 @@ static struct inode shmem_get_inode(struct super_block sb, const struct inode · 960 unmodified lines
2238	info = SHMEM_I(inode);	2233	info = SHMEM_I(inode);
2239	memset(info, 0, (char )inode - (char )info);	2234	memset(info, 0, (char )inode - (char )info);
2240	spin_lock_init(&info->lock);	2235	spin_lock_init(&info->lock);
		2236	atomic_set(&info->stop_eviction, 0);
2241	info->seals = F_SEAL_SEAL;	2237	info->seals = F_SEAL_SEAL;
2242	info->flags = flags & VM_NORESERVE;	2238	info->flags = flags & VM_NORESERVE;
2243	INIT_LIST_HEAD(&info->shrinklist);	2239	INIT_LIST_HEAD(&info->shrinklist);

mm/slab.c+0−1

@@ -2374,7 +2374,6 @@ static void alloc_slabmgmt(struct kmem_cache cachep, · 2373 unmodified lines
2374	/* Slab management obj is off-slab. */	2374	/* Slab management obj is off-slab. */
2375	freelist = kmem_cache_alloc_node(cachep->freelist_cache,	2375	freelist = kmem_cache_alloc_node(cachep->freelist_cache,
2376	local_flags, nodeid);	2376	local_flags, nodeid);
2377	freelist = kasan_reset_tag(freelist);
2378	if (!freelist)	2377	if (!freelist)
2379	return NULL;	2378	return NULL;
2380	} else {	2379	} else {

mm/swapfile.c+17−15

@@ -2023,7 +2023,6 @@ static unsigned int find_next_to_unuse(struct swap_info_struct *si, · 2022 unmodified lines
2023	* If the boolean frontswap is true, only unuse pages_to_unuse pages;	2023	* If the boolean frontswap is true, only unuse pages_to_unuse pages;
2024	* pages_to_unuse==0 means all pages; ignored if frontswap is false	2024	* pages_to_unuse==0 means all pages; ignored if frontswap is false
2025	*/	2025	*/
2026	#define SWAP_UNUSE_MAX_TRIES 3
2027	int try_to_unuse(unsigned int type, bool frontswap,	2026	int try_to_unuse(unsigned int type, bool frontswap,
2028	unsigned long pages_to_unuse)	2027	unsigned long pages_to_unuse)
2029	{	2028	{
@@ -2035,7 +2034,6 @@ int try_to_unuse(unsigned int type, bool frontswap, · 5 unmodified lines
2035	struct page *page;	2034	struct page *page;
2036	swp_entry_t entry;	2035	swp_entry_t entry;
2037	unsigned int i;	2036	unsigned int i;
2038	int retries = 0;
2039		2037
2040	if (!si->inuse_pages)	2038	if (!si->inuse_pages)
2041	return 0;	2039	return 0;
@@ -2053,11 +2051,9 @@ retry: · 11 unmodified lines
2053		2051
2054	spin_lock(&mmlist_lock);	2052	spin_lock(&mmlist_lock);
2055	p = &init_mm.mmlist;	2053	p = &init_mm.mmlist;
2056	while ((p = p->next) != &init_mm.mmlist) {	2054	while (si->inuse_pages &&
2057	if (signal_pending(current)) {	2055	!signal_pending(current) &&
2058	retval = -EINTR;	2056	(p = p->next) != &init_mm.mmlist) {
2059	break;
2060	}
2061		2057
2062	mm = list_entry(p, struct mm_struct, mmlist);	2058	mm = list_entry(p, struct mm_struct, mmlist);
2063	if (!mmget_not_zero(mm))	2059	if (!mmget_not_zero(mm))
@@ -2084,7 +2080,9 @@ retry: · 20 unmodified lines
2084	mmput(prev_mm);	2080	mmput(prev_mm);
2085		2081
2086	i = 0;	2082	i = 0;
2087	while ((i = find_next_to_unuse(si, i, frontswap)) != 0) {	2083	while (si->inuse_pages &&
		2084	!signal_pending(current) &&
		2085	(i = find_next_to_unuse(si, i, frontswap)) != 0) {
2088		2086
2089	entry = swp_entry(type, i);	2087	entry = swp_entry(type, i);
2090	page = find_get_page(swap_address_space(entry), i);	2088	page = find_get_page(swap_address_space(entry), i);
@@ -2117,14 +2115,18 @@ retry: · 26 unmodified lines
2117	* If yes, we would need to do retry the unuse logic again.	2115	* If yes, we would need to do retry the unuse logic again.
2118	* Under global memory pressure, swap entries can be reinserted back	2116	* Under global memory pressure, swap entries can be reinserted back
2119	* into process space after the mmlist loop above passes over them.	2117	* into process space after the mmlist loop above passes over them.
2120	* Its not worth continuosuly retrying to unuse the swap in this case.	2118	*
2121	* So we try SWAP_UNUSE_MAX_TRIES times.	2119	* Limit the number of retries? No: when mmget_not_zero() above fails,
		2120	* that mm is likely to be freeing swap from exit_mmap(), which proceeds
		2121	* at its own independent pace; and even shmem_writepage() could have
		2122	* been preempted after get_swap_page(), temporarily hiding that swap.
		2123	* It's easy and robust (though cpu-intensive) just to keep retrying.
2122	*/	2124	*/
2123	if (++retries >= SWAP_UNUSE_MAX_TRIES)	2125	if (si->inuse_pages) {
2124	retval = -EBUSY;	2126	if (!signal_pending(current))
2125	else if (si->inuse_pages)	2127	goto retry;
2126	goto retry;	2128	retval = -EINTR;
2127		2129	}
2128	out:	2130	out:
2129	return (retval == FRONTSWAP_PAGES_UNUSED) ? 0 : retval;	2131	return (retval == FRONTSWAP_PAGES_UNUSED) ? 0 : retval;
2130	}	2132	}

mm/vmscan.c+9−20

  *   10TB     320        32GB
  */
 static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
-				 struct mem_cgroup *memcg,
 				 struct scan_control *sc, bool actual_reclaim)
 {
 	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
 	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
 	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
-	if (memcg)
-		refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
-	else
-		refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
 	/*
 	 * When refaults are being observed, it means a new workingset
 	 * is being established. Disable active list protection to get
 	 * rid of the stale workingset quickly.
 	 */
+	refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
 	if (file && actual_reclaim && lruvec->refaults != refaults) {
 		inactive_ratio = 0;
 	} else {
 }
 static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
-				 struct lruvec *lruvec, struct mem_cgroup *memcg,
+				 struct lruvec *lruvec, struct scan_control *sc)
-				 struct scan_control *sc)
 {
 	if (is_active_lru(lru)) {
-		if (inactive_list_is_low(lruvec, is_file_lru(lru),
+		if (inactive_list_is_low(lruvec, is_file_lru(lru), sc, true))
-					 memcg, sc, true))
 			shrink_active_list(nr_to_scan, lruvec, sc, lru);
 		return 0;
 	}
 			 * anonymous pages on the LRU in eligible zones.
 			 * Otherwise, the small LRU gets thrashed.
 			 */
-			if (!inactive_list_is_low(lruvec, false, memcg, sc, false) &&
+			if (!inactive_list_is_low(lruvec, false, sc, false) &&
 			    lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
 					>> sc->priority) {
 				scan_balance = SCAN_ANON;
 	 * lruvec even if it has plenty of old anonymous pages unless the
 	 * system is under heavy pressure.
 	 */
-	if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
+	if (!inactive_list_is_low(lruvec, true, sc, false) &&
 	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
 		scan_balance = SCAN_FILE;
 		goto out;
 				nr[lru] -= nr_to_scan;
 				nr_reclaimed += shrink_list(lru, nr_to_scan,
-							    lruvec, memcg, sc);
+							    lruvec, sc);
 			}
 		}
 	 * Even if we did not try to evict anon pages at all, we want to
 	 * rebalance the anon lru active/inactive ratio.
 	 */
-	if (inactive_list_is_low(lruvec, false, memcg, sc, true))
+	if (inactive_list_is_low(lruvec, false, sc, true))
 		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
 				   sc, LRU_ACTIVE_ANON);
 }
 		unsigned long refaults;
 		struct lruvec *lruvec;
-		if (memcg)
-			refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
-		else
-			refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
 		lruvec = mem_cgroup_lruvec(pgdat, memcg);
+		refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
 		lruvec->refaults = refaults;
 	} while ((memcg = mem_cgroup_iter(root_memcg, memcg, NULL)));
 }
 	do {
 		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
-		if (inactive_list_is_low(lruvec, false, memcg, sc, true))
+		if (inactive_list_is_low(lruvec, false, sc, true))
 			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
 					   sc, LRU_ACTIVE_ANON);

mm/vmstat.c+0−5

 #endif
 #endif /* CONFIG_MEMORY_BALLOON */
 #ifdef CONFIG_DEBUG_TLBFLUSH
-#ifdef CONFIG_SMP
 	"nr_tlb_remote_flush",
 	"nr_tlb_remote_flush_received",
-#else
-	"", /* nr_tlb_remote_flush */
-	"", /* nr_tlb_remote_flush_received */
-#endif /* CONFIG_SMP */
 	"nr_tlb_local_flush_all",
 	"nr_tlb_local_flush_one",
 #endif /* CONFIG_DEBUG_TLBFLUSH */

net/bridge/netfilter/ebtables.c+2−1

@@ -2027,7 +2027,8 @@ static int ebt_size_mwt(struct compat_ebt_entry_mwt *match32, · 2026 unmodified lines
2027	if (match_kern)	2027	if (match_kern)
2028	match_kern->match_size = ret;	2028	match_kern->match_size = ret;
2029		2029
2030	if (WARN_ON(type == EBT_COMPAT_TARGET && size_left))	2030	/* rule should have no remaining data after target */
		2031	if (type == EBT_COMPAT_TARGET && size_left)
2031	return -EINVAL;	2032	return -EINVAL;
2032		2033
2033	match32 = (struct compat_ebt_entry_mwt *) buf;	2034	match32 = (struct compat_ebt_entry_mwt *) buf;

net/ipv4/route.c+23−9

 	return dst;
 }
-static void ipv4_link_failure(struct sk_buff *skb)
+static void ipv4_send_dest_unreach(struct sk_buff *skb)
 {
 	struct ip_options opt;
-	struct rtable *rt;
 	int res;
 	/* Recompile ip options since IPCB may not be valid anymore.
+	 * Also check we have a reasonable ipv4 header.
 	 */
-	memset(&opt, 0, sizeof(opt));
+	if (!pskb_network_may_pull(skb, sizeof(struct iphdr)) ||
-	opt.optlen = ip_hdr(skb)->ihl*4 - sizeof(struct iphdr);
+	    ip_hdr(skb)->version != 4 || ip_hdr(skb)->ihl < 5)
+		return;
-	rcu_read_lock();
+	memset(&opt, 0, sizeof(opt));
-	res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL);
+	if (ip_hdr(skb)->ihl > 5) {
-	rcu_read_unlock();
+		if (!pskb_network_may_pull(skb, ip_hdr(skb)->ihl * 4))
+			return;
+		opt.optlen = ip_hdr(skb)->ihl * 4 - sizeof(struct iphdr);
-	if (res)
+		rcu_read_lock();
-		return;
+		res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL);
+		rcu_read_unlock();
+		if (res)
+			return;
+	}
 	__icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, &opt);
+}
+static void ipv4_link_failure(struct sk_buff *skb)
+{
+	struct rtable *rt;
+	ipv4_send_dest_unreach(skb);
 	rt = skb_rtable(skb);
 	if (rt)

net/ipv4/sysctl_net_ipv4.c+4−1

 static int ip_ping_group_range_max[] = { GID_T_MAX, GID_T_MAX };
 static int comp_sack_nr_max = 255;
 static u32 u32_max_div_HZ = UINT_MAX / HZ;
+static int one_day_secs = 24 * 3600;
 /* obsolete */
 static int sysctl_tcp_low_latency __read_mostly;
 		.data		= &init_net.ipv4.sysctl_tcp_min_rtt_wlen,
 		.maxlen		= sizeof(int),
 		.mode		= 0644,
-		.proc_handler	= proc_dointvec
+		.proc_handler	= proc_dointvec_minmax,
+		.extra1		= &zero,
+		.extra2		= &one_day_secs
 	},
 	{
 		.procname	= "tcp_autocorking",

net/ipv6/addrlabel.c+1−1

@@ -476,7 +476,7 @@ static int ip6addrlbl_valid_dump_req(const struct nlmsghdr *nlh, · 475 unmodified lines
476	}	476	}
477		477
478	if (nlmsg_attrlen(nlh, sizeof(*ifal))) {	478	if (nlmsg_attrlen(nlh, sizeof(*ifal))) {
479	NL_SET_ERR_MSG_MOD(extack, "Invalid data after header for address label dump requewst");	479	NL_SET_ERR_MSG_MOD(extack, "Invalid data after header for address label dump request");
480	return -EINVAL;	480	return -EINVAL;
481	}	481	}
482		482

net/ncsi/ncsi-rsp.c+5−1

 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
+#include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <net/ncsi.h>
 	ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 	memcpy(saddr.sa_data, &rsp->data[BCM_MAC_ADDR_OFFSET], ETH_ALEN);
 	/* Increase mac address by 1 for BMC's address */
-	saddr.sa_data[ETH_ALEN - 1]++;
+	eth_addr_inc((u8 *)saddr.sa_data);
+	if (!is_valid_ether_addr((const u8 *)saddr.sa_data))
+		return -ENXIO;
 	ret = ops->ndo_set_mac_address(ndev, &saddr);
 	if (ret < 0)
 		netdev_warn(ndev, "NCSI: 'Writing mac address to device failed\n");

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

@@ -1678,7 +1678,7 @@ ip_vs_in_icmp(struct netns_ipvs ipvs, struct sk_buff skb, int *related, · 1677 unmodified lines
1678	if (!cp) {	1678	if (!cp) {
1679	int v;	1679	int v;
1680		1680
1681	if (!sysctl_schedule_icmp(ipvs))	1681	if (ipip \|\| !sysctl_schedule_icmp(ipvs))
1682	return NF_ACCEPT;	1682	return NF_ACCEPT;
1683		1683
1684	if (!ip_vs_try_to_schedule(ipvs, AF_INET, skb, pd, &v, &cp, &ciph))	1684	if (!ip_vs_try_to_schedule(ipvs, AF_INET, skb, pd, &v, &cp, &ciph))

net/netfilter/nf_conntrack_core.c+38−5

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	#include <linux/slab.h>	25	#include <linux/slab.h>
26	#include <linux/random.h>	26	#include <linux/random.h>
27	#include <linux/jhash.h>	27	#include <linux/jhash.h>
		28	#include <linux/siphash.h>
28	#include <linux/err.h>	29	#include <linux/err.h>
29	#include <linux/percpu.h>	30	#include <linux/percpu.h>
30	#include <linux/moduleparam.h>	31	#include <linux/moduleparam.h>
@@ -449,6 +450,40 @@ nf_ct_invert_tuple(struct nf_conntrack_tuple *inverse, · 418 unmodified lines
449	}	450	}
450	EXPORT_SYMBOL_GPL(nf_ct_invert_tuple);	451	EXPORT_SYMBOL_GPL(nf_ct_invert_tuple);
451		452
		453	/* Generate a almost-unique pseudo-id for a given conntrack.
		454	*
		455	* intentionally doesn't re-use any of the seeds used for hash
		456	* table location, we assume id gets exposed to userspace.
		457	*
		458	* Following nf_conn items do not change throughout lifetime
		459	* of the nf_conn after it has been committed to main hash table:
		460	*
		461	* 1. nf_conn address
		462	* 2. nf_conn->ext address
		463	* 3. nf_conn->master address (normally NULL)
		464	* 4. tuple
		465	* 5. the associated net namespace
		466	*/
		467	u32 nf_ct_get_id(const struct nf_conn *ct)
		468	{
		469	static __read_mostly siphash_key_t ct_id_seed;
		470	unsigned long a, b, c, d;
		471
		472	net_get_random_once(&ct_id_seed, sizeof(ct_id_seed));
		473
		474	a = (unsigned long)ct;
		475	b = (unsigned long)ct->master ^ net_hash_mix(nf_ct_net(ct));
		476	c = (unsigned long)ct->ext;
		477	d = (unsigned long)siphash(&ct->tuplehash, sizeof(ct->tuplehash),
		478	&ct_id_seed);
		479	#ifdef CONFIG_64BIT
		480	return siphash_4u64((u64)a, (u64)b, (u64)c, (u64)d, &ct_id_seed);
		481	#else
		482	return siphash_4u32((u32)a, (u32)b, (u32)c, (u32)d, &ct_id_seed);
		483	#endif
		484	}
		485	EXPORT_SYMBOL_GPL(nf_ct_get_id);
		486
452	static void	487	static void
453	clean_from_lists(struct nf_conn *ct)	488	clean_from_lists(struct nf_conn *ct)
454	{	489	{
@@ -982,12 +1017,9 @@ __nf_conntrack_confirm(struct sk_buff *skb) · 527 unmodified lines
982		1017
983	/* set conntrack timestamp, if enabled. */	1018	/* set conntrack timestamp, if enabled. */
984	tstamp = nf_conn_tstamp_find(ct);	1019	tstamp = nf_conn_tstamp_find(ct);
985	if (tstamp) {	1020	if (tstamp)
986	if (skb->tstamp == 0)	1021	tstamp->start = ktime_get_real_ns();
987	__net_timestamp(skb);
988		1022
989	tstamp->start = ktime_to_ns(skb->tstamp);
990	}
991	/* Since the lookup is lockless, hash insertion must be done after	1023	/* Since the lookup is lockless, hash insertion must be done after
992	* starting the timer and setting the CONFIRMED bit. The RCU barriers	1024	* starting the timer and setting the CONFIRMED bit. The RCU barriers
993	* guarantee that no other CPU can find the conntrack before the above	1025	* guarantee that no other CPU can find the conntrack before the above
@@ -1350,6 +1382,7 @@ __nf_conntrack_alloc(struct net *net, · 356 unmodified lines
1350	/* save hash for reusing when confirming */	1382	/* save hash for reusing when confirming */
1351	(unsigned long )(&ct->tuplehash[IP_CT_DIR_REPLY].hnnode.pprev) = hash;	1383	(unsigned long )(&ct->tuplehash[IP_CT_DIR_REPLY].hnnode.pprev) = hash;
1352	ct->status = 0;	1384	ct->status = 0;
		1385	ct->timeout = 0;
1353	write_pnet(&ct->ct_net, net);	1386	write_pnet(&ct->ct_net, net);
1354	memset(&ct->__nfct_init_offset[0], 0,	1387	memset(&ct->__nfct_init_offset[0], 0,
1355	offsetof(struct nf_conn, proto) -	1388	offsetof(struct nf_conn, proto) -

net/netfilter/nf_conntrack_netlink.c+29−5

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include <linux/spinlock.h>	29	#include <linux/spinlock.h>
30	#include <linux/interrupt.h>	30	#include <linux/interrupt.h>
31	#include <linux/slab.h>	31	#include <linux/slab.h>
		32	#include <linux/siphash.h>
32		33
33	#include <linux/netfilter.h>	34	#include <linux/netfilter.h>
34	#include <net/netlink.h>	35	#include <net/netlink.h>
@@ -485,7 +486,9 @@ nla_put_failure: · 450 unmodified lines
485		486
486	static int ctnetlink_dump_id(struct sk_buff skb, const struct nf_conn ct)	487	static int ctnetlink_dump_id(struct sk_buff skb, const struct nf_conn ct)
487	{	488	{
488	if (nla_put_be32(skb, CTA_ID, htonl((unsigned long)ct)))	489	__be32 id = (__force __be32)nf_ct_get_id(ct);
		490
		491	if (nla_put_be32(skb, CTA_ID, id))
489	goto nla_put_failure;	492	goto nla_put_failure;
490	return 0;	493	return 0;
491		494
@@ -1286,8 +1289,9 @@ static int ctnetlink_del_conntrack(struct net net, struct sock ctnl, · 794 unmodified lines
1286	}	1289	}
1287		1290
1288	if (cda[CTA_ID]) {	1291	if (cda[CTA_ID]) {
1289	u_int32_t id = ntohl(nla_get_be32(cda[CTA_ID]));	1292	__be32 id = nla_get_be32(cda[CTA_ID]);
1290	if (id != (u32)(unsigned long)ct) {	1293
		1294	if (id != (__force __be32)nf_ct_get_id(ct)) {
1291	nf_ct_put(ct);	1295	nf_ct_put(ct);
1292	return -ENOENT;	1296	return -ENOENT;
1293	}	1297	}
@@ -2692,6 +2696,25 @@ nla_put_failure: · 1398 unmodified lines
2692		2696
2693	static const union nf_inet_addr any_addr;	2697	static const union nf_inet_addr any_addr;
2694		2698
		2699	static __be32 nf_expect_get_id(const struct nf_conntrack_expect *exp)
		2700	{
		2701	static __read_mostly siphash_key_t exp_id_seed;
		2702	unsigned long a, b, c, d;
		2703
		2704	net_get_random_once(&exp_id_seed, sizeof(exp_id_seed));
		2705
		2706	a = (unsigned long)exp;
		2707	b = (unsigned long)exp->helper;
		2708	c = (unsigned long)exp->master;
		2709	d = (unsigned long)siphash(&exp->tuple, sizeof(exp->tuple), &exp_id_seed);
		2710
		2711	#ifdef CONFIG_64BIT
		2712	return (__force __be32)siphash_4u64((u64)a, (u64)b, (u64)c, (u64)d, &exp_id_seed);
		2713	#else
		2714	return (__force __be32)siphash_4u32((u32)a, (u32)b, (u32)c, (u32)d, &exp_id_seed);
		2715	#endif
		2716	}
		2717
2695	static int	2718	static int
2696	ctnetlink_exp_dump_expect(struct sk_buff *skb,	2719	ctnetlink_exp_dump_expect(struct sk_buff *skb,
2697	const struct nf_conntrack_expect *exp)	2720	const struct nf_conntrack_expect *exp)
@@ -2739,7 +2762,7 @@ ctnetlink_exp_dump_expect(struct sk_buff *skb, · 41 unmodified lines
2739	}	2762	}
2740	#endif	2763	#endif
2741	if (nla_put_be32(skb, CTA_EXPECT_TIMEOUT, htonl(timeout)) \|\|	2764	if (nla_put_be32(skb, CTA_EXPECT_TIMEOUT, htonl(timeout)) \|\|
2742	nla_put_be32(skb, CTA_EXPECT_ID, htonl((unsigned long)exp)) \|\|	2765	nla_put_be32(skb, CTA_EXPECT_ID, nf_expect_get_id(exp)) \|\|
2743	nla_put_be32(skb, CTA_EXPECT_FLAGS, htonl(exp->flags)) \|\|	2766	nla_put_be32(skb, CTA_EXPECT_FLAGS, htonl(exp->flags)) \|\|
2744	nla_put_be32(skb, CTA_EXPECT_CLASS, htonl(exp->class)))	2767	nla_put_be32(skb, CTA_EXPECT_CLASS, htonl(exp->class)))
2745	goto nla_put_failure;	2768	goto nla_put_failure;
@@ -3044,7 +3067,8 @@ static int ctnetlink_get_expect(struct net net, struct sock ctnl, · 298 unmodified lines
3044		3067
3045	if (cda[CTA_EXPECT_ID]) {	3068	if (cda[CTA_EXPECT_ID]) {
3046	__be32 id = nla_get_be32(cda[CTA_EXPECT_ID]);	3069	__be32 id = nla_get_be32(cda[CTA_EXPECT_ID]);
3047	if (ntohl(id) != (u32)(unsigned long)exp) {	3070
		3071	if (id != nf_expect_get_id(exp)) {
3048	nf_ct_expect_put(exp);	3072	nf_ct_expect_put(exp);
3049	return -ENOENT;	3073	return -ENOENT;
3050	}	3074	}

net/netfilter/nf_conntrack_proto.c+1−1

@@ -55,7 +55,7 @@ void nf_l4proto_log_invalid(const struct sk_buff *skb, · 54 unmodified lines
55	struct va_format vaf;	55	struct va_format vaf;
56	va_list args;	56	va_list args;
57		57
58	if (net->ct.sysctl_log_invalid != protonum \|\|	58	if (net->ct.sysctl_log_invalid != protonum &&
59	net->ct.sysctl_log_invalid != IPPROTO_RAW)	59	net->ct.sysctl_log_invalid != IPPROTO_RAW)
60	return;	60	return;
61		61

net/netfilter/nf_conntrack_proto_icmp.c+72−21

 	return NF_ACCEPT;
 }
-/* Returns conntrack if it dealt with ICMP, and filled in skb fields */
+/* Check inner header is related to any of the existing connections */
-static int
+int nf_conntrack_inet_error(struct nf_conn *tmpl, struct sk_buff *skb,
-icmp_error_message(struct nf_conn *tmpl, struct sk_buff *skb,
+			    unsigned int dataoff,
-		   const struct nf_hook_state *state)
+			    const struct nf_hook_state *state,
+			    u8 l4proto, union nf_inet_addr *outer_daddr)
 {
 	struct nf_conntrack_tuple innertuple, origtuple;
 	const struct nf_conntrack_tuple_hash *h;
 	const struct nf_conntrack_zone *zone;
 	enum ip_conntrack_info ctinfo;
 	struct nf_conntrack_zone tmp;
+	union nf_inet_addr *ct_daddr;
+	enum ip_conntrack_dir dir;
+	struct nf_conn *ct;
 	WARN_ON(skb_nfct(skb));
 	zone = nf_ct_zone_tmpl(tmpl, skb, &tmp);
 	/* Are they talking about one of our connections? */
-	if (!nf_ct_get_tuplepr(skb,
+	if (!nf_ct_get_tuplepr(skb, dataoff,
-			       skb_network_offset(skb) + ip_hdrlen(skb)
+			       state->pf, state->net, &origtuple))
-						       + sizeof(struct icmphdr),
-			       PF_INET, state->net, &origtuple)) {
-		pr_debug("icmp_error_message: failed to get tuple\n");
 		return -NF_ACCEPT;
-	}
 	/* Ordinarily, we'd expect the inverted tupleproto, but it's
 	   been preserved inside the ICMP. */
-	if (!nf_ct_invert_tuple(&innertuple, &origtuple)) {
+	if (!nf_ct_invert_tuple(&innertuple, &origtuple))
-		pr_debug("icmp_error_message: no match\n");
 		return -NF_ACCEPT;
-	}
-	ctinfo = IP_CT_RELATED;
 	h = nf_conntrack_find_get(state->net, zone, &innertuple);
-	if (!h) {
+	if (!h)
-		pr_debug("icmp_error_message: no match\n");
+		return -NF_ACCEPT;
+	/* Consider: A -> T (=This machine) -> B
+	 *   Conntrack entry will look like this:
+	 *      Original:  A->B
+	 *      Reply:     B->T (SNAT case) OR A
+	 *
+	 * When this function runs, we got packet that looks like this:
+	 * iphdr|icmphdr|inner_iphdr|l4header (tcp, udp, ..).
+	 *
+	 * Above nf_conntrack_find_get() makes lookup based on inner_hdr,
+	 * so we should expect that destination of the found connection
+	 * matches outer header destination address.
+	 *
+	 * In above example, we can consider these two cases:
+	 *  1. Error coming in reply direction from B or M (middle box) to
+	 *     T (SNAT case) or A.
+	 *     Inner saddr will be B, dst will be T or A.
+	 *     The found conntrack will be reply tuple (B->T/A).
+	 *  2. Error coming in original direction from A or M to B.
+	 *     Inner saddr will be A, inner daddr will be B.
+	 *     The found conntrack will be original tuple (A->B).
+	 *
+	 * In both cases, conntrack[dir].dst == inner.dst.
+	 *
+	 * A bogus packet could look like this:
+	 *   Inner: B->T
+	 *   Outer: B->X (other machine reachable by T).
+	 *
+	 * In this case, lookup yields connection A->B and will
+	 * set packet from B->X as *RELATED*, even though no connection
+	 * from X was ever seen.
+	 */
+	ct = nf_ct_tuplehash_to_ctrack(h);
+	dir = NF_CT_DIRECTION(h);
+	ct_daddr = &ct->tuplehash[dir].tuple.dst.u3;
+	if (!nf_inet_addr_cmp(outer_daddr, ct_daddr)) {
+		if (state->pf == AF_INET) {
+			nf_l4proto_log_invalid(skb, state->net, state->pf,
+					       l4proto,
+					       "outer daddr %pI4 != inner %pI4",
+					       &outer_daddr->ip, &ct_daddr->ip);
+		} else if (state->pf == AF_INET6) {
+			nf_l4proto_log_invalid(skb, state->net, state->pf,
+					       l4proto,
+					       "outer daddr %pI6 != inner %pI6",
+					       &outer_daddr->ip6, &ct_daddr->ip6);
+		}
+		nf_ct_put(ct);
 		return -NF_ACCEPT;
 	}
-	if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY)
+	ctinfo = IP_CT_RELATED;
+	if (dir == IP_CT_DIR_REPLY)
 		ctinfo += IP_CT_IS_REPLY;
 	/* Update skb to refer to this connection */
-	nf_ct_set(skb, nf_ct_tuplehash_to_ctrack(h), ctinfo);
+	nf_ct_set(skb, ct, ctinfo);
 	return NF_ACCEPT;
 }
 			      struct sk_buff *skb, unsigned int dataoff,
 			      const struct nf_hook_state *state)
 {
+	union nf_inet_addr outer_daddr;
 	const struct icmphdr *icmph;
 	struct icmphdr _ih;
 	/* Not enough header? */
-	icmph = skb_header_pointer(skb, ip_hdrlen(skb), sizeof(_ih), &_ih);
+	icmph = skb_header_pointer(skb, dataoff, sizeof(_ih), &_ih);
 	if (icmph == NULL) {
 		icmp_error_log(skb, state, "short packet");
 		return -NF_ACCEPT;
 	    icmph->type != ICMP_REDIRECT)
 		return NF_ACCEPT;
-	return icmp_error_message(tmpl, skb, state);
+	memset(&outer_daddr, 0, sizeof(outer_daddr));
+	outer_daddr.ip = ip_hdr(skb)->daddr;
+	dataoff += sizeof(*icmph);
+	return nf_conntrack_inet_error(tmpl, skb, dataoff, state,
+				       IPPROTO_ICMP, &outer_daddr);
 }
 #if IS_ENABLED(CONFIG_NF_CT_NETLINK)

net/netfilter/nf_conntrack_proto_icmpv6.c+6−46

@@ -123,51 +123,6 @@ int nf_conntrack_icmpv6_packet(struct nf_conn *ct, · 122 unmodified lines
123	return NF_ACCEPT;	123	return NF_ACCEPT;
124	}	124	}
125		125
126	static int
127	icmpv6_error_message(struct net net, struct nf_conn tmpl,
128	struct sk_buff *skb,
129	unsigned int icmp6off)
130	{
131	struct nf_conntrack_tuple intuple, origtuple;
132	const struct nf_conntrack_tuple_hash *h;
133	enum ip_conntrack_info ctinfo;
134	struct nf_conntrack_zone tmp;
135
136	WARN_ON(skb_nfct(skb));
137
138	/* Are they talking about one of our connections? */
139	if (!nf_ct_get_tuplepr(skb,
140	skb_network_offset(skb)
141	+ sizeof(struct ipv6hdr)
142	+ sizeof(struct icmp6hdr),
143	PF_INET6, net, &origtuple)) {
144	pr_debug("icmpv6_error: Can't get tuple\n");
145	return -NF_ACCEPT;
146	}
147
148	/* Ordinarily, we'd expect the inverted tupleproto, but it's
149	been preserved inside the ICMP. */
150	if (!nf_ct_invert_tuple(&intuple, &origtuple)) {
151	pr_debug("icmpv6_error: Can't invert tuple\n");
152	return -NF_ACCEPT;
153	}
154
155	ctinfo = IP_CT_RELATED;
156
157	h = nf_conntrack_find_get(net, nf_ct_zone_tmpl(tmpl, skb, &tmp),
158	&intuple);
159	if (!h) {
160	pr_debug("icmpv6_error: no match\n");
161	return -NF_ACCEPT;
162	} else {
163	if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY)
164	ctinfo += IP_CT_IS_REPLY;
165	}
166
167	/* Update skb to refer to this connection */
168	nf_ct_set(skb, nf_ct_tuplehash_to_ctrack(h), ctinfo);
169	return NF_ACCEPT;
170	}
171		126
172	static void icmpv6_error_log(const struct sk_buff *skb,	127	static void icmpv6_error_log(const struct sk_buff *skb,
173	const struct nf_hook_state *state,	128	const struct nf_hook_state *state,
@@ -182,6 +137,7 @@ int nf_conntrack_icmpv6_error(struct nf_conn *tmpl, · 8 unmodified lines
182	unsigned int dataoff,	137	unsigned int dataoff,
183	const struct nf_hook_state *state)	138	const struct nf_hook_state *state)
184	{	139	{
		140	union nf_inet_addr outer_daddr;
185	const struct icmp6hdr *icmp6h;	141	const struct icmp6hdr *icmp6h;
186	struct icmp6hdr _ih;	142	struct icmp6hdr _ih;
187	int type;	143	int type;
@@ -210,7 +166,11 @@ int nf_conntrack_icmpv6_error(struct nf_conn *tmpl, · 22 unmodified lines
210	if (icmp6h->icmp6_type >= 128)	166	if (icmp6h->icmp6_type >= 128)
211	return NF_ACCEPT;	167	return NF_ACCEPT;
212		168
213	return icmpv6_error_message(state->net, tmpl, skb, dataoff);	169	memcpy(&outer_daddr.ip6, &ipv6_hdr(skb)->daddr,
		170	sizeof(outer_daddr.ip6));
		171	dataoff += sizeof(*icmp6h);
		172	return nf_conntrack_inet_error(tmpl, skb, dataoff, state,
		173	IPPROTO_ICMPV6, &outer_daddr);
214	}	174	}
215		175
216	#if IS_ENABLED(CONFIG_NF_CT_NETLINK)	176	#if IS_ENABLED(CONFIG_NF_CT_NETLINK)

net/netfilter/nf_nat_core.c+8−3

 	case IPPROTO_ICMPV6:
 		/* id is same for either direction... */
 		keyptr = &tuple->src.u.icmp.id;
-		min = range->min_proto.icmp.id;
+		if (!(range->flags & NF_NAT_RANGE_PROTO_SPECIFIED)) {
-		range_size = ntohs(range->max_proto.icmp.id) -
+			min = 0;
-			     ntohs(range->min_proto.icmp.id) + 1;
+			range_size = 65536;
+		} else {
+			min = ntohs(range->min_proto.icmp.id);
+			range_size = ntohs(range->max_proto.icmp.id) -
+				     ntohs(range->min_proto.icmp.id) + 1;
+		}
 		goto find_free_id;
 #if IS_ENABLED(CONFIG_NF_CT_PROTO_GRE)
 	case IPPROTO_GRE:

net/netfilter/nf_tables_api.c+1−1

@@ -1544,7 +1544,7 @@ static int nft_chain_parse_hook(struct net *net, · 1543 unmodified lines
1544	if (IS_ERR(type))	1544	if (IS_ERR(type))
1545	return PTR_ERR(type);	1545	return PTR_ERR(type);
1546	}	1546	}
1547	if (!(type->hook_mask & (1 << hook->num)))	1547	if (hook->num > NF_MAX_HOOKS \|\| !(type->hook_mask & (1 << hook->num)))
1548	return -EOPNOTSUPP;	1548	return -EOPNOTSUPP;
1549		1549
1550	if (type->type == NFT_CHAIN_T_NAT &&	1550	if (type->type == NFT_CHAIN_T_NAT &&

net/netfilter/nfnetlink_log.c+1−1

@@ -540,7 +540,7 @@ __build_packet_message(struct nfnl_log_net *log, · 539 unmodified lines
540	goto nla_put_failure;	540	goto nla_put_failure;
541	}	541	}
542		542
543	if (skb->tstamp) {	543	if (hooknum <= NF_INET_FORWARD && skb->tstamp) {
544	struct nfulnl_msg_packet_timestamp ts;	544	struct nfulnl_msg_packet_timestamp ts;
545	struct timespec64 kts = ktime_to_timespec64(skb->tstamp);	545	struct timespec64 kts = ktime_to_timespec64(skb->tstamp);
546	ts.sec = cpu_to_be64(kts.tv_sec);	546	ts.sec = cpu_to_be64(kts.tv_sec);

net/netfilter/nfnetlink_queue.c+1−1

@@ -582,7 +582,7 @@ nfqnl_build_packet_message(struct net net, struct nfqnl_instance queue, · 581 unmodified lines
582	if (nfqnl_put_bridge(entry, skb) < 0)	582	if (nfqnl_put_bridge(entry, skb) < 0)
583	goto nla_put_failure;	583	goto nla_put_failure;
584		584
585	if (entskb->tstamp) {	585	if (entry->state.hook <= NF_INET_FORWARD && entskb->tstamp) {
586	struct nfqnl_msg_packet_timestamp ts;	586	struct nfqnl_msg_packet_timestamp ts;
587	struct timespec64 kts = ktime_to_timespec64(entskb->tstamp);	587	struct timespec64 kts = ktime_to_timespec64(entskb->tstamp);
588		588

net/netfilter/xt_time.c+14−9

 	s64 stamp;
 	/*
-	 * We cannot use get_seconds() instead of __net_timestamp() here.
+	 * We need real time here, but we can neither use skb->tstamp
+	 * nor __net_timestamp().
+	 *
+	 * skb->tstamp and skb->skb_mstamp_ns overlap, however, they
+	 * use different clock types (real vs monotonic).
+	 *
 	 * Suppose you have two rules:
-	 * 	1. match before 13:00
+	 *	1. match before 13:00
-	 * 	2. match after 13:00
+	 *	2. match after 13:00
+	 *
 	 * If you match against processing time (get_seconds) it
 	 * may happen that the same packet matches both rules if
-	 * it arrived at the right moment before 13:00.
+	 * it arrived at the right moment before 13:00, so it would be
+	 * better to check skb->tstamp and set it via __net_timestamp()
+	 * if needed.  This however breaks outgoing packets tx timestamp,
+	 * and causes them to get delayed forever by fq packet scheduler.
 	 */
-	if (skb->tstamp == 0)
+	stamp = get_seconds();
-		__net_timestamp((struct sk_buff *)skb);
-	stamp = ktime_to_ns(skb->tstamp);
-	stamp = div_s64(stamp, NSEC_PER_SEC);
 	if (info->flags & XT_TIME_LOCAL_TZ)
 		/* Adjust for local timezone */

net/rds/ib_fmr.c+11−0

@@ -44,6 +44,17 @@ struct rds_ib_mr rds_ib_alloc_fmr(struct rds_ib_device rds_ibdev, int npages) · 43 unmodified lines
44	else	44	else
45	pool = rds_ibdev->mr_1m_pool;	45	pool = rds_ibdev->mr_1m_pool;
46		46
		47	if (atomic_read(&pool->dirty_count) >= pool->max_items / 10)
		48	queue_delayed_work(rds_ib_mr_wq, &pool->flush_worker, 10);
		49
		50	/* Switch pools if one of the pool is reaching upper limit */
		51	if (atomic_read(&pool->dirty_count) >= pool->max_items * 9 / 10) {
		52	if (pool->pool_type == RDS_IB_MR_8K_POOL)
		53	pool = rds_ibdev->mr_1m_pool;
		54	else
		55	pool = rds_ibdev->mr_8k_pool;
		56	}
		57
47	ibmr = rds_ib_try_reuse_ibmr(pool);	58	ibmr = rds_ib_try_reuse_ibmr(pool);
48	if (ibmr)	59	if (ibmr)
49	return ibmr;	60	return ibmr;

net/rds/ib_rdma.c+0−3

@@ -454,9 +454,6 @@ struct rds_ib_mr rds_ib_try_reuse_ibmr(struct rds_ib_mr_pool pool) · 453 unmodified lines
454	struct rds_ib_mr *ibmr = NULL;	454	struct rds_ib_mr *ibmr = NULL;
455	int iter = 0;	455	int iter = 0;
456		456
457	if (atomic_read(&pool->dirty_count) >= pool->max_items_soft / 10)
458	queue_delayed_work(rds_ib_mr_wq, &pool->flush_worker, 10);
459
460	while (1) {	457	while (1) {
461	ibmr = rds_ib_reuse_mr(pool);	458	ibmr = rds_ib_reuse_mr(pool);
462	if (ibmr)	459	if (ibmr)

net/rose/rose_loopback.c+16−11

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <linux/init.h>	16	#include <linux/init.h>
17		17
18	static struct sk_buff_head loopback_queue;	18	static struct sk_buff_head loopback_queue;
		19	#define ROSE_LOOPBACK_LIMIT 1000
19	static struct timer_list loopback_timer;	20	static struct timer_list loopback_timer;
20		21
21	static void rose_set_loopback_timer(void);	22	static void rose_set_loopback_timer(void);
@@ -35,29 +36,27 @@ static int rose_loopback_running(void) · 13 unmodified lines
35		36
36	int rose_loopback_queue(struct sk_buff skb, struct rose_neigh neigh)	37	int rose_loopback_queue(struct sk_buff skb, struct rose_neigh neigh)
37	{	38	{
38	struct sk_buff *skbn;	39	struct sk_buff *skbn = NULL;
39		40
40	skbn = skb_clone(skb, GFP_ATOMIC);	41	if (skb_queue_len(&loopback_queue) < ROSE_LOOPBACK_LIMIT)
		42	skbn = skb_clone(skb, GFP_ATOMIC);
41		43
42	kfree_skb(skb);	44	if (skbn) {
43		45	consume_skb(skb);
44	if (skbn != NULL) {
45	skb_queue_tail(&loopback_queue, skbn);	46	skb_queue_tail(&loopback_queue, skbn);
46		47
47	if (!rose_loopback_running())	48	if (!rose_loopback_running())
48	rose_set_loopback_timer();	49	rose_set_loopback_timer();
		50	} else {
		51	kfree_skb(skb);
49	}	52	}
50		53
51	return 1;	54	return 1;
52	}	55	}
53		56
54
55	static void rose_set_loopback_timer(void)	57	static void rose_set_loopback_timer(void)
56	{	58	{
57	del_timer(&loopback_timer);	59	mod_timer(&loopback_timer, jiffies + 10);
58
59	loopback_timer.expires = jiffies + 10;
60	add_timer(&loopback_timer);
61	}	60	}
62		61
63	static void rose_loopback_timer(struct timer_list *unused)	62	static void rose_loopback_timer(struct timer_list *unused)
@@ -68,8 +67,12 @@ static void rose_loopback_timer(struct timer_list *unused) · 4 unmodified lines
68	struct sock *sk;	67	struct sock *sk;
69	unsigned short frametype;	68	unsigned short frametype;
70	unsigned int lci_i, lci_o;	69	unsigned int lci_i, lci_o;
		70	int count;
71		71
72	while ((skb = skb_dequeue(&loopback_queue)) != NULL) {	72	for (count = 0; count < ROSE_LOOPBACK_LIMIT; count++) {
		73	skb = skb_dequeue(&loopback_queue);
		74	if (!skb)
		75	return;
73	if (skb->len < ROSE_MIN_LEN) {	76	if (skb->len < ROSE_MIN_LEN) {
74	kfree_skb(skb);	77	kfree_skb(skb);
75	continue;	78	continue;
@@ -106,6 +109,8 @@ static void rose_loopback_timer(struct timer_list *unused) · 30 unmodified lines
106	kfree_skb(skb);	109	kfree_skb(skb);
107	}	110	}
108	}	111	}
		112	if (!skb_queue_empty(&loopback_queue))
		113	mod_timer(&loopback_timer, jiffies + 1);
109	}	114	}
110		115
111	void __exit rose_loopback_clear(void)	116	void __exit rose_loopback_clear(void)

net/rxrpc/input.c+8−4

  * handle data received on the local endpoint
  * - may be called in interrupt context
  *
- * The socket is locked by the caller and this prevents the socket from being
+ * [!] Note that as this is called from the encap_rcv hook, the socket is not
- * shut down and the local endpoint from going away, thus sk_user_data will not
+ * held locked by the caller and nothing prevents sk_user_data on the UDP from
- * be cleared until this function returns.
+ * being cleared in the middle of processing this function.
  *
  * Called with the RCU read lock held from the IP layer via UDP.
  */
 int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb)
 {
+	struct rxrpc_local *local = rcu_dereference_sk_user_data(udp_sk);
 	struct rxrpc_connection *conn;
 	struct rxrpc_channel *chan;
 	struct rxrpc_call *call = NULL;
 	struct rxrpc_skb_priv *sp;
-	struct rxrpc_local *local = udp_sk->sk_user_data;
 	struct rxrpc_peer *peer = NULL;
 	struct rxrpc_sock *rx = NULL;
 	unsigned int channel;
 	_enter("%p", udp_sk);
+	if (unlikely(!local)) {
+		kfree_skb(skb);
+		return 0;
+	}
 	if (skb->tstamp == 0)
 		skb->tstamp = ktime_get_real();

net/rxrpc/local_object.c+2−1

@@ -304,7 +304,8 @@ nomem: · 303 unmodified lines
304	ret = -ENOMEM;	304	ret = -ENOMEM;
305	sock_error:	305	sock_error:
306	mutex_unlock(&rxnet->local_mutex);	306	mutex_unlock(&rxnet->local_mutex);
307	kfree(local);	307	if (local)
		308	call_rcu(&local->rcu, rxrpc_local_rcu);
308	_leave(" = %d", ret);	309	_leave(" = %d", ret);
309	return ERR_PTR(ret);	310	return ERR_PTR(ret);
310		311

net/sunrpc/cache.c+3−0

 	h->last_refresh = now;
 }
+static inline int cache_is_valid(struct cache_head *h);
 static void cache_fresh_locked(struct cache_head *head, time_t expiry,
 				struct cache_detail *detail);
 static void cache_fresh_unlocked(struct cache_head *head,
 			if (cache_is_expired(detail, tmp)) {
 				hlist_del_init_rcu(&tmp->cache_list);
 				detail->entries --;
+				if (cache_is_valid(tmp) == -EAGAIN)
+					set_bit(CACHE_NEGATIVE, &tmp->flags);
 				cache_fresh_locked(tmp, 0, detail);
 				freeme = tmp;
 				break;

net/sunrpc/clnt.c+5−2

 	 * test first.
 	 */
 	if (rpc_task_transmitted(task)) {
-		if (task->tk_status == 0)
+		task->tk_status = 0;
-			xprt_request_wait_receive(task);
+		xprt_request_wait_receive(task);
 		return;
 	}
 {
 	struct rpc_rqst *req = task->tk_rqstp;
+	if (rpc_task_transmitted(task))
+		task->tk_status = 0;
 	dprint_status(task);
 	switch (task->tk_status) {

net/tls/tls_device.c+2−2

 	goto release_netdev;
 free_sw_resources:
+	up_read(&device_offload_lock);
 	tls_sw_free_resources_rx(sk);
+	down_read(&device_offload_lock);
 release_ctx:
 	ctx->priv_ctx_rx = NULL;
 release_netdev:
 	}
 out:
 	up_read(&device_offload_lock);
-	kfree(tls_ctx->rx.rec_seq);
-	kfree(tls_ctx->rx.iv);
 	tls_sw_release_resources_rx(sk);
 }

net/tls/tls_device_fallback.c+10−3

@@ -194,6 +194,9 @@ static void update_chksum(struct sk_buff *skb, int headln) · 193 unmodified lines
194		194
195	static void complete_skb(struct sk_buff nskb, struct sk_buff skb, int headln)	195	static void complete_skb(struct sk_buff nskb, struct sk_buff skb, int headln)
196	{	196	{
		197	struct sock *sk = skb->sk;
		198	int delta;
		199
197	skb_copy_header(nskb, skb);	200	skb_copy_header(nskb, skb);
198		201
199	skb_put(nskb, skb->len);	202	skb_put(nskb, skb->len);
@@ -201,11 +204,15 @@ static void complete_skb(struct sk_buff nskb, struct sk_buff skb, int headln) · 1 unmodified line
201	update_chksum(nskb, headln);	204	update_chksum(nskb, headln);
202		205
203	nskb->destructor = skb->destructor;	206	nskb->destructor = skb->destructor;
204	nskb->sk = skb->sk;	207	nskb->sk = sk;
205	skb->destructor = NULL;	208	skb->destructor = NULL;
206	skb->sk = NULL;	209	skb->sk = NULL;
207	refcount_add(nskb->truesize - skb->truesize,	210
208	&nskb->sk->sk_wmem_alloc);	211	delta = nskb->truesize - skb->truesize;
		212	if (likely(delta < 0))
		213	WARN_ON_ONCE(refcount_sub_and_test(-delta, &sk->sk_wmem_alloc));
		214	else if (delta)
		215	refcount_add(delta, &sk->sk_wmem_alloc);
209	}	216	}
210		217
211	/* This function may be called after the user socket is already	218	/* This function may be called after the user socket is already

net/tls/tls_main.c+1−4

 #endif
 	}
-	if (ctx->rx_conf == TLS_SW) {
+	if (ctx->rx_conf == TLS_SW)
-		kfree(ctx->rx.rec_seq);
-		kfree(ctx->rx.iv);
 		tls_sw_free_resources_rx(sk);
-	}
 #ifdef CONFIG_TLS_DEVICE
 	if (ctx->rx_conf == TLS_HW)

net/tls/tls_sw.c+3−0

@@ -2091,6 +2091,9 @@ void tls_sw_release_resources_rx(struct sock *sk) · 2090 unmodified lines
2091	struct tls_context *tls_ctx = tls_get_ctx(sk);	2091	struct tls_context *tls_ctx = tls_get_ctx(sk);
2092	struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);	2092	struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
2093		2093
		2094	kfree(tls_ctx->rx.rec_seq);
		2095	kfree(tls_ctx->rx.iv);
		2096
2094	if (ctx->aead_recv) {	2097	if (ctx->aead_recv) {
2095	kfree_skb(ctx->recv_pkt);	2098	kfree_skb(ctx->recv_pkt);
2096	ctx->recv_pkt = NULL;	2099	ctx->recv_pkt = NULL;

scripts/atomic/gen-atomics.sh+1−1

@@ -13,7 +13,7 @@ gen-atomic-long.sh asm-generic/atomic-long.h · 12 unmodified lines
13	gen-atomic-fallback.sh linux/atomic-fallback.h	13	gen-atomic-fallback.sh linux/atomic-fallback.h
14	EOF	14	EOF
15	while read script header; do	15	while read script header; do
16	${ATOMICDIR}/${script} ${ATOMICTBL} > ${LINUXDIR}/include/${header}	16	/bin/sh ${ATOMICDIR}/${script} ${ATOMICTBL} > ${LINUXDIR}/include/${header}
17	HASH="$(sha1sum ${LINUXDIR}/include/${header})"	17	HASH="$(sha1sum ${LINUXDIR}/include/${header})"
18	HASH="${HASH%% *}"	18	HASH="${HASH%% *}"
19	printf "// %s\n" "${HASH}" >> ${LINUXDIR}/include/${header}	19	printf "// %s\n" "${HASH}" >> ${LINUXDIR}/include/${header}

security/device_cgroup.c+1−1

@@ -560,7 +560,7 @@ static int propagate_exception(struct dev_cgroup *devcg_root, · 559 unmodified lines
560	devcg->behavior == DEVCG_DEFAULT_ALLOW) {	560	devcg->behavior == DEVCG_DEFAULT_ALLOW) {
561	rc = dev_exception_add(devcg, ex);	561	rc = dev_exception_add(devcg, ex);
562	if (rc)	562	if (rc)
563	break;	563	return rc;
564	} else {	564	} else {
565	/*	565	/*
566	* in the other possible cases:	566	* in the other possible cases:

sound/core/info.c+10−2

 	INIT_LIST_HEAD(&entry->list);
 	entry->parent = parent;
 	entry->module = module;
-	if (parent)
+	if (parent) {
+		mutex_lock(&parent->access);
 		list_add_tail(&entry->list, &parent->children);
+		mutex_unlock(&parent->access);
+	}
 	return entry;
 }
 	list_for_each_entry_safe(p, n, &entry->children, list)
 		snd_info_free_entry(p);
-	list_del(&entry->list);
+	p = entry->parent;
+	if (p) {
+		mutex_lock(&p->access);
+		list_del(&entry->list);
+		mutex_unlock(&p->access);
+	}
 	kfree(entry->name);
 	if (entry->private_free)
 		entry->private_free(entry);

sound/core/init.c+9−9

 	card->shutdown = 1;
 	spin_unlock(&card->files_lock);
-	/* phase 1: disable fops (user space) operations for ALSA API */
+	/* replace file->f_op with special dummy operations */
-	mutex_lock(&snd_card_mutex);
-	snd_cards[card->number] = NULL;
-	clear_bit(card->number, snd_cards_lock);
-	mutex_unlock(&snd_card_mutex);
-	/* phase 2: replace file->f_op with special dummy operations */
 	spin_lock(&card->files_lock);
 	list_for_each_entry(mfile, &card->files_list, list) {
 		/* it's critical part, use endless loop */
 	}
 	spin_unlock(&card->files_lock);
-	/* phase 3: notify all connected devices about disconnection */
+	/* notify all connected devices about disconnection */
 	/* at this point, they cannot respond to any calls except release() */
 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
 		device_del(&card->card_dev);
 		card->registered = false;
 	}
+	/* disable fops (user space) operations for ALSA API */
+	mutex_lock(&snd_card_mutex);
+	snd_cards[card->number] = NULL;
+	clear_bit(card->number, snd_cards_lock);
+	mutex_unlock(&snd_card_mutex);
 #ifdef CONFIG_PM
 	wake_up(&card->power_sleep);
 #endif

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

@@ -969,6 +969,7 @@ int snd_hda_codec_device_new(struct hda_bus bus, struct snd_card card, · 968 unmodified lines
969		969
970	/* power-up all before initialization */	970	/* power-up all before initialization */
971	hda_set_power_state(codec, AC_PWRST_D0);	971	hda_set_power_state(codec, AC_PWRST_D0);
		972	codec->core.dev.power.power_state = PMSG_ON;
972		973
973	snd_hda_codec_proc_new(codec);	974	snd_hda_codec_proc_new(codec);
974		975

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

 		{0x12, 0x90a60140},
 		{0x14, 0x90170150},
 		{0x21, 0x02211020}),
+	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
+		{0x21, 0x02211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
 		{0x14, 0x90170110},
 		{0x21, 0x02211020}),
 		{0x21, 0x0221101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC256_STANDARD_PINS),
+	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
+		{0x14, 0x90170110},
+		{0x1b, 0x01011020},
+		{0x21, 0x0221101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
 		{0x14, 0x90170110},
 		{0x1b, 0x90a70130},

tools/include/uapi/sound/asound.h+1−0

@@ -32,6 +32,7 @@ · 31 unmodified lines
32		32
33	#ifndef __KERNEL__	33	#ifndef __KERNEL__
34	#include <stdlib.h>	34	#include <stdlib.h>
		35	#include <time.h>
35	#endif	36	#endif
36		37
37	/*	38	/*

tools/lib/traceevent/event-parse.c+1−1

@@ -2233,7 +2233,7 @@ eval_type_str(unsigned long long val, const char *type, int pointer) · 2232 unmodified lines
2233	return val & 0xffffffff;	2233	return val & 0xffffffff;
2234		2234
2235	if (strcmp(type, "u64") == 0 \|\|	2235	if (strcmp(type, "u64") == 0 \|\|
2236	strcmp(type, "s64"))	2236	strcmp(type, "s64") == 0)
2237	return val;	2237	return val;
2238		2238
2239	if (strcmp(type, "s8") == 0)	2239	if (strcmp(type, "s8") == 0)

tools/perf/builtin-stat.c+1−0

@@ -1308,6 +1308,7 @@ static void init_features(struct perf_session *session) · 1307 unmodified lines
1308	for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)	1308	for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
1309	perf_header__set_feat(&session->header, feat);	1309	perf_header__set_feat(&session->header, feat);
1310		1310
		1311	perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
1311	perf_header__clear_feat(&session->header, HEADER_BUILD_ID);	1312	perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
1312	perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);	1313	perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
1313	perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);	1314	perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);

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

@@ -1377,6 +1377,7 @@ int cmd_top(int argc, const char **argv) · 1376 unmodified lines
1377	* */	1377	* */
1378	.overwrite = 0,	1378	.overwrite = 0,
1379	.sample_time = true,	1379	.sample_time = true,
		1380	.sample_time_set = true,
1380	},	1381	},
1381	.max_stack = sysctl__max_stack(),	1382	.max_stack = sysctl__max_stack(),
1382	.annotation_opts = annotation__default_options,	1383	.annotation_opts = annotation__default_options,

tools/perf/scripts/python/export-to-sqlite.py+1−1

@@ -331,7 +331,7 @@ if perf_db_export_calls: · 330 unmodified lines
331	'return_id,'	331	'return_id,'
332	'CASE WHEN flags=0 THEN \'\' WHEN flags=1 THEN \'no call\' WHEN flags=2 THEN \'no return\' WHEN flags=3 THEN \'no call/return\' WHEN flags=6 THEN \'jump\' ELSE flags END AS flags,'	332	'CASE WHEN flags=0 THEN \'\' WHEN flags=1 THEN \'no call\' WHEN flags=2 THEN \'no return\' WHEN flags=3 THEN \'no call/return\' WHEN flags=6 THEN \'jump\' ELSE flags END AS flags,'
333	'parent_call_path_id,'	333	'parent_call_path_id,'
334	'parent_id'	334	'calls.parent_id'
335	' FROM calls INNER JOIN call_paths ON call_paths.id = call_path_id')	335	' FROM calls INNER JOIN call_paths ON call_paths.id = call_path_id')
336		336
337	do_query(query, 'CREATE VIEW samples_view AS '	337	do_query(query, 'CREATE VIEW samples_view AS '

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

 		else if (prog_id > node->info_linear->info.id)
 			n = n->rb_right;
 		else
-			break;
+			goto out;
 	}
+	node = NULL;
+out:
 	up_read(&env->bpf_progs.lock);
 	return node;
 }
 		else if (btf_id > node->id)
 			n = n->rb_right;
 		else
-			break;
+			goto out;
 	}
+	node = NULL;
 	up_read(&env->bpf_progs.lock);
+out:
 	return node;
 }

tools/perf/util/evlist.c+9−5

 {
 	struct perf_evlist *evlist = arg;
 	bool draining = false;
-	int i;
+	int i, done = 0;
+	while (!done) {
+		bool got_data = false;
-	while (draining || !(evlist->thread.done)) {
+		if (evlist->thread.done)
-		if (draining)
-			draining = false;
-		else if (evlist->thread.done)
 			draining = true;
 		if (!draining)
 					pr_warning("cannot locate proper evsel for the side band event\n");
 				perf_mmap__consume(map);
+				got_data = true;
 			}
 			perf_mmap__read_done(map);
 		}
+		if (draining && !got_data)
+			break;
 	}
 	return NULL;
 }

tools/perf/util/evsel.c+6−6

@@ -2368,7 +2368,7 @@ int perf_evsel__parse_sample(struct perf_evsel evsel, union perf_event event, · 2367 unmodified lines
2368	if (data->user_regs.abi) {	2368	if (data->user_regs.abi) {
2369	u64 mask = evsel->attr.sample_regs_user;	2369	u64 mask = evsel->attr.sample_regs_user;
2370		2370
2371	sz = hweight_long(mask) * sizeof(u64);	2371	sz = hweight64(mask) * sizeof(u64);
2372	OVERFLOW_CHECK(array, sz, max_size);	2372	OVERFLOW_CHECK(array, sz, max_size);
2373	data->user_regs.mask = mask;	2373	data->user_regs.mask = mask;
2374	data->user_regs.regs = (u64 *)array;	2374	data->user_regs.regs = (u64 *)array;
@@ -2424,7 +2424,7 @@ int perf_evsel__parse_sample(struct perf_evsel evsel, union perf_event event, · 49 unmodified lines
2424	if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) {	2424	if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) {
2425	u64 mask = evsel->attr.sample_regs_intr;	2425	u64 mask = evsel->attr.sample_regs_intr;
2426		2426
2427	sz = hweight_long(mask) * sizeof(u64);	2427	sz = hweight64(mask) * sizeof(u64);
2428	OVERFLOW_CHECK(array, sz, max_size);	2428	OVERFLOW_CHECK(array, sz, max_size);
2429	data->intr_regs.mask = mask;	2429	data->intr_regs.mask = mask;
2430	data->intr_regs.regs = (u64 *)array;	2430	data->intr_regs.regs = (u64 *)array;
@@ -2552,7 +2552,7 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type, · 121 unmodified lines
2552	if (type & PERF_SAMPLE_REGS_USER) {	2552	if (type & PERF_SAMPLE_REGS_USER) {
2553	if (sample->user_regs.abi) {	2553	if (sample->user_regs.abi) {
2554	result += sizeof(u64);	2554	result += sizeof(u64);
2555	sz = hweight_long(sample->user_regs.mask) * sizeof(u64);	2555	sz = hweight64(sample->user_regs.mask) * sizeof(u64);
2556	result += sz;	2556	result += sz;
2557	} else {	2557	} else {
2558	result += sizeof(u64);	2558	result += sizeof(u64);
@@ -2580,7 +2580,7 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type, · 21 unmodified lines
2580	if (type & PERF_SAMPLE_REGS_INTR) {	2580	if (type & PERF_SAMPLE_REGS_INTR) {
2581	if (sample->intr_regs.abi) {	2581	if (sample->intr_regs.abi) {
2582	result += sizeof(u64);	2582	result += sizeof(u64);
2583	sz = hweight_long(sample->intr_regs.mask) * sizeof(u64);	2583	sz = hweight64(sample->intr_regs.mask) * sizeof(u64);
2584	result += sz;	2584	result += sz;
2585	} else {	2585	} else {
2586	result += sizeof(u64);	2586	result += sizeof(u64);
@@ -2710,7 +2710,7 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, · 123 unmodified lines
2710	if (type & PERF_SAMPLE_REGS_USER) {	2710	if (type & PERF_SAMPLE_REGS_USER) {
2711	if (sample->user_regs.abi) {	2711	if (sample->user_regs.abi) {
2712	*array++ = sample->user_regs.abi;	2712	*array++ = sample->user_regs.abi;
2713	sz = hweight_long(sample->user_regs.mask) * sizeof(u64);	2713	sz = hweight64(sample->user_regs.mask) * sizeof(u64);
2714	memcpy(array, sample->user_regs.regs, sz);	2714	memcpy(array, sample->user_regs.regs, sz);
2715	array = (void *)array + sz;	2715	array = (void *)array + sz;
2716	} else {	2716	} else {
@@ -2746,7 +2746,7 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, · 29 unmodified lines
2746	if (type & PERF_SAMPLE_REGS_INTR) {	2746	if (type & PERF_SAMPLE_REGS_INTR) {
2747	if (sample->intr_regs.abi) {	2747	if (sample->intr_regs.abi) {
2748	*array++ = sample->intr_regs.abi;	2748	*array++ = sample->intr_regs.abi;
2749	sz = hweight_long(sample->intr_regs.mask) * sizeof(u64);	2749	sz = hweight64(sample->intr_regs.mask) * sizeof(u64);
2750	memcpy(array, sample->intr_regs.regs, sz);	2750	memcpy(array, sample->intr_regs.regs, sz);
2751	array = (void *)array + sz;	2751	array = (void *)array + sz;
2752	} else {	2752	} else {

tools/perf/util/header.c+13−9

 		perf_env__insert_bpf_prog_info(env, info_node);
 	}
+	up_write(&env->bpf_progs.lock);
 	return 0;
 out:
 	free(info_linear);
 static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
 {
 	struct perf_env *env = &ff->ph->env;
+	struct btf_node *node = NULL;
 	u32 count, i;
+	int err = -1;
 	if (ff->ph->needs_swap) {
 		pr_warning("interpreting btf from systems with endianity is not yet supported\n");
 	down_write(&env->bpf_progs.lock);
 	for (i = 0; i < count; ++i) {
-		struct btf_node *node;
 		u32 id, data_size;
 		if (do_read_u32(ff, &id))
-			return -1;
+			goto out;
 		if (do_read_u32(ff, &data_size))
-			return -1;
+			goto out;
 		node = malloc(sizeof(struct btf_node) + data_size);
 		if (!node)
-			return -1;
+			goto out;
 		node->id = id;
 		node->data_size = data_size;
-		if (__do_read(ff, node->data, data_size)) {
+		if (__do_read(ff, node->data, data_size))
-			free(node);
+			goto out;
-			return -1;
-		}
 		perf_env__insert_btf(env, node);
+		node = NULL;
 	}
+	err = 0;
+out:
 	up_write(&env->bpf_progs.lock);
-	return 0;
+	free(node);
+	return err;
 }
 struct feature_ops {

tools/perf/util/map.c+17−3

 	return kmap && kmap->name[0];
 }
+bool __map__is_bpf_prog(const struct map *map)
+{
+	const char *name;
+	if (map->dso->binary_type == DSO_BINARY_TYPE__BPF_PROG_INFO)
+		return true;
+	/*
+	 * If PERF_RECORD_BPF_EVENT is not included, the dso will not have
+	 * type of DSO_BINARY_TYPE__BPF_PROG_INFO. In such cases, we can
+	 * guess the type based on name.
+	 */
+	name = map->dso->short_name;
+	return name && (strstr(name, "bpf_prog_") == name);
+}
 bool map__has_symbols(const struct map *map)
 {
 	return dso__has_symbols(map->dso);
 		rc = strcmp(m->dso->short_name, map->dso->short_name);
 		if (rc < 0)
 			p = &(*p)->rb_left;
-		else if (rc  > 0)
-			p = &(*p)->rb_right;
 		else
-			return;
+			p = &(*p)->rb_right;
 	}
 	rb_link_node(&map->rb_node_name, parent, p);
 	rb_insert_color(&map->rb_node_name, &maps->names);

tools/perf/util/map.h+3−1

 bool __map__is_kernel(const struct map *map);
 bool __map__is_extra_kernel_map(const struct map *map);
+bool __map__is_bpf_prog(const struct map *map);
 static inline bool __map__is_kmodule(const struct map *map)
 {
-	return !__map__is_kernel(map) && !__map__is_extra_kernel_map(map);
+	return !__map__is_kernel(map) && !__map__is_extra_kernel_map(map) &&
+	       !__map__is_bpf_prog(map);
 }
 bool map__has_symbols(const struct map *map);

tools/testing/selftests/net/run_afpackettests+5−0

 	exit 0
 fi
+ret=0
 echo "--------------------"
 echo "running psock_fanout test"
 echo "--------------------"
 ./in_netns.sh ./psock_fanout
 if [ $? -ne 0 ]; then
 	echo "[FAIL]"
+	ret=1
 else
 	echo "[PASS]"
 fi
 ./in_netns.sh ./psock_tpacket
 if [ $? -ne 0 ]; then
 	echo "[FAIL]"
+	ret=1
 else
 	echo "[PASS]"
 fi
 ./in_netns.sh ./txring_overwrite
 if [ $? -ne 0 ]; then
 	echo "[FAIL]"
+	ret=1
 else
 	echo "[PASS]"
 fi
+exit $ret

tools/testing/selftests/net/run_netsocktests+1−1

@@ -7,7 +7,7 @@ echo "--------------------" · 6 unmodified lines
7	./socket	7	./socket
8	if [ $? -ne 0 ]; then	8	if [ $? -ne 0 ]; then
9	echo "[FAIL]"	9	echo "[FAIL]"
		10	exit 1
10	else	11	else
11	echo "[PASS]"	12	echo "[PASS]"
12	fi	13	fi
13

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

@@ -1,6 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	# Makefile for netfilter selftests	2	# Makefile for netfilter selftests
3		3
4	TEST_PROGS := nft_trans_stress.sh nft_nat.sh bridge_brouter.sh	4	TEST_PROGS := nft_trans_stress.sh nft_nat.sh bridge_brouter.sh \
		5	conntrack_icmp_related.sh
5		6
6	include ../lib.mk	7	include ../lib.mk

tools/testing/selftests/netfilter/conntrack_icmp_related.sh+283−0

@@ -0,0 +1,283 @@
	1	#!/bin/bash
	2	#
	3	# check that ICMP df-needed/pkttoobig icmp are set are set as related
	4	# state
	5	#
	6	# Setup is:
	7	#
	8	# nsclient1 -> nsrouter1 -> nsrouter2 -> nsclient2
	9	# MTU 1500, except for nsrouter2 <-> nsclient2 link (1280).
	10	# ping nsclient2 from nsclient1, checking that conntrack did set RELATED
	11	# 'fragmentation needed' icmp packet.
	12	#
	13	# In addition, nsrouter1 will perform IP masquerading, i.e. also
	14	# check the icmp errors are propagated to the correct host as per
	15	# nat of "established" icmp-echo "connection".
	16
	17	# Kselftest framework requirement - SKIP code is 4.
	18	ksft_skip=4
	19	ret=0
	20
	21	nft --version > /dev/null 2>&1
	22	if [ $? -ne 0 ];then
	23	echo "SKIP: Could not run test without nft tool"
	24	exit $ksft_skip
	25	fi
	26
	27	ip -Version > /dev/null 2>&1
	28	if [ $? -ne 0 ];then
	29	echo "SKIP: Could not run test without ip tool"
	30	exit $ksft_skip
	31	fi
	32
	33	cleanup() {
	34	for i in 1 2;do ip netns del nsclient$i;done
	35	for i in 1 2;do ip netns del nsrouter$i;done
	36	}
	37
	38	ipv4() {
	39	echo -n 192.168.$1.2
	40	}
	41
	42	ipv6 () {
	43	echo -n dead:$1::2
	44	}
	45
	46	check_counter()
	47	{
	48	ns=$1
	49	name=$2
	50	expect=$3
	51	local lret=0
	52
	53	cnt=$(ip netns exec $ns nft list counter inet filter "$name" \| grep -q "$expect")
	54	if [ $? -ne 0 ]; then
	55	echo "ERROR: counter $name in $ns has unexpected value (expected $expect)" 1>&2
	56	ip netns exec $ns nft list counter inet filter "$name" 1>&2
	57	lret=1
	58	fi
	59
	60	return $lret
	61	}
	62
	63	check_unknown()
	64	{
	65	expect="packets 0 bytes 0"
	66	for n in nsclient1 nsclient2 nsrouter1 nsrouter2; do
	67	check_counter $n "unknown" "$expect"
	68	if [ $? -ne 0 ] ;then
	69	return 1
	70	fi
	71	done
	72
	73	return 0
	74	}
	75
	76	for n in nsclient1 nsclient2 nsrouter1 nsrouter2; do
	77	ip netns add $n
	78	ip -net $n link set lo up
	79	done
	80
	81	DEV=veth0
	82	ip link add $DEV netns nsclient1 type veth peer name eth1 netns nsrouter1
	83	DEV=veth0
	84	ip link add $DEV netns nsclient2 type veth peer name eth1 netns nsrouter2
	85
	86	DEV=veth0
	87	ip link add $DEV netns nsrouter1 type veth peer name eth2 netns nsrouter2
	88
	89	DEV=veth0
	90	for i in 1 2; do
	91	ip -net nsclient$i link set $DEV up
	92	ip -net nsclient$i addr add $(ipv4 $i)/24 dev $DEV
	93	ip -net nsclient$i addr add $(ipv6 $i)/64 dev $DEV
	94	done
	95
	96	ip -net nsrouter1 link set eth1 up
	97	ip -net nsrouter1 link set veth0 up
	98
	99	ip -net nsrouter2 link set eth1 up
	100	ip -net nsrouter2 link set eth2 up
	101
	102	ip -net nsclient1 route add default via 192.168.1.1
	103	ip -net nsclient1 -6 route add default via dead:1::1
	104
	105	ip -net nsclient2 route add default via 192.168.2.1
	106	ip -net nsclient2 route add default via dead:2::1
	107
	108	i=3
	109	ip -net nsrouter1 addr add 192.168.1.1/24 dev eth1
	110	ip -net nsrouter1 addr add 192.168.3.1/24 dev veth0
	111	ip -net nsrouter1 addr add dead:1::1/64 dev eth1
	112	ip -net nsrouter1 addr add dead:3::1/64 dev veth0
	113	ip -net nsrouter1 route add default via 192.168.3.10
	114	ip -net nsrouter1 -6 route add default via dead:3::10
	115
	116	ip -net nsrouter2 addr add 192.168.2.1/24 dev eth1
	117	ip -net nsrouter2 addr add 192.168.3.10/24 dev eth2
	118	ip -net nsrouter2 addr add dead:2::1/64 dev eth1
	119	ip -net nsrouter2 addr add dead:3::10/64 dev eth2
	120	ip -net nsrouter2 route add default via 192.168.3.1
	121	ip -net nsrouter2 route add default via dead:3::1
	122
	123	sleep 2
	124	for i in 4 6; do
	125	ip netns exec nsrouter1 sysctl -q net.ipv$i.conf.all.forwarding=1
	126	ip netns exec nsrouter2 sysctl -q net.ipv$i.conf.all.forwarding=1
	127	done
	128
	129	for netns in nsrouter1 nsrouter2; do
	130	ip netns exec $netns nft -f - <<EOF
	131	table inet filter {
	132	counter unknown { }
	133	counter related { }
	134	chain forward {
	135	type filter hook forward priority 0; policy accept;
	136	meta l4proto icmpv6 icmpv6 type "packet-too-big" ct state "related" counter name "related" accept
	137	meta l4proto icmp icmp type "destination-unreachable" ct state "related" counter name "related" accept
	138	meta l4proto { icmp, icmpv6 } ct state new,established accept
	139	counter name "unknown" drop
	140	}
	141	}
	142	EOF
	143	done
	144
	145	ip netns exec nsclient1 nft -f - <<EOF
	146	table inet filter {
	147	counter unknown { }
	148	counter related { }
	149	chain input {
	150	type filter hook input priority 0; policy accept;
	151	meta l4proto { icmp, icmpv6 } ct state established,untracked accept
	152
	153	meta l4proto { icmp, icmpv6 } ct state "related" counter name "related" accept
	154	counter name "unknown" drop
	155	}
	156	}
	157	EOF
	158
	159	ip netns exec nsclient2 nft -f - <<EOF
	160	table inet filter {
	161	counter unknown { }
	162	counter new { }
	163	counter established { }
	164
	165	chain input {
	166	type filter hook input priority 0; policy accept;
	167	meta l4proto { icmp, icmpv6 } ct state established,untracked accept
	168
	169	meta l4proto { icmp, icmpv6 } ct state "new" counter name "new" accept
	170	meta l4proto { icmp, icmpv6 } ct state "established" counter name "established" accept
	171	counter name "unknown" drop
	172	}
	173	chain output {
	174	type filter hook output priority 0; policy accept;
	175	meta l4proto { icmp, icmpv6 } ct state established,untracked accept
	176
	177	meta l4proto { icmp, icmpv6 } ct state "new" counter name "new"
	178	meta l4proto { icmp, icmpv6 } ct state "established" counter name "established"
	179	counter name "unknown" drop
	180	}
	181	}
	182	EOF
	183
	184
	185	# make sure NAT core rewrites adress of icmp error if nat is used according to
	186	# conntrack nat information (icmp error will be directed at nsrouter1 address,
	187	# but it needs to be routed to nsclient1 address).
	188	ip netns exec nsrouter1 nft -f - <<EOF
	189	table ip nat {
	190	chain postrouting {
	191	type nat hook postrouting priority 0; policy accept;
	192	ip protocol icmp oifname "veth0" counter masquerade
	193	}
	194	}
	195	table ip6 nat {
	196	chain postrouting {
	197	type nat hook postrouting priority 0; policy accept;
	198	ip6 nexthdr icmpv6 oifname "veth0" counter masquerade
	199	}
	200	}
	201	EOF
	202
	203	ip netns exec nsrouter2 ip link set eth1 mtu 1280
	204	ip netns exec nsclient2 ip link set veth0 mtu 1280
	205	sleep 1
	206
	207	ip netns exec nsclient1 ping -c 1 -s 1000 -q -M do 192.168.2.2 >/dev/null
	208	if [ $? -ne 0 ]; then
	209	echo "ERROR: netns ip routing/connectivity broken" 1>&2
	210	cleanup
	211	exit 1
	212	fi
	213	ip netns exec nsclient1 ping6 -q -c 1 -s 1000 dead:2::2 >/dev/null
	214	if [ $? -ne 0 ]; then
	215	echo "ERROR: netns ipv6 routing/connectivity broken" 1>&2
	216	cleanup
	217	exit 1
	218	fi
	219
	220	check_unknown
	221	if [ $? -ne 0 ]; then
	222	ret=1
	223	fi
	224
	225	expect="packets 0 bytes 0"
	226	for netns in nsrouter1 nsrouter2 nsclient1;do
	227	check_counter "$netns" "related" "$expect"
	228	if [ $? -ne 0 ]; then
	229	ret=1
	230	fi
	231	done
	232
	233	expect="packets 2 bytes 2076"
	234	check_counter nsclient2 "new" "$expect"
	235	if [ $? -ne 0 ]; then
	236	ret=1
	237	fi
	238
	239	ip netns exec nsclient1 ping -q -c 1 -s 1300 -M do 192.168.2.2 > /dev/null
	240	if [ $? -eq 0 ]; then
	241	echo "ERROR: ping should have failed with PMTU too big error" 1>&2
	242	ret=1
	243	fi
	244
	245	# nsrouter2 should have generated the icmp error, so
	246	# related counter should be 0 (its in forward).
	247	expect="packets 0 bytes 0"
	248	check_counter "nsrouter2" "related" "$expect"
	249	if [ $? -ne 0 ]; then
	250	ret=1
	251	fi
	252
	253	# but nsrouter1 should have seen it, same for nsclient1.
	254	expect="packets 1 bytes 576"
	255	for netns in nsrouter1 nsclient1;do
	256	check_counter "$netns" "related" "$expect"
	257	if [ $? -ne 0 ]; then
	258	ret=1
	259	fi
	260	done
	261
	262	ip netns exec nsclient1 ping6 -c 1 -s 1300 dead:2::2 > /dev/null
	263	if [ $? -eq 0 ]; then
	264	echo "ERROR: ping6 should have failed with PMTU too big error" 1>&2
	265	ret=1
	266	fi
	267
	268	expect="packets 2 bytes 1856"
	269	for netns in nsrouter1 nsclient1;do
	270	check_counter "$netns" "related" "$expect"
	271	if [ $? -ne 0 ]; then
	272	ret=1
	273	fi
	274	done
	275
	276	if [ $ret -eq 0 ];then
	277	echo "PASS: icmp mtu error had RELATED state"
	278	else
	279	echo "ERROR: icmp error RELATED state test has failed"
	280	fi
	281
	282	cleanup
	283	exit $ret

tools/testing/selftests/netfilter/nft_nat.sh+53−3

 test_masquerade6()
 {
 	local family=$1
+	local natflags=$1
 	local lret=0
 	ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null
 table $family nat {
 	chain postrouting {
 		type nat hook postrouting priority 0; policy accept;
-		meta oif veth0 masquerade
+		meta oif veth0 masquerade $natflags
 	}
 }
 EOF
 	ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
 	if [ $? -ne 0 ] ; then
+<<<<<<< HEAD
 		echo "ERROR: cannot ping ns1 from ns2 with active $family masquerading"
+=======
+		echo "ERROR: cannot ping ns1 from ns2 with active ipv6 masquerade $natflags"
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 		lret=1
 	fi
 		fi
 	done
+<<<<<<< HEAD
 	ip netns exec ns0 nft flush chain $family nat postrouting
+=======
+	ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
+	if [ $? -ne 0 ] ; then
+		echo "ERROR: cannot ping ns1 from ns2 with active ipv6 masquerade $natflags (attempt 2)"
+		lret=1
+	fi
+	ip netns exec ns0 nft flush chain ip6 nat postrouting
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 	if [ $? -ne 0 ]; then
 		echo "ERROR: Could not flush $family nat postrouting" 1>&2
 		lret=1
 	fi
+<<<<<<< HEAD
 	test $lret -eq 0 && echo "PASS: $family IPv6 masquerade for ns2"
+=======
+	test $lret -eq 0 && echo "PASS: IPv6 masquerade $natflags for ns2"
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 	return $lret
 }
 test_masquerade()
 {
+<<<<<<< HEAD
 	local family=$1
+=======
+	local natflags=$1
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 	local lret=0
 	ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null
 	ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 	if [ $? -ne 0 ] ; then
-		echo "ERROR: canot ping ns1 from ns2"
+		echo "ERROR: cannot ping ns1 from ns2 $natflags"
 		lret=1
 	fi
 table $family nat {
 	chain postrouting {
 		type nat hook postrouting priority 0; policy accept;
-		meta oif veth0 masquerade
+		meta oif veth0 masquerade $natflags
 	}
 }
 EOF
 	ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 	if [ $? -ne 0 ] ; then
+<<<<<<< HEAD
 		echo "ERROR: cannot ping ns1 from ns2 with active $family masquerading"
+=======
+		echo "ERROR: cannot ping ns1 from ns2 with active ip masquere $natflags"
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 		lret=1
 	fi
 		fi
 	done
+<<<<<<< HEAD
 	ip netns exec ns0 nft flush chain $family nat postrouting
+=======
+	ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
+	if [ $? -ne 0 ] ; then
+		echo "ERROR: cannot ping ns1 from ns2 with active ip masquerade $natflags (attempt 2)"
+		lret=1
+	fi
+	ip netns exec ns0 nft flush chain ip nat postrouting
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 	if [ $? -ne 0 ]; then
 		echo "ERROR: Could not flush $family nat postrouting" 1>&2
 		lret=1
 	fi
+<<<<<<< HEAD
 	test $lret -eq 0 && echo "PASS: $family IP masquerade for ns2"
+=======
+	test $lret -eq 0 && echo "PASS: IP masquerade $natflags for ns2"
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 	return $lret
 }
 $test_inet_nat && test_local_dnat6 inet
 reset_counters
+<<<<<<< HEAD
 test_masquerade ip
 test_masquerade6 ip6
 reset_counters
 $test_inet_nat && test_masquerade inet
 $test_inet_nat && test_masquerade6 inet
+=======
+test_masquerade ""
+test_masquerade6 ""
+reset_counters
+test_masquerade "fully-random"
+test_masquerade6 "fully-random"
+>>>>>>> cd8dead0c39457e58ec1d36db93aedca811d48f1
 reset_counters
 test_redirect ip

tools/testing/selftests/proc/proc-pid-vm.c+2−2

@@ -187,8 +187,8 @@ static int make_exe(const uint8_t *payload, size_t len) · 186 unmodified lines
187	ph.p_offset = 0;	187	ph.p_offset = 0;
188	ph.p_vaddr = VADDR;	188	ph.p_vaddr = VADDR;
189	ph.p_paddr = 0;	189	ph.p_paddr = 0;
190	ph.p_filesz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + sizeof(payload);	190	ph.p_filesz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + len;
191	ph.p_memsz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + sizeof(payload);	191	ph.p_memsz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + len;
192	ph.p_align = 4096;	192	ph.p_align = 4096;
193		193
194	fd = openat(AT_FDCWD, "/tmp", O_WRONLY\|O_EXCL\|O_TMPFILE, 0700);	194	fd = openat(AT_FDCWD, "/tmp", O_WRONLY\|O_EXCL\|O_TMPFILE, 0700);

tools/testing/selftests/proc/proc-self-map-files-002.c+10−10

 int main(void)
 {
-	const unsigned int PAGE_SIZE = sysconf(_SC_PAGESIZE);
+	const int PAGE_SIZE = sysconf(_SC_PAGESIZE);
-#ifdef __arm__
+	const unsigned long va_max = 1UL << 32;
-	unsigned long va = 2 * PAGE_SIZE;
+	unsigned long va;
-#else
-	unsigned long va = 0;
-#endif
 	void *p;
 	int fd;
 	unsigned long a, b;
 	if (fd == -1)
 		return 1;
-	p = mmap((void *)va, PAGE_SIZE, PROT_NONE, MAP_PRIVATE|MAP_FILE|MAP_FIXED, fd, 0);
+	for (va = 0; va < va_max; va += PAGE_SIZE) {
-	if (p == MAP_FAILED) {
+		p = mmap((void *)va, PAGE_SIZE, PROT_NONE, MAP_PRIVATE|MAP_FILE|MAP_FIXED, fd, 0);
-		if (errno == EPERM)
+		if (p == (void *)va)
-			return 4;
+			break;
+	}
+	if (va == va_max) {
+		fprintf(stderr, "error: mmap doesn't like you\n");
 		return 1;
 	}

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -1721,7 +1721,7 @@ static void atl1_inc_smb(struct atl1_adapter *adapter) · 1720 unmodified lines
1721	adapter->soft_stats.scc += smb->tx_1_col;	1721	adapter->soft_stats.scc += smb->tx_1_col;
1722	adapter->soft_stats.mcc += smb->tx_2_col;	1722	adapter->soft_stats.mcc += smb->tx_2_col;
1723	adapter->soft_stats.latecol += smb->tx_late_col;	1723	adapter->soft_stats.latecol += smb->tx_late_col;
1724	adapter->soft_stats.tx_underun += smb->tx_underrun;	1724	adapter->soft_stats.tx_underrun += smb->tx_underrun;
1725	adapter->soft_stats.tx_trunc += smb->tx_trunc;	1725	adapter->soft_stats.tx_trunc += smb->tx_trunc;
1726	adapter->soft_stats.tx_pause += smb->tx_pause;	1726	adapter->soft_stats.tx_pause += smb->tx_pause;
1727		1727
@@ -3179,7 +3179,7 @@ static struct atl1_stats atl1_gstrings_stats[] = { · 1451 unmodified lines
3179	{"tx_deferred_ok", ATL1_STAT(soft_stats.deffer)},	3179	{"tx_deferred_ok", ATL1_STAT(soft_stats.deffer)},
3180	{"tx_single_coll_ok", ATL1_STAT(soft_stats.scc)},	3180	{"tx_single_coll_ok", ATL1_STAT(soft_stats.scc)},
3181	{"tx_multi_coll_ok", ATL1_STAT(soft_stats.mcc)},	3181	{"tx_multi_coll_ok", ATL1_STAT(soft_stats.mcc)},
3182	{"tx_underun", ATL1_STAT(soft_stats.tx_underun)},	3182	{"tx_underrun", ATL1_STAT(soft_stats.tx_underrun)},
3183	{"tx_trunc", ATL1_STAT(soft_stats.tx_trunc)},	3183	{"tx_trunc", ATL1_STAT(soft_stats.tx_trunc)},
3184	{"tx_pause", ATL1_STAT(soft_stats.tx_pause)},	3184	{"tx_pause", ATL1_STAT(soft_stats.tx_pause)},
3185	{"rx_pause", ATL1_STAT(soft_stats.rx_pause)},	3185	{"rx_pause", ATL1_STAT(soft_stats.rx_pause)},