lael-labs/linux

.mailmap+3−0

 Alan Cox <alan@lxorguk.ukuu.org.uk>
 Alan Cox <root@hraefn.swansea.linux.org.uk>
 Aleksey Gorelov <aleksey_gorelov@phoenix.com>
+Aleksandar Markovic <aleksandar.markovic@mips.com> <aleksandar.markovic@imgtec.com>
 Al Viro <viro@ftp.linux.org.uk>
 Al Viro <viro@zenIV.linux.org.uk>
 Andreas Herrmann <aherrman@de.ibm.com>
 Linas Vepstas <linas@austin.ibm.com>
 Linus Lüssing <linus.luessing@c0d3.blue> <linus.luessing@web.de>
 Linus Lüssing <linus.luessing@c0d3.blue> <linus.luessing@ascom.ch>
+Marcin Nowakowski <marcin.nowakowski@mips.com> <marcin.nowakowski@imgtec.com>
 Mark Brown <broonie@sirena.org.uk>
 Martin Kepplinger <martink@posteo.de> <martin.kepplinger@theobroma-systems.com>
 Martin Kepplinger <martink@posteo.de> <martin.kepplinger@ginzinger.com>
 Mayuresh Janorkar <mayur@ti.com>
 Michael Buesch <m@bues.ch>
 Michel Dänzer <michel@tungstengraphics.com>
+Miodrag Dinic <miodrag.dinic@mips.com> <miodrag.dinic@imgtec.com>
 Mitesh shah <mshah@teja.com>
 Mohit Kumar <mohit.kumar@st.com> <mohit.kumar.dhaka@gmail.com>
 Morten Welinder <terra@gnome.org>

Documentation/process/kernel-enforcement-statement.rst+16−6

 Except where noted below, we speak only for ourselves, and not for any company
 we might work for today, have in the past, or will in the future.
+  - Laura Abbott
   - Bjorn Andersson (Linaro)
-  - Andrea Arcangeli (Red Hat)
+  - Andrea Arcangeli
   - Neil Armstrong
   - Jens Axboe
   - Pablo Neira Ayuso
   - Felipe Balbi
   - Arnd Bergmann
   - Ard Biesheuvel
-  - Paolo Bonzini (Red Hat)
+  - Tim Bird
+  - Paolo Bonzini
   - Christian Borntraeger
   - Mark Brown (Linaro)
   - Paul Burton
   - Javier Martinez Canillas
   - Rob Clark
   - Jonathan Corbet
+  - Dennis Dalessandro
   - Vivien Didelot (Savoir-faire Linux)
-  - Hans de Goede (Red Hat)
+  - Hans de Goede
   - Mel Gorman (SUSE)
   - Sven Eckelmann
   - Alex Elder (Linaro)
   - Juergen Gross
   - Shawn Guo
   - Ulf Hansson
+  - Stephen Hemminger (Microsoft)
   - Tejun Heo
   - Rob Herring
   - Masami Hiramatsu
   - Viresh Kumar
   - Aneesh Kumar K.V
   - Julia Lawall
-  - Doug Ledford (Red Hat)
+  - Doug Ledford
   - Chuck Lever (Oracle)
   - Daniel Lezcano
   - Shaohua Li
-  - Xin Long (Red Hat)
+  - Xin Long
   - Tony Luck
+  - Catalin Marinas (Arm Ltd)
   - Mike Marshall
   - Chris Mason
   - Paul E. McKenney
   - David S. Miller
   - Ingo Molnar
   - Kuninori Morimoto
+  - Trond Myklebust
+  - Martin K. Petersen (Oracle)
   - Borislav Petkov
   - Jiri Pirko
   - Josh Poimboeuf
   - Joerg Roedel
   - Leon Romanovsky
   - Steven Rostedt (VMware)
-  - Ivan Safonov
+  - Frank Rowand
   - Ivan Safonov
   - Anna Schumaker
   - Jes Sorensen
   - K.Y. Srinivasan
   - Heiko Stuebner
   - Jiri Kosina (SUSE)
+  - Willy Tarreau
   - Dmitry Torokhov
   - Linus Torvalds
   - Thierry Reding
   - Rik van Riel
   - Geert Uytterhoeven (Glider bvba)
+  - Eduardo Valentin (Amazon.com)
   - Daniel Vetter
   - Linus Walleij
   - Richard Weinberger
   - Masahiro Yamada
   - Wei Yongjun
   - Lv Zheng
+  - Marc Zyngier (Arm Ltd)

MAINTAINERS+9−5

@@ -873,7 +873,7 @@ F: drivers/android/ · 872 unmodified lines
873	F: drivers/staging/android/	873	F: drivers/staging/android/
874		874
875	ANDROID GOLDFISH RTC DRIVER	875	ANDROID GOLDFISH RTC DRIVER
876	M: Miodrag Dinic <miodrag.dinic@imgtec.com>	876	M: Miodrag Dinic <miodrag.dinic@mips.com>
877	S: Supported	877	S: Supported
878	F: Documentation/devicetree/bindings/rtc/google,goldfish-rtc.txt	878	F: Documentation/devicetree/bindings/rtc/google,goldfish-rtc.txt
879	F: drivers/rtc/rtc-goldfish.c	879	F: drivers/rtc/rtc-goldfish.c
@@ -7752,6 +7752,11 @@ S: Maintained · 6872 unmodified lines
7752	F: Documentation/scsi/53c700.txt	7752	F: Documentation/scsi/53c700.txt
7753	F: drivers/scsi/53c700*	7753	F: drivers/scsi/53c700*
7754		7754
		7755	LEAKING_ADDRESSES
		7756	M: Tobin C. Harding <me@tobin.cc>
		7757	S: Maintained
		7758	F: scripts/leaking_addresses.pl
		7759
7755	LED SUBSYSTEM	7760	LED SUBSYSTEM
7756	M: Richard Purdie <rpurdie@rpsys.net>	7761	M: Richard Purdie <rpurdie@rpsys.net>
7757	M: Jacek Anaszewski <jacek.anaszewski@gmail.com>	7762	M: Jacek Anaszewski <jacek.anaszewski@gmail.com>
@@ -9027,7 +9032,7 @@ F: drivers//loongson1* · 1269 unmodified lines
9027	F: drivers///loongson1	9032	F: drivers///loongson1
9028		9033
9029	MIPS RINT INSTRUCTION EMULATION	9034	MIPS RINT INSTRUCTION EMULATION
9030	M: Aleksandar Markovic <aleksandar.markovic@imgtec.com>	9035	M: Aleksandar Markovic <aleksandar.markovic@mips.com>
9031	L: linux-mips@linux-mips.org	9036	L: linux-mips@linux-mips.org
9032	S: Supported	9037	S: Supported
9033	F: arch/mips/math-emu/sp_rint.c	9038	F: arch/mips/math-emu/sp_rint.c
@@ -10692,10 +10697,9 @@ S: Maintained · 1658 unmodified lines
10692	F: drivers/pinctrl/spear/	10697	F: drivers/pinctrl/spear/
10693		10698
10694	PISTACHIO SOC SUPPORT	10699	PISTACHIO SOC SUPPORT
10695	M: James Hartley <james.hartley@imgtec.com>	10700	M: James Hartley <james.hartley@sondrel.com>
10696	M: Ionela Voinescu <ionela.voinescu@imgtec.com>
10697	L: linux-mips@linux-mips.org	10701	L: linux-mips@linux-mips.org
10698	S: Maintained	10702	S: Odd Fixes
10699	F: arch/mips/pistachio/	10703	F: arch/mips/pistachio/
10700	F: arch/mips/include/asm/mach-pistachio/	10704	F: arch/mips/include/asm/mach-pistachio/
10701	F: arch/mips/boot/dts/img/pistachio*	10705	F: arch/mips/boot/dts/img/pistachio*

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 4	2	VERSION = 4
3	PATCHLEVEL = 14	3	PATCHLEVEL = 14
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc7	5	EXTRAVERSION = -rc8
6	NAME = Fearless Coyote	6	NAME = Fearless Coyote
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/Makefile+2−0

 ifeq ($(CONFIG_CPU_BIG_ENDIAN),y)
 KBUILD_CPPFLAGS	+= -mbig-endian
+CHECKFLAGS	+= -D__ARMEB__
 AS		+= -EB
 LD		+= -EB
 else
 KBUILD_CPPFLAGS	+= -mlittle-endian
+CHECKFLAGS	+= -D__ARMEL__
 AS		+= -EL
 LD		+= -EL
 endif

arch/arm/boot/compressed/vmlinux.lds.S+9−0

@@ -85,6 +85,15 @@ SECTIONS · 84 unmodified lines
85		85
86	_edata = .;	86	_edata = .;
87		87
		88	/*
		89	* The image_end section appears after any additional loadable sections
		90	* that the linker may decide to insert in the binary image. Having
		91	* this symbol allows further debug in the near future.
		92	*/
		93	.image_end (NOLOAD) : {
		94	_edata_real = .;
		95	}
		96
88	_magic_sig = ZIMAGE_MAGIC(0x016f2818);	97	_magic_sig = ZIMAGE_MAGIC(0x016f2818);
89	_magic_start = ZIMAGE_MAGIC(_start);	98	_magic_start = ZIMAGE_MAGIC(_start);
90	_magic_end = ZIMAGE_MAGIC(_edata);	99	_magic_end = ZIMAGE_MAGIC(_edata);

arch/arm/boot/dts/armada-375.dtsi+2−2

@@ -178,9 +178,9 @@ · 177 unmodified lines
178	reg = <0x8000 0x1000>;	178	reg = <0x8000 0x1000>;
179	cache-unified;	179	cache-unified;
180	cache-level = <2>;	180	cache-level = <2>;
181	arm,double-linefill-incr = <1>;	181	arm,double-linefill-incr = <0>;
182	arm,double-linefill-wrap = <0>;	182	arm,double-linefill-wrap = <0>;
183	arm,double-linefill = <1>;	183	arm,double-linefill = <0>;
184	prefetch-data = <1>;	184	prefetch-data = <1>;
185	};	185	};
186		186

arch/arm/boot/dts/armada-38x.dtsi+2−2

@@ -143,9 +143,9 @@ · 142 unmodified lines
143	reg = <0x8000 0x1000>;	143	reg = <0x8000 0x1000>;
144	cache-unified;	144	cache-unified;
145	cache-level = <2>;	145	cache-level = <2>;
146	arm,double-linefill-incr = <1>;	146	arm,double-linefill-incr = <0>;
147	arm,double-linefill-wrap = <0>;	147	arm,double-linefill-wrap = <0>;
148	arm,double-linefill = <1>;	148	arm,double-linefill = <0>;
149	prefetch-data = <1>;	149	prefetch-data = <1>;
150	};	150	};
151		151

arch/arm/boot/dts/armada-39x.dtsi+2−2

@@ -111,9 +111,9 @@ · 110 unmodified lines
111	reg = <0x8000 0x1000>;	111	reg = <0x8000 0x1000>;
112	cache-unified;	112	cache-unified;
113	cache-level = <2>;	113	cache-level = <2>;
114	arm,double-linefill-incr = <1>;	114	arm,double-linefill-incr = <0>;
115	arm,double-linefill-wrap = <0>;	115	arm,double-linefill-wrap = <0>;
116	arm,double-linefill = <1>;	116	arm,double-linefill = <0>;
117	prefetch-data = <1>;	117	prefetch-data = <1>;
118	};	118	};
119		119

arch/arm/boot/dts/uniphier-ld4.dtsi+6−3

 			interrupts = <0 80 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb0>;
-			clocks = <&mio_clk 7>, <&mio_clk 8>, <&mio_clk 12>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 8>,
+				 <&mio_clk 12>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 8>,
 				 <&mio_rst 12>;
 		};
 			interrupts = <0 81 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb1>;
-			clocks = <&mio_clk 7>, <&mio_clk 9>, <&mio_clk 13>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 9>,
+				 <&mio_clk 13>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 9>,
 				 <&mio_rst 13>;
 		};
 			interrupts = <0 82 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb2>;
-			clocks = <&mio_clk 7>, <&mio_clk 10>, <&mio_clk 14>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 10>,
+				 <&mio_clk 14>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 10>,
 				 <&mio_rst 14>;
 		};

arch/arm/boot/dts/uniphier-pro4.dtsi+4−2

 			interrupts = <0 80 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb2>;
-			clocks = <&mio_clk 7>, <&mio_clk 8>, <&mio_clk 12>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 8>,
+				 <&mio_clk 12>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 8>,
 				 <&mio_rst 12>;
 		};
 			interrupts = <0 81 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb3>;
-			clocks = <&mio_clk 7>, <&mio_clk 9>, <&mio_clk 13>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 9>,
+				 <&mio_clk 13>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 9>,
 				 <&mio_rst 13>;
 		};

arch/arm/boot/dts/uniphier-sld8.dtsi+6−3

 			interrupts = <0 80 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb0>;
-			clocks = <&mio_clk 7>, <&mio_clk 8>, <&mio_clk 12>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 8>,
+				 <&mio_clk 12>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 8>,
 				 <&mio_rst 12>;
 		};
 			interrupts = <0 81 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb1>;
-			clocks = <&mio_clk 7>, <&mio_clk 9>, <&mio_clk 13>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 9>,
+				 <&mio_clk 13>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 9>,
 				 <&mio_rst 13>;
 		};
 			interrupts = <0 82 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb2>;
-			clocks = <&mio_clk 7>, <&mio_clk 10>, <&mio_clk 14>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 10>,
+				 <&mio_clk 14>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 10>,
 				 <&mio_rst 14>;
 		};

arch/arm/include/asm/Kbuild+0−1

@@ -20,7 +20,6 @@ generic-y += simd.h · 19 unmodified lines
20	generic-y += sizes.h	20	generic-y += sizes.h
21	generic-y += timex.h	21	generic-y += timex.h
22	generic-y += trace_clock.h	22	generic-y += trace_clock.h
23	generic-y += unaligned.h
24		23
25	generated-y += mach-types.h	24	generated-y += mach-types.h
26	generated-y += unistd-nr.h	25	generated-y += unistd-nr.h

arch/arm/include/asm/unaligned.h+27−0

@@ -0,0 +1,27 @@
	1	#ifndef __ASM_ARM_UNALIGNED_H
	2	#define __ASM_ARM_UNALIGNED_H
	3
	4	/*
	5	* We generally want to set CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS on ARMv6+,
	6	* but we don't want to use linux/unaligned/access_ok.h since that can lead
	7	* to traps on unaligned stm/ldm or strd/ldrd.
	8	*/
	9	#include <asm/byteorder.h>
	10
	11	#if defined(__LITTLE_ENDIAN)
	12	# include <linux/unaligned/le_struct.h>
	13	# include <linux/unaligned/be_byteshift.h>
	14	# include <linux/unaligned/generic.h>
	15	# define get_unaligned __get_unaligned_le
	16	# define put_unaligned __put_unaligned_le
	17	#elif defined(__BIG_ENDIAN)
	18	# include <linux/unaligned/be_struct.h>
	19	# include <linux/unaligned/le_byteshift.h>
	20	# include <linux/unaligned/generic.h>
	21	# define get_unaligned __get_unaligned_be
	22	# define put_unaligned __put_unaligned_be
	23	#else
	24	# error need to define endianess
	25	#endif
	26
	27	#endif /* __ASM_ARM_UNALIGNED_H */

arch/arm/kvm/emulate.c+2−4

 	u32 return_offset = (is_thumb) ? 2 : 4;
 	kvm_update_psr(vcpu, UND_MODE);
-	*vcpu_reg(vcpu, 14) = *vcpu_pc(vcpu) - return_offset;
+	*vcpu_reg(vcpu, 14) = *vcpu_pc(vcpu) + return_offset;
 	/* Branch to exception vector */
 	*vcpu_pc(vcpu) = exc_vector_base(vcpu) + vect_offset;
  */
 static void inject_abt(struct kvm_vcpu *vcpu, bool is_pabt, unsigned long addr)
 {
-	unsigned long cpsr = *vcpu_cpsr(vcpu);
-	bool is_thumb = (cpsr & PSR_T_BIT);
 	u32 vect_offset;
-	u32 return_offset = (is_thumb) ? 4 : 0;
+	u32 return_offset = (is_pabt) ? 4 : 8;
 	bool is_lpae;
 	kvm_update_psr(vcpu, ABT_MODE);

arch/arm/kvm/hyp/Makefile+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# Makefile for Kernel-based Virtual Machine module, HYP part	3	# Makefile for Kernel-based Virtual Machine module, HYP part
4	#	4	#
5		5
6	ccflags-y += -fno-stack-protector	6	ccflags-y += -fno-stack-protector -DDISABLE_BRANCH_PROFILING
7		7
8	KVM=../../../../virt/kvm	8	KVM=../../../../virt/kvm
9		9

arch/arm64/boot/dts/socionext/uniphier-ld11.dtsi+6−3

 			interrupts = <0 243 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb0>;
-			clocks = <&mio_clk 7>, <&mio_clk 8>, <&mio_clk 12>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 8>,
+				 <&mio_clk 12>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 8>,
 				 <&mio_rst 12>;
 		};
 			interrupts = <0 244 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb1>;
-			clocks = <&mio_clk 7>, <&mio_clk 9>, <&mio_clk 13>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 9>,
+				 <&mio_clk 13>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 9>,
 				 <&mio_rst 13>;
 		};
 			interrupts = <0 245 4>;
 			pinctrl-names = "default";
 			pinctrl-0 = <&pinctrl_usb2>;
-			clocks = <&mio_clk 7>, <&mio_clk 10>, <&mio_clk 14>;
+			clocks = <&sys_clk 8>, <&mio_clk 7>, <&mio_clk 10>,
+				 <&mio_clk 14>;
 			resets = <&sys_rst 8>, <&mio_rst 7>, <&mio_rst 10>,
 				 <&mio_rst 14>;
 		};

arch/arm64/kvm/hyp/Makefile+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# Makefile for Kernel-based Virtual Machine module, HYP part	3	# Makefile for Kernel-based Virtual Machine module, HYP part
4	#	4	#
5		5
6	ccflags-y += -fno-stack-protector	6	ccflags-y += -fno-stack-protector -DDISABLE_BRANCH_PROFILING
7		7
8	KVM=../../../../virt/kvm	8	KVM=../../../../virt/kvm
9		9

arch/arm64/kvm/inject_fault.c+15−1

@@ -33,12 +33,26 @@ · 32 unmodified lines
33	#define LOWER_EL_AArch64_VECTOR 0x400	33	#define LOWER_EL_AArch64_VECTOR 0x400
34	#define LOWER_EL_AArch32_VECTOR 0x600	34	#define LOWER_EL_AArch32_VECTOR 0x600
35		35
		36	/*
		37	* Table taken from ARMv8 ARM DDI0487B-B, table G1-10.
		38	*/
		39	static const u8 return_offsets[8][2] = {
		40	[0] = { 0, 0 }, /* Reset, unused */
		41	[1] = { 4, 2 }, /* Undefined */
		42	[2] = { 0, 0 }, /* SVC, unused */
		43	[3] = { 4, 4 }, /* Prefetch abort */
		44	[4] = { 8, 8 }, /* Data abort */
		45	[5] = { 0, 0 }, /* HVC, unused */
		46	[6] = { 4, 4 }, /* IRQ, unused */
		47	[7] = { 4, 4 }, /* FIQ, unused */
		48	};
		49
