lael-labs/linux

Documentation/devicetree/bindings/mmc/marvell,xenon-sdhci.txt+7−5

 - clocks:
   Array of clocks required for SDHC.
-  Require at least input clock for Xenon IP core.
+  Require at least input clock for Xenon IP core. For Armada AP806 and
+  CP110, the AXI clock is also mandatory.
 - clock-names:
   Array of names corresponding to clocks property.
   The input clock for Xenon IP core should be named as "core".
+  The input clock for the AXI bus must be named as "axi".
 - reg:
   * For "marvell,armada-3700-sdhci", two register areas.
 		compatible = "marvell,armada-ap806-sdhci";
 		reg = <0xaa0000 0x1000>;
 		interrupts = <GIC_SPI 13 IRQ_TYPE_LEVEL_HIGH>
-		clocks = <&emmc_clk>;
+		clocks = <&emmc_clk>,<&axi_clk>;
-		clock-names = "core";
+		clock-names = "core", "axi";
 		bus-width = <4>;
 		marvell,xenon-phy-slow-mode;
 		marvell,xenon-tun-count = <11>;
 		interrupts = <GIC_SPI 55 IRQ_TYPE_LEVEL_HIGH>
 		vqmmc-supply = <&sd_vqmmc_regulator>;
 		vmmc-supply = <&sd_vmmc_regulator>;
-		clocks = <&sdclk>;
+		clocks = <&sdclk>, <&axi_clk>;
-		clock-names = "core";
+		clock-names = "core", "axi";
 		bus-width = <4>;
 		marvell,xenon-tun-count = <9>;
 	};

Documentation/filesystems/overlayfs.txt+4−1

@@ -210,8 +210,11 @@ path as another overlay mount and it may use a lower layer path that is · 209 unmodified lines
210	beneath or above the path of another overlay lower layer path.	210	beneath or above the path of another overlay lower layer path.
211		211
212	Using an upper layer path and/or a workdir path that are already used by	212	Using an upper layer path and/or a workdir path that are already used by
213	another overlay mount is not allowed and will fail with EBUSY. Using	213	another overlay mount is not allowed and may fail with EBUSY. Using
214	partially overlapping paths is not allowed but will not fail with EBUSY.	214	partially overlapping paths is not allowed but will not fail with EBUSY.
		215	If files are accessed from two overlayfs mounts which share or overlap the
		216	upper layer and/or workdir path the behavior of the overlay is undefined,
		217	though it will not result in a crash or deadlock.
215		218
216	Mounting an overlay using an upper layer path, where the upper layer path	219	Mounting an overlay using an upper layer path, where the upper layer path
217	was previously used by another mounted overlay in combination with a	220	was previously used by another mounted overlay in combination with a

Documentation/i2c/busses/i2c-i801+1−0

@@ -36,6 +36,7 @@ Supported adapters: · 35 unmodified lines
36	* Intel Gemini Lake (SOC)	36	* Intel Gemini Lake (SOC)
37	* Intel Cannon Lake-H (PCH)	37	* Intel Cannon Lake-H (PCH)
38	* Intel Cannon Lake-LP (PCH)	38	* Intel Cannon Lake-LP (PCH)
		39	* Intel Cedar Fork (PCH)
39	Datasheets: Publicly available at the Intel website	40	Datasheets: Publicly available at the Intel website
40		41
41	On Intel Patsburg and later chipsets, both the normal host SMBus controller	42	On Intel Patsburg and later chipsets, both the normal host SMBus controller

Documentation/networking/bonding.txt+1−1

@@ -2387,7 +2387,7 @@ broadcast: Like active-backup, there is not much advantage to this · 2386 unmodified lines
2387	and packet type ID), so in a "gatewayed" configuration, all	2387	and packet type ID), so in a "gatewayed" configuration, all
2388	outgoing traffic will generally use the same device. Incoming	2388	outgoing traffic will generally use the same device. Incoming
2389	traffic may also end up on a single device, but that is	2389	traffic may also end up on a single device, but that is
2390	dependent upon the balancing policy of the peer's 8023.ad	2390	dependent upon the balancing policy of the peer's 802.3ad
2391	implementation. In a "local" configuration, traffic will be	2391	implementation. In a "local" configuration, traffic will be
2392	distributed across the devices in the bond.	2392	distributed across the devices in the bond.
2393		2393

MAINTAINERS+3−2

@@ -5259,7 +5259,8 @@ S: Maintained · 5258 unmodified lines
5259	F: drivers/iommu/exynos-iommu.c	5259	F: drivers/iommu/exynos-iommu.c
5260		5260
5261	EZchip NPS platform support	5261	EZchip NPS platform support
5262	M: Noam Camus <noamc@ezchip.com>	5262	M: Elad Kanfi <eladkan@mellanox.com>
		5263	M: Vineet Gupta <vgupta@synopsys.com>
5263	S: Supported	5264	S: Supported
5264	F: arch/arc/plat-eznps	5265	F: arch/arc/plat-eznps
5265	F: arch/arc/boot/dts/eznps.dts	5266	F: arch/arc/boot/dts/eznps.dts
@@ -9360,7 +9361,7 @@ NETWORK BLOCK DEVICE (NBD) · 4094 unmodified lines
9360	M: Josef Bacik <jbacik@fb.com>	9361	M: Josef Bacik <jbacik@fb.com>
9361	S: Maintained	9362	S: Maintained
9362	L: linux-block@vger.kernel.org	9363	L: linux-block@vger.kernel.org
9363	L: nbd-general@lists.sourceforge.net	9364	L: nbd@other.debian.org
9364	F: Documentation/blockdev/nbd.txt	9365	F: Documentation/blockdev/nbd.txt
9365	F: drivers/block/nbd.c	9366	F: drivers/block/nbd.c
9366	F: include/uapi/linux/nbd.h	9367	F: include/uapi/linux/nbd.h

Makefile+1−1

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 14	2	PATCHLEVEL = 14
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc3	4	EXTRAVERSION = -rc4
5	NAME = Fearless Coyote	5	NAME = Fearless Coyote
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION

arch/Kconfig+0−3

@@ -937,9 +937,6 @@ config STRICT_MODULE_RWX · 936 unmodified lines
937	and non-text memory will be made non-executable. This provides	937	and non-text memory will be made non-executable. This provides
938	protection against certain security exploits (e.g. writing to text)	938	protection against certain security exploits (e.g. writing to text)
939		939
940	config ARCH_WANT_RELAX_ORDER
941	bool
942
943	config ARCH_HAS_REFCOUNT	940	config ARCH_HAS_REFCOUNT
944	bool	941	bool
945	help	942	help

arch/arc/Kconfig+1−1

@@ -24,7 +24,7 @@ config ARC · 23 unmodified lines
24	select GENERIC_SMP_IDLE_THREAD	24	select GENERIC_SMP_IDLE_THREAD
25	select HAVE_ARCH_KGDB	25	select HAVE_ARCH_KGDB
26	select HAVE_ARCH_TRACEHOOK	26	select HAVE_ARCH_TRACEHOOK
27	select HAVE_FUTEX_CMPXCHG	27	select HAVE_FUTEX_CMPXCHG if FUTEX
28	select HAVE_IOREMAP_PROT	28	select HAVE_IOREMAP_PROT
29	select HAVE_KPROBES	29	select HAVE_KPROBES
30	select HAVE_KRETPROBES	30	select HAVE_KRETPROBES

arch/arc/Makefile+0−2

@@ -6,8 +6,6 @@ · 5 unmodified lines
6	# published by the Free Software Foundation.	6	# published by the Free Software Foundation.
7	#	7	#
8		8
9	UTS_MACHINE := arc
10
11	ifeq ($(CROSS_COMPILE),)	9	ifeq ($(CROSS_COMPILE),)
12	ifndef CONFIG_CPU_BIG_ENDIAN	10	ifndef CONFIG_CPU_BIG_ENDIAN
13	CROSS_COMPILE := arc-linux-	11	CROSS_COMPILE := arc-linux-

arch/arc/boot/dts/axs10x_mb.dtsi+8−1

 			mmcclk: mmcclk {
 				compatible = "fixed-clock";
-				clock-frequency = <50000000>;
+				/*
+				 * DW sdio controller has external ciu clock divider
+				 * controlled via register in SDIO IP. It divides
+				 * sdio_ref_clk (which comes from CGU) by 16 for
+				 * default. So default mmcclk clock (which comes
+				 * to sdk_in) is 25000000 Hz.
+				 */
+				clock-frequency = <25000000>;
 				#clock-cells = <0>;
 			};

arch/arc/boot/dts/hsdk.dts+29−3

 /dts-v1/;
 #include <dt-bindings/net/ti-dp83867.h>
+#include <dt-bindings/reset/snps,hsdk-reset.h>
 / {
 	model = "snps,hsdk";
 		};
 	};
-	core_clk: core-clk {
+	input_clk: input-clk {
 		#clock-cells = <0>;
 		compatible = "fixed-clock";
-		clock-frequency = <500000000>;
+		clock-frequency = <33333333>;
 	};
 	cpu_intc: cpu-interrupt-controller {
 		ranges = <0x00000000 0xf0000000 0x10000000>;
+		cgu_rst: reset-controller@8a0 {
+			compatible = "snps,hsdk-reset";
+			#reset-cells = <1>;
+			reg = <0x8A0 0x4>, <0xFF0 0x4>;
+		};
+		core_clk: core-clk@0 {
+			compatible = "snps,hsdk-core-pll-clock";
+			reg = <0x00 0x10>, <0x14B8 0x4>;
+			#clock-cells = <0>;
+			clocks = <&input_clk>;
+		};
 		serial: serial@5000 {
 			compatible = "snps,dw-apb-uart";
 			reg = <0x5000 0x100>;
 		mmcclk_ciu: mmcclk-ciu {
 			compatible = "fixed-clock";
-			clock-frequency = <100000000>;
+			/*
+			 * DW sdio controller has external ciu clock divider
+			 * controlled via register in SDIO IP. Due to its
+			 * unexpected default value (it should devide by 1
+			 * but it devides by 8) SDIO IP uses wrong clock and
+			 * works unstable (see STAR 9001204800)
+			 * So add temporary fix and change clock frequency
+			 * from 100000000 to 12500000 Hz until we fix dw sdio
+			 * driver itself.
+			 */
+			clock-frequency = <12500000>;
 			#clock-cells = <0>;
 		};
 			clocks = <&gmacclk>;
 			clock-names = "stmmaceth";
 			phy-handle = <&phy0>;
+			resets = <&cgu_rst HSDK_ETH_RESET>;
+			reset-names = "stmmaceth";
 			mdio {
 				#address-cells = <1>;

arch/arc/configs/axs101_defconfig+1−1

@@ -105,7 +105,7 @@ CONFIG_NLS_ISO8859_1=y · 104 unmodified lines
105	# CONFIG_ENABLE_WARN_DEPRECATED is not set	105	# CONFIG_ENABLE_WARN_DEPRECATED is not set
106	# CONFIG_ENABLE_MUST_CHECK is not set	106	# CONFIG_ENABLE_MUST_CHECK is not set
107	CONFIG_STRIP_ASM_SYMS=y	107	CONFIG_STRIP_ASM_SYMS=y
108	CONFIG_LOCKUP_DETECTOR=y	108	CONFIG_SOFTLOCKUP_DETECTOR=y
109	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10	109	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
110	# CONFIG_SCHED_DEBUG is not set	110	# CONFIG_SCHED_DEBUG is not set
111	# CONFIG_DEBUG_PREEMPT is not set	111	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/axs103_defconfig+1−1

@@ -104,7 +104,7 @@ CONFIG_NLS_ISO8859_1=y · 103 unmodified lines
104	# CONFIG_ENABLE_WARN_DEPRECATED is not set	104	# CONFIG_ENABLE_WARN_DEPRECATED is not set
105	# CONFIG_ENABLE_MUST_CHECK is not set	105	# CONFIG_ENABLE_MUST_CHECK is not set
106	CONFIG_STRIP_ASM_SYMS=y	106	CONFIG_STRIP_ASM_SYMS=y
107	CONFIG_LOCKUP_DETECTOR=y	107	CONFIG_SOFTLOCKUP_DETECTOR=y
108	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10	108	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
109	# CONFIG_SCHED_DEBUG is not set	109	# CONFIG_SCHED_DEBUG is not set
110	# CONFIG_DEBUG_PREEMPT is not set	110	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/axs103_smp_defconfig+1−1

@@ -107,7 +107,7 @@ CONFIG_NLS_ISO8859_1=y · 106 unmodified lines
107	# CONFIG_ENABLE_WARN_DEPRECATED is not set	107	# CONFIG_ENABLE_WARN_DEPRECATED is not set
108	# CONFIG_ENABLE_MUST_CHECK is not set	108	# CONFIG_ENABLE_MUST_CHECK is not set
109	CONFIG_STRIP_ASM_SYMS=y	109	CONFIG_STRIP_ASM_SYMS=y
110	CONFIG_LOCKUP_DETECTOR=y	110	CONFIG_SOFTLOCKUP_DETECTOR=y
111	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10	111	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
112	# CONFIG_SCHED_DEBUG is not set	112	# CONFIG_SCHED_DEBUG is not set
113	# CONFIG_DEBUG_PREEMPT is not set	113	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/haps_hs_smp_defconfig+1−1

@@ -84,5 +84,5 @@ CONFIG_TMPFS=y · 83 unmodified lines
84	CONFIG_NFS_FS=y	84	CONFIG_NFS_FS=y
85	# CONFIG_ENABLE_WARN_DEPRECATED is not set	85	# CONFIG_ENABLE_WARN_DEPRECATED is not set
86	# CONFIG_ENABLE_MUST_CHECK is not set	86	# CONFIG_ENABLE_MUST_CHECK is not set
87	CONFIG_LOCKUP_DETECTOR=y	87	CONFIG_SOFTLOCKUP_DETECTOR=y
88	# CONFIG_DEBUG_PREEMPT is not set	88	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/hsdk_defconfig+2−1

 CONFIG_MMC_SDHCI_PLTFM=y
 CONFIG_MMC_DW=y
 # CONFIG_IOMMU_SUPPORT is not set
+CONFIG_RESET_HSDK=y
 CONFIG_EXT3_FS=y
 CONFIG_VFAT_FS=y
 CONFIG_TMPFS=y
 # CONFIG_ENABLE_WARN_DEPRECATED is not set
 # CONFIG_ENABLE_MUST_CHECK is not set
 CONFIG_STRIP_ASM_SYMS=y
-CONFIG_LOCKUP_DETECTOR=y
+CONFIG_SOFTLOCKUP_DETECTOR=y
 CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/vdk_hs38_defconfig+1−1

@@ -94,7 +94,7 @@ CONFIG_NLS_ISO8859_1=y · 93 unmodified lines
94	# CONFIG_ENABLE_MUST_CHECK is not set	94	# CONFIG_ENABLE_MUST_CHECK is not set
95	CONFIG_STRIP_ASM_SYMS=y	95	CONFIG_STRIP_ASM_SYMS=y
96	CONFIG_DEBUG_SHIRQ=y	96	CONFIG_DEBUG_SHIRQ=y
97	CONFIG_LOCKUP_DETECTOR=y	97	CONFIG_SOFTLOCKUP_DETECTOR=y
98	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10	98	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
99	# CONFIG_SCHED_DEBUG is not set	99	# CONFIG_SCHED_DEBUG is not set
100	# CONFIG_DEBUG_PREEMPT is not set	100	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/configs/vdk_hs38_smp_defconfig+1−1

@@ -98,7 +98,7 @@ CONFIG_NLS_ISO8859_1=y · 97 unmodified lines
98	# CONFIG_ENABLE_MUST_CHECK is not set	98	# CONFIG_ENABLE_MUST_CHECK is not set
99	CONFIG_STRIP_ASM_SYMS=y	99	CONFIG_STRIP_ASM_SYMS=y
100	CONFIG_DEBUG_SHIRQ=y	100	CONFIG_DEBUG_SHIRQ=y
101	CONFIG_LOCKUP_DETECTOR=y	101	CONFIG_SOFTLOCKUP_DETECTOR=y
102	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10	102	CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=10
103	# CONFIG_SCHED_DEBUG is not set	103	# CONFIG_SCHED_DEBUG is not set
104	# CONFIG_DEBUG_PREEMPT is not set	104	# CONFIG_DEBUG_PREEMPT is not set

arch/arc/include/asm/arcregs.h+6−5

 /* Auxiliary registers */
 #define AUX_IDENTITY		4
+#define AUX_EXEC_CTRL		8
 #define AUX_INTR_VEC_BASE	0x25
 #define AUX_VOL			0x5e
 #endif
 };
-struct bcr_isa {
+struct bcr_isa_arcv2 {
 #ifdef CONFIG_CPU_BIG_ENDIAN
 	unsigned int div_rem:4, pad2:4, ldd:1, unalign:1, atomic:1, be:1,
-		     pad1:11, atomic1:1, ver:8;
+		     pad1:12, ver:8;
 #else
-	unsigned int ver:8, atomic1:1, pad1:11, be:1, atomic:1, unalign:1,
+	unsigned int ver:8, pad1:12, be:1, atomic:1, unalign:1,
 		     ldd:1, pad2:4, div_rem:4;
 #endif
 };
 	struct cpuinfo_arc_mmu mmu;
 	struct cpuinfo_arc_bpu bpu;
 	struct bcr_identity core;
-	struct bcr_isa isa;
+	struct bcr_isa_arcv2 isa;
 	const char *details, *name;
 	unsigned int vec_base;
 	struct cpuinfo_arc_ccm iccm, dccm;
 	struct {
 		unsigned int swap:1, norm:1, minmax:1, barrel:1, crc:1, swape:1, pad1:2,
-			     fpu_sp:1, fpu_dp:1, pad2:6,
+			     fpu_sp:1, fpu_dp:1, dual_iss_enb:1, dual_iss_exist:1, pad2:4,
 			     debug:1, ap:1, smart:1, rtt:1, pad3:4,
 			     timer0:1, timer1:1, rtc:1, gfrc:1, pad4:4;
 	} extn;

arch/arc/kernel/setup.c+25−7

 	{ 0x51, "R2.0" },
 	{ 0x52, "R2.1" },
 	{ 0x53, "R3.0" },
+	{ 0x54, "R4.0" },
 #endif
 	{ 0x00, NULL   }
 };
 #else
 	{ 0x40, "ARC EM"  },
 	{ 0x50, "ARC HS38"  },
+	{ 0x54, "ARC HS48"  },
 #endif
 	{ 0x00, "Unknown"   }
 };
 	struct bcr_generic bcr;
 	struct cpuinfo_arc *cpu = &cpuinfo_arc700[smp_processor_id()];
 	const struct id_to_str *tbl;
+	struct bcr_isa_arcv2 isa;
 	FIX_PTR(cpu);
 	READ_BCR(AUX_IDENTITY, cpu->core);
-	READ_BCR(ARC_REG_ISA_CFG_BCR, cpu->isa);
 	for (tbl = &arc_cpu_rel[0]; tbl->id != 0; tbl++) {
 		if (cpu->core.family == tbl->id) {
 	}
 	for (tbl = &arc_cpu_nm[0]; tbl->id != 0; tbl++) {
-		if ((cpu->core.family & 0xF0) == tbl->id)
+		if ((cpu->core.family & 0xF4) == tbl->id)
 			break;
 	}
 	cpu->name = tbl->str;
 		cpu->bpu.full = bpu.ft;
 		cpu->bpu.num_cache = 256 << bpu.bce;
 		cpu->bpu.num_pred = 2048 << bpu.pte;
+		if (cpu->core.family >= 0x54) {
+			unsigned int exec_ctrl;
+			READ_BCR(AUX_EXEC_CTRL, exec_ctrl);
+			cpu->extn.dual_iss_exist = 1;
+			cpu->extn.dual_iss_enb = exec_ctrl & 1;
+		}
 	}
 	READ_BCR(ARC_REG_AP_BCR, bcr);
 	cpu->extn.debug = cpu->extn.ap | cpu->extn.smart | cpu->extn.rtt;
+	READ_BCR(ARC_REG_ISA_CFG_BCR, isa);
 	/* some hacks for lack of feature BCR info in old ARC700 cores */
 	if (is_isa_arcompact()) {
-		if (!cpu->isa.ver)	/* ISA BCR absent, use Kconfig info */
+		if (!isa.ver)	/* ISA BCR absent, use Kconfig info */
 			cpu->isa.atomic = IS_ENABLED(CONFIG_ARC_HAS_LLSC);
-		else
+		else {
-			cpu->isa.atomic = cpu->isa.atomic1;
+			/* ARC700_BUILD only has 2 bits of isa info */
+			struct bcr_generic bcr = *(struct bcr_generic *)&isa;
+			cpu->isa.atomic = bcr.info & 1;
+		}
 		cpu->isa.be = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN);
 		 /* there's no direct way to distinguish 750 vs. 770 */
 		if (unlikely(cpu->core.family < 0x34 || cpu->mmu.ver < 3))
 			cpu->name = "ARC750";
+	} else {
+		cpu->isa = isa;
 	}
 }
 		       "\nIDENTITY\t: ARCVER [%#02x] ARCNUM [%#02x] CHIPID [%#4x]\n",
 		       core->family, core->cpu_id, core->chip_id);
-	n += scnprintf(buf + n, len - n, "processor [%d]\t: %s %s (%s ISA) %s\n",
+	n += scnprintf(buf + n, len - n, "processor [%d]\t: %s %s (%s ISA) %s%s%s\n",
 		       cpu_id, cpu->name, cpu->details,
 		       is_isa_arcompact() ? "ARCompact" : "ARCv2",
-		       IS_AVAIL1(cpu->isa.be, "[Big-Endian]"));
+		       IS_AVAIL1(cpu->isa.be, "[Big-Endian]"),
+		       IS_AVAIL3(cpu->extn.dual_iss_exist, cpu->extn.dual_iss_enb, " Dual-Issue"));
 	n += scnprintf(buf + n, len - n, "Timers\t\t: %s%s%s%s%s%s\nISA Extn\t: ",
 		       IS_AVAIL1(cpu->extn.timer0, "Timer0 "),

arch/arc/plat-axs10x/axs10x.c+7−0

@@ -111,6 +111,13 @@ static void __init axs10x_early_init(void) · 110 unmodified lines
111		111
112	axs10x_enable_gpio_intc_wire();	112	axs10x_enable_gpio_intc_wire();
113		113
		114	/*
		115	* Reset ethernet IP core.
		116	* TODO: get rid of this quirk after axs10x reset driver (or simple
		117	* reset driver) will be available in upstream.
		118	*/
		119	iowrite32((1 << 5), (void __iomem *) CREG_MB_SW_RESET);
		120
114	scnprintf(mb, 32, "MainBoard v%d", mb_rev);	121	scnprintf(mb, 32, "MainBoard v%d", mb_rev);
115	axs10x_print_board_ver(CREG_MB_VER, mb);	122	axs10x_print_board_ver(CREG_MB_VER, mb);
116	}	123	}

arch/arc/plat-hsdk/Kconfig+2−1

@@ -6,4 +6,5 @@ · 5 unmodified lines
6	#	6	#
7		7
8	menuconfig ARC_SOC_HSDK	8	menuconfig ARC_SOC_HSDK
9	bool "ARC HS Development Kit SOC"	9	bool "ARC HS Development Kit SOC"
		10	select CLK_HSDK

arch/arc/plat-hsdk/platform.c+42−0

@@ -38,6 +38,42 @@ static void __init hsdk_init_per_cpu(unsigned int cpu) · 37 unmodified lines
38	#define CREG_PAE (CREG_BASE + 0x180)	38	#define CREG_PAE (CREG_BASE + 0x180)
39	#define CREG_PAE_UPDATE (CREG_BASE + 0x194)	39	#define CREG_PAE_UPDATE (CREG_BASE + 0x194)
40		40
		41	#define CREG_CORE_IF_CLK_DIV (CREG_BASE + 0x4B8)
		42	#define CREG_CORE_IF_CLK_DIV_2 0x1
		43	#define CGU_BASE ARC_PERIPHERAL_BASE
		44	#define CGU_PLL_STATUS (ARC_PERIPHERAL_BASE + 0x4)
		45	#define CGU_PLL_CTRL (ARC_PERIPHERAL_BASE + 0x0)
		46	#define CGU_PLL_STATUS_LOCK BIT(0)
		47	#define CGU_PLL_STATUS_ERR BIT(1)
		48	#define CGU_PLL_CTRL_1GHZ 0x3A10
		49	#define HSDK_PLL_LOCK_TIMEOUT 500
		50
		51	#define HSDK_PLL_LOCKED() \
		52	!!(ioread32((void __iomem *) CGU_PLL_STATUS) & CGU_PLL_STATUS_LOCK)
		53
		54	#define HSDK_PLL_ERR() \
		55	!!(ioread32((void __iomem *) CGU_PLL_STATUS) & CGU_PLL_STATUS_ERR)
		56
		57	static void __init hsdk_set_cpu_freq_1ghz(void)
		58	{
		59	u32 timeout = HSDK_PLL_LOCK_TIMEOUT;
		60
		61	/*
		62	* As we set cpu clock which exceeds 500MHz, the divider for the interface
		63	* clock must be programmed to div-by-2.
		64	*/
		65	iowrite32(CREG_CORE_IF_CLK_DIV_2, (void __iomem *) CREG_CORE_IF_CLK_DIV);
		66
		67	/* Set cpu clock to 1GHz */
		68	iowrite32(CGU_PLL_CTRL_1GHZ, (void __iomem *) CGU_PLL_CTRL);
		69
		70	while (!HSDK_PLL_LOCKED() && timeout--)
		71	cpu_relax();
		72
		73	if (!HSDK_PLL_LOCKED() \|\| HSDK_PLL_ERR())
		74	pr_err("Failed to setup CPU frequency to 1GHz!");
		75	}
		76
41	static void __init hsdk_init_early(void)	77	static void __init hsdk_init_early(void)
42	{	78	{
43	/*	79	/*
@@ -52,6 +88,12 @@ static void __init hsdk_init_early(void) · 8 unmodified lines
52		88
53	/* Really apply settings made above */	89	/* Really apply settings made above */
54	writel(1, (void __iomem *) CREG_PAE_UPDATE);	90	writel(1, (void __iomem *) CREG_PAE_UPDATE);
		91
		92	/*
		93	* Setup CPU frequency to 1GHz.
		94	* TODO: remove it after smart hsdk pll driver will be introduced.
		95	*/
		96	hsdk_set_cpu_freq_1ghz();
55	}	97	}
56		98
57	static const char *hsdk_compat[] __initconst = {	99	static const char *hsdk_compat[] __initconst = {

arch/arm64/include/asm/memory.h+6−3

 #define KERNEL_END        _end
 /*
- * The size of the KASAN shadow region. This should be 1/8th of the
+ * KASAN requires 1/8th of the kernel virtual address space for the shadow
- * size of the entire kernel virtual address space.
+ * region. KASAN can bloat the stack significantly, so double the (minimum)
+ * stack size when KASAN is in use.
  */
 #ifdef CONFIG_KASAN
 #define KASAN_SHADOW_SIZE	(UL(1) << (VA_BITS - 3))
+#define KASAN_THREAD_SHIFT	1
 #else
 #define KASAN_SHADOW_SIZE	(0)
+#define KASAN_THREAD_SHIFT	0
 #endif
-#define MIN_THREAD_SHIFT	14
+#define MIN_THREAD_SHIFT	(14 + KASAN_THREAD_SHIFT)
 /*
  * VMAP'd stacks are allocated at page granularity, so we must ensure that such

arch/arm64/kernel/armv8_deprecated.c+1−1

@@ -649,4 +649,4 @@ static int __init armv8_deprecated_init(void) · 648 unmodified lines
649	return 0;	649	return 0;
650	}	650	}
651		651
652	late_initcall(armv8_deprecated_init);	652	core_initcall(armv8_deprecated_init);

arch/arm64/kernel/cpufeature.c+1−1

@@ -1307,4 +1307,4 @@ static int __init enable_mrs_emulation(void) · 1306 unmodified lines
1307	return 0;	1307	return 0;
1308	}	1308	}
1309		1309
1310	late_initcall(enable_mrs_emulation);	1310	core_initcall(enable_mrs_emulation);

arch/arm64/kernel/fpsimd.c+1−1

@@ -444,4 +444,4 @@ static int __init fpsimd_init(void) · 443 unmodified lines
444		444
445	return 0;	445	return 0;
446	}	446	}
447	late_initcall(fpsimd_init);	447	core_initcall(fpsimd_init);

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

@@ -97,7 +97,7 @@ static void data_abort_decode(unsigned int esr) · 96 unmodified lines
97	(esr & ESR_ELx_SF) >> ESR_ELx_SF_SHIFT,	97	(esr & ESR_ELx_SF) >> ESR_ELx_SF_SHIFT,
98	(esr & ESR_ELx_AR) >> ESR_ELx_AR_SHIFT);	98	(esr & ESR_ELx_AR) >> ESR_ELx_AR_SHIFT);
99	} else {	99	} else {
100	pr_alert(" ISV = 0, ISS = 0x%08lu\n", esr & ESR_ELx_ISS_MASK);	100	pr_alert(" ISV = 0, ISS = 0x%08lx\n", esr & ESR_ELx_ISS_MASK);
101	}	101	}
102		102
103	pr_alert(" CM = %lu, WnR = %lu\n",	103	pr_alert(" CM = %lu, WnR = %lu\n",

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

@@ -146,7 +146,7 @@ void machine_power_off(void) · 145 unmodified lines
146		146
147	/* prevent soft lockup/stalled CPU messages for endless loop. */	147	/* prevent soft lockup/stalled CPU messages for endless loop. */
148	rcu_sysrq_start();	148	rcu_sysrq_start();
149	lockup_detector_suspend();	149	lockup_detector_soft_poweroff();
150	for (;;);	150	for (;;);
151	}	151	}
152		152

arch/powerpc/kernel/dt_cpu_ftrs.c+2−2

@@ -102,10 +102,10 @@ static void cpufeatures_flush_tlb(void) · 101 unmodified lines
102	case PVR_POWER8:	102	case PVR_POWER8:
103	case PVR_POWER8E:	103	case PVR_POWER8E:
104	case PVR_POWER8NVL:	104	case PVR_POWER8NVL:
105	__flush_tlb_power8(POWER8_TLB_SETS);	105	__flush_tlb_power8(TLB_INVAL_SCOPE_GLOBAL);
106	break;	106	break;
107	case PVR_POWER9:	107	case PVR_POWER9:
108	__flush_tlb_power9(POWER9_TLB_SETS_HASH);	108	__flush_tlb_power9(TLB_INVAL_SCOPE_GLOBAL);
109	break;	109	break;
110	default:	110	default:
111	pr_err("unknown CPU version for boot TLB flush\n");	111	pr_err("unknown CPU version for boot TLB flush\n");

arch/powerpc/kernel/exceptions-64s.S+23−1

@@ -734,7 +734,29 @@ EXC_REAL(program_check, 0x700, 0x100) · 733 unmodified lines
734	EXC_VIRT(program_check, 0x4700, 0x100, 0x700)	734	EXC_VIRT(program_check, 0x4700, 0x100, 0x700)
735	TRAMP_KVM(PACA_EXGEN, 0x700)	735	TRAMP_KVM(PACA_EXGEN, 0x700)
736	EXC_COMMON_BEGIN(program_check_common)	736	EXC_COMMON_BEGIN(program_check_common)
737	EXCEPTION_PROLOG_COMMON(0x700, PACA_EXGEN)	737	/*
		738	* It's possible to receive a TM Bad Thing type program check with
		739	* userspace register values (in particular r1), but with SRR1 reporting
		740	* that we came from the kernel. Normally that would confuse the bad
		741	* stack logic, and we would report a bad kernel stack pointer. Instead
		742	* we switch to the emergency stack if we're taking a TM Bad Thing from
		743	* the kernel.
		744	*/
		745	li r10,MSR_PR /* Build a mask of MSR_PR .. */
		746	oris r10,r10,0x200000@h /* .. and SRR1_PROGTM */
		747	and r10,r10,r12 /* Mask SRR1 with that. */
		748	srdi r10,r10,8 /* Shift it so we can compare */
		749	cmpldi r10,(0x200000 >> 8) /* .. with an immediate. */
		750	bne 1f /* If != go to normal path. */
		751
		752	/* SRR1 had PR=0 and SRR1_PROGTM=1, so use the emergency stack */
		753	andi. r10,r12,MSR_PR; /* Set CR0 correctly for label */
		754	/* 3 in EXCEPTION_PROLOG_COMMON */
		755	mr r10,r1 /* Save r1 */
		756	ld r1,PACAEMERGSP(r13) /* Use emergency stack */
		757	subi r1,r1,INT_FRAME_SIZE /* alloc stack frame */
		758	b 3f /* Jump into the macro !! */
		759	1: EXCEPTION_PROLOG_COMMON(0x700, PACA_EXGEN)
