lael-labs/linux

MAINTAINERS+2−0

 BROADCOM BCM2835 ARM ARCHITECTURE
 M:	Eric Anholt <eric@anholt.net>
 M:	Stefan Wahren <wahrenst@gmx.net>
+L:	bcm-kernel-feedback-list@broadcom.com
 L:	linux-rpi-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 T:	git git://github.com/anholt/linux
 BROADCOM BCM53573 ARM ARCHITECTURE
 M:	Rafał Miłecki <rafal@milecki.pl>
+L:	bcm-kernel-feedback-list@broadcom.com
 L:	linux-arm-kernel@lists.infradead.org
 S:	Maintained
 F:	arch/arm/boot/dts/bcm53573*

Makefile+1−1

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

arch/arm/boot/dts/gemini-dlink-dir-685.dts+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	};	20	};
21		21
22	chosen {	22	chosen {
23	bootargs = "console=ttyS0,19200n8 root=/dev/sda1 rw rootwait";	23	bootargs = "console=ttyS0,19200n8 root=/dev/sda1 rw rootwait consoleblank=300";
24	stdout-path = "uart0:19200n8";	24	stdout-path = "uart0:19200n8";
25	};	25	};
26		26

arch/arm/boot/dts/gemini-dlink-dns-313.dts+1−1