36	static void prepare_fault32(struct kvm_vcpu *vcpu, u32 mode, u32 vect_offset)	50	static void prepare_fault32(struct kvm_vcpu *vcpu, u32 mode, u32 vect_offset)
37	{	51	{
38	unsigned long cpsr;	52	unsigned long cpsr;
39	unsigned long new_spsr_value = *vcpu_cpsr(vcpu);	53	unsigned long new_spsr_value = *vcpu_cpsr(vcpu);
40	bool is_thumb = (new_spsr_value & COMPAT_PSR_T_BIT);	54	bool is_thumb = (new_spsr_value & COMPAT_PSR_T_BIT);
41	u32 return_offset = (is_thumb) ? 4 : 0;	55	u32 return_offset = return_offsets[vect_offset >> 2][is_thumb];
42	u32 sctlr = vcpu_cp15(vcpu, c1_SCTLR);	56	u32 sctlr = vcpu_cp15(vcpu, c1_SCTLR);
43		57
44	cpsr = mode \| COMPAT_PSR_I_BIT;	58	cpsr = mode \| COMPAT_PSR_I_BIT;

arch/ia64/include/asm/acpi.h+2−0

@@ -112,6 +112,8 @@ static inline void arch_acpi_set_pdc_bits(u32 *buf) · 111 unmodified lines
112	buf[2] \|= ACPI_PDC_EST_CAPABILITY_SMP;	112	buf[2] \|= ACPI_PDC_EST_CAPABILITY_SMP;
113	}	113	}
114		114
		115	#define acpi_unlazy_tlb(x)
		116
115	#ifdef CONFIG_ACPI_NUMA	117	#ifdef CONFIG_ACPI_NUMA
116	extern cpumask_t early_cpu_possible_map;	118	extern cpumask_t early_cpu_possible_map;
117	#define for_each_possible_early_cpu(cpu) \	119	#define for_each_possible_early_cpu(cpu) \

arch/mips/generic/board-ni169445.its.S+1−1

@@ -1,4 +1,4 @@
1	{	1	/ {
2	images {	2	images {
3	fdt@ni169445 {	3	fdt@ni169445 {
4	description = "NI 169445 device tree";	4	description = "NI 169445 device tree";

arch/mips/generic/init.c+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	#include <asm/fw/fw.h>	20	#include <asm/fw/fw.h>
21	#include <asm/irq_cpu.h>	21	#include <asm/irq_cpu.h>
22	#include <asm/machine.h>	22	#include <asm/machine.h>
23	#include <asm/mips-cpc.h>	23	#include <asm/mips-cps.h>
24	#include <asm/prom.h>	24	#include <asm/prom.h>
25	#include <asm/smp-ops.h>	25	#include <asm/smp-ops.h>
26	#include <asm/time.h>	26	#include <asm/time.h>

arch/mips/generic/kexec.c+1−1

@@ -1,6 +1,6 @@
1	/*	1	/*
2	* Copyright (C) 2016 Imagination Technologies	2	* Copyright (C) 2016 Imagination Technologies
3	* Author: Marcin Nowakowski <marcin.nowakowski@imgtec.com>	3	* Author: Marcin Nowakowski <marcin.nowakowski@mips.com>
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify it	5	* This program is free software; you can redistribute it and/or modify it
6	* under the terms of the GNU General Public License as published by the	6	* under the terms of the GNU General Public License as published by the

arch/mips/include/asm/mips-cm.h+2−2

@@ -142,8 +142,8 @@ GCR_ACCESSOR_RO(64, 0x000, config) · 141 unmodified lines
142	GCR_ACCESSOR_RW(64, 0x008, base)	142	GCR_ACCESSOR_RW(64, 0x008, base)
143	#define CM_GCR_BASE_GCRBASE GENMASK_ULL(47, 15)	143	#define CM_GCR_BASE_GCRBASE GENMASK_ULL(47, 15)
144	#define CM_GCR_BASE_CMDEFTGT GENMASK(1, 0)	144	#define CM_GCR_BASE_CMDEFTGT GENMASK(1, 0)
145	#define CM_GCR_BASE_CMDEFTGT_DISABLED 0	145	#define CM_GCR_BASE_CMDEFTGT_MEM 0
146	#define CM_GCR_BASE_CMDEFTGT_MEM 1	146	#define CM_GCR_BASE_CMDEFTGT_RESERVED 1
147	#define CM_GCR_BASE_CMDEFTGT_IOCU0 2	147	#define CM_GCR_BASE_CMDEFTGT_IOCU0 2
148	#define CM_GCR_BASE_CMDEFTGT_IOCU1 3	148	#define CM_GCR_BASE_CMDEFTGT_IOCU1 3
149		149

arch/mips/include/asm/stackframe.h+4−4

 		sll	k0, 3		/* extract cu0 bit */
 		.set	noreorder
 		bltz	k0, 8f
+		 move	k0, sp
+		.if \docfi
+		.cfi_register sp, k0
+		.endif
 #ifdef CONFIG_EVA
 		/*
 		 * Flush interAptiv's Return Prediction Stack (RPS) by writing
 		MTC0	k0, CP0_ENTRYHI
 #endif
 		.set	reorder
-		 move	k0, sp
-		.if \docfi
-		.cfi_register sp, k0
-		.endif
 		/* Called from user mode, new stack. */
 		get_saved_sp docfi=\docfi tosp=1
 8:

arch/mips/kernel/probes-common.h+1−1

@@ -1,6 +1,6 @@
1	/*	1	/*
2	* Copyright (C) 2016 Imagination Technologies	2	* Copyright (C) 2016 Imagination Technologies
3	* Author: Marcin Nowakowski <marcin.nowakowski@imgtec.com>	3	* Author: Marcin Nowakowski <marcin.nowakowski@mips.com>
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify it	5	* This program is free software; you can redistribute it and/or modify it
6	* under the terms of the GNU General Public License as published by the	6	* under the terms of the GNU General Public License as published by the

arch/mips/kernel/smp-cmp.c+3−3

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	#undef DEBUG	19	#undef DEBUG
20		20
21	#include <linux/kernel.h>	21	#include <linux/kernel.h>
22	#include <linux/sched.h>	22	#include <linux/sched/task_stack.h>
23	#include <linux/smp.h>	23	#include <linux/smp.h>
24	#include <linux/cpumask.h>	24	#include <linux/cpumask.h>
25	#include <linux/interrupt.h>	25	#include <linux/interrupt.h>
@@ -50,8 +50,8 @@ static void cmp_init_secondary(void) · 24 unmodified lines
50		50
51	#ifdef CONFIG_MIPS_MT_SMP	51	#ifdef CONFIG_MIPS_MT_SMP
52	if (cpu_has_mipsmt)	52	if (cpu_has_mipsmt)
53	c->vpe_id = (read_c0_tcbind() >> TCBIND_CURVPE_SHIFT) &	53	cpu_set_vpe_id(c, (read_c0_tcbind() >> TCBIND_CURVPE_SHIFT) &
54	TCBIND_CURVPE;	54	TCBIND_CURVPE);
55	#endif	55	#endif
56	}	56	}
57		57

arch/mips/kernel/smp-cps.c+1−1

@@ -306,7 +306,7 @@ static int cps_boot_secondary(int cpu, struct task_struct *idle) · 305 unmodified lines
306	int err;	306	int err;
307		307
308	/* We don't yet support booting CPUs in other clusters */	308	/* We don't yet support booting CPUs in other clusters */
309	if (cpu_cluster(&cpu_data[cpu]) != cpu_cluster(&current_cpu_data))	309	if (cpu_cluster(&cpu_data[cpu]) != cpu_cluster(&raw_current_cpu_data))
310	return -ENOSYS;	310	return -ENOSYS;
311		311
312	vpe_cfg->pc = (unsigned long)&smp_bootstrap;	312	vpe_cfg->pc = (unsigned long)&smp_bootstrap;

arch/mips/kernel/smp.c+17−7

 #include <asm/processor.h>
 #include <asm/idle.h>
 #include <asm/r4k-timer.h>
-#include <asm/mips-cpc.h>
+#include <asm/mips-cps.h>
 #include <asm/mmu_context.h>
 #include <asm/time.h>
 #include <asm/setup.h>
 cpumask_t cpu_core_map[NR_CPUS] __read_mostly;
 EXPORT_SYMBOL(cpu_core_map);
+static DECLARE_COMPLETION(cpu_starting);
 static DECLARE_COMPLETION(cpu_running);
 /*
 	cpumask_set_cpu(cpu, &cpu_coherent_mask);
 	notify_cpu_starting(cpu);
+	/* Notify boot CPU that we're starting & ready to sync counters */
+	complete(&cpu_starting);
+	synchronise_count_slave(cpu);
+	/* The CPU is running and counters synchronised, now mark it online */
 	set_cpu_online(cpu, true);
 	set_cpu_sibling_map(cpu);
 	calculate_cpu_foreign_map();
+	/*
+	 * Notify boot CPU that we're up & online and it can safely return
+	 * from __cpu_up
+	 */
 	complete(&cpu_running);
-	synchronise_count_slave(cpu);
 	/*
 	 * irq will be enabled in ->smp_finish(), enabling it too early
 	if (err)
 		return err;
-	/*
+	/* Wait for CPU to start and be ready to sync counters */
-	 * We must check for timeout here, as the CPU will not be marked
+	if (!wait_for_completion_timeout(&cpu_starting,
-	 * online until the counters are synchronised.
-	 */
-	if (!wait_for_completion_timeout(&cpu_running,
 					 msecs_to_jiffies(1000))) {
 		pr_crit("CPU%u: failed to start\n", cpu);
 		return -EIO;
 	}
 	synchronise_count_master(cpu);
+	/* Wait for CPU to finish startup & mark itself online before return */
+	wait_for_completion(&cpu_running);
 	return 0;
 }

arch/mips/mm/uasm-micromips.c+1−1

@@ -80,7 +80,7 @@ static const struct insn const insn_table_MM[insn_invalid] = { · 79 unmodified lines
80	[insn_jr] = {M(mm_pool32a_op, 0, 0, 0, mm_jalr_op, mm_pool32axf_op), RS},	80	[insn_jr] = {M(mm_pool32a_op, 0, 0, 0, mm_jalr_op, mm_pool32axf_op), RS},
81	[insn_lb] = {M(mm_lb32_op, 0, 0, 0, 0, 0), RT \| RS \| SIMM},	81	[insn_lb] = {M(mm_lb32_op, 0, 0, 0, 0, 0), RT \| RS \| SIMM},
82	[insn_ld] = {0, 0},	82	[insn_ld] = {0, 0},
83	[insn_lh] = {M(mm_lh32_op, 0, 0, 0, 0, 0), RS \| RS \| SIMM},	83	[insn_lh] = {M(mm_lh32_op, 0, 0, 0, 0, 0), RT \| RS \| SIMM},
84	[insn_ll] = {M(mm_pool32c_op, 0, 0, (mm_ll_func << 1), 0, 0), RS \| RT \| SIMM},	84	[insn_ll] = {M(mm_pool32c_op, 0, 0, (mm_ll_func << 1), 0, 0), RS \| RT \| SIMM},
85	[insn_lld] = {0, 0},	85	[insn_lld] = {0, 0},
86	[insn_lui] = {M(mm_pool32i_op, mm_lui_op, 0, 0, 0, 0), RS \| SIMM},	86	[insn_lui] = {M(mm_pool32i_op, mm_lui_op, 0, 0, 0, 0), RS \| SIMM},

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

@@ -1513,7 +1513,7 @@ ld_skb_common: · 1512 unmodified lines
1513	}	1513	}
1514	src = ebpf_to_mips_reg(ctx, insn, src_reg_no_fp);	1514	src = ebpf_to_mips_reg(ctx, insn, src_reg_no_fp);
1515	if (src < 0)	1515	if (src < 0)
1516	return dst;	1516	return src;
1517	if (BPF_MODE(insn->code) == BPF_XADD) {	1517	if (BPF_MODE(insn->code) == BPF_XADD) {
1518	switch (BPF_SIZE(insn->code)) {	1518	switch (BPF_SIZE(insn->code)) {
1519	case BPF_W:	1519	case BPF_W:

arch/x86/crypto/sha1-mb/sha1_mb_mgr_flush_avx2.S+6−6

@@ -157,8 +157,8 @@ LABEL skip_ %I · 156 unmodified lines
157	.endr	157	.endr
158		158
159	# Find min length	159	# Find min length
160	vmovdqa _lens+0*16(state), %xmm0	160	vmovdqu _lens+0*16(state), %xmm0
161	vmovdqa _lens+1*16(state), %xmm1	161	vmovdqu _lens+1*16(state), %xmm1
162		162
163	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}	163	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}
164	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}	164	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}
@@ -178,8 +178,8 @@ LABEL skip_ %I · 13 unmodified lines
178	vpsubd %xmm2, %xmm0, %xmm0	178	vpsubd %xmm2, %xmm0, %xmm0
179	vpsubd %xmm2, %xmm1, %xmm1	179	vpsubd %xmm2, %xmm1, %xmm1
180		180
181	vmovdqa %xmm0, _lens+0*16(state)	181	vmovdqu %xmm0, _lens+0*16(state)
182	vmovdqa %xmm1, _lens+1*16(state)	182	vmovdqu %xmm1, _lens+1*16(state)
183		183
184	# "state" and "args" are the same address, arg1	184	# "state" and "args" are the same address, arg1
185	# len is arg2	185	# len is arg2
@@ -235,8 +235,8 @@ ENTRY(sha1_mb_mgr_get_comp_job_avx2) · 49 unmodified lines
235	jc .return_null	235	jc .return_null
236		236
237	# Find min length	237	# Find min length
238	vmovdqa _lens(state), %xmm0	238	vmovdqu _lens(state), %xmm0
239	vmovdqa _lens+1*16(state), %xmm1	239	vmovdqu _lens+1*16(state), %xmm1
240		240
241	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}	241	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}
242	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}	242	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}

arch/x86/crypto/sha256-mb/sha256_mb_mgr_flush_avx2.S+6−6

@@ -155,8 +155,8 @@ LABEL skip_ %I · 154 unmodified lines
155	.endr	155	.endr
156		156
157	# Find min length	157	# Find min length
158	vmovdqa _lens+0*16(state), %xmm0	158	vmovdqu _lens+0*16(state), %xmm0
159	vmovdqa _lens+1*16(state), %xmm1	159	vmovdqu _lens+1*16(state), %xmm1
160		160
161	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}	161	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}
162	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}	162	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}
@@ -176,8 +176,8 @@ LABEL skip_ %I · 13 unmodified lines
176	vpsubd %xmm2, %xmm0, %xmm0	176	vpsubd %xmm2, %xmm0, %xmm0
177	vpsubd %xmm2, %xmm1, %xmm1	177	vpsubd %xmm2, %xmm1, %xmm1
178		178
179	vmovdqa %xmm0, _lens+0*16(state)	179	vmovdqu %xmm0, _lens+0*16(state)
180	vmovdqa %xmm1, _lens+1*16(state)	180	vmovdqu %xmm1, _lens+1*16(state)
181		181
182	# "state" and "args" are the same address, arg1	182	# "state" and "args" are the same address, arg1
183	# len is arg2	183	# len is arg2
@@ -234,8 +234,8 @@ ENTRY(sha256_mb_mgr_get_comp_job_avx2) · 50 unmodified lines
234	jc .return_null	234	jc .return_null
235		235
236	# Find min length	236	# Find min length
237	vmovdqa _lens(state), %xmm0	237	vmovdqu _lens(state), %xmm0
238	vmovdqa _lens+1*16(state), %xmm1	238	vmovdqu _lens+1*16(state), %xmm1
239		239
240	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}	240	vpminud %xmm1, %xmm0, %xmm2 # xmm2 has {D,C,B,A}
241	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}	241	vpalignr $8, %xmm2, %xmm3, %xmm3 # xmm3 has {x,x,D,C}

arch/x86/include/asm/acpi.h+2−0

@@ -150,6 +150,8 @@ static inline void disable_acpi(void) { } · 149 unmodified lines
150	extern int x86_acpi_numa_init(void);	150	extern int x86_acpi_numa_init(void);
151	#endif /* CONFIG_ACPI_NUMA */	151	#endif /* CONFIG_ACPI_NUMA */
152		152
		153	#define acpi_unlazy_tlb(x) leave_mm(x)
		154
153	#ifdef CONFIG_ACPI_APEI	155	#ifdef CONFIG_ACPI_APEI
154	static inline pgprot_t arch_apei_get_mem_attribute(phys_addr_t addr)	156	static inline pgprot_t arch_apei_get_mem_attribute(phys_addr_t addr)
155	{	157	{

arch/x86/kernel/cpu/mcheck/dev-mcelog.c+27−94

@@ -24,14 +24,6 @@ static DEFINE_MUTEX(mce_chrdev_read_mutex); · 23 unmodified lines
24	static char mce_helper[128];	24	static char mce_helper[128];
25	static char *mce_helper_argv[2] = { mce_helper, NULL };	25	static char *mce_helper_argv[2] = { mce_helper, NULL };
26		26
27	#define mce_log_get_idx_check(p) \
28	({ \
29	RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held() && \
30	!lockdep_is_held(&mce_chrdev_read_mutex), \
31	"suspicious mce_log_get_idx_check() usage"); \
32	smp_load_acquire(&(p)); \
33	})
34
35	/*	27	/*
36	* Lockless MCE logging infrastructure.	28	* Lockless MCE logging infrastructure.
37	* This avoids deadlocks on printk locks without having to break locks. Also	29	* This avoids deadlocks on printk locks without having to break locks. Also
@@ -53,43 +45,32 @@ static int dev_mce_log(struct notifier_block *nb, unsigned long val, · 15 unmodified lines
53	void *data)	45	void *data)
54	{	46	{
55	struct mce mce = (struct mce )data;	47	struct mce mce = (struct mce )data;
56	unsigned int next, entry;	48	unsigned int entry;
57		49
58	wmb();	50	mutex_lock(&mce_chrdev_read_mutex);
59	for (;;) {	51
60	entry = mce_log_get_idx_check(mcelog.next);	52	entry = mcelog.next;
61	for (;;) {	53
62		54	/*
63	/*	55	* When the buffer fills up discard new entries. Assume that the
64	* When the buffer fills up discard new entries.	56	* earlier errors are the more interesting ones:
65	* Assume that the earlier errors are the more	57	*/
66	* interesting ones:	58	if (entry >= MCE_LOG_LEN) {
67	*/	59	set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags);
68	if (entry >= MCE_LOG_LEN) {	60	goto unlock;
69	set_bit(MCE_OVERFLOW,
70	(unsigned long *)&mcelog.flags);
71	return NOTIFY_OK;
72	}
73	/* Old left over entry. Skip: */
74	if (mcelog.entry[entry].finished) {
75	entry++;
76	continue;
77	}
78	break;
79	}
80	smp_rmb();
81	next = entry + 1;
82	if (cmpxchg(&mcelog.next, entry, next) == entry)
83	break;
84	}	61	}
		62
		63	mcelog.next = entry + 1;
		64
85	memcpy(mcelog.entry + entry, mce, sizeof(struct mce));	65	memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
86	wmb();
87	mcelog.entry[entry].finished = 1;	66	mcelog.entry[entry].finished = 1;
88	wmb();
89		67
90	/* wake processes polling /dev/mcelog */	68	/* wake processes polling /dev/mcelog */
91	wake_up_interruptible(&mce_chrdev_wait);	69	wake_up_interruptible(&mce_chrdev_wait);
92		70
		71	unlock:
		72	mutex_unlock(&mce_chrdev_read_mutex);
		73
