lael-labs/linux

Documentation/admin-guide/kernel-parameters.txt+7−0

@@ -3811,6 +3811,13 @@ · 3810 unmodified lines
3811	expediting. Set to zero to disable automatic	3811	expediting. Set to zero to disable automatic
3812	expediting.	3812	expediting.
3813		3813
		3814	stack_guard_gap= [MM]
		3815	override the default stack gap protection. The value
		3816	is in page units and it defines how many pages prior
		3817	to (for stacks growing down) resp. after (for stacks
		3818	growing up) the main stack are reserved for no other
		3819	mapping. Default value is 256 pages.
		3820
3814	stacktrace [FTRACE]	3821	stacktrace [FTRACE]
3815	Enabled the stack tracer on boot up.	3822	Enabled the stack tracer on boot up.
3816		3823

Documentation/devicetree/bindings/clock/sunxi-ccu.txt+4−3

 - #clock-cells : must contain 1
 - #reset-cells : must contain 1
-For the PRCM CCUs on H3/A64, one more clock is needed:
+For the PRCM CCUs on H3/A64, two more clocks are needed:
+- "pll-periph": the SoC's peripheral PLL from the main CCU
 - "iosc": the SoC's internal frequency oscillator
 Example for generic CCU:
 r_ccu: clock@01f01400 {
 	compatible = "allwinner,sun50i-a64-r-ccu";
 	reg = <0x01f01400 0x100>;
-	clocks = <&osc24M>, <&osc32k>, <&iosc>;
+	clocks = <&osc24M>, <&osc32k>, <&iosc>, <&ccu CLK_PLL_PERIPH0>;
-	clock-names = "hosc", "losc", "iosc";
+	clock-names = "hosc", "losc", "iosc", "pll-periph";
 	#clock-cells = <1>;
 	#reset-cells = <1>;
 };

Documentation/devicetree/bindings/gpio/gpio-mvebu.txt+3−3

@@ -41,9 +41,9 @@ Required properties: · 40 unmodified lines
41	Optional properties:	41	Optional properties:
42		42
43	In order to use the GPIO lines in PWM mode, some additional optional	43	In order to use the GPIO lines in PWM mode, some additional optional
44	properties are required. Only Armada 370 and XP support these properties.	44	properties are required.
45		45
46	- compatible: Must contain "marvell,armada-370-xp-gpio"	46	- compatible: Must contain "marvell,armada-370-gpio"
47		47
48	- reg: an additional register set is needed, for the GPIO Blink	48	- reg: an additional register set is needed, for the GPIO Blink
49	Counter on/off registers.	49	Counter on/off registers.
@@ -71,7 +71,7 @@ Example: · 21 unmodified lines
71	};	71	};
72		72
73	gpio1: gpio@18140 {	73	gpio1: gpio@18140 {
74	compatible = "marvell,armada-370-xp-gpio";	74	compatible = "marvell,armada-370-gpio";
75	reg = <0x18140 0x40>, <0x181c8 0x08>;	75	reg = <0x18140 0x40>, <0x181c8 0x08>;
76	reg-names = "gpio", "pwm";	76	reg-names = "gpio", "pwm";
77	ngpios = <17>;	77	ngpios = <17>;

Documentation/devicetree/bindings/mfd/stm32-timers.txt+1−1

@@ -31,7 +31,7 @@ Example: · 30 unmodified lines
31	compatible = "st,stm32-timers";	31	compatible = "st,stm32-timers";
32	reg = <0x40010000 0x400>;	32	reg = <0x40010000 0x400>;
33	clocks = <&rcc 0 160>;	33	clocks = <&rcc 0 160>;
34	clock-names = "clk_int";	34	clock-names = "int";
35		35
36	pwm {	36	pwm {
37	compatible = "st,stm32-pwm";	37	compatible = "st,stm32-pwm";

Documentation/devicetree/bindings/net/dsa/b53.txt+1−1

@@ -34,7 +34,7 @@ Required properties: · 33 unmodified lines
34	"brcm,bcm6328-switch"	34	"brcm,bcm6328-switch"
35	"brcm,bcm6368-switch" and the mandatory "brcm,bcm63xx-switch"	35	"brcm,bcm6368-switch" and the mandatory "brcm,bcm63xx-switch"
36		36
37	See Documentation/devicetree/bindings/dsa/dsa.txt for a list of additional	37	See Documentation/devicetree/bindings/net/dsa/dsa.txt for a list of additional
38	required and optional properties.	38	required and optional properties.
39		39
40	Examples:	40	Examples:

Documentation/devicetree/bindings/net/smsc911x.txt+1−0

@@ -27,6 +27,7 @@ Optional properties: · 26 unmodified lines
27	of the device. On many systems this is wired high so the device goes	27	of the device. On many systems this is wired high so the device goes
28	out of reset at power-on, but if it is under program control, this	28	out of reset at power-on, but if it is under program control, this
29	optional GPIO can wake up in response to it.	29	optional GPIO can wake up in response to it.
		30	- vdd33a-supply, vddvario-supply : 3.3V analog and IO logic power supplies
30		31
31	Examples:	32	Examples:
32		33

Documentation/networking/scaling.txt+1−1

@@ -122,7 +122,7 @@ associated flow of the packet. The hash is either provided by hardware · 121 unmodified lines
122	or will be computed in the stack. Capable hardware can pass the hash in	122	or will be computed in the stack. Capable hardware can pass the hash in
123	the receive descriptor for the packet; this would usually be the same	123	the receive descriptor for the packet; this would usually be the same
124	hash used for RSS (e.g. computed Toeplitz hash). The hash is saved in	124	hash used for RSS (e.g. computed Toeplitz hash). The hash is saved in
125	skb->rx_hash and can be used elsewhere in the stack as a hash of the	125	skb->hash and can be used elsewhere in the stack as a hash of the
126	packet’s flow.	126	packet’s flow.
127		127
128	Each receive hardware queue has an associated list of CPUs to which	128	Each receive hardware queue has an associated list of CPUs to which

Makefile+2−2

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 12	2	PATCHLEVEL = 12
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc5	4	EXTRAVERSION = -rc7
5	NAME = Fearless Coyote	5	NAME = Fearless Coyote
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION
@@ -1437,7 +1437,7 @@ help: · 1429 unmodified lines
1437	@echo ' make V=0\|1 [targets] 0 => quiet build (default), 1 => verbose build'	1437	@echo ' make V=0\|1 [targets] 0 => quiet build (default), 1 => verbose build'
1438	@echo ' make V=2 [targets] 2 => give reason for rebuild of target'	1438	@echo ' make V=2 [targets] 2 => give reason for rebuild of target'
1439	@echo ' make O=dir [targets] Locate all output files in "dir", including .config'	1439	@echo ' make O=dir [targets] Locate all output files in "dir", including .config'
1440	@echo ' make C=1 [targets] Check all c source with $$CHECK (sparse by default)'	1440	@echo ' make C=1 [targets] Check re-compiled c source with $$CHECK (sparse by default)'
1441	@echo ' make C=2 [targets] Force check of all c source with $$CHECK'	1441	@echo ' make C=2 [targets] Force check of all c source with $$CHECK'
1442	@echo ' make RECORDMCOUNT_WARN=1 [targets] Warn about ignored mcount sections'	1442	@echo ' make RECORDMCOUNT_WARN=1 [targets] Warn about ignored mcount sections'
1443	@echo ' make W=n [targets] Enable extra gcc checks, n=1,2,3 where'	1443	@echo ' make W=n [targets] Enable extra gcc checks, n=1,2,3 where'

arch/arc/mm/mmap.c+1−1

@@ -65,7 +65,7 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 64 unmodified lines
65		65
66	vma = find_vma(mm, addr);	66	vma = find_vma(mm, addr);
67	if (TASK_SIZE - len >= addr &&	67	if (TASK_SIZE - len >= addr &&
68	(!vma \|\| addr + len <= vma->vm_start))	68	(!vma \|\| addr + len <= vm_start_gap(vma)))
69	return addr;	69	return addr;
70	}	70	}
71		71

arch/arm/boot/dts/am335x-sl50.dts+2−6

 	mmc1_pins: pinmux_mmc1_pins {
 		pinctrl-single,pins = <
-			AM33XX_IOPAD(0x960, PIN_INPUT | MUX_MODE7)		/* spi0_cs1.gpio0_6 */
+			AM33XX_IOPAD(0x96c, PIN_INPUT | MUX_MODE7)		/* uart0_rtsn.gpio1_9 */
 		>;
 	};
 			AM33XX_IOPAD(0x834, PIN_INPUT_PULLUP | MUX_MODE7)	/* nKbdReset - gpmc_ad13.gpio1_13 */
 			AM33XX_IOPAD(0x838, PIN_INPUT_PULLUP | MUX_MODE7)	/* nDispReset - gpmc_ad14.gpio1_14 */
 			AM33XX_IOPAD(0x844, PIN_INPUT_PULLUP | MUX_MODE7)	/* USB1_enPower - gpmc_a1.gpio1_17 */
-			/* AVR Programming - SPI Bus (bit bang) - Screen and Keyboard */
-			AM33XX_IOPAD(0x954, PIN_INPUT_PULLUP | MUX_MODE7)	/* Kbd/Disp/BattMOSI spi0_d0.gpio0_3 */
-			AM33XX_IOPAD(0x958, PIN_INPUT_PULLUP | MUX_MODE7)	/* Kbd/Disp/BattMISO spi0_d1.gpio0_4 */
-			AM33XX_IOPAD(0x950, PIN_INPUT_PULLUP | MUX_MODE7)	/* Kbd/Disp/BattSCLK spi0_clk.gpio0_2 */
 			/* PDI Bus - Battery system */
 			AM33XX_IOPAD(0x840, PIN_INPUT_PULLUP | MUX_MODE7)	/* nBattReset  gpmc_a0.gpio1_16 */
 			AM33XX_IOPAD(0x83c, PIN_INPUT_PULLUP | MUX_MODE7)	/* BattPDIData gpmc_ad15.gpio1_15 */
 	pinctrl-names = "default";
 	pinctrl-0 = <&mmc1_pins>;
 	bus-width = <4>;
-	cd-gpios = <&gpio0 6 GPIO_ACTIVE_LOW>;
+	cd-gpios = <&gpio1 9 GPIO_ACTIVE_LOW>;
 	vmmc-supply = <&vmmcsd_fixed>;
 };

arch/arm/boot/dts/sunxi-h3-h5.dtsi+4−3

 		};
 		r_ccu: clock@1f01400 {
-			compatible = "allwinner,sun50i-a64-r-ccu";
+			compatible = "allwinner,sun8i-h3-r-ccu";
 			reg = <0x01f01400 0x100>;
-			clocks = <&osc24M>, <&osc32k>, <&iosc>;
+			clocks = <&osc24M>, <&osc32k>, <&iosc>,
-			clock-names = "hosc", "losc", "iosc";
+				 <&ccu 9>;
+			clock-names = "hosc", "losc", "iosc", "pll-periph";
 			#clock-cells = <1>;
 			#reset-cells = <1>;
 		};

arch/arm/mm/mmap.c+2−2

@@ -90,7 +90,7 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 89 unmodified lines
90		90
91	vma = find_vma(mm, addr);	91	vma = find_vma(mm, addr);
92	if (TASK_SIZE - len >= addr &&	92	if (TASK_SIZE - len >= addr &&
93	(!vma \|\| addr + len <= vma->vm_start))	93	(!vma \|\| addr + len <= vm_start_gap(vma)))
94	return addr;	94	return addr;
95	}	95	}
96		96
@@ -141,7 +141,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 44 unmodified lines
141	addr = PAGE_ALIGN(addr);	141	addr = PAGE_ALIGN(addr);
142	vma = find_vma(mm, addr);	142	vma = find_vma(mm, addr);
143	if (TASK_SIZE - len >= addr &&	143	if (TASK_SIZE - len >= addr &&
144	(!vma \|\| addr + len <= vma->vm_start))	144	(!vma \|\| addr + len <= vm_start_gap(vma)))
145	return addr;	145	return addr;
146	}	146	}
147		147

arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi+3−2

 		r_ccu: clock@1f01400 {
 			compatible = "allwinner,sun50i-a64-r-ccu";
 			reg = <0x01f01400 0x100>;
-			clocks = <&osc24M>, <&osc32k>, <&iosc>;
+			clocks = <&osc24M>, <&osc32k>, <&iosc>,
-			clock-names = "hosc", "losc", "iosc";
+				 <&ccu 11>;
+			clock-names = "hosc", "losc", "iosc", "pll-periph";
 			#clock-cells = <1>;
 			#reset-cells = <1>;
 		};

arch/arm64/boot/dts/allwinner/sun50i-h5.dtsi+1−1

@@ -40,7 +40,7 @@ · 39 unmodified lines
40	* OTHER DEALINGS IN THE SOFTWARE.	40	* OTHER DEALINGS IN THE SOFTWARE.
41	*/	41	*/
42		42
43	#include "sunxi-h3-h5.dtsi"	43	#include <arm/sunxi-h3-h5.dtsi>
44		44
45	/ {	45	/ {
46	cpus {	46	cpus {

arch/arm64/boot/dts/allwinner/sunxi-h3-h5.dtsi+0−1

@@ -1 +0,0 @@
1	../../../../arm/boot/dts/sunxi-h3-h5.dtsi

arch/arm64/kernel/vdso.c+3−2

 		/* tkr_mono.cycle_last == tkr_raw.cycle_last */
 		vdso_data->cs_cycle_last	= tk->tkr_mono.cycle_last;
 		vdso_data->raw_time_sec		= tk->raw_time.tv_sec;
-		vdso_data->raw_time_nsec	= tk->raw_time.tv_nsec;
+		vdso_data->raw_time_nsec	= (tk->raw_time.tv_nsec <<
+						   tk->tkr_raw.shift) +
+						  tk->tkr_raw.xtime_nsec;
 		vdso_data->xtime_clock_sec	= tk->xtime_sec;
 		vdso_data->xtime_clock_nsec	= tk->tkr_mono.xtime_nsec;
-		/* tkr_raw.xtime_nsec == 0 */
 		vdso_data->cs_mono_mult		= tk->tkr_mono.mult;
 		vdso_data->cs_raw_mult		= tk->tkr_raw.mult;
 		/* tkr_mono.shift == tkr_raw.shift */

arch/arm64/kernel/vdso/gettimeofday.S+0−1

@@ -256,7 +256,6 @@ monotonic_raw: · 255 unmodified lines
256	seqcnt_check fail=monotonic_raw	256	seqcnt_check fail=monotonic_raw
257		257
258	/* All computations are done with left-shifted nsecs. */	258	/* All computations are done with left-shifted nsecs. */
259	lsl x14, x14, x12
260	get_nsec_per_sec res=x9	259	get_nsec_per_sec res=x9
261	lsl x9, x9, x12	260	lsl x9, x9, x12
262		261

arch/arm64/net/bpf_jit_comp.c+5−2

 #define TMP_REG_1 (MAX_BPF_JIT_REG + 0)
 #define TMP_REG_2 (MAX_BPF_JIT_REG + 1)
 #define TCALL_CNT (MAX_BPF_JIT_REG + 2)
+#define TMP_REG_3 (MAX_BPF_JIT_REG + 3)
 /* Map BPF registers to A64 registers */
 static const int bpf2a64[] = {
 	/* temporary registers for internal BPF JIT */
 	[TMP_REG_1] = A64_R(10),
 	[TMP_REG_2] = A64_R(11),
+	[TMP_REG_3] = A64_R(12),
 	/* tail_call_cnt */
 	[TCALL_CNT] = A64_R(26),
 	/* temporary register for blinding constants */
 	const u8 src = bpf2a64[insn->src_reg];
 	const u8 tmp = bpf2a64[TMP_REG_1];
 	const u8 tmp2 = bpf2a64[TMP_REG_2];
+	const u8 tmp3 = bpf2a64[TMP_REG_3];
 	const s16 off = insn->off;
 	const s32 imm = insn->imm;
 	const int i = insn - ctx->prog->insnsi;
 		emit(A64_PRFM(tmp, PST, L1, STRM), ctx);
 		emit(A64_LDXR(isdw, tmp2, tmp), ctx);
 		emit(A64_ADD(isdw, tmp2, tmp2, src), ctx);
-		emit(A64_STXR(isdw, tmp2, tmp, tmp2), ctx);
+		emit(A64_STXR(isdw, tmp2, tmp, tmp3), ctx);
 		jmp_offset = -3;
 		check_imm19(jmp_offset);
-		emit(A64_CBNZ(0, tmp2, jmp_offset), ctx);
+		emit(A64_CBNZ(0, tmp3, jmp_offset), ctx);
 		break;
 	/* R0 = ntohx(*(size *)(((struct sk_buff *)R6)->data + imm)) */

arch/frv/mm/elf-fdpic.c+1−1

@@ -75,7 +75,7 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsi · 74 unmodified lines
75	addr = PAGE_ALIGN(addr);	75	addr = PAGE_ALIGN(addr);
76	vma = find_vma(current->mm, addr);	76	vma = find_vma(current->mm, addr);
77	if (TASK_SIZE - len >= addr &&	77	if (TASK_SIZE - len >= addr &&
78	(!vma \|\| addr + len <= vma->vm_start))	78	(!vma \|\| addr + len <= vm_start_gap(vma)))
79	goto success;	79	goto success;
80	}	80	}
81		81

arch/mips/boot/Makefile+5−5

@@ -128,19 +128,19 @@ quiet_cmd_cpp_its_S = ITS $@ · 127 unmodified lines
128	-DADDR_BITS=$(ADDR_BITS) \	128	-DADDR_BITS=$(ADDR_BITS) \
129	-DADDR_CELLS=$(itb_addr_cells)	129	-DADDR_CELLS=$(itb_addr_cells)
130		130
131	$(obj)/vmlinux.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S FORCE	131	$(obj)/vmlinux.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S $(VMLINUX) FORCE
132	$(call if_changed_dep,cpp_its_S,none,vmlinux.bin)	132	$(call if_changed_dep,cpp_its_S,none,vmlinux.bin)
133		133
134	$(obj)/vmlinux.gz.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S FORCE	134	$(obj)/vmlinux.gz.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S $(VMLINUX) FORCE
135	$(call if_changed_dep,cpp_its_S,gzip,vmlinux.bin.gz)	135	$(call if_changed_dep,cpp_its_S,gzip,vmlinux.bin.gz)
136		136
137	$(obj)/vmlinux.bz2.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S FORCE	137	$(obj)/vmlinux.bz2.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S $(VMLINUX) FORCE
138	$(call if_changed_dep,cpp_its_S,bzip2,vmlinux.bin.bz2)	138	$(call if_changed_dep,cpp_its_S,bzip2,vmlinux.bin.bz2)
139		139
140	$(obj)/vmlinux.lzma.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S FORCE	140	$(obj)/vmlinux.lzma.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S $(VMLINUX) FORCE
141	$(call if_changed_dep,cpp_its_S,lzma,vmlinux.bin.lzma)	141	$(call if_changed_dep,cpp_its_S,lzma,vmlinux.bin.lzma)
142		142
143	$(obj)/vmlinux.lzo.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S FORCE	143	$(obj)/vmlinux.lzo.its: $(srctree)/arch/mips/$(PLATFORM)/vmlinux.its.S $(VMLINUX) FORCE
144	$(call if_changed_dep,cpp_its_S,lzo,vmlinux.bin.lzo)	144	$(call if_changed_dep,cpp_its_S,lzo,vmlinux.bin.lzo)
145		145
146	quiet_cmd_itb-image = ITB $@	146	quiet_cmd_itb-image = ITB $@

arch/mips/include/asm/highmem.h+5−0

  * easily, subsequent pte tables have to be allocated in one physical
  * chunk of RAM.
  */
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+#define LAST_PKMAP 512
+#else
 #define LAST_PKMAP 1024
+#endif
 #define LAST_PKMAP_MASK (LAST_PKMAP-1)
 #define PKMAP_NR(virt)	((virt-PKMAP_BASE) >> PAGE_SHIFT)
 #define PKMAP_ADDR(nr)	(PKMAP_BASE + ((nr) << PAGE_SHIFT))

arch/mips/include/asm/kprobes.h+2−1

@@ -43,7 +43,8 @@ typedef union mips_instruction kprobe_opcode_t; · 42 unmodified lines
43		43
44	#define flush_insn_slot(p) \	44	#define flush_insn_slot(p) \
45	do { \	45	do { \
46	flush_icache_range((unsigned long)p->addr, \	46	if (p->addr) \
		47	flush_icache_range((unsigned long)p->addr, \
47	(unsigned long)p->addr + \	48	(unsigned long)p->addr + \
48	(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))); \	49	(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))); \
49	} while (0)	50	} while (0)

arch/mips/include/asm/pgtable-32.h+6−1

 #define __ARCH_USE_5LEVEL_HACK
 #include <asm-generic/pgtable-nopmd.h>
+#ifdef CONFIG_HIGHMEM
+#include <asm/highmem.h>
+#endif
 extern int temp_tlb_entry;
 /*
 #define VMALLOC_START	  MAP_BASE
-#define PKMAP_BASE		(0xfe000000UL)
+#define PKMAP_END	((FIXADDR_START) & ~((LAST_PKMAP << PAGE_SHIFT)-1))
+#define PKMAP_BASE	(PKMAP_END - PAGE_SIZE * LAST_PKMAP)
 #ifdef CONFIG_HIGHMEM
 # define VMALLOC_END	(PKMAP_BASE-2*PAGE_SIZE)

arch/mips/kernel/branch.c+3−1

 			break;
 		}
 		/* Compact branch: BNEZC || JIALC */
-		if (insn.i_format.rs)
+		if (!insn.i_format.rs) {
+			/* JIALC: set $31/ra */
 			regs->regs[31] = epc + 4;
+		}
 		regs->cp0_epc += 8;
 		break;
 #endif

arch/mips/kernel/ftrace.c+5−19

 #endif
-/*
- * Check if the address is in kernel space
- *
- * Clone core_kernel_text() from kernel/extable.c, but doesn't call
- * init_kernel_text() for Ftrace doesn't trace functions in init sections.
- */
-static inline int in_kernel_space(unsigned long ip)
-{
-	if (ip >= (unsigned long)_stext &&
-	    ip <= (unsigned long)_etext)
-		return 1;
-	return 0;
-}
 #ifdef CONFIG_DYNAMIC_FTRACE
 #define JAL 0x0c000000		/* jump & link: ip --> ra, jump to target */
 	 * If ip is in kernel space, no long call, otherwise, long call is
 	 * needed.
 	 */
-	new = in_kernel_space(ip) ? INSN_NOP : INSN_B_1F;
+	new = core_kernel_text(ip) ? INSN_NOP : INSN_B_1F;
 #ifdef CONFIG_64BIT
 	return ftrace_modify_code(ip, new);
 #else
 	unsigned int new;
 	unsigned long ip = rec->ip;
-	new = in_kernel_space(ip) ? insn_jal_ftrace_caller : insn_la_mcount[0];
+	new = core_kernel_text(ip) ? insn_jal_ftrace_caller : insn_la_mcount[0];
 #ifdef CONFIG_64BIT
 	return ftrace_modify_code(ip, new);
 #else
-	return ftrace_modify_code_2r(ip, new, in_kernel_space(ip) ?
+	return ftrace_modify_code_2r(ip, new, core_kernel_text(ip) ?
 						INSN_NOP : insn_la_mcount[1]);
 #endif
 }
 	 * instruction "lui v1, hi_16bit_of_mcount"(offset is 24), but for
 	 * kernel, move after the instruction "move ra, at"(offset is 16)
 	 */
-	ip = self_ra - (in_kernel_space(self_ra) ? 16 : 24);
+	ip = self_ra - (core_kernel_text(self_ra) ? 16 : 24);
 	/*
 	 * search the text until finding the non-store instruction or "s{d,w}
 	 * entries configured through the tracing/set_graph_function interface.
 	 */
-	insns = in_kernel_space(self_ra) ? 2 : MCOUNT_OFFSET_INSNS + 1;
+	insns = core_kernel_text(self_ra) ? 2 : MCOUNT_OFFSET_INSNS + 1;
 	trace.func = self_ra - (MCOUNT_INSN_SIZE * insns);
 	/* Only trace if the calling function expects to */

arch/mips/kernel/perf_event_mipsxx.c+5−1

 		break;
 	case CPU_P5600:
 	case CPU_P6600:
-	case CPU_I6400:
 		/* 8-bit event numbers */
 		raw_id = config & 0x1ff;
 		base_id = raw_id & 0xff;
 		raw_event.range = P;
 #endif
 		break;
+	case CPU_I6400:
+		/* 8-bit event numbers */
+		base_id = config & 0xff;
+		raw_event.cntr_mask = CNTR_EVEN | CNTR_ODD;
+		break;
 	case CPU_1004K:
 		if (IS_BOTH_COUNTERS_1004K_EVENT(base_id))
 			raw_event.cntr_mask = CNTR_EVEN | CNTR_ODD;

arch/mips/kvm/tlb.c+5−1

 int kvm_mips_host_tlb_inv(struct kvm_vcpu *vcpu, unsigned long va,
 			  bool user, bool kernel)
 {
-	int idx_user, idx_kernel;
+	/*
+	 * Initialize idx_user and idx_kernel to workaround bogus
+	 * maybe-initialized warning when using GCC 6.
+	 */
+	int idx_user = 0, idx_kernel = 0;
 	unsigned long flags, old_entryhi;
 	local_irq_save(flags);

arch/mips/mm/mmap.c+1−1

@@ -93,7 +93,7 @@ static unsigned long arch_get_unmapped_area_common(struct file *filp, · 92 unmodified lines
93		93
94	vma = find_vma(mm, addr);	94	vma = find_vma(mm, addr);
95	if (TASK_SIZE - len >= addr &&	95	if (TASK_SIZE - len >= addr &&
96	(!vma \|\| addr + len <= vma->vm_start))	96	(!vma \|\| addr + len <= vm_start_gap(vma)))
97	return addr;	97	return addr;
98	}	98	}
99		99

arch/mips/mm/pgtable-32.c+3−3

@@ -51,15 +51,15 @@ void __init pagetable_init(void) · 50 unmodified lines
51	/*	51	/*
52	* Fixed mappings:	52	* Fixed mappings:
53	*/	53	*/
54	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;	54	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1);
55	fixrange_init(vaddr, vaddr + FIXADDR_SIZE, pgd_base);	55	fixrange_init(vaddr & PMD_MASK, vaddr + FIXADDR_SIZE, pgd_base);
56		56
57	#ifdef CONFIG_HIGHMEM	57	#ifdef CONFIG_HIGHMEM
58	/*	58	/*
59	* Permanent kmaps:	59	* Permanent kmaps:
60	*/	60	*/
61	vaddr = PKMAP_BASE;	61	vaddr = PKMAP_BASE;
62	fixrange_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);	62	fixrange_init(vaddr & PMD_MASK, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);
63		63
64	pgd = swapper_pg_dir + __pgd_offset(vaddr);	64	pgd = swapper_pg_dir + __pgd_offset(vaddr);
65	pud = pud_offset(pgd, vaddr);	65	pud = pud_offset(pgd, vaddr);

arch/parisc/kernel/sys_parisc.c+9−6

@@ -90,7 +90,7 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, · 89 unmodified lines
90	unsigned long len, unsigned long pgoff, unsigned long flags)	90	unsigned long len, unsigned long pgoff, unsigned long flags)
91	{	91	{
92	struct mm_struct *mm = current->mm;	92	struct mm_struct *mm = current->mm;
93	struct vm_area_struct *vma;	93	struct vm_area_struct vma, prev;
94	unsigned long task_size = TASK_SIZE;	94	unsigned long task_size = TASK_SIZE;
95	int do_color_align, last_mmap;	95	int do_color_align, last_mmap;
96	struct vm_unmapped_area_info info;	96	struct vm_unmapped_area_info info;
@@ -117,9 +117,10 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, · 20 unmodified lines
117	else	117	else
118	addr = PAGE_ALIGN(addr);	118	addr = PAGE_ALIGN(addr);
119		119
120	vma = find_vma(mm, addr);	120	vma = find_vma_prev(mm, addr, &prev);
121	if (task_size - len >= addr &&	121	if (task_size - len >= addr &&
122	(!vma \|\| addr + len <= vma->vm_start))	122	(!vma \|\| addr + len <= vm_start_gap(vma)) &&
		123	(!prev \|\| addr >= vm_end_gap(prev)))
123	goto found_addr;	124	goto found_addr;
124	}	125	}
125		126
@@ -143,7 +144,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 17 unmodified lines
143	const unsigned long len, const unsigned long pgoff,	144	const unsigned long len, const unsigned long pgoff,
144	const unsigned long flags)	145	const unsigned long flags)
145	{	146	{
146	struct vm_area_struct *vma;	147	struct vm_area_struct vma, prev;
147	struct mm_struct *mm = current->mm;	148	struct mm_struct *mm = current->mm;
148	unsigned long addr = addr0;	149	unsigned long addr = addr0;
149	int do_color_align, last_mmap;	150	int do_color_align, last_mmap;
@@ -177,9 +178,11 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 27 unmodified lines
177	addr = COLOR_ALIGN(addr, last_mmap, pgoff);	178	addr = COLOR_ALIGN(addr, last_mmap, pgoff);
178	else	179	else
179	addr = PAGE_ALIGN(addr);	180	addr = PAGE_ALIGN(addr);
180	vma = find_vma(mm, addr);	181
		182	vma = find_vma_prev(mm, addr, &prev);
181	if (TASK_SIZE - len >= addr &&	183	if (TASK_SIZE - len >= addr &&
182	(!vma \|\| addr + len <= vma->vm_start))	184	(!vma \|\| addr + len <= vm_start_gap(vma)) &&
		185	(!prev \|\| addr >= vm_end_gap(prev)))
183	goto found_addr;	186	goto found_addr;
184	}	187	}
185		188

arch/powerpc/include/asm/bug.h+1−1

@@ -104,7 +104,7 @@ · 103 unmodified lines
104	"1: "PPC_TLNEI" %4,0\n" \	104	"1: "PPC_TLNEI" %4,0\n" \
105	_EMIT_BUG_ENTRY \	105	_EMIT_BUG_ENTRY \
106	: : "i" (__FILE__), "i" (__LINE__), \	106	: : "i" (__FILE__), "i" (__LINE__), \
107	"i" (BUGFLAG_TAINT(TAINT_WARN)), \	107	"i" (BUGFLAG_WARNING\|BUGFLAG_TAINT(TAINT_WARN)),\
108	"i" (sizeof(struct bug_entry)), \	108	"i" (sizeof(struct bug_entry)), \
109	"r" (__ret_warn_on)); \	109	"r" (__ret_warn_on)); \
110	} \	110	} \

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

@@ -103,6 +103,7 @@ extern int kprobe_exceptions_notify(struct notifier_block *self, · 102 unmodified lines
103	extern int kprobe_fault_handler(struct pt_regs *regs, int trapnr);	103	extern int kprobe_fault_handler(struct pt_regs *regs, int trapnr);
104	extern int kprobe_handler(struct pt_regs *regs);	104	extern int kprobe_handler(struct pt_regs *regs);
105	extern int kprobe_post_handler(struct pt_regs *regs);	105	extern int kprobe_post_handler(struct pt_regs *regs);
		106	extern int is_current_kprobe_addr(unsigned long addr);
106	#ifdef CONFIG_KPROBES_ON_FTRACE	107	#ifdef CONFIG_KPROBES_ON_FTRACE
107	extern int skip_singlestep(struct kprobe p, struct pt_regs regs,	108	extern int skip_singlestep(struct kprobe p, struct pt_regs regs,
108	struct kprobe_ctlblk *kcb);	109	struct kprobe_ctlblk *kcb);

arch/powerpc/include/asm/xive.h+7−5

@@ -94,11 +94,13 @@ struct xive_q { · 93 unmodified lines
94	* store at 0 and some ESBs support doing a trigger via a	94	* store at 0 and some ESBs support doing a trigger via a
95	* separate trigger page.	95	* separate trigger page.
96	*/	96	*/
97	#define XIVE_ESB_GET 0x800	97	#define XIVE_ESB_STORE_EOI 0x400 /* Store */
98	#define XIVE_ESB_SET_PQ_00 0xc00	98	#define XIVE_ESB_LOAD_EOI 0x000 /* Load */
99	#define XIVE_ESB_SET_PQ_01 0xd00	99	#define XIVE_ESB_GET 0x800 /* Load */
100	#define XIVE_ESB_SET_PQ_10 0xe00	100	#define XIVE_ESB_SET_PQ_00 0xc00 /* Load */
101	#define XIVE_ESB_SET_PQ_11 0xf00	101	#define XIVE_ESB_SET_PQ_01 0xd00 /* Load */
		102	#define XIVE_ESB_SET_PQ_10 0xe00 /* Load */
		103	#define XIVE_ESB_SET_PQ_11 0xf00 /* Load */
102		104
103	#define XIVE_ESB_VAL_P 0x2	105	#define XIVE_ESB_VAL_P 0x2
104	#define XIVE_ESB_VAL_Q 0x1	106	#define XIVE_ESB_VAL_Q 0x1

arch/powerpc/kernel/exceptions-64s.S+7−4

 	.balign	IFETCH_ALIGN_BYTES
 do_hash_page:
 #ifdef CONFIG_PPC_STD_MMU_64
-	andis.	r0,r4,0xa410		/* weird error? */
+	andis.	r0,r4,0xa450		/* weird error? */
 	bne-	handle_page_fault	/* if not, try to insert a HPTE */
-	andis.  r0,r4,DSISR_DABRMATCH@h
-	bne-    handle_dabr_fault
 	CURRENT_THREAD_INFO(r11, r1)
 	lwz	r0,TI_PREEMPT(r11)	/* If we're in an "NMI" */
 	andis.	r0,r0,NMI_MASK@h	/* (i.e. an irq when soft-disabled) */
 	/* Error */
 	blt-	13f
+	/* Reload DSISR into r4 for the DABR check below */
+	ld      r4,_DSISR(r1)
 #endif /* CONFIG_PPC_STD_MMU_64 */
 /* Here we have a page fault that hash_page can't handle. */
 handle_page_fault:
-11:	ld	r4,_DAR(r1)
+11:	andis.  r0,r4,DSISR_DABRMATCH@h
+	bne-    handle_dabr_fault
+	ld	r4,_DAR(r1)
 	ld	r5,_DSISR(r1)
 	addi	r3,r1,STACK_FRAME_OVERHEAD
 	bl	do_page_fault

arch/powerpc/kernel/kprobes.c+17−0

 struct kretprobe_blackpoint kretprobe_blacklist[] = {{NULL, NULL}};
+int is_current_kprobe_addr(unsigned long addr)
+{
+	struct kprobe *p = kprobe_running();
+	return (p && (unsigned long)p->addr == addr) ? 1 : 0;
+}
 bool arch_within_kprobe_blacklist(unsigned long addr)
 {
 	return  (addr >= (unsigned long)__kprobes_text_start &&
 	regs->gpr[2] = (unsigned long)(((func_descr_t *)jp->entry)->toc);
 #endif
+	/*
+	 * jprobes use jprobe_return() which skips the normal return
+	 * path of the function, and this messes up the accounting of the
+	 * function graph tracer.
+	 *
+	 * Pause function graph tracing while performing the jprobe function.
+	 */
+	pause_graph_tracing();
 	return 1;
 }
 NOKPROBE_SYMBOL(setjmp_pre_handler);
 	 * saved regs...
 	 */
 	memcpy(regs, &kcb->jprobe_saved_regs, sizeof(struct pt_regs));
+	/* It's OK to start function graph tracing again */
+	unpause_graph_tracing();
 	preempt_enable_no_resched();
 	return 1;
 }

arch/powerpc/kernel/setup_64.c+28−3

 }
 #endif
+/*
+ * Emergency stacks are used for a range of things, from asynchronous
+ * NMIs (system reset, machine check) to synchronous, process context.
+ * We set preempt_count to zero, even though that isn't necessarily correct. To
+ * get the right value we'd need to copy it from the previous thread_info, but
+ * doing that might fault causing more problems.
+ * TODO: what to do with accounting?
+ */
+static void emerg_stack_init_thread_info(struct thread_info *ti, int cpu)
+{
+	ti->task = NULL;
+	ti->cpu = cpu;
+	ti->preempt_count = 0;
+	ti->local_flags = 0;
+	ti->flags = 0;
+	klp_init_thread_info(ti);
+}
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled. Exclusive emergency
 	 * Since we use these as temporary stacks during secondary CPU
 	 * bringup, we need to get at them in real mode. This means they
 	 * must also be within the RMO region.
+	 *
+	 * The IRQ stacks allocated elsewhere in this file are zeroed and
+	 * initialized in kernel/irq.c. These are initialized here in order
+	 * to have emergency stacks available as early as possible.
 	 */
 	limit = min(safe_stack_limit(), ppc64_rma_size);
 	for_each_possible_cpu(i) {
 		struct thread_info *ti;
 		ti = __va(memblock_alloc_base(THREAD_SIZE, THREAD_SIZE, limit));
-		klp_init_thread_info(ti);
+		memset(ti, 0, THREAD_SIZE);
+		emerg_stack_init_thread_info(ti, i);
 		paca[i].emergency_sp = (void *)ti + THREAD_SIZE;
 #ifdef CONFIG_PPC_BOOK3S_64
 		/* emergency stack for NMI exception handling. */
 		ti = __va(memblock_alloc_base(THREAD_SIZE, THREAD_SIZE, limit));
-		klp_init_thread_info(ti);
+		memset(ti, 0, THREAD_SIZE);
+		emerg_stack_init_thread_info(ti, i);
 		paca[i].nmi_emergency_sp = (void *)ti + THREAD_SIZE;
 		/* emergency stack for machine check exception handling. */
 		ti = __va(memblock_alloc_base(THREAD_SIZE, THREAD_SIZE, limit));
-		klp_init_thread_info(ti);
+		memset(ti, 0, THREAD_SIZE);
+		emerg_stack_init_thread_info(ti, i);
 		paca[i].mc_emergency_sp = (void *)ti + THREAD_SIZE;
 #endif
 	}

arch/powerpc/kernel/trace/ftrace_64_mprofile.S+46−13

@@ -45,10 +45,14 @@ _GLOBAL(ftrace_caller) · 44 unmodified lines
45	stdu r1,-SWITCH_FRAME_SIZE(r1)	45	stdu r1,-SWITCH_FRAME_SIZE(r1)
46		46
47	/* Save all gprs to pt_regs */	47	/* Save all gprs to pt_regs */
48	SAVE_8GPRS(0,r1)	48	SAVE_GPR(0, r1)
49	SAVE_8GPRS(8,r1)	49	SAVE_10GPRS(2, r1)
50	SAVE_8GPRS(16,r1)	50	SAVE_10GPRS(12, r1)
51	SAVE_8GPRS(24,r1)	51	SAVE_10GPRS(22, r1)
		52
		53	/* Save previous stack pointer (r1) */
		54	addi r8, r1, SWITCH_FRAME_SIZE
		55	std r8, GPR1(r1)
52		56
53	/* Load special regs for save below */	57	/* Load special regs for save below */
54	mfmsr r8	58	mfmsr r8
@@ -95,18 +99,44 @@ ftrace_call: · 40 unmodified lines
95	bl ftrace_stub	99	bl ftrace_stub
96	nop	100	nop
97		101
98	/* Load ctr with the possibly modified NIP */	102	/* Load the possibly modified NIP */
99	ld r3, _NIP(r1)	103	ld r15, _NIP(r1)
100	mtctr r3	104
101	#ifdef CONFIG_LIVEPATCH	105	#ifdef CONFIG_LIVEPATCH
102	cmpd r14,r3 /* has NIP been altered? */	106	cmpd r14, r15 /* has NIP been altered? */
		107	#endif
		108
		109	#if defined(CONFIG_LIVEPATCH) && defined(CONFIG_KPROBES_ON_FTRACE)
		110	/* NIP has not been altered, skip over further checks */
		111	beq 1f
		112
		113	/* Check if there is an active kprobe on us */
		114	subi r3, r14, 4
		115	bl is_current_kprobe_addr
		116	nop
		117
		118	/*
		119	* If r3 == 1, then this is a kprobe/jprobe.
		120	* else, this is livepatched function.
		121	*
		122	* The conditional branch for livepatch_handler below will use the
		123	* result of this comparison. For kprobe/jprobe, we just need to branch to
		124	* the new NIP, not call livepatch_handler. The branch below is bne, so we
		125	* want CR0[EQ] to be true if this is a kprobe/jprobe. Which means we want
		126	* CR0[EQ] = (r3 == 1).
		127	*/
		128	cmpdi r3, 1
		129	1:
103	#endif	130	#endif
104		131
		132	/* Load CTR with the possibly modified NIP */
		133	mtctr r15
		134
105	/* Restore gprs */	135	/* Restore gprs */
106	REST_8GPRS(0,r1)	136	REST_GPR(0,r1)
107	REST_8GPRS(8,r1)	137	REST_10GPRS(2,r1)
108	REST_8GPRS(16,r1)	138	REST_10GPRS(12,r1)
109	REST_8GPRS(24,r1)	139	REST_10GPRS(22,r1)
110		140
111	/* Restore possibly modified LR */	141	/* Restore possibly modified LR */
112	ld r0, _LINK(r1)	142	ld r0, _LINK(r1)
@@ -119,7 +149,10 @@ ftrace_call: · 6 unmodified lines
119	addi r1, r1, SWITCH_FRAME_SIZE	149	addi r1, r1, SWITCH_FRAME_SIZE
120		150
121	#ifdef CONFIG_LIVEPATCH	151	#ifdef CONFIG_LIVEPATCH
122	/* Based on the cmpd above, if the NIP was altered handle livepatch */	152	/*
		153	* Based on the cmpd or cmpdi above, if the NIP was altered and we're
		154	* not on a kprobe/jprobe, then handle livepatch.
		155	*/
123	bne- livepatch_handler	156	bne- livepatch_handler
124	#endif	157	#endif
125		158

arch/powerpc/kvm/book3s_hv.c+51−0

@@ -1486,6 +1486,14 @@ static int kvmppc_set_one_reg_hv(struct kvm_vcpu *vcpu, u64 id, · 1485 unmodified lines
1486	r = set_vpa(vcpu, &vcpu->arch.dtl, addr, len);	1486	r = set_vpa(vcpu, &vcpu->arch.dtl, addr, len);
1487	break;	1487	break;
1488	case KVM_REG_PPC_TB_OFFSET:	1488	case KVM_REG_PPC_TB_OFFSET:
		1489	/*
		1490	* POWER9 DD1 has an erratum where writing TBU40 causes
		1491	* the timebase to lose ticks. So we don't let the
		1492	* timebase offset be changed on P9 DD1. (It is
		1493	* initialized to zero.)
		1494	*/
		1495	if (cpu_has_feature(CPU_FTR_POWER9_DD1))
		1496	break;
1489	/* round up to multiple of 2^24 */	1497	/* round up to multiple of 2^24 */
1490	vcpu->arch.vcore->tb_offset =	1498	vcpu->arch.vcore->tb_offset =
1491	ALIGN(set_reg_val(id, *val), 1UL << 24);	1499	ALIGN(set_reg_val(id, *val), 1UL << 24);
@@ -2907,12 +2915,36 @@ static int kvmppc_vcpu_run_hv(struct kvm_run run, struct kvm_vcpu vcpu) · 1415 unmodified lines
2907	{	2915	{
2908	int r;	2916	int r;
2909	int srcu_idx;	2917	int srcu_idx;
		2918	unsigned long ebb_regs[3] = {}; /* shut up GCC */
		2919	unsigned long user_tar = 0;
		2920	unsigned int user_vrsave;
2910		2921
2911	if (!vcpu->arch.sane) {	2922	if (!vcpu->arch.sane) {
2912	run->exit_reason = KVM_EXIT_INTERNAL_ERROR;	2923	run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
2913	return -EINVAL;	2924	return -EINVAL;
2914	}	2925	}
2915		2926
		2927	/*
		2928	* Don't allow entry with a suspended transaction, because
		2929	* the guest entry/exit code will lose it.
		2930	* If the guest has TM enabled, save away their TM-related SPRs
		2931	* (they will get restored by the TM unavailable interrupt).
		2932	*/
		2933	#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
		2934	if (cpu_has_feature(CPU_FTR_TM) && current->thread.regs &&
		2935	(current->thread.regs->msr & MSR_TM)) {
		2936	if (MSR_TM_ACTIVE(current->thread.regs->msr)) {
		2937	run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		2938	run->fail_entry.hardware_entry_failure_reason = 0;
		2939	return -EINVAL;
		2940	}
		2941	current->thread.tm_tfhar = mfspr(SPRN_TFHAR);
		2942	current->thread.tm_tfiar = mfspr(SPRN_TFIAR);
		2943	current->thread.tm_texasr = mfspr(SPRN_TEXASR);
		2944	current->thread.regs->msr &= ~MSR_TM;
		2945	}
		2946	#endif
		2947
2916	kvmppc_core_prepare_to_enter(vcpu);	2948	kvmppc_core_prepare_to_enter(vcpu);
2917		2949
2918	/* No need to go into the guest when all we'll do is come back out */	2950	/* No need to go into the guest when all we'll do is come back out */
@@ -2934,6 +2966,15 @@ static int kvmppc_vcpu_run_hv(struct kvm_run run, struct kvm_vcpu vcpu) · 15 unmodified lines
2934		2966
2935	flush_all_to_thread(current);	2967	flush_all_to_thread(current);
2936		2968
		2969	/* Save userspace EBB and other register values */
		2970	if (cpu_has_feature(CPU_FTR_ARCH_207S)) {
		2971	ebb_regs[0] = mfspr(SPRN_EBBHR);
		2972	ebb_regs[1] = mfspr(SPRN_EBBRR);
		2973	ebb_regs[2] = mfspr(SPRN_BESCR);
		2974	user_tar = mfspr(SPRN_TAR);
		2975	}
		2976	user_vrsave = mfspr(SPRN_VRSAVE);
		2977
2937	vcpu->arch.wqp = &vcpu->arch.vcore->wq;	2978	vcpu->arch.wqp = &vcpu->arch.vcore->wq;
2938	vcpu->arch.pgdir = current->mm->pgd;	2979	vcpu->arch.pgdir = current->mm->pgd;
2939	vcpu->arch.state = KVMPPC_VCPU_BUSY_IN_HOST;	2980	vcpu->arch.state = KVMPPC_VCPU_BUSY_IN_HOST;
@@ -2960,6 +3001,16 @@ static int kvmppc_vcpu_run_hv(struct kvm_run run, struct kvm_vcpu vcpu) · 20 unmodified lines
2960	}	3001	}
2961	} while (is_kvmppc_resume_guest(r));	3002	} while (is_kvmppc_resume_guest(r));
2962		3003
		3004	/* Restore userspace EBB and other register values */
		3005	if (cpu_has_feature(CPU_FTR_ARCH_207S)) {
		3006	mtspr(SPRN_EBBHR, ebb_regs[0]);
		3007	mtspr(SPRN_EBBRR, ebb_regs[1]);
		3008	mtspr(SPRN_BESCR, ebb_regs[2]);
		3009	mtspr(SPRN_TAR, user_tar);
		3010	mtspr(SPRN_FSCR, current->thread.fscr);
		3011	}
		3012	mtspr(SPRN_VRSAVE, user_vrsave);
		3013
2963	out:	3014	out:
2964	vcpu->arch.state = KVMPPC_VCPU_NOTREADY;	3015	vcpu->arch.state = KVMPPC_VCPU_NOTREADY;
2965	atomic_dec(&vcpu->kvm->arch.vcpus_running);	3016	atomic_dec(&vcpu->kvm->arch.vcpus_running);

arch/powerpc/kvm/book3s_hv_interrupts.S+11−1

 	 * Put whatever is in the decrementer into the
 	 * hypervisor decrementer.
 	 */
+BEGIN_FTR_SECTION
+	ld	r5, HSTATE_KVM_VCORE(r13)
+	ld	r6, VCORE_KVM(r5)
+	ld	r9, KVM_HOST_LPCR(r6)
+	andis.	r9, r9, LPCR_LD@h
+END_FTR_SECTION_IFSET(CPU_FTR_ARCH_300)
 	mfspr	r8,SPRN_DEC
 	mftb	r7
-	mtspr	SPRN_HDEC,r8
+BEGIN_FTR_SECTION
+	/* On POWER9, don't sign-extend if host LPCR[LD] bit is set */
+	bne	32f
+END_FTR_SECTION_IFSET(CPU_FTR_ARCH_300)
 	extsw	r8,r8
+32:	mtspr	SPRN_HDEC,r8
 	add	r8,r8,r7
 	std	r8,HSTATE_DECEXP(r13)

arch/powerpc/kvm/book3s_hv_rmhandlers.S+56−19

 #include <asm/opal.h>
 #include <asm/xive-regs.h>
+/* Sign-extend HDEC if not on POWER9 */
+#define EXTEND_HDEC(reg)			\
+BEGIN_FTR_SECTION;				\
+	extsw	reg, reg;			\
+END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_300)
 #define VCPU_GPRS_TM(reg) (((reg) * ULONG_SIZE) + VCPU_GPR_TM)
 /* Values in HSTATE_NAPPING(r13) */
 #define NAPPING_CEDE	1
 #define NAPPING_NOVCPU	2
+/* Stack frame offsets for kvmppc_hv_entry */
+#define SFS			144
+#define STACK_SLOT_TRAP		(SFS-4)
+#define STACK_SLOT_TID		(SFS-16)
+#define STACK_SLOT_PSSCR	(SFS-24)
+#define STACK_SLOT_PID		(SFS-32)
+#define STACK_SLOT_IAMR		(SFS-40)
+#define STACK_SLOT_CIABR	(SFS-48)
+#define STACK_SLOT_DAWR		(SFS-56)
+#define STACK_SLOT_DAWRX	(SFS-64)
 /*
  * Call kvmppc_hv_entry in real mode.
  * Must be called with interrupts hard-disabled.
 kvmppc_primary_no_guest:
 	/* We handle this much like a ceded vcpu */
 	/* put the HDEC into the DEC, since HDEC interrupts don't wake us */
+	/* HDEC may be larger than DEC for arch >= v3.00, but since the */
+	/* HDEC value came from DEC in the first place, it will fit */
 	mfspr	r3, SPRN_HDEC
 	mtspr	SPRN_DEC, r3
 	/*
 	/* See if our timeslice has expired (HDEC is negative) */
 	mfspr	r0, SPRN_HDEC
+	EXTEND_HDEC(r0)
 	li	r12, BOOK3S_INTERRUPT_HV_DECREMENTER
-	cmpwi	r0, 0
+	cmpdi	r0, 0
 	blt	kvm_novcpu_exit
 	/* Got an IPI but other vcpus aren't yet exiting, must be a latecomer */
 	bl	kvmhv_accumulate_time
 #endif
 13:	mr	r3, r12
-	stw	r12, 112-4(r1)
+	stw	r12, STACK_SLOT_TRAP(r1)
 	bl	kvmhv_commence_exit
 	nop
-	lwz	r12, 112-4(r1)
+	lwz	r12, STACK_SLOT_TRAP(r1)
 	b	kvmhv_switch_to_host
 /*
 	lbz	r4, HSTATE_PTID(r13)
 	cmpwi	r4, 0
 	bne	63f
-	lis	r6, 0x7fff
+	LOAD_REG_ADDR(r6, decrementer_max)
-	ori	r6, r6, 0xffff
+	ld	r6, 0(r6)
 	mtspr	SPRN_HDEC, r6
 	/* and set per-LPAR registers, if doing dynamic micro-threading */
 	ld	r6, HSTATE_SPLIT_MODE(r13)
  *                                                                            *
  *****************************************************************************/
-/* Stack frame offsets */
-#define STACK_SLOT_TID		(112-16)
-#define STACK_SLOT_PSSCR	(112-24)
-#define STACK_SLOT_PID		(112-32)
 .global kvmppc_hv_entry
 kvmppc_hv_entry:
 	 */
 	mflr	r0
 	std	r0, PPC_LR_STKOFF(r1)
-	stdu	r1, -112(r1)
+	stdu	r1, -SFS(r1)
 	/* Save R1 in the PACA */
 	std	r1, HSTATE_HOST_R1(r13)
 	mfspr	r5, SPRN_TIDR
 	mfspr	r6, SPRN_PSSCR
 	mfspr	r7, SPRN_PID
+	mfspr	r8, SPRN_IAMR
 	std	r5, STACK_SLOT_TID(r1)
 	std	r6, STACK_SLOT_PSSCR(r1)
 	std	r7, STACK_SLOT_PID(r1)
+	std	r8, STACK_SLOT_IAMR(r1)
 END_FTR_SECTION_IFSET(CPU_FTR_ARCH_300)
+BEGIN_FTR_SECTION
+	mfspr	r5, SPRN_CIABR
+	mfspr	r6, SPRN_DAWR
+	mfspr	r7, SPRN_DAWRX
+	std	r5, STACK_SLOT_CIABR(r1)
+	std	r6, STACK_SLOT_DAWR(r1)
+	std	r7, STACK_SLOT_DAWRX(r1)
+END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
 BEGIN_FTR_SECTION
 	/* Set partition DABR */
 	/* Check if HDEC expires soon */
 	mfspr	r3, SPRN_HDEC
-	cmpwi	r3, 512		/* 1 microsecond */
+	EXTEND_HDEC(r3)
+	cmpdi	r3, 512		/* 1 microsecond */
 	blt	hdec_soon
 #ifdef CONFIG_KVM_XICS
 	 * set by the guest could disrupt the host.
 	 */
 	li	r0, 0
-	mtspr	SPRN_IAMR, r0
+	mtspr	SPRN_PSPB, r0
-	mtspr	SPRN_CIABR, r0
-	mtspr	SPRN_DAWRX, r0
 	mtspr	SPRN_WORT, r0
 BEGIN_FTR_SECTION
+	mtspr	SPRN_IAMR, r0
 	mtspr	SPRN_TCSCR, r0
 	/* Set MMCRS to 1<<31 to freeze and disable the SPMC counters */
 	li	r0, 1
 	std	r6,VCPU_UAMOR(r9)
 	li	r6,0
 	mtspr	SPRN_AMR,r6
+	mtspr	SPRN_UAMOR, r6
 	/* Switch DSCR back to host value */
 	mfspr	r8, SPRN_DSCR
 	ptesync
 	/* Restore host values of some registers */
+BEGIN_FTR_SECTION
+	ld	r5, STACK_SLOT_CIABR(r1)
+	ld	r6, STACK_SLOT_DAWR(r1)
+	ld	r7, STACK_SLOT_DAWRX(r1)
+	mtspr	SPRN_CIABR, r5
+	mtspr	SPRN_DAWR, r6
+	mtspr	SPRN_DAWRX, r7
+END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
 BEGIN_FTR_SECTION
 	ld	r5, STACK_SLOT_TID(r1)
 	ld	r6, STACK_SLOT_PSSCR(r1)
 	ld	r7, STACK_SLOT_PID(r1)
+	ld	r8, STACK_SLOT_IAMR(r1)
 	mtspr	SPRN_TIDR, r5
 	mtspr	SPRN_PSSCR, r6
 	mtspr	SPRN_PID, r7
+	mtspr	SPRN_IAMR, r8
 END_FTR_SECTION_IFSET(CPU_FTR_ARCH_300)
 BEGIN_FTR_SECTION
 	PPC_INVALIDATE_ERAT
 	li	r0, KVM_GUEST_MODE_NONE
 	stb	r0, HSTATE_IN_GUEST(r13)
-	ld	r0, 112+PPC_LR_STKOFF(r1)
+	ld	r0, SFS+PPC_LR_STKOFF(r1)
-	addi	r1, r1, 112
+	addi	r1, r1, SFS
 	mtlr	r0
 	blr
 	mfspr	r3, SPRN_DEC
 	mfspr	r4, SPRN_HDEC
 	mftb	r5
-	cmpw	r3, r4
+	extsw	r3, r3
+	EXTEND_HDEC(r4)
+	cmpd	r3, r4
 	ble	67f
 	mtspr	SPRN_DEC, r4
 67:
 	/* save expiry time of guest decrementer */
-	extsw	r3, r3
 	add	r3, r3, r5
 	ld	r4, HSTATE_KVM_VCPU(r13)
 	ld	r5, HSTATE_KVM_VCORE(r13)

arch/powerpc/kvm/book3s_xive_template.c+2−2

@@ -69,7 +69,7 @@ static void GLUE(X_PFX,source_eoi)(u32 hw_irq, struct xive_irq_data *xd) · 68 unmodified lines
69	{	69	{
70	/* If the XIVE supports the new "store EOI facility, use it */	70	/* If the XIVE supports the new "store EOI facility, use it */
71	if (xd->flags & XIVE_IRQ_FLAG_STORE_EOI)	71	if (xd->flags & XIVE_IRQ_FLAG_STORE_EOI)
72	__x_writeq(0, __x_eoi_page(xd));	72	__x_writeq(0, __x_eoi_page(xd) + XIVE_ESB_STORE_EOI);
73	else if (hw_irq && xd->flags & XIVE_IRQ_FLAG_EOI_FW) {	73	else if (hw_irq && xd->flags & XIVE_IRQ_FLAG_EOI_FW) {
74	opal_int_eoi(hw_irq);	74	opal_int_eoi(hw_irq);
75	} else {	75	} else {
@@ -89,7 +89,7 @@ static void GLUE(X_PFX,source_eoi)(u32 hw_irq, struct xive_irq_data *xd) · 13 unmodified lines
89	* properly.	89	* properly.
90	*/	90	*/
91	if (xd->flags & XIVE_IRQ_FLAG_LSI)	91	if (xd->flags & XIVE_IRQ_FLAG_LSI)
92	__x_readq(__x_eoi_page(xd));	92	__x_readq(__x_eoi_page(xd) + XIVE_ESB_LOAD_EOI);
93	else {	93	else {
94	eoi_val = GLUE(X_PFX,esb_load)(xd, XIVE_ESB_SET_PQ_00);	94	eoi_val = GLUE(X_PFX,esb_load)(xd, XIVE_ESB_SET_PQ_00);
95		95

arch/powerpc/mm/hugetlbpage-radix.c+1−1

@@ -68,7 +68,7 @@ radix__hugetlb_get_unmapped_area(struct file *file, unsigned long addr, · 67 unmodified lines
68	addr = ALIGN(addr, huge_page_size(h));	68	addr = ALIGN(addr, huge_page_size(h));
69	vma = find_vma(mm, addr);	69	vma = find_vma(mm, addr);
70	if (mm->task_size - len >= addr &&	70	if (mm->task_size - len >= addr &&
71	(!vma \|\| addr + len <= vma->vm_start))	71	(!vma \|\| addr + len <= vm_start_gap(vma)))
72	return addr;	72	return addr;
73	}	73	}
74	/*	74	/*

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

@@ -112,7 +112,7 @@ radix__arch_get_unmapped_area(struct file *filp, unsigned long addr, · 111 unmodified lines
112	addr = PAGE_ALIGN(addr);	112	addr = PAGE_ALIGN(addr);
113	vma = find_vma(mm, addr);	113	vma = find_vma(mm, addr);
114	if (mm->task_size - len >= addr && addr >= mmap_min_addr &&	114	if (mm->task_size - len >= addr && addr >= mmap_min_addr &&
115	(!vma \|\| addr + len <= vma->vm_start))	115	(!vma \|\| addr + len <= vm_start_gap(vma)))
116	return addr;	116	return addr;
117	}	117	}
118		118
@@ -157,7 +157,7 @@ radix__arch_get_unmapped_area_topdown(struct file *filp, · 38 unmodified lines
157	addr = PAGE_ALIGN(addr);	157	addr = PAGE_ALIGN(addr);
158	vma = find_vma(mm, addr);	158	vma = find_vma(mm, addr);
159	if (mm->task_size - len >= addr && addr >= mmap_min_addr &&	159	if (mm->task_size - len >= addr && addr >= mmap_min_addr &&
160	(!vma \|\| addr + len <= vma->vm_start))	160	(!vma \|\| addr + len <= vm_start_gap(vma)))
161	return addr;	161	return addr;
162	}	162	}
163		163

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

@@ -99,7 +99,7 @@ static int slice_area_is_free(struct mm_struct *mm, unsigned long addr, · 98 unmodified lines
99	if ((mm->task_size - len) < addr)	99	if ((mm->task_size - len) < addr)
100	return 0;	100	return 0;
101	vma = find_vma(mm, addr);	101	vma = find_vma(mm, addr);
102	return (!vma \|\| (addr + len) <= vma->vm_start);	102	return (!vma \|\| (addr + len) <= vm_start_gap(vma));
103	}	103	}
104		104
105	static int slice_low_has_vma(struct mm_struct *mm, unsigned long slice)	105	static int slice_low_has_vma(struct mm_struct *mm, unsigned long slice)

arch/powerpc/perf/perf_regs.c+2−1

@@ -101,5 +101,6 @@ void perf_get_regs_user(struct perf_regs *regs_user, · 100 unmodified lines
101	struct pt_regs *regs_user_copy)	101	struct pt_regs *regs_user_copy)
102	{	102	{
103	regs_user->regs = task_pt_regs(current);	103	regs_user->regs = task_pt_regs(current);
104	regs_user->abi = perf_reg_abi(current);	104	regs_user->abi = (regs_user->regs) ? perf_reg_abi(current) :
		105	PERF_SAMPLE_REGS_ABI_NONE;
105	}	106	}

arch/powerpc/platforms/powernv/npu-dma.c+67−30

 	if (WARN_ON(!gpdev))
 		return NULL;
-	if (WARN_ON(!gpdev->dev.of_node))
+	/* Not all PCI devices have device-tree nodes */
+	if (!gpdev->dev.of_node)
 		return NULL;
 	/* Get assoicated PCI device */
 	return mmio_atsd_reg;
 }
-static int mmio_invalidate_pid(struct npu *npu, unsigned long pid)
+static int mmio_invalidate_pid(struct npu *npu, unsigned long pid, bool flush)
 {
 	unsigned long launch;
 	/* PID */
 	launch |= pid << PPC_BITLSHIFT(38);
+	/* No flush */
+	launch |= !flush << PPC_BITLSHIFT(39);
 	/* Invalidating the entire process doesn't use a va */
 	return mmio_launch_invalidate(npu, launch, 0);
 }
 static int mmio_invalidate_va(struct npu *npu, unsigned long va,
-			unsigned long pid)
+			unsigned long pid, bool flush)
 {
 	unsigned long launch;
 	/* PID */
 	launch |= pid << PPC_BITLSHIFT(38);
+	/* No flush */
+	launch |= !flush << PPC_BITLSHIFT(39);
 	return mmio_launch_invalidate(npu, launch, va);
 }
 #define mn_to_npu_context(x) container_of(x, struct npu_context, mn)
+struct mmio_atsd_reg {
+	struct npu *npu;
+	int reg;
+};
+static void mmio_invalidate_wait(
+	struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS], bool flush)
+{
+	struct npu *npu;
+	int i, reg;
+	/* Wait for all invalidations to complete */
+	for (i = 0; i <= max_npu2_index; i++) {
+		if (mmio_atsd_reg[i].reg < 0)
+			continue;
+		/* Wait for completion */
+		npu = mmio_atsd_reg[i].npu;
+		reg = mmio_atsd_reg[i].reg;
+		while (__raw_readq(npu->mmio_atsd_regs[reg] + XTS_ATSD_STAT))
+			cpu_relax();
+		put_mmio_atsd_reg(npu, reg);
+		/*
+		 * The GPU requires two flush ATSDs to ensure all entries have
+		 * been flushed. We use PID 0 as it will never be used for a
+		 * process on the GPU.
+		 */
+		if (flush)
+			mmio_invalidate_pid(npu, 0, true);
+	}
+}
 /*
  * Invalidate either a single address or an entire PID depending on
  * the value of va.
  */
 static void mmio_invalidate(struct npu_context *npu_context, int va,
-			unsigned long address)
+			unsigned long address, bool flush)
 {
-	int i, j, reg;
+	int i, j;
 	struct npu *npu;
 	struct pnv_phb *nphb;
 	struct pci_dev *npdev;
-	struct {
+	struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS];
-		struct npu *npu;
-		int reg;
-	} mmio_atsd_reg[NV_MAX_NPUS];
 	unsigned long pid = npu_context->mm->context.id;
 	/*
 			if (va)
 				mmio_atsd_reg[i].reg =
-					mmio_invalidate_va(npu, address, pid);
+					mmio_invalidate_va(npu, address, pid,
+							flush);
 			else
 				mmio_atsd_reg[i].reg =
-					mmio_invalidate_pid(npu, pid);
+					mmio_invalidate_pid(npu, pid, flush);
 			/*
 			 * The NPU hardware forwards the shootdown to all GPUs
 	 */
 	flush_tlb_mm(npu_context->mm);
-	/* Wait for all invalidations to complete */
+	mmio_invalidate_wait(mmio_atsd_reg, flush);
-	for (i = 0; i <= max_npu2_index; i++) {
+	if (flush)
-		if (mmio_atsd_reg[i].reg < 0)
+		/* Wait for the flush to complete */
-			continue;
+		mmio_invalidate_wait(mmio_atsd_reg, false);
-		/* Wait for completion */
-		npu = mmio_atsd_reg[i].npu;
-		reg = mmio_atsd_reg[i].reg;
-		while (__raw_readq(npu->mmio_atsd_regs[reg] + XTS_ATSD_STAT))
-			cpu_relax();
-		put_mmio_atsd_reg(npu, reg);
-	}
 }
 static void pnv_npu2_mn_release(struct mmu_notifier *mn,
 	 * There should be no more translation requests for this PID, but we
 	 * need to ensure any entries for it are removed from the TLB.
 	 */
-	mmio_invalidate(npu_context, 0, 0);
+	mmio_invalidate(npu_context, 0, 0, true);
 }
 static void pnv_npu2_mn_change_pte(struct mmu_notifier *mn,
 {
 	struct npu_context *npu_context = mn_to_npu_context(mn);
-	mmio_invalidate(npu_context, 1, address);
+	mmio_invalidate(npu_context, 1, address, true);
 }
 static void pnv_npu2_mn_invalidate_page(struct mmu_notifier *mn,
 {
 	struct npu_context *npu_context = mn_to_npu_context(mn);
-	mmio_invalidate(npu_context, 1, address);
+	mmio_invalidate(npu_context, 1, address, true);
 }
 static void pnv_npu2_mn_invalidate_range(struct mmu_notifier *mn,
 	struct npu_context *npu_context = mn_to_npu_context(mn);
 	unsigned long address;
-	for (address = start; address <= end; address += PAGE_SIZE)
+	for (address = start; address < end; address += PAGE_SIZE)
-		mmio_invalidate(npu_context, 1, address);
+		mmio_invalidate(npu_context, 1, address, false);
+	/* Do the flush only on the final addess == end */
+	mmio_invalidate(npu_context, 1, address, true);
 }
 static const struct mmu_notifier_ops nv_nmmu_notifier_ops = {
 		/* No nvlink associated with this GPU device */
 		return ERR_PTR(-ENODEV);
-	if (!mm) {
+	if (!mm || mm->context.id == 0) {
-		/* kernel thread contexts are not supported */
+		/*
+		 * Kernel thread contexts are not supported and context id 0 is
+		 * reserved on the GPU.
+		 */
 		return ERR_PTR(-EINVAL);
 	}

arch/powerpc/sysdev/xive/common.c+1−1

@@ -297,7 +297,7 @@ void xive_do_source_eoi(u32 hw_irq, struct xive_irq_data *xd) · 296 unmodified lines
297	{	297	{
298	/* If the XIVE supports the new "store EOI facility, use it */	298	/* If the XIVE supports the new "store EOI facility, use it */
299	if (xd->flags & XIVE_IRQ_FLAG_STORE_EOI)	299	if (xd->flags & XIVE_IRQ_FLAG_STORE_EOI)
300	out_be64(xd->eoi_mmio, 0);	300	out_be64(xd->eoi_mmio + XIVE_ESB_STORE_EOI, 0);
301	else if (hw_irq && xd->flags & XIVE_IRQ_FLAG_EOI_FW) {	301	else if (hw_irq && xd->flags & XIVE_IRQ_FLAG_EOI_FW) {
302	/*	302	/*
303	* The FW told us to call it. This happens for some	303	* The FW told us to call it. This happens for some

arch/s390/configs/default_defconfig+33−6

 CONFIG_SCHED_AUTOGROUP=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_EXPERT=y
+# CONFIG_SYSFS_SYSCALL is not set
 CONFIG_BPF_SYSCALL=y
 CONFIG_USERFAULTFD=y
 # CONFIG_COMPAT_BRK is not set
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_BLK_DEV_INTEGRITY=y
 CONFIG_BLK_DEV_THROTTLING=y
+CONFIG_BLK_WBT=y
+CONFIG_BLK_WBT_SQ=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_IBM_PARTITION=y
 CONFIG_BSD_DISKLABEL=y
 CONFIG_UNIX_DIAG=m
 CONFIG_XFRM_USER=m
 CONFIG_NET_KEY=m
+CONFIG_SMC=m
+CONFIG_SMC_DIAG=m
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
 CONFIG_IP_ADVANCED_ROUTER=y
 CONFIG_NET_ACT_SKBEDIT=m
 CONFIG_NET_ACT_CSUM=m
 CONFIG_DNS_RESOLVER=y
+CONFIG_NETLINK_DIAG=m
 CONFIG_CGROUP_NET_PRIO=y
 CONFIG_BPF_JIT=y
 CONFIG_NET_PKTGEN=m
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_CONNECTOR=y
+CONFIG_ZRAM=m
 CONFIG_BLK_DEV_LOOP=m
 CONFIG_BLK_DEV_CRYPTOLOOP=m
+CONFIG_BLK_DEV_DRBD=m
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_OSD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=32768
-CONFIG_CDROM_PKTCDVD=m
+CONFIG_BLK_DEV_RAM_DAX=y
-CONFIG_ATA_OVER_ETH=m
 CONFIG_VIRTIO_BLK=y
+CONFIG_BLK_DEV_RBD=m
 CONFIG_ENCLOSURE_SERVICES=m
+CONFIG_GENWQE=m
 CONFIG_RAID_ATTRS=m
 CONFIG_SCSI=y
 CONFIG_BLK_DEV_SD=y
 # CONFIG_NET_VENDOR_INTEL is not set
 # CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
+CONFIG_MLX5_CORE=m
+CONFIG_MLX5_CORE_EN=y
 # CONFIG_NET_VENDOR_NATSEMI is not set
 CONFIG_PPP=m
 CONFIG_PPP_BSDCOMP=m
 CONFIG_PPPOL2TP=m
 CONFIG_PPP_ASYNC=m
 CONFIG_PPP_SYNC_TTY=m
-# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_SERIO is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
+CONFIG_MLX5_INFINIBAND=m
 CONFIG_VIRTIO_BALLOON=m
 CONFIG_EXT4_FS=y
 CONFIG_EXT4_FS_POSIX_ACL=y
 CONFIG_XFS_RT=y
 CONFIG_XFS_DEBUG=y
 CONFIG_GFS2_FS=m
+CONFIG_GFS2_FS_LOCKING_DLM=y
 CONFIG_OCFS2_FS=m
 CONFIG_BTRFS_FS=y
 CONFIG_BTRFS_FS_POSIX_ACL=y
+CONFIG_BTRFS_DEBUG=y
 CONFIG_NILFS2_FS=m
+CONFIG_FS_DAX=y
+CONFIG_EXPORTFS_BLOCK_OPS=y
 CONFIG_FANOTIFY=y
+CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y
 CONFIG_QUOTA_NETLINK_INTERFACE=y
+CONFIG_QUOTA_DEBUG=y
 CONFIG_QFMT_V1=m
 CONFIG_QFMT_V2=m
 CONFIG_AUTOFS4_FS=m
 CONFIG_DEBUG_SECTION_MISMATCH=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_PAGEALLOC=y
+CONFIG_DEBUG_RODATA_TEST=y
 CONFIG_DEBUG_OBJECTS=y
 CONFIG_DEBUG_OBJECTS_SELFTEST=y
 CONFIG_DEBUG_OBJECTS_FREE=y
 CONFIG_WQ_WATCHDOG=y
 CONFIG_PANIC_ON_OOPS=y
 CONFIG_DEBUG_TIMEKEEPING=y
-CONFIG_TIMER_STATS=y
 CONFIG_DEBUG_RT_MUTEXES=y
 CONFIG_DEBUG_WW_MUTEX_SLOWPATH=y
 CONFIG_PROVE_LOCKING=y
 CONFIG_RCU_CPU_STALL_TIMEOUT=300
 CONFIG_NOTIFIER_ERROR_INJECTION=m
 CONFIG_PM_NOTIFIER_ERROR_INJECT=m
+CONFIG_NETDEV_NOTIFIER_ERROR_INJECT=m
 CONFIG_FAULT_INJECTION=y
 CONFIG_FAILSLAB=y
 CONFIG_FAIL_PAGE_ALLOC=y
 CONFIG_TRACE_ENUM_MAP_FILE=y
 CONFIG_LKDTM=m
 CONFIG_TEST_LIST_SORT=y
+CONFIG_TEST_SORT=y
 CONFIG_KPROBES_SANITY_TEST=y
 CONFIG_RBTREE_TEST=y
 CONFIG_INTERVAL_TREE_TEST=m
 CONFIG_PERCPU_TEST=m
 CONFIG_ATOMIC64_SELFTEST=y
-CONFIG_TEST_STRING_HELPERS=y
-CONFIG_TEST_KSTRTOX=y
 CONFIG_DMA_API_DEBUG=y
 CONFIG_TEST_BPF=m
 CONFIG_BUG_ON_DATA_CORRUPTION=y
 CONFIG_ENCRYPTED_KEYS=m
 CONFIG_SECURITY=y
 CONFIG_SECURITY_NETWORK=y
+CONFIG_HARDENED_USERCOPY=y
 CONFIG_SECURITY_SELINUX=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=0
 CONFIG_CRYPTO_DH=m
 CONFIG_CRYPTO_ECDH=m
 CONFIG_CRYPTO_USER=m
+CONFIG_CRYPTO_PCRYPT=m
 CONFIG_CRYPTO_CRYPTD=m
+CONFIG_CRYPTO_MCRYPTD=m
 CONFIG_CRYPTO_TEST=m
 CONFIG_CRYPTO_CCM=m
 CONFIG_CRYPTO_GCM=m
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_KEYWRAP=m
+CONFIG_CRYPTO_CMAC=m
 CONFIG_CRYPTO_XCBC=m
 CONFIG_CRYPTO_VMAC=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_RMD256=m
 CONFIG_CRYPTO_RMD320=m
 CONFIG_CRYPTO_SHA512=m
+CONFIG_CRYPTO_SHA3=m
 CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_WP512=m
+CONFIG_CRYPTO_AES_TI=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_CAMELLIA=m
 CONFIG_CRYPTO_842=m
 CONFIG_CRYPTO_LZ4=m
 CONFIG_CRYPTO_LZ4HC=m
+CONFIG_CRYPTO_ANSI_CPRNG=m
 CONFIG_CRYPTO_USER_API_HASH=m
 CONFIG_CRYPTO_USER_API_SKCIPHER=m
 CONFIG_CRYPTO_USER_API_RNG=m
 CONFIG_CRYPTO_SHA512_S390=m
 CONFIG_CRYPTO_DES_S390=m
 CONFIG_CRYPTO_AES_S390=m
+CONFIG_CRYPTO_PAES_S390=m
 CONFIG_CRYPTO_GHASH_S390=m
 CONFIG_CRYPTO_CRC32_S390=y
 CONFIG_ASYMMETRIC_KEY_TYPE=y
 CONFIG_X509_CERTIFICATE_PARSER=m
 CONFIG_CRC7=m
 CONFIG_CRC8=m
+CONFIG_RANDOM32_SELFTEST=y
 CONFIG_CORDIC=m
 CONFIG_CMM=m
 CONFIG_APPLDATA_BASE=y

arch/s390/configs/gcov_defconfig+24−4

 CONFIG_SCHED_AUTOGROUP=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_EXPERT=y
+# CONFIG_SYSFS_SYSCALL is not set
 CONFIG_BPF_SYSCALL=y
 CONFIG_USERFAULTFD=y
 # CONFIG_COMPAT_BRK is not set
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_BLK_DEV_INTEGRITY=y
 CONFIG_BLK_DEV_THROTTLING=y
+CONFIG_BLK_WBT=y
+CONFIG_BLK_WBT_SQ=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_IBM_PARTITION=y
 CONFIG_BSD_DISKLABEL=y
 CONFIG_UNIX_DIAG=m
 CONFIG_XFRM_USER=m
 CONFIG_NET_KEY=m
+CONFIG_SMC=m
+CONFIG_SMC_DIAG=m
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
 CONFIG_IP_ADVANCED_ROUTER=y
 CONFIG_NET_ACT_SKBEDIT=m
 CONFIG_NET_ACT_CSUM=m
 CONFIG_DNS_RESOLVER=y
+CONFIG_NETLINK_DIAG=m
 CONFIG_CGROUP_NET_PRIO=y
 CONFIG_BPF_JIT=y
 CONFIG_NET_PKTGEN=m
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_CONNECTOR=y
+CONFIG_ZRAM=m
 CONFIG_BLK_DEV_LOOP=m
 CONFIG_BLK_DEV_CRYPTOLOOP=m
+CONFIG_BLK_DEV_DRBD=m
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_OSD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=32768
-CONFIG_CDROM_PKTCDVD=m
+CONFIG_BLK_DEV_RAM_DAX=y
-CONFIG_ATA_OVER_ETH=m
 CONFIG_VIRTIO_BLK=y
 CONFIG_ENCLOSURE_SERVICES=m
+CONFIG_GENWQE=m
 CONFIG_RAID_ATTRS=m
 CONFIG_SCSI=y
 CONFIG_BLK_DEV_SD=y
 # CONFIG_NET_VENDOR_INTEL is not set
 # CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
+CONFIG_MLX5_CORE=m
+CONFIG_MLX5_CORE_EN=y
 # CONFIG_NET_VENDOR_NATSEMI is not set
 CONFIG_PPP=m
 CONFIG_PPP_BSDCOMP=m
 CONFIG_PPPOL2TP=m
 CONFIG_PPP_ASYNC=m
 CONFIG_PPP_SYNC_TTY=m
-# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_SERIO is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
+CONFIG_MLX5_INFINIBAND=m
 CONFIG_VIRTIO_BALLOON=m
 CONFIG_EXT4_FS=y
 CONFIG_EXT4_FS_POSIX_ACL=y
 CONFIG_XFS_POSIX_ACL=y
 CONFIG_XFS_RT=y
 CONFIG_GFS2_FS=m
+CONFIG_GFS2_FS_LOCKING_DLM=y
 CONFIG_OCFS2_FS=m
 CONFIG_BTRFS_FS=y
 CONFIG_BTRFS_FS_POSIX_ACL=y
 CONFIG_NILFS2_FS=m
+CONFIG_FS_DAX=y
+CONFIG_EXPORTFS_BLOCK_OPS=y
 CONFIG_FANOTIFY=y
+CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y
 CONFIG_QUOTA_NETLINK_INTERFACE=y
 CONFIG_QFMT_V1=m
 CONFIG_QFMT_V2=m
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_MEMORY_INIT=y
 CONFIG_PANIC_ON_OOPS=y
-CONFIG_TIMER_STATS=y
 CONFIG_RCU_TORTURE_TEST=m
 CONFIG_RCU_CPU_STALL_TIMEOUT=60
 CONFIG_LATENCYTOP=y
 CONFIG_ENCRYPTED_KEYS=m
 CONFIG_SECURITY=y
 CONFIG_SECURITY_NETWORK=y
+CONFIG_HARDENED_USERCOPY=y
 CONFIG_SECURITY_SELINUX=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=0
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_KEYWRAP=m
+CONFIG_CRYPTO_CMAC=m
 CONFIG_CRYPTO_XCBC=m
 CONFIG_CRYPTO_VMAC=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_SHA3=m
 CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_WP512=m
+CONFIG_CRYPTO_AES_TI=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_CAMELLIA=m
 CONFIG_CRYPTO_842=m
 CONFIG_CRYPTO_LZ4=m
 CONFIG_CRYPTO_LZ4HC=m
+CONFIG_CRYPTO_ANSI_CPRNG=m
 CONFIG_CRYPTO_USER_API_HASH=m
 CONFIG_CRYPTO_USER_API_SKCIPHER=m
 CONFIG_CRYPTO_USER_API_RNG=m
 CONFIG_CRYPTO_USER_API_AEAD=m
 CONFIG_ZCRYPT=m
+CONFIG_PKEY=m
 CONFIG_CRYPTO_SHA1_S390=m
 CONFIG_CRYPTO_SHA256_S390=m
 CONFIG_CRYPTO_SHA512_S390=m
 CONFIG_CRYPTO_DES_S390=m
 CONFIG_CRYPTO_AES_S390=m
+CONFIG_CRYPTO_PAES_S390=m
 CONFIG_CRYPTO_GHASH_S390=m
 CONFIG_CRYPTO_CRC32_S390=y
 CONFIG_CRC7=m

arch/s390/configs/performance_defconfig+23−4

 CONFIG_SCHED_AUTOGROUP=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_EXPERT=y
+# CONFIG_SYSFS_SYSCALL is not set
 CONFIG_BPF_SYSCALL=y
 CONFIG_USERFAULTFD=y
 # CONFIG_COMPAT_BRK is not set
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_BLK_DEV_INTEGRITY=y
 CONFIG_BLK_DEV_THROTTLING=y
+CONFIG_BLK_WBT=y
+CONFIG_BLK_WBT_SQ=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_IBM_PARTITION=y
 CONFIG_BSD_DISKLABEL=y
 CONFIG_UNIX_DIAG=m
 CONFIG_XFRM_USER=m
 CONFIG_NET_KEY=m
+CONFIG_SMC=m
+CONFIG_SMC_DIAG=m
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
 CONFIG_IP_ADVANCED_ROUTER=y
 CONFIG_NET_ACT_SKBEDIT=m
 CONFIG_NET_ACT_CSUM=m
 CONFIG_DNS_RESOLVER=y
+CONFIG_NETLINK_DIAG=m
 CONFIG_CGROUP_NET_PRIO=y
 CONFIG_BPF_JIT=y
 CONFIG_NET_PKTGEN=m
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_CONNECTOR=y
+CONFIG_ZRAM=m
 CONFIG_BLK_DEV_LOOP=m
 CONFIG_BLK_DEV_CRYPTOLOOP=m
+CONFIG_BLK_DEV_DRBD=m
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_OSD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=32768
-CONFIG_CDROM_PKTCDVD=m
+CONFIG_BLK_DEV_RAM_DAX=y
-CONFIG_ATA_OVER_ETH=m
 CONFIG_VIRTIO_BLK=y
 CONFIG_ENCLOSURE_SERVICES=m
+CONFIG_GENWQE=m
 CONFIG_RAID_ATTRS=m
 CONFIG_SCSI=y
 CONFIG_BLK_DEV_SD=y
 # CONFIG_NET_VENDOR_INTEL is not set
 # CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
+CONFIG_MLX5_CORE=m
+CONFIG_MLX5_CORE_EN=y
 # CONFIG_NET_VENDOR_NATSEMI is not set
 CONFIG_PPP=m
 CONFIG_PPP_BSDCOMP=m
 CONFIG_PPPOL2TP=m
 CONFIG_PPP_ASYNC=m
 CONFIG_PPP_SYNC_TTY=m
-# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_SERIO is not set
 CONFIG_INFINIBAND=m
 CONFIG_INFINIBAND_USER_ACCESS=m
 CONFIG_MLX4_INFINIBAND=m
+CONFIG_MLX5_INFINIBAND=m
 CONFIG_VIRTIO_BALLOON=m
 CONFIG_EXT4_FS=y
 CONFIG_EXT4_FS_POSIX_ACL=y
 CONFIG_XFS_POSIX_ACL=y
 CONFIG_XFS_RT=y
 CONFIG_GFS2_FS=m
+CONFIG_GFS2_FS_LOCKING_DLM=y
 CONFIG_OCFS2_FS=m
 CONFIG_BTRFS_FS=y
 CONFIG_BTRFS_FS_POSIX_ACL=y
 CONFIG_NILFS2_FS=m
+CONFIG_FS_DAX=y
+CONFIG_EXPORTFS_BLOCK_OPS=y
 CONFIG_FANOTIFY=y
+CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y
 CONFIG_QUOTA_NETLINK_INTERFACE=y
 CONFIG_QFMT_V1=m
 CONFIG_QFMT_V2=m
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_MEMORY_INIT=y
 CONFIG_PANIC_ON_OOPS=y
-CONFIG_TIMER_STATS=y
 CONFIG_RCU_TORTURE_TEST=m
 CONFIG_RCU_CPU_STALL_TIMEOUT=60
 CONFIG_LATENCYTOP=y
 CONFIG_ENCRYPTED_KEYS=m
 CONFIG_SECURITY=y
 CONFIG_SECURITY_NETWORK=y
+CONFIG_HARDENED_USERCOPY=y
 CONFIG_SECURITY_SELINUX=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM=y
 CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=0
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_KEYWRAP=m
+CONFIG_CRYPTO_CMAC=m
 CONFIG_CRYPTO_XCBC=m
 CONFIG_CRYPTO_VMAC=m
 CONFIG_CRYPTO_CRC32=m
 CONFIG_CRYPTO_SHA3=m
 CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_WP512=m
+CONFIG_CRYPTO_AES_TI=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_CAMELLIA=m
 CONFIG_CRYPTO_842=m
 CONFIG_CRYPTO_LZ4=m
 CONFIG_CRYPTO_LZ4HC=m
+CONFIG_CRYPTO_ANSI_CPRNG=m
 CONFIG_CRYPTO_USER_API_HASH=m
 CONFIG_CRYPTO_USER_API_SKCIPHER=m
 CONFIG_CRYPTO_USER_API_RNG=m
 CONFIG_CRYPTO_SHA512_S390=m
 CONFIG_CRYPTO_DES_S390=m
 CONFIG_CRYPTO_AES_S390=m
+CONFIG_CRYPTO_PAES_S390=m
 CONFIG_CRYPTO_GHASH_S390=m
 CONFIG_CRYPTO_CRC32_S390=y
 CONFIG_CRC7=m

arch/s390/configs/zfcpdump_defconfig+4−2

 CONFIG_NR_CPUS=2
 # CONFIG_HOTPLUG_CPU is not set
 CONFIG_HZ_100=y
+# CONFIG_ARCH_RANDOM is not set
 # CONFIG_COMPACTION is not set
 # CONFIG_MIGRATION is not set
+# CONFIG_BOUNCE is not set
 # CONFIG_CHECK_STACK is not set
 # CONFIG_CHSC_SCH is not set
 # CONFIG_SCM_BUS is not set
 CONFIG_SCSI_LOGGING=y
 CONFIG_SCSI_FC_ATTRS=y
 CONFIG_ZFCP=y
-# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_SERIO is not set
 # CONFIG_HVC_IUCV is not set
+# CONFIG_HW_RANDOM_S390 is not set
 CONFIG_RAW_DRIVER=y
 # CONFIG_SCLP_ASYNC is not set
 # CONFIG_HMC_DRV is not set
 # CONFIG_INOTIFY_USER is not set
 CONFIG_CONFIGFS_FS=y
 # CONFIG_MISC_FILESYSTEMS is not set
+# CONFIG_NETWORK_FILESYSTEMS is not set
 CONFIG_PRINTK_TIME=y
 CONFIG_DEBUG_INFO=y
-CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_PANIC_ON_OOPS=y
 # CONFIG_SCHED_DEBUG is not set

arch/s390/defconfig+3−5

 CONFIG_USER_NS=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_EXPERT=y
+# CONFIG_SYSFS_SYSCALL is not set
 CONFIG_BPF_SYSCALL=y
 CONFIG_USERFAULTFD=y
 # CONFIG_COMPAT_BRK is not set
 CONFIG_SCSI_VIRTIO=y
 CONFIG_MD=y
 CONFIG_MD_LINEAR=m
-CONFIG_MD_RAID0=m
 CONFIG_MD_MULTIPATH=m
 CONFIG_BLK_DEV_DM=y
 CONFIG_DM_CRYPT=m
 CONFIG_VIRTIO_NET=y
 # CONFIG_NET_VENDOR_ALACRITECH is not set
 # CONFIG_NET_VENDOR_SOLARFLARE is not set
+# CONFIG_NET_VENDOR_SYNOPSYS is not set
 # CONFIG_INPUT is not set
 # CONFIG_SERIO is not set
 CONFIG_DEVKMEM=y
 CONFIG_DEBUG_PAGEALLOC=y
 CONFIG_DETECT_HUNG_TASK=y
 CONFIG_PANIC_ON_OOPS=y
-CONFIG_TIMER_STATS=y
 CONFIG_DEBUG_RT_MUTEXES=y
 CONFIG_PROVE_LOCKING=y
 CONFIG_LOCK_STAT=y
 CONFIG_DEBUG_SG=y
 CONFIG_DEBUG_NOTIFIERS=y
 CONFIG_RCU_CPU_STALL_TIMEOUT=60
-CONFIG_RCU_TRACE=y
 CONFIG_LATENCYTOP=y
 CONFIG_SCHED_TRACER=y
 CONFIG_FTRACE_SYSCALLS=y
 CONFIG_TRACER_SNAPSHOT_PER_CPU_SWAP=y
 CONFIG_STACK_TRACER=y
 CONFIG_BLK_DEV_IO_TRACE=y
-CONFIG_UPROBE_EVENTS=y
 CONFIG_FUNCTION_PROFILER=y
 CONFIG_TRACE_ENUM_MAP_FILE=y
 CONFIG_KPROBES_SANITY_TEST=y
 CONFIG_CRYPTO_GCM=m
 CONFIG_CRYPTO_CBC=y
 CONFIG_CRYPTO_CTS=m
-CONFIG_CRYPTO_ECB=m
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_XTS=m
 CONFIG_CRYPTO_USER_API_RNG=m
 CONFIG_ZCRYPT=m
 CONFIG_PKEY=m
+CONFIG_CRYPTO_PAES_S390=m
 CONFIG_CRYPTO_SHA1_S390=m
 CONFIG_CRYPTO_SHA256_S390=m
 CONFIG_CRYPTO_SHA512_S390=m

arch/s390/kernel/entry.S+13−6

 	lctlg	%c1,%c1,__LC_USER_ASCE		# load primary asce
 .Lsie_done:
 # some program checks are suppressing. C code (e.g. do_protection_exception)
-# will rewind the PSW by the ILC, which is 4 bytes in case of SIE. Other
+# will rewind the PSW by the ILC, which is often 4 bytes in case of SIE. There
-# instructions between sie64a and .Lsie_done should not cause program
+# are some corner cases (e.g. runtime instrumentation) where ILC is unpredictable.
-# interrupts. So lets use a nop (47 00 00 00) as a landing pad.
+# Other instructions between sie64a and .Lsie_done should not cause program
+# interrupts. So lets use 3 nops as a landing pad for all possible rewinds.
 # See also .Lcleanup_sie
-.Lrewind_pad:
+.Lrewind_pad6:
-	nop	0
+	nopr	7
+.Lrewind_pad4:
+	nopr	7
+.Lrewind_pad2:
+	nopr	7
 	.globl sie_exit
 sie_exit:
 	lg	%r14,__SF_EMPTY+8(%r15)		# load guest register save area
 	stg	%r14,__SF_EMPTY+16(%r15)	# set exit reason code
 	j	sie_exit
-	EX_TABLE(.Lrewind_pad,.Lsie_fault)
+	EX_TABLE(.Lrewind_pad6,.Lsie_fault)
+	EX_TABLE(.Lrewind_pad4,.Lsie_fault)
+	EX_TABLE(.Lrewind_pad2,.Lsie_fault)
 	EX_TABLE(sie_exit,.Lsie_fault)
 EXPORT_SYMBOL(sie64a)
 EXPORT_SYMBOL(sie_exit)

arch/s390/kvm/gaccess.c+6−9

 	ptr = asce.origin * 4096;
 	if (asce.r) {
 		*fake = 1;
+		ptr = 0;
 		asce.dt = ASCE_TYPE_REGION1;
 	}
 	switch (asce.dt) {
 	case ASCE_TYPE_REGION1:
-		if (vaddr.rfx01 > asce.tl && !asce.r)
+		if (vaddr.rfx01 > asce.tl && !*fake)
 			return PGM_REGION_FIRST_TRANS;
 		break;
 	case ASCE_TYPE_REGION2:
 		union region1_table_entry rfte;
 		if (*fake) {
-			/* offset in 16EB guest memory block */
+			ptr += (unsigned long) vaddr.rfx << 53;
-			ptr = ptr + ((unsigned long) vaddr.rsx << 53UL);
 			rfte.val = ptr;
 			goto shadow_r2t;
 		}
 		union region2_table_entry rste;
 		if (*fake) {
-			/* offset in 8PB guest memory block */
+			ptr += (unsigned long) vaddr.rsx << 42;
-			ptr = ptr + ((unsigned long) vaddr.rtx << 42UL);
 			rste.val = ptr;
 			goto shadow_r3t;
 		}
 		union region3_table_entry rtte;
 		if (*fake) {
-			/* offset in 4TB guest memory block */
+			ptr += (unsigned long) vaddr.rtx << 31;
-			ptr = ptr + ((unsigned long) vaddr.sx << 31UL);
 			rtte.val = ptr;
 			goto shadow_sgt;
 		}
 		union segment_table_entry ste;
 		if (*fake) {
-			/* offset in 2G guest memory block */
+			ptr += (unsigned long) vaddr.sx << 20;
-			ptr = ptr + ((unsigned long) vaddr.sx << 20UL);
 			ste.val = ptr;
 			goto shadow_pgt;
 		}

arch/s390/mm/mmap.c+2−2

@@ -101,7 +101,7 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 100 unmodified lines
101	addr = PAGE_ALIGN(addr);	101	addr = PAGE_ALIGN(addr);
102	vma = find_vma(mm, addr);	102	vma = find_vma(mm, addr);
103	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&	103	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&
104	(!vma \|\| addr + len <= vma->vm_start))	104	(!vma \|\| addr + len <= vm_start_gap(vma)))
105	goto check_asce_limit;	105	goto check_asce_limit;
106	}	106	}
107		107
@@ -151,7 +151,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 43 unmodified lines
151	addr = PAGE_ALIGN(addr);	151	addr = PAGE_ALIGN(addr);
152	vma = find_vma(mm, addr);	152	vma = find_vma(mm, addr);
153	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&	153	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&
154	(!vma \|\| addr + len <= vma->vm_start))	154	(!vma \|\| addr + len <= vm_start_gap(vma)))
155	goto check_asce_limit;	155	goto check_asce_limit;
156	}	156	}
157		157

arch/sh/mm/mmap.c+2−2

@@ -64,7 +64,7 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, · 63 unmodified lines
64		64
65	vma = find_vma(mm, addr);	65	vma = find_vma(mm, addr);
66	if (TASK_SIZE - len >= addr &&	66	if (TASK_SIZE - len >= addr &&
67	(!vma \|\| addr + len <= vma->vm_start))	67	(!vma \|\| addr + len <= vm_start_gap(vma)))
68	return addr;	68	return addr;
69	}	69	}
70		70
@@ -114,7 +114,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 43 unmodified lines
114		114
115	vma = find_vma(mm, addr);	115	vma = find_vma(mm, addr);
116	if (TASK_SIZE - len >= addr &&	116	if (TASK_SIZE - len >= addr &&
117	(!vma \|\| addr + len <= vma->vm_start))	117	(!vma \|\| addr + len <= vm_start_gap(vma)))
118	return addr;	118	return addr;
119	}	119	}
120		120

arch/sparc/kernel/sys_sparc_64.c+2−2

@@ -120,7 +120,7 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsi · 119 unmodified lines
120		120
121	vma = find_vma(mm, addr);	121	vma = find_vma(mm, addr);
122	if (task_size - len >= addr &&	122	if (task_size - len >= addr &&
123	(!vma \|\| addr + len <= vma->vm_start))	123	(!vma \|\| addr + len <= vm_start_gap(vma)))
124	return addr;	124	return addr;
125	}	125	}
126		126
@@ -183,7 +183,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 56 unmodified lines
183		183
184	vma = find_vma(mm, addr);	184	vma = find_vma(mm, addr);
185	if (task_size - len >= addr &&	185	if (task_size - len >= addr &&
186	(!vma \|\| addr + len <= vma->vm_start))	186	(!vma \|\| addr + len <= vm_start_gap(vma)))
187	return addr;	187	return addr;
188	}	188	}
189		189

arch/sparc/mm/hugetlbpage.c+1−1

@@ -120,7 +120,7 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr, · 119 unmodified lines
120	addr = ALIGN(addr, huge_page_size(h));	120	addr = ALIGN(addr, huge_page_size(h));
121	vma = find_vma(mm, addr);	121	vma = find_vma(mm, addr);
122	if (task_size - len >= addr &&	122	if (task_size - len >= addr &&
123	(!vma \|\| addr + len <= vma->vm_start))	123	(!vma \|\| addr + len <= vm_start_gap(vma)))
124	return addr;	124	return addr;
125	}	125	}
126	if (mm->get_unmapped_area == arch_get_unmapped_area)	126	if (mm->get_unmapped_area == arch_get_unmapped_area)

arch/tile/mm/hugetlbpage.c+1−1

@@ -233,7 +233,7 @@ unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr, · 232 unmodified lines
233	addr = ALIGN(addr, huge_page_size(h));	233	addr = ALIGN(addr, huge_page_size(h));
234	vma = find_vma(mm, addr);	234	vma = find_vma(mm, addr);
235	if (TASK_SIZE - len >= addr &&	235	if (TASK_SIZE - len >= addr &&
236	(!vma \|\| addr + len <= vma->vm_start))	236	(!vma \|\| addr + len <= vm_start_gap(vma)))
237	return addr;	237	return addr;
238	}	238	}
239	if (current->mm->get_unmapped_area == arch_get_unmapped_area)	239	if (current->mm->get_unmapped_area == arch_get_unmapped_area)

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

@@ -431,11 +431,11 @@ static __initconst const u64 skl_hw_cache_event_ids · 430 unmodified lines
431	[ C(DTLB) ] = {	431	[ C(DTLB) ] = {
432	[ C(OP_READ) ] = {	432	[ C(OP_READ) ] = {
433	[ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_INST_RETIRED.ALL_LOADS */	433	[ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_INST_RETIRED.ALL_LOADS */
434	[ C(RESULT_MISS) ] = 0x608, /* DTLB_LOAD_MISSES.WALK_COMPLETED */	434	[ C(RESULT_MISS) ] = 0xe08, /* DTLB_LOAD_MISSES.WALK_COMPLETED */
435	},	435	},
436	[ C(OP_WRITE) ] = {	436	[ C(OP_WRITE) ] = {
437	[ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_INST_RETIRED.ALL_STORES */	437	[ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_INST_RETIRED.ALL_STORES */
438	[ C(RESULT_MISS) ] = 0x649, /* DTLB_STORE_MISSES.WALK_COMPLETED */	438	[ C(RESULT_MISS) ] = 0xe49, /* DTLB_STORE_MISSES.WALK_COMPLETED */
439	},	439	},
440	[ C(OP_PREFETCH) ] = {	440	[ C(OP_PREFETCH) ] = {
441	[ C(RESULT_ACCESS) ] = 0x0,	441	[ C(RESULT_ACCESS) ] = 0x0,

arch/x86/include/asm/extable.h+1−0

@@ -29,6 +29,7 @@ struct pt_regs; · 28 unmodified lines
29	} while (0)	29	} while (0)
30		30
31	extern int fixup_exception(struct pt_regs *regs, int trapnr);	31	extern int fixup_exception(struct pt_regs *regs, int trapnr);
		32	extern int fixup_bug(struct pt_regs *regs, int trapnr);
32	extern bool ex_has_fault_handler(unsigned long ip);	33	extern bool ex_has_fault_handler(unsigned long ip);
33	extern void early_fixup_exception(struct pt_regs *regs, int trapnr);	34	extern void early_fixup_exception(struct pt_regs *regs, int trapnr);
34		35

arch/x86/include/asm/kvm_emulate.h+1−0

@@ -296,6 +296,7 @@ struct x86_emulate_ctxt { · 295 unmodified lines
296		296
297	bool perm_ok; /* do not check permissions if true */	297	bool perm_ok; /* do not check permissions if true */
298	bool ud; /* inject an #UD if host doesn't support insn */	298	bool ud; /* inject an #UD if host doesn't support insn */
		299	bool tf; /* TF value before instruction (after for syscall/sysret) */
299		300
300	bool have_exception;	301	bool have_exception;
301	struct x86_exception exception;	302	struct x86_exception exception;

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

@@ -2,8 +2,7 @@ · 1 unmodified line
2	#define _ASM_X86_MSHYPER_H	2	#define _ASM_X86_MSHYPER_H
3		3
4	#include <linux/types.h>	4	#include <linux/types.h>
5	#include <linux/interrupt.h>	5	#include <linux/atomic.h>
6	#include <linux/clocksource.h>
7	#include <asm/hyperv.h>	6	#include <asm/hyperv.h>
8		7
9	/*	8	/*

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

@@ -144,7 +144,7 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 143 unmodified lines
144	addr = PAGE_ALIGN(addr);	144	addr = PAGE_ALIGN(addr);
145	vma = find_vma(mm, addr);	145	vma = find_vma(mm, addr);
146	if (end - len >= addr &&	146	if (end - len >= addr &&
147	(!vma \|\| addr + len <= vma->vm_start))	147	(!vma \|\| addr + len <= vm_start_gap(vma)))
148	return addr;	148	return addr;
149	}	149	}
150		150
@@ -187,7 +187,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 36 unmodified lines
187	addr = PAGE_ALIGN(addr);	187	addr = PAGE_ALIGN(addr);
188	vma = find_vma(mm, addr);	188	vma = find_vma(mm, addr);
189	if (TASK_SIZE - len >= addr &&	189	if (TASK_SIZE - len >= addr &&
190	(!vma \|\| addr + len <= vma->vm_start))	190	(!vma \|\| addr + len <= vm_start_gap(vma)))
191	return addr;	191	return addr;
192	}	192	}
193		193

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

@@ -182,7 +182,7 @@ int is_valid_bugaddr(unsigned long addr) · 181 unmodified lines
182	return ud == INSN_UD0 \|\| ud == INSN_UD2;	182	return ud == INSN_UD0 \|\| ud == INSN_UD2;
183	}	183	}
184		184
185	static int fixup_bug(struct pt_regs *regs, int trapnr)	185	int fixup_bug(struct pt_regs *regs, int trapnr)
186	{	186	{
187	if (trapnr != X86_TRAP_UD)	187	if (trapnr != X86_TRAP_UD)
188	return 0;	188	return 0;

arch/x86/kvm/emulate.c+1−0

@@ -2742,6 +2742,7 @@ static int em_syscall(struct x86_emulate_ctxt *ctxt) · 2741 unmodified lines
2742	ctxt->eflags &= ~(X86_EFLAGS_VM \| X86_EFLAGS_IF);	2742	ctxt->eflags &= ~(X86_EFLAGS_VM \| X86_EFLAGS_IF);
2743	}	2743	}
2744		2744
		2745	ctxt->tf = (ctxt->eflags & X86_EFLAGS_TF) != 0;
2745	return X86EMUL_CONTINUE;	2746	return X86EMUL_CONTINUE;
2746	}	2747	}
2747		2748

arch/x86/kvm/x86.c+32−30

@@ -5313,6 +5313,8 @@ static void init_emulate_ctxt(struct kvm_vcpu *vcpu) · 5312 unmodified lines
5313	kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);	5313	kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);
5314		5314
5315	ctxt->eflags = kvm_get_rflags(vcpu);	5315	ctxt->eflags = kvm_get_rflags(vcpu);
		5316	ctxt->tf = (ctxt->eflags & X86_EFLAGS_TF) != 0;
		5317
5316	ctxt->eip = kvm_rip_read(vcpu);	5318	ctxt->eip = kvm_rip_read(vcpu);
5317	ctxt->mode = (!is_protmode(vcpu)) ? X86EMUL_MODE_REAL :	5319	ctxt->mode = (!is_protmode(vcpu)) ? X86EMUL_MODE_REAL :
5318	(ctxt->eflags & X86_EFLAGS_VM) ? X86EMUL_MODE_VM86 :	5320	(ctxt->eflags & X86_EFLAGS_VM) ? X86EMUL_MODE_VM86 :
@@ -5528,36 +5530,25 @@ static int kvm_vcpu_check_hw_bp(unsigned long addr, u32 type, u32 dr7, · 209 unmodified lines
5528	return dr6;	5530	return dr6;
5529	}	5531	}
5530		5532
5531	static void kvm_vcpu_check_singlestep(struct kvm_vcpu vcpu, unsigned long rflags, int r)	5533	static void kvm_vcpu_do_singlestep(struct kvm_vcpu vcpu, int r)
5532	{	5534	{
5533	struct kvm_run *kvm_run = vcpu->run;	5535	struct kvm_run *kvm_run = vcpu->run;
5534		5536
5535	/*	5537	if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) {
5536	* rflags is the old, "raw" value of the flags. The new value has	5538	kvm_run->debug.arch.dr6 = DR6_BS \| DR6_FIXED_1 \| DR6_RTM;
5537	* not been saved yet.	5539	kvm_run->debug.arch.pc = vcpu->arch.singlestep_rip;
5538	*	5540	kvm_run->debug.arch.exception = DB_VECTOR;
5539	* This is correct even for TF set by the guest, because "the	5541	kvm_run->exit_reason = KVM_EXIT_DEBUG;
5540	* processor will not generate this exception after the instruction	5542	*r = EMULATE_USER_EXIT;
5541	* that sets the TF flag".	5543	} else {
5542	*/	5544	/*
5543	if (unlikely(rflags & X86_EFLAGS_TF)) {	5545	* "Certain debug exceptions may clear bit 0-3. The
5544	if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) {	5546	* remaining contents of the DR6 register are never
5545	kvm_run->debug.arch.dr6 = DR6_BS \| DR6_FIXED_1 \|	5547	* cleared by the processor".
5546	DR6_RTM;	5548	*/
5547	kvm_run->debug.arch.pc = vcpu->arch.singlestep_rip;	5549	vcpu->arch.dr6 &= ~15;
5548	kvm_run->debug.arch.exception = DB_VECTOR;	5550	vcpu->arch.dr6 \|= DR6_BS \| DR6_RTM;
5549	kvm_run->exit_reason = KVM_EXIT_DEBUG;	5551	kvm_queue_exception(vcpu, DB_VECTOR);
5550	*r = EMULATE_USER_EXIT;
5551	} else {
5552	/*
5553	* "Certain debug exceptions may clear bit 0-3. The
5554	* remaining contents of the DR6 register are never
5555	* cleared by the processor".
5556	*/
5557	vcpu->arch.dr6 &= ~15;
5558	vcpu->arch.dr6 \|= DR6_BS \| DR6_RTM;
5559	kvm_queue_exception(vcpu, DB_VECTOR);
5560	}
5561	}	5552	}
5562	}	5553	}
5563		5554
@@ -5567,7 +5558,17 @@ int kvm_skip_emulated_instruction(struct kvm_vcpu *vcpu) · 3 unmodified lines
5567	int r = EMULATE_DONE;	5558	int r = EMULATE_DONE;
5568		5559
5569	kvm_x86_ops->skip_emulated_instruction(vcpu);	5560	kvm_x86_ops->skip_emulated_instruction(vcpu);
5570	kvm_vcpu_check_singlestep(vcpu, rflags, &r);	5561
		5562	/*
		5563	* rflags is the old, "raw" value of the flags. The new value has
		5564	* not been saved yet.
		5565	*
		5566	* This is correct even for TF set by the guest, because "the
		5567	* processor will not generate this exception after the instruction
		5568	* that sets the TF flag".
		5569	*/
		5570	if (unlikely(rflags & X86_EFLAGS_TF))
		5571	kvm_vcpu_do_singlestep(vcpu, &r);
5571	return r == EMULATE_DONE;	5572	return r == EMULATE_DONE;
5572	}	5573	}
5573	EXPORT_SYMBOL_GPL(kvm_skip_emulated_instruction);	5574	EXPORT_SYMBOL_GPL(kvm_skip_emulated_instruction);
@@ -5726,8 +5727,9 @@ restart: · 152 unmodified lines
5726	toggle_interruptibility(vcpu, ctxt->interruptibility);	5727	toggle_interruptibility(vcpu, ctxt->interruptibility);
5727	vcpu->arch.emulate_regs_need_sync_to_vcpu = false;	5728	vcpu->arch.emulate_regs_need_sync_to_vcpu = false;
5728	kvm_rip_write(vcpu, ctxt->eip);	5729	kvm_rip_write(vcpu, ctxt->eip);
5729	if (r == EMULATE_DONE)	5730	if (r == EMULATE_DONE &&
5730	kvm_vcpu_check_singlestep(vcpu, rflags, &r);	5731	(ctxt->tf \|\| (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)))
		5732	kvm_vcpu_do_singlestep(vcpu, &r);
5731	if (!ctxt->have_exception \|\|	5733	if (!ctxt->have_exception \|\|
5732	exception_type(ctxt->exception.vector) == EXCPT_TRAP)	5734	exception_type(ctxt->exception.vector) == EXCPT_TRAP)
5733	__kvm_set_rflags(vcpu, ctxt->eflags);	5735	__kvm_set_rflags(vcpu, ctxt->eflags);

arch/x86/mm/extable.c+3−0

@@ -162,6 +162,9 @@ void __init early_fixup_exception(struct pt_regs *regs, int trapnr) · 161 unmodified lines
162	if (fixup_exception(regs, trapnr))	162	if (fixup_exception(regs, trapnr))
163	return;	163	return;
164		164
		165	if (fixup_bug(regs, trapnr))
		166	return;
		167
165	fail:	168	fail:
166	early_printk("PANIC: early exception 0x%02x IP %lx:%lx error %lx cr2 0x%lx\n",	169	early_printk("PANIC: early exception 0x%02x IP %lx:%lx error %lx cr2 0x%lx\n",
167	(unsigned)trapnr, (unsigned long)regs->cs, regs->ip,	170	(unsigned)trapnr, (unsigned long)regs->cs, regs->ip,

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

@@ -148,7 +148,7 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr, · 147 unmodified lines
148	addr = ALIGN(addr, huge_page_size(h));	148	addr = ALIGN(addr, huge_page_size(h));
149	vma = find_vma(mm, addr);	149	vma = find_vma(mm, addr);
150	if (TASK_SIZE - len >= addr &&	150	if (TASK_SIZE - len >= addr &&
151	(!vma \|\| addr + len <= vma->vm_start))	151	(!vma \|\| addr + len <= vm_start_gap(vma)))
152	return addr;	152	return addr;
153	}	153	}
154	if (mm->get_unmapped_area == arch_get_unmapped_area)	154	if (mm->get_unmapped_area == arch_get_unmapped_area)

arch/x86/mm/init.c+3−3

 static void __init probe_page_size_mask(void)
 {
-#if !defined(CONFIG_KMEMCHECK)
 	/*
 	 * For CONFIG_KMEMCHECK or pagealloc debugging, identity mapping will
 	 * use small pages.
 	 * This will simplify cpa(), which otherwise needs to support splitting
 	 * large pages into small in interrupt context, etc.
 	 */
-	if (boot_cpu_has(X86_FEATURE_PSE) && !debug_pagealloc_enabled())
+	if (boot_cpu_has(X86_FEATURE_PSE) && !debug_pagealloc_enabled() && !IS_ENABLED(CONFIG_KMEMCHECK))
 		page_size_mask |= 1 << PG_LEVEL_2M;
-#endif
+	else
+		direct_gbpages = 0;
 	/* Enable PSE if available */
 	if (boot_cpu_has(X86_FEATURE_PSE))

arch/xtensa/include/asm/irq.h+2−1

@@ -29,7 +29,8 @@ static inline void variant_irq_disable(unsigned int irq) { } · 28 unmodified lines
29	# define PLATFORM_NR_IRQS 0	29	# define PLATFORM_NR_IRQS 0
30	#endif	30	#endif
31	#define XTENSA_NR_IRQS XCHAL_NUM_INTERRUPTS	31	#define XTENSA_NR_IRQS XCHAL_NUM_INTERRUPTS
32	#define NR_IRQS (XTENSA_NR_IRQS + VARIANT_NR_IRQS + PLATFORM_NR_IRQS)	32	#define NR_IRQS (XTENSA_NR_IRQS + VARIANT_NR_IRQS + PLATFORM_NR_IRQS + 1)
		33	#define XTENSA_PIC_LINUX_IRQ(hwirq) ((hwirq) + 1)
33		34
34	#if VARIANT_NR_IRQS == 0	35	#if VARIANT_NR_IRQS == 0
35	static inline void variant_init_irq(void) { }	36	static inline void variant_init_irq(void) { }

arch/xtensa/kernel/irq.c+0−5

 {
 	int irq = irq_find_mapping(NULL, hwirq);
-	if (hwirq >= NR_IRQS) {
-		printk(KERN_EMERG "%s: cannot handle IRQ %d\n",
-				__func__, hwirq);
-	}
 #ifdef CONFIG_DEBUG_STACKOVERFLOW
 	/* Debugging check for stack overflow: is there less than 1KB free? */
 	{

arch/xtensa/kernel/setup.c+1−2

@@ -593,8 +593,7 @@ c_show(struct seq_file f, void slot) · 592 unmodified lines
593	(ccount_freq/10000) % 100,	593	(ccount_freq/10000) % 100,
594	loops_per_jiffy/(500000/HZ),	594	loops_per_jiffy/(500000/HZ),
595	(loops_per_jiffy/(5000/HZ)) % 100);	595	(loops_per_jiffy/(5000/HZ)) % 100);
596		596	seq_puts(f, "flags\t\t: "
597	seq_printf(f,"flags\t\t: "
598	#if XCHAL_HAVE_NMI	597	#if XCHAL_HAVE_NMI
599	"nmi "	598	"nmi "
600	#endif	599	#endif

arch/xtensa/kernel/syscall.c+1−1

@@ -88,7 +88,7 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, · 87 unmodified lines
88	/* At this point: (!vmm \|\| addr < vmm->vm_end). */	88	/* At this point: (!vmm \|\| addr < vmm->vm_end). */
89	if (TASK_SIZE - len < addr)	89	if (TASK_SIZE - len < addr)
90	return -ENOMEM;	90	return -ENOMEM;
91	if (!vmm \|\| addr + len <= vmm->vm_start)	91	if (!vmm \|\| addr + len <= vm_start_gap(vmm))
92	return addr;	92	return addr;
93	addr = vmm->vm_end;	93	addr = vmm->vm_end;
94	if (flags & MAP_SHARED)	94	if (flags & MAP_SHARED)

arch/xtensa/kernel/vmlinux.lds.S+3−3

@@ -118,7 +118,7 @@ SECTIONS · 117 unmodified lines
118	SECTION_VECTOR (.KernelExceptionVector.text, KERNEL_VECTOR_VADDR)	118	SECTION_VECTOR (.KernelExceptionVector.text, KERNEL_VECTOR_VADDR)
119	SECTION_VECTOR (.UserExceptionVector.literal, USER_VECTOR_VADDR - 4)	119	SECTION_VECTOR (.UserExceptionVector.literal, USER_VECTOR_VADDR - 4)
120	SECTION_VECTOR (.UserExceptionVector.text, USER_VECTOR_VADDR)	120	SECTION_VECTOR (.UserExceptionVector.text, USER_VECTOR_VADDR)
121	SECTION_VECTOR (.DoubleExceptionVector.literal, DOUBLEEXC_VECTOR_VADDR - 48)	121	SECTION_VECTOR (.DoubleExceptionVector.literal, DOUBLEEXC_VECTOR_VADDR - 20)
122	SECTION_VECTOR (.DoubleExceptionVector.text, DOUBLEEXC_VECTOR_VADDR)	122	SECTION_VECTOR (.DoubleExceptionVector.text, DOUBLEEXC_VECTOR_VADDR)
123	#endif	123	#endif
124		124
@@ -306,13 +306,13 @@ SECTIONS · 181 unmodified lines
306	.UserExceptionVector.literal)	306	.UserExceptionVector.literal)
307	SECTION_VECTOR (_DoubleExceptionVector_literal,	307	SECTION_VECTOR (_DoubleExceptionVector_literal,
308	.DoubleExceptionVector.literal,	308	.DoubleExceptionVector.literal,
309	DOUBLEEXC_VECTOR_VADDR - 48,	309	DOUBLEEXC_VECTOR_VADDR - 20,
310	SIZEOF(.UserExceptionVector.text),	310	SIZEOF(.UserExceptionVector.text),
311	.UserExceptionVector.text)	311	.UserExceptionVector.text)
312	SECTION_VECTOR (_DoubleExceptionVector_text,	312	SECTION_VECTOR (_DoubleExceptionVector_text,
313	.DoubleExceptionVector.text,	313	.DoubleExceptionVector.text,
314	DOUBLEEXC_VECTOR_VADDR,	314	DOUBLEEXC_VECTOR_VADDR,
315	48,	315	20,
316	.DoubleExceptionVector.literal)	316	.DoubleExceptionVector.literal)
317		317
318	. = (LOADADDR( .DoubleExceptionVector.text ) + SIZEOF( .DoubleExceptionVector.text ) + 3) & ~ 3;	318	. = (LOADADDR( .DoubleExceptionVector.text ) + SIZEOF( .DoubleExceptionVector.text ) + 3) & ~ 3;

arch/xtensa/platforms/iss/simdisk.c+1−2

@@ -317,8 +317,7 @@ static int __init simdisk_init(void) · 316 unmodified lines
317	if (simdisk_count > MAX_SIMDISK_COUNT)	317	if (simdisk_count > MAX_SIMDISK_COUNT)
318	simdisk_count = MAX_SIMDISK_COUNT;	318	simdisk_count = MAX_SIMDISK_COUNT;
319		319
320	sddev = kmalloc(simdisk_count * sizeof(struct simdisk),	320	sddev = kmalloc_array(simdisk_count, sizeof(*sddev), GFP_KERNEL);
321	GFP_KERNEL);
322	if (sddev == NULL)	321	if (sddev == NULL)
323	goto out_unregister;	322	goto out_unregister;
324		323

arch/xtensa/platforms/xtfpga/include/platform/hardware.h+4−2

@@ -24,16 +24,18 @@ · 23 unmodified lines
24		24
25	/* Interrupt configuration. */	25	/* Interrupt configuration. */
26		26
27	#define PLATFORM_NR_IRQS 10	27	#define PLATFORM_NR_IRQS 0
28		28
29	/* Default assignment of LX60 devices to external interrupts. */	29	/* Default assignment of LX60 devices to external interrupts. */
30		30
31	#ifdef CONFIG_XTENSA_MX	31	#ifdef CONFIG_XTENSA_MX
32	#define DUART16552_INTNUM XCHAL_EXTINT3_NUM	32	#define DUART16552_INTNUM XCHAL_EXTINT3_NUM
33	#define OETH_IRQ XCHAL_EXTINT4_NUM	33	#define OETH_IRQ XCHAL_EXTINT4_NUM
		34	#define C67X00_IRQ XCHAL_EXTINT8_NUM
34	#else	35	#else
35	#define DUART16552_INTNUM XCHAL_EXTINT0_NUM	36	#define DUART16552_INTNUM XCHAL_EXTINT0_NUM
36	#define OETH_IRQ XCHAL_EXTINT1_NUM	37	#define OETH_IRQ XCHAL_EXTINT1_NUM
		38	#define C67X00_IRQ XCHAL_EXTINT5_NUM
37	#endif	39	#endif
38		40
39	/*	41	/*
@@ -63,5 +65,5 @@ · 23 unmodified lines
63		65
64	#define C67X00_PADDR (XCHAL_KIO_PADDR + 0x0D0D0000)	66	#define C67X00_PADDR (XCHAL_KIO_PADDR + 0x0D0D0000)
65	#define C67X00_SIZE 0x10	67	#define C67X00_SIZE 0x10
66	#define C67X00_IRQ 5	68
67	#endif /* __XTENSA_XTAVNET_HARDWARE_H */	69	#endif /* __XTENSA_XTAVNET_HARDWARE_H */

arch/xtensa/platforms/xtfpga/setup.c+5−5

@@ -175,8 +175,8 @@ static struct resource ethoc_res[] = { · 174 unmodified lines
175	.flags = IORESOURCE_MEM,	175	.flags = IORESOURCE_MEM,
176	},	176	},
177	[2] = { /* IRQ number */	177	[2] = { /* IRQ number */
178	.start = OETH_IRQ,	178	.start = XTENSA_PIC_LINUX_IRQ(OETH_IRQ),
179	.end = OETH_IRQ,	179	.end = XTENSA_PIC_LINUX_IRQ(OETH_IRQ),
180	.flags = IORESOURCE_IRQ,	180	.flags = IORESOURCE_IRQ,
181	},	181	},
182	};	182	};
@@ -213,8 +213,8 @@ static struct resource c67x00_res[] = { · 30 unmodified lines
213	.flags = IORESOURCE_MEM,	213	.flags = IORESOURCE_MEM,
214	},	214	},
215	[1] = { /* IRQ number */	215	[1] = { /* IRQ number */
216	.start = C67X00_IRQ,	216	.start = XTENSA_PIC_LINUX_IRQ(C67X00_IRQ),
217	.end = C67X00_IRQ,	217	.end = XTENSA_PIC_LINUX_IRQ(C67X00_IRQ),
218	.flags = IORESOURCE_IRQ,	218	.flags = IORESOURCE_IRQ,
219	},	219	},
220	};	220	};
@@ -247,7 +247,7 @@ static struct resource serial_resource = { · 26 unmodified lines
247	static struct plat_serial8250_port serial_platform_data[] = {	247	static struct plat_serial8250_port serial_platform_data[] = {
248	[0] = {	248	[0] = {
249	.mapbase = DUART16552_PADDR,	249	.mapbase = DUART16552_PADDR,
250	.irq = DUART16552_INTNUM,	250	.irq = XTENSA_PIC_LINUX_IRQ(DUART16552_INTNUM),
251	.flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \|	251	.flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \|
252	UPF_IOREMAP,	252	UPF_IOREMAP,
253	.iotype = XCHAL_HAVE_BE ? UPIO_MEM32BE : UPIO_MEM32,	253	.iotype = XCHAL_HAVE_BE ? UPIO_MEM32BE : UPIO_MEM32,

block/blk-mq-sched.c+46−12

@@ -68,6 +68,45 @@ static void blk_mq_sched_assign_ioc(struct request_queue *q, · 67 unmodified lines
68	__blk_mq_sched_assign_ioc(q, rq, bio, ioc);	68	__blk_mq_sched_assign_ioc(q, rq, bio, ioc);
69	}	69	}
70		70
		71	/*
		72	* Mark a hardware queue as needing a restart. For shared queues, maintain
		73	* a count of how many hardware queues are marked for restart.
		74	*/
		75	static void blk_mq_sched_mark_restart_hctx(struct blk_mq_hw_ctx *hctx)
		76	{
		77	if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
		78	return;
		79
		80	if (hctx->flags & BLK_MQ_F_TAG_SHARED) {
		81	struct request_queue *q = hctx->queue;
		82
		83	if (!test_and_set_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
		84	atomic_inc(&q->shared_hctx_restart);
		85	} else
		86	set_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);
		87	}
		88
		89	static bool blk_mq_sched_restart_hctx(struct blk_mq_hw_ctx *hctx)
		90	{
		91	if (!test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
		92	return false;
		93
		94	if (hctx->flags & BLK_MQ_F_TAG_SHARED) {
		95	struct request_queue *q = hctx->queue;
		96
		97	if (test_and_clear_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
		98	atomic_dec(&q->shared_hctx_restart);
		99	} else
		100	clear_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);
		101
		102	if (blk_mq_hctx_has_pending(hctx)) {
		103	blk_mq_run_hw_queue(hctx, true);
		104	return true;
		105	}
		106
		107	return false;
		108	}
		109
71	struct request blk_mq_sched_get_request(struct request_queue q,	110	struct request blk_mq_sched_get_request(struct request_queue q,
72	struct bio *bio,	111	struct bio *bio,
73	unsigned int op,	112	unsigned int op,
@@ -266,18 +305,6 @@ static bool blk_mq_sched_bypass_insert(struct blk_mq_hw_ctx *hctx, · 192 unmodified lines
266	return true;	305	return true;
267	}	306	}
268		307
269	static bool blk_mq_sched_restart_hctx(struct blk_mq_hw_ctx *hctx)
270	{
271	if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state)) {
272	clear_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);
273	if (blk_mq_hctx_has_pending(hctx)) {
274	blk_mq_run_hw_queue(hctx, true);
275	return true;
276	}
277	}
278	return false;
279	}
280
281	/**	308	/**
282	* list_for_each_entry_rcu_rr - iterate in a round-robin fashion over rcu list	309	* list_for_each_entry_rcu_rr - iterate in a round-robin fashion over rcu list
283	* @pos: loop cursor.	310	* @pos: loop cursor.
@@ -309,6 +336,13 @@ void blk_mq_sched_restart(struct blk_mq_hw_ctx *const hctx) · 25 unmodified lines
309	unsigned int i, j;	336	unsigned int i, j;
310		337
311	if (set->flags & BLK_MQ_F_TAG_SHARED) {	338	if (set->flags & BLK_MQ_F_TAG_SHARED) {
		339	/*
		340	* If this is 0, then we know that no hardware queues
		341	* have RESTART marked. We're done.
		342	*/
		343	if (!atomic_read(&queue->shared_hctx_restart))
		344	return;
		345
312	rcu_read_lock();	346	rcu_read_lock();
313	list_for_each_entry_rcu_rr(q, queue, &set->tag_list,	347	list_for_each_entry_rcu_rr(q, queue, &set->tag_list,
314	tag_set_list) {	348	tag_set_list) {

block/blk-mq-sched.h+0−9

@@ -115,15 +115,6 @@ static inline bool blk_mq_sched_has_work(struct blk_mq_hw_ctx *hctx) · 114 unmodified lines
115	return false;	115	return false;
116	}	116	}
117		117
118	/*
119	* Mark a hardware queue as needing a restart.
120	*/
121	static inline void blk_mq_sched_mark_restart_hctx(struct blk_mq_hw_ctx *hctx)
122	{
123	if (!test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
124	set_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);
125	}
126
127	static inline bool blk_mq_sched_needs_restart(struct blk_mq_hw_ctx *hctx)	118	static inline bool blk_mq_sched_needs_restart(struct blk_mq_hw_ctx *hctx)
128	{	119	{
129	return test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);	120	return test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);

block/blk-mq.c+13−3

 	}
 }
+/*
+ * Caller needs to ensure that we're either frozen/quiesced, or that
+ * the queue isn't live yet.
+ */
 static void queue_set_hctx_shared(struct request_queue *q, bool shared)
 {
 	struct blk_mq_hw_ctx *hctx;
 	int i;
 	queue_for_each_hw_ctx(q, hctx, i) {
-		if (shared)
+		if (shared) {
+			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
+				atomic_inc(&q->shared_hctx_restart);
 			hctx->flags |= BLK_MQ_F_TAG_SHARED;
-		else
+		} else {
+			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
+				atomic_dec(&q->shared_hctx_restart);
 			hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
+		}
 	}
 }
-static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set, bool shared)
+static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set,
+					bool shared)
 {
 	struct request_queue *q;

block/blk-sysfs.c+22−12

 }
 /**
- * blk_release_queue: - release a &struct request_queue when it is no longer needed
+ * __blk_release_queue - release a request queue when it is no longer needed
- * @kobj:    the kobj belonging to the request queue to be released
+ * @work: pointer to the release_work member of the request queue to be released
  *
  * Description:
- *     blk_release_queue is the pair to blk_init_queue() or
+ *     blk_release_queue is the counterpart of blk_init_queue(). It should be
- *     blk_queue_make_request().  It should be called when a request queue is
+ *     called when a request queue is being released; typically when a block
- *     being released; typically when a block device is being de-registered.
+ *     device is being de-registered. Its primary task it to free the queue
- *     Currently, its primary task it to free all the &struct request
+ *     itself.
- *     structures that were allocated to the queue and the queue itself.
  *
- * Note:
+ * Notes:
  *     The low level driver must have finished any outstanding requests first
  *     via blk_cleanup_queue().
- **/
+ *
-static void blk_release_queue(struct kobject *kobj)
+ *     Although blk_release_queue() may be called with preemption disabled,
+ *     __blk_release_queue() may sleep.
+ */
+static void __blk_release_queue(struct work_struct *work)
 {
-	struct request_queue *q =
+	struct request_queue *q = container_of(work, typeof(*q), release_work);
-		container_of(kobj, struct request_queue, kobj);
 	if (test_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags))
 		blk_stat_remove_callback(q, q->poll_cb);
 	call_rcu(&q->rcu_head, blk_free_queue_rcu);
 }
+static void blk_release_queue(struct kobject *kobj)
+{
+	struct request_queue *q =
+		container_of(kobj, struct request_queue, kobj);
+	INIT_WORK(&q->release_work, __blk_release_queue);
+	schedule_work(&q->release_work);
+}
 static const struct sysfs_ops queue_sysfs_ops = {
 	.show	= queue_attr_show,
 	.store	= queue_attr_store,

drivers/acpi/acpica/tbutils.c+25−9

@@ -416,9 +416,18 @@ acpi_tb_get_table(struct acpi_table_desc *table_desc, · 415 unmodified lines
416	}	416	}
417	}	417	}
418		418
419	table_desc->validation_count++;	419	if (table_desc->validation_count < ACPI_MAX_TABLE_VALIDATIONS) {
420	if (table_desc->validation_count == 0) {	420	table_desc->validation_count++;
421	table_desc->validation_count--;	421
		422	/*
		423	* Detect validation_count overflows to ensure that the warning
		424	* message will only be printed once.
		425	*/
		426	if (table_desc->validation_count >= ACPI_MAX_TABLE_VALIDATIONS) {
		427	ACPI_WARNING((AE_INFO,
		428	"Table %p, Validation count overflows\n",
		429	table_desc));
		430	}
422	}	431	}
423		432
424	*out_table = table_desc->pointer;	433	*out_table = table_desc->pointer;
@@ -445,13 +454,20 @@ void acpi_tb_put_table(struct acpi_table_desc *table_desc) · 20 unmodified lines
445		454
446	ACPI_FUNCTION_TRACE(acpi_tb_put_table);	455	ACPI_FUNCTION_TRACE(acpi_tb_put_table);
447		456
448	if (table_desc->validation_count == 0) {	457	if (table_desc->validation_count < ACPI_MAX_TABLE_VALIDATIONS) {
449	ACPI_WARNING((AE_INFO,	458	table_desc->validation_count--;
450	"Table %p, Validation count is zero before decrement\n",	459
451	table_desc));	460	/*
452	return_VOID;	461	* Detect validation_count underflows to ensure that the warning
		462	* message will only be printed once.
		463	*/
		464	if (table_desc->validation_count >= ACPI_MAX_TABLE_VALIDATIONS) {
		465	ACPI_WARNING((AE_INFO,
		466	"Table %p, Validation count underflows\n",
		467	table_desc));
		468	return_VOID;
		469	}
453	}	470	}
454	table_desc->validation_count--;
455		471
456	if (table_desc->validation_count == 0) {	472	if (table_desc->validation_count == 0) {
457		473

drivers/acpi/acpica/utresrc.c+0−9

@@ -474,15 +474,6 @@ acpi_ut_walk_aml_resources(struct acpi_walk_state *walk_state, · 473 unmodified lines
474	return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);	474	return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
475	}	475	}
476		476
477	/*
478	* The end_tag opcode must be followed by a zero byte.
479	* Although this byte is technically defined to be a checksum,
480	* in practice, all ASL compilers set this byte to zero.
481	*/
482	if (*(aml + 1) != 0) {
483	return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
484	}
485
486	/* Return the pointer to the end_tag if requested */	477	/* Return the pointer to the end_tag if requested */
487		478
488	if (!user_function) {	479	if (!user_function) {

drivers/acpi/scan.c+37−30

 	adev->flags.coherent_dma = cca;
 }
+static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
+{
+	bool *is_spi_i2c_slave_p = data;
+	if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
+		return 1;
+	/*
+	 * devices that are connected to UART still need to be enumerated to
+	 * platform bus
+	 */
+	if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
+		*is_spi_i2c_slave_p = true;
+	 /* no need to do more checking */
+	return -1;
+}
+static bool acpi_is_spi_i2c_slave(struct acpi_device *device)
+{
+	struct list_head resource_list;
+	bool is_spi_i2c_slave = false;
+	INIT_LIST_HEAD(&resource_list);
+	acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
+			       &is_spi_i2c_slave);
+	acpi_dev_free_resource_list(&resource_list);
+	return is_spi_i2c_slave;
+}
 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
 			     int type, unsigned long long sta)
 {
 	acpi_bus_get_flags(device);
 	device->flags.match_driver = false;
 	device->flags.initialized = true;
+	device->flags.spi_i2c_slave = acpi_is_spi_i2c_slave(device);
 	acpi_device_clear_enumerated(device);
 	device_initialize(&device->dev);
 	dev_set_uevent_suppress(&device->dev, true);
 	return AE_OK;
 }
-static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
-{
-	bool *is_spi_i2c_slave_p = data;
-	if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
-		return 1;
-	/*
-	 * devices that are connected to UART still need to be enumerated to
-	 * platform bus
-	 */
-	if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
-		*is_spi_i2c_slave_p = true;
-	 /* no need to do more checking */
-	return -1;
-}
 static void acpi_default_enumeration(struct acpi_device *device)
 {
-	struct list_head resource_list;
-	bool is_spi_i2c_slave = false;
 	/*
 	 * Do not enumerate SPI/I2C slaves as they will be enumerated by their
 	 * respective parents.
 	 */
-	INIT_LIST_HEAD(&resource_list);
+	if (!device->flags.spi_i2c_slave) {
-	acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
-			       &is_spi_i2c_slave);
-	acpi_dev_free_resource_list(&resource_list);
-	if (!is_spi_i2c_slave) {
 		acpi_create_platform_device(device, NULL);
 		acpi_device_set_enumerated(device);
 	} else {
 		return;
 	device->flags.match_driver = true;
-	if (ret > 0) {
+	if (ret > 0 && !device->flags.spi_i2c_slave) {
 		acpi_device_set_enumerated(device);
 		goto ok;
 	}
 	if (ret < 0)
 		return;
-	if (device->pnp.type.platform_id)
+	if (!device->pnp.type.platform_id && !device->flags.spi_i2c_slave)
-		acpi_default_enumeration(device);
-	else
 		acpi_device_set_enumerated(device);
+	else
+		acpi_default_enumeration(device);
  ok:
 	list_for_each_entry(child, &device->children, node)

drivers/block/xen-blkback/blkback.c+12−14

 	unsigned long timeout;
 	int ret;
-	xen_blkif_get(blkif);
 	set_freezable();
 	while (!kthread_should_stop()) {
 		if (try_to_freeze())
 		print_stats(ring);
 	ring->xenblkd = NULL;
-	xen_blkif_put(blkif);
 	return 0;
 }
 static void make_response(struct xen_blkif_ring *ring, u64 id,
 			  unsigned short op, int st)
 {
-	struct blkif_response  resp;
+	struct blkif_response *resp;
 	unsigned long     flags;
 	union blkif_back_rings *blk_rings;
 	int notify;
-	resp.id        = id;
-	resp.operation = op;
-	resp.status    = st;
 	spin_lock_irqsave(&ring->blk_ring_lock, flags);
 	blk_rings = &ring->blk_rings;
 	/* Place on the response ring for the relevant domain. */
 	switch (ring->blkif->blk_protocol) {
 	case BLKIF_PROTOCOL_NATIVE:
-		memcpy(RING_GET_RESPONSE(&blk_rings->native, blk_rings->native.rsp_prod_pvt),
+		resp = RING_GET_RESPONSE(&blk_rings->native,
-		       &resp, sizeof(resp));
+					 blk_rings->native.rsp_prod_pvt);
 		break;
 	case BLKIF_PROTOCOL_X86_32:
-		memcpy(RING_GET_RESPONSE(&blk_rings->x86_32, blk_rings->x86_32.rsp_prod_pvt),
+		resp = RING_GET_RESPONSE(&blk_rings->x86_32,
-		       &resp, sizeof(resp));
+					 blk_rings->x86_32.rsp_prod_pvt);
 		break;
 	case BLKIF_PROTOCOL_X86_64:
-		memcpy(RING_GET_RESPONSE(&blk_rings->x86_64, blk_rings->x86_64.rsp_prod_pvt),
+		resp = RING_GET_RESPONSE(&blk_rings->x86_64,
-		       &resp, sizeof(resp));
+					 blk_rings->x86_64.rsp_prod_pvt);
 		break;
 	default:
 		BUG();
 	}
+	resp->id        = id;
+	resp->operation = op;
+	resp->status    = st;
 	blk_rings->common.rsp_prod_pvt++;
 	RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blk_rings->common, notify);
 	spin_unlock_irqrestore(&ring->blk_ring_lock, flags);

drivers/block/xen-blkback/common.h+6−20

@@ -75,9 +75,8 @@ extern unsigned int xenblk_max_queues; · 74 unmodified lines
75	struct blkif_common_request {	75	struct blkif_common_request {
76	char dummy;	76	char dummy;
77	};	77	};
78	struct blkif_common_response {	78
79	char dummy;	79	/* i386 protocol version */
80	};
81		80
82	struct blkif_x86_32_request_rw {	81	struct blkif_x86_32_request_rw {
83	uint8_t nr_segments; /* number of segments */	82	uint8_t nr_segments; /* number of segments */
@@ -129,14 +128,6 @@ struct blkif_x86_32_request { · 45 unmodified lines
129	} u;	128	} u;
130	} __attribute__((__packed__));	129	} __attribute__((__packed__));
131		130
132	/* i386 protocol version */
133	#pragma pack(push, 4)
134	struct blkif_x86_32_response {
135	uint64_t id; /* copied from request */
136	uint8_t operation; /* copied from request */
137	int16_t status; /* BLKIF_RSP_??? */
138	};
139	#pragma pack(pop)
140	/* x86_64 protocol version */	131	/* x86_64 protocol version */
141		132
142	struct blkif_x86_64_request_rw {	133	struct blkif_x86_64_request_rw {
@@ -193,18 +184,12 @@ struct blkif_x86_64_request { · 50 unmodified lines
193	} u;	184	} u;
194	} __attribute__((__packed__));	185	} __attribute__((__packed__));
195		186
196	struct blkif_x86_64_response {
197	uint64_t __attribute__((__aligned__(8))) id;
198	uint8_t operation; /* copied from request */
199	int16_t status; /* BLKIF_RSP_??? */
200	};
201
202	DEFINE_RING_TYPES(blkif_common, struct blkif_common_request,	187	DEFINE_RING_TYPES(blkif_common, struct blkif_common_request,
203	struct blkif_common_response);	188	struct blkif_response);
204	DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request,	189	DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request,
205	struct blkif_x86_32_response);	190	struct blkif_response __packed);
206	DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request,	191	DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request,
207	struct blkif_x86_64_response);	192	struct blkif_response);
208		193
209	union blkif_back_rings {	194	union blkif_back_rings {
210	struct blkif_back_ring native;	195	struct blkif_back_ring native;
@@ -281,6 +266,7 @@ struct xen_blkif_ring { · 70 unmodified lines
281		266
282	wait_queue_head_t wq;	267	wait_queue_head_t wq;
283	atomic_t inflight;	268	atomic_t inflight;
		269	bool active;
284	/* One thread per blkif ring. */	270	/* One thread per blkif ring. */
285	struct task_struct *xenblkd;	271	struct task_struct *xenblkd;
286	unsigned int waiting_reqs;	272	unsigned int waiting_reqs;

drivers/block/xen-blkback/xenbus.c+8−7

@@ -159,7 +159,7 @@ static int xen_blkif_alloc_rings(struct xen_blkif *blkif) · 158 unmodified lines
159	init_waitqueue_head(&ring->shutdown_wq);	159	init_waitqueue_head(&ring->shutdown_wq);
160	ring->blkif = blkif;	160	ring->blkif = blkif;
161	ring->st_print = jiffies;	161	ring->st_print = jiffies;
162	xen_blkif_get(blkif);	162	ring->active = true;
163	}	163	}
164		164
165	return 0;	165	return 0;
@@ -249,10 +249,12 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif) · 83 unmodified lines
249	struct xen_blkif_ring *ring = &blkif->rings[r];	249	struct xen_blkif_ring *ring = &blkif->rings[r];
250	unsigned int i = 0;	250	unsigned int i = 0;
251		251
		252	if (!ring->active)
		253	continue;
		254
252	if (ring->xenblkd) {	255	if (ring->xenblkd) {
253	kthread_stop(ring->xenblkd);	256	kthread_stop(ring->xenblkd);
254	wake_up(&ring->shutdown_wq);	257	wake_up(&ring->shutdown_wq);
255	ring->xenblkd = NULL;
256	}	258	}
257		259
258	/* The above kthread_stop() guarantees that at this point we	260	/* The above kthread_stop() guarantees that at this point we
@@ -296,7 +298,7 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif) · 37 unmodified lines
296	BUG_ON(ring->free_pages_num != 0);	298	BUG_ON(ring->free_pages_num != 0);
297	BUG_ON(ring->persistent_gnt_c != 0);	299	BUG_ON(ring->persistent_gnt_c != 0);
298	WARN_ON(i != (XEN_BLKIF_REQS_PER_PAGE * blkif->nr_ring_pages));	300	WARN_ON(i != (XEN_BLKIF_REQS_PER_PAGE * blkif->nr_ring_pages));
299	xen_blkif_put(blkif);	301	ring->active = false;
300	}	302	}
301	blkif->nr_ring_pages = 0;	303	blkif->nr_ring_pages = 0;
302	/*	304	/*
@@ -312,9 +314,10 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif) · 9 unmodified lines
312		314
313	static void xen_blkif_free(struct xen_blkif *blkif)	315	static void xen_blkif_free(struct xen_blkif *blkif)
314	{	316	{
315		317	WARN_ON(xen_blkif_disconnect(blkif));
316	xen_blkif_disconnect(blkif);
317	xen_vbd_free(&blkif->vbd);	318	xen_vbd_free(&blkif->vbd);
		319	kfree(blkif->be->mode);
		320	kfree(blkif->be);
318		321
319	/* Make sure everything is drained before shutting down */	322	/* Make sure everything is drained before shutting down */
320	kmem_cache_free(xen_blkif_cachep, blkif);	323	kmem_cache_free(xen_blkif_cachep, blkif);
@@ -511,8 +514,6 @@ static int xen_blkbk_remove(struct xenbus_device *dev) · 190 unmodified lines
511	xen_blkif_put(be->blkif);	514	xen_blkif_put(be->blkif);
512	}	515	}
513		516
514	kfree(be->mode);
515	kfree(be);
516	return 0;	517	return 0;
517	}	518	}
518		519

drivers/char/random.c+6−6

 		p[crng_init_cnt % CHACHA20_KEY_SIZE] ^= *cp;
 		cp++; crng_init_cnt++; len--;
 	}
+	spin_unlock_irqrestore(&primary_crng.lock, flags);
 	if (crng_init_cnt >= CRNG_INIT_CNT_THRESH) {
 		invalidate_batched_entropy();
 		crng_init = 1;
 		wake_up_interruptible(&crng_init_wait);
 		pr_notice("random: fast init done\n");
 	}
-	spin_unlock_irqrestore(&primary_crng.lock, flags);
 	return 1;
 }
 	}
 	memzero_explicit(&buf, sizeof(buf));
 	crng->init_time = jiffies;
+	spin_unlock_irqrestore(&primary_crng.lock, flags);
 	if (crng == &primary_crng && crng_init < 2) {
 		invalidate_batched_entropy();
 		crng_init = 2;
 		wake_up_interruptible(&crng_init_wait);
 		pr_notice("random: crng init done\n");
 	}
-	spin_unlock_irqrestore(&primary_crng.lock, flags);
 }
 static inline void crng_wait_ready(void)
 u64 get_random_u64(void)
 {
 	u64 ret;
-	bool use_lock = crng_init < 2;
+	bool use_lock = READ_ONCE(crng_init) < 2;
-	unsigned long flags;
+	unsigned long flags = 0;
 	struct batched_entropy *batch;
 #if BITS_PER_LONG == 64
 u32 get_random_u32(void)
 {
 	u32 ret;
-	bool use_lock = crng_init < 2;
+	bool use_lock = READ_ONCE(crng_init) < 2;
-	unsigned long flags;
+	unsigned long flags = 0;
 	struct batched_entropy *batch;
 	if (arch_get_random_int(&ret))

drivers/clk/meson/Kconfig+1−0

@@ -14,6 +14,7 @@ config COMMON_CLK_MESON8B · 13 unmodified lines
14	config COMMON_CLK_GXBB	14	config COMMON_CLK_GXBB
15	bool	15	bool
16	depends on COMMON_CLK_AMLOGIC	16	depends on COMMON_CLK_AMLOGIC
		17	select RESET_CONTROLLER
17	help	18	help
18	Support for the clock controller on AmLogic S905 devices, aka gxbb.	19	Support for the clock controller on AmLogic S905 devices, aka gxbb.
19	Say Y if you want peripherals and CPU frequency scaling to work.	20	Say Y if you want peripherals and CPU frequency scaling to work.

drivers/clk/sunxi-ng/Kconfig+1−0

@@ -156,6 +156,7 @@ config SUN8I_R_CCU · 155 unmodified lines
156	bool "Support for Allwinner SoCs' PRCM CCUs"	156	bool "Support for Allwinner SoCs' PRCM CCUs"
157	select SUNXI_CCU_DIV	157	select SUNXI_CCU_DIV
158	select SUNXI_CCU_GATE	158	select SUNXI_CCU_GATE
		159	select SUNXI_CCU_MP
159	default MACH_SUN8I \|\| (ARCH_SUNXI && ARM64)	160	default MACH_SUN8I \|\| (ARCH_SUNXI && ARM64)
160		161
161	endif	162	endif

drivers/clk/sunxi-ng/ccu-sun50i-a64.h+3−1

@@ -31,7 +31,9 @@ · 30 unmodified lines
31	#define CLK_PLL_VIDEO0_2X 8	31	#define CLK_PLL_VIDEO0_2X 8
32	#define CLK_PLL_VE 9	32	#define CLK_PLL_VE 9
33	#define CLK_PLL_DDR0 10	33	#define CLK_PLL_DDR0 10
34	#define CLK_PLL_PERIPH0 11	34
		35	/* PLL_PERIPH0 exported for PRCM */
		36
35	#define CLK_PLL_PERIPH0_2X 12	37	#define CLK_PLL_PERIPH0_2X 12
36	#define CLK_PLL_PERIPH1 13	38	#define CLK_PLL_PERIPH1 13
37	#define CLK_PLL_PERIPH1_2X 14	39	#define CLK_PLL_PERIPH1_2X 14

drivers/clk/sunxi-ng/ccu-sun5i.c+1−1

@@ -243,7 +243,7 @@ static SUNXI_CCU_GATE(ahb_ss_clk, "ahb-ss", "ahb", · 242 unmodified lines
243	static SUNXI_CCU_GATE(ahb_dma_clk, "ahb-dma", "ahb",	243	static SUNXI_CCU_GATE(ahb_dma_clk, "ahb-dma", "ahb",
244	0x060, BIT(6), 0);	244	0x060, BIT(6), 0);
245	static SUNXI_CCU_GATE(ahb_bist_clk, "ahb-bist", "ahb",	245	static SUNXI_CCU_GATE(ahb_bist_clk, "ahb-bist", "ahb",
246	0x060, BIT(6), 0);	246	0x060, BIT(7), 0);
247	static SUNXI_CCU_GATE(ahb_mmc0_clk, "ahb-mmc0", "ahb",	247	static SUNXI_CCU_GATE(ahb_mmc0_clk, "ahb-mmc0", "ahb",
248	0x060, BIT(8), 0);	248	0x060, BIT(8), 0);
249	static SUNXI_CCU_GATE(ahb_mmc1_clk, "ahb-mmc1", "ahb",	249	static SUNXI_CCU_GATE(ahb_mmc1_clk, "ahb-mmc1", "ahb",

drivers/clk/sunxi-ng/ccu-sun6i-a31.c+1−1

@@ -556,7 +556,7 @@ static SUNXI_CCU_M_WITH_MUX_GATE(lcd0_ch1_clk, "lcd0-ch1", lcd_ch1_parents, · 555 unmodified lines
556	0x12c, 0, 4, 24, 3, BIT(31),	556	0x12c, 0, 4, 24, 3, BIT(31),
557	CLK_SET_RATE_PARENT);	557	CLK_SET_RATE_PARENT);
558	static SUNXI_CCU_M_WITH_MUX_GATE(lcd1_ch1_clk, "lcd1-ch1", lcd_ch1_parents,	558	static SUNXI_CCU_M_WITH_MUX_GATE(lcd1_ch1_clk, "lcd1-ch1", lcd_ch1_parents,
559	0x12c, 0, 4, 24, 3, BIT(31),	559	0x130, 0, 4, 24, 3, BIT(31),
560	CLK_SET_RATE_PARENT);	560	CLK_SET_RATE_PARENT);
561		561
562	static const char * const csi_sclk_parents[] = { "pll-video0", "pll-video1",	562	static const char * const csi_sclk_parents[] = { "pll-video0", "pll-video1",

drivers/clk/sunxi-ng/ccu-sun8i-h3.h+3−1

@@ -29,7 +29,9 @@ · 28 unmodified lines
29	#define CLK_PLL_VIDEO 6	29	#define CLK_PLL_VIDEO 6
30	#define CLK_PLL_VE 7	30	#define CLK_PLL_VE 7
31	#define CLK_PLL_DDR 8	31	#define CLK_PLL_DDR 8
32	#define CLK_PLL_PERIPH0 9	32
		33	/* PLL_PERIPH0 exported for PRCM */
		34
33	#define CLK_PLL_PERIPH0_2X 10	35	#define CLK_PLL_PERIPH0_2X 10
34	#define CLK_PLL_GPU 11	36	#define CLK_PLL_GPU 11
35	#define CLK_PLL_PERIPH1 12	37	#define CLK_PLL_PERIPH1 12

drivers/clk/sunxi-ng/ccu-sun8i-v3s.c+1−1

@@ -537,7 +537,7 @@ static struct ccu_reset_map sun8i_v3s_ccu_resets[] = { · 536 unmodified lines
537	[RST_BUS_EMAC] = { 0x2c0, BIT(17) },	537	[RST_BUS_EMAC] = { 0x2c0, BIT(17) },
538	[RST_BUS_HSTIMER] = { 0x2c0, BIT(19) },	538	[RST_BUS_HSTIMER] = { 0x2c0, BIT(19) },
539	[RST_BUS_SPI0] = { 0x2c0, BIT(20) },	539	[RST_BUS_SPI0] = { 0x2c0, BIT(20) },
540	[RST_BUS_OTG] = { 0x2c0, BIT(23) },	540	[RST_BUS_OTG] = { 0x2c0, BIT(24) },
541	[RST_BUS_EHCI0] = { 0x2c0, BIT(26) },	541	[RST_BUS_EHCI0] = { 0x2c0, BIT(26) },
542	[RST_BUS_OHCI0] = { 0x2c0, BIT(29) },	542	[RST_BUS_OHCI0] = { 0x2c0, BIT(29) },
543		543

drivers/clocksource/arm_arch_timer.c+2−2

@@ -1209,9 +1209,9 @@ arch_timer_mem_frame_get_cntfrq(struct arch_timer_mem_frame *frame) · 1208 unmodified lines
1209	return 0;	1209	return 0;
1210	}	1210	}
1211		1211
1212	rate = readl_relaxed(frame + CNTFRQ);	1212	rate = readl_relaxed(base + CNTFRQ);
1213		1213
1214	iounmap(frame);	1214	iounmap(base);
1215		1215
1216	return rate;	1216	return rate;
1217	}	1217	}

drivers/clocksource/cadence_ttc_timer.c+1−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <linux/clk.h>	18	#include <linux/clk.h>
19	#include <linux/interrupt.h>	19	#include <linux/interrupt.h>
20	#include <linux/clockchips.h>	20	#include <linux/clockchips.h>
		21	#include <linux/clocksource.h>
21	#include <linux/of_address.h>	22	#include <linux/of_address.h>
22	#include <linux/of_irq.h>	23	#include <linux/of_irq.h>
23	#include <linux/slab.h>	24	#include <linux/slab.h>

drivers/clocksource/timer-sun5i.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12		12
13	#include <linux/clk.h>	13	#include <linux/clk.h>
14	#include <linux/clockchips.h>	14	#include <linux/clockchips.h>
		15	#include <linux/clocksource.h>
15	#include <linux/delay.h>	16	#include <linux/delay.h>
16	#include <linux/interrupt.h>	17	#include <linux/interrupt.h>
17	#include <linux/irq.h>	18	#include <linux/irq.h>

drivers/cpufreq/cpufreq_conservative.c+2−2

@@ -185,8 +185,8 @@ static ssize_t store_down_threshold(struct gov_attr_set *attr_set, · 184 unmodified lines
185	int ret;	185	int ret;
186	ret = sscanf(buf, "%u", &input);	186	ret = sscanf(buf, "%u", &input);
187		187
188	/* cannot be lower than 11 otherwise freq will not fall */	188	/* cannot be lower than 1 otherwise freq will not fall */
189	if (ret != 1 \|\| input < 11 \|\| input > 100 \|\|	189	if (ret != 1 \|\| input < 1 \|\| input > 100 \|\|
190	input >= dbs_data->up_threshold)	190	input >= dbs_data->up_threshold)
191	return -EINVAL;	191	return -EINVAL;
192		192

drivers/cpuidle/dt_idle_states.c+3−1

 		if (!state_node)
 			break;
-		if (!of_device_is_available(state_node))
+		if (!of_device_is_available(state_node)) {
+			of_node_put(state_node);
 			continue;
+		}
 		if (!idle_state_valid(state_node, i, cpumask)) {
 			pr_warn("%s idle state not valid, bailing out\n",

drivers/devfreq/event/exynos-nocp.c+5−1

 	}
 	platform_set_drvdata(pdev, nocp);
-	clk_prepare_enable(nocp->clk);
+	ret = clk_prepare_enable(nocp->clk);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to prepare ppmu clock\n");
+		return ret;
+	}
 	pr_info("exynos-nocp: new NoC Probe device registered: %s\n",
 			dev_name(dev));

drivers/devfreq/event/exynos-ppmu.c+6−2

 	{ "ppmu-event2-"#name, PPMU_PMNCNT2 },	\
 	{ "ppmu-event3-"#name, PPMU_PMNCNT3 }
-struct __exynos_ppmu_events {
+static struct __exynos_ppmu_events {
 	char *name;
 	int id;
 } ppmu_events[] = {
 			dev_name(&pdev->dev), desc[i].name);
 	}
-	clk_prepare_enable(info->ppmu.clk);
+	ret = clk_prepare_enable(info->ppmu.clk);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to prepare ppmu clock\n");
+		return ret;
+	}
 	return 0;
 }

drivers/firmware/dmi-id.c+2−2

drivers/firmware/dmi_scan.c+37−12

 	buf = dmi_early_remap(dmi_base, orig_dmi_len);
 	if (buf == NULL)
-		return -1;
+		return -ENOMEM;
 	dmi_decode_table(buf, decode, NULL);
 	const char *d = (const char *) dm;
 	const char *p;
-	if (dmi_ident[slot])
+	if (dmi_ident[slot] || dm->length <= string)
 		return;
 	p = dmi_string(dm, d[string]);
 static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
 		int index)
 {
-	const u8 *d = (u8 *) dm + index;
+	const u8 *d;
 	char *s;
 	int is_ff = 1, is_00 = 1, i;
-	if (dmi_ident[slot])
+	if (dmi_ident[slot] || dm->length <= index + 16)
 		return;
+	d = (u8 *) dm + index;
 	for (i = 0; i < 16 && (is_ff || is_00); i++) {
 		if (d[i] != 0x00)
 			is_00 = 0;
 static void __init dmi_save_type(const struct dmi_header *dm, int slot,
 		int index)
 {
-	const u8 *d = (u8 *) dm + index;
+	const u8 *d;
 	char *s;
-	if (dmi_ident[slot])
+	if (dmi_ident[slot] || dm->length <= index)
 		return;
 	s = dmi_alloc(4);
 	if (!s)
 		return;
+	d = (u8 *) dm + index;
 	sprintf(s, "%u", *d & 0x7F);
 	dmi_ident[slot] = s;
 }
 static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
 {
-	int i, count = *(u8 *)(dm + 1);
+	int i, count;
 	struct dmi_device *dev;
+	if (dm->length < 0x05)
+		return;
+	count = *(u8 *)(dm + 1);
 	for (i = 1; i <= count; i++) {
 		const char *devname = dmi_string(dm, i);
 	const char *name;
 	const u8 *d = (u8 *)dm;
+	if (dm->length < 0x0B)
+		return;
 	/* Skip disabled device */
 	if ((d[0x5] & 0x80) == 0)
 		return;
 	const char *d = (const char *)dm;
 	static int nr;
-	if (dm->type != DMI_ENTRY_MEM_DEVICE)
+	if (dm->type != DMI_ENTRY_MEM_DEVICE || dm->length < 0x12)
 		return;
 	if (nr >= dmi_memdev_nr) {
 		pr_warn(FW_BUG "Too many DIMM entries in SMBIOS table\n");
 		if (p == NULL)
 			goto error;
+		/*
+		 * Same logic as above, look for a 64-bit entry point
+		 * first, and if not found, fall back to 32-bit entry point.
+		 */
+		memcpy_fromio(buf, p, 16);
+		for (q = p + 16; q < p + 0x10000; q += 16) {
+			memcpy_fromio(buf + 16, q, 16);
+			if (!dmi_smbios3_present(buf)) {
+				dmi_available = 1;
+				dmi_early_unmap(p, 0x10000);
+				goto out;
+			}
+			memcpy(buf, buf + 16, 16);
+		}
 		/*
 		 * Iterate over all possible DMI header addresses q.
 		 * Maintain the 32 bytes around q in buf.  On the
 		memset(buf, 0, 16);
 		for (q = p; q < p + 0x10000; q += 16) {
 			memcpy_fromio(buf + 16, q, 16);
-			if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
+			if (!dmi_present(buf)) {
 				dmi_available = 1;
 				dmi_early_unmap(p, 0x10000);
 				goto out;
  *	@decode: Callback function
  *	@private_data: Private data to be passed to the callback function
  *
- *	Returns -1 when the DMI table can't be reached, 0 on success.
+ *	Returns 0 on success, -ENXIO if DMI is not selected or not present,
+ *	or a different negative error code if DMI walking fails.
  */
 int dmi_walk(void (*decode)(const struct dmi_header *, void *),
 	     void *private_data)
 	u8 *buf;
 	if (!dmi_available)
-		return -1;
+		return -ENXIO;
 	buf = dmi_remap(dmi_base, dmi_len);
 	if (buf == NULL)
-		return -1;
+		return -ENOMEM;
 	dmi_decode_table(buf, decode, private_data);

drivers/gpio/gpio-mvebu.c+3−3

@@ -721,7 +721,7 @@ static int mvebu_pwm_probe(struct platform_device *pdev, · 720 unmodified lines
721	u32 set;	721	u32 set;
722		722
723	if (!of_device_is_compatible(mvchip->chip.of_node,	723	if (!of_device_is_compatible(mvchip->chip.of_node,
724	"marvell,armada-370-xp-gpio"))	724	"marvell,armada-370-gpio"))
725	return 0;	725	return 0;
726		726
727	if (IS_ERR(mvchip->clk))	727	if (IS_ERR(mvchip->clk))
@@ -852,7 +852,7 @@ static const struct of_device_id mvebu_gpio_of_match[] = { · 124 unmodified lines
852	.data = (void *) MVEBU_GPIO_SOC_VARIANT_ARMADAXP,	852	.data = (void *) MVEBU_GPIO_SOC_VARIANT_ARMADAXP,
853	},	853	},
854	{	854	{
855	.compatible = "marvell,armada-370-xp-gpio",	855	.compatible = "marvell,armada-370-gpio",
856	.data = (void *) MVEBU_GPIO_SOC_VARIANT_ORION,	856	.data = (void *) MVEBU_GPIO_SOC_VARIANT_ORION,
857	},	857	},
858	{	858	{
@@ -1128,7 +1128,7 @@ static int mvebu_gpio_probe(struct platform_device *pdev) · 269 unmodified lines
1128	mvchip);	1128	mvchip);
1129	}	1129	}
1130		1130
1131	/* Armada 370/XP has simple PWM support for GPIO lines */	1131	/* Some MVEBU SoCs have simple PWM support for GPIO lines */
1132	if (IS_ENABLED(CONFIG_PWM))	1132	if (IS_ENABLED(CONFIG_PWM))
1133	return mvebu_pwm_probe(pdev, mvchip, id);	1133	return mvebu_pwm_probe(pdev, mvchip, id);
1134		1134

drivers/gpu/drm/amd/amdgpu/amdgpu_atombios.c+4−0

 			DRM_INFO("Changing default dispclk from %dMhz to 600Mhz\n",
 				 adev->clock.default_dispclk / 100);
 			adev->clock.default_dispclk = 60000;
+		} else if (adev->clock.default_dispclk <= 60000) {
+			DRM_INFO("Changing default dispclk from %dMhz to 625Mhz\n",
+				 adev->clock.default_dispclk / 100);
+			adev->clock.default_dispclk = 62500;
 		}
 		adev->clock.dp_extclk =
 			le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);

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

@@ -475,6 +475,7 @@ static const struct pci_device_id pciidlist[] = { · 474 unmodified lines
475	{0x1002, 0x6986, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},	475	{0x1002, 0x6986, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},
476	{0x1002, 0x6987, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},	476	{0x1002, 0x6987, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},
477	{0x1002, 0x6995, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},	477	{0x1002, 0x6995, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},
		478	{0x1002, 0x6997, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},
478	{0x1002, 0x699F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},	479	{0x1002, 0x699F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_POLARIS12},
479	/* Vega 10 */	480	/* Vega 10 */
480	{0x1002, 0x6860, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VEGA10\|AMD_EXP_HW_SUPPORT},	481	{0x1002, 0x6860, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VEGA10\|AMD_EXP_HW_SUPPORT},

drivers/gpu/drm/amd/amdgpu/atombios_crtc.c+2−2

@@ -165,7 +165,7 @@ void amdgpu_atombios_crtc_powergate(struct drm_crtc *crtc, int state) · 164 unmodified lines
165	struct drm_device *dev = crtc->dev;	165	struct drm_device *dev = crtc->dev;
166	struct amdgpu_device *adev = dev->dev_private;	166	struct amdgpu_device *adev = dev->dev_private;
167	int index = GetIndexIntoMasterTable(COMMAND, EnableDispPowerGating);	167	int index = GetIndexIntoMasterTable(COMMAND, EnableDispPowerGating);
168	ENABLE_DISP_POWER_GATING_PARAMETERS_V2_1 args;	168	ENABLE_DISP_POWER_GATING_PS_ALLOCATION args;
169		169
170	memset(&args, 0, sizeof(args));	170	memset(&args, 0, sizeof(args));
171		171
@@ -178,7 +178,7 @@ void amdgpu_atombios_crtc_powergate(struct drm_crtc *crtc, int state) · 6 unmodified lines
178	void amdgpu_atombios_crtc_powergate_init(struct amdgpu_device *adev)	178	void amdgpu_atombios_crtc_powergate_init(struct amdgpu_device *adev)
179	{	179	{
180	int index = GetIndexIntoMasterTable(COMMAND, EnableDispPowerGating);	180	int index = GetIndexIntoMasterTable(COMMAND, EnableDispPowerGating);
181	ENABLE_DISP_POWER_GATING_PARAMETERS_V2_1 args;	181	ENABLE_DISP_POWER_GATING_PS_ALLOCATION args;
182		182
183	memset(&args, 0, sizeof(args));	183	memset(&args, 0, sizeof(args));
184		184

drivers/gpu/drm/amd/amdgpu/dce_v10_0.c+5−2

 	u32 tmp, wm_mask, lb_vblank_lead_lines = 0;
 	if (amdgpu_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		/* watermark for high clocks */
 		if (adev->pm.dpm_enabled) {

drivers/gpu/drm/amd/amdgpu/dce_v11_0.c+5−2

 	u32 tmp, wm_mask, lb_vblank_lead_lines = 0;
 	if (amdgpu_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		/* watermark for high clocks */
 		if (adev->pm.dpm_enabled) {

drivers/gpu/drm/amd/amdgpu/dce_v6_0.c+5−2

 	fixed20_12 a, b, c;
 	if (amdgpu_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		priority_a_cnt = 0;
 		priority_b_cnt = 0;

drivers/gpu/drm/amd/amdgpu/dce_v8_0.c+5−2

 	u32 tmp, wm_mask, lb_vblank_lead_lines = 0;
 	if (amdgpu_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		/* watermark for high clocks */
 		if (adev->pm.dpm_enabled) {

drivers/gpu/drm/bridge/synopsys/Kconfig+1−0

@@ -1,6 +1,7 @@
1	config DRM_DW_HDMI	1	config DRM_DW_HDMI
2	tristate	2	tristate
3	select DRM_KMS_HELPER	3	select DRM_KMS_HELPER
		4	select REGMAP_MMIO
4		5
5	config DRM_DW_HDMI_AHB_AUDIO	6	config DRM_DW_HDMI_AHB_AUDIO
6	tristate "Synopsys Designware AHB Audio interface"	7	tristate "Synopsys Designware AHB Audio interface"

drivers/gpu/drm/drm_connector.c+20−18

@@ -1293,21 +1293,6 @@ int drm_mode_getconnector(struct drm_device dev, void data, · 1292 unmodified lines
1293	if (!connector)	1293	if (!connector)
1294	return -ENOENT;	1294	return -ENOENT;
1295		1295
1296	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
1297	encoder = drm_connector_get_encoder(connector);
1298	if (encoder)
1299	out_resp->encoder_id = encoder->base.id;
1300	else
1301	out_resp->encoder_id = 0;
1302
1303	ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic,
1304	(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
1305	(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
1306	&out_resp->count_props);
1307	drm_modeset_unlock(&dev->mode_config.connection_mutex);
1308	if (ret)
1309	goto out_unref;
1310
1311	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)	1296	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
1312	if (connector->encoder_ids[i] != 0)	1297	if (connector->encoder_ids[i] != 0)
1313	encoders_count++;	1298	encoders_count++;
@@ -1320,7 +1305,7 @@ int drm_mode_getconnector(struct drm_device dev, void data, · 6 unmodified lines
1320	if (put_user(connector->encoder_ids[i],	1305	if (put_user(connector->encoder_ids[i],
1321	encoder_ptr + copied)) {	1306	encoder_ptr + copied)) {
1322	ret = -EFAULT;	1307	ret = -EFAULT;
1323	goto out_unref;	1308	goto out;
1324	}	1309	}
1325	copied++;	1310	copied++;
1326	}	1311	}
@@ -1364,15 +1349,32 @@ int drm_mode_getconnector(struct drm_device dev, void data, · 37 unmodified lines
1364	if (copy_to_user(mode_ptr + copied,	1349	if (copy_to_user(mode_ptr + copied,
1365	&u_mode, sizeof(u_mode))) {	1350	&u_mode, sizeof(u_mode))) {
1366	ret = -EFAULT;	1351	ret = -EFAULT;
		1352	mutex_unlock(&dev->mode_config.mutex);
		1353
1367	goto out;	1354	goto out;
1368	}	1355	}
1369	copied++;	1356	copied++;
1370	}	1357	}
1371	}	1358	}
1372	out_resp->count_modes = mode_count;	1359	out_resp->count_modes = mode_count;
1373	out:
1374	mutex_unlock(&dev->mode_config.mutex);	1360	mutex_unlock(&dev->mode_config.mutex);
1375	out_unref:	1361
		1362	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
		1363	encoder = drm_connector_get_encoder(connector);
		1364	if (encoder)
		1365	out_resp->encoder_id = encoder->base.id;
		1366	else
		1367	out_resp->encoder_id = 0;
		1368
		1369	/* Only grab properties after probing, to make sure EDID and other
		1370	* properties reflect the latest status. */
		1371	ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic,
		1372	(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
		1373	(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
		1374	&out_resp->count_props);
		1375	drm_modeset_unlock(&dev->mode_config.connection_mutex);
		1376
		1377	out:
1376	drm_connector_put(connector);	1378	drm_connector_put(connector);
1377		1379
1378	return ret;	1380	return ret;

drivers/gpu/drm/mgag200/mgag200_mode.c+8−1

 	if (IS_G200_SE(mdev)) {
-		if (mdev->unique_rev_id >= 0x02) {
+		if  (mdev->unique_rev_id >= 0x04) {
+			WREG8(MGAREG_CRTCEXT_INDEX, 0x06);
+			WREG8(MGAREG_CRTCEXT_DATA, 0);
+		} else if (mdev->unique_rev_id >= 0x02) {
 			u8 hi_pri_lvl;
 			u32 bpp;
 			u32 mb;
 			if (mga_vga_calculate_mode_bandwidth(mode, bpp)
 				> (30100 * 1024))
 				return MODE_BANDWIDTH;
+		} else {
+			if (mga_vga_calculate_mode_bandwidth(mode, bpp)
+				> (55000 * 1024))
+				return MODE_BANDWIDTH;
 		}
 	} else if (mdev->type == G200_WB) {
 		if (mode->hdisplay > 1280)

drivers/gpu/drm/radeon/cik.c+5−2

 	u32 tmp, wm_mask;
 	if (radeon_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		/* watermark for high clocks */
 		if ((rdev->pm.pm_method == PM_METHOD_DPM) &&

drivers/gpu/drm/radeon/evergreen.c+5−2

 	fixed20_12 a, b, c;
 	if (radeon_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		priority_a_cnt = 0;
 		priority_b_cnt = 0;
 		dram_channels = evergreen_get_number_of_dram_channels(rdev);

drivers/gpu/drm/radeon/radeon_combios.c+7−0

@@ -3393,6 +3393,13 @@ void radeon_combios_asic_init(struct drm_device *dev) · 3392 unmodified lines
3393	rdev->pdev->subsystem_vendor == 0x103c &&	3393	rdev->pdev->subsystem_vendor == 0x103c &&
3394	rdev->pdev->subsystem_device == 0x280a)	3394	rdev->pdev->subsystem_device == 0x280a)
3395	return;	3395	return;
		3396	/* quirk for rs4xx Toshiba Sattellite L20-183 latop to make it resume
		3397	* - it hangs on resume inside the dynclk 1 table.
		3398	*/
		3399	if (rdev->family == CHIP_RS400 &&
		3400	rdev->pdev->subsystem_vendor == 0x1179 &&
		3401	rdev->pdev->subsystem_device == 0xff31)
		3402	return;
3396		3403
3397	/* DYN CLK 1 */	3404	/* DYN CLK 1 */
3398	table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);	3405	table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);

drivers/gpu/drm/radeon/radeon_device.c+4−0

 	 * https://bugzilla.kernel.org/show_bug.cgi?id=51381
 	 */
 	{ PCI_VENDOR_ID_ATI, 0x6840, 0x1043, 0x2122, RADEON_PX_QUIRK_DISABLE_PX },
+	/* Asus K53TK laptop with AMD A6-3420M APU and Radeon 7670m GPU
+	 * https://bugs.freedesktop.org/show_bug.cgi?id=101491
+	 */
+	{ PCI_VENDOR_ID_ATI, 0x6741, 0x1043, 0x2122, RADEON_PX_QUIRK_DISABLE_PX },
 	/* macbook pro 8.2 */
 	{ PCI_VENDOR_ID_ATI, 0x6741, PCI_VENDOR_ID_APPLE, 0x00e2, RADEON_PX_QUIRK_LONG_WAKEUP },
 	{ 0, 0, 0, 0, 0 },

drivers/gpu/drm/radeon/radeon_uvd.c+1−1

@@ -621,7 +621,7 @@ static int radeon_uvd_cs_reloc(struct radeon_cs_parser *p, · 620 unmodified lines
621	}	621	}
622		622
623	/* TODO: is this still necessary on NI+ ? */	623	/* TODO: is this still necessary on NI+ ? */
624	if ((cmd == 0 \|\| cmd == 1 \|\| cmd == 0x3) &&	624	if ((cmd == 0 \|\| cmd == 0x3) &&
625	(start >> 28) != (p->rdev->uvd.gpu_addr >> 28)) {	625	(start >> 28) != (p->rdev->uvd.gpu_addr >> 28)) {
626	DRM_ERROR("msg/fb buffer %LX-%LX out of 256MB segment!\n",	626	DRM_ERROR("msg/fb buffer %LX-%LX out of 256MB segment!\n",
627	start, end);	627	start, end);

drivers/gpu/drm/radeon/si.c+5−2

 	fixed20_12 a, b, c;
 	if (radeon_crtc->base.enabled && num_heads && mode) {
-		active_time = 1000000UL * (u32)mode->crtc_hdisplay / (u32)mode->clock;
+		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
-		line_time = min((u32) (1000000UL * (u32)mode->crtc_htotal / (u32)mode->clock), (u32)65535);
+					    (u32)mode->clock);
+		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
+					  (u32)mode->clock);
+		line_time = min(line_time, (u32)65535);
 		priority_a_cnt = 0;
 		priority_b_cnt = 0;

drivers/gpu/drm/tegra/drm.c+5−17

 #ifdef CONFIG_DRM_TEGRA_STAGING
-static struct tegra_drm_context *
-tegra_drm_file_get_context(struct tegra_drm_file *file, u32 id)
-{
-	struct tegra_drm_context *context;
-	mutex_lock(&file->lock);
-	context = idr_find(&file->contexts, id);
-	mutex_unlock(&file->lock);
-	return context;
-}
 static int tegra_gem_create(struct drm_device *drm, void *data,
 			    struct drm_file *file)
 {
 	if (err < 0)
 		return err;
-	err = idr_alloc(&fpriv->contexts, context, 0, 0, GFP_KERNEL);
+	err = idr_alloc(&fpriv->contexts, context, 1, 0, GFP_KERNEL);
 	if (err < 0) {
 		client->ops->close_channel(context);
 		return err;
 	mutex_lock(&fpriv->lock);
-	context = tegra_drm_file_get_context(fpriv, args->context);
+	context = idr_find(&fpriv->contexts, args->context);
 	if (!context) {
 		err = -EINVAL;
 		goto unlock;
 	mutex_lock(&fpriv->lock);
-	context = tegra_drm_file_get_context(fpriv, args->context);
+	context = idr_find(&fpriv->contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;
 	mutex_lock(&fpriv->lock);
-	context = tegra_drm_file_get_context(fpriv, args->context);
+	context = idr_find(&fpriv->contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;
 	mutex_lock(&fpriv->lock);
-	context = tegra_drm_file_get_context(fpriv, args->context);
+	context = idr_find(&fpriv->contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;

drivers/gpu/host1x/dev.c+1−1

@@ -172,7 +172,7 @@ static int host1x_probe(struct platform_device *pdev) · 171 unmodified lines
172		172
173	host->rst = devm_reset_control_get(&pdev->dev, "host1x");	173	host->rst = devm_reset_control_get(&pdev->dev, "host1x");
174	if (IS_ERR(host->rst)) {	174	if (IS_ERR(host->rst)) {
175	err = PTR_ERR(host->clk);	175	err = PTR_ERR(host->rst);
176	dev_err(&pdev->dev, "failed to get reset: %d\n", err);	176	dev_err(&pdev->dev, "failed to get reset: %d\n", err);
177	return err;	177	return err;
178	}	178	}

drivers/hid/hid-core.c+221−61

@@ -826,11 +826,35 @@ static int hid_scan_report(struct hid_device *hid) · 825 unmodified lines
826	* hid-rmi should take care of them,	826	* hid-rmi should take care of them,
827	* not hid-generic	827	* not hid-generic
828	*/	828	*/
829	if (IS_ENABLED(CONFIG_HID_RMI))	829	hid->group = HID_GROUP_RMI;
830	hid->group = HID_GROUP_RMI;
831	break;	830	break;
832	}	831	}
833		832
		833	/* fall back to generic driver in case specific driver doesn't exist */
		834	switch (hid->group) {
		835	case HID_GROUP_MULTITOUCH_WIN_8:
		836	/* fall-through */
		837	case HID_GROUP_MULTITOUCH:
		838	if (!IS_ENABLED(CONFIG_HID_MULTITOUCH))
		839	hid->group = HID_GROUP_GENERIC;
		840	break;
		841	case HID_GROUP_SENSOR_HUB:
		842	if (!IS_ENABLED(CONFIG_HID_SENSOR_HUB))
		843	hid->group = HID_GROUP_GENERIC;
		844	break;
		845	case HID_GROUP_RMI:
		846	if (!IS_ENABLED(CONFIG_HID_RMI))
		847	hid->group = HID_GROUP_GENERIC;
		848	break;
		849	case HID_GROUP_WACOM:
		850	if (!IS_ENABLED(CONFIG_HID_WACOM))
		851	hid->group = HID_GROUP_GENERIC;
		852	break;
		853	case HID_GROUP_LOGITECH_DJ_DEVICE:
		854	if (!IS_ENABLED(CONFIG_HID_LOGITECH_DJ))
		855	hid->group = HID_GROUP_GENERIC;
		856	break;
		857	}
834	vfree(parser);	858	vfree(parser);
835	return 0;	859	return 0;
836	}	860	}
@@ -1763,15 +1787,23 @@ EXPORT_SYMBOL_GPL(hid_disconnect); · 926 unmodified lines
1763	* used as a driver. See hid_scan_report().	1787	* used as a driver. See hid_scan_report().
1764	*/	1788	*/
1765	static const struct hid_device_id hid_have_special_driver[] = {	1789	static const struct hid_device_id hid_have_special_driver[] = {
		1790	#if IS_ENABLED(CONFIG_HID_A4TECH)
1766	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },	1791	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
1767	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },	1792	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
1768	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },	1793	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
		1794	#endif
		1795	#if IS_ENABLED(CONFIG_HID_ACCUTOUCH)
		1796	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_ACCUTOUCH_2216) },
		1797	#endif
		1798	#if IS_ENABLED(CONFIG_HID_ACRUX)
1769	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },	1799	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
1770	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0xf705) },	1800	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0xf705) },
		1801	#endif
		1802	#if IS_ENABLED(CONFIG_HID_ALPS)
1771	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_ALPS_JP, HID_DEVICE_ID_ALPS_U1_DUAL) },	1803	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_ALPS_JP, HID_DEVICE_ID_ALPS_U1_DUAL) },
		1804	#endif
		1805	#if IS_ENABLED(CONFIG_HID_APPLE)
1772	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },	1806	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
1773	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
1774	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
1775	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },	1807	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
1776	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },	1808	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
1777	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },	1809	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
@@ -1792,11 +1824,6 @@ static const struct hid_device_id hid_have_special_driver[] = { · 14 unmodified lines
1792	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },	1824	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
1793	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },	1825	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
1794	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },	1826	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
1795	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },
1796	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
1797	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
1798	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
1799	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
1800	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },	1827	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
1801	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },	1828	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
1802	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },	1829	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
@@ -1851,62 +1878,100 @@ static const struct hid_device_id hid_have_special_driver[] = { · 48 unmodified lines
1851	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) },	1878	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) },
1852	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },	1879	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
1853	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },	1880	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
		1881	#endif
		1882	#if IS_ENABLED(CONFIG_HID_APPLEIR)
		1883	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },
		1884	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
		1885	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
		1886	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
		1887	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
		1888	#endif
		1889	#if IS_ENABLED(CONFIG_HID_ASUS)
1854	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_KEYBOARD) },	1890	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_KEYBOARD) },
1855	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_TOUCHPAD) },	1891	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_TOUCHPAD) },
1856	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1) },	1892	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1) },
1857	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2) },	1893	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2) },
1858	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T100_KEYBOARD) },	1894	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T100_KEYBOARD) },
		1895	#endif
		1896	#if IS_ENABLED(CONFIG_HID_AUREAL)
1859	{ HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },	1897	{ HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
		1898	#endif
		1899	#if IS_ENABLED(CONFIG_HID_BELKIN)
1860	{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },	1900	{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
		1901	{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
		1902	#endif
		1903	#if IS_ENABLED(CONFIG_HID_BETOP_FF)
1861	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185BFM, 0x2208) },	1904	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185BFM, 0x2208) },
1862	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185PC, 0x5506) },	1905	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185PC, 0x5506) },
1863	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2PC, 0x1850) },	1906	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2PC, 0x1850) },
1864	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2BFM, 0x5500) },	1907	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2BFM, 0x5500) },
1865	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },	1908	#endif
1866	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },	1909	#if IS_ENABLED(CONFIG_HID_CHERRY)
1867	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },	1910	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
1868	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },	1911	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
		1912	#endif
		1913	#if IS_ENABLED(CONFIG_HID_CHICONY)
1869	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },	1914	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
1870	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
1871	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },	1915	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
1872	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },	1916	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
1873	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },	1917	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },
		1918	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_JESS_ZEN_AIO_KBD) },
		1919	#endif
		1920	#if IS_ENABLED(CONFIG_HID_CMEDIA)
		1921	{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) },
		1922	#endif
		1923	#if IS_ENABLED(CONFIG_HID_CORSAIR)
1874	{ HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90) },	1924	{ HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90) },
1875	{ HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },	1925	{ HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },
1876	{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },	1926	#endif
		1927	#if IS_ENABLED(CONFIG_HID_CP2112)
1877	{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },	1928	{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
		1929	#endif
		1930	#if IS_ENABLED(CONFIG_HID_CYPRESS)
1878	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },	1931	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
1879	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },	1932	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
1880	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },	1933	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
1881	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_4) },	1934	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_4) },
1882	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },	1935	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
1883	{ HID_USB_DEVICE(USB_VENDOR_ID_DELCOM, USB_DEVICE_ID_DELCOM_VISUAL_IND) },	1936	#endif
		1937	#if IS_ENABLED(CONFIG_HID_DRAGONRISE)
1884	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },	1938	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
1885	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },	1939	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
1886	#if IS_ENABLED(CONFIG_HID_MAYFLASH)
1887	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) },
1888	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR) },
1889	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1) },
1890	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2) },
1891	#endif	1940	#endif
1892	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) },	1941	#if IS_ENABLED(CONFIG_HID_ELECOM)
1893	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) },
1894	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },	1942	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
1895	{ HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRED) },	1943	{ HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRED) },
1896	{ HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRELESS) },	1944	{ HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRELESS) },
		1945	#endif
		1946	#if IS_ENABLED(CONFIG_HID_ELO)
1897	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },	1947	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
1898	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },	1948	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
1899	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_ACCUTOUCH_2216) },	1949	#endif
		1950	#if IS_ENABLED(CONFIG_HID_EMS_FF)
1900	{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },	1951	{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
		1952	#endif
		1953	#if IS_ENABLED(CONFIG_HID_EZKEY)
1901	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },	1954	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
1902	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },	1955	#endif
1903	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },	1956	#if IS_ENABLED(CONFIG_HID_GEMBIRD)
1904	{ HID_USB_DEVICE(USB_VENDOR_ID_GEMBIRD, USB_DEVICE_ID_GEMBIRD_JPD_DUALFORCE2) },	1957	{ HID_USB_DEVICE(USB_VENDOR_ID_GEMBIRD, USB_DEVICE_ID_GEMBIRD_JPD_DUALFORCE2) },
1905	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },	1958	#endif
		1959	#if IS_ENABLED(CONFIG_HID_GFRM)
		1960	{ HID_BLUETOOTH_DEVICE(0x58, 0x2000) },
		1961	{ HID_BLUETOOTH_DEVICE(0x471, 0x2210) },
		1962	#endif
		1963	#if IS_ENABLED(CONFIG_HID_GREENASIA)
1906	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },	1964	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
		1965	#endif
		1966	#if IS_ENABLED(CONFIG_HID_GT683R)
		1967	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
		1968	#endif
		1969	#if IS_ENABLED(CONFIG_HID_GYRATION)
1907	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },	1970	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
1908	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },	1971	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
1909	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },	1972	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
		1973	#endif
		1974	#if IS_ENABLED(CONFIG_HID_HOLTEK)
1910	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },	1975	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
1911	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },	1976	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
1912	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },	1977	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
@@ -1915,12 +1980,17 @@ static const struct hid_device_id hid_have_special_driver[] = { · 2 unmodified lines
1915	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072) },	1980	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072) },
1916	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081) },	1981	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081) },
1917	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2) },	1982	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2) },
1918	{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },	1983	#endif
1919	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_JESS_ZEN_AIO_KBD) },	1984	#if IS_ENABLED(CONFIG_HID_ICADE)
1920	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
1921	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },	1985	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
		1986	#endif
		1987	#if IS_ENABLED(CONFIG_HID_KENSINGTON)
1922	{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },	1988	{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
		1989	#endif
		1990	#if IS_ENABLED(CONFIG_HID_KEYTOUCH)
1923	{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },	1991	{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
		1992	#endif
		1993	#if IS_ENABLED(CONFIG_HID_KYE)
1924	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },	1994	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
1925	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_MANTICORE) },	1995	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_MANTICORE) },
1926	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },	1996	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
@@ -1930,21 +2000,29 @@ static const struct hid_device_id hid_have_special_driver[] = { · 3 unmodified lines
1930	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_V2) },	2000	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_V2) },
1931	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },	2001	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
1932	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912) },	2002	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912) },
1933	{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },	2003	#endif
		2004	#if IS_ENABLED(CONFIG_HID_LCPOWER)
1934	{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },	2005	{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
		2006	#endif
		2007	#if IS_ENABLED(CONFIG_HID_LED)
		2008	{ HID_USB_DEVICE(USB_VENDOR_ID_DELCOM, USB_DEVICE_ID_DELCOM_VISUAL_IND) },
		2009	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) },
		2010	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) },
		2011	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_LUXAFOR) },
		2012	{ HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU, USB_DEVICE_ID_RI_KA_WEBMAIL) },
		2013	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
		2014	#endif
1935	#if IS_ENABLED(CONFIG_HID_LENOVO)	2015	#if IS_ENABLED(CONFIG_HID_LENOVO)
1936	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },	2016	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
1937	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },	2017	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
1938	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },	2018	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
1939	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },	2019	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
1940	#endif	2020	#endif
1941	{ HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MELFAS_MT) },	2021	#if IS_ENABLED(CONFIG_HID_LOGITECH)
1942	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },	2022	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
1943	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },	2023	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
1944	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },	2024	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
1945	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },	2025	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
1946	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
1947	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
1948	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },	2026	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
1949	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },	2027	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
1950	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },	2028	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
@@ -1957,7 +2035,6 @@ static const struct hid_device_id hid_have_special_driver[] = { · 6 unmodified lines
1957	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },	2035	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
1958	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },	2036	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
1959	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29_WHEEL) },	2037	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29_WHEEL) },
1960	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL) },
1961	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },	2038	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
1962	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },	2039	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
1963	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },	2040	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
@@ -1969,17 +2046,30 @@ static const struct hid_device_id hid_have_special_driver[] = { · 5 unmodified lines
1969	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },	2046	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
1970	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },	2047	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
1971	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },	2048	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
1972	#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
1973	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
1974	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
1975	#endif
1976	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },	2049	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
1977	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },	2050	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
1978	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },	2051	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
1979	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },	2052	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
1980	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },	2053	#endif
1981	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },	2054	#if IS_ENABLED(CONFIG_HID_LOGITECH_HIDPP)
1982	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_LUXAFOR) },	2055	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
		2056	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL) },
		2057	#endif
		2058	#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
		2059	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
		2060	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
		2061	#endif
		2062	#if IS_ENABLED(CONFIG_HID_MAGICMOUSE)
		2063	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
		2064	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
		2065	#endif
		2066	#if IS_ENABLED(CONFIG_HID_MAYFLASH)
		2067	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) },
		2068	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR) },
		2069	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1) },
		2070	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2) },
		2071	#endif
		2072	#if IS_ENABLED(CONFIG_HID_MICROSOFT)
1983	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },	2073	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
1984	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD) },	2074	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD) },
1985	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },	2075	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
@@ -1995,9 +2085,22 @@ static const struct hid_device_id hid_have_special_driver[] = { · 9 unmodified lines
1995	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },	2085	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },
1996	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },	2086	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },
1997	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER) },	2087	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER) },
		2088	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
		2089	#endif
		2090	#if IS_ENABLED(CONFIG_HID_MONTEREY)
1998	{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },	2091	{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
1999	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },	2092	#endif
		2093	#if IS_ENABLED(CONFIG_HID_MULTITOUCH)
		2094	{ HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MELFAS_MT) },
		2095	#endif
		2096	#if IS_ENABLED(CONFIG_HID_WIIMOTE)
		2097	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
		2098	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
		2099	#endif
		2100	#if IS_ENABLED(CONFIG_HID_NTI)
2000	{ HID_USB_DEVICE(USB_VENDOR_ID_NTI, USB_DEVICE_ID_USB_SUN) },	2101	{ HID_USB_DEVICE(USB_VENDOR_ID_NTI, USB_DEVICE_ID_USB_SUN) },
		2102	#endif
		2103	#if IS_ENABLED(CONFIG_HID_NTRIG)
2001	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },	2104	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
2002	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },	2105	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
2003	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },	2106	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
@@ -2017,13 +2120,41 @@ static const struct hid_device_id hid_have_special_driver[] = { · 13 unmodified lines
2017	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },	2120	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
2018	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },	2121	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
2019	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },	2122	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
		2123	#endif
		2124	#if IS_ENABLED(CONFIG_HID_ORTEK)
2020	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },	2125	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
2021	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },	2126	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
		2127	{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
		2128	#endif
		2129	#if IS_ENABLED(CONFIG_HID_PANTHERLORD)
		2130	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
		2131	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
		2132	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
		2133	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
		2134	#endif
		2135	#if IS_ENABLED(CONFIG_HID_PENMOUNT)
2022	{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_6000) },	2136	{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_6000) },
		2137	#endif
		2138	#if IS_ENABLED(CONFIG_HID_PETALYNX)
2023	{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },	2139	{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
		2140	#endif
		2141	#if IS_ENABLED(CONFIG_HID_PICOLCD)
		2142	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
		2143	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
		2144	#endif
		2145	#if IS_ENABLED(CONFIG_HID_PLANTRONICS)
2024	{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },	2146	{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
		2147	#endif
		2148	#if IS_ENABLED(CONFIG_HID_PRIMAX)
2025	{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },	2149	{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
2026	{ HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU, USB_DEVICE_ID_RI_KA_WEBMAIL) },	2150	#endif
		2151	#if IS_ENABLED(CONFIG_HID_PRODIKEYS)
		2152	{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
		2153	#endif
		2154	#if IS_ENABLED(CONFIG_HID_RMI)
		2155	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
		2156	{ HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) },
		2157	#endif
2027	#if IS_ENABLED(CONFIG_HID_ROCCAT)	2158	#if IS_ENABLED(CONFIG_HID_ROCCAT)
2028	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },	2159	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
2029	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },	2160	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
@@ -2051,9 +2182,21 @@ static const struct hid_device_id hid_have_special_driver[] = { · 21 unmodified lines
2051	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT5) },	2182	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT5) },
2052	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },	2183	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },
2053	#endif	2184	#endif
		2185	#if IS_ENABLED(CONFIG_HID_SAMSUNG)
2054	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },	2186	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
2055	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },	2187	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
2056	{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },	2188	#endif
		2189	#if IS_ENABLED(CONFIG_HID_SMARTJOYPLUS)
		2190	{ HID_USB_DEVICE(USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII) },
		2191	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
		2192	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
		2193	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
		2194	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
		2195	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
		2196	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
		2197	#endif
		2198	#if IS_ENABLED(CONFIG_HID_SONY)
		2199	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
2057	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) },	2200	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) },
2058	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },	2201	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
2059	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },	2202	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
@@ -2072,9 +2215,17 @@ static const struct hid_device_id hid_have_special_driver[] = { · 12 unmodified lines
2072	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },	2215	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
2073	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },	2216	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },
2074	{ HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER) },	2217	{ HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER) },
		2218	#endif
		2219	#if IS_ENABLED(CONFIG_HID_SPEEDLINK)
		2220	{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
		2221	#endif
		2222	#if IS_ENABLED(CONFIG_HID_STEELSERIES)
2075	{ HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) },	2223	{ HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) },
		2224	#endif
		2225	#if IS_ENABLED(CONFIG_HID_SUNPLUS)
2076	{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },	2226	{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
2077	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },	2227	#endif
		2228	#if IS_ENABLED(CONFIG_HID_THRUSTMASTER)
2078	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },	2229	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
2079	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },	2230	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
2080	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },	2231	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
@@ -2083,12 +2234,25 @@ static const struct hid_device_id hid_have_special_driver[] = { · 2 unmodified lines
2083	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },	2234	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
2084	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },	2235	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
2085	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },	2236	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
		2237	#endif
		2238	#if IS_ENABLED(CONFIG_HID_TIVO)
2086	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },	2239	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },
2087	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },	2240	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
2088	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_PRO) },	2241	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_PRO) },
		2242	#endif
		2243	#if IS_ENABLED(CONFIG_HID_TOPSEED)
		2244	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
		2245	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
		2246	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
2089	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },	2247	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
2090	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },	2248	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
		2249	#endif
		2250	#if IS_ENABLED(CONFIG_HID_TWINHAN)
2091	{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },	2251	{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
		2252	#endif
		2253	#if IS_ENABLED(CONFIG_HID_UCLOGIC)
		2254	{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },
		2255	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_HUION_TABLET) },
2092	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },	2256	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
2093	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },	2257	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
2094	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },	2258	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
@@ -2096,20 +2260,17 @@ static const struct hid_device_id hid_have_special_driver[] = { · 1 unmodified line
2096	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },	2260	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
2097	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },	2261	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
2098	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },	2262	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
2099	{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },
2100	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_YIYNOVA_TABLET) },	2263	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_YIYNOVA_TABLET) },
2101	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_81) },	2264	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_81) },
2102	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_45) },	2265	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_45) },
2103	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3) },	2266	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3) },
2104	{ HID_USB_DEVICE(USB_VENDOR_ID_UGTIZER, USB_DEVICE_ID_UGTIZER_TABLET_GP0610) },
2105	{ HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_TABLET_EX07S) },	2267	{ HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_TABLET_EX07S) },
2106	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },	2268	{ HID_USB_DEVICE(USB_VENDOR_ID_UGTIZER, USB_DEVICE_ID_UGTIZER_TABLET_GP0610) },
2107	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },	2269	#endif
2108	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },	2270	#if IS_ENABLED(CONFIG_HID_UDRAW_PS3)
2109	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },	2271	{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },
2110	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },	2272	#endif
2111	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },	2273	#if IS_ENABLED(CONFIG_HID_WALTOP)
2112	{ HID_USB_DEVICE(USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII) },
2113	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },	2274	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
2114	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },	2275	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
2115	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },	2276	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
@@ -2117,19 +2278,18 @@ static const struct hid_device_id hid_have_special_driver[] = { · 1 unmodified line
2117	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },	2278	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
2118	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },	2279	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
2119	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },	2280	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
2120	{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },	2281	#endif
		2282	#if IS_ENABLED(CONFIG_HID_XINMO)
2121	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },	2283	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },
2122	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_THT_2P_ARCADE) },	2284	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_THT_2P_ARCADE) },
		2285	#endif
		2286	#if IS_ENABLED(CONFIG_HID_ZEROPLUS)
2123	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },	2287	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
2124	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },	2288	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
		2289	#endif
		2290	#if IS_ENABLED(CONFIG_HID_ZYDACRON)
2125	{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },	2291	{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
2126		2292	#endif
2127	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
2128	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
2129	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
2130	{ HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) },
2131	{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) },
2132	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
2133	{ }	2293	{ }
2134	};	2294	};
2135		2295

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

@@ -319,6 +319,9 @@ · 318 unmodified lines
319	#define USB_VENDOR_ID_DELCOM 0x0fc5	319	#define USB_VENDOR_ID_DELCOM 0x0fc5
320	#define USB_DEVICE_ID_DELCOM_VISUAL_IND 0xb080	320	#define USB_DEVICE_ID_DELCOM_VISUAL_IND 0xb080
321		321
		322	#define USB_VENDOR_ID_DELL 0x413c
		323	#define USB_DEVICE_ID_DELL_PIXART_USB_OPTICAL_MOUSE 0x301a
		324
322	#define USB_VENDOR_ID_DELORME 0x1163	325	#define USB_VENDOR_ID_DELORME 0x1163
323	#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100	326	#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
324	#define USB_DEVICE_ID_DELORME_EM_LT20 0x0200	327	#define USB_DEVICE_ID_DELORME_EM_LT20 0x0200

drivers/hid/hid-magicmouse.c+7−8

 	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
 		magicmouse_emit_buttons(msc, clicks & 3);
-		input_mt_report_pointer_emulation(input, true);
 		input_report_rel(input, REL_X, x);
 		input_report_rel(input, REL_Y, y);
 	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 		__clear_bit(BTN_RIGHT, input->keybit);
 		__clear_bit(BTN_MIDDLE, input->keybit);
 		__set_bit(BTN_MOUSE, input->keybit);
+		__set_bit(BTN_TOOL_FINGER, input->keybit);
+		__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
+		__set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
+		__set_bit(BTN_TOOL_QUADTAP, input->keybit);
+		__set_bit(BTN_TOOL_QUINTTAP, input->keybit);
+		__set_bit(BTN_TOUCH, input->keybit);
+		__set_bit(INPUT_PROP_POINTER, input->propbit);
 		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 	}
-	__set_bit(BTN_TOOL_FINGER, input->keybit);
-	__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
-	__set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
-	__set_bit(BTN_TOOL_QUADTAP, input->keybit);
-	__set_bit(BTN_TOOL_QUINTTAP, input->keybit);
-	__set_bit(BTN_TOUCH, input->keybit);
-	__set_bit(INPUT_PROP_POINTER, input->propbit);
 	__set_bit(EV_ABS, input->evbit);

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

@@ -85,6 +85,7 @@ static const struct hid_blacklist { · 84 unmodified lines
85	{ USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K65RGB_RAPIDFIRE, HID_QUIRK_NO_INIT_REPORTS \| HID_QUIRK_ALWAYS_POLL },	85	{ USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K65RGB_RAPIDFIRE, HID_QUIRK_NO_INIT_REPORTS \| HID_QUIRK_ALWAYS_POLL },
86	{ USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB, HID_QUIRK_NO_INIT_REPORTS \| HID_QUIRK_ALWAYS_POLL },	86	{ USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB, HID_QUIRK_NO_INIT_REPORTS \| HID_QUIRK_ALWAYS_POLL },
87	{ USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_CREATIVE_SB_OMNI_SURROUND_51, HID_QUIRK_NOGET },	87	{ USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_CREATIVE_SB_OMNI_SURROUND_51, HID_QUIRK_NOGET },
		88	{ USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_PIXART_USB_OPTICAL_MOUSE, HID_QUIRK_ALWAYS_POLL },
88	{ USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },	89	{ USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
89	{ USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_WIIU, HID_QUIRK_MULTI_INPUT },	90	{ USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_WIIU, HID_QUIRK_MULTI_INPUT },
90	{ USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3, HID_QUIRK_MULTI_INPUT },	91	{ USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3, HID_QUIRK_MULTI_INPUT },

drivers/hsi/clients/ssi_protocol.c+1−1

@@ -1066,7 +1066,7 @@ static void ssip_pn_setup(struct net_device *dev) · 1065 unmodified lines
1066	dev->addr_len = 1;	1066	dev->addr_len = 1;
1067	dev->tx_queue_len = SSIP_TXQUEUE_LEN;	1067	dev->tx_queue_len = SSIP_TXQUEUE_LEN;
1068		1068
1069	dev->destructor = free_netdev;	1069	dev->needs_free_netdev = true;
1070	dev->header_ops = &phonet_header_ops;	1070	dev->header_ops = &phonet_header_ops;
1071	}	1071	}
1072		1072

drivers/i2c/busses/i2c-imx.c+4−4

@@ -734,9 +734,9 @@ static int i2c_imx_dma_read(struct imx_i2c_struct *i2c_imx, · 733 unmodified lines
734	* the first read operation, otherwise the first read cost	734	* the first read operation, otherwise the first read cost
735	* one extra clock cycle.	735	* one extra clock cycle.
736	*/	736	*/
737	temp = readb(i2c_imx->base + IMX_I2C_I2CR);	737	temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
738	temp \|= I2CR_MTX;	738	temp \|= I2CR_MTX;
739	writeb(temp, i2c_imx->base + IMX_I2C_I2CR);	739	imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
740	}	740	}
741	msgs->buf[msgs->len-1] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);	741	msgs->buf[msgs->len-1] = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2DR);
742		742
@@ -857,9 +857,9 @@ static int i2c_imx_read(struct imx_i2c_struct i2c_imx, struct i2c_msg msgs, bo · 114 unmodified lines
857	* the first read operation, otherwise the first read cost	857	* the first read operation, otherwise the first read cost
858	* one extra clock cycle.	858	* one extra clock cycle.
859	*/	859	*/
860	temp = readb(i2c_imx->base + IMX_I2C_I2CR);	860	temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
861	temp \|= I2CR_MTX;	861	temp \|= I2CR_MTX;
862	writeb(temp, i2c_imx->base + IMX_I2C_I2CR);	862	imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
863	}	863	}
864	} else if (i == (msgs->len - 2)) {	864	} else if (i == (msgs->len - 2)) {
865	dev_dbg(&i2c_imx->adapter.dev,	865	dev_dbg(&i2c_imx->adapter.dev,

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

@@ -584,7 +584,7 @@ static int ismt_access(struct i2c_adapter *adap, u16 addr, · 583 unmodified lines
584		584
585	/* unmap the data buffer */	585	/* unmap the data buffer */
586	if (dma_size != 0)	586	if (dma_size != 0)
587	dma_unmap_single(&adap->dev, dma_addr, dma_size, dma_direction);	587	dma_unmap_single(dev, dma_addr, dma_size, dma_direction);
588		588
589	if (unlikely(!time_left)) {	589	if (unlikely(!time_left)) {
590	dev_err(dev, "completion wait timed out\n");	590	dev_err(dev, "completion wait timed out\n");

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

@@ -319,7 +319,7 @@ static void rcar_i2c_dma_unmap(struct rcar_i2c_priv *priv) · 318 unmodified lines
319	rcar_i2c_write(priv, ICFBSCR, TCYC06);	319	rcar_i2c_write(priv, ICFBSCR, TCYC06);
320		320
321	dma_unmap_single(chan->device->dev, sg_dma_address(&priv->sg),	321	dma_unmap_single(chan->device->dev, sg_dma_address(&priv->sg),
322	priv->msg->len, priv->dma_direction);	322	sg_dma_len(&priv->sg), priv->dma_direction);
323		323
324	priv->dma_direction = DMA_NONE;	324	priv->dma_direction = DMA_NONE;
325	}	325	}

drivers/iio/adc/meson_saradc.c+2−2

@@ -468,13 +468,13 @@ static void meson_sar_adc_unlock(struct iio_dev *indio_dev) · 467 unmodified lines
468	static void meson_sar_adc_clear_fifo(struct iio_dev *indio_dev)	468	static void meson_sar_adc_clear_fifo(struct iio_dev *indio_dev)
469	{	469	{
470	struct meson_sar_adc_priv *priv = iio_priv(indio_dev);	470	struct meson_sar_adc_priv *priv = iio_priv(indio_dev);
471	int count;	471	unsigned int count, tmp;
472		472
473	for (count = 0; count < MESON_SAR_ADC_MAX_FIFO_SIZE; count++) {	473	for (count = 0; count < MESON_SAR_ADC_MAX_FIFO_SIZE; count++) {
474	if (!meson_sar_adc_get_fifo_count(indio_dev))	474	if (!meson_sar_adc_get_fifo_count(indio_dev))
475	break;	475	break;
476		476
477	regmap_read(priv->regmap, MESON_SAR_ADC_FIFO_RD, 0);	477	regmap_read(priv->regmap, MESON_SAR_ADC_FIFO_RD, &tmp);
478	}	478	}
479	}	479	}
480		480

drivers/iio/adc/mxs-lradc-adc.c+5−2

 	adc->dev = dev;
 	iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!iores)
+		return -EINVAL;
 	adc->base = devm_ioremap(dev, iores->start, resource_size(iores));
-	if (IS_ERR(adc->base))
+	if (!adc->base)
-		return PTR_ERR(adc->base);
+		return -ENOMEM;
 	init_completion(&adc->completion);
 	spin_lock_init(&adc->lock);

drivers/iio/buffer/industrialio-buffer-dma.c+1−0

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	#include <linux/sched.h>	14	#include <linux/sched.h>
15	#include <linux/poll.h>	15	#include <linux/poll.h>
16	#include <linux/iio/buffer.h>	16	#include <linux/iio/buffer.h>
		17	#include <linux/iio/buffer_impl.h>
17	#include <linux/iio/buffer-dma.h>	18	#include <linux/iio/buffer-dma.h>
18	#include <linux/dma-mapping.h>	19	#include <linux/dma-mapping.h>
19	#include <linux/sizes.h>	20	#include <linux/sizes.h>

drivers/iio/buffer/industrialio-buffer-dmaengine.c+1−0

@@ -14,6 +14,7 @@ · 13 unmodified lines
14		14
15	#include <linux/iio/iio.h>	15	#include <linux/iio/iio.h>
16	#include <linux/iio/buffer.h>	16	#include <linux/iio/buffer.h>
		17	#include <linux/iio/buffer_impl.h>
17	#include <linux/iio/buffer-dma.h>	18	#include <linux/iio/buffer-dma.h>
18	#include <linux/iio/buffer-dmaengine.h>	19	#include <linux/iio/buffer-dmaengine.h>
19		20

drivers/iio/imu/inv_mpu6050/inv_mpu_core.c+36−3

@@ -41,6 +41,7 @@ static const int accel_scale[] = {598, 1196, 2392, 4785}; · 40 unmodified lines
41	static const struct inv_mpu6050_reg_map reg_set_6500 = {	41	static const struct inv_mpu6050_reg_map reg_set_6500 = {
42	.sample_rate_div = INV_MPU6050_REG_SAMPLE_RATE_DIV,	42	.sample_rate_div = INV_MPU6050_REG_SAMPLE_RATE_DIV,
43	.lpf = INV_MPU6050_REG_CONFIG,	43	.lpf = INV_MPU6050_REG_CONFIG,
		44	.accel_lpf = INV_MPU6500_REG_ACCEL_CONFIG_2,
44	.user_ctrl = INV_MPU6050_REG_USER_CTRL,	45	.user_ctrl = INV_MPU6050_REG_USER_CTRL,
45	.fifo_en = INV_MPU6050_REG_FIFO_EN,	46	.fifo_en = INV_MPU6050_REG_FIFO_EN,
46	.gyro_config = INV_MPU6050_REG_GYRO_CONFIG,	47	.gyro_config = INV_MPU6050_REG_GYRO_CONFIG,
@@ -210,6 +211,37 @@ int inv_mpu6050_set_power_itg(struct inv_mpu6050_state *st, bool power_on) · 163 unmodified lines
210	}	211	}
211	EXPORT_SYMBOL_GPL(inv_mpu6050_set_power_itg);	212	EXPORT_SYMBOL_GPL(inv_mpu6050_set_power_itg);
212		213
		214	/**
		215	* inv_mpu6050_set_lpf_regs() - set low pass filter registers, chip dependent
		216	*
		217	* MPU60xx/MPU9150 use only 1 register for accelerometer + gyroscope
		218	* MPU6500 and above have a dedicated register for accelerometer
		219	*/
		220	static int inv_mpu6050_set_lpf_regs(struct inv_mpu6050_state *st,
		221	enum inv_mpu6050_filter_e val)
		222	{
		223	int result;
		224
		225	result = regmap_write(st->map, st->reg->lpf, val);
		226	if (result)
		227	return result;
		228
		229	switch (st->chip_type) {
		230	case INV_MPU6050:
		231	case INV_MPU6000:
		232	case INV_MPU9150:
		233	/* old chips, nothing to do */
		234	result = 0;
		235	break;
		236	default:
		237	/* set accel lpf */
		238	result = regmap_write(st->map, st->reg->accel_lpf, val);
		239	break;
		240	}
		241
		242	return result;
		243	}
		244
213	/**	245	/**
214	* inv_mpu6050_init_config() - Initialize hardware, disable FIFO.	246	* inv_mpu6050_init_config() - Initialize hardware, disable FIFO.
215	*	247	*
@@ -233,8 +265,7 @@ static int inv_mpu6050_init_config(struct iio_dev *indio_dev) · 17 unmodified lines
233	if (result)	265	if (result)
234	return result;	266	return result;
235		267
236	d = INV_MPU6050_FILTER_20HZ;	268	result = inv_mpu6050_set_lpf_regs(st, INV_MPU6050_FILTER_20HZ);
237	result = regmap_write(st->map, st->reg->lpf, d);
238	if (result)	269	if (result)
239	return result;	270	return result;
240		271
@@ -537,6 +568,8 @@ error_write_raw: · 296 unmodified lines
537	* would be alising. This function basically search for the	568	* would be alising. This function basically search for the
538	* correct low pass parameters based on the fifo rate, e.g,	569	* correct low pass parameters based on the fifo rate, e.g,
539	* sampling frequency.	570	* sampling frequency.
		571	*
		572	* lpf is set automatically when setting sampling rate to avoid any aliases.
540	*/	573	*/
541	static int inv_mpu6050_set_lpf(struct inv_mpu6050_state *st, int rate)	574	static int inv_mpu6050_set_lpf(struct inv_mpu6050_state *st, int rate)
542	{	575	{
@@ -552,7 +585,7 @@ static int inv_mpu6050_set_lpf(struct inv_mpu6050_state *st, int rate) · 9 unmodified lines
552	while ((h < hz[i]) && (i < ARRAY_SIZE(d) - 1))	585	while ((h < hz[i]) && (i < ARRAY_SIZE(d) - 1))
553	i++;	586	i++;
554	data = d[i];	587	data = d[i];
555	result = regmap_write(st->map, st->reg->lpf, data);	588	result = inv_mpu6050_set_lpf_regs(st, data);
556	if (result)	589	if (result)
557	return result;	590	return result;
558	st->chip_config.lpf = data;	591	st->chip_config.lpf = data;

drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h+3−0

  *  struct inv_mpu6050_reg_map - Notable registers.
  *  @sample_rate_div:	Divider applied to gyro output rate.
  *  @lpf:		Configures internal low pass filter.
+ *  @accel_lpf:		Configures accelerometer low pass filter.
  *  @user_ctrl:		Enables/resets the FIFO.
  *  @fifo_en:		Determines which data will appear in FIFO.
  *  @gyro_config:	gyro config register.
 struct inv_mpu6050_reg_map {
 	u8 sample_rate_div;
 	u8 lpf;
+	u8 accel_lpf;
 	u8 user_ctrl;
 	u8 fifo_en;
 	u8 gyro_config;
 #define INV_MPU6050_FIFO_THRESHOLD           500
 /* mpu6500 registers */
+#define INV_MPU6500_REG_ACCEL_CONFIG_2      0x1D
 #define INV_MPU6500_REG_ACCEL_OFFSET        0x77
 /* delay time in milliseconds */

drivers/infiniband/core/addr.c+1−9

 		return ret;
 	rt = (struct rt6_info *)dst;
-	if (ipv6_addr_any(&fl6.saddr)) {
+	if (ipv6_addr_any(&src_in->sin6_addr)) {
-		ret = ipv6_dev_get_saddr(addr->net, ip6_dst_idev(dst)->dev,
-					 &fl6.daddr, 0, &fl6.saddr);
-		if (ret)
-			goto put;
 		src_in->sin6_family = AF_INET6;
 		src_in->sin6_addr = fl6.saddr;
 	}
 	*pdst = dst;
 	return 0;
-put:
-	dst_release(dst);
-	return ret;
 }
 #else
 static int addr6_resolve(struct sockaddr_in6 *src_in,

drivers/infiniband/hw/bnxt_re/bnxt_re.h+4−0

@@ -56,6 +56,10 @@ · 55 unmodified lines
56	#define BNXT_RE_MAX_SRQC_COUNT (64 * 1024)	56	#define BNXT_RE_MAX_SRQC_COUNT (64 * 1024)
57	#define BNXT_RE_MAX_CQ_COUNT (64 * 1024)	57	#define BNXT_RE_MAX_CQ_COUNT (64 * 1024)
58		58
		59	#define BNXT_RE_UD_QP_HW_STALL 0x400000
		60
		61	#define BNXT_RE_RQ_WQE_THRESHOLD 32
		62
59	struct bnxt_re_work {	63	struct bnxt_re_work {
60	struct work_struct work;	64	struct work_struct work;
61	unsigned long event;	65	unsigned long event;

drivers/infiniband/hw/bnxt_re/ib_verbs.c+347−124

@@ -61,6 +61,48 @@ · 60 unmodified lines
61	#include "ib_verbs.h"	61	#include "ib_verbs.h"
62	#include <rdma/bnxt_re-abi.h>	62	#include <rdma/bnxt_re-abi.h>
63		63
		64	static int __from_ib_access_flags(int iflags)
		65	{
		66	int qflags = 0;
		67
		68	if (iflags & IB_ACCESS_LOCAL_WRITE)
		69	qflags \|= BNXT_QPLIB_ACCESS_LOCAL_WRITE;
		70	if (iflags & IB_ACCESS_REMOTE_READ)
		71	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_READ;
		72	if (iflags & IB_ACCESS_REMOTE_WRITE)
		73	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_WRITE;
		74	if (iflags & IB_ACCESS_REMOTE_ATOMIC)
		75	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_ATOMIC;
		76	if (iflags & IB_ACCESS_MW_BIND)
		77	qflags \|= BNXT_QPLIB_ACCESS_MW_BIND;
		78	if (iflags & IB_ZERO_BASED)
		79	qflags \|= BNXT_QPLIB_ACCESS_ZERO_BASED;
		80	if (iflags & IB_ACCESS_ON_DEMAND)
		81	qflags \|= BNXT_QPLIB_ACCESS_ON_DEMAND;
		82	return qflags;
		83	};
		84
		85	static enum ib_access_flags __to_ib_access_flags(int qflags)
		86	{
		87	enum ib_access_flags iflags = 0;
		88
		89	if (qflags & BNXT_QPLIB_ACCESS_LOCAL_WRITE)
		90	iflags \|= IB_ACCESS_LOCAL_WRITE;
		91	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_WRITE)
		92	iflags \|= IB_ACCESS_REMOTE_WRITE;
		93	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_READ)
		94	iflags \|= IB_ACCESS_REMOTE_READ;
		95	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_ATOMIC)
		96	iflags \|= IB_ACCESS_REMOTE_ATOMIC;
		97	if (qflags & BNXT_QPLIB_ACCESS_MW_BIND)
		98	iflags \|= IB_ACCESS_MW_BIND;
		99	if (qflags & BNXT_QPLIB_ACCESS_ZERO_BASED)
		100	iflags \|= IB_ZERO_BASED;
		101	if (qflags & BNXT_QPLIB_ACCESS_ON_DEMAND)
		102	iflags \|= IB_ACCESS_ON_DEMAND;
		103	return iflags;
		104	};
		105
64	static int bnxt_re_build_sgl(struct ib_sge *ib_sg_list,	106	static int bnxt_re_build_sgl(struct ib_sge *ib_sg_list,
65	struct bnxt_qplib_sge *sg_list, int num)	107	struct bnxt_qplib_sge *sg_list, int num)
66	{	108	{
@@ -149,8 +191,8 @@ int bnxt_re_query_device(struct ib_device *ibdev, · 82 unmodified lines
149	ib_attr->max_total_mcast_qp_attach = 0;	191	ib_attr->max_total_mcast_qp_attach = 0;
150	ib_attr->max_ah = dev_attr->max_ah;	192	ib_attr->max_ah = dev_attr->max_ah;
151		193
152	ib_attr->max_fmr = dev_attr->max_fmr;	194	ib_attr->max_fmr = 0;
153	ib_attr->max_map_per_fmr = 1; /* ? */	195	ib_attr->max_map_per_fmr = 0;
154		196
155	ib_attr->max_srq = dev_attr->max_srq;	197	ib_attr->max_srq = dev_attr->max_srq;
156	ib_attr->max_srq_wr = dev_attr->max_srq_wqes;	198	ib_attr->max_srq_wr = dev_attr->max_srq_wqes;
@@ -410,6 +452,158 @@ enum rdma_link_layer bnxt_re_get_link_layer(struct ib_device *ibdev, · 253 unmodified lines
410	return IB_LINK_LAYER_ETHERNET;	452	return IB_LINK_LAYER_ETHERNET;
411	}	453	}
412		454
		455	#define BNXT_RE_FENCE_PBL_SIZE DIV_ROUND_UP(BNXT_RE_FENCE_BYTES, PAGE_SIZE)
		456
		457	static void bnxt_re_create_fence_wqe(struct bnxt_re_pd *pd)
		458	{
		459	struct bnxt_re_fence_data *fence = &pd->fence;
		460	struct ib_mr *ib_mr = &fence->mr->ib_mr;
		461	struct bnxt_qplib_swqe *wqe = &fence->bind_wqe;
		462
		463	memset(wqe, 0, sizeof(*wqe));
		464	wqe->type = BNXT_QPLIB_SWQE_TYPE_BIND_MW;
		465	wqe->wr_id = BNXT_QPLIB_FENCE_WRID;
		466	wqe->flags \|= BNXT_QPLIB_SWQE_FLAGS_SIGNAL_COMP;
		467	wqe->flags \|= BNXT_QPLIB_SWQE_FLAGS_UC_FENCE;
		468	wqe->bind.zero_based = false;
		469	wqe->bind.parent_l_key = ib_mr->lkey;
		470	wqe->bind.va = (u64)(unsigned long)fence->va;
		471	wqe->bind.length = fence->size;
		472	wqe->bind.access_cntl = __from_ib_access_flags(IB_ACCESS_REMOTE_READ);
		473	wqe->bind.mw_type = SQ_BIND_MW_TYPE_TYPE1;
		474
		475	/* Save the initial rkey in fence structure for now;
		476	* wqe->bind.r_key will be set at (re)bind time.
		477	*/
		478	fence->bind_rkey = ib_inc_rkey(fence->mw->rkey);
		479	}
		480
		481	static int bnxt_re_bind_fence_mw(struct bnxt_qplib_qp *qplib_qp)
		482	{
		483	struct bnxt_re_qp *qp = container_of(qplib_qp, struct bnxt_re_qp,
		484	qplib_qp);
		485	struct ib_pd *ib_pd = qp->ib_qp.pd;
		486	struct bnxt_re_pd *pd = container_of(ib_pd, struct bnxt_re_pd, ib_pd);
		487	struct bnxt_re_fence_data *fence = &pd->fence;
		488	struct bnxt_qplib_swqe *fence_wqe = &fence->bind_wqe;
		489	struct bnxt_qplib_swqe wqe;
		490	int rc;
		491
		492	memcpy(&wqe, fence_wqe, sizeof(wqe));
		493	wqe.bind.r_key = fence->bind_rkey;
		494	fence->bind_rkey = ib_inc_rkey(fence->bind_rkey);
		495
		496	dev_dbg(rdev_to_dev(qp->rdev),
		497	"Posting bind fence-WQE: rkey: %#x QP: %d PD: %p\n",
		498	wqe.bind.r_key, qp->qplib_qp.id, pd);
		499	rc = bnxt_qplib_post_send(&qp->qplib_qp, &wqe);
		500	if (rc) {
		501	dev_err(rdev_to_dev(qp->rdev), "Failed to bind fence-WQE\n");
		502	return rc;
		503	}
		504	bnxt_qplib_post_send_db(&qp->qplib_qp);
		505
		506	return rc;
		507	}
		508
		509	static void bnxt_re_destroy_fence_mr(struct bnxt_re_pd *pd)
		510	{
		511	struct bnxt_re_fence_data *fence = &pd->fence;
		512	struct bnxt_re_dev *rdev = pd->rdev;
		513	struct device *dev = &rdev->en_dev->pdev->dev;
		514	struct bnxt_re_mr *mr = fence->mr;
		515
		516	if (fence->mw) {
		517	bnxt_re_dealloc_mw(fence->mw);
		518	fence->mw = NULL;
		519	}
		520	if (mr) {
		521	if (mr->ib_mr.rkey)
		522	bnxt_qplib_dereg_mrw(&rdev->qplib_res, &mr->qplib_mr,
		523	true);
		524	if (mr->ib_mr.lkey)
		525	bnxt_qplib_free_mrw(&rdev->qplib_res, &mr->qplib_mr);
		526	kfree(mr);
		527	fence->mr = NULL;
		528	}
		529	if (fence->dma_addr) {
		530	dma_unmap_single(dev, fence->dma_addr, BNXT_RE_FENCE_BYTES,
		531	DMA_BIDIRECTIONAL);
		532	fence->dma_addr = 0;
		533	}
		534	}
		535
		536	static int bnxt_re_create_fence_mr(struct bnxt_re_pd *pd)
		537	{
		538	int mr_access_flags = IB_ACCESS_LOCAL_WRITE \| IB_ACCESS_MW_BIND;
		539	struct bnxt_re_fence_data *fence = &pd->fence;
		540	struct bnxt_re_dev *rdev = pd->rdev;
		541	struct device *dev = &rdev->en_dev->pdev->dev;
		542	struct bnxt_re_mr *mr = NULL;
		543	dma_addr_t dma_addr = 0;
		544	struct ib_mw *mw;
		545	u64 pbl_tbl;
		546	int rc;
		547
		548	dma_addr = dma_map_single(dev, fence->va, BNXT_RE_FENCE_BYTES,
		549	DMA_BIDIRECTIONAL);
		550	rc = dma_mapping_error(dev, dma_addr);
		551	if (rc) {
		552	dev_err(rdev_to_dev(rdev), "Failed to dma-map fence-MR-mem\n");
		553	rc = -EIO;
		554	fence->dma_addr = 0;
		555	goto fail;
		556	}
		557	fence->dma_addr = dma_addr;
		558
		559	/* Allocate a MR */
		560	mr = kzalloc(sizeof(*mr), GFP_KERNEL);
		561	if (!mr) {
		562	rc = -ENOMEM;
		563	goto fail;
		564	}
		565	fence->mr = mr;
		566	mr->rdev = rdev;
		567	mr->qplib_mr.pd = &pd->qplib_pd;
		568	mr->qplib_mr.type = CMDQ_ALLOCATE_MRW_MRW_FLAGS_PMR;
		569	mr->qplib_mr.flags = __from_ib_access_flags(mr_access_flags);
		570	rc = bnxt_qplib_alloc_mrw(&rdev->qplib_res, &mr->qplib_mr);
		571	if (rc) {
		572	dev_err(rdev_to_dev(rdev), "Failed to alloc fence-HW-MR\n");
		573	goto fail;
		574	}
		575
		576	/* Register MR */
		577	mr->ib_mr.lkey = mr->qplib_mr.lkey;
		578	mr->qplib_mr.va = (u64)(unsigned long)fence->va;
		579	mr->qplib_mr.total_size = BNXT_RE_FENCE_BYTES;
		580	pbl_tbl = dma_addr;
		581	rc = bnxt_qplib_reg_mr(&rdev->qplib_res, &mr->qplib_mr, &pbl_tbl,
		582	BNXT_RE_FENCE_PBL_SIZE, false);
		583	if (rc) {
		584	dev_err(rdev_to_dev(rdev), "Failed to register fence-MR\n");
		585	goto fail;
		586	}
		587	mr->ib_mr.rkey = mr->qplib_mr.rkey;
		588
		589	/* Create a fence MW only for kernel consumers */
		590	mw = bnxt_re_alloc_mw(&pd->ib_pd, IB_MW_TYPE_1, NULL);
		591	if (!mw) {
		592	dev_err(rdev_to_dev(rdev),
		593	"Failed to create fence-MW for PD: %p\n", pd);
		594	rc = -EINVAL;
		595	goto fail;
		596	}
		597	fence->mw = mw;
		598
		599	bnxt_re_create_fence_wqe(pd);
		600	return 0;
		601
		602	fail:
		603	bnxt_re_destroy_fence_mr(pd);
		604	return rc;
		605	}
		606
413	/* Protection Domains */	607	/* Protection Domains */
414	int bnxt_re_dealloc_pd(struct ib_pd *ib_pd)	608	int bnxt_re_dealloc_pd(struct ib_pd *ib_pd)
415	{	609	{
@@ -417,6 +611,7 @@ int bnxt_re_dealloc_pd(struct ib_pd *ib_pd) · 1 unmodified line
417	struct bnxt_re_dev *rdev = pd->rdev;	611	struct bnxt_re_dev *rdev = pd->rdev;
418	int rc;	612	int rc;
419		613
		614	bnxt_re_destroy_fence_mr(pd);
420	if (ib_pd->uobject && pd->dpi.dbr) {	615	if (ib_pd->uobject && pd->dpi.dbr) {
421	struct ib_ucontext *ib_uctx = ib_pd->uobject->context;	616	struct ib_ucontext *ib_uctx = ib_pd->uobject->context;
422	struct bnxt_re_ucontext *ucntx;	617	struct bnxt_re_ucontext *ucntx;
@@ -498,6 +693,10 @@ struct ib_pd bnxt_re_alloc_pd(struct ib_device ibdev, · 75 unmodified lines
498	}	693	}
499	}	694	}
500		695
		696	if (!udata)
		697	if (bnxt_re_create_fence_mr(pd))
		698	dev_warn(rdev_to_dev(rdev),
		699	"Failed to create Fence-MR\n");
501	return &pd->ib_pd;	700	return &pd->ib_pd;
502	dbfail:	701	dbfail:
503	(void)bnxt_qplib_dealloc_pd(&rdev->qplib_res, &rdev->qplib_res.pd_tbl,	702	(void)bnxt_qplib_dealloc_pd(&rdev->qplib_res, &rdev->qplib_res.pd_tbl,
@@ -849,12 +1048,16 @@ static struct bnxt_re_qp *bnxt_re_create_shadow_qp · 345 unmodified lines
849	/* Shadow QP SQ depth should be same as QP1 RQ depth */	1048	/* Shadow QP SQ depth should be same as QP1 RQ depth */
850	qp->qplib_qp.sq.max_wqe = qp1_qp->rq.max_wqe;	1049	qp->qplib_qp.sq.max_wqe = qp1_qp->rq.max_wqe;
851	qp->qplib_qp.sq.max_sge = 2;	1050	qp->qplib_qp.sq.max_sge = 2;
		1051	/* Q full delta can be 1 since it is internal QP */
		1052	qp->qplib_qp.sq.q_full_delta = 1;
852		1053
853	qp->qplib_qp.scq = qp1_qp->scq;	1054	qp->qplib_qp.scq = qp1_qp->scq;
854	qp->qplib_qp.rcq = qp1_qp->rcq;	1055	qp->qplib_qp.rcq = qp1_qp->rcq;
855		1056
856	qp->qplib_qp.rq.max_wqe = qp1_qp->rq.max_wqe;	1057	qp->qplib_qp.rq.max_wqe = qp1_qp->rq.max_wqe;
857	qp->qplib_qp.rq.max_sge = qp1_qp->rq.max_sge;	1058	qp->qplib_qp.rq.max_sge = qp1_qp->rq.max_sge;
		1059	/* Q full delta can be 1 since it is internal QP */
		1060	qp->qplib_qp.rq.q_full_delta = 1;
858		1061
859	qp->qplib_qp.mtu = qp1_qp->mtu;	1062	qp->qplib_qp.mtu = qp1_qp->mtu;
860		1063
@@ -917,10 +1120,6 @@ struct ib_qp bnxt_re_create_qp(struct ib_pd ib_pd, · 56 unmodified lines
917	qp->qplib_qp.sig_type = ((qp_init_attr->sq_sig_type ==	1120	qp->qplib_qp.sig_type = ((qp_init_attr->sq_sig_type ==
918	IB_SIGNAL_ALL_WR) ? true : false);	1121	IB_SIGNAL_ALL_WR) ? true : false);
919		1122
920	entries = roundup_pow_of_two(qp_init_attr->cap.max_send_wr + 1);
921	qp->qplib_qp.sq.max_wqe = min_t(u32, entries,
922	dev_attr->max_qp_wqes + 1);
923
924	qp->qplib_qp.sq.max_sge = qp_init_attr->cap.max_send_sge;	1123	qp->qplib_qp.sq.max_sge = qp_init_attr->cap.max_send_sge;
925	if (qp->qplib_qp.sq.max_sge > dev_attr->max_qp_sges)	1124	if (qp->qplib_qp.sq.max_sge > dev_attr->max_qp_sges)
926	qp->qplib_qp.sq.max_sge = dev_attr->max_qp_sges;	1125	qp->qplib_qp.sq.max_sge = dev_attr->max_qp_sges;
@@ -959,6 +1158,9 @@ struct ib_qp bnxt_re_create_qp(struct ib_pd ib_pd, · 32 unmodified lines
959	qp->qplib_qp.rq.max_wqe = min_t(u32, entries,	1158	qp->qplib_qp.rq.max_wqe = min_t(u32, entries,
960	dev_attr->max_qp_wqes + 1);	1159	dev_attr->max_qp_wqes + 1);
961		1160
		1161	qp->qplib_qp.rq.q_full_delta = qp->qplib_qp.rq.max_wqe -
		1162	qp_init_attr->cap.max_recv_wr;
		1163
962	qp->qplib_qp.rq.max_sge = qp_init_attr->cap.max_recv_sge;	1164	qp->qplib_qp.rq.max_sge = qp_init_attr->cap.max_recv_sge;
963	if (qp->qplib_qp.rq.max_sge > dev_attr->max_qp_sges)	1165	if (qp->qplib_qp.rq.max_sge > dev_attr->max_qp_sges)
964	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;	1166	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;
@@ -967,6 +1169,12 @@ struct ib_qp bnxt_re_create_qp(struct ib_pd ib_pd, · 2 unmodified lines
967	qp->qplib_qp.mtu = ib_mtu_enum_to_int(iboe_get_mtu(rdev->netdev->mtu));	1169	qp->qplib_qp.mtu = ib_mtu_enum_to_int(iboe_get_mtu(rdev->netdev->mtu));
968		1170
969	if (qp_init_attr->qp_type == IB_QPT_GSI) {	1171	if (qp_init_attr->qp_type == IB_QPT_GSI) {
		1172	/* Allocate 1 more than what's provided */
		1173	entries = roundup_pow_of_two(qp_init_attr->cap.max_send_wr + 1);
		1174	qp->qplib_qp.sq.max_wqe = min_t(u32, entries,
		1175	dev_attr->max_qp_wqes + 1);
		1176	qp->qplib_qp.sq.q_full_delta = qp->qplib_qp.sq.max_wqe -
		1177	qp_init_attr->cap.max_send_wr;
970	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;	1178	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;
971	if (qp->qplib_qp.rq.max_sge > dev_attr->max_qp_sges)	1179	if (qp->qplib_qp.rq.max_sge > dev_attr->max_qp_sges)
972	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;	1180	qp->qplib_qp.rq.max_sge = dev_attr->max_qp_sges;
@@ -1006,6 +1214,22 @@ struct ib_qp bnxt_re_create_qp(struct ib_pd ib_pd, · 33 unmodified lines
1006	}	1214	}
1007		1215
1008	} else {	1216	} else {
		1217	/* Allocate 128 + 1 more than what's provided */
		1218	entries = roundup_pow_of_two(qp_init_attr->cap.max_send_wr +
		1219	BNXT_QPLIB_RESERVED_QP_WRS + 1);
		1220	qp->qplib_qp.sq.max_wqe = min_t(u32, entries,
		1221	dev_attr->max_qp_wqes +
		1222	BNXT_QPLIB_RESERVED_QP_WRS + 1);
		1223	qp->qplib_qp.sq.q_full_delta = BNXT_QPLIB_RESERVED_QP_WRS + 1;
		1224
		1225	/*
		1226	* Reserving one slot for Phantom WQE. Application can
		1227	* post one extra entry in this case. But allowing this to avoid
		1228	* unexpected Queue full condition
		1229	*/
		1230
		1231	qp->qplib_qp.sq.q_full_delta -= 1;
		1232
1009	qp->qplib_qp.max_rd_atomic = dev_attr->max_qp_rd_atom;	1233	qp->qplib_qp.max_rd_atomic = dev_attr->max_qp_rd_atom;
1010	qp->qplib_qp.max_dest_rd_atomic = dev_attr->max_qp_init_rd_atom;	1234	qp->qplib_qp.max_dest_rd_atomic = dev_attr->max_qp_init_rd_atom;
1011	if (udata) {	1235	if (udata) {
@@ -1025,6 +1249,7 @@ struct ib_qp bnxt_re_create_qp(struct ib_pd ib_pd, · 13 unmodified lines
1025		1249
1026	qp->ib_qp.qp_num = qp->qplib_qp.id;	1250	qp->ib_qp.qp_num = qp->qplib_qp.id;
1027	spin_lock_init(&qp->sq_lock);	1251	spin_lock_init(&qp->sq_lock);
		1252	spin_lock_init(&qp->rq_lock);
1028		1253
1029	if (udata) {	1254	if (udata) {
1030	struct bnxt_re_qp_resp resp;	1255	struct bnxt_re_qp_resp resp;
@@ -1129,48 +1354,6 @@ static enum ib_mtu __to_ib_mtu(u32 mtu) · 98 unmodified lines
1129	}	1354	}
1130	}	1355	}
1131		1356
1132	static int __from_ib_access_flags(int iflags)
1133	{
1134	int qflags = 0;
1135
1136	if (iflags & IB_ACCESS_LOCAL_WRITE)
1137	qflags \|= BNXT_QPLIB_ACCESS_LOCAL_WRITE;
1138	if (iflags & IB_ACCESS_REMOTE_READ)
1139	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_READ;
1140	if (iflags & IB_ACCESS_REMOTE_WRITE)
1141	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_WRITE;
1142	if (iflags & IB_ACCESS_REMOTE_ATOMIC)
1143	qflags \|= BNXT_QPLIB_ACCESS_REMOTE_ATOMIC;
1144	if (iflags & IB_ACCESS_MW_BIND)
1145	qflags \|= BNXT_QPLIB_ACCESS_MW_BIND;
1146	if (iflags & IB_ZERO_BASED)
1147	qflags \|= BNXT_QPLIB_ACCESS_ZERO_BASED;
1148	if (iflags & IB_ACCESS_ON_DEMAND)
1149	qflags \|= BNXT_QPLIB_ACCESS_ON_DEMAND;
1150	return qflags;
1151	};
1152
1153	static enum ib_access_flags __to_ib_access_flags(int qflags)
1154	{
1155	enum ib_access_flags iflags = 0;
1156
1157	if (qflags & BNXT_QPLIB_ACCESS_LOCAL_WRITE)
1158	iflags \|= IB_ACCESS_LOCAL_WRITE;
1159	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_WRITE)
1160	iflags \|= IB_ACCESS_REMOTE_WRITE;
1161	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_READ)
1162	iflags \|= IB_ACCESS_REMOTE_READ;
1163	if (qflags & BNXT_QPLIB_ACCESS_REMOTE_ATOMIC)
1164	iflags \|= IB_ACCESS_REMOTE_ATOMIC;
1165	if (qflags & BNXT_QPLIB_ACCESS_MW_BIND)
1166	iflags \|= IB_ACCESS_MW_BIND;
1167	if (qflags & BNXT_QPLIB_ACCESS_ZERO_BASED)
1168	iflags \|= IB_ZERO_BASED;
1169	if (qflags & BNXT_QPLIB_ACCESS_ON_DEMAND)
1170	iflags \|= IB_ACCESS_ON_DEMAND;
1171	return iflags;
1172	};
1173
1174	static int bnxt_re_modify_shadow_qp(struct bnxt_re_dev *rdev,	1357	static int bnxt_re_modify_shadow_qp(struct bnxt_re_dev *rdev,
1175	struct bnxt_re_qp *qp1_qp,	1358	struct bnxt_re_qp *qp1_qp,
1176	int qp_attr_mask)	1359	int qp_attr_mask)
@@ -1378,11 +1561,21 @@ int bnxt_re_modify_qp(struct ib_qp ib_qp, struct ib_qp_attr qp_attr, · 201 unmodified lines
1378	entries = roundup_pow_of_two(qp_attr->cap.max_send_wr);	1561	entries = roundup_pow_of_two(qp_attr->cap.max_send_wr);
1379	qp->qplib_qp.sq.max_wqe = min_t(u32, entries,	1562	qp->qplib_qp.sq.max_wqe = min_t(u32, entries,
1380	dev_attr->max_qp_wqes + 1);	1563	dev_attr->max_qp_wqes + 1);
		1564	qp->qplib_qp.sq.q_full_delta = qp->qplib_qp.sq.max_wqe -
		1565	qp_attr->cap.max_send_wr;
		1566	/*
		1567	* Reserving one slot for Phantom WQE. Some application can
		1568	* post one extra entry in this case. Allowing this to avoid
		1569	* unexpected Queue full condition
		1570	*/
		1571	qp->qplib_qp.sq.q_full_delta -= 1;
1381	qp->qplib_qp.sq.max_sge = qp_attr->cap.max_send_sge;	1572	qp->qplib_qp.sq.max_sge = qp_attr->cap.max_send_sge;
1382	if (qp->qplib_qp.rq.max_wqe) {	1573	if (qp->qplib_qp.rq.max_wqe) {
1383	entries = roundup_pow_of_two(qp_attr->cap.max_recv_wr);	1574	entries = roundup_pow_of_two(qp_attr->cap.max_recv_wr);
1384	qp->qplib_qp.rq.max_wqe =	1575	qp->qplib_qp.rq.max_wqe =
1385	min_t(u32, entries, dev_attr->max_qp_wqes + 1);	1576	min_t(u32, entries, dev_attr->max_qp_wqes + 1);
		1577	qp->qplib_qp.rq.q_full_delta = qp->qplib_qp.rq.max_wqe -
		1578	qp_attr->cap.max_recv_wr;
1386	qp->qplib_qp.rq.max_sge = qp_attr->cap.max_recv_sge;	1579	qp->qplib_qp.rq.max_sge = qp_attr->cap.max_recv_sge;
1387	} else {	1580	} else {
1388	/* SRQ was used prior, just ignore the RQ caps */	1581	/* SRQ was used prior, just ignore the RQ caps */
@@ -1883,6 +2076,22 @@ static int bnxt_re_copy_wr_payload(struct bnxt_re_dev *rdev, · 494 unmodified lines
1883	return payload_sz;	2076	return payload_sz;
1884	}	2077	}
1885		2078
		2079	static void bnxt_ud_qp_hw_stall_workaround(struct bnxt_re_qp *qp)
		2080	{
		2081	if ((qp->ib_qp.qp_type == IB_QPT_UD \|\|
		2082	qp->ib_qp.qp_type == IB_QPT_GSI \|\|
		2083	qp->ib_qp.qp_type == IB_QPT_RAW_ETHERTYPE) &&
		2084	qp->qplib_qp.wqe_cnt == BNXT_RE_UD_QP_HW_STALL) {
		2085	int qp_attr_mask;
		2086	struct ib_qp_attr qp_attr;
		2087
		2088	qp_attr_mask = IB_QP_STATE;
		2089	qp_attr.qp_state = IB_QPS_RTS;
		2090	bnxt_re_modify_qp(&qp->ib_qp, &qp_attr, qp_attr_mask, NULL);
		2091	qp->qplib_qp.wqe_cnt = 0;
		2092	}
		2093	}
		2094
1886	static int bnxt_re_post_send_shadow_qp(struct bnxt_re_dev *rdev,	2095	static int bnxt_re_post_send_shadow_qp(struct bnxt_re_dev *rdev,
1887	struct bnxt_re_qp *qp,	2096	struct bnxt_re_qp *qp,
1888	struct ib_send_wr *wr)	2097	struct ib_send_wr *wr)
@@ -1928,6 +2137,7 @@ bad: · 39 unmodified lines
1928	wr = wr->next;	2137	wr = wr->next;
1929	}	2138	}
1930	bnxt_qplib_post_send_db(&qp->qplib_qp);	2139	bnxt_qplib_post_send_db(&qp->qplib_qp);
		2140	bnxt_ud_qp_hw_stall_workaround(qp);
1931	spin_unlock_irqrestore(&qp->sq_lock, flags);	2141	spin_unlock_irqrestore(&qp->sq_lock, flags);
1932	return rc;	2142	return rc;
1933	}	2143	}
@@ -2024,6 +2234,7 @@ bad: · 90 unmodified lines
2024	wr = wr->next;	2234	wr = wr->next;
2025	}	2235	}
2026	bnxt_qplib_post_send_db(&qp->qplib_qp);	2236	bnxt_qplib_post_send_db(&qp->qplib_qp);
		2237	bnxt_ud_qp_hw_stall_workaround(qp);
2027	spin_unlock_irqrestore(&qp->sq_lock, flags);	2238	spin_unlock_irqrestore(&qp->sq_lock, flags);
2028		2239
2029	return rc;	2240	return rc;
@@ -2071,7 +2282,10 @@ int bnxt_re_post_recv(struct ib_qp ib_qp, struct ib_recv_wr wr, · 41 unmodified lines
2071	struct bnxt_re_qp *qp = container_of(ib_qp, struct bnxt_re_qp, ib_qp);	2282	struct bnxt_re_qp *qp = container_of(ib_qp, struct bnxt_re_qp, ib_qp);
2072	struct bnxt_qplib_swqe wqe;	2283	struct bnxt_qplib_swqe wqe;
2073	int rc = 0, payload_sz = 0;	2284	int rc = 0, payload_sz = 0;
		2285	unsigned long flags;
		2286	u32 count = 0;
2074		2287
		2288	spin_lock_irqsave(&qp->rq_lock, flags);
2075	while (wr) {	2289	while (wr) {
2076	/* House keeping */	2290	/* House keeping */
2077	memset(&wqe, 0, sizeof(wqe));	2291	memset(&wqe, 0, sizeof(wqe));
@@ -2100,9 +2314,21 @@ int bnxt_re_post_recv(struct ib_qp ib_qp, struct ib_recv_wr wr, · 22 unmodified lines
2100	*bad_wr = wr;	2314	*bad_wr = wr;
2101	break;	2315	break;
2102	}	2316	}
		2317
		2318	/* Ring DB if the RQEs posted reaches a threshold value */
		2319	if (++count >= BNXT_RE_RQ_WQE_THRESHOLD) {
		2320	bnxt_qplib_post_recv_db(&qp->qplib_qp);
		2321	count = 0;
		2322	}
		2323
2103	wr = wr->next;	2324	wr = wr->next;
2104	}	2325	}
2105	bnxt_qplib_post_recv_db(&qp->qplib_qp);	2326
		2327	if (count)
		2328	bnxt_qplib_post_recv_db(&qp->qplib_qp);
		2329
		2330	spin_unlock_irqrestore(&qp->rq_lock, flags);
		2331
2106	return rc;	2332	return rc;
2107	}	2333	}
2108		2334
@@ -2643,12 +2869,36 @@ static void bnxt_re_process_res_ud_wc(struct ib_wc *wc, · 534 unmodified lines
2643	wc->opcode = IB_WC_RECV_RDMA_WITH_IMM;	2869	wc->opcode = IB_WC_RECV_RDMA_WITH_IMM;
2644	}	2870	}
2645		2871
		2872	static int send_phantom_wqe(struct bnxt_re_qp *qp)
		2873	{
		2874	struct bnxt_qplib_qp *lib_qp = &qp->qplib_qp;
		2875	unsigned long flags;
		2876	int rc = 0;
		2877
		2878	spin_lock_irqsave(&qp->sq_lock, flags);
		2879
		2880	rc = bnxt_re_bind_fence_mw(lib_qp);
		2881	if (!rc) {
		2882	lib_qp->sq.phantom_wqe_cnt++;
		2883	dev_dbg(&lib_qp->sq.hwq.pdev->dev,
		2884	"qp %#x sq->prod %#x sw_prod %#x phantom_wqe_cnt %d\n",
		2885	lib_qp->id, lib_qp->sq.hwq.prod,
		2886	HWQ_CMP(lib_qp->sq.hwq.prod, &lib_qp->sq.hwq),
		2887	lib_qp->sq.phantom_wqe_cnt);
		2888	}
		2889
		2890	spin_unlock_irqrestore(&qp->sq_lock, flags);
		2891	return rc;
		2892	}
		2893
2646	int bnxt_re_poll_cq(struct ib_cq ib_cq, int num_entries, struct ib_wc wc)	2894	int bnxt_re_poll_cq(struct ib_cq ib_cq, int num_entries, struct ib_wc wc)
2647	{	2895	{
2648	struct bnxt_re_cq *cq = container_of(ib_cq, struct bnxt_re_cq, ib_cq);	2896	struct bnxt_re_cq *cq = container_of(ib_cq, struct bnxt_re_cq, ib_cq);
2649	struct bnxt_re_qp *qp;	2897	struct bnxt_re_qp *qp;
2650	struct bnxt_qplib_cqe *cqe;	2898	struct bnxt_qplib_cqe *cqe;
2651	int i, ncqe, budget;	2899	int i, ncqe, budget;
		2900	struct bnxt_qplib_q *sq;
		2901	struct bnxt_qplib_qp *lib_qp;
2652	u32 tbl_idx;	2902	u32 tbl_idx;
2653	struct bnxt_re_sqp_entries *sqp_entry = NULL;	2903	struct bnxt_re_sqp_entries *sqp_entry = NULL;
2654	unsigned long flags;	2904	unsigned long flags;
@@ -2661,7 +2911,21 @@ int bnxt_re_poll_cq(struct ib_cq ib_cq, int num_entries, struct ib_wc wc) · 6 unmodified lines
2661	}	2911	}
2662	cqe = &cq->cql[0];	2912	cqe = &cq->cql[0];
2663	while (budget) {	2913	while (budget) {
2664	ncqe = bnxt_qplib_poll_cq(&cq->qplib_cq, cqe, budget);	2914	lib_qp = NULL;
		2915	ncqe = bnxt_qplib_poll_cq(&cq->qplib_cq, cqe, budget, &lib_qp);
		2916	if (lib_qp) {
		2917	sq = &lib_qp->sq;
		2918	if (sq->send_phantom) {
		2919	qp = container_of(lib_qp,
		2920	struct bnxt_re_qp, qplib_qp);
		2921	if (send_phantom_wqe(qp) == -ENOMEM)
		2922	dev_err(rdev_to_dev(cq->rdev),
		2923	"Phantom failed! Scheduled to send again\n");
		2924	else
		2925	sq->send_phantom = false;
		2926	}
		2927	}
		2928
2665	if (!ncqe)	2929	if (!ncqe)
2666	break;	2930	break;
2667		2931
@@ -2822,6 +3086,12 @@ int bnxt_re_dereg_mr(struct ib_mr *ib_mr) · 154 unmodified lines
2822	struct bnxt_re_dev *rdev = mr->rdev;	3086	struct bnxt_re_dev *rdev = mr->rdev;
2823	int rc;	3087	int rc;
2824		3088
		3089	rc = bnxt_qplib_free_mrw(&rdev->qplib_res, &mr->qplib_mr);
		3090	if (rc) {
		3091	dev_err(rdev_to_dev(rdev), "Dereg MR failed: %#x\n", rc);
		3092	return rc;
		3093	}
		3094
2825	if (mr->npages && mr->pages) {	3095	if (mr->npages && mr->pages) {
2826	rc = bnxt_qplib_free_fast_reg_page_list(&rdev->qplib_res,	3096	rc = bnxt_qplib_free_fast_reg_page_list(&rdev->qplib_res,
2827	&mr->qplib_frpl);	3097	&mr->qplib_frpl);
@@ -2829,8 +3099,6 @@ int bnxt_re_dereg_mr(struct ib_mr *ib_mr) · 1 unmodified line
2829	mr->npages = 0;	3099	mr->npages = 0;
2830	mr->pages = NULL;	3100	mr->pages = NULL;
2831	}	3101	}
2832	rc = bnxt_qplib_free_mrw(&rdev->qplib_res, &mr->qplib_mr);
2833
2834	if (!IS_ERR_OR_NULL(mr->ib_umem))	3102	if (!IS_ERR_OR_NULL(mr->ib_umem))
2835	ib_umem_release(mr->ib_umem);	3103	ib_umem_release(mr->ib_umem);
2836		3104
@@ -2914,97 +3182,52 @@ fail: · 77 unmodified lines
2914	return ERR_PTR(rc);	3182	return ERR_PTR(rc);
2915	}	3183	}
2916		3184
2917	/* Fast Memory Regions */	3185	struct ib_mw bnxt_re_alloc_mw(struct ib_pd ib_pd, enum ib_mw_type type,
2918	struct ib_fmr bnxt_re_alloc_fmr(struct ib_pd ib_pd, int mr_access_flags,	3186	struct ib_udata *udata)
2919	struct ib_fmr_attr *fmr_attr)
2920	{	3187	{
2921	struct bnxt_re_pd *pd = container_of(ib_pd, struct bnxt_re_pd, ib_pd);	3188	struct bnxt_re_pd *pd = container_of(ib_pd, struct bnxt_re_pd, ib_pd);
2922	struct bnxt_re_dev *rdev = pd->rdev;	3189	struct bnxt_re_dev *rdev = pd->rdev;
2923	struct bnxt_re_fmr *fmr;	3190	struct bnxt_re_mw *mw;
2924	int rc;	3191	int rc;
2925		3192
2926	if (fmr_attr->max_pages > MAX_PBL_LVL_2_PGS \|\|	3193	mw = kzalloc(sizeof(*mw), GFP_KERNEL);
2927	fmr_attr->max_maps > rdev->dev_attr.max_map_per_fmr) {	3194	if (!mw)
2928	dev_err(rdev_to_dev(rdev), "Allocate FMR exceeded Max limit");
2929	return ERR_PTR(-ENOMEM);	3195	return ERR_PTR(-ENOMEM);
2930	}	3196	mw->rdev = rdev;
2931	fmr = kzalloc(sizeof(*fmr), GFP_KERNEL);	3197	mw->qplib_mw.pd = &pd->qplib_pd;
2932	if (!fmr)
2933	return ERR_PTR(-ENOMEM);
2934
2935	fmr->rdev = rdev;
2936	fmr->qplib_fmr.pd = &pd->qplib_pd;
2937	fmr->qplib_fmr.type = CMDQ_ALLOCATE_MRW_MRW_FLAGS_PMR;
2938		3198
2939	rc = bnxt_qplib_alloc_mrw(&rdev->qplib_res, &fmr->qplib_fmr);	3199	mw->qplib_mw.type = (type == IB_MW_TYPE_1 ?
2940	if (rc)	3200	CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE1 :
		3201	CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE2B);
		3202	rc = bnxt_qplib_alloc_mrw(&rdev->qplib_res, &mw->qplib_mw);
		3203	if (rc) {
		3204	dev_err(rdev_to_dev(rdev), "Allocate MW failed!");
2941	goto fail;	3205	goto fail;
		3206	}
		3207	mw->ib_mw.rkey = mw->qplib_mw.rkey;
2942		3208
2943	fmr->qplib_fmr.flags = __from_ib_access_flags(mr_access_flags);	3209	atomic_inc(&rdev->mw_count);
2944	fmr->ib_fmr.lkey = fmr->qplib_fmr.lkey;	3210	return &mw->ib_mw;
2945	fmr->ib_fmr.rkey = fmr->ib_fmr.lkey;
2946		3211
2947	atomic_inc(&rdev->mr_count);
2948	return &fmr->ib_fmr;
2949	fail:	3212	fail:
2950	kfree(fmr);	3213	kfree(mw);
2951	return ERR_PTR(rc);	3214	return ERR_PTR(rc);
2952	}	3215	}
2953		3216
2954	int bnxt_re_map_phys_fmr(struct ib_fmr ib_fmr, u64 page_list, int list_len,	3217	int bnxt_re_dealloc_mw(struct ib_mw *ib_mw)
2955	u64 iova)
2956	{	3218	{
2957	struct bnxt_re_fmr *fmr = container_of(ib_fmr, struct bnxt_re_fmr,	3219	struct bnxt_re_mw *mw = container_of(ib_mw, struct bnxt_re_mw, ib_mw);
2958	ib_fmr);	3220	struct bnxt_re_dev *rdev = mw->rdev;
2959	struct bnxt_re_dev *rdev = fmr->rdev;
2960	int rc;	3221	int rc;
2961		3222
2962	fmr->qplib_fmr.va = iova;	3223	rc = bnxt_qplib_free_mrw(&rdev->qplib_res, &mw->qplib_mw);
2963	fmr->qplib_fmr.total_size = list_len * PAGE_SIZE;	3224	if (rc) {
2964		3225	dev_err(rdev_to_dev(rdev), "Free MW failed: %#x\n", rc);
2965	rc = bnxt_qplib_reg_mr(&rdev->qplib_res, &fmr->qplib_fmr, page_list,	3226	return rc;
2966	list_len, true);
2967	if (rc)
2968	dev_err(rdev_to_dev(rdev), "Failed to map FMR for lkey = 0x%x!",
2969	fmr->ib_fmr.lkey);
2970	return rc;
2971	}
2972
2973	int bnxt_re_unmap_fmr(struct list_head *fmr_list)
2974	{
2975	struct bnxt_re_dev *rdev;
2976	struct bnxt_re_fmr *fmr;
2977	struct ib_fmr *ib_fmr;
2978	int rc = 0;
2979
2980	/* Validate each FMRs inside the fmr_list */
2981	list_for_each_entry(ib_fmr, fmr_list, list) {
2982	fmr = container_of(ib_fmr, struct bnxt_re_fmr, ib_fmr);
2983	rdev = fmr->rdev;
2984
2985	if (rdev) {
2986	rc = bnxt_qplib_dereg_mrw(&rdev->qplib_res,
2987	&fmr->qplib_fmr, true);
2988	if (rc)
2989	break;
2990	}
2991	}	3227	}
2992	return rc;
2993	}
2994
2995	int bnxt_re_dealloc_fmr(struct ib_fmr *ib_fmr)
2996	{
2997	struct bnxt_re_fmr *fmr = container_of(ib_fmr, struct bnxt_re_fmr,
2998	ib_fmr);
2999	struct bnxt_re_dev *rdev = fmr->rdev;
3000	int rc;
3001		3228
3002	rc = bnxt_qplib_free_mrw(&rdev->qplib_res, &fmr->qplib_fmr);	3229	kfree(mw);
3003	if (rc)	3230	atomic_dec(&rdev->mw_count);
3004	dev_err(rdev_to_dev(rdev), "Failed to free FMR");
3005
3006	kfree(fmr);
3007	atomic_dec(&rdev->mr_count);
3008	return rc;	3231	return rc;
3009	}	3232	}
3010		3233

drivers/infiniband/hw/bnxt_re/ib_verbs.h+16−6

 	u32			refcnt;
 };
+#define BNXT_RE_FENCE_BYTES	64
+struct bnxt_re_fence_data {
+	u32 size;
+	u8 va[BNXT_RE_FENCE_BYTES];
+	dma_addr_t dma_addr;
+	struct bnxt_re_mr *mr;
+	struct ib_mw *mw;
+	struct bnxt_qplib_swqe bind_wqe;
+	u32 bind_rkey;
+};
 struct bnxt_re_pd {
 	struct bnxt_re_dev	*rdev;
 	struct ib_pd		ib_pd;
 	struct bnxt_qplib_pd	qplib_pd;
 	struct bnxt_qplib_dpi	dpi;
+	struct bnxt_re_fence_data fence;
 };
 struct bnxt_re_ah {
 	struct bnxt_re_dev	*rdev;
 	struct ib_qp		ib_qp;
 	spinlock_t		sq_lock;	/* protect sq */
+	spinlock_t		rq_lock;	/* protect rq */
 	struct bnxt_qplib_qp	qplib_qp;
 	struct ib_umem		*sumem;
 	struct ib_umem		*rumem;
 struct ib_mr *bnxt_re_alloc_mr(struct ib_pd *ib_pd, enum ib_mr_type mr_type,
 			       u32 max_num_sg);
 int bnxt_re_dereg_mr(struct ib_mr *mr);
-struct ib_fmr *bnxt_re_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
+struct ib_mw *bnxt_re_alloc_mw(struct ib_pd *ib_pd, enum ib_mw_type type,
-				 struct ib_fmr_attr *fmr_attr);
+			       struct ib_udata *udata);
-int bnxt_re_map_phys_fmr(struct ib_fmr *fmr, u64 *page_list, int list_len,
+int bnxt_re_dealloc_mw(struct ib_mw *mw);
-			 u64 iova);
-int bnxt_re_unmap_fmr(struct list_head *fmr_list);
-int bnxt_re_dealloc_fmr(struct ib_fmr *fmr);
 struct ib_mr *bnxt_re_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
 				  u64 virt_addr, int mr_access_flags,
 				  struct ib_udata *udata);

drivers/infiniband/hw/bnxt_re/main.c+0−4

 	ibdev->dereg_mr			= bnxt_re_dereg_mr;
 	ibdev->alloc_mr			= bnxt_re_alloc_mr;
 	ibdev->map_mr_sg		= bnxt_re_map_mr_sg;
-	ibdev->alloc_fmr		= bnxt_re_alloc_fmr;
-	ibdev->map_phys_fmr		= bnxt_re_map_phys_fmr;
-	ibdev->unmap_fmr		= bnxt_re_unmap_fmr;
-	ibdev->dealloc_fmr		= bnxt_re_dealloc_fmr;
 	ibdev->reg_user_mr		= bnxt_re_reg_user_mr;
 	ibdev->alloc_ucontext		= bnxt_re_alloc_ucontext;

drivers/infiniband/hw/bnxt_re/qplib_fp.c+199−185

@@ -284,7 +284,7 @@ int bnxt_qplib_create_qp1(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 283 unmodified lines
284	{	284	{
285	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	285	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
286	struct cmdq_create_qp1 req;	286	struct cmdq_create_qp1 req;
287	struct creq_create_qp1_resp *resp;	287	struct creq_create_qp1_resp resp;
288	struct bnxt_qplib_pbl *pbl;	288	struct bnxt_qplib_pbl *pbl;
289	struct bnxt_qplib_q *sq = &qp->sq;	289	struct bnxt_qplib_q *sq = &qp->sq;
290	struct bnxt_qplib_q *rq = &qp->rq;	290	struct bnxt_qplib_q *rq = &qp->rq;
@@ -394,31 +394,12 @@ int bnxt_qplib_create_qp1(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 103 unmodified lines
394		394
395	req.pd_id = cpu_to_le32(qp->pd->id);	395	req.pd_id = cpu_to_le32(qp->pd->id);
396		396
397	resp = (struct creq_create_qp1_resp *)	397	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
398	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	398	(void *)&resp, NULL, 0);
399	NULL, 0);	399	if (rc)
400	if (!resp) {
401	dev_err(&res->pdev->dev, "QPLIB: FP: CREATE_QP1 send failed");
402	rc = -EINVAL;
403	goto fail;
404	}
405	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
406	/* Cmd timed out */
407	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_QP1 timed out");
408	rc = -ETIMEDOUT;
409	goto fail;
410	}
411	if (resp->status \|\|
412	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
413	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_QP1 failed ");
414	dev_err(&rcfw->pdev->dev,
415	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
416	resp->status, le16_to_cpu(req.cookie),
417	le16_to_cpu(resp->cookie));
418	rc = -EINVAL;
419	goto fail;	400	goto fail;
420	}	401
421	qp->id = le32_to_cpu(resp->xid);	402	qp->id = le32_to_cpu(resp.xid);
422	qp->cur_qp_state = CMDQ_MODIFY_QP_NEW_STATE_RESET;	403	qp->cur_qp_state = CMDQ_MODIFY_QP_NEW_STATE_RESET;
423	sq->flush_in_progress = false;	404	sq->flush_in_progress = false;
424	rq->flush_in_progress = false;	405	rq->flush_in_progress = false;
@@ -442,7 +423,7 @@ int bnxt_qplib_create_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 17 unmodified lines
442	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	423	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
443	struct sq_send hw_sq_send_hdr, *hw_sq_send_ptr;	424	struct sq_send hw_sq_send_hdr, *hw_sq_send_ptr;
444	struct cmdq_create_qp req;	425	struct cmdq_create_qp req;
445	struct creq_create_qp_resp *resp;	426	struct creq_create_qp_resp resp;
446	struct bnxt_qplib_pbl *pbl;	427	struct bnxt_qplib_pbl *pbl;
447	struct sq_psn_search **psn_search_ptr;	428	struct sq_psn_search **psn_search_ptr;
448	unsigned long int psn_search, poff = 0;	429	unsigned long int psn_search, poff = 0;
@@ -627,31 +608,12 @@ int bnxt_qplib_create_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 178 unmodified lines
627	}	608	}
628	req.pd_id = cpu_to_le32(qp->pd->id);	609	req.pd_id = cpu_to_le32(qp->pd->id);
629		610
630	resp = (struct creq_create_qp_resp *)	611	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
631	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	612	(void *)&resp, NULL, 0);
632	NULL, 0);	613	if (rc)
633	if (!resp) {
634	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_QP send failed");
635	rc = -EINVAL;
636	goto fail;
637	}
638	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
639	/* Cmd timed out */
640	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_QP timed out");
641	rc = -ETIMEDOUT;
642	goto fail;
643	}
644	if (resp->status \|\|
645	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
646	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_QP failed ");
647	dev_err(&rcfw->pdev->dev,
648	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
649	resp->status, le16_to_cpu(req.cookie),
650	le16_to_cpu(resp->cookie));
651	rc = -EINVAL;
652	goto fail;	614	goto fail;
653	}	615
654	qp->id = le32_to_cpu(resp->xid);	616	qp->id = le32_to_cpu(resp.xid);
655	qp->cur_qp_state = CMDQ_MODIFY_QP_NEW_STATE_RESET;	617	qp->cur_qp_state = CMDQ_MODIFY_QP_NEW_STATE_RESET;
656	sq->flush_in_progress = false;	618	sq->flush_in_progress = false;
657	rq->flush_in_progress = false;	619	rq->flush_in_progress = false;
@@ -769,10 +731,11 @@ int bnxt_qplib_modify_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 111 unmodified lines
769	{	731	{
770	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	732	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
771	struct cmdq_modify_qp req;	733	struct cmdq_modify_qp req;
772	struct creq_modify_qp_resp *resp;	734	struct creq_modify_qp_resp resp;
773	u16 cmd_flags = 0, pkey;	735	u16 cmd_flags = 0, pkey;
774	u32 temp32[4];	736	u32 temp32[4];
775	u32 bmask;	737	u32 bmask;
		738	int rc;
776		739
777	RCFW_CMD_PREP(req, MODIFY_QP, cmd_flags);	740	RCFW_CMD_PREP(req, MODIFY_QP, cmd_flags);
778		741
@@ -862,27 +825,10 @@ int bnxt_qplib_modify_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 83 unmodified lines
862		825
863	req.vlan_pcp_vlan_dei_vlan_id = cpu_to_le16(qp->vlan_id);	826	req.vlan_pcp_vlan_dei_vlan_id = cpu_to_le16(qp->vlan_id);
864		827
865	resp = (struct creq_modify_qp_resp *)	828	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
866	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	829	(void *)&resp, NULL, 0);
867	NULL, 0);	830	if (rc)
868	if (!resp) {	831	return rc;
869	dev_err(&rcfw->pdev->dev, "QPLIB: FP: MODIFY_QP send failed");
870	return -EINVAL;
871	}
872	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
873	/* Cmd timed out */
874	dev_err(&rcfw->pdev->dev, "QPLIB: FP: MODIFY_QP timed out");
875	return -ETIMEDOUT;
876	}
877	if (resp->status \|\|
878	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
879	dev_err(&rcfw->pdev->dev, "QPLIB: FP: MODIFY_QP failed ");
880	dev_err(&rcfw->pdev->dev,
881	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
882	resp->status, le16_to_cpu(req.cookie),
883	le16_to_cpu(resp->cookie));
884	return -EINVAL;
885	}
886	qp->cur_qp_state = qp->state;	832	qp->cur_qp_state = qp->state;
887	return 0;	833	return 0;
888	}	834	}
@@ -891,37 +837,26 @@ int bnxt_qplib_query_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 2 unmodified lines
891	{	837	{
892	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	838	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
893	struct cmdq_query_qp req;	839	struct cmdq_query_qp req;
894	struct creq_query_qp_resp *resp;	840	struct creq_query_qp_resp resp;
		841	struct bnxt_qplib_rcfw_sbuf *sbuf;
895	struct creq_query_qp_resp_sb *sb;	842	struct creq_query_qp_resp_sb *sb;
896	u16 cmd_flags = 0;	843	u16 cmd_flags = 0;
897	u32 temp32[4];	844	u32 temp32[4];
898	int i;	845	int i, rc = 0;
899		846
900	RCFW_CMD_PREP(req, QUERY_QP, cmd_flags);	847	RCFW_CMD_PREP(req, QUERY_QP, cmd_flags);
901		848
		849	sbuf = bnxt_qplib_rcfw_alloc_sbuf(rcfw, sizeof(*sb));
		850	if (!sbuf)
		851	return -ENOMEM;
		852	sb = sbuf->sb;
		853
902	req.qp_cid = cpu_to_le32(qp->id);	854	req.qp_cid = cpu_to_le32(qp->id);
903	req.resp_size = sizeof(*sb) / BNXT_QPLIB_CMDQE_UNITS;	855	req.resp_size = sizeof(*sb) / BNXT_QPLIB_CMDQE_UNITS;
904	resp = (struct creq_query_qp_resp *)	856	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
905	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	857	(void *)sbuf, 0);
906	(void **)&sb, 0);	858	if (rc)
907	if (!resp) {	859	goto bail;
908	dev_err(&rcfw->pdev->dev, "QPLIB: FP: QUERY_QP send failed");
909	return -EINVAL;
910	}
911	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
912	/* Cmd timed out */
913	dev_err(&rcfw->pdev->dev, "QPLIB: FP: QUERY_QP timed out");
914	return -ETIMEDOUT;
915	}
916	if (resp->status \|\|
917	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
918	dev_err(&rcfw->pdev->dev, "QPLIB: FP: QUERY_QP failed ");
919	dev_err(&rcfw->pdev->dev,
920	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
921	resp->status, le16_to_cpu(req.cookie),
922	le16_to_cpu(resp->cookie));
923	return -EINVAL;
924	}
925	/* Extract the context from the side buffer */	860	/* Extract the context from the side buffer */
926	qp->state = sb->en_sqd_async_notify_state &	861	qp->state = sb->en_sqd_async_notify_state &
927	CREQ_QUERY_QP_RESP_SB_STATE_MASK;	862	CREQ_QUERY_QP_RESP_SB_STATE_MASK;
@@ -976,7 +911,9 @@ int bnxt_qplib_query_qp(struct bnxt_qplib_res res, struct bnxt_qplib_qp qp) · 48 unmodified lines
976	qp->dest_qpn = le32_to_cpu(sb->dest_qp_id);	911	qp->dest_qpn = le32_to_cpu(sb->dest_qp_id);
977	memcpy(qp->smac, sb->src_mac, 6);	912	memcpy(qp->smac, sb->src_mac, 6);
978	qp->vlan_id = le16_to_cpu(sb->vlan_pcp_vlan_dei_vlan_id);	913	qp->vlan_id = le16_to_cpu(sb->vlan_pcp_vlan_dei_vlan_id);
979	return 0;	914	bail:
		915	bnxt_qplib_rcfw_free_sbuf(rcfw, sbuf);
		916	return rc;
980	}	917	}
981		918
982	static void __clean_cq(struct bnxt_qplib_cq *cq, u64 qp)	919	static void __clean_cq(struct bnxt_qplib_cq *cq, u64 qp)
@@ -1021,34 +958,18 @@ int bnxt_qplib_destroy_qp(struct bnxt_qplib_res *res, · 38 unmodified lines
1021	{	958	{
1022	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	959	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
1023	struct cmdq_destroy_qp req;	960	struct cmdq_destroy_qp req;
1024	struct creq_destroy_qp_resp *resp;	961	struct creq_destroy_qp_resp resp;
1025	unsigned long flags;	962	unsigned long flags;
1026	u16 cmd_flags = 0;	963	u16 cmd_flags = 0;
		964	int rc;
1027		965
1028	RCFW_CMD_PREP(req, DESTROY_QP, cmd_flags);	966	RCFW_CMD_PREP(req, DESTROY_QP, cmd_flags);
1029		967
1030	req.qp_cid = cpu_to_le32(qp->id);	968	req.qp_cid = cpu_to_le32(qp->id);
1031	resp = (struct creq_destroy_qp_resp *)	969	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
1032	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	970	(void *)&resp, NULL, 0);
1033	NULL, 0);	971	if (rc)
1034	if (!resp) {	972	return rc;
1035	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_QP send failed");
1036	return -EINVAL;
1037	}
1038	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
1039	/* Cmd timed out */
1040	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_QP timed out");
1041	return -ETIMEDOUT;
1042	}
1043	if (resp->status \|\|
1044	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
1045	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_QP failed ");
1046	dev_err(&rcfw->pdev->dev,
1047	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
1048	resp->status, le16_to_cpu(req.cookie),
1049	le16_to_cpu(resp->cookie));
1050	return -EINVAL;
1051	}
1052		973
1053	/* Must walk the associated CQs to nullified the QP ptr */	974	/* Must walk the associated CQs to nullified the QP ptr */
1054	spin_lock_irqsave(&qp->scq->hwq.lock, flags);	975	spin_lock_irqsave(&qp->scq->hwq.lock, flags);
@@ -1162,8 +1083,12 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp, · 107 unmodified lines
1162	rc = -EINVAL;	1083	rc = -EINVAL;
1163	goto done;	1084	goto done;
1164	}	1085	}
1165	if (HWQ_CMP((sq->hwq.prod + 1), &sq->hwq) ==	1086
1166	HWQ_CMP(sq->hwq.cons, &sq->hwq)) {	1087	if (bnxt_qplib_queue_full(sq)) {
		1088	dev_err(&sq->hwq.pdev->dev,
		1089	"QPLIB: prod = %#x cons = %#x qdepth = %#x delta = %#x",
		1090	sq->hwq.prod, sq->hwq.cons, sq->hwq.max_elements,
		1091	sq->q_full_delta);
1167	rc = -ENOMEM;	1092	rc = -ENOMEM;
1168	goto done;	1093	goto done;
1169	}	1094	}
@@ -1373,6 +1298,9 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp, · 203 unmodified lines
1373	}	1298	}
1374		1299
1375	sq->hwq.prod++;	1300	sq->hwq.prod++;
		1301
		1302	qp->wqe_cnt++;
		1303
1376	done:	1304	done:
1377	return rc;	1305	return rc;
1378	}	1306	}
@@ -1411,8 +1339,7 @@ int bnxt_qplib_post_recv(struct bnxt_qplib_qp *qp, · 32 unmodified lines
1411	rc = -EINVAL;	1339	rc = -EINVAL;
1412	goto done;	1340	goto done;
1413	}	1341	}
1414	if (HWQ_CMP((rq->hwq.prod + 1), &rq->hwq) ==	1342	if (bnxt_qplib_queue_full(rq)) {
1415	HWQ_CMP(rq->hwq.cons, &rq->hwq)) {
1416	dev_err(&rq->hwq.pdev->dev,	1343	dev_err(&rq->hwq.pdev->dev,
1417	"QPLIB: FP: QP (0x%x) RQ is full!", qp->id);	1344	"QPLIB: FP: QP (0x%x) RQ is full!", qp->id);
1418	rc = -EINVAL;	1345	rc = -EINVAL;
@@ -1483,7 +1410,7 @@ int bnxt_qplib_create_cq(struct bnxt_qplib_res res, struct bnxt_qplib_cq cq) · 64 unmodified lines
1483	{	1410	{
1484	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	1411	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
1485	struct cmdq_create_cq req;	1412	struct cmdq_create_cq req;
1486	struct creq_create_cq_resp *resp;	1413	struct creq_create_cq_resp resp;
1487	struct bnxt_qplib_pbl *pbl;	1414	struct bnxt_qplib_pbl *pbl;
1488	u16 cmd_flags = 0;	1415	u16 cmd_flags = 0;
1489	int rc;	1416	int rc;
@@ -1525,30 +1452,12 @@ int bnxt_qplib_create_cq(struct bnxt_qplib_res res, struct bnxt_qplib_cq cq) · 35 unmodified lines
1525	(cq->cnq_hw_ring_id & CMDQ_CREATE_CQ_CNQ_ID_MASK) <<	1452	(cq->cnq_hw_ring_id & CMDQ_CREATE_CQ_CNQ_ID_MASK) <<
1526	CMDQ_CREATE_CQ_CNQ_ID_SFT);	1453	CMDQ_CREATE_CQ_CNQ_ID_SFT);
1527		1454
1528	resp = (struct creq_create_cq_resp *)	1455	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
1529	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	1456	(void *)&resp, NULL, 0);
1530	NULL, 0);	1457	if (rc)
1531	if (!resp) {
1532	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_CQ send failed");
1533	return -EINVAL;
1534	}
1535	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
1536	/* Cmd timed out */
1537	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_CQ timed out");
1538	rc = -ETIMEDOUT;
1539	goto fail;
1540	}
1541	if (resp->status \|\|
1542	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
1543	dev_err(&rcfw->pdev->dev, "QPLIB: FP: CREATE_CQ failed ");
1544	dev_err(&rcfw->pdev->dev,
1545	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
1546	resp->status, le16_to_cpu(req.cookie),
1547	le16_to_cpu(resp->cookie));
1548	rc = -EINVAL;
1549	goto fail;	1458	goto fail;
1550	}	1459
1551	cq->id = le32_to_cpu(resp->xid);	1460	cq->id = le32_to_cpu(resp.xid);
1552	cq->dbr_base = res->dpi_tbl.dbr_bar_reg_iomem;	1461	cq->dbr_base = res->dpi_tbl.dbr_bar_reg_iomem;
1553	cq->period = BNXT_QPLIB_QUEUE_START_PERIOD;	1462	cq->period = BNXT_QPLIB_QUEUE_START_PERIOD;
1554	init_waitqueue_head(&cq->waitq);	1463	init_waitqueue_head(&cq->waitq);
@@ -1566,33 +1475,17 @@ int bnxt_qplib_destroy_cq(struct bnxt_qplib_res res, struct bnxt_qplib_cq cq) · 11 unmodified lines
1566	{	1475	{
1567	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	1476	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
1568	struct cmdq_destroy_cq req;	1477	struct cmdq_destroy_cq req;
1569	struct creq_destroy_cq_resp *resp;	1478	struct creq_destroy_cq_resp resp;
1570	u16 cmd_flags = 0;	1479	u16 cmd_flags = 0;
		1480	int rc;
1571		1481
1572	RCFW_CMD_PREP(req, DESTROY_CQ, cmd_flags);	1482	RCFW_CMD_PREP(req, DESTROY_CQ, cmd_flags);
1573		1483
1574	req.cq_cid = cpu_to_le32(cq->id);	1484	req.cq_cid = cpu_to_le32(cq->id);
1575	resp = (struct creq_destroy_cq_resp *)	1485	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
1576	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	1486	(void *)&resp, NULL, 0);
1577	NULL, 0);	1487	if (rc)
1578	if (!resp) {	1488	return rc;
1579	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_CQ send failed");
1580	return -EINVAL;
1581	}
1582	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
1583	/* Cmd timed out */
1584	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_CQ timed out");
1585	return -ETIMEDOUT;
1586	}
1587	if (resp->status \|\|
1588	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
1589	dev_err(&rcfw->pdev->dev, "QPLIB: FP: DESTROY_CQ failed ");
1590	dev_err(&rcfw->pdev->dev,
1591	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
1592	resp->status, le16_to_cpu(req.cookie),
1593	le16_to_cpu(resp->cookie));
1594	return -EINVAL;
1595	}
1596	bnxt_qplib_free_hwq(res->pdev, &cq->hwq);	1489	bnxt_qplib_free_hwq(res->pdev, &cq->hwq);
1597	return 0;	1490	return 0;
1598	}	1491	}
@@ -1664,14 +1557,113 @@ static int __flush_rq(struct bnxt_qplib_q rq, struct bnxt_qplib_qp qp, · 65 unmodified lines
1664	return rc;	1557	return rc;
1665	}	1558	}
1666		1559
		1560	/* Note: SQE is valid from sw_sq_cons up to cqe_sq_cons (exclusive)
		1561	* CQE is track from sw_cq_cons to max_element but valid only if VALID=1
		1562	*/
		1563	static int do_wa9060(struct bnxt_qplib_qp qp, struct bnxt_qplib_cq cq,
		1564	u32 cq_cons, u32 sw_sq_cons, u32 cqe_sq_cons)
		1565	{
		1566	struct bnxt_qplib_q *sq = &qp->sq;
		1567	struct bnxt_qplib_swq *swq;
		1568	u32 peek_sw_cq_cons, peek_raw_cq_cons, peek_sq_cons_idx;
		1569	struct cq_base peek_hwcqe, *peek_hw_cqe_ptr;
		1570	struct cq_req *peek_req_hwcqe;
		1571	struct bnxt_qplib_qp *peek_qp;
		1572	struct bnxt_qplib_q *peek_sq;
		1573	int i, rc = 0;
		1574
		1575	/* Normal mode */
		1576	/* Check for the psn_search marking before completing */
		1577	swq = &sq->swq[sw_sq_cons];
		1578	if (swq->psn_search &&
		1579	le32_to_cpu(swq->psn_search->flags_next_psn) & 0x80000000) {
		1580	/* Unmark */
		1581	swq->psn_search->flags_next_psn = cpu_to_le32
		1582	(le32_to_cpu(swq->psn_search->flags_next_psn)
		1583	& ~0x80000000);
		1584	dev_dbg(&cq->hwq.pdev->dev,
		1585	"FP: Process Req cq_cons=0x%x qp=0x%x sq cons sw=0x%x cqe=0x%x marked!\n",
		1586	cq_cons, qp->id, sw_sq_cons, cqe_sq_cons);
		1587	sq->condition = true;
		1588	sq->send_phantom = true;
		1589
		1590	/* TODO: Only ARM if the previous SQE is ARMALL */
		1591	bnxt_qplib_arm_cq(cq, DBR_DBR_TYPE_CQ_ARMALL);
		1592
		1593	rc = -EAGAIN;
		1594	goto out;
		1595	}
		1596	if (sq->condition) {
		1597	/* Peek at the completions */
		1598	peek_raw_cq_cons = cq->hwq.cons;
		1599	peek_sw_cq_cons = cq_cons;
		1600	i = cq->hwq.max_elements;
		1601	while (i--) {
		1602	peek_sw_cq_cons = HWQ_CMP((peek_sw_cq_cons), &cq->hwq);
		1603	peek_hw_cqe_ptr = (struct cq_base **)cq->hwq.pbl_ptr;
		1604	peek_hwcqe = &peek_hw_cqe_ptr[CQE_PG(peek_sw_cq_cons)]
		1605	[CQE_IDX(peek_sw_cq_cons)];
		1606	/* If the next hwcqe is VALID */
		1607	if (CQE_CMP_VALID(peek_hwcqe, peek_raw_cq_cons,
		1608	cq->hwq.max_elements)) {
		1609	/* If the next hwcqe is a REQ */
		1610	if ((peek_hwcqe->cqe_type_toggle &
		1611	CQ_BASE_CQE_TYPE_MASK) ==
		1612	CQ_BASE_CQE_TYPE_REQ) {
		1613	peek_req_hwcqe = (struct cq_req *)
		1614	peek_hwcqe;
		1615	peek_qp = (struct bnxt_qplib_qp *)
		1616	((unsigned long)
		1617	le64_to_cpu
		1618	(peek_req_hwcqe->qp_handle));
		1619	peek_sq = &peek_qp->sq;
		1620	peek_sq_cons_idx = HWQ_CMP(le16_to_cpu(
		1621	peek_req_hwcqe->sq_cons_idx) - 1
		1622	, &sq->hwq);
		1623	/* If the hwcqe's sq's wr_id matches */
		1624	if (peek_sq == sq &&
		1625	sq->swq[peek_sq_cons_idx].wr_id ==
		1626	BNXT_QPLIB_FENCE_WRID) {
		1627	/*
		1628	* Unbreak only if the phantom
		1629	* comes back
		1630	*/
		1631	dev_dbg(&cq->hwq.pdev->dev,
		1632	"FP:Got Phantom CQE");
		1633	sq->condition = false;
		1634	sq->single = true;
		1635	rc = 0;
		1636	goto out;
		1637	}
		1638	}
		1639	/* Valid but not the phantom, so keep looping */
		1640	} else {
		1641	/* Not valid yet, just exit and wait */
		1642	rc = -EINVAL;
		1643	goto out;
		1644	}
		1645	peek_sw_cq_cons++;
		1646	peek_raw_cq_cons++;
		1647	}
		1648	dev_err(&cq->hwq.pdev->dev,
		1649	"Should not have come here! cq_cons=0x%x qp=0x%x sq cons sw=0x%x hw=0x%x",
		1650	cq_cons, qp->id, sw_sq_cons, cqe_sq_cons);
		1651	rc = -EINVAL;
		1652	}
		1653	out:
		1654	return rc;
		1655	}
		1656
1667	static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq,	1657	static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq,
1668	struct cq_req *hwcqe,	1658	struct cq_req *hwcqe,
1669	struct bnxt_qplib_cqe *pcqe, int budget)	1659	struct bnxt_qplib_cqe *pcqe, int budget,
		1660	u32 cq_cons, struct bnxt_qplib_qp **lib_qp)
1670	{	1661	{
1671	struct bnxt_qplib_qp *qp;	1662	struct bnxt_qplib_qp *qp;
1672	struct bnxt_qplib_q *sq;	1663	struct bnxt_qplib_q *sq;
1673	struct bnxt_qplib_cqe *cqe;	1664	struct bnxt_qplib_cqe *cqe;
1674	u32 sw_cons, cqe_cons;	1665	u32 sw_sq_cons, cqe_sq_cons;
		1666	struct bnxt_qplib_swq *swq;
1675	int rc = 0;	1667	int rc = 0;
1676		1668
1677	qp = (struct bnxt_qplib_qp *)((unsigned long)	1669	qp = (struct bnxt_qplib_qp *)((unsigned long)
@@ -1683,13 +1675,13 @@ static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq, · 5 unmodified lines
1683	}	1675	}
1684	sq = &qp->sq;	1676	sq = &qp->sq;
1685		1677
1686	cqe_cons = HWQ_CMP(le16_to_cpu(hwcqe->sq_cons_idx), &sq->hwq);	1678	cqe_sq_cons = HWQ_CMP(le16_to_cpu(hwcqe->sq_cons_idx), &sq->hwq);
1687	if (cqe_cons > sq->hwq.max_elements) {	1679	if (cqe_sq_cons > sq->hwq.max_elements) {
1688	dev_err(&cq->hwq.pdev->dev,	1680	dev_err(&cq->hwq.pdev->dev,
1689	"QPLIB: FP: CQ Process req reported ");	1681	"QPLIB: FP: CQ Process req reported ");
1690	dev_err(&cq->hwq.pdev->dev,	1682	dev_err(&cq->hwq.pdev->dev,
1691	"QPLIB: sq_cons_idx 0x%x which exceeded max 0x%x",	1683	"QPLIB: sq_cons_idx 0x%x which exceeded max 0x%x",
1692	cqe_cons, sq->hwq.max_elements);	1684	cqe_sq_cons, sq->hwq.max_elements);
1693	return -EINVAL;	1685	return -EINVAL;
1694	}	1686	}
1695	/* If we were in the middle of flushing the SQ, continue */	1687	/* If we were in the middle of flushing the SQ, continue */
@@ -1698,53 +1690,74 @@ static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq, · 2 unmodified lines
1698		1690
1699	/* Require to walk the sq's swq to fabricate CQEs for all previously	1691	/* Require to walk the sq's swq to fabricate CQEs for all previously
1700	* signaled SWQEs due to CQE aggregation from the current sq cons	1692	* signaled SWQEs due to CQE aggregation from the current sq cons
1701	* to the cqe_cons	1693	* to the cqe_sq_cons
1702	*/	1694	*/
1703	cqe = *pcqe;	1695	cqe = *pcqe;
1704	while (*budget) {	1696	while (*budget) {
1705	sw_cons = HWQ_CMP(sq->hwq.cons, &sq->hwq);	1697	sw_sq_cons = HWQ_CMP(sq->hwq.cons, &sq->hwq);
1706	if (sw_cons == cqe_cons)	1698	if (sw_sq_cons == cqe_sq_cons)
		1699	/* Done */
1707	break;	1700	break;
		1701
		1702	swq = &sq->swq[sw_sq_cons];
1708	memset(cqe, 0, sizeof(*cqe));	1703	memset(cqe, 0, sizeof(*cqe));
1709	cqe->opcode = CQ_BASE_CQE_TYPE_REQ;	1704	cqe->opcode = CQ_BASE_CQE_TYPE_REQ;
1710	cqe->qp_handle = (u64)(unsigned long)qp;	1705	cqe->qp_handle = (u64)(unsigned long)qp;
1711	cqe->src_qp = qp->id;	1706	cqe->src_qp = qp->id;
1712	cqe->wr_id = sq->swq[sw_cons].wr_id;	1707	cqe->wr_id = swq->wr_id;
1713	cqe->type = sq->swq[sw_cons].type;	1708	if (cqe->wr_id == BNXT_QPLIB_FENCE_WRID)
		1709	goto skip;
		1710	cqe->type = swq->type;
1714		1711
1715	/* For the last CQE, check for status. For errors, regardless	1712	/* For the last CQE, check for status. For errors, regardless
1716	* of the request being signaled or not, it must complete with	1713	* of the request being signaled or not, it must complete with
1717	* the hwcqe error status	1714	* the hwcqe error status
1718	*/	1715	*/
1719	if (HWQ_CMP((sw_cons + 1), &sq->hwq) == cqe_cons &&	1716	if (HWQ_CMP((sw_sq_cons + 1), &sq->hwq) == cqe_sq_cons &&
1720	hwcqe->status != CQ_REQ_STATUS_OK) {	1717	hwcqe->status != CQ_REQ_STATUS_OK) {
1721	cqe->status = hwcqe->status;	1718	cqe->status = hwcqe->status;
1722	dev_err(&cq->hwq.pdev->dev,	1719	dev_err(&cq->hwq.pdev->dev,
1723	"QPLIB: FP: CQ Processed Req ");	1720	"QPLIB: FP: CQ Processed Req ");
1724	dev_err(&cq->hwq.pdev->dev,	1721	dev_err(&cq->hwq.pdev->dev,
1725	"QPLIB: wr_id[%d] = 0x%llx with status 0x%x",	1722	"QPLIB: wr_id[%d] = 0x%llx with status 0x%x",
1726	sw_cons, cqe->wr_id, cqe->status);	1723	sw_sq_cons, cqe->wr_id, cqe->status);
1727	cqe++;	1724	cqe++;
1728	(*budget)--;	1725	(*budget)--;
1729	sq->flush_in_progress = true;	1726	sq->flush_in_progress = true;
1730	/* Must block new posting of SQ and RQ */	1727	/* Must block new posting of SQ and RQ */
1731	qp->state = CMDQ_MODIFY_QP_NEW_STATE_ERR;	1728	qp->state = CMDQ_MODIFY_QP_NEW_STATE_ERR;
		1729	sq->condition = false;
		1730	sq->single = false;
1732	} else {	1731	} else {
1733	if (sq->swq[sw_cons].flags &	1732	if (swq->flags & SQ_SEND_FLAGS_SIGNAL_COMP) {
1734	SQ_SEND_FLAGS_SIGNAL_COMP) {	1733	/* Before we complete, do WA 9060 */
		1734	if (do_wa9060(qp, cq, cq_cons, sw_sq_cons,
		1735	cqe_sq_cons)) {
		1736	*lib_qp = qp;
		1737	goto out;
		1738	}
1735	cqe->status = CQ_REQ_STATUS_OK;	1739	cqe->status = CQ_REQ_STATUS_OK;
1736	cqe++;	1740	cqe++;
1737	(*budget)--;	1741	(*budget)--;
1738	}	1742	}
1739	}	1743	}
		1744	skip:
1740	sq->hwq.cons++;	1745	sq->hwq.cons++;
		1746	if (sq->single)
		1747	break;
1741	}	1748	}
		1749	out:
1742	*pcqe = cqe;	1750	*pcqe = cqe;
1743	if (!*budget && HWQ_CMP(sq->hwq.cons, &sq->hwq) != cqe_cons) {	1751	if (HWQ_CMP(sq->hwq.cons, &sq->hwq) != cqe_sq_cons) {
1744	/* Out of budget */	1752	/* Out of budget */
1745	rc = -EAGAIN;	1753	rc = -EAGAIN;
1746	goto done;	1754	goto done;
1747	}	1755	}
		1756	/*
		1757	* Back to normal completion mode only after it has completed all of
		1758	* the WC for this CQE
		1759	*/
		1760	sq->single = false;
1748	if (!sq->flush_in_progress)	1761	if (!sq->flush_in_progress)
1749	goto done;	1762	goto done;
1750	flush:	1763	flush:
@@ -2074,7 +2087,7 @@ static int bnxt_qplib_cq_process_cutoff(struct bnxt_qplib_cq *cq, · 323 unmodified lines
2074	}	2087	}
2075		2088
2076	int bnxt_qplib_poll_cq(struct bnxt_qplib_cq cq, struct bnxt_qplib_cqe cqe,	2089	int bnxt_qplib_poll_cq(struct bnxt_qplib_cq cq, struct bnxt_qplib_cqe cqe,
2077	int num_cqes)	2090	int num_cqes, struct bnxt_qplib_qp **lib_qp)
2078	{	2091	{
2079	struct cq_base hw_cqe, *hw_cqe_ptr;	2092	struct cq_base hw_cqe, *hw_cqe_ptr;
2080	unsigned long flags;	2093	unsigned long flags;
@@ -2099,7 +2112,8 @@ int bnxt_qplib_poll_cq(struct bnxt_qplib_cq cq, struct bnxt_qplib_cqe cqe, · 18 unmodified lines
2099	case CQ_BASE_CQE_TYPE_REQ:	2112	case CQ_BASE_CQE_TYPE_REQ:
2100	rc = bnxt_qplib_cq_process_req(cq,	2113	rc = bnxt_qplib_cq_process_req(cq,
2101	(struct cq_req *)hw_cqe,	2114	(struct cq_req *)hw_cqe,
2102	&cqe, &budget);	2115	&cqe, &budget,
		2116	sw_cons, lib_qp);
2103	break;	2117	break;
2104	case CQ_BASE_CQE_TYPE_RES_RC:	2118	case CQ_BASE_CQE_TYPE_RES_RC:
2105	rc = bnxt_qplib_cq_process_res_rc(cq,	2119	rc = bnxt_qplib_cq_process_res_rc(cq,

drivers/infiniband/hw/bnxt_re/qplib_fp.h+17−1

 struct bnxt_qplib_swqe {
 	/* General */
+#define	BNXT_QPLIB_FENCE_WRID	0x46454E43	/* "FENC" */
 	u64				wr_id;
 	u8				reqs_type;
 	u8				type;
 	struct scatterlist		*sglist;
 	u32				nmap;
 	u32				max_wqe;
+	u16				q_full_delta;
 	u16				max_sge;
 	u32				psn;
 	bool				flush_in_progress;
+	bool				condition;
+	bool				single;
+	bool				send_phantom;
+	u32				phantom_wqe_cnt;
+	u32				phantom_cqe_cnt;
+	u32				next_cq_cons;
 };
 struct bnxt_qplib_qp {
 	u8				timeout;
 	u8				retry_cnt;
 	u8				rnr_retry;
+	u64				wqe_cnt;
 	u32				min_rnr_timer;
 	u32				max_rd_atomic;
 	u32				max_dest_rd_atomic;
 	(!!((hdr)->cqe_type_toggle & CQ_BASE_TOGGLE) ==		\
 	   !((raw_cons) & (cp_bit)))
+static inline bool bnxt_qplib_queue_full(struct bnxt_qplib_q *qplib_q)
+{
+	return HWQ_CMP((qplib_q->hwq.prod + qplib_q->q_full_delta),
+		       &qplib_q->hwq) == HWQ_CMP(qplib_q->hwq.cons,
+						 &qplib_q->hwq);
+}
 struct bnxt_qplib_cqe {
 	u8				status;
 	u8				type;
 int bnxt_qplib_create_cq(struct bnxt_qplib_res *res, struct bnxt_qplib_cq *cq);
 int bnxt_qplib_destroy_cq(struct bnxt_qplib_res *res, struct bnxt_qplib_cq *cq);
 int bnxt_qplib_poll_cq(struct bnxt_qplib_cq *cq, struct bnxt_qplib_cqe *cqe,
-		       int num);
+		       int num, struct bnxt_qplib_qp **qp);
 void bnxt_qplib_req_notify_cq(struct bnxt_qplib_cq *cq, u32 arm_type);
 void bnxt_qplib_free_nq(struct bnxt_qplib_nq *nq);
 int bnxt_qplib_alloc_nq(struct pci_dev *pdev, struct bnxt_qplib_nq *nq);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c+164−150

@@ -39,72 +39,55 @@ · 38 unmodified lines
39	#include <linux/spinlock.h>	39	#include <linux/spinlock.h>
40	#include <linux/pci.h>	40	#include <linux/pci.h>
41	#include <linux/prefetch.h>	41	#include <linux/prefetch.h>
		42	#include <linux/delay.h>
		43
42	#include "roce_hsi.h"	44	#include "roce_hsi.h"
43	#include "qplib_res.h"	45	#include "qplib_res.h"
44	#include "qplib_rcfw.h"	46	#include "qplib_rcfw.h"
45	static void bnxt_qplib_service_creq(unsigned long data);	47	static void bnxt_qplib_service_creq(unsigned long data);
46		48
47	/* Hardware communication channel */	49	/* Hardware communication channel */
48	int bnxt_qplib_rcfw_wait_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie)	50	static int __wait_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie)
49	{	51	{
50	u16 cbit;	52	u16 cbit;
51	int rc;	53	int rc;
52		54
53	cookie &= RCFW_MAX_COOKIE_VALUE;
54	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;	55	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;
55	if (!test_bit(cbit, rcfw->cmdq_bitmap))
56	dev_warn(&rcfw->pdev->dev,
57	"QPLIB: CMD bit %d for cookie 0x%x is not set?",
58	cbit, cookie);
59
60	rc = wait_event_timeout(rcfw->waitq,	56	rc = wait_event_timeout(rcfw->waitq,
61	!test_bit(cbit, rcfw->cmdq_bitmap),	57	!test_bit(cbit, rcfw->cmdq_bitmap),
62	msecs_to_jiffies(RCFW_CMD_WAIT_TIME_MS));	58	msecs_to_jiffies(RCFW_CMD_WAIT_TIME_MS));
63	if (!rc) {	59	return rc ? 0 : -ETIMEDOUT;
64	dev_warn(&rcfw->pdev->dev,
65	"QPLIB: Bono Error: timeout %d msec, msg {0x%x}\n",
66	RCFW_CMD_WAIT_TIME_MS, cookie);
67	}
68
69	return rc;
70	};	60	};
71		61
72	int bnxt_qplib_rcfw_block_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie)	62	static int __block_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie)
73	{	63	{
74	u32 count = -1;	64	u32 count = RCFW_BLOCKED_CMD_WAIT_COUNT;
75	u16 cbit;	65	u16 cbit;
76		66
77	cookie &= RCFW_MAX_COOKIE_VALUE;
78	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;	67	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;
79	if (!test_bit(cbit, rcfw->cmdq_bitmap))	68	if (!test_bit(cbit, rcfw->cmdq_bitmap))
80	goto done;	69	goto done;
81	do {	70	do {
		71	mdelay(1); /* 1m sec */
82	bnxt_qplib_service_creq((unsigned long)rcfw);	72	bnxt_qplib_service_creq((unsigned long)rcfw);
83	} while (test_bit(cbit, rcfw->cmdq_bitmap) && --count);	73	} while (test_bit(cbit, rcfw->cmdq_bitmap) && --count);
84	done:	74	done:
85	return count;	75	return count ? 0 : -ETIMEDOUT;
86	};	76	};
87		77
88	void bnxt_qplib_rcfw_send_message(struct bnxt_qplib_rcfw rcfw,	78	static int __send_message(struct bnxt_qplib_rcfw rcfw, struct cmdq_base req,
89	struct cmdq_base req, void *crsbe,	79	struct creq_base resp, void sb, u8 is_block)
90	u8 is_block)
91	{	80	{
92	struct bnxt_qplib_crsq *crsq = &rcfw->crsq;
93	struct bnxt_qplib_cmdqe cmdqe, *cmdq_ptr;	81	struct bnxt_qplib_cmdqe cmdqe, *cmdq_ptr;
94	struct bnxt_qplib_hwq *cmdq = &rcfw->cmdq;	82	struct bnxt_qplib_hwq *cmdq = &rcfw->cmdq;
95	struct bnxt_qplib_hwq *crsb = &rcfw->crsb;	83	struct bnxt_qplib_crsq *crsqe;
96	struct bnxt_qplib_crsqe *crsqe = NULL;
97	struct bnxt_qplib_crsbe **crsb_ptr;
98	u32 sw_prod, cmdq_prod;	84	u32 sw_prod, cmdq_prod;
99	u8 retry_cnt = 0xFF;
100	dma_addr_t dma_addr;
101	unsigned long flags;	85	unsigned long flags;
102	u32 size, opcode;	86	u32 size, opcode;
103	u16 cookie, cbit;	87	u16 cookie, cbit;
104	int pg, idx;	88	int pg, idx;
105	u8 *preq;	89	u8 *preq;
106		90
107	retry:
108	opcode = req->opcode;	91	opcode = req->opcode;
109	if (!test_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags) &&	92	if (!test_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags) &&
110	(opcode != CMDQ_BASE_OPCODE_QUERY_FUNC &&	93	(opcode != CMDQ_BASE_OPCODE_QUERY_FUNC &&
@@ -112,63 +95,50 @@ retry: · 1 unmodified line
112	dev_err(&rcfw->pdev->dev,	95	dev_err(&rcfw->pdev->dev,
113	"QPLIB: RCFW not initialized, reject opcode 0x%x",	96	"QPLIB: RCFW not initialized, reject opcode 0x%x",
114	opcode);	97	opcode);
115	return NULL;	98	return -EINVAL;
116	}	99	}
117		100
118	if (test_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags) &&	101	if (test_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags) &&
119	opcode == CMDQ_BASE_OPCODE_INITIALIZE_FW) {	102	opcode == CMDQ_BASE_OPCODE_INITIALIZE_FW) {
120	dev_err(&rcfw->pdev->dev, "QPLIB: RCFW already initialized!");	103	dev_err(&rcfw->pdev->dev, "QPLIB: RCFW already initialized!");
121	return NULL;	104	return -EINVAL;
122	}	105	}
123		106
124	/* Cmdq are in 16-byte units, each request can consume 1 or more	107	/* Cmdq are in 16-byte units, each request can consume 1 or more
125	* cmdqe	108	* cmdqe
126	*/	109	*/
127	spin_lock_irqsave(&cmdq->lock, flags);	110	spin_lock_irqsave(&cmdq->lock, flags);
128	if (req->cmd_size > cmdq->max_elements -	111	if (req->cmd_size >= HWQ_FREE_SLOTS(cmdq)) {
129	((HWQ_CMP(cmdq->prod, cmdq) - HWQ_CMP(cmdq->cons, cmdq)) &
130	(cmdq->max_elements - 1))) {
131	dev_err(&rcfw->pdev->dev, "QPLIB: RCFW: CMDQ is full!");	112	dev_err(&rcfw->pdev->dev, "QPLIB: RCFW: CMDQ is full!");
132	spin_unlock_irqrestore(&cmdq->lock, flags);	113	spin_unlock_irqrestore(&cmdq->lock, flags);
133		114	return -EAGAIN;
134	if (!retry_cnt--)
135	return NULL;
136	goto retry;
137	}	115	}
138		116
139	retry_cnt = 0xFF;
140		117
141	cookie = atomic_inc_return(&rcfw->seq_num) & RCFW_MAX_COOKIE_VALUE;	118	cookie = rcfw->seq_num & RCFW_MAX_COOKIE_VALUE;
142	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;	119	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;
143	if (is_block)	120	if (is_block)
144	cookie \|= RCFW_CMD_IS_BLOCKING;	121	cookie \|= RCFW_CMD_IS_BLOCKING;
		122
		123	set_bit(cbit, rcfw->cmdq_bitmap);
145	req->cookie = cpu_to_le16(cookie);	124	req->cookie = cpu_to_le16(cookie);
146	if (test_and_set_bit(cbit, rcfw->cmdq_bitmap)) {	125	crsqe = &rcfw->crsqe_tbl[cbit];
147	dev_err(&rcfw->pdev->dev,	126	if (crsqe->resp) {
148	"QPLIB: RCFW MAX outstanding cmd reached!");
149	atomic_dec(&rcfw->seq_num);
150	spin_unlock_irqrestore(&cmdq->lock, flags);	127	spin_unlock_irqrestore(&cmdq->lock, flags);
151		128	return -EBUSY;
152	if (!retry_cnt--)
153	return NULL;
154	goto retry;
155	}	129	}
156	/* Reserve a resp buffer slot if requested */	130	memset(resp, 0, sizeof(*resp));
157	if (req->resp_size && crsbe) {	131	crsqe->resp = (struct creq_qp_event *)resp;
158	spin_lock(&crsb->lock);	132	crsqe->resp->cookie = req->cookie;
159	sw_prod = HWQ_CMP(crsb->prod, crsb);	133	crsqe->req_size = req->cmd_size;
160	crsb_ptr = (struct bnxt_qplib_crsbe **)crsb->pbl_ptr;	134	if (req->resp_size && sb) {
161	crsbe = (void )&crsb_ptr[get_crsb_pg(sw_prod)]	135	struct bnxt_qplib_rcfw_sbuf *sbuf = sb;
162	[get_crsb_idx(sw_prod)];	136
163	bnxt_qplib_crsb_dma_next(crsb->pbl_dma_ptr, sw_prod, &dma_addr);	137	req->resp_addr = cpu_to_le64(sbuf->dma_addr);
164	req->resp_addr = cpu_to_le64(dma_addr);	138	req->resp_size = (sbuf->size + BNXT_QPLIB_CMDQE_UNITS - 1) /
165	crsb->prod++;	139	BNXT_QPLIB_CMDQE_UNITS;
166	spin_unlock(&crsb->lock);
167
168	req->resp_size = (sizeof(struct bnxt_qplib_crsbe) +
169	BNXT_QPLIB_CMDQE_UNITS - 1) /
170	BNXT_QPLIB_CMDQE_UNITS;
171	}	140	}
		141
172	cmdq_ptr = (struct bnxt_qplib_cmdqe **)cmdq->pbl_ptr;	142	cmdq_ptr = (struct bnxt_qplib_cmdqe **)cmdq->pbl_ptr;
173	preq = (u8 *)req;	143	preq = (u8 *)req;
174	size = req->cmd_size * BNXT_QPLIB_CMDQE_UNITS;	144	size = req->cmd_size * BNXT_QPLIB_CMDQE_UNITS;
@@ -190,23 +160,24 @@ retry: · 15 unmodified lines
190	preq += min_t(u32, size, sizeof(*cmdqe));	160	preq += min_t(u32, size, sizeof(*cmdqe));
191	size -= min_t(u32, size, sizeof(*cmdqe));	161	size -= min_t(u32, size, sizeof(*cmdqe));
192	cmdq->prod++;	162	cmdq->prod++;
		163	rcfw->seq_num++;
193	} while (size > 0);	164	} while (size > 0);
194		165
		166	rcfw->seq_num++;
		167
195	cmdq_prod = cmdq->prod;	168	cmdq_prod = cmdq->prod;
196	if (rcfw->flags & FIRMWARE_FIRST_FLAG) {	169	if (rcfw->flags & FIRMWARE_FIRST_FLAG) {
197	/* The very first doorbell write is required to set this flag	170	/* The very first doorbell write
198	* which prompts the FW to reset its internal pointers	171	* is required to set this flag
		172	* which prompts the FW to reset
		173	* its internal pointers
199	*/	174	*/
200	cmdq_prod \|= FIRMWARE_FIRST_FLAG;	175	cmdq_prod \|= FIRMWARE_FIRST_FLAG;
201	rcfw->flags &= ~FIRMWARE_FIRST_FLAG;	176	rcfw->flags &= ~FIRMWARE_FIRST_FLAG;
202	}	177	}
203	sw_prod = HWQ_CMP(crsq->prod, crsq);
204	crsqe = &crsq->crsq[sw_prod];
205	memset(crsqe, 0, sizeof(*crsqe));
206	crsq->prod++;
207	crsqe->req_size = req->cmd_size;
208		178
209	/* ring CMDQ DB */	179	/* ring CMDQ DB */
		180	wmb();
210	writel(cmdq_prod, rcfw->cmdq_bar_reg_iomem +	181	writel(cmdq_prod, rcfw->cmdq_bar_reg_iomem +
211	rcfw->cmdq_bar_reg_prod_off);	182	rcfw->cmdq_bar_reg_prod_off);
212	writel(RCFW_CMDQ_TRIG_VAL, rcfw->cmdq_bar_reg_iomem +	183	writel(RCFW_CMDQ_TRIG_VAL, rcfw->cmdq_bar_reg_iomem +
@@ -214,9 +185,56 @@ retry: · 1 unmodified line
214	done:	185	done:
215	spin_unlock_irqrestore(&cmdq->lock, flags);	186	spin_unlock_irqrestore(&cmdq->lock, flags);
216	/* Return the CREQ response pointer */	187	/* Return the CREQ response pointer */
217	return crsqe ? &crsqe->qp_event : NULL;	188	return 0;
218	}	189	}
219		190
		191	int bnxt_qplib_rcfw_send_message(struct bnxt_qplib_rcfw *rcfw,
		192	struct cmdq_base *req,
		193	struct creq_base *resp,
		194	void *sb, u8 is_block)
		195	{
		196	struct creq_qp_event evnt = (struct creq_qp_event )resp;
		197	u16 cookie;
		198	u8 opcode, retry_cnt = 0xFF;
		199	int rc = 0;
		200
		201	do {
		202	opcode = req->opcode;
		203	rc = __send_message(rcfw, req, resp, sb, is_block);
		204	cookie = le16_to_cpu(req->cookie) & RCFW_MAX_COOKIE_VALUE;
		205	if (!rc)
		206	break;
		207
		208	if (!retry_cnt \|\| (rc != -EAGAIN && rc != -EBUSY)) {
		209	/* send failed */
		210	dev_err(&rcfw->pdev->dev, "QPLIB: cmdq[%#x]=%#x send failed",
		211	cookie, opcode);
		212	return rc;
		213	}
		214	is_block ? mdelay(1) : usleep_range(500, 1000);
		215
		216	} while (retry_cnt--);
		217
		218	if (is_block)
		219	rc = __block_for_resp(rcfw, cookie);
		220	else
		221	rc = __wait_for_resp(rcfw, cookie);
		222	if (rc) {
		223	/* timed out */
		224	dev_err(&rcfw->pdev->dev, "QPLIB: cmdq[%#x]=%#x timedout (%d)msec",
		225	cookie, opcode, RCFW_CMD_WAIT_TIME_MS);
		226	return rc;
		227	}
		228
		229	if (evnt->status) {
		230	/* failed with status */
		231	dev_err(&rcfw->pdev->dev, "QPLIB: cmdq[%#x]=%#x status %#x",
		232	cookie, opcode, evnt->status);
		233	rc = -EFAULT;
		234	}
		235
		236	return rc;
		237	}
220	/* Completions */	238	/* Completions */
221	static int bnxt_qplib_process_func_event(struct bnxt_qplib_rcfw *rcfw,	239	static int bnxt_qplib_process_func_event(struct bnxt_qplib_rcfw *rcfw,
222	struct creq_func_event *func_event)	240	struct creq_func_event *func_event)
@@ -260,12 +278,12 @@ static int bnxt_qplib_process_func_event(struct bnxt_qplib_rcfw *rcfw, · 37 unmodified lines
260	static int bnxt_qplib_process_qp_event(struct bnxt_qplib_rcfw *rcfw,	278	static int bnxt_qplib_process_qp_event(struct bnxt_qplib_rcfw *rcfw,
261	struct creq_qp_event *qp_event)	279	struct creq_qp_event *qp_event)
262	{	280	{
263	struct bnxt_qplib_crsq *crsq = &rcfw->crsq;
264	struct bnxt_qplib_hwq *cmdq = &rcfw->cmdq;	281	struct bnxt_qplib_hwq *cmdq = &rcfw->cmdq;
265	struct bnxt_qplib_crsqe *crsqe;	282	struct bnxt_qplib_crsq *crsqe;
266	u16 cbit, cookie, blocked = 0;
267	unsigned long flags;	283	unsigned long flags;
268	u32 sw_cons;	284	u16 cbit, blocked = 0;
		285	u16 cookie;
		286	__le16 mcookie;
269		287
270	switch (qp_event->event) {	288	switch (qp_event->event) {
271	case CREQ_QP_EVENT_EVENT_QP_ERROR_NOTIFICATION:	289	case CREQ_QP_EVENT_EVENT_QP_ERROR_NOTIFICATION:
@@ -275,24 +293,31 @@ static int bnxt_qplib_process_qp_event(struct bnxt_qplib_rcfw *rcfw, · 3 unmodified lines
275	default:	293	default:
276	/* Command Response */	294	/* Command Response */
277	spin_lock_irqsave(&cmdq->lock, flags);	295	spin_lock_irqsave(&cmdq->lock, flags);
278	sw_cons = HWQ_CMP(crsq->cons, crsq);	296	cookie = le16_to_cpu(qp_event->cookie);
279	crsqe = &crsq->crsq[sw_cons];	297	mcookie = qp_event->cookie;
280	crsq->cons++;
281	memcpy(&crsqe->qp_event, qp_event, sizeof(crsqe->qp_event));
282
283	cookie = le16_to_cpu(crsqe->qp_event.cookie);
284	blocked = cookie & RCFW_CMD_IS_BLOCKING;	298	blocked = cookie & RCFW_CMD_IS_BLOCKING;
285	cookie &= RCFW_MAX_COOKIE_VALUE;	299	cookie &= RCFW_MAX_COOKIE_VALUE;
286	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;	300	cbit = cookie % RCFW_MAX_OUTSTANDING_CMD;
		301	crsqe = &rcfw->crsqe_tbl[cbit];
		302	if (crsqe->resp &&
		303	crsqe->resp->cookie == mcookie) {
		304	memcpy(crsqe->resp, qp_event, sizeof(*qp_event));
		305	crsqe->resp = NULL;
		306	} else {
		307	dev_err(&rcfw->pdev->dev,
		308	"QPLIB: CMD %s resp->cookie = %#x, evnt->cookie = %#x",
		309	crsqe->resp ? "mismatch" : "collision",
		310	crsqe->resp ? crsqe->resp->cookie : 0, mcookie);
		311	}
287	if (!test_and_clear_bit(cbit, rcfw->cmdq_bitmap))	312	if (!test_and_clear_bit(cbit, rcfw->cmdq_bitmap))
288	dev_warn(&rcfw->pdev->dev,	313	dev_warn(&rcfw->pdev->dev,
289	"QPLIB: CMD bit %d was not requested", cbit);	314	"QPLIB: CMD bit %d was not requested", cbit);
290
291	cmdq->cons += crsqe->req_size;	315	cmdq->cons += crsqe->req_size;
292	spin_unlock_irqrestore(&cmdq->lock, flags);	316	crsqe->req_size = 0;
		317
293	if (!blocked)	318	if (!blocked)
294	wake_up(&rcfw->waitq);	319	wake_up(&rcfw->waitq);
295	break;	320	spin_unlock_irqrestore(&cmdq->lock, flags);
296	}	321	}
297	return 0;	322	return 0;
298	}	323	}
@@ -305,12 +330,12 @@ static void bnxt_qplib_service_creq(unsigned long data) · 6 unmodified lines
305	struct creq_base creqe, *creq_ptr;	330	struct creq_base creqe, *creq_ptr;
306	u32 sw_cons, raw_cons;	331	u32 sw_cons, raw_cons;
307	unsigned long flags;	332	unsigned long flags;
308	u32 type;	333	u32 type, budget = CREQ_ENTRY_POLL_BUDGET;
309		334
310	/* Service the CREQ until empty */	335	/* Service the CREQ until budget is over */
311	spin_lock_irqsave(&creq->lock, flags);	336	spin_lock_irqsave(&creq->lock, flags);
312	raw_cons = creq->cons;	337	raw_cons = creq->cons;
313	while (1) {	338	while (budget > 0) {
314	sw_cons = HWQ_CMP(raw_cons, creq);	339	sw_cons = HWQ_CMP(raw_cons, creq);
315	creq_ptr = (struct creq_base **)creq->pbl_ptr;	340	creq_ptr = (struct creq_base **)creq->pbl_ptr;
316	creqe = &creq_ptr[get_creq_pg(sw_cons)][get_creq_idx(sw_cons)];	341	creqe = &creq_ptr[get_creq_pg(sw_cons)][get_creq_idx(sw_cons)];
@@ -320,15 +345,9 @@ static void bnxt_qplib_service_creq(unsigned long data) · 3 unmodified lines
320	type = creqe->type & CREQ_BASE_TYPE_MASK;	345	type = creqe->type & CREQ_BASE_TYPE_MASK;
321	switch (type) {	346	switch (type) {
322	case CREQ_BASE_TYPE_QP_EVENT:	347	case CREQ_BASE_TYPE_QP_EVENT:
323	if (!bnxt_qplib_process_qp_event	348	bnxt_qplib_process_qp_event
324	(rcfw, (struct creq_qp_event *)creqe))	349	(rcfw, (struct creq_qp_event *)creqe);
325	rcfw->creq_qp_event_processed++;	350	rcfw->creq_qp_event_processed++;
326	else {
327	dev_warn(&rcfw->pdev->dev, "QPLIB: crsqe with");
328	dev_warn(&rcfw->pdev->dev,
329	"QPLIB: type = 0x%x not handled",
330	type);
331	}
332	break;	351	break;
333	case CREQ_BASE_TYPE_FUNC_EVENT:	352	case CREQ_BASE_TYPE_FUNC_EVENT:
334	if (!bnxt_qplib_process_func_event	353	if (!bnxt_qplib_process_func_event
@@ -346,7 +365,9 @@ static void bnxt_qplib_service_creq(unsigned long data) · 11 unmodified lines
346	break;	365	break;
347	}	366	}
348	raw_cons++;	367	raw_cons++;
		368	budget--;
349	}	369	}
		370
350	if (creq->cons != raw_cons) {	371	if (creq->cons != raw_cons) {
351	creq->cons = raw_cons;	372	creq->cons = raw_cons;
352	CREQ_DB_REARM(rcfw->creq_bar_reg_iomem, raw_cons,	373	CREQ_DB_REARM(rcfw->creq_bar_reg_iomem, raw_cons,
@@ -375,23 +396,16 @@ static irqreturn_t bnxt_qplib_creq_irq(int irq, void *dev_instance) · 22 unmodified lines
375	/* RCFW */	396	/* RCFW */
376	int bnxt_qplib_deinit_rcfw(struct bnxt_qplib_rcfw *rcfw)	397	int bnxt_qplib_deinit_rcfw(struct bnxt_qplib_rcfw *rcfw)
377	{	398	{
378	struct creq_deinitialize_fw_resp *resp;
379	struct cmdq_deinitialize_fw req;	399	struct cmdq_deinitialize_fw req;
		400	struct creq_deinitialize_fw_resp resp;
380	u16 cmd_flags = 0;	401	u16 cmd_flags = 0;
		402	int rc;
381		403
382	RCFW_CMD_PREP(req, DEINITIALIZE_FW, cmd_flags);	404	RCFW_CMD_PREP(req, DEINITIALIZE_FW, cmd_flags);
383	resp = (struct creq_deinitialize_fw_resp *)	405	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
384	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	406	NULL, 0);
385	NULL, 0);	407	if (rc)
386	if (!resp)	408	return rc;
387	return -EINVAL;
388
389	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie)))
390	return -ETIMEDOUT;
391
392	if (resp->status \|\|
393	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie))
394	return -EFAULT;
395		409
396	clear_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags);	410	clear_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags);
397	return 0;	411	return 0;
@@ -417,9 +431,10 @@ static int __get_pbl_pg_idx(struct bnxt_qplib_pbl *pbl) · 19 unmodified lines
417	int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw,	431	int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw,
418	struct bnxt_qplib_ctx *ctx, int is_virtfn)	432	struct bnxt_qplib_ctx *ctx, int is_virtfn)
419	{	433	{
420	struct creq_initialize_fw_resp *resp;
421	struct cmdq_initialize_fw req;	434	struct cmdq_initialize_fw req;
		435	struct creq_initialize_fw_resp resp;
422	u16 cmd_flags = 0, level;	436	u16 cmd_flags = 0, level;
		437	int rc;
423		438
424	RCFW_CMD_PREP(req, INITIALIZE_FW, cmd_flags);	439	RCFW_CMD_PREP(req, INITIALIZE_FW, cmd_flags);
425		440
@@ -482,37 +497,19 @@ int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw, · 56 unmodified lines
482		497
483	skip_ctx_setup:	498	skip_ctx_setup:
484	req.stat_ctx_id = cpu_to_le32(ctx->stats.fw_id);	499	req.stat_ctx_id = cpu_to_le32(ctx->stats.fw_id);
485	resp = (struct creq_initialize_fw_resp *)	500	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
486	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	501	NULL, 0);
487	NULL, 0);	502	if (rc)
488	if (!resp) {	503	return rc;
489	dev_err(&rcfw->pdev->dev,
490	"QPLIB: RCFW: INITIALIZE_FW send failed");
491	return -EINVAL;
492	}
493	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
494	/* Cmd timed out */
495	dev_err(&rcfw->pdev->dev,
496	"QPLIB: RCFW: INITIALIZE_FW timed out");
497	return -ETIMEDOUT;
498	}
499	if (resp->status \|\|
500	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
501	dev_err(&rcfw->pdev->dev,
502	"QPLIB: RCFW: INITIALIZE_FW failed");
503	return -EINVAL;
504	}
505	set_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags);	504	set_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->flags);
506	return 0;	505	return 0;
507	}	506	}
508		507
509	void bnxt_qplib_free_rcfw_channel(struct bnxt_qplib_rcfw *rcfw)	508	void bnxt_qplib_free_rcfw_channel(struct bnxt_qplib_rcfw *rcfw)
510	{	509	{
511	bnxt_qplib_free_hwq(rcfw->pdev, &rcfw->crsb);	510	kfree(rcfw->crsqe_tbl);
512	kfree(rcfw->crsq.crsq);
513	bnxt_qplib_free_hwq(rcfw->pdev, &rcfw->cmdq);	511	bnxt_qplib_free_hwq(rcfw->pdev, &rcfw->cmdq);
514	bnxt_qplib_free_hwq(rcfw->pdev, &rcfw->creq);	512	bnxt_qplib_free_hwq(rcfw->pdev, &rcfw->creq);
515
516	rcfw->pdev = NULL;	513	rcfw->pdev = NULL;
517	}	514	}
518		515
@@ -539,21 +536,11 @@ int bnxt_qplib_alloc_rcfw_channel(struct pci_dev *pdev, · 20 unmodified lines
539	goto fail;	536	goto fail;
540	}	537	}
541		538
542	rcfw->crsq.max_elements = rcfw->cmdq.max_elements;	539	rcfw->crsqe_tbl = kcalloc(rcfw->cmdq.max_elements,
543	rcfw->crsq.crsq = kcalloc(rcfw->crsq.max_elements,	540	sizeof(*rcfw->crsqe_tbl), GFP_KERNEL);
544	sizeof(*rcfw->crsq.crsq), GFP_KERNEL);	541	if (!rcfw->crsqe_tbl)
545	if (!rcfw->crsq.crsq)
546	goto fail;	542	goto fail;
547		543
548	rcfw->crsb.max_elements = BNXT_QPLIB_CRSBE_MAX_CNT;
549	if (bnxt_qplib_alloc_init_hwq(rcfw->pdev, &rcfw->crsb, NULL, 0,
550	&rcfw->crsb.max_elements,
551	BNXT_QPLIB_CRSBE_UNITS, 0, PAGE_SIZE,
552	HWQ_TYPE_CTX)) {
553	dev_err(&rcfw->pdev->dev,
554	"QPLIB: HW channel CRSB allocation failed");
555	goto fail;
556	}
557	return 0;	544	return 0;
558		545
559	fail:	546	fail:
@@ -606,7 +593,7 @@ int bnxt_qplib_enable_rcfw_channel(struct pci_dev *pdev, · 46 unmodified lines
606	int rc;	593	int rc;
607		594
608	/* General */	595	/* General */
609	atomic_set(&rcfw->seq_num, 0);	596	rcfw->seq_num = 0;
610	rcfw->flags = FIRMWARE_FIRST_FLAG;	597	rcfw->flags = FIRMWARE_FIRST_FLAG;
611	bmap_size = BITS_TO_LONGS(RCFW_MAX_OUTSTANDING_CMD *	598	bmap_size = BITS_TO_LONGS(RCFW_MAX_OUTSTANDING_CMD *
612	sizeof(unsigned long));	599	sizeof(unsigned long));
@@ -636,10 +623,6 @@ int bnxt_qplib_enable_rcfw_channel(struct pci_dev *pdev, · 23 unmodified lines
636		623
637	rcfw->cmdq_bar_reg_trig_off = RCFW_COMM_TRIG_OFFSET;	624	rcfw->cmdq_bar_reg_trig_off = RCFW_COMM_TRIG_OFFSET;
638		625
639	/* CRSQ */
640	rcfw->crsq.prod = 0;
641	rcfw->crsq.cons = 0;
642
643	/* CREQ */	626	/* CREQ */
644	rcfw->creq_bar_reg = RCFW_COMM_CONS_PCI_BAR_REGION;	627	rcfw->creq_bar_reg = RCFW_COMM_CONS_PCI_BAR_REGION;
645	res_base = pci_resource_start(pdev, rcfw->creq_bar_reg);	628	res_base = pci_resource_start(pdev, rcfw->creq_bar_reg);
@@ -692,3 +675,34 @@ int bnxt_qplib_enable_rcfw_channel(struct pci_dev *pdev, · 46 unmodified lines
692	__iowrite32_copy(rcfw->cmdq_bar_reg_iomem, &init, sizeof(init) / 4);	675	__iowrite32_copy(rcfw->cmdq_bar_reg_iomem, &init, sizeof(init) / 4);
693	return 0;	676	return 0;
694	}	677	}
		678
		679	struct bnxt_qplib_rcfw_sbuf *bnxt_qplib_rcfw_alloc_sbuf(
		680	struct bnxt_qplib_rcfw *rcfw,
		681	u32 size)
		682	{
		683	struct bnxt_qplib_rcfw_sbuf *sbuf;
		684
		685	sbuf = kzalloc(sizeof(*sbuf), GFP_ATOMIC);
		686	if (!sbuf)
		687	return NULL;
		688
		689	sbuf->size = size;
		690	sbuf->sb = dma_zalloc_coherent(&rcfw->pdev->dev, sbuf->size,
		691	&sbuf->dma_addr, GFP_ATOMIC);
		692	if (!sbuf->sb)
		693	goto bail;
		694
		695	return sbuf;
		696	bail:
		697	kfree(sbuf);
		698	return NULL;
		699	}
		700
		701	void bnxt_qplib_rcfw_free_sbuf(struct bnxt_qplib_rcfw *rcfw,
		702	struct bnxt_qplib_rcfw_sbuf *sbuf)
		703	{
		704	if (sbuf->sb)
		705	dma_free_coherent(&rcfw->pdev->dev, sbuf->size,
		706	sbuf->sb, sbuf->dma_addr);
		707	kfree(sbuf);
		708	}

drivers/infiniband/hw/bnxt_re/qplib_rcfw.h+20−41

@@ -73,6 +73,7 @@ · 72 unmodified lines
73	#define RCFW_MAX_OUTSTANDING_CMD BNXT_QPLIB_CMDQE_MAX_CNT	73	#define RCFW_MAX_OUTSTANDING_CMD BNXT_QPLIB_CMDQE_MAX_CNT
74	#define RCFW_MAX_COOKIE_VALUE 0x7FFF	74	#define RCFW_MAX_COOKIE_VALUE 0x7FFF
75	#define RCFW_CMD_IS_BLOCKING 0x8000	75	#define RCFW_CMD_IS_BLOCKING 0x8000
		76	#define RCFW_BLOCKED_CMD_WAIT_COUNT 0x4E20
76		77
77	/* Cmdq contains a fix number of a 16-Byte slots */	78	/* Cmdq contains a fix number of a 16-Byte slots */
78	struct bnxt_qplib_cmdqe {	79	struct bnxt_qplib_cmdqe {
@@ -94,32 +95,6 @@ struct bnxt_qplib_crsbe { · 15 unmodified lines
94	u8 data[1024];	95	u8 data[1024];
95	};	96	};
96		97
97	/* CRSQ SB */
98	#define BNXT_QPLIB_CRSBE_MAX_CNT 4
99	#define BNXT_QPLIB_CRSBE_UNITS sizeof(struct bnxt_qplib_crsbe)
100	#define BNXT_QPLIB_CRSBE_CNT_PER_PG (PAGE_SIZE / BNXT_QPLIB_CRSBE_UNITS)
101
102	#define MAX_CRSB_IDX (BNXT_QPLIB_CRSBE_MAX_CNT - 1)
103	#define MAX_CRSB_IDX_PER_PG (BNXT_QPLIB_CRSBE_CNT_PER_PG - 1)
104
105	static inline u32 get_crsb_pg(u32 val)
106	{
107	return (val & ~MAX_CRSB_IDX_PER_PG) / BNXT_QPLIB_CRSBE_CNT_PER_PG;
108	}
109
110	static inline u32 get_crsb_idx(u32 val)
111	{
112	return val & MAX_CRSB_IDX_PER_PG;
113	}
114
115	static inline void bnxt_qplib_crsb_dma_next(dma_addr_t *pg_map_arr,
116	u32 prod, dma_addr_t *dma_addr)
117	{
118	*dma_addr = pg_map_arr[(prod) / BNXT_QPLIB_CRSBE_CNT_PER_PG];
119	dma_addr += ((prod) % BNXT_QPLIB_CRSBE_CNT_PER_PG)
120	BNXT_QPLIB_CRSBE_UNITS;
121	}
122
123	/* CREQ */	98	/* CREQ */
124	/* Allocate 1 per QP for async error notification for now */	99	/* Allocate 1 per QP for async error notification for now */
125	#define BNXT_QPLIB_CREQE_MAX_CNT (64 * 1024)	100	#define BNXT_QPLIB_CREQE_MAX_CNT (64 * 1024)
@@ -158,17 +133,19 @@ static inline u32 get_creq_idx(u32 val) · 32 unmodified lines
158	#define CREQ_DB(db, raw_cons, cp_bit) \	133	#define CREQ_DB(db, raw_cons, cp_bit) \
159	writel(CREQ_DB_CP_FLAGS \| ((raw_cons) & ((cp_bit) - 1)), db)	134	writel(CREQ_DB_CP_FLAGS \| ((raw_cons) & ((cp_bit) - 1)), db)
160		135
		136	#define CREQ_ENTRY_POLL_BUDGET 0x100
		137
161	/* HWQ */	138	/* HWQ */
162	struct bnxt_qplib_crsqe {	139
163	struct creq_qp_event qp_event;	140	struct bnxt_qplib_crsq {
		141	struct creq_qp_event *resp;
164	u32 req_size;	142	u32 req_size;
165	};	143	};
166		144
167	struct bnxt_qplib_crsq {	145	struct bnxt_qplib_rcfw_sbuf {
168	struct bnxt_qplib_crsqe *crsq;	146	void *sb;
169	u32 prod;	147	dma_addr_t dma_addr;
170	u32 cons;	148	u32 size;
171	u32 max_elements;
172	};	149	};
173		150
174	/* RCFW Communication Channels */	151	/* RCFW Communication Channels */
@@ -185,7 +162,7 @@ struct bnxt_qplib_rcfw { · 10 unmodified lines
185	wait_queue_head_t waitq;	162	wait_queue_head_t waitq;
186	int (aeq_handler)(struct bnxt_qplib_rcfw ,	163	int (aeq_handler)(struct bnxt_qplib_rcfw ,
187	struct creq_func_event *);	164	struct creq_func_event *);
188	atomic_t seq_num;	165	u32 seq_num;
189		166
190	/* Bar region info */	167	/* Bar region info */
191	void __iomem *cmdq_bar_reg_iomem;	168	void __iomem *cmdq_bar_reg_iomem;
@@ -203,8 +180,7 @@ struct bnxt_qplib_rcfw { · 11 unmodified lines
203		180
204	/* Actual Cmd and Resp Queues */	181	/* Actual Cmd and Resp Queues */
205	struct bnxt_qplib_hwq cmdq;	182	struct bnxt_qplib_hwq cmdq;
206	struct bnxt_qplib_crsq crsq;	183	struct bnxt_qplib_crsq *crsqe_tbl;
207	struct bnxt_qplib_hwq crsb;
208	};	184	};
209		185
210	void bnxt_qplib_free_rcfw_channel(struct bnxt_qplib_rcfw *rcfw);	186	void bnxt_qplib_free_rcfw_channel(struct bnxt_qplib_rcfw *rcfw);
@@ -219,11 +195,14 @@ int bnxt_qplib_enable_rcfw_channel(struct pci_dev *pdev, · 8 unmodified lines
219	(struct bnxt_qplib_rcfw *,	195	(struct bnxt_qplib_rcfw *,
220	struct creq_func_event *));	196	struct creq_func_event *));
221		197
222	int bnxt_qplib_rcfw_block_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie);	198	struct bnxt_qplib_rcfw_sbuf *bnxt_qplib_rcfw_alloc_sbuf(
223	int bnxt_qplib_rcfw_wait_for_resp(struct bnxt_qplib_rcfw *rcfw, u16 cookie);	199	struct bnxt_qplib_rcfw *rcfw,
224	void bnxt_qplib_rcfw_send_message(struct bnxt_qplib_rcfw rcfw,	200	u32 size);
225	struct cmdq_base req, void *crsbe,	201	void bnxt_qplib_rcfw_free_sbuf(struct bnxt_qplib_rcfw *rcfw,
226	u8 is_block);	202	struct bnxt_qplib_rcfw_sbuf *sbuf);
		203	int bnxt_qplib_rcfw_send_message(struct bnxt_qplib_rcfw *rcfw,
		204	struct cmdq_base req, struct creq_base resp,
		205	void *sbuf, u8 is_block);
227		206
228	int bnxt_qplib_deinit_rcfw(struct bnxt_qplib_rcfw *rcfw);	207	int bnxt_qplib_deinit_rcfw(struct bnxt_qplib_rcfw *rcfw);
229	int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw,	208	int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw,

drivers/infiniband/hw/bnxt_re/qplib_res.h+4−0

 #define HWQ_CMP(idx, hwq)	((idx) & ((hwq)->max_elements - 1))
+#define HWQ_FREE_SLOTS(hwq)	(hwq->max_elements - \
+				((HWQ_CMP(hwq->prod, hwq)\
+				- HWQ_CMP(hwq->cons, hwq))\
+				& (hwq->max_elements - 1)))
 enum bnxt_qplib_hwq_type {
 	HWQ_TYPE_CTX,
 	HWQ_TYPE_QUEUE,

drivers/infiniband/hw/bnxt_re/qplib_sp.c+83−250

@@ -55,37 +55,30 @@ int bnxt_qplib_get_dev_attr(struct bnxt_qplib_rcfw *rcfw, · 54 unmodified lines
55	struct bnxt_qplib_dev_attr *attr)	55	struct bnxt_qplib_dev_attr *attr)
56	{	56	{
57	struct cmdq_query_func req;	57	struct cmdq_query_func req;
58	struct creq_query_func_resp *resp;	58	struct creq_query_func_resp resp;
		59	struct bnxt_qplib_rcfw_sbuf *sbuf;
59	struct creq_query_func_resp_sb *sb;	60	struct creq_query_func_resp_sb *sb;
60	u16 cmd_flags = 0;	61	u16 cmd_flags = 0;
61	u32 temp;	62	u32 temp;
62	u8 *tqm_alloc;	63	u8 *tqm_alloc;
63	int i;	64	int i, rc = 0;
64		65
65	RCFW_CMD_PREP(req, QUERY_FUNC, cmd_flags);	66	RCFW_CMD_PREP(req, QUERY_FUNC, cmd_flags);
66		67
67	req.resp_size = sizeof(*sb) / BNXT_QPLIB_CMDQE_UNITS;	68	sbuf = bnxt_qplib_rcfw_alloc_sbuf(rcfw, sizeof(*sb));
68	resp = (struct creq_query_func_resp *)	69	if (!sbuf) {
69	bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void *)&sb,
70	0);
71	if (!resp) {
72	dev_err(&rcfw->pdev->dev, "QPLIB: SP: QUERY_FUNC send failed");
73	return -EINVAL;
74	}
75	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
76	/* Cmd timed out */
77	dev_err(&rcfw->pdev->dev, "QPLIB: SP: QUERY_FUNC timed out");
78	return -ETIMEDOUT;
79	}
80	if (resp->status \|\|
81	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
82	dev_err(&rcfw->pdev->dev, "QPLIB: SP: QUERY_FUNC failed ");
83	dev_err(&rcfw->pdev->dev,	70	dev_err(&rcfw->pdev->dev,
84	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",	71	"QPLIB: SP: QUERY_FUNC alloc side buffer failed");
85	resp->status, le16_to_cpu(req.cookie),	72	return -ENOMEM;
86	le16_to_cpu(resp->cookie));
87	return -EINVAL;
88	}	73	}
		74
		75	sb = sbuf->sb;
		76	req.resp_size = sizeof(*sb) / BNXT_QPLIB_CMDQE_UNITS;
		77	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
		78	(void *)sbuf, 0);
		79	if (rc)
		80	goto bail;
		81
89	/* Extract the context from the side buffer */	82	/* Extract the context from the side buffer */
90	attr->max_qp = le32_to_cpu(sb->max_qp);	83	attr->max_qp = le32_to_cpu(sb->max_qp);
91	attr->max_qp_rd_atom =	84	attr->max_qp_rd_atom =
@@ -95,6 +88,11 @@ int bnxt_qplib_get_dev_attr(struct bnxt_qplib_rcfw *rcfw, · 3 unmodified lines
95	sb->max_qp_init_rd_atom > BNXT_QPLIB_MAX_OUT_RD_ATOM ?	88	sb->max_qp_init_rd_atom > BNXT_QPLIB_MAX_OUT_RD_ATOM ?
96	BNXT_QPLIB_MAX_OUT_RD_ATOM : sb->max_qp_init_rd_atom;	89	BNXT_QPLIB_MAX_OUT_RD_ATOM : sb->max_qp_init_rd_atom;
97	attr->max_qp_wqes = le16_to_cpu(sb->max_qp_wr);	90	attr->max_qp_wqes = le16_to_cpu(sb->max_qp_wr);
		91	/*
		92	* 128 WQEs needs to be reserved for the HW (8916). Prevent
		93	* reporting the max number
		94	*/
		95	attr->max_qp_wqes -= BNXT_QPLIB_RESERVED_QP_WRS;
98	attr->max_qp_sges = sb->max_sge;	96	attr->max_qp_sges = sb->max_sge;
99	attr->max_cq = le32_to_cpu(sb->max_cq);	97	attr->max_cq = le32_to_cpu(sb->max_cq);
100	attr->max_cq_wqes = le32_to_cpu(sb->max_cqe);	98	attr->max_cq_wqes = le32_to_cpu(sb->max_cqe);
@@ -130,7 +128,10 @@ int bnxt_qplib_get_dev_attr(struct bnxt_qplib_rcfw *rcfw, · 29 unmodified lines
130	attr->tqm_alloc_reqs[i * 4 + 2] = *(++tqm_alloc);	128	attr->tqm_alloc_reqs[i * 4 + 2] = *(++tqm_alloc);
131	attr->tqm_alloc_reqs[i * 4 + 3] = *(++tqm_alloc);	129	attr->tqm_alloc_reqs[i * 4 + 3] = *(++tqm_alloc);
132	}	130	}
133	return 0;	131
		132	bail:
		133	bnxt_qplib_rcfw_free_sbuf(rcfw, sbuf);
		134	return rc;
134	}	135	}
135		136
136	/* SGID */	137	/* SGID */
@@ -178,8 +179,9 @@ int bnxt_qplib_del_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 41 unmodified lines
178	/* Remove GID from the SGID table */	179	/* Remove GID from the SGID table */
179	if (update) {	180	if (update) {
180	struct cmdq_delete_gid req;	181	struct cmdq_delete_gid req;
181	struct creq_delete_gid_resp *resp;	182	struct creq_delete_gid_resp resp;
182	u16 cmd_flags = 0;	183	u16 cmd_flags = 0;
		184	int rc;
183		185
184	RCFW_CMD_PREP(req, DELETE_GID, cmd_flags);	186	RCFW_CMD_PREP(req, DELETE_GID, cmd_flags);
185	if (sgid_tbl->hw_id[index] == 0xFFFF) {	187	if (sgid_tbl->hw_id[index] == 0xFFFF) {
@@ -188,31 +190,10 @@ int bnxt_qplib_del_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 2 unmodified lines
188	return -EINVAL;	190	return -EINVAL;
189	}	191	}
190	req.gid_index = cpu_to_le16(sgid_tbl->hw_id[index]);	192	req.gid_index = cpu_to_le16(sgid_tbl->hw_id[index]);
191	resp = (struct creq_delete_gid_resp *)	193	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
192	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req, NULL,	194	(void *)&resp, NULL, 0);
193	0);	195	if (rc)
194	if (!resp) {	196	return rc;
195	dev_err(&res->pdev->dev,
196	"QPLIB: SP: DELETE_GID send failed");
197	return -EINVAL;
198	}
199	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw,
200	le16_to_cpu(req.cookie))) {
201	/* Cmd timed out */
202	dev_err(&res->pdev->dev,
203	"QPLIB: SP: DELETE_GID timed out");
204	return -ETIMEDOUT;
205	}
206	if (resp->status \|\|
207	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
208	dev_err(&res->pdev->dev,
209	"QPLIB: SP: DELETE_GID failed ");
210	dev_err(&res->pdev->dev,
211	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
212	resp->status, le16_to_cpu(req.cookie),
213	le16_to_cpu(resp->cookie));
214	return -EINVAL;
215	}
216	}	197	}
217	memcpy(&sgid_tbl->tbl[index], &bnxt_qplib_gid_zero,	198	memcpy(&sgid_tbl->tbl[index], &bnxt_qplib_gid_zero,
218	sizeof(bnxt_qplib_gid_zero));	199	sizeof(bnxt_qplib_gid_zero));
@@ -234,7 +215,7 @@ int bnxt_qplib_add_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 15 unmodified lines
234	struct bnxt_qplib_res,	215	struct bnxt_qplib_res,
235	sgid_tbl);	216	sgid_tbl);
236	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	217	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
237	int i, free_idx, rc = 0;	218	int i, free_idx;
238		219
239	if (!sgid_tbl) {	220	if (!sgid_tbl) {
240	dev_err(&res->pdev->dev, "QPLIB: SGID table not allocated");	221	dev_err(&res->pdev->dev, "QPLIB: SGID table not allocated");
@@ -266,10 +247,11 @@ int bnxt_qplib_add_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 25 unmodified lines
266	}	247	}
267	if (update) {	248	if (update) {
268	struct cmdq_add_gid req;	249	struct cmdq_add_gid req;
269	struct creq_add_gid_resp *resp;	250	struct creq_add_gid_resp resp;
270	u16 cmd_flags = 0;	251	u16 cmd_flags = 0;
271	u32 temp32[4];	252	u32 temp32[4];
272	u16 temp16[3];	253	u16 temp16[3];
		254	int rc;
273		255
274	RCFW_CMD_PREP(req, ADD_GID, cmd_flags);	256	RCFW_CMD_PREP(req, ADD_GID, cmd_flags);
275		257
@@ -290,31 +272,11 @@ int bnxt_qplib_add_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 14 unmodified lines
290	req.src_mac[1] = cpu_to_be16(temp16[1]);	272	req.src_mac[1] = cpu_to_be16(temp16[1]);
291	req.src_mac[2] = cpu_to_be16(temp16[2]);	273	req.src_mac[2] = cpu_to_be16(temp16[2]);
292		274
293	resp = (struct creq_add_gid_resp *)	275	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
294	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	276	(void *)&resp, NULL, 0);
295	NULL, 0);	277	if (rc)
296	if (!resp) {	278	return rc;
297	dev_err(&res->pdev->dev,	279	sgid_tbl->hw_id[free_idx] = le32_to_cpu(resp.xid);
298	"QPLIB: SP: ADD_GID send failed");
299	return -EINVAL;
300	}
301	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw,
302	le16_to_cpu(req.cookie))) {
303	/* Cmd timed out */
304	dev_err(&res->pdev->dev,
305	"QPIB: SP: ADD_GID timed out");
306	return -ETIMEDOUT;
307	}
308	if (resp->status \|\|
309	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
310	dev_err(&res->pdev->dev, "QPLIB: SP: ADD_GID failed ");
311	dev_err(&res->pdev->dev,
312	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
313	resp->status, le16_to_cpu(req.cookie),
314	le16_to_cpu(resp->cookie));
315	return -EINVAL;
316	}
317	sgid_tbl->hw_id[free_idx] = le32_to_cpu(resp->xid);
318	}	280	}
319	/* Add GID to the sgid_tbl */	281	/* Add GID to the sgid_tbl */
320	memcpy(&sgid_tbl->tbl[free_idx], gid, sizeof(*gid));	282	memcpy(&sgid_tbl->tbl[free_idx], gid, sizeof(*gid));
@@ -325,7 +287,7 @@ int bnxt_qplib_add_sgid(struct bnxt_qplib_sgid_tbl *sgid_tbl, · 4 unmodified lines
325		287
326	*index = free_idx;	288	*index = free_idx;
327	/* unlock */	289	/* unlock */
328	return rc;	290	return 0;
329	}	291	}
330		292
331	/* pkeys */	293	/* pkeys */
@@ -422,10 +384,11 @@ int bnxt_qplib_create_ah(struct bnxt_qplib_res res, struct bnxt_qplib_ah ah) · 90 unmodified lines
422	{	384	{
423	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	385	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
424	struct cmdq_create_ah req;	386	struct cmdq_create_ah req;
425	struct creq_create_ah_resp *resp;	387	struct creq_create_ah_resp resp;
426	u16 cmd_flags = 0;	388	u16 cmd_flags = 0;
427	u32 temp32[4];	389	u32 temp32[4];
428	u16 temp16[3];	390	u16 temp16[3];
		391	int rc;
429		392
430	RCFW_CMD_PREP(req, CREATE_AH, cmd_flags);	393	RCFW_CMD_PREP(req, CREATE_AH, cmd_flags);
431		394
@@ -450,28 +413,12 @@ int bnxt_qplib_create_ah(struct bnxt_qplib_res res, struct bnxt_qplib_ah ah) · 18 unmodified lines
450	req.dest_mac[1] = cpu_to_le16(temp16[1]);	413	req.dest_mac[1] = cpu_to_le16(temp16[1]);
451	req.dest_mac[2] = cpu_to_le16(temp16[2]);	414	req.dest_mac[2] = cpu_to_le16(temp16[2]);
452		415
453	resp = (struct creq_create_ah_resp *)	416	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
454	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	417	NULL, 1);
455	NULL, 1);	418	if (rc)
456	if (!resp) {	419	return rc;
457	dev_err(&rcfw->pdev->dev, "QPLIB: SP: CREATE_AH send failed");	420
458	return -EINVAL;	421	ah->id = le32_to_cpu(resp.xid);
459	}
460	if (!bnxt_qplib_rcfw_block_for_resp(rcfw, le16_to_cpu(req.cookie))) {
461	/* Cmd timed out */
462	dev_err(&rcfw->pdev->dev, "QPLIB: SP: CREATE_AH timed out");
463	return -ETIMEDOUT;
464	}
465	if (resp->status \|\|
466	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
467	dev_err(&rcfw->pdev->dev, "QPLIB: SP: CREATE_AH failed ");
468	dev_err(&rcfw->pdev->dev,
469	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
470	resp->status, le16_to_cpu(req.cookie),
471	le16_to_cpu(resp->cookie));
472	return -EINVAL;
473	}
474	ah->id = le32_to_cpu(resp->xid);
475	return 0;	422	return 0;
476	}	423	}
477		424
@@ -479,35 +426,19 @@ int bnxt_qplib_destroy_ah(struct bnxt_qplib_res res, struct bnxt_qplib_ah ah) · 1 unmodified line
479	{	426	{
480	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	427	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
481	struct cmdq_destroy_ah req;	428	struct cmdq_destroy_ah req;
482	struct creq_destroy_ah_resp *resp;	429	struct creq_destroy_ah_resp resp;
483	u16 cmd_flags = 0;	430	u16 cmd_flags = 0;
		431	int rc;
484		432
485	/* Clean up the AH table in the device */	433	/* Clean up the AH table in the device */
486	RCFW_CMD_PREP(req, DESTROY_AH, cmd_flags);	434	RCFW_CMD_PREP(req, DESTROY_AH, cmd_flags);
487		435
488	req.ah_cid = cpu_to_le32(ah->id);	436	req.ah_cid = cpu_to_le32(ah->id);
489		437
490	resp = (struct creq_destroy_ah_resp *)	438	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
491	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	439	NULL, 1);
492	NULL, 1);	440	if (rc)
493	if (!resp) {	441	return rc;
494	dev_err(&rcfw->pdev->dev, "QPLIB: SP: DESTROY_AH send failed");
495	return -EINVAL;
496	}
497	if (!bnxt_qplib_rcfw_block_for_resp(rcfw, le16_to_cpu(req.cookie))) {
498	/* Cmd timed out */
499	dev_err(&rcfw->pdev->dev, "QPLIB: SP: DESTROY_AH timed out");
500	return -ETIMEDOUT;
501	}
502	if (resp->status \|\|
503	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
504	dev_err(&rcfw->pdev->dev, "QPLIB: SP: DESTROY_AH failed ");
505	dev_err(&rcfw->pdev->dev,
506	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
507	resp->status, le16_to_cpu(req.cookie),
508	le16_to_cpu(resp->cookie));
509	return -EINVAL;
510	}
511	return 0;	442	return 0;
512	}	443	}
513		444
@@ -516,8 +447,9 @@ int bnxt_qplib_free_mrw(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mrw) · 2 unmodified lines
516	{	447	{
517	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	448	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
518	struct cmdq_deallocate_key req;	449	struct cmdq_deallocate_key req;
519	struct creq_deallocate_key_resp *resp;	450	struct creq_deallocate_key_resp resp;
520	u16 cmd_flags = 0;	451	u16 cmd_flags = 0;
		452	int rc;
521		453
522	if (mrw->lkey == 0xFFFFFFFF) {	454	if (mrw->lkey == 0xFFFFFFFF) {
523	dev_info(&res->pdev->dev,	455	dev_info(&res->pdev->dev,
@@ -536,27 +468,11 @@ int bnxt_qplib_free_mrw(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mrw) · 12 unmodified lines
536	else	468	else
537	req.key = cpu_to_le32(mrw->lkey);	469	req.key = cpu_to_le32(mrw->lkey);
538		470
539	resp = (struct creq_deallocate_key_resp *)	471	rc = bnxt_qplib_rcfw_send_message(rcfw, (void )&req, (void )&resp,
540	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	472	NULL, 0);
541	NULL, 0);	473	if (rc)
542	if (!resp) {	474	return rc;
543	dev_err(&res->pdev->dev, "QPLIB: SP: FREE_MR send failed");	475
544	return -EINVAL;
545	}
546	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
547	/* Cmd timed out */
548	dev_err(&res->pdev->dev, "QPLIB: SP: FREE_MR timed out");
549	return -ETIMEDOUT;
550	}
551	if (resp->status \|\|
552	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
553	dev_err(&res->pdev->dev, "QPLIB: SP: FREE_MR failed ");
554	dev_err(&res->pdev->dev,
555	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
556	resp->status, le16_to_cpu(req.cookie),
557	le16_to_cpu(resp->cookie));
558	return -EINVAL;
559	}
560	/* Free the qplib's MRW memory */	476	/* Free the qplib's MRW memory */
561	if (mrw->hwq.max_elements)	477	if (mrw->hwq.max_elements)
562	bnxt_qplib_free_hwq(res->pdev, &mrw->hwq);	478	bnxt_qplib_free_hwq(res->pdev, &mrw->hwq);
@@ -568,9 +484,10 @@ int bnxt_qplib_alloc_mrw(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mrw) · 5 unmodified lines
568	{	484	{
569	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	485	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
570	struct cmdq_allocate_mrw req;	486	struct cmdq_allocate_mrw req;
571	struct creq_allocate_mrw_resp *resp;	487	struct creq_allocate_mrw_resp resp;
572	u16 cmd_flags = 0;	488	u16 cmd_flags = 0;
573	unsigned long tmp;	489	unsigned long tmp;
		490	int rc;
574		491
575	RCFW_CMD_PREP(req, ALLOCATE_MRW, cmd_flags);	492	RCFW_CMD_PREP(req, ALLOCATE_MRW, cmd_flags);
576		493
@@ -584,33 +501,17 @@ int bnxt_qplib_alloc_mrw(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mrw) · 7 unmodified lines
584	tmp = (unsigned long)mrw;	501	tmp = (unsigned long)mrw;
585	req.mrw_handle = cpu_to_le64(tmp);	502	req.mrw_handle = cpu_to_le64(tmp);
586		503
587	resp = (struct creq_allocate_mrw_resp *)	504	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
588	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	505	(void *)&resp, NULL, 0);
589	NULL, 0);	506	if (rc)
590	if (!resp) {	507	return rc;
591	dev_err(&rcfw->pdev->dev, "QPLIB: SP: ALLOC_MRW send failed");	508
592	return -EINVAL;
593	}
594	if (!bnxt_qplib_rcfw_wait_for_resp(rcfw, le16_to_cpu(req.cookie))) {
595	/* Cmd timed out */
596	dev_err(&rcfw->pdev->dev, "QPLIB: SP: ALLOC_MRW timed out");
597	return -ETIMEDOUT;
598	}
599	if (resp->status \|\|
600	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
601	dev_err(&rcfw->pdev->dev, "QPLIB: SP: ALLOC_MRW failed ");
602	dev_err(&rcfw->pdev->dev,
603	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
604	resp->status, le16_to_cpu(req.cookie),
605	le16_to_cpu(resp->cookie));
606	return -EINVAL;
607	}
608	if ((mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE1) \|\|	509	if ((mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE1) \|\|
609	(mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE2A) \|\|	510	(mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE2A) \|\|
610	(mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE2B))	511	(mrw->type == CMDQ_ALLOCATE_MRW_MRW_FLAGS_MW_TYPE2B))
611	mrw->rkey = le32_to_cpu(resp->xid);	512	mrw->rkey = le32_to_cpu(resp.xid);
612	else	513	else
613	mrw->lkey = le32_to_cpu(resp->xid);	514	mrw->lkey = le32_to_cpu(resp.xid);
614	return 0;	515	return 0;
615	}	516	}
616		517
@@ -619,40 +520,17 @@ int bnxt_qplib_dereg_mrw(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mrw, · 2 unmodified lines
619	{	520	{
620	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	521	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
621	struct cmdq_deregister_mr req;	522	struct cmdq_deregister_mr req;
622	struct creq_deregister_mr_resp *resp;	523	struct creq_deregister_mr_resp resp;
623	u16 cmd_flags = 0;	524	u16 cmd_flags = 0;
624	int rc;	525	int rc;
625		526
626	RCFW_CMD_PREP(req, DEREGISTER_MR, cmd_flags);	527	RCFW_CMD_PREP(req, DEREGISTER_MR, cmd_flags);
627		528
628	req.lkey = cpu_to_le32(mrw->lkey);	529	req.lkey = cpu_to_le32(mrw->lkey);
629	resp = (struct creq_deregister_mr_resp *)	530	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
630	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	531	(void *)&resp, NULL, block);
631	NULL, block);	532	if (rc)
632	if (!resp) {	533	return rc;
633	dev_err(&rcfw->pdev->dev, "QPLIB: SP: DEREG_MR send failed");
634	return -EINVAL;
635	}
636	if (block)
637	rc = bnxt_qplib_rcfw_block_for_resp(rcfw,
638	le16_to_cpu(req.cookie));
639	else
640	rc = bnxt_qplib_rcfw_wait_for_resp(rcfw,
641	le16_to_cpu(req.cookie));
642	if (!rc) {
643	/* Cmd timed out */
644	dev_err(&res->pdev->dev, "QPLIB: SP: DEREG_MR timed out");
645	return -ETIMEDOUT;
646	}
647	if (resp->status \|\|
648	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
649	dev_err(&rcfw->pdev->dev, "QPLIB: SP: DEREG_MR failed ");
650	dev_err(&rcfw->pdev->dev,
651	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
652	resp->status, le16_to_cpu(req.cookie),
653	le16_to_cpu(resp->cookie));
654	return -EINVAL;
655	}
656		534
657	/* Free the qplib's MR memory */	535	/* Free the qplib's MR memory */
658	if (mrw->hwq.max_elements) {	536	if (mrw->hwq.max_elements) {
@@ -669,7 +547,7 @@ int bnxt_qplib_reg_mr(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mr, · 10 unmodified lines
669	{	547	{
670	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	548	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
671	struct cmdq_register_mr req;	549	struct cmdq_register_mr req;
672	struct creq_register_mr_resp *resp;	550	struct creq_register_mr_resp resp;
673	u16 cmd_flags = 0, level;	551	u16 cmd_flags = 0, level;
674	int pg_ptrs, pages, i, rc;	552	int pg_ptrs, pages, i, rc;
675	dma_addr_t **pbl_ptr;	553	dma_addr_t **pbl_ptr;
@@ -730,36 +608,11 @@ int bnxt_qplib_reg_mr(struct bnxt_qplib_res res, struct bnxt_qplib_mrw mr, · 54 unmodified lines
730	req.key = cpu_to_le32(mr->lkey);	608	req.key = cpu_to_le32(mr->lkey);
731	req.mr_size = cpu_to_le64(mr->total_size);	609	req.mr_size = cpu_to_le64(mr->total_size);
732		610
733	resp = (struct creq_register_mr_resp *)	611	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
734	bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,	612	(void *)&resp, NULL, block);
735	NULL, block);	613	if (rc)
736	if (!resp) {
737	dev_err(&res->pdev->dev, "SP: REG_MR send failed");
738	rc = -EINVAL;
739	goto fail;
740	}
741	if (block)
742	rc = bnxt_qplib_rcfw_block_for_resp(rcfw,
743	le16_to_cpu(req.cookie));
744	else
745	rc = bnxt_qplib_rcfw_wait_for_resp(rcfw,
746	le16_to_cpu(req.cookie));
747	if (!rc) {
748	/* Cmd timed out */
749	dev_err(&res->pdev->dev, "SP: REG_MR timed out");
750	rc = -ETIMEDOUT;
751	goto fail;
752	}
753	if (resp->status \|\|
754	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
755	dev_err(&res->pdev->dev, "QPLIB: SP: REG_MR failed ");
756	dev_err(&res->pdev->dev,
757	"QPLIB: SP: with status 0x%x cmdq 0x%x resp 0x%x",
758	resp->status, le16_to_cpu(req.cookie),
759	le16_to_cpu(resp->cookie));
760	rc = -EINVAL;
761	goto fail;	614	goto fail;
762	}	615
763	return 0;	616	return 0;
764		617
765	fail:	618	fail:
@@ -804,35 +657,15 @@ int bnxt_qplib_map_tc2cos(struct bnxt_qplib_res res, u16 cids) · 38 unmodified lines
804	{	657	{
805	struct bnxt_qplib_rcfw *rcfw = res->rcfw;	658	struct bnxt_qplib_rcfw *rcfw = res->rcfw;
806	struct cmdq_map_tc_to_cos req;	659	struct cmdq_map_tc_to_cos req;
807	struct creq_map_tc_to_cos_resp *resp;	660	struct creq_map_tc_to_cos_resp resp;
808	u16 cmd_flags = 0;	661	u16 cmd_flags = 0;
809	int tleft;	662	int rc = 0;
810		663
811	RCFW_CMD_PREP(req, MAP_TC_TO_COS, cmd_flags);	664	RCFW_CMD_PREP(req, MAP_TC_TO_COS, cmd_flags);
812	req.cos0 = cpu_to_le16(cids[0]);	665	req.cos0 = cpu_to_le16(cids[0]);
813	req.cos1 = cpu_to_le16(cids[1]);	666	req.cos1 = cpu_to_le16(cids[1]);
814		667
815	resp = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req, NULL, 0);	668	rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req,
816	if (!resp) {	669	(void *)&resp, NULL, 0);
817	dev_err(&res->pdev->dev, "QPLIB: SP: MAP_TC2COS send failed");
818	return -EINVAL;
819	}
820
821	tleft = bnxt_qplib_rcfw_block_for_resp(rcfw, le16_to_cpu(req.cookie));
822	if (!tleft) {
823	dev_err(&res->pdev->dev, "QPLIB: SP: MAP_TC2COS timed out");
824	return -ETIMEDOUT;
825	}
826
827	if (resp->status \|\|
828	le16_to_cpu(resp->cookie) != le16_to_cpu(req.cookie)) {
829	dev_err(&res->pdev->dev, "QPLIB: SP: MAP_TC2COS failed ");
830	dev_err(&res->pdev->dev,
831	"QPLIB: with status 0x%x cmdq 0x%x resp 0x%x",
832	resp->status, le16_to_cpu(req.cookie),
833	le16_to_cpu(resp->cookie));
834	return -EINVAL;
835	}
836
837	return 0;	670	return 0;
838	}	671	}

drivers/infiniband/hw/bnxt_re/qplib_sp.h+2−0

@@ -40,6 +40,8 @@ · 39 unmodified lines
40	#ifndef __BNXT_QPLIB_SP_H__	40	#ifndef __BNXT_QPLIB_SP_H__
41	#define __BNXT_QPLIB_SP_H__	41	#define __BNXT_QPLIB_SP_H__
42		42
		43	#define BNXT_QPLIB_RESERVED_QP_WRS 128
		44
43	struct bnxt_qplib_dev_attr {	45	struct bnxt_qplib_dev_attr {
44	char fw_ver[32];	46	char fw_ver[32];
45	u16 max_sgid;	47	u16 max_sgid;

drivers/infiniband/hw/cxgb4/device.c+7−3

 		kfree(entry);
 	}
-	list_for_each_safe(pos, nxt, &uctx->qpids) {
+	list_for_each_safe(pos, nxt, &uctx->cqids) {
 		entry = list_entry(pos, struct c4iw_qid_list, entry);
 		list_del_init(&entry->entry);
 		kfree(entry);
 	rdev->free_workq = create_singlethread_workqueue("iw_cxgb4_free");
 	if (!rdev->free_workq) {
 		err = -ENOMEM;
-		goto err_free_status_page;
+		goto err_free_status_page_and_wr_log;
 	}
 	rdev->status_page->db_off = 0;
 	return 0;
-err_free_status_page:
+err_free_status_page_and_wr_log:
+	if (c4iw_wr_log && rdev->wr_log)
+		kfree(rdev->wr_log);
 	free_page((unsigned long)rdev->status_page);
 destroy_ocqp_pool:
 	c4iw_ocqp_pool_destroy(rdev);
 {
 	destroy_workqueue(rdev->free_workq);
 	kfree(rdev->wr_log);
+	c4iw_release_dev_ucontext(rdev, &rdev->uctx);
 	free_page((unsigned long)rdev->status_page);
 	c4iw_pblpool_destroy(rdev);
 	c4iw_rqtpool_destroy(rdev);
+	c4iw_ocqp_pool_destroy(rdev);
 	c4iw_destroy_resource(&rdev->resource);
 }

drivers/infiniband/hw/mlx5/main.c+4−2

 	dev->ib_dev.check_mr_status	= mlx5_ib_check_mr_status;
 	dev->ib_dev.get_port_immutable  = mlx5_port_immutable;
 	dev->ib_dev.get_dev_fw_str      = get_dev_fw_str;
-	dev->ib_dev.alloc_rdma_netdev	= mlx5_ib_alloc_rdma_netdev;
+	if (MLX5_CAP_GEN(mdev, ipoib_enhanced_offloads)) {
-	dev->ib_dev.free_rdma_netdev	= mlx5_ib_free_rdma_netdev;
+		dev->ib_dev.alloc_rdma_netdev	= mlx5_ib_alloc_rdma_netdev;
+		dev->ib_dev.free_rdma_netdev	= mlx5_ib_free_rdma_netdev;
+	}
 	if (mlx5_core_is_pf(mdev)) {
 		dev->ib_dev.get_vf_config	= mlx5_ib_get_vf_config;
 		dev->ib_dev.set_vf_link_state	= mlx5_ib_set_vf_link_state;

drivers/infiniband/hw/qedr/qedr.h+4−1

@@ -58,7 +58,10 @@ · 57 unmodified lines
58	#define QEDR_MSG_QP " QP"	58	#define QEDR_MSG_QP " QP"
59	#define QEDR_MSG_GSI " GSI"	59	#define QEDR_MSG_GSI " GSI"
60		60
61	#define QEDR_CQ_MAGIC_NUMBER (0x11223344)	61	#define QEDR_CQ_MAGIC_NUMBER (0x11223344)
		62
		63	#define FW_PAGE_SIZE (RDMA_RING_PAGE_SIZE)
		64	#define FW_PAGE_SHIFT (12)
62		65
63	struct qedr_dev;	66	struct qedr_dev;
64		67

drivers/infiniband/hw/qedr/verbs.c+41−27

@@ -653,14 +653,15 @@ static int qedr_prepare_pbl_tbl(struct qedr_dev *dev, · 652 unmodified lines
653		653
654	static void qedr_populate_pbls(struct qedr_dev dev, struct ib_umem umem,	654	static void qedr_populate_pbls(struct qedr_dev dev, struct ib_umem umem,
655	struct qedr_pbl *pbl,	655	struct qedr_pbl *pbl,
656	struct qedr_pbl_info *pbl_info)	656	struct qedr_pbl_info *pbl_info, u32 pg_shift)
657	{	657	{
658	int shift, pg_cnt, pages, pbe_cnt, total_num_pbes = 0;	658	int shift, pg_cnt, pages, pbe_cnt, total_num_pbes = 0;
		659	u32 fw_pg_cnt, fw_pg_per_umem_pg;
659	struct qedr_pbl *pbl_tbl;	660	struct qedr_pbl *pbl_tbl;
660	struct scatterlist *sg;	661	struct scatterlist *sg;
661	struct regpair *pbe;	662	struct regpair *pbe;
		663	u64 pg_addr;
662	int entry;	664	int entry;
663	u32 addr;
664		665
665	if (!pbl_info->num_pbes)	666	if (!pbl_info->num_pbes)
666	return;	667	return;
@@ -683,29 +684,35 @@ static void qedr_populate_pbls(struct qedr_dev dev, struct ib_umem umem, · 16 unmodified lines
683		684
684	shift = umem->page_shift;	685	shift = umem->page_shift;
685		686
		687	fw_pg_per_umem_pg = BIT(umem->page_shift - pg_shift);
		688
686	for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {	689	for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {
687	pages = sg_dma_len(sg) >> shift;	690	pages = sg_dma_len(sg) >> shift;
		691	pg_addr = sg_dma_address(sg);
688	for (pg_cnt = 0; pg_cnt < pages; pg_cnt++) {	692	for (pg_cnt = 0; pg_cnt < pages; pg_cnt++) {
689	/* store the page address in pbe */	693	for (fw_pg_cnt = 0; fw_pg_cnt < fw_pg_per_umem_pg;) {
690	pbe->lo = cpu_to_le32(sg_dma_address(sg) +	694	pbe->lo = cpu_to_le32(pg_addr);
691	(pg_cnt << shift));	695	pbe->hi = cpu_to_le32(upper_32_bits(pg_addr));
692	addr = upper_32_bits(sg_dma_address(sg) +	696
693	(pg_cnt << shift));	697	pg_addr += BIT(pg_shift);
694	pbe->hi = cpu_to_le32(addr);	698	pbe_cnt++;
695	pbe_cnt++;	699	total_num_pbes++;
696	total_num_pbes++;	700	pbe++;
697	pbe++;	701
698		702	if (total_num_pbes == pbl_info->num_pbes)
699	if (total_num_pbes == pbl_info->num_pbes)	703	return;
700	return;	704
701		705	/* If the given pbl is full storing the pbes,
702	/* If the given pbl is full storing the pbes,	706	* move to next pbl.
703	* move to next pbl.	707	*/
704	*/	708	if (pbe_cnt ==
705	if (pbe_cnt == (pbl_info->pbl_size / sizeof(u64))) {	709	(pbl_info->pbl_size / sizeof(u64))) {
706	pbl_tbl++;	710	pbl_tbl++;
707	pbe = (struct regpair *)pbl_tbl->va;	711	pbe = (struct regpair *)pbl_tbl->va;
708	pbe_cnt = 0;	712	pbe_cnt = 0;
		713	}
		714
		715	fw_pg_cnt++;
709	}	716	}
710	}	717	}
711	}	718	}
@@ -754,7 +761,7 @@ static inline int qedr_init_user_queue(struct ib_ucontext *ib_ctx, · 42 unmodified lines
754	u64 buf_addr, size_t buf_len,	761	u64 buf_addr, size_t buf_len,
755	int access, int dmasync)	762	int access, int dmasync)
756	{	763	{
757	int page_cnt;	764	u32 fw_pages;
758	int rc;	765	int rc;
759		766
760	q->buf_addr = buf_addr;	767	q->buf_addr = buf_addr;
@@ -766,8 +773,10 @@ static inline int qedr_init_user_queue(struct ib_ucontext *ib_ctx, · 5 unmodified lines
766	return PTR_ERR(q->umem);	773	return PTR_ERR(q->umem);
767	}	774	}
768		775
769	page_cnt = ib_umem_page_count(q->umem);	776	fw_pages = ib_umem_page_count(q->umem) <<
770	rc = qedr_prepare_pbl_tbl(dev, &q->pbl_info, page_cnt, 0);	777	(q->umem->page_shift - FW_PAGE_SHIFT);
		778
		779	rc = qedr_prepare_pbl_tbl(dev, &q->pbl_info, fw_pages, 0);
771	if (rc)	780	if (rc)
772	goto err0;	781	goto err0;
773		782
@@ -777,7 +786,8 @@ static inline int qedr_init_user_queue(struct ib_ucontext *ib_ctx, · 3 unmodified lines
777	goto err0;	786	goto err0;
778	}	787	}
779		788
780	qedr_populate_pbls(dev, q->umem, q->pbl_tbl, &q->pbl_info);	789	qedr_populate_pbls(dev, q->umem, q->pbl_tbl, &q->pbl_info,
		790	FW_PAGE_SHIFT);
781		791
782	return 0;	792	return 0;
783		793
@@ -2226,7 +2236,7 @@ struct ib_mr qedr_reg_user_mr(struct ib_pd ibpd, u64 start, u64 len, · 1442 unmodified lines
2226	goto err1;	2236	goto err1;
2227		2237
2228	qedr_populate_pbls(dev, mr->umem, mr->info.pbl_table,	2238	qedr_populate_pbls(dev, mr->umem, mr->info.pbl_table,
2229	&mr->info.pbl_info);	2239	&mr->info.pbl_info, mr->umem->page_shift);
2230		2240
2231	rc = dev->ops->rdma_alloc_tid(dev->rdma_ctx, &mr->hw_mr.itid);	2241	rc = dev->ops->rdma_alloc_tid(dev->rdma_ctx, &mr->hw_mr.itid);
2232	if (rc) {	2242	if (rc) {
@@ -3209,6 +3219,10 @@ static int process_req(struct qedr_dev dev, struct qedr_qp qp, · 976 unmodified lines
3209	case IB_WC_REG_MR:	3219	case IB_WC_REG_MR:
3210	qp->wqe_wr_id[qp->sq.cons].mr->info.completed++;	3220	qp->wqe_wr_id[qp->sq.cons].mr->info.completed++;
3211	break;	3221	break;
		3222	case IB_WC_RDMA_READ:
		3223	case IB_WC_SEND:
		3224	wc->byte_len = qp->wqe_wr_id[qp->sq.cons].bytes_len;
		3225	break;
3212	default:	3226	default:
3213	break;	3227	break;
3214	}	3228	}

drivers/infiniband/sw/rxe/rxe.h+4−1

 static inline u32 rxe_crc32(struct rxe_dev *rxe,
 			    u32 crc, void *next, size_t len)
 {
+	u32 retval;
 	int err;
 	SHASH_DESC_ON_STACK(shash, rxe->tfm);
 		return crc32_le(crc, next, len);
 	}
-	return *(u32 *)shash_desc_ctx(shash);
+	retval = *(u32 *)shash_desc_ctx(shash);
+	barrier_data(shash_desc_ctx(shash));
+	return retval;
 }
 int rxe_set_mtu(struct rxe_dev *rxe, unsigned int dev_mtu);

drivers/infiniband/sw/rxe/rxe_verbs.c+2−7

 		sge = ibwr->sg_list;
 		for (i = 0; i < num_sge; i++, sge++) {
-			if (qp->is_user && copy_from_user(p, (__user void *)
+			memcpy(p, (void *)(uintptr_t)sge->addr,
-					    (uintptr_t)sge->addr, sge->length))
+					sge->length);
-				return -EFAULT;
-			else if (!qp->is_user)
-				memcpy(p, (void *)(uintptr_t)sge->addr,
-				       sge->length);
 			p += sge->length;
 		}

drivers/infiniband/ulp/ipoib/ipoib_ib.c+0−1

@@ -863,7 +863,6 @@ dev_stop: · 862 unmodified lines
863	set_bit(IPOIB_STOP_REAPER, &priv->flags);	863	set_bit(IPOIB_STOP_REAPER, &priv->flags);
864	cancel_delayed_work(&priv->ah_reap_task);	864	cancel_delayed_work(&priv->ah_reap_task);
865	set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags);	865	set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags);
866	napi_enable(&priv->napi);
867	ipoib_ib_dev_stop(dev);	866	ipoib_ib_dev_stop(dev);
868	return -1;	867	return -1;
869	}	868	}

drivers/infiniband/ulp/ipoib/ipoib_main.c+13−2

 	ipoib_transport_dev_cleanup(dev);
+	netif_napi_del(&priv->napi);
 	ipoib_cm_dev_cleanup(dev);
 	kfree(priv->rx_ring);
 	kfree(priv->rx_ring);
 out:
+	netif_napi_del(&priv->napi);
 	return -ENOMEM;
 }
 device_init_failed:
 	free_netdev(priv->dev);
+	kfree(priv);
 alloc_mem_failed:
 	return ERR_PTR(result);
 static void ipoib_remove_one(struct ib_device *device, void *client_data)
 {
-	struct ipoib_dev_priv *priv, *tmp;
+	struct ipoib_dev_priv *priv, *tmp, *cpriv, *tcpriv;
 	struct list_head *dev_list = client_data;
 	if (!dev_list)
 		flush_workqueue(priv->wq);
 		unregister_netdev(priv->dev);
-		free_netdev(priv->dev);
+		if (device->free_rdma_netdev)
+			device->free_rdma_netdev(priv->dev);
+		else
+			free_netdev(priv->dev);
+		list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list)
+			kfree(cpriv);
 		kfree(priv);
 	}

drivers/infiniband/ulp/ipoib/ipoib_vlan.c+7−4

 	snprintf(intf_name, sizeof intf_name, "%s.%04x",
 		 ppriv->dev->name, pkey);
+	if (!rtnl_trylock())
+		return restart_syscall();
 	priv = ipoib_intf_alloc(ppriv->ca, ppriv->port, intf_name);
 	if (!priv)
 		return -ENOMEM;
-	if (!rtnl_trylock())
-		return restart_syscall();
 	down_write(&ppriv->vlan_rwsem);
 	/*
 	rtnl_unlock();
-	if (result)
+	if (result) {
 		free_netdev(priv->dev);
+		kfree(priv);
+	}
 	return result;
 }
 	if (dev) {
 		free_netdev(dev);
+		kfree(priv);
 		return 0;
 	}

drivers/input/misc/soc_button_array.c+14−6

 	if (!btns_desc) {
 		dev_err(dev, "ACPI Button Descriptors not found\n");
-		return ERR_PTR(-ENODEV);
+		button_info = ERR_PTR(-ENODEV);
+		goto out;
 	}
 	/* The first package describes the collection */
 	}
 	if (collection_uid == -1) {
 		dev_err(dev, "Invalid Button Collection Descriptor\n");
-		return ERR_PTR(-ENODEV);
+		button_info = ERR_PTR(-ENODEV);
+		goto out;
 	}
 	/* There are package.count - 1 buttons + 1 terminating empty entry */
 	button_info = devm_kcalloc(dev, btns_desc->package.count,
 				   sizeof(*button_info), GFP_KERNEL);
-	if (!button_info)
+	if (!button_info) {
-		return ERR_PTR(-ENOMEM);
+		button_info = ERR_PTR(-ENOMEM);
+		goto out;
+	}
 	/* Parse the button descriptors */
 	for (i = 1, btn = 0; i < btns_desc->package.count; i++, btn++) {
 		if (soc_button_parse_btn_desc(dev,
 					      &btns_desc->package.elements[i],
 					      collection_uid,
-					      &button_info[btn]))
+					      &button_info[btn])) {
-			return ERR_PTR(-ENODEV);
+			button_info = ERR_PTR(-ENODEV);
+			goto out;
+		}
 	}
+out:
+	kfree(buf.pointer);
 	return button_info;
 }

drivers/input/rmi4/rmi_f54.c+7−10

 #define F54_GET_REPORT          1
 #define F54_FORCE_CAL           2
-/* Fixed sizes of reports */
-#define F54_QUERY_LEN			27
 /* F54 capabilities */
 #define F54_CAP_BASELINE	(1 << 2)
 #define F54_CAP_IMAGE8		(1 << 3)
 struct f54_data {
 	struct rmi_function *fn;
-	u8 qry[F54_QUERY_LEN];
 	u8 num_rx_electrodes;
 	u8 num_tx_electrodes;
 	u8 capabilities;
 {
 	int error;
 	struct f54_data *f54;
+	u8 buf[6];
 	f54 = dev_get_drvdata(&fn->dev);
 	error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
-			       &f54->qry, sizeof(f54->qry));
+			       buf, sizeof(buf));
 	if (error) {
 		dev_err(&fn->dev, "%s: Failed to query F54 properties\n",
 			__func__);
 		return error;
 	}
-	f54->num_rx_electrodes = f54->qry[0];
+	f54->num_rx_electrodes = buf[0];
-	f54->num_tx_electrodes = f54->qry[1];
+	f54->num_tx_electrodes = buf[1];
-	f54->capabilities = f54->qry[2];
+	f54->capabilities = buf[2];
-	f54->clock_rate = f54->qry[3] | (f54->qry[4] << 8);
+	f54->clock_rate = buf[3] | (buf[4] << 8);
-	f54->family = f54->qry[5];
+	f54->family = buf[5];
 	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 num_rx_electrodes: %d\n",
 		f54->num_rx_electrodes);

drivers/input/serio/i8042-x86ia64io.h+7−0

@@ -723,6 +723,13 @@ static const struct dmi_system_id __initconst i8042_dmi_notimeout_table[] = { · 722 unmodified lines
723	DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U574"),	723	DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U574"),
724	},	724	},
725	},	725	},
		726	{
		727	/* Fujitsu UH554 laptop */
		728	.matches = {
		729	DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
		730	DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK UH544"),
		731	},
		732	},
726	{ }	733	{ }
727	};	734	};
728		735

drivers/irqchip/irq-mips-gic.c+3−3

@@ -140,7 +140,7 @@ static inline void gic_map_to_vpe(unsigned int intr, unsigned int vpe) · 139 unmodified lines
140	}	140	}
141		141
142	#ifdef CONFIG_CLKSRC_MIPS_GIC	142	#ifdef CONFIG_CLKSRC_MIPS_GIC
143	u64 gic_read_count(void)	143	u64 notrace gic_read_count(void)
144	{	144	{
145	unsigned int hi, hi2, lo;	145	unsigned int hi, hi2, lo;
146		146
@@ -167,7 +167,7 @@ unsigned int gic_get_count_width(void) · 20 unmodified lines
167	return bits;	167	return bits;
168	}	168	}
169		169
170	void gic_write_compare(u64 cnt)	170	void notrace gic_write_compare(u64 cnt)
171	{	171	{
172	if (mips_cm_is64) {	172	if (mips_cm_is64) {
173	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE), cnt);	173	gic_write(GIC_REG(VPE_LOCAL, GIC_VPE_COMPARE), cnt);
@@ -179,7 +179,7 @@ void gic_write_compare(u64 cnt) · 5 unmodified lines
179	}	179	}
180	}	180	}
181		181
182	void gic_write_cpu_compare(u64 cnt, int cpu)	182	void notrace gic_write_cpu_compare(u64 cnt, int cpu)
183	{	183	{
184	unsigned long flags;	184	unsigned long flags;
185		185

drivers/irqchip/irq-xtensa-mx.c+1−1

@@ -142,7 +142,7 @@ static struct irq_chip xtensa_mx_irq_chip = { · 141 unmodified lines
142	int __init xtensa_mx_init_legacy(struct device_node *interrupt_parent)	142	int __init xtensa_mx_init_legacy(struct device_node *interrupt_parent)
143	{	143	{
144	struct irq_domain *root_domain =	144	struct irq_domain *root_domain =
145	irq_domain_add_legacy(NULL, NR_IRQS, 0, 0,	145	irq_domain_add_legacy(NULL, NR_IRQS - 1, 1, 0,
146	&xtensa_mx_irq_domain_ops,	146	&xtensa_mx_irq_domain_ops,
147	&xtensa_mx_irq_chip);	147	&xtensa_mx_irq_chip);
148	irq_set_default_host(root_domain);	148	irq_set_default_host(root_domain);

drivers/irqchip/irq-xtensa-pic.c+1−1

@@ -89,7 +89,7 @@ static struct irq_chip xtensa_irq_chip = { · 88 unmodified lines
89	int __init xtensa_pic_init_legacy(struct device_node *interrupt_parent)	89	int __init xtensa_pic_init_legacy(struct device_node *interrupt_parent)
90	{	90	{
91	struct irq_domain *root_domain =	91	struct irq_domain *root_domain =
92	irq_domain_add_legacy(NULL, NR_IRQS, 0, 0,	92	irq_domain_add_legacy(NULL, NR_IRQS - 1, 1, 0,
93	&xtensa_irq_domain_ops, &xtensa_irq_chip);	93	&xtensa_irq_domain_ops, &xtensa_irq_chip);
94	irq_set_default_host(root_domain);	94	irq_set_default_host(root_domain);
95	return 0;	95	return 0;

drivers/leds/leds-bcm6328.c+2−2

@@ -242,7 +242,7 @@ static int bcm6328_hwled(struct device dev, struct device_node nc, u32 reg, · 241 unmodified lines
242		242
243	spin_lock_irqsave(lock, flags);	243	spin_lock_irqsave(lock, flags);
244	val = bcm6328_led_read(addr);	244	val = bcm6328_led_read(addr);
245	val \|= (BIT(reg) << (((sel % 4) * 4) + 16));	245	val \|= (BIT(reg % 4) << (((sel % 4) * 4) + 16));
246	bcm6328_led_write(addr, val);	246	bcm6328_led_write(addr, val);
247	spin_unlock_irqrestore(lock, flags);	247	spin_unlock_irqrestore(lock, flags);
248	}	248	}
@@ -269,7 +269,7 @@ static int bcm6328_hwled(struct device dev, struct device_node nc, u32 reg, · 20 unmodified lines
269		269
270	spin_lock_irqsave(lock, flags);	270	spin_lock_irqsave(lock, flags);
271	val = bcm6328_led_read(addr);	271	val = bcm6328_led_read(addr);
272	val \|= (BIT(reg) << ((sel % 4) * 4));	272	val \|= (BIT(reg % 4) << ((sel % 4) * 4));
273	bcm6328_led_write(addr, val);	273	bcm6328_led_write(addr, val);
274	spin_unlock_irqrestore(lock, flags);	274	spin_unlock_irqrestore(lock, flags);
275	}	275	}

drivers/leds/trigger/ledtrig-heartbeat.c+0−31

@@ -20,7 +20,6 @@ · 19 unmodified lines
20	#include <linux/sched/loadavg.h>	20	#include <linux/sched/loadavg.h>
21	#include <linux/leds.h>	21	#include <linux/leds.h>
22	#include <linux/reboot.h>	22	#include <linux/reboot.h>
23	#include <linux/suspend.h>
24	#include "../leds.h"	23	#include "../leds.h"
25		24
26	static int panic_heartbeats;	25	static int panic_heartbeats;
@@ -163,30 +162,6 @@ static struct led_trigger heartbeat_led_trigger = { · 136 unmodified lines
163	.deactivate = heartbeat_trig_deactivate,	162	.deactivate = heartbeat_trig_deactivate,
164	};	163	};
165		164
166	static int heartbeat_pm_notifier(struct notifier_block *nb,
167	unsigned long pm_event, void *unused)
168	{
169	int rc;
170
171	switch (pm_event) {
172	case PM_SUSPEND_PREPARE:
173	case PM_HIBERNATION_PREPARE:
174	case PM_RESTORE_PREPARE:
175	led_trigger_unregister(&heartbeat_led_trigger);
176	break;
177	case PM_POST_SUSPEND:
178	case PM_POST_HIBERNATION:
179	case PM_POST_RESTORE:
180	rc = led_trigger_register(&heartbeat_led_trigger);
181	if (rc)
182	pr_err("could not re-register heartbeat trigger\n");
183	break;
184	default:
185	break;
186	}
187	return NOTIFY_DONE;
188	}
189
190	static int heartbeat_reboot_notifier(struct notifier_block *nb,	165	static int heartbeat_reboot_notifier(struct notifier_block *nb,
191	unsigned long code, void *unused)	166	unsigned long code, void *unused)
192	{	167	{
@@ -201,10 +176,6 @@ static int heartbeat_panic_notifier(struct notifier_block *nb, · 8 unmodified lines
201	return NOTIFY_DONE;	176	return NOTIFY_DONE;
202	}	177	}
203		178
204	static struct notifier_block heartbeat_pm_nb = {
205	.notifier_call = heartbeat_pm_notifier,
206	};
207
208	static struct notifier_block heartbeat_reboot_nb = {	179	static struct notifier_block heartbeat_reboot_nb = {
209	.notifier_call = heartbeat_reboot_notifier,	180	.notifier_call = heartbeat_reboot_notifier,
210	};	181	};
@@ -221,14 +192,12 @@ static int __init heartbeat_trig_init(void) · 10 unmodified lines
221	atomic_notifier_chain_register(&panic_notifier_list,	192	atomic_notifier_chain_register(&panic_notifier_list,
222	&heartbeat_panic_nb);	193	&heartbeat_panic_nb);
223	register_reboot_notifier(&heartbeat_reboot_nb);	194	register_reboot_notifier(&heartbeat_reboot_nb);
224	register_pm_notifier(&heartbeat_pm_nb);
225	}	195	}
226	return rc;	196	return rc;
227	}	197	}
228		198
229	static void __exit heartbeat_trig_exit(void)	199	static void __exit heartbeat_trig_exit(void)
230	{	200	{
231	unregister_pm_notifier(&heartbeat_pm_nb);
232	unregister_reboot_notifier(&heartbeat_reboot_nb);	201	unregister_reboot_notifier(&heartbeat_reboot_nb);
233	atomic_notifier_chain_unregister(&panic_notifier_list,	202	atomic_notifier_chain_unregister(&panic_notifier_list,
234	&heartbeat_panic_nb);	203	&heartbeat_panic_nb);

drivers/md/dm-integrity.c+10−2

 static void submit_flush_bio(struct dm_integrity_c *ic, struct dm_integrity_io *dio)
 {
 	struct bio *bio;
-	spin_lock_irq(&ic->endio_wait.lock);
+	unsigned long flags;
+	spin_lock_irqsave(&ic->endio_wait.lock, flags);
 	bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));
 	bio_list_add(&ic->flush_bio_list, bio);
-	spin_unlock_irq(&ic->endio_wait.lock);
+	spin_unlock_irqrestore(&ic->endio_wait.lock, flags);
 	queue_work(ic->commit_wq, &ic->commit_work);
 }
 		ti->error = "The device is too small";
 		goto bad;
 	}
+	if (ti->len > ic->provided_data_sectors) {
+		r = -EINVAL;
+		ti->error = "Not enough provided sectors for requested mapping size";
+		goto bad;
+	}
 	if (!buffer_sectors)
 		buffer_sectors = 1;

drivers/md/dm-io.c+2−2

@@ -317,8 +317,8 @@ static void do_region(int op, int op_flags, unsigned region, · 316 unmodified lines
317	else if (op == REQ_OP_WRITE_SAME)	317	else if (op == REQ_OP_WRITE_SAME)
318	special_cmd_max_sectors = q->limits.max_write_same_sectors;	318	special_cmd_max_sectors = q->limits.max_write_same_sectors;
319	if ((op == REQ_OP_DISCARD \|\| op == REQ_OP_WRITE_ZEROES \|\|	319	if ((op == REQ_OP_DISCARD \|\| op == REQ_OP_WRITE_ZEROES \|\|
320	op == REQ_OP_WRITE_SAME) &&	320	op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) {
321	special_cmd_max_sectors == 0) {	321	atomic_inc(&io->count);
322	dec_count(io, region, -EOPNOTSUPP);	322	dec_count(io, region, -EOPNOTSUPP);
323	return;	323	return;
324	}	324	}

drivers/md/dm-raid1.c+19−2

 struct dm_raid1_bio_record {
 	struct mirror *m;
+	/* if details->bi_bdev == NULL, details were not saved */
 	struct dm_bio_details details;
 	region_t write_region;
 };
 	struct dm_raid1_bio_record *bio_record =
 	  dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
+	bio_record->details.bi_bdev = NULL;
 	if (rw == WRITE) {
 		/* Save region for mirror_end_io() handler */
 		bio_record->write_region = dm_rh_bio_to_region(ms->rh, bio);
 	}
 	if (error == -EOPNOTSUPP)
-		return error;
+		goto out;
 	if ((error == -EWOULDBLOCK) && (bio->bi_opf & REQ_RAHEAD))
-		return error;
+		goto out;
 	if (unlikely(error)) {
+		if (!bio_record->details.bi_bdev) {
+			/*
+			 * There wasn't enough memory to record necessary
+			 * information for a retry or there was no other
+			 * mirror in-sync.
+			 */
+			DMERR_LIMIT("Mirror read failed.");
+			return -EIO;
+		}
 		m = bio_record->m;
 		DMERR("Mirror read failed from %s. Trying alternative device.",
 			bd = &bio_record->details;
 			dm_bio_restore(bd, bio);
+			bio_record->details.bi_bdev = NULL;
 			bio->bi_error = 0;
 			queue_bio(ms, bio, rw);
 		DMERR("All replicated volumes dead, failing I/O");
 	}
+out:
+	bio_record->details.bi_bdev = NULL;
 	return error;
 }

drivers/media/cec/Kconfig+1−0

@@ -1,5 +1,6 @@
1	config MEDIA_CEC_RC	1	config MEDIA_CEC_RC
2	bool "HDMI CEC RC integration"	2	bool "HDMI CEC RC integration"
3	depends on CEC_CORE && RC_CORE	3	depends on CEC_CORE && RC_CORE
		4	depends on CEC_CORE=m \|\| RC_CORE=y
4	---help---	5	---help---
5	Pass on CEC remote control messages to the RC framework.	6	Pass on CEC remote control messages to the RC framework.

drivers/media/cec/cec-api.c+1−7

 			bool block, struct cec_msg __user *parg)
 {
 	struct cec_msg msg = {};
-	long err = 0;
+	long err;
 	if (copy_from_user(&msg, parg, sizeof(msg)))
 		return -EFAULT;
-	mutex_lock(&adap->lock);
-	if (!adap->is_configured && fh->mode_follower < CEC_MODE_MONITOR)
-		err = -ENONET;
-	mutex_unlock(&adap->lock);
-	if (err)
-		return err;
 	err = cec_receive_msg(fh, &msg, block);
 	if (err)

drivers/media/i2c/tc358743.c+1−1

@@ -223,7 +223,7 @@ static void i2c_wr8(struct v4l2_subdev *sd, u16 reg, u8 val) · 222 unmodified lines
223	static void i2c_wr8_and_or(struct v4l2_subdev *sd, u16 reg,	223	static void i2c_wr8_and_or(struct v4l2_subdev *sd, u16 reg,
224	u8 mask, u8 val)	224	u8 mask, u8 val)
225	{	225	{
226	i2c_wrreg(sd, reg, (i2c_rdreg(sd, reg, 2) & mask) \| val, 2);	226	i2c_wrreg(sd, reg, (i2c_rdreg(sd, reg, 1) & mask) \| val, 1);
227	}	227	}
228		228
229	static u16 i2c_rd16(struct v4l2_subdev *sd, u16 reg)	229	static u16 i2c_rd16(struct v4l2_subdev *sd, u16 reg)

drivers/media/rc/sir_ir.c+6−0

 	static unsigned long delt;
 	unsigned long deltintr;
 	unsigned long flags;
+	int counter = 0;
 	int iir, lsr;
 	while ((iir = inb(io + UART_IIR) & UART_IIR_ID)) {
+		if (++counter > 256) {
+			dev_err(&sir_ir_dev->dev, "Trapped in interrupt");
+			break;
+		}
 		switch (iir & UART_IIR_ID) { /* FIXME toto treba preriedit */
 		case UART_IIR_MSI:
 			(void)inb(io + UART_MSR);

drivers/media/usb/rainshadow-cec/rainshadow-cec.c+1−0

@@ -336,6 +336,7 @@ static int rain_connect(struct serio serio, struct serio_driver drv) · 335 unmodified lines
336	serio_set_drvdata(serio, rain);	336	serio_set_drvdata(serio, rain);
337	INIT_WORK(&rain->work, rain_irq_work_handler);	337	INIT_WORK(&rain->work, rain_irq_work_handler);
338	mutex_init(&rain->write_lock);	338	mutex_init(&rain->write_lock);
		339	spin_lock_init(&rain->buf_lock);
339		340
340	err = serio_open(serio, drv);	341	err = serio_open(serio, drv);
341	if (err)	342	if (err)

drivers/media/v4l2-core/videobuf2-core.c+1−1

@@ -868,7 +868,7 @@ EXPORT_SYMBOL_GPL(vb2_core_create_bufs); · 867 unmodified lines
868		868
869	void vb2_plane_vaddr(struct vb2_buffer vb, unsigned int plane_no)	869	void vb2_plane_vaddr(struct vb2_buffer vb, unsigned int plane_no)
870	{	870	{
871	if (plane_no > vb->num_planes \|\| !vb->planes[plane_no].mem_priv)	871	if (plane_no >= vb->num_planes \|\| !vb->planes[plane_no].mem_priv)
872	return NULL;	872	return NULL;
873		873
874	return call_ptr_memop(vb, vaddr, vb->planes[plane_no].mem_priv);	874	return call_ptr_memop(vb, vaddr, vb->planes[plane_no].mem_priv);

drivers/mfd/arizona-core.c+1−2

@@ -245,8 +245,7 @@ static int arizona_poll_reg(struct arizona *arizona, · 244 unmodified lines
245	int ret;	245	int ret;
246		246
247	ret = regmap_read_poll_timeout(arizona->regmap,	247	ret = regmap_read_poll_timeout(arizona->regmap,
248	ARIZONA_INTERRUPT_RAW_STATUS_5, val,	248	reg, val, ((val & mask) == target),
249	((val & mask) == target),
250	ARIZONA_REG_POLL_DELAY_US,	249	ARIZONA_REG_POLL_DELAY_US,
251	timeout_ms * 1000);	250	timeout_ms * 1000);
252	if (ret)	251	if (ret)

drivers/mmc/host/meson-gx-mmc.c+9−0

@@ -210,6 +210,15 @@ static void meson_mmc_get_transfer_mode(struct mmc_host *mmc, · 209 unmodified lines
210	int i;	210	int i;
211	bool use_desc_chain_mode = true;	211	bool use_desc_chain_mode = true;
212		212
		213	/*
		214	* Broken SDIO with AP6255-based WiFi on Khadas VIM Pro has been
		215	* reported. For some strange reason this occurs in descriptor
		216	* chain mode only. So let's fall back to bounce buffer mode
		217	* for command SD_IO_RW_EXTENDED.
		218	*/
		219	if (mrq->cmd->opcode == SD_IO_RW_EXTENDED)
		220	return;
		221
213	for_each_sg(data->sg, sg, data->sg_len, i)	222	for_each_sg(data->sg, sg, data->sg_len, i)
214	/* check for 8 byte alignment */	223	/* check for 8 byte alignment */
215	if (sg->offset & 7) {	224	if (sg->offset & 7) {

drivers/net/bonding/bond_3ad.c+27−0

 	AD_LINK_SPEED_100MBPS,
 	AD_LINK_SPEED_1000MBPS,
 	AD_LINK_SPEED_2500MBPS,
+	AD_LINK_SPEED_5000MBPS,
 	AD_LINK_SPEED_10000MBPS,
+	AD_LINK_SPEED_14000MBPS,
 	AD_LINK_SPEED_20000MBPS,
 	AD_LINK_SPEED_25000MBPS,
 	AD_LINK_SPEED_40000MBPS,
+	AD_LINK_SPEED_50000MBPS,
 	AD_LINK_SPEED_56000MBPS,
 	AD_LINK_SPEED_100000MBPS,
 };
  *     %AD_LINK_SPEED_100MBPS,
  *     %AD_LINK_SPEED_1000MBPS,
  *     %AD_LINK_SPEED_2500MBPS,
+ *     %AD_LINK_SPEED_5000MBPS,
  *     %AD_LINK_SPEED_10000MBPS
+ *     %AD_LINK_SPEED_14000MBPS,
  *     %AD_LINK_SPEED_20000MBPS
  *     %AD_LINK_SPEED_25000MBPS
  *     %AD_LINK_SPEED_40000MBPS
+ *     %AD_LINK_SPEED_50000MBPS
  *     %AD_LINK_SPEED_56000MBPS
  *     %AD_LINK_SPEED_100000MBPS
  */
 			speed = AD_LINK_SPEED_2500MBPS;
 			break;
+		case SPEED_5000:
+			speed = AD_LINK_SPEED_5000MBPS;
+			break;
 		case SPEED_10000:
 			speed = AD_LINK_SPEED_10000MBPS;
 			break;
+		case SPEED_14000:
+			speed = AD_LINK_SPEED_14000MBPS;
+			break;
 		case SPEED_20000:
 			speed = AD_LINK_SPEED_20000MBPS;
 			break;
 			speed = AD_LINK_SPEED_40000MBPS;
 			break;
+		case SPEED_50000:
+			speed = AD_LINK_SPEED_50000MBPS;
+			break;
 		case SPEED_56000:
 			speed = AD_LINK_SPEED_56000MBPS;
 			break;
 		case AD_LINK_SPEED_2500MBPS:
 			bandwidth = nports * 2500;
 			break;
+		case AD_LINK_SPEED_5000MBPS:
+			bandwidth = nports * 5000;
+			break;
 		case AD_LINK_SPEED_10000MBPS:
 			bandwidth = nports * 10000;
 			break;
+		case AD_LINK_SPEED_14000MBPS:
+			bandwidth = nports * 14000;
+			break;
 		case AD_LINK_SPEED_20000MBPS:
 			bandwidth = nports * 20000;
 			break;
 		case AD_LINK_SPEED_40000MBPS:
 			bandwidth = nports * 40000;
 			break;
+		case AD_LINK_SPEED_50000MBPS:
+			bandwidth = nports * 50000;
+			break;
 		case AD_LINK_SPEED_56000MBPS:
 			bandwidth = nports * 56000;
 			break;

drivers/net/bonding/bond_main.c+3−3

 	struct bonding *bond = netdev_priv(bond_dev);
 	if (bond->wq)
 		destroy_workqueue(bond->wq);
-	free_netdev(bond_dev);
 }
 void bond_setup(struct net_device *bond_dev)
 	bond_dev->netdev_ops = &bond_netdev_ops;
 	bond_dev->ethtool_ops = &bond_ethtool_ops;
-	bond_dev->destructor = bond_destructor;
+	bond_dev->needs_free_netdev = true;
+	bond_dev->priv_destructor = bond_destructor;
 	SET_NETDEV_DEVTYPE(bond_dev, &bond_type);
 	rtnl_unlock();
 	if (res < 0)
-		bond_destructor(bond_dev);
+		free_netdev(bond_dev);
 	return res;
 }

drivers/net/caif/caif_hsi.c+1−1

@@ -1121,7 +1121,7 @@ static void cfhsi_setup(struct net_device *dev) · 1120 unmodified lines
1121	dev->flags = IFF_POINTOPOINT \| IFF_NOARP;	1121	dev->flags = IFF_POINTOPOINT \| IFF_NOARP;
1122	dev->mtu = CFHSI_MAX_CAIF_FRAME_SZ;	1122	dev->mtu = CFHSI_MAX_CAIF_FRAME_SZ;
1123	dev->priv_flags \|= IFF_NO_QUEUE;	1123	dev->priv_flags \|= IFF_NO_QUEUE;
1124	dev->destructor = free_netdev;	1124	dev->needs_free_netdev = true;
1125	dev->netdev_ops = &cfhsi_netdevops;	1125	dev->netdev_ops = &cfhsi_netdevops;
1126	for (i = 0; i < CFHSI_PRIO_LAST; ++i)	1126	for (i = 0; i < CFHSI_PRIO_LAST; ++i)
1127	skb_queue_head_init(&cfhsi->qhead[i]);	1127	skb_queue_head_init(&cfhsi->qhead[i]);

drivers/net/caif/caif_serial.c+1−1

@@ -428,7 +428,7 @@ static void caifdev_setup(struct net_device *dev) · 427 unmodified lines
428	dev->flags = IFF_POINTOPOINT \| IFF_NOARP;	428	dev->flags = IFF_POINTOPOINT \| IFF_NOARP;
429	dev->mtu = CAIF_MAX_MTU;	429	dev->mtu = CAIF_MAX_MTU;
430	dev->priv_flags \|= IFF_NO_QUEUE;	430	dev->priv_flags \|= IFF_NO_QUEUE;
431	dev->destructor = free_netdev;	431	dev->needs_free_netdev = true;
432	skb_queue_head_init(&serdev->head);	432	skb_queue_head_init(&serdev->head);
433	serdev->common.link_select = CAIF_LINK_LOW_LATENCY;	433	serdev->common.link_select = CAIF_LINK_LOW_LATENCY;
434	serdev->common.use_frag = true;	434	serdev->common.use_frag = true;

drivers/net/caif/caif_spi.c+1−1

@@ -712,7 +712,7 @@ static void cfspi_setup(struct net_device *dev) · 711 unmodified lines
712	dev->flags = IFF_NOARP \| IFF_POINTOPOINT;	712	dev->flags = IFF_NOARP \| IFF_POINTOPOINT;
713	dev->priv_flags \|= IFF_NO_QUEUE;	713	dev->priv_flags \|= IFF_NO_QUEUE;
714	dev->mtu = SPI_MAX_PAYLOAD_SIZE;	714	dev->mtu = SPI_MAX_PAYLOAD_SIZE;
715	dev->destructor = free_netdev;	715	dev->needs_free_netdev = true;
716	skb_queue_head_init(&cfspi->qhead);	716	skb_queue_head_init(&cfspi->qhead);
717	skb_queue_head_init(&cfspi->chead);	717	skb_queue_head_init(&cfspi->chead);
718	cfspi->cfdev.link_select = CAIF_LINK_HIGH_BANDW;	718	cfspi->cfdev.link_select = CAIF_LINK_HIGH_BANDW;

drivers/net/caif/caif_virtio.c+1−1

@@ -617,7 +617,7 @@ static void cfv_netdev_setup(struct net_device *netdev) · 616 unmodified lines
617	netdev->tx_queue_len = 100;	617	netdev->tx_queue_len = 100;
618	netdev->flags = IFF_POINTOPOINT \| IFF_NOARP;	618	netdev->flags = IFF_POINTOPOINT \| IFF_NOARP;
619	netdev->mtu = CFV_DEF_MTU_SIZE;	619	netdev->mtu = CFV_DEF_MTU_SIZE;
620	netdev->destructor = free_netdev;	620	netdev->needs_free_netdev = true;
621	}	621	}
622		622
623	/* Create debugfs counters for the device */	623	/* Create debugfs counters for the device */

drivers/net/can/dev.c+3−0

@@ -391,6 +391,9 @@ void can_change_state(struct net_device dev, struct can_frame cf, · 390 unmodified lines
391	can_update_state_error_stats(dev, new_state);	391	can_update_state_error_stats(dev, new_state);
392	priv->state = new_state;	392	priv->state = new_state;
393		393
		394	if (!cf)
		395	return;
		396
394	if (unlikely(new_state == CAN_STATE_BUS_OFF)) {	397	if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
395	cf->can_id \|= CAN_ERR_BUSOFF;	398	cf->can_id \|= CAN_ERR_BUSOFF;
396	return;	399	return;

drivers/net/can/peak_canfd/peak_canfd.c+1−1

@@ -489,7 +489,7 @@ int peak_canfd_handle_msgs_list(struct peak_canfd_priv *priv, · 488 unmodified lines
489	struct pucan_rx_msg *msg_list, int msg_count)	489	struct pucan_rx_msg *msg_list, int msg_count)
490	{	490	{
491	void *msg_ptr = msg_list;	491	void *msg_ptr = msg_list;
492	int i, msg_size;	492	int i, msg_size = 0;
493		493
494	for (i = 0; i < msg_count; i++) {	494	for (i = 0; i < msg_count; i++) {
495	msg_size = peak_canfd_handle_msg(priv, msg_ptr);	495	msg_size = peak_canfd_handle_msg(priv, msg_ptr);

drivers/net/can/slcan.c+3−4

@@ -417,7 +417,7 @@ static int slc_open(struct net_device *dev) · 416 unmodified lines
417	static void slc_free_netdev(struct net_device *dev)	417	static void slc_free_netdev(struct net_device *dev)
418	{	418	{
419	int i = dev->base_addr;	419	int i = dev->base_addr;
420	free_netdev(dev);	420
421	slcan_devs[i] = NULL;	421	slcan_devs[i] = NULL;
422	}	422	}
423		423
@@ -436,7 +436,8 @@ static const struct net_device_ops slc_netdev_ops = { · 12 unmodified lines
436	static void slc_setup(struct net_device *dev)	436	static void slc_setup(struct net_device *dev)
437	{	437	{
438	dev->netdev_ops = &slc_netdev_ops;	438	dev->netdev_ops = &slc_netdev_ops;
439	dev->destructor = slc_free_netdev;	439	dev->needs_free_netdev = true;
		440	dev->priv_destructor = slc_free_netdev;
440		441
441	dev->hard_header_len = 0;	442	dev->hard_header_len = 0;
442	dev->addr_len = 0;	443	dev->addr_len = 0;
@@ -761,8 +762,6 @@ static void __exit slcan_exit(void) · 318 unmodified lines
761	if (sl->tty) {	762	if (sl->tty) {
762	printk(KERN_ERR "%s: tty discipline still running\n",	763	printk(KERN_ERR "%s: tty discipline still running\n",
763	dev->name);	764	dev->name);
764	/* Intentionally leak the control block. */
765	dev->destructor = NULL;
766	}	765	}
767		766
768	unregister_netdev(dev);	767	unregister_netdev(dev);

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

@@ -265,6 +265,8 @@ static int gs_cmd_reset(struct gs_usb gsusb, struct gs_can gsdev) · 264 unmodified lines
265	sizeof(*dm),	265	sizeof(*dm),
266	1000);	266	1000);
267		267
		268	kfree(dm);
		269
268	return rc;	270	return rc;
269	}	271	}
270		272

drivers/net/can/usb/peak_usb/pcan_usb_core.c+1−3

 	const struct peak_usb_adapter *peak_usb_adapter = NULL;
 	int i, err = -ENOMEM;
-	usb_dev = interface_to_usbdev(intf);
 	/* get corresponding PCAN-USB adapter */
 	for (i = 0; i < ARRAY_SIZE(peak_usb_adapters_list); i++)
 		if (peak_usb_adapters_list[i]->device_id == usb_id_product) {
 	if (!peak_usb_adapter) {
 		/* should never come except device_id bad usage in this file */
 		pr_err("%s: didn't find device id. 0x%x in devices list\n",
-			PCAN_USB_DRIVER_NAME, usb_dev->descriptor.idProduct);
+			PCAN_USB_DRIVER_NAME, usb_id_product);
 		return -ENODEV;
 	}

drivers/net/can/vcan.c+2−2

@@ -152,7 +152,7 @@ static const struct net_device_ops vcan_netdev_ops = { · 151 unmodified lines
152	static void vcan_setup(struct net_device *dev)	152	static void vcan_setup(struct net_device *dev)
153	{	153	{
154	dev->type = ARPHRD_CAN;	154	dev->type = ARPHRD_CAN;
155	dev->mtu = CAN_MTU;	155	dev->mtu = CANFD_MTU;
156	dev->hard_header_len = 0;	156	dev->hard_header_len = 0;
157	dev->addr_len = 0;	157	dev->addr_len = 0;
158	dev->tx_queue_len = 0;	158	dev->tx_queue_len = 0;
@@ -163,7 +163,7 @@ static void vcan_setup(struct net_device *dev) · 4 unmodified lines
163	dev->flags \|= IFF_ECHO;	163	dev->flags \|= IFF_ECHO;
164		164
165	dev->netdev_ops = &vcan_netdev_ops;	165	dev->netdev_ops = &vcan_netdev_ops;
166	dev->destructor = free_netdev;	166	dev->needs_free_netdev = true;
167	}	167	}
168		168
169	static struct rtnl_link_ops vcan_link_ops __read_mostly = {	169	static struct rtnl_link_ops vcan_link_ops __read_mostly = {

drivers/net/can/vxcan.c+2−2

@@ -150,13 +150,13 @@ static const struct net_device_ops vxcan_netdev_ops = { · 149 unmodified lines
150	static void vxcan_setup(struct net_device *dev)	150	static void vxcan_setup(struct net_device *dev)
151	{	151	{
152	dev->type = ARPHRD_CAN;	152	dev->type = ARPHRD_CAN;
153	dev->mtu = CAN_MTU;	153	dev->mtu = CANFD_MTU;
154	dev->hard_header_len = 0;	154	dev->hard_header_len = 0;
155	dev->addr_len = 0;	155	dev->addr_len = 0;
156	dev->tx_queue_len = 0;	156	dev->tx_queue_len = 0;
157	dev->flags = (IFF_NOARP\|IFF_ECHO);	157	dev->flags = (IFF_NOARP\|IFF_ECHO);
158	dev->netdev_ops = &vxcan_netdev_ops;	158	dev->netdev_ops = &vxcan_netdev_ops;
159	dev->destructor = free_netdev;	159	dev->needs_free_netdev = true;
160	}	160	}
161		161
162	/* forward declaration for rtnl_create_link() */	162	/* forward declaration for rtnl_create_link() */

drivers/net/dummy.c+2−2

 	struct dummy_priv *priv = netdev_priv(dev);
 	kfree(priv->vfinfo);
-	free_netdev(dev);
 }
 static void dummy_setup(struct net_device *dev)
 	/* Initialize the device structure. */
 	dev->netdev_ops = &dummy_netdev_ops;
 	dev->ethtool_ops = &dummy_ethtool_ops;
-	dev->destructor = dummy_free_netdev;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = dummy_free_netdev;
 	/* Fill in device structure with ethernet-generic values. */
 	dev->flags |= IFF_NOARP;

drivers/net/ethernet/amazon/ena/ena_com.c+21−14

 #define ENA_MMIO_READ_TIMEOUT 0xFFFFFFFF
+#define ENA_REGS_ADMIN_INTR_MASK 1
 /*****************************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
 	tail_masked = admin_queue->sq.tail & queue_size_mask;
 	/* In case of queue FULL */
-	cnt = admin_queue->sq.tail - admin_queue->sq.head;
+	cnt = atomic_read(&admin_queue->outstanding_cmds);
 	if (cnt >= admin_queue->q_depth) {
-		pr_debug("admin queue is FULL (tail %d head %d depth: %d)\n",
+		pr_debug("admin queue is full.\n");
-			 admin_queue->sq.tail, admin_queue->sq.head,
-			 admin_queue->q_depth);
 		admin_queue->stats.out_of_space++;
 		return ERR_PTR(-ENOSPC);
 	}
 static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_ctx,
 						     struct ena_com_admin_queue *admin_queue)
 {
-	unsigned long flags;
+	unsigned long flags, timeout;
-	u32 start_time;
 	int ret;
-	start_time = ((u32)jiffies_to_usecs(jiffies));
+	timeout = jiffies + ADMIN_CMD_TIMEOUT_US;
+	while (1) {
+		spin_lock_irqsave(&admin_queue->q_lock, flags);
+		ena_com_handle_admin_completion(admin_queue);
+		spin_unlock_irqrestore(&admin_queue->q_lock, flags);
+		if (comp_ctx->status != ENA_CMD_SUBMITTED)
+			break;
-	while (comp_ctx->status == ENA_CMD_SUBMITTED) {
+		if (time_is_before_jiffies(timeout)) {
-		if ((((u32)jiffies_to_usecs(jiffies)) - start_time) >
-		    ADMIN_CMD_TIMEOUT_US) {
 			pr_err("Wait for completion (polling) timeout\n");
 			/* ENA didn't have any completion */
 			spin_lock_irqsave(&admin_queue->q_lock, flags);
 			goto err;
 		}
-		spin_lock_irqsave(&admin_queue->q_lock, flags);
-		ena_com_handle_admin_completion(admin_queue);
-		spin_unlock_irqrestore(&admin_queue->q_lock, flags);
 		msleep(100);
 	}
 void ena_com_set_admin_polling_mode(struct ena_com_dev *ena_dev, bool polling)
 {
+	u32 mask_value = 0;
+	if (polling)
+		mask_value = ENA_REGS_ADMIN_INTR_MASK;
+	writel(mask_value, ena_dev->reg_bar + ENA_REGS_INTR_MASK_OFF);
 	ena_dev->admin_queue.polling = polling;
 }

drivers/net/ethernet/amazon/ena/ena_ethtool.c+1−1

 	ENA_STAT_TX_ENTRY(tx_poll),
 	ENA_STAT_TX_ENTRY(doorbells),
 	ENA_STAT_TX_ENTRY(prepare_ctx_err),
-	ENA_STAT_TX_ENTRY(missing_tx_comp),
 	ENA_STAT_TX_ENTRY(bad_req_id),
 };
 	ENA_STAT_RX_ENTRY(dma_mapping_err),
 	ENA_STAT_RX_ENTRY(bad_desc_num),
 	ENA_STAT_RX_ENTRY(rx_copybreak_pkt),
+	ENA_STAT_RX_ENTRY(empty_rx_ring),
 };
 static const struct ena_stats ena_stats_ena_com_strings[] = {

drivers/net/ethernet/amazon/ena/ena_netdev.c+132−47

 		rxr->sgl_size = adapter->max_rx_sgl_size;
 		rxr->smoothed_interval =
 			ena_com_get_nonadaptive_moderation_interval_rx(ena_dev);
+		rxr->empty_rx_queue = 0;
 	}
 }
 	rx_ring->per_napi_bytes = 0;
 }
+static inline void ena_unmask_interrupt(struct ena_ring *tx_ring,
+					struct ena_ring *rx_ring)
+{
+	struct ena_eth_io_intr_reg intr_reg;
+	/* Update intr register: rx intr delay,
+	 * tx intr delay and interrupt unmask
+	 */
+	ena_com_update_intr_reg(&intr_reg,
+				rx_ring->smoothed_interval,
+				tx_ring->smoothed_interval,
+				true);
+	/* It is a shared MSI-X.
+	 * Tx and Rx CQ have pointer to it.
+	 * So we use one of them to reach the intr reg
+	 */
+	ena_com_unmask_intr(rx_ring->ena_com_io_cq, &intr_reg);
+}
 static inline void ena_update_ring_numa_node(struct ena_ring *tx_ring,
 					     struct ena_ring *rx_ring)
 {
 {
 	struct ena_napi *ena_napi = container_of(napi, struct ena_napi, napi);
 	struct ena_ring *tx_ring, *rx_ring;
-	struct ena_eth_io_intr_reg intr_reg;
 	u32 tx_work_done;
 	u32 rx_work_done;
 			if (ena_com_get_adaptive_moderation_enabled(rx_ring->ena_dev))
 				ena_adjust_intr_moderation(rx_ring, tx_ring);
-			/* Update intr register: rx intr delay,
+			ena_unmask_interrupt(tx_ring, rx_ring);
-			 * tx intr delay and interrupt unmask
-			 */
-			ena_com_update_intr_reg(&intr_reg,
-						rx_ring->smoothed_interval,
-						tx_ring->smoothed_interval,
-						true);
-			/* It is a shared MSI-X.
-			 * Tx and Rx CQ have pointer to it.
-			 * So we use one of them to reach the intr reg
-			 */
-			ena_com_unmask_intr(rx_ring->ena_com_io_cq, &intr_reg);
 		}
 		ena_update_ring_numa_node(tx_ring, rx_ring);
 		ret = rx_work_done;
 	ena_napi_enable_all(adapter);
+	/* Enable completion queues interrupt */
+	for (i = 0; i < adapter->num_queues; i++)
+		ena_unmask_interrupt(&adapter->tx_ring[i],
+				     &adapter->rx_ring[i]);
 	/* schedule napi in case we had pending packets
 	 * from the last time we disable napi
 	 */
 			  "Failed to get TX queue handlers. TX queue num %d rc: %d\n",
 			  qid, rc);
 		ena_com_destroy_io_queue(ena_dev, ena_qid);
+		return rc;
 	}
 	ena_com_update_numa_node(tx_ring->ena_com_io_cq, ctx.numa_node);
 			  "Failed to get RX queue handlers. RX queue num %d rc: %d\n",
 			  qid, rc);
 		ena_com_destroy_io_queue(ena_dev, ena_qid);
+		return rc;
 	}
 	ena_com_update_numa_node(rx_ring->ena_com_io_cq, ctx.numa_node);
 	tx_info->tx_descs = nb_hw_desc;
 	tx_info->last_jiffies = jiffies;
+	tx_info->print_once = 0;
 	tx_ring->next_to_use = ENA_TX_RING_IDX_NEXT(next_to_use,
 		tx_ring->ring_size);
 		"Reset attempt failed. Can not reset the device\n");
 }
-static void check_for_missing_tx_completions(struct ena_adapter *adapter)
+static int check_missing_comp_in_queue(struct ena_adapter *adapter,
+				       struct ena_ring *tx_ring)
 {
 	struct ena_tx_buffer *tx_buf;
 	unsigned long last_jiffies;
+	u32 missed_tx = 0;
+	int i;
+	for (i = 0; i < tx_ring->ring_size; i++) {
+		tx_buf = &tx_ring->tx_buffer_info[i];
+		last_jiffies = tx_buf->last_jiffies;
+		if (unlikely(last_jiffies &&
+			     time_is_before_jiffies(last_jiffies + TX_TIMEOUT))) {
+			if (!tx_buf->print_once)
+				netif_notice(adapter, tx_err, adapter->netdev,
+					     "Found a Tx that wasn't completed on time, qid %d, index %d.\n",
+					     tx_ring->qid, i);
+			tx_buf->print_once = 1;
+			missed_tx++;
+			if (unlikely(missed_tx > MAX_NUM_OF_TIMEOUTED_PACKETS)) {
+				netif_err(adapter, tx_err, adapter->netdev,
+					  "The number of lost tx completions is above the threshold (%d > %d). Reset the device\n",
+					  missed_tx, MAX_NUM_OF_TIMEOUTED_PACKETS);
+				set_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags);
+				return -EIO;
+			}
+		}
+	}
+	return 0;
+}
+static void check_for_missing_tx_completions(struct ena_adapter *adapter)
+{
 	struct ena_ring *tx_ring;
-	int i, j, budget;
+	int i, budget, rc;
-	u32 missed_tx;
 	/* Make sure the driver doesn't turn the device in other process */
 	smp_rmb();
 	for (i = adapter->last_monitored_tx_qid; i < adapter->num_queues; i++) {
 		tx_ring = &adapter->tx_ring[i];
-		for (j = 0; j < tx_ring->ring_size; j++) {
+		rc = check_missing_comp_in_queue(adapter, tx_ring);
-			tx_buf = &tx_ring->tx_buffer_info[j];
+		if (unlikely(rc))
-			last_jiffies = tx_buf->last_jiffies;
+			return;
-			if (unlikely(last_jiffies && time_is_before_jiffies(last_jiffies + TX_TIMEOUT))) {
-				netif_notice(adapter, tx_err, adapter->netdev,
-					     "Found a Tx that wasn't completed on time, qid %d, index %d.\n",
-					     tx_ring->qid, j);
-				u64_stats_update_begin(&tx_ring->syncp);
-				missed_tx = tx_ring->tx_stats.missing_tx_comp++;
-				u64_stats_update_end(&tx_ring->syncp);
-				/* Clear last jiffies so the lost buffer won't
-				 * be counted twice.
-				 */
-				tx_buf->last_jiffies = 0;
-				if (unlikely(missed_tx > MAX_NUM_OF_TIMEOUTED_PACKETS)) {
-					netif_err(adapter, tx_err, adapter->netdev,
-						  "The number of lost tx completion is above the threshold (%d > %d). Reset the device\n",
-						  missed_tx, MAX_NUM_OF_TIMEOUTED_PACKETS);
-					set_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags);
-				}
-			}
-		}
 		budget--;
 		if (!budget)
 	adapter->last_monitored_tx_qid = i % adapter->num_queues;
 }
+/* trigger napi schedule after 2 consecutive detections */
+#define EMPTY_RX_REFILL 2
+/* For the rare case where the device runs out of Rx descriptors and the
+ * napi handler failed to refill new Rx descriptors (due to a lack of memory
+ * for example).
+ * This case will lead to a deadlock:
+ * The device won't send interrupts since all the new Rx packets will be dropped
+ * The napi handler won't allocate new Rx descriptors so the device will be
+ * able to send new packets.
+ *
+ * This scenario can happen when the kernel's vm.min_free_kbytes is too small.
+ * It is recommended to have at least 512MB, with a minimum of 128MB for
+ * constrained environment).
+ *
+ * When such a situation is detected - Reschedule napi
+ */
+static void check_for_empty_rx_ring(struct ena_adapter *adapter)
+{
+	struct ena_ring *rx_ring;
+	int i, refill_required;
+	if (!test_bit(ENA_FLAG_DEV_UP, &adapter->flags))
+		return;
+	if (test_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags))
+		return;
+	for (i = 0; i < adapter->num_queues; i++) {
+		rx_ring = &adapter->rx_ring[i];
+		refill_required =
+			ena_com_sq_empty_space(rx_ring->ena_com_io_sq);
+		if (unlikely(refill_required == (rx_ring->ring_size - 1))) {
+			rx_ring->empty_rx_queue++;
+			if (rx_ring->empty_rx_queue >= EMPTY_RX_REFILL) {
+				u64_stats_update_begin(&rx_ring->syncp);
+				rx_ring->rx_stats.empty_rx_ring++;
+				u64_stats_update_end(&rx_ring->syncp);
+				netif_err(adapter, drv, adapter->netdev,
+					  "trigger refill for ring %d\n", i);
+				napi_schedule(rx_ring->napi);
+				rx_ring->empty_rx_queue = 0;
+			}
+		} else {
+			rx_ring->empty_rx_queue = 0;
+		}
+	}
+}
 /* Check for keep alive expiration */
 static void check_for_missing_keep_alive(struct ena_adapter *adapter)
 {
 	check_for_missing_tx_completions(adapter);
+	check_for_empty_rx_ring(adapter);
 	if (debug_area)
 		ena_dump_stats_to_buf(adapter, debug_area);
 {
 	int release_bars;
+	if (ena_dev->mem_bar)
+		devm_iounmap(&pdev->dev, ena_dev->mem_bar);
+	devm_iounmap(&pdev->dev, ena_dev->reg_bar);
 	release_bars = pci_select_bars(pdev, IORESOURCE_MEM) & ENA_BAR_MASK;
 	pci_release_selected_regions(pdev, release_bars);
 }
 		goto err_free_ena_dev;
 	}
-	ena_dev->reg_bar = ioremap(pci_resource_start(pdev, ENA_REG_BAR),
+	ena_dev->reg_bar = devm_ioremap(&pdev->dev,
-				   pci_resource_len(pdev, ENA_REG_BAR));
+					pci_resource_start(pdev, ENA_REG_BAR),
+					pci_resource_len(pdev, ENA_REG_BAR));
 	if (!ena_dev->reg_bar) {
 		dev_err(&pdev->dev, "failed to remap regs bar\n");
 		rc = -EFAULT;
 	ena_set_push_mode(pdev, ena_dev, &get_feat_ctx);
 	if (ena_dev->tx_mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) {
-		ena_dev->mem_bar = ioremap_wc(pci_resource_start(pdev, ENA_MEM_BAR),
+		ena_dev->mem_bar = devm_ioremap_wc(&pdev->dev,
-					      pci_resource_len(pdev, ENA_MEM_BAR));
+						   pci_resource_start(pdev, ENA_MEM_BAR),
+						   pci_resource_len(pdev, ENA_MEM_BAR));
 		if (!ena_dev->mem_bar) {
 			rc = -EFAULT;
 			goto err_device_destroy;

drivers/net/ethernet/amazon/ena/ena_netdev.h+15−3

@@ -45,7 +45,7 @@ · 44 unmodified lines
45		45
46	#define DRV_MODULE_VER_MAJOR 1	46	#define DRV_MODULE_VER_MAJOR 1
47	#define DRV_MODULE_VER_MINOR 1	47	#define DRV_MODULE_VER_MINOR 1
48	#define DRV_MODULE_VER_SUBMINOR 2	48	#define DRV_MODULE_VER_SUBMINOR 7
49		49
50	#define DRV_MODULE_NAME "ena"	50	#define DRV_MODULE_NAME "ena"
51	#ifndef DRV_MODULE_VERSION	51	#ifndef DRV_MODULE_VERSION
@@ -146,7 +146,18 @@ struct ena_tx_buffer { · 94 unmodified lines
146	u32 tx_descs;	146	u32 tx_descs;
147	/* num of buffers used by this skb */	147	/* num of buffers used by this skb */
148	u32 num_of_bufs;	148	u32 num_of_bufs;
149	/* Save the last jiffies to detect missing tx packets */	149
		150	/* Used for detect missing tx packets to limit the number of prints */
		151	u32 print_once;
		152	/* Save the last jiffies to detect missing tx packets
		153	*
		154	* sets to non zero value on ena_start_xmit and set to zero on
		155	* napi and timer_Service_routine.
		156	*
		157	* while this value is not protected by lock,
		158	* a given packet is not expected to be handled by ena_start_xmit
		159	* and by napi/timer_service at the same time.
		160	*/
150	unsigned long last_jiffies;	161	unsigned long last_jiffies;
151	struct ena_com_buf bufs[ENA_PKT_MAX_BUFS];	162	struct ena_com_buf bufs[ENA_PKT_MAX_BUFS];
152	} ____cacheline_aligned;	163	} ____cacheline_aligned;
@@ -170,7 +181,6 @@ struct ena_stats_tx { · 17 unmodified lines
170	u64 napi_comp;	181	u64 napi_comp;
171	u64 tx_poll;	182	u64 tx_poll;
172	u64 doorbells;	183	u64 doorbells;
173	u64 missing_tx_comp;
174	u64 bad_req_id;	184	u64 bad_req_id;
175	};	185	};
176		186
@@ -184,6 +194,7 @@ struct ena_stats_rx { · 7 unmodified lines
184	u64 dma_mapping_err;	194	u64 dma_mapping_err;
185	u64 bad_desc_num;	195	u64 bad_desc_num;
186	u64 rx_copybreak_pkt;	196	u64 rx_copybreak_pkt;
		197	u64 empty_rx_ring;
187	};	198	};
188		199
189	struct ena_ring {	200	struct ena_ring {
@@ -231,6 +242,7 @@ struct ena_ring { · 41 unmodified lines
231	struct ena_stats_tx tx_stats;	242	struct ena_stats_tx tx_stats;
232	struct ena_stats_rx rx_stats;	243	struct ena_stats_rx rx_stats;
233	};	244	};
		245	int empty_rx_queue;
234	} ____cacheline_aligned;	246	} ____cacheline_aligned;
235		247
236	struct ena_stats_dev {	248	struct ena_stats_dev {

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.h+0−3

@@ -193,9 +193,6 @@ int hw_atl_utils_hw_get_regs(struct aq_hw_s *self, · 192 unmodified lines
193	struct aq_hw_caps_s *aq_hw_caps,	193	struct aq_hw_caps_s *aq_hw_caps,
194	u32 *regs_buff);	194	u32 *regs_buff);
195		195
196	int hw_atl_utils_hw_get_settings(struct aq_hw_s *self,
197	struct ethtool_cmd *cmd);
198
199	int hw_atl_utils_hw_set_power(struct aq_hw_s *self,	196	int hw_atl_utils_hw_set_power(struct aq_hw_s *self,
200	unsigned int power_state);	197	unsigned int power_state);
201		198

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c+15−4

 		/* when transmitting in a vf, start bd must hold the ethertype
 		 * for fw to enforce it
 		 */
+		u16 vlan_tci = 0;
 #ifndef BNX2X_STOP_ON_ERROR
-		if (IS_VF(bp))
+		if (IS_VF(bp)) {
 #endif
-			tx_start_bd->vlan_or_ethertype =
+			/* Still need to consider inband vlan for enforced */
-				cpu_to_le16(ntohs(eth->h_proto));
+			if (__vlan_get_tag(skb, &vlan_tci)) {
+				tx_start_bd->vlan_or_ethertype =
+					cpu_to_le16(ntohs(eth->h_proto));
+			} else {
+				tx_start_bd->bd_flags.as_bitfield |=
+					(X_ETH_INBAND_VLAN <<
+					 ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
+				tx_start_bd->vlan_or_ethertype =
+					cpu_to_le16(vlan_tci);
+			}
 #ifndef BNX2X_STOP_ON_ERROR
-		else
+		} else {
 			/* used by FW for packet accounting */
 			tx_start_bd->vlan_or_ethertype = cpu_to_le16(pkt_prod);
+		}
 #endif
 	}

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c+13−2

 	/* release VF resources */
 	bnx2x_vf_free_resc(bp, vf);
+	vf->malicious = false;
 	/* re-open the mailbox */
 	bnx2x_vf_enable_mbx(bp, vf->abs_vfid);
 	return;
 		   vf->abs_vfid, qidx);
 		bnx2x_vf_handle_rss_update_eqe(bp, vf);
 	case EVENT_RING_OPCODE_VF_FLR:
-	case EVENT_RING_OPCODE_MALICIOUS_VF:
 		/* Do nothing for now */
 		return 0;
+	case EVENT_RING_OPCODE_MALICIOUS_VF:
+		vf->malicious = true;
+		return 0;
 	}
 	return 0;
 			continue;
 		}
+		if (vf->malicious) {
+			DP_AND((BNX2X_MSG_IOV | BNX2X_MSG_STATS),
+			       "vf %d malicious so no stats for it\n",
+			       vf->abs_vfid);
+			continue;
+		}
 		DP_AND((BNX2X_MSG_IOV | BNX2X_MSG_STATS),
 		       "add addresses for vf %d\n", vf->abs_vfid);
 		for_each_vfq(vf, j) {
 {
 	BNX2X_PCI_FREE(bp->vf2pf_mbox, bp->vf2pf_mbox_mapping,
 		       sizeof(struct bnx2x_vf_mbx_msg));
-	BNX2X_PCI_FREE(bp->vf2pf_mbox, bp->pf2vf_bulletin_mapping,
+	BNX2X_PCI_FREE(bp->pf2vf_bulletin, bp->pf2vf_bulletin_mapping,
 		       sizeof(union pf_vf_bulletin));
 }

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h+1−0

@@ -141,6 +141,7 @@ struct bnx2x_virtf { · 140 unmodified lines
141	#define VF_RESET 3 /* VF FLR'd, pending cleanup */	141	#define VF_RESET 3 /* VF FLR'd, pending cleanup */
142		142
143	bool flr_clnup_stage; /* true during flr cleanup */	143	bool flr_clnup_stage; /* true during flr cleanup */
		144	bool malicious; /* true if FW indicated so, until FLR */
144		145
145	/* dma */	146	/* dma */
146	dma_addr_t fw_stat_map;	147	dma_addr_t fw_stat_map;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c+7−5

 {
 	int err;
+	mutex_lock(&uld_mutex);
 	err = setup_sge_queues(adap);
 	if (err)
-		goto out;
+		goto rel_lock;
 	err = setup_rss(adap);
 	if (err)
 		goto freeq;
 			goto irq_err;
 	}
-	mutex_lock(&uld_mutex);
 	enable_rx(adap);
 	t4_sge_start(adap);
 	t4_intr_enable(adap);
 #endif
 	/* Initialize hash mac addr list*/
 	INIT_LIST_HEAD(&adap->mac_hlist);
- out:
 	return err;
  irq_err:
 	dev_err(adap->pdev_dev, "request_irq failed, err %d\n", err);
  freeq:
 	t4_free_sge_resources(adap);
-	goto out;
+ rel_lock:
+	mutex_unlock(&uld_mutex);
+	return err;
 }
 static void cxgb_down(struct adapter *adapter)
 	/* Initialize the device structure. */
 	dev->netdev_ops = &cxgb4_mgmt_netdev_ops;
 	dev->ethtool_ops = &cxgb4_mgmt_ethtool_ops;
-	dev->destructor = free_netdev;
+	dev->needs_free_netdev = true;
 }
 static int config_mgmt_dev(struct pci_dev *pdev)

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c+1−1

@@ -2647,7 +2647,7 @@ static int dpaa_eth_probe(struct platform_device *pdev) · 2646 unmodified lines
2647	priv->buf_layout[TX].priv_data_size = DPAA_TX_PRIV_DATA_SIZE; /* Tx */	2647	priv->buf_layout[TX].priv_data_size = DPAA_TX_PRIV_DATA_SIZE; /* Tx */
2648		2648
2649	/* device used for DMA mapping */	2649	/* device used for DMA mapping */
2650	arch_setup_dma_ops(dev, 0, 0, NULL, false);	2650	set_dma_ops(dev, get_dma_ops(&pdev->dev));
2651	err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(40));	2651	err = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(40));
2652	if (err) {	2652	if (err) {
2653	dev_err(dev, "dma_coerce_mask_and_coherent() failed\n");	2653	dev_err(dev, "dma_coerce_mask_and_coherent() failed\n");

drivers/net/ethernet/freescale/fman/mac.c+2−0

@@ -623,6 +623,8 @@ static struct platform_device *dpaa_eth_add_device(int fman_id, · 622 unmodified lines
623	goto no_mem;	623	goto no_mem;
624	}	624	}
625		625
		626	set_dma_ops(&pdev->dev, get_dma_ops(priv->dev));
		627
626	ret = platform_device_add_data(pdev, &data, sizeof(data));	628	ret = platform_device_add_data(pdev, &data, sizeof(data));
627	if (ret)	629	if (ret)
628	goto err;	630	goto err;

drivers/net/ethernet/hisilicon/hns/hns_ethtool.c+14−2

 		/* Force 1000M Link, Default is 0x0200 */
 		phy_write(phy_dev, 7, 0x20C);
-		phy_write(phy_dev, HNS_PHY_PAGE_REG, 0);
-		/* Enable PHY loop-back */
+		/* Powerup Fiber */
+		phy_write(phy_dev, HNS_PHY_PAGE_REG, 1);
+		val = phy_read(phy_dev, COPPER_CONTROL_REG);
+		val &= ~PHY_POWER_DOWN;
+		phy_write(phy_dev, COPPER_CONTROL_REG, val);
+		/* Enable Phy Loopback */
+		phy_write(phy_dev, HNS_PHY_PAGE_REG, 0);
 		val = phy_read(phy_dev, COPPER_CONTROL_REG);
 		val |= PHY_LOOP_BACK;
 		val &= ~PHY_POWER_DOWN;
 		phy_write(phy_dev, HNS_PHY_PAGE_REG, 0xFA);
 		phy_write(phy_dev, 1, 0x400);
 		phy_write(phy_dev, 7, 0x200);
+		phy_write(phy_dev, HNS_PHY_PAGE_REG, 1);
+		val = phy_read(phy_dev, COPPER_CONTROL_REG);
+		val |= PHY_POWER_DOWN;
+		phy_write(phy_dev, COPPER_CONTROL_REG, val);
 		phy_write(phy_dev, HNS_PHY_PAGE_REG, 0);
 		phy_write(phy_dev, 9, 0xF00);

drivers/net/ethernet/ibm/emac/core.c+40−27

 {
 	struct emac_regs __iomem *p = dev->emacp;
 	int n = 20;
+	bool __maybe_unused try_internal_clock = false;
 	DBG(dev, "reset" NL);
 	}
 #ifdef CONFIG_PPC_DCR_NATIVE
+do_retry:
 	/*
 	 * PPC460EX/GT Embedded Processor Advanced User's Manual
 	 * section 28.10.1 Mode Register 0 (EMACx_MR0) states:
 	 * of the EMAC. If none is present, select the internal clock
 	 * (SDR0_ETH_CFG[EMACx_PHY_CLK] = 1).
 	 * After a soft reset, select the external clock.
+	 *
+	 * The AR8035-A PHY Meraki MR24 does not provide a TX Clk if the
+	 * ethernet cable is not attached. This causes the reset to timeout
+	 * and the PHY detection code in emac_init_phy() is unable to
+	 * communicate and detect the AR8035-A PHY. As a result, the emac
+	 * driver bails out early and the user has no ethernet.
+	 * In order to stay compatible with existing configurations, the
+	 * driver will temporarily switch to the internal clock, after
+	 * the first reset fails.
 	 */
 	if (emac_has_feature(dev, EMAC_FTR_460EX_PHY_CLK_FIX)) {
-		if (dev->phy_address == 0xffffffff &&
+		if (try_internal_clock || (dev->phy_address == 0xffffffff &&
-		    dev->phy_map == 0xffffffff) {
+					   dev->phy_map == 0xffffffff)) {
 			/* No PHY: select internal loop clock before reset */
 			dcri_clrset(SDR0, SDR0_ETH_CFG,
 				    0, SDR0_ETH_CFG_ECS << dev->cell_index);
 #ifdef CONFIG_PPC_DCR_NATIVE
 	if (emac_has_feature(dev, EMAC_FTR_460EX_PHY_CLK_FIX)) {
-		if (dev->phy_address == 0xffffffff &&
+		if (!n && !try_internal_clock) {
-		    dev->phy_map == 0xffffffff) {
+			/* first attempt has timed out. */
+			n = 20;
+			try_internal_clock = true;
+			goto do_retry;
+		}
+		if (try_internal_clock || (dev->phy_address == 0xffffffff &&
+					   dev->phy_map == 0xffffffff)) {
 			/* No PHY: restore external clock source after reset */
 			dcri_clrset(SDR0, SDR0_ETH_CFG,
 				    SDR0_ETH_CFG_ECS << dev->cell_index, 0);
 	return emac_reset(dev);
 }
+static int emac_mdio_phy_start_aneg(struct mii_phy *phy,
+				    struct phy_device *phy_dev)
+{
+	phy_dev->autoneg = phy->autoneg;
+	phy_dev->speed = phy->speed;
+	phy_dev->duplex = phy->duplex;
+	phy_dev->advertising = phy->advertising;
+	return phy_start_aneg(phy_dev);
+}
 static int emac_mdio_setup_aneg(struct mii_phy *phy, u32 advertise)
 {
 	struct net_device *ndev = phy->dev;
 	struct emac_instance *dev = netdev_priv(ndev);
-	dev->phy.autoneg = AUTONEG_ENABLE;
-	dev->phy.speed = SPEED_1000;
-	dev->phy.duplex = DUPLEX_FULL;
-	dev->phy.advertising = advertise;
 	phy->autoneg = AUTONEG_ENABLE;
-	phy->speed = dev->phy.speed;
-	phy->duplex = dev->phy.duplex;
 	phy->advertising = advertise;
-	return phy_start_aneg(dev->phy_dev);
+	return emac_mdio_phy_start_aneg(phy, dev->phy_dev);
 }
 static int emac_mdio_setup_forced(struct mii_phy *phy, int speed, int fd)
 	struct net_device *ndev = phy->dev;
 	struct emac_instance *dev = netdev_priv(ndev);
-	dev->phy.autoneg =  AUTONEG_DISABLE;
-	dev->phy.speed = speed;
-	dev->phy.duplex = fd;
 	phy->autoneg = AUTONEG_DISABLE;
 	phy->speed = speed;
 	phy->duplex = fd;
-	return phy_start_aneg(dev->phy_dev);
+	return emac_mdio_phy_start_aneg(phy, dev->phy_dev);
 }
 static int emac_mdio_poll_link(struct mii_phy *phy)
 {
 	struct net_device *ndev = phy->dev;
 	struct emac_instance *dev = netdev_priv(ndev);
+	struct phy_device *phy_dev = dev->phy_dev;
 	int res;
-	res = phy_read_status(dev->phy_dev);
+	res = phy_read_status(phy_dev);
 	if (res)
 		return res;
-	dev->phy.speed = phy->speed;
+	phy->speed = phy_dev->speed;
-	dev->phy.duplex = phy->duplex;
+	phy->duplex = phy_dev->duplex;
-	dev->phy.pause = phy->pause;
+	phy->pause = phy_dev->pause;
-	dev->phy.asym_pause = phy->asym_pause;
+	phy->asym_pause = phy_dev->asym_pause;
 	return 0;
 }
 	struct emac_instance *dev = netdev_priv(ndev);
 	phy_start(dev->phy_dev);
-	dev->phy.autoneg = phy->autoneg;
-	dev->phy.speed = phy->speed;
-	dev->phy.duplex = phy->duplex;
-	dev->phy.advertising = phy->advertising;
-	dev->phy.pause = phy->pause;
-	dev->phy.asym_pause = phy->asym_pause;
 	return phy_init_hw(dev->phy_dev);
 }

drivers/net/ethernet/ibm/ibmvnic.c+6−0

 }
 #endif
+static int ibmvnic_change_mtu(struct net_device *netdev, int new_mtu)
+{
+	return -EOPNOTSUPP;
+}
 static const struct net_device_ops ibmvnic_netdev_ops = {
 	.ndo_open		= ibmvnic_open,
 	.ndo_stop		= ibmvnic_close,
 #ifdef CONFIG_NET_POLL_CONTROLLER
 	.ndo_poll_controller	= ibmvnic_netpoll_controller,
 #endif
+	.ndo_change_mtu		= ibmvnic_change_mtu,
 };
 /* ethtool functions */

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

@@ -399,6 +399,7 @@ struct i40e_pf { · 398 unmodified lines
399	#define I40E_FLAG_RX_CSUM_ENABLED BIT_ULL(1)	399	#define I40E_FLAG_RX_CSUM_ENABLED BIT_ULL(1)
400	#define I40E_FLAG_MSI_ENABLED BIT_ULL(2)	400	#define I40E_FLAG_MSI_ENABLED BIT_ULL(2)
401	#define I40E_FLAG_MSIX_ENABLED BIT_ULL(3)	401	#define I40E_FLAG_MSIX_ENABLED BIT_ULL(3)
		402	#define I40E_FLAG_HW_ATR_EVICT_ENABLED BIT_ULL(4)
402	#define I40E_FLAG_RSS_ENABLED BIT_ULL(6)	403	#define I40E_FLAG_RSS_ENABLED BIT_ULL(6)
403	#define I40E_FLAG_VMDQ_ENABLED BIT_ULL(7)	404	#define I40E_FLAG_VMDQ_ENABLED BIT_ULL(7)
404	#define I40E_FLAG_IWARP_ENABLED BIT_ULL(10)	405	#define I40E_FLAG_IWARP_ENABLED BIT_ULL(10)

drivers/net/ethernet/intel/i40e/i40e_ethtool.c+2−2

@@ -224,7 +224,7 @@ static const struct i40e_priv_flags i40e_gstrings_priv_flags[] = { · 223 unmodified lines
224	I40E_PRIV_FLAG("LinkPolling", I40E_FLAG_LINK_POLLING_ENABLED, 0),	224	I40E_PRIV_FLAG("LinkPolling", I40E_FLAG_LINK_POLLING_ENABLED, 0),
225	I40E_PRIV_FLAG("flow-director-atr", I40E_FLAG_FD_ATR_ENABLED, 0),	225	I40E_PRIV_FLAG("flow-director-atr", I40E_FLAG_FD_ATR_ENABLED, 0),
226	I40E_PRIV_FLAG("veb-stats", I40E_FLAG_VEB_STATS_ENABLED, 0),	226	I40E_PRIV_FLAG("veb-stats", I40E_FLAG_VEB_STATS_ENABLED, 0),
227	I40E_PRIV_FLAG("hw-atr-eviction", I40E_FLAG_HW_ATR_EVICT_CAPABLE, 0),	227	I40E_PRIV_FLAG("hw-atr-eviction", I40E_FLAG_HW_ATR_EVICT_ENABLED, 0),
228	I40E_PRIV_FLAG("legacy-rx", I40E_FLAG_LEGACY_RX, 0),	228	I40E_PRIV_FLAG("legacy-rx", I40E_FLAG_LEGACY_RX, 0),
229	};	229	};
230		230
@@ -4092,7 +4092,7 @@ flags_complete: · 3861 unmodified lines
4092		4092
4093	/* Only allow ATR evict on hardware that is capable of handling it */	4093	/* Only allow ATR evict on hardware that is capable of handling it */
4094	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_CAPABLE)	4094	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_CAPABLE)
4095	pf->flags &= ~I40E_FLAG_HW_ATR_EVICT_CAPABLE;	4095	pf->flags &= ~I40E_FLAG_HW_ATR_EVICT_ENABLED;
4096		4096
4097	if (changed_flags & I40E_FLAG_TRUE_PROMISC_SUPPORT) {	4097	if (changed_flags & I40E_FLAG_TRUE_PROMISC_SUPPORT) {
4098	u16 sw_flags = 0, valid_flags = 0;	4098	u16 sw_flags = 0, valid_flags = 0;

drivers/net/ethernet/intel/i40e/i40e_main.c+4−3

 		    (pf->hw.aq.api_min_ver > 4))) {
 		/* Supported in FW API version higher than 1.4 */
 		pf->flags |= I40E_FLAG_GENEVE_OFFLOAD_CAPABLE;
-		pf->flags = I40E_FLAG_HW_ATR_EVICT_CAPABLE;
-	} else {
-		pf->flags = I40E_FLAG_HW_ATR_EVICT_CAPABLE;
 	}
+	/* Enable HW ATR eviction if possible */
+	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_CAPABLE)
+		pf->flags |= I40E_FLAG_HW_ATR_EVICT_ENABLED;
 	pf->eeprom_version = 0xDEAD;
 	pf->lan_veb = I40E_NO_VEB;
 	pf->lan_vsi = I40E_NO_VSI;

drivers/net/ethernet/intel/i40e/i40e_txrx.c+2−2

@@ -2341,7 +2341,7 @@ static void i40e_atr(struct i40e_ring tx_ring, struct sk_buff skb, · 2340 unmodified lines
2341	/* Due to lack of space, no more new filters can be programmed */	2341	/* Due to lack of space, no more new filters can be programmed */
2342	if (th->syn && (pf->flags & I40E_FLAG_FD_ATR_AUTO_DISABLED))	2342	if (th->syn && (pf->flags & I40E_FLAG_FD_ATR_AUTO_DISABLED))
2343	return;	2343	return;
2344	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_CAPABLE) {	2344	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_ENABLED) {
2345	/* HW ATR eviction will take care of removing filters on FIN	2345	/* HW ATR eviction will take care of removing filters on FIN
2346	* and RST packets.	2346	* and RST packets.
2347	*/	2347	*/
@@ -2403,7 +2403,7 @@ static void i40e_atr(struct i40e_ring tx_ring, struct sk_buff skb, · 55 unmodified lines
2403	I40E_TXD_FLTR_QW1_CNTINDEX_SHIFT) &	2403	I40E_TXD_FLTR_QW1_CNTINDEX_SHIFT) &
2404	I40E_TXD_FLTR_QW1_CNTINDEX_MASK;	2404	I40E_TXD_FLTR_QW1_CNTINDEX_MASK;
2405		2405
2406	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_CAPABLE)	2406	if (pf->flags & I40E_FLAG_HW_ATR_EVICT_ENABLED)
2407	dtype_cmd \|= I40E_TXD_FLTR_QW1_ATR_MASK;	2407	dtype_cmd \|= I40E_TXD_FLTR_QW1_ATR_MASK;
2408		2408
2409	fdir_desc->qindex_flex_ptype_vsi = cpu_to_le32(flex_ptype);	2409	fdir_desc->qindex_flex_ptype_vsi = cpu_to_le32(flex_ptype);

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c+2−0

 					   VLAN_VID_MASK));
 	}
+	spin_unlock_bh(&vsi->mac_filter_hash_lock);
 	if (vlan_id || qos)
 		ret = i40e_vsi_add_pvid(vsi, vlanprio);
 	else
 		i40e_vsi_remove_pvid(vsi);
+	spin_lock_bh(&vsi->mac_filter_hash_lock);
 	if (vlan_id) {
 		dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",

drivers/net/ethernet/marvell/mvpp2.c+33−43

 				    dma_addr_t *dma_addr,
 				    phys_addr_t *phys_addr)
 {
-	int cpu = smp_processor_id();
+	int cpu = get_cpu();
 	*dma_addr = mvpp2_percpu_read(priv, cpu,
 				      MVPP2_BM_PHY_ALLOC_REG(bm_pool->id));
 		if (sizeof(phys_addr_t) == 8)
 			*phys_addr |= (u64)phys_addr_highbits << 32;
 	}
+	put_cpu();
 }
 /* Free all buffers from the pool */
 	return bm;
 }
-/* Get pool number from a BM cookie */
-static inline int mvpp2_bm_cookie_pool_get(unsigned long cookie)
-{
-	return (cookie >> MVPP2_BM_COOKIE_POOL_OFFS) & 0xFF;
-}
 /* Release buffer to BM */
 static inline void mvpp2_bm_pool_put(struct mvpp2_port *port, int pool,
 				     dma_addr_t buf_dma_addr,
 				     phys_addr_t buf_phys_addr)
 {
-	int cpu = smp_processor_id();
+	int cpu = get_cpu();
 	if (port->priv->hw_version == MVPP22) {
 		u32 val = 0;
 			   MVPP2_BM_VIRT_RLS_REG, buf_phys_addr);
 	mvpp2_percpu_write(port->priv, cpu,
 			   MVPP2_BM_PHY_RLS_REG(pool), buf_dma_addr);
+	put_cpu();
 }
 /* Refill BM pool */
-static void mvpp2_pool_refill(struct mvpp2_port *port, u32 bm,
+static void mvpp2_pool_refill(struct mvpp2_port *port, int pool,
 			      dma_addr_t dma_addr,
 			      phys_addr_t phys_addr)
 {
-	int pool = mvpp2_bm_cookie_pool_get(bm);
 	mvpp2_bm_pool_put(port, pool, dma_addr, phys_addr);
 }
 {
 	u32 val;
-	return;
 	/* Only GOP port 0 has an XLG MAC */
 	if (port->gop_id == 0) {
 		val = readl(port->base + MVPP22_XLG_CTRL3_REG);
 	mvpp2_write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val);
 }
-/* Obtain BM cookie information from descriptor */
-static u32 mvpp2_bm_cookie_build(struct mvpp2_port *port,
-				 struct mvpp2_rx_desc *rx_desc)
-{
-	int cpu = smp_processor_id();
-	int pool;
-	pool = (mvpp2_rxdesc_status_get(port, rx_desc) &
-		MVPP2_RXD_BM_POOL_ID_MASK) >>
-		MVPP2_RXD_BM_POOL_ID_OFFS;
-	return ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS) |
-	       ((cpu & 0xFF) << MVPP2_BM_COOKIE_CPU_OFFS);
-}
 /* Tx descriptors helper methods */
 /* Get pointer to next Tx descriptor to be processed (send) by HW */
 static void mvpp2_rx_pkts_coal_set(struct mvpp2_port *port,
 				   struct mvpp2_rx_queue *rxq)
 {
-	int cpu = smp_processor_id();
+	int cpu = get_cpu();
 	if (rxq->pkts_coal > MVPP2_OCCUPIED_THRESH_MASK)
 		rxq->pkts_coal = MVPP2_OCCUPIED_THRESH_MASK;
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_NUM_REG, rxq->id);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_THRESH_REG,
 			   rxq->pkts_coal);
+	put_cpu();
 }
 static u32 mvpp2_usec_to_cycles(u32 usec, unsigned long clk_hz)
 	mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
 	/* Set Rx descriptors queue starting address - indirect access */
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_NUM_REG, rxq->id);
 	if (port->priv->hw_version == MVPP21)
 		rxq_dma = rxq->descs_dma;
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_DESC_ADDR_REG, rxq_dma);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_DESC_SIZE_REG, rxq->size);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_INDEX_REG, 0);
+	put_cpu();
 	/* Set Offset */
 	mvpp2_rxq_offset_set(port, rxq->id, NET_SKB_PAD);
 	for (i = 0; i < rx_received; i++) {
 		struct mvpp2_rx_desc *rx_desc = mvpp2_rxq_next_desc_get(rxq);
-		u32 bm = mvpp2_bm_cookie_build(port, rx_desc);
+		u32 status = mvpp2_rxdesc_status_get(port, rx_desc);
+		int pool;
+		pool = (status & MVPP2_RXD_BM_POOL_ID_MASK) >>
+			MVPP2_RXD_BM_POOL_ID_OFFS;
-		mvpp2_pool_refill(port, bm,
+		mvpp2_pool_refill(port, pool,
 				  mvpp2_rxdesc_dma_addr_get(port, rx_desc),
 				  mvpp2_rxdesc_cookie_get(port, rx_desc));
 	}
 	 * free descriptor number
 	 */
 	mvpp2_write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0);
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_NUM_REG, rxq->id);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_DESC_ADDR_REG, 0);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_RXQ_DESC_SIZE_REG, 0);
+	put_cpu();
 }
 /* Create and initialize a Tx queue */
 	txq->last_desc = txq->size - 1;
 	/* Set Tx descriptors queue starting address - indirect access */
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_NUM_REG, txq->id);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_DESC_ADDR_REG,
 			   txq->descs_dma);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_PREF_BUF_REG,
 			   MVPP2_PREF_BUF_PTR(desc) | MVPP2_PREF_BUF_SIZE_16 |
 			   MVPP2_PREF_BUF_THRESH(desc_per_txq / 2));
+	put_cpu();
 	/* WRR / EJP configuration - indirect access */
 	tx_port_num = mvpp2_egress_port(port);
 	mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0);
 	/* Set Tx descriptors queue starting address and size */
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_NUM_REG, txq->id);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_DESC_ADDR_REG, 0);
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_DESC_SIZE_REG, 0);
+	put_cpu();
 }
 /* Cleanup Tx ports */
 	int delay, pending, cpu;
 	u32 val;
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_NUM_REG, txq->id);
 	val = mvpp2_percpu_read(port->priv, cpu, MVPP2_TXQ_PREF_BUF_REG);
 	val |= MVPP2_TXQ_DRAIN_EN_MASK;
 	val &= ~MVPP2_TXQ_DRAIN_EN_MASK;
 	mvpp2_percpu_write(port->priv, cpu, MVPP2_TXQ_PREF_BUF_REG, val);
+	put_cpu();
 	for_each_present_cpu(cpu) {
 		txq_pcpu = per_cpu_ptr(txq->pcpu, cpu);
 /* Reuse skb if possible, or allocate a new skb and add it to BM pool */
 static int mvpp2_rx_refill(struct mvpp2_port *port,
-			   struct mvpp2_bm_pool *bm_pool, u32 bm)
+			   struct mvpp2_bm_pool *bm_pool, int pool)
 {
 	dma_addr_t dma_addr;
 	phys_addr_t phys_addr;
 	if (!buf)
 		return -ENOMEM;
-	mvpp2_pool_refill(port, bm, dma_addr, phys_addr);
+	mvpp2_pool_refill(port, pool, dma_addr, phys_addr);
 	return 0;
 }
 		unsigned int frag_size;
 		dma_addr_t dma_addr;
 		phys_addr_t phys_addr;
-		u32 bm, rx_status;
+		u32 rx_status;
 		int pool, rx_bytes, err;
 		void *data;
 		phys_addr = mvpp2_rxdesc_cookie_get(port, rx_desc);
 		data = (void *)phys_to_virt(phys_addr);
-		bm = mvpp2_bm_cookie_build(port, rx_desc);
+		pool = (rx_status & MVPP2_RXD_BM_POOL_ID_MASK) >>
-		pool = mvpp2_bm_cookie_pool_get(bm);
+			MVPP2_RXD_BM_POOL_ID_OFFS;
 		bm_pool = &port->priv->bm_pools[pool];
 		/* In case of an error, release the requested buffer pointer
 			dev->stats.rx_errors++;
 			mvpp2_rx_error(port, rx_desc);
 			/* Return the buffer to the pool */
-			mvpp2_pool_refill(port, bm, dma_addr, phys_addr);
+			mvpp2_pool_refill(port, pool, dma_addr, phys_addr);
 			continue;
 		}
 			goto err_drop_frame;
 		}
-		err = mvpp2_rx_refill(port, bm_pool, bm);
+		err = mvpp2_rx_refill(port, bm_pool, pool);
 		if (err) {
 			netdev_err(port->dev, "failed to refill BM pools\n");
 			goto err_drop_frame;

drivers/net/ethernet/mellanox/mlx5/core/en.h+5−3

 struct mlx5e_rx_am_stats {
 	int ppms; /* packets per msec */
+	int bpms; /* bytes per msec */
 	int epms; /* events per msec */
 };
 struct mlx5e_rx_am_sample {
-	ktime_t		time;
+	ktime_t	time;
-	unsigned int	pkt_ctr;
+	u32	pkt_ctr;
-	u16		event_ctr;
+	u32	byte_ctr;
+	u16	event_ctr;
 };
 struct mlx5e_rx_am { /* Adaptive Moderation */

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

@@ -1242,11 +1242,11 @@ static int mlx5e_get_ts_info(struct net_device *dev, · 1241 unmodified lines
1242	SOF_TIMESTAMPING_RX_HARDWARE \|	1242	SOF_TIMESTAMPING_RX_HARDWARE \|
1243	SOF_TIMESTAMPING_RAW_HARDWARE;	1243	SOF_TIMESTAMPING_RAW_HARDWARE;
1244		1244
1245	info->tx_types = (BIT(1) << HWTSTAMP_TX_OFF) \|	1245	info->tx_types = BIT(HWTSTAMP_TX_OFF) \|
1246	(BIT(1) << HWTSTAMP_TX_ON);	1246	BIT(HWTSTAMP_TX_ON);
1247		1247
1248	info->rx_filters = (BIT(1) << HWTSTAMP_FILTER_NONE) \|	1248	info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) \|
1249	(BIT(1) << HWTSTAMP_FILTER_ALL);	1249	BIT(HWTSTAMP_FILTER_ALL);
1250		1250
1251	return 0;	1251	return 0;
1252	}	1252	}

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

@@ -4241,7 +4241,8 @@ struct net_device mlx5e_create_netdev(struct mlx5_core_dev mdev, · 4240 unmodified lines
4241	return netdev;	4241	return netdev;
4242		4242
4243	err_cleanup_nic:	4243	err_cleanup_nic:
4244	profile->cleanup(priv);	4244	if (profile->cleanup)
		4245	profile->cleanup(priv);
4245	free_netdev(netdev);	4246	free_netdev(netdev);
4246		4247
4247	return NULL;	4248	return NULL;

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

@@ -791,6 +791,8 @@ static void mlx5e_build_rep_params(struct mlx5_core_dev *mdev, · 790 unmodified lines
791	params->tx_max_inline = mlx5e_get_max_inline_cap(mdev);	791	params->tx_max_inline = mlx5e_get_max_inline_cap(mdev);
792	params->num_tc = 1;	792	params->num_tc = 1;
793	params->lro_wqe_sz = MLX5E_PARAMS_DEFAULT_LRO_WQE_SZ;	793	params->lro_wqe_sz = MLX5E_PARAMS_DEFAULT_LRO_WQE_SZ;
		794
		795	mlx5_query_min_inline(mdev, &params->tx_min_inline_mode);
794	}	796	}
795		797
796	static void mlx5e_build_rep_netdev(struct net_device *netdev)	798	static void mlx5e_build_rep_netdev(struct net_device *netdev)

drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c+26−19

@@ -183,28 +183,27 @@ static void mlx5e_am_exit_parking(struct mlx5e_rx_am *am) · 182 unmodified lines
183	mlx5e_am_step(am);	183	mlx5e_am_step(am);
184	}	184	}
185		185
		186	#define IS_SIGNIFICANT_DIFF(val, ref) \
		187	(((100 * abs((val) - (ref))) / (ref)) > 10) /* more than 10% difference */
		188
186	static int mlx5e_am_stats_compare(struct mlx5e_rx_am_stats *curr,	189	static int mlx5e_am_stats_compare(struct mlx5e_rx_am_stats *curr,
187	struct mlx5e_rx_am_stats *prev)	190	struct mlx5e_rx_am_stats *prev)
188	{	191	{
189	int diff;	192	if (!prev->bpms)
190		193	return curr->bpms ? MLX5E_AM_STATS_BETTER :
191	if (!prev->ppms)
192	return curr->ppms ? MLX5E_AM_STATS_BETTER :
193	MLX5E_AM_STATS_SAME;	194	MLX5E_AM_STATS_SAME;
194		195
195	diff = curr->ppms - prev->ppms;	196	if (IS_SIGNIFICANT_DIFF(curr->bpms, prev->bpms))
196	if (((100 * abs(diff)) / prev->ppms) > 10) /* more than 10% diff */	197	return (curr->bpms > prev->bpms) ? MLX5E_AM_STATS_BETTER :
197	return (diff > 0) ? MLX5E_AM_STATS_BETTER :	198	MLX5E_AM_STATS_WORSE;
198	MLX5E_AM_STATS_WORSE;
199		199
200	if (!prev->epms)	200	if (IS_SIGNIFICANT_DIFF(curr->ppms, prev->ppms))
201	return curr->epms ? MLX5E_AM_STATS_WORSE :	201	return (curr->ppms > prev->ppms) ? MLX5E_AM_STATS_BETTER :
202	MLX5E_AM_STATS_SAME;	202	MLX5E_AM_STATS_WORSE;
203		203
204	diff = curr->epms - prev->epms;	204	if (IS_SIGNIFICANT_DIFF(curr->epms, prev->epms))
205	if (((100 * abs(diff)) / prev->epms) > 10) /* more than 10% diff */	205	return (curr->epms < prev->epms) ? MLX5E_AM_STATS_BETTER :
206	return (diff < 0) ? MLX5E_AM_STATS_BETTER :	206	MLX5E_AM_STATS_WORSE;
207	MLX5E_AM_STATS_WORSE;
208		207
209	return MLX5E_AM_STATS_SAME;	208	return MLX5E_AM_STATS_SAME;
210	}	209	}
@@ -266,10 +265,13 @@ static void mlx5e_am_sample(struct mlx5e_rq *rq, · 55 unmodified lines
266	{	265	{
267	s->time = ktime_get();	266	s->time = ktime_get();
268	s->pkt_ctr = rq->stats.packets;	267	s->pkt_ctr = rq->stats.packets;
		268	s->byte_ctr = rq->stats.bytes;
269	s->event_ctr = rq->cq.event_ctr;	269	s->event_ctr = rq->cq.event_ctr;
270	}	270	}
271		271
272	#define MLX5E_AM_NEVENTS 64	272	#define MLX5E_AM_NEVENTS 64
		273	#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
		274	#define BIT_GAP(bits, end, start) ((((end) - (start)) + BIT_ULL(bits)) & (BIT_ULL(bits) - 1))
273		275
274	static void mlx5e_am_calc_stats(struct mlx5e_rx_am_sample *start,	276	static void mlx5e_am_calc_stats(struct mlx5e_rx_am_sample *start,
275	struct mlx5e_rx_am_sample *end,	277	struct mlx5e_rx_am_sample *end,
@@ -277,13 +279,17 @@ static void mlx5e_am_calc_stats(struct mlx5e_rx_am_sample *start, · 1 unmodified line
277	{	279	{
278	/* u32 holds up to 71 minutes, should be enough */	280	/* u32 holds up to 71 minutes, should be enough */
279	u32 delta_us = ktime_us_delta(end->time, start->time);	281	u32 delta_us = ktime_us_delta(end->time, start->time);
280	unsigned int npkts = end->pkt_ctr - start->pkt_ctr;	282	u32 npkts = BIT_GAP(BITS_PER_TYPE(u32), end->pkt_ctr, start->pkt_ctr);
		283	u32 nbytes = BIT_GAP(BITS_PER_TYPE(u32), end->byte_ctr,
		284	start->byte_ctr);
281		285
282	if (!delta_us)	286	if (!delta_us)
283	return;	287	return;
284		288
285	curr_stats->ppms = (npkts * USEC_PER_MSEC) / delta_us;	289	curr_stats->ppms = DIV_ROUND_UP(npkts * USEC_PER_MSEC, delta_us);
286	curr_stats->epms = (MLX5E_AM_NEVENTS * USEC_PER_MSEC) / delta_us;	290	curr_stats->bpms = DIV_ROUND_UP(nbytes * USEC_PER_MSEC, delta_us);
		291	curr_stats->epms = DIV_ROUND_UP(MLX5E_AM_NEVENTS * USEC_PER_MSEC,
		292	delta_us);
287	}	293	}
288		294
289	void mlx5e_rx_am_work(struct work_struct *work)	295	void mlx5e_rx_am_work(struct work_struct *work)
@@ -308,7 +314,8 @@ void mlx5e_rx_am(struct mlx5e_rq *rq) · 18 unmodified lines
308		314
309	switch (am->state) {	315	switch (am->state) {
310	case MLX5E_AM_MEASURE_IN_PROGRESS:	316	case MLX5E_AM_MEASURE_IN_PROGRESS:
311	nevents = rq->cq.event_ctr - am->start_sample.event_ctr;	317	nevents = BIT_GAP(BITS_PER_TYPE(u16), rq->cq.event_ctr,
		318	am->start_sample.event_ctr);
312	if (nevents < MLX5E_AM_NEVENTS)	319	if (nevents < MLX5E_AM_NEVENTS)
313	break;	320	break;
314	mlx5e_am_sample(rq, &end_sample);	321	mlx5e_am_sample(rq, &end_sample);

drivers/net/ethernet/mellanox/mlx5/core/en_stats.h+2−9

 };
 static const struct counter_desc mlx5e_pme_status_desc[] = {
-	{ "module_plug", 0 },
 	{ "module_unplug", 8 },
 };
 static const struct counter_desc mlx5e_pme_error_desc[] = {
-	{ "module_pwr_budget_exd", 0 },  /* power budget exceed */
+	{ "module_bus_stuck", 16 },       /* bus stuck (I2C or data shorted) */
-	{ "module_long_range", 8 },      /* long range for non MLNX cable */
+	{ "module_high_temp", 48 },       /* high temperature */
-	{ "module_bus_stuck", 16 },      /* bus stuck (I2C or data shorted) */
-	{ "module_no_eeprom", 24 },      /* no eeprom/retry time out */
-	{ "module_enforce_part", 32 },   /* enforce part number list */
-	{ "module_unknown_id", 40 },     /* unknown identifier */
-	{ "module_high_temp", 48 },      /* high temperature */
 	{ "module_bad_shorted", 56 },    /* bad or shorted cable/module */
-	{ "module_unknown_status", 64 },
 };
 #endif /* __MLX5_EN_STATS_H__ */

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

@@ -895,7 +895,6 @@ static struct mlx5_fields fields[] = { · 894 unmodified lines
895	{MLX5_ACTION_IN_FIELD_OUT_SMAC_15_0, 2, offsetof(struct pedit_headers, eth.h_source[4])},	895	{MLX5_ACTION_IN_FIELD_OUT_SMAC_15_0, 2, offsetof(struct pedit_headers, eth.h_source[4])},
896	{MLX5_ACTION_IN_FIELD_OUT_ETHERTYPE, 2, offsetof(struct pedit_headers, eth.h_proto)},	896	{MLX5_ACTION_IN_FIELD_OUT_ETHERTYPE, 2, offsetof(struct pedit_headers, eth.h_proto)},
897		897
898	{MLX5_ACTION_IN_FIELD_OUT_IP_DSCP, 1, offsetof(struct pedit_headers, ip4.tos)},
899	{MLX5_ACTION_IN_FIELD_OUT_IP_TTL, 1, offsetof(struct pedit_headers, ip4.ttl)},	898	{MLX5_ACTION_IN_FIELD_OUT_IP_TTL, 1, offsetof(struct pedit_headers, ip4.ttl)},
900	{MLX5_ACTION_IN_FIELD_OUT_SIPV4, 4, offsetof(struct pedit_headers, ip4.saddr)},	899	{MLX5_ACTION_IN_FIELD_OUT_SIPV4, 4, offsetof(struct pedit_headers, ip4.saddr)},
901	{MLX5_ACTION_IN_FIELD_OUT_DIPV4, 4, offsetof(struct pedit_headers, ip4.daddr)},	900	{MLX5_ACTION_IN_FIELD_OUT_DIPV4, 4, offsetof(struct pedit_headers, ip4.daddr)},

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+40−37

@@ -906,21 +906,34 @@ static int esw_inline_mode_to_devlink(u8 mlx5_mode, u8 *mode) · 905 unmodified lines
906	return 0;	906	return 0;
907	}	907	}
908		908
909	int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)	909	static int mlx5_devlink_eswitch_check(struct devlink *devlink)
910	{	910	{
911	struct mlx5_core_dev *dev;	911	struct mlx5_core_dev *dev = devlink_priv(devlink);
912	u16 cur_mlx5_mode, mlx5_mode = 0;
913		912
914	dev = devlink_priv(devlink);	913	if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
		914	return -EOPNOTSUPP;
915		915
916	if (!MLX5_CAP_GEN(dev, vport_group_manager))	916	if (!MLX5_CAP_GEN(dev, vport_group_manager))
917	return -EOPNOTSUPP;	917	return -EOPNOTSUPP;
918		918
919	cur_mlx5_mode = dev->priv.eswitch->mode;	919	if (dev->priv.eswitch->mode == SRIOV_NONE)
920
921	if (cur_mlx5_mode == SRIOV_NONE)
922	return -EOPNOTSUPP;	920	return -EOPNOTSUPP;
923		921
		922	return 0;
		923	}
		924
		925	int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)
		926	{
		927	struct mlx5_core_dev *dev = devlink_priv(devlink);
		928	u16 cur_mlx5_mode, mlx5_mode = 0;
		929	int err;
		930
		931	err = mlx5_devlink_eswitch_check(devlink);
		932	if (err)
		933	return err;
		934
		935	cur_mlx5_mode = dev->priv.eswitch->mode;
		936
924	if (esw_mode_from_devlink(mode, &mlx5_mode))	937	if (esw_mode_from_devlink(mode, &mlx5_mode))
925	return -EINVAL;	938	return -EINVAL;
926		939
@@ -937,15 +950,12 @@ int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode) · 10 unmodified lines
937		950
938	int mlx5_devlink_eswitch_mode_get(struct devlink devlink, u16 mode)	951	int mlx5_devlink_eswitch_mode_get(struct devlink devlink, u16 mode)
939	{	952	{
940	struct mlx5_core_dev *dev;	953	struct mlx5_core_dev *dev = devlink_priv(devlink);
941		954	int err;
942	dev = devlink_priv(devlink);
943
944	if (!MLX5_CAP_GEN(dev, vport_group_manager))
945	return -EOPNOTSUPP;
946		955
947	if (dev->priv.eswitch->mode == SRIOV_NONE)	956	err = mlx5_devlink_eswitch_check(devlink);
948	return -EOPNOTSUPP;	957	if (err)
		958	return err;
949		959
950	return esw_mode_to_devlink(dev->priv.eswitch->mode, mode);	960	return esw_mode_to_devlink(dev->priv.eswitch->mode, mode);
951	}	961	}
@@ -954,15 +964,12 @@ int mlx5_devlink_eswitch_inline_mode_set(struct devlink *devlink, u8 mode) · 2 unmodified lines
954	{	964	{
955	struct mlx5_core_dev *dev = devlink_priv(devlink);	965	struct mlx5_core_dev *dev = devlink_priv(devlink);
956	struct mlx5_eswitch *esw = dev->priv.eswitch;	966	struct mlx5_eswitch *esw = dev->priv.eswitch;
957	int num_vports = esw->enabled_vports;
958	int err, vport;	967	int err, vport;
959	u8 mlx5_mode;	968	u8 mlx5_mode;
960		969
961	if (!MLX5_CAP_GEN(dev, vport_group_manager))	970	err = mlx5_devlink_eswitch_check(devlink);
962	return -EOPNOTSUPP;	971	if (err)
963		972	return err;
964	if (esw->mode == SRIOV_NONE)
965	return -EOPNOTSUPP;
966		973
967	switch (MLX5_CAP_ETH(dev, wqe_inline_mode)) {	974	switch (MLX5_CAP_ETH(dev, wqe_inline_mode)) {
968	case MLX5_CAP_INLINE_MODE_NOT_REQUIRED:	975	case MLX5_CAP_INLINE_MODE_NOT_REQUIRED:
@@ -985,7 +992,7 @@ int mlx5_devlink_eswitch_inline_mode_set(struct devlink *devlink, u8 mode) · 16 unmodified lines
985	if (err)	992	if (err)
986	goto out;	993	goto out;
987		994
988	for (vport = 1; vport < num_vports; vport++) {	995	for (vport = 1; vport < esw->enabled_vports; vport++) {
989	err = mlx5_modify_nic_vport_min_inline(dev, vport, mlx5_mode);	996	err = mlx5_modify_nic_vport_min_inline(dev, vport, mlx5_mode);
990	if (err) {	997	if (err) {
991	esw_warn(dev, "Failed to set min inline on vport %d\n",	998	esw_warn(dev, "Failed to set min inline on vport %d\n",
@@ -1010,12 +1017,11 @@ int mlx5_devlink_eswitch_inline_mode_get(struct devlink devlink, u8 mode) · 18 unmodified lines
1010	{	1017	{
1011	struct mlx5_core_dev *dev = devlink_priv(devlink);	1018	struct mlx5_core_dev *dev = devlink_priv(devlink);
1012	struct mlx5_eswitch *esw = dev->priv.eswitch;	1019	struct mlx5_eswitch *esw = dev->priv.eswitch;
		1020	int err;
1013		1021
1014	if (!MLX5_CAP_GEN(dev, vport_group_manager))	1022	err = mlx5_devlink_eswitch_check(devlink);
1015	return -EOPNOTSUPP;	1023	if (err)
1016		1024	return err;
1017	if (esw->mode == SRIOV_NONE)
1018	return -EOPNOTSUPP;
1019		1025
1020	return esw_inline_mode_to_devlink(esw->offloads.inline_mode, mode);	1026	return esw_inline_mode_to_devlink(esw->offloads.inline_mode, mode);
1021	}	1027	}
@@ -1062,11 +1068,9 @@ int mlx5_devlink_eswitch_encap_mode_set(struct devlink *devlink, u8 encap) · 40 unmodified lines
1062	struct mlx5_eswitch *esw = dev->priv.eswitch;	1068	struct mlx5_eswitch *esw = dev->priv.eswitch;
1063	int err;	1069	int err;
1064		1070
1065	if (!MLX5_CAP_GEN(dev, vport_group_manager))	1071	err = mlx5_devlink_eswitch_check(devlink);
1066	return -EOPNOTSUPP;	1072	if (err)
1067		1073	return err;
1068	if (esw->mode == SRIOV_NONE)
1069	return -EOPNOTSUPP;
1070		1074
1071	if (encap != DEVLINK_ESWITCH_ENCAP_MODE_NONE &&	1075	if (encap != DEVLINK_ESWITCH_ENCAP_MODE_NONE &&
1072	(!MLX5_CAP_ESW_FLOWTABLE_FDB(dev, encap) \|\|	1076	(!MLX5_CAP_ESW_FLOWTABLE_FDB(dev, encap) \|\|
@@ -1105,12 +1109,11 @@ int mlx5_devlink_eswitch_encap_mode_get(struct devlink devlink, u8 encap) · 32 unmodified lines
1105	{	1109	{
1106	struct mlx5_core_dev *dev = devlink_priv(devlink);	1110	struct mlx5_core_dev *dev = devlink_priv(devlink);
1107	struct mlx5_eswitch *esw = dev->priv.eswitch;	1111	struct mlx5_eswitch *esw = dev->priv.eswitch;
		1112	int err;
1108		1113
1109	if (!MLX5_CAP_GEN(dev, vport_group_manager))	1114	err = mlx5_devlink_eswitch_check(devlink);
1110	return -EOPNOTSUPP;	1115	if (err)
1111		1116	return err;
1112	if (esw->mode == SRIOV_NONE)
1113	return -EOPNOTSUPP;
1114		1117
1115	*encap = esw->offloads.encap;	1118	*encap = esw->offloads.encap;
1116	return 0;	1119	return 0;

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

@@ -862,7 +862,7 @@ struct mlx5_flow_table *mlx5_create_vport_flow_table(struct mlx5_flow_namespace · 861 unmodified lines
862	ft_attr.level = level;	862	ft_attr.level = level;
863	ft_attr.prio = prio;	863	ft_attr.prio = prio;
864		864
865	return __mlx5_create_flow_table(ns, &ft_attr, FS_FT_OP_MOD_NORMAL, 0);	865	return __mlx5_create_flow_table(ns, &ft_attr, FS_FT_OP_MOD_NORMAL, vport);
866	}	866	}
867		867
868	struct mlx5_flow_table*	868	struct mlx5_flow_table*

drivers/net/ethernet/mellanox/mlx5/core/health.c+5−6

 	struct mlx5_core_health *health = &dev->priv.health;
 	u32 count;
-	if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {
+	if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR)
-		mod_timer(&health->timer, get_next_poll_jiffies());
+		goto out;
-		return;
-	}
 	count = ioread32be(health->health_counter);
 	if (count == health->prev)
 	if (health->miss_counter == MAX_MISSES) {
 		dev_err(&dev->pdev->dev, "device's health compromised - reached miss count\n");
 		print_health_info(dev);
-	} else {
-		mod_timer(&health->timer, get_next_poll_jiffies());
 	}
 	if (in_fatal(dev) && !health->sick) {
 				"new health works are not permitted at this stage\n");
 		spin_unlock(&health->wq_lock);
 	}
+out:
+	mod_timer(&health->timer, get_next_poll_jiffies());
 }
 void mlx5_start_health_poll(struct mlx5_core_dev *dev)

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

 	},
 };
-#define FW_INIT_TIMEOUT_MILI	2000
+#define FW_INIT_TIMEOUT_MILI		2000
-#define FW_INIT_WAIT_MS		2
+#define FW_INIT_WAIT_MS			2
+#define FW_PRE_INIT_TIMEOUT_MILI	10000
 static int wait_fw_init(struct mlx5_core_dev *dev, u32 max_wait_mili)
 {
 	/* disable cmdif checksum */
 	MLX5_SET(cmd_hca_cap, set_hca_cap, cmdif_checksum, 0);
-	/* If the HCA supports 4K UARs use it */
+	/* Enable 4K UAR only when HCA supports it and page size is bigger
-	if (MLX5_CAP_GEN_MAX(dev, uar_4k))
+	 * than 4K.
+	 */
+	if (MLX5_CAP_GEN_MAX(dev, uar_4k) && PAGE_SIZE > 4096)
 		MLX5_SET(cmd_hca_cap, set_hca_cap, uar_4k, 1);
 	MLX5_SET(cmd_hca_cap, set_hca_cap, log_uar_page_sz, PAGE_SHIFT - 12);
 	 */
 	dev->state = MLX5_DEVICE_STATE_UP;
+	/* wait for firmware to accept initialization segments configurations
+	 */
+	err = wait_fw_init(dev, FW_PRE_INIT_TIMEOUT_MILI);
+	if (err) {
+		dev_err(&dev->pdev->dev, "Firmware over %d MS in pre-initializing state, aborting\n",
+			FW_PRE_INIT_TIMEOUT_MILI);
+		goto out;
+	}
 	err = mlx5_cmd_init(dev);
 	if (err) {
 		dev_err(&pdev->dev, "Failed initializing command interface, aborting\n");

drivers/net/ethernet/qlogic/qed/qed_debug.c+1−1

@@ -2956,7 +2956,7 @@ static u32 qed_grc_dump_ctx_data(struct qed_hwfn *p_hwfn, · 2955 unmodified lines
2956	qed_wr(p_hwfn,	2956	qed_wr(p_hwfn,
2957	p_ptt,	2957	p_ptt,
2958	s_storm_defs[storm_id].cm_ctx_wr_addr,	2958	s_storm_defs[storm_id].cm_ctx_wr_addr,
2959	BIT(9) \| lid);	2959	(i << 9) \| lid);
2960	*(dump_buf + offset) = qed_rd(p_hwfn,	2960	*(dump_buf + offset) = qed_rd(p_hwfn,
2961	p_ptt,	2961	p_ptt,
2962	rd_reg_addr);	2962	rd_reg_addr);

drivers/net/ethernet/sfc/ef10_sriov.c+0−2

@@ -661,8 +661,6 @@ restore_filters: · 660 unmodified lines
661	up_write(&vf->efx->filter_sem);	661	up_write(&vf->efx->filter_sem);
662	mutex_unlock(&vf->efx->mac_lock);	662	mutex_unlock(&vf->efx->mac_lock);
663		663
664	up_write(&vf->efx->filter_sem);
665
666	rc2 = efx_net_open(vf->efx->net_dev);	664	rc2 = efx_net_open(vf->efx->net_dev);
667	if (rc2)	665	if (rc2)
668	goto reset_nic;	666	goto reset_nic;

drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c+7−4

 {
 	/* Context type from W/B descriptor must be zero */
 	if (le32_to_cpu(p->des3) & TDES3_CONTEXT_TYPE)
-		return -EINVAL;
+		return 0;
 	/* Tx Timestamp Status is 1 so des0 and des1'll have valid values */
 	if (le32_to_cpu(p->des3) & TDES3_TIMESTAMP_STATUS)
-		return 0;
+		return 1;
-	return 1;
+	return 0;
 }
 static inline u64 dwmac4_get_timestamp(void *desc, u32 ats)
 		}
 	}
 exit:
-	return ret;
+	if (likely(ret == 0))
+		return 1;
+	return 0;
 }
 static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic,

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+33−12

 		return;
 	/* check tx tstamp status */
-	if (!priv->hw->desc->get_tx_timestamp_status(p)) {
+	if (priv->hw->desc->get_tx_timestamp_status(p)) {
 		/* get the valid tstamp */
 		ns = priv->hw->desc->get_timestamp(p, priv->adv_ts);
 		memset(&shhwtstamp, 0, sizeof(struct skb_shared_hwtstamps));
 		shhwtstamp.hwtstamp = ns_to_ktime(ns);
-		netdev_info(priv->dev, "get valid TX hw timestamp %llu\n", ns);
+		netdev_dbg(priv->dev, "get valid TX hw timestamp %llu\n", ns);
 		/* pass tstamp to stack */
 		skb_tstamp_tx(skb, &shhwtstamp);
 	}
 		return;
 	/* Check if timestamp is available */
-	if (!priv->hw->desc->get_rx_timestamp_status(p, priv->adv_ts)) {
+	if (priv->hw->desc->get_rx_timestamp_status(p, priv->adv_ts)) {
 		/* For GMAC4, the valid timestamp is from CTX next desc. */
 		if (priv->plat->has_gmac4)
 			ns = priv->hw->desc->get_timestamp(np, priv->adv_ts);
 		else
 			ns = priv->hw->desc->get_timestamp(p, priv->adv_ts);
-		netdev_info(priv->dev, "get valid RX hw timestamp %llu\n", ns);
+		netdev_dbg(priv->dev, "get valid RX hw timestamp %llu\n", ns);
 		shhwtstamp = skb_hwtstamps(skb);
 		memset(shhwtstamp, 0, sizeof(struct skb_shared_hwtstamps));
 		shhwtstamp->hwtstamp = ns_to_ktime(ns);
 	} else  {
-		netdev_err(priv->dev, "cannot get RX hw timestamp\n");
+		netdev_dbg(priv->dev, "cannot get RX hw timestamp\n");
 	}
 }
 			/* PTP v1, UDP, any kind of event packet */
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_EVENT;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_EVENT;
 			ptp_v2 = PTP_TCR_TSVER2ENA;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
 			ptp_v2 = PTP_TCR_TSVER2ENA;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 	tx_q->tx_skbuff_dma[first_entry].buf = des;
 	tx_q->tx_skbuff_dma[first_entry].len = skb_headlen(skb);
-	tx_q->tx_skbuff[first_entry] = skb;
 	first->des0 = cpu_to_le32(des);
 	tx_q->tx_skbuff_dma[tx_q->cur_tx].last_segment = true;
+	/* Only the last descriptor gets to point to the skb. */
+	tx_q->tx_skbuff[tx_q->cur_tx] = skb;
+	/* We've used all descriptors we need for this skb, however,
+	 * advance cur_tx so that it references a fresh descriptor.
+	 * ndo_start_xmit will fill this descriptor the next time it's
+	 * called and stmmac_tx_clean may clean up to this descriptor.
+	 */
 	tx_q->cur_tx = STMMAC_GET_ENTRY(tx_q->cur_tx, DMA_TX_SIZE);
 	if (unlikely(stmmac_tx_avail(priv, queue) <= (MAX_SKB_FRAGS + 1))) {
 	first = desc;
-	tx_q->tx_skbuff[first_entry] = skb;
 	enh_desc = priv->plat->enh_desc;
 	/* To program the descriptors according to the size of the frame */
 	if (enh_desc)
 						skb->len);
 	}
-	entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);
+	/* Only the last descriptor gets to point to the skb. */
+	tx_q->tx_skbuff[entry] = skb;
+	/* We've used all descriptors we need for this skb, however,
+	 * advance cur_tx so that it references a fresh descriptor.
+	 * ndo_start_xmit will fill this descriptor the next time it's
+	 * called and stmmac_tx_clean may clean up to this descriptor.
+	 */
+	entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);
 	tx_q->cur_tx = entry;
 	if (netif_msg_pktdata(priv)) {

drivers/net/ethernet/stmicro/stmmac/stmmac_ptp.h+2−1

@@ -59,7 +59,8 @@ · 58 unmodified lines
59	/* Enable Snapshot for Messages Relevant to Master */	59	/* Enable Snapshot for Messages Relevant to Master */
60	#define PTP_TCR_TSMSTRENA BIT(15)	60	#define PTP_TCR_TSMSTRENA BIT(15)
61	/* Select PTP packets for Taking Snapshots */	61	/* Select PTP packets for Taking Snapshots */
62	#define PTP_TCR_SNAPTYPSEL_1 GENMASK(17, 16)	62	#define PTP_TCR_SNAPTYPSEL_1 BIT(16)
		63	#define PTP_GMAC4_TCR_SNAPTYPSEL_1 GENMASK(17, 16)
63	/* Enable MAC address for PTP Frame Filtering */	64	/* Enable MAC address for PTP Frame Filtering */
64	#define PTP_TCR_TSENMACADDR BIT(18)	65	#define PTP_TCR_TSENMACADDR BIT(18)
65		66

drivers/net/geneve.c+1−1

@@ -1007,7 +1007,7 @@ static void geneve_setup(struct net_device *dev) · 1006 unmodified lines
1007		1007
1008	dev->netdev_ops = &geneve_netdev_ops;	1008	dev->netdev_ops = &geneve_netdev_ops;
1009	dev->ethtool_ops = &geneve_ethtool_ops;	1009	dev->ethtool_ops = &geneve_ethtool_ops;
1010	dev->destructor = free_netdev;	1010	dev->needs_free_netdev = true;
1011		1011
1012	SET_NETDEV_DEVTYPE(dev, &geneve_type);	1012	SET_NETDEV_DEVTYPE(dev, &geneve_type);
1013		1013

drivers/net/gtp.c+1−1

@@ -611,7 +611,7 @@ static const struct net_device_ops gtp_netdev_ops = { · 610 unmodified lines
611	static void gtp_link_setup(struct net_device *dev)	611	static void gtp_link_setup(struct net_device *dev)
612	{	612	{
613	dev->netdev_ops = &gtp_netdev_ops;	613	dev->netdev_ops = &gtp_netdev_ops;
614	dev->destructor = free_netdev;	614	dev->needs_free_netdev = true;
615		615
616	dev->hard_header_len = 0;	616	dev->hard_header_len = 0;
617	dev->addr_len = 0;	617	dev->addr_len = 0;

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

@@ -311,7 +311,7 @@ static void sp_setup(struct net_device *dev) · 310 unmodified lines
311	{	311	{
312	/* Finish setting up the DEVICE info. */	312	/* Finish setting up the DEVICE info. */
313	dev->netdev_ops = &sp_netdev_ops;	313	dev->netdev_ops = &sp_netdev_ops;
314	dev->destructor = free_netdev;	314	dev->needs_free_netdev = true;
315	dev->mtu = SIXP_MTU;	315	dev->mtu = SIXP_MTU;
316	dev->hard_header_len = AX25_MAX_HEADER_LEN;	316	dev->hard_header_len = AX25_MAX_HEADER_LEN;
317	dev->header_ops = &ax25_header_ops;	317	dev->header_ops = &ax25_header_ops;

drivers/net/hamradio/bpqether.c+1−1

@@ -476,7 +476,7 @@ static const struct net_device_ops bpq_netdev_ops = { · 475 unmodified lines
476	static void bpq_setup(struct net_device *dev)	476	static void bpq_setup(struct net_device *dev)
477	{	477	{
478	dev->netdev_ops = &bpq_netdev_ops;	478	dev->netdev_ops = &bpq_netdev_ops;
479	dev->destructor = free_netdev;	479	dev->needs_free_netdev = true;
480		480
481	memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);	481	memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
482	memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);	482	memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);

drivers/net/hyperv/hyperv_net.h+3−2

 	spinlock_t request_lock;
 	struct list_head req_list;
+	struct work_struct mcast_work;
 	u8 hw_mac_adr[ETH_ALEN];
 	u8 rss_key[NETVSC_HASH_KEYLEN];
 	u16 ind_table[ITAB_NUM];
 int rndis_filter_close(struct netvsc_device *nvdev);
 int rndis_filter_device_add(struct hv_device *dev,
 			    struct netvsc_device_info *info);
+void rndis_filter_update(struct netvsc_device *nvdev);
 void rndis_filter_device_remove(struct hv_device *dev,
 				struct netvsc_device *nvdev);
 int rndis_filter_set_rss_param(struct rndis_device *rdev,
 			 struct vmbus_channel *channel,
 			 void *data, u32 buflen);
-int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter);
 int rndis_filter_set_device_mac(struct net_device *ndev, char *mac);
 void netvsc_switch_datapath(struct net_device *nv_dev, bool vf);
 	/* list protection */
 	spinlock_t lock;
-	struct work_struct work;
 	u32 msg_enable; /* debug level */
 	u32 tx_checksum_mask;

drivers/net/hyperv/netvsc_drv.c+18−36

 module_param(debug, int, S_IRUGO);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
-static void do_set_multicast(struct work_struct *w)
-{
-	struct net_device_context *ndevctx =
-		container_of(w, struct net_device_context, work);
-	struct hv_device *device_obj = ndevctx->device_ctx;
-	struct net_device *ndev = hv_get_drvdata(device_obj);
-	struct netvsc_device *nvdev = rcu_dereference(ndevctx->nvdev);
-	struct rndis_device *rdev;
-	if (!nvdev)
-		return;
-	rdev = nvdev->extension;
-	if (rdev == NULL)
-		return;
-	if (ndev->flags & IFF_PROMISC)
-		rndis_filter_set_packet_filter(rdev,
-			NDIS_PACKET_TYPE_PROMISCUOUS);
-	else
-		rndis_filter_set_packet_filter(rdev,
-			NDIS_PACKET_TYPE_BROADCAST |
-			NDIS_PACKET_TYPE_ALL_MULTICAST |
-			NDIS_PACKET_TYPE_DIRECTED);
-}
 static void netvsc_set_multicast_list(struct net_device *net)
 {
 	struct net_device_context *net_device_ctx = netdev_priv(net);
+	struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
-	schedule_work(&net_device_ctx->work);
+	rndis_filter_update(nvdev);
 }
 static int netvsc_open(struct net_device *net)
 	netif_tx_disable(net);
-	/* Make sure netvsc_set_multicast_list doesn't re-enable filter! */
-	cancel_work_sync(&net_device_ctx->work);
 	ret = rndis_filter_close(nvdev);
 	if (ret != 0) {
 		netdev_err(net, "unable to close device (ret %d).\n", ret);
 static int netvsc_get_sset_count(struct net_device *dev, int string_set)
 {
 	struct net_device_context *ndc = netdev_priv(dev);
-	struct netvsc_device *nvdev = rcu_dereference(ndc->nvdev);
+	struct netvsc_device *nvdev = rtnl_dereference(ndc->nvdev);
 	if (!nvdev)
 		return -ENODEV;
 }
 #ifdef CONFIG_NET_POLL_CONTROLLER
-static void netvsc_poll_controller(struct net_device *net)
+static void netvsc_poll_controller(struct net_device *dev)
 {
-	/* As netvsc_start_xmit() works synchronous we don't have to
+	struct net_device_context *ndc = netdev_priv(dev);
-	 * trigger anything here.
+	struct netvsc_device *ndev;
-	 */
+	int i;
+	rcu_read_lock();
+	ndev = rcu_dereference(ndc->nvdev);
+	if (ndev) {
+		for (i = 0; i < ndev->num_chn; i++) {
+			struct netvsc_channel *nvchan = &ndev->chan_table[i];
+			napi_schedule(&nvchan->napi);
+		}
+	}
+	rcu_read_unlock();
 }
 #endif
 	hv_set_drvdata(dev, net);
 	INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change);
-	INIT_WORK(&net_device_ctx->work, do_set_multicast);
 	spin_lock_init(&net_device_ctx->lock);
 	INIT_LIST_HEAD(&net_device_ctx->reconfig_events);
 	netif_device_detach(net);
 	cancel_delayed_work_sync(&ndev_ctx->dwork);
-	cancel_work_sync(&ndev_ctx->work);
 	/*
 	 * Call to the vsc driver to let it know that the device is being

drivers/net/hyperv/rndis_filter.c+29−1

 #include "hyperv_net.h"
+static void rndis_set_multicast(struct work_struct *w);
 #define RNDIS_EXT_LEN PAGE_SIZE
 struct rndis_request {
 	spin_lock_init(&device->request_lock);
 	INIT_LIST_HEAD(&device->req_list);
+	INIT_WORK(&device->mcast_work, rndis_set_multicast);
 	device->state = RNDIS_DEV_UNINITIALIZED;
 	return ret;
 }
-int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter)
+static int rndis_filter_set_packet_filter(struct rndis_device *dev,
+					  u32 new_filter)
 {
 	struct rndis_request *request;
 	struct rndis_set_request *set;
 	return ret;
 }
+static void rndis_set_multicast(struct work_struct *w)
+{
+	struct rndis_device *rdev
+		= container_of(w, struct rndis_device, mcast_work);
+	if (rdev->ndev->flags & IFF_PROMISC)
+		rndis_filter_set_packet_filter(rdev,
+					       NDIS_PACKET_TYPE_PROMISCUOUS);
+	else
+		rndis_filter_set_packet_filter(rdev,
+					       NDIS_PACKET_TYPE_BROADCAST |
+					       NDIS_PACKET_TYPE_ALL_MULTICAST |
+					       NDIS_PACKET_TYPE_DIRECTED);
+}
+void rndis_filter_update(struct netvsc_device *nvdev)
+{
+	struct rndis_device *rdev = nvdev->extension;
+	schedule_work(&rdev->mcast_work);
+}
 static int rndis_filter_init_device(struct rndis_device *dev)
 {
 	struct rndis_request *request;
 	if (dev->state != RNDIS_DEV_DATAINITIALIZED)
 		return 0;
+	/* Make sure rndis_set_multicast doesn't re-enable filter! */
+	cancel_work_sync(&dev->mcast_work);
 	ret = rndis_filter_set_packet_filter(dev, 0);
 	if (ret == -ENODEV)
 		ret = 0;

drivers/net/ifb.c+2−2

 		__skb_queue_purge(&txp->tq);
 	}
 	kfree(dp->tx_private);
-	free_netdev(dev);
 }
 static void ifb_setup(struct net_device *dev)
 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 	netif_keep_dst(dev);
 	eth_hw_addr_random(dev);
-	dev->destructor = ifb_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ifb_dev_free;
 }
 static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)

drivers/net/ipvlan/ipvlan_main.c+1−1

@@ -632,7 +632,7 @@ void ipvlan_link_setup(struct net_device *dev) · 631 unmodified lines
632	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE \| IFF_TX_SKB_SHARING);	632	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE \| IFF_TX_SKB_SHARING);
633	dev->priv_flags \|= IFF_UNICAST_FLT \| IFF_NO_QUEUE;	633	dev->priv_flags \|= IFF_UNICAST_FLT \| IFF_NO_QUEUE;
634	dev->netdev_ops = &ipvlan_netdev_ops;	634	dev->netdev_ops = &ipvlan_netdev_ops;
635	dev->destructor = free_netdev;	635	dev->needs_free_netdev = true;
636	dev->header_ops = &ipvlan_header_ops;	636	dev->header_ops = &ipvlan_header_ops;
637	dev->ethtool_ops = &ipvlan_ethtool_ops;	637	dev->ethtool_ops = &ipvlan_ethtool_ops;
638	}	638	}

drivers/net/loopback.c+2−2

 {
 	dev_net(dev)->loopback_dev = NULL;
 	free_percpu(dev->lstats);
-	free_netdev(dev);
 }
 static const struct net_device_ops loopback_ops = {
 	dev->ethtool_ops	= &loopback_ethtool_ops;
 	dev->header_ops		= &eth_header_ops;
 	dev->netdev_ops		= &loopback_ops;
-	dev->destructor		= loopback_dev_free;
+	dev->needs_free_netdev	= true;
+	dev->priv_destructor	= loopback_dev_free;
 }
 /* Setup and register the loopback device. */

drivers/net/macsec.c+2−2

 	free_percpu(macsec->secy.tx_sc.stats);
 	dev_put(real_dev);
-	free_netdev(dev);
 }
 static void macsec_setup(struct net_device *dev)
 	dev->max_mtu = ETH_MAX_MTU;
 	dev->priv_flags |= IFF_NO_QUEUE;
 	dev->netdev_ops = &macsec_netdev_ops;
-	dev->destructor = macsec_free_netdev;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = macsec_free_netdev;
 	SET_NETDEV_DEVTYPE(dev, &macsec_type);
 	eth_zero_addr(dev->broadcast);

drivers/net/macvlan.c+1−1

@@ -1092,7 +1092,7 @@ void macvlan_common_setup(struct net_device *dev) · 1091 unmodified lines
1092	netif_keep_dst(dev);	1092	netif_keep_dst(dev);
1093	dev->priv_flags \|= IFF_UNICAST_FLT;	1093	dev->priv_flags \|= IFF_UNICAST_FLT;
1094	dev->netdev_ops = &macvlan_netdev_ops;	1094	dev->netdev_ops = &macvlan_netdev_ops;
1095	dev->destructor = free_netdev;	1095	dev->needs_free_netdev = true;
1096	dev->header_ops = &macvlan_hard_header_ops;	1096	dev->header_ops = &macvlan_hard_header_ops;
1097	dev->ethtool_ops = &macvlan_ethtool_ops;	1097	dev->ethtool_ops = &macvlan_ethtool_ops;
1098	}	1098	}

drivers/net/netconsole.c+1−1

@@ -358,7 +358,7 @@ static ssize_t enabled_store(struct config_item *item, · 357 unmodified lines
358	if (err)	358	if (err)
359	goto out_unlock;	359	goto out_unlock;
360		360
361	pr_info("netconsole: network logging started\n");	361	pr_info("network logging started\n");
362	} else { /* false */	362	} else { /* false */
363	/* We need to disable the netconsole before cleaning it up	363	/* We need to disable the netconsole before cleaning it up
364	* otherwise we might end up in write_msg() with	364	* otherwise we might end up in write_msg() with

drivers/net/nlmon.c+1−1

@@ -113,7 +113,7 @@ static void nlmon_setup(struct net_device *dev) · 112 unmodified lines
113		113
114	dev->netdev_ops = &nlmon_ops;	114	dev->netdev_ops = &nlmon_ops;
115	dev->ethtool_ops = &nlmon_ethtool_ops;	115	dev->ethtool_ops = &nlmon_ethtool_ops;
116	dev->destructor = free_netdev;	116	dev->needs_free_netdev = true;
117		117
118	dev->features = NETIF_F_SG \| NETIF_F_FRAGLIST \|	118	dev->features = NETIF_F_SG \| NETIF_F_FRAGLIST \|
119	NETIF_F_HIGHDMA \| NETIF_F_LLTX;	119	NETIF_F_HIGHDMA \| NETIF_F_LLTX;

drivers/net/phy/Kconfig+1−0

@@ -127,6 +127,7 @@ config MDIO_THUNDER · 126 unmodified lines
127	tristate "ThunderX SOCs MDIO buses"	127	tristate "ThunderX SOCs MDIO buses"
128	depends on 64BIT	128	depends on 64BIT
129	depends on PCI	129	depends on PCI
		130	depends on !(MDIO_DEVICE=y && PHYLIB=m)
130	select MDIO_CAVIUM	131	select MDIO_CAVIUM
131	help	132	help
132	This driver supports the MDIO interfaces found on Cavium	133	This driver supports the MDIO interfaces found on Cavium

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

 		return "5Gbps";
 	case SPEED_10000:
 		return "10Gbps";
+	case SPEED_14000:
+		return "14Gbps";
 	case SPEED_20000:
 		return "20Gbps";
 	case SPEED_25000:

drivers/net/slip/slip.c+3−4

@@ -629,7 +629,7 @@ static void sl_uninit(struct net_device *dev) · 628 unmodified lines
629	static void sl_free_netdev(struct net_device *dev)	629	static void sl_free_netdev(struct net_device *dev)
630	{	630	{
631	int i = dev->base_addr;	631	int i = dev->base_addr;
632	free_netdev(dev);	632
633	slip_devs[i] = NULL;	633	slip_devs[i] = NULL;
634	}	634	}
635		635
@@ -651,7 +651,8 @@ static const struct net_device_ops sl_netdev_ops = { · 15 unmodified lines
651	static void sl_setup(struct net_device *dev)	651	static void sl_setup(struct net_device *dev)
652	{	652	{
653	dev->netdev_ops = &sl_netdev_ops;	653	dev->netdev_ops = &sl_netdev_ops;
654	dev->destructor = sl_free_netdev;	654	dev->needs_free_netdev = true;
		655	dev->priv_destructor = sl_free_netdev;
655		656
656	dev->hard_header_len = 0;	657	dev->hard_header_len = 0;
657	dev->addr_len = 0;	658	dev->addr_len = 0;
@@ -1369,8 +1370,6 @@ static void __exit slip_exit(void) · 711 unmodified lines
1369	if (sl->tty) {	1370	if (sl->tty) {
1370	printk(KERN_ERR "%s: tty discipline still running\n",	1371	printk(KERN_ERR "%s: tty discipline still running\n",
1371	dev->name);	1372	dev->name);
1372	/* Intentionally leak the control block. */
1373	dev->destructor = NULL;
1374	}	1373	}
1375		1374
1376	unregister_netdev(dev);	1375	unregister_netdev(dev);

drivers/net/team/team.c+2−2

 	struct team *team = netdev_priv(dev);
 	free_percpu(team->pcpu_stats);
-	free_netdev(dev);
 }
 static int team_open(struct net_device *dev)
 	dev->netdev_ops = &team_netdev_ops;
 	dev->ethtool_ops = &team_ethtool_ops;
-	dev->destructor	= team_destructor;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = team_destructor;
 	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
 	dev->priv_flags |= IFF_NO_QUEUE;
 	dev->priv_flags |= IFF_TEAM;

drivers/net/tun.c+2−2

 	free_percpu(tun->pcpu_stats);
 	tun_flow_uninit(tun);
 	security_tun_dev_free_security(tun->security);
-	free_netdev(dev);
 }
 static void tun_setup(struct net_device *dev)
 	tun->group = INVALID_GID;
 	dev->ethtool_ops = &tun_ethtool_ops;
-	dev->destructor = tun_free_netdev;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = tun_free_netdev;
 	/* We prefer our own queue length */
 	dev->tx_queue_len = TUN_READQ_SIZE;
 }

drivers/net/usb/cdc-phonet.c+1−1

@@ -298,7 +298,7 @@ static void usbpn_setup(struct net_device *dev) · 297 unmodified lines
298	dev->addr_len = 1;	298	dev->addr_len = 1;
299	dev->tx_queue_len = 3;	299	dev->tx_queue_len = 3;
300		300
301	dev->destructor = free_netdev;	301	dev->needs_free_netdev = true;
302	}	302	}
303		303
304	/*	304	/*

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

 	dev->addr_len        = 0;
 	dev->flags           = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
 	dev->netdev_ops      = &qmimux_netdev_ops;
-	dev->destructor      = free_netdev;
+	dev->needs_free_netdev = true;
 }
 static struct net_device *qmimux_find_dev(struct usbnet *dev, u8 mux_id)
 	{QMI_FIXED_INTF(0x1199, 0x9056, 8)},	/* Sierra Wireless Modem */
 	{QMI_FIXED_INTF(0x1199, 0x9057, 8)},
 	{QMI_FIXED_INTF(0x1199, 0x9061, 8)},	/* Sierra Wireless Modem */
+	{QMI_FIXED_INTF(0x1199, 0x9063, 8)},	/* Sierra Wireless EM7305 */
+	{QMI_FIXED_INTF(0x1199, 0x9063, 10)},	/* Sierra Wireless EM7305 */
 	{QMI_FIXED_INTF(0x1199, 0x9071, 8)},	/* Sierra Wireless MC74xx */
 	{QMI_FIXED_INTF(0x1199, 0x9071, 10)},	/* Sierra Wireless MC74xx */
 	{QMI_FIXED_INTF(0x1199, 0x9079, 8)},	/* Sierra Wireless EM74xx */
 	{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)},	/* Telit ME910 */
 	{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)},	/* Telit LE920 */
 	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1201, 2)},	/* Telit LE920, LE920A4 */
+	{QMI_FIXED_INTF(0x1c9e, 0x9801, 3)},	/* Telewell TW-3G HSPA+ */
+	{QMI_FIXED_INTF(0x1c9e, 0x9803, 4)},	/* Telewell TW-3G HSPA+ */
 	{QMI_FIXED_INTF(0x1c9e, 0x9b01, 3)},	/* XS Stick W100-2 from 4G Systems */
 	{QMI_FIXED_INTF(0x0b3c, 0xc000, 4)},	/* Olivetti Olicard 100 */
 	{QMI_FIXED_INTF(0x0b3c, 0xc001, 4)},	/* Olivetti Olicard 120 */

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

@@ -4368,6 +4368,8 @@ static u8 rtl_get_version(struct usb_interface *intf) · 4367 unmodified lines
4368	break;	4368	break;
4369	}	4369	}
4370		4370
		4371	dev_dbg(&intf->dev, "Detected version 0x%04x\n", version);
		4372
4371	return version;	4373	return version;
4372	}	4374	}
4373		4375

drivers/net/veth.c+2−2

 static void veth_dev_free(struct net_device *dev)
 {
 	free_percpu(dev->vstats);
-	free_netdev(dev);
 }
 #ifdef CONFIG_NET_POLL_CONTROLLER
 			       NETIF_F_HW_VLAN_STAG_TX |
 			       NETIF_F_HW_VLAN_CTAG_RX |
 			       NETIF_F_HW_VLAN_STAG_RX);
-	dev->destructor = veth_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = veth_dev_free;
 	dev->max_mtu = ETH_MAX_MTU;
 	dev->hw_features = VETH_FEATURES;

drivers/net/vrf.c+33−5

@@ -36,12 +36,14 @@ · 35 unmodified lines
36	#include <net/addrconf.h>	36	#include <net/addrconf.h>
37	#include <net/l3mdev.h>	37	#include <net/l3mdev.h>
38	#include <net/fib_rules.h>	38	#include <net/fib_rules.h>
		39	#include <net/netns/generic.h>
39		40
40	#define DRV_NAME "vrf"	41	#define DRV_NAME "vrf"
41	#define DRV_VERSION "1.0"	42	#define DRV_VERSION "1.0"
42		43
43	#define FIB_RULE_PREF 1000 /* default preference for FIB rules */	44	#define FIB_RULE_PREF 1000 /* default preference for FIB rules */
44	static bool add_fib_rules = true;	45
		46	static unsigned int vrf_net_id;
45		47
46	struct net_vrf {	48	struct net_vrf {
47	struct rtable __rcu *rth;	49	struct rtable __rcu *rth;
@@ -1348,7 +1350,7 @@ static void vrf_setup(struct net_device *dev) · 1300 unmodified lines
1348	dev->netdev_ops = &vrf_netdev_ops;	1350	dev->netdev_ops = &vrf_netdev_ops;
1349	dev->l3mdev_ops = &vrf_l3mdev_ops;	1351	dev->l3mdev_ops = &vrf_l3mdev_ops;
1350	dev->ethtool_ops = &vrf_ethtool_ops;	1352	dev->ethtool_ops = &vrf_ethtool_ops;
1351	dev->destructor = free_netdev;	1353	dev->needs_free_netdev = true;
1352		1354
1353	/* Fill in device structure with ethernet-generic values. */	1355	/* Fill in device structure with ethernet-generic values. */
1354	eth_hw_addr_random(dev);	1356	eth_hw_addr_random(dev);
@@ -1394,6 +1396,8 @@ static int vrf_newlink(struct net src_net, struct net_device dev, · 39 unmodified lines
1394	struct nlattr tb[], struct nlattr data[])	1396	struct nlattr tb[], struct nlattr data[])
1395	{	1397	{
1396	struct net_vrf *vrf = netdev_priv(dev);	1398	struct net_vrf *vrf = netdev_priv(dev);
		1399	bool *add_fib_rules;
		1400	struct net *net;
1397	int err;	1401	int err;
1398		1402
1399	if (!data \|\| !data[IFLA_VRF_TABLE])	1403	if (!data \|\| !data[IFLA_VRF_TABLE])
@@ -1409,13 +1413,15 @@ static int vrf_newlink(struct net src_net, struct net_device dev, · 9 unmodified lines
1409	if (err)	1413	if (err)
1410	goto out;	1414	goto out;
1411		1415
1412	if (add_fib_rules) {	1416	net = dev_net(dev);
		1417	add_fib_rules = net_generic(net, vrf_net_id);
		1418	if (*add_fib_rules) {
1413	err = vrf_add_fib_rules(dev);	1419	err = vrf_add_fib_rules(dev);
1414	if (err) {	1420	if (err) {
1415	unregister_netdevice(dev);	1421	unregister_netdevice(dev);
1416	goto out;	1422	goto out;
1417	}	1423	}
1418	add_fib_rules = false;	1424	*add_fib_rules = false;
1419	}	1425	}
1420		1426
1421	out:	1427	out:
@@ -1498,16 +1504,38 @@ static struct notifier_block vrf_notifier_block __read_mostly = { · 76 unmodified lines
1498	.notifier_call = vrf_device_event,	1504	.notifier_call = vrf_device_event,
1499	};	1505	};
1500		1506
		1507	/* Initialize per network namespace state */
		1508	static int __net_init vrf_netns_init(struct net *net)
		1509	{
		1510	bool *add_fib_rules = net_generic(net, vrf_net_id);
		1511
		1512	*add_fib_rules = true;
		1513
		1514	return 0;
		1515	}
		1516
		1517	static struct pernet_operations vrf_net_ops __net_initdata = {
		1518	.init = vrf_netns_init,
		1519	.id = &vrf_net_id,
		1520	.size = sizeof(bool),
		1521	};
		1522
1501	static int __init vrf_init_module(void)	1523	static int __init vrf_init_module(void)
1502	{	1524	{
1503	int rc;	1525	int rc;
1504		1526
1505	register_netdevice_notifier(&vrf_notifier_block);	1527	register_netdevice_notifier(&vrf_notifier_block);
1506		1528
1507	rc = rtnl_link_register(&vrf_link_ops);	1529	rc = register_pernet_subsys(&vrf_net_ops);
1508	if (rc < 0)	1530	if (rc < 0)
1509	goto error;	1531	goto error;
1510		1532
		1533	rc = rtnl_link_register(&vrf_link_ops);
		1534	if (rc < 0) {
		1535	unregister_pernet_subsys(&vrf_net_ops);
		1536	goto error;
		1537	}
		1538
1511	return 0;	1539	return 0;
1512		1540
1513	error:	1541	error:

drivers/net/vsockmon.c+1−1

@@ -135,7 +135,7 @@ static void vsockmon_setup(struct net_device *dev) · 134 unmodified lines
135		135
136	dev->netdev_ops = &vsockmon_ops;	136	dev->netdev_ops = &vsockmon_ops;
137	dev->ethtool_ops = &vsockmon_ethtool_ops;	137	dev->ethtool_ops = &vsockmon_ethtool_ops;
138	dev->destructor = free_netdev;	138	dev->needs_free_netdev = true;
139		139
140	dev->features = NETIF_F_SG \| NETIF_F_FRAGLIST \|	140	dev->features = NETIF_F_SG \| NETIF_F_FRAGLIST \|
141	NETIF_F_HIGHDMA \| NETIF_F_LLTX;	141	NETIF_F_HIGHDMA \| NETIF_F_LLTX;

drivers/net/vxlan.c+1−1

@@ -2611,7 +2611,7 @@ static void vxlan_setup(struct net_device *dev) · 2610 unmodified lines
2611	eth_hw_addr_random(dev);	2611	eth_hw_addr_random(dev);
2612	ether_setup(dev);	2612	ether_setup(dev);
2613		2613
2614	dev->destructor = free_netdev;	2614	dev->needs_free_netdev = true;
2615	SET_NETDEV_DEVTYPE(dev, &vxlan_type);	2615	SET_NETDEV_DEVTYPE(dev, &vxlan_type);
2616		2616
2617	dev->features \|= NETIF_F_LLTX;	2617	dev->features \|= NETIF_F_LLTX;

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

@@ -475,7 +475,7 @@ static void dlci_setup(struct net_device *dev) · 474 unmodified lines
475	dev->flags = 0;	475	dev->flags = 0;
476	dev->header_ops = &dlci_header_ops;	476	dev->header_ops = &dlci_header_ops;
477	dev->netdev_ops = &dlci_netdev_ops;	477	dev->netdev_ops = &dlci_netdev_ops;
478	dev->destructor = free_netdev;	478	dev->needs_free_netdev = true;
479		479
480	dlp->receive = dlci_receive;	480	dlp->receive = dlci_receive;
481		481

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

@@ -1106,7 +1106,7 @@ static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type) · 1105 unmodified lines
1106	return -EIO;	1106	return -EIO;
1107	}	1107	}
1108		1108
1109	dev->destructor = free_netdev;	1109	dev->needs_free_netdev = true;
1110	*get_dev_p(pvc, type) = dev;	1110	*get_dev_p(pvc, type) = dev;
1111	if (!used) {	1111	if (!used) {
1112	state(hdlc)->dce_changed = 1;	1112	state(hdlc)->dce_changed = 1;

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

@@ -306,7 +306,7 @@ static const struct net_device_ops lapbeth_netdev_ops = { · 305 unmodified lines
306	static void lapbeth_setup(struct net_device *dev)	306	static void lapbeth_setup(struct net_device *dev)
307	{	307	{
308	dev->netdev_ops = &lapbeth_netdev_ops;	308	dev->netdev_ops = &lapbeth_netdev_ops;
309	dev->destructor = free_netdev;	309	dev->needs_free_netdev = true;
310	dev->type = ARPHRD_X25;	310	dev->type = ARPHRD_X25;
311	dev->hard_header_len = 3;	311	dev->hard_header_len = 3;
312	dev->mtu = 1000;	312	dev->mtu = 1000;

drivers/net/wireless/ath/ath6kl/main.c+1−1

@@ -1287,7 +1287,7 @@ void init_netdev(struct net_device *dev) · 1286 unmodified lines
1287	struct ath6kl *ar = ath6kl_priv(dev);	1287	struct ath6kl *ar = ath6kl_priv(dev);
1288		1288
1289	dev->netdev_ops = &ath6kl_netdev_ops;	1289	dev->netdev_ops = &ath6kl_netdev_ops;
1290	dev->destructor = free_netdev;	1290	dev->needs_free_netdev = true;
1291	dev->watchdog_timeo = ATH6KL_TX_TIMEOUT;	1291	dev->watchdog_timeo = ATH6KL_TX_TIMEOUT;
1292		1292
1293	dev->needed_headroom = ETH_HLEN;	1293	dev->needed_headroom = ETH_HLEN;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c+0−1

@@ -5225,7 +5225,6 @@ void brcmf_cfg80211_free_netdev(struct net_device *ndev) · 5224 unmodified lines
5225		5225
5226	if (vif)	5226	if (vif)
5227	brcmf_free_vif(vif);	5227	brcmf_free_vif(vif);
5228	free_netdev(ndev);
5229	}	5228	}
5230		5229
5231	static bool brcmf_is_linkup(const struct brcmf_event_msg *e)	5230	static bool brcmf_is_linkup(const struct brcmf_event_msg *e)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c+2−1

@@ -624,7 +624,8 @@ struct brcmf_if brcmf_add_if(struct brcmf_pub drvr, s32 bsscfgidx, s32 ifidx, · 623 unmodified lines
624	if (!ndev)	624	if (!ndev)
625	return ERR_PTR(-ENOMEM);	625	return ERR_PTR(-ENOMEM);
626		626
627	ndev->destructor = brcmf_cfg80211_free_netdev;	627	ndev->needs_free_netdev = true;
		628	ndev->priv_destructor = brcmf_cfg80211_free_netdev;
628	ifp = netdev_priv(ndev);	629	ifp = netdev_priv(ndev);
629	ifp->ndev = ndev;	630	ifp->ndev = ndev;
630	/* store mapping ifidx to bsscfgidx */	631	/* store mapping ifidx to bsscfgidx */

drivers/net/wireless/broadcom/brcm80211/brcmfmac/firmware.c+17−18

@@ -442,7 +442,7 @@ struct brcmf_fw { · 441 unmodified lines
442	const char *nvram_name;	442	const char *nvram_name;
443	u16 domain_nr;	443	u16 domain_nr;
444	u16 bus_nr;	444	u16 bus_nr;
445	void (done)(struct device dev, const struct firmware *fw,	445	void (done)(struct device dev, int err, const struct firmware *fw,
446	void *nvram_image, u32 nvram_len);	446	void *nvram_image, u32 nvram_len);
447	};	447	};
448		448
@@ -477,52 +477,51 @@ static void brcmf_fw_request_nvram_done(const struct firmware fw, void ctx) · 28 unmodified lines
477	if (!nvram && !(fwctx->flags & BRCMF_FW_REQ_NV_OPTIONAL))	477	if (!nvram && !(fwctx->flags & BRCMF_FW_REQ_NV_OPTIONAL))
478	goto fail;	478	goto fail;
479		479
480	fwctx->done(fwctx->dev, fwctx->code, nvram, nvram_length);	480	fwctx->done(fwctx->dev, 0, fwctx->code, nvram, nvram_length);
481	kfree(fwctx);	481	kfree(fwctx);
482	return;	482	return;
483		483
484	fail:	484	fail:
485	brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));	485	brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));
486	release_firmware(fwctx->code);	486	release_firmware(fwctx->code);
487	device_release_driver(fwctx->dev);	487	fwctx->done(fwctx->dev, -ENOENT, NULL, NULL, 0);
488	kfree(fwctx);	488	kfree(fwctx);
489	}	489	}
490		490
491	static void brcmf_fw_request_code_done(const struct firmware fw, void ctx)	491	static void brcmf_fw_request_code_done(const struct firmware fw, void ctx)
492	{	492	{
493	struct brcmf_fw *fwctx = ctx;	493	struct brcmf_fw *fwctx = ctx;
494	int ret;	494	int ret = 0;
495		495
496	brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev));	496	brcmf_dbg(TRACE, "enter: dev=%s\n", dev_name(fwctx->dev));
497	if (!fw)	497	if (!fw) {
		498	ret = -ENOENT;
498	goto fail;	499	goto fail;
499
500	/* only requested code so done here */
501	if (!(fwctx->flags & BRCMF_FW_REQUEST_NVRAM)) {
502	fwctx->done(fwctx->dev, fw, NULL, 0);
503	kfree(fwctx);
504	return;
505	}	500	}
		501	/* only requested code so done here */
		502	if (!(fwctx->flags & BRCMF_FW_REQUEST_NVRAM))
		503	goto done;
		504
506	fwctx->code = fw;	505	fwctx->code = fw;
507	ret = request_firmware_nowait(THIS_MODULE, true, fwctx->nvram_name,	506	ret = request_firmware_nowait(THIS_MODULE, true, fwctx->nvram_name,
508	fwctx->dev, GFP_KERNEL, fwctx,	507	fwctx->dev, GFP_KERNEL, fwctx,
509	brcmf_fw_request_nvram_done);	508	brcmf_fw_request_nvram_done);
510		509
511	if (!ret)	510	/* pass NULL to nvram callback for bcm47xx fallback */
512	return;	511	if (ret)
513		512	brcmf_fw_request_nvram_done(NULL, fwctx);
514	brcmf_fw_request_nvram_done(NULL, fwctx);
515	return;	513	return;
516		514
517	fail:	515	fail:
518	brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));	516	brcmf_dbg(TRACE, "failed: dev=%s\n", dev_name(fwctx->dev));
519	device_release_driver(fwctx->dev);	517	done:
		518	fwctx->done(fwctx->dev, ret, fw, NULL, 0);
520	kfree(fwctx);	519	kfree(fwctx);
521	}	520	}
522		521
523	int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags,	522	int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags,
524	const char code, const char nvram,	523	const char code, const char nvram,
525	void (fw_cb)(struct device dev,	524	void (fw_cb)(struct device dev, int err,
526	const struct firmware *fw,	525	const struct firmware *fw,
527	void *nvram_image, u32 nvram_len),	526	void *nvram_image, u32 nvram_len),
528	u16 domain_nr, u16 bus_nr)	527	u16 domain_nr, u16 bus_nr)
@@ -555,7 +554,7 @@ int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags, · 26 unmodified lines
555		554
556	int brcmf_fw_get_firmwares(struct device *dev, u16 flags,	555	int brcmf_fw_get_firmwares(struct device *dev, u16 flags,
557	const char code, const char nvram,	556	const char code, const char nvram,
558	void (fw_cb)(struct device dev,	557	void (fw_cb)(struct device dev, int err,
559	const struct firmware *fw,	558	const struct firmware *fw,
560	void *nvram_image, u32 nvram_len))	559	void *nvram_image, u32 nvram_len))
561	{	560	{

drivers/net/wireless/broadcom/brcm80211/brcmfmac/firmware.h+2−2

@@ -73,13 +73,13 @@ void brcmf_fw_nvram_free(void *nvram); · 72 unmodified lines
73	*/	73	*/
74	int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags,	74	int brcmf_fw_get_firmwares_pcie(struct device *dev, u16 flags,
75	const char code, const char nvram,	75	const char code, const char nvram,
76	void (fw_cb)(struct device dev,	76	void (fw_cb)(struct device dev, int err,
77	const struct firmware *fw,	77	const struct firmware *fw,
78	void *nvram_image, u32 nvram_len),	78	void *nvram_image, u32 nvram_len),
79	u16 domain_nr, u16 bus_nr);	79	u16 domain_nr, u16 bus_nr);
80	int brcmf_fw_get_firmwares(struct device *dev, u16 flags,	80	int brcmf_fw_get_firmwares(struct device *dev, u16 flags,
81	const char code, const char nvram,	81	const char code, const char nvram,
82	void (fw_cb)(struct device dev,	82	void (fw_cb)(struct device dev, int err,
83	const struct firmware *fw,	83	const struct firmware *fw,
84	void *nvram_image, u32 nvram_len));	84	void *nvram_image, u32 nvram_len));
85		85

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c+1−1

@@ -2145,7 +2145,7 @@ void brcmf_fws_add_interface(struct brcmf_if *ifp) · 2144 unmodified lines
2145	struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr);	2145	struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr);
2146	struct brcmf_fws_mac_descriptor *entry;	2146	struct brcmf_fws_mac_descriptor *entry;
2147		2147
2148	if (!ifp->ndev \|\| fws->fcmode == BRCMF_FWS_FCMODE_NONE)	2148	if (!ifp->ndev \|\| !brcmf_fws_queue_skbs(fws))
2149	return;	2149	return;
2150		2150
2151	entry = &fws->desc.iface[ifp->ifidx];	2151	entry = &fws->desc.iface[ifp->ifidx];

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c+12−5

 	.write32 = brcmf_pcie_buscore_write32,
 };
-static void brcmf_pcie_setup(struct device *dev, const struct firmware *fw,
+static void brcmf_pcie_setup(struct device *dev, int ret,
+			     const struct firmware *fw,
 			     void *nvram, u32 nvram_len)
 {
-	struct brcmf_bus *bus = dev_get_drvdata(dev);
+	struct brcmf_bus *bus;
-	struct brcmf_pciedev *pcie_bus_dev = bus->bus_priv.pcie;
+	struct brcmf_pciedev *pcie_bus_dev;
-	struct brcmf_pciedev_info *devinfo = pcie_bus_dev->devinfo;
+	struct brcmf_pciedev_info *devinfo;
 	struct brcmf_commonring **flowrings;
-	int ret;
 	u32 i;
+	/* check firmware loading result */
+	if (ret)
+		goto fail;
+	bus = dev_get_drvdata(dev);
+	pcie_bus_dev = bus->bus_priv.pcie;
+	devinfo = pcie_bus_dev->devinfo;
 	brcmf_pcie_attach(devinfo);
 	/* Some of the firmwares have the size of the memory of the device

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c+12−6

 	.get_memdump = brcmf_sdio_bus_get_memdump,
 };
-static void brcmf_sdio_firmware_callback(struct device *dev,
+static void brcmf_sdio_firmware_callback(struct device *dev, int err,
 					 const struct firmware *code,
 					 void *nvram, u32 nvram_len)
 {
-	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
+	struct brcmf_bus *bus_if;
-	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
+	struct brcmf_sdio_dev *sdiodev;
-	struct brcmf_sdio *bus = sdiodev->bus;
+	struct brcmf_sdio *bus;
-	int err = 0;
 	u8 saveclk;
-	brcmf_dbg(TRACE, "Enter: dev=%s\n", dev_name(dev));
+	brcmf_dbg(TRACE, "Enter: dev=%s, err=%d\n", dev_name(dev), err);
+	bus_if = dev_get_drvdata(dev);
+	sdiodev = bus_if->bus_priv.sdio;
+	if (err)
+		goto fail;
 	if (!bus_if->drvr)
 		return;
+	bus = sdiodev->bus;
 	/* try to download image and nvram to the dongle */
 	bus->alp_only = true;
 	err = brcmf_sdio_download_firmware(bus, code, nvram, nvram_len);
 fail:
 	brcmf_dbg(TRACE, "failed: dev=%s, err=%d\n", dev_name(dev), err);
 	device_release_driver(dev);
+	device_release_driver(&sdiodev->func[2]->dev);
 }
 struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/usb.c+5−4

@@ -1159,17 +1159,18 @@ fail: · 1158 unmodified lines
1159	return ret;	1159	return ret;
1160	}	1160	}
1161		1161
1162	static void brcmf_usb_probe_phase2(struct device *dev,	1162	static void brcmf_usb_probe_phase2(struct device *dev, int ret,
1163	const struct firmware *fw,	1163	const struct firmware *fw,
1164	void *nvram, u32 nvlen)	1164	void *nvram, u32 nvlen)
1165	{	1165	{
1166	struct brcmf_bus *bus = dev_get_drvdata(dev);	1166	struct brcmf_bus *bus = dev_get_drvdata(dev);
1167	struct brcmf_usbdev_info *devinfo;	1167	struct brcmf_usbdev_info *devinfo = bus->bus_priv.usb->devinfo;
1168	int ret;	1168
		1169	if (ret)
		1170	goto error;
1169		1171
1170	brcmf_dbg(USB, "Start fw downloading\n");	1172	brcmf_dbg(USB, "Start fw downloading\n");
1171		1173
1172	devinfo = bus->bus_priv.usb->devinfo;
1173	ret = check_file(fw->data);	1174	ret = check_file(fw->data);
1174	if (ret < 0) {	1175	if (ret < 0) {
1175	brcmf_err("invalid firmware\n");	1176	brcmf_err("invalid firmware\n");

drivers/net/wireless/intersil/hostap/hostap_main.c+1−1

@@ -73,7 +73,7 @@ struct net_device * hostap_add_interface(struct local_info *local, · 72 unmodified lines
73	dev->mem_end = mdev->mem_end;	73	dev->mem_end = mdev->mem_end;
74		74
75	hostap_setup_dev(dev, local, type);	75	hostap_setup_dev(dev, local, type);
76	dev->destructor = free_netdev;	76	dev->needs_free_netdev = true;
77		77
78	sprintf(dev->name, "%s%s", prefix, name);	78	sprintf(dev->name, "%s%s", prefix, name);
79	if (!rtnl_locked)	79	if (!rtnl_locked)

drivers/net/wireless/mac80211_hwsim.c+1−1

@@ -2861,7 +2861,7 @@ static const struct net_device_ops hwsim_netdev_ops = { · 2860 unmodified lines
2861	static void hwsim_mon_setup(struct net_device *dev)	2861	static void hwsim_mon_setup(struct net_device *dev)
2862	{	2862	{
2863	dev->netdev_ops = &hwsim_netdev_ops;	2863	dev->netdev_ops = &hwsim_netdev_ops;
2864	dev->destructor = free_netdev;	2864	dev->needs_free_netdev = true;
2865	ether_setup(dev);	2865	ether_setup(dev);
2866	dev->priv_flags \|= IFF_NO_QUEUE;	2866	dev->priv_flags \|= IFF_NO_QUEUE;
2867	dev->type = ARPHRD_IEEE80211_RADIOTAP;	2867	dev->type = ARPHRD_IEEE80211_RADIOTAP;

drivers/net/wireless/marvell/mwifiex/main.c+1−1

@@ -1280,7 +1280,7 @@ void mwifiex_init_priv_params(struct mwifiex_private *priv, · 1279 unmodified lines
1280	struct net_device *dev)	1280	struct net_device *dev)
1281	{	1281	{
1282	dev->netdev_ops = &mwifiex_netdev_ops;	1282	dev->netdev_ops = &mwifiex_netdev_ops;
1283	dev->destructor = free_netdev;	1283	dev->needs_free_netdev = true;
1284	/* Initialize private structure */	1284	/* Initialize private structure */
1285	priv->current_key_index = 0;	1285	priv->current_key_index = 0;
1286	priv->media_connected = false;	1286	priv->media_connected = false;

drivers/ntb/hw/intel/ntb_hw_intel.c+1−1

@@ -2878,7 +2878,7 @@ static const struct intel_ntb_reg skx_reg = { · 2877 unmodified lines
2878	.link_is_up = xeon_link_is_up,	2878	.link_is_up = xeon_link_is_up,
2879	.db_ioread = skx_db_ioread,	2879	.db_ioread = skx_db_ioread,
2880	.db_iowrite = skx_db_iowrite,	2880	.db_iowrite = skx_db_iowrite,
2881	.db_size = sizeof(u64),	2881	.db_size = sizeof(u32),
2882	.ntb_ctl = SKX_NTBCNTL_OFFSET,	2882	.ntb_ctl = SKX_NTBCNTL_OFFSET,
2883	.mw_bar = {2, 4},	2883	.mw_bar = {2, 4},
2884	};	2884	};

drivers/ntb/ntb_transport.c+11−47

 	u64 rx_err_ver;
 	u64 rx_memcpy;
 	u64 rx_async;
-	u64 dma_rx_prep_err;
 	u64 tx_bytes;
 	u64 tx_pkts;
 	u64 tx_ring_full;
 	u64 tx_err_no_buf;
 	u64 tx_memcpy;
 	u64 tx_async;
-	u64 dma_tx_prep_err;
 };
 struct ntb_transport_mw {
 #define QP_TO_MW(nt, qp)	((qp) % nt->mw_count)
 #define NTB_QP_DEF_NUM_ENTRIES	100
 #define NTB_LINK_DOWN_TIMEOUT	10
-#define DMA_RETRIES		20
-#define DMA_OUT_RESOURCE_TO	msecs_to_jiffies(50)
 static void ntb_transport_rxc_db(unsigned long data);
 static const struct ntb_ctx_ops ntb_transport_ops;
 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
 			       "free tx - \t%u\n",
 			       ntb_transport_tx_free_entry(qp));
-	out_offset += snprintf(buf + out_offset, out_count - out_offset,
-			       "DMA tx prep err - \t%llu\n",
-			       qp->dma_tx_prep_err);
-	out_offset += snprintf(buf + out_offset, out_count - out_offset,
-			       "DMA rx prep err - \t%llu\n",
-			       qp->dma_rx_prep_err);
 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
 			       "\n");
 	if (!mw->virt_addr)
 		return -ENOMEM;
-	if (qp_count % mw_count && mw_num + 1 < qp_count / mw_count)
+	if (mw_num < qp_count % mw_count)
 		num_qps_mw = qp_count / mw_count + 1;
 	else
 		num_qps_mw = qp_count / mw_count;
 	qp->tx_err_no_buf = 0;
 	qp->tx_memcpy = 0;
 	qp->tx_async = 0;
-	qp->dma_tx_prep_err = 0;
-	qp->dma_rx_prep_err = 0;
 }
 static void ntb_qp_link_cleanup(struct ntb_transport_qp *qp)
 	qp->event_handler = NULL;
 	ntb_qp_link_down_reset(qp);
-	if (qp_count % mw_count && mw_num + 1 < qp_count / mw_count)
+	if (mw_num < qp_count % mw_count)
 		num_qps_mw = qp_count / mw_count + 1;
 	else
 		num_qps_mw = qp_count / mw_count;
 	qp_count = ilog2(qp_bitmap);
 	if (max_num_clients && max_num_clients < qp_count)
 		qp_count = max_num_clients;
-	else if (mw_count < qp_count)
+	else if (nt->mw_count < qp_count)
-		qp_count = mw_count;
+		qp_count = nt->mw_count;
 	qp_bitmap &= BIT_ULL(qp_count) - 1;
 	struct dmaengine_unmap_data *unmap;
 	dma_cookie_t cookie;
 	void *buf = entry->buf;
-	int retries = 0;
 	len = entry->len;
 	device = chan->device;
 	unmap->from_cnt = 1;
-	for (retries = 0; retries < DMA_RETRIES; retries++) {
+	txd = device->device_prep_dma_memcpy(chan, unmap->addr[1],
-		txd = device->device_prep_dma_memcpy(chan,
+					     unmap->addr[0], len,
-						     unmap->addr[1],
+					     DMA_PREP_INTERRUPT);
-						     unmap->addr[0], len,
+	if (!txd)
-						     DMA_PREP_INTERRUPT);
-		if (txd)
-			break;
-		set_current_state(TASK_INTERRUPTIBLE);
-		schedule_timeout(DMA_OUT_RESOURCE_TO);
-	}
-	if (!txd) {
-		qp->dma_rx_prep_err++;
 		goto err_get_unmap;
-	}
 	txd->callback_result = ntb_rx_copy_callback;
 	txd->callback_param = entry;
 	struct dmaengine_unmap_data *unmap;
 	dma_addr_t dest;
 	dma_cookie_t cookie;
-	int retries = 0;
 	device = chan->device;
 	dest = qp->tx_mw_phys + qp->tx_max_frame * entry->tx_index;
 	unmap->to_cnt = 1;
-	for (retries = 0; retries < DMA_RETRIES; retries++) {
+	txd = device->device_prep_dma_memcpy(chan, dest, unmap->addr[0], len,
-		txd = device->device_prep_dma_memcpy(chan, dest,
+					     DMA_PREP_INTERRUPT);
-						     unmap->addr[0], len,
+	if (!txd)
-						     DMA_PREP_INTERRUPT);
-		if (txd)
-			break;
-		set_current_state(TASK_INTERRUPTIBLE);
-		schedule_timeout(DMA_OUT_RESOURCE_TO);
-	}
-	if (!txd) {
-		qp->dma_tx_prep_err++;
 		goto err_get_unmap;
-	}
 	txd->callback_result = ntb_tx_copy_callback;
 	txd->callback_param = entry;

drivers/ntb/test/ntb_perf.c+2−2

@@ -90,11 +90,11 @@ MODULE_PARM_DESC(max_mw_size, "Limit size of large memory windows"); · 89 unmodified lines
90		90
91	static unsigned int seg_order = 19; /* 512K */	91	static unsigned int seg_order = 19; /* 512K */
92	module_param(seg_order, uint, 0644);	92	module_param(seg_order, uint, 0644);
93	MODULE_PARM_DESC(seg_order, "size order [n^2] of buffer segment for testing");	93	MODULE_PARM_DESC(seg_order, "size order [2^n] of buffer segment for testing");
94		94
95	static unsigned int run_order = 32; /* 4G */	95	static unsigned int run_order = 32; /* 4G */
96	module_param(run_order, uint, 0644);	96	module_param(run_order, uint, 0644);
97	MODULE_PARM_DESC(run_order, "size order [n^2] of total data to transfer");	97	MODULE_PARM_DESC(run_order, "size order [2^n] of total data to transfer");
98		98
99	static bool use_dma; /* default to 0 */	99	static bool use_dma; /* default to 0 */
100	module_param(use_dma, bool, 0644);	100	module_param(use_dma, bool, 0644);

drivers/pci/access.c+6−6

@@ -896,7 +896,7 @@ int pci_read_config_byte(const struct pci_dev dev, int where, u8 val) · 895 unmodified lines
896	{	896	{
897	if (pci_dev_is_disconnected(dev)) {	897	if (pci_dev_is_disconnected(dev)) {
898	*val = ~0;	898	*val = ~0;
899	return -ENODEV;	899	return PCIBIOS_DEVICE_NOT_FOUND;
900	}	900	}
901	return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);	901	return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
902	}	902	}
@@ -906,7 +906,7 @@ int pci_read_config_word(const struct pci_dev dev, int where, u16 val) · 3 unmodified lines
906	{	906	{
907	if (pci_dev_is_disconnected(dev)) {	907	if (pci_dev_is_disconnected(dev)) {
908	*val = ~0;	908	*val = ~0;
909	return -ENODEV;	909	return PCIBIOS_DEVICE_NOT_FOUND;
910	}	910	}
911	return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);	911	return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
912	}	912	}
@@ -917,7 +917,7 @@ int pci_read_config_dword(const struct pci_dev *dev, int where, · 4 unmodified lines
917	{	917	{
918	if (pci_dev_is_disconnected(dev)) {	918	if (pci_dev_is_disconnected(dev)) {
919	*val = ~0;	919	*val = ~0;
920	return -ENODEV;	920	return PCIBIOS_DEVICE_NOT_FOUND;
921	}	921	}
922	return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);	922	return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
923	}	923	}
@@ -926,7 +926,7 @@ EXPORT_SYMBOL(pci_read_config_dword); · 2 unmodified lines
926	int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)	926	int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)
927	{	927	{
928	if (pci_dev_is_disconnected(dev))	928	if (pci_dev_is_disconnected(dev))
929	return -ENODEV;	929	return PCIBIOS_DEVICE_NOT_FOUND;
930	return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);	930	return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
931	}	931	}
932	EXPORT_SYMBOL(pci_write_config_byte);	932	EXPORT_SYMBOL(pci_write_config_byte);
@@ -934,7 +934,7 @@ EXPORT_SYMBOL(pci_write_config_byte); · 1 unmodified line
934	int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)	934	int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)
935	{	935	{
936	if (pci_dev_is_disconnected(dev))	936	if (pci_dev_is_disconnected(dev))
937	return -ENODEV;	937	return PCIBIOS_DEVICE_NOT_FOUND;
938	return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);	938	return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
939	}	939	}
940	EXPORT_SYMBOL(pci_write_config_word);	940	EXPORT_SYMBOL(pci_write_config_word);
@@ -943,7 +943,7 @@ int pci_write_config_dword(const struct pci_dev *dev, int where, · 2 unmodified lines
943	u32 val)	943	u32 val)
944	{	944	{
945	if (pci_dev_is_disconnected(dev))	945	if (pci_dev_is_disconnected(dev))
946	return -ENODEV;	946	return PCIBIOS_DEVICE_NOT_FOUND;
947	return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);	947	return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
948	}	948	}
949	EXPORT_SYMBOL(pci_write_config_dword);	949	EXPORT_SYMBOL(pci_write_config_dword);

drivers/pci/endpoint/functions/Kconfig+1−0

@@ -5,6 +5,7 @@ · 4 unmodified lines
5	config PCI_EPF_TEST	5	config PCI_EPF_TEST
6	tristate "PCI Endpoint Test driver"	6	tristate "PCI Endpoint Test driver"
7	depends on PCI_ENDPOINT	7	depends on PCI_ENDPOINT
		8	select CRC32
8	help	9	help
9	Enable this configuration option to enable the test driver	10	Enable this configuration option to enable the test driver
10	for PCI Endpoint.	11	for PCI Endpoint.

drivers/pinctrl/pinctrl-amd.c+41−50

@@ -495,64 +495,54 @@ static struct irq_chip amd_gpio_irqchip = { · 494 unmodified lines
495	.flags = IRQCHIP_SKIP_SET_WAKE,	495	.flags = IRQCHIP_SKIP_SET_WAKE,
496	};	496	};
497		497
498	static void amd_gpio_irq_handler(struct irq_desc *desc)	498	#define PIN_IRQ_PENDING (BIT(INTERRUPT_STS_OFF) \| BIT(WAKE_STS_OFF))
		499
		500	static irqreturn_t amd_gpio_irq_handler(int irq, void *dev_id)
499	{	501	{
500	u32 i;	502	struct amd_gpio *gpio_dev = dev_id;
501	u32 off;	503	struct gpio_chip *gc = &gpio_dev->gc;
502	u32 reg;	504	irqreturn_t ret = IRQ_NONE;
503	u32 pin_reg;	505	unsigned int i, irqnr;
504	u64 reg64;
505	int handled = 0;
506	unsigned int irq;
507	unsigned long flags;	506	unsigned long flags;
508	struct irq_chip *chip = irq_desc_get_chip(desc);	507	u32 *regs, regval;
509	struct gpio_chip *gc = irq_desc_get_handler_data(desc);	508	u64 status, mask;
510	struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
511		509
512	chained_irq_enter(chip, desc);	510	/* Read the wake status */
513	/enable GPIO interrupt again/
514	raw_spin_lock_irqsave(&gpio_dev->lock, flags);	511	raw_spin_lock_irqsave(&gpio_dev->lock, flags);
515	reg = readl(gpio_dev->base + WAKE_INT_STATUS_REG1);	512	status = readl(gpio_dev->base + WAKE_INT_STATUS_REG1);
516	reg64 = reg;	513	status <<= 32;
517	reg64 = reg64 << 32;	514	status \|= readl(gpio_dev->base + WAKE_INT_STATUS_REG0);
518
519	reg = readl(gpio_dev->base + WAKE_INT_STATUS_REG0);
520	reg64 \|= reg;
521	raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);	515	raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
522		516
523	/*	517	/* Bit 0-45 contain the relevant status bits */
524	* first 46 bits indicates interrupt status.	518	status &= (1ULL << 46) - 1;
525	* one bit represents four interrupt sources.	519	regs = gpio_dev->base;
526	*/	520	for (mask = 1, irqnr = 0; status; mask <<= 1, regs += 4, irqnr += 4) {
527	for (off = 0; off < 46 ; off++) {	521	if (!(status & mask))
528	if (reg64 & BIT(off)) {	522	continue;
529	for (i = 0; i < 4; i++) {	523	status &= ~mask;
530	pin_reg = readl(gpio_dev->base +	524
531	(off * 4 + i) * 4);	525	/* Each status bit covers four pins */
532	if ((pin_reg & BIT(INTERRUPT_STS_OFF)) \|\|	526	for (i = 0; i < 4; i++) {
533	(pin_reg & BIT(WAKE_STS_OFF))) {	527	regval = readl(regs + i);
534	irq = irq_find_mapping(gc->irqdomain,	528	if (!(regval & PIN_IRQ_PENDING))
535	off * 4 + i);	529	continue;
536	generic_handle_irq(irq);	530	irq = irq_find_mapping(gc->irqdomain, irqnr + i);
537	writel(pin_reg,	531	generic_handle_irq(irq);
538	gpio_dev->base	532	/* Clear interrupt */
539	+ (off * 4 + i) * 4);	533	writel(regval, regs + i);
540	handled++;	534	ret = IRQ_HANDLED;
541	}
542	}
543	}	535	}
544	}	536	}
545		537
546	if (handled == 0)	538	/* Signal EOI to the GPIO unit */
547	handle_bad_irq(desc);
548
549	raw_spin_lock_irqsave(&gpio_dev->lock, flags);	539	raw_spin_lock_irqsave(&gpio_dev->lock, flags);
550	reg = readl(gpio_dev->base + WAKE_INT_MASTER_REG);	540	regval = readl(gpio_dev->base + WAKE_INT_MASTER_REG);
551	reg \|= EOI_MASK;	541	regval \|= EOI_MASK;
552	writel(reg, gpio_dev->base + WAKE_INT_MASTER_REG);	542	writel(regval, gpio_dev->base + WAKE_INT_MASTER_REG);
553	raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);	543	raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
554		544
555	chained_irq_exit(chip, desc);	545	return ret;
556	}	546	}
557		547
558	static int amd_get_groups_count(struct pinctrl_dev *pctldev)	548	static int amd_get_groups_count(struct pinctrl_dev *pctldev)
@@ -821,10 +811,11 @@ static int amd_gpio_probe(struct platform_device *pdev) · 262 unmodified lines
821	goto out2;	811	goto out2;
822	}	812	}
823		813
824	gpiochip_set_chained_irqchip(&gpio_dev->gc,	814	ret = devm_request_irq(&pdev->dev, irq_base, amd_gpio_irq_handler, 0,
825	&amd_gpio_irqchip,	815	KBUILD_MODNAME, gpio_dev);
826	irq_base,	816	if (ret)
827	amd_gpio_irq_handler);	817	goto out2;
		818
828	platform_set_drvdata(pdev, gpio_dev);	819	platform_set_drvdata(pdev, gpio_dev);
829		820
830	dev_dbg(&pdev->dev, "amd gpio driver loaded\n");	821	dev_dbg(&pdev->dev, "amd gpio driver loaded\n");

drivers/pinctrl/stm32/pinctrl-stm32.c+1−1

@@ -798,7 +798,7 @@ static int stm32_pconf_parse_conf(struct pinctrl_dev *pctldev, · 797 unmodified lines
798	break;	798	break;
799	case PIN_CONFIG_OUTPUT:	799	case PIN_CONFIG_OUTPUT:
800	__stm32_gpio_set(bank, offset, arg);	800	__stm32_gpio_set(bank, offset, arg);
801	ret = stm32_pmx_gpio_set_direction(pctldev, NULL, pin, false);	801	ret = stm32_pmx_gpio_set_direction(pctldev, range, pin, false);
802	break;	802	break;
803	default:	803	default:
804	ret = -EINVAL;	804	ret = -EINVAL;

drivers/platform/x86/intel_telemetry_debugfs.c+7−9

 	} \
 }
-#ifdef CONFIG_PM_SLEEP
 static u8 suspend_prep_ok;
 static u32 suspend_shlw_ctr_temp, suspend_deep_ctr_temp;
 static u64 suspend_shlw_res_temp, suspend_deep_res_temp;
-#endif
 struct telemetry_susp_stats {
 	u32 shlw_swake_ctr;
 	.release	= single_release,
 };
-#ifdef CONFIG_PM_SLEEP
 static int pm_suspend_prep_cb(void)
 {
 	struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 static struct notifier_block pm_notifier = {
 	.notifier_call = pm_notification,
 };
-#endif /* CONFIG_PM_SLEEP */
 static int __init telemetry_debugfs_init(void)
 {
 	if (err < 0)
 		return -EINVAL;
-#ifdef CONFIG_PM_SLEEP
 	register_pm_notifier(&pm_notifier);
-#endif /* CONFIG_PM_SLEEP */
 	debugfs_conf->telemetry_dbg_dir = debugfs_create_dir("telemetry", NULL);
-	if (!debugfs_conf->telemetry_dbg_dir)
+	if (!debugfs_conf->telemetry_dbg_dir) {
-		return -ENOMEM;
+		err = -ENOMEM;
+		goto out_pm;
+	}
 	f = debugfs_create_file("pss_info", S_IFREG | S_IRUGO,
 				debugfs_conf->telemetry_dbg_dir, NULL,
 out:
 	debugfs_remove_recursive(debugfs_conf->telemetry_dbg_dir);
 	debugfs_conf->telemetry_dbg_dir = NULL;
+out_pm:
+	unregister_pm_notifier(&pm_notifier);
 	return err;
 }
 {
 	debugfs_remove_recursive(debugfs_conf->telemetry_dbg_dir);
 	debugfs_conf->telemetry_dbg_dir = NULL;
+	unregister_pm_notifier(&pm_notifier);
 }
 late_initcall(telemetry_debugfs_init);

drivers/s390/cio/vfio_ccw_ops.c+6−6

@@ -70,14 +70,14 @@ static ssize_t name_show(struct kobject kobj, struct device dev, char *buf) · 69 unmodified lines
70	{	70	{
71	return sprintf(buf, "I/O subchannel (Non-QDIO)\n");	71	return sprintf(buf, "I/O subchannel (Non-QDIO)\n");
72	}	72	}
73	MDEV_TYPE_ATTR_RO(name);	73	static MDEV_TYPE_ATTR_RO(name);
74		74
75	static ssize_t device_api_show(struct kobject kobj, struct device dev,	75	static ssize_t device_api_show(struct kobject kobj, struct device dev,
76	char *buf)	76	char *buf)
77	{	77	{
78	return sprintf(buf, "%s\n", VFIO_DEVICE_API_CCW_STRING);	78	return sprintf(buf, "%s\n", VFIO_DEVICE_API_CCW_STRING);
79	}	79	}
80	MDEV_TYPE_ATTR_RO(device_api);	80	static MDEV_TYPE_ATTR_RO(device_api);
81		81
82	static ssize_t available_instances_show(struct kobject *kobj,	82	static ssize_t available_instances_show(struct kobject *kobj,
83	struct device dev, char buf)	83	struct device dev, char buf)
@@ -86,7 +86,7 @@ static ssize_t available_instances_show(struct kobject *kobj, · 2 unmodified lines
86		86
87	return sprintf(buf, "%d\n", atomic_read(&private->avail));	87	return sprintf(buf, "%d\n", atomic_read(&private->avail));
88	}	88	}
89	MDEV_TYPE_ATTR_RO(available_instances);	89	static MDEV_TYPE_ATTR_RO(available_instances);
90		90
91	static struct attribute *mdev_types_attrs[] = {	91	static struct attribute *mdev_types_attrs[] = {
92	&mdev_type_attr_name.attr,	92	&mdev_type_attr_name.attr,
@@ -100,7 +100,7 @@ static struct attribute_group mdev_type_group = { · 7 unmodified lines
100	.attrs = mdev_types_attrs,	100	.attrs = mdev_types_attrs,
101	};	101	};
102		102
103	struct attribute_group *mdev_type_groups[] = {	103	static struct attribute_group *mdev_type_groups[] = {
104	&mdev_type_group,	104	&mdev_type_group,
105	NULL,	105	NULL,
106	};	106	};
@@ -152,7 +152,7 @@ static int vfio_ccw_mdev_open(struct mdev_device *mdev) · 45 unmodified lines
152	&events, &private->nb);	152	&events, &private->nb);
153	}	153	}
154		154
155	void vfio_ccw_mdev_release(struct mdev_device *mdev)	155	static void vfio_ccw_mdev_release(struct mdev_device *mdev)
156	{	156	{
157	struct vfio_ccw_private *private =	157	struct vfio_ccw_private *private =
158	dev_get_drvdata(mdev_parent_dev(mdev));	158	dev_get_drvdata(mdev_parent_dev(mdev));
@@ -233,7 +233,7 @@ static int vfio_ccw_mdev_get_region_info(struct vfio_region_info *info, · 74 unmodified lines
233	}	233	}
234	}	234	}
235		235
236	int vfio_ccw_mdev_get_irq_info(struct vfio_irq_info *info)	236	static int vfio_ccw_mdev_get_irq_info(struct vfio_irq_info *info)
237	{	237	{
238	if (info->index != VFIO_CCW_IO_IRQ_INDEX)	238	if (info->index != VFIO_CCW_IO_IRQ_INDEX)
239	return -EINVAL;	239	return -EINVAL;

drivers/s390/crypto/ap_bus.c+24−14

@@ -668,10 +668,28 @@ static int ap_device_probe(struct device *dev) · 667 unmodified lines
668	struct ap_driver *ap_drv = to_ap_drv(dev->driver);	668	struct ap_driver *ap_drv = to_ap_drv(dev->driver);
669	int rc;	669	int rc;
670		670
		671	/* Add queue/card to list of active queues/cards */
		672	spin_lock_bh(&ap_list_lock);
		673	if (is_card_dev(dev))
		674	list_add(&to_ap_card(dev)->list, &ap_card_list);
		675	else
		676	list_add(&to_ap_queue(dev)->list,
		677	&to_ap_queue(dev)->card->queues);
		678	spin_unlock_bh(&ap_list_lock);
		679
671	ap_dev->drv = ap_drv;	680	ap_dev->drv = ap_drv;
672	rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;	681	rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
673	if (rc)	682
		683	if (rc) {
		684	spin_lock_bh(&ap_list_lock);
		685	if (is_card_dev(dev))
		686	list_del_init(&to_ap_card(dev)->list);
		687	else
		688	list_del_init(&to_ap_queue(dev)->list);
		689	spin_unlock_bh(&ap_list_lock);
674	ap_dev->drv = NULL;	690	ap_dev->drv = NULL;
		691	}
		692
675	return rc;	693	return rc;
676	}	694	}
677		695
@@ -680,14 +698,17 @@ static int ap_device_remove(struct device *dev) · 2 unmodified lines
680	struct ap_device *ap_dev = to_ap_dev(dev);	698	struct ap_device *ap_dev = to_ap_dev(dev);
681	struct ap_driver *ap_drv = ap_dev->drv;	699	struct ap_driver *ap_drv = ap_dev->drv;
682		700
		701	if (ap_drv->remove)
		702	ap_drv->remove(ap_dev);
		703
		704	/* Remove queue/card from list of active queues/cards */
683	spin_lock_bh(&ap_list_lock);	705	spin_lock_bh(&ap_list_lock);
684	if (is_card_dev(dev))	706	if (is_card_dev(dev))
685	list_del_init(&to_ap_card(dev)->list);	707	list_del_init(&to_ap_card(dev)->list);
686	else	708	else
687	list_del_init(&to_ap_queue(dev)->list);	709	list_del_init(&to_ap_queue(dev)->list);
688	spin_unlock_bh(&ap_list_lock);	710	spin_unlock_bh(&ap_list_lock);
689	if (ap_drv->remove)	711
690	ap_drv->remove(ap_dev);
691	return 0;	712	return 0;
692	}	713	}
693		714
@@ -1056,10 +1077,6 @@ static void ap_scan_bus(struct work_struct *unused) · 362 unmodified lines
1056	}	1077	}
1057	/* get it and thus adjust reference counter */	1078	/* get it and thus adjust reference counter */
1058	get_device(&ac->ap_dev.device);	1079	get_device(&ac->ap_dev.device);
1059	/* Add card device to card list */
1060	spin_lock_bh(&ap_list_lock);
1061	list_add(&ac->list, &ap_card_list);
1062	spin_unlock_bh(&ap_list_lock);
1063	}	1080	}
1064	/* now create the new queue device */	1081	/* now create the new queue device */
1065	aq = ap_queue_create(qid, type);	1082	aq = ap_queue_create(qid, type);
@@ -1070,10 +1087,6 @@ static void ap_scan_bus(struct work_struct *unused) · 4 unmodified lines
1070	aq->ap_dev.device.parent = &ac->ap_dev.device;	1087	aq->ap_dev.device.parent = &ac->ap_dev.device;
1071	dev_set_name(&aq->ap_dev.device,	1088	dev_set_name(&aq->ap_dev.device,
1072	"%02x.%04x", id, dom);	1089	"%02x.%04x", id, dom);
1073	/* Add queue device to card queue list */
1074	spin_lock_bh(&ap_list_lock);
1075	list_add(&aq->list, &ac->queues);
1076	spin_unlock_bh(&ap_list_lock);
1077	/* Start with a device reset */	1090	/* Start with a device reset */
1078	spin_lock_bh(&aq->lock);	1091	spin_lock_bh(&aq->lock);
1079	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));	1092	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));
@@ -1081,9 +1094,6 @@ static void ap_scan_bus(struct work_struct *unused) · 1 unmodified line
1081	/* Register device */	1094	/* Register device */
1082	rc = device_register(&aq->ap_dev.device);	1095	rc = device_register(&aq->ap_dev.device);
1083	if (rc) {	1096	if (rc) {
1084	spin_lock_bh(&ap_list_lock);
1085	list_del_init(&aq->list);
1086	spin_unlock_bh(&ap_list_lock);
1087	put_device(&aq->ap_dev.device);	1097	put_device(&aq->ap_dev.device);
1088	continue;	1098	continue;
1089	}	1099	}

drivers/s390/crypto/ap_card.c+8−1

 static void ap_card_device_release(struct device *dev)
 {
-	kfree(to_ap_card(dev));
+	struct ap_card *ac = to_ap_card(dev);
+	if (!list_empty(&ac->list)) {
+		spin_lock_bh(&ap_list_lock);
+		list_del_init(&ac->list);
+		spin_unlock_bh(&ap_list_lock);
+	}
+	kfree(ac);
 }
 struct ap_card *ap_card_create(int id, int queue_depth, int device_type,

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

 static void ap_queue_device_release(struct device *dev)
 {
-	kfree(to_ap_queue(dev));
+	struct ap_queue *aq = to_ap_queue(dev);
+	if (!list_empty(&aq->list)) {
+		spin_lock_bh(&ap_list_lock);
+		list_del_init(&aq->list);
+		spin_unlock_bh(&ap_list_lock);
+	}
+	kfree(aq);
 }
 struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type)

drivers/s390/net/netiucv.c+2−2

 		privptr->conn = NULL; privptr->fsm = NULL;
 		/* privptr gets freed by free_netdev() */
 	}
-	free_netdev(dev);
 }
 /**
 	dev->mtu	         = NETIUCV_MTU_DEFAULT;
 	dev->min_mtu		 = 576;
 	dev->max_mtu		 = NETIUCV_MTU_MAX;
-	dev->destructor          = netiucv_free_netdevice;
+	dev->needs_free_netdev   = true;
+	dev->priv_destructor     = netiucv_free_netdevice;
 	dev->hard_header_len     = NETIUCV_HDRLEN;
 	dev->addr_len            = 0;
 	dev->type                = ARPHRD_SLIP;

drivers/scsi/qedi/qedi_fw.c+0−1

@@ -870,7 +870,6 @@ static void qedi_process_cmd_cleanup_resp(struct qedi_ctx *qedi, · 869 unmodified lines
870	QEDI_ERR(&qedi->dbg_ctx,	870	QEDI_ERR(&qedi->dbg_ctx,
871	"Delayed or untracked cleanup response, itt=0x%x, tid=0x%x, cid=0x%x, task=%p\n",	871	"Delayed or untracked cleanup response, itt=0x%x, tid=0x%x, cid=0x%x, task=%p\n",
872	protoitt, cqe->itid, qedi_conn->iscsi_conn_id, task);	872	protoitt, cqe->itid, qedi_conn->iscsi_conn_id, task);
873	WARN_ON(1);
874	}	873	}
875	}	874	}
876		875

drivers/scsi/qedi/qedi_main.c+1−3

 void qedi_clear_task_idx(struct qedi_ctx *qedi, int idx)
 {
-	if (!test_and_clear_bit(idx, qedi->task_idx_map)) {
+	if (!test_and_clear_bit(idx, qedi->task_idx_map))
 		QEDI_ERR(&qedi->dbg_ctx,
 			 "FW task context, already cleared, tid=0x%x\n", idx);
-		WARN_ON(1);
-	}
 }
 void qedi_update_itt_map(struct qedi_ctx *qedi, u32 tid, u32 proto_itt,

drivers/staging/iio/cdc/ad7152.c+1−5

 	if (i >= ARRAY_SIZE(ad7152_filter_rate_table))
 		i = ARRAY_SIZE(ad7152_filter_rate_table) - 1;
-	mutex_lock(&chip->state_lock);
 	ret = i2c_smbus_write_byte_data(chip->client,
 					AD7152_REG_CFG2, AD7152_CFG2_OSR(i));
-	if (ret < 0) {
+	if (ret < 0)
-		mutex_unlock(&chip->state_lock);
 		return ret;
-	}
 	chip->filter_rate_setup = i;
-	mutex_unlock(&chip->state_lock);
 	return ret;
 }

drivers/staging/rtl8188eu/os_dep/mon.c+1−1

@@ -152,7 +152,7 @@ static const struct net_device_ops mon_netdev_ops = { · 151 unmodified lines
152	static void mon_setup(struct net_device *dev)	152	static void mon_setup(struct net_device *dev)
153	{	153	{
154	dev->netdev_ops = &mon_netdev_ops;	154	dev->netdev_ops = &mon_netdev_ops;
155	dev->destructor = free_netdev;	155	dev->needs_free_netdev = true;
156	ether_setup(dev);	156	ether_setup(dev);
157	dev->priv_flags \|= IFF_NO_QUEUE;	157	dev->priv_flags \|= IFF_NO_QUEUE;
158	dev->type = ARPHRD_IEEE80211;	158	dev->type = ARPHRD_IEEE80211;

drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c+2−1

@@ -2667,7 +2667,8 @@ static int rtw_cfg80211_add_monitor_if (struct adapter padapter, char name, st · 2666 unmodified lines
2667	mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP;	2667	mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP;
2668	strncpy(mon_ndev->name, name, IFNAMSIZ);	2668	strncpy(mon_ndev->name, name, IFNAMSIZ);
2669	mon_ndev->name[IFNAMSIZ - 1] = 0;	2669	mon_ndev->name[IFNAMSIZ - 1] = 0;
2670	mon_ndev->destructor = rtw_ndev_destructor;	2670	mon_ndev->needs_free_netdev = true;
		2671	mon_ndev->priv_destructor = rtw_ndev_destructor;
2671		2672
2672	mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops;	2673	mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops;
2673		2674

drivers/staging/rtl8723bs/os_dep/os_intfs.c+0−2

@@ -1207,8 +1207,6 @@ void rtw_ndev_destructor(struct net_device *ndev) · 1206 unmodified lines
1207		1207
1208	if (ndev->ieee80211_ptr)	1208	if (ndev->ieee80211_ptr)
1209	kfree((u8 *)ndev->ieee80211_ptr);	1209	kfree((u8 *)ndev->ieee80211_ptr);
1210
1211	free_netdev(ndev);
1212	}	1210	}
1213		1211
1214	void rtw_dev_unload(struct adapter *padapter)	1212	void rtw_dev_unload(struct adapter *padapter)

drivers/staging/rtl8723bs/os_dep/osdep_service.c+1−1

@@ -160,7 +160,7 @@ static int isFileReadable(char *path) · 159 unmodified lines
160	oldfs = get_fs(); set_fs(get_ds());	160	oldfs = get_fs(); set_fs(get_ds());
161		161
162	if (1!=readFile(fp, &buf, 1))	162	if (1!=readFile(fp, &buf, 1))
163	ret = PTR_ERR(fp);	163	ret = -EINVAL;
164		164
165	set_fs(oldfs);	165	set_fs(oldfs);
166	filp_close(fp, NULL);	166	filp_close(fp, NULL);

drivers/target/iscsi/iscsi_target.c+20−2

 	 */
 	if (dump_payload)
 		goto after_immediate_data;
+	/*
+	 * Check for underflow case where both EDTL and immediate data payload
+	 * exceeds what is presented by CDB's TRANSFER LENGTH, and what has
+	 * already been set in target_cmd_size_check() as se_cmd->data_length.
+	 *
+	 * For this special case, fail the command and dump the immediate data
+	 * payload.
+	 */
+	if (cmd->first_burst_len > cmd->se_cmd.data_length) {
+		cmd->sense_reason = TCM_INVALID_CDB_FIELD;
+		goto after_immediate_data;
+	}
 	immed_ret = iscsit_handle_immediate_data(cmd, hdr,
 					cmd->first_burst_len);
 	 * always sleep waiting for RX/TX thread shutdown to complete
 	 * within iscsit_close_connection().
 	 */
-	if (!conn->conn_transport->rdma_shutdown)
+	if (!conn->conn_transport->rdma_shutdown) {
 		sleep = cmpxchg(&conn->tx_thread_active, true, false);
+		if (!sleep)
+			return;
+	}
 	atomic_set(&conn->conn_logout_remove, 0);
 	complete(&conn->conn_logout_comp);
 {
 	int sleep = 1;
-	if (!conn->conn_transport->rdma_shutdown)
+	if (!conn->conn_transport->rdma_shutdown) {
 		sleep = cmpxchg(&conn->tx_thread_active, true, false);
+		if (!sleep)
+			return;
+	}
 	atomic_set(&conn->conn_logout_remove, 0);
 	complete(&conn->conn_logout_comp);

drivers/target/target_core_internal.h+1−1

@@ -136,7 +136,7 @@ int init_se_kmem_caches(void); · 135 unmodified lines
136	void release_se_kmem_caches(void);	136	void release_se_kmem_caches(void);
137	u32 scsi_get_new_index(scsi_index_t);	137	u32 scsi_get_new_index(scsi_index_t);
138	void transport_subsystem_check_init(void);	138	void transport_subsystem_check_init(void);
139	void transport_cmd_finish_abort(struct se_cmd *, int);	139	int transport_cmd_finish_abort(struct se_cmd *, int);
140	unsigned char transport_dump_cmd_direction(struct se_cmd );	140	unsigned char transport_dump_cmd_direction(struct se_cmd );
141	void transport_dump_dev_state(struct se_device , char , int *);	141	void transport_dump_dev_state(struct se_device , char , int *);
142	void transport_dump_dev_info(struct se_device , struct se_lun ,	142	void transport_dump_dev_info(struct se_device , struct se_lun ,

drivers/target/target_core_tmr.c+8−8

@@ -75,7 +75,7 @@ void core_tmr_release_req(struct se_tmr_req *tmr) · 74 unmodified lines
75	kfree(tmr);	75	kfree(tmr);
76	}	76	}
77		77
78	static void core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas)	78	static int core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas)
79	{	79	{
80	unsigned long flags;	80	unsigned long flags;
81	bool remove = true, send_tas;	81	bool remove = true, send_tas;
@@ -91,7 +91,7 @@ static void core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas) · 9 unmodified lines
91	transport_send_task_abort(cmd);	91	transport_send_task_abort(cmd);
92	}	92	}
93		93
94	transport_cmd_finish_abort(cmd, remove);	94	return transport_cmd_finish_abort(cmd, remove);
95	}	95	}
96		96
97	static int target_check_cdb_and_preempt(struct list_head *list,	97	static int target_check_cdb_and_preempt(struct list_head *list,
@@ -184,8 +184,8 @@ void core_tmr_abort_task( · 86 unmodified lines
184	cancel_work_sync(&se_cmd->work);	184	cancel_work_sync(&se_cmd->work);
185	transport_wait_for_tasks(se_cmd);	185	transport_wait_for_tasks(se_cmd);
186		186
187	transport_cmd_finish_abort(se_cmd, true);	187	if (!transport_cmd_finish_abort(se_cmd, true))
188	target_put_sess_cmd(se_cmd);	188	target_put_sess_cmd(se_cmd);
189		189
190	printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"	190	printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
191	" ref_tag: %llu\n", ref_tag);	191	" ref_tag: %llu\n", ref_tag);
@@ -281,8 +281,8 @@ static void core_tmr_drain_tmr_list( · 89 unmodified lines
281	cancel_work_sync(&cmd->work);	281	cancel_work_sync(&cmd->work);
282	transport_wait_for_tasks(cmd);	282	transport_wait_for_tasks(cmd);
283		283
284	transport_cmd_finish_abort(cmd, 1);	284	if (!transport_cmd_finish_abort(cmd, 1))
285	target_put_sess_cmd(cmd);	285	target_put_sess_cmd(cmd);
286	}	286	}
287	}	287	}
288		288
@@ -380,8 +380,8 @@ static void core_tmr_drain_state_list( · 91 unmodified lines
380	cancel_work_sync(&cmd->work);	380	cancel_work_sync(&cmd->work);
381	transport_wait_for_tasks(cmd);	381	transport_wait_for_tasks(cmd);
382		382
383	core_tmr_handle_tas_abort(cmd, tas);	383	if (!core_tmr_handle_tas_abort(cmd, tas))
384	target_put_sess_cmd(cmd);	384	target_put_sess_cmd(cmd);
385	}	385	}
386	}	386	}
387		387

drivers/target/target_core_transport.c+6−3

 		percpu_ref_put(&lun->lun_ref);
 }
-void transport_cmd_finish_abort(struct se_cmd *cmd, int remove)
+int transport_cmd_finish_abort(struct se_cmd *cmd, int remove)
 {
 	bool ack_kref = (cmd->se_cmd_flags & SCF_ACK_KREF);
+	int ret = 0;
 	if (cmd->se_cmd_flags & SCF_SE_LUN_CMD)
 		transport_lun_remove_cmd(cmd);
 		cmd->se_tfo->aborted_task(cmd);
 	if (transport_cmd_check_stop_to_fabric(cmd))
-		return;
+		return 1;
 	if (remove && ack_kref)
-		transport_put_cmd(cmd);
+		ret = transport_put_cmd(cmd);
+	return ret;
 }
 static void target_complete_failure_work(struct work_struct *work)

drivers/usb/gadget/composite.c+5−6

@@ -315,6 +315,9 @@ void usb_remove_function(struct usb_configuration c, struct usb_function f) · 314 unmodified lines
315	list_del(&f->list);	315	list_del(&f->list);
316	if (f->unbind)	316	if (f->unbind)
317	f->unbind(c, f);	317	f->unbind(c, f);
		318
		319	if (f->bind_deactivated)
		320	usb_function_activate(f);
318	}	321	}
319	EXPORT_SYMBOL_GPL(usb_remove_function);	322	EXPORT_SYMBOL_GPL(usb_remove_function);
320		323
@@ -956,12 +959,8 @@ static void remove_config(struct usb_composite_dev *cdev, · 635 unmodified lines
956		959
957	f = list_first_entry(&config->functions,	960	f = list_first_entry(&config->functions,
958	struct usb_function, list);	961	struct usb_function, list);
959	list_del(&f->list);	962
960	if (f->unbind) {	963	usb_remove_function(config, f);
961	DBG(cdev, "unbind function '%s'/%p\n", f->name, f);
962	f->unbind(config, f);
963	/* may free memory for "f" */
964	}
965	}	964	}
966	list_del(&config->list);	965	list_del(&config->list);
967	if (config->unbind) {	966	if (config->unbind) {

drivers/usb/gadget/function/f_phonet.c+1−1

@@ -281,7 +281,7 @@ static void pn_net_setup(struct net_device *dev) · 280 unmodified lines
281	dev->tx_queue_len = 1;	281	dev->tx_queue_len = 1;
282		282
283	dev->netdev_ops = &pn_netdev_ops;	283	dev->netdev_ops = &pn_netdev_ops;
284	dev->destructor = free_netdev;	284	dev->needs_free_netdev = true;
285	dev->header_ops = &phonet_header_ops;	285	dev->header_ops = &phonet_header_ops;
286	}	286	}
287		287

drivers/usb/gadget/legacy/inode.c+6−3

 	/* closing ep0 === shutdown all */
-	if (dev->gadget_registered)
+	if (dev->gadget_registered) {
 		usb_gadget_unregister_driver (&gadgetfs_driver);
+		dev->gadget_registered = false;
+	}
 	/* at this point "good" hardware has disconnected the
 	 * device from USB; the host won't see it any more.
 gadgetfs_suspend (struct usb_gadget *gadget)
 {
 	struct dev_data		*dev = get_gadget_data (gadget);
+	unsigned long		flags;
 	INFO (dev, "suspended from state %d\n", dev->state);
-	spin_lock (&dev->lock);
+	spin_lock_irqsave(&dev->lock, flags);
 	switch (dev->state) {
 	case STATE_DEV_SETUP:		// VERY odd... host died??
 	case STATE_DEV_CONNECTED:
 	default:
 		break;
 	}
-	spin_unlock (&dev->lock);
+	spin_unlock_irqrestore(&dev->lock, flags);
 }
 static struct usb_gadget_driver gadgetfs_driver = {

drivers/usb/gadget/udc/dummy_hcd.c+4−9

 		/* Report reset and disconnect events to the driver */
 		if (dum->driver && (disconnect || reset)) {
 			stop_activity(dum);
-			spin_unlock(&dum->lock);
 			if (reset)
 				usb_gadget_udc_reset(&dum->gadget, dum->driver);
 			else
 				dum->driver->disconnect(&dum->gadget);
-			spin_lock(&dum->lock);
 		}
 	} else if (dum_hcd->active != dum_hcd->old_active) {
-		if (dum_hcd->old_active && dum->driver->suspend) {
+		if (dum_hcd->old_active && dum->driver->suspend)
-			spin_unlock(&dum->lock);
 			dum->driver->suspend(&dum->gadget);
-			spin_lock(&dum->lock);
+		else if (!dum_hcd->old_active &&  dum->driver->resume)
-		} else if (!dum_hcd->old_active &&  dum->driver->resume) {
-			spin_unlock(&dum->lock);
 			dum->driver->resume(&dum->gadget);
-			spin_lock(&dum->lock);
-		}
 	}
 	dum_hcd->old_status = dum_hcd->port_status;
 	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
 	struct dummy		*dum = dum_hcd->dum;
+	spin_lock_irq(&dum->lock);
 	dum->driver = NULL;
+	spin_unlock_irq(&dum->lock);
 	return 0;
 }

drivers/usb/gadget/udc/net2280.c+1−8

 		nuke(&dev->ep[i]);
 	/* report disconnect; the driver is already quiesced */
-	if (driver) {
+	if (driver)
-		spin_unlock(&dev->lock);
 		driver->disconnect(&dev->gadget);
-		spin_lock(&dev->lock);
-	}
 	usb_reinit(dev);
 }
 		BIT(PCI_RETRY_ABORT_INTERRUPT))
 static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
-__releases(dev->lock)
-__acquires(dev->lock)
 {
 	struct net2280_ep	*ep;
 	u32			tmp, num, mask, scratch;
 			if (disconnect || reset) {
 				stop_activity(dev, dev->driver);
 				ep0_start(dev);
-				spin_unlock(&dev->lock);
 				if (reset)
 					usb_gadget_udc_reset
 						(&dev->gadget, dev->driver);
 				else
 					(dev->driver->disconnect)
 						(&dev->gadget);
-				spin_lock(&dev->lock);
 				return;
 			}
 		}

drivers/usb/host/xhci-mem.c+5−2

@@ -2119,11 +2119,12 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports, · 2118 unmodified lines
2119	{	2119	{
2120	u32 temp, port_offset, port_count;	2120	u32 temp, port_offset, port_count;
2121	int i;	2121	int i;
2122	u8 major_revision;	2122	u8 major_revision, minor_revision;
2123	struct xhci_hub *rhub;	2123	struct xhci_hub *rhub;
2124		2124
2125	temp = readl(addr);	2125	temp = readl(addr);
2126	major_revision = XHCI_EXT_PORT_MAJOR(temp);	2126	major_revision = XHCI_EXT_PORT_MAJOR(temp);
		2127	minor_revision = XHCI_EXT_PORT_MINOR(temp);
2127		2128
2128	if (major_revision == 0x03) {	2129	if (major_revision == 0x03) {
2129	rhub = &xhci->usb3_rhub;	2130	rhub = &xhci->usb3_rhub;
@@ -2137,7 +2138,9 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports, · 7 unmodified lines
2137	return;	2138	return;
2138	}	2139	}
2139	rhub->maj_rev = XHCI_EXT_PORT_MAJOR(temp);	2140	rhub->maj_rev = XHCI_EXT_PORT_MAJOR(temp);
2140	rhub->min_rev = XHCI_EXT_PORT_MINOR(temp);	2141
		2142	if (rhub->min_rev < minor_revision)
		2143	rhub->min_rev = minor_revision;
2141		2144
2142	/* Port offset and count in the third dword, see section 7.2 */	2145	/* Port offset and count in the third dword, see section 7.2 */
2143	temp = readl(addr + 2);	2146	temp = readl(addr + 2);

drivers/usb/host/xhci-pci.c+3−0

 	if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA &&
 			pdev->device == 0x1042)
 		xhci->quirks |= XHCI_BROKEN_STREAMS;
+	if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA &&
+			pdev->device == 0x1142)
+		xhci->quirks |= XHCI_TRUST_TX_LENGTH;
 	if (pdev->vendor == PCI_VENDOR_ID_TI && pdev->device == 0x8241)
 		xhci->quirks |= XHCI_LIMIT_ENDPOINT_INTERVAL_7;

drivers/video/fbdev/core/fbmon.c+1−1

@@ -1048,7 +1048,7 @@ void fb_edid_add_monspecs(unsigned char edid, struct fb_monspecs specs) · 1047 unmodified lines
1048		1048
1049	for (i = 0; i < (128 - edid[2]) / DETAILED_TIMING_DESCRIPTION_SIZE;	1049	for (i = 0; i < (128 - edid[2]) / DETAILED_TIMING_DESCRIPTION_SIZE;
1050	i++, block += DETAILED_TIMING_DESCRIPTION_SIZE)	1050	i++, block += DETAILED_TIMING_DESCRIPTION_SIZE)
1051	if (PIXEL_CLOCK)	1051	if (PIXEL_CLOCK != 0)
1052	edt[num++] = block - edid;	1052	edt[num++] = block - edid;
1053		1053
1054	/* Yikes, EDID data is totally useless */	1054	/* Yikes, EDID data is totally useless */

drivers/video/fbdev/smscufx.c+3−2

 	dev_dbg(dev->gdev, "%s %s - serial #%s\n",
 		usbdev->manufacturer, usbdev->product, usbdev->serial);
 	dev_dbg(dev->gdev, "vid_%04x&pid_%04x&rev_%04x driver's ufx_data struct at %p\n",
-		usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
+		le16_to_cpu(usbdev->descriptor.idVendor),
-		usbdev->descriptor.bcdDevice, dev);
+		le16_to_cpu(usbdev->descriptor.idProduct),
+		le16_to_cpu(usbdev->descriptor.bcdDevice), dev);
 	dev_dbg(dev->gdev, "console enable=%d\n", console);
 	dev_dbg(dev->gdev, "fb_defio enable=%d\n", fb_defio);

drivers/video/fbdev/udlfb.c+5−4

 	char *bufptr;
 	struct urb *urb;
-	pr_info("/dev/fb%d FB_BLANK mode %d --> %d\n",
+	pr_debug("/dev/fb%d FB_BLANK mode %d --> %d\n",
-		info->node, dev->blank_mode, blank_mode);
+		 info->node, dev->blank_mode, blank_mode);
 	if ((dev->blank_mode == FB_BLANK_POWERDOWN) &&
 	    (blank_mode != FB_BLANK_POWERDOWN)) {
 	pr_info("%s %s - serial #%s\n",
 		usbdev->manufacturer, usbdev->product, usbdev->serial);
 	pr_info("vid_%04x&pid_%04x&rev_%04x driver's dlfb_data struct at %p\n",
-		usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
+		le16_to_cpu(usbdev->descriptor.idVendor),
-		usbdev->descriptor.bcdDevice, dev);
+		le16_to_cpu(usbdev->descriptor.idProduct),
+		le16_to_cpu(usbdev->descriptor.bcdDevice), dev);
 	pr_info("console enable=%d\n", console);
 	pr_info("fb_defio enable=%d\n", fb_defio);
 	pr_info("shadow enable=%d\n", shadow);

drivers/video/fbdev/via/viafbdev.c+3−5

 }
 static void viafb_remove_proc(struct viafb_shared *shared)
 {
-	struct proc_dir_entry *viafb_entry = shared->proc_entry,
+	struct proc_dir_entry *viafb_entry = shared->proc_entry;
-		*iga1_entry = shared->iga1_proc_entry,
-		*iga2_entry = shared->iga2_proc_entry;
 	if (!viafb_entry)
 		return;
-	remove_proc_entry("output_devices", iga2_entry);
+	remove_proc_entry("output_devices", shared->iga2_proc_entry);
 	remove_proc_entry("iga2", viafb_entry);
-	remove_proc_entry("output_devices", iga1_entry);
+	remove_proc_entry("output_devices", shared->iga1_proc_entry);
 	remove_proc_entry("iga1", viafb_entry);
 	remove_proc_entry("supported_output_devices", viafb_entry);

drivers/virtio/virtio_balloon.c+7−0

 }
 #endif
+static int virtballoon_validate(struct virtio_device *vdev)
+{
+	__virtio_clear_bit(vdev, VIRTIO_F_IOMMU_PLATFORM);
+	return 0;
+}
 static unsigned int features[] = {
 	VIRTIO_BALLOON_F_MUST_TELL_HOST,
 	VIRTIO_BALLOON_F_STATS_VQ,
 	.driver.name =	KBUILD_MODNAME,
 	.driver.owner =	THIS_MODULE,
 	.id_table =	id_table,
+	.validate =	virtballoon_validate,
 	.probe =	virtballoon_probe,
 	.remove =	virtballoon_remove,
 	.config_changed = virtballoon_changed,

fs/autofs4/dev-ioctl.c+1−1

@@ -344,7 +344,7 @@ static int autofs_dev_ioctl_fail(struct file *fp, · 343 unmodified lines
344	int status;	344	int status;
345		345
346	token = (autofs_wqt_t) param->fail.token;	346	token = (autofs_wqt_t) param->fail.token;
347	status = param->fail.status ? param->fail.status : -ENOENT;	347	status = param->fail.status < 0 ? param->fail.status : -ENOENT;
348	return autofs4_wait_release(sbi, token, status);	348	return autofs4_wait_release(sbi, token, status);
349	}	349	}
350		350

fs/btrfs/hash.c+4−1

 {
 	SHASH_DESC_ON_STACK(shash, tfm);
 	u32 *ctx = (u32 *)shash_desc_ctx(shash);
+	u32 retval;
 	int err;
 	shash->tfm = tfm;
 	err = crypto_shash_update(shash, address, length);
 	BUG_ON(err);
-	return *ctx;
+	retval = *ctx;
+	barrier_data(ctx);
+	return retval;
 }

fs/ceph/acl.c+1−0

@@ -131,6 +131,7 @@ int ceph_set_acl(struct inode inode, struct posix_acl acl, int type) · 130 unmodified lines
131	}	131	}
132		132
133	if (new_mode != old_mode) {	133	if (new_mode != old_mode) {
		134	newattrs.ia_ctime = current_time(inode);
134	newattrs.ia_mode = new_mode;	135	newattrs.ia_mode = new_mode;
135	newattrs.ia_valid = ATTR_MODE;	136	newattrs.ia_valid = ATTR_MODE;
136	ret = __ceph_setattr(inode, &newattrs);	137	ret = __ceph_setattr(inode, &newattrs);

fs/ceph/export.c+4−0

 		ceph_mdsc_put_request(req);
 		if (!inode)
 			return ERR_PTR(-ESTALE);
+		if (inode->i_nlink == 0) {
+			iput(inode);
+			return ERR_PTR(-ESTALE);
+		}
 	}
 	return d_obtain_alias(inode);

fs/ceph/inode.c+2−3

 		    attr->ia_size > inode->i_size) {
 			i_size_write(inode, attr->ia_size);
 			inode->i_blocks = calc_inode_blocks(attr->ia_size);
-			inode->i_ctime = attr->ia_ctime;
 			ci->i_reported_size = attr->ia_size;
 			dirtied |= CEPH_CAP_FILE_EXCL;
 		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
 		     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
 		     attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
 		     only ? "ctime only" : "ignored");
-		inode->i_ctime = attr->ia_ctime;
 		if (only) {
 			/*
 			 * if kernel wants to dirty ctime but nothing else,
 	if (dirtied) {
 		inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied,
 							   &prealloc_cf);
-		inode->i_ctime = current_time(inode);
+		inode->i_ctime = attr->ia_ctime;
 	}
 	release &= issued;
 		req->r_inode_drop = release;
 		req->r_args.setattr.mask = cpu_to_le32(mask);
 		req->r_num_caps = 1;
+		req->r_stamp = attr->ia_ctime;
 		err = ceph_mdsc_do_request(mdsc, NULL, req);
 	}
 	dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,

fs/ceph/mds_client.c+1−3

 ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op, int mode)
 {
 	struct ceph_mds_request *req = kzalloc(sizeof(*req), GFP_NOFS);
-	struct timespec ts;
 	if (!req)
 		return ERR_PTR(-ENOMEM);
 	init_completion(&req->r_safe_completion);
 	INIT_LIST_HEAD(&req->r_unsafe_item);
-	ktime_get_real_ts(&ts);
+	req->r_stamp = timespec_trunc(current_kernel_time(), mdsc->fsc->sb->s_time_gran);
-	req->r_stamp = timespec_trunc(ts, mdsc->fsc->sb->s_time_gran);
 	req->r_op = op;
 	req->r_direct_mode = mode;

fs/cifs/file.c+1−1

@@ -3271,7 +3271,7 @@ ssize_t cifs_user_readv(struct kiocb iocb, struct iov_iter to) · 3270 unmodified lines
3271	if (!is_sync_kiocb(iocb))	3271	if (!is_sync_kiocb(iocb))
3272	ctx->iocb = iocb;	3272	ctx->iocb = iocb;
3273		3273
3274	if (to->type & ITER_IOVEC)	3274	if (to->type == ITER_IOVEC)
3275	ctx->should_dirty = true;	3275	ctx->should_dirty = true;
3276		3276
3277	rc = setup_aio_ctx_iter(ctx, to, READ);	3277	rc = setup_aio_ctx_iter(ctx, to, READ);

fs/cifs/misc.c+1−1

@@ -810,7 +810,7 @@ setup_aio_ctx_iter(struct cifs_aio_ctx ctx, struct iov_iter iter, int rw) · 809 unmodified lines
810		810
811	if (!pages) {	811	if (!pages) {
812	pages = vmalloc(max_pages * sizeof(struct page *));	812	pages = vmalloc(max_pages * sizeof(struct page *));
813	if (!bv) {	813	if (!pages) {
814	kvfree(bv);	814	kvfree(bv);
815	return -ENOMEM;	815	return -ENOMEM;
816	}	816	}

fs/cifs/smb1ops.c+7−2

@@ -849,8 +849,13 @@ cifs_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon, · 848 unmodified lines
849	struct cifs_fid *fid, __u16 search_flags,	849	struct cifs_fid *fid, __u16 search_flags,
850	struct cifs_search_info *srch_inf)	850	struct cifs_search_info *srch_inf)
851	{	851	{
852	return CIFSFindFirst(xid, tcon, path, cifs_sb,	852	int rc;
853	&fid->netfid, search_flags, srch_inf, true);	853
		854	rc = CIFSFindFirst(xid, tcon, path, cifs_sb,
		855	&fid->netfid, search_flags, srch_inf, true);
		856	if (rc)
		857	cifs_dbg(FYI, "find first failed=%d\n", rc);
		858	return rc;
854	}	859	}
855		860
856	static int	861	static int

fs/cifs/smb2ops.c+5−3

 	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL);
 	kfree(utf16_path);
 	if (rc) {
-		cifs_dbg(VFS, "open dir failed\n");
+		cifs_dbg(FYI, "open dir failed rc=%d\n", rc);
 		return rc;
 	}
 	rc = SMB2_query_directory(xid, tcon, fid->persistent_fid,
 				  fid->volatile_fid, 0, srch_inf);
 	if (rc) {
-		cifs_dbg(VFS, "query directory failed\n");
+		cifs_dbg(FYI, "query directory failed rc=%d\n", rc);
 		SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
 	}
 	return rc;
 	sg = init_sg(rqst, sign);
 	if (!sg) {
-		cifs_dbg(VFS, "%s: Failed to init sg %d", __func__, rc);
+		cifs_dbg(VFS, "%s: Failed to init sg", __func__);
+		rc = -ENOMEM;
 		goto free_req;
 	}
 	iv = kzalloc(iv_len, GFP_KERNEL);
 	if (!iv) {
 		cifs_dbg(VFS, "%s: Failed to alloc IV", __func__);
+		rc = -ENOMEM;
 		goto free_sg;
 	}
 	iv[0] = 3;

fs/cifs/xattr.c+0−2

@@ -188,8 +188,6 @@ static int cifs_creation_time_get(struct dentry dentry, struct inode inode, · 187 unmodified lines
188	pcreatetime = (__u64 *)value;	188	pcreatetime = (__u64 *)value;
189	*pcreatetime = CIFS_I(inode)->createtime;	189	*pcreatetime = CIFS_I(inode)->createtime;
190	return sizeof(__u64);	190	return sizeof(__u64);
191
192	return rc;
193	}	191	}
194		192
195		193

fs/configfs/item.c+8−0

@@ -138,6 +138,14 @@ struct config_item config_item_get(struct config_item item) · 137 unmodified lines
138	}	138	}
139	EXPORT_SYMBOL(config_item_get);	139	EXPORT_SYMBOL(config_item_get);
140		140
		141	struct config_item config_item_get_unless_zero(struct config_item item)
		142	{
		143	if (item && kref_get_unless_zero(&item->ci_kref))
		144	return item;
		145	return NULL;
		146	}
		147	EXPORT_SYMBOL(config_item_get_unless_zero);
		148
141	static void config_item_cleanup(struct config_item *item)	149	static void config_item_cleanup(struct config_item *item)
142	{	150	{
143	struct config_item_type *t = item->ci_type;	151	struct config_item_type *t = item->ci_type;

fs/configfs/symlink.c+1−2

 	ret = -ENOMEM;
 	sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);
 	if (sl) {
-		sl->sl_target = config_item_get(item);
 		spin_lock(&configfs_dirent_lock);
 		if (target_sd->s_type & CONFIGFS_USET_DROPPING) {
 			spin_unlock(&configfs_dirent_lock);
-			config_item_put(item);
 			kfree(sl);
 			return -ENOENT;
 		}
+		sl->sl_target = config_item_get(item);
 		list_add(&sl->sl_list, &target_sd->s_links);
 		spin_unlock(&configfs_dirent_lock);
 		ret = configfs_create_link(sl, parent_item->ci_dentry,

fs/dax.c+1−0

@@ -859,6 +859,7 @@ int dax_writeback_mapping_range(struct address_space *mapping, · 858 unmodified lines
859	if (ret < 0)	859	if (ret < 0)
860	goto out;	860	goto out;
861	}	861	}
		862	start_index = indices[pvec.nr - 1] + 1;
862	}	863	}
863	out:	864	out:
864	put_dax(dax_dev);	865	put_dax(dax_dev);

fs/dcache.c+4−6

 {
 	struct detach_data *data = _data;
-	if (!data->mountpoint && !data->select.found)
+	if (!data->mountpoint && list_empty(&data->select.dispose))
 		__d_drop(data->select.start);
 }
 		d_walk(dentry, &data, detach_and_collect, check_and_drop);
-		if (data.select.found)
+		if (!list_empty(&data.select.dispose))
 			shrink_dentry_list(&data.select.dispose);
+		else if (!data.mountpoint)
+			return;
 		if (data.mountpoint) {
 			detach_mounts(data.mountpoint);
 			dput(data.mountpoint);
 		}
-		if (!data.mountpoint && !data.select.found)
-			break;
 		cond_resched();
 	}
 }

fs/exec.c+24−4

@@ -220,8 +220,26 @@ static struct page get_arg_page(struct linux_binprm bprm, unsigned long pos, · 219 unmodified lines
220		220
221	if (write) {	221	if (write) {
222	unsigned long size = bprm->vma->vm_end - bprm->vma->vm_start;	222	unsigned long size = bprm->vma->vm_end - bprm->vma->vm_start;
		223	unsigned long ptr_size;
223	struct rlimit *rlim;	224	struct rlimit *rlim;
224		225
		226	/*
		227	* Since the stack will hold pointers to the strings, we
		228	* must account for them as well.
		229	*
		230	* The size calculation is the entire vma while each arg page is
		231	* built, so each time we get here it's calculating how far it
		232	* is currently (rather than each call being just the newly
		233	* added size from the arg page). As a result, we need to
		234	* always add the entire size of the pointers, so that on the
		235	* last call to get_arg_page() we'll actually have the entire
		236	* correct size.
		237	*/
		238	ptr_size = (bprm->argc + bprm->envc) * sizeof(void *);
		239	if (ptr_size > ULONG_MAX - size)
		240	goto fail;
		241	size += ptr_size;
		242
225	acct_arg_size(bprm, size / PAGE_SIZE);	243	acct_arg_size(bprm, size / PAGE_SIZE);
226		244
227	/*	245	/*
@@ -239,13 +257,15 @@ static struct page get_arg_page(struct linux_binprm bprm, unsigned long pos, · 11 unmodified lines
239	* to work from.	257	* to work from.
240	*/	258	*/
241	rlim = current->signal->rlim;	259	rlim = current->signal->rlim;
242	if (size > ACCESS_ONCE(rlim[RLIMIT_STACK].rlim_cur) / 4) {	260	if (size > READ_ONCE(rlim[RLIMIT_STACK].rlim_cur) / 4)
243	put_page(page);	261	goto fail;
244	return NULL;
245	}
246	}	262	}
247		263
248	return page;	264	return page;
		265
		266	fail:
		267	put_page(page);
		268	return NULL;
249	}	269	}
250		270
251	static void put_arg_page(struct page *page)	271	static void put_arg_page(struct page *page)

fs/f2fs/f2fs.h+4−1

 {
 	SHASH_DESC_ON_STACK(shash, sbi->s_chksum_driver);
 	u32 *ctx = (u32 *)shash_desc_ctx(shash);
+	u32 retval;
 	int err;
 	shash->tfm = sbi->s_chksum_driver;
 	err = crypto_shash_update(shash, address, length);
 	BUG_ON(err);
-	return *ctx;
+	retval = *ctx;
+	barrier_data(ctx);
+	return retval;
 }
 static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,

fs/hugetlbfs/inode.c+1−1

@@ -200,7 +200,7 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr, · 199 unmodified lines
200	addr = ALIGN(addr, huge_page_size(h));	200	addr = ALIGN(addr, huge_page_size(h));
201	vma = find_vma(mm, addr);	201	vma = find_vma(mm, addr);
202	if (TASK_SIZE - len >= addr &&	202	if (TASK_SIZE - len >= addr &&
203	(!vma \|\| addr + len <= vma->vm_start))	203	(!vma \|\| addr + len <= vm_start_gap(vma)))
204	return addr;	204	return addr;
205	}	205	}
206		206

fs/namespace.c+2−0

@@ -3488,6 +3488,8 @@ static int mntns_install(struct nsproxy nsproxy, struct ns_common ns) · 3487 unmodified lines
3488	return err;	3488	return err;
3489	}	3489	}
3490		3490
		3491	put_mnt_ns(old_mnt_ns);
		3492
3491	/* Update the pwd and root */	3493	/* Update the pwd and root */
3492	set_fs_pwd(fs, &root);	3494	set_fs_pwd(fs, &root);
3493	set_fs_root(fs, &root);	3495	set_fs_root(fs, &root);

fs/ocfs2/dlmglue.c+4−0

 	struct ocfs2_lock_res *lockres;
 	lockres = &OCFS2_I(inode)->ip_inode_lockres;
+	/* had_lock means that the currect process already takes the cluster
+	 * lock previously. If had_lock is 1, we have nothing to do here, and
+	 * it will get unlocked where we got the lock.
+	 */
 	if (!had_lock) {
 		ocfs2_remove_holder(lockres, oh);
 		ocfs2_inode_unlock(inode, ex);

fs/ocfs2/xattr.c+13−10

 			   void *buffer,
 			   size_t buffer_size)
 {
-	int ret;
+	int ret, had_lock;
 	struct buffer_head *di_bh = NULL;
+	struct ocfs2_lock_holder oh;
-	ret = ocfs2_inode_lock(inode, &di_bh, 0);
+	had_lock = ocfs2_inode_lock_tracker(inode, &di_bh, 0, &oh);
-	if (ret < 0) {
+	if (had_lock < 0) {
-		mlog_errno(ret);
+		mlog_errno(had_lock);
-		return ret;
+		return had_lock;
 	}
 	down_read(&OCFS2_I(inode)->ip_xattr_sem);
 	ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index,
 				     name, buffer, buffer_size);
 	up_read(&OCFS2_I(inode)->ip_xattr_sem);
-	ocfs2_inode_unlock(inode, 0);
+	ocfs2_inode_unlock_tracker(inode, 0, &oh, had_lock);
 	brelse(di_bh);
 {
 	struct buffer_head *di_bh = NULL;
 	struct ocfs2_dinode *di;
-	int ret, credits, ref_meta = 0, ref_credits = 0;
+	int ret, credits, had_lock, ref_meta = 0, ref_credits = 0;
 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 	struct inode *tl_inode = osb->osb_tl_inode;
 	struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, NULL, };
 	struct ocfs2_refcount_tree *ref_tree = NULL;
+	struct ocfs2_lock_holder oh;
 	struct ocfs2_xattr_info xi = {
 		.xi_name_index = name_index,
 		return -ENOMEM;
 	}
-	ret = ocfs2_inode_lock(inode, &di_bh, 1);
+	had_lock = ocfs2_inode_lock_tracker(inode, &di_bh, 1, &oh);
-	if (ret < 0) {
+	if (had_lock < 0) {
+		ret = had_lock;
 		mlog_errno(ret);
 		goto cleanup_nolock;
 	}
 		if (ret)
 			mlog_errno(ret);
 	}
-	ocfs2_inode_unlock(inode, 1);
+	ocfs2_inode_unlock_tracker(inode, 1, &oh, had_lock);
 cleanup_nolock:
 	brelse(di_bh);
 	brelse(xbs.xattr_bh);

fs/proc/task_mmu.c+0−4

 	/* We don't show the stack guard page in /proc/maps */
 	start = vma->vm_start;
-	if (stack_guard_page_start(vma, start))
-		start += PAGE_SIZE;
 	end = vma->vm_end;
-	if (stack_guard_page_end(vma, end))
-		end -= PAGE_SIZE;
 	seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
 	seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",

fs/read_write.c+1−1

@@ -1285,7 +1285,7 @@ static size_t compat_writev(struct file *file, · 1284 unmodified lines
1285	if (!(file->f_mode & FMODE_CAN_WRITE))	1285	if (!(file->f_mode & FMODE_CAN_WRITE))
1286	goto out;	1286	goto out;
1287		1287
1288	ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos, 0);	1288	ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos, flags);
1289		1289
1290	out:	1290	out:
1291	if (ret > 0)	1291	if (ret > 0)

fs/ufs/balloc.c+19−25

 	/*
 	 * There is not enough space for user on the device
 	 */
-	if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
+	if (unlikely(ufs_freefrags(uspi) <= uspi->s_root_blocks)) {
-		mutex_unlock(&UFS_SB(sb)->s_lock);
+		if (!capable(CAP_SYS_RESOURCE)) {
-		UFSD("EXIT (FAILED)\n");
+			mutex_unlock(&UFS_SB(sb)->s_lock);
-		return 0;
+			UFSD("EXIT (FAILED)\n");
+			return 0;
+		}
 	}
 	if (goal >= uspi->s_size)
 		if (result) {
 			ufs_clear_frags(inode, result + oldcount,
 					newcount - oldcount, locked_page != NULL);
+			*err = 0;
 			write_seqlock(&UFS_I(inode)->meta_lock);
 			ufs_cpu_to_data_ptr(sb, p, result);
-			write_sequnlock(&UFS_I(inode)->meta_lock);
-			*err = 0;
 			UFS_I(inode)->i_lastfrag =
 				max(UFS_I(inode)->i_lastfrag, fragment + count);
+			write_sequnlock(&UFS_I(inode)->meta_lock);
 		}
 		mutex_unlock(&UFS_SB(sb)->s_lock);
 		UFSD("EXIT, result %llu\n", (unsigned long long)result);
 	result = ufs_add_fragments(inode, tmp, oldcount, newcount);
 	if (result) {
 		*err = 0;
+		read_seqlock_excl(&UFS_I(inode)->meta_lock);
 		UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
 						fragment + count);
+		read_sequnlock_excl(&UFS_I(inode)->meta_lock);
 		ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
 				locked_page != NULL);
 		mutex_unlock(&UFS_SB(sb)->s_lock);
 	/*
 	 * allocate new block and move data
 	 */
-	switch (fs32_to_cpu(sb, usb1->fs_optim)) {
+	if (fs32_to_cpu(sb, usb1->fs_optim) == UFS_OPTSPACE) {
-	    case UFS_OPTSPACE:
 		request = newcount;
-		if (uspi->s_minfree < 5 || uspi->cs_total.cs_nffree
+		if (uspi->cs_total.cs_nffree < uspi->s_space_to_time)
-		    > uspi->s_dsize * uspi->s_minfree / (2 * 100))
+			usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
-			break;
+	} else {
-		usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
-		break;
-	    default:
-		usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
-	    case UFS_OPTTIME:
 		request = uspi->s_fpb;
-		if (uspi->cs_total.cs_nffree < uspi->s_dsize *
+		if (uspi->cs_total.cs_nffree > uspi->s_time_to_space)
-		    (uspi->s_minfree - 2) / 100)
+			usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
-			break;
-		usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
-		break;
 	}
 	result = ufs_alloc_fragments (inode, cgno, goal, request, err);
 	if (result) {
 		ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
 				locked_page != NULL);
+		mutex_unlock(&UFS_SB(sb)->s_lock);
 		ufs_change_blocknr(inode, fragment - oldcount, oldcount,
 				   uspi->s_sbbase + tmp,
 				   uspi->s_sbbase + result, locked_page);
+		*err = 0;
 		write_seqlock(&UFS_I(inode)->meta_lock);
 		ufs_cpu_to_data_ptr(sb, p, result);
-		write_sequnlock(&UFS_I(inode)->meta_lock);
-		*err = 0;
 		UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
 						fragment + count);
-		mutex_unlock(&UFS_SB(sb)->s_lock);
+		write_sequnlock(&UFS_I(inode)->meta_lock);
 		if (newcount < request)
 			ufs_free_fragments (inode, result + newcount, request - newcount);
 		ufs_free_fragments (inode, tmp, oldcount);

fs/ufs/inode.c+43−31

@@ -401,13 +401,20 @@ static int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buff · 400 unmodified lines
401	u64 phys64 = 0;	401	u64 phys64 = 0;
402	unsigned frag = fragment & uspi->s_fpbmask;	402	unsigned frag = fragment & uspi->s_fpbmask;
403		403
404	if (!create) {	404	phys64 = ufs_frag_map(inode, offsets, depth);
405	phys64 = ufs_frag_map(inode, offsets, depth);	405	if (!create)
406	if (phys64)	406	goto done;
407	map_bh(bh_result, sb, phys64 + frag);
408	return 0;
409	}
410		407
		408	if (phys64) {
		409	if (fragment >= UFS_NDIR_FRAGMENT)
		410	goto done;
		411	read_seqlock_excl(&UFS_I(inode)->meta_lock);
		412	if (fragment < UFS_I(inode)->i_lastfrag) {
		413	read_sequnlock_excl(&UFS_I(inode)->meta_lock);
		414	goto done;
		415	}
		416	read_sequnlock_excl(&UFS_I(inode)->meta_lock);
		417	}
411	/* This code entered only while writing ....? */	418	/* This code entered only while writing ....? */
412		419
413	mutex_lock(&UFS_I(inode)->truncate_mutex);	420	mutex_lock(&UFS_I(inode)->truncate_mutex);
@@ -451,6 +458,11 @@ out: · 37 unmodified lines
451	}	458	}
452	mutex_unlock(&UFS_I(inode)->truncate_mutex);	459	mutex_unlock(&UFS_I(inode)->truncate_mutex);
453	return err;	460	return err;
		461
		462	done:
		463	if (phys64)
		464	map_bh(bh_result, sb, phys64 + frag);
		465	return 0;
454	}	466	}
455		467
456	static int ufs_writepage(struct page page, struct writeback_control wbc)	468	static int ufs_writepage(struct page page, struct writeback_control wbc)
@@ -554,10 +566,8 @@ static int ufs1_read_inode(struct inode inode, struct ufs_inode ufs_inode) · 97 unmodified lines
554	*/	566	*/
555	inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);	567	inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
556	set_nlink(inode, fs16_to_cpu(sb, ufs_inode->ui_nlink));	568	set_nlink(inode, fs16_to_cpu(sb, ufs_inode->ui_nlink));
557	if (inode->i_nlink == 0) {	569	if (inode->i_nlink == 0)
558	ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);	570	return -ESTALE;
559	return -1;
560	}
561		571
562	/*	572	/*
563	* Linux now has 32-bit uid and gid, so we can support EFT.	573	* Linux now has 32-bit uid and gid, so we can support EFT.
@@ -566,9 +576,9 @@ static int ufs1_read_inode(struct inode inode, struct ufs_inode ufs_inode) · 2 unmodified lines
566	i_gid_write(inode, ufs_get_inode_gid(sb, ufs_inode));	576	i_gid_write(inode, ufs_get_inode_gid(sb, ufs_inode));
567		577
568	inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);	578	inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);
569	inode->i_atime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);	579	inode->i_atime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);
570	inode->i_ctime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);	580	inode->i_ctime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);
571	inode->i_mtime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);	581	inode->i_mtime.tv_sec = (signed)fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);
572	inode->i_mtime.tv_nsec = 0;	582	inode->i_mtime.tv_nsec = 0;
573	inode->i_atime.tv_nsec = 0;	583	inode->i_atime.tv_nsec = 0;
574	inode->i_ctime.tv_nsec = 0;	584	inode->i_ctime.tv_nsec = 0;
@@ -602,10 +612,8 @@ static int ufs2_read_inode(struct inode inode, struct ufs2_inode ufs2_inode) · 27 unmodified lines
602	*/	612	*/
603	inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);	613	inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);
604	set_nlink(inode, fs16_to_cpu(sb, ufs2_inode->ui_nlink));	614	set_nlink(inode, fs16_to_cpu(sb, ufs2_inode->ui_nlink));
605	if (inode->i_nlink == 0) {	615	if (inode->i_nlink == 0)
606	ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);	616	return -ESTALE;
607	return -1;
608	}
609		617
610	/*	618	/*
611	* Linux now has 32-bit uid and gid, so we can support EFT.	619	* Linux now has 32-bit uid and gid, so we can support EFT.
@@ -645,7 +653,7 @@ struct inode ufs_iget(struct super_block sb, unsigned long ino) · 33 unmodified lines
645	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;	653	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
646	struct buffer_head * bh;	654	struct buffer_head * bh;
647	struct inode *inode;	655	struct inode *inode;
648	int err;	656	int err = -EIO;
649		657
650	UFSD("ENTER, ino %lu\n", ino);	658	UFSD("ENTER, ino %lu\n", ino);
651		659
@@ -680,9 +688,10 @@ struct inode ufs_iget(struct super_block sb, unsigned long ino) · 28 unmodified lines
680	err = ufs1_read_inode(inode,	688	err = ufs1_read_inode(inode,
681	ufs_inode + ufs_inotofsbo(inode->i_ino));	689	ufs_inode + ufs_inotofsbo(inode->i_ino));
682	}	690	}
683		691	brelse(bh);
684	if (err)	692	if (err)
685	goto bad_inode;	693	goto bad_inode;
		694
686	inode->i_version++;	695	inode->i_version++;
687	ufsi->i_lastfrag =	696	ufsi->i_lastfrag =
688	(inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;	697	(inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
@@ -691,15 +700,13 @@ struct inode ufs_iget(struct super_block sb, unsigned long ino) · 2 unmodified lines
691		700
692	ufs_set_inode_ops(inode);	701	ufs_set_inode_ops(inode);
693		702
694	brelse(bh);
695
696	UFSD("EXIT\n");	703	UFSD("EXIT\n");
697	unlock_new_inode(inode);	704	unlock_new_inode(inode);
698	return inode;	705	return inode;
699		706
700	bad_inode:	707	bad_inode:
701	iget_failed(inode);	708	iget_failed(inode);
702	return ERR_PTR(-EIO);	709	return ERR_PTR(err);
703	}	710	}
704		711
705	static void ufs1_update_inode(struct inode inode, struct ufs_inode ufs_inode)	712	static void ufs1_update_inode(struct inode inode, struct ufs_inode ufs_inode)
@@ -874,7 +881,6 @@ static inline void free_data(struct to_free *ctx, u64 from, unsigned count) · 168 unmodified lines
874	ctx->to = from + count;	881	ctx->to = from + count;
875	}	882	}
876		883
877	#define DIRECT_BLOCK ((inode->i_size + uspi->s_bsize - 1) >> uspi->s_bshift)
878	#define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift)	884	#define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift)
879		885
880	static void ufs_trunc_direct(struct inode *inode)	886	static void ufs_trunc_direct(struct inode *inode)
@@ -1112,19 +1118,24 @@ static void ufs_truncate_blocks(struct inode *inode) · 231 unmodified lines
1112	struct super_block *sb = inode->i_sb;	1118	struct super_block *sb = inode->i_sb;
1113	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;	1119	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
1114	unsigned offsets[4];	1120	unsigned offsets[4];
1115	int depth = ufs_block_to_path(inode, DIRECT_BLOCK, offsets);	1121	int depth;
1116	int depth2;	1122	int depth2;
1117	unsigned i;	1123	unsigned i;
1118	struct ufs_buffer_head *ubh[3];	1124	struct ufs_buffer_head *ubh[3];
1119	void *p;	1125	void *p;
1120	u64 block;	1126	u64 block;
1121		1127
1122	if (!depth)	1128	if (inode->i_size) {
1123	return;	1129	sector_t last = (inode->i_size - 1) >> uspi->s_bshift;
		1130	depth = ufs_block_to_path(inode, last, offsets);
		1131	if (!depth)
		1132	return;
		1133	} else {
		1134	depth = 1;
		1135	}
1124		1136
1125	/* find the last non-zero in offsets[] */
1126	for (depth2 = depth - 1; depth2; depth2--)	1137	for (depth2 = depth - 1; depth2; depth2--)
1127	if (offsets[depth2])	1138	if (offsets[depth2] != uspi->s_apb - 1)
1128	break;	1139	break;
1129		1140
1130	mutex_lock(&ufsi->truncate_mutex);	1141	mutex_lock(&ufsi->truncate_mutex);
@@ -1133,9 +1144,8 @@ static void ufs_truncate_blocks(struct inode *inode) · 2 unmodified lines
1133	offsets[0] = UFS_IND_BLOCK;	1144	offsets[0] = UFS_IND_BLOCK;
1134	} else {	1145	} else {
1135	/* get the blocks that should be partially emptied */	1146	/* get the blocks that should be partially emptied */
1136	p = ufs_get_direct_data_ptr(uspi, ufsi, offsets[0]);	1147	p = ufs_get_direct_data_ptr(uspi, ufsi, offsets[0]++);
1137	for (i = 0; i < depth2; i++) {	1148	for (i = 0; i < depth2; i++) {
1138	offsets[i]++; /* next branch is fully freed */
1139	block = ufs_data_ptr_to_cpu(sb, p);	1149	block = ufs_data_ptr_to_cpu(sb, p);
1140	if (!block)	1150	if (!block)
1141	break;	1151	break;
@@ -1146,7 +1156,7 @@ static void ufs_truncate_blocks(struct inode *inode) · 4 unmodified lines
1146	write_sequnlock(&ufsi->meta_lock);	1156	write_sequnlock(&ufsi->meta_lock);
1147	break;	1157	break;
1148	}	1158	}
1149	p = ubh_get_data_ptr(uspi, ubh[i], offsets[i + 1]);	1159	p = ubh_get_data_ptr(uspi, ubh[i], offsets[i + 1]++);
1150	}	1160	}
1151	while (i--)	1161	while (i--)
1152	free_branch_tail(inode, offsets[i + 1], ubh[i], depth - i - 1);	1162	free_branch_tail(inode, offsets[i + 1], ubh[i], depth - i - 1);
@@ -1161,7 +1171,9 @@ static void ufs_truncate_blocks(struct inode *inode) · 8 unmodified lines
1161	free_full_branch(inode, block, i - UFS_IND_BLOCK + 1);	1171	free_full_branch(inode, block, i - UFS_IND_BLOCK + 1);
1162	}	1172	}
1163	}	1173	}
		1174	read_seqlock_excl(&ufsi->meta_lock);
1164	ufsi->i_lastfrag = DIRECT_FRAGMENT;	1175	ufsi->i_lastfrag = DIRECT_FRAGMENT;
		1176	read_sequnlock_excl(&ufsi->meta_lock);
1165	mark_inode_dirty(inode);	1177	mark_inode_dirty(inode);
1166	mutex_unlock(&ufsi->truncate_mutex);	1178	mutex_unlock(&ufsi->truncate_mutex);
1167	}	1179	}

fs/ufs/super.c+49−24

@@ -480,7 +480,7 @@ static void ufs_setup_cstotal(struct super_block *sb) · 479 unmodified lines
480	usb3 = ubh_get_usb_third(uspi);	480	usb3 = ubh_get_usb_third(uspi);
481		481
482	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&	482	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
483	(usb1->fs_flags & UFS_FLAGS_UPDATED)) \|\|	483	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) \|\|
484	mtype == UFS_MOUNT_UFSTYPE_UFS2) {	484	mtype == UFS_MOUNT_UFSTYPE_UFS2) {
485	/we have statistic in different place, then usual/	485	/we have statistic in different place, then usual/
486	uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);	486	uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
@@ -596,9 +596,7 @@ static void ufs_put_cstotal(struct super_block *sb) · 109 unmodified lines
596	usb2 = ubh_get_usb_second(uspi);	596	usb2 = ubh_get_usb_second(uspi);
597	usb3 = ubh_get_usb_third(uspi);	597	usb3 = ubh_get_usb_third(uspi);
598		598
599	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&	599	if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
600	(usb1->fs_flags & UFS_FLAGS_UPDATED)) \|\|
601	mtype == UFS_MOUNT_UFSTYPE_UFS2) {
602	/we have statistic in different place, then usual/	600	/we have statistic in different place, then usual/
603	usb2->fs_un.fs_u2.cs_ndir =	601	usb2->fs_un.fs_u2.cs_ndir =
604	cpu_to_fs64(sb, uspi->cs_total.cs_ndir);	602	cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
@@ -608,16 +606,26 @@ static void ufs_put_cstotal(struct super_block *sb) · 3 unmodified lines
608	cpu_to_fs64(sb, uspi->cs_total.cs_nifree);	606	cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
609	usb3->fs_un1.fs_u2.cs_nffree =	607	usb3->fs_un1.fs_u2.cs_nffree =
610	cpu_to_fs64(sb, uspi->cs_total.cs_nffree);	608	cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
611	} else {	609	goto out;
612	usb1->fs_cstotal.cs_ndir =	610	}
613	cpu_to_fs32(sb, uspi->cs_total.cs_ndir);	611
614	usb1->fs_cstotal.cs_nbfree =	612	if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
615	cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);	613	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
616	usb1->fs_cstotal.cs_nifree =	614	/* store stats in both old and new places */
617	cpu_to_fs32(sb, uspi->cs_total.cs_nifree);	615	usb2->fs_un.fs_u2.cs_ndir =
618	usb1->fs_cstotal.cs_nffree =	616	cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
619	cpu_to_fs32(sb, uspi->cs_total.cs_nffree);	617	usb2->fs_un.fs_u2.cs_nbfree =
		618	cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
		619	usb3->fs_un1.fs_u2.cs_nifree =
		620	cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
		621	usb3->fs_un1.fs_u2.cs_nffree =
		622	cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
620	}	623	}
		624	usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
		625	usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
		626	usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
		627	usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
		628	out:
621	ubh_mark_buffer_dirty(USPI_UBH(uspi));	629	ubh_mark_buffer_dirty(USPI_UBH(uspi));
622	ufs_print_super_stuff(sb, usb1, usb2, usb3);	630	ufs_print_super_stuff(sb, usb1, usb2, usb3);
623	UFSD("EXIT\n");	631	UFSD("EXIT\n");
@@ -996,6 +1004,13 @@ again: · 372 unmodified lines
996	flags \|= UFS_ST_SUN;	1004	flags \|= UFS_ST_SUN;
997	}	1005	}
998		1006
		1007	if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
		1008	uspi->s_postblformat == UFS_42POSTBLFMT) {
		1009	if (!silent)
		1010	pr_err("this is not a 44bsd filesystem");
		1011	goto failed;
		1012	}
		1013
999	/*	1014	/*
1000	* Check ufs magic number	1015	* Check ufs magic number
1001	*/	1016	*/
@@ -1143,8 +1158,8 @@ magic_found: · 141 unmodified lines
1143	uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);	1158	uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
1144		1159
1145	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {	1160	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1146	uspi->s_u2_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);	1161	uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
1147	uspi->s_u2_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);	1162	uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1148	} else {	1163	} else {
1149	uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);	1164	uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
1150	uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);	1165	uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
@@ -1193,6 +1208,18 @@ magic_found: · 42 unmodified lines
1193	uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);	1208	uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
1194	uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);	1209	uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
1195		1210
		1211	uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
		1212	uspi->s_minfree, 100);
		1213	if (uspi->s_minfree <= 5) {
		1214	uspi->s_time_to_space = ~0ULL;
		1215	uspi->s_space_to_time = 0;
		1216	usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
		1217	} else {
		1218	uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
		1219	uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
		1220	uspi->s_minfree - 2, 100) - 1;
		1221	}
		1222
1196	/*	1223	/*
1197	* Compute another frequently used values	1224	* Compute another frequently used values
1198	*/	1225	*/
@@ -1382,19 +1409,17 @@ static int ufs_statfs(struct dentry dentry, struct kstatfs buf) · 183 unmodified lines
1382	mutex_lock(&UFS_SB(sb)->s_lock);	1409	mutex_lock(&UFS_SB(sb)->s_lock);
1383	usb3 = ubh_get_usb_third(uspi);	1410	usb3 = ubh_get_usb_third(uspi);
1384		1411
1385	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {	1412	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1386	buf->f_type = UFS2_MAGIC;	1413	buf->f_type = UFS2_MAGIC;
1387	buf->f_blocks = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);	1414	else
1388	} else {
1389	buf->f_type = UFS_MAGIC;	1415	buf->f_type = UFS_MAGIC;
1390	buf->f_blocks = uspi->s_dsize;	1416
1391	}	1417	buf->f_blocks = uspi->s_dsize;
1392	buf->f_bfree = ufs_blkstofrags(uspi->cs_total.cs_nbfree) +	1418	buf->f_bfree = ufs_freefrags(uspi);
1393	uspi->cs_total.cs_nffree;
1394	buf->f_ffree = uspi->cs_total.cs_nifree;	1419	buf->f_ffree = uspi->cs_total.cs_nifree;
1395	buf->f_bsize = sb->s_blocksize;	1420	buf->f_bsize = sb->s_blocksize;
1396	buf->f_bavail = (buf->f_bfree > (((long)buf->f_blocks / 100) * uspi->s_minfree))	1421	buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1397	? (buf->f_bfree - (((long)buf->f_blocks / 100) * uspi->s_minfree)) : 0;	1422	? (buf->f_bfree - uspi->s_root_blocks) : 0;
1398	buf->f_files = uspi->s_ncg * uspi->s_ipg;	1423	buf->f_files = uspi->s_ncg * uspi->s_ipg;
1399	buf->f_namelen = UFS_MAXNAMLEN;	1424	buf->f_namelen = UFS_MAXNAMLEN;
1400	buf->f_fsid.val[0] = (u32)id;	1425	buf->f_fsid.val[0] = (u32)id;

fs/ufs/ufs_fs.h+5−4

 	__u32	s_dblkno;	/* offset of first data after cg */
 	__u32	s_cgoffset;	/* cylinder group offset in cylinder */
 	__u32	s_cgmask;	/* used to calc mod fs_ntrak */
-	__u32	s_size;		/* number of blocks (fragments) in fs */
+	__u64	s_size;		/* number of blocks (fragments) in fs */
-	__u32	s_dsize;	/* number of data blocks in fs */
+	__u64	s_dsize;	/* number of data blocks in fs */
-	__u64	s_u2_size;	/* ufs2: number of blocks (fragments) in fs */
-	__u64	s_u2_dsize;	/*ufs2:  number of data blocks in fs */
 	__u32	s_ncg;		/* number of cylinder groups */
 	__u32	s_bsize;	/* size of basic blocks */
 	__u32	s_fsize;	/* size of fragments */
 	__u32	s_maxsymlinklen;/* upper limit on fast symlinks' size */
 	__s32	fs_magic;       /* filesystem magic */
 	unsigned int s_dirblksize;
+	__u64   s_root_blocks;
+	__u64	s_time_to_space;
+	__u64	s_space_to_time;
 };
 /*

fs/ufs/util.c+8−9

@@ -243,9 +243,8 @@ ufs_set_inode_dev(struct super_block sb, struct ufs_inode_info ufsi, dev_t dev · 242 unmodified lines
243	struct page ufs_get_locked_page(struct address_space mapping,	243	struct page ufs_get_locked_page(struct address_space mapping,
244	pgoff_t index)	244	pgoff_t index)
245	{	245	{
246	struct page *page;	246	struct inode *inode = mapping->host;
247		247	struct page *page = find_lock_page(mapping, index);
248	page = find_lock_page(mapping, index);
249	if (!page) {	248	if (!page) {
250	page = read_mapping_page(mapping, index, NULL);	249	page = read_mapping_page(mapping, index, NULL);
251		250
@@ -253,7 +252,7 @@ struct page ufs_get_locked_page(struct address_space mapping, · 1 unmodified line
253	printk(KERN_ERR "ufs_change_blocknr: "	252	printk(KERN_ERR "ufs_change_blocknr: "
254	"read_mapping_page error: ino %lu, index: %lu\n",	253	"read_mapping_page error: ino %lu, index: %lu\n",
255	mapping->host->i_ino, index);	254	mapping->host->i_ino, index);
256	goto out;	255	return page;
257	}	256	}
258		257
259	lock_page(page);	258	lock_page(page);
@@ -262,8 +261,7 @@ struct page ufs_get_locked_page(struct address_space mapping, · 2 unmodified lines
262	/* Truncate got there first */	261	/* Truncate got there first */
263	unlock_page(page);	262	unlock_page(page);
264	put_page(page);	263	put_page(page);
265	page = NULL;	264	return NULL;
266	goto out;
267	}	265	}
268		266
269	if (!PageUptodate(page) \|\| PageError(page)) {	267	if (!PageUptodate(page) \|\| PageError(page)) {
@@ -272,11 +270,12 @@ struct page ufs_get_locked_page(struct address_space mapping, · 2 unmodified lines
272		270
273	printk(KERN_ERR "ufs_change_blocknr: "	271	printk(KERN_ERR "ufs_change_blocknr: "
274	"can not read page: ino %lu, index: %lu\n",	272	"can not read page: ino %lu, index: %lu\n",
275	mapping->host->i_ino, index);	273	inode->i_ino, index);
276		274
277	page = ERR_PTR(-EIO);	275	return ERR_PTR(-EIO);
278	}	276	}
279	}	277	}
280	out:	278	if (!page_has_buffers(page))
		279	create_empty_buffers(page, 1 << inode->i_blkbits, 0);
281	return page;	280	return page;
282	}	281	}

fs/ufs/util.h+2−7

 #define ubh_blkmap(ubh,begin,bit) \
 	((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
-/*
- * Determine the number of available frags given a
- * percentage to hold in reserve.
- */
 static inline u64
-ufs_freespace(struct ufs_sb_private_info *uspi, int percentreserved)
+ufs_freefrags(struct ufs_sb_private_info *uspi)
 {
 	return ufs_blkstofrags(uspi->cs_total.cs_nbfree) +
-		uspi->cs_total.cs_nffree -
+		uspi->cs_total.cs_nffree;
-		(uspi->s_dsize * (percentreserved) / 100);
 }
 /*

fs/userfaultfd.c+21−8

 	bool must_wait, return_to_userland;
 	long blocking_state;
-	BUG_ON(!rwsem_is_locked(&mm->mmap_sem));
 	ret = VM_FAULT_SIGBUS;
+	/*
+	 * We don't do userfault handling for the final child pid update.
+	 *
+	 * We also don't do userfault handling during
+	 * coredumping. hugetlbfs has the special
+	 * follow_hugetlb_page() to skip missing pages in the
+	 * FOLL_DUMP case, anon memory also checks for FOLL_DUMP with
+	 * the no_page_table() helper in follow_page_mask(), but the
+	 * shmem_vm_ops->fault method is invoked even during
+	 * coredumping without mmap_sem and it ends up here.
+	 */
+	if (current->flags & (PF_EXITING|PF_DUMPCORE))
+		goto out;
+	/*
+	 * Coredumping runs without mmap_sem so we can only check that
+	 * the mmap_sem is held, if PF_DUMPCORE was not set.
+	 */
+	WARN_ON_ONCE(!rwsem_is_locked(&mm->mmap_sem));
 	ctx = vmf->vma->vm_userfaultfd_ctx.ctx;
 	if (!ctx)
 		goto out;
 	if (unlikely(ACCESS_ONCE(ctx->released)))
 		goto out;
-	/*
-	 * We don't do userfault handling for the final child pid update.
-	 */
-	if (current->flags & PF_EXITING)
-		goto out;
 	/*
 	 * Check that we can return VM_FAULT_RETRY.
 	 *

fs/xfs/xfs_aops.c+5−2

 	 * The swap code (ab-)uses ->bmap to get a block mapping and then
 	 * bypasseѕ the file system for actual I/O.  We really can't allow
 	 * that on reflinks inodes, so we have to skip out here.  And yes,
-	 * 0 is the magic code for a bmap error..
+	 * 0 is the magic code for a bmap error.
+	 *
+	 * Since we don't pass back blockdev info, we can't return bmap
+	 * information for rt files either.
 	 */
-	if (xfs_is_reflink_inode(ip))
+	if (xfs_is_reflink_inode(ip) || XFS_IS_REALTIME_INODE(ip))
 		return 0;
 	filemap_write_and_wait(mapping);

fs/xfs/xfs_buf.c+1−1

@@ -117,7 +117,7 @@ static inline void · 116 unmodified lines
117	__xfs_buf_ioacct_dec(	117	__xfs_buf_ioacct_dec(
118	struct xfs_buf *bp)	118	struct xfs_buf *bp)
119	{	119	{
120	ASSERT(spin_is_locked(&bp->b_lock));	120	lockdep_assert_held(&bp->b_lock);
121		121
122	if (bp->b_state & XFS_BSTATE_IN_FLIGHT) {	122	if (bp->b_state & XFS_BSTATE_IN_FLIGHT) {
123	bp->b_state &= ~XFS_BSTATE_IN_FLIGHT;	123	bp->b_state &= ~XFS_BSTATE_IN_FLIGHT;

fs/xfs/xfs_icache.c+2−3

 	XFS_STATS_INC(mp, vn_active);
 	ASSERT(atomic_read(&ip->i_pincount) == 0);
-	ASSERT(!spin_is_locked(&ip->i_flags_lock));
 	ASSERT(!xfs_isiflocked(ip));
 	ASSERT(ip->i_ino == 0);
 {
 	struct xfs_mount	*mp = pag->pag_mount;
-	ASSERT(spin_is_locked(&pag->pag_ici_lock));
+	lockdep_assert_held(&pag->pag_ici_lock);
 	if (pag->pag_ici_reclaimable++)
 		return;
 {
 	struct xfs_mount	*mp = pag->pag_mount;
-	ASSERT(spin_is_locked(&pag->pag_ici_lock));
+	lockdep_assert_held(&pag->pag_ici_lock);
 	if (--pag->pag_ici_reclaimable)
 		return;

include/acpi/acpi_bus.h+2−1

@@ -210,7 +210,8 @@ struct acpi_device_flags { · 209 unmodified lines
210	u32 of_compatible_ok:1;	210	u32 of_compatible_ok:1;
211	u32 coherent_dma:1;	211	u32 coherent_dma:1;
212	u32 cca_seen:1;	212	u32 cca_seen:1;
213	u32 reserved:20;	213	u32 spi_i2c_slave:1;
		214	u32 reserved:19;
214	};	215	};
215		216
216	/* File System */	217	/* File System */

include/acpi/actbl.h+14−0

@@ -374,6 +374,20 @@ struct acpi_table_desc { · 373 unmodified lines
374	u16 validation_count;	374	u16 validation_count;
375	};	375	};
376		376
		377	/*
		378	* Maximum value of the validation_count field in struct acpi_table_desc.
		379	* When reached, validation_count cannot be changed any more and the table will
		380	* be permanently regarded as validated.
		381	*
		382	* This is to prevent situations in which unbalanced table get/put operations
		383	* may cause premature table unmapping in the OS to happen.
		384	*
		385	* The maximum validation count can be defined to any value, but should be
		386	* greater than the maximum number of OS early stage mapping slots to avoid
		387	* leaking early stage table mappings to the late stage.
		388	*/
		389	#define ACPI_MAX_TABLE_VALIDATIONS ACPI_UINT16_MAX
		390
377	/* Masks for Flags field above */	391	/* Masks for Flags field above */
378		392
379	#define ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL (0) /* Virtual address, external maintained */	393	#define ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL (0) /* Virtual address, external maintained */

include/dt-bindings/clock/sun50i-a64-ccu.h+2−0

@@ -43,6 +43,8 @@ · 42 unmodified lines
43	#ifndef _DT_BINDINGS_CLK_SUN50I_A64_H_	43	#ifndef _DT_BINDINGS_CLK_SUN50I_A64_H_
44	#define _DT_BINDINGS_CLK_SUN50I_A64_H_	44	#define _DT_BINDINGS_CLK_SUN50I_A64_H_
45		45
		46	#define CLK_PLL_PERIPH0 11
		47
46	#define CLK_BUS_MIPI_DSI 28	48	#define CLK_BUS_MIPI_DSI 28
47	#define CLK_BUS_CE 29	49	#define CLK_BUS_CE 29
48	#define CLK_BUS_DMA 30	50	#define CLK_BUS_DMA 30

include/dt-bindings/clock/sun8i-h3-ccu.h+2−0

@@ -43,6 +43,8 @@ · 42 unmodified lines
43	#ifndef _DT_BINDINGS_CLK_SUN8I_H3_H_	43	#ifndef _DT_BINDINGS_CLK_SUN8I_H3_H_
44	#define _DT_BINDINGS_CLK_SUN8I_H3_H_	44	#define _DT_BINDINGS_CLK_SUN8I_H3_H_
45		45
		46	#define CLK_PLL_PERIPH0 9
		47
46	#define CLK_CPUX 14	48	#define CLK_CPUX 14
47		49
48	#define CLK_BUS_CE 20	50	#define CLK_BUS_CE 20

include/linux/blkdev.h+4−0

 	int			nr_rqs[2];	/* # allocated [a]sync rqs */
 	int			nr_rqs_elvpriv;	/* # allocated rqs w/ elvpriv */
+	atomic_t		shared_hctx_restart;
 	struct blk_queue_stats	*stats;
 	struct rq_wb		*rq_wb;
 	size_t			cmd_size;
 	void			*rq_alloc_data;
+	struct work_struct	release_work;
 };
 #define QUEUE_FLAG_QUEUED	1	/* uses generic tag queueing */

include/linux/configfs.h+2−1

@@ -74,7 +74,8 @@ extern void config_item_init_type_name(struct config_item *item, · 73 unmodified lines
74	const char *name,	74	const char *name,
75	struct config_item_type *type);	75	struct config_item_type *type);
76		76
77	extern struct config_item * config_item_get(struct config_item *);	77	extern struct config_item config_item_get(struct config_item );
		78	extern struct config_item config_item_get_unless_zero(struct config_item );
78	extern void config_item_put(struct config_item *);	79	extern void config_item_put(struct config_item *);
79		80
80	struct config_item_type {	81	struct config_item_type {

include/linux/dmi.h+1−1

@@ -136,7 +136,7 @@ static inline int dmi_name_in_vendors(const char *s) { return 0; } · 135 unmodified lines
136	static inline int dmi_name_in_serial(const char *s) { return 0; }	136	static inline int dmi_name_in_serial(const char *s) { return 0; }
137	#define dmi_available 0	137	#define dmi_available 0
138	static inline int dmi_walk(void (decode)(const struct dmi_header , void *),	138	static inline int dmi_walk(void (decode)(const struct dmi_header , void *),
139	void *private_data) { return -1; }	139	void *private_data) { return -ENXIO; }
140	static inline bool dmi_match(enum dmi_field f, const char *str)	140	static inline bool dmi_match(enum dmi_field f, const char *str)
141	{ return false; }	141	{ return false; }
142	static inline void dmi_memdev_name(u16 handle, const char **bank,	142	static inline void dmi_memdev_name(u16 handle, const char **bank,

include/linux/mm.h+25−28

 int get_cmdline(struct task_struct *task, char *buffer, int buflen);
-/* Is the vma a continuation of the stack vma above it? */
-static inline int vma_growsdown(struct vm_area_struct *vma, unsigned long addr)
-{
-	return vma && (vma->vm_end == addr) && (vma->vm_flags & VM_GROWSDOWN);
-}
 static inline bool vma_is_anonymous(struct vm_area_struct *vma)
 {
 	return !vma->vm_ops;
 static inline bool vma_is_shmem(struct vm_area_struct *vma) { return false; }
 #endif
-static inline int stack_guard_page_start(struct vm_area_struct *vma,
-					     unsigned long addr)
-{
-	return (vma->vm_flags & VM_GROWSDOWN) &&
-		(vma->vm_start == addr) &&
-		!vma_growsdown(vma->vm_prev, addr);
-}
-/* Is the vma a continuation of the stack vma below it? */
-static inline int vma_growsup(struct vm_area_struct *vma, unsigned long addr)
-{
-	return vma && (vma->vm_start == addr) && (vma->vm_flags & VM_GROWSUP);
-}
-static inline int stack_guard_page_end(struct vm_area_struct *vma,
-					   unsigned long addr)
-{
-	return (vma->vm_flags & VM_GROWSUP) &&
-		(vma->vm_end == addr) &&
-		!vma_growsup(vma->vm_next, addr);
-}
 int vma_is_stack_for_current(struct vm_area_struct *vma);
 extern unsigned long move_page_tables(struct vm_area_struct *vma,
 				pgoff_t offset,
 				unsigned long size);
+extern unsigned long stack_guard_gap;
 /* Generic expand stack which grows the stack according to GROWS{UP,DOWN} */
 extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
 	return vma;
 }
+static inline unsigned long vm_start_gap(struct vm_area_struct *vma)
+{
+	unsigned long vm_start = vma->vm_start;
+	if (vma->vm_flags & VM_GROWSDOWN) {
+		vm_start -= stack_guard_gap;
+		if (vm_start > vma->vm_start)
+			vm_start = 0;
+	}
+	return vm_start;
+}
+static inline unsigned long vm_end_gap(struct vm_area_struct *vma)
+{
+	unsigned long vm_end = vma->vm_end;
+	if (vma->vm_flags & VM_GROWSUP) {
+		vm_end += stack_guard_gap;
+		if (vm_end < vma->vm_end)
+			vm_end = -PAGE_SIZE;
+	}
+	return vm_end;
+}
 static inline unsigned long vma_pages(struct vm_area_struct *vma)
 {
 	return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;

include/linux/netdevice.h+10−5

  *
  * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  *	Called when a user wants to change the Maximum Transfer Unit
- *	of a device. If not defined, any request to change MTU will
+ *	of a device.
- *	will return an error.
  *
  * void (*ndo_tx_timeout)(struct net_device *dev);
  *	Callback used when the transmitter has not made any progress
  *	@rtnl_link_state:	This enum represents the phases of creating
  *				a new link
  *
- *	@destructor:		Called from unregister,
+ *	@needs_free_netdev:	Should unregister perform free_netdev?
- *				can be used to call free_netdev
+ *	@priv_destructor:	Called from unregister
  *	@npinfo:		XXX: need comments on this one
  * 	@nd_net:		Network namespace this network device is inside
  *
 		RTNL_LINK_INITIALIZING,
 	} rtnl_link_state:16;
-	void (*destructor)(struct net_device *dev);
+	bool needs_free_netdev;
+	void (*priv_destructor)(struct net_device *dev);
 #ifdef CONFIG_NETPOLL
 	struct netpoll_info __rcu	*npinfo;
 	return dev->name;
 }
+static inline bool netdev_unregistering(const struct net_device *dev)
+{
+	return dev->reg_state == NETREG_UNREGISTERING;
+}
 static inline const char *netdev_reg_state(const struct net_device *dev)
 {
 	switch (dev->reg_state) {

include/linux/slub_def.h+1−0

@@ -84,6 +84,7 @@ struct kmem_cache { · 83 unmodified lines
84	int red_left_pad; /* Left redzone padding size */	84	int red_left_pad; /* Left redzone padding size */
85	#ifdef CONFIG_SYSFS	85	#ifdef CONFIG_SYSFS
86	struct kobject kobj; /* For sysfs */	86	struct kobject kobj; /* For sysfs */
		87	struct work_struct kobj_remove_work;
87	#endif	88	#endif
88	#ifdef CONFIG_MEMCG	89	#ifdef CONFIG_MEMCG
89	struct memcg_cache_params memcg_params;	90	struct memcg_cache_params memcg_params;

include/linux/timekeeper_internal.h+2−3

  */
 struct tk_read_base {
 	struct clocksource	*clock;
-	u64			(*read)(struct clocksource *cs);
 	u64			mask;
 	u64			cycle_last;
 	u32			mult;
  *			interval.
  * @xtime_remainder:	Shifted nano seconds left over when rounding
  *			@cycle_interval
- * @raw_interval:	Raw nano seconds accumulated per NTP interval.
+ * @raw_interval:	Shifted raw nano seconds accumulated per NTP interval.
  * @ntp_error:		Difference between accumulated time and NTP time in ntp
  *			shifted nano seconds.
  * @ntp_error_shift:	Shift conversion between clock shifted nano seconds and
 	u64			cycle_interval;
 	u64			xtime_interval;
 	s64			xtime_remainder;
-	u32			raw_interval;
+	u64			raw_interval;
 	/* The ntp_tick_length() value currently being used.
 	 * This cached copy ensures we consistently apply the tick
 	 * length for an entire tick, as ntp_tick_length may change

include/media/cec-notifier.h+10−0

@@ -106,6 +106,16 @@ static inline void cec_notifier_set_phys_addr_from_edid(struct cec_notifier *n, · 105 unmodified lines
106	{	106	{
107	}	107	}
108		108
		109	static inline void cec_notifier_register(struct cec_notifier *n,
		110	struct cec_adapter *adap,
		111	void (callback)(struct cec_adapter adap, u16 pa))
		112	{
		113	}
		114
		115	static inline void cec_notifier_unregister(struct cec_notifier *n)
		116	{
		117	}
		118
109	#endif	119	#endif
110		120
111	#endif	121	#endif

include/media/cec.h+1−1

@@ -206,7 +206,7 @@ static inline bool cec_is_sink(const struct cec_adapter *adap) · 205 unmodified lines
206	#define cec_phys_addr_exp(pa) \	206	#define cec_phys_addr_exp(pa) \
207	((pa) >> 12), ((pa) >> 8) & 0xf, ((pa) >> 4) & 0xf, (pa) & 0xf	207	((pa) >> 12), ((pa) >> 8) & 0xf, ((pa) >> 4) & 0xf, (pa) & 0xf
208		208
209	#if IS_ENABLED(CONFIG_CEC_CORE)	209	#if IS_REACHABLE(CONFIG_CEC_CORE)
210	struct cec_adapter cec_allocate_adapter(const struct cec_adap_ops ops,	210	struct cec_adapter cec_allocate_adapter(const struct cec_adap_ops ops,
211	void priv, const char name, u32 caps, u8 available_las);	211	void priv, const char name, u32 caps, u8 available_las);
212	int cec_register_adapter(struct cec_adapter adap, struct device parent);	212	int cec_register_adapter(struct cec_adapter adap, struct device parent);

include/net/wext.h+2−2

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	struct net;	6	struct net;
7		7
8	#ifdef CONFIG_WEXT_CORE	8	#ifdef CONFIG_WEXT_CORE
9	int wext_handle_ioctl(struct net net, struct ifreq ifr, unsigned int cmd,	9	int wext_handle_ioctl(struct net net, struct iwreq iwr, unsigned int cmd,
10	void __user *arg);	10	void __user *arg);
11	int compat_wext_handle_ioctl(struct net *net, unsigned int cmd,	11	int compat_wext_handle_ioctl(struct net *net, unsigned int cmd,
12	unsigned long arg);	12	unsigned long arg);
@@ -14,7 +14,7 @@ int compat_wext_handle_ioctl(struct net *net, unsigned int cmd, · 1 unmodified line
14	struct iw_statistics get_wireless_stats(struct net_device dev);	14	struct iw_statistics get_wireless_stats(struct net_device dev);
15	int call_commit_handler(struct net_device *dev);	15	int call_commit_handler(struct net_device *dev);
16	#else	16	#else
17	static inline int wext_handle_ioctl(struct net net, struct ifreq ifr, unsigned int cmd,	17	static inline int wext_handle_ioctl(struct net net, struct iwreq iwr, unsigned int cmd,
18	void __user *arg)	18	void __user *arg)
19	{	19	{
20	return -EINVAL;	20	return -EINVAL;

include/uapi/linux/ethtool.h+4−2

  * it was forced up into this mode or autonegotiated.
  */
-/* The forced speed, in units of 1Mb. All values 0 to INT_MAX are legal. */
+/* The forced speed, in units of 1Mb. All values 0 to INT_MAX are legal.
-/* Update drivers/net/phy/phy.c:phy_speed_to_str() when adding new values */
+ * Update drivers/net/phy/phy.c:phy_speed_to_str() and
+ * drivers/net/bonding/bond_3ad.c:__get_link_speed() when adding new values.
+ */
 #define SPEED_10		10
 #define SPEED_100		100
 #define SPEED_1000		1000

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

@@ -343,6 +343,7 @@ enum ovs_key_attr { · 342 unmodified lines
343	#define OVS_KEY_ATTR_MAX (__OVS_KEY_ATTR_MAX - 1)	343	#define OVS_KEY_ATTR_MAX (__OVS_KEY_ATTR_MAX - 1)
344		344
345	enum ovs_tunnel_key_attr {	345	enum ovs_tunnel_key_attr {
		346	/* OVS_TUNNEL_KEY_ATTR_NONE, standard nl API requires this attribute! */
346	OVS_TUNNEL_KEY_ATTR_ID, /* be64 Tunnel ID */	347	OVS_TUNNEL_KEY_ATTR_ID, /* be64 Tunnel ID */
347	OVS_TUNNEL_KEY_ATTR_IPV4_SRC, /* be32 src IP address. */	348	OVS_TUNNEL_KEY_ATTR_IPV4_SRC, /* be32 src IP address. */
348	OVS_TUNNEL_KEY_ATTR_IPV4_DST, /* be32 dst IP address. */	349	OVS_TUNNEL_KEY_ATTR_IPV4_DST, /* be32 dst IP address. */

kernel/events/ring_buffer.c+1−1

@@ -580,7 +580,7 @@ int rb_alloc_aux(struct ring_buffer rb, struct perf_event event, · 579 unmodified lines
580	int ret = -ENOMEM, max_order = 0;	580	int ret = -ENOMEM, max_order = 0;
581		581
582	if (!has_aux(event))	582	if (!has_aux(event))
583	return -ENOTSUPP;	583	return -EOPNOTSUPP;
584		584
585	if (event->pmu->capabilities & PERF_PMU_CAP_AUX_NO_SG) {	585	if (event->pmu->capabilities & PERF_PMU_CAP_AUX_NO_SG) {
586	/*	586	/*

kernel/irq/manage.c+3−1

 			ret = __irq_set_trigger(desc,
 						new->flags & IRQF_TRIGGER_MASK);
-			if (ret)
+			if (ret) {
+				irq_release_resources(desc);
 				goto out_mask;
+			}
 		}
 		desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \

kernel/livepatch/patch.c+6−2

 	ops = container_of(fops, struct klp_ops, fops);
-	rcu_read_lock();
+	/*
+	 * A variant of synchronize_sched() is used to allow patching functions
+	 * where RCU is not watching, see klp_synchronize_transition().
+	 */
+	preempt_disable_notrace();
 	func = list_first_or_null_rcu(&ops->func_stack, struct klp_func,
 				      stack_node);
 	klp_arch_set_pc(regs, (unsigned long)func->new_func);
 unlock:
-	rcu_read_unlock();
+	preempt_enable_notrace();
 }
 /*

kernel/livepatch/transition.c+31−5

 }
 static DECLARE_DELAYED_WORK(klp_transition_work, klp_transition_work_fn);
+/*
+ * This function is just a stub to implement a hard force
+ * of synchronize_sched(). This requires synchronizing
+ * tasks even in userspace and idle.
+ */
+static void klp_sync(struct work_struct *work)
+{
+}
+/*
+ * We allow to patch also functions where RCU is not watching,
+ * e.g. before user_exit(). We can not rely on the RCU infrastructure
+ * to do the synchronization. Instead hard force the sched synchronization.
+ *
+ * This approach allows to use RCU functions for manipulating func_stack
+ * safely.
+ */
+static void klp_synchronize_transition(void)
+{
+	schedule_on_each_cpu(klp_sync);
+}
 /*
  * The transition to the target patch state is complete.  Clean up the data
  * structures.
 		 * func->transition gets cleared, the handler may choose a
 		 * removed function.
 		 */
-		synchronize_rcu();
+		klp_synchronize_transition();
 	}
 	if (klp_transition_patch->immediate)
 	/* Prevent klp_ftrace_handler() from seeing KLP_UNDEFINED state */
 	if (klp_target_state == KLP_PATCHED)
-		synchronize_rcu();
+		klp_synchronize_transition();
 	read_lock(&tasklist_lock);
 	for_each_process_thread(g, task) {
  */
 void klp_update_patch_state(struct task_struct *task)
 {
-	rcu_read_lock();
+	/*
+	 * A variant of synchronize_sched() is used to allow patching functions
+	 * where RCU is not watching, see klp_synchronize_transition().
+	 */
+	preempt_disable_notrace();
 	/*
 	 * This test_and_clear_tsk_thread_flag() call also serves as a read
 	if (test_and_clear_tsk_thread_flag(task, TIF_PATCH_PENDING))
 		task->patch_state = READ_ONCE(klp_target_state);
-	rcu_read_unlock();
+	preempt_enable_notrace();
 }
 /*
 		clear_tsk_thread_flag(idle_task(cpu), TIF_PATCH_PENDING);
 	/* Let any remaining calls to klp_update_patch_state() complete */
-	synchronize_rcu();
+	klp_synchronize_transition();
 	klp_start_transition();
 }

kernel/sched/core.c+1−1

@@ -5605,7 +5605,7 @@ void idle_task_exit(void) · 5604 unmodified lines
5605	BUG_ON(cpu_online(smp_processor_id()));	5605	BUG_ON(cpu_online(smp_processor_id()));
5606		5606
5607	if (mm != &init_mm) {	5607	if (mm != &init_mm) {
5608	switch_mm_irqs_off(mm, &init_mm, current);	5608	switch_mm(mm, &init_mm, current);
5609	finish_arch_post_lock_switch();	5609	finish_arch_post_lock_switch();
5610	}	5610	}
5611	mmdrop(mm);	5611	mmdrop(mm);

kernel/sched/cpufreq_schedutil.c+0−3

@@ -101,9 +101,6 @@ static void sugov_update_commit(struct sugov_policy *sg_policy, u64 time, · 100 unmodified lines
101	if (sg_policy->next_freq == next_freq)	101	if (sg_policy->next_freq == next_freq)
102	return;	102	return;
103		103
104	if (sg_policy->next_freq > next_freq)
105	next_freq = (sg_policy->next_freq + next_freq) >> 1;
106
107	sg_policy->next_freq = next_freq;	104	sg_policy->next_freq = next_freq;
108	sg_policy->last_freq_update_time = time;	105	sg_policy->last_freq_update_time = time;
109		106

kernel/sched/fair.c+1−1

@@ -3563,7 +3563,7 @@ static inline void check_schedstat_required(void) · 3562 unmodified lines
3563	trace_sched_stat_runtime_enabled()) {	3563	trace_sched_stat_runtime_enabled()) {
3564	printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "	3564	printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "
3565	"stat_blocked and stat_runtime require the "	3565	"stat_blocked and stat_runtime require the "
3566	"kernel parameter schedstats=enabled or "	3566	"kernel parameter schedstats=enable or "
3567	"kernel.sched_schedstats=1\n");	3567	"kernel.sched_schedstats=1\n");
3568	}	3568	}
3569	#endif	3569	#endif

kernel/signal.c+14−6

 	return !tsk->ptrace;
 }
-static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
+static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
+			   bool *resched_timer)
 {
 	struct sigqueue *q, *first = NULL;
 still_pending:
 		list_del_init(&first->list);
 		copy_siginfo(info, &first->info);
+		*resched_timer =
+			(first->flags & SIGQUEUE_PREALLOC) &&
+			(info->si_code == SI_TIMER) &&
+			(info->si_sys_private);
 		__sigqueue_free(first);
 	} else {
 		/*
 }
 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
-			siginfo_t *info)
+			siginfo_t *info, bool *resched_timer)
 {
 	int sig = next_signal(pending, mask);
 	if (sig)
-		collect_signal(sig, pending, info);
+		collect_signal(sig, pending, info, resched_timer);
 	return sig;
 }
  */
 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
+	bool resched_timer = false;
 	int signr;
 	/* We only dequeue private signals from ourselves, we don't let
 	 * signalfd steal them
 	 */
-	signr = __dequeue_signal(&tsk->pending, mask, info);
+	signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
 	if (!signr) {
 		signr = __dequeue_signal(&tsk->signal->shared_pending,
-					 mask, info);
+					 mask, info, &resched_timer);
 #ifdef CONFIG_POSIX_TIMERS
 		/*
 		 * itimer signal ?
 		current->jobctl |= JOBCTL_STOP_DEQUEUED;
 	}
 #ifdef CONFIG_POSIX_TIMERS
-	if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
+	if (resched_timer) {
 		/*
 		 * Release the siglock to ensure proper locking order
 		 * of timer locks outside of siglocks.  Note, we leave

kernel/time/alarmtimer.c+11−3

 {
 	struct alarm_base *base = &alarm_bases[alarm->type];
-	start = ktime_add(start, base->gettime());
+	start = ktime_add_safe(start, base->gettime());
 	alarm_start(alarm, start);
 }
 EXPORT_SYMBOL_GPL(alarm_start_relative);
 		overrun++;
 	}
-	alarm->node.expires = ktime_add(alarm->node.expires, interval);
+	alarm->node.expires = ktime_add_safe(alarm->node.expires, interval);
 	return overrun;
 }
 EXPORT_SYMBOL_GPL(alarm_forward);
 	/* start the timer */
 	timr->it.alarm.interval = timespec64_to_ktime(new_setting->it_interval);
+	/*
+	 * Rate limit to the tick as a hot fix to prevent DOS. Will be
+	 * mopped up later.
+	 */
+	if (timr->it.alarm.interval < TICK_NSEC)
+		timr->it.alarm.interval = TICK_NSEC;
 	exp = timespec64_to_ktime(new_setting->it_value);
 	/* Convert (if necessary) to absolute time */
 	if (flags != TIMER_ABSTIME) {
 		ktime_t now;
 		now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
-		exp = ktime_add(now, exp);
+		exp = ktime_add_safe(now, exp);
 	}
 	alarm_start(&timr->it.alarm.alarmtimer, exp);

kernel/time/tick-broadcast.c+3−1

 static __cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
 #ifdef CONFIG_TICK_ONESHOT
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 static void tick_broadcast_clear_oneshot(int cpu);
 static void tick_resume_broadcast_oneshot(struct clock_event_device *bc);
 #else
+static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_clear_oneshot(int cpu) { }
 static inline void tick_resume_broadcast_oneshot(struct clock_event_device *bc) { }
 #endif
 /**
  * tick_broadcast_setup_oneshot - setup the broadcast device
  */
-void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
 	int cpu = smp_processor_id();

kernel/time/tick-internal.h+0−2

 /* Functions related to oneshot broadcasting */
 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
-extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 extern void tick_broadcast_switch_to_oneshot(void);
 extern void tick_shutdown_broadcast_oneshot(unsigned int cpu);
 extern int tick_broadcast_oneshot_active(void);
 bool tick_broadcast_oneshot_available(void);
 extern struct cpumask *tick_get_broadcast_oneshot_mask(void);
 #else /* !(BROADCAST && ONESHOT): */
-static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_switch_to_oneshot(void) { }
 static inline void tick_shutdown_broadcast_oneshot(unsigned int cpu) { }
 static inline int tick_broadcast_oneshot_active(void) { return 0; }

kernel/time/timekeeping.c+46−25

@@ -118,6 +118,26 @@ static inline void tk_update_sleep_time(struct timekeeper *tk, ktime_t delta) · 117 unmodified lines
118	tk->offs_boot = ktime_add(tk->offs_boot, delta);	118	tk->offs_boot = ktime_add(tk->offs_boot, delta);
119	}	119	}
120		120
		121	/*
		122	* tk_clock_read - atomic clocksource read() helper
		123	*
		124	* This helper is necessary to use in the read paths because, while the
		125	* seqlock ensures we don't return a bad value while structures are updated,
		126	* it doesn't protect from potential crashes. There is the possibility that
		127	* the tkr's clocksource may change between the read reference, and the
		128	* clock reference passed to the read function. This can cause crashes if
		129	* the wrong clocksource is passed to the wrong read function.
		130	* This isn't necessary to use when holding the timekeeper_lock or doing
		131	* a read of the fast-timekeeper tkrs (which is protected by its own locking
		132	* and update logic).
		133	*/
		134	static inline u64 tk_clock_read(struct tk_read_base *tkr)
		135	{
		136	struct clocksource *clock = READ_ONCE(tkr->clock);
		137
		138	return clock->read(clock);
		139	}
		140
121	#ifdef CONFIG_DEBUG_TIMEKEEPING	141	#ifdef CONFIG_DEBUG_TIMEKEEPING
122	#define WARNING_FREQ (HZ300) / 5 minute rate-limiting */	142	#define WARNING_FREQ (HZ300) / 5 minute rate-limiting */
123		143
@@ -175,7 +195,7 @@ static inline u64 timekeeping_get_delta(struct tk_read_base *tkr) · 51 unmodified lines
175	*/	195	*/
176	do {	196	do {
177	seq = read_seqcount_begin(&tk_core.seq);	197	seq = read_seqcount_begin(&tk_core.seq);
178	now = tkr->read(tkr->clock);	198	now = tk_clock_read(tkr);
179	last = tkr->cycle_last;	199	last = tkr->cycle_last;
180	mask = tkr->mask;	200	mask = tkr->mask;
181	max = tkr->clock->max_cycles;	201	max = tkr->clock->max_cycles;
@@ -209,7 +229,7 @@ static inline u64 timekeeping_get_delta(struct tk_read_base *tkr) · 27 unmodified lines
209	u64 cycle_now, delta;	229	u64 cycle_now, delta;
210		230
211	/* read clocksource */	231	/* read clocksource */
212	cycle_now = tkr->read(tkr->clock);	232	cycle_now = tk_clock_read(tkr);
213		233
214	/* calculate the delta since the last update_wall_time */	234	/* calculate the delta since the last update_wall_time */
215	delta = clocksource_delta(cycle_now, tkr->cycle_last, tkr->mask);	235	delta = clocksource_delta(cycle_now, tkr->cycle_last, tkr->mask);
@@ -238,12 +258,10 @@ static void tk_setup_internals(struct timekeeper tk, struct clocksource clock) · 22 unmodified lines
238	++tk->cs_was_changed_seq;	258	++tk->cs_was_changed_seq;
239	old_clock = tk->tkr_mono.clock;	259	old_clock = tk->tkr_mono.clock;
240	tk->tkr_mono.clock = clock;	260	tk->tkr_mono.clock = clock;
241	tk->tkr_mono.read = clock->read;
242	tk->tkr_mono.mask = clock->mask;	261	tk->tkr_mono.mask = clock->mask;
243	tk->tkr_mono.cycle_last = tk->tkr_mono.read(clock);	262	tk->tkr_mono.cycle_last = tk_clock_read(&tk->tkr_mono);
244		263
245	tk->tkr_raw.clock = clock;	264	tk->tkr_raw.clock = clock;
246	tk->tkr_raw.read = clock->read;
247	tk->tkr_raw.mask = clock->mask;	265	tk->tkr_raw.mask = clock->mask;
248	tk->tkr_raw.cycle_last = tk->tkr_mono.cycle_last;	266	tk->tkr_raw.cycle_last = tk->tkr_mono.cycle_last;
249		267
@@ -262,7 +280,7 @@ static void tk_setup_internals(struct timekeeper tk, struct clocksource clock) · 12 unmodified lines
262	/* Go back from cycles -> shifted ns */	280	/* Go back from cycles -> shifted ns */
263	tk->xtime_interval = interval * clock->mult;	281	tk->xtime_interval = interval * clock->mult;
264	tk->xtime_remainder = ntpinterval - tk->xtime_interval;	282	tk->xtime_remainder = ntpinterval - tk->xtime_interval;
265	tk->raw_interval = (interval * clock->mult) >> clock->shift;	283	tk->raw_interval = interval * clock->mult;
266		284
267	/* if changing clocks, convert xtime_nsec shift units */	285	/* if changing clocks, convert xtime_nsec shift units */
268	if (old_clock) {	286	if (old_clock) {
@@ -404,7 +422,7 @@ static __always_inline u64 __ktime_get_fast_ns(struct tk_fast *tkf) · 135 unmodified lines
404		422
405	now += timekeeping_delta_to_ns(tkr,	423	now += timekeeping_delta_to_ns(tkr,
406	clocksource_delta(	424	clocksource_delta(
407	tkr->read(tkr->clock),	425	tk_clock_read(tkr),
408	tkr->cycle_last,	426	tkr->cycle_last,
409	tkr->mask));	427	tkr->mask));
410	} while (read_seqcount_retry(&tkf->seq, seq));	428	} while (read_seqcount_retry(&tkf->seq, seq));
@@ -461,6 +479,10 @@ static u64 dummy_clock_read(struct clocksource *cs) · 50 unmodified lines
461	return cycles_at_suspend;	479	return cycles_at_suspend;
462	}	480	}
463		481
		482	static struct clocksource dummy_clock = {
		483	.read = dummy_clock_read,
		484	};
		485
464	/**	486	/**
465	* halt_fast_timekeeper - Prevent fast timekeeper from accessing clocksource.	487	* halt_fast_timekeeper - Prevent fast timekeeper from accessing clocksource.
466	* @tk: Timekeeper to snapshot.	488	* @tk: Timekeeper to snapshot.
@@ -477,13 +499,13 @@ static void halt_fast_timekeeper(struct timekeeper *tk) · 10 unmodified lines
477	struct tk_read_base *tkr = &tk->tkr_mono;	499	struct tk_read_base *tkr = &tk->tkr_mono;
478		500
479	memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));	501	memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));
480	cycles_at_suspend = tkr->read(tkr->clock);	502	cycles_at_suspend = tk_clock_read(tkr);
481	tkr_dummy.read = dummy_clock_read;	503	tkr_dummy.clock = &dummy_clock;
482	update_fast_timekeeper(&tkr_dummy, &tk_fast_mono);	504	update_fast_timekeeper(&tkr_dummy, &tk_fast_mono);
483		505
484	tkr = &tk->tkr_raw;	506	tkr = &tk->tkr_raw;
485	memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));	507	memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));
486	tkr_dummy.read = dummy_clock_read;	508	tkr_dummy.clock = &dummy_clock;
487	update_fast_timekeeper(&tkr_dummy, &tk_fast_raw);	509	update_fast_timekeeper(&tkr_dummy, &tk_fast_raw);
488	}	510	}
489		511
@@ -649,11 +671,10 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action) · 159 unmodified lines
649	*/	671	*/
650	static void timekeeping_forward_now(struct timekeeper *tk)	672	static void timekeeping_forward_now(struct timekeeper *tk)
651	{	673	{
652	struct clocksource *clock = tk->tkr_mono.clock;
653	u64 cycle_now, delta;	674	u64 cycle_now, delta;
654	u64 nsec;	675	u64 nsec;
655		676
656	cycle_now = tk->tkr_mono.read(clock);	677	cycle_now = tk_clock_read(&tk->tkr_mono);
657	delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask);	678	delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
658	tk->tkr_mono.cycle_last = cycle_now;	679	tk->tkr_mono.cycle_last = cycle_now;
659	tk->tkr_raw.cycle_last = cycle_now;	680	tk->tkr_raw.cycle_last = cycle_now;
@@ -929,8 +950,7 @@ void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot) · 269 unmodified lines
929		950
930	do {	951	do {
931	seq = read_seqcount_begin(&tk_core.seq);	952	seq = read_seqcount_begin(&tk_core.seq);
932		953	now = tk_clock_read(&tk->tkr_mono);
933	now = tk->tkr_mono.read(tk->tkr_mono.clock);
934	systime_snapshot->cs_was_changed_seq = tk->cs_was_changed_seq;	954	systime_snapshot->cs_was_changed_seq = tk->cs_was_changed_seq;
935	systime_snapshot->clock_was_set_seq = tk->clock_was_set_seq;	955	systime_snapshot->clock_was_set_seq = tk->clock_was_set_seq;
936	base_real = ktime_add(tk->tkr_mono.base,	956	base_real = ktime_add(tk->tkr_mono.base,
@@ -1108,7 +1128,7 @@ int get_device_system_crosststamp(int (*get_time_fn) · 171 unmodified lines
1108	* Check whether the system counter value provided by the	1128	* Check whether the system counter value provided by the
1109	* device driver is on the current timekeeping interval.	1129	* device driver is on the current timekeeping interval.
1110	*/	1130	*/
1111	now = tk->tkr_mono.read(tk->tkr_mono.clock);	1131	now = tk_clock_read(&tk->tkr_mono);
1112	interval_start = tk->tkr_mono.cycle_last;	1132	interval_start = tk->tkr_mono.cycle_last;
1113	if (!cycle_between(interval_start, cycles, now)) {	1133	if (!cycle_between(interval_start, cycles, now)) {
1114	clock_was_set_seq = tk->clock_was_set_seq;	1134	clock_was_set_seq = tk->clock_was_set_seq;
@@ -1629,7 +1649,7 @@ void timekeeping_resume(void) · 514 unmodified lines
1629	* The less preferred source will only be tried if there is no better	1649	* The less preferred source will only be tried if there is no better
1630	* usable source. The rtc part is handled separately in rtc core code.	1650	* usable source. The rtc part is handled separately in rtc core code.
1631	*/	1651	*/
1632	cycle_now = tk->tkr_mono.read(clock);	1652	cycle_now = tk_clock_read(&tk->tkr_mono);
1633	if ((clock->flags & CLOCK_SOURCE_SUSPEND_NONSTOP) &&	1653	if ((clock->flags & CLOCK_SOURCE_SUSPEND_NONSTOP) &&
1634	cycle_now > tk->tkr_mono.cycle_last) {	1654	cycle_now > tk->tkr_mono.cycle_last) {
1635	u64 nsec, cyc_delta;	1655	u64 nsec, cyc_delta;
@@ -1976,7 +1996,7 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset, · 340 unmodified lines
1976	u32 shift, unsigned int *clock_set)	1996	u32 shift, unsigned int *clock_set)
1977	{	1997	{
1978	u64 interval = tk->cycle_interval << shift;	1998	u64 interval = tk->cycle_interval << shift;
1979	u64 raw_nsecs;	1999	u64 snsec_per_sec;
1980		2000
1981	/* If the offset is smaller than a shifted interval, do nothing */	2001	/* If the offset is smaller than a shifted interval, do nothing */
1982	if (offset < interval)	2002	if (offset < interval)
@@ -1991,14 +2011,15 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset, · 8 unmodified lines
1991	*clock_set \|= accumulate_nsecs_to_secs(tk);	2011	*clock_set \|= accumulate_nsecs_to_secs(tk);
1992		2012
1993	/* Accumulate raw time */	2013	/* Accumulate raw time */
1994	raw_nsecs = (u64)tk->raw_interval << shift;	2014	tk->tkr_raw.xtime_nsec += (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;
1995	raw_nsecs += tk->raw_time.tv_nsec;	2015	tk->tkr_raw.xtime_nsec += tk->raw_interval << shift;
1996	if (raw_nsecs >= NSEC_PER_SEC) {	2016	snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
1997	u64 raw_secs = raw_nsecs;	2017	while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) {
1998	raw_nsecs = do_div(raw_secs, NSEC_PER_SEC);	2018	tk->tkr_raw.xtime_nsec -= snsec_per_sec;
1999	tk->raw_time.tv_sec += raw_secs;	2019	tk->raw_time.tv_sec++;
2000	}	2020	}
2001	tk->raw_time.tv_nsec = raw_nsecs;	2021	tk->raw_time.tv_nsec = tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift;
		2022	tk->tkr_raw.xtime_nsec -= (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;
2002		2023
2003	/* Accumulate error between NTP and clock interval */	2024	/* Accumulate error between NTP and clock interval */
2004	tk->ntp_error += tk->ntp_tick << shift;	2025	tk->ntp_error += tk->ntp_tick << shift;
@@ -2030,7 +2051,7 @@ void update_wall_time(void) · 25 unmodified lines
2030	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET	2051	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
2031	offset = real_tk->cycle_interval;	2052	offset = real_tk->cycle_interval;
2032	#else	2053	#else
2033	offset = clocksource_delta(tk->tkr_mono.read(tk->tkr_mono.clock),	2054	offset = clocksource_delta(tk_clock_read(&tk->tkr_mono),
2034	tk->tkr_mono.cycle_last, tk->tkr_mono.mask);	2055	tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
2035	#endif	2056	#endif
2036		2057

lib/cmdline.c+3−3

@@ -23,14 +23,14 @@ · 22 unmodified lines
23	* the values[M, M+1, ..., N] into the ints array in get_options.	23	* the values[M, M+1, ..., N] into the ints array in get_options.
24	*/	24	*/
25		25
26	static int get_range(char *str, int pint)	26	static int get_range(char *str, int pint, int n)
27	{	27	{
28	int x, inc_counter, upper_range;	28	int x, inc_counter, upper_range;
29		29
30	(*str)++;	30	(*str)++;
31	upper_range = simple_strtol((*str), NULL, 0);	31	upper_range = simple_strtol((*str), NULL, 0);
32	inc_counter = upper_range - *pint;	32	inc_counter = upper_range - *pint;
33	for (x = *pint; x < upper_range; x++)	33	for (x = *pint; n && x < upper_range; x++, n--)
34	*pint++ = x;	34	*pint++ = x;
35	return inc_counter;	35	return inc_counter;
36	}	36	}
@@ -97,7 +97,7 @@ char get_options(const char str, int nints, int *ints) · 60 unmodified lines
97	break;	97	break;
98	if (res == 3) {	98	if (res == 3) {
99	int range_nums;	99	int range_nums;
100	range_nums = get_range((char **)&str, ints + i);	100	range_nums = get_range((char **)&str, ints + i, nints - i);
101	if (range_nums < 0)	101	if (range_nums < 0)
102	break;	102	break;
103	/*	103	/*

lib/libcrc32c.c+4−2

 u32 crc32c(u32 crc, const void *address, unsigned int length)
 {
 	SHASH_DESC_ON_STACK(shash, tfm);
-	u32 *ctx = (u32 *)shash_desc_ctx(shash);
+	u32 ret, *ctx = (u32 *)shash_desc_ctx(shash);
 	int err;
 	shash->tfm = tfm;
 	err = crypto_shash_update(shash, address, length);
 	BUG_ON(err);
-	return *ctx;
+	ret = *ctx;
+	barrier_data(ctx);
+	return ret;
 }
 EXPORT_SYMBOL(crc32c);

mm/gup.c+0−5

 	/* mlock all present pages, but do not fault in new pages */
 	if ((*flags & (FOLL_POPULATE | FOLL_MLOCK)) == FOLL_MLOCK)
 		return -ENOENT;
-	/* For mm_populate(), just skip the stack guard page. */
-	if ((*flags & FOLL_POPULATE) &&
-			(stack_guard_page_start(vma, address) ||
-			 stack_guard_page_end(vma, address + PAGE_SIZE)))
-		return -ENOENT;
 	if (*flags & FOLL_WRITE)
 		fault_flags |= FAULT_FLAG_WRITE;
 	if (*flags & FOLL_REMOTE)

mm/huge_memory.c+7−1

 	 */
 	if (unlikely(pmd_trans_migrating(*vmf->pmd))) {
 		page = pmd_page(*vmf->pmd);
+		if (!get_page_unless_zero(page))
+			goto out_unlock;
 		spin_unlock(vmf->ptl);
 		wait_on_page_locked(page);
+		put_page(page);
 		goto out;
 	}
 	/* Migration could have started since the pmd_trans_migrating check */
 	if (!page_locked) {
+		page_nid = -1;
+		if (!get_page_unless_zero(page))
+			goto out_unlock;
 		spin_unlock(vmf->ptl);
 		wait_on_page_locked(page);
-		page_nid = -1;
+		put_page(page);
 		goto out;
 	}

mm/khugepaged.c+0−1

@@ -652,7 +652,6 @@ static void __collapse_huge_page_copy(pte_t pte, struct page page, · 651 unmodified lines
652	spin_unlock(ptl);	652	spin_unlock(ptl);
653	free_page_and_swap_cache(src_page);	653	free_page_and_swap_cache(src_page);
654	}	654	}
655	cond_resched();
656	}	655	}
657	}	656	}
658		657

mm/memory-failure.c+4−1

 	 * page_remove_rmap() in try_to_unmap_one(). So to determine page status
 	 * correctly, we save a copy of the page flags at this time.
 	 */
-	page_flags = p->flags;
+	if (PageHuge(p))
+		page_flags = hpage->flags;
+	else
+		page_flags = p->flags;
 	/*
 	 * unpoison always clear PG_hwpoison inside page lock

mm/memory.c+0−38

@@ -2854,40 +2854,6 @@ out_release: · 2853 unmodified lines
2854	return ret;	2854	return ret;
2855	}	2855	}
2856		2856
2857	/*
2858	* This is like a special single-page "expand_{down\|up}wards()",
2859	* except we must first make sure that 'address{-\|+}PAGE_SIZE'
2860	* doesn't hit another vma.
2861	*/
2862	static inline int check_stack_guard_page(struct vm_area_struct *vma, unsigned long address)
2863	{
2864	address &= PAGE_MASK;
2865	if ((vma->vm_flags & VM_GROWSDOWN) && address == vma->vm_start) {
2866	struct vm_area_struct *prev = vma->vm_prev;
2867
2868	/*
2869	* Is there a mapping abutting this one below?
2870	*
2871	* That's only ok if it's the same stack mapping
2872	* that has gotten split..
2873	*/
2874	if (prev && prev->vm_end == address)
2875	return prev->vm_flags & VM_GROWSDOWN ? 0 : -ENOMEM;
2876
2877	return expand_downwards(vma, address - PAGE_SIZE);
2878	}
2879	if ((vma->vm_flags & VM_GROWSUP) && address + PAGE_SIZE == vma->vm_end) {
2880	struct vm_area_struct *next = vma->vm_next;
2881
2882	/* As VM_GROWSDOWN but s/below/above/ */
2883	if (next && next->vm_start == address + PAGE_SIZE)
2884	return next->vm_flags & VM_GROWSUP ? 0 : -ENOMEM;
2885
2886	return expand_upwards(vma, address + PAGE_SIZE);
2887	}
2888	return 0;
2889	}
2890
2891	/*	2857	/*
2892	* We enter with non-exclusive mmap_sem (to exclude vma changes,	2858	* We enter with non-exclusive mmap_sem (to exclude vma changes,
2893	* but allow concurrent faults), and pte mapped but not yet locked.	2859	* but allow concurrent faults), and pte mapped but not yet locked.
@@ -2904,10 +2870,6 @@ static int do_anonymous_page(struct vm_fault *vmf) · 10 unmodified lines
2904	if (vma->vm_flags & VM_SHARED)	2870	if (vma->vm_flags & VM_SHARED)
2905	return VM_FAULT_SIGBUS;	2871	return VM_FAULT_SIGBUS;
2906		2872
2907	/* Check if we need to add a guard page to the stack */
2908	if (check_stack_guard_page(vma, vmf->address) < 0)
2909	return VM_FAULT_SIGSEGV;
2910
2911	/*	2873	/*
2912	* Use pte_alloc() instead of pte_alloc_map(). We can't run	2874	* Use pte_alloc() instead of pte_alloc_map(). We can't run
2913	* pte_offset_map() on pmds where a huge pmd might be created	2875	* pte_offset_map() on pmds where a huge pmd might be created

mm/mmap.c+97−63

@@ -183,6 +183,7 @@ SYSCALL_DEFINE1(brk, unsigned long, brk) · 182 unmodified lines
183	unsigned long retval;	183	unsigned long retval;
184	unsigned long newbrk, oldbrk;	184	unsigned long newbrk, oldbrk;
185	struct mm_struct *mm = current->mm;	185	struct mm_struct *mm = current->mm;
		186	struct vm_area_struct *next;
186	unsigned long min_brk;	187	unsigned long min_brk;
187	bool populate;	188	bool populate;
188	LIST_HEAD(uf);	189	LIST_HEAD(uf);
@@ -229,7 +230,8 @@ SYSCALL_DEFINE1(brk, unsigned long, brk) · 40 unmodified lines
229	}	230	}
230		231
231	/* Check against existing mmap mappings. */	232	/* Check against existing mmap mappings. */
232	if (find_vma_intersection(mm, oldbrk, newbrk+PAGE_SIZE))	233	next = find_vma(mm, oldbrk);
		234	if (next && newbrk + PAGE_SIZE > vm_start_gap(next))
233	goto out;	235	goto out;
234		236
235	/* Ok, looks good - let it rip. */	237	/* Ok, looks good - let it rip. */
@@ -253,10 +255,22 @@ out: · 17 unmodified lines
253		255
254	static long vma_compute_subtree_gap(struct vm_area_struct *vma)	256	static long vma_compute_subtree_gap(struct vm_area_struct *vma)
255	{	257	{
256	unsigned long max, subtree_gap;	258	unsigned long max, prev_end, subtree_gap;
257	max = vma->vm_start;	259
258	if (vma->vm_prev)	260	/*
259	max -= vma->vm_prev->vm_end;	261	* Note: in the rare case of a VM_GROWSDOWN above a VM_GROWSUP, we
		262	* allow two stack_guard_gaps between them here, and when choosing
		263	* an unmapped area; whereas when expanding we only require one.
		264	* That's a little inconsistent, but keeps the code here simpler.
		265	*/
		266	max = vm_start_gap(vma);
		267	if (vma->vm_prev) {
		268	prev_end = vm_end_gap(vma->vm_prev);
		269	if (max > prev_end)
		270	max -= prev_end;
		271	else
		272	max = 0;
		273	}
260	if (vma->vm_rb.rb_left) {	274	if (vma->vm_rb.rb_left) {
261	subtree_gap = rb_entry(vma->vm_rb.rb_left,	275	subtree_gap = rb_entry(vma->vm_rb.rb_left,
262	struct vm_area_struct, vm_rb)->rb_subtree_gap;	276	struct vm_area_struct, vm_rb)->rb_subtree_gap;
@@ -352,7 +366,7 @@ static void validate_mm(struct mm_struct *mm) · 89 unmodified lines
352	anon_vma_unlock_read(anon_vma);	366	anon_vma_unlock_read(anon_vma);
353	}	367	}
354		368
355	highest_address = vma->vm_end;	369	highest_address = vm_end_gap(vma);
356	vma = vma->vm_next;	370	vma = vma->vm_next;
357	i++;	371	i++;
358	}	372	}
@@ -541,7 +555,7 @@ void __vma_link_rb(struct mm_struct mm, struct vm_area_struct vma, · 182 unmodified lines
541	if (vma->vm_next)	555	if (vma->vm_next)
542	vma_gap_update(vma->vm_next);	556	vma_gap_update(vma->vm_next);
543	else	557	else
544	mm->highest_vm_end = vma->vm_end;	558	mm->highest_vm_end = vm_end_gap(vma);
545		559
546	/*	560	/*
547	* vma->vm_prev wasn't known when we followed the rbtree to find the	561	* vma->vm_prev wasn't known when we followed the rbtree to find the
@@ -856,7 +870,7 @@ again: · 308 unmodified lines
856	vma_gap_update(vma);	870	vma_gap_update(vma);
857	if (end_changed) {	871	if (end_changed) {
858	if (!next)	872	if (!next)
859	mm->highest_vm_end = end;	873	mm->highest_vm_end = vm_end_gap(vma);
860	else if (!adjust_next)	874	else if (!adjust_next)
861	vma_gap_update(next);	875	vma_gap_update(next);
862	}	876	}
@@ -941,7 +955,7 @@ again: · 78 unmodified lines
941	* mm->highest_vm_end doesn't need any update	955	* mm->highest_vm_end doesn't need any update
942	* in remove_next == 1 case.	956	* in remove_next == 1 case.
943	*/	957	*/
944	VM_WARN_ON(mm->highest_vm_end != end);	958	VM_WARN_ON(mm->highest_vm_end != vm_end_gap(vma));
945	}	959	}
946	}	960	}
947	if (insert && file)	961	if (insert && file)
@@ -1787,7 +1801,7 @@ unsigned long unmapped_area(struct vm_unmapped_area_info *info) · 839 unmodified lines
1787		1801
1788	while (true) {	1802	while (true) {
1789	/* Visit left subtree if it looks promising */	1803	/* Visit left subtree if it looks promising */
1790	gap_end = vma->vm_start;	1804	gap_end = vm_start_gap(vma);
1791	if (gap_end >= low_limit && vma->vm_rb.rb_left) {	1805	if (gap_end >= low_limit && vma->vm_rb.rb_left) {
1792	struct vm_area_struct *left =	1806	struct vm_area_struct *left =
1793	rb_entry(vma->vm_rb.rb_left,	1807	rb_entry(vma->vm_rb.rb_left,
@@ -1798,12 +1812,13 @@ unsigned long unmapped_area(struct vm_unmapped_area_info *info) · 4 unmodified lines
1798	}	1812	}
1799	}	1813	}
1800		1814
1801	gap_start = vma->vm_prev ? vma->vm_prev->vm_end : 0;	1815	gap_start = vma->vm_prev ? vm_end_gap(vma->vm_prev) : 0;
1802	check_current:	1816	check_current:
1803	/* Check if current node has a suitable gap */	1817	/* Check if current node has a suitable gap */
1804	if (gap_start > high_limit)	1818	if (gap_start > high_limit)
1805	return -ENOMEM;	1819	return -ENOMEM;
1806	if (gap_end >= low_limit && gap_end - gap_start >= length)	1820	if (gap_end >= low_limit &&
		1821	gap_end > gap_start && gap_end - gap_start >= length)
1807	goto found;	1822	goto found;
1808		1823
1809	/* Visit right subtree if it looks promising */	1824	/* Visit right subtree if it looks promising */
@@ -1825,8 +1840,8 @@ check_current: · 15 unmodified lines
1825	vma = rb_entry(rb_parent(prev),	1840	vma = rb_entry(rb_parent(prev),
1826	struct vm_area_struct, vm_rb);	1841	struct vm_area_struct, vm_rb);
1827	if (prev == vma->vm_rb.rb_left) {	1842	if (prev == vma->vm_rb.rb_left) {
1828	gap_start = vma->vm_prev->vm_end;	1843	gap_start = vm_end_gap(vma->vm_prev);
1829	gap_end = vma->vm_start;	1844	gap_end = vm_start_gap(vma);
1830	goto check_current;	1845	goto check_current;
1831	}	1846	}
1832	}	1847	}
@@ -1890,7 +1905,7 @@ unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info) · 57 unmodified lines
1890		1905
1891	while (true) {	1906	while (true) {
1892	/* Visit right subtree if it looks promising */	1907	/* Visit right subtree if it looks promising */
1893	gap_start = vma->vm_prev ? vma->vm_prev->vm_end : 0;	1908	gap_start = vma->vm_prev ? vm_end_gap(vma->vm_prev) : 0;
1894	if (gap_start <= high_limit && vma->vm_rb.rb_right) {	1909	if (gap_start <= high_limit && vma->vm_rb.rb_right) {
1895	struct vm_area_struct *right =	1910	struct vm_area_struct *right =
1896	rb_entry(vma->vm_rb.rb_right,	1911	rb_entry(vma->vm_rb.rb_right,
@@ -1903,10 +1918,11 @@ unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info) · 6 unmodified lines
1903		1918
1904	check_current:	1919	check_current:
1905	/* Check if current node has a suitable gap */	1920	/* Check if current node has a suitable gap */
1906	gap_end = vma->vm_start;	1921	gap_end = vm_start_gap(vma);
1907	if (gap_end < low_limit)	1922	if (gap_end < low_limit)
1908	return -ENOMEM;	1923	return -ENOMEM;
1909	if (gap_start <= high_limit && gap_end - gap_start >= length)	1924	if (gap_start <= high_limit &&
		1925	gap_end > gap_start && gap_end - gap_start >= length)
1910	goto found;	1926	goto found;
1911		1927
1912	/* Visit left subtree if it looks promising */	1928	/* Visit left subtree if it looks promising */
@@ -1929,7 +1945,7 @@ check_current: · 16 unmodified lines
1929	struct vm_area_struct, vm_rb);	1945	struct vm_area_struct, vm_rb);
1930	if (prev == vma->vm_rb.rb_right) {	1946	if (prev == vma->vm_rb.rb_right) {
1931	gap_start = vma->vm_prev ?	1947	gap_start = vma->vm_prev ?
1932	vma->vm_prev->vm_end : 0;	1948	vm_end_gap(vma->vm_prev) : 0;
1933	goto check_current;	1949	goto check_current;
1934	}	1950	}
1935	}	1951	}
@@ -1967,7 +1983,7 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 31 unmodified lines
1967	unsigned long len, unsigned long pgoff, unsigned long flags)	1983	unsigned long len, unsigned long pgoff, unsigned long flags)
1968	{	1984	{
1969	struct mm_struct *mm = current->mm;	1985	struct mm_struct *mm = current->mm;
1970	struct vm_area_struct *vma;	1986	struct vm_area_struct vma, prev;
1971	struct vm_unmapped_area_info info;	1987	struct vm_unmapped_area_info info;
1972		1988
1973	if (len > TASK_SIZE - mmap_min_addr)	1989	if (len > TASK_SIZE - mmap_min_addr)
@@ -1978,9 +1994,10 @@ arch_get_unmapped_area(struct file *filp, unsigned long addr, · 4 unmodified lines
1978		1994
1979	if (addr) {	1995	if (addr) {
1980	addr = PAGE_ALIGN(addr);	1996	addr = PAGE_ALIGN(addr);
1981	vma = find_vma(mm, addr);	1997	vma = find_vma_prev(mm, addr, &prev);
1982	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&	1998	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&
1983	(!vma \|\| addr + len <= vma->vm_start))	1999	(!vma \|\| addr + len <= vm_start_gap(vma)) &&
		2000	(!prev \|\| addr >= vm_end_gap(prev)))
1984	return addr;	2001	return addr;
1985	}	2002	}
1986		2003
@@ -2003,7 +2020,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 16 unmodified lines
2003	const unsigned long len, const unsigned long pgoff,	2020	const unsigned long len, const unsigned long pgoff,
2004	const unsigned long flags)	2021	const unsigned long flags)
2005	{	2022	{
2006	struct vm_area_struct *vma;	2023	struct vm_area_struct vma, prev;
2007	struct mm_struct *mm = current->mm;	2024	struct mm_struct *mm = current->mm;
2008	unsigned long addr = addr0;	2025	unsigned long addr = addr0;
2009	struct vm_unmapped_area_info info;	2026	struct vm_unmapped_area_info info;
@@ -2018,9 +2035,10 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0, · 8 unmodified lines
2018	/* requesting a specific address */	2035	/* requesting a specific address */
2019	if (addr) {	2036	if (addr) {
2020	addr = PAGE_ALIGN(addr);	2037	addr = PAGE_ALIGN(addr);
2021	vma = find_vma(mm, addr);	2038	vma = find_vma_prev(mm, addr, &prev);
2022	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&	2039	if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&
2023	(!vma \|\| addr + len <= vma->vm_start))	2040	(!vma \|\| addr + len <= vm_start_gap(vma)) &&
		2041	(!prev \|\| addr >= vm_end_gap(prev)))
2024	return addr;	2042	return addr;
2025	}	2043	}
2026		2044
@@ -2155,21 +2173,19 @@ find_vma_prev(struct mm_struct *mm, unsigned long addr, · 128 unmodified lines
2155	* update accounting. This is shared with both the	2173	* update accounting. This is shared with both the
2156	* grow-up and grow-down cases.	2174	* grow-up and grow-down cases.
2157	*/	2175	*/
2158	static int acct_stack_growth(struct vm_area_struct *vma, unsigned long size, unsigned long grow)	2176	static int acct_stack_growth(struct vm_area_struct *vma,
		2177	unsigned long size, unsigned long grow)
2159	{	2178	{
2160	struct mm_struct *mm = vma->vm_mm;	2179	struct mm_struct *mm = vma->vm_mm;
2161	struct rlimit *rlim = current->signal->rlim;	2180	struct rlimit *rlim = current->signal->rlim;
2162	unsigned long new_start, actual_size;	2181	unsigned long new_start;
2163		2182
2164	/* address space limit tests */	2183	/* address space limit tests */
2165	if (!may_expand_vm(mm, vma->vm_flags, grow))	2184	if (!may_expand_vm(mm, vma->vm_flags, grow))
2166	return -ENOMEM;	2185	return -ENOMEM;
2167		2186
2168	/* Stack limit test */	2187	/* Stack limit test */
2169	actual_size = size;	2188	if (size > READ_ONCE(rlim[RLIMIT_STACK].rlim_cur))
2170	if (size && (vma->vm_flags & (VM_GROWSUP \| VM_GROWSDOWN)))
2171	actual_size -= PAGE_SIZE;
2172	if (actual_size > READ_ONCE(rlim[RLIMIT_STACK].rlim_cur))
2173	return -ENOMEM;	2189	return -ENOMEM;
2174		2190
2175	/* mlock limit tests */	2191	/* mlock limit tests */
@@ -2207,16 +2223,32 @@ static int acct_stack_growth(struct vm_area_struct *vma, unsigned long size, uns · 31 unmodified lines
2207	int expand_upwards(struct vm_area_struct *vma, unsigned long address)	2223	int expand_upwards(struct vm_area_struct *vma, unsigned long address)
2208	{	2224	{
2209	struct mm_struct *mm = vma->vm_mm;	2225	struct mm_struct *mm = vma->vm_mm;
		2226	struct vm_area_struct *next;
		2227	unsigned long gap_addr;
2210	int error = 0;	2228	int error = 0;
2211		2229
2212	if (!(vma->vm_flags & VM_GROWSUP))	2230	if (!(vma->vm_flags & VM_GROWSUP))
2213	return -EFAULT;	2231	return -EFAULT;
2214		2232
2215	/* Guard against wrapping around to address 0. */	2233	/* Guard against exceeding limits of the address space. */
2216	if (address < PAGE_ALIGN(address+4))	2234	address &= PAGE_MASK;
2217	address = PAGE_ALIGN(address+4);	2235	if (address >= TASK_SIZE)
2218	else
2219	return -ENOMEM;	2236	return -ENOMEM;
		2237	address += PAGE_SIZE;
		2238
		2239	/* Enforce stack_guard_gap */
		2240	gap_addr = address + stack_guard_gap;
		2241
		2242	/* Guard against overflow */
		2243	if (gap_addr < address \|\| gap_addr > TASK_SIZE)
		2244	gap_addr = TASK_SIZE;
		2245
		2246	next = vma->vm_next;
		2247	if (next && next->vm_start < gap_addr) {
		2248	if (!(next->vm_flags & VM_GROWSUP))
		2249	return -ENOMEM;
		2250	/* Check that both stack segments have the same anon_vma? */
		2251	}
2220		2252
2221	/* We must make sure the anon_vma is allocated. */	2253	/* We must make sure the anon_vma is allocated. */
2222	if (unlikely(anon_vma_prepare(vma)))	2254	if (unlikely(anon_vma_prepare(vma)))
@@ -2261,7 +2293,7 @@ int expand_upwards(struct vm_area_struct *vma, unsigned long address) · 38 unmodified lines
2261	if (vma->vm_next)	2293	if (vma->vm_next)
2262	vma_gap_update(vma->vm_next);	2294	vma_gap_update(vma->vm_next);
2263	else	2295	else
2264	mm->highest_vm_end = address;	2296	mm->highest_vm_end = vm_end_gap(vma);
2265	spin_unlock(&mm->page_table_lock);	2297	spin_unlock(&mm->page_table_lock);
2266		2298
2267	perf_event_mmap(vma);	2299	perf_event_mmap(vma);
@@ -2282,6 +2314,8 @@ int expand_downwards(struct vm_area_struct *vma, · 14 unmodified lines
2282	unsigned long address)	2314	unsigned long address)
2283	{	2315	{
2284	struct mm_struct *mm = vma->vm_mm;	2316	struct mm_struct *mm = vma->vm_mm;
		2317	struct vm_area_struct *prev;
		2318	unsigned long gap_addr;
2285	int error;	2319	int error;
2286		2320
2287	address &= PAGE_MASK;	2321	address &= PAGE_MASK;
@@ -2289,6 +2323,17 @@ int expand_downwards(struct vm_area_struct *vma, · 1 unmodified line
2289	if (error)	2323	if (error)
2290	return error;	2324	return error;
2291		2325
		2326	/* Enforce stack_guard_gap */
		2327	gap_addr = address - stack_guard_gap;
		2328	if (gap_addr > address)
		2329	return -ENOMEM;
		2330	prev = vma->vm_prev;
		2331	if (prev && prev->vm_end > gap_addr) {
		2332	if (!(prev->vm_flags & VM_GROWSDOWN))
		2333	return -ENOMEM;
		2334	/* Check that both stack segments have the same anon_vma? */
		2335	}
		2336
2292	/* We must make sure the anon_vma is allocated. */	2337	/* We must make sure the anon_vma is allocated. */
2293	if (unlikely(anon_vma_prepare(vma)))	2338	if (unlikely(anon_vma_prepare(vma)))
2294	return -ENOMEM;	2339	return -ENOMEM;
@@ -2343,28 +2388,25 @@ int expand_downwards(struct vm_area_struct *vma, · 48 unmodified lines
2343	return error;	2388	return error;
2344	}	2389	}
2345		2390
2346	/*	2391	/* enforced gap between the expanding stack and other mappings. */
2347	* Note how expand_stack() refuses to expand the stack all the way to	2392	unsigned long stack_guard_gap = 256UL<<PAGE_SHIFT;
2348	* abut the next virtual mapping, unless that mapping itself is also	2393
2349	* a stack mapping. We want to leave room for a guard page, after all	2394	static int __init cmdline_parse_stack_guard_gap(char *p)
2350	* (the guard page itself is not added here, that is done by the	2395	{
2351	* actual page faulting logic)	2396	unsigned long val;
2352	*	2397	char *endptr;
2353	* This matches the behavior of the guard page logic (see mm/memory.c:	2398
2354	* check_stack_guard_page()), which only allows the guard page to be	2399	val = simple_strtoul(p, &endptr, 10);
2355	* removed under these circumstances.	2400	if (!*endptr)
2356	*/	2401	stack_guard_gap = val << PAGE_SHIFT;
		2402
		2403	return 0;
		2404	}
		2405	__setup("stack_guard_gap=", cmdline_parse_stack_guard_gap);
		2406
2357	#ifdef CONFIG_STACK_GROWSUP	2407	#ifdef CONFIG_STACK_GROWSUP
2358	int expand_stack(struct vm_area_struct *vma, unsigned long address)	2408	int expand_stack(struct vm_area_struct *vma, unsigned long address)
2359	{	2409	{
2360	struct vm_area_struct *next;
2361
2362	address &= PAGE_MASK;
2363	next = vma->vm_next;
2364	if (next && next->vm_start == address + PAGE_SIZE) {
2365	if (!(next->vm_flags & VM_GROWSUP))
2366	return -ENOMEM;
2367	}
2368	return expand_upwards(vma, address);	2410	return expand_upwards(vma, address);
2369	}	2411	}
2370		2412
@@ -2386,14 +2428,6 @@ find_extend_vma(struct mm_struct *mm, unsigned long addr) · 15 unmodified lines
2386	#else	2428	#else
2387	int expand_stack(struct vm_area_struct *vma, unsigned long address)	2429	int expand_stack(struct vm_area_struct *vma, unsigned long address)
2388	{	2430	{
2389	struct vm_area_struct *prev;
2390
2391	address &= PAGE_MASK;
2392	prev = vma->vm_prev;
2393	if (prev && prev->vm_end == address) {
2394	if (!(prev->vm_flags & VM_GROWSDOWN))
2395	return -ENOMEM;
2396	}
2397	return expand_downwards(vma, address);	2431	return expand_downwards(vma, address);
2398	}	2432	}
2399		2433
@@ -2491,7 +2525,7 @@ detach_vmas_to_be_unmapped(struct mm_struct mm, struct vm_area_struct vma, · 91 unmodified lines
2491	vma->vm_prev = prev;	2525	vma->vm_prev = prev;
2492	vma_gap_update(vma);	2526	vma_gap_update(vma);
2493	} else	2527	} else
2494	mm->highest_vm_end = prev ? prev->vm_end : 0;	2528	mm->highest_vm_end = prev ? vm_end_gap(prev) : 0;
2495	tail_vma->vm_next = NULL;	2529	tail_vma->vm_next = NULL;
2496		2530
2497	/* Kill the cache */	2531	/* Kill the cache */

mm/slub.c+26−14

 	return name;
 }
+static void sysfs_slab_remove_workfn(struct work_struct *work)
+{
+	struct kmem_cache *s =
+		container_of(work, struct kmem_cache, kobj_remove_work);
+	if (!s->kobj.state_in_sysfs)
+		/*
+		 * For a memcg cache, this may be called during
+		 * deactivation and again on shutdown.  Remove only once.
+		 * A cache is never shut down before deactivation is
+		 * complete, so no need to worry about synchronization.
+		 */
+		return;
+#ifdef CONFIG_MEMCG
+	kset_unregister(s->memcg_kset);
+#endif
+	kobject_uevent(&s->kobj, KOBJ_REMOVE);
+	kobject_del(&s->kobj);
+	kobject_put(&s->kobj);
+}
 static int sysfs_slab_add(struct kmem_cache *s)
 {
 	int err;
 	struct kset *kset = cache_kset(s);
 	int unmergeable = slab_unmergeable(s);
+	INIT_WORK(&s->kobj_remove_work, sysfs_slab_remove_workfn);
 	if (!kset) {
 		kobject_init(&s->kobj, &slab_ktype);
 		return 0;
 		 */
 		return;
-	if (!s->kobj.state_in_sysfs)
+	kobject_get(&s->kobj);
-		/*
+	schedule_work(&s->kobj_remove_work);
-		 * For a memcg cache, this may be called during
-		 * deactivation and again on shutdown.  Remove only once.
-		 * A cache is never shut down before deactivation is
-		 * complete, so no need to worry about synchronization.
-		 */
-		return;
-#ifdef CONFIG_MEMCG
-	kset_unregister(s->memcg_kset);
-#endif
-	kobject_uevent(&s->kobj, KOBJ_REMOVE);
-	kobject_del(&s->kobj);
 }
 void sysfs_slab_release(struct kmem_cache *s)

mm/swap_cgroup.c+3−0

 		if (!page)
 			goto not_enough_page;
 		ctrl->map[idx] = page;
+		if (!(idx % SWAP_CLUSTER_MAX))
+			cond_resched();
 	}
 	return 0;
 not_enough_page:

mm/vmalloc.c+13−2

@@ -287,10 +287,21 @@ struct page vmalloc_to_page(const void vmalloc_addr) · 286 unmodified lines
287	if (p4d_none(*p4d))	287	if (p4d_none(*p4d))
288	return NULL;	288	return NULL;
289	pud = pud_offset(p4d, addr);	289	pud = pud_offset(p4d, addr);
290	if (pud_none(*pud))	290
		291	/*
		292	* Don't dereference bad PUD or PMD (below) entries. This will also
		293	* identify huge mappings, which we may encounter on architectures
		294	* that define CONFIG_HAVE_ARCH_HUGE_VMAP=y. Such regions will be
		295	* identified as vmalloc addresses by is_vmalloc_addr(), but are
		296	* not [unambiguously] associated with a struct page, so there is
		297	* no correct value to return for them.
		298	*/
		299	WARN_ON_ONCE(pud_bad(*pud));
		300	if (pud_none(pud) \|\| pud_bad(pud))
291	return NULL;	301	return NULL;
292	pmd = pmd_offset(pud, addr);	302	pmd = pmd_offset(pud, addr);
293	if (pmd_none(*pmd))	303	WARN_ON_ONCE(pmd_bad(*pmd));
		304	if (pmd_none(pmd) \|\| pmd_bad(pmd))
294	return NULL;	305	return NULL;
295		306
296	ptep = pte_offset_map(pmd, addr);	307	ptep = pte_offset_map(pmd, addr);

mm/vmpressure.c+3−3

@@ -115,9 +115,9 @@ static enum vmpressure_levels vmpressure_calc_level(unsigned long scanned, · 114 unmodified lines
115	unsigned long pressure = 0;	115	unsigned long pressure = 0;
116		116
117	/*	117	/*
118	* reclaimed can be greater than scanned in cases	118	* reclaimed can be greater than scanned for things such as reclaimed
119	* like THP, where the scanned is 1 and reclaimed	119	* slab pages. shrink_node() just adds reclaimed pages without a
120	* could be 512	120	* related increment to scanned pages.
121	*/	121	*/
122	if (reclaimed >= scanned)	122	if (reclaimed >= scanned)
123	goto out;	123	goto out;

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

@@ -277,7 +277,8 @@ static int register_vlan_device(struct net_device *real_dev, u16 vlan_id) · 276 unmodified lines
277	return 0;	277	return 0;
278		278
279	out_free_newdev:	279	out_free_newdev:
280	free_netdev(new_dev);	280	if (new_dev->reg_state == NETREG_UNINITIALIZED)
		281	free_netdev(new_dev);
281	return err;	282	return err;
282	}	283	}
283		284

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

 	free_percpu(vlan->vlan_pcpu_stats);
 	vlan->vlan_pcpu_stats = NULL;
-	free_netdev(dev);
 }
 void vlan_setup(struct net_device *dev)
 	netif_keep_dst(dev);
 	dev->netdev_ops		= &vlan_netdev_ops;
-	dev->destructor		= vlan_dev_free;
+	dev->needs_free_netdev	= true;
+	dev->priv_destructor	= vlan_dev_free;
 	dev->ethtool_ops	= &vlan_ethtool_ops;
 	dev->min_mtu		= 0;

net/batman-adv/distributed-arp-table.c+3−2

@@ -1064,8 +1064,9 @@ bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv, · 1063 unmodified lines
1064		1064
1065	skb_new->protocol = eth_type_trans(skb_new, soft_iface);	1065	skb_new->protocol = eth_type_trans(skb_new, soft_iface);
1066		1066
1067	soft_iface->stats.rx_packets++;	1067	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
1068	soft_iface->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;	1068	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
		1069	skb->len + ETH_HLEN + hdr_size);
1069		1070
1070	netif_rx(skb_new);	1071	netif_rx(skb_new);
1071	batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");	1072	batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");

net/batman-adv/routing.c+1−1

@@ -987,7 +987,7 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, · 986 unmodified lines
987	batadv_dbg(BATADV_DBG_BLA, bat_priv,	987	batadv_dbg(BATADV_DBG_BLA, bat_priv,
988	"recv_unicast_packet(): Dropped unicast pkt received from another backbone gw %pM.\n",	988	"recv_unicast_packet(): Dropped unicast pkt received from another backbone gw %pM.\n",
989	orig_addr_gw);	989	orig_addr_gw);
990	return NET_RX_DROP;	990	goto free_skb;
991	}	991	}
992	}	992	}
993		993

net/batman-adv/soft-interface.c+2−3

 	 * netdev and its private data (bat_priv)
 	 */
 	rcu_barrier();
-	free_netdev(dev);
 }
 /**
 	ether_setup(dev);
 	dev->netdev_ops = &batadv_netdev_ops;
-	dev->destructor = batadv_softif_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = batadv_softif_free;
 	dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_NETNS_LOCAL;
 	dev->priv_flags |= IFF_NO_QUEUE;

net/bluetooth/6lowpan.c+1−1

@@ -598,7 +598,7 @@ static void netdev_setup(struct net_device *dev) · 597 unmodified lines
598		598
599	dev->netdev_ops = &netdev_ops;	599	dev->netdev_ops = &netdev_ops;
600	dev->header_ops = &header_ops;	600	dev->header_ops = &header_ops;
601	dev->destructor = free_netdev;	601	dev->needs_free_netdev = true;
602	}	602	}
603		603
604	static struct device_type bt_type = {	604	static struct device_type bt_type = {

net/bridge/br_device.c+1−1

@@ -379,7 +379,7 @@ void br_dev_setup(struct net_device *dev) · 378 unmodified lines
379	ether_setup(dev);	379	ether_setup(dev);
380		380
381	dev->netdev_ops = &br_netdev_ops;	381	dev->netdev_ops = &br_netdev_ops;
382	dev->destructor = free_netdev;	382	dev->needs_free_netdev = true;
383	dev->ethtool_ops = &br_ethtool_ops;	383	dev->ethtool_ops = &br_ethtool_ops;
384	SET_NETDEV_DEVTYPE(dev, &br_type);	384	SET_NETDEV_DEVTYPE(dev, &br_type);
385	dev->priv_flags = IFF_EBRIDGE \| IFF_NO_QUEUE;	385	dev->priv_flags = IFF_EBRIDGE \| IFF_NO_QUEUE;

net/caif/caif_socket.c+4−0

@@ -754,6 +754,10 @@ static int caif_connect(struct socket sock, struct sockaddr uaddr, · 753 unmodified lines
754		754
755	lock_sock(sk);	755	lock_sock(sk);
756		756
		757	err = -EINVAL;
		758	if (addr_len < offsetofend(struct sockaddr, sa_family))
		759	goto out;
		760
757	err = -EAFNOSUPPORT;	761	err = -EAFNOSUPPORT;
758	if (uaddr->sa_family != AF_CAIF)	762	if (uaddr->sa_family != AF_CAIF)
759	goto out;	763	goto out;

net/caif/cfpkt_skbuff.c+1−5

 {
 	struct sk_buff *skb;
-	if (likely(in_interrupt()))
+	skb = alloc_skb(len + pfx, GFP_ATOMIC);
-		skb = alloc_skb(len + pfx, GFP_ATOMIC);
-	else
-		skb = alloc_skb(len + pfx, GFP_KERNEL);
 	if (unlikely(skb == NULL))
 		return NULL;

net/caif/chnl_net.c+2−2

 {
 	struct chnl_net *priv = netdev_priv(dev);
 	caif_free_client(&priv->chnl);
-	free_netdev(dev);
 }
 static void ipcaif_net_setup(struct net_device *dev)
 {
 	struct chnl_net *priv;
 	dev->netdev_ops = &netdev_ops;
-	dev->destructor = chnl_net_destructor;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = chnl_net_destructor;
 	dev->flags |= IFF_NOARP;
 	dev->flags |= IFF_POINTOPOINT;
 	dev->mtu = GPRS_PDP_MTU;

net/can/af_can.c+1−2

@@ -872,8 +872,7 @@ static int can_notifier(struct notifier_block *nb, unsigned long msg, · 871 unmodified lines
872		872
873	static int can_pernet_init(struct net *net)	873	static int can_pernet_init(struct net *net)
874	{	874	{
875	net->can.can_rcvlists_lock =	875	spin_lock_init(&net->can.can_rcvlists_lock);
876	__SPIN_LOCK_UNLOCKED(net->can.can_rcvlists_lock);
877	net->can.can_rx_alldev_list =	876	net->can.can_rx_alldev_list =
878	kzalloc(sizeof(struct dev_rcv_lists), GFP_KERNEL);	877	kzalloc(sizeof(struct dev_rcv_lists), GFP_KERNEL);
879		878

net/core/dev.c+30−14

 	if (!new_ifalias)
 		return -ENOMEM;
 	dev->ifalias = new_ifalias;
+	memcpy(dev->ifalias, alias, len);
+	dev->ifalias[len] = 0;
-	strlcpy(dev->ifalias, alias, len+1);
 	return len;
 }
 }
 EXPORT_SYMBOL(__skb_gro_checksum_complete);
+static void net_rps_send_ipi(struct softnet_data *remsd)
+{
+#ifdef CONFIG_RPS
+	while (remsd) {
+		struct softnet_data *next = remsd->rps_ipi_next;
+		if (cpu_online(remsd->cpu))
+			smp_call_function_single_async(remsd->cpu, &remsd->csd);
+		remsd = next;
+	}
+#endif
+}
 /*
  * net_rps_action_and_irq_enable sends any pending IPI's for rps.
  * Note: called with local irq disabled, but exits with local irq enabled.
 		local_irq_enable();
 		/* Send pending IPI's to kick RPS processing on remote cpus. */
-		while (remsd) {
+		net_rps_send_ipi(remsd);
-			struct softnet_data *next = remsd->rps_ipi_next;
-			if (cpu_online(remsd->cpu))
-				smp_call_function_single_async(remsd->cpu,
-							   &remsd->csd);
-			remsd = next;
-		}
 	} else
 #endif
 		local_irq_enable();
 	if (rc == BUSY_POLL_BUDGET)
 		__napi_schedule(napi);
 	local_bh_enable();
-	if (local_softirq_pending())
-		do_softirq();
 }
 void napi_busy_loop(unsigned int napi_id,
 err_uninit:
 	if (dev->netdev_ops->ndo_uninit)
 		dev->netdev_ops->ndo_uninit(dev);
+	if (dev->priv_destructor)
+		dev->priv_destructor(dev);
 	goto out;
 }
 EXPORT_SYMBOL(register_netdevice);
 		WARN_ON(rcu_access_pointer(dev->ip6_ptr));
 		WARN_ON(dev->dn_ptr);
-		if (dev->destructor)
+		if (dev->priv_destructor)
-			dev->destructor(dev);
+			dev->priv_destructor(dev);
+		if (dev->needs_free_netdev)
+			free_netdev(dev);
 		/* Report a network device has been unregistered */
 		rtnl_lock();
 	struct sk_buff **list_skb;
 	struct sk_buff *skb;
 	unsigned int cpu;
-	struct softnet_data *sd, *oldsd;
+	struct softnet_data *sd, *oldsd, *remsd = NULL;
 	local_irq_disable();
 	cpu = smp_processor_id();
 	raise_softirq_irqoff(NET_TX_SOFTIRQ);
 	local_irq_enable();
+#ifdef CONFIG_RPS
+	remsd = oldsd->rps_ipi_list;
+	oldsd->rps_ipi_list = NULL;
+#endif
+	/* send out pending IPI's on offline CPU */
+	net_rps_send_ipi(remsd);
 	/* Process offline CPU's input_pkt_queue */
 	while ((skb = __skb_dequeue(&oldsd->process_queue))) {
 		netif_rx_ni(skb);

net/core/dev_ioctl.c+16−3

@@ -410,6 +410,22 @@ int dev_ioctl(struct net net, unsigned int cmd, void __user arg) · 409 unmodified lines
410	if (cmd == SIOCGIFNAME)	410	if (cmd == SIOCGIFNAME)
411	return dev_ifname(net, (struct ifreq __user *)arg);	411	return dev_ifname(net, (struct ifreq __user *)arg);
412		412
		413	/*
		414	* Take care of Wireless Extensions. Unfortunately struct iwreq
		415	* isn't a proper subset of struct ifreq (it's 8 byte shorter)
		416	* so we need to treat it specially, otherwise applications may
		417	* fault if the struct they're passing happens to land at the
		418	* end of a mapped page.
		419	*/
		420	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
		421	struct iwreq iwr;
		422
		423	if (copy_from_user(&iwr, arg, sizeof(iwr)))
		424	return -EFAULT;
		425
		426	return wext_handle_ioctl(net, &iwr, cmd, arg);
		427	}
		428
413	if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))	429	if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
414	return -EFAULT;	430	return -EFAULT;
415		431
@@ -559,9 +575,6 @@ int dev_ioctl(struct net net, unsigned int cmd, void __user arg) · 143 unmodified lines
559	ret = -EFAULT;	575	ret = -EFAULT;
560	return ret;	576	return ret;
561	}	577	}
562	/* Take care of Wireless Extensions */
563	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
564	return wext_handle_ioctl(net, &ifr, cmd, arg);
565	return -ENOTTY;	578	return -ENOTTY;
566	}	579	}
567	}	580	}

net/core/dst.c+14−0

@@ -469,6 +469,20 @@ static int dst_dev_event(struct notifier_block *this, unsigned long event, · 468 unmodified lines
469	spin_lock_bh(&dst_garbage.lock);	469	spin_lock_bh(&dst_garbage.lock);
470	dst = dst_garbage.list;	470	dst = dst_garbage.list;
471	dst_garbage.list = NULL;	471	dst_garbage.list = NULL;
		472	/* The code in dst_ifdown places a hold on the loopback device.
		473	* If the gc entry processing is set to expire after a lengthy
		474	* interval, this hold can cause netdev_wait_allrefs() to hang
		475	* out and wait for a long time -- until the the loopback
		476	* interface is released. If we're really unlucky, it'll emit
		477	* pr_emerg messages to console too. Reset the interval here,
		478	* so dst cleanups occur in a more timely fashion.
		479	*/
		480	if (dst_garbage.timer_inc > DST_GC_INC) {
		481	dst_garbage.timer_inc = DST_GC_INC;
		482	dst_garbage.timer_expires = DST_GC_MIN;
		483	mod_delayed_work(system_wq, &dst_gc_work,
		484	dst_garbage.timer_expires);
		485	}
472	spin_unlock_bh(&dst_garbage.lock);	486	spin_unlock_bh(&dst_garbage.lock);
473		487
474	if (last)	488	if (last)

net/core/fib_rules.c+14−7

@@ -568,7 +568,7 @@ int fib_nl_delrule(struct sk_buff skb, struct nlmsghdr nlh, · 567 unmodified lines
568	struct net *net = sock_net(skb->sk);	568	struct net *net = sock_net(skb->sk);
569	struct fib_rule_hdr *frh = nlmsg_data(nlh);	569	struct fib_rule_hdr *frh = nlmsg_data(nlh);
570	struct fib_rules_ops *ops = NULL;	570	struct fib_rules_ops *ops = NULL;
571	struct fib_rule rule, tmp;	571	struct fib_rule rule, r;
572	struct nlattr *tb[FRA_MAX+1];	572	struct nlattr *tb[FRA_MAX+1];
573	struct fib_kuid_range range;	573	struct fib_kuid_range range;
574	int err = -EINVAL;	574	int err = -EINVAL;
@@ -668,16 +668,23 @@ int fib_nl_delrule(struct sk_buff skb, struct nlmsghdr nlh, · 93 unmodified lines
668		668
669	/*	669	/*
670	* Check if this rule is a target to any of them. If so,	670	* Check if this rule is a target to any of them. If so,
		671	* adjust to the next one with the same preference or
671	* disable them. As this operation is eventually very	672	* disable them. As this operation is eventually very
672	* expensive, it is only performed if goto rules have	673	* expensive, it is only performed if goto rules, except
673	* actually been added.	674	* current if it is goto rule, have actually been added.
674	*/	675	*/
675	if (ops->nr_goto_rules > 0) {	676	if (ops->nr_goto_rules > 0) {
676	list_for_each_entry(tmp, &ops->rules_list, list) {	677	struct fib_rule *n;
677	if (rtnl_dereference(tmp->ctarget) == rule) {	678
678	RCU_INIT_POINTER(tmp->ctarget, NULL);	679	n = list_next_entry(rule, list);
		680	if (&n->list == &ops->rules_list \|\| n->pref != rule->pref)
		681	n = NULL;
		682	list_for_each_entry(r, &ops->rules_list, list) {
		683	if (rtnl_dereference(r->ctarget) != rule)
		684	continue;
		685	rcu_assign_pointer(r->ctarget, n);
		686	if (!n)
679	ops->unresolved_rules++;	687	ops->unresolved_rules++;
680	}
681	}	688	}
682	}	689	}
683		690

net/core/rtnetlink.c+4−1

 	       + nla_total_size(1) /* IFLA_LINKMODE */
 	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
 	       + nla_total_size(4) /* IFLA_LINK_NETNSID */
+	       + nla_total_size(4) /* IFLA_GROUP */
 	       + nla_total_size(ext_filter_mask
 			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
 	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
 	struct ifla_vf_mac vf_mac;
 	struct ifla_vf_info ivi;
+	memset(&ivi, 0, sizeof(ivi));
 	/* Not all SR-IOV capable drivers support the
 	 * spoofcheck and "RSS query enable" query.  Preset to
 	 * -1 so the user space tool can detect that the driver
 	ivi.spoofchk = -1;
 	ivi.rss_query_en = -1;
 	ivi.trusted = -1;
-	memset(ivi.mac, 0, sizeof(ivi.mac));
 	/* The default value for VF link state is "auto"
 	 * IFLA_VF_LINK_STATE_AUTO which equals zero
 	 */
 	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },
 	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },
 	[IFLA_XDP]		= { .type = NLA_NESTED },
+	[IFLA_GROUP]		= { .type = NLA_U32 },
 };
 static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {

net/decnet/dn_route.c+4−10

 	call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
 }
-static inline void dnrt_drop(struct dn_route *rt)
-{
-	dst_release(&rt->dst);
-	call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
-}
 static void dn_dst_check_expire(unsigned long dummy)
 {
 	int i;
 			}
 			*rtp = rt->dst.dn_next;
 			rt->dst.dn_next = NULL;
-			dnrt_drop(rt);
+			dnrt_free(rt);
 			break;
 		}
 		spin_unlock_bh(&dn_rt_hash_table[i].lock);
 			dst_use(&rth->dst, now);
 			spin_unlock_bh(&dn_rt_hash_table[hash].lock);
-			dnrt_drop(rt);
+			dst_free(&rt->dst);
 			*rp = rth;
 			return 0;
 		}
 		for(; rt; rt = next) {
 			next = rcu_dereference_raw(rt->dst.dn_next);
 			RCU_INIT_POINTER(rt->dst.dn_next, NULL);
-			dst_free((struct dst_entry *)rt);
+			dnrt_free(rt);
 		}
 nothing_to_declare:
 	if (dev_out->flags & IFF_LOOPBACK)
 		flags |= RTCF_LOCAL;
-	rt = dst_alloc(&dn_dst_ops, dev_out, 1, DST_OBSOLETE_NONE, DST_HOST);
+	rt = dst_alloc(&dn_dst_ops, dev_out, 0, DST_OBSOLETE_NONE, DST_HOST);
 	if (rt == NULL)
 		goto e_nobufs;

net/decnet/netfilter/dn_rtmsg.c+3−1

@@ -102,7 +102,9 @@ static inline void dnrmg_receive_user_skb(struct sk_buff *skb) · 101 unmodified lines
102	{	102	{
103	struct nlmsghdr *nlh = nlmsg_hdr(skb);	103	struct nlmsghdr *nlh = nlmsg_hdr(skb);
104		104
105	if (nlh->nlmsg_len < sizeof(*nlh) \|\| skb->len < nlh->nlmsg_len)	105	if (skb->len < sizeof(*nlh) \|\|
		106	nlh->nlmsg_len < sizeof(*nlh) \|\|
		107	skb->len < nlh->nlmsg_len)
106	return;	108	return;
107		109
108	if (!netlink_capable(skb, CAP_NET_ADMIN))	110	if (!netlink_capable(skb, CAP_NET_ADMIN))

net/hsr/hsr_device.c+2−2

 	del_timer_sync(&hsr->announce_timer);
 	synchronize_rcu();
-	free_netdev(hsr_dev);
 }
 static const struct net_device_ops hsr_device_ops = {
 	SET_NETDEV_DEVTYPE(dev, &hsr_type);
 	dev->priv_flags |= IFF_NO_QUEUE;
-	dev->destructor = hsr_dev_destroy;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = hsr_dev_destroy;
 	dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
 			   NETIF_F_GSO_MASK | NETIF_F_HW_CSUM |

net/hsr/hsr_forward.c+1−2

@@ -324,8 +324,7 @@ static int hsr_fill_frame_info(struct hsr_frame_info *frame, · 323 unmodified lines
324	unsigned long irqflags;	324	unsigned long irqflags;
325		325
326	frame->is_supervision = is_supervision_frame(port->hsr, skb);	326	frame->is_supervision = is_supervision_frame(port->hsr, skb);
327	frame->node_src = hsr_get_node(&port->hsr->node_db, skb,	327	frame->node_src = hsr_get_node(port, skb, frame->is_supervision);
328	frame->is_supervision);
329	if (frame->node_src == NULL)	328	if (frame->node_src == NULL)
330	return -1; /* Unknown node and !is_supervision, or no mem */	329	return -1; /* Unknown node and !is_supervision, or no mem */
331		330

net/hsr/hsr_framereg.c+7−2

 /* Get the hsr_node from which 'skb' was sent.
  */
-struct hsr_node *hsr_get_node(struct list_head *node_db, struct sk_buff *skb,
+struct hsr_node *hsr_get_node(struct hsr_port *port, struct sk_buff *skb,
 			      bool is_sup)
 {
+	struct list_head *node_db = &port->hsr->node_db;
 	struct hsr_node *node;
 	struct ethhdr *ethhdr;
 	u16 seq_out;
 		 */
 		seq_out = hsr_get_skb_sequence_nr(skb) - 1;
 	} else {
-		WARN_ONCE(1, "%s: Non-HSR frame\n", __func__);
+		/* this is called also for frames from master port and
+		 * so warn only for non master ports
+		 */
+		if (port->type != HSR_PT_MASTER)
+			WARN_ONCE(1, "%s: Non-HSR frame\n", __func__);
 		seq_out = HSR_SEQNR_START;
 	}

net/hsr/hsr_framereg.h+1−1

@@ -18,7 +18,7 @@ struct hsr_node; · 17 unmodified lines
18		18
19	struct hsr_node hsr_add_node(struct list_head node_db, unsigned char addr[],	19	struct hsr_node hsr_add_node(struct list_head node_db, unsigned char addr[],
20	u16 seq_out);	20	u16 seq_out);
21	struct hsr_node hsr_get_node(struct list_head node_db, struct sk_buff *skb,	21	struct hsr_node hsr_get_node(struct hsr_port port, struct sk_buff *skb,
22	bool is_sup);	22	bool is_sup);
23	void hsr_handle_sup_frame(struct sk_buff skb, struct hsr_node node_curr,	23	void hsr_handle_sup_frame(struct sk_buff skb, struct hsr_node node_curr,
24	struct hsr_port *port);	24	struct hsr_port *port);

net/ieee802154/6lowpan/core.c+1−1

@@ -107,7 +107,7 @@ static void lowpan_setup(struct net_device *ldev) · 106 unmodified lines
107		107
108	ldev->netdev_ops = &lowpan_netdev_ops;	108	ldev->netdev_ops = &lowpan_netdev_ops;
109	ldev->header_ops = &lowpan_header_ops;	109	ldev->header_ops = &lowpan_header_ops;
110	ldev->destructor = free_netdev;	110	ldev->needs_free_netdev = true;
111	ldev->features \|= NETIF_F_NETNS_LOCAL;	111	ldev->features \|= NETIF_F_NETNS_LOCAL;
112	}	112	}
113		113

net/ipv4/icmp.c+6−2

 	/* Needed by both icmp_global_allow and icmp_xmit_lock */
 	local_bh_disable();
-	/* Check global sysctl_icmp_msgs_per_sec ratelimit */
+	/* Check global sysctl_icmp_msgs_per_sec ratelimit, unless
-	if (!icmpv4_global_allow(net, type, code))
+	 * incoming dev is loopback.  If outgoing dev change to not be
+	 * loopback, then peer ratelimit still work (in icmpv4_xrlim_allow)
+	 */
+	if (!(skb_in->dev && (skb_in->dev->flags&IFF_LOOPBACK)) &&
+	      !icmpv4_global_allow(net, type, code))
 		goto out_bh_enable;
 	sk = icmp_xmit_lock(net);

net/ipv4/igmp.c+14−8

 	pmc = kzalloc(sizeof(*pmc), GFP_KERNEL);
 	if (!pmc)
 		return;
+	spin_lock_init(&pmc->lock);
 	spin_lock_bh(&im->lock);
 	pmc->interface = im->interface;
 	in_dev_hold(in_dev);
 static void ip_mc_clear_src(struct ip_mc_list *pmc)
 {
-	struct ip_sf_list *psf, *nextpsf;
+	struct ip_sf_list *psf, *nextpsf, *tomb, *sources;
-	for (psf = pmc->tomb; psf; psf = nextpsf) {
+	spin_lock_bh(&pmc->lock);
+	tomb = pmc->tomb;
+	pmc->tomb = NULL;
+	sources = pmc->sources;
+	pmc->sources = NULL;
+	pmc->sfmode = MCAST_EXCLUDE;
+	pmc->sfcount[MCAST_INCLUDE] = 0;
+	pmc->sfcount[MCAST_EXCLUDE] = 1;
+	spin_unlock_bh(&pmc->lock);
+	for (psf = tomb; psf; psf = nextpsf) {
 		nextpsf = psf->sf_next;
 		kfree(psf);
 	}
-	pmc->tomb = NULL;
+	for (psf = sources; psf; psf = nextpsf) {
-	for (psf = pmc->sources; psf; psf = nextpsf) {
 		nextpsf = psf->sf_next;
 		kfree(psf);
 	}
-	pmc->sources = NULL;
-	pmc->sfmode = MCAST_EXCLUDE;
-	pmc->sfcount[MCAST_INCLUDE] = 0;
-	pmc->sfcount[MCAST_EXCLUDE] = 1;
 }
 /* Join a multicast group

net/ipv4/ip_tunnel.c+4−2

 	return 0;
 drop:
+	if (tun_dst)
+		dst_release((struct dst_entry *)tun_dst);
 	kfree_skb(skb);
 	return 0;
 }
 	gro_cells_destroy(&tunnel->gro_cells);
 	dst_cache_destroy(&tunnel->dst_cache);
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
 	struct iphdr *iph = &tunnel->parms.iph;
 	int err;
-	dev->destructor	= ip_tunnel_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ip_tunnel_dev_free;
 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 	if (!dev->tstats)
 		return -ENOMEM;

net/ipv4/ipmr.c+16−18

 static void ipmr_free_table(struct mr_table *mrt);
 static void ip_mr_forward(struct net *net, struct mr_table *mrt,
-			  struct sk_buff *skb, struct mfc_cache *cache,
+			  struct net_device *dev, struct sk_buff *skb,
-			  int local);
+			  struct mfc_cache *cache, int local);
 static int ipmr_cache_report(struct mr_table *mrt,
 			     struct sk_buff *pkt, vifi_t vifi, int assert);
 static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 8;
 	dev->flags		= IFF_NOARP;
 	dev->netdev_ops		= &reg_vif_netdev_ops;
-	dev->destructor		= free_netdev;
+	dev->needs_free_netdev	= true;
 	dev->features		|= NETIF_F_NETNS_LOCAL;
 }
 			rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
 		} else {
-			ip_mr_forward(net, mrt, skb, c, 0);
+			ip_mr_forward(net, mrt, skb->dev, skb, c, 0);
 		}
 	}
 }
 /* Queue a packet for resolution. It gets locked cache entry! */
 static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi,
-				 struct sk_buff *skb)
+				 struct sk_buff *skb, struct net_device *dev)
 {
 	const struct iphdr *iph = ip_hdr(skb);
 	struct mfc_cache *c;
 		kfree_skb(skb);
 		err = -ENOBUFS;
 	} else {
+		if (dev) {
+			skb->dev = dev;
+			skb->skb_iif = dev->ifindex;
+		}
 		skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
 		err = 0;
 	}
 /* "local" means that we should preserve one skb (for local delivery) */
 static void ip_mr_forward(struct net *net, struct mr_table *mrt,
-			  struct sk_buff *skb, struct mfc_cache *cache,
+			  struct net_device *dev, struct sk_buff *skb,
-			  int local)
+			  struct mfc_cache *cache, int local)
 {
-	int true_vifi = ipmr_find_vif(mrt, skb->dev);
+	int true_vifi = ipmr_find_vif(mrt, dev);
 	int psend = -1;
 	int vif, ct;
 	}
 	/* Wrong interface: drop packet and (maybe) send PIM assert. */
-	if (mrt->vif_table[vif].dev != skb->dev) {
+	if (mrt->vif_table[vif].dev != dev) {
-		struct net_device *mdev;
-		mdev = l3mdev_master_dev_rcu(mrt->vif_table[vif].dev);
-		if (mdev == skb->dev)
-			goto forward;
 		if (rt_is_output_route(skb_rtable(skb))) {
 			/* It is our own packet, looped back.
 			 * Very complicated situation...
 		read_lock(&mrt_lock);
 		vif = ipmr_find_vif(mrt, dev);
 		if (vif >= 0) {
-			int err2 = ipmr_cache_unresolved(mrt, vif, skb);
+			int err2 = ipmr_cache_unresolved(mrt, vif, skb, dev);
 			read_unlock(&mrt_lock);
 			return err2;
 	}
 	read_lock(&mrt_lock);
-	ip_mr_forward(net, mrt, skb, cache, local);
+	ip_mr_forward(net, mrt, dev, skb, cache, local);
 	read_unlock(&mrt_lock);
 	if (local)
 		iph->saddr = saddr;
 		iph->daddr = daddr;
 		iph->version = 0;
-		err = ipmr_cache_unresolved(mrt, vif, skb2);
+		err = ipmr_cache_unresolved(mrt, vif, skb2, dev);
 		read_unlock(&mrt_lock);
 		rcu_read_unlock();
 		return err;

net/ipv6/addrconf.c+3−3

@@ -332,9 +332,9 @@ static void addrconf_mod_rs_timer(struct inet6_dev *idev, · 331 unmodified lines
332	static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,	332	static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
333	unsigned long delay)	333	unsigned long delay)
334	{	334	{
335	if (!delayed_work_pending(&ifp->dad_work))	335	in6_ifa_hold(ifp);
336	in6_ifa_hold(ifp);	336	if (mod_delayed_work(addrconf_wq, &ifp->dad_work, delay))
337	mod_delayed_work(addrconf_wq, &ifp->dad_work, delay);	337	in6_ifa_put(ifp);
338	}	338	}
339		339
340	static int snmp6_alloc_dev(struct inet6_dev *idev)	340	static int snmp6_alloc_dev(struct inet6_dev *idev)

net/ipv6/fib6_rules.c+6−16

 struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi6 *fl6,
 				   int flags, pol_lookup_t lookup)
 {
-	struct rt6_info *rt;
 	struct fib_lookup_arg arg = {
 		.lookup_ptr = lookup,
 		.flags = FIB_LOOKUP_NOREF,
 	fib_rules_lookup(net->ipv6.fib6_rules_ops,
 			 flowi6_to_flowi(fl6), flags, &arg);
-	rt = arg.result;
+	if (arg.result)
+		return arg.result;
-	if (!rt) {
+	dst_hold(&net->ipv6.ip6_null_entry->dst);
-		dst_hold(&net->ipv6.ip6_null_entry->dst);
+	return &net->ipv6.ip6_null_entry->dst;
-		return &net->ipv6.ip6_null_entry->dst;
-	}
-	if (rt->rt6i_flags & RTF_REJECT &&
-	    rt->dst.error == -EAGAIN) {
-		ip6_rt_put(rt);
-		rt = net->ipv6.ip6_null_entry;
-		dst_hold(&rt->dst);
-	}
-	return &rt->dst;
 }
 static int fib6_rule_action(struct fib_rule *rule, struct flowi *flp,
 			flp6->saddr = saddr;
 		}
 		err = rt->dst.error;
-		goto out;
+		if (err != -EAGAIN)
+			goto out;
 	}
 again:
 	ip6_rt_put(rt);

net/ipv6/icmp.c+1−1

@@ -491,7 +491,7 @@ static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, · 490 unmodified lines
491	local_bh_disable();	491	local_bh_disable();
492		492
493	/* Check global sysctl_icmp_msgs_per_sec ratelimit */	493	/* Check global sysctl_icmp_msgs_per_sec ratelimit */
494	if (!icmpv6_global_allow(type))	494	if (!(skb->dev->flags&IFF_LOOPBACK) && !icmpv6_global_allow(type))
495	goto out_bh_enable;	495	goto out_bh_enable;
496		496
497	mip6_addr_swap(skb);	497	mip6_addr_swap(skb);

net/ipv6/ila/ila_xlat.c+1−0

@@ -62,6 +62,7 @@ static inline u32 ila_locator_hash(struct ila_locator loc) · 61 unmodified lines
62	{	62	{
63	u32 v = (u32 )loc.v32;	63	u32 v = (u32 )loc.v32;
64		64
		65	__ila_hash_secret_init();
65	return jhash_2words(v[0], v[1], hashrnd);	66	return jhash_2words(v[0], v[1], hashrnd);
66	}	67	}
67		68

net/ipv6/ip6_fib.c+1−2

@@ -289,8 +289,7 @@ struct dst_entry fib6_rule_lookup(struct net net, struct flowi6 *fl6, · 288 unmodified lines
289	struct rt6_info *rt;	289	struct rt6_info *rt;
290		290
291	rt = lookup(net, net->ipv6.fib6_main_tbl, fl6, flags);	291	rt = lookup(net, net->ipv6.fib6_main_tbl, fl6, flags);
292	if (rt->rt6i_flags & RTF_REJECT &&	292	if (rt->dst.error == -EAGAIN) {
293	rt->dst.error == -EAGAIN) {
294	ip6_rt_put(rt);	293	ip6_rt_put(rt);
295	rt = net->ipv6.ip6_null_entry;	294	rt = net->ipv6.ip6_null_entry;
296	dst_hold(&rt->dst);	295	dst_hold(&rt->dst);

net/ipv6/ip6_gre.c+5−4

 	dst_cache_destroy(&t->dst_cache);
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 static void ip6gre_tunnel_setup(struct net_device *dev)
 {
 	dev->netdev_ops = &ip6gre_netdev_ops;
-	dev->destructor = ip6gre_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ip6gre_dev_free;
 	dev->type = ARPHRD_IP6GRE;
 	return 0;
 err_reg_dev:
-	ip6gre_dev_free(ign->fb_tunnel_dev);
+	free_netdev(ign->fb_tunnel_dev);
 err_alloc_dev:
 	return err;
 }
 	ether_setup(dev);
 	dev->netdev_ops = &ip6gre_tap_netdev_ops;
-	dev->destructor = ip6gre_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ip6gre_dev_free;
 	dev->features |= NETIF_F_NETNS_LOCAL;
 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;

net/ipv6/ip6_tunnel.c+8−6

 	gro_cells_destroy(&t->gro_cells);
 	dst_cache_destroy(&t->dst_cache);
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 static int ip6_tnl_create2(struct net_device *dev)
 	return t;
 failed_free:
-	ip6_dev_free(dev);
+	free_netdev(dev);
 failed:
 	return ERR_PTR(err);
 }
 	return 0;
 drop:
+	if (tun_dst)
+		dst_release((struct dst_entry *)tun_dst);
 	kfree_skb(skb);
 	return 0;
 }
 		fl6.flowi6_proto = IPPROTO_IPIP;
 		fl6.daddr = key->u.ipv6.dst;
 		fl6.flowlabel = key->label;
-		dsfield = ip6_tclass(key->label);
+		dsfield =  key->tos;
 	} else {
 		if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
 			encap_limit = t->parms.encap_limit;
 		fl6.flowi6_proto = IPPROTO_IPV6;
 		fl6.daddr = key->u.ipv6.dst;
 		fl6.flowlabel = key->label;
-		dsfield = ip6_tclass(key->label);
+		dsfield = key->tos;
 	} else {
 		offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
 		/* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
 static void ip6_tnl_dev_setup(struct net_device *dev)
 {
 	dev->netdev_ops = &ip6_tnl_netdev_ops;
-	dev->destructor = ip6_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ip6_dev_free;
 	dev->type = ARPHRD_TUNNEL6;
 	dev->flags |= IFF_NOARP;
 	return 0;
 err_register:
-	ip6_dev_free(ip6n->fb_tnl_dev);
+	free_netdev(ip6n->fb_tnl_dev);
 err_alloc_dev:
 	return err;
 }

net/ipv6/ip6_vti.c+4−4

 static void vti6_dev_free(struct net_device *dev)
 {
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 static int vti6_tnl_create2(struct net_device *dev)
 	return t;
 failed_free:
-	vti6_dev_free(dev);
+	free_netdev(dev);
 failed:
 	return NULL;
 }
 static void vti6_dev_setup(struct net_device *dev)
 {
 	dev->netdev_ops = &vti6_netdev_ops;
-	dev->destructor = vti6_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = vti6_dev_free;
 	dev->type = ARPHRD_TUNNEL6;
 	dev->hard_header_len = LL_MAX_HEADER + sizeof(struct ipv6hdr);
 	return 0;
 err_register:
-	vti6_dev_free(ip6n->fb_tnl_dev);
+	free_netdev(ip6n->fb_tnl_dev);
 err_alloc_dev:
 	return err;
 }

net/ipv6/ip6mr.c+1−1

@@ -733,7 +733,7 @@ static void reg_vif_setup(struct net_device *dev) · 732 unmodified lines
733	dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;	733	dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
734	dev->flags = IFF_NOARP;	734	dev->flags = IFF_NOARP;
735	dev->netdev_ops = &reg_vif_netdev_ops;	735	dev->netdev_ops = &reg_vif_netdev_ops;
736	dev->destructor = free_netdev;	736	dev->needs_free_netdev = true;
737	dev->features \|= NETIF_F_NETNS_LOCAL;	737	dev->features \|= NETIF_F_NETNS_LOCAL;
738	}	738	}
739		739

net/ipv6/proc.c+1−1

@@ -219,7 +219,7 @@ static void snmp6_seq_show_item64(struct seq_file seq, void __percpu mib, · 218 unmodified lines
219	u64 buff64[SNMP_MIB_MAX];	219	u64 buff64[SNMP_MIB_MAX];
220	int i;	220	int i;
221		221
222	memset(buff64, 0, sizeof(unsigned long) * SNMP_MIB_MAX);	222	memset(buff64, 0, sizeof(u64) * SNMP_MIB_MAX);
223		223
224	snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff);	224	snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff);
225	for (i = 0; itemlist[i].name; i++)	225	for (i = 0; itemlist[i].name; i++)

net/ipv6/route.c+1−0

@@ -2804,6 +2804,7 @@ static int fib6_ifdown(struct rt6_info rt, void arg) · 2803 unmodified lines
2804	if ((rt->dst.dev == dev \|\| !dev) &&	2804	if ((rt->dst.dev == dev \|\| !dev) &&
2805	rt != adn->net->ipv6.ip6_null_entry &&	2805	rt != adn->net->ipv6.ip6_null_entry &&
2806	(rt->rt6i_nsiblings == 0 \|\|	2806	(rt->rt6i_nsiblings == 0 \|\|
		2807	(dev && netdev_unregistering(dev)) \|\|
2807	!rt->rt6i_idev->cnf.ignore_routes_with_linkdown))	2808	!rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
2808	return -1;	2809	return -1;
2809		2810

net/ipv6/sit.c+3−3

 	return nt;
 failed_free:
-	ipip6_dev_free(dev);
+	free_netdev(dev);
 failed:
 	return NULL;
 }
 	dst_cache_destroy(&tunnel->dst_cache);
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 #define SIT_FEATURES (NETIF_F_SG	   | \
 	int t_hlen = tunnel->hlen + sizeof(struct iphdr);
 	dev->netdev_ops		= &ipip6_netdev_ops;
-	dev->destructor		= ipip6_dev_free;
+	dev->needs_free_netdev	= true;
+	dev->priv_destructor	= ipip6_dev_free;
 	dev->type		= ARPHRD_SIT;
 	dev->hard_header_len	= LL_MAX_HEADER + t_hlen;

net/irda/irlan/irlan_eth.c+1−1

@@ -65,7 +65,7 @@ static void irlan_eth_setup(struct net_device *dev) · 64 unmodified lines
65	ether_setup(dev);	65	ether_setup(dev);
66		66
67	dev->netdev_ops = &irlan_eth_netdev_ops;	67	dev->netdev_ops = &irlan_eth_netdev_ops;
68	dev->destructor = free_netdev;	68	dev->needs_free_netdev = true;
69	dev->min_mtu = 0;	69	dev->min_mtu = 0;
70	dev->max_mtu = ETH_MAX_MTU;	70	dev->max_mtu = ETH_MAX_MTU;
71		71

net/l2tp/l2tp_eth.c+8−7

@@ -114,12 +114,13 @@ static void l2tp_eth_get_stats64(struct net_device *dev, · 113 unmodified lines
114	{	114	{
115	struct l2tp_eth *priv = netdev_priv(dev);	115	struct l2tp_eth *priv = netdev_priv(dev);
116		116
117	stats->tx_bytes = atomic_long_read(&priv->tx_bytes);	117	stats->tx_bytes = (unsigned long) atomic_long_read(&priv->tx_bytes);
118	stats->tx_packets = atomic_long_read(&priv->tx_packets);	118	stats->tx_packets = (unsigned long) atomic_long_read(&priv->tx_packets);
119	stats->tx_dropped = atomic_long_read(&priv->tx_dropped);	119	stats->tx_dropped = (unsigned long) atomic_long_read(&priv->tx_dropped);
120	stats->rx_bytes = atomic_long_read(&priv->rx_bytes);	120	stats->rx_bytes = (unsigned long) atomic_long_read(&priv->rx_bytes);
121	stats->rx_packets = atomic_long_read(&priv->rx_packets);	121	stats->rx_packets = (unsigned long) atomic_long_read(&priv->rx_packets);
122	stats->rx_errors = atomic_long_read(&priv->rx_errors);	122	stats->rx_errors = (unsigned long) atomic_long_read(&priv->rx_errors);
		123
123	}	124	}
124		125
125	static const struct net_device_ops l2tp_eth_netdev_ops = {	126	static const struct net_device_ops l2tp_eth_netdev_ops = {
@@ -141,7 +142,7 @@ static void l2tp_eth_dev_setup(struct net_device *dev) · 15 unmodified lines
141	dev->priv_flags &= ~IFF_TX_SKB_SHARING;	142	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
142	dev->features \|= NETIF_F_LLTX;	143	dev->features \|= NETIF_F_LLTX;
143	dev->netdev_ops = &l2tp_eth_netdev_ops;	144	dev->netdev_ops = &l2tp_eth_netdev_ops;
144	dev->destructor = free_netdev;	145	dev->needs_free_netdev = true;
145	}	146	}
146		147
147	static void l2tp_eth_dev_recv(struct l2tp_session session, struct sk_buff skb, int data_len)	148	static void l2tp_eth_dev_recv(struct l2tp_session session, struct sk_buff skb, int data_len)

net/mac80211/cfg.c+2−0

@@ -902,6 +902,8 @@ static int ieee80211_start_ap(struct wiphy wiphy, struct net_device dev, · 901 unmodified lines
902	default:	902	default:
903	return -EINVAL;	903	return -EINVAL;
904	}	904	}
		905	sdata->u.ap.req_smps = sdata->smps_mode;
		906
905	sdata->needed_rx_chains = sdata->local->rx_chains;	907	sdata->needed_rx_chains = sdata->local->rx_chains;
906		908
907	sdata->vif.bss_conf.beacon_int = params->beacon_interval;	909	sdata->vif.bss_conf.beacon_int = params->beacon_interval;

net/mac80211/ieee80211_i.h+1−1

@@ -1531,7 +1531,7 @@ ieee80211_have_rx_timestamp(struct ieee80211_rx_status *status) · 1530 unmodified lines
1531	return true;	1531	return true;
1532	/* can't handle non-legacy preamble yet */	1532	/* can't handle non-legacy preamble yet */
1533	if (status->flag & RX_FLAG_MACTIME_PLCP_START &&	1533	if (status->flag & RX_FLAG_MACTIME_PLCP_START &&
1534	status->encoding != RX_ENC_LEGACY)	1534	status->encoding == RX_ENC_LEGACY)
1535	return true;	1535	return true;
1536	return false;	1536	return false;
1537	}	1537	}

net/mac80211/iface.c+4−3

 static void ieee80211_if_free(struct net_device *dev)
 {
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 static void ieee80211_if_setup(struct net_device *dev)
 	ether_setup(dev);
 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 	dev->netdev_ops = &ieee80211_dataif_ops;
-	dev->destructor = ieee80211_if_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ieee80211_if_free;
 }
 static void ieee80211_if_setup_no_queue(struct net_device *dev)
 		ret = dev_alloc_name(ndev, ndev->name);
 		if (ret < 0) {
 			ieee80211_if_free(ndev);
+			free_netdev(ndev);
 			return ret;
 		}
 		ret = register_netdevice(ndev);
 		if (ret) {
-			ieee80211_if_free(ndev);
+			free_netdev(ndev);
 			return ret;
 		}
 	}

net/mac80211/mlme.c+31−31

@@ -601,7 +601,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata) · 600 unmodified lines
601	struct ieee80211_supported_band *sband;	601	struct ieee80211_supported_band *sband;
602	struct ieee80211_chanctx_conf *chanctx_conf;	602	struct ieee80211_chanctx_conf *chanctx_conf;
603	struct ieee80211_channel *chan;	603	struct ieee80211_channel *chan;
604	u32 rate_flags, rates = 0;	604	u32 rates = 0;
605		605
606	sdata_assert_lock(sdata);	606	sdata_assert_lock(sdata);
607		607
@@ -612,7 +612,6 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata) · 4 unmodified lines
612	return;	612	return;
613	}	613	}
614	chan = chanctx_conf->def.chan;	614	chan = chanctx_conf->def.chan;
615	rate_flags = ieee80211_chandef_rate_flags(&chanctx_conf->def);
616	rcu_read_unlock();	615	rcu_read_unlock();
617	sband = local->hw.wiphy->bands[chan->band];	616	sband = local->hw.wiphy->bands[chan->band];
618	shift = ieee80211_vif_get_shift(&sdata->vif);	617	shift = ieee80211_vif_get_shift(&sdata->vif);
@@ -636,9 +635,6 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata) · 17 unmodified lines
636	*/	635	*/
637	rates_len = 0;	636	rates_len = 0;
638	for (i = 0; i < sband->n_bitrates; i++) {	637	for (i = 0; i < sband->n_bitrates; i++) {
639	if ((rate_flags & sband->bitrates[i].flags)
640	!= rate_flags)
641	continue;
642	rates \|= BIT(i);	638	rates \|= BIT(i);
643	rates_len++;	639	rates_len++;
644	}	640	}
@@ -2818,7 +2814,7 @@ static void ieee80211_get_rates(struct ieee80211_supported_band *sband, · 2173 unmodified lines
2818	u32 rates, u32 basic_rates,	2814	u32 rates, u32 basic_rates,
2819	bool *have_higher_than_11mbit,	2815	bool *have_higher_than_11mbit,
2820	int min_rate, int min_rate_index,	2816	int min_rate, int min_rate_index,
2821	int shift, u32 rate_flags)	2817	int shift)
2822	{	2818	{
2823	int i, j;	2819	int i, j;
2824		2820
@@ -2846,8 +2842,6 @@ static void ieee80211_get_rates(struct ieee80211_supported_band *sband, · 21 unmodified lines
2846	int brate;	2842	int brate;
2847		2843
2848	br = &sband->bitrates[j];	2844	br = &sband->bitrates[j];
2849	if ((rate_flags & br->flags) != rate_flags)
2850	continue;
2851		2845
2852	brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);	2846	brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
2853	if (brate == rate) {	2847	if (brate == rate) {
@@ -4398,40 +4392,32 @@ static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata, · 1544 unmodified lines
4398	return -ENOMEM;	4392	return -ENOMEM;
4399	}	4393	}
4400		4394
4401	if (new_sta \|\| override) {	4395	/*
4402	err = ieee80211_prep_channel(sdata, cbss);	4396	* Set up the information for the new channel before setting the
4403	if (err) {	4397	* new channel. We can't - completely race-free - change the basic
4404	if (new_sta)	4398	* rates bitmap and the channel (sband) that it refers to, but if
4405	sta_info_free(local, new_sta);	4399	* we set it up before we at least avoid calling into the driver's
4406	return -EINVAL;	4400	* bss_info_changed() method with invalid information (since we do
4407	}	4401	* call that from changing the channel - only for IDLE and perhaps
4408	}	4402	* some others, but ...).
4409		4403	*
		4404	* So to avoid that, just set up all the new information before the
		4405	* channel, but tell the driver to apply it only afterwards, since
		4406	* it might need the new channel for that.
		4407	*/
4410	if (new_sta) {	4408	if (new_sta) {
4411	u32 rates = 0, basic_rates = 0;	4409	u32 rates = 0, basic_rates = 0;
4412	bool have_higher_than_11mbit;	4410	bool have_higher_than_11mbit;
4413	int min_rate = INT_MAX, min_rate_index = -1;	4411	int min_rate = INT_MAX, min_rate_index = -1;
4414	struct ieee80211_chanctx_conf *chanctx_conf;
4415	const struct cfg80211_bss_ies *ies;	4412	const struct cfg80211_bss_ies *ies;
4416	int shift = ieee80211_vif_get_shift(&sdata->vif);	4413	int shift = ieee80211_vif_get_shift(&sdata->vif);
4417	u32 rate_flags;
4418
4419	rcu_read_lock();
4420	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
4421	if (WARN_ON(!chanctx_conf)) {
4422	rcu_read_unlock();
4423	sta_info_free(local, new_sta);
4424	return -EINVAL;
4425	}
4426	rate_flags = ieee80211_chandef_rate_flags(&chanctx_conf->def);
4427	rcu_read_unlock();
4428		4414
4429	ieee80211_get_rates(sband, bss->supp_rates,	4415	ieee80211_get_rates(sband, bss->supp_rates,
4430	bss->supp_rates_len,	4416	bss->supp_rates_len,
4431	&rates, &basic_rates,	4417	&rates, &basic_rates,
4432	&have_higher_than_11mbit,	4418	&have_higher_than_11mbit,
4433	&min_rate, &min_rate_index,	4419	&min_rate, &min_rate_index,
4434	shift, rate_flags);	4420	shift);
4435		4421
4436	/*	4422	/*
4437	* This used to be a workaround for basic rates missing	4423	* This used to be a workaround for basic rates missing
@@ -4489,8 +4475,22 @@ static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata, · 51 unmodified lines
4489	sdata->vif.bss_conf.sync_dtim_count = 0;	4475	sdata->vif.bss_conf.sync_dtim_count = 0;
4490	}	4476	}
4491	rcu_read_unlock();	4477	rcu_read_unlock();
		4478	}
4492		4479
4493	/* tell driver about BSSID, basic rates and timing */	4480	if (new_sta \|\| override) {
		4481	err = ieee80211_prep_channel(sdata, cbss);
		4482	if (err) {
		4483	if (new_sta)
		4484	sta_info_free(local, new_sta);
		4485	return -EINVAL;
		4486	}
		4487	}
		4488
		4489	if (new_sta) {
		4490	/*
		4491	* tell driver about BSSID, basic rates and timing
		4492	* this was set up above, before setting the channel
		4493	*/
4494	ieee80211_bss_info_change_notify(sdata,	4494	ieee80211_bss_info_change_notify(sdata,
4495	BSS_CHANGED_BSSID \| BSS_CHANGED_BASIC_RATES \|	4495	BSS_CHANGED_BSSID \| BSS_CHANGED_BASIC_RATES \|
4496	BSS_CHANGED_BEACON_INT);	4496	BSS_CHANGED_BEACON_INT);

net/mac80211/rx.c+5−1

 	 */
 	if (!ieee80211_hw_check(&sta->local->hw, AP_LINK_PS) &&
 	    !ieee80211_has_morefrags(hdr->frame_control) &&
+	    !ieee80211_is_back_req(hdr->frame_control) &&
 	    !(status->rx_flags & IEEE80211_RX_DEFERRED_RELEASE) &&
 	    (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
 	     rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
-	    /* PM bit is only checked in frames where it isn't reserved,
+	    /*
+	     * PM bit is only checked in frames where it isn't reserved,
 	     * in AP mode it's reserved in non-bufferable management frames
 	     * (cf. IEEE 802.11-2012 8.2.4.1.7 Power Management field)
+	     * BAR frames should be ignored as specified in
+	     * IEEE 802.11-2012 10.2.1.2.
 	     */
 	    (!ieee80211_is_mgmt(hdr->frame_control) ||
 	     ieee80211_is_bufferable_mmpdu(hdr->frame_control))) {

net/mac80211/wpa.c+5−4

 #include <asm/unaligned.h>
 #include <net/mac80211.h>
 #include <crypto/aes.h>
+#include <crypto/algapi.h>
 #include "ieee80211_i.h"
 #include "michael.h"
 	data_len = skb->len - hdrlen - MICHAEL_MIC_LEN;
 	key = &rx->key->conf.key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
 	michael_mic(key, hdr, data, data_len, mic);
-	if (memcmp(mic, data + data_len, MICHAEL_MIC_LEN) != 0)
+	if (crypto_memneq(mic, data + data_len, MICHAEL_MIC_LEN))
 		goto mic_fail;
 	/* remove Michael MIC from payload */
 		bip_aad(skb, aad);
 		ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad,
 				   skb->data + 24, skb->len - 24, mic);
-		if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
+		if (crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
 			key->u.aes_cmac.icverrors++;
 			return RX_DROP_UNUSABLE;
 		}
 		bip_aad(skb, aad);
 		ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad,
 				       skb->data + 24, skb->len - 24, mic);
-		if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
+		if (crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
 			key->u.aes_cmac.icverrors++;
 			return RX_DROP_UNUSABLE;
 		}
 		if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
 				       skb->data + 24, skb->len - 24,
 				       mic) < 0 ||
-		    memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
+		    crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
 			key->u.aes_gmac.icverrors++;
 			return RX_DROP_UNUSABLE;
 		}

net/mac802154/iface.c+3−4

 	struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 	mac802154_llsec_destroy(&sdata->sec);
-	free_netdev(dev);
 }
 static void ieee802154_if_setup(struct net_device *dev)
 					sdata->dev->dev_addr);
 		sdata->dev->header_ops = &mac802154_header_ops;
-		sdata->dev->destructor = mac802154_wpan_free;
+		sdata->dev->needs_free_netdev = true;
+		sdata->dev->priv_destructor = mac802154_wpan_free;
 		sdata->dev->netdev_ops = &mac802154_wpan_ops;
 		sdata->dev->ml_priv = &mac802154_mlme_wpan;
 		wpan_dev->promiscuous_mode = false;
 		break;
 	case NL802154_IFTYPE_MONITOR:
-		sdata->dev->destructor = free_netdev;
+		sdata->dev->needs_free_netdev = true;
 		sdata->dev->netdev_ops = &mac802154_monitor_ops;
 		wpan_dev->promiscuous_mode = true;
 		break;

net/openvswitch/vport-internal_dev.c+2−2

 	struct vport *vport = ovs_internal_dev_get_vport(dev);
 	ovs_vport_free(vport);
-	free_netdev(dev);
 }
 static void
 	netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
 	netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_OPENVSWITCH |
 			      IFF_PHONY_HEADROOM | IFF_NO_QUEUE;
-	netdev->destructor = internal_dev_destructor;
+	netdev->needs_free_netdev = true;
+	netdev->priv_destructor = internal_dev_destructor;
 	netdev->ethtool_ops = &internal_dev_ethtool_ops;
 	netdev->rtnl_link_ops = &internal_dev_link_ops;

net/phonet/pep-gprs.c+1−1

@@ -236,7 +236,7 @@ static void gprs_setup(struct net_device *dev) · 235 unmodified lines
236	dev->tx_queue_len = 10;	236	dev->tx_queue_len = 10;
237		237
238	dev->netdev_ops = &gprs_netdev_ops;	238	dev->netdev_ops = &gprs_netdev_ops;
239	dev->destructor = free_netdev;	239	dev->needs_free_netdev = true;
240	}	240	}
241		241
242	/*	242	/*

net/rxrpc/key.c+34−30

 				       unsigned int *_toklen)
 {
 	const __be32 *xdr = *_xdr;
-	unsigned int toklen = *_toklen, n_parts, loop, tmp;
+	unsigned int toklen = *_toklen, n_parts, loop, tmp, paddedlen;
 	/* there must be at least one name, and at least #names+1 length
 	 * words */
 		toklen -= 4;
 		if (tmp <= 0 || tmp > AFSTOKEN_STRING_MAX)
 			return -EINVAL;
-		if (tmp > toklen)
+		paddedlen = (tmp + 3) & ~3;
+		if (paddedlen > toklen)
 			return -EINVAL;
 		princ->name_parts[loop] = kmalloc(tmp + 1, GFP_KERNEL);
 		if (!princ->name_parts[loop])
 			return -ENOMEM;
 		memcpy(princ->name_parts[loop], xdr, tmp);
 		princ->name_parts[loop][tmp] = 0;
-		tmp = (tmp + 3) & ~3;
+		toklen -= paddedlen;
-		toklen -= tmp;
+		xdr += paddedlen >> 2;
-		xdr += tmp >> 2;
 	}
 	if (toklen < 4)
 	toklen -= 4;
 	if (tmp <= 0 || tmp > AFSTOKEN_K5_REALM_MAX)
 		return -EINVAL;
-	if (tmp > toklen)
+	paddedlen = (tmp + 3) & ~3;
+	if (paddedlen > toklen)
 		return -EINVAL;
 	princ->realm = kmalloc(tmp + 1, GFP_KERNEL);
 	if (!princ->realm)
 		return -ENOMEM;
 	memcpy(princ->realm, xdr, tmp);
 	princ->realm[tmp] = 0;
-	tmp = (tmp + 3) & ~3;
+	toklen -= paddedlen;
-	toklen -= tmp;
+	xdr += paddedlen >> 2;
-	xdr += tmp >> 2;
 	_debug("%s/...@%s", princ->name_parts[0], princ->realm);
 					 unsigned int *_toklen)
 {
 	const __be32 *xdr = *_xdr;
-	unsigned int toklen = *_toklen, len;
+	unsigned int toklen = *_toklen, len, paddedlen;
 	/* there must be at least one tag and one length word */
 	if (toklen <= 8)
 	toklen -= 8;
 	if (len > max_data_size)
 		return -EINVAL;
+	paddedlen = (len + 3) & ~3;
+	if (paddedlen > toklen)
+		return -EINVAL;
 	td->data_len = len;
 	if (len > 0) {
 		td->data = kmemdup(xdr, len, GFP_KERNEL);
 		if (!td->data)
 			return -ENOMEM;
-		len = (len + 3) & ~3;
+		toklen -= paddedlen;
-		toklen -= len;
+		xdr += paddedlen >> 2;
-		xdr += len >> 2;
 	}
 	_debug("tag %x len %x", td->tag, td->data_len);
 				    const __be32 **_xdr, unsigned int *_toklen)
 {
 	const __be32 *xdr = *_xdr;
-	unsigned int toklen = *_toklen, len;
+	unsigned int toklen = *_toklen, len, paddedlen;
 	/* there must be at least one length word */
 	if (toklen <= 4)
 	toklen -= 4;
 	if (len > AFSTOKEN_K5_TIX_MAX)
 		return -EINVAL;
+	paddedlen = (len + 3) & ~3;
+	if (paddedlen > toklen)
+		return -EINVAL;
 	*_tktlen = len;
 	_debug("ticket len %u", len);
 		*_ticket = kmemdup(xdr, len, GFP_KERNEL);
 		if (!*_ticket)
 			return -ENOMEM;
-		len = (len + 3) & ~3;
+		toklen -= paddedlen;
-		toklen -= len;
+		xdr += paddedlen >> 2;
-		xdr += len >> 2;
 	}
 	*_xdr = xdr;
 {
 	const __be32 *xdr = prep->data, *token;
 	const char *cp;
-	unsigned int len, tmp, loop, ntoken, toklen, sec_ix;
+	unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
 	size_t datalen = prep->datalen;
 	int ret;
 	if (len < 1 || len > AFSTOKEN_CELL_MAX)
 		goto not_xdr;
 	datalen -= 4;
-	tmp = (len + 3) & ~3;
+	paddedlen = (len + 3) & ~3;
-	if (tmp > datalen)
+	if (paddedlen > datalen)
 		goto not_xdr;
 	cp = (const char *) xdr;
 	for (loop = 0; loop < len; loop++)
 		if (!isprint(cp[loop]))
 			goto not_xdr;
-	if (len < tmp)
+	for (; loop < paddedlen; loop++)
-		for (; loop < tmp; loop++)
+		if (cp[loop])
-			if (cp[loop])
+			goto not_xdr;
-				goto not_xdr;
 	_debug("cellname: [%u/%u] '%*.*s'",
-	       len, tmp, len, len, (const char *) xdr);
+	       len, paddedlen, len, len, (const char *) xdr);
-	datalen -= tmp;
+	datalen -= paddedlen;
-	xdr += tmp >> 2;
+	xdr += paddedlen >> 2;
 	/* get the token count */
 	if (datalen < 12)
 		sec_ix = ntohl(*xdr);
 		datalen -= 4;
 		_debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
-		if (toklen < 20 || toklen > datalen)
+		paddedlen = (toklen + 3) & ~3;
+		if (toklen < 20 || toklen > datalen || paddedlen > datalen)
 			goto not_xdr;
-		datalen -= (toklen + 3) & ~3;
+		datalen -= paddedlen;
-		xdr += (toklen + 3) >> 2;
+		xdr += paddedlen >> 2;
 	} while (--loop > 0);

net/sched/act_pedit.c+3−1

@@ -94,8 +94,10 @@ static struct tcf_pedit_key_ex tcf_pedit_keys_ex_parse(struct nlattr nla, · 93 unmodified lines
94	k++;	94	k++;
95	}	95	}
96		96
97	if (n)	97	if (n) {
		98	err = -EINVAL;
98	goto err_out;	99	goto err_out;
		100	}
99		101
100	return keys_ex;	102	return keys_ex;
101		103

net/sched/act_police.c+3−5

 		}
 	}
-	spin_lock_bh(&police->tcf_lock);
 	if (est) {
 		err = gen_replace_estimator(&police->tcf_bstats, NULL,
 					    &police->tcf_rate_est,
 					    &police->tcf_lock,
 					    NULL, est);
 		if (err)
-			goto failure_unlock;
+			goto failure;
 	} else if (tb[TCA_POLICE_AVRATE] &&
 		   (ret == ACT_P_CREATED ||
 		    !gen_estimator_active(&police->tcf_rate_est))) {
 		err = -EINVAL;
-		goto failure_unlock;
+		goto failure;
 	}
+	spin_lock_bh(&police->tcf_lock);
 	/* No failure allowed after this point */
 	police->tcfp_mtu = parm->mtu;
 	if (police->tcfp_mtu == 0) {
 	return ret;
-failure_unlock:
-	spin_unlock_bh(&police->tcf_lock);
 failure:
 	qdisc_put_rtab(P_tab);
 	qdisc_put_rtab(R_tab);

net/sctp/endpointola.c+1−0

@@ -275,6 +275,7 @@ static void sctp_endpoint_destroy(struct sctp_endpoint *ep) · 274 unmodified lines
275	if (sctp_sk(sk)->bind_hash)	275	if (sctp_sk(sk)->bind_hash)
276	sctp_put_port(sk);	276	sctp_put_port(sk);
277		277
		278	sctp_sk(sk)->ep = NULL;
278	sock_put(sk);	279	sock_put(sk);
279	}	280	}
280		281

net/sctp/sctp_diag.c+3−2

 static int sctp_sock_dump(struct sock *sk, void *p)
 {
-	struct sctp_endpoint *ep = sctp_sk(sk)->ep;
 	struct sctp_comm_param *commp = p;
 	struct sk_buff *skb = commp->skb;
 	struct netlink_callback *cb = commp->cb;
 	int err = 0;
 	lock_sock(sk);
-	list_for_each_entry(assoc, &ep->asocs, asocs) {
+	if (!sctp_sk(sk)->ep)
+		goto release;
+	list_for_each_entry(assoc, &sctp_sk(sk)->ep->asocs, asocs) {
 		if (cb->args[4] < cb->args[1])
 			goto next;

net/sctp/socket.c+4−5

 	for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
 	     hash++, head++) {
-		read_lock(&head->lock);
+		read_lock_bh(&head->lock);
 		sctp_for_each_hentry(epb, &head->chain) {
 			err = cb(sctp_ep(epb), p);
 			if (err)
 				break;
 		}
-		read_unlock(&head->lock);
+		read_unlock_bh(&head->lock);
 	}
 	return err;
 	if (err)
 		return err;
-	sctp_transport_get_idx(net, &hti, pos);
+	obj = sctp_transport_get_idx(net, &hti, pos + 1);
-	obj = sctp_transport_get_next(net, &hti);
+	for (; !IS_ERR_OR_NULL(obj); obj = sctp_transport_get_next(net, &hti)) {
-	for (; obj && !IS_ERR(obj); obj = sctp_transport_get_next(net, &hti)) {
 		struct sctp_transport *transport = obj;
 		if (!sctp_transport_hold(transport))

net/tipc/msg.c+1−1

@@ -508,7 +508,7 @@ bool tipc_msg_reverse(u32 own_node, struct sk_buff **skb, int err) · 507 unmodified lines
508	}	508	}
509		509
510	if (skb_cloned(_skb) &&	510	if (skb_cloned(_skb) &&
511	pskb_expand_head(_skb, BUF_HEADROOM, BUF_TAILROOM, GFP_KERNEL))	511	pskb_expand_head(_skb, BUF_HEADROOM, BUF_TAILROOM, GFP_ATOMIC))
512	goto exit;	512	goto exit;
513		513
514	/* Now reverse the concerned fields */	514	/* Now reverse the concerned fields */

net/unix/af_unix.c+6−1

 	struct path path = { };
 	err = -EINVAL;
-	if (sunaddr->sun_family != AF_UNIX)
+	if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
+	    sunaddr->sun_family != AF_UNIX)
 		goto out;
 	if (addr_len == sizeof(short)) {
 	unsigned int hash;
 	int err;
+	err = -EINVAL;
+	if (alen < offsetofend(struct sockaddr, sa_family))
+		goto out;
 	if (addr->sa_family != AF_UNSPEC) {
 		err = unix_mkname(sunaddr, alen, &hash);
 		if (err < 0)

net/wireless/wext-core.c+9−13

  * Main IOCTl dispatcher.
  * Check the type of IOCTL and call the appropriate wrapper...
  */
-static int wireless_process_ioctl(struct net *net, struct ifreq *ifr,
+static int wireless_process_ioctl(struct net *net, struct iwreq *iwr,
 				  unsigned int cmd,
 				  struct iw_request_info *info,
 				  wext_ioctl_func standard,
 				  wext_ioctl_func private)
 {
-	struct iwreq *iwr = (struct iwreq *) ifr;
 	struct net_device *dev;
 	iw_handler	handler;
 	 * The copy_to/from_user() of ifr is also dealt with in there */
 	/* Make sure the device exist */
-	if ((dev = __dev_get_by_name(net, ifr->ifr_name)) == NULL)
+	if ((dev = __dev_get_by_name(net, iwr->ifr_name)) == NULL)
 		return -ENODEV;
 	/* A bunch of special cases, then the generic case...
 		else if (private)
 			return private(dev, iwr, cmd, info, handler);
 	}
-	/* Old driver API : call driver ioctl handler */
-	if (dev->netdev_ops->ndo_do_ioctl)
-		return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd);
 	return -EOPNOTSUPP;
 }
 }
 /* entry point from dev ioctl */
-static int wext_ioctl_dispatch(struct net *net, struct ifreq *ifr,
+static int wext_ioctl_dispatch(struct net *net, struct iwreq *iwr,
 			       unsigned int cmd, struct iw_request_info *info,
 			       wext_ioctl_func standard,
 			       wext_ioctl_func private)
 	if (ret)
 		return ret;
-	dev_load(net, ifr->ifr_name);
+	dev_load(net, iwr->ifr_name);
 	rtnl_lock();
-	ret = wireless_process_ioctl(net, ifr, cmd, info, standard, private);
+	ret = wireless_process_ioctl(net, iwr, cmd, info, standard, private);
 	rtnl_unlock();
 	return ret;
 }
-int wext_handle_ioctl(struct net *net, struct ifreq *ifr, unsigned int cmd,
+int wext_handle_ioctl(struct net *net, struct iwreq *iwr, unsigned int cmd,
 		      void __user *arg)
 {
 	struct iw_request_info info = { .cmd = cmd, .flags = 0 };
 	int ret;
-	ret = wext_ioctl_dispatch(net, ifr, cmd, &info,
+	ret = wext_ioctl_dispatch(net, iwr, cmd, &info,
 				  ioctl_standard_call,
 				  ioctl_private_call);
 	if (ret >= 0 &&
 	    IW_IS_GET(cmd) &&
-	    copy_to_user(arg, ifr, sizeof(struct iwreq)))
+	    copy_to_user(arg, iwr, sizeof(struct iwreq)))
 		return -EFAULT;
 	return ret;
 	info.cmd = cmd;
 	info.flags = IW_REQUEST_FLAG_COMPAT;
-	ret = wext_ioctl_dispatch(net, (struct ifreq *) &iwr, cmd, &info,
+	ret = wext_ioctl_dispatch(net, &iwr, cmd, &info,
 				  compat_standard_call,
 				  compat_private_call);

scripts/Makefile.headersinst+9−1

@@ -14,7 +14,15 @@ __headers: · 13 unmodified lines
14	include scripts/Kbuild.include	14	include scripts/Kbuild.include
15		15
16	srcdir := $(srctree)/$(obj)	16	srcdir := $(srctree)/$(obj)
17	subdirs := $(patsubst $(srcdir)/%/.,%,$(wildcard $(srcdir)/*/.))	17
		18	# When make is run under a fakechroot environment, the function
		19	# $(wildcard $(srcdir)/*/.) doesn't only return directories, but also regular
		20	# files. So, we are using a combination of sort/dir/wildcard which works
		21	# with fakechroot.
		22	subdirs := $(patsubst $(srcdir)/%/,%,\
		23	$(filter-out $(srcdir)/,\
		24	$(sort $(dir $(wildcard $(srcdir)/*/)))))
		25
18	# caller may set destination dir (when installing to asm/)	26	# caller may set destination dir (when installing to asm/)
19	_dst := $(if $(dst),$(dst),$(obj))	27	_dst := $(if $(dst),$(dst),$(obj))
20		28

scripts/genksyms/genksyms.h+1−1

@@ -75,7 +75,7 @@ struct string_list copy_list_range(struct string_list start, · 74 unmodified lines
75	int yylex(void);	75	int yylex(void);
76	int yyparse(void);	76	int yyparse(void);
77		77
78	void error_with_pos(const char *, ...);	78	void error_with_pos(const char *, ...) __attribute__ ((format(printf, 1, 2)));
79		79
80	/----------------------------------------------------------------------/	80	/----------------------------------------------------------------------/
81	#define xmalloc(size) ({ void *__ptr = malloc(size); \	81	#define xmalloc(size) ({ void *__ptr = malloc(size); \

scripts/kconfig/Makefile+1−1

@@ -196,7 +196,7 @@ clean-files += config.pot linux.pot · 195 unmodified lines
196		196
197	# Check that we have the required ncurses stuff installed for lxdialog (menuconfig)	197	# Check that we have the required ncurses stuff installed for lxdialog (menuconfig)
198	PHONY += $(obj)/dochecklxdialog	198	PHONY += $(obj)/dochecklxdialog
199	$(addprefix $(obj)/,$(lxdialog)): $(obj)/dochecklxdialog	199	$(addprefix $(obj)/, mconf.o $(lxdialog)): $(obj)/dochecklxdialog
200	$(obj)/dochecklxdialog:	200	$(obj)/dochecklxdialog:
201	$(Q)$(CONFIG_SHELL) $(check-lxdialog) -check $(HOSTCC) $(HOST_EXTRACFLAGS) $(HOSTLOADLIBES_mconf)	201	$(Q)$(CONFIG_SHELL) $(check-lxdialog) -check $(HOSTCC) $(HOST_EXTRACFLAGS) $(HOSTLOADLIBES_mconf)
202		202

scripts/kconfig/nconf.c+6−6

@@ -271,7 +271,7 @@ static struct mitem k_menu_items[MAX_MENU_ITEMS]; · 270 unmodified lines
271	static int items_num;	271	static int items_num;
272	static int global_exit;	272	static int global_exit;
273	/* the currently selected button */	273	/* the currently selected button */
274	const char *current_instructions = menu_instructions;	274	static const char *current_instructions = menu_instructions;
275		275
276	static char *dialog_input_result;	276	static char *dialog_input_result;
277	static int dialog_input_result_len;	277	static int dialog_input_result_len;
@@ -305,7 +305,7 @@ struct function_keys { · 27 unmodified lines
305	};	305	};
306		306
307	static const int function_keys_num = 9;	307	static const int function_keys_num = 9;
308	struct function_keys function_keys[] = {	308	static struct function_keys function_keys[] = {
309	{	309	{
310	.key_str = "F1",	310	.key_str = "F1",
311	.func = "Help",	311	.func = "Help",
@@ -508,7 +508,7 @@ static int get_mext_match(const char *match_str, match_f flag) · 196 unmodified lines
508	index = (index + items_num) % items_num;	508	index = (index + items_num) % items_num;
509	while (true) {	509	while (true) {
510	char *str = k_menu_items[index].str;	510	char *str = k_menu_items[index].str;
511	if (strcasestr(str, match_str) != 0)	511	if (strcasestr(str, match_str) != NULL)
512	return index;	512	return index;
513	if (flag == FIND_NEXT_MATCH_UP \|\|	513	if (flag == FIND_NEXT_MATCH_UP \|\|
514	flag == MATCH_TINKER_PATTERN_UP)	514	flag == MATCH_TINKER_PATTERN_UP)
@@ -1067,7 +1067,7 @@ static int do_match(int key, struct match_state state, int ans) · 552 unmodified lines
1067		1067
1068	static void conf(struct menu *menu)	1068	static void conf(struct menu *menu)
1069	{	1069	{
1070	struct menu *submenu = 0;	1070	struct menu *submenu = NULL;
1071	const char *prompt = menu_get_prompt(menu);	1071	const char *prompt = menu_get_prompt(menu);
1072	struct symbol *sym;	1072	struct symbol *sym;
1073	int res;	1073	int res;
@@ -1234,7 +1234,7 @@ static void show_help(struct menu *menu) · 160 unmodified lines
1234	static void conf_choice(struct menu *menu)	1234	static void conf_choice(struct menu *menu)
1235	{	1235	{
1236	const char *prompt = _(menu_get_prompt(menu));	1236	const char *prompt = _(menu_get_prompt(menu));
1237	struct menu *child = 0;	1237	struct menu *child = NULL;
1238	struct symbol *active;	1238	struct symbol *active;
1239	int selected_index = 0;	1239	int selected_index = 0;
1240	int last_top_row = 0;	1240	int last_top_row = 0;
@@ -1456,7 +1456,7 @@ static void conf_save(void) · 215 unmodified lines
1456	}	1456	}
1457	}	1457	}
1458		1458
1459	void setup_windows(void)	1459	static void setup_windows(void)
1460	{	1460	{
1461	int lines, columns;	1461	int lines, columns;
1462		1462

scripts/kconfig/nconf.gui.c+2−2

@@ -129,7 +129,7 @@ static void no_colors_theme(void) · 128 unmodified lines
129	mkattrn(FUNCTION_TEXT, A_REVERSE);	129	mkattrn(FUNCTION_TEXT, A_REVERSE);
130	}	130	}
131		131
132	void set_colors()	132	void set_colors(void)
133	{	133	{
134	start_color();	134	start_color();
135	use_default_colors();	135	use_default_colors();
@@ -192,7 +192,7 @@ const char get_line(const char text, int line_no) · 56 unmodified lines
192	int lines = 0;	192	int lines = 0;
193		193
194	if (!text)	194	if (!text)
195	return 0;	195	return NULL;
196		196
197	for (i = 0; text[i] != '\0' && lines < line_no; i++)	197	for (i = 0; text[i] != '\0' && lines < line_no; i++)
198	if (text[i] == '\n')	198	if (text[i] == '\n')

scripts/tags.sh+1−0

@@ -106,6 +106,7 @@ all_compiled_sources() · 105 unmodified lines
106	case "$i" in	106	case "$i" in
107	*.[cS])	107	*.[cS])
108	j=${i/\.[cS]/\.o}	108	j=${i/\.[cS]/\.o}
		109	j="${j#$tree}"
109	if [ -e $j ]; then	110	if [ -e $j ]; then
110	echo $i	111	echo $i
111	fi	112	fi

security/selinux/hooks.c+2−3

 	opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int),
 				       GFP_KERNEL);
-	if (!opts->mnt_opts_flags) {
+	if (!opts->mnt_opts_flags)
-		kfree(opts->mnt_opts);
 		goto out_err;
-	}
 	if (fscontext) {
 		opts->mnt_opts[num_mnt_opts] = fscontext;
 	return 0;
 out_err:
+	security_free_mnt_opts(opts);
 	kfree(context);
 	kfree(defcontext);
 	kfree(fscontext);

sound/core/pcm_lib.c+2−2

@@ -2492,7 +2492,7 @@ static int pcm_chmap_ctl_get(struct snd_kcontrol *kcontrol, · 2491 unmodified lines
2492	struct snd_pcm_substream *substream;	2492	struct snd_pcm_substream *substream;
2493	const struct snd_pcm_chmap_elem *map;	2493	const struct snd_pcm_chmap_elem *map;
2494		2494
2495	if (snd_BUG_ON(!info->chmap))	2495	if (!info->chmap)
2496	return -EINVAL;	2496	return -EINVAL;
2497	substream = snd_pcm_chmap_substream(info, idx);	2497	substream = snd_pcm_chmap_substream(info, idx);
2498	if (!substream)	2498	if (!substream)
@@ -2524,7 +2524,7 @@ static int pcm_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag, · 25 unmodified lines
2524	unsigned int __user *dst;	2524	unsigned int __user *dst;
2525	int c, count = 0;	2525	int c, count = 0;
2526		2526
2527	if (snd_BUG_ON(!info->chmap))	2527	if (!info->chmap)
2528	return -EINVAL;	2528	return -EINVAL;
2529	if (size < 8)	2529	if (size < 8)
2530	return -ENOMEM;	2530	return -ENOMEM;

sound/firewire/amdtp-stream.c+6−2

 		cycle = increment_cycle_count(cycle, 1);
 		if (s->handle_packet(s, 0, cycle, i) < 0) {
 			s->packet_index = -1;
-			amdtp_stream_pcm_abort(s);
+			if (in_interrupt())
+				amdtp_stream_pcm_abort(s);
+			WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);
 			return;
 		}
 	}
 	/* Queueing error or detecting invalid payload. */
 	if (i < packets) {
 		s->packet_index = -1;
-		amdtp_stream_pcm_abort(s);
+		if (in_interrupt())
+			amdtp_stream_pcm_abort(s);
+		WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);
 		return;
 	}

sound/firewire/amdtp-stream.h+1−1

@@ -135,7 +135,7 @@ struct amdtp_stream { · 134 unmodified lines
135	/* For a PCM substream processing. */	135	/* For a PCM substream processing. */
136	struct snd_pcm_substream *pcm;	136	struct snd_pcm_substream *pcm;
137	struct tasklet_struct period_tasklet;	137	struct tasklet_struct period_tasklet;
138	unsigned int pcm_buffer_pointer;	138	snd_pcm_uframes_t pcm_buffer_pointer;
139	unsigned int pcm_period_pointer;	139	unsigned int pcm_period_pointer;
140		140
141	/* To wait for first packet. */	141	/* To wait for first packet. */

sound/pci/hda/hda_intel.c+8−3

 #define IS_KBL_LP(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x9d71)
 #define IS_KBL_H(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0xa2f0)
 #define IS_BXT(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x5a98)
+#define IS_BXT_T(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x1a98)
 #define IS_GLK(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x3198)
-#define IS_SKL_PLUS(pci) (IS_SKL(pci) || IS_SKL_LP(pci) || IS_BXT(pci)) || \
+#define IS_CFL(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0xa348)
-			IS_KBL(pci) || IS_KBL_LP(pci) || IS_KBL_H(pci)	|| \
+#define IS_SKL_PLUS(pci) (IS_SKL(pci) || IS_SKL_LP(pci) || IS_BXT(pci) || \
-			IS_GLK(pci)
+			  IS_BXT_T(pci) || IS_KBL(pci) || IS_KBL_LP(pci) || \
+			  IS_KBL_H(pci)	|| IS_GLK(pci) || IS_CFL(pci))
 static char *driver_short_names[] = {
 	[AZX_DRIVER_ICH] = "HDA Intel",
 	/* Kabylake-H */
 	{ PCI_DEVICE(0x8086, 0xa2f0),
 	  .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_SKYLAKE },
+	/* Coffelake */
+	{ PCI_DEVICE(0x8086, 0xa348),
+	  .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_SKYLAKE},
 	/* Broxton-P(Apollolake) */
 	{ PCI_DEVICE(0x8086, 0x5a98),
 	  .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_BROXTON },

tools/objtool/builtin-check.c+2−1

@@ -192,7 +192,8 @@ static int __dead_end_function(struct objtool_file file, struct symbol func, · 191 unmodified lines
192	"complete_and_exit",	192	"complete_and_exit",
193	"kvm_spurious_fault",	193	"kvm_spurious_fault",
194	"__reiserfs_panic",	194	"__reiserfs_panic",
195	"lbug_with_loc"	195	"lbug_with_loc",
		196	"fortify_panic",
196	};	197	};
197		198
198	if (func->bind == STB_WEAK)	199	if (func->bind == STB_WEAK)

tools/perf/Makefile.config+19−19

@@ -19,18 +19,18 @@ CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS) · 18 unmodified lines
19		19
20	include $(srctree)/tools/scripts/Makefile.arch	20	include $(srctree)/tools/scripts/Makefile.arch
21		21
22	$(call detected_var,ARCH)	22	$(call detected_var,SRCARCH)
23		23
24	NO_PERF_REGS := 1	24	NO_PERF_REGS := 1
25		25
26	# Additional ARCH settings for ppc	26	# Additional ARCH settings for ppc
27	ifeq ($(ARCH),powerpc)	27	ifeq ($(SRCARCH),powerpc)
28	NO_PERF_REGS := 0	28	NO_PERF_REGS := 0
29	LIBUNWIND_LIBS := -lunwind -lunwind-ppc64	29	LIBUNWIND_LIBS := -lunwind -lunwind-ppc64
30	endif	30	endif
31		31
32	# Additional ARCH settings for x86	32	# Additional ARCH settings for x86
33	ifeq ($(ARCH),x86)	33	ifeq ($(SRCARCH),x86)
34	$(call detected,CONFIG_X86)	34	$(call detected,CONFIG_X86)
35	ifeq (${IS_64_BIT}, 1)	35	ifeq (${IS_64_BIT}, 1)
36	CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT -DHAVE_SYSCALL_TABLE -I$(OUTPUT)arch/x86/include/generated	36	CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT -DHAVE_SYSCALL_TABLE -I$(OUTPUT)arch/x86/include/generated
@@ -43,12 +43,12 @@ ifeq ($(ARCH),x86) · 6 unmodified lines
43	NO_PERF_REGS := 0	43	NO_PERF_REGS := 0
44	endif	44	endif
45		45
46	ifeq ($(ARCH),arm)	46	ifeq ($(SRCARCH),arm)
47	NO_PERF_REGS := 0	47	NO_PERF_REGS := 0
48	LIBUNWIND_LIBS = -lunwind -lunwind-arm	48	LIBUNWIND_LIBS = -lunwind -lunwind-arm
49	endif	49	endif
50		50
51	ifeq ($(ARCH),arm64)	51	ifeq ($(SRCARCH),arm64)
52	NO_PERF_REGS := 0	52	NO_PERF_REGS := 0
53	LIBUNWIND_LIBS = -lunwind -lunwind-aarch64	53	LIBUNWIND_LIBS = -lunwind -lunwind-aarch64
54	endif	54	endif
@@ -61,7 +61,7 @@ endif · 6 unmodified lines
61	# Disable it on all other architectures in case libdw unwind	61	# Disable it on all other architectures in case libdw unwind
62	# support is detected in system. Add supported architectures	62	# support is detected in system. Add supported architectures
63	# to the check.	63	# to the check.
64	ifneq ($(ARCH),$(filter $(ARCH),x86 arm))	64	ifneq ($(SRCARCH),$(filter $(SRCARCH),x86 arm))
65	NO_LIBDW_DWARF_UNWIND := 1	65	NO_LIBDW_DWARF_UNWIND := 1
66	endif	66	endif
67		67
@@ -115,9 +115,9 @@ endif · 47 unmodified lines
115	FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)	115	FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)
116	FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf	116	FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf
117		117
118	FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi	118	FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(SRCARCH)/include/uapi -I$(srctree)/tools/include/uapi
119	# include ARCH specific config	119	# include ARCH specific config
120	-include $(src-perf)/arch/$(ARCH)/Makefile	120	-include $(src-perf)/arch/$(SRCARCH)/Makefile
121		121
122	ifdef PERF_HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET	122	ifdef PERF_HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET
123	CFLAGS += -DHAVE_ARCH_REGS_QUERY_REGISTER_OFFSET	123	CFLAGS += -DHAVE_ARCH_REGS_QUERY_REGISTER_OFFSET
@@ -228,12 +228,12 @@ ifeq ($(DEBUG),0) · 104 unmodified lines
228	endif	228	endif
229		229
230	INC_FLAGS += -I$(src-perf)/util/include	230	INC_FLAGS += -I$(src-perf)/util/include
231	INC_FLAGS += -I$(src-perf)/arch/$(ARCH)/include	231	INC_FLAGS += -I$(src-perf)/arch/$(SRCARCH)/include
232	INC_FLAGS += -I$(srctree)/tools/include/uapi	232	INC_FLAGS += -I$(srctree)/tools/include/uapi
233	INC_FLAGS += -I$(srctree)/tools/include/	233	INC_FLAGS += -I$(srctree)/tools/include/
234	INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/uapi	234	INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/include/uapi
235	INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/	235	INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/include/
236	INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/	236	INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/
237		237
238	# $(obj-perf) for generated common-cmds.h	238	# $(obj-perf) for generated common-cmds.h
239	# $(obj-perf)/util for generated bison/flex headers	239	# $(obj-perf)/util for generated bison/flex headers
@@ -355,7 +355,7 @@ ifndef NO_LIBELF · 115 unmodified lines
355		355
356	ifndef NO_DWARF	356	ifndef NO_DWARF
357	ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)	357	ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
358	msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);	358	msg := $(warning DWARF register mappings have not been defined for architecture $(SRCARCH), DWARF support disabled);
359	NO_DWARF := 1	359	NO_DWARF := 1
360	else	360	else
361	CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)	361	CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)
@@ -380,7 +380,7 @@ ifndef NO_LIBELF · 18 unmodified lines
380	CFLAGS += -DHAVE_BPF_PROLOGUE	380	CFLAGS += -DHAVE_BPF_PROLOGUE
381	$(call detected,CONFIG_BPF_PROLOGUE)	381	$(call detected,CONFIG_BPF_PROLOGUE)
382	else	382	else
383	msg := $(warning BPF prologue is not supported by architecture $(ARCH), missing regs_query_register_offset());	383	msg := $(warning BPF prologue is not supported by architecture $(SRCARCH), missing regs_query_register_offset());
384	endif	384	endif
385	else	385	else
386	msg := $(warning DWARF support is off, BPF prologue is disabled);	386	msg := $(warning DWARF support is off, BPF prologue is disabled);
@@ -406,7 +406,7 @@ ifdef PERF_HAVE_JITDUMP · 19 unmodified lines
406	endif	406	endif
407	endif	407	endif
408		408
409	ifeq ($(ARCH),powerpc)	409	ifeq ($(SRCARCH),powerpc)
410	ifndef NO_DWARF	410	ifndef NO_DWARF
411	CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX	411	CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX
412	endif	412	endif
@@ -487,7 +487,7 @@ else · 74 unmodified lines
487	endif	487	endif
488		488
489	ifndef NO_LOCAL_LIBUNWIND	489	ifndef NO_LOCAL_LIBUNWIND
490	ifeq ($(ARCH),$(filter $(ARCH),arm arm64))	490	ifeq ($(SRCARCH),$(filter $(SRCARCH),arm arm64))
491	$(call feature_check,libunwind-debug-frame)	491	$(call feature_check,libunwind-debug-frame)
492	ifneq ($(feature-libunwind-debug-frame), 1)	492	ifneq ($(feature-libunwind-debug-frame), 1)
493	msg := $(warning No debug_frame support found in libunwind);	493	msg := $(warning No debug_frame support found in libunwind);
@@ -740,7 +740,7 @@ ifeq (${IS_64_BIT}, 1) · 246 unmodified lines
740	NO_PERF_READ_VDSO32 := 1	740	NO_PERF_READ_VDSO32 := 1
741	endif	741	endif
742	endif	742	endif
743	ifneq ($(ARCH), x86)	743	ifneq ($(SRCARCH), x86)
744	NO_PERF_READ_VDSOX32 := 1	744	NO_PERF_READ_VDSOX32 := 1
745	endif	745	endif
746	ifndef NO_PERF_READ_VDSOX32	746	ifndef NO_PERF_READ_VDSOX32
@@ -769,7 +769,7 @@ ifdef LIBBABELTRACE · 22 unmodified lines
769	endif	769	endif
770		770
771	ifndef NO_AUXTRACE	771	ifndef NO_AUXTRACE
772	ifeq ($(ARCH),x86)	772	ifeq ($(SRCARCH),x86)
773	ifeq ($(feature-get_cpuid), 0)	773	ifeq ($(feature-get_cpuid), 0)
774	msg := $(warning Your gcc lacks the __get_cpuid() builtin, disables support for auxtrace/Intel PT, please install a newer gcc);	774	msg := $(warning Your gcc lacks the __get_cpuid() builtin, disables support for auxtrace/Intel PT, please install a newer gcc);
775	NO_AUXTRACE := 1	775	NO_AUXTRACE := 1
@@ -872,7 +872,7 @@ sysconfdir = $(prefix)/etc · 96 unmodified lines
872	ETC_PERFCONFIG = etc/perfconfig	872	ETC_PERFCONFIG = etc/perfconfig
873	endif	873	endif
874	ifndef lib	874	ifndef lib
875	ifeq ($(ARCH)$(IS_64_BIT), x861)	875	ifeq ($(SRCARCH)$(IS_64_BIT), x861)
876	lib = lib64	876	lib = lib64
877	else	877	else
878	lib = lib	878	lib = lib

tools/perf/Makefile.perf+1−1

@@ -226,7 +226,7 @@ endif · 225 unmodified lines
226		226
227	ifeq ($(config),0)	227	ifeq ($(config),0)
228	include $(srctree)/tools/scripts/Makefile.arch	228	include $(srctree)/tools/scripts/Makefile.arch
229	-include arch/$(ARCH)/Makefile	229	-include arch/$(SRCARCH)/Makefile
230	endif	230	endif
231		231
232	# The FEATURE_DUMP_EXPORT holds location of the actual	232	# The FEATURE_DUMP_EXPORT holds location of the actual

tools/perf/arch/Build+1−1

@@ -1,2 +1,2 @@
1	libperf-y += common.o	1	libperf-y += common.o
2	libperf-y += $(ARCH)/	2	libperf-y += $(SRCARCH)/

tools/perf/pmu-events/Build+2−2

@@ -2,7 +2,7 @@ hostprogs := jevents · 1 unmodified line
2		2
3	jevents-y += json.o jsmn.o jevents.o	3	jevents-y += json.o jsmn.o jevents.o
4	pmu-events-y += pmu-events.o	4	pmu-events-y += pmu-events.o
5	JDIR = pmu-events/arch/$(ARCH)	5	JDIR = pmu-events/arch/$(SRCARCH)
6	JSON = $(shell [ -d $(JDIR) ] && \	6	JSON = $(shell [ -d $(JDIR) ] && \
7	find $(JDIR) -name '*.json' -o -name 'mapfile.csv')	7	find $(JDIR) -name '*.json' -o -name 'mapfile.csv')
8	#	8	#
@@ -10,4 +10,4 @@ JSON = $(shell [ -d $(JDIR) ] && \ · 1 unmodified line
10	# directory and create tables in pmu-events.c.	10	# directory and create tables in pmu-events.c.
11	#	11	#
12	$(OUTPUT)pmu-events/pmu-events.c: $(JSON) $(JEVENTS)	12	$(OUTPUT)pmu-events/pmu-events.c: $(JSON) $(JEVENTS)
13	$(Q)$(call echo-cmd,gen)$(JEVENTS) $(ARCH) pmu-events/arch $(OUTPUT)pmu-events/pmu-events.c $(V)	13	$(Q)$(call echo-cmd,gen)$(JEVENTS) $(SRCARCH) pmu-events/arch $(OUTPUT)pmu-events/pmu-events.c $(V)

tools/perf/tests/Build+1−1

@@ -75,7 +75,7 @@ $(OUTPUT)tests/llvm-src-relocation.c: tests/bpf-script-test-relocation.c tests/B · 74 unmodified lines
75	$(Q)sed -e 's/"/\\"/g' -e 's/$.*$/"\1\\n"/g' $< >> $@	75	$(Q)sed -e 's/"/\\"/g' -e 's/$.*$/"\1\\n"/g' $< >> $@
76	$(Q)echo ';' >> $@	76	$(Q)echo ';' >> $@
77		77
78	ifeq ($(ARCH),$(filter $(ARCH),x86 arm arm64 powerpc))	78	ifeq ($(SRCARCH),$(filter $(SRCARCH),x86 arm arm64 powerpc))
79	perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o	79	perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
80	endif	80	endif
81		81

tools/perf/tests/task-exit.c+1−1

@@ -83,7 +83,7 @@ int test__task_exit(int subtest __maybe_unused) · 82 unmodified lines
83		83
84	evsel = perf_evlist__first(evlist);	84	evsel = perf_evlist__first(evlist);
85	evsel->attr.task = 1;	85	evsel->attr.task = 1;
86	evsel->attr.sample_freq = 0;	86	evsel->attr.sample_freq = 1;
87	evsel->attr.inherit = 0;	87	evsel->attr.inherit = 0;
88	evsel->attr.watermark = 0;	88	evsel->attr.watermark = 0;
89	evsel->attr.wakeup_events = 1;	89	evsel->attr.wakeup_events = 1;

tools/perf/util/evsel.c+12−0

@@ -273,8 +273,20 @@ struct perf_evsel *perf_evsel__new_cycles(void) · 272 unmodified lines
273	struct perf_evsel *evsel;	273	struct perf_evsel *evsel;
274		274
275	event_attr_init(&attr);	275	event_attr_init(&attr);
		276	/*
		277	* Unnamed union member, not supported as struct member named
		278	* initializer in older compilers such as gcc 4.4.7
		279	*
		280	* Just for probing the precise_ip:
		281	*/
		282	attr.sample_period = 1;
276		283
277	perf_event_attr__set_max_precise_ip(&attr);	284	perf_event_attr__set_max_precise_ip(&attr);
		285	/*
		286	* Now let the usual logic to set up the perf_event_attr defaults
		287	* to kick in when we return and before perf_evsel__open() is called.
		288	*/
		289	attr.sample_period = 0;
278		290
279	evsel = perf_evsel__new(&attr);	291	evsel = perf_evsel__new(&attr);
280	if (evsel == NULL)	292	if (evsel == NULL)

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

@@ -841,7 +841,7 @@ static int write_group_desc(int fd, struct perf_header *h __maybe_unused, · 840 unmodified lines
841		841
842	/*	842	/*
843	* default get_cpuid(): nothing gets recorded	843	* default get_cpuid(): nothing gets recorded
844	* actual implementation must be in arch/$(ARCH)/util/header.c	844	* actual implementation must be in arch/$(SRCARCH)/util/header.c
845	*/	845	*/
846	int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)	846	int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)
847	{	847	{

tools/perf/util/probe-event.c+1−1

@@ -619,7 +619,7 @@ static int post_process_probe_trace_point(struct probe_trace_point *tp, · 618 unmodified lines
619	struct map *map, unsigned long offs)	619	struct map *map, unsigned long offs)
620	{	620	{
621	struct symbol *sym;	621	struct symbol *sym;
622	u64 addr = tp->address + tp->offset - offs;	622	u64 addr = tp->address - offs;
623		623
624	sym = map__find_symbol(map, addr);	624	sym = map__find_symbol(map, addr);
625	if (!sym)	625	if (!sym)

tools/perf/util/unwind-libdw.c+8−0

@@ -178,6 +178,14 @@ frame_callback(Dwfl_Frame state, void arg) · 177 unmodified lines
178	Dwarf_Addr pc;	178	Dwarf_Addr pc;
179	bool isactivation;	179	bool isactivation;
180		180
		181	if (!dwfl_frame_pc(state, &pc, NULL)) {
		182	pr_err("%s", dwfl_errmsg(-1));
		183	return DWARF_CB_ABORT;
		184	}
		185
		186	// report the module before we query for isactivation
		187	report_module(pc, ui);
		188
181	if (!dwfl_frame_pc(state, &pc, &isactivation)) {	189	if (!dwfl_frame_pc(state, &pc, &isactivation)) {
182	pr_err("%s", dwfl_errmsg(-1));	190	pr_err("%s", dwfl_errmsg(-1));
183	return DWARF_CB_ABORT;	191	return DWARF_CB_ABORT;

tools/testing/selftests/bpf/bpf_endian.h+30−11

 #ifndef __BPF_ENDIAN__
 #define __BPF_ENDIAN__
-#include <asm/byteorder.h>
+#include <linux/swab.h>
-#if __BYTE_ORDER == __LITTLE_ENDIAN
+/* LLVM's BPF target selects the endianness of the CPU
-# define __bpf_ntohs(x)		__builtin_bswap16(x)
+ * it compiles on, or the user specifies (bpfel/bpfeb),
-# define __bpf_htons(x)		__builtin_bswap16(x)
+ * respectively. The used __BYTE_ORDER__ is defined by
-#elif __BYTE_ORDER == __BIG_ENDIAN
+ * the compiler, we cannot rely on __BYTE_ORDER from
-# define __bpf_ntohs(x)		(x)
+ * libc headers, since it doesn't reflect the actual
-# define __bpf_htons(x)		(x)
+ * requested byte order.
+ *
+ * Note, LLVM's BPF target has different __builtin_bswapX()
+ * semantics. It does map to BPF_ALU | BPF_END | BPF_TO_BE
+ * in bpfel and bpfeb case, which means below, that we map
+ * to cpu_to_be16(). We could use it unconditionally in BPF
+ * case, but better not rely on it, so that this header here
+ * can be used from application and BPF program side, which
+ * use different targets.
+ */
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define __bpf_ntohs(x)			__builtin_bswap16(x)
+# define __bpf_htons(x)			__builtin_bswap16(x)
+# define __bpf_constant_ntohs(x)	___constant_swab16(x)
+# define __bpf_constant_htons(x)	___constant_swab16(x)
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+# define __bpf_ntohs(x)			(x)
+# define __bpf_htons(x)			(x)
+# define __bpf_constant_ntohs(x)	(x)
+# define __bpf_constant_htons(x)	(x)
 #else
-# error "Fix your __BYTE_ORDER?!"
+# error "Fix your compiler's __BYTE_ORDER__?!"
 #endif
 #define bpf_htons(x)				\
 	(__builtin_constant_p(x) ?		\
-	 __constant_htons(x) : __bpf_htons(x))
+	 __bpf_constant_htons(x) : __bpf_htons(x))
 #define bpf_ntohs(x)				\
 	(__builtin_constant_p(x) ?		\
-	 __constant_ntohs(x) : __bpf_ntohs(x))
+	 __bpf_constant_ntohs(x) : __bpf_ntohs(x))
-#endif
+#endif /* __BPF_ENDIAN__ */

tools/testing/selftests/ntb/ntb_test.sh+1−1

@@ -305,7 +305,7 @@ function perf_test() · 304 unmodified lines
305	echo "Running remote perf test $WITH DMA"	305	echo "Running remote perf test $WITH DMA"
306	write_file "" $REMOTE_PERF/run	306	write_file "" $REMOTE_PERF/run
307	echo -n " "	307	echo -n " "
308	read_file $LOCAL_PERF/run	308	read_file $REMOTE_PERF/run
309	echo " Passed"	309	echo " Passed"
310		310
311	_modprobe -r ntb_perf	311	_modprobe -r ntb_perf

Backmerge tag 'v4.12-rc7' into drm-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -47,7 +47,7 @@ DEFINE_DMI_ATTR_WITH_SHOW(product_name, 0444, DMI_PRODUCT_NAME); · 46 unmodified lines
47	DEFINE_DMI_ATTR_WITH_SHOW(product_version, 0444, DMI_PRODUCT_VERSION);	47	DEFINE_DMI_ATTR_WITH_SHOW(product_version, 0444, DMI_PRODUCT_VERSION);
48	DEFINE_DMI_ATTR_WITH_SHOW(product_serial, 0400, DMI_PRODUCT_SERIAL);	48	DEFINE_DMI_ATTR_WITH_SHOW(product_serial, 0400, DMI_PRODUCT_SERIAL);
49	DEFINE_DMI_ATTR_WITH_SHOW(product_uuid, 0400, DMI_PRODUCT_UUID);	49	DEFINE_DMI_ATTR_WITH_SHOW(product_uuid, 0400, DMI_PRODUCT_UUID);
50	DEFINE_DMI_ATTR_WITH_SHOW(product_family, 0400, DMI_PRODUCT_FAMILY);	50	DEFINE_DMI_ATTR_WITH_SHOW(product_family, 0444, DMI_PRODUCT_FAMILY);
51	DEFINE_DMI_ATTR_WITH_SHOW(board_vendor, 0444, DMI_BOARD_VENDOR);	51	DEFINE_DMI_ATTR_WITH_SHOW(board_vendor, 0444, DMI_BOARD_VENDOR);
52	DEFINE_DMI_ATTR_WITH_SHOW(board_name, 0444, DMI_BOARD_NAME);	52	DEFINE_DMI_ATTR_WITH_SHOW(board_name, 0444, DMI_BOARD_NAME);
53	DEFINE_DMI_ATTR_WITH_SHOW(board_version, 0444, DMI_BOARD_VERSION);	53	DEFINE_DMI_ATTR_WITH_SHOW(board_version, 0444, DMI_BOARD_VERSION);
@@ -192,7 +192,7 @@ static void __init dmi_id_init_attr_table(void) · 138 unmodified lines
192	ADD_DMI_ATTR(product_version, DMI_PRODUCT_VERSION);	192	ADD_DMI_ATTR(product_version, DMI_PRODUCT_VERSION);
193	ADD_DMI_ATTR(product_serial, DMI_PRODUCT_SERIAL);	193	ADD_DMI_ATTR(product_serial, DMI_PRODUCT_SERIAL);
194	ADD_DMI_ATTR(product_uuid, DMI_PRODUCT_UUID);	194	ADD_DMI_ATTR(product_uuid, DMI_PRODUCT_UUID);
195	ADD_DMI_ATTR(product_family, DMI_PRODUCT_FAMILY);	195	ADD_DMI_ATTR(product_family, DMI_PRODUCT_FAMILY);
196	ADD_DMI_ATTR(board_vendor, DMI_BOARD_VENDOR);	196	ADD_DMI_ATTR(board_vendor, DMI_BOARD_VENDOR);
197	ADD_DMI_ATTR(board_name, DMI_BOARD_NAME);	197	ADD_DMI_ATTR(board_name, DMI_BOARD_NAME);
198	ADD_DMI_ATTR(board_version, DMI_BOARD_VERSION);	198	ADD_DMI_ATTR(board_version, DMI_BOARD_VERSION);

@@ -75,7 +75,7 @@ $(OUTPUT)tests/llvm-src-relocation.c: tests/bpf-script-test-relocation.c tests/B · 74 unmodified lines
75	$(Q)sed -e 's/"/\\"/g' -e 's/\(.*\)/"\1\\n"/g' $< >> $@	75	$(Q)sed -e 's/"/\\"/g' -e 's/\(.*\)/"\1\\n"/g' $< >> $@
76	$(Q)echo ';' >> $@	76	$(Q)echo ';' >> $@
77		77
78	ifeq ($(ARCH),$(filter $(ARCH),x86 arm arm64 powerpc))	78	ifeq ($(SRCARCH),$(filter $(SRCARCH),x86 arm arm64 powerpc))
79	perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o	79	perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
80	endif	80	endif
81		81