@@ -11,7 +11,7 @@ · 10 unmodified lines
11		11
12	/ {	12	/ {
13	model = "D-Link DNS-313 1-Bay Network Storage Enclosure";	13	model = "D-Link DNS-313 1-Bay Network Storage Enclosure";
14	compatible = "dlink,dir-313", "cortina,gemini";	14	compatible = "dlink,dns-313", "cortina,gemini";
15	#address-cells = <1>;	15	#address-cells = <1>;
16	#size-cells = <1>;	16	#size-cells = <1>;
17		17

arch/arm/boot/dts/imx6ul.dtsi+4−4

@@ -358,7 +358,7 @@ · 357 unmodified lines
358	pwm1: pwm@2080000 {	358	pwm1: pwm@2080000 {
359	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";	359	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";
360	reg = <0x02080000 0x4000>;	360	reg = <0x02080000 0x4000>;
361	interrupts = <GIC_SPI 115 IRQ_TYPE_LEVEL_HIGH>;	361	interrupts = <GIC_SPI 83 IRQ_TYPE_LEVEL_HIGH>;
362	clocks = <&clks IMX6UL_CLK_PWM1>,	362	clocks = <&clks IMX6UL_CLK_PWM1>,
363	<&clks IMX6UL_CLK_PWM1>;	363	<&clks IMX6UL_CLK_PWM1>;
364	clock-names = "ipg", "per";	364	clock-names = "ipg", "per";
@@ -369,7 +369,7 @@ · 4 unmodified lines
369	pwm2: pwm@2084000 {	369	pwm2: pwm@2084000 {
370	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";	370	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";
371	reg = <0x02084000 0x4000>;	371	reg = <0x02084000 0x4000>;
372	interrupts = <GIC_SPI 116 IRQ_TYPE_LEVEL_HIGH>;	372	interrupts = <GIC_SPI 84 IRQ_TYPE_LEVEL_HIGH>;
373	clocks = <&clks IMX6UL_CLK_PWM2>,	373	clocks = <&clks IMX6UL_CLK_PWM2>,
374	<&clks IMX6UL_CLK_PWM2>;	374	<&clks IMX6UL_CLK_PWM2>;
375	clock-names = "ipg", "per";	375	clock-names = "ipg", "per";
@@ -380,7 +380,7 @@ · 4 unmodified lines
380	pwm3: pwm@2088000 {	380	pwm3: pwm@2088000 {
381	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";	381	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";
382	reg = <0x02088000 0x4000>;	382	reg = <0x02088000 0x4000>;
383	interrupts = <GIC_SPI 117 IRQ_TYPE_LEVEL_HIGH>;	383	interrupts = <GIC_SPI 85 IRQ_TYPE_LEVEL_HIGH>;
384	clocks = <&clks IMX6UL_CLK_PWM3>,	384	clocks = <&clks IMX6UL_CLK_PWM3>,
385	<&clks IMX6UL_CLK_PWM3>;	385	<&clks IMX6UL_CLK_PWM3>;
386	clock-names = "ipg", "per";	386	clock-names = "ipg", "per";
@@ -391,7 +391,7 @@ · 4 unmodified lines
391	pwm4: pwm@208c000 {	391	pwm4: pwm@208c000 {
392	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";	392	compatible = "fsl,imx6ul-pwm", "fsl,imx27-pwm";
393	reg = <0x0208c000 0x4000>;	393	reg = <0x0208c000 0x4000>;
394	interrupts = <GIC_SPI 118 IRQ_TYPE_LEVEL_HIGH>;	394	interrupts = <GIC_SPI 86 IRQ_TYPE_LEVEL_HIGH>;
395	clocks = <&clks IMX6UL_CLK_PWM4>,	395	clocks = <&clks IMX6UL_CLK_PWM4>,
396	<&clks IMX6UL_CLK_PWM4>;	396	<&clks IMX6UL_CLK_PWM4>;
397	clock-names = "ipg", "per";	397	clock-names = "ipg", "per";

arch/arm/boot/dts/meson8.dtsi+2−3

 				     <GIC_SPI 167 IRQ_TYPE_LEVEL_HIGH>,
 				     <GIC_SPI 168 IRQ_TYPE_LEVEL_HIGH>,
 				     <GIC_SPI 169 IRQ_TYPE_LEVEL_HIGH>,
-				     <GIC_SPI 172 IRQ_TYPE_LEVEL_HIGH>,
+				     <GIC_SPI 170 IRQ_TYPE_LEVEL_HIGH>,
-				     <GIC_SPI 173 IRQ_TYPE_LEVEL_HIGH>,
+				     <GIC_SPI 171 IRQ_TYPE_LEVEL_HIGH>,
 				     <GIC_SPI 172 IRQ_TYPE_LEVEL_HIGH>,
 				     <GIC_SPI 173 IRQ_TYPE_LEVEL_HIGH>,
 				     <GIC_SPI 174 IRQ_TYPE_LEVEL_HIGH>,
 			clocks = <&clkc CLKID_CLK81>, <&clkc CLKID_MALI>;
 			clock-names = "bus", "core";
 			operating-points-v2 = <&gpu_opp_table>;
-			switch-delay = <0xffff>;
 		};
 	};
 }; /* end of / */

arch/arm/boot/dts/meson8b.dtsi+5−6

 		opp-255000000 {
 			opp-hz = /bits/ 64 <255000000>;
-			opp-microvolt = <1150000>;
+			opp-microvolt = <1100000>;
 		};
 		opp-364300000 {
 			opp-hz = /bits/ 64 <364300000>;
-			opp-microvolt = <1150000>;
+			opp-microvolt = <1100000>;
 		};
 		opp-425000000 {
 			opp-hz = /bits/ 64 <425000000>;
-			opp-microvolt = <1150000>;
+			opp-microvolt = <1100000>;
 		};
 		opp-510000000 {
 			opp-hz = /bits/ 64 <510000000>;
-			opp-microvolt = <1150000>;
+			opp-microvolt = <1100000>;
 		};
 		opp-637500000 {
 			opp-hz = /bits/ 64 <637500000>;
-			opp-microvolt = <1150000>;
+			opp-microvolt = <1100000>;
 			turbo-mode;
 		};
 	};
 			clocks = <&clkc CLKID_CLK81>, <&clkc CLKID_MALI>;
 			clock-names = "bus", "core";
 			operating-points-v2 = <&gpu_opp_table>;
-			switch-delay = <0xffff>;
 		};
 	};
 }; /* end of / */

arch/arm/mach-omap2/prm3xxx.c+1−1

@@ -430,7 +430,7 @@ static void omap3_prm_reconfigure_io_chain(void) · 429 unmodified lines
430	* registers, and omap3xxx_prm_reconfigure_io_chain() must be called.	430	* registers, and omap3xxx_prm_reconfigure_io_chain() must be called.
431	* No return value.	431	* No return value.
432	*/	432	*/
433	static void __init omap3xxx_prm_enable_io_wakeup(void)	433	static void omap3xxx_prm_enable_io_wakeup(void)
434	{	434	{
435	if (prm_features & PRM_HAS_IO_WAKEUP)	435	if (prm_features & PRM_HAS_IO_WAKEUP)
436	omap2_prm_set_mod_reg_bits(OMAP3430_EN_IO_MASK, WKUP_MOD,	436	omap2_prm_set_mod_reg_bits(OMAP3430_EN_IO_MASK, WKUP_MOD,

arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi+9−9

@@ -28,7 +28,7 @@ · 27 unmodified lines
28	enable-method = "psci";	28	enable-method = "psci";
29	clocks = <&clockgen 1 0>;	29	clocks = <&clockgen 1 0>;
30	next-level-cache = <&l2>;	30	next-level-cache = <&l2>;
31	cpu-idle-states = <&CPU_PH20>;	31	cpu-idle-states = <&CPU_PW20>;
32	};	32	};
33		33
34	cpu1: cpu@1 {	34	cpu1: cpu@1 {
@@ -38,7 +38,7 @@ · 3 unmodified lines
38	enable-method = "psci";	38	enable-method = "psci";
39	clocks = <&clockgen 1 0>;	39	clocks = <&clockgen 1 0>;
40	next-level-cache = <&l2>;	40	next-level-cache = <&l2>;
41	cpu-idle-states = <&CPU_PH20>;	41	cpu-idle-states = <&CPU_PW20>;
42	};	42	};
43		43
44	l2: l2-cache {	44	l2: l2-cache {
@@ -53,13 +53,13 @@ · 8 unmodified lines
53	*/	53	*/
54	entry-method = "arm,psci";	54	entry-method = "arm,psci";
55		55
56	CPU_PH20: cpu-ph20 {	56	CPU_PW20: cpu-pw20 {
57	compatible = "arm,idle-state";	57	compatible = "arm,idle-state";
58	idle-state-name = "PH20";	58	idle-state-name = "PW20";
59	arm,psci-suspend-param = <0x00010000>;	59	arm,psci-suspend-param = <0x0>;
60	entry-latency-us = <1000>;	60	entry-latency-us = <2000>;
61	exit-latency-us = <1000>;	61	exit-latency-us = <2000>;
62	min-residency-us = <3000>;	62	min-residency-us = <6000>;
63	};	63	};
64	};	64	};
65		65

arch/arm64/configs/defconfig+1−0

@@ -613,6 +613,7 @@ CONFIG_RTC_DRV_TEGRA=y · 612 unmodified lines
613	CONFIG_RTC_DRV_IMX_SC=m	613	CONFIG_RTC_DRV_IMX_SC=m
614	CONFIG_RTC_DRV_XGENE=y	614	CONFIG_RTC_DRV_XGENE=y
615	CONFIG_DMADEVICES=y	615	CONFIG_DMADEVICES=y
		616	CONFIG_FSL_EDMA=y
616	CONFIG_DMA_BCM2835=m	617	CONFIG_DMA_BCM2835=m
617	CONFIG_K3_DMA=y	618	CONFIG_K3_DMA=y
618	CONFIG_MV_XOR=y	619	CONFIG_MV_XOR=y

arch/csky/kernel/signal.c+5−0

 #endif
 struct rt_sigframe {
+	/*
+	 * pad[3] is compatible with the same struct defined in
+	 * gcc/libgcc/config/csky/linux-unwind.h
+	 */
+	int pad[3];
 	struct siginfo info;
 	struct ucontext uc;
 };

arch/parisc/kernel/module.c+4−0

 			/* 32-bit PC relative address */
 			*loc = val - dot - 8 + addend;
 			break;
+		case R_PARISC_PCREL64:
+			/* 64-bit PC relative address */
+			*loc64 = val - dot - 8 + addend;
+			break;
 		case R_PARISC_DIR64:
 			/* 64-bit effective address */
 			*loc64 = val + addend;

arch/powerpc/include/asm/page.h+7−0

@@ -319,6 +319,13 @@ struct vm_area_struct; · 318 unmodified lines
319	#endif /* __ASSEMBLY__ */	319	#endif /* __ASSEMBLY__ */
320	#include <asm/slice.h>	320	#include <asm/slice.h>
321		321
		322	/*
		323	* Allow 30-bit DMA for very limited Broadcom wifi chips on many powerbooks.
		324	*/
		325	#ifdef CONFIG_PPC32
		326	#define ARCH_ZONE_DMA_BITS 30
		327	#else
322	#define ARCH_ZONE_DMA_BITS 31	328	#define ARCH_ZONE_DMA_BITS 31
		329	#endif
323		330
324	#endif /* _ASM_POWERPC_PAGE_H */	331	#endif /* _ASM_POWERPC_PAGE_H */

arch/powerpc/kernel/head_32.S+1−0

@@ -752,6 +752,7 @@ __secondary_start: · 751 unmodified lines
752	stw r0,0(r3)	752	stw r0,0(r3)
753		753
754	/* load up the MMU */	754	/* load up the MMU */
		755	bl load_segment_registers
755	bl load_up_mmu	756	bl load_up_mmu
756		757
757	/* ptr to phys current thread */	758	/* ptr to phys current thread */

arch/powerpc/kernel/head_booke.h+5−5

@@ -83,7 +83,7 @@ END_BTB_FLUSH_SECTION · 82 unmodified lines
83	SAVE_4GPRS(3, r11); \	83	SAVE_4GPRS(3, r11); \
84	SAVE_2GPRS(7, r11)	84	SAVE_2GPRS(7, r11)
85		85
86	.macro SYSCALL_ENTRY trapno intno	86	.macro SYSCALL_ENTRY trapno intno srr1
87	mfspr r10, SPRN_SPRG_THREAD	87	mfspr r10, SPRN_SPRG_THREAD
88	#ifdef CONFIG_KVM_BOOKE_HV	88	#ifdef CONFIG_KVM_BOOKE_HV
89	BEGIN_FTR_SECTION	89	BEGIN_FTR_SECTION
@@ -94,7 +94,7 @@ BEGIN_FTR_SECTION · 4 unmodified lines
94	mfspr r11, SPRN_SRR1	94	mfspr r11, SPRN_SRR1
95	mtocrf 0x80, r11 /* check MSR[GS] without clobbering reg */	95	mtocrf 0x80, r11 /* check MSR[GS] without clobbering reg */
96	bf 3, 1975f	96	bf 3, 1975f
97	b kvmppc_handler_BOOKE_INTERRUPT_\intno\()_SPRN_SRR1	97	b kvmppc_handler_\intno\()_\srr1
98	1975:	98	1975:
99	mr r12, r13	99	mr r12, r13
100	lwz r13, THREAD_NORMSAVE(2)(r10)	100	lwz r13, THREAD_NORMSAVE(2)(r10)
@@ -145,9 +145,9 @@ ALT_FTR_SECTION_END_IFSET(CPU_FTR_EMB_HV) · 44 unmodified lines
145	tophys(r11,r11)	145	tophys(r11,r11)
146	addi r11,r11,global_dbcr0@l	146	addi r11,r11,global_dbcr0@l
147	#ifdef CONFIG_SMP	147	#ifdef CONFIG_SMP
148	lwz r9,TASK_CPU(r2)	148	lwz r10, TASK_CPU(r2)
149	slwi r9,r9,3	149	slwi r10, r10, 3
150	add r11,r11,r9	150	add r11, r11, r10
151	#endif	151	#endif
152	lwz r12,0(r11)	152	lwz r12,0(r11)
153	mtspr SPRN_DBCR0,r12	153	mtspr SPRN_DBCR0,r12

arch/powerpc/kernel/head_fsl_booke.S+1−1

@@ -409,7 +409,7 @@ interrupt_base: · 408 unmodified lines
409		409
410	/* System Call Interrupt */	410	/* System Call Interrupt */
411	START_EXCEPTION(SystemCall)	411	START_EXCEPTION(SystemCall)
412	SYSCALL_ENTRY 0xc00 SYSCALL	412	SYSCALL_ENTRY 0xc00 BOOKE_INTERRUPT_SYSCALL SPRN_SRR1
413		413
414	/* Auxiliary Processor Unavailable Interrupt */	414	/* Auxiliary Processor Unavailable Interrupt */
415	EXCEPTION(0x2900, AP_UNAVAIL, AuxillaryProcessorUnavailable, \	415	EXCEPTION(0x2900, AP_UNAVAIL, AuxillaryProcessorUnavailable, \

arch/powerpc/kvm/book3s_hv_builtin.c+1−0

@@ -830,6 +830,7 @@ static void flush_guest_tlb(struct kvm *kvm) · 829 unmodified lines
830	}	830	}
831	}	831	}
832	asm volatile("ptesync": : :"memory");	832	asm volatile("ptesync": : :"memory");
		833	asm volatile(PPC_INVALIDATE_ERAT : : :"memory");
833	}	834	}
834		835
835	void kvmppc_check_need_tlb_flush(struct kvm *kvm, int pcpu,	836	void kvmppc_check_need_tlb_flush(struct kvm *kvm, int pcpu,

arch/powerpc/kvm/book3s_hv_rmhandlers.S+13−2

 	LOAD_REG_ADDR(r11, dawr_force_enable)
 	lbz	r11, 0(r11)
 	cmpdi	r11, 0
+	bne	3f
 	li	r3, H_HARDWARE
-	beqlr
+	blr
+3:
 	/* Emulate H_SET_DABR/X on P8 for the sake of compat mode guests */
 	rlwimi	r5, r4, 5, DAWRX_DR | DAWRX_DW
 	rlwimi	r5, r4, 2, DAWRX_WT
 	clrrdi	r4, r4, 3
 	std	r4, VCPU_DAWR(r3)
 	std	r5, VCPU_DAWRX(r3)
+	/*
+	 * If came in through the real mode hcall handler then it is necessary
+	 * to write the registers since the return path won't. Otherwise it is
+	 * sufficient to store then in the vcpu struct as they will be loaded
+	 * next time the vcpu is run.
+	 */
+	mfmsr	r6
+	andi.	r6, r6, MSR_DR		/* in real mode? */
+	bne	4f
 	mtspr	SPRN_DAWR, r4
 	mtspr	SPRN_DAWRX, r5
-	li	r3, 0
+4:	li	r3, 0
 	blr
 _GLOBAL(kvmppc_h_cede)		/* r3 = vcpu pointer, r11 = msr, r13 = paca */

arch/powerpc/mm/book3s64/mmu_context.c+47−8

@@ -50,20 +50,52 @@ EXPORT_SYMBOL_GPL(hash__alloc_context_id); · 49 unmodified lines
50		50
51	void slb_setup_new_exec(void);	51	void slb_setup_new_exec(void);
52		52
		53	static int realloc_context_ids(mm_context_t *ctx)
		54	{
		55	int i, id;
		56
		57	/*
		58	* id 0 (aka. ctx->id) is special, we always allocate a new one, even if
		59	* there wasn't one allocated previously (which happens in the exec
		60	* case where ctx is newly allocated).
		61	*
		62	* We have to be a bit careful here. We must keep the existing ids in
		63	* the array, so that we can test if they're non-zero to decide if we
		64	* need to allocate a new one. However in case of error we must free the
		65	* ids we've allocated but not any of the existing ones (or risk a
		66	* UAF). That's why we decrement i at the start of the error handling
		67	* loop, to skip the id that we just tested but couldn't reallocate.
		68	*/
		69	for (i = 0; i < ARRAY_SIZE(ctx->extended_id); i++) {
		70	if (i == 0 \|\| ctx->extended_id[i]) {
		71	id = hash__alloc_context_id();
		72	if (id < 0)
		73	goto error;
		74
		75	ctx->extended_id[i] = id;
		76	}
		77	}
		78
		79	/* The caller expects us to return id */
		80	return ctx->id;
		81
		82	error:
		83	for (i--; i >= 0; i--) {
		84	if (ctx->extended_id[i])
		85	ida_free(&mmu_context_ida, ctx->extended_id[i]);
		86	}
		87
		88	return id;
		89	}
		90
53	static int hash__init_new_context(struct mm_struct *mm)	91	static int hash__init_new_context(struct mm_struct *mm)
54	{	92	{
55	int index;	93	int index;
56		94
57	index = hash__alloc_context_id();
58	if (index < 0)
59	return index;
60
61	mm->context.hash_context = kmalloc(sizeof(struct hash_mm_context),	95	mm->context.hash_context = kmalloc(sizeof(struct hash_mm_context),
62	GFP_KERNEL);	96	GFP_KERNEL);
63	if (!mm->context.hash_context) {	97	if (!mm->context.hash_context)
64	ida_free(&mmu_context_ida, index);
65	return -ENOMEM;	98	return -ENOMEM;
66	}
67		99
68	/*	100	/*
69	* The old code would re-promote on fork, we don't do that when using	101	* The old code would re-promote on fork, we don't do that when using
@@ -91,13 +123,20 @@ static int hash__init_new_context(struct mm_struct *mm) · 21 unmodified lines
91	mm->context.hash_context->spt = kmalloc(sizeof(struct subpage_prot_table),	123	mm->context.hash_context->spt = kmalloc(sizeof(struct subpage_prot_table),
92	GFP_KERNEL);	124	GFP_KERNEL);
93	if (!mm->context.hash_context->spt) {	125	if (!mm->context.hash_context->spt) {
94	ida_free(&mmu_context_ida, index);
95	kfree(mm->context.hash_context);	126	kfree(mm->context.hash_context);
96	return -ENOMEM;	127	return -ENOMEM;
97	}	128	}
98	}	129	}
99	#endif	130	#endif
		131	}
100		132
		133	index = realloc_context_ids(&mm->context);
		134	if (index < 0) {
		135	#ifdef CONFIG_PPC_SUBPAGE_PROT
		136	kfree(mm->context.hash_context->spt);
		137	#endif
		138	kfree(mm->context.hash_context);
		139	return index;
101	}	140	}
102		141
103	pkey_mm_init(mm);	142	pkey_mm_init(mm);

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

@@ -248,7 +248,8 @@ void __init paging_init(void) · 247 unmodified lines
248	(long int)((top_of_ram - total_ram) >> 20));	248	(long int)((top_of_ram - total_ram) >> 20));
249		249
250	#ifdef CONFIG_ZONE_DMA	250	#ifdef CONFIG_ZONE_DMA
251	max_zone_pfns[ZONE_DMA] = min(max_low_pfn, 0x7fffffffUL >> PAGE_SHIFT);	251	max_zone_pfns[ZONE_DMA] = min(max_low_pfn,
		252	((1UL << ARCH_ZONE_DMA_BITS) - 1) >> PAGE_SHIFT);
252	#endif	253	#endif
253	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;	254	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
254	#ifdef CONFIG_HIGHMEM	255	#ifdef CONFIG_HIGHMEM

arch/powerpc/platforms/powermac/Kconfig+1−0

@@ -7,6 +7,7 @@ config PPC_PMAC · 6 unmodified lines
7	select PPC_INDIRECT_PCI if PPC32	7	select PPC_INDIRECT_PCI if PPC32
8	select PPC_MPC106 if PPC32	8	select PPC_MPC106 if PPC32
9	select PPC_NATIVE	9	select PPC_NATIVE
		10	select ZONE_DMA if PPC32
10	default y	11	default y
11		12
12	config PPC_PMAC64	13	config PPC_PMAC64

drivers/auxdisplay/cfag12864bfb.c+3−2

@@ -52,8 +52,9 @@ static const struct fb_var_screeninfo cfag12864bfb_var = { · 51 unmodified lines
52		52
53	static int cfag12864bfb_mmap(struct fb_info info, struct vm_area_struct vma)	53	static int cfag12864bfb_mmap(struct fb_info info, struct vm_area_struct vma)
54	{	54	{
55	return vm_insert_page(vma, vma->vm_start,	55	struct page *pages = virt_to_page(cfag12864b_buffer);
56	virt_to_page(cfag12864b_buffer));	56
		57	return vm_map_pages_zero(vma, &pages, 1);
57	}	58	}
58		59
59	static struct fb_ops cfag12864bfb_ops = {	60	static struct fb_ops cfag12864bfb_ops = {

drivers/auxdisplay/ht16k33.c+2−2

 static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
 	struct ht16k33_priv *priv = info->par;
+	struct page *pages = virt_to_page(priv->fbdev.buffer);
-	return vm_insert_page(vma, vma->vm_start,
+	return vm_map_pages_zero(vma, &pages, 1);
-			      virt_to_page(priv->fbdev.buffer));
 }
 static struct fb_ops ht16k33_fb_ops = {

drivers/clk/clk.c+1−1

@@ -368,7 +368,7 @@ static struct clk_core clk_core_get(struct clk_core core, u8 p_index) · 367 unmodified lines
368	const char *dev_id = dev ? dev_name(dev) : NULL;	368	const char *dev_id = dev ? dev_name(dev) : NULL;
369	struct device_node *np = core->of_node;	369	struct device_node *np = core->of_node;
370		370
371	if (np && index >= 0)	371	if (np && (name \|\| index >= 0))
372	hw = of_clk_get_hw(np, index, name);	372	hw = of_clk_get_hw(np, index, name);
373		373
374	/*	374	/*

drivers/clk/meson/g12a.c+2−2

@@ -2734,8 +2734,8 @@ static struct clk_hw_onecell_data g12a_hw_onecell_data = { · 2733 unmodified lines
2734	[CLKID_MALI_1_DIV] = &g12a_mali_1_div.hw,	2734	[CLKID_MALI_1_DIV] = &g12a_mali_1_div.hw,
2735	[CLKID_MALI_1] = &g12a_mali_1.hw,	2735	[CLKID_MALI_1] = &g12a_mali_1.hw,
2736	[CLKID_MALI] = &g12a_mali.hw,	2736	[CLKID_MALI] = &g12a_mali.hw,
2737	[CLKID_MPLL_5OM_DIV] = &g12a_mpll_50m_div.hw,	2737	[CLKID_MPLL_50M_DIV] = &g12a_mpll_50m_div.hw,
2738	[CLKID_MPLL_5OM] = &g12a_mpll_50m.hw,	2738	[CLKID_MPLL_50M] = &g12a_mpll_50m.hw,
2739	[CLKID_SYS_PLL_DIV16_EN] = &g12a_sys_pll_div16_en.hw,	2739	[CLKID_SYS_PLL_DIV16_EN] = &g12a_sys_pll_div16_en.hw,
2740	[CLKID_SYS_PLL_DIV16] = &g12a_sys_pll_div16.hw,	2740	[CLKID_SYS_PLL_DIV16] = &g12a_sys_pll_div16.hw,
2741	[CLKID_CPU_CLK_DYN0_SEL] = &g12a_cpu_clk_premux0.hw,	2741	[CLKID_CPU_CLK_DYN0_SEL] = &g12a_cpu_clk_premux0.hw,

drivers/clk/meson/g12a.h+1−1

@@ -166,7 +166,7 @@ · 165 unmodified lines
166	#define CLKID_HDMI_DIV 167	166	#define CLKID_HDMI_DIV 167
167	#define CLKID_MALI_0_DIV 170	167	#define CLKID_MALI_0_DIV 170
168	#define CLKID_MALI_1_DIV 173	168	#define CLKID_MALI_1_DIV 173
169	#define CLKID_MPLL_5OM_DIV 176	169	#define CLKID_MPLL_50M_DIV 176
170	#define CLKID_SYS_PLL_DIV16_EN 178	170	#define CLKID_SYS_PLL_DIV16_EN 178
171	#define CLKID_SYS_PLL_DIV16 179	171	#define CLKID_SYS_PLL_DIV16 179
172	#define CLKID_CPU_CLK_DYN0_SEL 180	172	#define CLKID_CPU_CLK_DYN0_SEL 180

drivers/clk/meson/meson8b.c+5−5

@@ -1761,7 +1761,7 @@ static struct clk_regmap meson8m2_gp_pll = { · 1760 unmodified lines
1761	},	1761	},
1762	};	1762	};
1763		1763
1764	static const char * const mmeson8b_vpu_0_1_parent_names[] = {	1764	static const char * const meson8b_vpu_0_1_parent_names[] = {
1765	"fclk_div4", "fclk_div3", "fclk_div5", "fclk_div7"	1765	"fclk_div4", "fclk_div3", "fclk_div5", "fclk_div7"
1766	};	1766	};
1767		1767
@@ -1778,8 +1778,8 @@ static struct clk_regmap meson8b_vpu_0_sel = { · 10 unmodified lines
1778	.hw.init = &(struct clk_init_data){	1778	.hw.init = &(struct clk_init_data){
1779	.name = "vpu_0_sel",	1779	.name = "vpu_0_sel",
1780	.ops = &clk_regmap_mux_ops,	1780	.ops = &clk_regmap_mux_ops,
1781	.parent_names = mmeson8b_vpu_0_1_parent_names,	1781	.parent_names = meson8b_vpu_0_1_parent_names,
1782	.num_parents = ARRAY_SIZE(mmeson8b_vpu_0_1_parent_names),	1782	.num_parents = ARRAY_SIZE(meson8b_vpu_0_1_parent_names),
1783	.flags = CLK_SET_RATE_PARENT,	1783	.flags = CLK_SET_RATE_PARENT,
1784	},	1784	},
1785	};	1785	};
@@ -1837,8 +1837,8 @@ static struct clk_regmap meson8b_vpu_1_sel = { · 51 unmodified lines
1837	.hw.init = &(struct clk_init_data){	1837	.hw.init = &(struct clk_init_data){
1838	.name = "vpu_1_sel",	1838	.name = "vpu_1_sel",
1839	.ops = &clk_regmap_mux_ops,	1839	.ops = &clk_regmap_mux_ops,
1840	.parent_names = mmeson8b_vpu_0_1_parent_names,	1840	.parent_names = meson8b_vpu_0_1_parent_names,
1841	.num_parents = ARRAY_SIZE(mmeson8b_vpu_0_1_parent_names),	1841	.num_parents = ARRAY_SIZE(meson8b_vpu_0_1_parent_names),
1842	.flags = CLK_SET_RATE_PARENT,	1842	.flags = CLK_SET_RATE_PARENT,
1843	},	1843	},
1844	};	1844	};

drivers/clk/socfpga/clk-s10.c+2−2

@@ -103,9 +103,9 @@ static const struct stratix10_perip_cnt_clock s10_main_perip_cnt_clks[] = { · 102 unmodified lines
103	{ STRATIX10_NOC_CLK, "noc_clk", NULL, noc_mux, ARRAY_SIZE(noc_mux),	103	{ STRATIX10_NOC_CLK, "noc_clk", NULL, noc_mux, ARRAY_SIZE(noc_mux),
104	0, 0, 0, 0x3C, 1},	104	0, 0, 0, 0x3C, 1},
105	{ STRATIX10_EMAC_A_FREE_CLK, "emaca_free_clk", NULL, emaca_free_mux, ARRAY_SIZE(emaca_free_mux),	105	{ STRATIX10_EMAC_A_FREE_CLK, "emaca_free_clk", NULL, emaca_free_mux, ARRAY_SIZE(emaca_free_mux),
106	0, 0, 4, 0xB0, 0},	106	0, 0, 2, 0xB0, 0},
107	{ STRATIX10_EMAC_B_FREE_CLK, "emacb_free_clk", NULL, emacb_free_mux, ARRAY_SIZE(emacb_free_mux),	107	{ STRATIX10_EMAC_B_FREE_CLK, "emacb_free_clk", NULL, emacb_free_mux, ARRAY_SIZE(emacb_free_mux),
108	0, 0, 4, 0xB0, 1},	108	0, 0, 2, 0xB0, 1},
109	{ STRATIX10_EMAC_PTP_FREE_CLK, "emac_ptp_free_clk", NULL, emac_ptp_free_mux,	109	{ STRATIX10_EMAC_PTP_FREE_CLK, "emac_ptp_free_clk", NULL, emac_ptp_free_mux,
110	ARRAY_SIZE(emac_ptp_free_mux), 0, 0, 4, 0xB0, 2},	110	ARRAY_SIZE(emac_ptp_free_mux), 0, 0, 4, 0xB0, 2},
111	{ STRATIX10_GPIO_DB_FREE_CLK, "gpio_db_free_clk", NULL, gpio_db_free_mux,	111	{ STRATIX10_GPIO_DB_FREE_CLK, "gpio_db_free_clk", NULL, gpio_db_free_mux,

drivers/clk/tegra/clk-tegra210.c+2−0

 	{ TEGRA210_CLK_I2S3_SYNC, TEGRA210_CLK_CLK_MAX, 24576000, 0 },
 	{ TEGRA210_CLK_I2S4_SYNC, TEGRA210_CLK_CLK_MAX, 24576000, 0 },
 	{ TEGRA210_CLK_VIMCLK_SYNC, TEGRA210_CLK_CLK_MAX, 24576000, 0 },
+	{ TEGRA210_CLK_HDA, TEGRA210_CLK_PLL_P, 51000000, 0 },
+	{ TEGRA210_CLK_HDA2CODEC_2X, TEGRA210_CLK_PLL_P, 48000000, 0 },
 	/* This MUST be the last entry. */
 	{ TEGRA210_CLK_CLK_MAX, TEGRA210_CLK_CLK_MAX, 0, 0 },
 };

drivers/clk/ti/clkctrl.c+5−2

 {
 	struct omap_clkctrl_provider *provider = data;
 	struct omap_clkctrl_clk *entry;
+	bool found = false;
 	if (clkspec->args_count != 2)
 		return ERR_PTR(-EINVAL);
 	list_for_each_entry(entry, &provider->clocks, node) {
 		if (entry->reg_offset == clkspec->args[0] &&
-		    entry->bit_offset == clkspec->args[1])
+		    entry->bit_offset == clkspec->args[1]) {
+			found = true;
 			break;
+		}
 	}
-	if (!entry)
+	if (!found)
 		return ERR_PTR(-EINVAL);
 	return entry->clk;

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

 #define HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP	0x1220
 #define HID_DEVICE_ID_ALPS_U1		0x1215
 #define HID_DEVICE_ID_ALPS_T4_BTNLESS	0x120C
+#define HID_DEVICE_ID_ALPS_1222		0x1222
 #define USB_VENDOR_ID_AMI		0x046b
 #define USB_DEVICE_ID_CHICONY_MULTI_TOUCH	0xb19d
 #define USB_DEVICE_ID_CHICONY_WIRELESS	0x0618
 #define USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE	0x1053
+#define USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE2	0x0939
 #define USB_DEVICE_ID_CHICONY_WIRELESS2	0x1123
 #define USB_DEVICE_ID_ASUS_AK1D		0x1125
 #define USB_DEVICE_ID_CHICONY_TOSHIBA_WT10A	0x1408
 #define USB_VENDOR_ID_HUION		0x256c
 #define USB_DEVICE_ID_HUION_TABLET	0x006e
+#define USB_DEVICE_ID_HUION_HS64	0x006d
 #define USB_VENDOR_ID_IBM					0x04b3
 #define USB_DEVICE_ID_IBM_SCROLLPOINT_III			0x3100

drivers/hid/hid-logitech-dj.c+3−1

 #define REPORT_ID_HIDPP_SHORT			0x10
 #define REPORT_ID_HIDPP_LONG			0x11
+#define REPORT_ID_HIDPP_VERY_LONG		0x12
 #define HIDPP_REPORT_SHORT_LENGTH		7
 #define HIDPP_REPORT_LONG_LENGTH		20
 	int ret;
 	if ((buf[0] == REPORT_ID_HIDPP_SHORT) ||
-	    (buf[0] == REPORT_ID_HIDPP_LONG)) {
+	    (buf[0] == REPORT_ID_HIDPP_LONG) ||
+	    (buf[0] == REPORT_ID_HIDPP_VERY_LONG)) {
 		if (count < 2)
 			return -EINVAL;

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

 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
 			USB_VENDOR_ID_ALPS_JP,
 			HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP) },
+	{ .driver_data = MT_CLS_WIN_8_DUAL,
+		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
+			USB_VENDOR_ID_ALPS_JP,
+			HID_DEVICE_ID_ALPS_1222) },
 	/* Lenovo X1 TAB Gen 2 */
 	{ .driver_data = MT_CLS_WIN_8_DUAL,

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

@@ -42,6 +42,7 @@ static const struct hid_device_id hid_quirks[] = { · 41 unmodified lines
42	{ HID_USB_DEVICE(USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM), HID_QUIRK_NOGET },	42	{ HID_USB_DEVICE(USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM), HID_QUIRK_NOGET },
43	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH), HID_QUIRK_MULTI_INPUT },	43	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH), HID_QUIRK_MULTI_INPUT },
44	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE), HID_QUIRK_ALWAYS_POLL },	44	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE), HID_QUIRK_ALWAYS_POLL },
		45	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE2), HID_QUIRK_ALWAYS_POLL },