93	return NOTIFY_OK;	74	return NOTIFY_OK;
94	}	75	}
95		76
@@ -177,13 +158,6 @@ static int mce_chrdev_release(struct inode inode, struct file file) · 81 unmodified lines
177	return 0;	158	return 0;
178	}	159	}
179		160
180	static void collect_tscs(void *data)
181	{
182	unsigned long cpu_tsc = (unsigned long )data;
183
184	cpu_tsc[smp_processor_id()] = rdtsc();
185	}
186
187	static int mce_apei_read_done;	161	static int mce_apei_read_done;
188		162
189	/* Collect MCE record of previous boot in persistent storage via APEI ERST. */	163	/* Collect MCE record of previous boot in persistent storage via APEI ERST. */
@@ -231,14 +205,9 @@ static ssize_t mce_chrdev_read(struct file filp, char __user ubuf, · 41 unmodified lines
231	size_t usize, loff_t *off)	205	size_t usize, loff_t *off)
232	{	206	{
233	char __user *buf = ubuf;	207	char __user *buf = ubuf;
234	unsigned long *cpu_tsc;	208	unsigned next;
235	unsigned prev, next;
236	int i, err;	209	int i, err;
237		210
238	cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL);
239	if (!cpu_tsc)
240	return -ENOMEM;
241
242	mutex_lock(&mce_chrdev_read_mutex);	211	mutex_lock(&mce_chrdev_read_mutex);
243		212
244	if (!mce_apei_read_done) {	213	if (!mce_apei_read_done) {
@@ -247,65 +216,29 @@ static ssize_t mce_chrdev_read(struct file filp, char __user ubuf, · 2 unmodified lines
247	goto out;	216	goto out;
248	}	217	}
249		218
250	next = mce_log_get_idx_check(mcelog.next);
251
252	/* Only supports full reads right now */	219	/* Only supports full reads right now */
253	err = -EINVAL;	220	err = -EINVAL;
254	if (off != 0 \|\| usize < MCE_LOG_LENsizeof(struct mce))	221	if (off != 0 \|\| usize < MCE_LOG_LENsizeof(struct mce))
255	goto out;	222	goto out;
256		223
		224	next = mcelog.next;
257	err = 0;	225	err = 0;
258	prev = 0;
259	do {
260	for (i = prev; i < next; i++) {
261	unsigned long start = jiffies;
262	struct mce *m = &mcelog.entry[i];
263
264	while (!m->finished) {
265	if (time_after_eq(jiffies, start + 2)) {
266	memset(m, 0, sizeof(*m));
267	goto timeout;
268	}
269	cpu_relax();
270	}
271	smp_rmb();
272	err \|= copy_to_user(buf, m, sizeof(*m));
273	buf += sizeof(*m);
274	timeout:
275	;
276	}
277
278	memset(mcelog.entry + prev, 0,
279	(next - prev) * sizeof(struct mce));
280	prev = next;
281	next = cmpxchg(&mcelog.next, prev, 0);
282	} while (next != prev);
283
284	synchronize_sched();
285		226
286	/*	227	for (i = 0; i < next; i++) {
287	* Collect entries that were still getting written before the
288	* synchronize.
289	*/
290	on_each_cpu(collect_tscs, cpu_tsc, 1);
291
292	for (i = next; i < MCE_LOG_LEN; i++) {
293	struct mce *m = &mcelog.entry[i];	228	struct mce *m = &mcelog.entry[i];
294		229
295	if (m->finished && m->tsc < cpu_tsc[m->cpu]) {	230	err \|= copy_to_user(buf, m, sizeof(*m));
296	err \|= copy_to_user(buf, m, sizeof(*m));	231	buf += sizeof(*m);
297	smp_rmb();
298	buf += sizeof(*m);
299	memset(m, 0, sizeof(*m));
300	}
301	}	232	}
302		233
		234	memset(mcelog.entry, 0, next * sizeof(struct mce));
		235	mcelog.next = 0;
		236
303	if (err)	237	if (err)
304	err = -EFAULT;	238	err = -EFAULT;
305		239
306	out:	240	out:
307	mutex_unlock(&mce_chrdev_read_mutex);	241	mutex_unlock(&mce_chrdev_read_mutex);
308	kfree(cpu_tsc);
309		242
310	return err ? err : buf - ubuf;	243	return err ? err : buf - ubuf;
311	}	244	}

arch/x86/kernel/kvmclock.c+1−1

@@ -79,7 +79,7 @@ static void kvm_get_wallclock(struct timespec *now) · 78 unmodified lines
79		79
80	static int kvm_set_wallclock(const struct timespec *now)	80	static int kvm_set_wallclock(const struct timespec *now)
81	{	81	{
82	return -1;	82	return -ENODEV;
83	}	83	}
84		84
85	static u64 kvm_clock_read(void)	85	static u64 kvm_clock_read(void)

arch/x86/kernel/module.c+13−0

 		case R_X86_64_NONE:
 			break;
 		case R_X86_64_64:
+			if (*(u64 *)loc != 0)
+				goto invalid_relocation;
 			*(u64 *)loc = val;
 			break;
 		case R_X86_64_32:
+			if (*(u32 *)loc != 0)
+				goto invalid_relocation;
 			*(u32 *)loc = val;
 			if (val != *(u32 *)loc)
 				goto overflow;
 			break;
 		case R_X86_64_32S:
+			if (*(s32 *)loc != 0)
+				goto invalid_relocation;
 			*(s32 *)loc = val;
 			if ((s64)val != *(s32 *)loc)
 				goto overflow;
 			break;
 		case R_X86_64_PC32:
+			if (*(u32 *)loc != 0)
+				goto invalid_relocation;
 			val -= (u64)loc;
 			*(u32 *)loc = val;
 #if 0
 	}
 	return 0;
+invalid_relocation:
+	pr_err("x86/modules: Skipping invalid relocation target, existing value is nonzero for type %d, loc %p, val %Lx\n",
+	       (int)ELF64_R_TYPE(rel[i].r_info), loc, val);
+	return -ENOEXEC;
 overflow:
 	pr_err("overflow in relocation type %d val %Lx\n",
 	       (int)ELF64_R_TYPE(rel[i].r_info), val);

arch/x86/kvm/lapic.c+5−0

 				vcpu->arch.apic_base | MSR_IA32_APICBASE_BSP);
 	vcpu->arch.pv_eoi.msr_val = 0;
 	apic_update_ppr(apic);
+	if (vcpu->arch.apicv_active) {
+		kvm_x86_ops->apicv_post_state_restore(vcpu);
+		kvm_x86_ops->hwapic_irr_update(vcpu, -1);
+		kvm_x86_ops->hwapic_isr_update(vcpu, -1);
+	}
 	vcpu->arch.apic_arb_prio = 0;
 	vcpu->arch.apic_attention = 0;

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

@@ -5619,9 +5619,6 @@ static void vmx_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) · 5618 unmodified lines
5619		5619
5620	kvm_make_request(KVM_REQ_APIC_PAGE_RELOAD, vcpu);	5620	kvm_make_request(KVM_REQ_APIC_PAGE_RELOAD, vcpu);
5621		5621
5622	if (kvm_vcpu_apicv_active(vcpu))
5623	memset(&vmx->pi_desc, 0, sizeof(struct pi_desc));
5624
5625	if (vmx->vpid != 0)	5622	if (vmx->vpid != 0)
5626	vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid);	5623	vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid);
5627		5624

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

@@ -40,7 +40,7 @@ static char sme_cmdline_off[] __initdata = "off"; · 39 unmodified lines
40	* section is later cleared.	40	* section is later cleared.
41	*/	41	*/
42	u64 sme_me_mask __section(.data) = 0;	42	u64 sme_me_mask __section(.data) = 0;
43	EXPORT_SYMBOL_GPL(sme_me_mask);	43	EXPORT_SYMBOL(sme_me_mask);
44		44
45	/* Buffer used for early in-place encryption by BSP, no locking needed */	45	/* Buffer used for early in-place encryption by BSP, no locking needed */
46	static char sme_early_buffer[PAGE_SIZE] __aligned(PAGE_SIZE);	46	static char sme_early_buffer[PAGE_SIZE] __aligned(PAGE_SIZE);

arch/x86/mm/tlb.c+14−3

@@ -85,6 +85,7 @@ void leave_mm(int cpu) · 84 unmodified lines
85		85
86	switch_mm(NULL, &init_mm, NULL);	86	switch_mm(NULL, &init_mm, NULL);
87	}	87	}
		88	EXPORT_SYMBOL_GPL(leave_mm);
88		89
89	void switch_mm(struct mm_struct prev, struct mm_struct next,	90	void switch_mm(struct mm_struct prev, struct mm_struct next,
90	struct task_struct *tsk)	91	struct task_struct *tsk)
@@ -195,12 +196,22 @@ void switch_mm_irqs_off(struct mm_struct prev, struct mm_struct next, · 104 unmodified lines
195	this_cpu_write(cpu_tlbstate.ctxs[new_asid].ctx_id, next->context.ctx_id);	196	this_cpu_write(cpu_tlbstate.ctxs[new_asid].ctx_id, next->context.ctx_id);
196	this_cpu_write(cpu_tlbstate.ctxs[new_asid].tlb_gen, next_tlb_gen);	197	this_cpu_write(cpu_tlbstate.ctxs[new_asid].tlb_gen, next_tlb_gen);
197	write_cr3(build_cr3(next, new_asid));	198	write_cr3(build_cr3(next, new_asid));
198	trace_tlb_flush(TLB_FLUSH_ON_TASK_SWITCH,	199
199	TLB_FLUSH_ALL);	200	/*
		201	* NB: This gets called via leave_mm() in the idle path
		202	* where RCU functions differently. Tracing normally
		203	* uses RCU, so we need to use the _rcuidle variant.
		204	*
		205	* (There is no good reason for this. The idle code should
		206	* be rearranged to call this before rcu_idle_enter().)
		207	*/
		208	trace_tlb_flush_rcuidle(TLB_FLUSH_ON_TASK_SWITCH, TLB_FLUSH_ALL);
200	} else {	209	} else {
201	/* The new ASID is already up to date. */	210	/* The new ASID is already up to date. */
202	write_cr3(build_cr3_noflush(next, new_asid));	211	write_cr3(build_cr3_noflush(next, new_asid));
203	trace_tlb_flush(TLB_FLUSH_ON_TASK_SWITCH, 0);	212
		213	/* See above wrt _rcuidle. */
		214	trace_tlb_flush_rcuidle(TLB_FLUSH_ON_TASK_SWITCH, 0);
204	}	215	}
205		216
206	this_cpu_write(cpu_tlbstate.loaded_mm, next);	217	this_cpu_write(cpu_tlbstate.loaded_mm, next);

crypto/ccm.c+3−1

 	unsigned int cryptlen = req->cryptlen;
 	u8 *authtag = pctx->auth_tag;
 	u8 *odata = pctx->odata;
-	u8 *iv = req->iv;
+	u8 *iv = pctx->idata;
 	int err;
 	cryptlen -= authsize;
 	if (req->src != req->dst)
 		dst = pctx->dst;
+	memcpy(iv, req->iv, 16);
 	skcipher_request_set_tfm(skreq, ctx->ctr);
 	skcipher_request_set_callback(skreq, pctx->flags,
 				      crypto_ccm_decrypt_done, req);

drivers/acpi/processor_idle.c+2−0

@@ -710,6 +710,8 @@ static DEFINE_RAW_SPINLOCK(c3_lock); · 709 unmodified lines
710	static void acpi_idle_enter_bm(struct acpi_processor *pr,	710	static void acpi_idle_enter_bm(struct acpi_processor *pr,
711	struct acpi_processor_cx *cx, bool timer_bc)	711	struct acpi_processor_cx *cx, bool timer_bc)
712	{	712	{
		713	acpi_unlazy_tlb(smp_processor_id());
		714
713	/*	715	/*
714	* Must be done before busmaster disable as we might need to	716	* Must be done before busmaster disable as we might need to
715	* access HPET !	717	* access HPET !

drivers/acpi/sleep.c+28−0

@@ -160,6 +160,14 @@ static int __init init_nvs_nosave(const struct dmi_system_id *d) · 159 unmodified lines
160	return 0;	160	return 0;
161	}	161	}
162		162
		163	static bool acpi_sleep_no_lps0;
		164
		165	static int __init init_no_lps0(const struct dmi_system_id *d)
		166	{
		167	acpi_sleep_no_lps0 = true;
		168	return 0;
		169	}
		170
163	static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {	171	static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {
164	{	172	{
165	.callback = init_old_suspend_ordering,	173	.callback = init_old_suspend_ordering,
@@ -343,6 +351,19 @@ static const struct dmi_system_id acpisleep_dmi_table[] __initconst = { · 177 unmodified lines
343	DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),	351	DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
344	},	352	},
345	},	353	},
		354	/*
		355	* https://bugzilla.kernel.org/show_bug.cgi?id=196907
		356	* Some Dell XPS13 9360 cannot do suspend-to-idle using the Low Power
		357	* S0 Idle firmware interface.
		358	*/
		359	{
		360	.callback = init_no_lps0,
		361	.ident = "Dell XPS13 9360",
		362	.matches = {
		363	DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
		364	DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),
		365	},
		366	},
346	{},	367	{},
347	};	368	};
348		369
@@ -485,6 +506,7 @@ static void acpi_pm_end(void) · 136 unmodified lines
485	}	506	}
486	#else /* !CONFIG_ACPI_SLEEP */	507	#else /* !CONFIG_ACPI_SLEEP */
487	#define acpi_target_sleep_state ACPI_STATE_S0	508	#define acpi_target_sleep_state ACPI_STATE_S0
		509	#define acpi_sleep_no_lps0 (false)
488	static inline void acpi_sleep_dmi_check(void) {}	510	static inline void acpi_sleep_dmi_check(void) {}
489	#endif /* CONFIG_ACPI_SLEEP */	511	#endif /* CONFIG_ACPI_SLEEP */
490		512
@@ -863,6 +885,12 @@ static int lps0_device_attach(struct acpi_device *adev, · 372 unmodified lines
863	if (lps0_device_handle)	885	if (lps0_device_handle)
864	return 0;	886	return 0;
865		887
		888	if (acpi_sleep_no_lps0) {
		889	acpi_handle_info(adev->handle,
		890	"Low Power S0 Idle interface disabled\n");
		891	return 0;
		892	}
		893
866	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))	894	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
867	return 0;	895	return 0;
868		896

drivers/firmware/efi/libstub/Makefile+3−3

 lib-$(CONFIG_RESET_ATTACK_MITIGATION) += tpm.o
 # include the stub's generic dependencies from lib/ when building for ARM/arm64
-arm-deps := fdt_rw.c fdt_ro.c fdt_wip.c fdt.c fdt_empty_tree.c fdt_sw.c sort.c
+arm-deps-y := fdt_rw.c fdt_ro.c fdt_wip.c fdt.c fdt_empty_tree.c fdt_sw.c
+arm-deps-$(CONFIG_ARM64) += sort.c
 $(obj)/lib-%.o: $(srctree)/lib/%.c FORCE
 	$(call if_changed_rule,cc_o_c)
 lib-$(CONFIG_EFI_ARMSTUB)	+= arm-stub.o fdt.o string.o random.o \
-				   $(patsubst %.c,lib-%.o,$(arm-deps))
+				   $(patsubst %.c,lib-%.o,$(arm-deps-y))
 lib-$(CONFIG_ARM)		+= arm32-stub.o
 lib-$(CONFIG_ARM64)		+= arm64-stub.o
 # explicitly by the decompressor linker script.
 #
 STUBCOPY_FLAGS-$(CONFIG_ARM)	+= --rename-section .data=.data.efistub
-STUBCOPY_RM-$(CONFIG_ARM)	+= -R ___ksymtab+sort -R ___kcrctab+sort
 STUBCOPY_RELOC-$(CONFIG_ARM)	:= R_ARM_ABS

drivers/firmware/efi/libstub/arm-stub.c+5−2

 	 * The easiest way to find adjacent regions is to sort the memory map
 	 * before traversing it.
 	 */
-	sort(memory_map, map_size / desc_size, desc_size, cmp_mem_desc, NULL);
+	if (IS_ENABLED(CONFIG_ARM64))
+		sort(memory_map, map_size / desc_size, desc_size, cmp_mem_desc,
+		     NULL);
 	for (l = 0; l < map_size; l += desc_size, prev = in) {
 		u64 paddr, size;
 		 * a 4k page size kernel to kexec a 64k page size kernel and
 		 * vice versa.
 		 */
-		if (!regions_are_adjacent(prev, in) ||
+		if ((IS_ENABLED(CONFIG_ARM64) &&
+		     !regions_are_adjacent(prev, in)) ||
 		    !regions_have_compatible_memory_type_attrs(prev, in)) {
 			paddr = round_down(in->phys_addr, SZ_64K);

drivers/ide/ide-cd.c+6−1

 int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
 {
 	struct cdrom_info *info = drive->driver_data;
-	struct cdrom_device_info *cdi = &info->devinfo;
+	struct cdrom_device_info *cdi;
 	unsigned char cmd[BLK_MAX_CDB];
 	ide_debug_log(IDE_DBG_FUNC, "enter");
+	if (!info)
+		return -EIO;
+	cdi = &info->devinfo;
 	memset(cmd, 0, BLK_MAX_CDB);
 	cmd[0] = GPCMD_TEST_UNIT_READY;

drivers/idle/intel_idle.c+5−4

 	struct cpuidle_state *state = &drv->states[index];
 	unsigned long eax = flg2MWAIT(state->flags);
 	unsigned int cstate;
+	int cpu = smp_processor_id();
 	cstate = (((eax) >> MWAIT_SUBSTATE_SIZE) & MWAIT_CSTATE_MASK) + 1;
 	/*
-	 * NB: if CPUIDLE_FLAG_TLB_FLUSHED is set, this idle transition
+	 * leave_mm() to avoid costly and often unnecessary wakeups
-	 * will probably flush the TLB.  It's not guaranteed to flush
+	 * for flushing the user TLB's associated with the active mm.
-	 * the TLB, though, so it's not clear that we can do anything
-	 * useful with this knowledge.
 	 */
+	if (state->flags & CPUIDLE_FLAG_TLB_FLUSHED)
+		leave_mm(cpu);
 	if (!(lapic_timer_reliable_states & (1 << (cstate))))
 		tick_broadcast_enter();

drivers/input/sparse-keymap.c+1−0

@@ -255,6 +255,7 @@ void sparse_keymap_report_entry(struct input_dev dev, const struct key_entry k · 254 unmodified lines
255		255
256	case KE_VSW:	256	case KE_VSW:
257	input_report_switch(dev, ke->sw.code, value);	257	input_report_switch(dev, ke->sw.code, value);
		258	input_sync(dev);
258	break;	259	break;
259	}	260	}
260	}	261	}

drivers/input/touchscreen/ar1021_i2c.c+1−0

@@ -117,6 +117,7 @@ static int ar1021_i2c_probe(struct i2c_client *client, · 116 unmodified lines
117	input->open = ar1021_i2c_open;	117	input->open = ar1021_i2c_open;
118	input->close = ar1021_i2c_close;	118	input->close = ar1021_i2c_close;
119		119
		120	__set_bit(INPUT_PROP_DIRECT, input->propbit);
120	input_set_capability(input, EV_KEY, BTN_TOUCH);	121	input_set_capability(input, EV_KEY, BTN_TOUCH);
121	input_set_abs_params(input, ABS_X, 0, AR1021_MAX_X, 0, 0);	122	input_set_abs_params(input, ABS_X, 0, AR1021_MAX_X, 0, 0);
122	input_set_abs_params(input, ABS_Y, 0, AR1021_MAX_Y, 0, 0);	123	input_set_abs_params(input, ABS_Y, 0, AR1021_MAX_Y, 0, 0);

drivers/irqchip/irq-mvebu-gicp.c+1−0

@@ -194,6 +194,7 @@ static int mvebu_gicp_probe(struct platform_device *pdev) · 193 unmodified lines
194	return -ENOMEM;	194	return -ENOMEM;
195		195
196	gicp->dev = &pdev->dev;	196	gicp->dev = &pdev->dev;
		197	spin_lock_init(&gicp->spi_lock);
197		198
198	gicp->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);	199	gicp->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
199	if (!gicp->res)	200	if (!gicp->res)

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

 	bond_for_each_slave_rcu(bond, slave, iter) {
 		slave->new_link = BOND_LINK_NOCHANGE;
+		slave->link_new_state = slave->link;
 		link_state = bond_check_dev_link(bond, slave->dev, 0);
 	hash ^= (hash >> 16);
 	hash ^= (hash >> 8);
-	return hash;
+	return hash >> 1;
 }
 /*-------------------------- Device entry points ----------------------------*/

drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h+3−3

drivers/net/ethernet/marvell/mvpp2.c+4−0

 	for (i = 0; i < port->nqvecs; i++) {
 		struct mvpp2_queue_vector *qv = port->qvecs + i;
+		if (qv->type == MVPP2_QUEUE_VECTOR_PRIVATE)
+			irq_set_status_flags(qv->irq, IRQ_NO_BALANCING);
 		err = request_irq(qv->irq, mvpp2_isr, 0, port->dev->name, qv);
 		if (err)
 			goto err;
 		struct mvpp2_queue_vector *qv = port->qvecs + i;
 		irq_set_affinity_hint(qv->irq, NULL);
+		irq_clear_status_flags(qv->irq, IRQ_NO_BALANCING);
 		free_irq(qv->irq, qv);
 	}
 }