738	bl save_nvgprs	760	bl save_nvgprs
739	RECONCILE_IRQ_STATE(r10, r11)	761	RECONCILE_IRQ_STATE(r10, r11)
740	addi r3,r1,STACK_FRAME_OVERHEAD	762	addi r3,r1,STACK_FRAME_OVERHEAD

arch/powerpc/kernel/mce_power.c+13−0

@@ -624,5 +624,18 @@ long __machine_check_early_realmode_p8(struct pt_regs *regs) · 623 unmodified lines
624		624
625	long __machine_check_early_realmode_p9(struct pt_regs *regs)	625	long __machine_check_early_realmode_p9(struct pt_regs *regs)
626	{	626	{
		627	/*
		628	* On POWER9 DD2.1 and below, it's possible to get a machine check
		629	* caused by a paste instruction where only DSISR bit 25 is set. This
		630	* will result in the MCE handler seeing an unknown event and the kernel
		631	* crashing. An MCE that occurs like this is spurious, so we don't need
		632	* to do anything in terms of servicing it. If there is something that
		633	* needs to be serviced, the CPU will raise the MCE again with the
		634	* correct DSISR so that it can be serviced properly. So detect this
		635	* case and mark it as handled.
		636	*/
		637	if (SRR1_MC_LOADSTORE(regs->msr) && regs->dsisr == 0x02000000)
		638	return 1;
		639
627	return mce_handle_error(regs, mce_p9_derror_table, mce_p9_ierror_table);	640	return mce_handle_error(regs, mce_p9_derror_table, mce_p9_ierror_table);
628	}	641	}

arch/powerpc/kernel/setup-common.c+0−3

 #endif
 #endif
-#ifdef CONFIG_PPC_64K_PAGES
-	init_mm.context.pte_frag = NULL;
-#endif
 #ifdef CONFIG_SPAPR_TCE_IOMMU
 	mm_iommu_init(&init_mm);
 #endif

arch/powerpc/kernel/signal_64.c+12−1

@@ -452,9 +452,20 @@ static long restore_tm_sigcontexts(struct task_struct *tsk, · 451 unmodified lines
452	if (MSR_TM_RESV(msr))	452	if (MSR_TM_RESV(msr))
453	return -EINVAL;	453	return -EINVAL;
454		454
455	/* pull in MSR TM from user context */	455	/* pull in MSR TS bits from user context */
456	regs->msr = (regs->msr & ~MSR_TS_MASK) \| (msr & MSR_TS_MASK);	456	regs->msr = (regs->msr & ~MSR_TS_MASK) \| (msr & MSR_TS_MASK);
457		457
		458	/*
		459	* Ensure that TM is enabled in regs->msr before we leave the signal
		460	* handler. It could be the case that (a) user disabled the TM bit
		461	* through the manipulation of the MSR bits in uc_mcontext or (b) the
		462	* TM bit was disabled because a sufficient number of context switches
		463	* happened whilst in the signal handler and load_tm overflowed,
		464	* disabling the TM bit. In either case we can end up with an illegal
		465	* TM state leading to a TM Bad Thing when we return to userspace.
		466	*/
		467	regs->msr \|= MSR_TM;
		468
458	/* pull in MSR LE from user context */	469	/* pull in MSR LE from user context */
459	regs->msr = (regs->msr & ~MSR_LE) \| (msr & MSR_LE);	470	regs->msr = (regs->msr & ~MSR_LE) \| (msr & MSR_LE);
460		471

arch/powerpc/kernel/watchdog.c+15−15

@@ -310,9 +310,6 @@ static int start_wd_on_cpu(unsigned int cpu) · 309 unmodified lines
310	if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))	310	if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))
311	return 0;	311	return 0;
312		312
313	if (watchdog_suspended)
314	return 0;
315
316	if (!cpumask_test_cpu(cpu, &watchdog_cpumask))	313	if (!cpumask_test_cpu(cpu, &watchdog_cpumask))
317	return 0;	314	return 0;
318		315
@@ -358,36 +355,39 @@ static void watchdog_calc_timeouts(void) · 39 unmodified lines
358	wd_timer_period_ms = watchdog_thresh * 1000 * 2 / 5;	355	wd_timer_period_ms = watchdog_thresh * 1000 * 2 / 5;
359	}	356	}
360		357
361	void watchdog_nmi_reconfigure(void)	358	void watchdog_nmi_stop(void)
362	{	359	{
363	int cpu;	360	int cpu;
364		361
365	watchdog_calc_timeouts();
366
367	for_each_cpu(cpu, &wd_cpus_enabled)	362	for_each_cpu(cpu, &wd_cpus_enabled)
368	stop_wd_on_cpu(cpu);	363	stop_wd_on_cpu(cpu);
		364	}
369		365
		366	void watchdog_nmi_start(void)
		367	{
		368	int cpu;
		369
		370	watchdog_calc_timeouts();
370	for_each_cpu_and(cpu, cpu_online_mask, &watchdog_cpumask)	371	for_each_cpu_and(cpu, cpu_online_mask, &watchdog_cpumask)
371	start_wd_on_cpu(cpu);	372	start_wd_on_cpu(cpu);
372	}	373	}
373		374
374	/*	375	/*
375	* This runs after lockup_detector_init() which sets up watchdog_cpumask.	376	* Invoked from core watchdog init.
376	*/	377	*/
377	static int __init powerpc_watchdog_init(void)	378	int __init watchdog_nmi_probe(void)
378	{	379	{
379	int err;	380	int err;
380		381
381	watchdog_calc_timeouts();	382	err = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
382		383	"powerpc/watchdog:online",
383	err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "powerpc/watchdog:online",	384	start_wd_on_cpu, stop_wd_on_cpu);
384	start_wd_on_cpu, stop_wd_on_cpu);	385	if (err < 0) {
385	if (err < 0)
386	pr_warn("Watchdog could not be initialized");	386	pr_warn("Watchdog could not be initialized");
387		387	return err;
		388	}
388	return 0;	389	return 0;
389	}	390	}
390	arch_initcall(powerpc_watchdog_init);
391		391
392	static void handle_backtrace_ipi(struct pt_regs *regs)	392	static void handle_backtrace_ipi(struct pt_regs *regs)
393	{	393	{

arch/powerpc/kvm/book3s_xive.c+2−3

 		return -EINVAL;
 	state = &sb->irq_state[idx];
 	arch_spin_lock(&sb->lock);
-	*server = state->guest_server;
+	*server = state->act_server;
 	*priority = state->guest_priority;
 	arch_spin_unlock(&sb->lock);
 	xive->saved_src_count++;
 	/* Convert saved state into something compatible with xics */
-	val = state->guest_server;
+	val = state->act_server;
 	prio = state->saved_scan_prio;
 	if (prio == MASKED) {
 	/* First convert prio and mark interrupt as untargetted */
 	act_prio = xive_prio_from_guest(guest_prio);
 	state->act_priority = MASKED;
-	state->guest_server = server;
 	/*
 	 * We need to drop the lock due to the mutex below. Hopefully

arch/powerpc/kvm/book3s_xive.h+0−1

@@ -35,7 +35,6 @@ struct kvmppc_xive_irq_state { · 34 unmodified lines
35	struct xive_irq_data pt_data; / XIVE Pass-through associated data */	35	struct xive_irq_data pt_data; / XIVE Pass-through associated data */
36		36
37	/* Targetting as set by guest */	37	/* Targetting as set by guest */
38	u32 guest_server; /* Current guest selected target */
39	u8 guest_priority; /* Guest set priority */	38	u8 guest_priority; /* Guest set priority */
40	u8 saved_priority; /* Saved priority when masking */	39	u8 saved_priority; /* Saved priority when masking */
41		40

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

 			break;
 	}
 	wmb();
+	local_irq_restore(flags);
 	flush_tlb_kernel_range((unsigned long)page_address(start),
 			       (unsigned long)page_address(page));
-	local_irq_restore(flags);
 	return err;
 }

arch/powerpc/platforms/powernv/setup.c+9−1

@@ -272,7 +272,15 @@ static void pnv_kexec_cpu_down(int crash_shutdown, int secondary) · 271 unmodified lines
272	#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE	272	#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
273	static unsigned long pnv_memory_block_size(void)	273	static unsigned long pnv_memory_block_size(void)
274	{	274	{
275	return 256UL * 1024 * 1024;	275	/*
		276	* We map the kernel linear region with 1GB large pages on radix. For
		277	* memory hot unplug to work our memory block size must be at least
		278	* this size.
		279	*/
		280	if (radix_enabled())
		281	return 1UL * 1024 * 1024 * 1024;
		282	else
		283	return 256UL * 1024 * 1024;
276	}	284	}
277	#endif	285	#endif
278		286

arch/powerpc/sysdev/xive/common.c+8−0

@@ -1402,6 +1402,14 @@ void xive_teardown_cpu(void) · 1401 unmodified lines
1402		1402
1403	if (xive_ops->teardown_cpu)	1403	if (xive_ops->teardown_cpu)
1404	xive_ops->teardown_cpu(cpu, xc);	1404	xive_ops->teardown_cpu(cpu, xc);
		1405
		1406	#ifdef CONFIG_SMP
		1407	/* Get rid of IPI */
		1408	xive_cleanup_cpu_ipi(cpu, xc);
		1409	#endif
		1410
		1411	/* Disable and free the queues */
		1412	xive_cleanup_cpu_queues(cpu, xc);
1405	}	1413	}
1406		1414
1407	void xive_kexec_teardown_cpu(int secondary)	1415	void xive_kexec_teardown_cpu(int secondary)

arch/powerpc/sysdev/xive/spapr.c+4−0

 static void xive_spapr_put_ipi(unsigned int cpu, struct xive_cpu *xc)
 {
+	if (!xc->hw_ipi)
+		return;
 	xive_irq_bitmap_free(xc->hw_ipi);
+	xc->hw_ipi = 0;
 }
 #endif /* CONFIG_SMP */

arch/sparc/Kconfig+0−1

@@ -44,7 +44,6 @@ config SPARC · 43 unmodified lines
44	select ARCH_HAS_SG_CHAIN	44	select ARCH_HAS_SG_CHAIN
45	select CPU_NO_EFFICIENT_FFS	45	select CPU_NO_EFFICIENT_FFS
46	select LOCKDEP_SMALL if LOCKDEP	46	select LOCKDEP_SMALL if LOCKDEP
47	select ARCH_WANT_RELAX_ORDER
48		47
49	config SPARC32	48	config SPARC32
50	def_bool !64BIT	49	def_bool !64BIT

arch/x86/events/intel/core.c+4−7

@@ -4409,10 +4409,9 @@ static __init int fixup_ht_bug(void) · 4408 unmodified lines
4409	return 0;	4409	return 0;
4410	}	4410	}
4411		4411
4412	if (lockup_detector_suspend() != 0) {	4412	cpus_read_lock();
4413	pr_debug("failed to disable PMU erratum BJ122, BV98, HSD29 workaround\n");	4413
4414	return 0;	4414	hardlockup_detector_perf_stop();
4415	}
4416		4415
4417	x86_pmu.flags &= ~(PMU_FL_EXCL_CNTRS \| PMU_FL_EXCL_ENABLED);	4416	x86_pmu.flags &= ~(PMU_FL_EXCL_CNTRS \| PMU_FL_EXCL_ENABLED);
4418		4417
@@ -4420,9 +4419,7 @@ static __init int fixup_ht_bug(void) · 1 unmodified line
4420	x86_pmu.commit_scheduling = NULL;	4419	x86_pmu.commit_scheduling = NULL;
4421	x86_pmu.stop_scheduling = NULL;	4420	x86_pmu.stop_scheduling = NULL;
4422		4421
4423	lockup_detector_resume();	4422	hardlockup_detector_perf_restart();
4424
4425	cpus_read_lock();
4426		4423
4427	for_each_online_cpu(c)	4424	for_each_online_cpu(c)
4428	free_excl_cntrs(c);	4425	free_excl_cntrs(c);

arch/x86/include/asm/kvm_para.h+2−2

@@ -88,7 +88,7 @@ static inline long kvm_hypercall4(unsigned int nr, unsigned long p1, · 87 unmodified lines
88	bool kvm_para_available(void);	88	bool kvm_para_available(void);
89	unsigned int kvm_arch_para_features(void);	89	unsigned int kvm_arch_para_features(void);
90	void __init kvm_guest_init(void);	90	void __init kvm_guest_init(void);
91	void kvm_async_pf_task_wait(u32 token);	91	void kvm_async_pf_task_wait(u32 token, int interrupt_kernel);
92	void kvm_async_pf_task_wake(u32 token);	92	void kvm_async_pf_task_wake(u32 token);
93	u32 kvm_read_and_reset_pf_reason(void);	93	u32 kvm_read_and_reset_pf_reason(void);
94	extern void kvm_disable_steal_time(void);	94	extern void kvm_disable_steal_time(void);
@@ -103,7 +103,7 @@ static inline void kvm_spinlock_init(void) · 8 unmodified lines
103		103
104	#else /* CONFIG_KVM_GUEST */	104	#else /* CONFIG_KVM_GUEST */
105	#define kvm_guest_init() do {} while (0)	105	#define kvm_guest_init() do {} while (0)
106	#define kvm_async_pf_task_wait(T) do {} while(0)	106	#define kvm_async_pf_task_wait(T, I) do {} while(0)
107	#define kvm_async_pf_task_wake(T) do {} while(0)	107	#define kvm_async_pf_task_wake(T) do {} while(0)
108		108
109	static inline bool kvm_para_available(void)	109	static inline bool kvm_para_available(void)

arch/x86/kernel/kvm.c+10−4

 	return NULL;
 }
-void kvm_async_pf_task_wait(u32 token)
+/*
+ * @interrupt_kernel: Is this called from a routine which interrupts the kernel
+ * 		      (other than user space)?
+ */
+void kvm_async_pf_task_wait(u32 token, int interrupt_kernel)
 {
 	u32 key = hash_32(token, KVM_TASK_SLEEP_HASHBITS);
 	struct kvm_task_sleep_head *b = &async_pf_sleepers[key];
 	n.token = token;
 	n.cpu = smp_processor_id();
-	n.halted = is_idle_task(current) || preempt_count() > 1 ||
+	n.halted = is_idle_task(current) ||
-		   rcu_preempt_depth();
+		   (IS_ENABLED(CONFIG_PREEMPT_COUNT)
+		    ? preempt_count() > 1 || rcu_preempt_depth()
+		    : interrupt_kernel);
 	init_swait_queue_head(&n.wq);
 	hlist_add_head(&n.link, &b->list);
 	raw_spin_unlock(&b->lock);
 	case KVM_PV_REASON_PAGE_NOT_PRESENT:
 		/* page is swapped out by the host. */
 		prev_state = exception_enter();
-		kvm_async_pf_task_wait((u32)read_cr2());
+		kvm_async_pf_task_wait((u32)read_cr2(), !user_mode(regs));
 		exception_exit(prev_state);
 		break;
 	case KVM_PV_REASON_PAGE_READY:

arch/x86/kvm/Kconfig+1−0

@@ -23,6 +23,7 @@ config KVM · 22 unmodified lines
23	depends on HIGH_RES_TIMERS	23	depends on HIGH_RES_TIMERS
24	# for TASKSTATS/TASK_DELAY_ACCT:	24	# for TASKSTATS/TASK_DELAY_ACCT:
25	depends on NET && MULTIUSER	25	depends on NET && MULTIUSER
		26	depends on X86_LOCAL_APIC
26	select PREEMPT_NOTIFIERS	27	select PREEMPT_NOTIFIERS
27	select MMU_NOTIFIER	28	select MMU_NOTIFIER
28	select ANON_INODES	29	select ANON_INODES

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

 	#op " %al \n\t" \
 	FOP_RET
-asm(".global kvm_fastop_exception \n"
+asm(".pushsection .fixup, \"ax\"\n"
-    "kvm_fastop_exception: xor %esi, %esi; ret");
+    ".global kvm_fastop_exception \n"
+    "kvm_fastop_exception: xor %esi, %esi; ret\n"
+    ".popsection");
 FOP_START(setcc)
 FOP_SETCC(seto)

arch/x86/kvm/mmu.c+1−1

@@ -3837,7 +3837,7 @@ int kvm_handle_page_fault(struct kvm_vcpu *vcpu, u64 error_code, · 3836 unmodified lines
3837	case KVM_PV_REASON_PAGE_NOT_PRESENT:	3837	case KVM_PV_REASON_PAGE_NOT_PRESENT:
3838	vcpu->arch.apf.host_apf_reason = 0;	3838	vcpu->arch.apf.host_apf_reason = 0;
3839	local_irq_disable();	3839	local_irq_disable();
3840	kvm_async_pf_task_wait(fault_address);	3840	kvm_async_pf_task_wait(fault_address, 0);
3841	local_irq_enable();	3841	local_irq_enable();
3842	break;	3842	break;
3843	case KVM_PV_REASON_PAGE_READY:	3843	case KVM_PV_REASON_PAGE_READY:

block/blk-mq-debugfs.c+5−1

 		goto err;
 	/*
-	 * blk_mq_init_hctx() attempted to do this already, but q->debugfs_dir
+	 * blk_mq_init_sched() attempted to do this already, but q->debugfs_dir
 	 * didn't exist yet (because we don't know what to name the directory
 	 * until the queue is registered to a gendisk).
 	 */
+	if (q->elevator && !q->sched_debugfs_dir)
+		blk_mq_debugfs_register_sched(q);
+	/* Similarly, blk_mq_init_hctx() couldn't do this previously. */
 	queue_for_each_hw_ctx(q, hctx, i) {
 		if (!hctx->debugfs_dir && blk_mq_debugfs_register_hctx(q, hctx))
 			goto err;

block/blk-throttle.c+2−2

@@ -1911,11 +1911,11 @@ static void throtl_upgrade_state(struct throtl_data *td) · 1910 unmodified lines
1911		1911
1912	tg->disptime = jiffies - 1;	1912	tg->disptime = jiffies - 1;
1913	throtl_select_dispatch(sq);	1913	throtl_select_dispatch(sq);
1914	throtl_schedule_next_dispatch(sq, false);	1914	throtl_schedule_next_dispatch(sq, true);
1915	}	1915	}
1916	rcu_read_unlock();	1916	rcu_read_unlock();
1917	throtl_select_dispatch(&td->service_queue);	1917	throtl_select_dispatch(&td->service_queue);
1918	throtl_schedule_next_dispatch(&td->service_queue, false);	1918	throtl_schedule_next_dispatch(&td->service_queue, true);
1919	queue_work(kthrotld_workqueue, &td->dispatch_work);	1919	queue_work(kthrotld_workqueue, &td->dispatch_work);
1920	}	1920	}
1921		1921

block/bsg-lib.c+21−6

 	struct bsg_job *job = blk_mq_rq_to_pdu(req);
 	struct scsi_request *sreq = &job->sreq;
+	/* called right after the request is allocated for the request_queue */
+	sreq->sense = kzalloc(SCSI_SENSE_BUFFERSIZE, gfp);
+	if (!sreq->sense)
+		return -ENOMEM;
+	return 0;
+}
+static void bsg_initialize_rq(struct request *req)
+{
+	struct bsg_job *job = blk_mq_rq_to_pdu(req);
+	struct scsi_request *sreq = &job->sreq;
+	void *sense = sreq->sense;
+	/* called right before the request is given to the request_queue user */
 	memset(job, 0, sizeof(*job));
 	scsi_req_init(sreq);
+	sreq->sense = sense;
 	sreq->sense_len = SCSI_SENSE_BUFFERSIZE;
-	sreq->sense = kzalloc(sreq->sense_len, gfp);
-	if (!sreq->sense)
-		return -ENOMEM;
 	job->req = req;
-	job->reply = sreq->sense;
+	job->reply = sense;
 	job->reply_len = sreq->sense_len;
 	job->dd_data = job + 1;
-	return 0;
 }
 static void bsg_exit_rq(struct request_queue *q, struct request *req)
 	q->cmd_size = sizeof(struct bsg_job) + dd_job_size;
 	q->init_rq_fn = bsg_init_rq;
 	q->exit_rq_fn = bsg_exit_rq;
+	q->initialize_rq_fn = bsg_initialize_rq;
 	q->request_fn = bsg_request_fn;
 	ret = blk_init_allocated_queue(q);

drivers/acpi/arm64/iort.c+35−0

@@ -1178,12 +1178,44 @@ dev_put: · 1177 unmodified lines
1178	return ret;	1178	return ret;
1179	}	1179	}
1180		1180
		1181	static bool __init iort_enable_acs(struct acpi_iort_node *iort_node)
		1182	{
		1183	if (iort_node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
		1184	struct acpi_iort_node *parent;
		1185	struct acpi_iort_id_mapping *map;
		1186	int i;
		1187
		1188	map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, iort_node,
		1189	iort_node->mapping_offset);
		1190
		1191	for (i = 0; i < iort_node->mapping_count; i++, map++) {
		1192	if (!map->output_reference)
		1193	continue;
		1194
		1195	parent = ACPI_ADD_PTR(struct acpi_iort_node,
		1196	iort_table, map->output_reference);
		1197	/*
		1198	* If we detect a RC->SMMU mapping, make sure
		1199	* we enable ACS on the system.
		1200	*/
		1201	if ((parent->type == ACPI_IORT_NODE_SMMU) \|\|
		1202	(parent->type == ACPI_IORT_NODE_SMMU_V3)) {
		1203	pci_request_acs();
		1204	return true;
		1205	}
		1206	}
		1207	}
		1208
		1209	return false;
		1210	}
		1211
1181	static void __init iort_init_platform_devices(void)	1212	static void __init iort_init_platform_devices(void)
1182	{	1213	{
1183	struct acpi_iort_node iort_node, iort_end;	1214	struct acpi_iort_node iort_node, iort_end;
1184	struct acpi_table_iort *iort;	1215	struct acpi_table_iort *iort;
1185	struct fwnode_handle *fwnode;	1216	struct fwnode_handle *fwnode;
1186	int i, ret;	1217	int i, ret;
		1218	bool acs_enabled = false;
1187		1219
1188	/*	1220	/*
1189	* iort_table and iort both point to the start of IORT table, but	1221	* iort_table and iort both point to the start of IORT table, but
@@ -1203,6 +1235,9 @@ static void __init iort_init_platform_devices(void) · 13 unmodified lines
1203	return;	1235	return;
1204	}	1236	}
1205		1237
		1238	if (!acs_enabled)
		1239	acs_enabled = iort_enable_acs(iort_node);
		1240
1206	if ((iort_node->type == ACPI_IORT_NODE_SMMU) \|\|	1241	if ((iort_node->type == ACPI_IORT_NODE_SMMU) \|\|
1207	(iort_node->type == ACPI_IORT_NODE_SMMU_V3)) {	1242	(iort_node->type == ACPI_IORT_NODE_SMMU_V3)) {
1208		1243

drivers/block/Kconfig+1−1

@@ -17,7 +17,7 @@ if BLK_DEV · 16 unmodified lines
17		17
18	config BLK_DEV_NULL_BLK	18	config BLK_DEV_NULL_BLK
19	tristate "Null test block driver"	19	tristate "Null test block driver"
20	depends on CONFIGFS_FS	20	select CONFIGFS_FS
21		21
22	config BLK_DEV_FD	22	config BLK_DEV_FD
23	tristate "Normal floppy disk support"	23	tristate "Normal floppy disk support"

drivers/block/nbd.c+5−1

 	 * appropriate.
 	 */
 	ret = nbd_handle_cmd(cmd, hctx->queue_num);
+	if (ret < 0)
+		ret = BLK_STS_IOERR;
+	else if (!ret)
+		ret = BLK_STS_OK;
 	complete(&cmd->send_complete);
-	return ret < 0 ? BLK_STS_IOERR : BLK_STS_OK;
+	return ret;
 }
 static int nbd_add_socket(struct nbd_device *nbd, unsigned long arg,

drivers/clk/clk-bulk.c+1−0

@@ -105,6 +105,7 @@ err: · 104 unmodified lines
105		105
106	return ret;	106	return ret;
107	}	107	}
		108	EXPORT_SYMBOL_GPL(clk_bulk_prepare);
108		109
109	#endif /* CONFIG_HAVE_CLK_PREPARE */	110	#endif /* CONFIG_HAVE_CLK_PREPARE */
110		111

drivers/clk/rockchip/clk-rk3128.c+7−5

 			RK2928_CLKGATE_CON(10), 8, GFLAGS),
 	GATE(SCLK_PVTM_CORE, "clk_pvtm_core", "xin24m", 0,
-			RK2928_CLKGATE_CON(10), 8, GFLAGS),
+			RK2928_CLKGATE_CON(10), 0, GFLAGS),
 	GATE(SCLK_PVTM_GPU, "clk_pvtm_gpu", "xin24m", 0,
-			RK2928_CLKGATE_CON(10), 8, GFLAGS),
+			RK2928_CLKGATE_CON(10), 1, GFLAGS),
 	GATE(SCLK_PVTM_FUNC, "clk_pvtm_func", "xin24m", 0,
-			RK2928_CLKGATE_CON(10), 8, GFLAGS),
+			RK2928_CLKGATE_CON(10), 2, GFLAGS),
 	GATE(SCLK_MIPI_24M, "clk_mipi_24m", "xin24m", CLK_IGNORE_UNUSED,
-			RK2928_CLKGATE_CON(10), 8, GFLAGS),
+			RK2928_CLKGATE_CON(2), 15, GFLAGS),
 	COMPOSITE(SCLK_SDMMC, "sclk_sdmmc0", mux_mmc_src_p, 0,
 			RK2928_CLKSEL_CON(11), 6, 2, MFLAGS, 0, 6, DFLAGS,
 	GATE(0, "pclk_grf", "pclk_cpu", CLK_IGNORE_UNUSED, RK2928_CLKGATE_CON(5), 4, GFLAGS),
 	GATE(0, "pclk_mipiphy", "pclk_cpu", CLK_IGNORE_UNUSED, RK2928_CLKGATE_CON(5), 0, GFLAGS),
-	GATE(0, "pclk_pmu", "pclk_pmu_pre", CLK_IGNORE_UNUSED, RK2928_CLKGATE_CON(9), 2, GFLAGS),
+	GATE(0, "pclk_pmu", "pclk_pmu_pre", 0, RK2928_CLKGATE_CON(9), 2, GFLAGS),
 	GATE(0, "pclk_pmu_niu", "pclk_pmu_pre", CLK_IGNORE_UNUSED, RK2928_CLKGATE_CON(9), 3, GFLAGS),
 	/* PD_MMC */
 	"aclk_peri",
 	"hclk_peri",
 	"pclk_peri",
+	"pclk_pmu",
+	"sclk_timer5",
 };
 static struct rockchip_clk_provider *__init rk3128_common_clk_init(struct device_node *np)

drivers/clk/samsung/clk-exynos4.c+15−0