45	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS), HID_QUIRK_MULTI_INPUT },	46	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS), HID_QUIRK_MULTI_INPUT },
46	{ HID_USB_DEVICE(USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD), HID_QUIRK_BADPAD },	47	{ HID_USB_DEVICE(USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD), HID_QUIRK_BADPAD },
47	{ HID_USB_DEVICE(USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK), HID_QUIRK_NOGET },	48	{ HID_USB_DEVICE(USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK), HID_QUIRK_NOGET },

drivers/hid/hid-uclogic-core.c+2−0

 				USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HUION,
 				USB_DEVICE_ID_HUION_TABLET) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_HUION,
+				USB_DEVICE_ID_HUION_HS64) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,
 				USB_DEVICE_ID_HUION_TABLET) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC,

drivers/hid/hid-uclogic-params.c+2−0

 		/* FALL THROUGH */
 	case VID_PID(USB_VENDOR_ID_HUION,
 		     USB_DEVICE_ID_HUION_TABLET):
+	case VID_PID(USB_VENDOR_ID_HUION,
+		     USB_DEVICE_ID_HUION_HS64):
 	case VID_PID(USB_VENDOR_ID_UCLOGIC,
 		     USB_DEVICE_ID_HUION_TABLET):
 	case VID_PID(USB_VENDOR_ID_UCLOGIC,

drivers/hid/intel-ish-hid/ishtp-fw-loader.c+1−1

 		goto end_err_fw_release;
 	release_firmware(fw);
-	kfree(filename);
 	dev_info(cl_data_to_dev(client_data), "ISH firmware %s loaded\n",
 		 filename);
+	kfree(filename);
 	return 0;
 end_err_fw_release:

drivers/hid/intel-ish-hid/ishtp-hid-client.c+2−2

@@ -891,7 +891,7 @@ static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device) · 890 unmodified lines
891	*/	891	*/
892	static int hid_ishtp_cl_suspend(struct device *device)	892	static int hid_ishtp_cl_suspend(struct device *device)
893	{	893	{
894	struct ishtp_cl_device *cl_device = dev_get_drvdata(device);	894	struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
895	struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);	895	struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
896	struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);	896	struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
897		897
@@ -912,7 +912,7 @@ static int hid_ishtp_cl_suspend(struct device *device) · 14 unmodified lines
912	*/	912	*/
913	static int hid_ishtp_cl_resume(struct device *device)	913	static int hid_ishtp_cl_resume(struct device *device)
914	{	914	{
915	struct ishtp_cl_device *cl_device = dev_get_drvdata(device);	915	struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
916	struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);	916	struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
917	struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);	917	struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
918		918

drivers/hid/intel-ish-hid/ishtp/bus.c+14−1

@@ -471,7 +471,6 @@ static struct ishtp_cl_device ishtp_bus_add_device(struct ishtp_device dev, · 470 unmodified lines
471	}	471	}
472		472
473	ishtp_device_ready = true;	473	ishtp_device_ready = true;
474	dev_set_drvdata(&device->dev, device);
475		474
476	return device;	475	return device;
477	}	476	}
@@ -639,6 +638,20 @@ void ishtp_get_drvdata(struct ishtp_cl_device cl_device) · 161 unmodified lines
639	}	638	}
640	EXPORT_SYMBOL(ishtp_get_drvdata);	639	EXPORT_SYMBOL(ishtp_get_drvdata);
641		640
		641	/**
		642	* ishtp_dev_to_cl_device() - get ishtp_cl_device instance from device instance
		643	* @device: device instance
		644	*
		645	* Get ish_cl_device instance which embeds device instance in it.
		646	*
		647	* Return: pointer to ishtp_cl_device instance
		648	*/
		649	struct ishtp_cl_device ishtp_dev_to_cl_device(struct device device)
		650	{
		651	return to_ishtp_cl_device(device);
		652	}
		653	EXPORT_SYMBOL(ishtp_dev_to_cl_device);
		654
642	/**	655	/**
643	* ishtp_bus_new_client() - Create a new client	656	* ishtp_bus_new_client() - Create a new client
644	* @dev: ISHTP device instance	657	* @dev: ISHTP device instance

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

 		}
 	}
-	spin_lock(&iommu->lock);
 	spin_lock_irqsave(&device_domain_lock, flags);
 	if (dev)
 		found = find_domain(dev);
 	if (found) {
 		spin_unlock_irqrestore(&device_domain_lock, flags);
-		spin_unlock(&iommu->lock);
 		free_devinfo_mem(info);
 		/* Caller must free the original domain */
 		return found;
 	}
+	spin_lock(&iommu->lock);
 	ret = domain_attach_iommu(domain, iommu);
+	spin_unlock(&iommu->lock);
 	if (ret) {
 		spin_unlock_irqrestore(&device_domain_lock, flags);
-		spin_unlock(&iommu->lock);
 		free_devinfo_mem(info);
 		return NULL;
 	}
 	if (dev)
 		dev->archdata.iommu = info;
 	spin_unlock_irqrestore(&device_domain_lock, flags);