drivers/net/ethernet/mellanox/mlx5/core/en_fs.c+8−5

 				    struct mlx5e_l2_hash_node *hn)
 {
 	u8 action = hn->action;
+	u8 mac_addr[ETH_ALEN];
 	int l2_err = 0;
+	ether_addr_copy(mac_addr, hn->ai.addr);
 	switch (action) {
 	case MLX5E_ACTION_ADD:
 		mlx5e_add_l2_flow_rule(priv, &hn->ai, MLX5E_FULLMATCH);
-		if (!is_multicast_ether_addr(hn->ai.addr)) {
+		if (!is_multicast_ether_addr(mac_addr)) {
-			l2_err = mlx5_mpfs_add_mac(priv->mdev, hn->ai.addr);
+			l2_err = mlx5_mpfs_add_mac(priv->mdev, mac_addr);
 			hn->mpfs = !l2_err;
 		}
 		hn->action = MLX5E_ACTION_NONE;
 		break;
 	case MLX5E_ACTION_DEL:
-		if (!is_multicast_ether_addr(hn->ai.addr) && hn->mpfs)
+		if (!is_multicast_ether_addr(mac_addr) && hn->mpfs)
-			l2_err = mlx5_mpfs_del_mac(priv->mdev, hn->ai.addr);
+			l2_err = mlx5_mpfs_del_mac(priv->mdev, mac_addr);
 		mlx5e_del_l2_flow_rule(priv, &hn->ai);
 		mlx5e_del_l2_from_hash(hn);
 		break;
 	if (l2_err)
 		netdev_warn(priv->netdev, "MPFS, failed to %s mac %pM, err(%d)\n",
-			    action == MLX5E_ACTION_ADD ? "add" : "del", hn->ai.addr, l2_err);
+			    action == MLX5E_ACTION_ADD ? "add" : "del", mac_addr, l2_err);
 }
 static void mlx5e_sync_netdev_addr(struct mlx5e_priv *priv)

drivers/net/usb/asix_devices.c+2−2

@@ -626,7 +626,7 @@ static int asix_suspend(struct usb_interface *intf, pm_message_t message) · 625 unmodified lines
626	struct usbnet *dev = usb_get_intfdata(intf);	626	struct usbnet *dev = usb_get_intfdata(intf);
627	struct asix_common_private *priv = dev->driver_priv;	627	struct asix_common_private *priv = dev->driver_priv;
628		628
629	if (priv->suspend)	629	if (priv && priv->suspend)
630	priv->suspend(dev);	630	priv->suspend(dev);
631		631
632	return usbnet_suspend(intf, message);	632	return usbnet_suspend(intf, message);
@@ -678,7 +678,7 @@ static int asix_resume(struct usb_interface *intf) · 45 unmodified lines
678	struct usbnet *dev = usb_get_intfdata(intf);	678	struct usbnet *dev = usb_get_intfdata(intf);
679	struct asix_common_private *priv = dev->driver_priv;	679	struct asix_common_private *priv = dev->driver_priv;
680		680
681	if (priv->resume)	681	if (priv && priv->resume)
682	priv->resume(dev);	682	priv->resume(dev);
683		683
684	return usbnet_resume(intf);	684	return usbnet_resume(intf);

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

@@ -230,7 +230,7 @@ skip: · 229 unmodified lines
230	goto bad_desc;	230	goto bad_desc;
231	}	231	}
232		232
233	if (header.usb_cdc_ether_desc) {	233	if (header.usb_cdc_ether_desc && info->ether->wMaxSegmentSize) {
234	dev->hard_mtu = le16_to_cpu(info->ether->wMaxSegmentSize);	234	dev->hard_mtu = le16_to_cpu(info->ether->wMaxSegmentSize);
235	/* because of Zaurus, we may be ignoring the host	235	/* because of Zaurus, we may be ignoring the host
236	* side link address we were given.	236	* side link address we were given.

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

 		return 1;
 	}
 	if (rawip) {
+		skb_reset_mac_header(skb);
 		skb->dev = dev->net; /* normally set by eth_type_trans */
 		skb->protocol = proto;
 		return 1;
 	}
 	/* errors aren't fatal - we can live with the dynamic address */
-	if (cdc_ether) {
+	if (cdc_ether && cdc_ether->wMaxSegmentSize) {
 		dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);
 		usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);
 	}

drivers/scsi/scsi_lib.c+0−3

 	}
 	sdev->sdev_state = state;
-	sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
 	return 0;
  illegal:
 	case SDEV_BLOCK:
 	case SDEV_TRANSPORT_OFFLINE:
 		sdev->sdev_state = new_state;
-		sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
 		break;
 	case SDEV_CREATED_BLOCK:
 		if (new_state == SDEV_TRANSPORT_OFFLINE ||
 			sdev->sdev_state = new_state;
 		else
 			sdev->sdev_state = SDEV_CREATED;
-		sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
 		break;
 	case SDEV_CANCEL:
 	case SDEV_OFFLINE:

drivers/scsi/scsi_transport_srp.c+1−4

 		 */
 		shost_for_each_device(sdev, shost) {
 			mutex_lock(&sdev->state_mutex);
-			if (sdev->sdev_state == SDEV_OFFLINE) {
+			if (sdev->sdev_state == SDEV_OFFLINE)
 				sdev->sdev_state = SDEV_RUNNING;
-				sysfs_notify(&sdev->sdev_gendev.kobj,
-					     NULL, "state");
-			}
 			mutex_unlock(&sdev->state_mutex);
 		}
 	} else if (rport->state == SRP_RPORT_RUNNING) {

include/linux/compiler.h+2−2

@@ -191,13 +191,13 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val, · 190 unmodified lines
191	asm("%c0:\n\t" \	191	asm("%c0:\n\t" \
192	".pushsection .discard.reachable\n\t" \	192	".pushsection .discard.reachable\n\t" \
193	".long %c0b - .\n\t" \	193	".long %c0b - .\n\t" \
194	".popsection\n\t" : : "i" (__LINE__)); \	194	".popsection\n\t" : : "i" (__COUNTER__)); \
195	})	195	})
196	#define annotate_unreachable() ({ \	196	#define annotate_unreachable() ({ \
197	asm("%c0:\n\t" \	197	asm("%c0:\n\t" \
198	".pushsection .discard.unreachable\n\t" \	198	".pushsection .discard.unreachable\n\t" \
199	".long %c0b - .\n\t" \	199	".long %c0b - .\n\t" \
200	".popsection\n\t" : : "i" (__LINE__)); \	200	".popsection\n\t" : : "i" (__COUNTER__)); \
201	})	201	})
202	#define ASM_UNREACHABLE \	202	#define ASM_UNREACHABLE \
203	"999:\n\t" \	203	"999:\n\t" \

include/linux/skbuff.h+7−0

@@ -3841,6 +3841,13 @@ static inline void nf_reset_trace(struct sk_buff *skb) · 3840 unmodified lines
3841	#endif	3841	#endif
3842	}	3842	}
3843		3843
		3844	static inline void ipvs_reset(struct sk_buff *skb)
		3845	{
		3846	#if IS_ENABLED(CONFIG_IP_VS)
		3847	skb->ipvs_property = 0;
		3848	#endif
		3849	}
		3850
3844	/* Note: This doesn't put any conntrack and bridge info in dst. */	3851	/* Note: This doesn't put any conntrack and bridge info in dst. */
3845	static inline void __nf_copy(struct sk_buff dst, const struct sk_buff src,	3852	static inline void __nf_copy(struct sk_buff dst, const struct sk_buff src,
3846	bool copy)	3853	bool copy)