@@ -294,6 +294,18 @@ static const struct samsung_clk_reg_dump src_mask_suspend_e4210[] = { · 293 unmodified lines
294	#define PLL_ENABLED (1 << 31)	294	#define PLL_ENABLED (1 << 31)
295	#define PLL_LOCKED (1 << 29)	295	#define PLL_LOCKED (1 << 29)
296		296
		297	static void exynos4_clk_enable_pll(u32 reg)
		298	{
		299	u32 pll_con = readl(reg_base + reg);
		300	pll_con \|= PLL_ENABLED;
		301	writel(pll_con, reg_base + reg);
		302
		303	while (!(pll_con & PLL_LOCKED)) {
		304	cpu_relax();
		305	pll_con = readl(reg_base + reg);
		306	}
		307	}
		308
297	static void exynos4_clk_wait_for_pll(u32 reg)	309	static void exynos4_clk_wait_for_pll(u32 reg)
298	{	310	{
299	u32 pll_con;	311	u32 pll_con;
@@ -315,6 +327,9 @@ static int exynos4_clk_suspend(void) · 15 unmodified lines
315	samsung_clk_save(reg_base, exynos4_save_pll,	327	samsung_clk_save(reg_base, exynos4_save_pll,
316	ARRAY_SIZE(exynos4_clk_pll_regs));	328	ARRAY_SIZE(exynos4_clk_pll_regs));
317		329
		330	exynos4_clk_enable_pll(EPLL_CON0);
		331	exynos4_clk_enable_pll(VPLL_CON0);
		332
318	if (exynos4_soc == EXYNOS4210) {	333	if (exynos4_soc == EXYNOS4210) {
319	samsung_clk_save(reg_base, exynos4_save_soc,	334	samsung_clk_save(reg_base, exynos4_save_soc,
320	ARRAY_SIZE(exynos4210_clk_save));	335	ARRAY_SIZE(exynos4210_clk_save));

drivers/gpu/drm/i915/intel_audio.c+0−5

 			 connector->encoder->base.id,
 			 connector->encoder->name);
-	/* ELD Conn_Type */
-	connector->eld[5] &= ~(3 << 2);
-	if (intel_crtc_has_dp_encoder(crtc_state))
-		connector->eld[5] |= (1 << 2);
 	connector->eld[6] = drm_av_sync_delay(connector, adjusted_mode) / 2;
 	if (dev_priv->display.audio_codec_enable)

drivers/gpu/drm/i915/intel_bios.c+7−0

@@ -1163,6 +1163,13 @@ static void parse_ddi_port(struct drm_i915_private *dev_priv, enum port port, · 1162 unmodified lines
1163	is_hdmi = is_dvi && (child->common.device_type & DEVICE_TYPE_NOT_HDMI_OUTPUT) == 0;	1163	is_hdmi = is_dvi && (child->common.device_type & DEVICE_TYPE_NOT_HDMI_OUTPUT) == 0;
1164	is_edp = is_dp && (child->common.device_type & DEVICE_TYPE_INTERNAL_CONNECTOR);	1164	is_edp = is_dp && (child->common.device_type & DEVICE_TYPE_INTERNAL_CONNECTOR);
1165		1165
		1166	if (port == PORT_A && is_dvi) {
		1167	DRM_DEBUG_KMS("VBT claims port A supports DVI%s, ignoring\n",
		1168	is_hdmi ? "/HDMI" : "");
		1169	is_dvi = false;
		1170	is_hdmi = false;
		1171	}
		1172
1166	info->supports_dvi = is_dvi;	1173	info->supports_dvi = is_dvi;
1167	info->supports_hdmi = is_hdmi;	1174	info->supports_hdmi = is_hdmi;
1168	info->supports_dp = is_dp;	1175	info->supports_dp = is_dp;

drivers/gpu/drm/i915/intel_csr.c+1−1

@@ -216,7 +216,7 @@ static void gen9_set_dc_state_debugmask(struct drm_i915_private *dev_priv) · 215 unmodified lines
216		216
217	mask = DC_STATE_DEBUG_MASK_MEMORY_UP;	217	mask = DC_STATE_DEBUG_MASK_MEMORY_UP;
218		218
219	if (IS_BROXTON(dev_priv))	219	if (IS_GEN9_LP(dev_priv))
220	mask \|= DC_STATE_DEBUG_MASK_CORES;	220	mask \|= DC_STATE_DEBUG_MASK_CORES;
221		221
222	/* The below bit doesn't need to be cleared ever afterwards */	222	/* The below bit doesn't need to be cleared ever afterwards */

drivers/gpu/drm/i915/intel_ddi.c+2−1

 out:
 	if (ret && IS_GEN9_LP(dev_priv)) {
 		tmp = I915_READ(BXT_PHY_CTL(port));
-		if ((tmp & (BXT_PHY_LANE_POWERDOWN_ACK |
+		if ((tmp & (BXT_PHY_CMNLANE_POWERDOWN_ACK |
+			    BXT_PHY_LANE_POWERDOWN_ACK |
 			    BXT_PHY_LANE_ENABLED)) != BXT_PHY_LANE_ENABLED)
 			DRM_ERROR("Port %c enabled but PHY powered down? "
 				  "(PHY_CTL %08x)\n", port_name(port), tmp);

drivers/gpu/drm/i915/intel_display.c+0−2

 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
 	struct drm_crtc *crtc;
 	struct intel_crtc_state *intel_cstate;
-	bool hw_check = intel_state->modeset;
 	u64 put_domains[I915_MAX_PIPES] = {};
 	unsigned crtc_vblank_mask = 0;
 	int i;
 		if (needs_modeset(new_crtc_state) ||
 		    to_intel_crtc_state(new_crtc_state)->update_pipe) {
-			hw_check = true;
 			put_domains[to_intel_crtc(crtc)->pipe] =
 				modeset_get_crtc_power_domains(crtc,

drivers/gpu/drm/i915/intel_dpio_phy.c+0−20

@@ -208,12 +208,6 @@ static const struct bxt_ddi_phy_info glk_ddi_phy_info[] = { · 207 unmodified lines
208	},	208	},
209	};	209	};
210		210
211	static u32 bxt_phy_port_mask(const struct bxt_ddi_phy_info *phy_info)
212	{
213	return (phy_info->dual_channel * BIT(phy_info->channel[DPIO_CH1].port)) \|
214	BIT(phy_info->channel[DPIO_CH0].port);
215	}
216
217	static const struct bxt_ddi_phy_info *	211	static const struct bxt_ddi_phy_info *
218	bxt_get_phy_list(struct drm_i915_private dev_priv, int count)	212	bxt_get_phy_list(struct drm_i915_private dev_priv, int count)
219	{	213	{
@@ -313,7 +307,6 @@ bool bxt_ddi_phy_is_enabled(struct drm_i915_private *dev_priv, · 93 unmodified lines
313	enum dpio_phy phy)	307	enum dpio_phy phy)
314	{	308	{
315	const struct bxt_ddi_phy_info *phy_info;	309	const struct bxt_ddi_phy_info *phy_info;
316	enum port port;
317		310
318	phy_info = bxt_get_phy_info(dev_priv, phy);	311	phy_info = bxt_get_phy_info(dev_priv, phy);
319		312
@@ -335,19 +328,6 @@ bool bxt_ddi_phy_is_enabled(struct drm_i915_private *dev_priv, · 15 unmodified lines
335	return false;	328	return false;
336	}	329	}
337		330
338	for_each_port_masked(port, bxt_phy_port_mask(phy_info)) {
339	u32 tmp = I915_READ(BXT_PHY_CTL(port));
340
341	if (tmp & BXT_PHY_CMNLANE_POWERDOWN_ACK) {
342	DRM_DEBUG_DRIVER("DDI PHY %d powered, but common lane "
343	"for port %c powered down "
344	"(PHY_CTL %08x)\n",
345	phy, port_name(port), tmp);
346
347	return false;
348	}
349	}
350
351	return true;	331	return true;
352	}	332	}
353		333

drivers/gpu/drm/i915/intel_modes.c+17−0

@@ -30,6 +30,21 @@ · 29 unmodified lines
30	#include "intel_drv.h"	30	#include "intel_drv.h"
31	#include "i915_drv.h"	31	#include "i915_drv.h"
32		32
		33	static void intel_connector_update_eld_conn_type(struct drm_connector *connector)
		34	{
		35	u8 conn_type;
		36
		37	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort \|\|
		38	connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
		39	conn_type = DRM_ELD_CONN_TYPE_DP;
		40	} else {
		41	conn_type = DRM_ELD_CONN_TYPE_HDMI;
		42	}
		43
		44	connector->eld[DRM_ELD_SAD_COUNT_CONN_TYPE] &= ~DRM_ELD_CONN_TYPE_MASK;
		45	connector->eld[DRM_ELD_SAD_COUNT_CONN_TYPE] \|= conn_type;
		46	}
		47
33	/**	48	/**
34	* intel_connector_update_modes - update connector from edid	49	* intel_connector_update_modes - update connector from edid
35	* @connector: DRM connector device to use	50	* @connector: DRM connector device to use
@@ -44,6 +59,8 @@ int intel_connector_update_modes(struct drm_connector *connector, · 8 unmodified lines
44	ret = drm_add_edid_modes(connector, edid);	59	ret = drm_add_edid_modes(connector, edid);
45	drm_edid_to_eld(connector, edid);	60	drm_edid_to_eld(connector, edid);
46		61
		62	intel_connector_update_eld_conn_type(connector);
		63
47	return ret;	64	return ret;
48	}	65	}
49		66

drivers/gpu/drm/i915/intel_runtime_pm.c+3−0

@@ -2782,6 +2782,9 @@ static void cnl_display_core_init(struct drm_i915_private *dev_priv, bool resume · 2781 unmodified lines
2782		2782
2783	/* 6. Enable DBUF */	2783	/* 6. Enable DBUF */
2784	gen9_dbuf_enable(dev_priv);	2784	gen9_dbuf_enable(dev_priv);
		2785
		2786	if (resume && dev_priv->csr.dmc_payload)
		2787	intel_csr_load_program(dev_priv);
2785	}	2788	}
2786		2789
2787	#undef CNL_PROCMON_IDX	2790	#undef CNL_PROCMON_IDX

drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c+14−5

 	hdmi->mod_clk = devm_clk_get(dev, "mod");
 	if (IS_ERR(hdmi->mod_clk)) {
 		dev_err(dev, "Couldn't get the HDMI mod clock\n");
-		return PTR_ERR(hdmi->mod_clk);
+		ret = PTR_ERR(hdmi->mod_clk);
+		goto err_disable_bus_clk;
 	}
 	clk_prepare_enable(hdmi->mod_clk);
 	hdmi->pll0_clk = devm_clk_get(dev, "pll-0");
 	if (IS_ERR(hdmi->pll0_clk)) {
 		dev_err(dev, "Couldn't get the HDMI PLL 0 clock\n");
-		return PTR_ERR(hdmi->pll0_clk);
+		ret = PTR_ERR(hdmi->pll0_clk);
+		goto err_disable_mod_clk;
 	}
 	hdmi->pll1_clk = devm_clk_get(dev, "pll-1");
 	if (IS_ERR(hdmi->pll1_clk)) {
 		dev_err(dev, "Couldn't get the HDMI PLL 1 clock\n");
-		return PTR_ERR(hdmi->pll1_clk);
+		ret = PTR_ERR(hdmi->pll1_clk);
+		goto err_disable_mod_clk;
 	}
 	ret = sun4i_tmds_create(hdmi);
 	if (ret) {
 		dev_err(dev, "Couldn't create the TMDS clock\n");
-		return ret;
+		goto err_disable_mod_clk;
 	}
 	writel(SUN4I_HDMI_CTRL_ENABLE, hdmi->base + SUN4I_HDMI_CTRL_REG);
 	ret = sun4i_hdmi_i2c_create(dev, hdmi);
 	if (ret) {
 		dev_err(dev, "Couldn't create the HDMI I2C adapter\n");
-		return ret;
+		goto err_disable_mod_clk;
 	}
 	drm_encoder_helper_add(&hdmi->encoder,
 	drm_encoder_cleanup(&hdmi->encoder);
 err_del_i2c_adapter:
 	i2c_del_adapter(hdmi->i2c);
+err_disable_mod_clk:
+	clk_disable_unprepare(hdmi->mod_clk);
+err_disable_bus_clk:
+	clk_disable_unprepare(hdmi->bus_clk);
 	return ret;
 }
 	drm_connector_cleanup(&hdmi->connector);
 	drm_encoder_cleanup(&hdmi->encoder);
 	i2c_del_adapter(hdmi->i2c);
+	clk_disable_unprepare(hdmi->mod_clk);
+	clk_disable_unprepare(hdmi->bus_clk);
 }
 static const struct component_ops sun4i_hdmi_ops = {

drivers/hwmon/xgene-hwmon.c+11−8

 			 sizeof(struct slimpro_resp_msg) * ASYNC_MSG_FIFO_SIZE,
 			 GFP_KERNEL);
 	if (rc)
-		goto out_mbox_free;
+		return -ENOMEM;
 	INIT_WORK(&ctx->workq, xgene_hwmon_evt_work);
 		if (IS_ERR(ctx->mbox_chan)) {
 			dev_err(&pdev->dev,
 				"SLIMpro mailbox channel request failed\n");
-			return -ENODEV;
+			rc = -ENODEV;
+			goto out_mbox_free;
 		}
 	} else {
 		struct acpi_pcct_hw_reduced *cppc_ss;
 		if (device_property_read_u32(&pdev->dev, "pcc-channel",
 					     &ctx->mbox_idx)) {
 			dev_err(&pdev->dev, "no pcc-channel property\n");
-			return -ENODEV;
+			rc = -ENODEV;
+			goto out_mbox_free;
 		}
 		cl->rx_callback = xgene_hwmon_pcc_rx_cb;
 		if (IS_ERR(ctx->mbox_chan)) {
 			dev_err(&pdev->dev,
 				"PPC channel request failed\n");
-			return -ENODEV;
+			rc = -ENODEV;
+			goto out_mbox_free;
 		}
 		/*
 		if (!cppc_ss) {
 			dev_err(&pdev->dev, "PPC subspace not found\n");
 			rc = -ENODEV;
-			goto out_mbox_free;
+			goto out;
 		}
 		if (!ctx->mbox_chan->mbox->txdone_irq) {
 			dev_err(&pdev->dev, "PCC IRQ not supported\n");
 			rc = -ENODEV;
-			goto out_mbox_free;
+			goto out;
 		}
 		/*
 		} else {
 			dev_err(&pdev->dev, "Failed to get PCC comm region\n");
 			rc = -ENODEV;
-			goto out_mbox_free;
+			goto out;
 		}
 		if (!ctx->pcc_comm_addr) {
 			dev_err(&pdev->dev,
 				"Failed to ioremap PCC comm region\n");
 			rc = -ENOMEM;
-			goto out_mbox_free;
+			goto out;
 		}
 		/*

drivers/i2c/busses/Kconfig+1−0

@@ -131,6 +131,7 @@ config I2C_I801 · 130 unmodified lines
131	Gemini Lake (SOC)	131	Gemini Lake (SOC)
132	Cannon Lake-H (PCH)	132	Cannon Lake-H (PCH)
133	Cannon Lake-LP (PCH)	133	Cannon Lake-LP (PCH)
		134	Cedar Fork (PCH)
134		135
135	This driver can also be built as a module. If so, the module	136	This driver can also be built as a module. If so, the module
136	will be called i2c-i801.	137	will be called i2c-i801.

drivers/i2c/busses/i2c-i801.c+4−0

  * Gemini Lake (SOC)		0x31d4	32	hard	yes	yes	yes
  * Cannon Lake-H (PCH)		0xa323	32	hard	yes	yes	yes
  * Cannon Lake-LP (PCH)		0x9da3	32	hard	yes	yes	yes
+ * Cedar Fork (PCH)		0x18df	32	hard	yes	yes	yes
  *
  * Features supported by this driver:
  * Software PEC				no
 /* Older devices have their ID defined in <linux/pci_ids.h> */
 #define PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS		0x0f12
+#define PCI_DEVICE_ID_INTEL_CDF_SMBUS			0x18df
 #define PCI_DEVICE_ID_INTEL_DNV_SMBUS			0x19df
 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS		0x1c22
 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS		0x1d22
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BRASWELL_SMBUS) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS) },
+	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CDF_SMBUS) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DNV_SMBUS) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BROXTON_SMBUS) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS) },
 	case PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS:
 	case PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS:
 	case PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS:
+	case PCI_DEVICE_ID_INTEL_CDF_SMBUS:
 	case PCI_DEVICE_ID_INTEL_DNV_SMBUS:
 	case PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS:
 		priv->features |= FEATURE_I2C_BLOCK_READ;

drivers/i2c/busses/i2c-sprd.c+1−0

@@ -627,6 +627,7 @@ static const struct dev_pm_ops sprd_i2c_pm_ops = { · 626 unmodified lines
627		627
628	static const struct of_device_id sprd_i2c_of_match[] = {	628	static const struct of_device_id sprd_i2c_of_match[] = {
629	{ .compatible = "sprd,sc9860-i2c", },	629	{ .compatible = "sprd,sc9860-i2c", },
		630	{},
630	};	631	};
631		632
632	static struct platform_driver sprd_i2c_driver = {	633	static struct platform_driver sprd_i2c_driver = {

drivers/i2c/busses/i2c-stm32f7.c+7−10

 	unsigned int msg_num;
 	unsigned int msg_id;
 	struct stm32f7_i2c_msg f7_msg;
-	struct stm32f7_i2c_setup *setup;
+	struct stm32f7_i2c_setup setup;
 	struct stm32f7_i2c_timings timing;
 };
 	},
 };