-	spin_unlock(&iommu->lock);
 	/* PASID table is mandatory for a PCI device in scalable mode. */
 	if (dev && dev_is_pci(dev) && sm_supported(iommu)) {

drivers/md/dm-init.c+5−5

@@ -140,8 +140,8 @@ static char __init dm_parse_table_entry(struct dm_device dev, char *str) · 139 unmodified lines
140	return ERR_PTR(-EINVAL);	140	return ERR_PTR(-EINVAL);
141	}	141	}
142	/* target_args */	142	/* target_args */
143	dev->target_args_array[n] = kstrndup(field[3], GFP_KERNEL,	143	dev->target_args_array[n] = kstrndup(field[3], DM_MAX_STR_SIZE,
144	DM_MAX_STR_SIZE);	144	GFP_KERNEL);
145	if (!dev->target_args_array[n])	145	if (!dev->target_args_array[n])
146	return ERR_PTR(-ENOMEM);	146	return ERR_PTR(-ENOMEM);
147		147
@@ -272,10 +272,10 @@ static int __init dm_init_init(void) · 124 unmodified lines
272	return 0;	272	return 0;
273		273
274	if (strlen(create) >= DM_MAX_STR_SIZE) {	274	if (strlen(create) >= DM_MAX_STR_SIZE) {
275	DMERR("Argument is too big. Limit is %d\n", DM_MAX_STR_SIZE);	275	DMERR("Argument is too big. Limit is %d", DM_MAX_STR_SIZE);
276	return -EINVAL;	276	return -EINVAL;
277	}	277	}
278	str = kstrndup(create, GFP_KERNEL, DM_MAX_STR_SIZE);	278	str = kstrndup(create, DM_MAX_STR_SIZE, GFP_KERNEL);
279	if (!str)	279	if (!str)
280	return -ENOMEM;	280	return -ENOMEM;
281		281
@@ -283,7 +283,7 @@ static int __init dm_init_init(void) · 1 unmodified line
283	if (r)	283	if (r)
284	goto out;	284	goto out;
285		285
286	DMINFO("waiting for all devices to be available before creating mapped devices\n");	286	DMINFO("waiting for all devices to be available before creating mapped devices");
287	wait_for_device_probe();	287	wait_for_device_probe();
288		288
289	list_for_each_entry(dev, &devices, list) {	289	list_for_each_entry(dev, &devices, list) {

drivers/md/dm-log-writes.c+21−2

 #define WRITE_LOG_VERSION 1ULL
 #define WRITE_LOG_MAGIC 0x6a736677736872ULL
+#define WRITE_LOG_SUPER_SECTOR 0
 /*
  * The disk format for this is braindead simple.
 	struct list_head logging_blocks;
 	wait_queue_head_t wait;
 	struct task_struct *log_kthread;
+	struct completion super_done;
 };
 struct pending_block {
 	bio_put(bio);
 }
+static void log_end_super(struct bio *bio)
+{
+	struct log_writes_c *lc = bio->bi_private;
+	complete(&lc->super_done);
+	log_end_io(bio);
+}
 /*
  * Meant to be called if there is an error, it will free all the pages
  * associated with the block.
 	bio->bi_iter.bi_size = 0;
 	bio->bi_iter.bi_sector = sector;
 	bio_set_dev(bio, lc->logdev->bdev);
-	bio->bi_end_io = log_end_io;
+	bio->bi_end_io = (sector == WRITE_LOG_SUPER_SECTOR) ?
+			  log_end_super : log_end_io;
 	bio->bi_private = lc;
 	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
 	super.nr_entries = cpu_to_le64(lc->logged_entries);
 	super.sectorsize = cpu_to_le32(lc->sectorsize);
-	if (write_metadata(lc, &super, sizeof(super), NULL, 0, 0)) {
+	if (write_metadata(lc, &super, sizeof(super), NULL, 0,
+			   WRITE_LOG_SUPER_SECTOR)) {
 		DMERR("Couldn't write super");
 		return -1;
 	}
+	/*
+	 * Super sector should be writen in-order, otherwise the
+	 * nr_entries could be rewritten incorrectly by an old bio.
+	 */
+	wait_for_completion_io(&lc->super_done);
 	return 0;
 }
 	INIT_LIST_HEAD(&lc->unflushed_blocks);
 	INIT_LIST_HEAD(&lc->logging_blocks);
 	init_waitqueue_head(&lc->wait);
+	init_completion(&lc->super_done);
 	atomic_set(&lc->io_blocks, 0);
 	atomic_set(&lc->pending_blocks, 0);

drivers/md/dm-table.c+1−1

@@ -561,7 +561,7 @@ static char *realloc_argv(unsigned size, char **old_argv) · 560 unmodified lines
561	gfp = GFP_NOIO;	561	gfp = GFP_NOIO;
562	}	562	}
563	argv = kmalloc_array(new_size, sizeof(*argv), gfp);	563	argv = kmalloc_array(new_size, sizeof(*argv), gfp);
564	if (argv) {	564	if (argv && old_argv) {
565	memcpy(argv, old_argv, size sizeof(*argv));	565	memcpy(argv, old_argv, size sizeof(*argv));
566	*size = new_size;	566	*size = new_size;
567	}	567	}

drivers/md/dm-verity-target.c+2−2

@@ -235,8 +235,8 @@ static int verity_handle_err(struct dm_verity *v, enum verity_block_type type, · 234 unmodified lines
235	BUG();	235	BUG();
236	}	236	}
237		237
238	DMERR("%s: %s block %llu is corrupted", v->data_dev->name, type_str,	238	DMERR_LIMIT("%s: %s block %llu is corrupted", v->data_dev->name,
239	block);	239	type_str, block);
240		240
241	if (v->corrupted_errs == DM_VERITY_MAX_CORRUPTED_ERRS)	241	if (v->corrupted_errs == DM_VERITY_MAX_CORRUPTED_ERRS)
242	DMERR("%s: reached maximum errors", v->data_dev->name);	242	DMERR("%s: reached maximum errors", v->data_dev->name);

drivers/mfd/stmfx.c+6−6

 static irqreturn_t stmfx_irq_handler(int irq, void *data)
 {
 	struct stmfx *stmfx = data;
-	unsigned long n, pending;
+	unsigned long bits;
-	u32 ack;
+	u32 pending, ack;
-	int ret;
+	int n, ret;
-	ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING,
+	ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
-			  (u32 *)&pending);
 	if (ret)
 		return IRQ_NONE;
 			return IRQ_NONE;
 	}
-	for_each_set_bit(n, &pending, STMFX_REG_IRQ_SRC_MAX)
+	bits = pending;
+	for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
 		handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));
 	return IRQ_HANDLED;

drivers/mtd/nand/raw/nand_base.c+2−1

 	memorg = nanddev_get_memorg(&chip->base);
 	memorg->planes_per_lun = 1;
 	memorg->luns_per_target = 1;
-	memorg->ntargets = 1;
 	/*
 	 * Reset the chip, required by some chips (e.g. Micron MT29FxGxxxxx)
 	if (ret)
 		return ret;
+	memorg->ntargets = maxchips;
 	/* Read the flash type */
 	ret = nand_detect(chip, table);
 	if (ret) {

drivers/mtd/spi-nor/spi-nor.c+108−11

@@ -1636,6 +1636,95 @@ static int sr2_bit7_quad_enable(struct spi_nor *nor) · 1635 unmodified lines
1636	return 0;	1636	return 0;
1637	}	1637	}
1638		1638
		1639	/**
		1640	* spi_nor_clear_sr_bp() - clear the Status Register Block Protection bits.
		1641	* @nor: pointer to a 'struct spi_nor'
		1642	*
		1643	* Read-modify-write function that clears the Block Protection bits from the
		1644	* Status Register without affecting other bits.
		1645	*
		1646	* Return: 0 on success, -errno otherwise.
		1647	*/
		1648	static int spi_nor_clear_sr_bp(struct spi_nor *nor)
		1649	{
		1650	int ret;
		1651	u8 mask = SR_BP2 \| SR_BP1 \| SR_BP0;
		1652
		1653	ret = read_sr(nor);
		1654	if (ret < 0) {
		1655	dev_err(nor->dev, "error while reading status register\n");
		1656	return ret;
		1657	}
		1658
		1659	write_enable(nor);
		1660
		1661	ret = write_sr(nor, ret & ~mask);
		1662	if (ret) {
		1663	dev_err(nor->dev, "write to status register failed\n");
		1664	return ret;
		1665	}
		1666
		1667	ret = spi_nor_wait_till_ready(nor);
		1668	if (ret)
		1669	dev_err(nor->dev, "timeout while writing status register\n");
		1670	return ret;
		1671	}
		1672
		1673	/**
		1674	* spi_nor_spansion_clear_sr_bp() - clear the Status Register Block Protection
		1675	* bits on spansion flashes.
		1676	* @nor: pointer to a 'struct spi_nor'
		1677	*
		1678	* Read-modify-write function that clears the Block Protection bits from the
		1679	* Status Register without affecting other bits. The function is tightly
		1680	* coupled with the spansion_quad_enable() function. Both assume that the Write
		1681	* Register with 16 bits, together with the Read Configuration Register (35h)
		1682	* instructions are supported.
		1683	*
		1684	* Return: 0 on success, -errno otherwise.
		1685	*/
		1686	static int spi_nor_spansion_clear_sr_bp(struct spi_nor *nor)
		1687	{
		1688	int ret;
		1689	u8 mask = SR_BP2 \| SR_BP1 \| SR_BP0;
		1690	u8 sr_cr[2] = {0};
		1691
		1692	/* Check current Quad Enable bit value. */
		1693	ret = read_cr(nor);
		1694	if (ret < 0) {
		1695	dev_err(nor->dev,
		1696	"error while reading configuration register\n");
		1697	return ret;
		1698	}
		1699
		1700	/*
		1701	* When the configuration register Quad Enable bit is one, only the
		1702	* Write Status (01h) command with two data bytes may be used.
		1703	*/
		1704	if (ret & CR_QUAD_EN_SPAN) {
		1705	sr_cr[1] = ret;
		1706
		1707	ret = read_sr(nor);
		1708	if (ret < 0) {
		1709	dev_err(nor->dev,
		1710	"error while reading status register\n");
		1711	return ret;
		1712	}
		1713	sr_cr[0] = ret & ~mask;
		1714
		1715	ret = write_sr_cr(nor, sr_cr);
		1716	if (ret)
		1717	dev_err(nor->dev, "16-bit write register failed\n");
		1718	return ret;
		1719	}
		1720
		1721	/*
		1722	* If the Quad Enable bit is zero, use the Write Status (01h) command
		1723	* with one data byte.
		1724	*/
		1725	return spi_nor_clear_sr_bp(nor);
		1726	}
		1727
1639	/* Used when the "_ext_id" is two bytes at most */	1728	/* Used when the "_ext_id" is two bytes at most */
1640	#define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \	1729	#define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \
1641	.id = { \	1730	.id = { \
@@ -3660,6 +3749,8 @@ static int spi_nor_init_params(struct spi_nor *nor, · 2018 unmodified lines
3660	default:	3749	default:
3661	/* Kept only for backward compatibility purpose. */	3750	/* Kept only for backward compatibility purpose. */
3662	params->quad_enable = spansion_quad_enable;	3751	params->quad_enable = spansion_quad_enable;
		3752	if (nor->clear_sr_bp)
		3753	nor->clear_sr_bp = spi_nor_spansion_clear_sr_bp;
3663	break;	3754	break;
3664	}	3755	}
3665		3756
@@ -3912,17 +4003,13 @@ static int spi_nor_init(struct spi_nor *nor) · 246 unmodified lines
3912	{	4003	{
3913	int err;	4004	int err;
3914		4005
3915	/*	4006	if (nor->clear_sr_bp) {
3916	* Atmel, SST, Intel/Numonyx, and others serial NOR tend to power up	4007	err = nor->clear_sr_bp(nor);
3917	* with the software protection bits set	4008	if (err) {
3918	*/	4009	dev_err(nor->dev,
3919	if (JEDEC_MFR(nor->info) == SNOR_MFR_ATMEL \|\|	4010	"fail to clear block protection bits\n");
3920	JEDEC_MFR(nor->info) == SNOR_MFR_INTEL \|\|	4011	return err;
3921	JEDEC_MFR(nor->info) == SNOR_MFR_SST \|\|	4012	}
3922	nor->info->flags & SPI_NOR_HAS_LOCK) {
3923	write_enable(nor);
3924	write_sr(nor, 0);
3925	spi_nor_wait_till_ready(nor);
3926	}	4013	}
3927		4014
3928	if (nor->quad_enable) {	4015	if (nor->quad_enable) {
@@ -4047,6 +4134,16 @@ int spi_nor_scan(struct spi_nor nor, const char name, · 118 unmodified lines
4047	if (info->flags & SPI_S3AN)	4134	if (info->flags & SPI_S3AN)
4048	nor->flags \|= SNOR_F_READY_XSR_RDY;	4135	nor->flags \|= SNOR_F_READY_XSR_RDY;
4049		4136
		4137	/*
		4138	* Atmel, SST, Intel/Numonyx, and others serial NOR tend to power up
		4139	* with the software protection bits set.
		4140	*/
		4141	if (JEDEC_MFR(nor->info) == SNOR_MFR_ATMEL \|\|
		4142	JEDEC_MFR(nor->info) == SNOR_MFR_INTEL \|\|
		4143	JEDEC_MFR(nor->info) == SNOR_MFR_SST \|\|
		4144	nor->info->flags & SPI_NOR_HAS_LOCK)
		4145	nor->clear_sr_bp = spi_nor_clear_sr_bp;
		4146
4050	/* Parse the Serial Flash Discoverable Parameters table. */	4147	/* Parse the Serial Flash Discoverable Parameters table. */
4051	ret = spi_nor_init_params(nor, &params);	4148	ret = spi_nor_init_params(nor, &params);
4052	if (ret)	4149	if (ret)

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

 	bond_dev->features |= NETIF_F_NETNS_LOCAL;
 	bond_dev->hw_features = BOND_VLAN_FEATURES |
-				NETIF_F_HW_VLAN_CTAG_TX |
 				NETIF_F_HW_VLAN_CTAG_RX |
 				NETIF_F_HW_VLAN_CTAG_FILTER;
 	bond_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL | NETIF_F_GSO_UDP_L4;
 	bond_dev->features |= bond_dev->hw_features;
+	bond_dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 }
 /* Destroy a bonding device.

drivers/net/dsa/microchip/ksz_common.c+3−3

@@ -433,9 +433,9 @@ int ksz_switch_register(struct ksz_device *dev, · 432 unmodified lines
433	return PTR_ERR(dev->reset_gpio);	433	return PTR_ERR(dev->reset_gpio);
434		434
435	if (dev->reset_gpio) {	435	if (dev->reset_gpio) {
436	gpiod_set_value(dev->reset_gpio, 1);	436	gpiod_set_value_cansleep(dev->reset_gpio, 1);
437	mdelay(10);	437	mdelay(10);
438	gpiod_set_value(dev->reset_gpio, 0);	438	gpiod_set_value_cansleep(dev->reset_gpio, 0);
439	}	439	}
440		440
441	mutex_init(&dev->dev_mutex);	441	mutex_init(&dev->dev_mutex);
@@ -485,7 +485,7 @@ void ksz_switch_remove(struct ksz_device *dev) · 43 unmodified lines
485	dsa_unregister_switch(dev->ds);	485	dsa_unregister_switch(dev->ds);
486		486
487	if (dev->reset_gpio)	487	if (dev->reset_gpio)
488	gpiod_set_value(dev->reset_gpio, 1);	488	gpiod_set_value_cansleep(dev->reset_gpio, 1);
489		489
490	}	490	}
491	EXPORT_SYMBOL(ksz_switch_remove);	491	EXPORT_SYMBOL(ksz_switch_remove);

drivers/net/ethernet/aquantia/atlantic/aq_filters.c+8−2

 		return err;
 	if (aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
-		if (hweight < AQ_VLAN_MAX_FILTERS)
+		if (hweight < AQ_VLAN_MAX_FILTERS && hweight > 0) {
-			err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw, true);
+			err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw,
+				!(aq_nic->packet_filter & IFF_PROMISC));
+			aq_nic->aq_nic_cfg.is_vlan_force_promisc = false;
+		} else {
 		/* otherwise left in promiscue mode */
+			aq_nic->aq_nic_cfg.is_vlan_force_promisc = true;
+		}
 	}
 	return err;
 	if (unlikely(!aq_hw_ops->hw_filter_vlan_ctrl))
 		return -EOPNOTSUPP;
+	aq_nic->aq_nic_cfg.is_vlan_force_promisc = true;
 	err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw, false);
 	if (err)
 		return err;