include/net/act_api.h+1−3

 struct tcf_idrinfo {
 	spinlock_t	lock;
 	struct idr	action_idr;
-	struct net	*net;
 };
 struct tc_action_ops;
 static inline
 int tc_action_net_init(struct tc_action_net *tn,
-		       const struct tc_action_ops *ops, struct net *net)
+		       const struct tc_action_ops *ops)
 {
 	int err = 0;
 	if (!tn->idrinfo)
 		return -ENOMEM;
 	tn->ops = ops;
-	tn->idrinfo->net = net;
 	spin_lock_init(&tn->idrinfo->lock);
 	idr_init(&tn->idrinfo->action_idr);
 	return err;

include/net/pkt_cls.h+24−0

@@ -231,6 +231,7 @@ struct tcf_exts { · 230 unmodified lines
231	__u32 type; /* for backward compat(TCA_OLD_COMPAT) */	231	__u32 type; /* for backward compat(TCA_OLD_COMPAT) */
232	int nr_actions;	232	int nr_actions;
233	struct tc_action **actions;	233	struct tc_action **actions;
		234	struct net *net;
234	#endif	235	#endif
235	/* Map to export classifier specific extension TLV types to the	236	/* Map to export classifier specific extension TLV types to the
236	* generic extensions API. Unsupported extensions must be set to 0.	237	* generic extensions API. Unsupported extensions must be set to 0.
@@ -244,6 +245,7 @@ static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police) · 7 unmodified lines
244	#ifdef CONFIG_NET_CLS_ACT	245	#ifdef CONFIG_NET_CLS_ACT
245	exts->type = 0;	246	exts->type = 0;
246	exts->nr_actions = 0;	247	exts->nr_actions = 0;
		248	exts->net = NULL;
247	exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *),	249	exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *),
248	GFP_KERNEL);	250	GFP_KERNEL);
249	if (!exts->actions)	251	if (!exts->actions)
@@ -254,6 +256,28 @@ static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police) · 4 unmodified lines
254	return 0;	256	return 0;
255	}	257	}
256		258
		259	/* Return false if the netns is being destroyed in cleanup_net(). Callers
		260	* need to do cleanup synchronously in this case, otherwise may race with
		261	* tc_action_net_exit(). Return true for other cases.
		262	*/
		263	static inline bool tcf_exts_get_net(struct tcf_exts *exts)
		264	{
		265	#ifdef CONFIG_NET_CLS_ACT
		266	exts->net = maybe_get_net(exts->net);
		267	return exts->net != NULL;
		268	#else
		269	return true;
		270	#endif
		271	}
		272
		273	static inline void tcf_exts_put_net(struct tcf_exts *exts)
		274	{
		275	#ifdef CONFIG_NET_CLS_ACT
		276	if (exts->net)
		277	put_net(exts->net);
		278	#endif
		279	}
		280
257	static inline void tcf_exts_to_list(const struct tcf_exts *exts,	281	static inline void tcf_exts_to_list(const struct tcf_exts *exts,
258	struct list_head *actions)	282	struct list_head *actions)
259	{	283	{

include/sound/seq_kernel.h+2−1

@@ -49,7 +49,8 @@ typedef union snd_seq_timestamp snd_seq_timestamp_t; · 48 unmodified lines
49	#define SNDRV_SEQ_DEFAULT_CLIENT_EVENTS 200	49	#define SNDRV_SEQ_DEFAULT_CLIENT_EVENTS 200
50		50
51	/* max delivery path length */	51	/* max delivery path length */
52	#define SNDRV_SEQ_MAX_HOPS 10	52	/* NOTE: this shouldn't be greater than MAX_LOCKDEP_SUBCLASSES */
		53	#define SNDRV_SEQ_MAX_HOPS 8
53		54
54	/* max size of event size */	55	/* max size of event size */
55	#define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff	56	#define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff

include/sound/timer.h+2−0

@@ -90,6 +90,8 @@ struct snd_timer { · 89 unmodified lines
90	struct list_head ack_list_head;	90	struct list_head ack_list_head;
91	struct list_head sack_list_head; /* slow ack list head */	91	struct list_head sack_list_head; /* slow ack list head */
92	struct tasklet_struct task_queue;	92	struct tasklet_struct task_queue;
		93	int max_instances; /* upper limit of timer instances */
		94	int num_instances; /* current number of timer instances */
93	};	95	};
94		96
95	struct snd_timer_instance {	97	struct snd_timer_instance {

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

kernel/events/core.c+4−2

 	cpuctx_entry = &cpuctx->cgrp_cpuctx_entry;
 	/* cpuctx->cgrp is NULL unless a cgroup event is active in this CPU .*/
 	if (add) {
+		struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
 		list_add(cpuctx_entry, this_cpu_ptr(&cgrp_cpuctx_list));
-		if (perf_cgroup_from_task(current, ctx) == event->cgrp)
+		if (cgroup_is_descendant(cgrp->css.cgroup, event->cgrp->css.cgroup))
-			cpuctx->cgrp = event->cgrp;
+			cpuctx->cgrp = cgrp;
 	} else {
 		list_del(cpuctx_entry);
 		cpuctx->cgrp = NULL;

kernel/futex.c+20−3

 	 */
 	raw_spin_lock_irq(&curr->pi_lock);
 	while (!list_empty(head)) {
 		next = head->next;
 		pi_state = list_entry(next, struct futex_pi_state, list);
 		key = pi_state->key;
 		hb = hash_futex(&key);
+		/*
+		 * We can race against put_pi_state() removing itself from the
+		 * list (a waiter going away). put_pi_state() will first
+		 * decrement the reference count and then modify the list, so
+		 * its possible to see the list entry but fail this reference
+		 * acquire.
+		 *
+		 * In that case; drop the locks to let put_pi_state() make
+		 * progress and retry the loop.
+		 */
+		if (!atomic_inc_not_zero(&pi_state->refcount)) {
+			raw_spin_unlock_irq(&curr->pi_lock);
+			cpu_relax();
+			raw_spin_lock_irq(&curr->pi_lock);
+			continue;
+		}
 		raw_spin_unlock_irq(&curr->pi_lock);
 		spin_lock(&hb->lock);
 		 * task still owns the PI-state:
 		 */
 		if (head->next != next) {
+			/* retain curr->pi_lock for the loop invariant */
 			raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
 			spin_unlock(&hb->lock);
+			put_pi_state(pi_state);
 			continue;
 		}
 		WARN_ON(list_empty(&pi_state->list));
 		list_del_init(&pi_state->list);
 		pi_state->owner = NULL;
-		raw_spin_unlock(&curr->pi_lock);
-		get_pi_state(pi_state);
+		raw_spin_unlock(&curr->pi_lock);
 		raw_spin_unlock_irq(&pi_state->pi_mutex.wait_lock);
 		spin_unlock(&hb->lock);

kernel/sched/cpufreq_schedutil.c+1−5

 		struct sugov_cpu *sg_cpu = &per_cpu(sugov_cpu, cpu);
 		memset(sg_cpu, 0, sizeof(*sg_cpu));
+		sg_cpu->cpu = cpu;
 		sg_cpu->sg_policy = sg_policy;
 		sg_cpu->flags = SCHED_CPUFREQ_RT;
 		sg_cpu->iowait_boost_max = policy->cpuinfo.max_freq;
 static int __init sugov_register(void)
 {
-	int cpu;
-	for_each_possible_cpu(cpu)
-		per_cpu(sugov_cpu, cpu).cpu = cpu;
 	return cpufreq_register_governor(&schedutil_gov);
 }
 fs_initcall(sugov_register);

kernel/watchdog_hld.c+10−5

 #define pr_fmt(fmt) "NMI watchdog: " fmt
 #include <linux/nmi.h>
+#include <linux/atomic.h>
 #include <linux/module.h>
 #include <linux/sched/debug.h>
 static DEFINE_PER_CPU(bool, hard_watchdog_warn);
 static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
 static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
+static DEFINE_PER_CPU(struct perf_event *, dead_event);
 static struct cpumask dead_events_mask;
 static unsigned long hardlockup_allcpu_dumped;
-static unsigned int watchdog_cpus;
+static atomic_t watchdog_cpus = ATOMIC_INIT(0);
 void arch_touch_nmi_watchdog(void)
 {
 	if (hardlockup_detector_event_create())
 		return;
-	if (!watchdog_cpus++)
+	/* use original value for check */
+	if (!atomic_fetch_inc(&watchdog_cpus))
 		pr_info("Enabled. Permanently consumes one hw-PMU counter.\n");
 	perf_event_enable(this_cpu_read(watchdog_ev));
 	if (event) {
 		perf_event_disable(event);
+		this_cpu_write(watchdog_ev, NULL);
+		this_cpu_write(dead_event, event);
 		cpumask_set_cpu(smp_processor_id(), &dead_events_mask);
-		watchdog_cpus--;
+		atomic_dec(&watchdog_cpus);
 	}
 }
 	int cpu;
 	for_each_cpu(cpu, &dead_events_mask) {
-		struct perf_event *event = per_cpu(watchdog_ev, cpu);
+		struct perf_event *event = per_cpu(dead_event, cpu);
 		/*
 		 * Required because for_each_cpu() reports  unconditionally
 		 */
 		if (event)
 			perf_event_release_kernel(event);
-		per_cpu(watchdog_ev, cpu) = NULL;
+		per_cpu(dead_event, cpu) = NULL;
 	}
 	cpumask_clear(&dead_events_mask);
 }

kernel/workqueue_internal.h+2−1

 #include <linux/workqueue.h>
 #include <linux/kthread.h>
+#include <linux/preempt.h>
 struct worker_pool;
  */
 static inline struct worker *current_wq_worker(void)
 {
-	if (current->flags & PF_WQ_WORKER)
+	if (in_task() && (current->flags & PF_WQ_WORKER))
 		return kthread_data(current);
 	return NULL;
 }

lib/asn1_decoder.c+2−2

@@ -228,7 +228,7 @@ next_op: · 227 unmodified lines
228	hdr = 2;	228	hdr = 2;
229		229
230	/* Extract a tag from the data */	230	/* Extract a tag from the data */
231	if (unlikely(dp >= datalen - 1))	231	if (unlikely(datalen - dp < 2))
232	goto data_overrun_error;	232	goto data_overrun_error;
233	tag = data[dp++];	233	tag = data[dp++];
234	if (unlikely((tag & 0x1f) == ASN1_LONG_TAG))	234	if (unlikely((tag & 0x1f) == ASN1_LONG_TAG))
@@ -274,7 +274,7 @@ next_op: · 39 unmodified lines
274	int n = len - 0x80;	274	int n = len - 0x80;
275	if (unlikely(n > 2))	275	if (unlikely(n > 2))
276	goto length_too_long;	276	goto length_too_long;
277	if (unlikely(dp >= datalen - n))	277	if (unlikely(n > datalen - dp))
278	goto data_overrun_error;	278	goto data_overrun_error;
279	hdr += n;	279	hdr += n;
280	for (len = 0; n > 0; n--) {	280	for (len = 0; n > 0; n--) {

net/core/skbuff.c+1−0

@@ -4869,6 +4869,7 @@ void skb_scrub_packet(struct sk_buff *skb, bool xnet) · 4868 unmodified lines
4869	if (!xnet)	4869	if (!xnet)
4870	return;	4870	return;
4871		4871
		4872	ipvs_reset(skb);
4872	skb_orphan(skb);	4873	skb_orphan(skb);
4873	skb->mark = 0;	4874	skb->mark = 0;
4874	}	4875	}

net/ipv4/tcp_input.c+1−1

@@ -100,7 +100,7 @@ int sysctl_tcp_max_orphans __read_mostly = NR_FILE; · 99 unmodified lines
100		100
101	#define FLAG_ACKED (FLAG_DATA_ACKED\|FLAG_SYN_ACKED)	101	#define FLAG_ACKED (FLAG_DATA_ACKED\|FLAG_SYN_ACKED)
102	#define FLAG_NOT_DUP (FLAG_DATA\|FLAG_WIN_UPDATE\|FLAG_ACKED)	102	#define FLAG_NOT_DUP (FLAG_DATA\|FLAG_WIN_UPDATE\|FLAG_ACKED)
103	#define FLAG_CA_ALERT (FLAG_DATA_SACKED\|FLAG_ECE)	103	#define FLAG_CA_ALERT (FLAG_DATA_SACKED\|FLAG_ECE\|FLAG_DSACKING_ACK)
104	#define FLAG_FORWARD_PROGRESS (FLAG_ACKED\|FLAG_DATA_SACKED)	104	#define FLAG_FORWARD_PROGRESS (FLAG_ACKED\|FLAG_DATA_SACKED)
105		105
106	#define TCP_REMNANT (TCP_FLAG_FIN\|TCP_FLAG_URG\|TCP_FLAG_SYN\|TCP_FLAG_PSH)	106	#define TCP_REMNANT (TCP_FLAG_FIN\|TCP_FLAG_URG\|TCP_FLAG_SYN\|TCP_FLAG_PSH)

net/l2tp/l2tp_ip.c+9−15

 	unsigned char *ptr, *optr;
 	struct l2tp_session *session;
 	struct l2tp_tunnel *tunnel = NULL;
+	struct iphdr *iph;
 	int length;
 	if (!pskb_may_pull(skb, 4))
 		goto discard;
 	tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
-	tunnel = l2tp_tunnel_find(net, tunnel_id);
+	iph = (struct iphdr *)skb_network_header(skb);
-	if (tunnel) {
-		sk = tunnel->sock;
-		sock_hold(sk);
-	} else {
-		struct iphdr *iph = (struct iphdr *) skb_network_header(skb);
-		read_lock_bh(&l2tp_ip_lock);
-		sk = __l2tp_ip_bind_lookup(net, iph->daddr, iph->saddr,
-					   inet_iif(skb), tunnel_id);
-		if (!sk) {
-			read_unlock_bh(&l2tp_ip_lock);
-			goto discard;
-		}
-		sock_hold(sk);
+	read_lock_bh(&l2tp_ip_lock);
+	sk = __l2tp_ip_bind_lookup(net, iph->daddr, iph->saddr, inet_iif(skb),
+				   tunnel_id);
+	if (!sk) {
 		read_unlock_bh(&l2tp_ip_lock);
+		goto discard;
 	}
+	sock_hold(sk);
+	read_unlock_bh(&l2tp_ip_lock);
 	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
 		goto discard_put;

net/l2tp/l2tp_ip6.c+9−15

 	unsigned char *ptr, *optr;
 	struct l2tp_session *session;
 	struct l2tp_tunnel *tunnel = NULL;
+	struct ipv6hdr *iph;
 	int length;
 	if (!pskb_may_pull(skb, 4))
 		goto discard;
 	tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
-	tunnel = l2tp_tunnel_find(net, tunnel_id);
+	iph = ipv6_hdr(skb);
-	if (tunnel) {
-		sk = tunnel->sock;
-		sock_hold(sk);
-	} else {
-		struct ipv6hdr *iph = ipv6_hdr(skb);
-		read_lock_bh(&l2tp_ip6_lock);
-		sk = __l2tp_ip6_bind_lookup(net, &iph->daddr, &iph->saddr,
-					    inet6_iif(skb), tunnel_id);
-		if (!sk) {
-			read_unlock_bh(&l2tp_ip6_lock);
-			goto discard;
-		}
-		sock_hold(sk);
+	read_lock_bh(&l2tp_ip6_lock);
+	sk = __l2tp_ip6_bind_lookup(net, &iph->daddr, &iph->saddr,
+				    inet6_iif(skb), tunnel_id);
+	if (!sk) {
 		read_unlock_bh(&l2tp_ip6_lock);
+		goto discard;
 	}
+	sock_hold(sk);
+	read_unlock_bh(&l2tp_ip6_lock);
 	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
 		goto discard_put;

net/qrtr/qrtr.c+1−1

@@ -1120,7 +1120,7 @@ static int __init qrtr_proto_init(void) · 1119 unmodified lines
1120		1120
1121	return 0;	1121	return 0;
1122	}	1122	}
1123	module_init(qrtr_proto_init);	1123	postcore_initcall(qrtr_proto_init);
1124		1124
1125	static void __exit qrtr_proto_fini(void)	1125	static void __exit qrtr_proto_fini(void)
1126	{	1126	{

net/sched/act_api.c+0−2

 	spin_lock_bh(&idrinfo->lock);
 	idr_remove_ext(&idrinfo->action_idr, p->tcfa_index);
 	spin_unlock_bh(&idrinfo->lock);
-	put_net(idrinfo->net);
 	gen_kill_estimator(&p->tcfa_rate_est);
 	free_tcf(p);
 }
 	p->idrinfo = idrinfo;
 	p->ops = ops;
 	INIT_LIST_HEAD(&p->list);
-	get_net(idrinfo->net);
 	*a = p;
 	return 0;
 }

net/sched/act_bpf.c+1−1

@@ -398,7 +398,7 @@ static __net_init int bpf_init_net(struct net *net) · 397 unmodified lines
398	{	398	{
399	struct tc_action_net *tn = net_generic(net, bpf_net_id);	399	struct tc_action_net *tn = net_generic(net, bpf_net_id);
400		400
401	return tc_action_net_init(tn, &act_bpf_ops, net);	401	return tc_action_net_init(tn, &act_bpf_ops);
402	}	402	}
403		403
404	static void __net_exit bpf_exit_net(struct net *net)	404	static void __net_exit bpf_exit_net(struct net *net)

net/sched/act_connmark.c+1−1

@@ -206,7 +206,7 @@ static __net_init int connmark_init_net(struct net *net) · 205 unmodified lines
206	{	206	{
207	struct tc_action_net *tn = net_generic(net, connmark_net_id);	207	struct tc_action_net *tn = net_generic(net, connmark_net_id);
208		208
209	return tc_action_net_init(tn, &act_connmark_ops, net);	209	return tc_action_net_init(tn, &act_connmark_ops);
210	}	210	}
211		211
212	static void __net_exit connmark_exit_net(struct net *net)	212	static void __net_exit connmark_exit_net(struct net *net)

net/sched/act_csum.c+1−1

@@ -626,7 +626,7 @@ static __net_init int csum_init_net(struct net *net) · 625 unmodified lines
626	{	626	{
627	struct tc_action_net *tn = net_generic(net, csum_net_id);	627	struct tc_action_net *tn = net_generic(net, csum_net_id);
628		628
629	return tc_action_net_init(tn, &act_csum_ops, net);	629	return tc_action_net_init(tn, &act_csum_ops);
630	}	630	}
631		631
632	static void __net_exit csum_exit_net(struct net *net)	632	static void __net_exit csum_exit_net(struct net *net)

net/sched/act_gact.c+1−1

@@ -232,7 +232,7 @@ static __net_init int gact_init_net(struct net *net) · 231 unmodified lines
232	{	232	{
233	struct tc_action_net *tn = net_generic(net, gact_net_id);	233	struct tc_action_net *tn = net_generic(net, gact_net_id);
234		234
235	return tc_action_net_init(tn, &act_gact_ops, net);	235	return tc_action_net_init(tn, &act_gact_ops);
236	}	236	}
237		237
238	static void __net_exit gact_exit_net(struct net *net)	238	static void __net_exit gact_exit_net(struct net *net)

net/sched/act_ife.c+1−1

@@ -855,7 +855,7 @@ static __net_init int ife_init_net(struct net *net) · 854 unmodified lines
855	{	855	{
856	struct tc_action_net *tn = net_generic(net, ife_net_id);	856	struct tc_action_net *tn = net_generic(net, ife_net_id);
857		857
858	return tc_action_net_init(tn, &act_ife_ops, net);	858	return tc_action_net_init(tn, &act_ife_ops);
859	}	859	}
860		860
861	static void __net_exit ife_exit_net(struct net *net)	861	static void __net_exit ife_exit_net(struct net *net)

net/sched/act_ipt.c+2−2

@@ -334,7 +334,7 @@ static __net_init int ipt_init_net(struct net *net) · 333 unmodified lines
334	{	334	{
335	struct tc_action_net *tn = net_generic(net, ipt_net_id);	335	struct tc_action_net *tn = net_generic(net, ipt_net_id);
336		336
337	return tc_action_net_init(tn, &act_ipt_ops, net);	337	return tc_action_net_init(tn, &act_ipt_ops);
338	}	338	}
339		339
340	static void __net_exit ipt_exit_net(struct net *net)	340	static void __net_exit ipt_exit_net(struct net *net)
@@ -384,7 +384,7 @@ static __net_init int xt_init_net(struct net *net) · 43 unmodified lines
384	{	384	{
385	struct tc_action_net *tn = net_generic(net, xt_net_id);	385	struct tc_action_net *tn = net_generic(net, xt_net_id);
386		386
387	return tc_action_net_init(tn, &act_xt_ops, net);	387	return tc_action_net_init(tn, &act_xt_ops);
388	}	388	}
389		389
390	static void __net_exit xt_exit_net(struct net *net)	390	static void __net_exit xt_exit_net(struct net *net)

net/sched/act_mirred.c+1−1

@@ -340,7 +340,7 @@ static __net_init int mirred_init_net(struct net *net) · 339 unmodified lines
340	{	340	{
341	struct tc_action_net *tn = net_generic(net, mirred_net_id);	341	struct tc_action_net *tn = net_generic(net, mirred_net_id);
342		342
343	return tc_action_net_init(tn, &act_mirred_ops, net);	343	return tc_action_net_init(tn, &act_mirred_ops);
344	}	344	}
345		345
346	static void __net_exit mirred_exit_net(struct net *net)	346	static void __net_exit mirred_exit_net(struct net *net)

net/sched/act_nat.c+1−1

@@ -307,7 +307,7 @@ static __net_init int nat_init_net(struct net *net) · 306 unmodified lines
307	{	307	{
308	struct tc_action_net *tn = net_generic(net, nat_net_id);	308	struct tc_action_net *tn = net_generic(net, nat_net_id);
309		309
310	return tc_action_net_init(tn, &act_nat_ops, net);	310	return tc_action_net_init(tn, &act_nat_ops);
311	}	311	}
312		312
313	static void __net_exit nat_exit_net(struct net *net)	313	static void __net_exit nat_exit_net(struct net *net)

net/sched/act_pedit.c+1−1

@@ -450,7 +450,7 @@ static __net_init int pedit_init_net(struct net *net) · 449 unmodified lines
450	{	450	{
451	struct tc_action_net *tn = net_generic(net, pedit_net_id);	451	struct tc_action_net *tn = net_generic(net, pedit_net_id);
452		452
453	return tc_action_net_init(tn, &act_pedit_ops, net);	453	return tc_action_net_init(tn, &act_pedit_ops);
454	}	454	}
455		455
456	static void __net_exit pedit_exit_net(struct net *net)	456	static void __net_exit pedit_exit_net(struct net *net)

net/sched/act_police.c+1−1

@@ -331,7 +331,7 @@ static __net_init int police_init_net(struct net *net) · 330 unmodified lines
331	{	331	{
332	struct tc_action_net *tn = net_generic(net, police_net_id);	332	struct tc_action_net *tn = net_generic(net, police_net_id);
333		333
334	return tc_action_net_init(tn, &act_police_ops, net);	334	return tc_action_net_init(tn, &act_police_ops);
335	}	335	}
336		336
337	static void __net_exit police_exit_net(struct net *net)	337	static void __net_exit police_exit_net(struct net *net)

net/sched/act_sample.c+1−1

@@ -240,7 +240,7 @@ static __net_init int sample_init_net(struct net *net) · 239 unmodified lines
240	{	240	{
241	struct tc_action_net *tn = net_generic(net, sample_net_id);	241	struct tc_action_net *tn = net_generic(net, sample_net_id);
242		242
243	return tc_action_net_init(tn, &act_sample_ops, net);	243	return tc_action_net_init(tn, &act_sample_ops);
244	}	244	}
245		245
246	static void __net_exit sample_exit_net(struct net *net)	246	static void __net_exit sample_exit_net(struct net *net)

net/sched/act_simple.c+1−1

@@ -201,7 +201,7 @@ static __net_init int simp_init_net(struct net *net) · 200 unmodified lines
201	{	201	{
202	struct tc_action_net *tn = net_generic(net, simp_net_id);	202	struct tc_action_net *tn = net_generic(net, simp_net_id);
203		203
204	return tc_action_net_init(tn, &act_simp_ops, net);	204	return tc_action_net_init(tn, &act_simp_ops);
205	}	205	}
206		206
207	static void __net_exit simp_exit_net(struct net *net)	207	static void __net_exit simp_exit_net(struct net *net)

net/sched/act_skbedit.c+1−1

@@ -238,7 +238,7 @@ static __net_init int skbedit_init_net(struct net *net) · 237 unmodified lines
238	{	238	{
239	struct tc_action_net *tn = net_generic(net, skbedit_net_id);	239	struct tc_action_net *tn = net_generic(net, skbedit_net_id);
240		240
241	return tc_action_net_init(tn, &act_skbedit_ops, net);	241	return tc_action_net_init(tn, &act_skbedit_ops);
242	}	242	}
243		243
244	static void __net_exit skbedit_exit_net(struct net *net)	244	static void __net_exit skbedit_exit_net(struct net *net)

net/sched/act_skbmod.c+1−1

@@ -263,7 +263,7 @@ static __net_init int skbmod_init_net(struct net *net) · 262 unmodified lines
263	{	263	{
264	struct tc_action_net *tn = net_generic(net, skbmod_net_id);	264	struct tc_action_net *tn = net_generic(net, skbmod_net_id);
265		265
266	return tc_action_net_init(tn, &act_skbmod_ops, net);	266	return tc_action_net_init(tn, &act_skbmod_ops);
267	}	267	}
268		268
269	static void __net_exit skbmod_exit_net(struct net *net)	269	static void __net_exit skbmod_exit_net(struct net *net)

net/sched/act_tunnel_key.c+1−1

@@ -322,7 +322,7 @@ static __net_init int tunnel_key_init_net(struct net *net) · 321 unmodified lines
322	{	322	{
323	struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);	323	struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
324		324
325	return tc_action_net_init(tn, &act_tunnel_key_ops, net);	325	return tc_action_net_init(tn, &act_tunnel_key_ops);
326	}	326	}
327		327
328	static void __net_exit tunnel_key_exit_net(struct net *net)	328	static void __net_exit tunnel_key_exit_net(struct net *net)

net/sched/act_vlan.c+1−1

@@ -269,7 +269,7 @@ static __net_init int vlan_init_net(struct net *net) · 268 unmodified lines
269	{	269	{
270	struct tc_action_net *tn = net_generic(net, vlan_net_id);	270	struct tc_action_net *tn = net_generic(net, vlan_net_id);
271		271
272	return tc_action_net_init(tn, &act_vlan_ops, net);	272	return tc_action_net_init(tn, &act_vlan_ops);
273	}	273	}
274		274
275	static void __net_exit vlan_exit_net(struct net *net)	275	static void __net_exit vlan_exit_net(struct net *net)

net/sched/cls_api.c+1−0

@@ -1110,6 +1110,7 @@ int tcf_exts_validate(struct net net, struct tcf_proto tp, struct nlattr **tb, · 1109 unmodified lines
1110	exts->actions[i++] = act;	1110	exts->actions[i++] = act;
1111	exts->nr_actions = i;	1111	exts->nr_actions = i;
1112	}	1112	}
		1113	exts->net = net;
1113	}	1114	}
1114	#else	1115	#else
1115	if ((exts->action && tb[exts->action]) \|\|	1116	if ((exts->action && tb[exts->action]) \|\|

net/sched/cls_basic.c+15−5

 	return 0;
 }
+static void __basic_delete_filter(struct basic_filter *f)
+{
+	tcf_exts_destroy(&f->exts);
+	tcf_em_tree_destroy(&f->ematches);
+	tcf_exts_put_net(&f->exts);
+	kfree(f);
+}
 static void basic_delete_filter_work(struct work_struct *work)
 {
 	struct basic_filter *f = container_of(work, struct basic_filter, work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->exts);
+	__basic_delete_filter(f);
-	tcf_em_tree_destroy(&f->ematches);
 	rtnl_unlock();
-	kfree(f);
 }
 static void basic_delete_filter(struct rcu_head *head)
 		list_del_rcu(&f->link);
 		tcf_unbind_filter(tp, &f->res);
 		idr_remove_ext(&head->handle_idr, f->handle);
-		call_rcu(&f->rcu, basic_delete_filter);
+		if (tcf_exts_get_net(&f->exts))
+			call_rcu(&f->rcu, basic_delete_filter);
+		else
+			__basic_delete_filter(f);
 	}
 	idr_destroy(&head->handle_idr);
 	kfree_rcu(head, rcu);
 	list_del_rcu(&f->link);
 	tcf_unbind_filter(tp, &f->res);
 	idr_remove_ext(&head->handle_idr, f->handle);
+	tcf_exts_get_net(&f->exts);
 	call_rcu(&f->rcu, basic_delete_filter);
 	*last = list_empty(&head->flist);
 	return 0;
 		idr_replace_ext(&head->handle_idr, fnew, fnew->handle);
 		list_replace_rcu(&fold->link, &fnew->link);
 		tcf_unbind_filter(tp, &fold->res);
+		tcf_exts_get_net(&fold->exts);
 		call_rcu(&fold->rcu, basic_delete_filter);
 	} else {
 		list_add_rcu(&fnew->link, &head->flist);

net/sched/cls_bpf.c+6−1

 static void __cls_bpf_delete_prog(struct cls_bpf_prog *prog)
 {
 	tcf_exts_destroy(&prog->exts);
+	tcf_exts_put_net(&prog->exts);
 	if (cls_bpf_is_ebpf(prog))
 		bpf_prog_put(prog->filter);
 	cls_bpf_stop_offload(tp, prog);
 	list_del_rcu(&prog->link);
 	tcf_unbind_filter(tp, &prog->res);
-	call_rcu(&prog->rcu, cls_bpf_delete_prog_rcu);
+	if (tcf_exts_get_net(&prog->exts))
+		call_rcu(&prog->rcu, cls_bpf_delete_prog_rcu);
+	else
+		__cls_bpf_delete_prog(prog);
 }
 static int cls_bpf_delete(struct tcf_proto *tp, void *arg, bool *last)
 		idr_replace_ext(&head->handle_idr, prog, handle);
 		list_replace_rcu(&oldprog->link, &prog->link);
 		tcf_unbind_filter(tp, &oldprog->res);
+		tcf_exts_get_net(&oldprog->exts);
 		call_rcu(&oldprog->rcu, cls_bpf_delete_prog_rcu);
 	} else {
 		list_add_rcu(&prog->link, &head->plist);

net/sched/cls_cgroup.c+18−6

 	[TCA_CGROUP_EMATCHES]	= { .type = NLA_NESTED },
 };
+static void __cls_cgroup_destroy(struct cls_cgroup_head *head)
+{
+	tcf_exts_destroy(&head->exts);
+	tcf_em_tree_destroy(&head->ematches);
+	tcf_exts_put_net(&head->exts);
+	kfree(head);
+}
 static void cls_cgroup_destroy_work(struct work_struct *work)
 {
 	struct cls_cgroup_head *head = container_of(work,
 						    struct cls_cgroup_head,
 						    work);
 	rtnl_lock();
-	tcf_exts_destroy(&head->exts);
+	__cls_cgroup_destroy(head);
-	tcf_em_tree_destroy(&head->ematches);
-	kfree(head);
 	rtnl_unlock();
 }
 		goto errout;
 	rcu_assign_pointer(tp->root, new);
-	if (head)
+	if (head) {
+		tcf_exts_get_net(&head->exts);
 		call_rcu(&head->rcu, cls_cgroup_destroy_rcu);
+	}
 	return 0;
 errout:
 	tcf_exts_destroy(&new->exts);
 	struct cls_cgroup_head *head = rtnl_dereference(tp->root);
 	/* Head can still be NULL due to cls_cgroup_init(). */
-	if (head)
+	if (head) {
-		call_rcu(&head->rcu, cls_cgroup_destroy_rcu);
+		if (tcf_exts_get_net(&head->exts))
+			call_rcu(&head->rcu, cls_cgroup_destroy_rcu);
+		else
+			__cls_cgroup_destroy(head);
+	}
 }
 static int cls_cgroup_delete(struct tcf_proto *tp, void *arg, bool *last)