-struct stm32f7_i2c_setup stm32f7_setup = {
+static const struct stm32f7_i2c_setup stm32f7_setup = {
 	.rise_time = STM32F7_I2C_RISE_TIME_DEFAULT,
 	.fall_time = STM32F7_I2C_FALL_TIME_DEFAULT,
 	.dnf = STM32F7_I2C_DNF_DEFAULT,
 	writel_relaxed(timing, i2c_dev->base + STM32F7_I2C_TIMINGR);
 	/* Enable I2C */
-	if (i2c_dev->setup->analog_filter)
+	if (i2c_dev->setup.analog_filter)
 		stm32f7_i2c_clr_bits(i2c_dev->base + STM32F7_I2C_CR1,
 				     STM32F7_I2C_CR1_ANFOFF);
 	else
 	}
 	setup = of_device_get_match_data(&pdev->dev);
-	i2c_dev->setup->rise_time = setup->rise_time;
+	i2c_dev->setup = *setup;
-	i2c_dev->setup->fall_time = setup->fall_time;
-	i2c_dev->setup->dnf = setup->dnf;
-	i2c_dev->setup->analog_filter = setup->analog_filter;
 	ret = device_property_read_u32(i2c_dev->dev, "i2c-scl-rising-time-ns",
 				       &rise_time);
 	if (!ret)
-		i2c_dev->setup->rise_time = rise_time;
+		i2c_dev->setup.rise_time = rise_time;
 	ret = device_property_read_u32(i2c_dev->dev, "i2c-scl-falling-time-ns",
 				       &fall_time);
 	if (!ret)
-		i2c_dev->setup->fall_time = fall_time;
+		i2c_dev->setup.fall_time = fall_time;
-	ret = stm32f7_i2c_setup_timing(i2c_dev, i2c_dev->setup);
+	ret = stm32f7_i2c_setup_timing(i2c_dev, &i2c_dev->setup);
 	if (ret)
 		goto clk_free;

drivers/ide/ide-probe.c+1−0

@@ -1451,6 +1451,7 @@ int ide_host_register(struct ide_host host, const struct ide_port_info d, · 1450 unmodified lines
1451	if (hwif_init(hwif) == 0) {	1451	if (hwif_init(hwif) == 0) {
1452	printk(KERN_INFO "%s: failed to initialize IDE "	1452	printk(KERN_INFO "%s: failed to initialize IDE "
1453	"interface\n", hwif->name);	1453	"interface\n", hwif->name);
		1454	device_unregister(hwif->portdev);
1454	device_unregister(&hwif->gendev);	1455	device_unregister(&hwif->gendev);
1455	ide_disable_port(hwif);	1456	ide_disable_port(hwif);
1456	continue;	1457	continue;

drivers/ide/ide-scan-pci.c+9−4

 {
 	struct list_head *l;
 	struct pci_driver *d;
+	int ret;
 	list_for_each(l, &ide_pci_drivers) {
 		d = list_entry(l, struct pci_driver, node);
 			const struct pci_device_id *id =
 				pci_match_id(d->id_table, dev);
-			if (id != NULL && d->probe(dev, id) >= 0) {
+			if (id != NULL) {
-				dev->driver = d;
+				pci_assign_irq(dev);
-				pci_dev_get(dev);
+				ret = d->probe(dev, id);
-				return 1;
+				if (ret >= 0) {
+					dev->driver = d;
+					pci_dev_get(dev);
+					return 1;
+				}
 			}
 		}
 	}

drivers/ide/setup-pci.c+40−23

 /**
  *	ide_pci_enable	-	do PCI enables
  *	@dev: PCI device
+ *	@bars: PCI BARs mask
  *	@d: IDE port info
  *
  *	Enable the IDE PCI device. We attempt to enable the device in full
  *	Returns zero on success or an error code
  */
-static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
+static int ide_pci_enable(struct pci_dev *dev, int bars,
+			  const struct ide_port_info *d)
 {
-	int ret, bars;
+	int ret;
 	if (pci_enable_device(dev)) {
 		ret = pci_enable_device_io(dev);
 		goto out;
 	}
-	if (d->host_flags & IDE_HFLAG_SINGLE)
-		bars = (1 << 2) - 1;
-	else
-		bars = (1 << 4) - 1;
-	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
-		if (d->host_flags & IDE_HFLAG_CS5520)
-			bars |= (1 << 2);
-		else
-			bars |= (1 << 4);
-	}
 	ret = pci_request_selected_regions(dev, bars, d->name);
 	if (ret < 0)
 		printk(KERN_ERR "%s %s: can't reserve resources\n",
 /**
  *	ide_setup_pci_controller	-	set up IDE PCI
  *	@dev: PCI device
+ *	@bars: PCI BARs mask
  *	@d: IDE port info
  *	@noisy: verbose flag
  *
  *	and enables it if need be
  */
-static int ide_setup_pci_controller(struct pci_dev *dev,
+static int ide_setup_pci_controller(struct pci_dev *dev, int bars,
 				    const struct ide_port_info *d, int noisy)
 {
 	int ret;
 	if (noisy)
 		ide_setup_pci_noise(dev, d);
-	ret = ide_pci_enable(dev, d);
+	ret = ide_pci_enable(dev, bars, d);
 	if (ret < 0)
 		goto out;
 	if (ret < 0) {
 		printk(KERN_ERR "%s %s: error accessing PCI regs\n",
 			d->name, pci_name(dev));
-		goto out;
+		goto out_free_bars;
 	}
 	if (!(pcicmd & PCI_COMMAND_IO)) {	/* is device disabled? */
 		ret = ide_pci_configure(dev, d);
 		if (ret < 0)
-			goto out;
+			goto out_free_bars;
 		printk(KERN_INFO "%s %s: device enabled (Linux)\n",
 			d->name, pci_name(dev));
 	}
+	goto out;
+out_free_bars:
+	pci_release_selected_regions(dev, bars);
 out:
 	return ret;
 }
 {
 	struct pci_dev *pdev[] = { dev1, dev2 };
 	struct ide_host *host;
-	int ret, i, n_ports = dev2 ? 4 : 2;
+	int ret, i, n_ports = dev2 ? 4 : 2, bars;
 	struct ide_hw hw[4], *hws[] = { NULL, NULL, NULL, NULL };
+	if (d->host_flags & IDE_HFLAG_SINGLE)
+		bars = (1 << 2) - 1;
+	else
+		bars = (1 << 4) - 1;
+	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
+		if (d->host_flags & IDE_HFLAG_CS5520)
+			bars |= (1 << 2);
+		else
+			bars |= (1 << 4);
+	}
 	for (i = 0; i < n_ports / 2; i++) {
-		ret = ide_setup_pci_controller(pdev[i], d, !i);
+		ret = ide_setup_pci_controller(pdev[i], bars, d, !i);
-		if (ret < 0)
+		if (ret < 0) {
+			if (i == 1)
+				pci_release_selected_regions(pdev[0], bars);
 			goto out;
+		}
 		ide_pci_setup_ports(pdev[i], d, &hw[i*2], &hws[i*2]);
 	}
 	host = ide_host_alloc(d, hws, n_ports);
 	if (host == NULL) {
 		ret = -ENOMEM;
-		goto out;
+		goto out_free_bars;
 	}
 	host->dev[0] = &dev1->dev;
 		 * do_ide_setup_pci_device() on the first device!
 		 */
 		if (ret < 0)
-			goto out;
+			goto out_free_bars;
 		/* fixup IRQ */
 		if (ide_pci_is_in_compatibility_mode(pdev[i])) {
 	ret = ide_host_register(host, d, hws);
 	if (ret)
 		ide_host_free(host);
+	else
+		goto out;
+out_free_bars:
+	i = n_ports / 2;
+	while (i--)
+		pci_release_selected_regions(pdev[i], bars);
 out:
 	return ret;
 }

drivers/infiniband/core/iwpm_msg.c+8−0

 	if (ret)
 		goto pid_query_error;
+	nlmsg_end(skb, nlh);
 	pr_debug("%s: Multicasting a nlmsg (dev = %s ifname = %s iwpm = %s)\n",
 		__func__, pm_msg->dev_name, pm_msg->if_name, iwpm_ulib_name);
 				&pm_msg->loc_addr, IWPM_NLA_MANAGE_ADDR);
 	if (ret)
 		goto add_mapping_error;
+	nlmsg_end(skb, nlh);
 	nlmsg_request->req_buffer = pm_msg;
 	ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
 				&pm_msg->rem_addr, IWPM_NLA_QUERY_REMOTE_ADDR);
 	if (ret)
 		goto query_mapping_error;
+	nlmsg_end(skb, nlh);
 	nlmsg_request->req_buffer = pm_msg;
 	ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
 	if (ret)
 		goto remove_mapping_error;
+	nlmsg_end(skb, nlh);
 	ret = rdma_nl_unicast_wait(skb, iwpm_user_pid);
 	if (ret) {
 		skb = NULL; /* skb is freed in the netlink send-op handling */

drivers/infiniband/core/iwpm_util.c+5−0

 				&mapping_num, IWPM_NLA_MAPINFO_SEND_NUM);
 	if (ret)
 		goto mapinfo_num_error;
+	nlmsg_end(skb, nlh);
 	ret = rdma_nl_unicast(skb, iwpm_pid);
 	if (ret) {
 		skb = NULL;
 			if (ret)
 				goto send_mapping_info_unlock;
+			nlmsg_end(skb, nlh);
 			iwpm_print_sockaddr(&map_info->local_sockaddr,
 				"send_mapping_info: Local sockaddr:");
 			iwpm_print_sockaddr(&map_info->mapped_sockaddr,

drivers/infiniband/hw/i40iw/i40iw_ctrl.c+1−1

@@ -48,7 +48,7 @@ · 47 unmodified lines
48	* @wqe: cqp wqe for header	48	* @wqe: cqp wqe for header
49	* @header: header for the cqp wqe	49	* @header: header for the cqp wqe
50	*/	50	*/
51	static inline void i40iw_insert_wqe_hdr(u64 *wqe, u64 header)	51	void i40iw_insert_wqe_hdr(u64 *wqe, u64 header)
52	{	52	{
53	wmb(); /* make sure WQE is populated before polarity is set */	53	wmb(); /* make sure WQE is populated before polarity is set */
54	set_64bit_val(wqe, 24, header);	54	set_64bit_val(wqe, 24, header);

drivers/infiniband/hw/i40iw/i40iw_p.h+2−0

@@ -59,6 +59,8 @@ enum i40iw_status_code i40iw_sc_mr_fast_register(struct i40iw_sc_qp *qp, · 58 unmodified lines
59	struct i40iw_fast_reg_stag_info *info,	59	struct i40iw_fast_reg_stag_info *info,
60	bool post_sq);	60	bool post_sq);
61		61
		62	void i40iw_insert_wqe_hdr(u64 *wqe, u64 header);
		63
62	/* HMC/FPM functions */	64	/* HMC/FPM functions */
63	enum i40iw_status_code i40iw_sc_init_iw_hmc(struct i40iw_sc_dev *dev,	65	enum i40iw_status_code i40iw_sc_init_iw_hmc(struct i40iw_sc_dev *dev,
64	u8 hmc_fn_id);	66	u8 hmc_fn_id);

drivers/infiniband/hw/i40iw/i40iw_puda.c+4−7

 		get_64bit_val(wqe, 24, &offset24);
 	offset24 = (offset24) ? 0 : LS_64(1, I40IWQPSQ_VALID);
-	set_64bit_val(wqe, 24, offset24);
 	set_64bit_val(wqe, 0, buf->mem.pa);
 	set_64bit_val(wqe, 8,
 		      LS_64(buf->mem.size, I40IWQPSQ_FRAG_LEN));
-	set_64bit_val(wqe, 24, offset24);
+	i40iw_insert_wqe_hdr(wqe, offset24);
 }
 /**
 	set_64bit_val(wqe, 8, LS_64(info->len, I40IWQPSQ_FRAG_LEN));
 	set_64bit_val(wqe, 16, header[0]);
-	/* Ensure all data is written before writing valid bit */
+	i40iw_insert_wqe_hdr(wqe, header[1]);
-	wmb();
-	set_64bit_val(wqe, 24, header[1]);
 	i40iw_debug_buf(qp->dev, I40IW_DEBUG_PUDA, "PUDA SEND WQE", wqe, 32);
 	i40iw_qp_post_wr(&qp->qp_uk);
 		 LS_64(2, I40IW_CQPSQ_QP_NEXTIWSTATE) |
 		 LS_64(cqp->polarity, I40IW_CQPSQ_WQEVALID);
-	set_64bit_val(wqe, 24, header);
+	i40iw_insert_wqe_hdr(wqe, header);
 	i40iw_debug_buf(cqp->dev, I40IW_DEBUG_PUDA, "PUDA CQE", wqe, 32);
 	i40iw_sc_cqp_post_sq(cqp);
 	    LS_64(1, I40IW_CQPSQ_CQ_ENCEQEMASK) |
 	    LS_64(1, I40IW_CQPSQ_CQ_CEQIDVALID) |
 	    LS_64(cqp->polarity, I40IW_CQPSQ_WQEVALID);
-	set_64bit_val(wqe, 24, header);
+	i40iw_insert_wqe_hdr(wqe, header);
 	i40iw_debug_buf(dev, I40IW_DEBUG_PUDA, "PUDA CQE",
 			wqe, I40IW_CQP_WQE_SIZE * 8);

drivers/infiniband/hw/i40iw/i40iw_verbs.c+2−0

 	attr->cap.max_inline_data = I40IW_MAX_INLINE_DATA_SIZE;
 	attr->cap.max_send_sge = I40IW_MAX_WQ_FRAGMENT_COUNT;
 	attr->cap.max_recv_sge = I40IW_MAX_WQ_FRAGMENT_COUNT;
+	attr->port_num = 1;
 	init_attr->event_handler = iwqp->ibqp.event_handler;
 	init_attr->qp_context = iwqp->ibqp.qp_context;
 	init_attr->send_cq = iwqp->ibqp.send_cq;
 	init_attr->recv_cq = iwqp->ibqp.recv_cq;
 	init_attr->srq = iwqp->ibqp.srq;
 	init_attr->cap = attr->cap;
+	init_attr->port_num = 1;
 	return 0;
 }

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

 err_uar_page:
 	mlx5_put_uars_page(dev->mdev, dev->mdev->priv.uar);
-err_cnt:
-	mlx5_ib_cleanup_cong_debugfs(dev);
 err_cong:
+	mlx5_ib_cleanup_cong_debugfs(dev);
+err_cnt:
 	if (MLX5_CAP_GEN(dev->mdev, max_qp_cnt))
 		mlx5_ib_dealloc_counters(dev);

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

@@ -387,7 +387,7 @@ struct qedr_qp { · 386 unmodified lines
387	u8 wqe_size;	387	u8 wqe_size;
388		388
389	u8 smac[ETH_ALEN];	389	u8 smac[ETH_ALEN];
390	u16 vlan_id;	390	u16 vlan;
391	int rc;	391	int rc;
392	} *rqe_wr_id;	392	} *rqe_wr_id;
393		393

drivers/infiniband/hw/qedr/qedr_cm.c+9−3

@@ -105,7 +105,7 @@ void qedr_ll2_complete_rx_packet(void *cxt, · 104 unmodified lines
105		105
106	qp->rqe_wr_id[qp->rq.gsi_cons].rc = data->u.data_length_error ?	106	qp->rqe_wr_id[qp->rq.gsi_cons].rc = data->u.data_length_error ?
107	-EINVAL : 0;	107	-EINVAL : 0;
108	qp->rqe_wr_id[qp->rq.gsi_cons].vlan_id = data->vlan;	108	qp->rqe_wr_id[qp->rq.gsi_cons].vlan = data->vlan;
109	/* note: length stands for data length i.e. GRH is excluded */	109	/* note: length stands for data length i.e. GRH is excluded */
110	qp->rqe_wr_id[qp->rq.gsi_cons].sg_list[0].length =	110	qp->rqe_wr_id[qp->rq.gsi_cons].sg_list[0].length =
111	data->length.data_length;	111	data->length.data_length;
@@ -694,6 +694,7 @@ int qedr_gsi_poll_cq(struct ib_cq ibcq, int num_entries, struct ib_wc wc) · 582 unmodified lines
694	struct qedr_cq *cq = get_qedr_cq(ibcq);	694	struct qedr_cq *cq = get_qedr_cq(ibcq);
695	struct qedr_qp *qp = dev->gsi_qp;	695	struct qedr_qp *qp = dev->gsi_qp;
696	unsigned long flags;	696	unsigned long flags;
		697	u16 vlan_id;
697	int i = 0;	698	int i = 0;
698		699
699	spin_lock_irqsave(&cq->cq_lock, flags);	700	spin_lock_irqsave(&cq->cq_lock, flags);
@@ -712,9 +713,14 @@ int qedr_gsi_poll_cq(struct ib_cq ibcq, int num_entries, struct ib_wc wc) · 12 unmodified lines
712	wc[i].wc_flags \|= IB_WC_GRH \| IB_WC_IP_CSUM_OK;	713	wc[i].wc_flags \|= IB_WC_GRH \| IB_WC_IP_CSUM_OK;
713	ether_addr_copy(wc[i].smac, qp->rqe_wr_id[qp->rq.cons].smac);	714	ether_addr_copy(wc[i].smac, qp->rqe_wr_id[qp->rq.cons].smac);
714	wc[i].wc_flags \|= IB_WC_WITH_SMAC;	715	wc[i].wc_flags \|= IB_WC_WITH_SMAC;
715	if (qp->rqe_wr_id[qp->rq.cons].vlan_id) {	716
		717	vlan_id = qp->rqe_wr_id[qp->rq.cons].vlan &
		718	VLAN_VID_MASK;
		719	if (vlan_id) {
716	wc[i].wc_flags \|= IB_WC_WITH_VLAN;	720	wc[i].wc_flags \|= IB_WC_WITH_VLAN;
717	wc[i].vlan_id = qp->rqe_wr_id[qp->rq.cons].vlan_id;	721	wc[i].vlan_id = vlan_id;
		722	wc[i].sl = (qp->rqe_wr_id[qp->rq.cons].vlan &
		723	VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
718	}	724	}
719		725
720	qedr_inc_sw_cons(&qp->rq);	726	qedr_inc_sw_cons(&qp->rq);

drivers/md/bcache/closure.c+2−2

@@ -64,7 +64,7 @@ EXPORT_SYMBOL(closure_put); · 63 unmodified lines
64	void __closure_wake_up(struct closure_waitlist *wait_list)	64	void __closure_wake_up(struct closure_waitlist *wait_list)
65	{	65	{
66	struct llist_node *list;	66	struct llist_node *list;
67	struct closure *cl;	67	struct closure cl, t;
68	struct llist_node *reverse = NULL;	68	struct llist_node *reverse = NULL;
69		69
70	list = llist_del_all(&wait_list->list);	70	list = llist_del_all(&wait_list->list);
@@ -73,7 +73,7 @@ void __closure_wake_up(struct closure_waitlist *wait_list) · 2 unmodified lines
73	reverse = llist_reverse_order(list);	73	reverse = llist_reverse_order(list);
74		74
75	/* Then do the wakeups */	75	/* Then do the wakeups */
76	llist_for_each_entry(cl, reverse, list) {	76	llist_for_each_entry_safe(cl, t, reverse, list) {
77	closure_set_waiting(cl, 0);	77	closure_set_waiting(cl, 0);
78	closure_sub(cl, CLOSURE_WAITING + 1);	78	closure_sub(cl, CLOSURE_WAITING + 1);
79	}	79	}

drivers/misc/cxl/cxllib.c+11−2

@@ -219,8 +219,17 @@ int cxllib_handle_fault(struct mm_struct *mm, u64 addr, u64 size, u64 flags) · 218 unmodified lines
219		219
220	down_read(&mm->mmap_sem);	220	down_read(&mm->mmap_sem);
221		221
222	for (dar = addr; dar < addr + size; dar += page_size) {	222	vma = find_vma(mm, addr);
223	if (!vma \|\| dar < vma->vm_start \|\| dar > vma->vm_end) {	223	if (!vma) {
		224	pr_err("Can't find vma for addr %016llx\n", addr);
		225	rc = -EFAULT;
		226	goto out;
		227	}
		228	/* get the size of the pages allocated */
		229	page_size = vma_kernel_pagesize(vma);
		230
		231	for (dar = (addr & ~(page_size - 1)); dar < (addr + size); dar += page_size) {
		232	if (dar < vma->vm_start \|\| dar >= vma->vm_end) {
224	vma = find_vma(mm, addr);	233	vma = find_vma(mm, addr);
225	if (!vma) {	234	if (!vma) {
226	pr_err("Can't find vma for addr %016llx\n", addr);	235	pr_err("Can't find vma for addr %016llx\n", addr);

drivers/mmc/core/block.c+0−3

 	}
 	mqrq->areq.mrq = &brq->mrq;
-	mmc_queue_bounce_pre(mqrq);
 }
 static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
 		brq = &mq_rq->brq;
 		old_req = mmc_queue_req_to_req(mq_rq);
 		type = rq_data_dir(old_req) == READ ? MMC_BLK_READ : MMC_BLK_WRITE;
-		mmc_queue_bounce_post(mq_rq);
 		switch (status) {
 		case MMC_BLK_SUCCESS:

drivers/mmc/core/mmc.c+19−17

 	return err;
 }
+static void mmc_select_driver_type(struct mmc_card *card)
+{
+	int card_drv_type, drive_strength, drv_type;
+	card_drv_type = card->ext_csd.raw_driver_strength |
+			mmc_driver_type_mask(0);
+	drive_strength = mmc_select_drive_strength(card,
+						   card->ext_csd.hs200_max_dtr,
+						   card_drv_type, &drv_type);
+	card->drive_strength = drive_strength;
+	if (drv_type)
+		mmc_set_driver_type(card->host, drv_type);
+}
 static int mmc_select_hs400es(struct mmc_card *card)
 {
 	struct mmc_host *host = card->host;
 		goto out_err;
 	}
+	mmc_select_driver_type(card);
 	/* Switch card to HS400 */
 	val = EXT_CSD_TIMING_HS400 |
 	      card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
 	return err;
 }
-static void mmc_select_driver_type(struct mmc_card *card)
-{
-	int card_drv_type, drive_strength, drv_type;
-	card_drv_type = card->ext_csd.raw_driver_strength |
-			mmc_driver_type_mask(0);
-	drive_strength = mmc_select_drive_strength(card,
-						   card->ext_csd.hs200_max_dtr,
-						   card_drv_type, &drv_type);
-	card->drive_strength = drive_strength;
-	if (drv_type)
-		mmc_set_driver_type(card->host, drv_type);
-}
 /*
  * For device supporting HS200 mode, the following sequence
  * should be done before executing the tuning process.

drivers/mmc/core/queue.c+9−116

@@ -23,8 +23,6 @@ · 22 unmodified lines
23	#include "core.h"	23	#include "core.h"
24	#include "card.h"	24	#include "card.h"
25		25
26	#define MMC_QUEUE_BOUNCESZ 65536
27
28	/*	26	/*
29	* Prepare a MMC request. This just filters out odd stuff.	27	* Prepare a MMC request. This just filters out odd stuff.
30	*/	28	*/
@@ -150,26 +148,6 @@ static void mmc_queue_setup_discard(struct request_queue *q, · 119 unmodified lines
150	queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);	148	queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
151	}	149	}
152		150
153	static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
154	{
155	unsigned int bouncesz = MMC_QUEUE_BOUNCESZ;
156
157	if (host->max_segs != 1 \|\| (host->caps & MMC_CAP_NO_BOUNCE_BUFF))
158	return 0;
159
160	if (bouncesz > host->max_req_size)
161	bouncesz = host->max_req_size;
162	if (bouncesz > host->max_seg_size)
163	bouncesz = host->max_seg_size;
164	if (bouncesz > host->max_blk_count * 512)
165	bouncesz = host->max_blk_count * 512;
166
167	if (bouncesz <= 512)
168	return 0;
169
170	return bouncesz;
171	}
172
173	/**	151	/**
174	* mmc_init_request() - initialize the MMC-specific per-request data	152	* mmc_init_request() - initialize the MMC-specific per-request data
175	* @q: the request queue	153	* @q: the request queue
@@ -184,26 +162,9 @@ static int mmc_init_request(struct request_queue q, struct request req, · 8 unmodified lines
184	struct mmc_card *card = mq->card;	162	struct mmc_card *card = mq->card;
185	struct mmc_host *host = card->host;	163	struct mmc_host *host = card->host;
186		164
187	if (card->bouncesz) {	165	mq_rq->sg = mmc_alloc_sg(host->max_segs, gfp);
188	mq_rq->bounce_buf = kmalloc(card->bouncesz, gfp);	166	if (!mq_rq->sg)
189	if (!mq_rq->bounce_buf)	167	return -ENOMEM;
190	return -ENOMEM;
191	if (card->bouncesz > 512) {
192	mq_rq->sg = mmc_alloc_sg(1, gfp);
193	if (!mq_rq->sg)
194	return -ENOMEM;
195	mq_rq->bounce_sg = mmc_alloc_sg(card->bouncesz / 512,
196	gfp);
197	if (!mq_rq->bounce_sg)
198	return -ENOMEM;
199	}
200	} else {
201	mq_rq->bounce_buf = NULL;
202	mq_rq->bounce_sg = NULL;
203	mq_rq->sg = mmc_alloc_sg(host->max_segs, gfp);
204	if (!mq_rq->sg)
205	return -ENOMEM;
206	}
207		168
208	return 0;	169	return 0;
209	}	170	}
@@ -212,13 +173,6 @@ static void mmc_exit_request(struct request_queue q, struct request req) · 2 unmodified lines
212	{	173	{
213	struct mmc_queue_req *mq_rq = req_to_mmc_queue_req(req);	174	struct mmc_queue_req *mq_rq = req_to_mmc_queue_req(req);
214		175
215	/* It is OK to kfree(NULL) so this will be smooth */
216	kfree(mq_rq->bounce_sg);
217	mq_rq->bounce_sg = NULL;
218
219	kfree(mq_rq->bounce_buf);
220	mq_rq->bounce_buf = NULL;
221
222	kfree(mq_rq->sg);	176	kfree(mq_rq->sg);
223	mq_rq->sg = NULL;	177	mq_rq->sg = NULL;
224	}	178	}
@@ -242,12 +196,6 @@ int mmc_init_queue(struct mmc_queue mq, struct mmc_card card, · 17 unmodified lines
242	if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)	196	if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
243	limit = (u64)dma_max_pfn(mmc_dev(host)) << PAGE_SHIFT;	197	limit = (u64)dma_max_pfn(mmc_dev(host)) << PAGE_SHIFT;
244		198
245	/*
246	* mmc_init_request() depends on card->bouncesz so it must be calculated
247	* before blk_init_allocated_queue() starts allocating requests.
248	*/
249	card->bouncesz = mmc_queue_calc_bouncesz(host);
250
251	mq->card = card;	199	mq->card = card;
252	mq->queue = blk_alloc_queue(GFP_KERNEL);	200	mq->queue = blk_alloc_queue(GFP_KERNEL);
253	if (!mq->queue)	201	if (!mq->queue)
@@ -271,17 +219,11 @@ int mmc_init_queue(struct mmc_queue mq, struct mmc_card card, · 17 unmodified lines
271	if (mmc_can_erase(card))	219	if (mmc_can_erase(card))
272	mmc_queue_setup_discard(mq->queue, card);	220	mmc_queue_setup_discard(mq->queue, card);
273		221
274	if (card->bouncesz) {	222	blk_queue_bounce_limit(mq->queue, limit);
275	blk_queue_max_hw_sectors(mq->queue, card->bouncesz / 512);	223	blk_queue_max_hw_sectors(mq->queue,
276	blk_queue_max_segments(mq->queue, card->bouncesz / 512);	224	min(host->max_blk_count, host->max_req_size / 512));
277	blk_queue_max_segment_size(mq->queue, card->bouncesz);	225	blk_queue_max_segments(mq->queue, host->max_segs);
278	} else {	226	blk_queue_max_segment_size(mq->queue, host->max_seg_size);
279	blk_queue_bounce_limit(mq->queue, limit);
280	blk_queue_max_hw_sectors(mq->queue,
281	min(host->max_blk_count, host->max_req_size / 512));
282	blk_queue_max_segments(mq->queue, host->max_segs);
283	blk_queue_max_segment_size(mq->queue, host->max_seg_size);
284	}
285		227
286	sema_init(&mq->thread_sem, 1);	228	sema_init(&mq->thread_sem, 1);
287		229
@@ -370,56 +312,7 @@ void mmc_queue_resume(struct mmc_queue *mq) · 82 unmodified lines
370	*/	312	*/
371	unsigned int mmc_queue_map_sg(struct mmc_queue mq, struct mmc_queue_req mqrq)	313	unsigned int mmc_queue_map_sg(struct mmc_queue mq, struct mmc_queue_req mqrq)
372	{	314	{
373	unsigned int sg_len;
374	size_t buflen;
375	struct scatterlist *sg;
376	struct request *req = mmc_queue_req_to_req(mqrq);	315	struct request *req = mmc_queue_req_to_req(mqrq);
377	int i;
378
379	if (!mqrq->bounce_buf)
380	return blk_rq_map_sg(mq->queue, req, mqrq->sg);
381
382	sg_len = blk_rq_map_sg(mq->queue, req, mqrq->bounce_sg);
383
384	mqrq->bounce_sg_len = sg_len;
385
386	buflen = 0;
387	for_each_sg(mqrq->bounce_sg, sg, sg_len, i)
388	buflen += sg->length;
389
390	sg_init_one(mqrq->sg, mqrq->bounce_buf, buflen);
391
392	return 1;
393	}
394
395	/*
396	* If writing, bounce the data to the buffer before the request
397	* is sent to the host driver
398	*/
399	void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
400	{
401	if (!mqrq->bounce_buf)
402	return;
403
404	if (rq_data_dir(mmc_queue_req_to_req(mqrq)) != WRITE)
405	return;
406
407	sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
408	mqrq->bounce_buf, mqrq->sg[0].length);
409	}
410
411	/*
412	* If reading, bounce the data from the buffer after the request
413	* has been handled by the host driver
414	*/
415	void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
416	{
417	if (!mqrq->bounce_buf)
418	return;
419
420	if (rq_data_dir(mmc_queue_req_to_req(mqrq)) != READ)
421	return;
422		316
423	sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,	317	return blk_rq_map_sg(mq->queue, req, mqrq->sg);
424	mqrq->bounce_buf, mqrq->sg[0].length);
425	}	318	}

drivers/mmc/core/queue.h+0−6

 struct mmc_queue_req {
 	struct mmc_blk_request	brq;
 	struct scatterlist	*sg;
-	char			*bounce_buf;
-	struct scatterlist	*bounce_sg;
-	unsigned int		bounce_sg_len;
 	struct mmc_async_req	areq;
 	enum mmc_drv_op		drv_op;
 	int			drv_op_result;
 extern void mmc_cleanup_queue(struct mmc_queue *);
 extern void mmc_queue_suspend(struct mmc_queue *);
 extern void mmc_queue_resume(struct mmc_queue *);
 extern unsigned int mmc_queue_map_sg(struct mmc_queue *,
 				     struct mmc_queue_req *);
-extern void mmc_queue_bounce_pre(struct mmc_queue_req *);
-extern void mmc_queue_bounce_post(struct mmc_queue_req *);
 extern int mmc_access_rpmb(struct mmc_queue *);

drivers/mmc/host/cavium.c+1−1

@@ -1038,7 +1038,7 @@ int cvm_mmc_of_slot_probe(struct device dev, struct cvm_mmc_host host) · 1037 unmodified lines
1038	*/	1038	*/
1039	mmc->caps \|= MMC_CAP_MMC_HIGHSPEED \| MMC_CAP_SD_HIGHSPEED \|	1039	mmc->caps \|= MMC_CAP_MMC_HIGHSPEED \| MMC_CAP_SD_HIGHSPEED \|
1040	MMC_CAP_ERASE \| MMC_CAP_CMD23 \| MMC_CAP_POWER_OFF_CARD \|	1040	MMC_CAP_ERASE \| MMC_CAP_CMD23 \| MMC_CAP_POWER_OFF_CARD \|
1041	MMC_CAP_3_3V_DDR \| MMC_CAP_NO_BOUNCE_BUFF;	1041	MMC_CAP_3_3V_DDR;
1042		1042
1043	if (host->use_sg)	1043	if (host->use_sg)
1044	mmc->max_segs = 16;	1044	mmc->max_segs = 16;

drivers/mmc/host/meson-gx-mmc.c+22−4

 	div->shift = __ffs(CLK_DIV_MASK);
 	div->width = __builtin_popcountl(CLK_DIV_MASK);
 	div->hw.init = &init;
-	div->flags = (CLK_DIVIDER_ONE_BASED |
+	div->flags = CLK_DIVIDER_ONE_BASED;
-		      CLK_DIVIDER_ROUND_CLOSEST);
 	clk = devm_clk_register(host->dev, &div->hw);
 	if (WARN_ON(IS_ERR(clk)))
 static int meson_mmc_execute_tuning(struct mmc_host *mmc, u32 opcode)
 {
 	struct meson_host *host = mmc_priv(mmc);
+	int ret;
+	/*
+	 * If this is the initial tuning, try to get a sane Rx starting
+	 * phase before doing the actual tuning.
+	 */
+	if (!mmc->doing_retune) {
+		ret = meson_mmc_clk_phase_tuning(mmc, opcode, host->rx_clk);
+		if (ret)
+			return ret;
+	}
+	ret = meson_mmc_clk_phase_tuning(mmc, opcode, host->tx_clk);
+	if (ret)
+		return ret;
 	return meson_mmc_clk_phase_tuning(mmc, opcode, host->rx_clk);
 }
 	case MMC_POWER_UP:
 		if (!IS_ERR(mmc->supply.vmmc))
 			mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, ios->vdd);
+		/* Reset phases */
+		clk_set_phase(host->rx_clk, 0);
+		clk_set_phase(host->tx_clk, 270);
 		break;
 	case MMC_POWER_ON:
 				host->vqmmc_enabled = true;
 		}
-		/* Reset rx phase */
-		clk_set_phase(host->rx_clk, 0);
 		break;
 	}

drivers/mmc/host/pxamci.c+1−5

 	pxamci_init_ocr(host);
-	/*
+	mmc->caps = 0;
-	 * This architecture used to disable bounce buffers through its
-	 * defconfig, now it is done at runtime as a host property.
-	 */
-	mmc->caps = MMC_CAP_NO_BOUNCE_BUFF;
 	host->cmdat = 0;
 	if (!cpu_is_pxa25x()) {
 		mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;

drivers/mmc/host/sdhci-xenon.c+20−4

@@ -466,6 +466,7 @@ static int xenon_probe(struct platform_device *pdev) · 465 unmodified lines
466	{	466	{
467	struct sdhci_pltfm_host *pltfm_host;	467	struct sdhci_pltfm_host *pltfm_host;
468	struct sdhci_host *host;	468	struct sdhci_host *host;
		469	struct xenon_priv *priv;
469	int err;	470	int err;
470		471
471	host = sdhci_pltfm_init(pdev, &sdhci_xenon_pdata,	472	host = sdhci_pltfm_init(pdev, &sdhci_xenon_pdata,
@@ -474,6 +475,7 @@ static int xenon_probe(struct platform_device *pdev) · 2 unmodified lines
474	return PTR_ERR(host);	475	return PTR_ERR(host);
475		476
476	pltfm_host = sdhci_priv(host);	477	pltfm_host = sdhci_priv(host);
		478	priv = sdhci_pltfm_priv(pltfm_host);
477		479
478	/*	480	/*
479	* Link Xenon specific mmc_host_ops function,	481	* Link Xenon specific mmc_host_ops function,
@@ -491,9 +493,20 @@ static int xenon_probe(struct platform_device *pdev) · 11 unmodified lines
491	if (err)	493	if (err)
492	goto free_pltfm;	494	goto free_pltfm;
493		495
		496	priv->axi_clk = devm_clk_get(&pdev->dev, "axi");
		497	if (IS_ERR(priv->axi_clk)) {
		498	err = PTR_ERR(priv->axi_clk);
		499	if (err == -EPROBE_DEFER)
		500	goto err_clk;
		501	} else {
		502	err = clk_prepare_enable(priv->axi_clk);
		503	if (err)
		504	goto err_clk;
		505	}
		506
494	err = mmc_of_parse(host->mmc);	507	err = mmc_of_parse(host->mmc);
495	if (err)	508	if (err)
496	goto err_clk;	509	goto err_clk_axi;
497		510
498	sdhci_get_of_property(pdev);	511	sdhci_get_of_property(pdev);
499		512
@@ -502,11 +515,11 @@ static int xenon_probe(struct platform_device *pdev) · 2 unmodified lines
502	/* Xenon specific dt parse */	515	/* Xenon specific dt parse */
503	err = xenon_probe_dt(pdev);	516	err = xenon_probe_dt(pdev);
504	if (err)	517	if (err)
505	goto err_clk;	518	goto err_clk_axi;
506		519
507	err = xenon_sdhc_prepare(host);	520	err = xenon_sdhc_prepare(host);
508	if (err)	521	if (err)
509	goto err_clk;	522	goto err_clk_axi;
510		523
511	pm_runtime_get_noresume(&pdev->dev);	524	pm_runtime_get_noresume(&pdev->dev);
512	pm_runtime_set_active(&pdev->dev);	525	pm_runtime_set_active(&pdev->dev);
@@ -527,6 +540,8 @@ remove_sdhc: · 14 unmodified lines
527	pm_runtime_disable(&pdev->dev);	540	pm_runtime_disable(&pdev->dev);
528	pm_runtime_put_noidle(&pdev->dev);	541	pm_runtime_put_noidle(&pdev->dev);
529	xenon_sdhc_unprepare(host);	542	xenon_sdhc_unprepare(host);
		543	err_clk_axi:
		544	clk_disable_unprepare(priv->axi_clk);
530	err_clk:	545	err_clk:
531	clk_disable_unprepare(pltfm_host->clk);	546	clk_disable_unprepare(pltfm_host->clk);
532	free_pltfm:	547	free_pltfm:
@@ -538,6 +553,7 @@ static int xenon_remove(struct platform_device *pdev) · 5 unmodified lines
538	{	553	{
539	struct sdhci_host *host = platform_get_drvdata(pdev);	554	struct sdhci_host *host = platform_get_drvdata(pdev);
540	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);	555	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
		556	struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
541		557
542	pm_runtime_get_sync(&pdev->dev);	558	pm_runtime_get_sync(&pdev->dev);
543	pm_runtime_disable(&pdev->dev);	559	pm_runtime_disable(&pdev->dev);
@@ -546,7 +562,7 @@ static int xenon_remove(struct platform_device *pdev) · 2 unmodified lines
546	sdhci_remove_host(host, 0);	562	sdhci_remove_host(host, 0);
547		563
548	xenon_sdhc_unprepare(host);	564	xenon_sdhc_unprepare(host);
549		565	clk_disable_unprepare(priv->axi_clk);
550	clk_disable_unprepare(pltfm_host->clk);	566	clk_disable_unprepare(pltfm_host->clk);
551		567
552	sdhci_pltfm_free(pdev);	568	sdhci_pltfm_free(pdev);

drivers/mmc/host/sdhci-xenon.h+1−0

@@ -83,6 +83,7 @@ struct xenon_priv { · 82 unmodified lines
83	unsigned char bus_width;	83	unsigned char bus_width;
84	unsigned char timing;	84	unsigned char timing;
85	unsigned int clock;	85	unsigned int clock;
		86	struct clk *axi_clk;
86		87
87	int phy_type;	88	int phy_type;
88	/*	89	/*

drivers/net/ethernet/cavium/thunder/nicvf_main.c+2−0

 		return true;
 	default:
 		bpf_warn_invalid_xdp_action(action);
+		/* fall through */
 	case XDP_ABORTED:
 		trace_xdp_exception(nic->netdev, prog, action);
+		/* fall through */
 	case XDP_DROP:
 		/* Check if it's a recycled page, if not
 		 * unmap the DMA mapping.

drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c+0−22

@@ -175,31 +175,9 @@ static s32 ixgbe_init_phy_ops_82598(struct ixgbe_hw *hw) · 174 unmodified lines
175	**/	175	**/
176	static s32 ixgbe_start_hw_82598(struct ixgbe_hw *hw)	176	static s32 ixgbe_start_hw_82598(struct ixgbe_hw *hw)
177	{	177	{
178	#ifndef CONFIG_SPARC
179	u32 regval;
180	u32 i;
181	#endif
182	s32 ret_val;	178	s32 ret_val;
183		179
184	ret_val = ixgbe_start_hw_generic(hw);	180	ret_val = ixgbe_start_hw_generic(hw);
185
186	#ifndef CONFIG_SPARC
187	/* Disable relaxed ordering */
188	for (i = 0; ((i < hw->mac.max_tx_queues) &&
189	(i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
190	regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i));
191	regval &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
192	IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), regval);
193	}
194
195	for (i = 0; ((i < hw->mac.max_rx_queues) &&
196	(i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
197	regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
198	regval &= ~(IXGBE_DCA_RXCTRL_DATA_WRO_EN \|
199	IXGBE_DCA_RXCTRL_HEAD_WRO_EN);
200	IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
201	}
202	#endif
203	if (ret_val)	181	if (ret_val)
204	return ret_val;	182	return ret_val;
205		183

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c+0−19

@@ -366,25 +366,6 @@ s32 ixgbe_start_hw_gen2(struct ixgbe_hw *hw) · 365 unmodified lines
366	}	366	}
367	IXGBE_WRITE_FLUSH(hw);	367	IXGBE_WRITE_FLUSH(hw);
368		368
369	#ifndef CONFIG_ARCH_WANT_RELAX_ORDER
370	/* Disable relaxed ordering */
371	for (i = 0; i < hw->mac.max_tx_queues; i++) {
372	u32 regval;
373
374	regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(i));
375	regval &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
376	IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(i), regval);
377	}
378
379	for (i = 0; i < hw->mac.max_rx_queues; i++) {
380	u32 regval;
381
382	regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
383	regval &= ~(IXGBE_DCA_RXCTRL_DATA_WRO_EN \|
384	IXGBE_DCA_RXCTRL_HEAD_WRO_EN);
385	IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
386	}
387	#endif
388	return 0;	369	return 0;
389	}	370	}
390		371

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c+8−8

@@ -1049,7 +1049,7 @@ static int ixgbe_set_ringparam(struct net_device *netdev, · 1048 unmodified lines
1049	{	1049	{
1050	struct ixgbe_adapter *adapter = netdev_priv(netdev);	1050	struct ixgbe_adapter *adapter = netdev_priv(netdev);
1051	struct ixgbe_ring *temp_ring;	1051	struct ixgbe_ring *temp_ring;
1052	int i, err = 0;	1052	int i, j, err = 0;
1053	u32 new_rx_count, new_tx_count;	1053	u32 new_rx_count, new_tx_count;
1054		1054
1055	if ((ring->rx_mini_pending) \|\| (ring->rx_jumbo_pending))	1055	if ((ring->rx_mini_pending) \|\| (ring->rx_jumbo_pending))
@@ -1086,8 +1086,8 @@ static int ixgbe_set_ringparam(struct net_device *netdev, · 30 unmodified lines
1086	}	1086	}
1087		1087
1088	/* allocate temporary buffer to store rings in */	1088	/* allocate temporary buffer to store rings in */
1089	i = max_t(int, adapter->num_tx_queues, adapter->num_rx_queues);	1089	i = max_t(int, adapter->num_tx_queues + adapter->num_xdp_queues,
1090	i = max_t(int, i, adapter->num_xdp_queues);	1090	adapter->num_rx_queues);
1091	temp_ring = vmalloc(i * sizeof(struct ixgbe_ring));	1091	temp_ring = vmalloc(i * sizeof(struct ixgbe_ring));
1092		1092
1093	if (!temp_ring) {	1093	if (!temp_ring) {
@@ -1119,8 +1119,8 @@ static int ixgbe_set_ringparam(struct net_device *netdev, · 25 unmodified lines
1119	}	1119	}
1120	}	1120	}
1121		1121
1122	for (i = 0; i < adapter->num_xdp_queues; i++) {	1122	for (j = 0; j < adapter->num_xdp_queues; j++, i++) {
1123	memcpy(&temp_ring[i], adapter->xdp_ring[i],	1123	memcpy(&temp_ring[i], adapter->xdp_ring[j],
1124	sizeof(struct ixgbe_ring));	1124	sizeof(struct ixgbe_ring));
1125		1125
1126	temp_ring[i].count = new_tx_count;	1126	temp_ring[i].count = new_tx_count;
@@ -1140,10 +1140,10 @@ static int ixgbe_set_ringparam(struct net_device *netdev, · 13 unmodified lines
1140	memcpy(adapter->tx_ring[i], &temp_ring[i],	1140	memcpy(adapter->tx_ring[i], &temp_ring[i],
1141	sizeof(struct ixgbe_ring));	1141	sizeof(struct ixgbe_ring));
1142	}	1142	}
1143	for (i = 0; i < adapter->num_xdp_queues; i++) {	1143	for (j = 0; j < adapter->num_xdp_queues; j++, i++) {
1144	ixgbe_free_tx_resources(adapter->xdp_ring[i]);	1144	ixgbe_free_tx_resources(adapter->xdp_ring[j]);
1145		1145
1146	memcpy(adapter->xdp_ring[i], &temp_ring[i],	1146	memcpy(adapter->xdp_ring[j], &temp_ring[i],
1147	sizeof(struct ixgbe_ring));	1147	sizeof(struct ixgbe_ring));
1148	}	1148	}
1149		1149

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+5−1

 				IXGBE_FLAG_GENEVE_OFFLOAD_CAPABLE)))
 		return;
-	vxlanctrl = IXGBE_READ_REG(hw, IXGBE_VXLANCTRL) && ~mask;
+	vxlanctrl = IXGBE_READ_REG(hw, IXGBE_VXLANCTRL) & ~mask;
 	IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, vxlanctrl);
 	if (mask & IXGBE_VXLANCTRL_VXLAN_UDPPORT_MASK)
 		return ixgbe_ptp_set_ts_config(adapter, req);
 	case SIOCGHWTSTAMP:
 		return ixgbe_ptp_get_ts_config(adapter, req);
+	case SIOCGMIIPHY:
+		if (!adapter->hw.phy.ops.read_reg)
+			return -EOPNOTSUPP;
+		/* fall through */
 	default:
 		return mdio_mii_ioctl(&adapter->hw.phy.mdio, if_mii(req), cmd);
 	}

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

@@ -3640,20 +3640,6 @@ static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp, · 3639 unmodified lines
3640	static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,	3640	static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
3641	struct mlxsw_sp_fib *fib)	3641	struct mlxsw_sp_fib *fib)
3642	{	3642	{
3643	struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3644	struct mlxsw_sp_lpm_tree *lpm_tree;
3645
3646	/* Aggregate prefix lengths across all virtual routers to make
3647	* sure we only have used prefix lengths in the LPM tree.
3648	*/
3649	mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3650	lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3651	fib->proto);
3652	if (IS_ERR(lpm_tree))
3653	goto err_tree_get;
3654	mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3655
3656	err_tree_get:
3657	if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage))	3643	if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage))
3658	return;	3644	return;
3659	mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);	3645	mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);

drivers/net/ppp/ppp_generic.c+20−0

@@ -1339,7 +1339,17 @@ ppp_get_stats64(struct net_device dev, struct rtnl_link_stats64 stats64) · 1338 unmodified lines
1339		1339
1340	static int ppp_dev_init(struct net_device *dev)	1340	static int ppp_dev_init(struct net_device *dev)
1341	{	1341	{
		1342	struct ppp *ppp;
		1343
1342	netdev_lockdep_set_classes(dev);	1344	netdev_lockdep_set_classes(dev);
		1345
		1346	ppp = netdev_priv(dev);
		1347	/* Let the netdevice take a reference on the ppp file. This ensures
		1348	* that ppp_destroy_interface() won't run before the device gets
		1349	* unregistered.
		1350	*/
		1351	atomic_inc(&ppp->file.refcnt);
		1352
1343	return 0;	1353	return 0;
1344	}	1354	}
1345		1355
@@ -1362,6 +1372,15 @@ static void ppp_dev_uninit(struct net_device *dev) · 16 unmodified lines
1362	wake_up_interruptible(&ppp->file.rwait);	1372	wake_up_interruptible(&ppp->file.rwait);
1363	}	1373	}
1364		1374
		1375	static void ppp_dev_priv_destructor(struct net_device *dev)
		1376	{
		1377	struct ppp *ppp;
		1378
		1379	ppp = netdev_priv(dev);
		1380	if (atomic_dec_and_test(&ppp->file.refcnt))
		1381	ppp_destroy_interface(ppp);
		1382	}
		1383
1365	static const struct net_device_ops ppp_netdev_ops = {	1384	static const struct net_device_ops ppp_netdev_ops = {
1366	.ndo_init = ppp_dev_init,	1385	.ndo_init = ppp_dev_init,
1367	.ndo_uninit = ppp_dev_uninit,	1386	.ndo_uninit = ppp_dev_uninit,
@@ -1387,6 +1406,7 @@ static void ppp_setup(struct net_device *dev) · 19 unmodified lines
1387	dev->tx_queue_len = 3;	1406	dev->tx_queue_len = 3;
1388	dev->type = ARPHRD_PPP;	1407	dev->type = ARPHRD_PPP;
1389	dev->flags = IFF_POINTOPOINT \| IFF_NOARP \| IFF_MULTICAST;	1408	dev->flags = IFF_POINTOPOINT \| IFF_NOARP \| IFF_MULTICAST;
		1409	dev->priv_destructor = ppp_dev_priv_destructor;
1390	netif_keep_dst(dev);	1410	netif_keep_dst(dev);
1391	}	1411	}
1392		1412

drivers/net/usb/cdc_ether.c+13−0

@@ -560,6 +560,7 @@ static const struct driver_info wwan_info = { · 559 unmodified lines
560	#define NVIDIA_VENDOR_ID 0x0955	560	#define NVIDIA_VENDOR_ID 0x0955
561	#define HP_VENDOR_ID 0x03f0	561	#define HP_VENDOR_ID 0x03f0
562	#define MICROSOFT_VENDOR_ID 0x045e	562	#define MICROSOFT_VENDOR_ID 0x045e
		563	#define UBLOX_VENDOR_ID 0x1546
563		564
564	static const struct usb_device_id products[] = {	565	static const struct usb_device_id products[] = {
565	/* BLACKLIST !!	566	/* BLACKLIST !!
@@ -868,6 +869,18 @@ static const struct usb_device_id products[] = { · 302 unmodified lines
868	USB_CDC_SUBCLASS_ETHERNET,	869	USB_CDC_SUBCLASS_ETHERNET,
869	USB_CDC_PROTO_NONE),	870	USB_CDC_PROTO_NONE),
870	.driver_info = (unsigned long)&zte_cdc_info,	871	.driver_info = (unsigned long)&zte_cdc_info,
		872	}, {
		873	/* U-blox TOBY-L2 */
		874	USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1143, USB_CLASS_COMM,
		875	USB_CDC_SUBCLASS_ETHERNET,
		876	USB_CDC_PROTO_NONE),
		877	.driver_info = (unsigned long)&wwan_info,
		878	}, {
		879	/* U-blox SARA-U2 */
		880	USB_DEVICE_AND_INTERFACE_INFO(UBLOX_VENDOR_ID, 0x1104, USB_CLASS_COMM,
		881	USB_CDC_SUBCLASS_ETHERNET,
		882	USB_CDC_PROTO_NONE),
		883	.driver_info = (unsigned long)&wwan_info,
871	}, {	884	}, {
872	USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,	885	USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
873	USB_CDC_PROTO_NONE),	886	USB_CDC_PROTO_NONE),

drivers/nvme/host/core.c+1−1

@@ -2136,7 +2136,7 @@ static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj, · 2135 unmodified lines
2136	struct nvme_ns *ns = nvme_get_ns_from_dev(dev);	2136	struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
2137		2137
2138	if (a == &dev_attr_uuid.attr) {	2138	if (a == &dev_attr_uuid.attr) {
2139	if (uuid_is_null(&ns->uuid) \|\|	2139	if (uuid_is_null(&ns->uuid) &&
2140	!memchr_inv(ns->nguid, 0, sizeof(ns->nguid)))	2140	!memchr_inv(ns->nguid, 0, sizeof(ns->nguid)))
2141	return 0;	2141	return 0;
2142	}	2142	}

drivers/nvme/host/pci.c+7−7

 	struct mutex shutdown_lock;
 	bool subsystem;
 	void __iomem *cmb;