drivers/net/ethernet/aquantia/atlantic/aq_nic.c+1−0

@@ -128,6 +128,7 @@ void aq_nic_cfg_start(struct aq_nic_s *self) · 127 unmodified lines
128	cfg->features = cfg->aq_hw_caps->hw_features;	128	cfg->features = cfg->aq_hw_caps->hw_features;
129	cfg->is_vlan_rx_strip = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_RX);	129	cfg->is_vlan_rx_strip = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_RX);
130	cfg->is_vlan_tx_insert = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_TX);	130	cfg->is_vlan_tx_insert = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_TX);
		131	cfg->is_vlan_force_promisc = true;
131	}	132	}
132		133
133	static int aq_nic_update_link_status(struct aq_nic_s *self)	134	static int aq_nic_update_link_status(struct aq_nic_s *self)

drivers/net/ethernet/aquantia/atlantic/aq_nic.h+1−0

@@ -37,6 +37,7 @@ struct aq_nic_cfg_s { · 36 unmodified lines
37	u32 wol;	37	u32 wol;
38	u8 is_vlan_rx_strip;	38	u8 is_vlan_rx_strip;
39	u8 is_vlan_tx_insert;	39	u8 is_vlan_tx_insert;
		40	bool is_vlan_force_promisc;
40	u16 is_mc_list_enabled;	41	u16 is_mc_list_enabled;
41	u16 mc_list_count;	42	u16 mc_list_count;
42	bool is_autoneg;	43	bool is_autoneg;

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c+13−6

 					  unsigned int packet_filter)
 {
 	unsigned int i = 0U;
+	struct aq_nic_cfg_s *cfg = self->aq_nic_cfg;
+	hw_atl_rpfl2promiscuous_mode_en_set(self,
+					    IS_FILTER_ENABLED(IFF_PROMISC));
+	hw_atl_rpf_vlan_prom_mode_en_set(self,
+				     IS_FILTER_ENABLED(IFF_PROMISC) ||
+				     cfg->is_vlan_force_promisc);
-	hw_atl_rpfl2promiscuous_mode_en_set(self, IS_FILTER_ENABLED(IFF_PROMISC));
 	hw_atl_rpfl2multicast_flr_en_set(self,
 					 IS_FILTER_ENABLED(IFF_ALLMULTI), 0);
 	hw_atl_rpfl2broadcast_en_set(self, IS_FILTER_ENABLED(IFF_BROADCAST));
-	self->aq_nic_cfg->is_mc_list_enabled = IS_FILTER_ENABLED(IFF_MULTICAST);
+	cfg->is_mc_list_enabled = IS_FILTER_ENABLED(IFF_MULTICAST);
 	for (i = HW_ATL_B0_MAC_MIN; i < HW_ATL_B0_MAC_MAX; ++i)
 		hw_atl_rpfl2_uc_flr_en_set(self,
-					   (self->aq_nic_cfg->is_mc_list_enabled &&
+					   (cfg->is_mc_list_enabled &&
-				    (i <= self->aq_nic_cfg->mc_list_count)) ?
+					    (i <= cfg->mc_list_count)) ?
-				    1U : 0U, i);
+					   1U : 0U, i);
 	return aq_hw_err_from_flags(self);
 }
 static int hw_atl_b0_hw_vlan_ctrl(struct aq_hw_s *self, bool enable)
 {
 	/* set promisc in case of disabing the vland filter */
-	hw_atl_rpf_vlan_prom_mode_en_set(self, !!!enable);
+	hw_atl_rpf_vlan_prom_mode_en_set(self, !enable);
 	return aq_hw_err_from_flags(self);
 }

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

@@ -4303,7 +4303,7 @@ static int macb_probe(struct platform_device *pdev) · 4302 unmodified lines
4303	if (PTR_ERR(mac) == -EPROBE_DEFER) {	4303	if (PTR_ERR(mac) == -EPROBE_DEFER) {
4304	err = -EPROBE_DEFER;	4304	err = -EPROBE_DEFER;
4305	goto err_out_free_netdev;	4305	goto err_out_free_netdev;
4306	} else if (!IS_ERR(mac)) {	4306	} else if (!IS_ERR_OR_NULL(mac)) {
4307	ether_addr_copy(bp->dev->dev_addr, mac);	4307	ether_addr_copy(bp->dev->dev_addr, mac);
4308	} else {	4308	} else {
4309	macb_get_hwaddr(bp);	4309	macb_get_hwaddr(bp);

drivers/net/ethernet/emulex/benet/be_ethtool.c+22−6

 			 u64 *data)
 {
 	struct be_adapter *adapter = netdev_priv(netdev);
-	int status;
+	int status, cnt;
 	u8 link_status = 0;
 	if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) {
 	memset(data, 0, sizeof(u64) * ETHTOOL_TESTS_NUM);
+	/* check link status before offline tests */
+	link_status = netif_carrier_ok(netdev);
 	if (test->flags & ETH_TEST_FL_OFFLINE) {
 		if (be_loopback_test(adapter, BE_MAC_LOOPBACK, &data[0]) != 0)
 			test->flags |= ETH_TEST_FL_FAILED;
 		test->flags |= ETH_TEST_FL_FAILED;
 	}
-	status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
+	/* link status was down prior to test */
-	if (status) {
+	if (!link_status) {
-		test->flags |= ETH_TEST_FL_FAILED;
-		data[4] = -1;
-	} else if (!link_status) {
 		test->flags |= ETH_TEST_FL_FAILED;
 		data[4] = 1;
+		return;
+	}
+	for (cnt = 10; cnt; cnt--) {
+		status = be_cmd_link_status_query(adapter, NULL, &link_status,
+						  0);
+		if (status) {
+			test->flags |= ETH_TEST_FL_FAILED;
+			data[4] = -1;
+			break;
+		}
+		if (link_status)
+			break;
+		msleep_interruptible(500);
 	}
 }

drivers/net/ethernet/sis/sis900.c+8−8

@@ -1057,7 +1057,7 @@ sis900_open(struct net_device *net_dev) · 1056 unmodified lines
1057	sis900_set_mode(sis_priv, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);	1057	sis900_set_mode(sis_priv, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
1058		1058
1059	/* Enable all known interrupts by setting the interrupt mask. */	1059	/* Enable all known interrupts by setting the interrupt mask. */
1060	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE);	1060	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE \| TxDESC);
1061	sw32(cr, RxENA \| sr32(cr));	1061	sw32(cr, RxENA \| sr32(cr));
1062	sw32(ier, IE);	1062	sw32(ier, IE);
1063		1063
@@ -1578,7 +1578,7 @@ static void sis900_tx_timeout(struct net_device *net_dev) · 514 unmodified lines
1578	sw32(txdp, sis_priv->tx_ring_dma);	1578	sw32(txdp, sis_priv->tx_ring_dma);
1579		1579
1580	/* Enable all known interrupts by setting the interrupt mask. */	1580	/* Enable all known interrupts by setting the interrupt mask. */
1581	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE);	1581	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE \| TxDESC);
1582	}	1582	}
1583		1583
1584	/**	1584	/**
@@ -1618,7 +1618,7 @@ sis900_start_xmit(struct sk_buff skb, struct net_device net_dev) · 33 unmodified lines
1618	spin_unlock_irqrestore(&sis_priv->lock, flags);	1618	spin_unlock_irqrestore(&sis_priv->lock, flags);
1619	return NETDEV_TX_OK;	1619	return NETDEV_TX_OK;
1620	}	1620	}
1621	sis_priv->tx_ring[entry].cmdsts = (OWN \| skb->len);	1621	sis_priv->tx_ring[entry].cmdsts = (OWN \| INTR \| skb->len);
1622	sw32(cr, TxENA \| sr32(cr));	1622	sw32(cr, TxENA \| sr32(cr));
1623		1623
1624	sis_priv->cur_tx ++;	1624	sis_priv->cur_tx ++;
@@ -1674,7 +1674,7 @@ static irqreturn_t sis900_interrupt(int irq, void *dev_instance) · 49 unmodified lines
1674	do {	1674	do {
1675	status = sr32(isr);	1675	status = sr32(isr);
1676		1676
1677	if ((status & (HIBERR\|TxURN\|TxERR\|TxIDLE\|RxORN\|RxERR\|RxOK)) == 0)	1677	if ((status & (HIBERR\|TxURN\|TxERR\|TxIDLE\|TxDESC\|RxORN\|RxERR\|RxOK)) == 0)
1678	/* nothing intresting happened */	1678	/* nothing intresting happened */
1679	break;	1679	break;
1680	handled = 1;	1680	handled = 1;
@@ -1684,7 +1684,7 @@ static irqreturn_t sis900_interrupt(int irq, void *dev_instance) · 3 unmodified lines
1684	/* Rx interrupt */	1684	/* Rx interrupt */
1685	sis900_rx(net_dev);	1685	sis900_rx(net_dev);
1686		1686
1687	if (status & (TxURN \| TxERR \| TxIDLE))	1687	if (status & (TxURN \| TxERR \| TxIDLE \| TxDESC))
1688	/* Tx interrupt */	1688	/* Tx interrupt */
1689	sis900_finish_xmit(net_dev);	1689	sis900_finish_xmit(net_dev);
1690		1690
@@ -1896,8 +1896,8 @@ static void sis900_finish_xmit (struct net_device *net_dev) · 205 unmodified lines
1896		1896
1897	if (tx_status & OWN) {	1897	if (tx_status & OWN) {
1898	/* The packet is not transmitted yet (owned by hardware) !	1898	/* The packet is not transmitted yet (owned by hardware) !
1899	* Note: the interrupt is generated only when Tx Machine	1899	* Note: this is an almost impossible condition
1900	* is idle, so this is an almost impossible case */	1900	* in case of TxDESC ('descriptor interrupt') */
1901	break;	1901	break;
1902	}	1902	}
1903		1903
@@ -2473,7 +2473,7 @@ static int sis900_resume(struct pci_dev *pci_dev) · 569 unmodified lines
2473	sis900_set_mode(sis_priv, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);	2473	sis900_set_mode(sis_priv, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
2474		2474
2475	/* Enable all known interrupts by setting the interrupt mask. */	2475	/* Enable all known interrupts by setting the interrupt mask. */
2476	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE);	2476	sw32(imr, RxSOVR \| RxORN \| RxERR \| RxOK \| TxURN \| TxERR \| TxIDLE \| TxDESC);
2477	sw32(cr, RxENA \| sr32(cr));	2477	sw32(cr, RxENA \| sr32(cr));
2478	sw32(ier, IE);	2478	sw32(ier, IE);
2479		2479

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