net/sched/cls_flow.c+18−6

 	[TCA_FLOW_PERTURB]	= { .type = NLA_U32 },
 };
-static void flow_destroy_filter_work(struct work_struct *work)
+static void __flow_destroy_filter(struct flow_filter *f)
 {
-	struct flow_filter *f = container_of(work, struct flow_filter, work);
-	rtnl_lock();
 	del_timer_sync(&f->perturb_timer);
 	tcf_exts_destroy(&f->exts);
 	tcf_em_tree_destroy(&f->ematches);
+	tcf_exts_put_net(&f->exts);
 	kfree(f);
+}
+static void flow_destroy_filter_work(struct work_struct *work)
+{
+	struct flow_filter *f = container_of(work, struct flow_filter, work);
+	rtnl_lock();
+	__flow_destroy_filter(f);
 	rtnl_unlock();
 }
 	*arg = fnew;
-	if (fold)
+	if (fold) {
+		tcf_exts_get_net(&fold->exts);
 		call_rcu(&fold->rcu, flow_destroy_filter);
+	}
 	return 0;
 err2:
 	struct flow_filter *f = arg;
 	list_del_rcu(&f->list);
+	tcf_exts_get_net(&f->exts);
 	call_rcu(&f->rcu, flow_destroy_filter);
 	*last = list_empty(&head->filters);
 	return 0;
 	list_for_each_entry_safe(f, next, &head->filters, list) {
 		list_del_rcu(&f->list);
-		call_rcu(&f->rcu, flow_destroy_filter);
+		if (tcf_exts_get_net(&f->exts))
+			call_rcu(&f->rcu, flow_destroy_filter);
+		else
+			__flow_destroy_filter(f);
 	}
 	kfree_rcu(head, rcu);
 }

net/sched/cls_flower.c+13−3

 	return 0;
 }
+static void __fl_destroy_filter(struct cls_fl_filter *f)
+{
+	tcf_exts_destroy(&f->exts);
+	tcf_exts_put_net(&f->exts);
+	kfree(f);
+}
 static void fl_destroy_filter_work(struct work_struct *work)
 {
 	struct cls_fl_filter *f = container_of(work, struct cls_fl_filter, work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->exts);
+	__fl_destroy_filter(f);
-	kfree(f);
 	rtnl_unlock();
 }
 	if (!tc_skip_hw(f->flags))
 		fl_hw_destroy_filter(tp, f);
 	tcf_unbind_filter(tp, &f->res);
-	call_rcu(&f->rcu, fl_destroy_filter);
+	if (tcf_exts_get_net(&f->exts))
+		call_rcu(&f->rcu, fl_destroy_filter);
+	else
+		__fl_destroy_filter(f);
 }
 static void fl_destroy_sleepable(struct work_struct *work)
 		idr_replace_ext(&head->handle_idr, fnew, fnew->handle);
 		list_replace_rcu(&fold->list, &fnew->list);
 		tcf_unbind_filter(tp, &fold->res);
+		tcf_exts_get_net(&fold->exts);
 		call_rcu(&fold->rcu, fl_destroy_filter);
 	} else {
 		list_add_tail_rcu(&fnew->list, &head->filters);

net/sched/cls_fw.c+14−3

 	return 0;
 }
+static void __fw_delete_filter(struct fw_filter *f)
+{
+	tcf_exts_destroy(&f->exts);
+	tcf_exts_put_net(&f->exts);
+	kfree(f);
+}
 static void fw_delete_filter_work(struct work_struct *work)
 {
 	struct fw_filter *f = container_of(work, struct fw_filter, work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->exts);
+	__fw_delete_filter(f);
-	kfree(f);
 	rtnl_unlock();
 }
 			RCU_INIT_POINTER(head->ht[h],
 					 rtnl_dereference(f->next));
 			tcf_unbind_filter(tp, &f->res);
-			call_rcu(&f->rcu, fw_delete_filter);
+			if (tcf_exts_get_net(&f->exts))
+				call_rcu(&f->rcu, fw_delete_filter);
+			else
+				__fw_delete_filter(f);
 		}
 	}
 	kfree_rcu(head, rcu);
 		if (pfp == f) {
 			RCU_INIT_POINTER(*fp, rtnl_dereference(f->next));
 			tcf_unbind_filter(tp, &f->res);
+			tcf_exts_get_net(&f->exts);
 			call_rcu(&f->rcu, fw_delete_filter);
 			ret = 0;
 			break;
 		RCU_INIT_POINTER(fnew->next, rtnl_dereference(pfp->next));
 		rcu_assign_pointer(*fp, fnew);
 		tcf_unbind_filter(tp, &f->res);
+		tcf_exts_get_net(&f->exts);
 		call_rcu(&f->rcu, fw_delete_filter);
 		*arg = fnew;

net/sched/cls_matchall.c+12−3

 	return 0;
 }
+static void __mall_destroy(struct cls_mall_head *head)
+{
+	tcf_exts_destroy(&head->exts);
+	tcf_exts_put_net(&head->exts);
+	kfree(head);
+}
 static void mall_destroy_work(struct work_struct *work)
 {
 	struct cls_mall_head *head = container_of(work, struct cls_mall_head,
 						  work);
 	rtnl_lock();
-	tcf_exts_destroy(&head->exts);
+	__mall_destroy(head);
-	kfree(head);
 	rtnl_unlock();
 }
 	if (!tc_skip_hw(head->flags))
 		mall_destroy_hw_filter(tp, head, (unsigned long) head);
-	call_rcu(&head->rcu, mall_destroy_rcu);
+	if (tcf_exts_get_net(&head->exts))
+		call_rcu(&head->rcu, mall_destroy_rcu);
+	else
+		__mall_destroy(head);
 }
 static void *mall_get(struct tcf_proto *tp, u32 handle)

net/sched/cls_route.c+14−3

 	return 0;
 }
+static void __route4_delete_filter(struct route4_filter *f)
+{
+	tcf_exts_destroy(&f->exts);
+	tcf_exts_put_net(&f->exts);
+	kfree(f);
+}
 static void route4_delete_filter_work(struct work_struct *work)
 {
 	struct route4_filter *f = container_of(work, struct route4_filter, work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->exts);
+	__route4_delete_filter(f);
-	kfree(f);
 	rtnl_unlock();
 }
 					next = rtnl_dereference(f->next);
 					RCU_INIT_POINTER(b->ht[h2], next);
 					tcf_unbind_filter(tp, &f->res);
-					call_rcu(&f->rcu, route4_delete_filter);
+					if (tcf_exts_get_net(&f->exts))
+						call_rcu(&f->rcu, route4_delete_filter);
+					else
+						__route4_delete_filter(f);
 				}
 			}
 			RCU_INIT_POINTER(head->table[h1], NULL);
 			/* Delete it */
 			tcf_unbind_filter(tp, &f->res);
+			tcf_exts_get_net(&f->exts);
 			call_rcu(&f->rcu, route4_delete_filter);
 			/* Strip RTNL protected tree */
 	*arg = f;
 	if (fold) {
 		tcf_unbind_filter(tp, &fold->res);
+		tcf_exts_get_net(&fold->exts);
 		call_rcu(&fold->rcu, route4_delete_filter);
 	}
 	return 0;

net/sched/cls_rsvp.h+12−3

 	return -ENOBUFS;
 }
+static void __rsvp_delete_filter(struct rsvp_filter *f)
+{
+	tcf_exts_destroy(&f->exts);
+	tcf_exts_put_net(&f->exts);
+	kfree(f);
+}
 static void rsvp_delete_filter_work(struct work_struct *work)
 {
 	struct rsvp_filter *f = container_of(work, struct rsvp_filter, work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->exts);
+	__rsvp_delete_filter(f);
-	kfree(f);
 	rtnl_unlock();
 }
 	 * grace period, since converted-to-rcu actions are relying on that
 	 * in cleanup() callback
 	 */
-	call_rcu(&f->rcu, rsvp_delete_filter_rcu);
+	if (tcf_exts_get_net(&f->exts))
+		call_rcu(&f->rcu, rsvp_delete_filter_rcu);
+	else
+		__rsvp_delete_filter(f);
 }
 static void rsvp_destroy(struct tcf_proto *tp)

net/sched/cls_tcindex.c+26−7

 	return 0;
 }
+static void __tcindex_destroy_rexts(struct tcindex_filter_result *r)
+{
+	tcf_exts_destroy(&r->exts);
+	tcf_exts_put_net(&r->exts);
+}
 static void tcindex_destroy_rexts_work(struct work_struct *work)
 {
 	struct tcindex_filter_result *r;
 	r = container_of(work, struct tcindex_filter_result, work);
 	rtnl_lock();
-	tcf_exts_destroy(&r->exts);
+	__tcindex_destroy_rexts(r);
 	rtnl_unlock();
 }
 	tcf_queue_work(&r->work);
 }
+static void __tcindex_destroy_fexts(struct tcindex_filter *f)
+{
+	tcf_exts_destroy(&f->result.exts);
+	tcf_exts_put_net(&f->result.exts);
+	kfree(f);
+}
 static void tcindex_destroy_fexts_work(struct work_struct *work)
 {
 	struct tcindex_filter *f = container_of(work, struct tcindex_filter,
 						work);
 	rtnl_lock();
-	tcf_exts_destroy(&f->result.exts);
+	__tcindex_destroy_fexts(f);
-	kfree(f);
 	rtnl_unlock();
 }
 	 * grace period, since converted-to-rcu actions are relying on that
 	 * in cleanup() callback
 	 */
-	if (f)
+	if (f) {
-		call_rcu(&f->rcu, tcindex_destroy_fexts);
+		if (tcf_exts_get_net(&f->result.exts))
-	else
+			call_rcu(&f->rcu, tcindex_destroy_fexts);
-		call_rcu(&r->rcu, tcindex_destroy_rexts);
+		else
+			__tcindex_destroy_fexts(f);
+	} else {
+		if (tcf_exts_get_net(&r->exts))
+			call_rcu(&r->rcu, tcindex_destroy_rexts);
+		else
+			__tcindex_destroy_rexts(r);
+	}
 	*last = false;
 	return 0;

net/sched/cls_u32.c+7−1

 			   bool free_pf)
 {
 	tcf_exts_destroy(&n->exts);
+	tcf_exts_put_net(&n->exts);
 	if (n->ht_down)
 		n->ht_down->refcnt--;
 #ifdef CONFIG_CLS_U32_PERF
 				RCU_INIT_POINTER(*kp, key->next);
 				tcf_unbind_filter(tp, &key->res);
+				tcf_exts_get_net(&key->exts);
 				call_rcu(&key->rcu, u32_delete_key_freepf_rcu);
 				return 0;
 			}
 			tcf_unbind_filter(tp, &n->res);
 			u32_remove_hw_knode(tp, n->handle);
 			idr_remove_ext(&ht->handle_idr, n->handle);
-			call_rcu(&n->rcu, u32_delete_key_freepf_rcu);
+			if (tcf_exts_get_net(&n->exts))
+				call_rcu(&n->rcu, u32_delete_key_freepf_rcu);
+			else
+				u32_destroy_key(n->tp, n, true);
 		}
 	}
 }
 		u32_replace_knode(tp, tp_c, new);
 		tcf_unbind_filter(tp, &n->res);
+		tcf_exts_get_net(&n->exts);
 		call_rcu(&n->rcu, u32_delete_key_rcu);
 		return 0;
 	}

net/xfrm/xfrm_input.c+2−2

 		goto lock;
 	}
-	daddr = (xfrm_address_t *)(skb_network_header(skb) +
-				   XFRM_SPI_SKB_CB(skb)->daddroff);
 	family = XFRM_SPI_SKB_CB(skb)->family;
 	/* if tunnel is present override skb->mark value with tunnel i_key */
 		goto drop;
 	}