-	dma_addr_t cmb_dma_addr;
+	pci_bus_addr_t cmb_bus_addr;
 	u64 cmb_size;
 	u32 cmbsz;
 	u32 cmbloc;
 	if (qid && dev->cmb && use_cmb_sqes && NVME_CMB_SQS(dev->cmbsz)) {
 		unsigned offset = (qid - 1) * roundup(SQ_SIZE(depth),
 						      dev->ctrl.page_size);
-		nvmeq->sq_dma_addr = dev->cmb_dma_addr + offset;
+		nvmeq->sq_dma_addr = dev->cmb_bus_addr + offset;
 		nvmeq->sq_cmds_io = dev->cmb + offset;
 	} else {
 		nvmeq->sq_cmds = dma_alloc_coherent(dev->dev, SQ_SIZE(depth),
 	resource_size_t bar_size;
 	struct pci_dev *pdev = to_pci_dev(dev->dev);
 	void __iomem *cmb;
-	dma_addr_t dma_addr;
+	int bar;
 	dev->cmbsz = readl(dev->bar + NVME_REG_CMBSZ);
 	if (!(NVME_CMB_SZ(dev->cmbsz)))
 	szu = (u64)1 << (12 + 4 * NVME_CMB_SZU(dev->cmbsz));
 	size = szu * NVME_CMB_SZ(dev->cmbsz);
 	offset = szu * NVME_CMB_OFST(dev->cmbloc);
-	bar_size = pci_resource_len(pdev, NVME_CMB_BIR(dev->cmbloc));
+	bar = NVME_CMB_BIR(dev->cmbloc);
+	bar_size = pci_resource_len(pdev, bar);
 	if (offset > bar_size)
 		return NULL;
 	if (size > bar_size - offset)
 		size = bar_size - offset;
-	dma_addr = pci_resource_start(pdev, NVME_CMB_BIR(dev->cmbloc)) + offset;
+	cmb = ioremap_wc(pci_resource_start(pdev, bar) + offset, size);
-	cmb = ioremap_wc(dma_addr, size);
 	if (!cmb)
 		return NULL;
-	dev->cmb_dma_addr = dma_addr;
+	dev->cmb_bus_addr = pci_bus_address(pdev, bar) + offset;
 	dev->cmb_size = size;
 	return cmb;
 }

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c+1−1

@@ -3767,7 +3767,7 @@ static int ibmvscsis_write_pending(struct se_cmd *se_cmd) · 3766 unmodified lines
3767	*/	3767	*/
3768	if ((vscsi->flags & (CLIENT_FAILED \| RESPONSE_Q_DOWN))) {	3768	if ((vscsi->flags & (CLIENT_FAILED \| RESPONSE_Q_DOWN))) {
3769	pr_err("write_pending failed since: %d\n", vscsi->flags);	3769	pr_err("write_pending failed since: %d\n", vscsi->flags);
3770	return 0;	3770	return -EIO;
3771	}	3771	}
3772		3772
3773	rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma,	3773	rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma,

drivers/scsi/libiscsi.c+4−4

 /**
  * iscsi_session_teardown - destroy session, host, and cls_session
  * @cls_session: iscsi session
- *
- * The driver must have called iscsi_remove_session before
- * calling this.
  */
 void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
 {
 	iscsi_pool_free(&session->cmdpool);
+	iscsi_remove_session(cls_session);
 	kfree(session->password);
 	kfree(session->password_in);
 	kfree(session->username);
 	kfree(session->portal_type);
 	kfree(session->discovery_parent_type);
-	iscsi_destroy_session(cls_session);
+	iscsi_free_session(cls_session);
 	iscsi_host_dec_session_cnt(shost);
 	module_put(owner);
 }

drivers/scsi/scsi_scan.c+3−0

@@ -956,6 +956,9 @@ static int scsi_add_lun(struct scsi_device sdev, unsigned char inq_result, · 955 unmodified lines
956	if (*bflags & BLIST_NO_DIF)	956	if (*bflags & BLIST_NO_DIF)
957	sdev->no_dif = 1;	957	sdev->no_dif = 1;
958		958
		959	if (*bflags & BLIST_UNMAP_LIMIT_WS)
		960	sdev->unmap_limit_for_ws = 1;
		961
959	sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;	962	sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;
960		963
961	if (*bflags & BLIST_TRY_VPD_PAGES)	964	if (*bflags & BLIST_TRY_VPD_PAGES)

drivers/scsi/scsi_transport_iscsi.c+0−16

@@ -2210,22 +2210,6 @@ void iscsi_free_session(struct iscsi_cls_session *session) · 2209 unmodified lines
2210	}	2210	}
2211	EXPORT_SYMBOL_GPL(iscsi_free_session);	2211	EXPORT_SYMBOL_GPL(iscsi_free_session);
2212		2212
2213	/**
2214	* iscsi_destroy_session - destroy iscsi session
2215	* @session: iscsi_session
2216	*
2217	* Can be called by a LLD or iscsi_transport. There must not be
2218	* any running connections.
2219	*/
2220	int iscsi_destroy_session(struct iscsi_cls_session *session)
2221	{
2222	iscsi_remove_session(session);
2223	ISCSI_DBG_TRANS_SESSION(session, "Completing session destruction\n");
2224	iscsi_free_session(session);
2225	return 0;
2226	}
2227	EXPORT_SYMBOL_GPL(iscsi_destroy_session);
2228
2229	/**	2213	/**
2230	* iscsi_create_conn - create iscsi class connection	2214	* iscsi_create_conn - create iscsi class connection
2231	* @session: iscsi cls session	2215	* @session: iscsi cls session

drivers/scsi/sd.c+26−9

 		break;
 	case SD_LBP_WS16:
-		max_blocks = min_not_zero(sdkp->max_ws_blocks,
+		if (sdkp->device->unmap_limit_for_ws)
-					  (u32)SD_MAX_WS16_BLOCKS);
+			max_blocks = sdkp->max_unmap_blocks;
+		else
+			max_blocks = sdkp->max_ws_blocks;
+		max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS16_BLOCKS);
 		break;
 	case SD_LBP_WS10:
-		max_blocks = min_not_zero(sdkp->max_ws_blocks,
+		if (sdkp->device->unmap_limit_for_ws)
-					  (u32)SD_MAX_WS10_BLOCKS);
+			max_blocks = sdkp->max_unmap_blocks;
+		else
+			max_blocks = sdkp->max_ws_blocks;
+		max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS10_BLOCKS);
 		break;
 	case SD_LBP_ZERO:
 		sd_read_security(sdkp, buffer);
 	}
-	sdkp->first_scan = 0;
 	/*
 	 * We now have all cache related info, determine how we deal
 	 * with flush requests.
 	q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
 	/*
-	 * Use the device's preferred I/O size for reads and writes
+	 * Determine the device's preferred I/O size for reads and writes
 	 * unless the reported value is unreasonably small, large, or
 	 * garbage.
 	 */
 		rw_max = min_not_zero(logical_to_sectors(sdp, dev_max),
 				      (sector_t)BLK_DEF_MAX_SECTORS);
-	/* Combine with controller limits */
+	/* Do not exceed controller limit */
-	q->limits.max_sectors = min(rw_max, queue_max_hw_sectors(q));
+	rw_max = min(rw_max, queue_max_hw_sectors(q));
+	/*
+	 * Only update max_sectors if previously unset or if the current value
+	 * exceeds the capabilities of the hardware.
+	 */
+	if (sdkp->first_scan ||
+	    q->limits.max_sectors > q->limits.max_dev_sectors ||
+	    q->limits.max_sectors > q->limits.max_hw_sectors)
+		q->limits.max_sectors = rw_max;
+	sdkp->first_scan = 0;
 	set_capacity(disk, logical_to_sectors(sdp, sdkp->capacity));
 	sd_config_write_same(sdkp);

fs/btrfs/ctree.h+1−1

@@ -722,7 +722,7 @@ struct btrfs_delayed_root; · 721 unmodified lines
722	* Indicate that a whole-filesystem exclusive operation is running	722	* Indicate that a whole-filesystem exclusive operation is running
723	* (device replace, resize, device add/delete, balance)	723	* (device replace, resize, device add/delete, balance)
724	*/	724	*/
725	#define BTRFS_FS_EXCL_OP 14	725	#define BTRFS_FS_EXCL_OP 16
726		726
727	struct btrfs_fs_info {	727	struct btrfs_fs_info {
728	u8 fsid[BTRFS_FSID_SIZE];	728	u8 fsid[BTRFS_FSID_SIZE];

fs/btrfs/extent_io.c+1−1

@@ -2801,7 +2801,7 @@ static int submit_extent_page(unsigned int opf, struct extent_io_tree *tree, · 2800 unmodified lines
2801	}	2801	}
2802	}	2802	}
2803		2803
2804	bio = btrfs_bio_alloc(bdev, sector << 9);	2804	bio = btrfs_bio_alloc(bdev, (u64)sector << 9);
2805	bio_add_page(bio, page, page_size, offset);	2805	bio_add_page(bio, page, page_size, offset);
2806	bio->bi_end_io = end_io_func;	2806	bio->bi_end_io = end_io_func;
2807	bio->bi_private = tree;	2807	bio->bi_private = tree;

fs/ceph/mds_client.c+6−5

 			inode = req->r_inode;
 			ihold(inode);
 		} else {
-			/* req->r_dentry is non-null for LSSNAP request.
+			/* req->r_dentry is non-null for LSSNAP request */
-			 * fall-thru */
+			rcu_read_lock();
-			WARN_ON_ONCE(!req->r_dentry);
+			inode = get_nonsnap_parent(req->r_dentry);
+			rcu_read_unlock();
+			dout("__choose_mds using snapdir's parent %p\n", inode);
 		}
-	}
+	} else if (req->r_dentry) {
-	if (!inode && req->r_dentry) {
 		/* ignore race with rename; old or new d_parent is okay */
 		struct dentry *parent;
 		struct inode *dir;

fs/ceph/snap.c+3−5

 	     realm->ino, realm, snapc, snapc->seq,
 	     (unsigned int) snapc->num_snaps);
-	if (realm->cached_context) {
+	ceph_put_snap_context(realm->cached_context);
-		ceph_put_snap_context(realm->cached_context);
-		/* queue realm for cap_snap creation */
-		list_add_tail(&realm->dirty_item, dirty_realms);
-	}
 	realm->cached_context = snapc;
+	/* queue realm for cap_snap creation */
+	list_add_tail(&realm->dirty_item, dirty_realms);
 	return 0;
 fail:

fs/namespace.c+3−1

@@ -468,7 +468,9 @@ static inline int may_write_real(struct file *file) · 467 unmodified lines
468		468
469	/* File refers to upper, writable layer? */	469	/* File refers to upper, writable layer? */
470	upperdentry = d_real(dentry, NULL, 0, D_REAL_UPPER);	470	upperdentry = d_real(dentry, NULL, 0, D_REAL_UPPER);
471	if (upperdentry && file_inode(file) == d_inode(upperdentry))	471	if (upperdentry &&
		472	(file_inode(file) == d_inode(upperdentry) \|\|
		473	file_inode(file) == d_inode(dentry)))
472	return 0;	474	return 0;
473		475
474	/* Lower layer: can't write to real file, sorry... */	476	/* Lower layer: can't write to real file, sorry... */

fs/nfs/client.c+1−1

 static void pnfs_init_server(struct nfs_server *server)
 {
 	rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
-	rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
 }
 #else
 	ida_init(&server->openowner_id);
 	ida_init(&server->lockowner_id);
 	pnfs_init_server(server);
+	rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
 	return server;
 }

fs/nfs/filelayout/filelayout.c+2−1

@@ -745,7 +745,8 @@ filelayout_free_lseg(struct pnfs_layout_segment *lseg) · 744 unmodified lines
745	struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);	745	struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
746		746
747	dprintk("--> %s\n", __func__);	747	dprintk("--> %s\n", __func__);
748	nfs4_fl_put_deviceid(fl->dsaddr);	748	if (fl->dsaddr != NULL)
		749	nfs4_fl_put_deviceid(fl->dsaddr);