@@ -112,7 +112,7 @@ static int adjust_systime(void __iomem *ioaddr, u32 sec, u32 nsec, · 111 unmodified lines
112	* programmed with (2^32 – <new_sec_value>)	112	* programmed with (2^32 – <new_sec_value>)
113	*/	113	*/
114	if (gmac4)	114	if (gmac4)
115	sec = (100000000ULL - sec);	115	sec = -sec;
116		116
117	value = readl(ioaddr + PTP_TCR);	117	value = readl(ioaddr + PTP_TCR);
118	if (value & PTP_TCR_TSCTRLSSR)	118	if (value & PTP_TCR_TSCTRLSSR)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+14−8

 	/* Manage tx mitigation */
 	tx_q->tx_count_frames += nfrags + 1;
-	if (priv->tx_coal_frames <= tx_q->tx_count_frames) {
+	if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
+	    !(priv->synopsys_id >= DWMAC_CORE_4_00 &&
+	    (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+	    priv->hwts_tx_en)) {
+		stmmac_tx_timer_arm(priv, queue);
+	} else {
+		tx_q->tx_count_frames = 0;
 		stmmac_set_tx_ic(priv, desc);
 		priv->xstats.tx_set_ic_bit++;
-		tx_q->tx_count_frames = 0;
-	} else {
-		stmmac_tx_timer_arm(priv, queue);
 	}
 	skb_tx_timestamp(skb);
 	 * element in case of no SG.
 	 */
 	tx_q->tx_count_frames += nfrags + 1;
-	if (priv->tx_coal_frames <= tx_q->tx_count_frames) {
+	if (likely(priv->tx_coal_frames > tx_q->tx_count_frames) &&
+	    !(priv->synopsys_id >= DWMAC_CORE_4_00 &&
+	    (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+	    priv->hwts_tx_en)) {
+		stmmac_tx_timer_arm(priv, queue);
+	} else {
+		tx_q->tx_count_frames = 0;
 		stmmac_set_tx_ic(priv, desc);
 		priv->xstats.tx_set_ic_bit++;
-		tx_q->tx_count_frames = 0;
-	} else {
-		stmmac_tx_timer_arm(priv, queue);
 	}
 	skb_tx_timestamp(skb);

drivers/net/ppp/ppp_mppe.c+1−0

@@ -63,6 +63,7 @@ MODULE_AUTHOR("Frank Cusack <fcusack@fcusack.com>"); · 62 unmodified lines
63	MODULE_DESCRIPTION("Point-to-Point Protocol Microsoft Point-to-Point Encryption support");	63	MODULE_DESCRIPTION("Point-to-Point Protocol Microsoft Point-to-Point Encryption support");
64	MODULE_LICENSE("Dual BSD/GPL");	64	MODULE_LICENSE("Dual BSD/GPL");
65	MODULE_ALIAS("ppp-compress-" __stringify(CI_MPPE));	65	MODULE_ALIAS("ppp-compress-" __stringify(CI_MPPE));
		66	MODULE_SOFTDEP("pre: arc4");
66	MODULE_VERSION("1.0.2");	67	MODULE_VERSION("1.0.2");
67		68
68	static unsigned int	69	static unsigned int

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

 	dev->features |= NETIF_F_NETNS_LOCAL;
 	dev->hw_features = TEAM_VLAN_FEATURES |
-			   NETIF_F_HW_VLAN_CTAG_TX |
 			   NETIF_F_HW_VLAN_CTAG_RX |
 			   NETIF_F_HW_VLAN_CTAG_FILTER;
 	dev->hw_features |= NETIF_F_GSO_ENCAP_ALL | NETIF_F_GSO_UDP_L4;
 	dev->features |= dev->hw_features;
+	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 }
 static int team_newlink(struct net *src_net, struct net_device *dev,

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

@@ -1482,7 +1482,7 @@ static int qmi_wwan_probe(struct usb_interface *intf, · 1481 unmodified lines
1482	* different. Ignore the current interface if the number of endpoints	1482	* different. Ignore the current interface if the number of endpoints
1483	* equals the number for the diag interface (two).	1483	* equals the number for the diag interface (two).
1484	*/	1484	*/
1485	info = (void *)&id->driver_info;	1485	info = (void *)id->driver_info;
1486		1486
1487	if (info->data & QMI_WWAN_QUIRK_QUECTEL_DYNCFG) {	1487	if (info->data & QMI_WWAN_QUIRK_QUECTEL_DYNCFG) {
1488	if (desc->bNumEndpoints == 2)	1488	if (desc->bNumEndpoints == 2)

drivers/net/vrf.c+1−1

 {
 	struct dst_entry *dst = skb_dst(skb);
 	struct net_device *dev = dst->dev;
+	const struct in6_addr *nexthop;
 	struct neighbour *neigh;
-	struct in6_addr *nexthop;
 	int ret;
 	nf_reset(skb);

drivers/pci/p2pdma.c+4−0

 #include <linux/percpu-refcount.h>
 #include <linux/random.h>
 #include <linux/seq_buf.h>
+#include <linux/iommu.h>
 struct pci_p2pdma {
 	struct gen_pool *pool;
 	struct pci_dev *root = pci_get_slot(host->bus, PCI_DEVFN(0, 0));
 	unsigned short vendor, device;
+	if (iommu_present(dev->dev.bus))
+		return false;
 	if (!root)
 		return false;

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

@@ -987,6 +987,9 @@ static int qedi_find_boot_info(struct qedi_ctx *qedi, · 986 unmodified lines
987	if (!iscsi_is_session_online(cls_sess))	987	if (!iscsi_is_session_online(cls_sess))
988	continue;	988	continue;
989		989
		990	if (!sess->targetname)
		991	continue;
		992
990	if (pri_ctrl_flags) {	993	if (pri_ctrl_flags) {
991	if (!strcmp(pri_tgt->iscsi_name, sess->targetname) &&	994	if (!strcmp(pri_tgt->iscsi_name, sess->targetname) &&
992	!strcmp(pri_tgt->ip_addr, ep_ip_addr)) {	995	!strcmp(pri_tgt->ip_addr, ep_ip_addr)) {

drivers/scsi/qedi/qedi_version.h+3−3

@@ -4,8 +4,8 @@ · 3 unmodified lines
4	* Copyright (c) 2016 Cavium Inc.	4	* Copyright (c) 2016 Cavium Inc.
5	*/	5	*/
6		6
7	#define QEDI_MODULE_VERSION "8.33.0.21"	7	#define QEDI_MODULE_VERSION "8.37.0.20"
8	#define QEDI_DRIVER_MAJOR_VER 8	8	#define QEDI_DRIVER_MAJOR_VER 8
9	#define QEDI_DRIVER_MINOR_VER 33	9	#define QEDI_DRIVER_MINOR_VER 37
10	#define QEDI_DRIVER_REV_VER 0	10	#define QEDI_DRIVER_REV_VER 0
11	#define QEDI_DRIVER_ENG_VER 21	11	#define QEDI_DRIVER_ENG_VER 20

drivers/scsi/qla2xxx/qla_os.c+1−1

 	     !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
 	     !qla2x00_isp_reg_stat(ha))) {
 		sp->comp = &comp;
-		rval = ha->isp_ops->abort_command(sp);
 		spin_unlock_irqrestore(qp->qp_lock_ptr, *flags);
+		rval = ha->isp_ops->abort_command(sp);
 		switch (rval) {
 		case QLA_SUCCESS:

drivers/scsi/ufs/ufshcd-pltfrm.c+4−7

 		goto dealloc_host;
 	}
-	pm_runtime_set_active(&pdev->dev);
-	pm_runtime_enable(&pdev->dev);
 	ufshcd_init_lanes_per_dir(hba);
 	err = ufshcd_init(hba, mmio_base, irq);
 	if (err) {
 		dev_err(dev, "Initialization failed\n");
-		goto out_disable_rpm;
+		goto dealloc_host;
 	}
 	platform_set_drvdata(pdev, hba);
+	pm_runtime_set_active(&pdev->dev);
+	pm_runtime_enable(&pdev->dev);
 	return 0;
-out_disable_rpm:
-	pm_runtime_disable(&pdev->dev);
-	pm_runtime_set_suspended(&pdev->dev);
 dealloc_host:
 	ufshcd_dealloc_host(hba);
 out:

fs/afs/callback.c+2−2

@@ -275,9 +275,9 @@ static void afs_break_one_callback(struct afs_server *server, · 274 unmodified lines
275	struct afs_super_info *as = AFS_FS_S(cbi->sb);	275	struct afs_super_info *as = AFS_FS_S(cbi->sb);
276	struct afs_volume *volume = as->volume;	276	struct afs_volume *volume = as->volume;
277		277
278	write_lock(&volume->cb_break_lock);	278	write_lock(&volume->cb_v_break_lock);
279	volume->cb_v_break++;	279	volume->cb_v_break++;
280	write_unlock(&volume->cb_break_lock);	280	write_unlock(&volume->cb_v_break_lock);
281	} else {	281	} else {
282	data.volume = NULL;	282	data.volume = NULL;
283	data.fid = *fid;	283	data.fid = *fid;

fs/afs/inode.c+19−12

 		dump_stack();
 }
+/*
+ * Set the file size and block count.  Estimate the number of 512 bytes blocks
+ * used, rounded up to nearest 1K for consistency with other AFS clients.
+ */
+static void afs_set_i_size(struct afs_vnode *vnode, u64 size)
+{
+	i_size_write(&vnode->vfs_inode, size);
+	vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
+}
 /*
  * Initialise an inode from the vnode status.
  */
 		return afs_protocol_error(NULL, -EBADMSG, afs_eproto_file_type);
 	}
-	/*
+	afs_set_i_size(vnode, status->size);
-	 * Estimate 512 bytes  blocks used, rounded up to nearest 1K
-	 * for consistency with other AFS clients.
-	 */
-	inode->i_blocks		= ((i_size_read(inode) + 1023) >> 10) << 1;
-	i_size_write(&vnode->vfs_inode, status->size);
 	vnode->invalid_before	= status->data_version;
 	inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
 	if (expected_version &&
 	    *expected_version != status->data_version) {
-		kdebug("vnode modified %llx on {%llx:%llu} [exp %llx] %s",
+		if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags))
-		       (unsigned long long) status->data_version,
+			pr_warn("kAFS: vnode modified {%llx:%llu} %llx->%llx %s\n",
-		       vnode->fid.vid, vnode->fid.vnode,
+				vnode->fid.vid, vnode->fid.vnode,
-		       (unsigned long long) *expected_version,
+				(unsigned long long)*expected_version,
-		       fc->type ? fc->type->name : "???");
+				(unsigned long long)status->data_version,
+				fc->type ? fc->type->name : "???");
 		vnode->invalid_before = status->data_version;
 		if (vnode->status.type == AFS_FTYPE_DIR) {
 			if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
 	if (data_changed) {
 		inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
-		i_size_write(&vnode->vfs_inode, status->size);
+		afs_set_i_size(vnode, status->size);
 	}
 }

fs/afs/internal.h+3−5

 	struct rxrpc_call	*rxcall;	/* RxRPC call handle */
 	struct key		*key;		/* security for this call */
 	struct afs_net		*net;		/* The network namespace */
-	union {
+	struct afs_server	*server;	/* The fileserver record if fs op (pins ref) */
-		struct afs_server	*server;
+	struct afs_vlserver	*vlserver;	/* The vlserver record if vl op */
-		struct afs_vlserver	*vlserver;
-	};
 	struct afs_cb_interest	*cbi;		/* Callback interest for server used */
 	struct afs_vnode	*lvnode;	/* vnode being locked */
 	void			*request;	/* request data (first part) */
 	unsigned int		servers_seq;	/* Incremented each time ->servers changes */
 	unsigned		cb_v_break;	/* Break-everything counter. */
-	rwlock_t		cb_break_lock;
+	rwlock_t		cb_v_break_lock;
 	afs_voltype_t		type;		/* type of volume */
 	short			error;

fs/afs/volume.c+1−0

@@ -43,6 +43,7 @@ static struct afs_volume afs_alloc_volume(struct afs_fs_context params, · 42 unmodified lines
43	atomic_set(&volume->usage, 1);	43	atomic_set(&volume->usage, 1);
44	INIT_LIST_HEAD(&volume->proc_link);	44	INIT_LIST_HEAD(&volume->proc_link);
45	rwlock_init(&volume->servers_lock);	45	rwlock_init(&volume->servers_lock);
		46	rwlock_init(&volume->cb_v_break_lock);
46	memcpy(volume->name, vldb->name, vldb->name_len + 1);	47	memcpy(volume->name, vldb->name, vldb->name_len + 1);
47		48
48	slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask);	49	slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask);

fs/proc/base.c+1−2

@@ -3077,8 +3077,7 @@ static const struct file_operations proc_tgid_base_operations = { · 3076 unmodified lines
3077		3077
3078	struct pid tgid_pidfd_to_pid(const struct file file)	3078	struct pid tgid_pidfd_to_pid(const struct file file)
3079	{	3079	{
3080	if (!d_is_dir(file->f_path.dentry) \|\|	3080	if (file->f_op != &proc_tgid_base_operations)
3081	(file->f_op != &proc_tgid_base_operations))
3082	return ERR_PTR(-EBADF);	3081	return ERR_PTR(-EBADF);
3083		3082
3084	return proc_pid(file_inode(file));	3083	return proc_pid(file_inode(file));

include/dt-bindings/clock/g12a-clkc.h+1−1

@@ -130,7 +130,7 @@ · 129 unmodified lines
130	#define CLKID_MALI_1_SEL 172	130	#define CLKID_MALI_1_SEL 172
131	#define CLKID_MALI_1 174	131	#define CLKID_MALI_1 174
132	#define CLKID_MALI 175	132	#define CLKID_MALI 175
133	#define CLKID_MPLL_5OM 177	133	#define CLKID_MPLL_50M 177
134	#define CLKID_CPU_CLK 187	134	#define CLKID_CPU_CLK 187
135	#define CLKID_PCIE_PLL 201	135	#define CLKID_PCIE_PLL 201
136	#define CLKID_VDEC_1 204	136	#define CLKID_VDEC_1 204

include/linux/intel-ish-client-if.h+1−0

@@ -103,6 +103,7 @@ void ishtp_put_device(struct ishtp_cl_device *cl_dev); · 102 unmodified lines
103	void ishtp_get_device(struct ishtp_cl_device *cl_dev);	103	void ishtp_get_device(struct ishtp_cl_device *cl_dev);
104	void ishtp_set_drvdata(struct ishtp_cl_device cl_device, void data);	104	void ishtp_set_drvdata(struct ishtp_cl_device cl_device, void data);
105	void ishtp_get_drvdata(struct ishtp_cl_device cl_device);	105	void ishtp_get_drvdata(struct ishtp_cl_device cl_device);
		106	struct ishtp_cl_device ishtp_dev_to_cl_device(struct device dev);
106	int ishtp_register_event_cb(struct ishtp_cl_device *device,	107	int ishtp_register_event_cb(struct ishtp_cl_device *device,
107	void (read_cb)(struct ishtp_cl_device ));	108	void (read_cb)(struct ishtp_cl_device ));
108	struct ishtp_fw_client ishtp_fw_cl_get_client(struct ishtp_device dev,	109	struct ishtp_fw_client ishtp_fw_cl_get_client(struct ishtp_device dev,

include/linux/mtd/spi-nor.h+3−0

  * @flash_unlock:	[FLASH-SPECIFIC] unlock a region of the SPI NOR
  * @flash_is_locked:	[FLASH-SPECIFIC] check if a region of the SPI NOR is
  * @quad_enable:	[FLASH-SPECIFIC] enables SPI NOR quad mode
+ * @clear_sr_bp:	[FLASH-SPECIFIC] clears the Block Protection Bits from
+ *			the SPI NOR Status Register.
  *			completely locked
  * @priv:		the private data
  */
 	int (*flash_unlock)(struct spi_nor *nor, loff_t ofs, uint64_t len);
 	int (*flash_is_locked)(struct spi_nor *nor, loff_t ofs, uint64_t len);
 	int (*quad_enable)(struct spi_nor *nor);
+	int (*clear_sr_bp)(struct spi_nor *nor);
 	void *priv;
 };

include/net/ip6_route.h+2−2

@@ -281,8 +281,8 @@ static inline bool ip6_sk_ignore_df(const struct sock *sk) · 280 unmodified lines
281	inet6_sk(sk)->pmtudisc == IPV6_PMTUDISC_OMIT;	281	inet6_sk(sk)->pmtudisc == IPV6_PMTUDISC_OMIT;
282	}	282	}
283		283
284	static inline struct in6_addr rt6_nexthop(struct rt6_info rt,	284	static inline const struct in6_addr rt6_nexthop(const struct rt6_info rt,
285	struct in6_addr *daddr)	285	const struct in6_addr *daddr)
286	{	286	{
287	if (rt->rt6i_flags & RTF_GATEWAY)	287	if (rt->rt6i_flags & RTF_GATEWAY)
288	return &rt->rt6i_gateway;	288	return &rt->rt6i_gateway;

include/net/route.h+1−0

@@ -221,6 +221,7 @@ void ip_rt_get_source(u8 src, struct sk_buff skb, struct rtable *rt); · 220 unmodified lines
221	struct rtable rt_dst_alloc(struct net_device dev,	221	struct rtable rt_dst_alloc(struct net_device dev,
222	unsigned int flags, u16 type,	222	unsigned int flags, u16 type,
223	bool nopolicy, bool noxfrm, bool will_cache);	223	bool nopolicy, bool noxfrm, bool will_cache);
		224	struct rtable rt_dst_clone(struct net_device dev, struct rtable *rt);
224		225
225	struct in_ifaddr;	226	struct in_ifaddr;
226	void fib_add_ifaddr(struct in_ifaddr *);	227	void fib_add_ifaddr(struct in_ifaddr *);

include/net/tls.h+0−15

@@ -407,21 +407,6 @@ static inline bool tls_is_partially_sent_record(struct tls_context *ctx) · 406 unmodified lines
407	return !!ctx->partially_sent_record;	407	return !!ctx->partially_sent_record;
408	}	408	}
409		409
410	static inline int tls_complete_pending_work(struct sock *sk,
411	struct tls_context *ctx,
412	int flags, long *timeo)
413	{
414	int rc = 0;
415
416	if (unlikely(sk->sk_write_pending))
417	rc = wait_on_pending_writer(sk, timeo);
418
419	if (!rc && tls_is_partially_sent_record(ctx))
420	rc = tls_push_partial_record(sk, ctx, flags);
421
422	return rc;
423	}
424
425	static inline bool tls_is_pending_open_record(struct tls_context *tls_ctx)	410	static inline bool tls_is_pending_open_record(struct tls_context *tls_ctx)
426	{	411	{
427	return tls_ctx->pending_open_record_frags;	412	return tls_ctx->pending_open_record_frags;

kernel/fork.c+18−40

 #endif
 };
-/**
- * pidfd_create() - Create a new pid file descriptor.
- *
- * @pid:  struct pid that the pidfd will reference
- *
- * This creates a new pid file descriptor with the O_CLOEXEC flag set.
- *
- * Note, that this function can only be called after the fd table has
- * been unshared to avoid leaking the pidfd to the new process.
- *
- * Return: On success, a cloexec pidfd is returned.
- *         On error, a negative errno number will be returned.
- */
-static int pidfd_create(struct pid *pid)
-{
-	int fd;
-	fd = anon_inode_getfd("[pidfd]", &pidfd_fops, get_pid(pid),
-			      O_RDWR | O_CLOEXEC);
-	if (fd < 0)
-		put_pid(pid);
-	return fd;
-}
 static void __delayed_free_task(struct rcu_head *rhp)
 {
 	struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);
 	int pidfd = -1, retval;
 	struct task_struct *p;
 	struct multiprocess_signals delayed;
+	struct file *pidfile = NULL;
 	/*
 	 * Don't allow sharing the root directory with processes in a different
 	}
 	if (clone_flags & CLONE_PIDFD) {
-		int reserved;
 		/*
 		 * - CLONE_PARENT_SETTID is useless for pidfds and also
 		 *   parent_tidptr is used to return pidfds.
 		if (clone_flags &
 		    (CLONE_DETACHED | CLONE_PARENT_SETTID | CLONE_THREAD))
 			return ERR_PTR(-EINVAL);
-		/*
-		 * Verify that parent_tidptr is sane so we can potentially
-		 * reuse it later.
-		 */
-		if (get_user(reserved, parent_tidptr))
-			return ERR_PTR(-EFAULT);
-		if (reserved != 0)
-			return ERR_PTR(-EINVAL);
 	}
 	/*
 	 * if the fd table isn't shared).
 	 */
 	if (clone_flags & CLONE_PIDFD) {
-		retval = pidfd_create(pid);
+		retval = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
 		if (retval < 0)
 			goto bad_fork_free_pid;
 		pidfd = retval;
+		pidfile = anon_inode_getfile("[pidfd]", &pidfd_fops, pid,
+					      O_RDWR | O_CLOEXEC);
+		if (IS_ERR(pidfile)) {
+			put_unused_fd(pidfd);
+			goto bad_fork_free_pid;
+		}
+		get_pid(pid);	/* held by pidfile now */
 		retval = put_user(pidfd, parent_tidptr);
 		if (retval)
 			goto bad_fork_put_pidfd;
 		goto bad_fork_cancel_cgroup;
 	}
+	/* past the last point of failure */
+	if (pidfile)
+		fd_install(pidfd, pidfile);
 	init_task_pid_links(p);
 	if (likely(p->pid)) {
 bad_fork_cgroup_threadgroup_change_end:
 	cgroup_threadgroup_change_end(current);
 bad_fork_put_pidfd:
-	if (clone_flags & CLONE_PIDFD)
+	if (clone_flags & CLONE_PIDFD) {
-		ksys_close(pidfd);
+		fput(pidfile);
+		put_unused_fd(pidfd);
+	}
 bad_fork_free_pid:
 	if (pid != &init_struct_pid)
 		free_pid(pid);

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

 						  struct in6_addr *daddr,
 						  struct sk_buff *skb)
 {
-	struct lowpan_peer *peer;
-	struct in6_addr *nexthop;
 	struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
 	int count = atomic_read(&dev->peer_count);
+	const struct in6_addr *nexthop;
+	struct lowpan_peer *peer;
 	BT_DBG("peers %d addr %pI6c rt %p", count, daddr, rt);

net/bluetooth/hci_conn.c+9−9

 	    !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
 		return 0;
-	/* The minimum encryption key size needs to be enforced by the
-	 * host stack before establishing any L2CAP connections. The
-	 * specification in theory allows a minimum of 1, but to align
-	 * BR/EDR and LE transports, a minimum of 7 is chosen.
-	 */
-	if (conn->enc_key_size < HCI_MIN_ENC_KEY_SIZE)
-		return 0;
 	return 1;
 }
 		return 0;
 encrypt:
-	if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
+	if (test_bit(HCI_CONN_ENCRYPT, &conn->flags)) {
+		/* Ensure that the encryption key size has been read,
+		 * otherwise stall the upper layer responses.
+		 */
+		if (!conn->enc_key_size)
+			return 0;
+		/* Nothing else needed, all requirements are met */
 		return 1;
+	}
 	hci_conn_encrypt(conn);
 	return 0;

net/bluetooth/l2cap_core.c+28−5

 		       sizeof(req), &req);
 }
+static bool l2cap_check_enc_key_size(struct hci_conn *hcon)
+{
+	/* The minimum encryption key size needs to be enforced by the
+	 * host stack before establishing any L2CAP connections. The
+	 * specification in theory allows a minimum of 1, but to align
+	 * BR/EDR and LE transports, a minimum of 7 is chosen.
+	 *
+	 * This check might also be called for unencrypted connections
+	 * that have no key size requirements. Ensure that the link is
+	 * actually encrypted before enforcing a key size.
+	 */
+	return (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags) ||
+		hcon->enc_key_size > HCI_MIN_ENC_KEY_SIZE);
+}
 static void l2cap_do_start(struct l2cap_chan *chan)
 {
 	struct l2cap_conn *conn = chan->conn;
 	if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
 		return;
-	if (l2cap_chan_check_security(chan, true) &&
+	if (!l2cap_chan_check_security(chan, true) ||
-	    __l2cap_no_conn_pending(chan))
+	    !__l2cap_no_conn_pending(chan))
+		return;
+	if (l2cap_check_enc_key_size(conn->hcon))
 		l2cap_start_connection(chan);
+	else
+		__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
 }
 static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
 				continue;
 			}
-			l2cap_start_connection(chan);
+			if (l2cap_check_enc_key_size(conn->hcon))
+				l2cap_start_connection(chan);
+			else
+				l2cap_chan_close(chan, ECONNREFUSED);
 		} else if (chan->state == BT_CONNECT2) {
 			struct l2cap_conn_rsp rsp;
 		}
 		if (chan->state == BT_CONNECT) {
-			if (!status)
+			if (!status && l2cap_check_enc_key_size(hcon))
 				l2cap_start_connection(chan);
 			else
 				__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
 			struct l2cap_conn_rsp rsp;
 			__u16 res, stat;
-			if (!status) {
+			if (!status && l2cap_check_enc_key_size(hcon)) {
 				if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
 					res = L2CAP_CR_PEND;
 					stat = L2CAP_CS_AUTHOR_PEND;

net/ipv4/ip_output.c+21−4

@@ -327,18 +327,35 @@ static int ip_finish_output(struct net net, struct sock sk, struct sk_buff *sk · 326 unmodified lines
327	static int ip_mc_finish_output(struct net net, struct sock sk,	327	static int ip_mc_finish_output(struct net net, struct sock sk,
328	struct sk_buff *skb)	328	struct sk_buff *skb)
329	{	329	{
330	int ret;	330	struct rtable *new_rt;
		331	bool do_cn = false;
		332	int ret, err;
331		333
332	ret = BPF_CGROUP_RUN_PROG_INET_EGRESS(sk, skb);	334	ret = BPF_CGROUP_RUN_PROG_INET_EGRESS(sk, skb);
333	switch (ret) {	335	switch (ret) {
334	case NET_XMIT_SUCCESS:
335	return dev_loopback_xmit(net, sk, skb);
336	case NET_XMIT_CN:	336	case NET_XMIT_CN:
337	return dev_loopback_xmit(net, sk, skb) ? : ret;	337	do_cn = true;
		338	/* fall through */
		339	case NET_XMIT_SUCCESS:
		340	break;
338	default:	341	default:
339	kfree_skb(skb);	342	kfree_skb(skb);
340	return ret;	343	return ret;
341	}	344	}
		345
		346	/* Reset rt_iif so that inet_iif() will return skb->skb_iif. Setting
		347	* this to non-zero causes ipi_ifindex in in_pktinfo to be overwritten,
		348	* see ipv4_pktinfo_prepare().
		349	*/
		350	new_rt = rt_dst_clone(net->loopback_dev, skb_rtable(skb));
		351	if (new_rt) {
		352	new_rt->rt_iif = 0;
		353	skb_dst_drop(skb);
		354	skb_dst_set(skb, &new_rt->dst);
		355	}
		356
		357	err = dev_loopback_xmit(net, sk, skb);
		358	return (do_cn && err) ? ret : err;
342	}	359	}
343		360
344	int ip_mc_output(struct net net, struct sock sk, struct sk_buff *skb)	361	int ip_mc_output(struct net net, struct sock sk, struct sk_buff *skb)

net/ipv4/raw.c+1−1

@@ -197,7 +197,7 @@ static int raw_v4_input(struct sk_buff skb, const struct iphdr iph, int hash) · 196 unmodified lines
197	}	197	}
198	sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,	198	sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
199	iph->saddr, iph->daddr,	199	iph->saddr, iph->daddr,
200	skb->dev->ifindex, sdif);	200	dif, sdif);
201	}	201	}
202	out:	202	out:
203	read_unlock(&raw_v4_hashinfo.lock);	203	read_unlock(&raw_v4_hashinfo.lock);

net/ipv4/route.c+33−0

@@ -1648,6 +1648,39 @@ struct rtable rt_dst_alloc(struct net_device dev, · 1647 unmodified lines
1648	}	1648	}
1649	EXPORT_SYMBOL(rt_dst_alloc);	1649	EXPORT_SYMBOL(rt_dst_alloc);
1650		1650
		1651	struct rtable rt_dst_clone(struct net_device dev, struct rtable *rt)
		1652	{
		1653	struct rtable *new_rt;
		1654
		1655	new_rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
		1656	rt->dst.flags);
		1657
		1658	if (new_rt) {
		1659	new_rt->rt_genid = rt_genid_ipv4(dev_net(dev));
		1660	new_rt->rt_flags = rt->rt_flags;
		1661	new_rt->rt_type = rt->rt_type;
		1662	new_rt->rt_is_input = rt->rt_is_input;
		1663	new_rt->rt_iif = rt->rt_iif;
		1664	new_rt->rt_pmtu = rt->rt_pmtu;
		1665	new_rt->rt_mtu_locked = rt->rt_mtu_locked;
		1666	new_rt->rt_gw_family = rt->rt_gw_family;
		1667	if (rt->rt_gw_family == AF_INET)
		1668	new_rt->rt_gw4 = rt->rt_gw4;
		1669	else if (rt->rt_gw_family == AF_INET6)
		1670	new_rt->rt_gw6 = rt->rt_gw6;
		1671	INIT_LIST_HEAD(&new_rt->rt_uncached);
		1672
		1673	new_rt->dst.flags \|= DST_HOST;
		1674	new_rt->dst.input = rt->dst.input;
		1675	new_rt->dst.output = rt->dst.output;
		1676	new_rt->dst.error = rt->dst.error;
		1677	new_rt->dst.lastuse = jiffies;
		1678	new_rt->dst.lwtstate = lwtstate_get(rt->dst.lwtstate);
		1679	}
		1680	return new_rt;
		1681	}
		1682	EXPORT_SYMBOL(rt_dst_clone);
		1683
1651	/* called in rcu_read_lock() section */	1684	/* called in rcu_read_lock() section */
1652	int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,	1685	int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1653	u8 tos, struct net_device *dev,	1686	u8 tos, struct net_device *dev,

net/ipv6/ip6_output.c+1−1

 {
 	struct dst_entry *dst = skb_dst(skb);
 	struct net_device *dev = dst->dev;
+	const struct in6_addr *nexthop;
 	struct neighbour *neigh;
-	struct in6_addr *nexthop;
 	int ret;
 	if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {

net/ipv6/route.c+3−2

 {
 	const struct rt6_info *rt = container_of(dst, struct rt6_info, dst);
-	return ip6_neigh_lookup(&rt->rt6i_gateway, dst->dev, skb, daddr);
+	return ip6_neigh_lookup(rt6_nexthop(rt, &in6addr_any),
+				dst->dev, skb, daddr);
 }
 static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
 		.data		=	&init_net.ipv6.sysctl.skip_notify_on_dev_down,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
-		.proc_handler	=	proc_dointvec,
+		.proc_handler	=	proc_dointvec_minmax,
 		.extra1		=	&zero,
 		.extra2		=	&one,
 	},

net/netfilter/nf_flow_table_ip.c+1−1

 	struct nf_flowtable *flow_table = priv;
 	struct flow_offload_tuple tuple = {};
 	enum flow_offload_tuple_dir dir;
+	const struct in6_addr *nexthop;
 	struct flow_offload *flow;
 	struct net_device *outdev;
-	struct in6_addr *nexthop;
 	struct ipv6hdr *ip6h;
 	struct rt6_info *rt;

net/packet/af_packet.c+19−4

 		ts = __packet_set_timestamp(po, ph, skb);
 		__packet_set_status(po, ph, TP_STATUS_AVAILABLE | ts);
+		if (!packet_read_pending(&po->tx_ring))
+			complete(&po->skb_completion);
 	}
 	sock_wfree(skb);
 static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
 {
-	struct sk_buff *skb;
+	struct sk_buff *skb = NULL;
 	struct net_device *dev;
 	struct virtio_net_hdr *vnet_hdr = NULL;
 	struct sockcm_cookie sockc;
 	int len_sum = 0;
 	int status = TP_STATUS_AVAILABLE;
 	int hlen, tlen, copylen = 0;
+	long timeo = 0;
 	mutex_lock(&po->pg_vec_lock);
 	if ((size_max > dev->mtu + reserve + VLAN_HLEN) && !po->has_vnet_hdr)
 		size_max = dev->mtu + reserve + VLAN_HLEN;
+	reinit_completion(&po->skb_completion);
 	do {
 		ph = packet_current_frame(po, &po->tx_ring,
 					  TP_STATUS_SEND_REQUEST);
 		if (unlikely(ph == NULL)) {
-			if (need_wait && need_resched())
+			if (need_wait && skb) {
-				schedule();
+				timeo = sock_sndtimeo(&po->sk, msg->msg_flags & MSG_DONTWAIT);
+				timeo = wait_for_completion_interruptible_timeout(&po->skb_completion, timeo);
+				if (timeo <= 0) {
+					err = !timeo ? -ETIMEDOUT : -ERESTARTSYS;
+					goto out_put;
+				}
+			}
+			/* check for additional frames */
 			continue;
 		}
 	sock_init_data(sock, sk);
 	po = pkt_sk(sk);
+	init_completion(&po->skb_completion);
 	sk->sk_family = PF_PACKET;
 	po->num = proto;
 	po->xmit = dev_queue_xmit;
 				    req3->tp_sizeof_priv ||
 				    req3->tp_feature_req_word) {
 					err = -EINVAL;
-					goto out;
+					goto out_free_pg_vec;
 				}
 			}
 			break;
 			prb_shutdown_retire_blk_timer(po, rb_queue);
 	}
+out_free_pg_vec:
 	if (pg_vec)
 		free_pg_vec(pg_vec, order, req->tp_block_nr);
 out:

net/packet/internal.h+1−0

@@ -128,6 +128,7 @@ struct packet_sock { · 127 unmodified lines
128	unsigned int tp_hdrlen;	128	unsigned int tp_hdrlen;
129	unsigned int tp_reserve;	129	unsigned int tp_reserve;
130	unsigned int tp_tstamp;	130	unsigned int tp_tstamp;
		131	struct completion skb_completion;
131	struct net_device __rcu *cached_dev;	132	struct net_device __rcu *cached_dev;
132	int (xmit)(struct sk_buff skb);	133	int (xmit)(struct sk_buff skb);
133	struct packet_type prot_hook ____cacheline_aligned_in_smp;	134	struct packet_type prot_hook ____cacheline_aligned_in_smp;

net/sched/sch_cbs.c+7−2

 static int __init cbs_module_init(void)
 {
-	int err = register_netdevice_notifier(&cbs_device_notifier);
+	int err;
+	err = register_netdevice_notifier(&cbs_device_notifier);
 	if (err)
 		return err;
-	return register_qdisc(&cbs_qdisc_ops);
+	err = register_qdisc(&cbs_qdisc_ops);
+	if (err)
+		unregister_netdevice_notifier(&cbs_device_notifier);
+	return err;
 }
 static void __exit cbs_module_exit(void)

net/sctp/endpointola.c+4−4

 	/* Initialize the bind addr area */
 	sctp_bind_addr_init(&ep->base.bind_addr, 0);
-	/* Remember who we are attached to.  */
-	ep->base.sk = sk;
-	sock_hold(ep->base.sk);
 	/* Create the lists of associations.  */
 	INIT_LIST_HEAD(&ep->asocs);
 	ep->prsctp_enable = net->sctp.prsctp_enable;
 	ep->reconf_enable = net->sctp.reconf_enable;
+	/* Remember who we are attached to.  */
+	ep->base.sk = sk;
+	sock_hold(ep->base.sk);
 	return ep;
 nomem_shkey:

net/smc/af_smc.c+4−1

 	rc = smc_pnet_init();
 	if (rc)
-		return rc;
+		goto out_pernet_subsys;
 	rc = smc_llc_init();
 	if (rc) {
 	proto_unregister(&smc_proto);
 out_pnet:
 	smc_pnet_exit();
+out_pernet_subsys:
+	unregister_pernet_subsys(&smc_net_ops);
 	return rc;
 }

net/smc/smc_core.c+3−0

 		rc = smc_lgr_create(smc, ini);
 		if (rc)
 			goto out;
+		lgr = conn->lgr;
+		write_lock_bh(&lgr->conns_lock);
 		smc_lgr_register_conn(conn); /* add smc conn to lgr */
+		write_unlock_bh(&lgr->conns_lock);
 	}
 	conn->local_tx_ctrl.common.type = SMC_CDC_MSG_TYPE;
 	conn->local_tx_ctrl.len = SMC_WR_TX_SIZE;

net/tipc/core.c+6−6

@@ -134,7 +134,7 @@ static int __init tipc_init(void) · 133 unmodified lines
134	if (err)	134	if (err)
135	goto out_sysctl;	135	goto out_sysctl;
136		136
137	err = register_pernet_subsys(&tipc_net_ops);	137	err = register_pernet_device(&tipc_net_ops);
138	if (err)	138	if (err)
139	goto out_pernet;	139	goto out_pernet;
140		140
@@ -142,7 +142,7 @@ static int __init tipc_init(void) · 1 unmodified line
142	if (err)	142	if (err)
143	goto out_socket;	143	goto out_socket;
144		144
145	err = register_pernet_subsys(&tipc_topsrv_net_ops);	145	err = register_pernet_device(&tipc_topsrv_net_ops);
146	if (err)	146	if (err)
147	goto out_pernet_topsrv;	147	goto out_pernet_topsrv;
148		148
@@ -153,11 +153,11 @@ static int __init tipc_init(void) · 4 unmodified lines
153	pr_info("Started in single node mode\n");	153	pr_info("Started in single node mode\n");
154	return 0;	154	return 0;
155	out_bearer:	155	out_bearer:
156	unregister_pernet_subsys(&tipc_topsrv_net_ops);	156	unregister_pernet_device(&tipc_topsrv_net_ops);
157	out_pernet_topsrv:	157	out_pernet_topsrv:
158	tipc_socket_stop();	158	tipc_socket_stop();
159	out_socket:	159	out_socket:
160	unregister_pernet_subsys(&tipc_net_ops);	160	unregister_pernet_device(&tipc_net_ops);
161	out_pernet:	161	out_pernet:
162	tipc_unregister_sysctl();	162	tipc_unregister_sysctl();
163	out_sysctl:	163	out_sysctl:
@@ -172,9 +172,9 @@ out_netlink: · 8 unmodified lines
172	static void __exit tipc_exit(void)	172	static void __exit tipc_exit(void)
173	{	173	{
174	tipc_bearer_cleanup();	174	tipc_bearer_cleanup();
175	unregister_pernet_subsys(&tipc_topsrv_net_ops);	175	unregister_pernet_device(&tipc_topsrv_net_ops);
176	tipc_socket_stop();	176	tipc_socket_stop();
177	unregister_pernet_subsys(&tipc_net_ops);	177	unregister_pernet_device(&tipc_net_ops);
178	tipc_netlink_stop();	178	tipc_netlink_stop();
179	tipc_netlink_compat_stop();	179	tipc_netlink_compat_stop();
180	tipc_unregister_sysctl();	180	tipc_unregister_sysctl();

net/tipc/netlink_compat.c+15−3

 	if (!bearer)
 		return -EMSGSIZE;
-	len = min_t(int, TLV_GET_DATA_LEN(msg->req), TIPC_MAX_BEARER_NAME);
+	len = TLV_GET_DATA_LEN(msg->req);
+	if (len <= 0)
+		return -EINVAL;
+	len = min_t(int, len, TIPC_MAX_BEARER_NAME);
 	if (!string_is_valid(name, len))
 		return -EINVAL;
 	name = (char *)TLV_DATA(msg->req);
-	len = min_t(int, TLV_GET_DATA_LEN(msg->req), TIPC_MAX_LINK_NAME);
+	len = TLV_GET_DATA_LEN(msg->req);
+	if (len <= 0)
+		return -EINVAL;
+	len = min_t(int, len, TIPC_MAX_BEARER_NAME);
 	if (!string_is_valid(name, len))
 		return -EINVAL;
 	if (!link)
 		return -EMSGSIZE;
-	len = min_t(int, TLV_GET_DATA_LEN(msg->req), TIPC_MAX_LINK_NAME);
+	len = TLV_GET_DATA_LEN(msg->req);
+	if (len <= 0)
+		return -EINVAL;
+	len = min_t(int, len, TIPC_MAX_BEARER_NAME);
 	if (!string_is_valid(name, len))
 		return -EINVAL;

net/tls/tls_main.c+2−1

@@ -279,7 +279,8 @@ static void tls_sk_proto_close(struct sock *sk, long timeout) · 278 unmodified lines
279	goto skip_tx_cleanup;	279	goto skip_tx_cleanup;
280	}	280	}
281		281
282	if (!tls_complete_pending_work(sk, ctx, 0, &timeo))	282	if (unlikely(sk->sk_write_pending) &&
		283	!wait_on_pending_writer(sk, &timeo))
283	tls_handle_open_record(sk, 0);	284	tls_handle_open_record(sk, 0);
284		285
285	/* We need these for tls_sw_fallback handling of other packets */	286	/* We need these for tls_sw_fallback handling of other packets */

samples/pidfd/pidfd-metadata.c+6−2

 int main(int argc, char *argv[])
 {
-	int pidfd = 0, ret = EXIT_FAILURE;
+	int pidfd = -1, ret = EXIT_FAILURE;
 	char buf[4096] = { 0 };
 	pid_t pid;
 	int procfd, statusfd;
 	pid = pidfd_clone(CLONE_PIDFD, &pidfd);
 	if (pid < 0)
-		exit(ret);
+		err(ret, "CLONE_PIDFD");
+	if (pidfd == -1) {
+		warnx("CLONE_PIDFD is not supported by the kernel");
+		goto out;
+	}
 	procfd = pidfd_metadata_fd(pid, pidfd);
 	close(pidfd);

tools/testing/selftests/powerpc/mm/.gitignore+2−1

@@ -3,4 +3,5 @@ subpage_prot · 2 unmodified lines
3	tempfile	3	tempfile
4	prot_sao	4	prot_sao
5	segv_errors	5	segv_errors
6	wild_bctr	6	wild_bctr
		7	large_vm_fork_separation

tools/testing/selftests/powerpc/mm/Makefile+3−1

 noarg:
 	$(MAKE) -C ../
-TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors wild_bctr
+TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors wild_bctr \
+		  large_vm_fork_separation
 TEST_GEN_FILES := tempfile
 top_srcdir = ../../../../..
 $(OUTPUT)/prot_sao: ../utils.c
 $(OUTPUT)/wild_bctr: CFLAGS += -m64
+$(OUTPUT)/large_vm_fork_separation: CFLAGS += -m64
 $(OUTPUT)/tempfile:
 	dd if=/dev/zero of=$@ bs=64k count=1

tools/testing/selftests/powerpc/mm/large_vm_fork_separation.c+87−0

@@ -0,0 +1,87 @@
	1	// SPDX-License-Identifier: GPL-2.0+
	2	//
	3	// Copyright 2019, Michael Ellerman, IBM Corp.
	4	//
	5	// Test that allocating memory beyond the memory limit and then forking is
	6	// handled correctly, ie. the child is able to access the mappings beyond the
	7	// memory limit and the child's writes are not visible to the parent.
	8
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/mman.h>
	12	#include <sys/types.h>
	13	#include <sys/wait.h>
	14	#include <unistd.h>
	15
	16	#include "utils.h"
	17
	18
	19	#ifndef MAP_FIXED_NOREPLACE
	20	#define MAP_FIXED_NOREPLACE MAP_FIXED // "Should be safe" above 512TB
	21	#endif
	22
	23
	24	static int test(void)
	25	{
	26	int p2c[2], c2p[2], rc, status, c, *p;
	27	unsigned long page_size;
	28	pid_t pid;
	29
	30	page_size = sysconf(_SC_PAGESIZE);
	31	SKIP_IF(page_size != 65536);
	32
	33	// Create a mapping at 512TB to allocate an extended_id
	34	p = mmap((void *)(512ul << 40), page_size, PROT_READ \| PROT_WRITE,
	35	MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED_NOREPLACE, -1, 0);
	36	if (p == MAP_FAILED) {
	37	perror("mmap");
	38	printf("Error: couldn't mmap(), confirm kernel has 4TB support?\n");
	39	return 1;
	40	}
	41
	42	printf("parent writing %p = 1\n", p);
	43	*p = 1;
	44
	45	FAIL_IF(pipe(p2c) == -1 \|\| pipe(c2p) == -1);
	46
	47	pid = fork();
	48	if (pid == 0) {
	49	FAIL_IF(read(p2c[0], &c, 1) != 1);
	50
	51	pid = getpid();
	52	printf("child writing %p = %d\n", p, pid);
	53	*p = pid;
	54
	55	FAIL_IF(write(c2p[1], &c, 1) != 1);
	56	FAIL_IF(read(p2c[0], &c, 1) != 1);
	57	exit(0);
	58	}
	59
	60	c = 0;
	61	FAIL_IF(write(p2c[1], &c, 1) != 1);
	62	FAIL_IF(read(c2p[0], &c, 1) != 1);
	63
	64	// Prevent compiler optimisation
	65	barrier();
	66
	67	rc = 0;
	68	printf("parent reading %p = %d\n", p, *p);
	69	if (*p != 1) {
	70	printf("Error: BUG! parent saw child's write! p = %d\n", p);
	71	rc = 1;
	72	}
	73
	74	FAIL_IF(write(p2c[1], &c, 1) != 1);
	75	FAIL_IF(waitpid(pid, &status, 0) == -1);
	76	FAIL_IF(!WIFEXITED(status) \|\| WEXITSTATUS(status));
	77
	78	if (rc == 0)
	79	printf("success: test completed OK\n");
	80
	81	return rc;
	82	}
	83
	84	int main(void)
	85	{
	86	return test_harness(test, "large_vm_fork_separation");
	87	}

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code