+	daddr = (xfrm_address_t *)(skb_network_header(skb) +
+				   XFRM_SPI_SKB_CB(skb)->daddroff);
 	do {
 		if (skb->sp->len == XFRM_MAX_DEPTH) {
 			XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);

net/xfrm/xfrm_policy.c+35−36

 	struct net *net = xp_net(policy);
 	int nx;
 	int i, error;
-	xfrm_address_t *daddr = xfrm_flowi_daddr(fl, family);
-	xfrm_address_t *saddr = xfrm_flowi_saddr(fl, family);
 	xfrm_address_t tmp;
 	for (nx = 0, i = 0; i < policy->xfrm_nr; i++) {
 		struct xfrm_state *x;
-		xfrm_address_t *remote = daddr;
+		xfrm_address_t *local;
-		xfrm_address_t *local  = saddr;
+		xfrm_address_t *remote;
 		struct xfrm_tmpl *tmpl = &policy->xfrm_vec[i];
-		if (tmpl->mode == XFRM_MODE_TUNNEL ||
+		remote = &tmpl->id.daddr;
-		    tmpl->mode == XFRM_MODE_BEET) {
+		local = &tmpl->saddr;
-			remote = &tmpl->id.daddr;
+		if (xfrm_addr_any(local, tmpl->encap_family)) {
-			local = &tmpl->saddr;
+			error = xfrm_get_saddr(net, fl->flowi_oif,
-			if (xfrm_addr_any(local, tmpl->encap_family)) {
+					       &tmp, remote,
-				error = xfrm_get_saddr(net, fl->flowi_oif,
+					       tmpl->encap_family, 0);
-						       &tmp, remote,
+			if (error)
-						       tmpl->encap_family, 0);
+				goto fail;
-				if (error)
+			local = &tmp;
-					goto fail;
-				local = &tmp;
-			}
 		}
 		x = xfrm_state_find(remote, local, fl, tmpl, policy, &error, family);
 		if (x && x->km.state == XFRM_STATE_VALID) {
 			xfrm[nx++] = x;
-			daddr = remote;
-			saddr = local;
 			continue;
 		}
 		if (x) {
 	put_online_cpus();
 }
-static bool xfrm_pol_dead(struct xfrm_dst *xdst)
+static bool xfrm_xdst_can_reuse(struct xfrm_dst *xdst,
+				struct xfrm_state * const xfrm[],
+				int num)
 {
-	unsigned int num_pols = xdst->num_pols;
+	const struct dst_entry *dst = &xdst->u.dst;
-	unsigned int pol_dead = 0, i;
+	int i;
-	for (i = 0; i < num_pols; i++)
+	if (xdst->num_xfrms != num)
-		pol_dead |= xdst->pols[i]->walk.dead;
+		return false;
-	/* Mark DST_OBSOLETE_DEAD to fail the next xfrm_dst_check() */
+	for (i = 0; i < num; i++) {
-	if (pol_dead)
+		if (!dst || dst->xfrm != xfrm[i])
-		xdst->u.dst.obsolete = DST_OBSOLETE_DEAD;
+			return false;
+		dst = dst->child;
+	}
-	return pol_dead;
+	return xfrm_bundle_ok(xdst);
 }
 static struct xfrm_dst *
 	struct dst_entry *dst;
 	int err;
+	/* Try to instantiate a bundle */
+	err = xfrm_tmpl_resolve(pols, num_pols, fl, xfrm, family);
+	if (err <= 0) {
+		if (err != 0 && err != -EAGAIN)
+			XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
+		return ERR_PTR(err);
+	}
 	xdst = this_cpu_read(xfrm_last_dst);
 	if (xdst &&
 	    xdst->u.dst.dev == dst_orig->dev &&
 	    xdst->num_pols == num_pols &&
-	    !xfrm_pol_dead(xdst) &&
 	    memcmp(xdst->pols, pols,
 		   sizeof(struct xfrm_policy *) * num_pols) == 0 &&
-	    xfrm_bundle_ok(xdst)) {
+	    xfrm_xdst_can_reuse(xdst, xfrm, err)) {
 		dst_hold(&xdst->u.dst);
+		while (err > 0)
+			xfrm_state_put(xfrm[--err]);
 		return xdst;
 	}
 	old = xdst;
-	/* Try to instantiate a bundle */
-	err = xfrm_tmpl_resolve(pols, num_pols, fl, xfrm, family);
-	if (err <= 0) {
-		if (err != 0 && err != -EAGAIN)
-			XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
-		return ERR_PTR(err);
-	}
 	dst = xfrm_bundle_create(pols[0], xfrm, err, fl, dst_orig);
 	if (IS_ERR(dst)) {

scripts/leaking_addresses.pl+305−0

@@ -0,0 +1,305 @@
	1	#!/usr/bin/env perl
	2	#
	3	# (c) 2017 Tobin C. Harding <me@tobin.cc>
	4	# Licensed under the terms of the GNU GPL License version 2
	5	#
	6	# leaking_addresses.pl: Scan 64 bit kernel for potential leaking addresses.
	7	# - Scans dmesg output.
	8	# - Walks directory tree and parses each file (for each directory in @DIRS).
	9	#
	10	# You can configure the behaviour of the script;
	11	#
	12	# - By adding paths, for directories you do not want to walk;
	13	# absolute paths: @skip_walk_dirs_abs
	14	# directory names: @skip_walk_dirs_any
	15	#
	16	# - By adding paths, for files you do not want to parse;
	17	# absolute paths: @skip_parse_files_abs
	18	# file names: @skip_parse_files_any
	19	#
	20	# The use of @skip_xxx_xxx_any causes files to be skipped where ever they occur.
	21	# For example adding 'fd' to @skip_walk_dirs_any causes the fd/ directory to be
	22	# skipped for all PID sub-directories of /proc
	23	#
	24	# The same thing can be achieved by passing command line options to --dont-walk
	25	# and --dont-parse. If absolute paths are supplied to these options they are
	26	# appended to the @skip_xxx_xxx_abs arrays. If file names are supplied to these
	27	# options, they are appended to the @skip_xxx_xxx_any arrays.
	28	#
	29	# Use --debug to output path before parsing, this is useful to find files that
	30	# cause the script to choke.
	31	#
	32	# You may like to set kptr_restrict=2 before running script
	33	# (see Documentation/sysctl/kernel.txt).
	34
	35	use warnings;
	36	use strict;
	37	use POSIX;
	38	use File::Basename;
	39	use File::Spec;
	40	use Cwd 'abs_path';
	41	use Term::ANSIColor qw(:constants);
	42	use Getopt::Long qw(:config no_auto_abbrev);
	43
	44	my $P = $0;
	45	my $V = '0.01';
	46
	47	# Directories to scan.
	48	my @DIRS = ('/proc', '/sys');
	49
	50	# Command line options.
	51	my $help = 0;
	52	my $debug = 0;
	53	my @dont_walk = ();
	54	my @dont_parse = ();
	55
	56	# Do not parse these files (absolute path).
	57	my @skip_parse_files_abs = ('/proc/kmsg',
	58	'/proc/kcore',
	59	'/proc/fs/ext4/sdb1/mb_groups',
	60	'/proc/1/fd/3',
	61	'/sys/kernel/debug/tracing/trace_pipe',
	62	'/sys/kernel/security/apparmor/revision');
	63
	64	# Do not parse thes files under any subdirectory.
	65	my @skip_parse_files_any = ('0',
	66	'1',
	67	'2',
	68	'pagemap',
	69	'events',
	70	'access',
	71	'registers',
	72	'snapshot_raw',
	73	'trace_pipe_raw',
	74	'ptmx',
	75	'trace_pipe');
	76
	77	# Do not walk these directories (absolute path).
	78	my @skip_walk_dirs_abs = ();
	79
	80	# Do not walk these directories under any subdirectory.
	81	my @skip_walk_dirs_any = ('self',
	82	'thread-self',
	83	'cwd',
	84	'fd',
	85	'stderr',
	86	'stdin',
	87	'stdout');
	88
	89	sub help
	90	{
	91	my ($exitcode) = @_;
	92
	93	print << "EOM";
	94	Usage: $P [OPTIONS]
	95	Version: $V
	96
	97	Options:
	98
	99	--dont-walk=<dir> Don't walk tree starting at <dir>.
	100	--dont-parse=<file> Don't parse <file>.
	101	-d, --debug Display debugging output.
	102	-h, --help, --version Display this help and exit.
	103
	104	If an absolute path is passed to --dont_XXX then this path is skipped. If a
	105	single filename is passed then this file/directory will be skipped when
	106	appearing under any subdirectory.
	107
	108	Example:
	109
	110	# Just scan dmesg output.
	111	scripts/leaking_addresses.pl --dont_walk_abs /proc --dont_walk_abs /sys
	112
	113	Scans the running (64 bit) kernel for potential leaking addresses.
	114
	115	EOM
	116	exit($exitcode);
	117	}
	118
	119	GetOptions(
	120	'dont-walk=s' => \@dont_walk,
	121	'dont-parse=s' => \@dont_parse,
	122	'd\|debug' => \$debug,
	123	'h\|help' => \$help,
	124	'version' => \$help
	125	) or help(1);
	126
	127	help(0) if ($help);
	128
	129	push_to_global();
	130
	131	parse_dmesg();
	132	walk(@DIRS);
	133
	134	exit 0;
	135
	136	sub debug_arrays
	137	{
	138	print 'dirs_any: ' . join(", ", @skip_walk_dirs_any) . "\n";
	139	print 'dirs_abs: ' . join(", ", @skip_walk_dirs_abs) . "\n";
	140	print 'parse_any: ' . join(", ", @skip_parse_files_any) . "\n";
	141	print 'parse_abs: ' . join(", ", @skip_parse_files_abs) . "\n";
	142	}
	143
	144	sub dprint
	145	{
	146	printf(STDERR @_) if $debug;
	147	}
	148
	149	sub push_in_abs_any
	150	{
	151	my ($in, $abs, $any) = @_;
	152
	153	foreach my $path (@$in) {
	154	if (File::Spec->file_name_is_absolute($path)) {
	155	push @$abs, $path;
	156	} elsif (index($path,'/') == -1) {
	157	push @$any, $path;
	158	} else {
	159	print 'path error: ' . $path;
	160	}
	161	}
	162	}
	163
	164	# Push command line options to global arrays.
	165	sub push_to_global
	166	{
	167	push_in_abs_any(\@dont_walk, \@skip_walk_dirs_abs, \@skip_walk_dirs_any);
	168	push_in_abs_any(\@dont_parse, \@skip_parse_files_abs, \@skip_parse_files_any);
	169	}
	170
	171	sub is_false_positive
	172	{
	173	my ($match) = @_;
	174
	175	if ($match =~ '\b(0x)?(f\|F){16}\b' or
	176	$match =~ '\b(0x)?0{16}\b') {
	177	return 1;
	178	}
	179
	180	# vsyscall memory region, we should probably check against a range here.
	181	if ($match =~ '\bf{10}600000\b' or
	182	$match =~ '\bf{10}601000\b') {
	183	return 1;
	184	}
	185
	186	return 0;
	187	}
	188
	189	# True if argument potentially contains a kernel address.
	190	sub may_leak_address
	191	{
	192	my ($line) = @_;
	193	my $address = '\b(0x)?ffff[[:xdigit:]]{12}\b';
	194
	195	# Signal masks.
	196	if ($line =~ '^SigBlk:' or
	197	$line =~ '^SigCgt:') {
	198	return 0;
	199	}
	200
	201	if ($line =~ '\bKEY=[[:xdigit:]]{14} [[:xdigit:]]{16} [[:xdigit:]]{16}\b' or
	202	$line =~ '\b[[:xdigit:]]{14} [[:xdigit:]]{16} [[:xdigit:]]{16}\b') {
	203	return 0;
	204	}
	205
	206	while (/($address)/g) {
	207	if (!is_false_positive($1)) {
	208	return 1;
	209	}
	210	}
	211
	212	return 0;
	213	}
	214
	215	sub parse_dmesg
	216	{
	217	open my $cmd, '-\|', 'dmesg';
	218	while (<$cmd>) {
	219	if (may_leak_address($_)) {
	220	print 'dmesg: ' . $_;
	221	}
	222	}
	223	close $cmd;
	224	}
	225
	226	# True if we should skip this path.
	227	sub skip
	228	{
	229	my ($path, $paths_abs, $paths_any) = @_;
	230
	231	foreach (@$paths_abs) {
	232	return 1 if (/^$path$/);
	233	}
	234
	235	my($filename, $dirs, $suffix) = fileparse($path);
	236	foreach (@$paths_any) {
	237	return 1 if (/^$filename$/);
	238	}
	239
	240	return 0;
	241	}
	242
	243	sub skip_parse
	244	{
	245	my ($path) = @_;
	246	return skip($path, \@skip_parse_files_abs, \@skip_parse_files_any);
	247	}
	248
	249	sub parse_file
	250	{
	251	my ($file) = @_;
	252
	253	if (! -R $file) {
	254	return;
	255	}
	256
	257	if (skip_parse($file)) {
	258	dprint "skipping file: $file\n";
	259	return;
	260	}
	261	dprint "parsing: $file\n";
	262
	263	open my $fh, "<", $file or return;
	264	while ( <$fh> ) {
	265	if (may_leak_address($_)) {
	266	print $file . ': ' . $_;
	267	}
	268	}
	269	close $fh;
	270	}
	271
	272
	273	# True if we should skip walking this directory.
	274	sub skip_walk
	275	{
	276	my ($path) = @_;
	277	return skip($path, \@skip_walk_dirs_abs, \@skip_walk_dirs_any)
	278	}
	279
	280	# Recursively walk directory tree.
	281	sub walk
	282	{
	283	my @dirs = @_;
	284	my %seen;
	285
	286	while (my $pwd = shift @dirs) {
	287	next if (skip_walk($pwd));
	288	next if (!opendir(DIR, $pwd));
	289	my @files = readdir(DIR);
	290	closedir(DIR);
	291
	292	foreach my $file (@files) {
	293	next if ($file eq '.' or $file eq '..');
	294
	295	my $path = "$pwd/$file";
	296	next if (-l $path);
	297
	298	if (-d $path) {
	299	push @dirs, $path;
	300	} else {
	301	parse_file($path);
	302	}
	303	}
	304	}
	305	}

security/apparmor/ipc.c+2−2

@@ -128,7 +128,7 @@ static inline int map_signal_num(int sig) · 127 unmodified lines
128	return SIGUNKNOWN;	128	return SIGUNKNOWN;
129	else if (sig >= SIGRTMIN)	129	else if (sig >= SIGRTMIN)
130	return sig - SIGRTMIN + 128; /* rt sigs mapped to 128 */	130	return sig - SIGRTMIN + 128; /* rt sigs mapped to 128 */
131	else if (sig <= MAXMAPPED_SIG)	131	else if (sig < MAXMAPPED_SIG)
132	return sig_map[sig];	132	return sig_map[sig];
133	return SIGUNKNOWN;	133	return SIGUNKNOWN;
134	}	134	}
@@ -163,7 +163,7 @@ static void audit_signal_cb(struct audit_buffer ab, void va) · 28 unmodified lines
163	audit_signal_mask(ab, aad(sa)->denied);	163	audit_signal_mask(ab, aad(sa)->denied);
164	}	164	}
165	}	165	}
166	if (aad(sa)->signal <= MAXMAPPED_SIG)	166	if (aad(sa)->signal < MAXMAPPED_SIG)
167	audit_log_format(ab, " signal=%s", sig_names[aad(sa)->signal]);	167	audit_log_format(ab, " signal=%s", sig_names[aad(sa)->signal]);
168	else	168	else
169	audit_log_format(ab, " signal=rtmin+%d",	169	audit_log_format(ab, " signal=rtmin+%d",

sound/core/hrtimer.c+1−0

@@ -159,6 +159,7 @@ static int __init snd_hrtimer_init(void) · 158 unmodified lines
159	timer->hw = hrtimer_hw;	159	timer->hw = hrtimer_hw;
160	timer->hw.resolution = resolution;	160	timer->hw.resolution = resolution;
161	timer->hw.ticks = NANO_SEC / resolution;	161	timer->hw.ticks = NANO_SEC / resolution;
		162	timer->max_instances = 100; /* lower the limit */
162		163
163	err = snd_timer_global_register(timer);	164	err = snd_timer_global_register(timer);
164	if (err < 0) {	165	if (err < 0) {

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

 	if (!dp->timer->running)
 		len = snd_seq_oss_timer_start(dp->timer);
 	if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
-		if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
+		snd_seq_oss_readq_sysex(dp->readq, mdev->seq_device, ev);
-			snd_seq_oss_readq_puts(dp->readq, mdev->seq_device,
-					       ev->data.ext.ptr, ev->data.ext.len);
 	} else {
 		len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
 		if (len > 0)

sound/core/seq/oss/seq_oss_readq.c+29−0

@@ -117,6 +117,35 @@ snd_seq_oss_readq_puts(struct seq_oss_readq q, int dev, unsigned char data, in · 116 unmodified lines
117	return 0;	117	return 0;
118	}	118	}
119		119
		120	/*
		121	* put MIDI sysex bytes; the event buffer may be chained, thus it has
		122	* to be expanded via snd_seq_dump_var_event().
		123	*/
		124	struct readq_sysex_ctx {
		125	struct seq_oss_readq *readq;
		126	int dev;
		127	};
		128
		129	static int readq_dump_sysex(void ptr, void buf, int count)
		130	{
		131	struct readq_sysex_ctx *ctx = ptr;
		132
		133	return snd_seq_oss_readq_puts(ctx->readq, ctx->dev, buf, count);
		134	}
		135
		136	int snd_seq_oss_readq_sysex(struct seq_oss_readq *q, int dev,
		137	struct snd_seq_event *ev)
		138	{
		139	struct readq_sysex_ctx ctx = {
		140	.readq = q,
		141	.dev = dev
		142	};
		143
		144	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
		145	return 0;
		146	return snd_seq_dump_var_event(ev, readq_dump_sysex, &ctx);
		147	}
		148
120	/*	149	/*
121	* copy an event to input queue:	150	* copy an event to input queue:
122	* return zero if enqueued	151	* return zero if enqueued

sound/core/seq/oss/seq_oss_readq.h+2−0

 void snd_seq_oss_readq_clear(struct seq_oss_readq *readq);
 unsigned int snd_seq_oss_readq_poll(struct seq_oss_readq *readq, struct file *file, poll_table *wait);
 int snd_seq_oss_readq_puts(struct seq_oss_readq *readq, int dev, unsigned char *data, int len);
+int snd_seq_oss_readq_sysex(struct seq_oss_readq *q, int dev,
+			    struct snd_seq_event *ev);
 int snd_seq_oss_readq_put_event(struct seq_oss_readq *readq, union evrec *ev);
 int snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *readq, unsigned long curt, int seq_mode);
 int snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec);

sound/core/timer.c+54−13

  *
  * call this with register_mutex down.
  */
-static void snd_timer_check_slave(struct snd_timer_instance *slave)
+static int snd_timer_check_slave(struct snd_timer_instance *slave)
 {
 	struct snd_timer *timer;
 	struct snd_timer_instance *master;
 		list_for_each_entry(master, &timer->open_list_head, open_list) {
 			if (slave->slave_class == master->slave_class &&
 			    slave->slave_id == master->slave_id) {
+				if (master->timer->num_instances >=
+				    master->timer->max_instances)
+					return -EBUSY;
 				list_move_tail(&slave->open_list,
 					       &master->slave_list_head);
+				master->timer->num_instances++;
 				spin_lock_irq(&slave_active_lock);
 				slave->master = master;
 				slave->timer = master->timer;
 				spin_unlock_irq(&slave_active_lock);
-				return;
+				return 0;
 			}
 		}
 	}
+	return 0;
 }
 /*
  *
  * call this with register_mutex down.
  */
-static void snd_timer_check_master(struct snd_timer_instance *master)
+static int snd_timer_check_master(struct snd_timer_instance *master)
 {
 	struct snd_timer_instance *slave, *tmp;
 	list_for_each_entry_safe(slave, tmp, &snd_timer_slave_list, open_list) {
 		if (slave->slave_class == master->slave_class &&
 		    slave->slave_id == master->slave_id) {
+			if (master->timer->num_instances >=
+			    master->timer->max_instances)
+				return -EBUSY;
 			list_move_tail(&slave->open_list, &master->slave_list_head);
+			master->timer->num_instances++;
 			spin_lock_irq(&slave_active_lock);
 			spin_lock(&master->timer->lock);
 			slave->master = master;
 			spin_unlock_irq(&slave_active_lock);
 		}
 	}
+	return 0;
 }
+static int snd_timer_close_locked(struct snd_timer_instance *timeri);
 /*
  * open a timer instance
  * when opening a master, the slave id must be here given.
 {
 	struct snd_timer *timer;
 	struct snd_timer_instance *timeri = NULL;
+	int err;
 	if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) {
 		/* open a slave instance */
 		timeri->slave_id = tid->device;
 		timeri->flags |= SNDRV_TIMER_IFLG_SLAVE;
 		list_add_tail(&timeri->open_list, &snd_timer_slave_list);
-		snd_timer_check_slave(timeri);
+		err = snd_timer_check_slave(timeri);
+		if (err < 0) {
+			snd_timer_close_locked(timeri);
+			timeri = NULL;
+		}
 		mutex_unlock(&register_mutex);
 		*ti = timeri;
-		return 0;
+		return err;
 	}
 	/* open a master instance */
 			return -EBUSY;
 		}
 	}
+	if (timer->num_instances >= timer->max_instances) {
+		mutex_unlock(&register_mutex);
+		return -EBUSY;
+	}
 	timeri = snd_timer_instance_new(owner, timer);
 	if (!timeri) {
 		mutex_unlock(&register_mutex);
 	}
 	list_add_tail(&timeri->open_list, &timer->open_list_head);
-	snd_timer_check_master(timeri);
+	timer->num_instances++;
+	err = snd_timer_check_master(timeri);
+	if (err < 0) {
+		snd_timer_close_locked(timeri);
+		timeri = NULL;
+	}
 	mutex_unlock(&register_mutex);
 	*ti = timeri;
-	return 0;
+	return err;
 }
 EXPORT_SYMBOL(snd_timer_open);
 /*
  * close a timer instance
+ * call this with register_mutex down.
  */
-int snd_timer_close(struct snd_timer_instance *timeri)
+static int snd_timer_close_locked(struct snd_timer_instance *timeri)
 {
 	struct snd_timer *timer = NULL;
 	struct snd_timer_instance *slave, *tmp;
-	if (snd_BUG_ON(!timeri))
-		return -ENXIO;
-	mutex_lock(&register_mutex);
 	list_del(&timeri->open_list);
 	/* force to stop the timer */
 	timer = timeri->timer;
 	if (timer) {
+		timer->num_instances--;
 		/* wait, until the active callback is finished */
 		spin_lock_irq(&timer->lock);
 		while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
 		list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head,
 					 open_list) {
 			list_move_tail(&slave->open_list, &snd_timer_slave_list);
+			timer->num_instances--;
 			slave->master = NULL;
 			slave->timer = NULL;
 			list_del_init(&slave->ack_list);
 		module_put(timer->module);
 	}
-	mutex_unlock(&register_mutex);
 	return 0;
 }
+/*
+ * close a timer instance
+ */
+int snd_timer_close(struct snd_timer_instance *timeri)
+{
+	int err;
+	if (snd_BUG_ON(!timeri))
+		return -ENXIO;
+	mutex_lock(&register_mutex);
+	err = snd_timer_close_locked(timeri);
+	mutex_unlock(&register_mutex);
+	return err;
+}
 EXPORT_SYMBOL(snd_timer_close);
 unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
 	spin_lock_init(&timer->lock);
 	tasklet_init(&timer->task_queue, snd_timer_tasklet,
 		     (unsigned long)timer);
+	timer->max_instances = 1000; /* default limit per timer */
 	if (card != NULL) {
 		timer->module = card->module;
 		err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops);

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

 		{0x14, 0x90170110},
 		{0x1b, 0x90a70130},
 		{0x21, 0x03211020}),