749	/* This assumes a single RW lseg */	750	/* This assumes a single RW lseg */
750	if (lseg->pls_range.iomode == IOMODE_RW) {	751	if (lseg->pls_range.iomode == IOMODE_RW) {
751	struct nfs4_filelayout *flo;	752	struct nfs4_filelayout *flo;

fs/nfs/nfs4idmap.c+1−1

@@ -274,7 +274,7 @@ static struct key nfs_idmap_request_key(const char name, size_t namelen, · 273 unmodified lines
274	ssize_t ret;	274	ssize_t ret;
275		275
276	ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);	276	ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
277	if (ret <= 0)	277	if (ret < 0)
278	return ERR_PTR(ret);	278	return ERR_PTR(ret);
279		279
280	rkey = request_key(&key_type_id_resolver, desc, "");	280	rkey = request_key(&key_type_id_resolver, desc, "");

fs/nfs/nfs4proc.c+1−2

 		lo = NFS_I(inode)->layout;
 		/* If the open stateid was bad, then recover it. */
 		if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
-		    nfs4_stateid_match_other(&lgp->args.stateid,
+		    !nfs4_stateid_match_other(&lgp->args.stateid, &lo->plh_stateid)) {
-					&lgp->args.ctx->state->stateid)) {
 			spin_unlock(&inode->i_lock);
 			exception->state = lgp->args.ctx->state;
 			exception->stateid = &lgp->args.stateid;

fs/nfs/nfs4xdr.c+2−2

@@ -1842,8 +1842,8 @@ static void encode_create_session(struct xdr_stream *xdr, · 1841 unmodified lines
1842	* Assumes OPEN is the biggest non-idempotent compound.	1842	* Assumes OPEN is the biggest non-idempotent compound.
1843	* 2 is the verifier.	1843	* 2 is the verifier.
1844	*/	1844	*/
1845	max_resp_sz_cached = (NFS4_dec_open_sz + RPC_REPHDRSIZE +	1845	max_resp_sz_cached = (NFS4_dec_open_sz + RPC_REPHDRSIZE + 2)
1846	RPC_MAX_AUTH_SIZE + 2) * XDR_UNIT;	1846	* XDR_UNIT + RPC_MAX_AUTH_SIZE;
1847		1847
1848	encode_op_hdr(xdr, OP_CREATE_SESSION, decode_create_session_maxsz, hdr);	1848	encode_op_hdr(xdr, OP_CREATE_SESSION, decode_create_session_maxsz, hdr);
1849	p = reserve_space(xdr, 16 + 2*28 + 20 + clnt->cl_nodelen + 12);	1849	p = reserve_space(xdr, 16 + 2*28 + 20 + clnt->cl_nodelen + 12);

fs/overlayfs/copy_up.c+2−4

 		c->tmpfile = true;
 		err = ovl_copy_up_locked(c);
 	} else {
-		err = -EIO;
+		err = ovl_lock_rename_workdir(c->workdir, c->destdir);
-		if (lock_rename(c->workdir, c->destdir) != NULL) {
+		if (!err) {
-			pr_err("overlayfs: failed to lock workdir+upperdir\n");
-		} else {
 			err = ovl_copy_up_locked(c);
 			unlock_rename(c->workdir, c->destdir);
 		}

fs/overlayfs/dir.c+0−20

@@ -216,26 +216,6 @@ out_unlock: · 215 unmodified lines
216	return err;	216	return err;
217	}	217	}
218		218
219	static int ovl_lock_rename_workdir(struct dentry *workdir,
220	struct dentry *upperdir)
221	{
222	/* Workdir should not be the same as upperdir */
223	if (workdir == upperdir)
224	goto err;
225
226	/* Workdir should not be subdir of upperdir and vice versa */
227	if (lock_rename(workdir, upperdir) != NULL)
228	goto err_unlock;
229
230	return 0;
231
232	err_unlock:
233	unlock_rename(workdir, upperdir);
234	err:
235	pr_err("overlayfs: failed to lock workdir+upperdir\n");
236	return -EIO;
237	}
238
239	static struct dentry ovl_clear_empty(struct dentry dentry,	219	static struct dentry ovl_clear_empty(struct dentry dentry,
240	struct list_head *list)	220	struct list_head *list)
241	{	221	{

fs/overlayfs/namei.c+1−0

@@ -506,6 +506,7 @@ static struct dentry ovl_lookup_index(struct dentry dentry, · 505 unmodified lines
506		506
507	index = lookup_one_len_unlocked(name.name, ofs->indexdir, name.len);	507	index = lookup_one_len_unlocked(name.name, ofs->indexdir, name.len);
508	if (IS_ERR(index)) {	508	if (IS_ERR(index)) {
		509	err = PTR_ERR(index);
509	pr_warn_ratelimited("overlayfs: failed inode index lookup (ino=%lu, key=%*s, err=%i);\n"	510	pr_warn_ratelimited("overlayfs: failed inode index lookup (ino=%lu, key=%*s, err=%i);\n"
510	"overlayfs: mount with '-o index=off' to disable inodes index.\n",	511	"overlayfs: mount with '-o index=off' to disable inodes index.\n",
511	d_inode(origin)->i_ino, name.len, name.name,	512	d_inode(origin)->i_ino, name.len, name.name,

fs/overlayfs/overlayfs.h+1−0

@@ -235,6 +235,7 @@ bool ovl_inuse_trylock(struct dentry *dentry); · 234 unmodified lines
235	void ovl_inuse_unlock(struct dentry *dentry);	235	void ovl_inuse_unlock(struct dentry *dentry);
236	int ovl_nlink_start(struct dentry dentry, bool locked);	236	int ovl_nlink_start(struct dentry dentry, bool locked);
237	void ovl_nlink_end(struct dentry *dentry, bool locked);	237	void ovl_nlink_end(struct dentry *dentry, bool locked);
		238	int ovl_lock_rename_workdir(struct dentry workdir, struct dentry upperdir);
238		239
239	static inline bool ovl_is_impuredir(struct dentry *dentry)	240	static inline bool ovl_is_impuredir(struct dentry *dentry)
240	{	241	{

fs/overlayfs/ovl_entry.h+3−0

 	bool noxattr;
 	/* sb common to all layers */
 	struct super_block *same_sb;
+	/* Did we take the inuse lock? */
+	bool upperdir_locked;
+	bool workdir_locked;
 };
 /* private information held for every overlayfs dentry */

fs/overlayfs/readdir.c+4−2

 			 struct path *lowerstack, unsigned int numlower)
 {
 	int err;
+	struct dentry *index = NULL;
 	struct inode *dir = dentry->d_inode;
 	struct path path = { .mnt = mnt, .dentry = dentry };
 	LIST_HEAD(list);
 	inode_lock_nested(dir, I_MUTEX_PARENT);
 	list_for_each_entry(p, &list, l_node) {
-		struct dentry *index;
 		if (p->name[0] == '.') {
 			if (p->len == 1)
 				continue;
 		index = lookup_one_len(p->name, dentry, p->len);
 		if (IS_ERR(index)) {
 			err = PTR_ERR(index);
+			index = NULL;
 			break;
 		}
 		err = ovl_verify_index(index, lowerstack, numlower);
 				break;
 		}
 		dput(index);
+		index = NULL;
 	}
+	dput(index);
 	inode_unlock(dir);
 out:
 	ovl_cache_free(&list);

fs/overlayfs/super.c+19−8

 	dput(ufs->indexdir);
 	dput(ufs->workdir);
-	ovl_inuse_unlock(ufs->workbasedir);
+	if (ufs->workdir_locked)
+		ovl_inuse_unlock(ufs->workbasedir);
 	dput(ufs->workbasedir);
-	if (ufs->upper_mnt)
+	if (ufs->upper_mnt && ufs->upperdir_locked)
 		ovl_inuse_unlock(ufs->upper_mnt->mnt_root);
 	mntput(ufs->upper_mnt);
 	for (i = 0; i < ufs->numlower; i++)
 			goto out_put_upperpath;
 		err = -EBUSY;
-		if (!ovl_inuse_trylock(upperpath.dentry)) {
+		if (ovl_inuse_trylock(upperpath.dentry)) {
-			pr_err("overlayfs: upperdir is in-use by another mount\n");
+			ufs->upperdir_locked = true;
+		} else if (ufs->config.index) {
+			pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n");
 			goto out_put_upperpath;
+		} else {
+			pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
 		}
 		err = ovl_mount_dir(ufs->config.workdir, &workpath);
 		}
 		err = -EBUSY;
-		if (!ovl_inuse_trylock(workpath.dentry)) {
+		if (ovl_inuse_trylock(workpath.dentry)) {
-			pr_err("overlayfs: workdir is in-use by another mount\n");
+			ufs->workdir_locked = true;
+		} else if (ufs->config.index) {
+			pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n");
 			goto out_put_workpath;
+		} else {
+			pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
 		}
 		ufs->workbasedir = workpath.dentry;
 out_free_lowertmp:
 	kfree(lowertmp);
 out_unlock_workdentry:
-	ovl_inuse_unlock(workpath.dentry);
+	if (ufs->workdir_locked)
+		ovl_inuse_unlock(workpath.dentry);
 out_put_workpath:
 	path_put(&workpath);
 out_unlock_upperdentry:
-	ovl_inuse_unlock(upperpath.dentry);
+	if (ufs->upperdir_locked)
+		ovl_inuse_unlock(upperpath.dentry);
 out_put_upperpath:
 	path_put(&upperpath);
 out_free_config:

fs/overlayfs/util.c+23−1

@@ -430,7 +430,7 @@ void ovl_inuse_unlock(struct dentry *dentry) · 429 unmodified lines
430	}	430	}
431	}	431	}
432		432
433	/* Called must hold OVL_I(inode)->oi_lock */	433	/* Caller must hold OVL_I(inode)->lock */
434	static void ovl_cleanup_index(struct dentry *dentry)	434	static void ovl_cleanup_index(struct dentry *dentry)
435	{	435	{
436	struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;	436	struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;
@@ -469,6 +469,9 @@ static void ovl_cleanup_index(struct dentry *dentry) · 32 unmodified lines
469	err = PTR_ERR(index);	469	err = PTR_ERR(index);
470	if (!IS_ERR(index))	470	if (!IS_ERR(index))
471	err = ovl_cleanup(dir, index);	471	err = ovl_cleanup(dir, index);
		472	else
		473	index = NULL;
		474
472	inode_unlock(dir);	475	inode_unlock(dir);
473	if (err)	476	if (err)
474	goto fail;	477	goto fail;
@@ -557,3 +560,22 @@ void ovl_nlink_end(struct dentry *dentry, bool locked) · 82 unmodified lines
557	mutex_unlock(&OVL_I(d_inode(dentry))->lock);	560	mutex_unlock(&OVL_I(d_inode(dentry))->lock);
558	}	561	}
559	}	562	}
		563
		564	int ovl_lock_rename_workdir(struct dentry workdir, struct dentry upperdir)
		565	{
		566	/* Workdir should not be the same as upperdir */
		567	if (workdir == upperdir)
		568	goto err;
		569
		570	/* Workdir should not be subdir of upperdir and vice versa */
		571	if (lock_rename(workdir, upperdir) != NULL)
		572	goto err_unlock;
		573
		574	return 0;
		575
		576	err_unlock:
		577	unlock_rename(workdir, upperdir);
		578	err:
		579	pr_err("overlayfs: failed to lock workdir+upperdir\n");
		580	return -EIO;
		581	}

fs/xfs/xfs_bmap_util.c+22−2

@@ -2122,11 +2122,31 @@ xfs_swap_extents( · 2121 unmodified lines
2122	ip->i_d.di_flags2 \|= tip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK;	2122	ip->i_d.di_flags2 \|= tip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK;
2123	tip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;	2123	tip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
2124	tip->i_d.di_flags2 \|= f & XFS_DIFLAG2_REFLINK;	2124	tip->i_d.di_flags2 \|= f & XFS_DIFLAG2_REFLINK;
		2125	}
		2126
		2127	/* Swap the cow forks. */
		2128	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
		2129	xfs_extnum_t extnum;
		2130
		2131	ASSERT(ip->i_cformat == XFS_DINODE_FMT_EXTENTS);
		2132	ASSERT(tip->i_cformat == XFS_DINODE_FMT_EXTENTS);
		2133
		2134	extnum = ip->i_cnextents;
		2135	ip->i_cnextents = tip->i_cnextents;
		2136	tip->i_cnextents = extnum;
		2137
2125	cowfp = ip->i_cowfp;	2138	cowfp = ip->i_cowfp;
2126	ip->i_cowfp = tip->i_cowfp;	2139	ip->i_cowfp = tip->i_cowfp;
2127	tip->i_cowfp = cowfp;	2140	tip->i_cowfp = cowfp;
2128	xfs_inode_set_cowblocks_tag(ip);	2141
2129	xfs_inode_set_cowblocks_tag(tip);	2142	if (ip->i_cowfp && ip->i_cnextents)
		2143	xfs_inode_set_cowblocks_tag(ip);
		2144	else
		2145	xfs_inode_clear_cowblocks_tag(ip);
		2146	if (tip->i_cowfp && tip->i_cnextents)
		2147	xfs_inode_set_cowblocks_tag(tip);
		2148	else
		2149	xfs_inode_clear_cowblocks_tag(tip);
2130	}	2150	}
2131		2151
2132	xfs_trans_log_inode(tp, ip, src_log_flags);	2152	xfs_trans_log_inode(tp, ip, src_log_flags);

fs/xfs/xfs_reflink.c+8−1

 	/* If there is a hole at end_fsb - 1 go to the previous extent */
 	if (!xfs_iext_lookup_extent(ip, ifp, end_fsb - 1, &idx, &got) ||
 	    got.br_startoff > end_fsb) {
-		ASSERT(idx > 0);
+		/*
+		 * In case of racing, overlapping AIO writes no COW extents
+		 * might be left by the time I/O completes for the loser of
+		 * the race.  In that case we are done.
+		 */
+		if (idx <= 0)
+			goto out_cancel;
 		xfs_iext_get_extent(ifp, --idx, &got);
 	}
 out_defer:
 	xfs_defer_cancel(&dfops);
+out_cancel:
 	xfs_trans_cancel(tp);
 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 out:

include/linux/bpf.h+5−0

 {
 }
+static inline int bpf_obj_get_user(const char __user *pathname)
+{
+	return -EOPNOTSUPP;
+}
 static inline struct net_device  *__dev_map_lookup_elem(struct bpf_map *map,
 						       u32 key)
 {

include/linux/mmc/host.h+1−1

@@ -316,7 +316,7 @@ struct mmc_host { · 315 unmodified lines
316	#define MMC_CAP_UHS_SDR50 (1 << 18) /* Host supports UHS SDR50 mode */	316	#define MMC_CAP_UHS_SDR50 (1 << 18) /* Host supports UHS SDR50 mode */
317	#define MMC_CAP_UHS_SDR104 (1 << 19) /* Host supports UHS SDR104 mode */	317	#define MMC_CAP_UHS_SDR104 (1 << 19) /* Host supports UHS SDR104 mode */
318	#define MMC_CAP_UHS_DDR50 (1 << 20) /* Host supports UHS DDR50 mode */	318	#define MMC_CAP_UHS_DDR50 (1 << 20) /* Host supports UHS DDR50 mode */
319	#define MMC_CAP_NO_BOUNCE_BUFF (1 << 21) /* Disable bounce buffers on host */	319	/* (1 << 21) is free for reuse */
320	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */	320	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */
321	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */	321	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */
322	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */	322	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */

include/linux/netfilter_bridge/ebtables.h+4−3

 #define EBT_ALIGN(s) (((s) + (__alignof__(struct _xt_align)-1)) & \
 		     ~(__alignof__(struct _xt_align)-1))
-extern struct ebt_table *ebt_register_table(struct net *net,
+extern int ebt_register_table(struct net *net,
-					    const struct ebt_table *table,
+			      const struct ebt_table *table,
-					    const struct nf_hook_ops *);
+			      const struct nf_hook_ops *ops,
+			      struct ebt_table **res);
 extern void ebt_unregister_table(struct net *net, struct ebt_table *table,
 				 const struct nf_hook_ops *);
 extern unsigned int ebt_do_table(struct sk_buff *skb,

include/linux/nmi.h+62−59

@@ -12,11 +12,31 @@ · 11 unmodified lines
12		12
13	#ifdef CONFIG_LOCKUP_DETECTOR	13	#ifdef CONFIG_LOCKUP_DETECTOR
14	void lockup_detector_init(void);	14	void lockup_detector_init(void);
		15	void lockup_detector_soft_poweroff(void);
		16	void lockup_detector_cleanup(void);
		17	bool is_hardlockup(void);
		18
		19	extern int watchdog_user_enabled;
		20	extern int nmi_watchdog_user_enabled;
		21	extern int soft_watchdog_user_enabled;
		22	extern int watchdog_thresh;
		23	extern unsigned long watchdog_enabled;
		24
		25	extern struct cpumask watchdog_cpumask;
		26	extern unsigned long *watchdog_cpumask_bits;
		27	#ifdef CONFIG_SMP
		28	extern int sysctl_softlockup_all_cpu_backtrace;
		29	extern int sysctl_hardlockup_all_cpu_backtrace;
15	#else	30	#else
16	static inline void lockup_detector_init(void)	31	#define sysctl_softlockup_all_cpu_backtrace 0
17	{	32	#define sysctl_hardlockup_all_cpu_backtrace 0
18	}	33	#endif /* !CONFIG_SMP */
19	#endif	34
		35	#else /* CONFIG_LOCKUP_DETECTOR */
		36	static inline void lockup_detector_init(void) { }
		37	static inline void lockup_detector_soft_poweroff(void) { }
		38	static inline void lockup_detector_cleanup(void) { }
		39	#endif /* !CONFIG_LOCKUP_DETECTOR */
20		40
21	#ifdef CONFIG_SOFTLOCKUP_DETECTOR	41	#ifdef CONFIG_SOFTLOCKUP_DETECTOR
22	extern void touch_softlockup_watchdog_sched(void);	42	extern void touch_softlockup_watchdog_sched(void);
@@ -24,29 +44,17 @@ extern void touch_softlockup_watchdog(void); · 1 unmodified line
24	extern void touch_softlockup_watchdog_sync(void);	44	extern void touch_softlockup_watchdog_sync(void);
25	extern void touch_all_softlockup_watchdogs(void);	45	extern void touch_all_softlockup_watchdogs(void);
26	extern unsigned int softlockup_panic;	46	extern unsigned int softlockup_panic;
27	extern int soft_watchdog_enabled;
28	extern atomic_t watchdog_park_in_progress;
29	#else	47	#else
30	static inline void touch_softlockup_watchdog_sched(void)	48	static inline void touch_softlockup_watchdog_sched(void) { }
31	{	49	static inline void touch_softlockup_watchdog(void) { }
32	}	50	static inline void touch_softlockup_watchdog_sync(void) { }
33	static inline void touch_softlockup_watchdog(void)	51	static inline void touch_all_softlockup_watchdogs(void) { }
34	{
35	}
36	static inline void touch_softlockup_watchdog_sync(void)
37	{
38	}
39	static inline void touch_all_softlockup_watchdogs(void)
40	{
41	}
42	#endif	52	#endif
43		53
44	#ifdef CONFIG_DETECT_HUNG_TASK	54	#ifdef CONFIG_DETECT_HUNG_TASK
45	void reset_hung_task_detector(void);	55	void reset_hung_task_detector(void);
46	#else	56	#else
47	static inline void reset_hung_task_detector(void)	57	static inline void reset_hung_task_detector(void) { }
48	{
49	}
50	#endif	58	#endif
51		59
52	/*	60	/*
@@ -54,12 +62,12 @@ static inline void reset_hung_task_detector(void) · 1 unmodified line
54	* 'watchdog_enabled' variable. Each lockup detector has its dedicated bit -	62	* 'watchdog_enabled' variable. Each lockup detector has its dedicated bit -
55	* bit 0 for the hard lockup detector and bit 1 for the soft lockup detector.	63	* bit 0 for the hard lockup detector and bit 1 for the soft lockup detector.
56	*	64	*
57	* 'watchdog_user_enabled', 'nmi_watchdog_enabled' and 'soft_watchdog_enabled'	65	* 'watchdog_user_enabled', 'nmi_watchdog_user_enabled' and
58	* are variables that are only used as an 'interface' between the parameters	66	* 'soft_watchdog_user_enabled' are variables that are only used as an
59	* in /proc/sys/kernel and the internal state bits in 'watchdog_enabled'. The	67	* 'interface' between the parameters in /proc/sys/kernel and the internal
60	* 'watchdog_thresh' variable is handled differently because its value is not	68	* state bits in 'watchdog_enabled'. The 'watchdog_thresh' variable is
61	* boolean, and the lockup detectors are 'suspended' while 'watchdog_thresh'	69	* handled differently because its value is not boolean, and the lockup
62	* is equal zero.	70	* detectors are 'suspended' while 'watchdog_thresh' is equal zero.
63	*/	71	*/
64	#define NMI_WATCHDOG_ENABLED_BIT 0	72	#define NMI_WATCHDOG_ENABLED_BIT 0
65	#define SOFT_WATCHDOG_ENABLED_BIT 1	73	#define SOFT_WATCHDOG_ENABLED_BIT 1
@@ -73,17 +81,41 @@ extern unsigned int hardlockup_panic; · 7 unmodified lines
73	static inline void hardlockup_detector_disable(void) {}	81	static inline void hardlockup_detector_disable(void) {}
74	#endif	82	#endif
75		83
		84	#if defined(CONFIG_HAVE_NMI_WATCHDOG) \|\| defined(CONFIG_HARDLOCKUP_DETECTOR)
		85	# define NMI_WATCHDOG_SYSCTL_PERM 0644
		86	#else
		87	# define NMI_WATCHDOG_SYSCTL_PERM 0444
		88	#endif
		89
76	#if defined(CONFIG_HARDLOCKUP_DETECTOR_PERF)	90	#if defined(CONFIG_HARDLOCKUP_DETECTOR_PERF)
77	extern void arch_touch_nmi_watchdog(void);	91	extern void arch_touch_nmi_watchdog(void);
		92	extern void hardlockup_detector_perf_stop(void);
		93	extern void hardlockup_detector_perf_restart(void);
		94	extern void hardlockup_detector_perf_disable(void);
		95	extern void hardlockup_detector_perf_enable(void);
		96	extern void hardlockup_detector_perf_cleanup(void);
		97	extern int hardlockup_detector_perf_init(void);
78	#else	98	#else
79	#if !defined(CONFIG_HAVE_NMI_WATCHDOG)	99	static inline void hardlockup_detector_perf_stop(void) { }
		100	static inline void hardlockup_detector_perf_restart(void) { }
		101	static inline void hardlockup_detector_perf_disable(void) { }
		102	static inline void hardlockup_detector_perf_enable(void) { }
		103	static inline void hardlockup_detector_perf_cleanup(void) { }
		104	# if !defined(CONFIG_HAVE_NMI_WATCHDOG)
		105	static inline int hardlockup_detector_perf_init(void) { return -ENODEV; }
80	static inline void arch_touch_nmi_watchdog(void) {}	106	static inline void arch_touch_nmi_watchdog(void) {}
		107	# else
		108	static inline int hardlockup_detector_perf_init(void) { return 0; }
		109	# endif
81	#endif	110	#endif
82	#endif	111
		112	void watchdog_nmi_stop(void);
		113	void watchdog_nmi_start(void);
		114	int watchdog_nmi_probe(void);
83		115
84	/**	116	/**
85	* touch_nmi_watchdog - restart NMI watchdog timeout.	117	* touch_nmi_watchdog - restart NMI watchdog timeout.
86	*	118	*
87	* If the architecture supports the NMI watchdog, touch_nmi_watchdog()	119	* If the architecture supports the NMI watchdog, touch_nmi_watchdog()
88	* may be used to reset the timeout - for code which intentionally	120	* may be used to reset the timeout - for code which intentionally
89	* disables interrupts for a long time. This call is stateless.	121	* disables interrupts for a long time. This call is stateless.
@@ -153,22 +185,6 @@ static inline bool trigger_single_cpu_backtrace(int cpu) · 63 unmodified lines
153	u64 hw_nmi_get_sample_period(int watchdog_thresh);	185	u64 hw_nmi_get_sample_period(int watchdog_thresh);
154	#endif	186	#endif
155		187
156	#ifdef CONFIG_LOCKUP_DETECTOR
157	extern int nmi_watchdog_enabled;
158	extern int watchdog_user_enabled;
159	extern int watchdog_thresh;
160	extern unsigned long watchdog_enabled;
161	extern struct cpumask watchdog_cpumask;
162	extern unsigned long *watchdog_cpumask_bits;
163	extern int __read_mostly watchdog_suspended;
164	#ifdef CONFIG_SMP
165	extern int sysctl_softlockup_all_cpu_backtrace;
166	extern int sysctl_hardlockup_all_cpu_backtrace;
167	#else
168	#define sysctl_softlockup_all_cpu_backtrace 0
169	#define sysctl_hardlockup_all_cpu_backtrace 0
170	#endif
171
172	#if defined(CONFIG_HARDLOCKUP_CHECK_TIMESTAMP) && \	188	#if defined(CONFIG_HARDLOCKUP_CHECK_TIMESTAMP) && \
173	defined(CONFIG_HARDLOCKUP_DETECTOR)	189	defined(CONFIG_HARDLOCKUP_DETECTOR)
174	void watchdog_update_hrtimer_threshold(u64 period);	190	void watchdog_update_hrtimer_threshold(u64 period);
@@ -176,7 +192,6 @@ void watchdog_update_hrtimer_threshold(u64 period); · 1 unmodified line
176	static inline void watchdog_update_hrtimer_threshold(u64 period) { }	192	static inline void watchdog_update_hrtimer_threshold(u64 period) { }
177	#endif	193	#endif
178		194
179	extern bool is_hardlockup(void);
180	struct ctl_table;	195	struct ctl_table;
181	extern int proc_watchdog(struct ctl_table *, int ,	196	extern int proc_watchdog(struct ctl_table *, int ,
182	void __user , size_t , loff_t *);	197	void __user , size_t , loff_t *);
@@ -188,18 +203,6 @@ extern int proc_watchdog_thresh(struct ctl_table *, int , · 5 unmodified lines
188	void __user , size_t , loff_t *);	203	void __user , size_t , loff_t *);
189	extern int proc_watchdog_cpumask(struct ctl_table *, int,	204	extern int proc_watchdog_cpumask(struct ctl_table *, int,
190	void __user , size_t , loff_t *);	205	void __user , size_t , loff_t *);
191	extern int lockup_detector_suspend(void);
192	extern void lockup_detector_resume(void);
193	#else
194	static inline int lockup_detector_suspend(void)
195	{
196	return 0;
197	}
198
199	static inline void lockup_detector_resume(void)
200	{
201	}
202	#endif
203		206
204	#ifdef CONFIG_HAVE_ACPI_APEI_NMI	207	#ifdef CONFIG_HAVE_ACPI_APEI_NMI
205	#include <asm/nmi.h>	208	#include <asm/nmi.h>

include/linux/smpboot.h+2−2

@@ -55,7 +55,7 @@ smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread) · 54 unmodified lines
55	}	55	}
56		56
57	void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread);	57	void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread);
58	int smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,	58	void smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,
59	const struct cpumask *);	59	const struct cpumask *);
60		60
61	#endif	61	#endif

include/scsi/scsi_device.h+1−0

@@ -192,6 +192,7 @@ struct scsi_device { · 191 unmodified lines
192	unsigned no_dif:1; /* T10 PI (DIF) should be disabled */	192	unsigned no_dif:1; /* T10 PI (DIF) should be disabled */
193	unsigned broken_fua:1; /* Don't set FUA bit */	193	unsigned broken_fua:1; /* Don't set FUA bit */
194	unsigned lun_in_cdb:1; /* Store LUN bits in CDB[1] */	194	unsigned lun_in_cdb:1; /* Store LUN bits in CDB[1] */
		195	unsigned unmap_limit_for_ws:1; /* Use the UNMAP limit for WRITE SAME */
195		196
196	atomic_t disk_events_disable_depth; /* disable depth for disk events */	197	atomic_t disk_events_disable_depth; /* disable depth for disk events */
197		198

include/scsi/scsi_devinfo.h+1−0

@@ -29,5 +29,6 @@ · 28 unmodified lines
29	#define BLIST_TRY_VPD_PAGES 0x10000000 /* Attempt to read VPD pages */	29	#define BLIST_TRY_VPD_PAGES 0x10000000 /* Attempt to read VPD pages */
30	#define BLIST_NO_RSOC 0x20000000 /* don't try to issue RSOC */	30	#define BLIST_NO_RSOC 0x20000000 /* don't try to issue RSOC */
31	#define BLIST_MAX_1024 0x40000000 /* maximum 1024 sector cdb length */	31	#define BLIST_MAX_1024 0x40000000 /* maximum 1024 sector cdb length */
		32	#define BLIST_UNMAP_LIMIT_WS 0x80000000 /* Use UNMAP limit for WRITE SAME */
32		33
33	#endif	34	#endif

include/scsi/scsi_transport_iscsi.h+0−1

@@ -434,7 +434,6 @@ extern struct iscsi_cls_session iscsi_create_session(struct Scsi_Host shost, · 433 unmodified lines
434	unsigned int target_id);	434	unsigned int target_id);
435	extern void iscsi_remove_session(struct iscsi_cls_session *session);	435	extern void iscsi_remove_session(struct iscsi_cls_session *session);
436	extern void iscsi_free_session(struct iscsi_cls_session *session);	436	extern void iscsi_free_session(struct iscsi_cls_session *session);
437	extern int iscsi_destroy_session(struct iscsi_cls_session *session);
438	extern struct iscsi_cls_conn iscsi_create_conn(struct iscsi_cls_session sess,	437	extern struct iscsi_cls_conn iscsi_create_conn(struct iscsi_cls_session sess,
439	int dd_size, uint32_t cid);	438	int dd_size, uint32_t cid);
440	extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);	439	extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);

include/uapi/linux/netfilter/xt_bpf.h+1−0

@@ -23,6 +23,7 @@ enum xt_bpf_modes { · 22 unmodified lines
23	XT_BPF_MODE_FD_PINNED,	23	XT_BPF_MODE_FD_PINNED,
24	XT_BPF_MODE_FD_ELF,	24	XT_BPF_MODE_FD_ELF,
25	};	25	};
		26	#define XT_BPF_MODE_PATH_PINNED XT_BPF_MODE_FD_PINNED
26		27
27	struct xt_bpf_info_v1 {	28	struct xt_bpf_info_v1 {
28	__u16 mode;	29	__u16 mode;

kernel/bpf/inode.c+1−0

@@ -363,6 +363,7 @@ out: · 362 unmodified lines
363	putname(pname);	363	putname(pname);
364	return ret;	364	return ret;
365	}	365	}
		366	EXPORT_SYMBOL_GPL(bpf_obj_get_user);
366		367
367	static void bpf_evict_inode(struct inode *inode)	368	static void bpf_evict_inode(struct inode *inode)
368	{	369	{

kernel/bpf/verifier.c+5−0

 {
 	struct bpf_verifier_state *parent = state->parent;
+	if (regno == BPF_REG_FP)
+		/* We don't need to worry about FP liveness because it's read-only */
+		return;
 	while (parent) {
 		/* if read wasn't screened by an earlier write ... */
 		if (state->regs[regno].live & REG_LIVE_WRITTEN)
 				 * copy register state to dest reg
 				 */
 				regs[insn->dst_reg] = regs[insn->src_reg];
+				regs[insn->dst_reg].live |= REG_LIVE_WRITTEN;
 			} else {
 				/* R1 = (u32) R2 */
 				if (is_pointer_value(env, insn->src_reg)) {

kernel/cpu.c+6−0

 #include <linux/lockdep.h>
 #include <linux/tick.h>
 #include <linux/irq.h>
+#include <linux/nmi.h>
 #include <linux/smpboot.h>
 #include <linux/relay.h>
 #include <linux/slab.h>
 out:
 	cpus_write_unlock();
+	/*
+	 * Do post unplug cleanup. This is still protected against
+	 * concurrent CPU hotplug via cpu_add_remove_lock.
+	 */
+	lockup_detector_cleanup();
 	return ret;
 }

kernel/smpboot.c+8−17

  * by the client, but only by calling this function.
  * This function can only be called on a registered smp_hotplug_thread.
  */
-int smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,
+void smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,
-					 const struct cpumask *new)
+					  const struct cpumask *new)
 {
 	struct cpumask *old = plug_thread->cpumask;
-	cpumask_var_t tmp;
+	static struct cpumask tmp;
 	unsigned int cpu;
-	if (!alloc_cpumask_var(&tmp, GFP_KERNEL))
+	lockdep_assert_cpus_held();
-		return -ENOMEM;
-	get_online_cpus();
 	mutex_lock(&smpboot_threads_lock);
 	/* Park threads that were exclusively enabled on the old mask. */
-	cpumask_andnot(tmp, old, new);
+	cpumask_andnot(&tmp, old, new);
-	for_each_cpu_and(cpu, tmp, cpu_online_mask)
+	for_each_cpu_and(cpu, &tmp, cpu_online_mask)
 		smpboot_park_thread(plug_thread, cpu);
 	/* Unpark threads that are exclusively enabled on the new mask. */
-	cpumask_andnot(tmp, new, old);
+	cpumask_andnot(&tmp, new, old);
-	for_each_cpu_and(cpu, tmp, cpu_online_mask)
+	for_each_cpu_and(cpu, &tmp, cpu_online_mask)
 		smpboot_unpark_thread(plug_thread, cpu);
 	cpumask_copy(old, new);
 	mutex_unlock(&smpboot_threads_lock);
-	put_online_cpus();
-	free_cpumask_var(tmp);
-	return 0;
 }
-EXPORT_SYMBOL_GPL(smpboot_update_cpumask_percpu_thread);
 static DEFINE_PER_CPU(atomic_t, cpu_hotplug_state) = ATOMIC_INIT(CPU_POST_DEAD);

kernel/sysctl.c+9−13

 #if defined(CONFIG_LOCKUP_DETECTOR)
 	{
 		.procname       = "watchdog",
-		.data           = &watchdog_user_enabled,
+		.data		= &watchdog_user_enabled,
-		.maxlen         = sizeof (int),
+		.maxlen		= sizeof(int),
-		.mode           = 0644,
+		.mode		= 0644,
 		.proc_handler   = proc_watchdog,
 		.extra1		= &zero,
 		.extra2		= &one,
 	},
 	{
 		.procname       = "nmi_watchdog",
-		.data           = &nmi_watchdog_enabled,
+		.data		= &nmi_watchdog_user_enabled,
-		.maxlen         = sizeof (int),
+		.maxlen		= sizeof(int),
-		.mode           = 0644,
+		.mode		= NMI_WATCHDOG_SYSCTL_PERM,
 		.proc_handler   = proc_nmi_watchdog,
 		.extra1		= &zero,
-#if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
 		.extra2		= &one,
-#else
-		.extra2		= &zero,
-#endif
 	},
 	{
 		.procname	= "watchdog_cpumask",
 #ifdef CONFIG_SOFTLOCKUP_DETECTOR
 	{
 		.procname       = "soft_watchdog",
-		.data           = &soft_watchdog_enabled,
+		.data		= &soft_watchdog_user_enabled,
-		.maxlen         = sizeof (int),
+		.maxlen		= sizeof(int),
-		.mode           = 0644,
+		.mode		= 0644,
 		.proc_handler   = proc_soft_watchdog,
 		.extra1		= &zero,
 		.extra2		= &one,

kernel/watchdog.c+238−405

@@ -29,20 +29,29 @@ · 28 unmodified lines
29	#include <linux/kvm_para.h>	29	#include <linux/kvm_para.h>
30	#include <linux/kthread.h>	30	#include <linux/kthread.h>
31		31
32	/* Watchdog configuration */	32	static DEFINE_MUTEX(watchdog_mutex);
33	static DEFINE_MUTEX(watchdog_proc_mutex);
34
35	int __read_mostly nmi_watchdog_enabled;
36		33
37	#if defined(CONFIG_HARDLOCKUP_DETECTOR) \|\| defined(CONFIG_HAVE_NMI_WATCHDOG)	34	#if defined(CONFIG_HARDLOCKUP_DETECTOR) \|\| defined(CONFIG_HAVE_NMI_WATCHDOG)
38	unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED \|	35	# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED \| NMI_WATCHDOG_ENABLED)
39	NMI_WATCHDOG_ENABLED;	36	# define NMI_WATCHDOG_DEFAULT 1
40	#else	37	#else
41	unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED;	38	# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED)
		39	# define NMI_WATCHDOG_DEFAULT 0
42	#endif	40	#endif
43		41
		42	unsigned long __read_mostly watchdog_enabled;
		43	int __read_mostly watchdog_user_enabled = 1;
		44	int __read_mostly nmi_watchdog_user_enabled = NMI_WATCHDOG_DEFAULT;
		45	int __read_mostly soft_watchdog_user_enabled = 1;
		46	int __read_mostly watchdog_thresh = 10;
		47	int __read_mostly nmi_watchdog_available;
		48
		49	struct cpumask watchdog_allowed_mask __read_mostly;
		50
		51	struct cpumask watchdog_cpumask __read_mostly;
		52	unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
		53
44	#ifdef CONFIG_HARDLOCKUP_DETECTOR	54	#ifdef CONFIG_HARDLOCKUP_DETECTOR
45	/* boot commands */
46	/*	55	/*
47	* Should we panic when a soft-lockup or hard-lockup occurs:	56	* Should we panic when a soft-lockup or hard-lockup occurs:
48	*/	57	*/
@@ -56,9 +65,9 @@ unsigned int __read_mostly hardlockup_panic = · 7 unmodified lines
56	* kernel command line parameters are parsed, because otherwise it is not	65	* kernel command line parameters are parsed, because otherwise it is not
57	* possible to override this in hardlockup_panic_setup().	66	* possible to override this in hardlockup_panic_setup().
58	*/	67	*/
59	void hardlockup_detector_disable(void)	68	void __init hardlockup_detector_disable(void)
60	{	69	{
61	watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;	70	nmi_watchdog_user_enabled = 0;
62	}	71	}
63		72
64	static int __init hardlockup_panic_setup(char *str)	73	static int __init hardlockup_panic_setup(char *str)
@@ -68,48 +77,24 @@ static int __init hardlockup_panic_setup(char *str) · 3 unmodified lines
68	else if (!strncmp(str, "nopanic", 7))	77	else if (!strncmp(str, "nopanic", 7))
69	hardlockup_panic = 0;	78	hardlockup_panic = 0;
70	else if (!strncmp(str, "0", 1))	79	else if (!strncmp(str, "0", 1))
71	watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;	80	nmi_watchdog_user_enabled = 0;
72	else if (!strncmp(str, "1", 1))	81	else if (!strncmp(str, "1", 1))
73	watchdog_enabled \|= NMI_WATCHDOG_ENABLED;	82	nmi_watchdog_user_enabled = 1;
74	return 1;	83	return 1;
75	}	84	}
76	__setup("nmi_watchdog=", hardlockup_panic_setup);	85	__setup("nmi_watchdog=", hardlockup_panic_setup);
77		86
78	#endif	87	# ifdef CONFIG_SMP
79
80	#ifdef CONFIG_SOFTLOCKUP_DETECTOR
81	int __read_mostly soft_watchdog_enabled;
82	#endif
83
84	int __read_mostly watchdog_user_enabled;
85	int __read_mostly watchdog_thresh = 10;
86
87	#ifdef CONFIG_SMP
88	int __read_mostly sysctl_softlockup_all_cpu_backtrace;
89	int __read_mostly sysctl_hardlockup_all_cpu_backtrace;	88	int __read_mostly sysctl_hardlockup_all_cpu_backtrace;
90	#endif
91	struct cpumask watchdog_cpumask __read_mostly;
92	unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
93		89
94	/*	90	static int __init hardlockup_all_cpu_backtrace_setup(char *str)
95	* The 'watchdog_running' variable is set to 1 when the watchdog threads	91	{
96	* are registered/started and is set to 0 when the watchdog threads are	92	sysctl_hardlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0);
97	* unregistered/stopped, so it is an indicator whether the threads exist.	93	return 1;
98	*/	94	}
99	static int __read_mostly watchdog_running;	95	__setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup);
100	/*	96	# endif /* CONFIG_SMP */
101	* If a subsystem has a need to deactivate the watchdog temporarily, it	97	#endif /* CONFIG_HARDLOCKUP_DETECTOR */
102	* can use the suspend/resume interface to achieve this. The content of
103	* the 'watchdog_suspended' variable reflects this state. Existing threads
104	* are parked/unparked by the lockup_detector_{suspend\|resume} functions
105	* (see comment blocks pertaining to those functions for further details).
106	*
107	* 'watchdog_suspended' also prevents threads from being registered/started
108	* or unregistered/stopped via parameters in /proc/sys/kernel, so the state
109	* of 'watchdog_running' cannot change while the watchdog is deactivated
110	* temporarily (see related code in 'proc' handlers).
111	*/
112	int __read_mostly watchdog_suspended;
113		98
114	/*	99	/*
115	* These functions can be overridden if an architecture implements its	100	* These functions can be overridden if an architecture implements its
@@ -121,36 +106,68 @@ int __read_mostly watchdog_suspended; · 5 unmodified lines
121	*/	106	*/
122	int __weak watchdog_nmi_enable(unsigned int cpu)	107	int __weak watchdog_nmi_enable(unsigned int cpu)
123	{	108	{
		109	hardlockup_detector_perf_enable();
124	return 0;	110	return 0;
125	}	111	}
		112
126	void __weak watchdog_nmi_disable(unsigned int cpu)	113	void __weak watchdog_nmi_disable(unsigned int cpu)
127	{	114	{
		115	hardlockup_detector_perf_disable();
128	}	116	}
129		117
130	/*	118	/* Return 0, if a NMI watchdog is available. Error code otherwise */
131	* watchdog_nmi_reconfigure can be implemented to be notified after any	119	int __weak __init watchdog_nmi_probe(void)
132	* watchdog configuration change. The arch hardlockup watchdog should	120	{
133	* respond to the following variables:	121	return hardlockup_detector_perf_init();
134	* - nmi_watchdog_enabled	122	}
		123
		124	/**
		125	* watchdog_nmi_stop - Stop the watchdog for reconfiguration
		126	*
		127	* The reconfiguration steps are:
		128	* watchdog_nmi_stop();
		129	* update_variables();
		130	* watchdog_nmi_start();
		131	*/
		132	void __weak watchdog_nmi_stop(void) { }
		133
		134	/**
		135	* watchdog_nmi_start - Start the watchdog after reconfiguration
		136	*
		137	* Counterpart to watchdog_nmi_stop().
		138	*
		139	* The following variables have been updated in update_variables() and
		140	* contain the currently valid configuration:
		141	* - watchdog_enabled
135	* - watchdog_thresh	142	* - watchdog_thresh
136	* - watchdog_cpumask	143	* - watchdog_cpumask
137	* - sysctl_hardlockup_all_cpu_backtrace
138	* - hardlockup_panic
139	* - watchdog_suspended
140	*/	144	*/
141	void __weak watchdog_nmi_reconfigure(void)	145	void __weak watchdog_nmi_start(void) { }
		146
		147	/**
		148	* lockup_detector_update_enable - Update the sysctl enable bit
		149	*
		150	* Caller needs to make sure that the NMI/perf watchdogs are off, so this
		151	* can't race with watchdog_nmi_disable().
		152	*/
		153	static void lockup_detector_update_enable(void)
142	{	154	{
		155	watchdog_enabled = 0;
		156	if (!watchdog_user_enabled)
		157	return;
		158	if (nmi_watchdog_available && nmi_watchdog_user_enabled)
		159	watchdog_enabled \|= NMI_WATCHDOG_ENABLED;
		160	if (soft_watchdog_user_enabled)
		161	watchdog_enabled \|= SOFT_WATCHDOG_ENABLED;
143	}	162	}
144		163
145
146	#ifdef CONFIG_SOFTLOCKUP_DETECTOR	164	#ifdef CONFIG_SOFTLOCKUP_DETECTOR
147		165
148	/* Helper for online, unparked cpus. */	166	/* Global variables, exported for sysctl */
149	#define for_each_watchdog_cpu(cpu) \	167	unsigned int __read_mostly softlockup_panic =
150	for_each_cpu_and((cpu), cpu_online_mask, &watchdog_cpumask)	168	CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
151
152	atomic_t watchdog_park_in_progress = ATOMIC_INIT(0);
153		169
		170	static bool softlockup_threads_initialized __read_mostly;
154	static u64 __read_mostly sample_period;	171	static u64 __read_mostly sample_period;
155		172
156	static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);	173	static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts);
@@ -164,50 +181,40 @@ static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved); · 7 unmodified lines
164	static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);	181	static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);
165	static unsigned long soft_lockup_nmi_warn;	182	static unsigned long soft_lockup_nmi_warn;
166		183
167	unsigned int __read_mostly softlockup_panic =
168	CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
169
170	static int __init softlockup_panic_setup(char *str)	184	static int __init softlockup_panic_setup(char *str)
171	{	185	{
172	softlockup_panic = simple_strtoul(str, NULL, 0);	186	softlockup_panic = simple_strtoul(str, NULL, 0);
173
174	return 1;	187	return 1;
175	}	188	}
176	__setup("softlockup_panic=", softlockup_panic_setup);	189	__setup("softlockup_panic=", softlockup_panic_setup);
177		190
178	static int __init nowatchdog_setup(char *str)	191	static int __init nowatchdog_setup(char *str)
179	{	192	{
180	watchdog_enabled = 0;	193	watchdog_user_enabled = 0;
181	return 1;	194	return 1;
182	}	195	}
183	__setup("nowatchdog", nowatchdog_setup);	196	__setup("nowatchdog", nowatchdog_setup);
184		197
185	static int __init nosoftlockup_setup(char *str)	198	static int __init nosoftlockup_setup(char *str)
186	{	199	{
187	watchdog_enabled &= ~SOFT_WATCHDOG_ENABLED;	200	soft_watchdog_user_enabled = 0;
188	return 1;	201	return 1;
189	}	202	}
190	__setup("nosoftlockup", nosoftlockup_setup);	203	__setup("nosoftlockup", nosoftlockup_setup);
191		204
192	#ifdef CONFIG_SMP	205	#ifdef CONFIG_SMP
		206	int __read_mostly sysctl_softlockup_all_cpu_backtrace;
		207
193	static int __init softlockup_all_cpu_backtrace_setup(char *str)	208	static int __init softlockup_all_cpu_backtrace_setup(char *str)
194	{	209	{
195	sysctl_softlockup_all_cpu_backtrace =	210	sysctl_softlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0);
196	!!simple_strtol(str, NULL, 0);
197	return 1;	211	return 1;
198	}	212	}
199	__setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);	213	__setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);
200	#ifdef CONFIG_HARDLOCKUP_DETECTOR
201	static int __init hardlockup_all_cpu_backtrace_setup(char *str)
202	{
203	sysctl_hardlockup_all_cpu_backtrace =
204	!!simple_strtol(str, NULL, 0);
205	return 1;
206	}
207	__setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup);
208	#endif
209	#endif	214	#endif
210		215
		216	static void __lockup_detector_cleanup(void);
		217
211	/*	218	/*
212	* Hard-lockup warnings should be triggered after just a few seconds. Soft-	219	* Hard-lockup warnings should be triggered after just a few seconds. Soft-
213	* lockups can have false positives under extreme conditions. So we generally	220	* lockups can have false positives under extreme conditions. So we generally
@@ -278,11 +285,15 @@ void touch_all_softlockup_watchdogs(void) · 64 unmodified lines
278	int cpu;	285	int cpu;
279		286
280	/*	287	/*
281	* this is done lockless	288	* watchdog_mutex cannpt be taken here, as this might be called
282	* do we care if a 0 races with a timestamp?	289	* from (soft)interrupt context, so the access to
283	* all it means is the softlock check starts one cycle later	290	* watchdog_allowed_cpumask might race with a concurrent update.
		291	*
		292	* The watchdog time stamp can race against a concurrent real
		293	* update as well, the only side effect might be a cycle delay for
		294	* the softlockup check.
284	*/	295	*/
285	for_each_watchdog_cpu(cpu)	296	for_each_cpu(cpu, &watchdog_allowed_mask)
286	per_cpu(watchdog_touch_ts, cpu) = 0;	297	per_cpu(watchdog_touch_ts, cpu) = 0;
287	wq_watchdog_touch(-1);	298	wq_watchdog_touch(-1);
288	}	299	}
@@ -322,9 +333,6 @@ static void watchdog_interrupt_count(void) · 33 unmodified lines
322	__this_cpu_inc(hrtimer_interrupts);	333	__this_cpu_inc(hrtimer_interrupts);
323	}	334	}
324		335
325	static int watchdog_enable_all_cpus(void);
326	static void watchdog_disable_all_cpus(void);
327
328	/* watchdog kicker functions */	336	/* watchdog kicker functions */
329	static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)	337	static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
330	{	338	{
@@ -333,7 +341,7 @@ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer) · 2 unmodified lines
333	int duration;	341	int duration;
334	int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;	342	int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace;
335		343
336	if (atomic_read(&watchdog_park_in_progress) != 0)	344	if (!watchdog_enabled)
337	return HRTIMER_NORESTART;	345	return HRTIMER_NORESTART;
338		346
339	/* kick the hardlockup detector */	347	/* kick the hardlockup detector */
@@ -447,32 +455,38 @@ static void watchdog_set_prio(unsigned int policy, unsigned int prio) · 107 unmodified lines
447		455
448	static void watchdog_enable(unsigned int cpu)	456	static void watchdog_enable(unsigned int cpu)
449	{	457	{
450	struct hrtimer *hrtimer = raw_cpu_ptr(&watchdog_hrtimer);	458	struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);
451		459
452	/* kick off the timer for the hardlockup detector */	460	/*
		461	* Start the timer first to prevent the NMI watchdog triggering
		462	* before the timer has a chance to fire.
		463	*/
453	hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	464	hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
454	hrtimer->function = watchdog_timer_fn;	465	hrtimer->function = watchdog_timer_fn;
455
456	/* Enable the perf event */
457	watchdog_nmi_enable(cpu);
458
459	/* done here because hrtimer_start can only pin to smp_processor_id() */
460	hrtimer_start(hrtimer, ns_to_ktime(sample_period),	466	hrtimer_start(hrtimer, ns_to_ktime(sample_period),
461	HRTIMER_MODE_REL_PINNED);	467	HRTIMER_MODE_REL_PINNED);
462		468
463	/* initialize timestamp */	469	/* Initialize timestamp */
464	watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1);
465	__touch_watchdog();	470	__touch_watchdog();
		471	/* Enable the perf event */
		472	if (watchdog_enabled & NMI_WATCHDOG_ENABLED)
		473	watchdog_nmi_enable(cpu);
		474
		475	watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1);
466	}	476	}
467		477
468	static void watchdog_disable(unsigned int cpu)	478	static void watchdog_disable(unsigned int cpu)
469	{	479	{
470	struct hrtimer *hrtimer = raw_cpu_ptr(&watchdog_hrtimer);	480	struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);
471		481
472	watchdog_set_prio(SCHED_NORMAL, 0);	482	watchdog_set_prio(SCHED_NORMAL, 0);
473	hrtimer_cancel(hrtimer);	483	/*
474	/* disable the perf event */	484	* Disable the perf event first. That prevents that a large delay
		485	* between disabling the timer and disabling the perf event causes
		486	* the perf NMI to detect a false positive.
		487	*/
475	watchdog_nmi_disable(cpu);	488	watchdog_nmi_disable(cpu);
		489	hrtimer_cancel(hrtimer);
476	}	490	}
477		491
478	static void watchdog_cleanup(unsigned int cpu, bool online)	492	static void watchdog_cleanup(unsigned int cpu, bool online)
@@ -499,21 +513,6 @@ static void watchdog(unsigned int cpu) · 20 unmodified lines
499	__this_cpu_write(soft_lockup_hrtimer_cnt,	513	__this_cpu_write(soft_lockup_hrtimer_cnt,
500	__this_cpu_read(hrtimer_interrupts));	514	__this_cpu_read(hrtimer_interrupts));
501	__touch_watchdog();	515	__touch_watchdog();
502
503	/*
504	* watchdog_nmi_enable() clears the NMI_WATCHDOG_ENABLED bit in the
505	* failure path. Check for failures that can occur asynchronously -
506	* for example, when CPUs are on-lined - and shut down the hardware
507	* perf event on each CPU accordingly.
508	*
509	* The only non-obvious place this bit can be cleared is through
510	* watchdog_nmi_enable(), so a pr_info() is placed there. Placing a
511	* pr_info here would be too noisy as it would result in a message
512	* every few seconds if the hardlockup was disabled but the softlockup
513	* enabled.
514	*/
515	if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))
516	watchdog_nmi_disable(cpu);
517	}	516	}
518		517
519	static struct smp_hotplug_thread watchdog_threads = {	518	static struct smp_hotplug_thread watchdog_threads = {
@@ -527,295 +526,174 @@ static struct smp_hotplug_thread watchdog_threads = { · 7 unmodified lines
527	.unpark = watchdog_enable,	526	.unpark = watchdog_enable,
528	};	527	};
529		528
530	/*	529	static void softlockup_update_smpboot_threads(void)
531	* park all watchdog threads that are specified in 'watchdog_cpumask'
532	*
533	* This function returns an error if kthread_park() of a watchdog thread
534	* fails. In this situation, the watchdog threads of some CPUs can already
535	* be parked and the watchdog threads of other CPUs can still be runnable.
536	* Callers are expected to handle this special condition as appropriate in
537	* their context.
538	*
539	* This function may only be called in a context that is protected against
540	* races with CPU hotplug - for example, via get_online_cpus().
541	*/
542	static int watchdog_park_threads(void)
543	{	530	{
544	int cpu, ret = 0;	531	lockdep_assert_held(&watchdog_mutex);
545		532
546	atomic_set(&watchdog_park_in_progress, 1);	533	if (!softlockup_threads_initialized)
		534	return;
547		535
548	for_each_watchdog_cpu(cpu) {	536	smpboot_update_cpumask_percpu_thread(&watchdog_threads,
549	ret = kthread_park(per_cpu(softlockup_watchdog, cpu));	537	&watchdog_allowed_mask);
550	if (ret)
551	break;
552	}
553
554	atomic_set(&watchdog_park_in_progress, 0);
555
556	return ret;
557	}	538	}
558		539
559	/*	540	/* Temporarily park all watchdog threads */
560	* unpark all watchdog threads that are specified in 'watchdog_cpumask'	541	static void softlockup_park_all_threads(void)
561	*
562	* This function may only be called in a context that is protected against
563	* races with CPU hotplug - for example, via get_online_cpus().
564	*/
565	static void watchdog_unpark_threads(void)
566	{	542	{
567	int cpu;	543	cpumask_clear(&watchdog_allowed_mask);
568		544	softlockup_update_smpboot_threads();
569	for_each_watchdog_cpu(cpu)
570	kthread_unpark(per_cpu(softlockup_watchdog, cpu));
571	}	545	}
572		546
573	static int update_watchdog_all_cpus(void)	547	/* Unpark enabled threads */
		548	static void softlockup_unpark_threads(void)
574	{	549	{
575	int ret;	550	cpumask_copy(&watchdog_allowed_mask, &watchdog_cpumask);
576		551	softlockup_update_smpboot_threads();
577	ret = watchdog_park_threads();
578	if (ret)
579	return ret;
580
581	watchdog_unpark_threads();
582
583	return 0;
584	}	552	}
585		553
586	static int watchdog_enable_all_cpus(void)	554	static void lockup_detector_reconfigure(void)
587	{	555	{
588	int err = 0;	556	cpus_read_lock();
589		557	watchdog_nmi_stop();
590	if (!watchdog_running) {	558	softlockup_park_all_threads();
591	err = smpboot_register_percpu_thread_cpumask(&watchdog_threads,	559	set_sample_period();
592	&watchdog_cpumask);	560	lockup_detector_update_enable();
593	if (err)	561	if (watchdog_enabled && watchdog_thresh)
594	pr_err("Failed to create watchdog threads, disabled\n");	562	softlockup_unpark_threads();
595	else	563	watchdog_nmi_start();
596	watchdog_running = 1;	564	cpus_read_unlock();
597	} else {	565	/*
598	/*	566	* Must be called outside the cpus locked section to prevent
599	* Enable/disable the lockup detectors or	567	* recursive locking in the perf code.
600	* change the sample period 'on the fly'.	568	*/
601	*/	569	__lockup_detector_cleanup();
602	err = update_watchdog_all_cpus();
603
604	if (err) {
605	watchdog_disable_all_cpus();
606	pr_err("Failed to update lockup detectors, disabled\n");
607	}
608	}
609
610	if (err)
611	watchdog_enabled = 0;
612
613	return err;
614	}	570	}
615		571
616	static void watchdog_disable_all_cpus(void)	572	/*
		573	* Create the watchdog thread infrastructure and configure the detector(s).
		574	*
		575	* The threads are not unparked as watchdog_allowed_mask is empty. When
		576	* the threads are sucessfully initialized, take the proper locks and
		577	* unpark the threads in the watchdog_cpumask if the watchdog is enabled.
		578	*/
		579	static __init void lockup_detector_setup(void)
617	{	580	{
618	if (watchdog_running) {	581	int ret;
619	watchdog_running = 0;
620	smpboot_unregister_percpu_thread(&watchdog_threads);
621	}
622	}
623		582
624	#ifdef CONFIG_SYSCTL	583	/*
625	static int watchdog_update_cpus(void)	584	* If sysctl is off and watchdog got disabled on the command line,
626	{	585	* nothing to do here.
627	return smpboot_update_cpumask_percpu_thread(	586	*/
628	&watchdog_threads, &watchdog_cpumask);	587	lockup_detector_update_enable();
629	}
630	#endif
631		588
632	#else /* SOFTLOCKUP */	589	if (!IS_ENABLED(CONFIG_SYSCTL) &&
633	static int watchdog_park_threads(void)	590	!(watchdog_enabled && watchdog_thresh))
634	{	591	return;
635	return 0;
636	}
637		592
638	static void watchdog_unpark_threads(void)	593	ret = smpboot_register_percpu_thread_cpumask(&watchdog_threads,
639	{	594	&watchdog_allowed_mask);
640	}	595	if (ret) {
		596	pr_err("Failed to initialize soft lockup detector threads\n");
		597	return;
		598	}
641		599
642	static int watchdog_enable_all_cpus(void)	600	mutex_lock(&watchdog_mutex);
643	{	601	softlockup_threads_initialized = true;
644	return 0;	602	lockup_detector_reconfigure();
		603	mutex_unlock(&watchdog_mutex);
645	}	604	}
646		605
647	static void watchdog_disable_all_cpus(void)	606	#else /* CONFIG_SOFTLOCKUP_DETECTOR */
		607	static inline int watchdog_park_threads(void) { return 0; }
		608	static inline void watchdog_unpark_threads(void) { }
		609	static inline int watchdog_enable_all_cpus(void) { return 0; }
		610	static inline void watchdog_disable_all_cpus(void) { }
		611	static void lockup_detector_reconfigure(void)
648	{	612	{
		613	cpus_read_lock();
		614	watchdog_nmi_stop();
		615	lockup_detector_update_enable();
		616	watchdog_nmi_start();
		617	cpus_read_unlock();
649	}	618	}
650		619	static inline void lockup_detector_setup(void)
651	#ifdef CONFIG_SYSCTL
652	static int watchdog_update_cpus(void)
653	{	620	{
654	return 0;	621	lockup_detector_reconfigure();
655	}	622	}
656	#endif	623	#endif /* !CONFIG_SOFTLOCKUP_DETECTOR */
657		624
658	static void set_sample_period(void)	625	static void __lockup_detector_cleanup(void)
659	{	626	{
		627	lockdep_assert_held(&watchdog_mutex);
		628	hardlockup_detector_perf_cleanup();
660	}	629	}
661	#endif /* SOFTLOCKUP */
662		630
663	/*	631	/**
664	* Suspend the hard and soft lockup detector by parking the watchdog threads.	632	* lockup_detector_cleanup - Cleanup after cpu hotplug or sysctl changes
		633	*
		634	* Caller must not hold the cpu hotplug rwsem.
665	*/	635	*/
666	int lockup_detector_suspend(void)	636	void lockup_detector_cleanup(void)
667	{	637	{
668	int ret = 0;	638	mutex_lock(&watchdog_mutex);
669		639	__lockup_detector_cleanup();
670	get_online_cpus();	640	mutex_unlock(&watchdog_mutex);
671	mutex_lock(&watchdog_proc_mutex);
672	/*
673	* Multiple suspend requests can be active in parallel (counted by
674	* the 'watchdog_suspended' variable). If the watchdog threads are
675	* running, the first caller takes care that they will be parked.
676	* The state of 'watchdog_running' cannot change while a suspend
677	* request is active (see related code in 'proc' handlers).
678	*/
679	if (watchdog_running && !watchdog_suspended)
680	ret = watchdog_park_threads();
681
682	if (ret == 0)
683	watchdog_suspended++;
684	else {
685	watchdog_disable_all_cpus();
686	pr_err("Failed to suspend lockup detectors, disabled\n");
687	watchdog_enabled = 0;
688	}
689
690	watchdog_nmi_reconfigure();
691
692	mutex_unlock(&watchdog_proc_mutex);
693
694	return ret;
695	}	641	}
696		642
697	/*	643	/**
698	* Resume the hard and soft lockup detector by unparking the watchdog threads.	644	* lockup_detector_soft_poweroff - Interface to stop lockup detector(s)
		645	*
		646	* Special interface for parisc. It prevents lockup detector warnings from
		647	* the default pm_poweroff() function which busy loops forever.
699	*/	648	*/
700	void lockup_detector_resume(void)	649	void lockup_detector_soft_poweroff(void)
701	{	650	{
702	mutex_lock(&watchdog_proc_mutex);	651	watchdog_enabled = 0;
703
704	watchdog_suspended--;
705	/*
706	* The watchdog threads are unparked if they were previously running
707	* and if there is no more active suspend request.
708	*/
709	if (watchdog_running && !watchdog_suspended)
710	watchdog_unpark_threads();
711
712	watchdog_nmi_reconfigure();
713
714	mutex_unlock(&watchdog_proc_mutex);
715	put_online_cpus();
716	}	652	}
717		653
718	#ifdef CONFIG_SYSCTL	654	#ifdef CONFIG_SYSCTL
719		655
720	/*	656	/* Propagate any changes to the watchdog threads */
721	* Update the run state of the lockup detectors.	657	static void proc_watchdog_update(void)
722	*/
723	static int proc_watchdog_update(void)
724	{	658	{
725	int err = 0;	659	/* Remove impossible cpus to keep sysctl output clean. */
726		660	cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask);
727	/*	661	lockup_detector_reconfigure();
728	* Watchdog threads won't be started if they are already active.
729	* The 'watchdog_running' variable in watchdog_*_all_cpus() takes
730	* care of this. If those threads are already active, the sample
731	* period will be updated and the lockup detectors will be enabled
732	* or disabled 'on the fly'.
733	*/
734	if (watchdog_enabled && watchdog_thresh)
735	err = watchdog_enable_all_cpus();
736	else
737	watchdog_disable_all_cpus();
738
739	watchdog_nmi_reconfigure();
740
741	return err;
742
743	}	662	}
744		663
745	/*	664	/*
746	* common function for watchdog, nmi_watchdog and soft_watchdog parameter	665	* common function for watchdog, nmi_watchdog and soft_watchdog parameter
747	*	666	*
748	* caller \| table->data points to \| 'which' contains the flag(s)	667	* caller \| table->data points to \| 'which'
749	* -------------------\|-----------------------\|-----------------------------	668	* -------------------\|----------------------------\|--------------------------
750	* proc_watchdog \| watchdog_user_enabled \| NMI_WATCHDOG_ENABLED or'ed	669	* proc_watchdog \| watchdog_user_enabled \| NMI_WATCHDOG_ENABLED \|
751	* \| \| with SOFT_WATCHDOG_ENABLED	670	* \| \| SOFT_WATCHDOG_ENABLED
752	* -------------------\|-----------------------\|-----------------------------	671	* -------------------\|----------------------------\|--------------------------
753	* proc_nmi_watchdog \| nmi_watchdog_enabled \| NMI_WATCHDOG_ENABLED	672	* proc_nmi_watchdog \| nmi_watchdog_user_enabled \| NMI_WATCHDOG_ENABLED
754	* -------------------\|-----------------------\|-----------------------------	673	* -------------------\|----------------------------\|--------------------------
755	* proc_soft_watchdog \| soft_watchdog_enabled \| SOFT_WATCHDOG_ENABLED	674	* proc_soft_watchdog \| soft_watchdog_user_enabled \| SOFT_WATCHDOG_ENABLED
756	*/	675	*/
757	static int proc_watchdog_common(int which, struct ctl_table *table, int write,	676	static int proc_watchdog_common(int which, struct ctl_table *table, int write,
758	void __user buffer, size_t lenp, loff_t *ppos)	677	void __user buffer, size_t lenp, loff_t *ppos)
759	{	678	{
760	int err, old, new;	679	int err, old, *param = table->data;
761	int watchdog_param = (int )table->data;
762		680
763	get_online_cpus();	681	mutex_lock(&watchdog_mutex);
764	mutex_lock(&watchdog_proc_mutex);
765		682
766	if (watchdog_suspended) {
767	/* no parameter changes allowed while watchdog is suspended */
768	err = -EAGAIN;
769	goto out;
770	}
771
772	/*
773	* If the parameter is being read return the state of the corresponding
774	* bit(s) in 'watchdog_enabled', else update 'watchdog_enabled' and the
775	* run state of the lockup detectors.
776	*/
777	if (!write) {	683	if (!write) {
778	*watchdog_param = (watchdog_enabled & which) != 0;	684	/*
		685	* On read synchronize the userspace interface. This is a
		686	* racy snapshot.
		687	*/
		688	*param = (watchdog_enabled & which) != 0;
779	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);	689	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
780	} else {	690	} else {
		691	old = READ_ONCE(*param);
781	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);	692	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
782	if (err)	693	if (!err && old != READ_ONCE(*param))
783	goto out;	694	proc_watchdog_update();
784
785	/*
786	* There is a race window between fetching the current value
787	* from 'watchdog_enabled' and storing the new value. During
788	* this race window, watchdog_nmi_enable() can sneak in and
789	* clear the NMI_WATCHDOG_ENABLED bit in 'watchdog_enabled'.
790	* The 'cmpxchg' detects this race and the loop retries.
791	*/
792	do {
793	old = watchdog_enabled;
794	/*
795	* If the parameter value is not zero set the
796	* corresponding bit(s), else clear it(them).
797	*/
798	if (*watchdog_param)
799	new = old \| which;
800	else
801	new = old & ~which;
802	} while (cmpxchg(&watchdog_enabled, old, new) != old);
803
804	/*
805	* Update the run state of the lockup detectors. There is _no_
806	* need to check the value returned by proc_watchdog_update()
807	* and to restore the previous value of 'watchdog_enabled' as
808	* both lockup detectors are disabled if proc_watchdog_update()
809	* returns an error.
810	*/
811	if (old == new)
812	goto out;
813
814	err = proc_watchdog_update();
815	}	695	}
816	out:	696	mutex_unlock(&watchdog_mutex);
817	mutex_unlock(&watchdog_proc_mutex);
818	put_online_cpus();
819	return err;	697	return err;
820	}	698	}
821		699
@@ -835,6 +713,8 @@ int proc_watchdog(struct ctl_table *table, int write, · 13 unmodified lines
835	int proc_nmi_watchdog(struct ctl_table *table, int write,	713	int proc_nmi_watchdog(struct ctl_table *table, int write,
836	void __user buffer, size_t lenp, loff_t *ppos)	714	void __user buffer, size_t lenp, loff_t *ppos)
837	{	715	{
		716	if (!nmi_watchdog_available && write)
		717	return -ENOTSUPP;
838	return proc_watchdog_common(NMI_WATCHDOG_ENABLED,	718	return proc_watchdog_common(NMI_WATCHDOG_ENABLED,
839	table, write, buffer, lenp, ppos);	719	table, write, buffer, lenp, ppos);
840	}	720	}
@@ -855,39 +735,17 @@ int proc_soft_watchdog(struct ctl_table *table, int write, · 14 unmodified lines
855	int proc_watchdog_thresh(struct ctl_table *table, int write,	735	int proc_watchdog_thresh(struct ctl_table *table, int write,
856	void __user buffer, size_t lenp, loff_t *ppos)	736	void __user buffer, size_t lenp, loff_t *ppos)
857	{	737	{
858	int err, old, new;	738	int err, old;
859
860	get_online_cpus();
861	mutex_lock(&watchdog_proc_mutex);
862		739
863	if (watchdog_suspended) {	740	mutex_lock(&watchdog_mutex);
864	/* no parameter changes allowed while watchdog is suspended */
865	err = -EAGAIN;
866	goto out;
867	}
868		741
869	old = ACCESS_ONCE(watchdog_thresh);	742	old = READ_ONCE(watchdog_thresh);
870	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);	743	err = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
871		744
872	if (err \|\| !write)	745	if (!err && write && old != READ_ONCE(watchdog_thresh))
873	goto out;	746	proc_watchdog_update();
874
875	/*
876	* Update the sample period. Restore on failure.
877	*/
878	new = ACCESS_ONCE(watchdog_thresh);
879	if (old == new)
880	goto out;
881		747
882	set_sample_period();	748	mutex_unlock(&watchdog_mutex);
883	err = proc_watchdog_update();
884	if (err) {
885	watchdog_thresh = old;
886	set_sample_period();
887	}
888	out:
889	mutex_unlock(&watchdog_proc_mutex);
890	put_online_cpus();
891	return err;	749	return err;
892	}	750	}
893		751
@@ -902,45 +760,19 @@ int proc_watchdog_cpumask(struct ctl_table *table, int write, · 8 unmodified lines
902	{	760	{
903	int err;	761	int err;
904		762
905	get_online_cpus();	763	mutex_lock(&watchdog_mutex);
906	mutex_lock(&watchdog_proc_mutex);
907
908	if (watchdog_suspended) {
909	/* no parameter changes allowed while watchdog is suspended */
910	err = -EAGAIN;
911	goto out;
912	}
913		764
914	err = proc_do_large_bitmap(table, write, buffer, lenp, ppos);	765	err = proc_do_large_bitmap(table, write, buffer, lenp, ppos);
915	if (!err && write) {	766	if (!err && write)
916	/* Remove impossible cpus to keep sysctl output cleaner. */	767	proc_watchdog_update();
917	cpumask_and(&watchdog_cpumask, &watchdog_cpumask,
918	cpu_possible_mask);
919
920	if (watchdog_running) {
921	/*
922	* Failure would be due to being unable to allocate
923	* a temporary cpumask, so we are likely not in a
924	* position to do much else to make things better.
925	*/
926	if (watchdog_update_cpus() != 0)
927	pr_err("cpumask update failed\n");
928	}
929		768
930	watchdog_nmi_reconfigure();	769	mutex_unlock(&watchdog_mutex);
931	}
932	out:
933	mutex_unlock(&watchdog_proc_mutex);
934	put_online_cpus();
935	return err;	770	return err;
936	}	771	}
937
938	#endif /* CONFIG_SYSCTL */	772	#endif /* CONFIG_SYSCTL */
939		773
940	void __init lockup_detector_init(void)	774	void __init lockup_detector_init(void)
941	{	775	{
942	set_sample_period();
943
944	#ifdef CONFIG_NO_HZ_FULL	776	#ifdef CONFIG_NO_HZ_FULL
945	if (tick_nohz_full_enabled()) {	777	if (tick_nohz_full_enabled()) {
946	pr_info("Disabling watchdog on nohz_full cores by default\n");	778	pr_info("Disabling watchdog on nohz_full cores by default\n");
@@ -951,6 +783,7 @@ void __init lockup_detector_init(void) · 4 unmodified lines
951	cpumask_copy(&watchdog_cpumask, cpu_possible_mask);	783	cpumask_copy(&watchdog_cpumask, cpu_possible_mask);
952	#endif	784	#endif
953		785
954	if (watchdog_enabled)	786	if (!watchdog_nmi_probe())
955	watchdog_enable_all_cpus();	787	nmi_watchdog_available = true;
		788	lockup_detector_setup();
956	}	789	}

kernel/watchdog_hld.c+111−85

 static DEFINE_PER_CPU(bool, hard_watchdog_warn);
 static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
 static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
+static struct cpumask dead_events_mask;
 static unsigned long hardlockup_allcpu_dumped;
+static unsigned int watchdog_cpus;
 void arch_touch_nmi_watchdog(void)
 {
 /* Callback function for perf event subsystem */
 static void watchdog_overflow_callback(struct perf_event *event,
-		 struct perf_sample_data *data,
+				       struct perf_sample_data *data,
-		 struct pt_regs *regs)
+				       struct pt_regs *regs)
 {
 	/* Ensure the watchdog never gets throttled */
 	event->hw.interrupts = 0;
-	if (atomic_read(&watchdog_park_in_progress) != 0)
-		return;
 	if (__this_cpu_read(watchdog_nmi_touch) == true) {
 		__this_cpu_write(watchdog_nmi_touch, false);
 		return;
 	return;
 }
-/*
+static int hardlockup_detector_event_create(void)
- * People like the simple clean cpu node info on boot.
- * Reduce the watchdog noise by only printing messages
- * that are different from what cpu0 displayed.
- */
-static unsigned long firstcpu_err;
-static atomic_t watchdog_cpus;
-int watchdog_nmi_enable(unsigned int cpu)
 {
+	unsigned int cpu = smp_processor_id();
 	struct perf_event_attr *wd_attr;
-	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+	struct perf_event *evt;
-	int firstcpu = 0;
-	/* nothing to do if the hard lockup detector is disabled */
-	if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))
-		goto out;
-	/* is it already setup and enabled? */
-	if (event && event->state > PERF_EVENT_STATE_OFF)
-		goto out;
-	/* it is setup but not enabled */
-	if (event != NULL)
-		goto out_enable;
-	if (atomic_inc_return(&watchdog_cpus) == 1)
-		firstcpu = 1;
 	wd_attr = &wd_hw_attr;
 	wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh);
 	/* Try to register using hardware perf events */
-	event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback, NULL);
+	evt = perf_event_create_kernel_counter(wd_attr, cpu, NULL,
+					       watchdog_overflow_callback, NULL);
+	if (IS_ERR(evt)) {
+		pr_info("Perf event create on CPU %d failed with %ld\n", cpu,
+			PTR_ERR(evt));
+		return PTR_ERR(evt);
+	}
+	this_cpu_write(watchdog_ev, evt);
+	return 0;
+}
-	/* save the first cpu's error for future comparision */
+/**
-	if (firstcpu && IS_ERR(event))
+ * hardlockup_detector_perf_enable - Enable the local event
-		firstcpu_err = PTR_ERR(event);
+ */
+void hardlockup_detector_perf_enable(void)
+{
+	if (hardlockup_detector_event_create())
+		return;
-	if (!IS_ERR(event)) {
+	if (!watchdog_cpus++)
-		/* only print for the first cpu initialized */
+		pr_info("Enabled. Permanently consumes one hw-PMU counter.\n");
-		if (firstcpu || firstcpu_err)
-			pr_info("enabled on all CPUs, permanently consumes one hw-PMU counter.\n");
-		goto out_save;
-	}
-	/*
+	perf_event_enable(this_cpu_read(watchdog_ev));
-	 * Disable the hard lockup detector if _any_ CPU fails to set up
-	 * set up the hardware perf event. The watchdog() function checks
-	 * the NMI_WATCHDOG_ENABLED bit periodically.
-	 *
-	 * The barriers are for syncing up watchdog_enabled across all the
-	 * cpus, as clear_bit() does not use barriers.
-	 */
-	smp_mb__before_atomic();
-	clear_bit(NMI_WATCHDOG_ENABLED_BIT, &watchdog_enabled);
-	smp_mb__after_atomic();
-	/* skip displaying the same error again */
-	if (!firstcpu && (PTR_ERR(event) == firstcpu_err))
-		return PTR_ERR(event);
-	/* vary the KERN level based on the returned errno */
-	if (PTR_ERR(event) == -EOPNOTSUPP)
-		pr_info("disabled (cpu%i): not supported (no LAPIC?)\n", cpu);
-	else if (PTR_ERR(event) == -ENOENT)
-		pr_warn("disabled (cpu%i): hardware events not enabled\n",
-			 cpu);
-	else
-		pr_err("disabled (cpu%i): unable to create perf event: %ld\n",
-			cpu, PTR_ERR(event));
-	pr_info("Shutting down hard lockup detector on all cpus\n");
-	return PTR_ERR(event);
-	/* success path */
-out_save:
-	per_cpu(watchdog_ev, cpu) = event;
-out_enable:
-	perf_event_enable(per_cpu(watchdog_ev, cpu));
-out:
-	return 0;
 }
-void watchdog_nmi_disable(unsigned int cpu)
+/**
+ * hardlockup_detector_perf_disable - Disable the local event
+ */
+void hardlockup_detector_perf_disable(void)
 {
-	struct perf_event *event = per_cpu(watchdog_ev, cpu);
+	struct perf_event *event = this_cpu_read(watchdog_ev);
 	if (event) {
 		perf_event_disable(event);
+		cpumask_set_cpu(smp_processor_id(), &dead_events_mask);
+		watchdog_cpus--;
+	}
+}
+/**
+ * hardlockup_detector_perf_cleanup - Cleanup disabled events and destroy them
+ *
+ * Called from lockup_detector_cleanup(). Serialized by the caller.
+ */
+void hardlockup_detector_perf_cleanup(void)
+{
+	int cpu;
+	for_each_cpu(cpu, &dead_events_mask) {
+		struct perf_event *event = per_cpu(watchdog_ev, cpu);
+		/*
+		 * Required because for_each_cpu() reports  unconditionally
+		 * CPU0 as set on UP kernels. Sigh.
+		 */
+		if (event)
+			perf_event_release_kernel(event);
 		per_cpu(watchdog_ev, cpu) = NULL;
+	}
+	cpumask_clear(&dead_events_mask);
+}
+/**
+ * hardlockup_detector_perf_stop - Globally stop watchdog events
+ *
+ * Special interface for x86 to handle the perf HT bug.
+ */
+void __init hardlockup_detector_perf_stop(void)
+{
+	int cpu;
+	lockdep_assert_cpus_held();
+	for_each_online_cpu(cpu) {
+		struct perf_event *event = per_cpu(watchdog_ev, cpu);
+		if (event)
+			perf_event_disable(event);
+	}
+}
-		/* should be in cleanup, but blocks oprofile */
+/**
-		perf_event_release_kernel(event);
+ * hardlockup_detector_perf_restart - Globally restart watchdog events
+ *
+ * Special interface for x86 to handle the perf HT bug.
+ */
+void __init hardlockup_detector_perf_restart(void)
+{
+	int cpu;
+	lockdep_assert_cpus_held();
+	if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED))
+		return;
+	for_each_online_cpu(cpu) {
+		struct perf_event *event = per_cpu(watchdog_ev, cpu);
+		if (event)
+			perf_event_enable(event);
+	}
+}
+/**
+ * hardlockup_detector_perf_init - Probe whether NMI event is available at all
+ */
+int __init hardlockup_detector_perf_init(void)
+{
+	int ret = hardlockup_detector_event_create();
-		/* watchdog_nmi_enable() expects this to be zero initially. */
+	if (ret) {
-		if (atomic_dec_and_test(&watchdog_cpus))
+		pr_info("Perf NMI watchdog permanently disabled\n");
-			firstcpu_err = 0;
+	} else {
+		perf_event_release_kernel(this_cpu_read(watchdog_ev));
+		this_cpu_write(watchdog_ev, NULL);
 	}
+	return ret;
 }

net/bridge/netfilter/ebtable_broute.c+2−2

@@ -65,8 +65,8 @@ static int ebt_broute(struct sk_buff *skb) · 64 unmodified lines
65		65
66	static int __net_init broute_net_init(struct net *net)	66	static int __net_init broute_net_init(struct net *net)
67	{	67	{
68	net->xt.broute_table = ebt_register_table(net, &broute_table, NULL);	68	return ebt_register_table(net, &broute_table, NULL,
69	return PTR_ERR_OR_ZERO(net->xt.broute_table);	69	&net->xt.broute_table);
70	}	70	}
71		71
72	static void __net_exit broute_net_exit(struct net *net)	72	static void __net_exit broute_net_exit(struct net *net)

net/bridge/netfilter/ebtable_filter.c+2−2