+	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
+		{0x12, 0xb7a60130},
+		{0x13, 0xb8a61140},
+		{0x16, 0x90170110},
+		{0x21, 0x04211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
 		{0x12, 0x90a60130},
 		{0x14, 0x90170110},

sound/usb/quirks.c+1−0

@@ -1375,6 +1375,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, · 1374 unmodified lines
1375	case 0x199:	1375	case 0x199:
1376	return SNDRV_PCM_FMTBIT_DSD_U32_LE;	1376	return SNDRV_PCM_FMTBIT_DSD_U32_LE;
1377	case 0x19b:	1377	case 0x19b:
		1378	case 0x203:
1378	return SNDRV_PCM_FMTBIT_DSD_U32_BE;	1379	return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1379	default:	1380	default:
1380	break;	1381	break;

tools/arch/x86/include/asm/disabled-features.h+0−1

@@ -1,4 +1,3 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _ASM_X86_DISABLED_FEATURES_H	1	#ifndef _ASM_X86_DISABLED_FEATURES_H
3	#define _ASM_X86_DISABLED_FEATURES_H	2	#define _ASM_X86_DISABLED_FEATURES_H
4		3

tools/arch/x86/include/asm/required-features.h+0−1

@@ -1,4 +1,3 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _ASM_X86_REQUIRED_FEATURES_H	1	#ifndef _ASM_X86_REQUIRED_FEATURES_H
3	#define _ASM_X86_REQUIRED_FEATURES_H	2	#define _ASM_X86_REQUIRED_FEATURES_H
4		3

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

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef _UAPI_ASM_X86_UNISTD_H	2	#ifndef _UAPI_ASM_X86_UNISTD_H
2	#define _UAPI_ASM_X86_UNISTD_H	3	#define _UAPI_ASM_X86_UNISTD_H
3		4

tools/arch/x86/lib/memcpy_64.S+4−1

-/* SPDX-License-Identifier: GPL-2.0 */
 /* Copyright 2002 Andi Kleen */
 #include <linux/linkage.h>
 #include <asm/errno.h>
 #include <asm/cpufeatures.h>
 #include <asm/alternative-asm.h>
+#include <asm/export.h>
 /*
  * We build a jump to memcpy_orig by default which gets NOPped out on
 	ret
 ENDPROC(memcpy)
 ENDPROC(__memcpy)
+EXPORT_SYMBOL(memcpy)
+EXPORT_SYMBOL(__memcpy)
 /*
  * memcpy_erms() - enhanced fast string memcpy. This is faster and
 	xorq %rax, %rax
 	ret
 ENDPROC(memcpy_mcsafe_unrolled)
+EXPORT_SYMBOL_GPL(memcpy_mcsafe_unrolled)
 	.section .fixup, "ax"
 	/* Return -EFAULT for any failure */

tools/include/asm-generic/bitops/__fls.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	#ifndef _ASM_GENERIC_BITOPS___FLS_H_	2	#ifndef _ASM_GENERIC_BITOPS___FLS_H_
2	#define _ASM_GENERIC_BITOPS___FLS_H_	3	#define _ASM_GENERIC_BITOPS___FLS_H_
3		4

tools/include/asm-generic/bitops/arch_hweight.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	#ifndef _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_	2	#ifndef _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
2	#define _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_	3	#define _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
3		4

tools/include/asm-generic/bitops/const_hweight.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	#ifndef _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_	2	#ifndef _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
2	#define _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_	3	#define _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
3		4

tools/include/asm-generic/bitops/fls.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	#ifndef _ASM_GENERIC_BITOPS_FLS_H_	2	#ifndef _ASM_GENERIC_BITOPS_FLS_H_
2	#define _ASM_GENERIC_BITOPS_FLS_H_	3	#define _ASM_GENERIC_BITOPS_FLS_H_
3		4

tools/include/asm-generic/bitops/fls64.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	#ifndef _ASM_GENERIC_BITOPS_FLS64_H_	2	#ifndef _ASM_GENERIC_BITOPS_FLS64_H_
2	#define _ASM_GENERIC_BITOPS_FLS64_H_	3	#define _ASM_GENERIC_BITOPS_FLS64_H_
3		4

tools/include/asm/export.h+7−0

@@ -0,0 +1,7 @@
	1	#ifndef _TOOLS_ASM_EXPORT_H
	2	#define _TOOLS_ASM_EXPORT_H
	3
	4	#define EXPORT_SYMBOL(x)
	5	#define EXPORT_SYMBOL_GPL(x)
	6
	7	#endif /* _TOOLS_ASM_EXPORT_H */

tools/include/linux/hash.h+0−1

@@ -1,4 +1,3 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LINUX_HASH_H	1	#ifndef _LINUX_HASH_H
3	#define _LINUX_HASH_H	2	#define _LINUX_HASH_H
4	/* Fast hashing routine for ints, longs and pointers.	3	/* Fast hashing routine for ints, longs and pointers.

tools/include/uapi/asm-generic/ioctls.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef __ASM_GENERIC_IOCTLS_H	2	#ifndef __ASM_GENERIC_IOCTLS_H
2	#define __ASM_GENERIC_IOCTLS_H	3	#define __ASM_GENERIC_IOCTLS_H
3		4

tools/include/uapi/asm-generic/mman-common.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef __ASM_GENERIC_MMAN_COMMON_H	2	#ifndef __ASM_GENERIC_MMAN_COMMON_H
2	#define __ASM_GENERIC_MMAN_COMMON_H	3	#define __ASM_GENERIC_MMAN_COMMON_H
3		4

tools/include/uapi/asm-generic/mman.h+2−2

@@ -1,8 +1,8 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef __ASM_GENERIC_MMAN_H	2	#ifndef __ASM_GENERIC_MMAN_H
3	#define __ASM_GENERIC_MMAN_H	3	#define __ASM_GENERIC_MMAN_H
4		4
5	#include <uapi/asm-generic/mman-common.h>	5	#include <asm-generic/mman-common.h>
6		6
7	#define MAP_GROWSDOWN 0x0100 /* stack-like segment */	7	#define MAP_GROWSDOWN 0x0100 /* stack-like segment */
8	#define MAP_DENYWRITE 0x0800 /* ETXTBSY */	8	#define MAP_DENYWRITE 0x0800 /* ETXTBSY */

tools/include/uapi/linux/bpf.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com	2	/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
2	*	3	*
3	* This program is free software; you can redistribute it and/or	4	* This program is free software; you can redistribute it and/or

tools/include/uapi/linux/bpf_common.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef _UAPI__LINUX_BPF_COMMON_H__	2	#ifndef _UAPI__LINUX_BPF_COMMON_H__
3	#define _UAPI__LINUX_BPF_COMMON_H__	3	#define _UAPI__LINUX_BPF_COMMON_H__
4		4

tools/include/uapi/linux/fcntl.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef _UAPI_LINUX_FCNTL_H	2	#ifndef _UAPI_LINUX_FCNTL_H
3	#define _UAPI_LINUX_FCNTL_H	3	#define _UAPI_LINUX_FCNTL_H
4		4

tools/include/uapi/linux/hw_breakpoint.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef _UAPI_LINUX_HW_BREAKPOINT_H	2	#ifndef _UAPI_LINUX_HW_BREAKPOINT_H
3	#define _UAPI_LINUX_HW_BREAKPOINT_H	3	#define _UAPI_LINUX_HW_BREAKPOINT_H
4		4

tools/include/uapi/linux/kvm.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef __LINUX_KVM_H	2	#ifndef __LINUX_KVM_H
2	#define __LINUX_KVM_H	3	#define __LINUX_KVM_H
3		4

tools/include/uapi/linux/mman.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef _UAPI_LINUX_MMAN_H	2	#ifndef _UAPI_LINUX_MMAN_H
3	#define _UAPI_LINUX_MMAN_H	3	#define _UAPI_LINUX_MMAN_H
4		4

tools/include/uapi/linux/perf_event.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	/*	2	/*
2	* Performance events:	3	* Performance events:
3	*	4	*

tools/include/uapi/linux/sched.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef _UAPI_LINUX_SCHED_H	2	#ifndef _UAPI_LINUX_SCHED_H
2	#define _UAPI_LINUX_SCHED_H	3	#define _UAPI_LINUX_SCHED_H
3		4

tools/include/uapi/linux/stat.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	#ifndef _UAPI_LINUX_STAT_H	2	#ifndef _UAPI_LINUX_STAT_H
3	#define _UAPI_LINUX_STAT_H	3	#define _UAPI_LINUX_STAT_H
4		4

tools/include/uapi/linux/vhost.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
1	#ifndef _LINUX_VHOST_H	2	#ifndef _LINUX_VHOST_H
2	#define _LINUX_VHOST_H	3	#define _LINUX_VHOST_H
3	/* Userspace interface for in-kernel virtio accelerators. */	4	/* Userspace interface for in-kernel virtio accelerators. */

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

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
1	/*	2	/*
2	* Advanced Linux Sound Architecture - ALSA - Driver	3	* Advanced Linux Sound Architecture - ALSA - Driver
3	* Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,	4	* Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,

tools/objtool/arch/x86/insn/gen-insn-attr-x86.awk+1−0

@@ -1,4 +1,5 @@
1	#!/bin/awk -f	1	#!/bin/awk -f
		2	# SPDX-License-Identifier: GPL-2.0
2	# gen-insn-attr-x86.awk: Instruction attribute table generator	3	# gen-insn-attr-x86.awk: Instruction attribute table generator
3	# Written by Masami Hiramatsu <mhiramat@redhat.com>	4	# Written by Masami Hiramatsu <mhiramat@redhat.com>
4	#	5	#

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

@@ -606,9 +606,19 @@ static struct arch arch__find(const char name) · 605 unmodified lines
606	int symbol__alloc_hist(struct symbol *sym)	606	int symbol__alloc_hist(struct symbol *sym)
607	{	607	{
608	struct annotation *notes = symbol__annotation(sym);	608	struct annotation *notes = symbol__annotation(sym);
609	const size_t size = symbol__size(sym);	609	size_t size = symbol__size(sym);
610	size_t sizeof_sym_hist;	610	size_t sizeof_sym_hist;
611		611
		612	/*
		613	* Add buffer of one element for zero length symbol.
		614	* When sample is taken from first instruction of
		615	* zero length symbol, perf still resolves it and
		616	* shows symbol name in perf report and allows to
		617	* annotate it.
		618	*/
		619	if (size == 0)
		620	size = 1;
		621
612	/* Check for overflow when calculating sizeof_sym_hist */	622	/* Check for overflow when calculating sizeof_sym_hist */
613	if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(struct sym_hist_entry))	623	if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(struct sym_hist_entry))
614	return -1;	624	return -1;

tools/perf/util/parse-events.l+6−2

 	yycolumn += yyleng;				\
 } while (0);
+#define USER_REJECT		\
+	yycolumn -= yyleng;	\
+	REJECT
 %}
 %x mem
 {num_hex}		{ return value(yyscanner, 16); }
 {modifier_event}	{ return str(yyscanner, PE_MODIFIER_EVENT); }
-{bpf_object}		{ if (!isbpf(yyscanner)) REJECT; return str(yyscanner, PE_BPF_OBJECT); }
+{bpf_object}		{ if (!isbpf(yyscanner)) USER_REJECT; return str(yyscanner, PE_BPF_OBJECT); }
-{bpf_source}		{ if (!isbpf(yyscanner)) REJECT; return str(yyscanner, PE_BPF_SOURCE); }
+{bpf_source}		{ if (!isbpf(yyscanner)) USER_REJECT; return str(yyscanner, PE_BPF_SOURCE); }
 {name}			{ return pmu_str_check(yyscanner); }
 "/"			{ BEGIN(config); return '/'; }
 -			{ return '-'; }

virt/kvm/arm/arm.c+14−17

@@ -1326,21 +1326,12 @@ static void teardown_hyp_mode(void) · 1325 unmodified lines
1326	{	1326	{
1327	int cpu;	1327	int cpu;
1328		1328
1329	if (is_kernel_in_hyp_mode())
1330	return;
1331
1332	free_hyp_pgds();	1329	free_hyp_pgds();
1333	for_each_possible_cpu(cpu)	1330	for_each_possible_cpu(cpu)
1334	free_page(per_cpu(kvm_arm_hyp_stack_page, cpu));	1331	free_page(per_cpu(kvm_arm_hyp_stack_page, cpu));
1335	hyp_cpu_pm_exit();	1332	hyp_cpu_pm_exit();
1336	}	1333	}
1337		1334
1338	static int init_vhe_mode(void)
1339	{
1340	kvm_info("VHE mode initialized successfully\n");
1341	return 0;
1342	}
1343
1344	/**	1335	/**
1345	* Inits Hyp-mode on all online CPUs	1336	* Inits Hyp-mode on all online CPUs
1346	*/	1337	*/
@@ -1421,8 +1412,6 @@ static int init_hyp_mode(void) · 74 unmodified lines
1421	}	1412	}
1422	}	1413	}
1423		1414
1424	kvm_info("Hyp mode initialized successfully\n");
1425
1426	return 0;	1415	return 0;
1427		1416
1428	out_err:	1417	out_err:
@@ -1456,6 +1445,7 @@ int kvm_arch_init(void *opaque) · 27 unmodified lines
1456	{	1445	{
1457	int err;	1446	int err;
1458	int ret, cpu;	1447	int ret, cpu;
		1448	bool in_hyp_mode;
1459		1449
1460	if (!is_hyp_mode_available()) {	1450	if (!is_hyp_mode_available()) {
1461	kvm_err("HYP mode not available\n");	1451	kvm_err("HYP mode not available\n");
@@ -1474,21 +1464,28 @@ int kvm_arch_init(void *opaque) · 12 unmodified lines
1474	if (err)	1464	if (err)
1475	return err;	1465	return err;
1476		1466
1477	if (is_kernel_in_hyp_mode())	1467	in_hyp_mode = is_kernel_in_hyp_mode();
1478	err = init_vhe_mode();	1468
1479	else	1469	if (!in_hyp_mode) {
1480	err = init_hyp_mode();	1470	err = init_hyp_mode();
1481	if (err)	1471	if (err)
1482	goto out_err;	1472	goto out_err;
		1473	}
1483		1474
1484	err = init_subsystems();	1475	err = init_subsystems();
1485	if (err)	1476	if (err)
1486	goto out_hyp;	1477	goto out_hyp;
1487		1478
		1479	if (in_hyp_mode)
		1480	kvm_info("VHE mode initialized successfully\n");
		1481	else
		1482	kvm_info("Hyp mode initialized successfully\n");
		1483
1488	return 0;	1484	return 0;
1489		1485
1490	out_hyp:	1486	out_hyp:
1491	teardown_hyp_mode();	1487	if (!in_hyp_mode)
		1488	teardown_hyp_mode();
1492	out_err:	1489	out_err:
1493	teardown_common_resources();	1490	teardown_common_resources();
1494	return err;	1491	return err;

virt/kvm/arm/vgic/vgic-its.c+48−25

 {
 	mutex_lock(&its->cmd_lock);
+	/*
+	 * It is UNPREDICTABLE to enable the ITS if any of the CBASER or
+	 * device/collection BASER are invalid
+	 */
+	if (!its->enabled && (val & GITS_CTLR_ENABLE) &&
+		(!(its->baser_device_table & GITS_BASER_VALID) ||
+		 !(its->baser_coll_table & GITS_BASER_VALID) ||
+		 !(its->cbaser & GITS_CBASER_VALID)))
+		goto out;
 	its->enabled = !!(val & GITS_CTLR_ENABLE);
 	/*
 	 */
 	vgic_its_process_commands(kvm, its);
+out:
 	mutex_unlock(&its->cmd_lock);
 }
 static int scan_its_table(struct vgic_its *its, gpa_t base, int size, int esz,
 			  int start_id, entry_fn_t fn, void *opaque)
 {
-	void *entry = kzalloc(esz, GFP_KERNEL);
 	struct kvm *kvm = its->dev->kvm;
 	unsigned long len = size;
 	int id = start_id;
 	gpa_t gpa = base;
+	char entry[esz];
 	int ret;
+	memset(entry, 0, esz);
 	while (len > 0) {
 		int next_offset;
 		size_t byte_offset;
 		ret = kvm_read_guest(kvm, gpa, entry, esz);
 		if (ret)
-			goto out;
+			return ret;
 		next_offset = fn(its, id, entry, opaque);
-		if (next_offset <= 0) {
+		if (next_offset <= 0)
-			ret = next_offset;
+			return next_offset;
-			goto out;
-		}
 		byte_offset = next_offset * esz;
 		id += next_offset;
 		gpa += byte_offset;
 		len -= byte_offset;
 	}
-	ret =  1;
+	return 1;
-out:
-	kfree(entry);
-	return ret;
 }
 /**
 	return 0;
 }
+/**
+ * vgic_its_restore_itt - restore the ITT of a device
+ *
+ * @its: its handle
+ * @dev: device handle
+ *
+ * Return 0 on success, < 0 on error
+ */
 static int vgic_its_restore_itt(struct vgic_its *its, struct its_device *dev)
 {
 	const struct vgic_its_abi *abi = vgic_its_get_abi(its);
 	ret = scan_its_table(its, base, max_size, ite_esz, 0,
 			     vgic_its_restore_ite, dev);
+	/* scan_its_table returns +1 if all ITEs are invalid */
+	if (ret > 0)
+		ret = 0;
 	return ret;
 }
 static int vgic_its_save_device_tables(struct vgic_its *its)
 {
 	const struct vgic_its_abi *abi = vgic_its_get_abi(its);
+	u64 baser = its->baser_device_table;
 	struct its_device *dev;
 	int dte_esz = abi->dte_esz;
-	u64 baser;
-	baser = its->baser_device_table;
+	if (!(baser & GITS_BASER_VALID))
+		return 0;
 	list_sort(NULL, &its->device_list, vgic_its_device_cmp);
 	ret = scan_its_table(its, gpa, SZ_64K, dte_esz,
 			     l2_start_id, vgic_its_restore_dte, NULL);
-	if (ret <= 0)
+	return ret;
-		return ret;
-	return 1;
 }
 /**
 				     vgic_its_restore_dte, NULL);
 	}
+	/* scan_its_table returns +1 if all entries are invalid */
 	if (ret > 0)
-		ret = -EINVAL;
+		ret = 0;
 	return ret;
 }
 static int vgic_its_save_collection_table(struct vgic_its *its)
 {
 	const struct vgic_its_abi *abi = vgic_its_get_abi(its);
+	u64 baser = its->baser_coll_table;
+	gpa_t gpa = BASER_ADDRESS(baser);
 	struct its_collection *collection;
 	u64 val;
-	gpa_t gpa;
 	size_t max_size, filled = 0;
 	int ret, cte_esz = abi->cte_esz;
-	gpa = BASER_ADDRESS(its->baser_coll_table);
+	if (!(baser & GITS_BASER_VALID))
-	if (!gpa)
 		return 0;
-	max_size = GITS_BASER_NR_PAGES(its->baser_coll_table) * SZ_64K;
+	max_size = GITS_BASER_NR_PAGES(baser) * SZ_64K;
 	list_for_each_entry(collection, &its->collection_list, coll_list) {
 		ret = vgic_its_save_cte(its, collection, gpa, cte_esz);
 static int vgic_its_restore_collection_table(struct vgic_its *its)
 {
 	const struct vgic_its_abi *abi = vgic_its_get_abi(its);
+	u64 baser = its->baser_coll_table;
 	int cte_esz = abi->cte_esz;
 	size_t max_size, read = 0;
 	gpa_t gpa;
 	int ret;
-	if (!(its->baser_coll_table & GITS_BASER_VALID))
+	if (!(baser & GITS_BASER_VALID))
 		return 0;
-	gpa = BASER_ADDRESS(its->baser_coll_table);
+	gpa = BASER_ADDRESS(baser);
-	max_size = GITS_BASER_NR_PAGES(its->baser_coll_table) * SZ_64K;
+	max_size = GITS_BASER_NR_PAGES(baser) * SZ_64K;
 	while (read < max_size) {
 		ret = vgic_its_restore_cte(its, gpa, cte_esz);
 		gpa += cte_esz;
 		read += cte_esz;
 	}
+	if (ret > 0)
+		return 0;
 	return ret;
 }

@@ -37,7 +37,7 @@ · 36 unmodified lines
37		37
38	#define T4FW_VERSION_MAJOR 0x01	38	#define T4FW_VERSION_MAJOR 0x01
39	#define T4FW_VERSION_MINOR 0x10	39	#define T4FW_VERSION_MINOR 0x10
40	#define T4FW_VERSION_MICRO 0x2D	40	#define T4FW_VERSION_MICRO 0x3F
41	#define T4FW_VERSION_BUILD 0x00	41	#define T4FW_VERSION_BUILD 0x00
42		42
43	#define T4FW_MIN_VERSION_MAJOR 0x01	43	#define T4FW_MIN_VERSION_MAJOR 0x01
@@ -46,7 +46,7 @@ · 2 unmodified lines
46		46
47	#define T5FW_VERSION_MAJOR 0x01	47	#define T5FW_VERSION_MAJOR 0x01
48	#define T5FW_VERSION_MINOR 0x10	48	#define T5FW_VERSION_MINOR 0x10
49	#define T5FW_VERSION_MICRO 0x2D	49	#define T5FW_VERSION_MICRO 0x3F
50	#define T5FW_VERSION_BUILD 0x00	50	#define T5FW_VERSION_BUILD 0x00
51		51
52	#define T5FW_MIN_VERSION_MAJOR 0x00	52	#define T5FW_MIN_VERSION_MAJOR 0x00
@@ -55,7 +55,7 @@ · 2 unmodified lines
55		55
56	#define T6FW_VERSION_MAJOR 0x01	56	#define T6FW_VERSION_MAJOR 0x01
57	#define T6FW_VERSION_MINOR 0x10	57	#define T6FW_VERSION_MINOR 0x10
58	#define T6FW_VERSION_MICRO 0x2D	58	#define T6FW_VERSION_MICRO 0x3F
59	#define T6FW_VERSION_BUILD 0x00	59	#define T6FW_VERSION_BUILD 0x00
60		60
61	#define T6FW_MIN_VERSION_MAJOR 0x00	61	#define T6FW_MIN_VERSION_MAJOR 0x00

@@ -94,7 +94,7 @@ enum { · 93 unmodified lines
94	SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */	94	SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */
95	SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */	95	SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */
96	SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */	96	SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */
97	SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */	97	SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */
98	SNDRV_HWDEP_IFACE_BLUETOOTH, /* Bluetooth audio */	98	SNDRV_HWDEP_IFACE_BLUETOOTH, /* Bluetooth audio */
99	SNDRV_HWDEP_IFACE_USX2Y_PCM, /* Tascam US122, US224 & US428 rawusb pcm */	99	SNDRV_HWDEP_IFACE_USX2Y_PCM, /* Tascam US122, US224 & US428 rawusb pcm */
100	SNDRV_HWDEP_IFACE_PCXHR, /* Digigram PCXHR */	100	SNDRV_HWDEP_IFACE_PCXHR, /* Digigram PCXHR */
@@ -384,7 +384,7 @@ struct snd_mask { · 283 unmodified lines
384		384
385	struct snd_pcm_hw_params {	385	struct snd_pcm_hw_params {
386	unsigned int flags;	386	unsigned int flags;
387	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -	387	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
388	SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];	388	SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
389	struct snd_mask mres[5]; /* reserved masks */	389	struct snd_mask mres[5]; /* reserved masks */
390	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -	390	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
@@ -857,7 +857,7 @@ typedef int __bitwise snd_ctl_elem_iface_t; · 466 unmodified lines
857	#define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */	857	#define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */
858	#define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */	858	#define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */
859	#define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */	859	#define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */
860	#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) /* kernel use a TLV callback */	860	#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) /* kernel use a TLV callback */
861	#define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) /* user space element */	861	#define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) /* user space element */
862	/* bits 30 and 31 are obsoleted (for indirect access) */	862	/* bits 30 and 31 are obsoleted (for indirect access) */
863		863