@@ -93,8 +93,8 @@ static const struct nf_hook_ops ebt_ops_filter[] = { · 92 unmodified lines
93		93
94	static int __net_init frame_filter_net_init(struct net *net)	94	static int __net_init frame_filter_net_init(struct net *net)
95	{	95	{
96	net->xt.frame_filter = ebt_register_table(net, &frame_filter, ebt_ops_filter);	96	return ebt_register_table(net, &frame_filter, ebt_ops_filter,
97	return PTR_ERR_OR_ZERO(net->xt.frame_filter);	97	&net->xt.frame_filter);
98	}	98	}
99		99
100	static void __net_exit frame_filter_net_exit(struct net *net)	100	static void __net_exit frame_filter_net_exit(struct net *net)

net/bridge/netfilter/ebtable_nat.c+2−2

@@ -93,8 +93,8 @@ static const struct nf_hook_ops ebt_ops_nat[] = { · 92 unmodified lines
93		93
94	static int __net_init frame_nat_net_init(struct net *net)	94	static int __net_init frame_nat_net_init(struct net *net)
95	{	95	{
96	net->xt.frame_nat = ebt_register_table(net, &frame_nat, ebt_ops_nat);	96	return ebt_register_table(net, &frame_nat, ebt_ops_nat,
97	return PTR_ERR_OR_ZERO(net->xt.frame_nat);	97	&net->xt.frame_nat);
98	}	98	}
99		99
100	static void __net_exit frame_nat_net_exit(struct net *net)	100	static void __net_exit frame_nat_net_exit(struct net *net)

net/bridge/netfilter/ebtables.c+9−8

 	kfree(table);
 }
-struct ebt_table *
+int ebt_register_table(struct net *net, const struct ebt_table *input_table,
-ebt_register_table(struct net *net, const struct ebt_table *input_table,
+		       const struct nf_hook_ops *ops, struct ebt_table **res)
-		   const struct nf_hook_ops *ops)
 {
 	struct ebt_table_info *newinfo;
 	struct ebt_table *t, *table;
 	    repl->entries == NULL || repl->entries_size == 0 ||
 	    repl->counters != NULL || input_table->private != NULL) {
 		BUGPRINT("Bad table data for ebt_register_table!!!\n");
-		return ERR_PTR(-EINVAL);
+		return -EINVAL;
 	}
 	/* Don't add one table to multiple lists. */
 	list_add(&table->list, &net->xt.tables[NFPROTO_BRIDGE]);
 	mutex_unlock(&ebt_mutex);
+	WRITE_ONCE(*res, table);
 	if (!ops)
-		return table;
+		return 0;
 	ret = nf_register_net_hooks(net, ops, hweight32(table->valid_hooks));
 	if (ret) {
 		__ebt_unregister_table(net, table);
-		return ERR_PTR(ret);
+		*res = NULL;
 	}
-	return table;
+	return ret;
 free_unlock:
 	mutex_unlock(&ebt_mutex);
 free_chainstack:
 free_table:
 	kfree(table);
 out:
-	return ERR_PTR(ret);
+	return ret;
 }
 void ebt_unregister_table(struct net *net, struct ebt_table *table,

net/ipv4/gre_offload.c+1−1

@@ -86,7 +86,7 @@ static struct sk_buff gre_gso_segment(struct sk_buff skb, · 85 unmodified lines
86	greh = (struct gre_base_hdr *)skb_transport_header(skb);	86	greh = (struct gre_base_hdr *)skb_transport_header(skb);
87	pcsum = (__sum16 *)(greh + 1);	87	pcsum = (__sum16 *)(greh + 1);
88		88
89	if (gso_partial) {	89	if (gso_partial && skb_is_gso(skb)) {
90	unsigned int partial_adj;	90	unsigned int partial_adj;
91		91
92	/* Adjust checksum to account for the fact that	92	/* Adjust checksum to account for the fact that

net/ipv4/netfilter/ipt_SYNPROXY.c+2−1

@@ -330,7 +330,8 @@ static unsigned int ipv4_synproxy_hook(void *priv, · 329 unmodified lines
330	if (synproxy == NULL)	330	if (synproxy == NULL)
331	return NF_ACCEPT;	331	return NF_ACCEPT;
332		332
333	if (nf_is_loopback_packet(skb))	333	if (nf_is_loopback_packet(skb) \|\|
		334	ip_hdr(skb)->protocol != IPPROTO_TCP)
334	return NF_ACCEPT;	335	return NF_ACCEPT;
335		336
336	thoff = ip_hdrlen(skb);	337	thoff = ip_hdrlen(skb);

net/ipv4/route.c+1−1

@@ -2513,7 +2513,7 @@ struct dst_entry ipv4_blackhole_route(struct net net, struct dst_entry *dst_or · 2512 unmodified lines
2513	struct rtable ort = (struct rtable ) dst_orig;	2513	struct rtable ort = (struct rtable ) dst_orig;
2514	struct rtable *rt;	2514	struct rtable *rt;
2515		2515
2516	rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);	2516	rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
2517	if (rt) {	2517	if (rt) {
2518	struct dst_entry *new = &rt->dst;	2518	struct dst_entry *new = &rt->dst;
2519		2519

net/ipv4/udp.c+5−9

 	iph = ip_hdr(skb);
 	uh = udp_hdr(skb);
-	if (skb->pkt_type == PACKET_BROADCAST ||
+	if (skb->pkt_type == PACKET_MULTICAST) {
-	    skb->pkt_type == PACKET_MULTICAST) {
 		in_dev = __in_dev_get_rcu(skb->dev);
 		if (!in_dev)
 			return 0;
-		/* we are supposed to accept bcast packets */
+		ours = ip_check_mc_rcu(in_dev, iph->daddr, iph->saddr,
-		if (skb->pkt_type == PACKET_MULTICAST) {
+				       iph->protocol);
-			ours = ip_check_mc_rcu(in_dev, iph->daddr, iph->saddr,
+		if (!ours)
-					       iph->protocol);
+			return 0;
-			if (!ours)
-				return 0;
-		}
 		sk = __udp4_lib_mcast_demux_lookup(net, uh->dest, iph->daddr,
 						   uh->source, iph->saddr,

net/ipv4/udp_offload.c+1−1

@@ -120,7 +120,7 @@ static struct sk_buff __skb_udp_tunnel_segment(struct sk_buff skb, · 119 unmodified lines
120	* will be using a length value equal to only one MSS sized	120	* will be using a length value equal to only one MSS sized
121	* segment instead of the entire frame.	121	* segment instead of the entire frame.
122	*/	122	*/
123	if (gso_partial) {	123	if (gso_partial && skb_is_gso(skb)) {
124	uh->len = htons(skb_shinfo(skb)->gso_size +	124	uh->len = htons(skb_shinfo(skb)->gso_size +
125	SKB_GSO_CB(skb)->data_offset +	125	SKB_GSO_CB(skb)->data_offset +
126	skb->head - (unsigned char *)uh);	126	skb->head - (unsigned char *)uh);

net/ipv6/addrconf.c+2−2

@@ -3800,8 +3800,8 @@ static void addrconf_dad_begin(struct inet6_ifaddr *ifp) · 3799 unmodified lines
3800	goto out;	3800	goto out;
3801		3801
3802	if (dev->flags&(IFF_NOARP\|IFF_LOOPBACK) \|\|	3802	if (dev->flags&(IFF_NOARP\|IFF_LOOPBACK) \|\|
3803	dev_net(dev)->ipv6.devconf_all->accept_dad < 1 \|\|	3803	(dev_net(dev)->ipv6.devconf_all->accept_dad < 1 &&
3804	idev->cnf.accept_dad < 1 \|\|	3804	idev->cnf.accept_dad < 1) \|\|
3805	!(ifp->flags&IFA_F_TENTATIVE) \|\|	3805	!(ifp->flags&IFA_F_TENTATIVE) \|\|
3806	ifp->flags & IFA_F_NODAD) {	3806	ifp->flags & IFA_F_NODAD) {
3807	bump_id = ifp->flags & IFA_F_TENTATIVE;	3807	bump_id = ifp->flags & IFA_F_TENTATIVE;

net/ipv6/ip6_offload.c+1−1

@@ -105,7 +105,7 @@ static struct sk_buff ipv6_gso_segment(struct sk_buff skb, · 104 unmodified lines
105		105
106	for (skb = segs; skb; skb = skb->next) {	106	for (skb = segs; skb; skb = skb->next) {
107	ipv6h = (struct ipv6hdr *)(skb_mac_header(skb) + nhoff);	107	ipv6h = (struct ipv6hdr *)(skb_mac_header(skb) + nhoff);
108	if (gso_partial)	108	if (gso_partial && skb_is_gso(skb))
109	payload_len = skb_shinfo(skb)->gso_size +	109	payload_len = skb_shinfo(skb)->gso_size +
110	SKB_GSO_CB(skb)->data_offset +	110	SKB_GSO_CB(skb)->data_offset +
111	skb->head - (unsigned char *)(ipv6h + 1);	111	skb->head - (unsigned char *)(ipv6h + 1);

net/ipv6/netfilter/ip6t_SYNPROXY.c+1−1

@@ -353,7 +353,7 @@ static unsigned int ipv6_synproxy_hook(void *priv, · 352 unmodified lines
353	nexthdr = ipv6_hdr(skb)->nexthdr;	353	nexthdr = ipv6_hdr(skb)->nexthdr;
354	thoff = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr,	354	thoff = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr,
355	&frag_off);	355	&frag_off);
356	if (thoff < 0)	356	if (thoff < 0 \|\| nexthdr != IPPROTO_TCP)
357	return NF_ACCEPT;	357	return NF_ACCEPT;
358		358
359	th = skb_header_pointer(skb, thoff, sizeof(_th), &_th);	359	th = skb_header_pointer(skb, thoff, sizeof(_th), &_th);

net/ipv6/route.c+1−1

@@ -1877,7 +1877,7 @@ struct dst_entry ip6_blackhole_route(struct net net, struct dst_entry *dst_ori · 1876 unmodified lines
1877	struct dst_entry *new = NULL;	1877	struct dst_entry *new = NULL;
1878		1878
1879	rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,	1879	rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,
1880	DST_OBSOLETE_NONE, 0);	1880	DST_OBSOLETE_DEAD, 0);
1881	if (rt) {	1881	if (rt) {
1882	rt6_info_init(rt);	1882	rt6_info_init(rt);
1883	atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);	1883	atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);

net/netfilter/ipset/ip_set_core.c+18−11

@@ -1191,14 +1191,17 @@ static int ip_set_swap(struct net net, struct sock ctnl, struct sk_buff *skb, · 1190 unmodified lines
1191	from->family == to->family))	1191	from->family == to->family))
1192	return -IPSET_ERR_TYPE_MISMATCH;	1192	return -IPSET_ERR_TYPE_MISMATCH;
1193		1193
1194	if (from->ref_netlink \|\| to->ref_netlink)	1194	write_lock_bh(&ip_set_ref_lock);
		1195
		1196	if (from->ref_netlink \|\| to->ref_netlink) {
		1197	write_unlock_bh(&ip_set_ref_lock);
1195	return -EBUSY;	1198	return -EBUSY;
		1199	}
1196		1200
1197	strncpy(from_name, from->name, IPSET_MAXNAMELEN);	1201	strncpy(from_name, from->name, IPSET_MAXNAMELEN);
1198	strncpy(from->name, to->name, IPSET_MAXNAMELEN);	1202	strncpy(from->name, to->name, IPSET_MAXNAMELEN);
1199	strncpy(to->name, from_name, IPSET_MAXNAMELEN);	1203	strncpy(to->name, from_name, IPSET_MAXNAMELEN);
1200		1204
1201	write_lock_bh(&ip_set_ref_lock);
1202	swap(from->ref, to->ref);	1205	swap(from->ref, to->ref);
1203	ip_set(inst, from_id) = to;	1206	ip_set(inst, from_id) = to;
1204	ip_set(inst, to_id) = from;	1207	ip_set(inst, to_id) = from;
@@ -2072,25 +2075,28 @@ static struct pernet_operations ip_set_net_ops = { · 867 unmodified lines
2072	static int __init	2075	static int __init
2073	ip_set_init(void)	2076	ip_set_init(void)
2074	{	2077	{
2075	int ret = nfnetlink_subsys_register(&ip_set_netlink_subsys);	2078	int ret = register_pernet_subsys(&ip_set_net_ops);
		2079
		2080	if (ret) {
		2081	pr_err("ip_set: cannot register pernet_subsys.\n");
		2082	return ret;
		2083	}
2076		2084
		2085	ret = nfnetlink_subsys_register(&ip_set_netlink_subsys);
2077	if (ret != 0) {	2086	if (ret != 0) {
2078	pr_err("ip_set: cannot register with nfnetlink.\n");	2087	pr_err("ip_set: cannot register with nfnetlink.\n");
		2088	unregister_pernet_subsys(&ip_set_net_ops);
2079	return ret;	2089	return ret;
2080	}	2090	}
		2091
2081	ret = nf_register_sockopt(&so_set);	2092	ret = nf_register_sockopt(&so_set);
2082	if (ret != 0) {	2093	if (ret != 0) {
2083	pr_err("SO_SET registry failed: %d\n", ret);	2094	pr_err("SO_SET registry failed: %d\n", ret);
2084	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);	2095	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
		2096	unregister_pernet_subsys(&ip_set_net_ops);
2085	return ret;	2097	return ret;
2086	}	2098	}
2087	ret = register_pernet_subsys(&ip_set_net_ops);	2099
2088	if (ret) {
2089	pr_err("ip_set: cannot register pernet_subsys.\n");
2090	nf_unregister_sockopt(&so_set);
2091	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
2092	return ret;
2093	}
2094	pr_info("ip_set: protocol %u\n", IPSET_PROTOCOL);	2100	pr_info("ip_set: protocol %u\n", IPSET_PROTOCOL);
2095	return 0;	2101	return 0;
2096	}	2102	}
@@ -2098,9 +2104,10 @@ ip_set_init(void) · 1 unmodified line
2098	static void __exit	2104	static void __exit
2099	ip_set_fini(void)	2105	ip_set_fini(void)
2100	{	2106	{
2101	unregister_pernet_subsys(&ip_set_net_ops);
2102	nf_unregister_sockopt(&so_set);	2107	nf_unregister_sockopt(&so_set);
2103	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);	2108	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
		2109
		2110	unregister_pernet_subsys(&ip_set_net_ops);
2104	pr_debug("these are the famous last words\n");	2111	pr_debug("these are the famous last words\n");
2105	}	2112	}
2106		2113

net/netfilter/ipset/ip_set_hash_ip.c+12−10

 		return ret;
 	ip &= ip_set_hostmask(h->netmask);
+	e.ip = htonl(ip);
+	if (e.ip == 0)
+		return -IPSET_ERR_HASH_ELEM;
-	if (adt == IPSET_TEST) {
+	if (adt == IPSET_TEST)
-		e.ip = htonl(ip);
-		if (e.ip == 0)
-			return -IPSET_ERR_HASH_ELEM;
 		return adtfn(set, &e, &ext, &ext, flags);
-	}
 	ip_to = ip;
 	if (tb[IPSET_ATTR_IP_TO]) {
 	hosts = h->netmask == 32 ? 1 : 2 << (32 - h->netmask - 1);
-	if (retried)
+	if (retried) {
 		ip = ntohl(h->next.ip);
-	for (; !before(ip_to, ip); ip += hosts) {
 		e.ip = htonl(ip);
-		if (e.ip == 0)
+	}
-			return -IPSET_ERR_HASH_ELEM;
+	for (; ip <= ip_to;) {
 		ret = adtfn(set, &e, &ext, &ext, flags);
 		if (ret && !ip_set_eexist(ret, flags))
 			return ret;
+		ip += hosts;
+		e.ip = htonl(ip);
+		if (e.ip == 0)
+			return 0;
 		ret = 0;
 	}
 	return ret;

net/netfilter/ipset/ip_set_hash_ipmark.c+1−1

@@ -149,7 +149,7 @@ hash_ipmark4_uadt(struct ip_set set, struct nlattr tb[], · 148 unmodified lines
149		149
150	if (retried)	150	if (retried)
151	ip = ntohl(h->next.ip);	151	ip = ntohl(h->next.ip);
152	for (; !before(ip_to, ip); ip++) {	152	for (; ip <= ip_to; ip++) {
153	e.ip = htonl(ip);	153	e.ip = htonl(ip);
154	ret = adtfn(set, &e, &ext, &ext, flags);	154	ret = adtfn(set, &e, &ext, &ext, flags);
155		155

net/netfilter/ipset/ip_set_hash_ipport.c+1−1

@@ -178,7 +178,7 @@ hash_ipport4_uadt(struct ip_set set, struct nlattr tb[], · 177 unmodified lines
178		178
179	if (retried)	179	if (retried)
180	ip = ntohl(h->next.ip);	180	ip = ntohl(h->next.ip);
181	for (; !before(ip_to, ip); ip++) {	181	for (; ip <= ip_to; ip++) {
182	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)	182	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)
183	: port;	183	: port;
184	for (; p <= port_to; p++) {	184	for (; p <= port_to; p++) {

net/netfilter/ipset/ip_set_hash_ipportip.c+1−1

@@ -185,7 +185,7 @@ hash_ipportip4_uadt(struct ip_set set, struct nlattr tb[], · 184 unmodified lines
185		185
186	if (retried)	186	if (retried)
187	ip = ntohl(h->next.ip);	187	ip = ntohl(h->next.ip);
188	for (; !before(ip_to, ip); ip++) {	188	for (; ip <= ip_to; ip++) {
189	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)	189	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)
190	: port;	190	: port;
191	for (; p <= port_to; p++) {	191	for (; p <= port_to; p++) {

net/netfilter/ipset/ip_set_hash_ipportnet.c+2−2

@@ -271,7 +271,7 @@ hash_ipportnet4_uadt(struct ip_set set, struct nlattr tb[], · 270 unmodified lines
271		271
272	if (retried)	272	if (retried)
273	ip = ntohl(h->next.ip);	273	ip = ntohl(h->next.ip);
274	for (; !before(ip_to, ip); ip++) {	274	for (; ip <= ip_to; ip++) {
275	e.ip = htonl(ip);	275	e.ip = htonl(ip);
276	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)	276	p = retried && ip == ntohl(h->next.ip) ? ntohs(h->next.port)
277	: port;	277	: port;
@@ -281,7 +281,7 @@ hash_ipportnet4_uadt(struct ip_set set, struct nlattr tb[], · 3 unmodified lines
281	ip == ntohl(h->next.ip) &&	281	ip == ntohl(h->next.ip) &&
282	p == ntohs(h->next.port)	282	p == ntohs(h->next.port)
283	? ntohl(h->next.ip2) : ip2_from;	283	? ntohl(h->next.ip2) : ip2_from;
284	while (!after(ip2, ip2_to)) {	284	while (ip2 <= ip2_to) {
285	e.ip2 = htonl(ip2);	285	e.ip2 = htonl(ip2);
286	ip2_last = ip_set_range_to_cidr(ip2, ip2_to,	286	ip2_last = ip_set_range_to_cidr(ip2, ip2_to,
287	&cidr);	287	&cidr);

net/netfilter/ipset/ip_set_hash_net.c+1−1

@@ -193,7 +193,7 @@ hash_net4_uadt(struct ip_set set, struct nlattr tb[], · 192 unmodified lines
193	}	193	}
194	if (retried)	194	if (retried)
195	ip = ntohl(h->next.ip);	195	ip = ntohl(h->next.ip);
196	while (!after(ip, ip_to)) {	196	while (ip <= ip_to) {
197	e.ip = htonl(ip);	197	e.ip = htonl(ip);
198	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr);	198	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr);
199	ret = adtfn(set, &e, &ext, &ext, flags);	199	ret = adtfn(set, &e, &ext, &ext, flags);

net/netfilter/ipset/ip_set_hash_netiface.c+1−1

@@ -255,7 +255,7 @@ hash_netiface4_uadt(struct ip_set set, struct nlattr tb[], · 254 unmodified lines
255		255
256	if (retried)	256	if (retried)
257	ip = ntohl(h->next.ip);	257	ip = ntohl(h->next.ip);
258	while (!after(ip, ip_to)) {	258	while (ip <= ip_to) {
259	e.ip = htonl(ip);	259	e.ip = htonl(ip);
260	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr);	260	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr);
261	ret = adtfn(set, &e, &ext, &ext, flags);	261	ret = adtfn(set, &e, &ext, &ext, flags);

net/netfilter/ipset/ip_set_hash_netnet.c+2−2

@@ -250,13 +250,13 @@ hash_netnet4_uadt(struct ip_set set, struct nlattr tb[], · 249 unmodified lines
250	if (retried)	250	if (retried)
251	ip = ntohl(h->next.ip[0]);	251	ip = ntohl(h->next.ip[0]);
252		252
253	while (!after(ip, ip_to)) {	253	while (ip <= ip_to) {
254	e.ip[0] = htonl(ip);	254	e.ip[0] = htonl(ip);
255	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr[0]);	255	last = ip_set_range_to_cidr(ip, ip_to, &e.cidr[0]);
256	ip2 = (retried &&	256	ip2 = (retried &&
257	ip == ntohl(h->next.ip[0])) ? ntohl(h->next.ip[1])	257	ip == ntohl(h->next.ip[0])) ? ntohl(h->next.ip[1])
258	: ip2_from;	258	: ip2_from;
259	while (!after(ip2, ip2_to)) {	259	while (ip2 <= ip2_to) {
260	e.ip[1] = htonl(ip2);	260	e.ip[1] = htonl(ip2);
261	last2 = ip_set_range_to_cidr(ip2, ip2_to, &e.cidr[1]);	261	last2 = ip_set_range_to_cidr(ip2, ip2_to, &e.cidr[1]);
262	ret = adtfn(set, &e, &ext, &ext, flags);	262	ret = adtfn(set, &e, &ext, &ext, flags);

net/netfilter/ipset/ip_set_hash_netport.c+1−1

@@ -241,7 +241,7 @@ hash_netport4_uadt(struct ip_set set, struct nlattr tb[], · 240 unmodified lines
241		241
242	if (retried)	242	if (retried)
243	ip = ntohl(h->next.ip);	243	ip = ntohl(h->next.ip);
244	while (!after(ip, ip_to)) {	244	while (ip <= ip_to) {
245	e.ip = htonl(ip);	245	e.ip = htonl(ip);
246	last = ip_set_range_to_cidr(ip, ip_to, &cidr);	246	last = ip_set_range_to_cidr(ip, ip_to, &cidr);
247	e.cidr = cidr - 1;	247	e.cidr = cidr - 1;

net/netfilter/ipset/ip_set_hash_netportnet.c+2−2

@@ -291,7 +291,7 @@ hash_netportnet4_uadt(struct ip_set set, struct nlattr tb[], · 290 unmodified lines
291	if (retried)	291	if (retried)
292	ip = ntohl(h->next.ip[0]);	292	ip = ntohl(h->next.ip[0]);
293		293
294	while (!after(ip, ip_to)) {	294	while (ip <= ip_to) {
295	e.ip[0] = htonl(ip);	295	e.ip[0] = htonl(ip);
296	ip_last = ip_set_range_to_cidr(ip, ip_to, &e.cidr[0]);	296	ip_last = ip_set_range_to_cidr(ip, ip_to, &e.cidr[0]);
297	p = retried && ip == ntohl(h->next.ip[0]) ? ntohs(h->next.port)	297	p = retried && ip == ntohl(h->next.ip[0]) ? ntohs(h->next.port)
@@ -301,7 +301,7 @@ hash_netportnet4_uadt(struct ip_set set, struct nlattr tb[], · 3 unmodified lines
301	ip2 = (retried && ip == ntohl(h->next.ip[0]) &&	301	ip2 = (retried && ip == ntohl(h->next.ip[0]) &&
302	p == ntohs(h->next.port)) ? ntohl(h->next.ip[1])	302	p == ntohs(h->next.port)) ? ntohl(h->next.ip[1])
303	: ip2_from;	303	: ip2_from;
304	while (!after(ip2, ip2_to)) {	304	while (ip2 <= ip2_to) {
305	e.ip[1] = htonl(ip2);	305	e.ip[1] = htonl(ip2);
306	ip2_last = ip_set_range_to_cidr(ip2, ip2_to,	306	ip2_last = ip_set_range_to_cidr(ip2, ip2_to,
307	&e.cidr[1]);	307	&e.cidr[1]);

net/netfilter/ipvs/ip_vs_xmit.c+6−2

 {
 	struct sk_buff *new_skb = NULL;
 	struct iphdr *old_iph = NULL;
+	__u8 old_dsfield;
 #ifdef CONFIG_IP_VS_IPV6
 	struct ipv6hdr *old_ipv6h = NULL;
 #endif
 			*payload_len =
 				ntohs(old_ipv6h->payload_len) +
 				sizeof(*old_ipv6h);
-		*dsfield = ipv6_get_dsfield(old_ipv6h);
+		old_dsfield = ipv6_get_dsfield(old_ipv6h);
 		*ttl = old_ipv6h->hop_limit;
 		if (df)
 			*df = 0;
 		/* fix old IP header checksum */
 		ip_send_check(old_iph);
-		*dsfield = ipv4_get_dsfield(old_iph);
+		old_dsfield = ipv4_get_dsfield(old_iph);
 		*ttl = old_iph->ttl;
 		if (payload_len)
 			*payload_len = ntohs(old_iph->tot_len);
 	}
+	/* Implement full-functionality option for ECN encapsulation */
+	*dsfield = INET_ECN_encapsulate(old_dsfield, old_dsfield);
 	return skb;
 error:
 	kfree_skb(skb);

net/netfilter/nf_tables_api.c+6−4

 		if (nla_put_string(skb, NFTA_CHAIN_TYPE, basechain->type->name))
 			goto nla_put_failure;
-		if (nft_dump_stats(skb, nft_base_chain(chain)->stats))
+		if (basechain->stats && nft_dump_stats(skb, basechain->stats))
 			goto nla_put_failure;
 	}
 		chain2 = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME],
 						genmask);
-		if (IS_ERR(chain2))
+		if (!IS_ERR(chain2))
-			return PTR_ERR(chain2);
+			return -EEXIST;
 	}
 	if (nla[NFTA_CHAIN_COUNTERS]) {
 	list_for_each_entry(i, &ctx->table->sets, list) {
 		if (!nft_is_active_next(ctx->net, i))
 			continue;
-		if (!strcmp(set->name, i->name))
+		if (!strcmp(set->name, i->name)) {
+			kfree(set->name);
 			return -ENFILE;
+		}
 	}
 	return 0;
 }

net/netfilter/x_tables.c+2−2

 		if (copy_from_user(&compat_tmp, user, sizeof(compat_tmp)) != 0)
 			return ERR_PTR(-EFAULT);
-		strlcpy(info->name, compat_tmp.name, sizeof(info->name));
+		memcpy(info->name, compat_tmp.name, sizeof(info->name) - 1);
 		info->num_counters = compat_tmp.num_counters;
 		user += sizeof(compat_tmp);
 	} else
 		if (copy_from_user(info, user, sizeof(*info)) != 0)
 			return ERR_PTR(-EFAULT);
-		info->name[sizeof(info->name) - 1] = '\0';
 		user += sizeof(*info);
 	}
+	info->name[sizeof(info->name) - 1] = '\0';
 	size = sizeof(struct xt_counters);
 	size *= info->num_counters;

net/netfilter/xt_bpf.c+20−2

  */
 #include <linux/module.h>
+#include <linux/syscalls.h>
 #include <linux/skbuff.h>
 #include <linux/filter.h>
 #include <linux/bpf.h>
 	return 0;
 }
+static int __bpf_mt_check_path(const char *path, struct bpf_prog **ret)
+{
+	mm_segment_t oldfs = get_fs();
+	int retval, fd;
+	set_fs(KERNEL_DS);
+	fd = bpf_obj_get_user(path);
+	set_fs(oldfs);
+	if (fd < 0)
+		return fd;
+	retval = __bpf_mt_check_fd(fd, ret);
+	sys_close(fd);
+	return retval;
+}
 static int bpf_mt_check(const struct xt_mtchk_param *par)
 {
 	struct xt_bpf_info *info = par->matchinfo;
 		return __bpf_mt_check_bytecode(info->bpf_program,
 					       info->bpf_program_num_elem,
 					       &info->filter);
-	else if (info->mode == XT_BPF_MODE_FD_PINNED ||
+	else if (info->mode == XT_BPF_MODE_FD_ELF)
-		 info->mode == XT_BPF_MODE_FD_ELF)
 		return __bpf_mt_check_fd(info->fd, &info->filter);
+	else if (info->mode == XT_BPF_MODE_PATH_PINNED)
+		return __bpf_mt_check_path(info->path, &info->filter);
 	else
 		return -EINVAL;
 }

net/netfilter/xt_socket.c+2−2

@@ -76,7 +76,7 @@ socket_match(const struct sk_buff skb, struct xt_action_param par, · 75 unmodified lines
76	transparent = nf_sk_is_transparent(sk);	76	transparent = nf_sk_is_transparent(sk);
77		77
78	if (info->flags & XT_SOCKET_RESTORESKMARK && !wildcard &&	78	if (info->flags & XT_SOCKET_RESTORESKMARK && !wildcard &&
79	transparent)	79	transparent && sk_fullsock(sk))
80	pskb->mark = sk->sk_mark;	80	pskb->mark = sk->sk_mark;
81		81
82	if (sk != skb->sk)	82	if (sk != skb->sk)
@@ -133,7 +133,7 @@ socket_mt6_v1_v2_v3(const struct sk_buff skb, struct xt_action_param par) · 50 unmodified lines
133	transparent = nf_sk_is_transparent(sk);	133	transparent = nf_sk_is_transparent(sk);
134		134
135	if (info->flags & XT_SOCKET_RESTORESKMARK && !wildcard &&	135	if (info->flags & XT_SOCKET_RESTORESKMARK && !wildcard &&
136	transparent)	136	transparent && sk_fullsock(sk))
137	pskb->mark = sk->sk_mark;	137	pskb->mark = sk->sk_mark;
138		138
139	if (sk != skb->sk)	139	if (sk != skb->sk)

net/netlink/af_netlink.c+7−6

 	cb->min_dump_alloc = control->min_dump_alloc;
 	cb->skb = skb;
+	if (cb->start) {
+		ret = cb->start(cb);
+		if (ret)
+			goto error_unlock;
+	}
 	nlk->cb_running = true;
 	mutex_unlock(nlk->cb_mutex);
-	ret = 0;
+	ret = netlink_dump(sk);
-	if (cb->start)
-		ret = cb->start(cb);
-	if (!ret)
-		ret = netlink_dump(sk);
 	sock_put(sk);

net/sunrpc/xprtsock.c+1−1

@@ -2203,7 +2203,7 @@ static void xs_udp_setup_socket(struct work_struct *work) · 2202 unmodified lines
2203	struct sock_xprt *transport =	2203	struct sock_xprt *transport =
2204	container_of(work, struct sock_xprt, connect_worker.work);	2204	container_of(work, struct sock_xprt, connect_worker.work);
2205	struct rpc_xprt *xprt = &transport->xprt;	2205	struct rpc_xprt *xprt = &transport->xprt;
2206	struct socket *sock = transport->sock;	2206	struct socket *sock;
2207	int status = -EIO;	2207	int status = -EIO;
2208		2208
2209	sock = xs_create_sock(xprt, transport,	2209	sock = xs_create_sock(xprt, transport,

net/tipc/bcast.c+2−2

@@ -233,7 +233,7 @@ static int tipc_bcast_xmit(struct net net, struct sk_buff_head pkts, · 232 unmodified lines
233	struct sk_buff_head xmitq;	233	struct sk_buff_head xmitq;
234	int rc = 0;	234	int rc = 0;
235		235
236	__skb_queue_head_init(&xmitq);	236	skb_queue_head_init(&xmitq);
237	tipc_bcast_lock(net);	237	tipc_bcast_lock(net);
238	if (tipc_link_bc_peers(l))	238	if (tipc_link_bc_peers(l))
239	rc = tipc_link_xmit(l, pkts, &xmitq);	239	rc = tipc_link_xmit(l, pkts, &xmitq);
@@ -263,7 +263,7 @@ static int tipc_rcast_xmit(struct net net, struct sk_buff_head pkts, · 23 unmodified lines
263	u32 dst, selector;	263	u32 dst, selector;
264		264
265	selector = msg_link_selector(buf_msg(skb_peek(pkts)));	265	selector = msg_link_selector(buf_msg(skb_peek(pkts)));
266	__skb_queue_head_init(&_pkts);	266	skb_queue_head_init(&_pkts);
267		267
268	list_for_each_entry_safe(n, tmp, &dests->list, list) {	268	list_for_each_entry_safe(n, tmp, &dests->list, list) {
269	dst = n->value;	269	dst = n->value;

net/tipc/msg.c+8−0

@@ -568,6 +568,14 @@ bool tipc_msg_lookup_dest(struct net net, struct sk_buff skb, int *err) · 567 unmodified lines
568	msg_set_destnode(msg, dnode);	568	msg_set_destnode(msg, dnode);
569	msg_set_destport(msg, dport);	569	msg_set_destport(msg, dport);
570	*err = TIPC_OK;	570	*err = TIPC_OK;
		571
		572	if (!skb_cloned(skb))
		573	return true;
		574
		575	/* Unclone buffer in case it was bundled */
		576	if (pskb_expand_head(skb, BUF_HEADROOM, BUF_TAILROOM, GFP_ATOMIC))
		577	return false;
		578
571	return true;	579	return true;
572	}	580	}
573		581

net/wireless/nl80211.c+12−2

 	[NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
 };
+/* policy for packet pattern attributes */
+static const struct nla_policy
+nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
+	[NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
+	[NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
+	[NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
+};
 static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
 				     struct netlink_callback *cb,
 				     struct cfg80211_registered_device **rdev,
 			u8 *mask_pat;
 			nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
-					 NULL, info->extack);
+					 nl80211_packet_pattern_policy,
+					 info->extack);
 			err = -EINVAL;
 			if (!pat_tb[NL80211_PKTPAT_MASK] ||
 			    !pat_tb[NL80211_PKTPAT_PATTERN])
 			    rem) {
 		u8 *mask_pat;
-		nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat, NULL, NULL);
+		nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
+				 nl80211_packet_pattern_policy, NULL);
 		if (!pat_tb[NL80211_PKTPAT_MASK] ||
 		    !pat_tb[NL80211_PKTPAT_PATTERN])
 			return -EINVAL;

net/xfrm/xfrm_device.c+1−0

@@ -91,6 +91,7 @@ int xfrm_dev_state_add(struct net net, struct xfrm_state x, · 90 unmodified lines
91	}	91	}
92		92
93	if (!dev->xfrmdev_ops \|\| !dev->xfrmdev_ops->xdo_dev_state_add) {	93	if (!dev->xfrmdev_ops \|\| !dev->xfrmdev_ops->xdo_dev_state_add) {
		94	xso->dev = NULL;
94	dev_put(dev);	95	dev_put(dev);
95	return 0;	96	return 0;
96	}	97	}

net/xfrm/xfrm_input.c+4−2

 	nf_reset(skb);
 	if (decaps) {
-		skb->sp->olen = 0;
+		if (skb->sp)
+			skb->sp->olen = 0;
 		skb_dst_drop(skb);
 		gro_cells_receive(&gro_cells, skb);
 		return 0;
 		err = x->inner_mode->afinfo->transport_finish(skb, xfrm_gro || async);
 		if (xfrm_gro) {
-			skb->sp->olen = 0;
+			if (skb->sp)
+				skb->sp->olen = 0;
 			skb_dst_drop(skb);
 			gro_cells_receive(&gro_cells, skb);
 			return err;

net/xfrm/xfrm_state.c+2−2

 			}
 		}
 	}
+out:
+	spin_unlock_bh(&net->xfrm.xfrm_state_lock);
 	if (cnt) {
 		err = 0;
 		xfrm_policy_cache_flush();
 	}
-out:
-	spin_unlock_bh(&net->xfrm.xfrm_state_lock);
 	return err;
 }
 EXPORT_SYMBOL(xfrm_state_flush);

net/xfrm/xfrm_user.c+1−0

@@ -657,6 +657,7 @@ static int xfrm_add_sa(struct sk_buff skb, struct nlmsghdr nlh, · 656 unmodified lines
657		657
658	if (err < 0) {	658	if (err < 0) {
659	x->km.state = XFRM_STATE_DEAD;	659	x->km.state = XFRM_STATE_DEAD;
		660	xfrm_dev_state_delete(x);
660	__xfrm_state_put(x);	661	__xfrm_state_put(x);
661	goto out;	662	goto out;
662	}	663	}

tools/testing/selftests/networking/timestamping/rxtimestamp.c+1−1

@@ -341,7 +341,7 @@ int main(int argc, char **argv) · 340 unmodified lines
341	return 0;	341	return 0;
342	case 'n':	342	case 'n':
343	t = atoi(optarg);	343	t = atoi(optarg);
344	if (t > ARRAY_SIZE(test_cases))	344	if (t >= ARRAY_SIZE(test_cases))
345	error(1, 0, "Invalid test case: %d", t);	345	error(1, 0, "Invalid test case: %d", t);
346	all_tests = false;	346	all_tests = false;
347	test_cases[t].enabled = true;	347	test_cases[t].enabled = true;