lael-labs/linux

.mailmap+1−0

@@ -59,6 +59,7 @@ James Bottomley <jejb@mulgrave.(none)> · 58 unmodified lines
59	James Bottomley <jejb@titanic.il.steeleye.com>	59	James Bottomley <jejb@titanic.il.steeleye.com>
60	James E Wilson <wilson@specifix.com>	60	James E Wilson <wilson@specifix.com>
61	James Ketrenos <jketreno@io.(none)>	61	James Ketrenos <jketreno@io.(none)>
		62	<javier@osg.samsung.com> <javier.martinez@collabora.co.uk>
62	Jean Tourrilhes <jt@hpl.hp.com>	63	Jean Tourrilhes <jt@hpl.hp.com>
63	Jeff Garzik <jgarzik@pretzel.yyz.us>	64	Jeff Garzik <jgarzik@pretzel.yyz.us>
64	Jens Axboe <axboe@suse.de>	65	Jens Axboe <axboe@suse.de>

Documentation/arm/OMAP/README+7−0

@@ -0,0 +1,7 @@
	1	This file contains documentation for running mainline
	2	kernel on omaps.
	3
	4	KERNEL NEW DEPENDENCIES
	5	v4.3+ Update is needed for custom .config files to make sure
	6	CONFIG_REGULATOR_PBIAS is enabled for MMC1 to work
	7	properly.

MAINTAINERS+28−3

 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
-ARM/Allwinner A1X SoC support
+ARM/Allwinner sunXi SoC support
 M:	Maxime Ripard <maxime.ripard@free-electrons.com>
+M:	Chen-Yu Tsai <wens@csie.org>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
-N:	sun[x4567]i
+N:	sun[x456789]i
 ARM/Allwinner SoC Clock Support
 M:	Emilio López <emilio@elopez.com.ar>
 F:	include/drm/i915*
 F:	include/uapi/drm/i915*
+DRM DRIVERS FOR ATMEL HLCDC
+M:	Boris Brezillon <boris.brezillon@free-electrons.com>
+L:	dri-devel@lists.freedesktop.org
+S:	Supported
+F:	drivers/gpu/drm/atmel-hlcdc/
+F:	Documentation/devicetree/bindings/drm/atmel/
 DRM DRIVERS FOR EXYNOS
 M:	Inki Dae <inki.dae@samsung.com>
 M:	Joonyoung Shim <jy0922.shim@samsung.com>
 F:	drivers/gpu/drm/imx/
 F:	Documentation/devicetree/bindings/drm/imx/
+DRM DRIVERS FOR GMA500 (Poulsbo, Moorestown and derivative chipsets)
+M:	Patrik Jakobsson <patrik.r.jakobsson@gmail.com>
+L:	dri-devel@lists.freedesktop.org
+T:	git git://github.com/patjak/drm-gma500
+S:	Maintained
+F:	drivers/gpu/drm/gma500
+F:	include/drm/gma500*
 DRM DRIVERS FOR NVIDIA TEGRA
 M:	Thierry Reding <thierry.reding@gmail.com>
 M:	Terje Bergström <tbergstrom@nvidia.com>
 MELLANOX ETHERNET DRIVER (mlx4_en)
 M:	Amir Vadai <amirv@mellanox.com>
-M:	Ido Shamay <idos@mellanox.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 W:	http://www.mellanox.com
 F: Documentation/devicetree/bindings/net/snps,dwc-qos-ethernet.txt
 F: drivers/net/ethernet/synopsys/dwc_eth_qos.c
+SYNOPSYS DESIGNWARE I2C DRIVER
+M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+M:	Jarkko Nikula <jarkko.nikula@linux.intel.com>
+M:	Mika Westerberg <mika.westerberg@linux.intel.com>
+L:	linux-i2c@vger.kernel.org
+S:	Maintained
+F:	drivers/i2c/busses/i2c-designware-*
+F:	include/linux/platform_data/i2c-designware.h
 SYNOPSYS DESIGNWARE MMC/SD/SDIO DRIVER
 M:	Seungwon Jeon <tgih.jun@samsung.com>
 M:	Jaehoon Chung <jh80.chung@samsung.com>
 ZSMALLOC COMPRESSED SLAB MEMORY ALLOCATOR
 M:	Minchan Kim <minchan@kernel.org>
 M:	Nitin Gupta <ngupta@vflare.org>
+R:	Sergey Senozhatsky <sergey.senozhatsky.work@gmail.com>
 L:	linux-mm@kvack.org
 S:	Maintained
 F:	mm/zsmalloc.c

Makefile+1−1

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 3	2	PATCHLEVEL = 3
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc5	4	EXTRAVERSION = -rc7
5	NAME = Blurry Fish Butt	5	NAME = Blurry Fish Butt
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION

arch/arm/boot/dts/am57xx-beagle-x15.dts+2−1

 				/* SMPS9 unused */
 				ldo1_reg: ldo1 {
-					/* VDD_SD  */
+					/* VDD_SD / VDDSHV8  */
 					regulator-name = "ldo1";
 					regulator-min-microvolt = <1800000>;
 					regulator-max-microvolt = <3300000>;
 					regulator-boot-on;
+					regulator-always-on;
 				};
 				ldo2_reg: ldo2 {

arch/arm/boot/dts/armada-385-db-ap.dts+1−1

@@ -46,7 +46,7 @@ · 45 unmodified lines
46		46
47	/ {	47	/ {
48	model = "Marvell Armada 385 Access Point Development Board";	48	model = "Marvell Armada 385 Access Point Development Board";
49	compatible = "marvell,a385-db-ap", "marvell,armada385", "marvell,armada38x";	49	compatible = "marvell,a385-db-ap", "marvell,armada385", "marvell,armada380";
50		50
51	chosen {	51	chosen {
52	stdout-path = "serial1:115200n8";	52	stdout-path = "serial1:115200n8";

arch/arm/boot/dts/berlin2q.dtsi+3−3

@@ -152,7 +152,7 @@ · 151 unmodified lines
152	};	152	};
153		153
154	usb_phy2: phy@a2f400 {	154	usb_phy2: phy@a2f400 {
155	compatible = "marvell,berlin2-usb-phy";	155	compatible = "marvell,berlin2cd-usb-phy";
156	reg = <0xa2f400 0x128>;	156	reg = <0xa2f400 0x128>;
157	#phy-cells = <0>;	157	#phy-cells = <0>;
158	resets = <&chip_rst 0x104 14>;	158	resets = <&chip_rst 0x104 14>;
@@ -170,7 +170,7 @@ · 11 unmodified lines
170	};	170	};
171		171
172	usb_phy0: phy@b74000 {	172	usb_phy0: phy@b74000 {
173	compatible = "marvell,berlin2-usb-phy";	173	compatible = "marvell,berlin2cd-usb-phy";
174	reg = <0xb74000 0x128>;	174	reg = <0xb74000 0x128>;
175	#phy-cells = <0>;	175	#phy-cells = <0>;
176	resets = <&chip_rst 0x104 12>;	176	resets = <&chip_rst 0x104 12>;
@@ -178,7 +178,7 @@ · 1 unmodified line
178	};	178	};
179		179
180	usb_phy1: phy@b78000 {	180	usb_phy1: phy@b78000 {
181	compatible = "marvell,berlin2-usb-phy";	181	compatible = "marvell,berlin2cd-usb-phy";
182	reg = <0xb78000 0x128>;	182	reg = <0xb78000 0x128>;
183	#phy-cells = <0>;	183	#phy-cells = <0>;
184	resets = <&chip_rst 0x104 13>;	184	resets = <&chip_rst 0x104 13>;

arch/arm/boot/dts/exynos5420-peach-pit.dts+5−0

 	};
 };
+&pmu_system_controller {
+	assigned-clocks = <&pmu_system_controller 0>;
+	assigned-clock-parents = <&clock CLK_FIN_PLL>;
+};
 &rtc {
 	status = "okay";
 	clocks = <&clock CLK_RTC>, <&max77802 MAX77802_CLK_32K_AP>;

arch/arm/boot/dts/exynos5800-peach-pi.dts+5−0

 	};
 };
+&pmu_system_controller {
+	assigned-clocks = <&pmu_system_controller 0>;
+	assigned-clock-parents = <&clock CLK_FIN_PLL>;
+};
 &rtc {
 	status = "okay";
 	clocks = <&clock CLK_RTC>, <&max77802 MAX77802_CLK_32K_AP>;

arch/arm/boot/dts/imx7d.dtsi+2−2

@@ -588,10 +588,10 @@ · 587 unmodified lines
588	status = "disabled";	588	status = "disabled";
589	};	589	};
590		590
591	uart2: serial@30870000 {	591	uart2: serial@30890000 {
592	compatible = "fsl,imx7d-uart",	592	compatible = "fsl,imx7d-uart",
593	"fsl,imx6q-uart";	593	"fsl,imx6q-uart";
594	reg = <0x30870000 0x10000>;	594	reg = <0x30890000 0x10000>;
595	interrupts = <GIC_SPI 27 IRQ_TYPE_LEVEL_HIGH>;	595	interrupts = <GIC_SPI 27 IRQ_TYPE_LEVEL_HIGH>;
596	clocks = <&clks IMX7D_UART2_ROOT_CLK>,	596	clocks = <&clks IMX7D_UART2_ROOT_CLK>,
597	<&clks IMX7D_UART2_ROOT_CLK>;	597	<&clks IMX7D_UART2_ROOT_CLK>;

arch/arm/boot/dts/logicpd-torpedo-37xx-devkit.dts+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12		12
13	/ {	13	/ {
14	model = "LogicPD Zoom DM3730 Torpedo Development Kit";	14	model = "LogicPD Zoom DM3730 Torpedo Development Kit";
15	compatible = "logicpd,dm3730-torpedo-devkit", "ti,omap36xx";	15	compatible = "logicpd,dm3730-torpedo-devkit", "ti,omap3630", "ti,omap3";
16		16
17	gpio_keys {	17	gpio_keys {
18	compatible = "gpio-keys";	18	compatible = "gpio-keys";

arch/arm/boot/dts/meson.dtsi+12−11

 	timer@c1109940 {
 		compatible = "amlogic,meson6-timer";
-		reg = <0xc1109940 0x14>;
+		reg = <0xc1109940 0x18>;
 		interrupts = <0 10 1>;
 	};
 		wdt: watchdog@c1109900 {
 			compatible = "amlogic,meson6-wdt";
 			reg = <0xc1109900 0x8>;
+			interrupts = <0 0 1>;
 		};
 		uart_AO: serial@c81004c0 {
 			compatible = "amlogic,meson-uart";
-			reg = <0xc81004c0 0x14>;
+			reg = <0xc81004c0 0x18>;
 			interrupts = <0 90 1>;
 			clocks = <&clk81>;
 			status = "disabled";
 		};
-		uart_A: serial@c81084c0 {
+		uart_A: serial@c11084c0 {
 			compatible = "amlogic,meson-uart";
-			reg = <0xc81084c0 0x14>;
+			reg = <0xc11084c0 0x18>;
-			interrupts = <0 90 1>;
+			interrupts = <0 26 1>;
 			clocks = <&clk81>;
 			status = "disabled";
 		};
-		uart_B: serial@c81084dc {
+		uart_B: serial@c11084dc {
 			compatible = "amlogic,meson-uart";
-			reg = <0xc81084dc 0x14>;
+			reg = <0xc11084dc 0x18>;
-			interrupts = <0 90 1>;
+			interrupts = <0 75 1>;
 			clocks = <&clk81>;
 			status = "disabled";
 		};
-		uart_C: serial@c8108700 {
+		uart_C: serial@c1108700 {
 			compatible = "amlogic,meson-uart";
-			reg = <0xc8108700 0x14>;
+			reg = <0xc1108700 0x18>;
-			interrupts = <0 90 1>;
+			interrupts = <0 93 1>;
 			clocks = <&clk81>;
 			status = "disabled";
 		};

arch/arm/boot/dts/omap3-evm-37xx.dts+1−1

@@ -13,7 +13,7 @@ · 12 unmodified lines
13		13
14	/ {	14	/ {
15	model = "TI OMAP37XX EVM (TMDSEVM3730)";	15	model = "TI OMAP37XX EVM (TMDSEVM3730)";
16	compatible = "ti,omap3-evm-37xx", "ti,omap36xx";	16	compatible = "ti,omap3-evm-37xx", "ti,omap3630", "ti,omap3";
17		17
18	memory {	18	memory {
19	device_type = "memory";	19	device_type = "memory";

arch/arm/boot/dts/ste-hrefv60plus.dtsi+1−1

@@ -56,7 +56,7 @@ · 55 unmodified lines
56	/* VMMCI level-shifter enable */	56	/* VMMCI level-shifter enable */
57	default_hrefv60_cfg2 {	57	default_hrefv60_cfg2 {
58	pins = "GPIO169_D22";	58	pins = "GPIO169_D22";
59	ste,config = <&gpio_out_lo>;	59	ste,config = <&gpio_out_hi>;
60	};	60	};
61	/* VMMCI level-shifter voltage select */	61	/* VMMCI level-shifter voltage select */
62	default_hrefv60_cfg3 {	62	default_hrefv60_cfg3 {

arch/arm/boot/dts/tegra114.dtsi+2−0

 		gpio-controller;
 		#interrupt-cells = <2>;
 		interrupt-controller;
+		/*
 		gpio-ranges = <&pinmux 0 0 246>;
+		*/
 	};
 	apbmisc@70000800 {

arch/arm/boot/dts/tegra124.dtsi+2−0

 		gpio-controller;
 		#interrupt-cells = <2>;
 		interrupt-controller;
+		/*
 		gpio-ranges = <&pinmux 0 0 251>;
+		*/
 	};
 	apbdma: dma@0,60020000 {

arch/arm/boot/dts/tegra20.dtsi+2−0

 		gpio-controller;
 		#interrupt-cells = <2>;
 		interrupt-controller;
+		/*
 		gpio-ranges = <&pinmux 0 0 224>;
+		*/
 	};
 	apbmisc@70000800 {

arch/arm/boot/dts/tegra30.dtsi+2−0

 		gpio-controller;
 		#interrupt-cells = <2>;
 		interrupt-controller;
+		/*
 		gpio-ranges = <&pinmux 0 0 248>;
+		*/
 	};
 	apbmisc@70000800 {

arch/arm/boot/dts/uniphier-ph1-ld6b-ref.dts+1−1

@@ -85,7 +85,7 @@ · 84 unmodified lines
85	};	85	};
86		86
87	&ethsc {	87	&ethsc {
88	interrupts = <0 50 4>;	88	interrupts = <0 52 4>;
89	};	89	};
90		90
91	&serial0 {	91	&serial0 {

arch/arm/kvm/Kconfig+1−0

@@ -21,6 +21,7 @@ config KVM · 20 unmodified lines
21	depends on MMU && OF	21	depends on MMU && OF
22	select PREEMPT_NOTIFIERS	22	select PREEMPT_NOTIFIERS
23	select ANON_INODES	23	select ANON_INODES
		24	select ARM_GIC
24	select HAVE_KVM_CPU_RELAX_INTERCEPT	25	select HAVE_KVM_CPU_RELAX_INTERCEPT
25	select HAVE_KVM_ARCH_TLB_FLUSH_ALL	26	select HAVE_KVM_ARCH_TLB_FLUSH_ALL
26	select KVM_MMIO	27	select KVM_MMIO

arch/arm/kvm/arm.c+1−1

@@ -1080,7 +1080,7 @@ static int init_hyp_mode(void) · 1079 unmodified lines
1080	*/	1080	*/
1081	err = kvm_timer_hyp_init();	1081	err = kvm_timer_hyp_init();
1082	if (err)	1082	if (err)
1083	goto out_free_mappings;	1083	goto out_free_context;
1084		1084
1085	#ifndef CONFIG_HOTPLUG_CPU	1085	#ifndef CONFIG_HOTPLUG_CPU
1086	free_boot_hyp_pgd();	1086	free_boot_hyp_pgd();

arch/arm/mach-exynos/pm_domains.c+3−5

 		args.args_count = 0;
 		child_domain = of_genpd_get_from_provider(&args);
 		if (IS_ERR(child_domain))
-			goto next_pd;
+			continue;
 		if (of_parse_phandle_with_args(np, "power-domains",
 					 "#power-domain-cells", 0, &args) != 0)
-			goto next_pd;
+			continue;
 		parent_domain = of_genpd_get_from_provider(&args);
 		if (IS_ERR(parent_domain))
-			goto next_pd;
+			continue;
 		if (pm_genpd_add_subdomain(parent_domain, child_domain))
 			pr_warn("%s failed to add subdomain: %s\n",
 		else
 			pr_info("%s has as child subdomain: %s.\n",
 				parent_domain->name, child_domain->name);
-next_pd:
-		of_node_put(np);
 	}
 	return 0;

arch/arm/mach-omap2/Kconfig+2−0

 	select OMAP_INTERCONNECT
 	select OMAP_INTERCONNECT_BARRIER
 	select PM_OPP if PM
+	select ZONE_DMA if ARM_LPAE
 config SOC_AM33XX
 	bool "TI AM33XX"
 	select OMAP_INTERCONNECT
 	select OMAP_INTERCONNECT_BARRIER
 	select PM_OPP if PM
+	select ZONE_DMA if ARM_LPAE
 config ARCH_OMAP2PLUS
 	bool

arch/arm/mach-omap2/board-generic.c+10−0

 MACHINE_END
 static const char *const omap36xx_boards_compat[] __initconst = {
+	"ti,omap3630",
 	"ti,omap36xx",
 	NULL,
 };
 };
 DT_MACHINE_START(OMAP5_DT, "Generic OMAP5 (Flattened Device Tree)")
+#if defined(CONFIG_ZONE_DMA) && defined(CONFIG_ARM_LPAE)
+	.dma_zone_size	= SZ_2G,
+#endif
 	.reserve	= omap_reserve,
 	.smp		= smp_ops(omap4_smp_ops),
 	.map_io		= omap5_map_io,
 };
 DT_MACHINE_START(DRA74X_DT, "Generic DRA74X (Flattened Device Tree)")
+#if defined(CONFIG_ZONE_DMA) && defined(CONFIG_ARM_LPAE)
+	.dma_zone_size	= SZ_2G,
+#endif
 	.reserve	= omap_reserve,
 	.smp		= smp_ops(omap4_smp_ops),
 	.map_io		= dra7xx_map_io,
 };
 DT_MACHINE_START(DRA72X_DT, "Generic DRA72X (Flattened Device Tree)")
+#if defined(CONFIG_ZONE_DMA) && defined(CONFIG_ARM_LPAE)
+	.dma_zone_size	= SZ_2G,
+#endif
 	.reserve	= omap_reserve,
 	.map_io		= dra7xx_map_io,
 	.init_early	= dra7xx_init_early,

arch/arm/mach-omap2/pdata-quirks.c+8−1

 void __init pdata_quirks_init(const struct of_device_id *omap_dt_match_table)
 {
-	omap_sdrc_init(NULL, NULL);
+	/*
+	 * We still need this for omap2420 and omap3 PM to work, others are
+	 * using drivers/misc/sram.c already.
+	 */
+	if (of_machine_is_compatible("ti,omap2420") ||
+	    of_machine_is_compatible("ti,omap3"))
+		omap_sdrc_init(NULL, NULL);
 	pdata_quirks_check(auxdata_quirks);
 	of_platform_populate(NULL, omap_dt_match_table,
 			     omap_auxdata_lookup, NULL);

arch/arm/mach-pxa/pxa3xx.c+5−4

 #define PECR_IS(n)	((1 << ((n) * 2)) << 29)
 extern void __init pxa_dt_irq_init(int (*fn)(struct irq_data *, unsigned int));
-#ifdef CONFIG_PM
-#define ISRAM_START	0x5c000000
-#define ISRAM_SIZE	SZ_256K
 /*
  * NAND NFC: DFI bus arbitration subset
 #define NDCR_ND_ARB_EN		(1 << 12)
 #define NDCR_ND_ARB_CNTL	(1 << 19)
+#ifdef CONFIG_PM
+#define ISRAM_START	0x5c000000
+#define ISRAM_SIZE	SZ_256K
 static void __iomem *sram;
 static unsigned long wakeup_src;

arch/arm/net/bpf_jit_32.c+1−0

@@ -614,6 +614,7 @@ load_common: · 613 unmodified lines
614	case BPF_LD \| BPF_B \| BPF_IND:	614	case BPF_LD \| BPF_B \| BPF_IND:
615	load_order = 0;	615	load_order = 0;
616	load_ind:	616	load_ind:
		617	update_on_xread(ctx);
617	OP_IMM3(ARM_ADD, r_off, r_X, k, ctx);	618	OP_IMM3(ARM_ADD, r_off, r_X, k, ctx);
618	goto load_common;	619	goto load_common;
619	case BPF_LDX \| BPF_IMM:	620	case BPF_LDX \| BPF_IMM:

arch/arm/plat-orion/common.c+1−1

@@ -495,7 +495,7 @@ void __init orion_ge00_switch_init(struct dsa_platform_data *d, int irq) · 494 unmodified lines
495		495
496	d->netdev = &orion_ge00.dev;	496	d->netdev = &orion_ge00.dev;
497	for (i = 0; i < d->nr_chips; i++)	497	for (i = 0; i < d->nr_chips; i++)
498	d->chip[i].host_dev = &orion_ge00_shared.dev;	498	d->chip[i].host_dev = &orion_ge_mvmdio.dev;
499	orion_switch_device.dev.platform_data = d;	499	orion_switch_device.dev.platform_data = d;
500		500
501	platform_device_register(&orion_switch_device);	501	platform_device_register(&orion_switch_device);

arch/arm64/Makefile+1−1

@@ -42,7 +42,7 @@ endif · 41 unmodified lines
42	CHECKFLAGS += -D__aarch64__	42	CHECKFLAGS += -D__aarch64__
43		43
44	ifeq ($(CONFIG_ARM64_ERRATUM_843419), y)	44	ifeq ($(CONFIG_ARM64_ERRATUM_843419), y)
45	CFLAGS_MODULE += -mcmodel=large	45	KBUILD_CFLAGS_MODULE += -mcmodel=large
46	endif	46	endif
47		47
48	# Default value	48	# Default value

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

@@ -44,7 +44,7 @@ · 43 unmodified lines
44	#define __ARM_NR_compat_cacheflush (__ARM_NR_COMPAT_BASE+2)	44	#define __ARM_NR_compat_cacheflush (__ARM_NR_COMPAT_BASE+2)
45	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE+5)	45	#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE+5)
46		46
47	#define __NR_compat_syscalls 388	47	#define __NR_compat_syscalls 390
48	#endif	48	#endif
49		49
50	#define __ARCH_WANT_SYS_CLONE	50	#define __ARCH_WANT_SYS_CLONE

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

@@ -797,3 +797,12 @@ __SYSCALL(__NR_memfd_create, sys_memfd_create) · 796 unmodified lines
797	__SYSCALL(__NR_bpf, sys_bpf)	797	__SYSCALL(__NR_bpf, sys_bpf)
798	#define __NR_execveat 387	798	#define __NR_execveat 387
799	__SYSCALL(__NR_execveat, compat_sys_execveat)	799	__SYSCALL(__NR_execveat, compat_sys_execveat)
		800	#define __NR_userfaultfd 388
		801	__SYSCALL(__NR_userfaultfd, sys_userfaultfd)
		802	#define __NR_membarrier 389
		803	__SYSCALL(__NR_membarrier, sys_membarrier)
		804
		805	/*
		806	* Please add new compat syscalls above this comment and update
		807	* __NR_compat_syscalls in asm/unistd.h.
		808	*/

arch/arm64/include/uapi/asm/signal.h+3−0

@@ -19,6 +19,9 @@ · 18 unmodified lines
19	/* Required for AArch32 compatibility. */	19	/* Required for AArch32 compatibility. */
20	#define SA_RESTORER 0x04000000	20	#define SA_RESTORER 0x04000000
21		21
		22	#define MINSIGSTKSZ 5120
		23	#define SIGSTKSZ 16384
		24
22	#include <asm-generic/signal.h>	25	#include <asm-generic/signal.h>
23		26
24	#endif	27	#endif

arch/powerpc/configs/ppc64_defconfig+1−1

@@ -111,7 +111,7 @@ CONFIG_SCSI_QLA_FC=m · 110 unmodified lines
111	CONFIG_SCSI_QLA_ISCSI=m	111	CONFIG_SCSI_QLA_ISCSI=m
112	CONFIG_SCSI_LPFC=m	112	CONFIG_SCSI_LPFC=m
113	CONFIG_SCSI_VIRTIO=m	113	CONFIG_SCSI_VIRTIO=m
114	CONFIG_SCSI_DH=m	114	CONFIG_SCSI_DH=y
115	CONFIG_SCSI_DH_RDAC=m	115	CONFIG_SCSI_DH_RDAC=m
116	CONFIG_SCSI_DH_ALUA=m	116	CONFIG_SCSI_DH_ALUA=m
117	CONFIG_ATA=y	117	CONFIG_ATA=y

arch/powerpc/configs/pseries_defconfig+1−1

@@ -114,7 +114,7 @@ CONFIG_SCSI_QLA_FC=m · 113 unmodified lines
114	CONFIG_SCSI_QLA_ISCSI=m	114	CONFIG_SCSI_QLA_ISCSI=m
115	CONFIG_SCSI_LPFC=m	115	CONFIG_SCSI_LPFC=m
116	CONFIG_SCSI_VIRTIO=m	116	CONFIG_SCSI_VIRTIO=m
117	CONFIG_SCSI_DH=m	117	CONFIG_SCSI_DH=y
118	CONFIG_SCSI_DH_RDAC=m	118	CONFIG_SCSI_DH_RDAC=m
119	CONFIG_SCSI_DH_ALUA=m	119	CONFIG_SCSI_DH_ALUA=m
120	CONFIG_ATA=y	120	CONFIG_ATA=y

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

 #ifdef __KERNEL__
-#include <asm/reg.h>
 /* bytes per L1 cache line */
 #if defined(CONFIG_8xx) || defined(CONFIG_403GCX)
 };
 extern struct ppc64_caches ppc64_caches;
-static inline void logmpp(u64 x)
-{
-	asm volatile(PPC_LOGMPP(R1) : : "r" (x));
-}
 #endif /* __powerpc64__ && ! __ASSEMBLY__ */
 #if defined(__ASSEMBLY__)

arch/powerpc/include/asm/kvm_host.h+0−2

@@ -297,8 +297,6 @@ struct kvmppc_vcore { · 296 unmodified lines
297	u32 arch_compat;	297	u32 arch_compat;
298	ulong pcr;	298	ulong pcr;
299	ulong dpdes; /* doorbell state (POWER8) */	299	ulong dpdes; /* doorbell state (POWER8) */
300	void mpp_buffer; / Micro Partition Prefetch buffer */
301	bool mpp_buffer_is_valid;
302	ulong conferring_threads;	300	ulong conferring_threads;
303	};	301	};
304		302

arch/powerpc/include/asm/machdep.h+7−2

 					       unsigned long addr,
 					       unsigned char *hpte_slot_array,
 					       int psize, int ssize, int local);
-	/* special for kexec, to be called in real mode, linear mapping is
+	/*
-	 * destroyed as well */
+	 * Special for kexec.
+	 * To be called in real mode with interrupts disabled. No locks are
+	 * taken as such, concurrent access on pre POWER5 hardware could result
+	 * in a deadlock.
+	 * The linear mapping is destroyed as well.
+	 */
 	void		(*hpte_clear_all)(void);
 	void __iomem *	(*ioremap)(phys_addr_t addr, unsigned long size,

arch/powerpc/include/asm/ppc-opcode.h+0−17

 #define PPC_INST_ISEL			0x7c00001e
 #define PPC_INST_ISEL_MASK		0xfc00003e
 #define PPC_INST_LDARX			0x7c0000a8
-#define PPC_INST_LOGMPP			0x7c0007e4
 #define PPC_INST_LSWI			0x7c0004aa
 #define PPC_INST_LSWX			0x7c00042a
 #define PPC_INST_LWARX			0x7c000028
 #define __PPC_EH(eh)	0
 #endif
-/* POWER8 Micro Partition Prefetch (MPP) parameters */
-/* Address mask is common for LOGMPP instruction and MPPR SPR */
-#define PPC_MPPE_ADDRESS_MASK 0xffffffffc000ULL
-/* Bits 60 and 61 of MPP SPR should be set to one of the following */
-/* Aborting the fetch is indeed setting 00 in the table size bits */
-#define PPC_MPPR_FETCH_ABORT (0x0ULL << 60)
-#define PPC_MPPR_FETCH_WHOLE_TABLE (0x2ULL << 60)
-/* Bits 54 and 55 of register for LOGMPP instruction should be set to: */
-#define PPC_LOGMPP_LOG_L2 (0x02ULL << 54)
-#define PPC_LOGMPP_LOG_L2L3 (0x01ULL << 54)
-#define PPC_LOGMPP_LOG_ABORT (0x03ULL << 54)
 /* Deal with instructions that older assemblers aren't aware of */
 #define	PPC_DCBAL(a, b)		stringify_in_c(.long PPC_INST_DCBAL | \
 					__PPC_RA(a) | __PPC_RB(b))
 #define PPC_LDARX(t, a, b, eh)	stringify_in_c(.long PPC_INST_LDARX | \
 					___PPC_RT(t) | ___PPC_RA(a) | \
 					___PPC_RB(b) | __PPC_EH(eh))
-#define PPC_LOGMPP(b)		stringify_in_c(.long PPC_INST_LOGMPP | \
-					__PPC_RB(b))
 #define PPC_LWARX(t, a, b, eh)	stringify_in_c(.long PPC_INST_LWARX | \
 					___PPC_RT(t) | ___PPC_RA(a) | \
 					___PPC_RB(b) | __PPC_EH(eh))

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

@@ -226,7 +226,6 @@ · 225 unmodified lines
226	#define CTRL_TE 0x00c00000 /* thread enable */	226	#define CTRL_TE 0x00c00000 /* thread enable */
227	#define CTRL_RUNLATCH 0x1	227	#define CTRL_RUNLATCH 0x1
228	#define SPRN_DAWR 0xB4	228	#define SPRN_DAWR 0xB4
229	#define SPRN_MPPR 0xB8 /* Micro Partition Prefetch Register */
230	#define SPRN_RPR 0xBA /* Relative Priority Register */	229	#define SPRN_RPR 0xBA /* Relative Priority Register */
231	#define SPRN_CIABR 0xBB	230	#define SPRN_CIABR 0xBB
232	#define CIABR_PRIV 0x3	231	#define CIABR_PRIV 0x3

arch/powerpc/kernel/rtas.c+3−0

@@ -1043,6 +1043,9 @@ asmlinkage int ppc_rtas(struct rtas_args __user *uargs) · 1042 unmodified lines
1043	if (!capable(CAP_SYS_ADMIN))	1043	if (!capable(CAP_SYS_ADMIN))
1044	return -EPERM;	1044	return -EPERM;
1045		1045
		1046	if (!rtas.entry)
		1047	return -EINVAL;
		1048
1046	if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)	1049	if (copy_from_user(&args, uargs, 3 * sizeof(u32)) != 0)
1047	return -EFAULT;	1050	return -EFAULT;
1048		1051

arch/powerpc/kvm/book3s_hv.c+1−54

@@ -36,7 +36,6 @@ · 35 unmodified lines
36		36
37	#include <asm/reg.h>	37	#include <asm/reg.h>
38	#include <asm/cputable.h>	38	#include <asm/cputable.h>
39	#include <asm/cache.h>
40	#include <asm/cacheflush.h>	39	#include <asm/cacheflush.h>
41	#include <asm/tlbflush.h>	40	#include <asm/tlbflush.h>
42	#include <asm/uaccess.h>	41	#include <asm/uaccess.h>
@@ -75,12 +74,6 @@ · 32 unmodified lines
75		74
76	static DECLARE_BITMAP(default_enabled_hcalls, MAX_HCALL_OPCODE/4 + 1);	75	static DECLARE_BITMAP(default_enabled_hcalls, MAX_HCALL_OPCODE/4 + 1);
77		76
78	#if defined(CONFIG_PPC_64K_PAGES)
79	#define MPP_BUFFER_ORDER 0
80	#elif defined(CONFIG_PPC_4K_PAGES)
81	#define MPP_BUFFER_ORDER 3
82	#endif
83
84	static int dynamic_mt_modes = 6;	77	static int dynamic_mt_modes = 6;
85	module_param(dynamic_mt_modes, int, S_IRUGO \| S_IWUSR);	78	module_param(dynamic_mt_modes, int, S_IRUGO \| S_IWUSR);
86	MODULE_PARM_DESC(dynamic_mt_modes, "Set of allowed dynamic micro-threading modes: 0 (= none), 2, 4, or 6 (= 2 or 4)");	79	MODULE_PARM_DESC(dynamic_mt_modes, "Set of allowed dynamic micro-threading modes: 0 (= none), 2, 4, or 6 (= 2 or 4)");
@@ -1455,13 +1448,6 @@ static struct kvmppc_vcore kvmppc_vcore_create(struct kvm kvm, int core) · 1368 unmodified lines
1455	vcore->kvm = kvm;	1448	vcore->kvm = kvm;
1456	INIT_LIST_HEAD(&vcore->preempt_list);	1449	INIT_LIST_HEAD(&vcore->preempt_list);
1457		1450
1458	vcore->mpp_buffer_is_valid = false;
1459
1460	if (cpu_has_feature(CPU_FTR_ARCH_207S))
1461	vcore->mpp_buffer = (void *)__get_free_pages(
1462	GFP_KERNEL\|__GFP_ZERO,
1463	MPP_BUFFER_ORDER);
1464
1465	return vcore;	1451	return vcore;
1466	}	1452	}
1467		1453
@@ -1894,33 +1880,6 @@ static int on_primary_thread(void) · 426 unmodified lines
1894	return 1;	1880	return 1;
1895	}	1881	}
1896		1882
1897	static void kvmppc_start_saving_l2_cache(struct kvmppc_vcore *vc)
1898	{
1899	phys_addr_t phy_addr, mpp_addr;
1900
1901	phy_addr = (phys_addr_t)virt_to_phys(vc->mpp_buffer);
1902	mpp_addr = phy_addr & PPC_MPPE_ADDRESS_MASK;
1903
1904	mtspr(SPRN_MPPR, mpp_addr \| PPC_MPPR_FETCH_ABORT);
1905	logmpp(mpp_addr \| PPC_LOGMPP_LOG_L2);
1906
1907	vc->mpp_buffer_is_valid = true;
1908	}
1909
1910	static void kvmppc_start_restoring_l2_cache(const struct kvmppc_vcore *vc)
1911	{
1912	phys_addr_t phy_addr, mpp_addr;
1913
1914	phy_addr = virt_to_phys(vc->mpp_buffer);
1915	mpp_addr = phy_addr & PPC_MPPE_ADDRESS_MASK;
1916
1917	/* We must abort any in-progress save operations to ensure
1918	* the table is valid so that prefetch engine knows when to
1919	* stop prefetching. */
1920	logmpp(mpp_addr \| PPC_LOGMPP_LOG_ABORT);
1921	mtspr(SPRN_MPPR, mpp_addr \| PPC_MPPR_FETCH_WHOLE_TABLE);
1922	}
1923
1924	/*	1883	/*
1925	* A list of virtual cores for each physical CPU.	1884	* A list of virtual cores for each physical CPU.
1926	* These are vcores that could run but their runner VCPU tasks are	1885	* These are vcores that could run but their runner VCPU tasks are
@@ -2471,14 +2430,8 @@ static noinline void kvmppc_run_core(struct kvmppc_vcore *vc) · 544 unmodified lines
2471		2430
2472	srcu_idx = srcu_read_lock(&vc->kvm->srcu);	2431	srcu_idx = srcu_read_lock(&vc->kvm->srcu);
2473		2432
2474	if (vc->mpp_buffer_is_valid)
2475	kvmppc_start_restoring_l2_cache(vc);
2476
2477	__kvmppc_vcore_entry();	2433	__kvmppc_vcore_entry();
2478		2434
2479	if (vc->mpp_buffer)
2480	kvmppc_start_saving_l2_cache(vc);
2481
2482	srcu_read_unlock(&vc->kvm->srcu, srcu_idx);	2435	srcu_read_unlock(&vc->kvm->srcu, srcu_idx);
2483		2436
2484	spin_lock(&vc->lock);	2437	spin_lock(&vc->lock);
@@ -3073,14 +3026,8 @@ static void kvmppc_free_vcores(struct kvm *kvm) · 588 unmodified lines
3073	{	3026	{
3074	long int i;	3027	long int i;
3075		3028
3076	for (i = 0; i < KVM_MAX_VCORES; ++i) {	3029	for (i = 0; i < KVM_MAX_VCORES; ++i)
3077	if (kvm->arch.vcores[i] && kvm->arch.vcores[i]->mpp_buffer) {
3078	struct kvmppc_vcore *vc = kvm->arch.vcores[i];
3079	free_pages((unsigned long)vc->mpp_buffer,
3080	MPP_BUFFER_ORDER);
3081	}
3082	kfree(kvm->arch.vcores[i]);	3030	kfree(kvm->arch.vcores[i]);
3083	}
3084	kvm->arch.online_vcores = 0;	3031	kvm->arch.online_vcores = 0;
3085	}	3032	}
3086		3033

arch/powerpc/mm/hash_native_64.c+11−12

  * be when they isi), and we are the only one left.  We rely on our kernel
  * mapping being 0xC0's and the hardware ignoring those two real bits.
  *
+ * This must be called with interrupts disabled.
+ *
+ * Taking the native_tlbie_lock is unsafe here due to the possibility of
+ * lockdep being on. On pre POWER5 hardware, not taking the lock could
+ * cause deadlock. POWER5 and newer not taking the lock is fine. This only
+ * gets called during boot before secondary CPUs have come up and during
+ * crashdump and all bets are off anyway.
+ *
  * TODO: add batching support when enabled.  remember, no dynamic memory here,
  * athough there is the control page available...
  */
 static void native_hpte_clear(void)
 {
 	unsigned long vpn = 0;
-	unsigned long slot, slots, flags;
+	unsigned long slot, slots;
 	struct hash_pte *hptep = htab_address;
 	unsigned long hpte_v;
 	unsigned long pteg_count;
 	pteg_count = htab_hash_mask + 1;
-	local_irq_save(flags);
-	/* we take the tlbie lock and hold it.  Some hardware will
-	 * deadlock if we try to tlbie from two processors at once.
-	 */
-	raw_spin_lock(&native_tlbie_lock);
 	slots = pteg_count * HPTES_PER_GROUP;
 	for (slot = 0; slot < slots; slot++, hptep++) {
 		hpte_v = be64_to_cpu(hptep->v);
 		/*
-		 * Call __tlbie() here rather than tlbie() since we
+		 * Call __tlbie() here rather than tlbie() since we can't take the
-		 * already hold the native_tlbie_lock.
+		 * native_tlbie_lock.
 		 */
 		if (hpte_v & HPTE_V_VALID) {
 			hpte_decode(hptep, slot, &psize, &apsize, &ssize, &vpn);
 	}
 	asm volatile("eieio; tlbsync; ptesync":::"memory");
-	raw_spin_unlock(&native_tlbie_lock);
-	local_irq_restore(flags);
 }
 /*

arch/powerpc/platforms/powernv/opal.c+5−2

 	 *    PRD component would have already got notified about this
 	 *    error through other channels.
 	 *
-	 * In any case, let us just fall through. We anyway heading
+	 * If hardware marked this as an unrecoverable MCE, we are
-	 * down to panic path.
+	 * going to panic anyway. Even if it didn't, it's not safe to
+	 * continue at this point, so we should explicitly panic.
 	 */
+	panic("PowerNV Unrecovered Machine Check");
 	return 0;
 }

arch/powerpc/platforms/powernv/smp.c+24−5

 	 * so clear LPCR:PECE1. We keep PECE2 enabled.
 	 */
 	mtspr(SPRN_LPCR, mfspr(SPRN_LPCR) & ~(u64)LPCR_PECE1);
+	/*
+	 * Hard-disable interrupts, and then clear irq_happened flags
+	 * that we can safely ignore while off-line, since they
+	 * are for things for which we do no processing when off-line
+	 * (or in the case of HMI, all the processing we need to do
+	 * is done in lower-level real-mode code).
+	 */
+	hard_irq_disable();
+	local_paca->irq_happened &= ~(PACA_IRQ_DEC | PACA_IRQ_HMI);
 	while (!generic_check_cpu_restart(cpu)) {
+		/*
+		 * Clear IPI flag, since we don't handle IPIs while
+		 * offline, except for those when changing micro-threading
+		 * mode, which are handled explicitly below, and those
+		 * for coming online, which are handled via
+		 * generic_check_cpu_restart() calls.
+		 */
+		kvmppc_set_host_ipi(cpu, 0);
 		ppc64_runlatch_off();
 		 * having finished executing in a KVM guest, then srr1
 		 * contains 0.
 		 */
-		if ((srr1 & wmask) == SRR1_WAKEEE) {
+		if (((srr1 & wmask) == SRR1_WAKEEE) ||
+		    (local_paca->irq_happened & PACA_IRQ_EE)) {
 			icp_native_flush_interrupt();
-			local_paca->irq_happened &= PACA_IRQ_HARD_DIS;
-			smp_mb();
 		} else if ((srr1 & wmask) == SRR1_WAKEHDBELL) {
 			unsigned long msg = PPC_DBELL_TYPE(PPC_DBELL_SERVER);
 			asm volatile(PPC_MSGCLR(%0) : : "r" (msg));
-			kvmppc_set_host_ipi(cpu, 0);
 		}
+		local_paca->irq_happened &= ~(PACA_IRQ_EE | PACA_IRQ_DBELL);
+		smp_mb();
 		if (cpu_core_split_required())
 			continue;
-		if (!generic_check_cpu_restart(cpu))
+		if (srr1 && !generic_check_cpu_restart(cpu))
 			DBG("CPU%d Unexpected exit while offline !\n", cpu);
 	}
 	mtspr(SPRN_LPCR, mfspr(SPRN_LPCR) | LPCR_PECE1);

arch/powerpc/platforms/ps3/os-area.c+0−5

 	.key = OS_AREA_DB_KEY_RTC_DIFF
 };
-static const struct os_area_db_id os_area_db_id_video_mode = {
-	.owner = OS_AREA_DB_OWNER_LINUX,
-	.key = OS_AREA_DB_KEY_VIDEO_MODE
-};
 #define SECONDS_FROM_1970_TO_2000 946684800LL
 /**

arch/sh/include/asm/page.h+1−0

@@ -59,6 +59,7 @@ pages_do_alias(unsigned long addr1, unsigned long addr2) · 58 unmodified lines
59		59
60	#define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)	60	#define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)
61	extern void copy_page(void to, void from);	61	extern void copy_page(void to, void from);
		62	#define copy_user_page(to, from, vaddr, pg) __copy_user(to, from, PAGE_SIZE)
62		63
63	struct page;	64	struct page;
64	struct vm_area_struct;	65	struct vm_area_struct;

arch/sparc/crypto/aes_glue.c+2−0

 		.blkcipher = {
 			.min_keysize	= AES_MIN_KEY_SIZE,
 			.max_keysize	= AES_MAX_KEY_SIZE,
+			.ivsize		= AES_BLOCK_SIZE,
 			.setkey		= aes_set_key,
 			.encrypt	= cbc_encrypt,
 			.decrypt	= cbc_decrypt,
 		.blkcipher = {
 			.min_keysize	= AES_MIN_KEY_SIZE,
 			.max_keysize	= AES_MAX_KEY_SIZE,
+			.ivsize		= AES_BLOCK_SIZE,
 			.setkey		= aes_set_key,
 			.encrypt	= ctr_crypt,
 			.decrypt	= ctr_crypt,

arch/sparc/crypto/camellia_glue.c+1−0

@@ -274,6 +274,7 @@ static struct crypto_alg algs[] = { { · 273 unmodified lines
274	.blkcipher = {	274	.blkcipher = {
275	.min_keysize = CAMELLIA_MIN_KEY_SIZE,	275	.min_keysize = CAMELLIA_MIN_KEY_SIZE,
276	.max_keysize = CAMELLIA_MAX_KEY_SIZE,	276	.max_keysize = CAMELLIA_MAX_KEY_SIZE,
		277	.ivsize = CAMELLIA_BLOCK_SIZE,
277	.setkey = camellia_set_key,	278	.setkey = camellia_set_key,
278	.encrypt = cbc_encrypt,	279	.encrypt = cbc_encrypt,
279	.decrypt = cbc_decrypt,	280	.decrypt = cbc_decrypt,

arch/sparc/crypto/des_glue.c+2−0

 		.blkcipher = {
 			.min_keysize	= DES_KEY_SIZE,
 			.max_keysize	= DES_KEY_SIZE,
+			.ivsize		= DES_BLOCK_SIZE,
 			.setkey		= des_set_key,
 			.encrypt	= cbc_encrypt,
 			.decrypt	= cbc_decrypt,
 		.blkcipher = {
 			.min_keysize	= DES3_EDE_KEY_SIZE,
 			.max_keysize	= DES3_EDE_KEY_SIZE,
+			.ivsize		= DES3_EDE_BLOCK_SIZE,
 			.setkey		= des3_ede_set_key,
 			.encrypt	= cbc3_encrypt,
 			.decrypt	= cbc3_decrypt,

arch/um/Makefile+2−2

@@ -70,8 +70,8 @@ KBUILD_AFLAGS += $(ARCH_INCLUDE) · 69 unmodified lines
70		70
71	USER_CFLAGS = $(patsubst $(KERNEL_DEFINES),,$(patsubst -I%,,$(KBUILD_CFLAGS))) \	71	USER_CFLAGS = $(patsubst $(KERNEL_DEFINES),,$(patsubst -I%,,$(KBUILD_CFLAGS))) \
72	$(ARCH_INCLUDE) $(MODE_INCLUDE) $(filter -I%,$(CFLAGS)) \	72	$(ARCH_INCLUDE) $(MODE_INCLUDE) $(filter -I%,$(CFLAGS)) \
73	-D_FILE_OFFSET_BITS=64 -idirafter include \	73	-D_FILE_OFFSET_BITS=64 -idirafter $(srctree)/include \
74	-D__KERNEL__ -D__UM_HOST__	74	-idirafter $(obj)/include -D__KERNEL__ -D__UM_HOST__
75		75
76	#This will adjust *FLAGS accordingly to the platform.	76	#This will adjust *FLAGS accordingly to the platform.
77	include $(ARCH_DIR)/Makefile-os-$(OS)	77	include $(ARCH_DIR)/Makefile-os-$(OS)

arch/um/kernel/trap.c+1−1

@@ -220,7 +220,7 @@ unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, · 219 unmodified lines
220	show_regs(container_of(regs, struct pt_regs, regs));	220	show_regs(container_of(regs, struct pt_regs, regs));
221	panic("Segfault with no mm");	221	panic("Segfault with no mm");
222	}	222	}
223	else if (!is_user && address < TASK_SIZE) {	223	else if (!is_user && address > PAGE_SIZE && address < TASK_SIZE) {
224	show_regs(container_of(regs, struct pt_regs, regs));	224	show_regs(container_of(regs, struct pt_regs, regs));
225	panic("Kernel tried to access user memory at addr 0x%lx, ip 0x%lx",	225	panic("Kernel tried to access user memory at addr 0x%lx, ip 0x%lx",
226	address, ip);	226	address, ip);

arch/um/os-Linux/helper.c+3−3

@@ -96,7 +96,7 @@ int run_helper(void (pre_exec)(void ), void pre_data, char *argv) · 95 unmodified lines
96	"ret = %d\n", -n);	96	"ret = %d\n", -n);
97	ret = n;	97	ret = n;
98	}	98	}
99	CATCH_EINTR(waitpid(pid, NULL, __WCLONE));	99	CATCH_EINTR(waitpid(pid, NULL, __WALL));
100	}	100	}
101		101
102	out_free2:	102	out_free2:
@@ -129,7 +129,7 @@ int run_helper_thread(int (proc)(void ), void *arg, unsigned int flags, · 26 unmodified lines
129	return err;	129	return err;
130	}	130	}
131	if (stack_out == NULL) {	131	if (stack_out == NULL) {
132	CATCH_EINTR(pid = waitpid(pid, &status, __WCLONE));	132	CATCH_EINTR(pid = waitpid(pid, &status, __WALL));
133	if (pid < 0) {	133	if (pid < 0) {
134	err = -errno;	134	err = -errno;
135	printk(UM_KERN_ERR "run_helper_thread - wait failed, "	135	printk(UM_KERN_ERR "run_helper_thread - wait failed, "
@@ -148,7 +148,7 @@ int run_helper_thread(int (proc)(void ), void *arg, unsigned int flags, · 12 unmodified lines
148	int helper_wait(int pid)	148	int helper_wait(int pid)
149	{	149	{
150	int ret, status;	150	int ret, status;
151	int wflags = __WCLONE;	151	int wflags = __WALL;
152		152
153	CATCH_EINTR(ret = waitpid(pid, &status, wflags));	153	CATCH_EINTR(ret = waitpid(pid, &status, wflags));
154	if (ret < 0) {	154	if (ret < 0) {

arch/x86/boot/compressed/eboot.c+6−2

 		bool conout_found = false;
 		void *dummy = NULL;
 		u32 h = handles[i];
+		u32 current_fb_base;
 		status = efi_call_early(handle_protocol, h,
 					proto, (void **)&gop32);
 		if (status == EFI_SUCCESS)
 			conout_found = true;
-		status = __gop_query32(gop32, &info, &size, &fb_base);
+		status = __gop_query32(gop32, &info, &size, &current_fb_base);
 		if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
 			/*
 			 * Systems that use the UEFI Console Splitter may
 			pixel_format = info->pixel_format;
 			pixel_info = info->pixel_information;
 			pixels_per_scan_line = info->pixels_per_scan_line;
+			fb_base = current_fb_base;
 			/*
 			 * Once we've found a GOP supporting ConOut,
 		bool conout_found = false;
 		void *dummy = NULL;
 		u64 h = handles[i];
+		u32 current_fb_base;
 		status = efi_call_early(handle_protocol, h,
 					proto, (void **)&gop64);
 		if (status == EFI_SUCCESS)
 			conout_found = true;
-		status = __gop_query64(gop64, &info, &size, &fb_base);
+		status = __gop_query64(gop64, &info, &size, &current_fb_base);
 		if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
 			/*
 			 * Systems that use the UEFI Console Splitter may
 			pixel_format = info->pixel_format;
 			pixel_info = info->pixel_information;
 			pixels_per_scan_line = info->pixels_per_scan_line;
+			fb_base = current_fb_base;
 			/*
 			 * Once we've found a GOP supporting ConOut,

arch/x86/crypto/camellia_aesni_avx_glue.c+5−0

 {
 	const char *feature_name;
+	if (!cpu_has_avx || !cpu_has_aes || !cpu_has_osxsave) {
+		pr_info("AVX or AES-NI instructions are not detected.\n");
+		return -ENODEV;
+	}
 	if (!cpu_has_xfeatures(XSTATE_SSE | XSTATE_YMM, &feature_name)) {
 		pr_info("CPU feature '%s' is not supported.\n", feature_name);
 		return -ENODEV;

arch/x86/include/asm/kvm_host.h+2−4

@@ -1226,10 +1226,8 @@ void kvm_complete_insn_gp(struct kvm_vcpu *vcpu, int err); · 1225 unmodified lines
1226		1226
1227	int kvm_is_in_guest(void);	1227	int kvm_is_in_guest(void);
1228		1228
1229	int __x86_set_memory_region(struct kvm *kvm,	1229	int __x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size);
1230	const struct kvm_userspace_memory_region *mem);	1230	int x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size);
1231	int x86_set_memory_region(struct kvm *kvm,
1232	const struct kvm_userspace_memory_region *mem);
1233	bool kvm_vcpu_is_reset_bsp(struct kvm_vcpu *vcpu);	1231	bool kvm_vcpu_is_reset_bsp(struct kvm_vcpu *vcpu);
1234	bool kvm_vcpu_is_bsp(struct kvm_vcpu *vcpu);	1232	bool kvm_vcpu_is_bsp(struct kvm_vcpu *vcpu);
1235		1233

arch/x86/include/asm/string_64.h+2−3

    function. */
 #define __HAVE_ARCH_MEMCPY 1
+extern void *memcpy(void *to, const void *from, size_t len);
 extern void *__memcpy(void *to, const void *from, size_t len);
 #ifndef CONFIG_KMEMCHECK
-#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4
+#if (__GNUC__ == 4 && __GNUC_MINOR__ < 3) || __GNUC__ < 4
-extern void *memcpy(void *to, const void *from, size_t len);
-#else
 #define memcpy(dst, src, len)					\
 ({								\
 	size_t __len = (len);					\

arch/x86/kernel/apic/io_apic.c+4−0

 	struct irq_data *irq_data;
 	struct mp_chip_data *data;
 	struct irq_alloc_info *info = arg;
+	unsigned long flags;
 	if (!info || nr_irqs > 1)
 		return -EINVAL;
 	cfg = irqd_cfg(irq_data);
 	add_pin_to_irq_node(data, ioapic_alloc_attr_node(info), ioapic, pin);
+	local_irq_save(flags);
 	if (info->ioapic_entry)
 		mp_setup_entry(cfg, data, info->ioapic_entry);
 	mp_register_handler(virq, data->trigger);
 	if (virq < nr_legacy_irqs())
 		legacy_pic->mask(virq);
+	local_irq_restore(flags);
 	apic_printk(APIC_VERBOSE, KERN_DEBUG
 		    "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> IRQ %d Mode:%i Active:%i Dest:%d)\n",

arch/x86/kernel/process.c+3−3

@@ -550,14 +550,14 @@ unsigned long get_wchan(struct task_struct *p) · 549 unmodified lines
550	if (sp < bottom \|\| sp > top)	550	if (sp < bottom \|\| sp > top)
551	return 0;	551	return 0;
552		552
553	fp = READ_ONCE((unsigned long )sp);	553	fp = READ_ONCE_NOCHECK((unsigned long )sp);
554	do {	554	do {
555	if (fp < bottom \|\| fp > top)	555	if (fp < bottom \|\| fp > top)
556	return 0;	556	return 0;
557	ip = READ_ONCE((unsigned long )(fp + sizeof(unsigned long)));	557	ip = READ_ONCE_NOCHECK((unsigned long )(fp + sizeof(unsigned long)));
558	if (!in_sched_functions(ip))	558	if (!in_sched_functions(ip))
559	return ip;	559	return ip;
560	fp = READ_ONCE((unsigned long )fp);	560	fp = READ_ONCE_NOCHECK((unsigned long )fp);
561	} while (count++ < 16 && p->state != TASK_RUNNING);	561	} while (count++ < 16 && p->state != TASK_RUNNING);
562	return 0;	562	return 0;
563	}	563	}

arch/x86/kernel/setup.c+8−0

@@ -1173,6 +1173,14 @@ void __init setup_arch(char **cmdline_p) · 1172 unmodified lines
1173	clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,	1173	clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,
1174	swapper_pg_dir + KERNEL_PGD_BOUNDARY,	1174	swapper_pg_dir + KERNEL_PGD_BOUNDARY,
1175	KERNEL_PGD_PTRS);	1175	KERNEL_PGD_PTRS);
		1176
		1177	/*
		1178	* sync back low identity map too. It is used for example
		1179	* in the 32-bit EFI stub.
		1180	*/
		1181	clone_pgd_range(initial_page_table,
		1182	swapper_pg_dir + KERNEL_PGD_BOUNDARY,
		1183	KERNEL_PGD_PTRS);
1176	#endif	1184	#endif
1177		1185
1178	tboot_probe();	1186	tboot_probe();

arch/x86/kernel/smpboot.c+11−4

  */
 #define UDELAY_10MS_DEFAULT 10000
-static unsigned int init_udelay = UDELAY_10MS_DEFAULT;
+static unsigned int init_udelay = INT_MAX;
 static int __init cpu_init_udelay(char *str)
 {
 static void __init smp_quirk_init_udelay(void)
 {
 	/* if cmdline changed it from default, leave it alone */
-	if (init_udelay != UDELAY_10MS_DEFAULT)
+	if (init_udelay != INT_MAX)
 		return;
 	/* if modern processor, use no delay */
 	if (((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) && (boot_cpu_data.x86 == 6)) ||
 	    ((boot_cpu_data.x86_vendor == X86_VENDOR_AMD) && (boot_cpu_data.x86 >= 0xF)))
 		init_udelay = 0;
+	/* else, use legacy delay */
+	init_udelay = UDELAY_10MS_DEFAULT;
 }
 /*
 		/*
 		 * Give the other CPU some time to accept the IPI.
 		 */
-		if (init_udelay)
+		if (init_udelay == 0)
+			udelay(10);
+		else
 			udelay(300);
 		pr_debug("Startup point 1\n");
 		/*
 		 * Give the other CPU some time to accept the IPI.
 		 */
-		if (init_udelay)
+		if (init_udelay == 0)
+			udelay(10);
+		else
 			udelay(200);
 		if (maxlvt > 3)		/* Due to the Pentium erratum 3AP.  */

arch/x86/kvm/emulate.c+7−3

 	u64 val, cr0, cr4;
 	u32 base3;
 	u16 selector;
-	int i;
+	int i, r;
 	for (i = 0; i < 16; i++)
 		*reg_write(ctxt, i) = GET_SMSTATE(u64, smbase, 0x7ff8 - i * 8);
 	dt.address =                GET_SMSTATE(u64, smbase, 0x7e68);
 	ctxt->ops->set_gdt(ctxt, &dt);
+	r = rsm_enter_protected_mode(ctxt, cr0, cr4);
+	if (r != X86EMUL_CONTINUE)
+		return r;
 	for (i = 0; i < 6; i++) {
-		int r = rsm_load_seg_64(ctxt, smbase, i);
+		r = rsm_load_seg_64(ctxt, smbase, i);
 		if (r != X86EMUL_CONTINUE)
 			return r;
 	}
-	return rsm_enter_protected_mode(ctxt, cr0, cr4);
+	return X86EMUL_CONTINUE;
 }
 static int em_rsm(struct x86_emulate_ctxt *ctxt)

arch/x86/kvm/vmx.c+6−20

 static int alloc_apic_access_page(struct kvm *kvm)
 {
 	struct page *page;
-	struct kvm_userspace_memory_region kvm_userspace_mem;
 	int r = 0;
 	mutex_lock(&kvm->slots_lock);
 	if (kvm->arch.apic_access_page_done)
 		goto out;
-	kvm_userspace_mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT;
+	r = __x86_set_memory_region(kvm, APIC_ACCESS_PAGE_PRIVATE_MEMSLOT,
-	kvm_userspace_mem.flags = 0;
+				    APIC_DEFAULT_PHYS_BASE, PAGE_SIZE);
-	kvm_userspace_mem.guest_phys_addr = APIC_DEFAULT_PHYS_BASE;
-	kvm_userspace_mem.memory_size = PAGE_SIZE;
-	r = __x86_set_memory_region(kvm, &kvm_userspace_mem);
 	if (r)
 		goto out;
 {
 	/* Called with kvm->slots_lock held. */
-	struct kvm_userspace_memory_region kvm_userspace_mem;
 	int r = 0;
 	BUG_ON(kvm->arch.ept_identity_pagetable_done);
-	kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT;
+	r = __x86_set_memory_region(kvm, IDENTITY_PAGETABLE_PRIVATE_MEMSLOT,
-	kvm_userspace_mem.flags = 0;
+				    kvm->arch.ept_identity_map_addr, PAGE_SIZE);
-	kvm_userspace_mem.guest_phys_addr =
-		kvm->arch.ept_identity_map_addr;
-	kvm_userspace_mem.memory_size = PAGE_SIZE;
-	r = __x86_set_memory_region(kvm, &kvm_userspace_mem);
 	return r;
 }
 static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr)
 {
 	int ret;
-	struct kvm_userspace_memory_region tss_mem = {
-		.slot = TSS_PRIVATE_MEMSLOT,
-		.guest_phys_addr = addr,
-		.memory_size = PAGE_SIZE * 3,
-		.flags = 0,
-	};
-	ret = x86_set_memory_region(kvm, &tss_mem);
+	ret = x86_set_memory_region(kvm, TSS_PRIVATE_MEMSLOT, addr,
+				    PAGE_SIZE * 3);
 	if (ret)
 		return ret;
 	kvm->arch.tss_addr = addr;

arch/x86/kvm/x86.c+75−60

 	return 1;
 }
+static inline bool kvm_vcpu_running(struct kvm_vcpu *vcpu)
+{
+	return (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE &&
+		!vcpu->arch.apf.halted);
+}
 static int vcpu_run(struct kvm_vcpu *vcpu)
 {
 	int r;
 	vcpu->srcu_idx = srcu_read_lock(&kvm->srcu);
 	for (;;) {
-		if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE &&
+		if (kvm_vcpu_running(vcpu))
-		    !vcpu->arch.apf.halted)
 			r = vcpu_enter_guest(vcpu);
 		else
 			r = vcpu_block(kvm, vcpu);
 	kvm_free_pit(kvm);
 }
-int __x86_set_memory_region(struct kvm *kvm,
+int __x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size)
-			    const struct kvm_userspace_memory_region *mem)
 {
 	int i, r;
+	unsigned long hva;
+	struct kvm_memslots *slots = kvm_memslots(kvm);
+	struct kvm_memory_slot *slot, old;
 	/* Called with kvm->slots_lock held.  */
-	BUG_ON(mem->slot >= KVM_MEM_SLOTS_NUM);
+	if (WARN_ON(id >= KVM_MEM_SLOTS_NUM))
+		return -EINVAL;
+	slot = id_to_memslot(slots, id);
+	if (size) {
+		if (WARN_ON(slot->npages))
+			return -EEXIST;
+		/*
+		 * MAP_SHARED to prevent internal slot pages from being moved
+		 * by fork()/COW.
+		 */
+		hva = vm_mmap(NULL, 0, size, PROT_READ | PROT_WRITE,
+			      MAP_SHARED | MAP_ANONYMOUS, 0);
+		if (IS_ERR((void *)hva))
+			return PTR_ERR((void *)hva);
+	} else {
+		if (!slot->npages)
+			return 0;
+		hva = 0;
+	}
+	old = *slot;
 	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
-		struct kvm_userspace_memory_region m = *mem;
+		struct kvm_userspace_memory_region m;
-		m.slot |= i << 16;
+		m.slot = id | (i << 16);
+		m.flags = 0;
+		m.guest_phys_addr = gpa;
+		m.userspace_addr = hva;
+		m.memory_size = size;
 		r = __kvm_set_memory_region(kvm, &m);
 		if (r < 0)
 			return r;
 	}
+	if (!size) {
+		r = vm_munmap(old.userspace_addr, old.npages * PAGE_SIZE);
+		WARN_ON(r < 0);
+	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(__x86_set_memory_region);
-int x86_set_memory_region(struct kvm *kvm,
+int x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size)
-			  const struct kvm_userspace_memory_region *mem)
 {
 	int r;
 	mutex_lock(&kvm->slots_lock);
-	r = __x86_set_memory_region(kvm, mem);
+	r = __x86_set_memory_region(kvm, id, gpa, size);
 	mutex_unlock(&kvm->slots_lock);
 	return r;
 		 * unless the the memory map has changed due to process exit
 		 * or fd copying.
 		 */
-		struct kvm_userspace_memory_region mem;
+		x86_set_memory_region(kvm, APIC_ACCESS_PAGE_PRIVATE_MEMSLOT, 0, 0);
-		memset(&mem, 0, sizeof(mem));
+		x86_set_memory_region(kvm, IDENTITY_PAGETABLE_PRIVATE_MEMSLOT, 0, 0);
-		mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT;
+		x86_set_memory_region(kvm, TSS_PRIVATE_MEMSLOT, 0, 0);
-		x86_set_memory_region(kvm, &mem);
-		mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT;
-		x86_set_memory_region(kvm, &mem);
-		mem.slot = TSS_PRIVATE_MEMSLOT;
-		x86_set_memory_region(kvm, &mem);
 	}
 	kvm_iommu_unmap_guest(kvm);
 	kfree(kvm->arch.vpic);
 				const struct kvm_userspace_memory_region *mem,
 				enum kvm_mr_change change)
 {
-	/*
-	 * Only private memory slots need to be mapped here since
-	 * KVM_SET_MEMORY_REGION ioctl is no longer supported.
-	 */
-	if ((memslot->id >= KVM_USER_MEM_SLOTS) && (change == KVM_MR_CREATE)) {
-		unsigned long userspace_addr;
-		/*
-		 * MAP_SHARED to prevent internal slot pages from being moved
-		 * by fork()/COW.
-		 */
-		userspace_addr = vm_mmap(NULL, 0, memslot->npages * PAGE_SIZE,
-					 PROT_READ | PROT_WRITE,
-					 MAP_SHARED | MAP_ANONYMOUS, 0);
-		if (IS_ERR((void *)userspace_addr))
-			return PTR_ERR((void *)userspace_addr);
-		memslot->userspace_addr = userspace_addr;
-	}
 	return 0;
 }
 {
 	int nr_mmu_pages = 0;
-	if (change == KVM_MR_DELETE && old->id >= KVM_USER_MEM_SLOTS) {
-		int ret;
-		ret = vm_munmap(old->userspace_addr,
-				old->npages * PAGE_SIZE);
-		if (ret < 0)
-			printk(KERN_WARNING
-			       "kvm_vm_ioctl_set_memory_region: "
-			       "failed to munmap memory\n");
-	}
 	if (!kvm->arch.n_requested_mmu_pages)
 		nr_mmu_pages = kvm_mmu_calculate_mmu_pages(kvm);
 	kvm_mmu_invalidate_zap_all_pages(kvm);
 }
+static inline bool kvm_vcpu_has_events(struct kvm_vcpu *vcpu)
+{
+	if (!list_empty_careful(&vcpu->async_pf.done))
+		return true;
+	if (kvm_apic_has_events(vcpu))
+		return true;
+	if (vcpu->arch.pv.pv_unhalted)
+		return true;
+	if (atomic_read(&vcpu->arch.nmi_queued))
+		return true;
+	if (test_bit(KVM_REQ_SMI, &vcpu->requests))
+		return true;
+	if (kvm_arch_interrupt_allowed(vcpu) &&
+	    kvm_cpu_has_interrupt(vcpu))
+		return true;
+	return false;
+}
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
 {
 	if (is_guest_mode(vcpu) && kvm_x86_ops->check_nested_events)
 		kvm_x86_ops->check_nested_events(vcpu, false);
-	return (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE &&
+	return kvm_vcpu_running(vcpu) || kvm_vcpu_has_events(vcpu);
-		!vcpu->arch.apf.halted)
-		|| !list_empty_careful(&vcpu->async_pf.done)
-		|| kvm_apic_has_events(vcpu)
-		|| vcpu->arch.pv.pv_unhalted
-		|| atomic_read(&vcpu->arch.nmi_queued) ||
-		(kvm_arch_interrupt_allowed(vcpu) &&
-		 kvm_cpu_has_interrupt(vcpu));
 }
 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)

arch/x86/um/ldt.c+4−1

 #include <skas.h>
 #include <sysdep/tls.h>
-extern int modify_ldt(int func, void *ptr, unsigned long bytecount);
+static inline int modify_ldt (int func, void *ptr, unsigned long bytecount)
+{
+	return syscall(__NR_modify_ldt, func, ptr, bytecount);
+}
 static long write_ldt_entry(struct mm_id *mm_idp, int func,
 		     struct user_desc *desc, void **addr, int done)

block/blk-core.c+1−1

@@ -576,7 +576,7 @@ void blk_cleanup_queue(struct request_queue *q) · 575 unmodified lines
576	q->queue_lock = &q->__queue_lock;	576	q->queue_lock = &q->__queue_lock;
577	spin_unlock_irq(lock);	577	spin_unlock_irq(lock);
578		578
579	bdi_destroy(&q->backing_dev_info);	579	bdi_unregister(&q->backing_dev_info);
580		580
581	/* @q is and will stay empty, shutdown and put */	581	/* @q is and will stay empty, shutdown and put */
582	blk_put_queue(q);	582	blk_put_queue(q);

block/blk-mq-tag.c+1−0

@@ -641,6 +641,7 @@ void blk_mq_free_tags(struct blk_mq_tags *tags) · 640 unmodified lines
641	{	641	{
642	bt_free(&tags->bitmap_tags);	642	bt_free(&tags->bitmap_tags);
643	bt_free(&tags->breserved_tags);	643	bt_free(&tags->breserved_tags);
		644	free_cpumask_var(tags->cpumask);
644	kfree(tags);	645	kfree(tags);
645	}	646	}
646		647

block/blk-mq.c+1−3

 	int i;
 	for (i = 0; i < set->nr_hw_queues; i++) {
-		if (set->tags[i]) {
+		if (set->tags[i])
 			blk_mq_free_rq_map(set, set->tags[i], i);
-			free_cpumask_var(set->tags[i]->cpumask);
-		}
 	}
 	kfree(set->tags);

block/blk-sysfs.c+1−0

@@ -540,6 +540,7 @@ static void blk_release_queue(struct kobject *kobj) · 539 unmodified lines
540	struct request_queue *q =	540	struct request_queue *q =
541	container_of(kobj, struct request_queue, kobj);	541	container_of(kobj, struct request_queue, kobj);
542		542
		543	bdi_exit(&q->backing_dev_info);
543	blkcg_exit_queue(q);	544	blkcg_exit_queue(q);
544		545
545	if (q->elevator) {	546	if (q->elevator) {

crypto/ahash.c+2−1

@@ -544,7 +544,8 @@ static int ahash_prepare_alg(struct ahash_alg *alg) · 543 unmodified lines
544	struct crypto_alg *base = &alg->halg.base;	544	struct crypto_alg *base = &alg->halg.base;
545		545
546	if (alg->halg.digestsize > PAGE_SIZE / 8 \|\|	546	if (alg->halg.digestsize > PAGE_SIZE / 8 \|\|
547	alg->halg.statesize > PAGE_SIZE / 8)	547	alg->halg.statesize > PAGE_SIZE / 8 \|\|
		548	alg->halg.statesize == 0)
548	return -EINVAL;	549	return -EINVAL;
549		550
550	base->cra_type = &crypto_ahash_type;	551	base->cra_type = &crypto_ahash_type;

drivers/acpi/acpica/acglobal.h+1−0

@@ -61,6 +61,7 @@ ACPI_GLOBAL(struct acpi_table_header, acpi_gbl_original_dsdt_header); · 60 unmodified lines
61	ACPI_INIT_GLOBAL(u32, acpi_gbl_dsdt_index, ACPI_INVALID_TABLE_INDEX);	61	ACPI_INIT_GLOBAL(u32, acpi_gbl_dsdt_index, ACPI_INVALID_TABLE_INDEX);
62	ACPI_INIT_GLOBAL(u32, acpi_gbl_facs_index, ACPI_INVALID_TABLE_INDEX);	62	ACPI_INIT_GLOBAL(u32, acpi_gbl_facs_index, ACPI_INVALID_TABLE_INDEX);
63	ACPI_INIT_GLOBAL(u32, acpi_gbl_xfacs_index, ACPI_INVALID_TABLE_INDEX);	63	ACPI_INIT_GLOBAL(u32, acpi_gbl_xfacs_index, ACPI_INVALID_TABLE_INDEX);
		64	ACPI_INIT_GLOBAL(u32, acpi_gbl_fadt_index, ACPI_INVALID_TABLE_INDEX);
64		65
65	#if (!ACPI_REDUCED_HARDWARE)	66	#if (!ACPI_REDUCED_HARDWARE)
66	ACPI_GLOBAL(struct acpi_table_facs *, acpi_gbl_FACS);	67	ACPI_GLOBAL(struct acpi_table_facs *, acpi_gbl_FACS);

drivers/acpi/acpica/actables.h+1−3

 /*
  * tbfadt - FADT parse/convert/validate
  */
-void acpi_tb_parse_fadt(u32 table_index);
+void acpi_tb_parse_fadt(void);
 void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length);
  */
 acpi_status acpi_tb_initialize_facs(void);
-u8 acpi_tb_tables_loaded(void);
 void
 acpi_tb_print_table_header(acpi_physical_address address,
 			   struct acpi_table_header *header);

drivers/acpi/acpica/evxfevnt.c+1−1

@@ -71,7 +71,7 @@ acpi_status acpi_enable(void) · 70 unmodified lines
71		71
72	/* ACPI tables must be present */	72	/* ACPI tables must be present */
73		73
74	if (!acpi_tb_tables_loaded()) {	74	if (acpi_gbl_fadt_index == ACPI_INVALID_TABLE_INDEX) {
75	return_ACPI_STATUS(AE_NO_ACPI_TABLES);	75	return_ACPI_STATUS(AE_NO_ACPI_TABLES);
76	}	76	}
77		77

drivers/acpi/acpica/tbfadt.c+5−5

@@ -298,7 +298,7 @@ acpi_tb_select_address(char *register_name, u32 address32, u64 address64) · 297 unmodified lines
298	*	298	*
299	* FUNCTION: acpi_tb_parse_fadt	299	* FUNCTION: acpi_tb_parse_fadt
300	*	300	*
301	* PARAMETERS: table_index - Index for the FADT	301	* PARAMETERS: None
302	*	302	*
303	* RETURN: None	303	* RETURN: None
304	*	304	*
@@ -307,7 +307,7 @@ acpi_tb_select_address(char *register_name, u32 address32, u64 address64) · 2 unmodified lines
307	*	307	*
308	******************************************************************************/	308	******************************************************************************/
309		309
310	void acpi_tb_parse_fadt(u32 table_index)	310	void acpi_tb_parse_fadt(void)
311	{	311	{
312	u32 length;	312	u32 length;
313	struct acpi_table_header *table;	313	struct acpi_table_header *table;
@@ -319,11 +319,11 @@ void acpi_tb_parse_fadt(u32 table_index) · 5 unmodified lines
319	* Get a local copy of the FADT and convert it to a common format	319	* Get a local copy of the FADT and convert it to a common format
320	* Map entire FADT, assumed to be smaller than one page.	320	* Map entire FADT, assumed to be smaller than one page.
321	*/	321	*/
322	length = acpi_gbl_root_table_list.tables[table_index].length;	322	length = acpi_gbl_root_table_list.tables[acpi_gbl_fadt_index].length;
323		323
324	table =	324	table =
325	acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index].	325	acpi_os_map_memory(acpi_gbl_root_table_list.
326	address, length);	326	tables[acpi_gbl_fadt_index].address, length);
327	if (!table) {	327	if (!table) {
328	return;	328	return;
329	}	329	}

drivers/acpi/acpica/tbutils.c+2−24

@@ -97,29 +97,6 @@ acpi_status acpi_tb_initialize_facs(void) · 96 unmodified lines
97	}	97	}
98	#endif /* !ACPI_REDUCED_HARDWARE */	98	#endif /* !ACPI_REDUCED_HARDWARE */
99		99
100	/*******************************************************************************
101	*
102	* FUNCTION: acpi_tb_tables_loaded
103	*
104	* PARAMETERS: None
105	*
106	* RETURN: TRUE if required ACPI tables are loaded
107	*
108	* DESCRIPTION: Determine if the minimum required ACPI tables are present
109	* (FADT, FACS, DSDT)
110	*
111	******************************************************************************/
112
113	u8 acpi_tb_tables_loaded(void)
114	{
115
116	if (acpi_gbl_root_table_list.current_table_count >= 4) {
117	return (TRUE);
118	}
119
120	return (FALSE);
121	}
122
123	/*******************************************************************************	100	/*******************************************************************************
124	*	101	*
125	* FUNCTION: acpi_tb_check_dsdt_header	102	* FUNCTION: acpi_tb_check_dsdt_header
@@ -392,7 +369,8 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address) · 266 unmodified lines
392	ACPI_COMPARE_NAME(&acpi_gbl_root_table_list.	369	ACPI_COMPARE_NAME(&acpi_gbl_root_table_list.
393	tables[table_index].signature,	370	tables[table_index].signature,
394	ACPI_SIG_FADT)) {	371	ACPI_SIG_FADT)) {
395	acpi_tb_parse_fadt(table_index);	372	acpi_gbl_fadt_index = table_index;
		373	acpi_tb_parse_fadt();
396	}	374	}
397		375
398	next_table:	376	next_table:

drivers/base/dma-contiguous.c+1−1

@@ -187,7 +187,7 @@ int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base, · 186 unmodified lines
187	* global one. Requires architecture specific dev_get_cma_area() helper	187	* global one. Requires architecture specific dev_get_cma_area() helper
188	* function.	188	* function.
189	*/	189	*/
190	struct page dma_alloc_from_contiguous(struct device dev, int count,	190	struct page dma_alloc_from_contiguous(struct device dev, size_t count,
191	unsigned int align)	191	unsigned int align)
192	{	192	{
193	if (align > CONFIG_CMA_ALIGNMENT)	193	if (align > CONFIG_CMA_ALIGNMENT)

drivers/base/power/domain_governor.c+6−16

@@ -77,13 +77,16 @@ static bool default_stop_ok(struct device *dev) · 76 unmodified lines
77	dev_update_qos_constraint);	77	dev_update_qos_constraint);
78		78
79	if (constraint_ns > 0) {	79	if (constraint_ns > 0) {
80	constraint_ns -= td->start_latency_ns;	80	constraint_ns -= td->save_state_latency_ns +
		81	td->stop_latency_ns +
		82	td->start_latency_ns +
		83	td->restore_state_latency_ns;
81	if (constraint_ns == 0)	84	if (constraint_ns == 0)
82	return false;	85	return false;
83	}	86	}
84	td->effective_constraint_ns = constraint_ns;	87	td->effective_constraint_ns = constraint_ns;
85	td->cached_stop_ok = constraint_ns > td->stop_latency_ns \|\|	88	td->cached_stop_ok = constraint_ns >= 0;
86	constraint_ns == 0;	89
87	/*	90	/*
88	* The children have been suspended already, so we don't need to take	91	* The children have been suspended already, so we don't need to take
89	* their stop latencies into account here.	92	* their stop latencies into account here.
@@ -126,18 +129,6 @@ static bool default_power_down_ok(struct dev_pm_domain *pd) · 36 unmodified lines
126		129
127	off_on_time_ns = genpd->power_off_latency_ns +	130	off_on_time_ns = genpd->power_off_latency_ns +
128	genpd->power_on_latency_ns;	131	genpd->power_on_latency_ns;
129	/*
130	* It doesn't make sense to remove power from the domain if saving
131	* the state of all devices in it and the power off/power on operations
132	* take too much time.
133	*
134	* All devices in this domain have been stopped already at this point.
135	*/
136	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
137	if (pdd->dev->driver)
138	off_on_time_ns +=
139	to_gpd_data(pdd)->td.save_state_latency_ns;
140	}
141		132
142	min_off_time_ns = -1;	133	min_off_time_ns = -1;
143	/*	134	/*
@@ -193,7 +184,6 @@ static bool default_power_down_ok(struct dev_pm_domain *pd) · 49 unmodified lines
193	* constraint_ns cannot be negative here, because the device has	184	* constraint_ns cannot be negative here, because the device has
194	* been suspended.	185	* been suspended.
195	*/	186	*/
196	constraint_ns -= td->restore_state_latency_ns;
197	if (constraint_ns <= off_on_time_ns)	187	if (constraint_ns <= off_on_time_ns)
198	return false;	188	return false;
199		189

drivers/block/nbd.c+30−6

@@ -60,6 +60,7 @@ struct nbd_device { · 59 unmodified lines
60	bool disconnect; /* a disconnect has been requested by user */	60	bool disconnect; /* a disconnect has been requested by user */
61		61
62	struct timer_list timeout_timer;	62	struct timer_list timeout_timer;
		63	spinlock_t tasks_lock;
63	struct task_struct *task_recv;	64	struct task_struct *task_recv;
64	struct task_struct *task_send;	65	struct task_struct *task_send;
65		66
@@ -140,21 +141,23 @@ static void sock_shutdown(struct nbd_device *nbd) · 74 unmodified lines
140	static void nbd_xmit_timeout(unsigned long arg)	141	static void nbd_xmit_timeout(unsigned long arg)
141	{	142	{
142	struct nbd_device nbd = (struct nbd_device )arg;	143	struct nbd_device nbd = (struct nbd_device )arg;
143	struct task_struct *task;	144	unsigned long flags;
144		145
145	if (list_empty(&nbd->queue_head))	146	if (list_empty(&nbd->queue_head))
146	return;	147	return;
147		148
148	nbd->disconnect = true;	149	nbd->disconnect = true;
149		150
150	task = READ_ONCE(nbd->task_recv);	151	spin_lock_irqsave(&nbd->tasks_lock, flags);
151	if (task)	152
152	force_sig(SIGKILL, task);	153	if (nbd->task_recv)
		154	force_sig(SIGKILL, nbd->task_recv);
153		155
154	task = READ_ONCE(nbd->task_send);	156	if (nbd->task_send)
155	if (task)
156	force_sig(SIGKILL, nbd->task_send);	157	force_sig(SIGKILL, nbd->task_send);
157		158
		159	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
		160
158	dev_err(nbd_to_dev(nbd), "Connection timed out, killed receiver and sender, shutting down connection\n");	161	dev_err(nbd_to_dev(nbd), "Connection timed out, killed receiver and sender, shutting down connection\n");
159	}	162	}
160		163
@@ -403,17 +406,24 @@ static int nbd_thread_recv(struct nbd_device *nbd) · 242 unmodified lines
403	{	406	{
404	struct request *req;	407	struct request *req;
405	int ret;	408	int ret;
		409	unsigned long flags;
406		410
407	BUG_ON(nbd->magic != NBD_MAGIC);	411	BUG_ON(nbd->magic != NBD_MAGIC);
408		412
409	sk_set_memalloc(nbd->sock->sk);	413	sk_set_memalloc(nbd->sock->sk);
410		414
		415	spin_lock_irqsave(&nbd->tasks_lock, flags);
411	nbd->task_recv = current;	416	nbd->task_recv = current;
		417	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
412		418
413	ret = device_create_file(disk_to_dev(nbd->disk), &pid_attr);	419	ret = device_create_file(disk_to_dev(nbd->disk), &pid_attr);
414	if (ret) {	420	if (ret) {
415	dev_err(disk_to_dev(nbd->disk), "device_create_file failed!\n");	421	dev_err(disk_to_dev(nbd->disk), "device_create_file failed!\n");
		422
		423	spin_lock_irqsave(&nbd->tasks_lock, flags);
416	nbd->task_recv = NULL;	424	nbd->task_recv = NULL;
		425	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
		426
417	return ret;	427	return ret;
418	}	428	}
419		429
@@ -429,7 +439,9 @@ static int nbd_thread_recv(struct nbd_device *nbd) · 9 unmodified lines
429		439
430	device_remove_file(disk_to_dev(nbd->disk), &pid_attr);	440	device_remove_file(disk_to_dev(nbd->disk), &pid_attr);
431		441
		442	spin_lock_irqsave(&nbd->tasks_lock, flags);
432	nbd->task_recv = NULL;	443	nbd->task_recv = NULL;
		444	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
433		445
434	if (signal_pending(current)) {	446	if (signal_pending(current)) {
435	siginfo_t info;	447	siginfo_t info;
@@ -534,8 +546,11 @@ static int nbd_thread_send(void *data) · 98 unmodified lines
534	{	546	{
535	struct nbd_device *nbd = data;	547	struct nbd_device *nbd = data;
536	struct request *req;	548	struct request *req;
		549	unsigned long flags;
537		550
		551	spin_lock_irqsave(&nbd->tasks_lock, flags);
538	nbd->task_send = current;	552	nbd->task_send = current;
		553	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
539		554
540	set_user_nice(current, MIN_NICE);	555	set_user_nice(current, MIN_NICE);
541	while (!kthread_should_stop() \|\| !list_empty(&nbd->waiting_queue)) {	556	while (!kthread_should_stop() \|\| !list_empty(&nbd->waiting_queue)) {
@@ -572,7 +587,15 @@ static int nbd_thread_send(void *data) · 30 unmodified lines
572	nbd_handle_req(nbd, req);	587	nbd_handle_req(nbd, req);
573	}	588	}
574		589
		590	spin_lock_irqsave(&nbd->tasks_lock, flags);
575	nbd->task_send = NULL;	591	nbd->task_send = NULL;
		592	spin_unlock_irqrestore(&nbd->tasks_lock, flags);
		593
		594	/* Clear maybe pending signals */
		595	if (signal_pending(current)) {
		596	siginfo_t info;
		597	dequeue_signal_lock(current, &current->blocked, &info);
		598	}
576		599
577	return 0;	600	return 0;
578	}	601	}
@@ -1052,6 +1075,7 @@ static int __init nbd_init(void) · 473 unmodified lines
1052	nbd_dev[i].magic = NBD_MAGIC;	1075	nbd_dev[i].magic = NBD_MAGIC;
1053	INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);	1076	INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);
1054	spin_lock_init(&nbd_dev[i].queue_lock);	1077	spin_lock_init(&nbd_dev[i].queue_lock);
		1078	spin_lock_init(&nbd_dev[i].tasks_lock);
1055	INIT_LIST_HEAD(&nbd_dev[i].queue_head);	1079	INIT_LIST_HEAD(&nbd_dev[i].queue_head);
1056	mutex_init(&nbd_dev[i].tx_lock);	1080	mutex_init(&nbd_dev[i].tx_lock);
1057	init_timer(&nbd_dev[i].timeout_timer);	1081	init_timer(&nbd_dev[i].timeout_timer);

drivers/block/nvme-core.c+15−9

 	struct nvme_iod *iod = ctx;
 	struct request *req = iod_get_private(iod);
 	struct nvme_cmd_info *cmd_rq = blk_mq_rq_to_pdu(req);
 	u16 status = le16_to_cpup(&cqe->status) >> 1;
+	bool requeue = false;
+	int error = 0;
 	if (unlikely(status)) {
 		if (!(status & NVME_SC_DNR || blk_noretry_request(req))
 		    && (jiffies - req->start_time) < req->timeout) {
 			unsigned long flags;
+			requeue = true;
 			blk_mq_requeue_request(req);
 			spin_lock_irqsave(req->q->queue_lock, flags);
 			if (!blk_queue_stopped(req->q))
 				blk_mq_kick_requeue_list(req->q);
 			spin_unlock_irqrestore(req->q->queue_lock, flags);
-			return;
+			goto release_iod;
 		}
 		if (req->cmd_type == REQ_TYPE_DRV_PRIV) {
 			if (cmd_rq->ctx == CMD_CTX_CANCELLED)
-				status = -EINTR;
+				error = -EINTR;
+			else
+				error = status;
 		} else {
-			status = nvme_error_status(status);
+			error = nvme_error_status(status);
 		}
 	}
 	if (cmd_rq->aborted)
 		dev_warn(nvmeq->dev->dev,
 			"completing aborted command with status:%04x\n",
-			status);
+			error);
+release_iod:
 	if (iod->nents) {
 		dma_unmap_sg(nvmeq->dev->dev, iod->sg, iod->nents,
 			rq_data_dir(req) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 	}
 	nvme_free_iod(nvmeq->dev, iod);
-	blk_mq_complete_request(req, status);
+	if (likely(!requeue))
+		blk_mq_complete_request(req, error);
 }
 /* length is in bytes.  gfp flags indicates whether we may sleep. */
 	length = (io.nblocks + 1) << ns->lba_shift;
 	meta_len = (io.nblocks + 1) * ns->ms;
-	metadata = (void __user *)(unsigned long)io.metadata;
+	metadata = (void __user *)(uintptr_t)io.metadata;
 	write = io.opcode & 1;
 	if (ns->ext) {
 	c.rw.metadata = cpu_to_le64(meta_dma);
 	status = __nvme_submit_sync_cmd(ns->queue, &c, NULL,
-			(void __user *)io.addr, length, NULL, 0);
+			(void __user *)(uintptr_t)io.addr, length, NULL, 0);
  unmap:
 	if (meta) {
 		if (status == NVME_SC_SUCCESS && !write) {
 		timeout = msecs_to_jiffies(cmd.timeout_ms);
 	status = __nvme_submit_sync_cmd(ns ? ns->queue : dev->admin_q, &c,
-			NULL, (void __user *)cmd.addr, cmd.data_len,
+			NULL, (void __user *)(uintptr_t)cmd.addr, cmd.data_len,
 			&cmd.result, timeout);
 	if (status >= 0) {
 		if (put_user(cmd.result, &ucmd->result))

drivers/block/rbd.c+47−32

 #define RBD_MINORS_PER_MAJOR		256
 #define RBD_SINGLE_MAJOR_PART_SHIFT	4
+#define RBD_MAX_PARENT_CHAIN_LEN	16
 #define RBD_SNAP_DEV_NAME_PREFIX	"snap_"
 #define RBD_MAX_SNAP_NAME_LEN	\
 			(NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
 				    size_t count);
 static ssize_t rbd_remove_single_major(struct bus_type *bus, const char *buf,
 				       size_t count);
-static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping);
+static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth);
 static void rbd_spec_put(struct rbd_spec *spec);
 static int rbd_dev_id_to_minor(int dev_id)
 		rbd_osd_read_callback(obj_request);
 		break;
 	case CEPH_OSD_OP_SETALLOCHINT:
-		rbd_assert(osd_req->r_ops[1].op == CEPH_OSD_OP_WRITE);
+		rbd_assert(osd_req->r_ops[1].op == CEPH_OSD_OP_WRITE ||
+			   osd_req->r_ops[1].op == CEPH_OSD_OP_WRITEFULL);
 		/* fall through */
 	case CEPH_OSD_OP_WRITE:
+	case CEPH_OSD_OP_WRITEFULL:
 		rbd_osd_write_callback(obj_request);
 		break;
 	case CEPH_OSD_OP_STAT:
 				opcode = CEPH_OSD_OP_ZERO;
 		}
 	} else if (op_type == OBJ_OP_WRITE) {
-		opcode = CEPH_OSD_OP_WRITE;
+		if (!offset && length == object_size)
+			opcode = CEPH_OSD_OP_WRITEFULL;
+		else
+			opcode = CEPH_OSD_OP_WRITE;
 		osd_req_op_alloc_hint_init(osd_request, num_ops,
 					object_size, object_size);
 		num_ops++;
 	/* set io sizes to object size */
 	segment_size = rbd_obj_bytes(&rbd_dev->header);
 	blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
+	q->limits.max_sectors = queue_max_hw_sectors(q);
 	blk_queue_max_segments(q, segment_size / SECTOR_SIZE);
 	blk_queue_max_segment_size(q, segment_size);
 	blk_queue_io_min(q, segment_size);
 	return ret;
 }
-static int rbd_dev_probe_parent(struct rbd_device *rbd_dev)
+/*
+ * @depth is rbd_dev_image_probe() -> rbd_dev_probe_parent() ->
+ * rbd_dev_image_probe() recursion depth, which means it's also the
+ * length of the already discovered part of the parent chain.
+ */
+static int rbd_dev_probe_parent(struct rbd_device *rbd_dev, int depth)
 {
 	struct rbd_device *parent = NULL;
-	struct rbd_spec *parent_spec;
-	struct rbd_client *rbdc;
 	int ret;
 	if (!rbd_dev->parent_spec)
 		return 0;
-	/*
-	 * We need to pass a reference to the client and the parent
-	 * spec when creating the parent rbd_dev.  Images related by
-	 * parent/child relationships always share both.
-	 */
-	parent_spec = rbd_spec_get(rbd_dev->parent_spec);
-	rbdc = __rbd_get_client(rbd_dev->rbd_client);
-	ret = -ENOMEM;
+	if (++depth > RBD_MAX_PARENT_CHAIN_LEN) {
-	parent = rbd_dev_create(rbdc, parent_spec, NULL);
+		pr_info("parent chain is too long (%d)\n", depth);
-	if (!parent)
+		ret = -EINVAL;
 		goto out_err;
+	}
-	ret = rbd_dev_image_probe(parent, false);
+	parent = rbd_dev_create(rbd_dev->rbd_client, rbd_dev->parent_spec,
+				NULL);
+	if (!parent) {
+		ret = -ENOMEM;
+		goto out_err;
+	}
+	/*
+	 * Images related by parent/child relationships always share
+	 * rbd_client and spec/parent_spec, so bump their refcounts.
+	 */
+	__rbd_get_client(rbd_dev->rbd_client);
+	rbd_spec_get(rbd_dev->parent_spec);
+	ret = rbd_dev_image_probe(parent, depth);
 	if (ret < 0)
 		goto out_err;
 	rbd_dev->parent = parent;
 	atomic_set(&rbd_dev->parent_ref, 1);
 	return 0;
 out_err:
-	if (parent) {
+	rbd_dev_unparent(rbd_dev);
-		rbd_dev_unparent(rbd_dev);
+	if (parent)
 		rbd_dev_destroy(parent);
-	} else {
-		rbd_put_client(rbdc);
-		rbd_spec_put(parent_spec);
-	}
 	return ret;
 }
  * parent), initiate a watch on its header object before using that
  * object to get detailed information about the rbd image.
  */
-static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
+static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth)
 {
 	int ret;
 	if (ret)
 		goto err_out_format;
-	if (mapping) {
+	if (!depth) {
 		ret = rbd_dev_header_watch_sync(rbd_dev);
 		if (ret) {
 			if (ret == -ENOENT)
 	 * Otherwise this is a parent image, identified by pool, image
 	 * and snap ids - need to fill in names for those ids.
 	 */
-	if (mapping)
+	if (!depth)
 		ret = rbd_spec_fill_snap_id(rbd_dev);
 	else
 		ret = rbd_spec_fill_names(rbd_dev);
 		 * Need to warn users if this image is the one being
 		 * mapped and has a parent.
 		 */
-		if (mapping && rbd_dev->parent_spec)
+		if (!depth && rbd_dev->parent_spec)
 			rbd_warn(rbd_dev,
 				 "WARNING: kernel layering is EXPERIMENTAL!");
 	}
-	ret = rbd_dev_probe_parent(rbd_dev);
+	ret = rbd_dev_probe_parent(rbd_dev, depth);
 	if (ret)
 		goto err_out_probe;
 err_out_probe:
 	rbd_dev_unprobe(rbd_dev);
 err_out_watch:
-	if (mapping)
+	if (!depth)
 		rbd_dev_header_unwatch_sync(rbd_dev);
 out_header_name:
 	kfree(rbd_dev->header_name);
 	spec = NULL;		/* rbd_dev now owns this */
 	rbd_opts = NULL;	/* rbd_dev now owns this */
-	rc = rbd_dev_image_probe(rbd_dev, true);
+	rc = rbd_dev_image_probe(rbd_dev, 0);
 	if (rc < 0)
 		goto err_out_rbd_dev;

drivers/block/xen-blkfront.c+2−1

 			break;
 		/* Missed the backend's Closing state -- fallthrough */
 	case XenbusStateClosing:
-		blkfront_closing(info);
+		if (info)
+			blkfront_closing(info);
 		break;
 	}
 }

drivers/bus/arm-ccn.c+3−2

 		if (!cpumask_test_and_clear_cpu(cpu, &dt->cpu))
 			break;
 		target = cpumask_any_but(cpu_online_mask, cpu);
-		if (target < 0)
+		if (target >= nr_cpu_ids)
 			break;
 		perf_pmu_migrate_context(&dt->pmu, cpu, target);
 		cpumask_set_cpu(target, &dt->cpu);
-		WARN_ON(irq_set_affinity(ccn->irq, &dt->cpu) != 0);
+		if (ccn->irq)
+			WARN_ON(irq_set_affinity(ccn->irq, &dt->cpu) != 0);
 	default:
 		break;
 	}

drivers/clk/mvebu/clk-cpu.c+3−1

 	for_each_node_by_type(dn, "cpu") {
 		struct clk_init_data init;
 		struct clk *clk;
+		struct clk *parent_clk;
 		char *clk_name = kzalloc(5, GFP_KERNEL);
 		int cpu, err;
 			goto bail_out;
 		sprintf(clk_name, "cpu%d", cpu);
+		parent_clk = of_clk_get(node, 0);
-		cpuclk[cpu].parent_name = of_clk_get_parent_name(node, 0);
+		cpuclk[cpu].parent_name = __clk_get_name(parent_clk);
 		cpuclk[cpu].clk_name = clk_name;
 		cpuclk[cpu].cpu = cpu;
 		cpuclk[cpu].reg_base = clock_complex_base;

drivers/cpufreq/intel_pstate.c+5−0

 	local_irq_save(flags);
 	rdmsrl(MSR_IA32_APERF, aperf);
 	rdmsrl(MSR_IA32_MPERF, mperf);
+	if (cpu->prev_mperf == mperf) {
+		local_irq_restore(flags);
+		return;
+	}
 	tsc = rdtsc();
 	local_irq_restore(flags);

drivers/gpu/drm/amd/amdgpu/amdgpu_atombios.c+6−2

 		/* disp clock */
 		adev->clock.default_dispclk =
 			le32_to_cpu(firmware_info->info_21.ulDefaultDispEngineClkFreq);
-		if (adev->clock.default_dispclk == 0)
+		/* set a reasonable default for DP */
-			adev->clock.default_dispclk = 54000; /* 540 Mhz */
+		if (adev->clock.default_dispclk < 53900) {
+			DRM_INFO("Changing default dispclk from %dMhz to 600Mhz\n",
+				 adev->clock.default_dispclk / 100);
+			adev->clock.default_dispclk = 60000;
+		}
 		adev->clock.dp_extclk =
 			le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);
 		adev->clock.current_dispclk = adev->clock.default_dispclk;

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c+3−3

@@ -177,7 +177,7 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data) · 176 unmodified lines
177		177
178	/* get chunks */	178	/* get chunks */
179	INIT_LIST_HEAD(&p->validated);	179	INIT_LIST_HEAD(&p->validated);
180	chunk_array_user = (uint64_t __user *)(cs->in.chunks);	180	chunk_array_user = (uint64_t __user *)(unsigned long)(cs->in.chunks);
181	if (copy_from_user(chunk_array, chunk_array_user,	181	if (copy_from_user(chunk_array, chunk_array_user,
182	sizeof(uint64_t)*cs->in.num_chunks)) {	182	sizeof(uint64_t)*cs->in.num_chunks)) {
183	ret = -EFAULT;	183	ret = -EFAULT;
@@ -197,7 +197,7 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data) · 13 unmodified lines
197	struct drm_amdgpu_cs_chunk user_chunk;	197	struct drm_amdgpu_cs_chunk user_chunk;
198	uint32_t __user *cdata;	198	uint32_t __user *cdata;
199		199
200	chunk_ptr = (void __user *)chunk_array[i];	200	chunk_ptr = (void __user *)(unsigned long)chunk_array[i];
201	if (copy_from_user(&user_chunk, chunk_ptr,	201	if (copy_from_user(&user_chunk, chunk_ptr,
202	sizeof(struct drm_amdgpu_cs_chunk))) {	202	sizeof(struct drm_amdgpu_cs_chunk))) {
203	ret = -EFAULT;	203	ret = -EFAULT;
@@ -208,7 +208,7 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data) · 4 unmodified lines
208	p->chunks[i].length_dw = user_chunk.length_dw;	208	p->chunks[i].length_dw = user_chunk.length_dw;
209		209
210	size = p->chunks[i].length_dw;	210	size = p->chunks[i].length_dw;
211	cdata = (void __user *)user_chunk.chunk_data;	211	cdata = (void __user *)(unsigned long)user_chunk.chunk_data;
212	p->chunks[i].user_ptr = cdata;	212	p->chunks[i].user_ptr = cdata;
213		213
214	p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));	214	p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));

drivers/gpu/drm/amd/amdgpu/amdgpu_display.c+0−2

@@ -85,8 +85,6 @@ static void amdgpu_flip_work_func(struct work_struct *__work) · 84 unmodified lines
85	/* We borrow the event spin lock for protecting flip_status */	85	/* We borrow the event spin lock for protecting flip_status */
86	spin_lock_irqsave(&crtc->dev->event_lock, flags);	86	spin_lock_irqsave(&crtc->dev->event_lock, flags);
87		87
88	/* set the proper interrupt */
89	amdgpu_irq_get(adev, &adev->pageflip_irq, work->crtc_id);
90	/* do the flip (mmio) */	88	/* do the flip (mmio) */
91	adev->mode_info.funcs->page_flip(adev, work->crtc_id, work->base);	89	adev->mode_info.funcs->page_flip(adev, work->crtc_id, work->base);
92	/* set the flip status */	90	/* set the flip status */

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+5−5

@@ -242,11 +242,11 @@ static struct pci_device_id pciidlist[] = { · 241 unmodified lines
242	{0x1002, 0x985F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_MULLINS\|AMD_IS_MOBILITY\|AMD_IS_APU},	242	{0x1002, 0x985F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_MULLINS\|AMD_IS_MOBILITY\|AMD_IS_APU},
243	#endif	243	#endif
244	/* topaz */	244	/* topaz */
245	{0x1002, 0x6900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ},	245	{0x1002, 0x6900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ\|AMD_EXP_HW_SUPPORT},
246	{0x1002, 0x6901, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ},	246	{0x1002, 0x6901, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ\|AMD_EXP_HW_SUPPORT},
247	{0x1002, 0x6902, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ},	247	{0x1002, 0x6902, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ\|AMD_EXP_HW_SUPPORT},
248	{0x1002, 0x6903, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ},	248	{0x1002, 0x6903, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ\|AMD_EXP_HW_SUPPORT},
249	{0x1002, 0x6907, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ},	249	{0x1002, 0x6907, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TOPAZ\|AMD_EXP_HW_SUPPORT},
250	/* tonga */	250	/* tonga */
251	{0x1002, 0x6920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TONGA},	251	{0x1002, 0x6920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TONGA},
252	{0x1002, 0x6921, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TONGA},	252	{0x1002, 0x6921, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TONGA},

drivers/gpu/drm/amd/amdgpu/amdgpu_fb.c+16−0

@@ -402,3 +402,19 @@ bool amdgpu_fbdev_robj_is_fb(struct amdgpu_device adev, struct amdgpu_bo robj) · 401 unmodified lines
402	return true;	402	return true;
403	return false;	403	return false;
404	}	404	}
		405
		406	void amdgpu_fbdev_restore_mode(struct amdgpu_device *adev)
		407	{
		408	struct amdgpu_fbdev *afbdev = adev->mode_info.rfbdev;
		409	struct drm_fb_helper *fb_helper;
		410	int ret;
		411
		412	if (!afbdev)
		413	return;
		414
		415	fb_helper = &afbdev->helper;
		416
		417	ret = drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
		418	if (ret)
		419	DRM_DEBUG("failed to restore crtc mode\n");
		420	}

drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c+4−1

  * Outdated mess for old drm with Xorg being in charge (void function now).
  */
 /**
- * amdgpu_driver_firstopen_kms - drm callback for last close
+ * amdgpu_driver_lastclose_kms - drm callback for last close
  *
  * @dev: drm dev pointer
  *
  */
 void amdgpu_driver_lastclose_kms(struct drm_device *dev)
 {
+	struct amdgpu_device *adev = dev->dev_private;
+	amdgpu_fbdev_restore_mode(adev);
 	vga_switcheroo_process_delayed_switch();
 }

drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h+1−0

@@ -567,6 +567,7 @@ void amdgpu_fbdev_fini(struct amdgpu_device *adev); · 566 unmodified lines
567	void amdgpu_fbdev_set_suspend(struct amdgpu_device *adev, int state);	567	void amdgpu_fbdev_set_suspend(struct amdgpu_device *adev, int state);
568	int amdgpu_fbdev_total_size(struct amdgpu_device *adev);	568	int amdgpu_fbdev_total_size(struct amdgpu_device *adev);
569	bool amdgpu_fbdev_robj_is_fb(struct amdgpu_device adev, struct amdgpu_bo robj);	569	bool amdgpu_fbdev_robj_is_fb(struct amdgpu_device adev, struct amdgpu_bo robj);
		570	void amdgpu_fbdev_restore_mode(struct amdgpu_device *adev);
570		571
571	void amdgpu_fb_output_poll_changed(struct amdgpu_device *adev);	572	void amdgpu_fb_output_poll_changed(struct amdgpu_device *adev);
572		573

drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c+6−2

 	struct amdgpu_device *adev = dev_get_drvdata(dev);
 	umode_t effective_mode = attr->mode;
-	/* Skip limit attributes if DPM is not enabled */
+	/* Skip attributes if DPM is not enabled */
 	if (!adev->pm.dpm_enabled &&
 	    (attr == &sensor_dev_attr_temp1_crit.dev_attr.attr ||
-	     attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr))
+	     attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
 		return 0;
 	/* Skip fan attributes if fan is not present */

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c+3−1

 		return -ENOMEM;
 	r = amdgpu_ib_get(ring, NULL, ndw * 4, ib);
-	if (r)
+	if (r) {
+		kfree(ib);
 		return r;
+	}
 	ib->length_dw = 0;
 	/* walk over the address space and update the page directory */

drivers/gpu/drm/amd/amdgpu/ci_dpm.c+5−3

 	if (!amdgpu_dpm)
 		return 0;
+	/* init the sysfs and debugfs files late */
+	ret = amdgpu_pm_sysfs_init(adev);
+	if (ret)
+		return ret;
 	ret = ci_set_temperature_range(adev);
 	if (ret)
 		return ret;
 	adev->pm.dpm.current_ps = adev->pm.dpm.requested_ps = adev->pm.dpm.boot_ps;
 	if (amdgpu_dpm == 1)
 		amdgpu_pm_print_power_states(adev);
-	ret = amdgpu_pm_sysfs_init(adev);
-	if (ret)
-		goto dpm_failed;
 	mutex_unlock(&adev->pm.mutex);
 	DRM_INFO("amdgpu: dpm initialized\n");

drivers/gpu/drm/amd/amdgpu/cik.c+3−0

@@ -1567,6 +1567,9 @@ static void cik_pcie_gen3_enable(struct amdgpu_device *adev) · 1566 unmodified lines
1567	int ret, i;	1567	int ret, i;
1568	u16 tmp16;	1568	u16 tmp16;
1569		1569
		1570	if (pci_is_root_bus(adev->pdev->bus))
		1571	return;
		1572
1570	if (amdgpu_pcie_gen2 == 0)	1573	if (amdgpu_pcie_gen2 == 0)
1571	return;	1574	return;
1572		1575

drivers/gpu/drm/amd/amdgpu/cz_dpm.c+6−4

 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 	if (amdgpu_dpm) {
+		int ret;
+		/* init the sysfs and debugfs files late */
+		ret = amdgpu_pm_sysfs_init(adev);
+		if (ret)
+			return ret;
 		/* powerdown unused blocks for now */
 		cz_dpm_powergate_uvd(adev, true);
 		cz_dpm_powergate_vce(adev, true);
 	if (amdgpu_dpm == 1)
 		amdgpu_pm_print_power_states(adev);
-	ret = amdgpu_pm_sysfs_init(adev);
-	if (ret)
-		goto dpm_init_failed;
 	mutex_unlock(&adev->pm.mutex);
 	DRM_INFO("amdgpu: dpm initialized\n");

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

 		return RREG32(mmCRTC_STATUS_FRAME_COUNT + crtc_offsets[crtc]);
 }
+static void dce_v10_0_pageflip_interrupt_init(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Enable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_get(adev, &adev->pageflip_irq, i);
+}
+static void dce_v10_0_pageflip_interrupt_fini(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Disable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_put(adev, &adev->pageflip_irq, i);
+}
 /**
  * dce_v10_0_page_flip - pageflip callback.
  *
 		dce_v10_0_vga_enable(crtc, true);
 		amdgpu_atombios_crtc_blank(crtc, ATOM_DISABLE);
 		dce_v10_0_vga_enable(crtc, false);
-		/* Make sure VBLANK interrupt is still enabled */
+		/* Make sure VBLANK and PFLIP interrupts are still enabled */
 		type = amdgpu_crtc_idx_to_irq_type(adev, amdgpu_crtc->crtc_id);
 		amdgpu_irq_update(adev, &adev->crtc_irq, type);
+		amdgpu_irq_update(adev, &adev->pageflip_irq, type);
 		drm_vblank_post_modeset(dev, amdgpu_crtc->crtc_id);
 		dce_v10_0_crtc_load_lut(crtc);
 		break;
 		dce_v10_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v10_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 		dce_v10_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v10_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	dce_v10_0_hpd_fini(adev);
+	dce_v10_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	/* initialize hpd */
 	dce_v10_0_hpd_init(adev);
+	dce_v10_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 	spin_unlock_irqrestore(&adev->ddev->event_lock, flags);
 	drm_vblank_put(adev->ddev, amdgpu_crtc->crtc_id);
-	amdgpu_irq_put(adev, &adev->pageflip_irq, crtc_id);
 	queue_work(amdgpu_crtc->pflip_queue, &works->unpin_work);
 	return 0;

drivers/gpu/drm/amd/amdgpu/dce_v11_0.c+29−3

 		return RREG32(mmCRTC_STATUS_FRAME_COUNT + crtc_offsets[crtc]);
 }
+static void dce_v11_0_pageflip_interrupt_init(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Enable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_get(adev, &adev->pageflip_irq, i);
+}
+static void dce_v11_0_pageflip_interrupt_fini(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Disable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_put(adev, &adev->pageflip_irq, i);
+}
 /**
  * dce_v11_0_page_flip - pageflip callback.
  *
 		dce_v11_0_vga_enable(crtc, true);
 		amdgpu_atombios_crtc_blank(crtc, ATOM_DISABLE);
 		dce_v11_0_vga_enable(crtc, false);
-		/* Make sure VBLANK interrupt is still enabled */
+		/* Make sure VBLANK and PFLIP interrupts are still enabled */
 		type = amdgpu_crtc_idx_to_irq_type(adev, amdgpu_crtc->crtc_id);
 		amdgpu_irq_update(adev, &adev->crtc_irq, type);
+		amdgpu_irq_update(adev, &adev->pageflip_irq, type);
 		drm_vblank_post_modeset(dev, amdgpu_crtc->crtc_id);
 		dce_v11_0_crtc_load_lut(crtc);
 		break;
 	switch (adev->asic_type) {
 	case CHIP_CARRIZO:
-		adev->mode_info.num_crtc = 4;
+		adev->mode_info.num_crtc = 3;
 		adev->mode_info.num_hpd = 6;
 		adev->mode_info.num_dig = 9;
 		break;
 		dce_v11_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v11_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 		dce_v11_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v11_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	dce_v11_0_hpd_fini(adev);
+	dce_v11_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	/* initialize hpd */
 	dce_v11_0_hpd_init(adev);
+	dce_v11_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 	spin_unlock_irqrestore(&adev->ddev->event_lock, flags);
 	drm_vblank_put(adev->ddev, amdgpu_crtc->crtc_id);
-	amdgpu_irq_put(adev, &adev->pageflip_irq, crtc_id);
 	queue_work(amdgpu_crtc->pflip_queue, &works->unpin_work);
 	return 0;

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

 		return RREG32(mmCRTC_STATUS_FRAME_COUNT + crtc_offsets[crtc]);
 }
+static void dce_v8_0_pageflip_interrupt_init(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Enable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_get(adev, &adev->pageflip_irq, i);
+}
+static void dce_v8_0_pageflip_interrupt_fini(struct amdgpu_device *adev)
+{
+	unsigned i;
+	/* Disable pflip interrupts */
+	for (i = 0; i < adev->mode_info.num_crtc; i++)
+		amdgpu_irq_put(adev, &adev->pageflip_irq, i);
+}
 /**
  * dce_v8_0_page_flip - pageflip callback.
  *
 		dce_v8_0_vga_enable(crtc, true);
 		amdgpu_atombios_crtc_blank(crtc, ATOM_DISABLE);
 		dce_v8_0_vga_enable(crtc, false);
-		/* Make sure VBLANK interrupt is still enabled */
+		/* Make sure VBLANK and PFLIP interrupts are still enabled */
 		type = amdgpu_crtc_idx_to_irq_type(adev, amdgpu_crtc->crtc_id);
 		amdgpu_irq_update(adev, &adev->crtc_irq, type);
+		amdgpu_irq_update(adev, &adev->pageflip_irq, type);
 		drm_vblank_post_modeset(dev, amdgpu_crtc->crtc_id);
 		dce_v8_0_crtc_load_lut(crtc);
 		break;
 		dce_v8_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v8_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 		dce_v8_0_audio_enable(adev, &adev->mode_info.audio.pin[i], false);
 	}
+	dce_v8_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	dce_v8_0_hpd_fini(adev);
+	dce_v8_0_pageflip_interrupt_fini(adev);
 	return 0;
 }
 	/* initialize hpd */
 	dce_v8_0_hpd_init(adev);
+	dce_v8_0_pageflip_interrupt_init(adev);
 	return 0;
 }
 	spin_unlock_irqrestore(&adev->ddev->event_lock, flags);
 	drm_vblank_put(adev->ddev, amdgpu_crtc->crtc_id);
-	amdgpu_irq_put(adev, &adev->pageflip_irq, crtc_id);
 	queue_work(amdgpu_crtc->pflip_queue, &works->unpin_work);
 	return 0;

drivers/gpu/drm/amd/amdgpu/kv_dpm.c+9−3

 {
 	/* powerdown unused blocks for now */
 	struct amdgpu_device *adev = (struct amdgpu_device *)handle;
+	int ret;
+	if (!amdgpu_dpm)
+		return 0;
+	/* init the sysfs and debugfs files late */
+	ret = amdgpu_pm_sysfs_init(adev);
+	if (ret)
+		return ret;
 	kv_dpm_powergate_acp(adev, true);
 	kv_dpm_powergate_samu(adev, true);
 	adev->pm.dpm.current_ps = adev->pm.dpm.requested_ps = adev->pm.dpm.boot_ps;
 	if (amdgpu_dpm == 1)
 		amdgpu_pm_print_power_states(adev);
-	ret = amdgpu_pm_sysfs_init(adev);
-	if (ret)
-		goto dpm_failed;
 	mutex_unlock(&adev->pm.mutex);
 	DRM_INFO("amdgpu: dpm initialized\n");

drivers/gpu/drm/amd/amdgpu/vi.c+3−0

@@ -1005,6 +1005,9 @@ static void vi_pcie_gen3_enable(struct amdgpu_device *adev) · 1004 unmodified lines
1005	u32 mask;	1005	u32 mask;
1006	int ret;	1006	int ret;
1007		1007
		1008	if (pci_is_root_bus(adev->pdev->bus))
		1009	return;
		1010
1008	if (amdgpu_pcie_gen2 == 0)	1011	if (amdgpu_pcie_gen2 == 0)
1009	return;	1012	return;
1010		1013

drivers/gpu/drm/drm_dp_mst_topology.c+6−4

 		list_for_each_entry(port, &mstb->ports, next) {
 			if (port->port_num == port_num) {
-				if (!port->mstb) {
+				mstb = port->mstb;
+				if (!mstb) {
 					DRM_ERROR("failed to lookup MSTB with lct %d, rad %02x\n", lct, rad[0]);
-					return NULL;
+					goto out;
 				}
-				mstb = port->mstb;
 				break;
 			}
 		}
 	}
 	kref_get(&mstb->kref);
+out:
 	mutex_unlock(&mgr->lock);
 	return mstb;
 }
 	if (msgs[num - 1].flags & I2C_M_RD)
 		reading = true;
-	if (!reading) {
+	if (!reading || (num - 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS)) {
 		DRM_DEBUG_KMS("Unsupported I2C transaction for MST device\n");
 		ret = -EIO;
 		goto out;
 	}
+	memset(&msg, 0, sizeof(msg));
 	msg.req_type = DP_REMOTE_I2C_READ;
 	msg.u.i2c_read.num_transactions = num - 1;
 	msg.u.i2c_read.port_number = port->port_num;

drivers/gpu/drm/drm_sysfs.c+3−9

 			   char *buf)
 {
 	struct drm_connector *connector = to_drm_connector(device);
-	struct drm_device *dev = connector->dev;
+	int dpms;
-	uint64_t dpms_status;
-	int ret;
-	ret = drm_object_property_get_value(&connector->base,
+	dpms = READ_ONCE(connector->dpms);
-					    dev->mode_config.dpms_property,
-					    &dpms_status);
-	if (ret)
-		return 0;
 	return snprintf(buf, PAGE_SIZE, "%s\n",
-			drm_get_dpms_name((int)dpms_status));
+			drm_get_dpms_name(dpms));
 }
 static ssize_t enabled_show(struct device *device,

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

@@ -143,7 +143,7 @@ i915_gem_shrink(struct drm_i915_private *dev_priv, · 142 unmodified lines
143	}	143	}
144		144
145	/**	145	/**
146	* i915_gem_shrink - Shrink buffer object caches completely	146	* i915_gem_shrink_all - Shrink buffer object caches completely
147	* @dev_priv: i915 device	147	* @dev_priv: i915 device
148	*	148	*
149	* This is a simple wraper around i915_gem_shrink() to aggressively shrink all	149	* This is a simple wraper around i915_gem_shrink() to aggressively shrink all

drivers/gpu/drm/i915/i915_gem_userptr.c+4−1

  * Also note, that the object created here is not currently a "first class"
  * object, in that several ioctls are banned. These are the CPU access
  * ioctls: mmap(), pwrite and pread. In practice, you are expected to use
- * direct access via your pointer rather than use those ioctls.
+ * direct access via your pointer rather than use those ioctls. Another
+ * restriction is that we do not allow userptr surfaces to be pinned to the
+ * hardware and so we reject any attempt to create a framebuffer out of a
+ * userptr.
  *
  * If you think this is a good interface to use to pass GPU memory between
  * drivers, please use dma-buf instead. In fact, wherever possible use

drivers/gpu/drm/i915/intel_display.c+67−53

 			   I915_READ(DPLL(!crtc->pipe)) | DPLL_DVO_2X_MODE);
 	}
+	/*
+	 * Apparently we need to have VGA mode enabled prior to changing
+	 * the P1/P2 dividers. Otherwise the DPLL will keep using the old
+	 * dividers, even though the register value does change.
+	 */
+	I915_WRITE(reg, 0);
+	I915_WRITE(reg, dpll);
 	/* Wait for the clocks to stabilize. */
 	POSTING_READ(reg);
 	udelay(150);
 	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
 	struct drm_i915_gem_object *obj = intel_fb->obj;
+	if (obj->userptr.mm) {
+		DRM_DEBUG("attempting to use a userptr for a framebuffer, denied\n");
+		return -EINVAL;
+	}
 	return drm_gem_handle_create(file, &obj->base, handle);
 }
 	/* restore vblank interrupts to correct state */
 	drm_crtc_vblank_reset(&crtc->base);
 	if (crtc->active) {
+		struct intel_plane *plane;
 		drm_calc_timestamping_constants(&crtc->base, &crtc->base.hwmode);
 		update_scanline_offset(crtc);
 		drm_crtc_vblank_on(&crtc->base);
+		/* Disable everything but the primary plane */
+		for_each_intel_plane_on_crtc(dev, crtc, plane) {
+			if (plane->base.type == DRM_PLANE_TYPE_PRIMARY)
+				continue;
+			plane->disable_plane(&plane->base, &crtc->base);
+		}
 	}
 	/* We need to sanitize the plane -> pipe mapping first because this will
 	i915_redisable_vga_power_on(dev);
 }
-static bool primary_get_hw_state(struct intel_crtc *crtc)
+static bool primary_get_hw_state(struct intel_plane *plane)
 {
-	struct drm_i915_private *dev_priv = crtc->base.dev->dev_private;
+	struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
-	return !!(I915_READ(DSPCNTR(crtc->plane)) & DISPLAY_PLANE_ENABLE);
+	return I915_READ(DSPCNTR(plane->plane)) & DISPLAY_PLANE_ENABLE;
 }
-static void readout_plane_state(struct intel_crtc *crtc,
+/* FIXME read out full plane state for all planes */
-				struct intel_crtc_state *crtc_state)
+static void readout_plane_state(struct intel_crtc *crtc)
 {
-	struct intel_plane *p;
+	struct drm_plane *primary = crtc->base.primary;
-	struct intel_plane_state *plane_state;
+	struct intel_plane_state *plane_state =
-	bool active = crtc_state->base.active;
+		to_intel_plane_state(primary->state);
-	for_each_intel_plane(crtc->base.dev, p) {
-		if (crtc->pipe != p->pipe)
-			continue;
-		plane_state = to_intel_plane_state(p->base.state);
-		if (p->base.type == DRM_PLANE_TYPE_PRIMARY) {
+	plane_state->visible =
-			plane_state->visible = primary_get_hw_state(crtc);
+		primary_get_hw_state(to_intel_plane(primary));
-			if (plane_state->visible)
-				crtc->base.state->plane_mask |=
-					1 << drm_plane_index(&p->base);
-		} else {
-			if (active)
-				p->disable_plane(&p->base, &crtc->base);
-			plane_state->visible = false;
+	if (plane_state->visible)
-		}
+		crtc->base.state->plane_mask |= 1 << drm_plane_index(primary);
-	}
 }
 static void intel_modeset_readout_hw_state(struct drm_device *dev)
 		crtc->base.state->active = crtc->active;
 		crtc->base.enabled = crtc->active;
-		memset(&crtc->base.mode, 0, sizeof(crtc->base.mode));
+		readout_plane_state(crtc);
-		if (crtc->base.state->active) {
-			intel_mode_from_pipe_config(&crtc->base.mode, crtc->config);
-			intel_mode_from_pipe_config(&crtc->base.state->adjusted_mode, crtc->config);
-			WARN_ON(drm_atomic_set_mode_for_crtc(crtc->base.state, &crtc->base.mode));
-			/*
-			 * The initial mode needs to be set in order to keep
-			 * the atomic core happy. It wants a valid mode if the
-			 * crtc's enabled, so we do the above call.
-			 *
-			 * At this point some state updated by the connectors
-			 * in their ->detect() callback has not run yet, so
-			 * no recalculation can be done yet.
-			 *
-			 * Even if we could do a recalculation and modeset
-			 * right now it would cause a double modeset if
-			 * fbdev or userspace chooses a different initial mode.
-			 *
-			 * If that happens, someone indicated they wanted a
-			 * mode change, which means it's safe to do a full
-			 * recalculation.
-			 */
-			crtc->base.state->mode.private_flags = I915_MODE_FLAG_INHERITED;
-		}
-		crtc->base.hwmode = crtc->config->base.adjusted_mode;
-		readout_plane_state(crtc, to_intel_crtc_state(crtc->base.state));
 		DRM_DEBUG_KMS("[CRTC:%d] hw state readout: %s\n",
 			      crtc->base.base.id,
 			      connector->base.name,
 			      connector->base.encoder ? "enabled" : "disabled");
 	}
+	for_each_intel_crtc(dev, crtc) {
+		crtc->base.hwmode = crtc->config->base.adjusted_mode;
+		memset(&crtc->base.mode, 0, sizeof(crtc->base.mode));
+		if (crtc->base.state->active) {
+			intel_mode_from_pipe_config(&crtc->base.mode, crtc->config);
+			intel_mode_from_pipe_config(&crtc->base.state->adjusted_mode, crtc->config);
+			WARN_ON(drm_atomic_set_mode_for_crtc(crtc->base.state, &crtc->base.mode));
+			/*
+			 * The initial mode needs to be set in order to keep
+			 * the atomic core happy. It wants a valid mode if the
+			 * crtc's enabled, so we do the above call.
+			 *
+			 * At this point some state updated by the connectors
+			 * in their ->detect() callback has not run yet, so
+			 * no recalculation can be done yet.
+			 *
+			 * Even if we could do a recalculation and modeset
+			 * right now it would cause a double modeset if
+			 * fbdev or userspace chooses a different initial mode.
+			 *
+			 * If that happens, someone indicated they wanted a
+			 * mode change, which means it's safe to do a full
+			 * recalculation.
+			 */
+			crtc->base.state->mode.private_flags = I915_MODE_FLAG_INHERITED;
+		}
+	}
 }
 /* Scan out the current hw modeset state,

drivers/gpu/drm/i915/intel_lrc.c+1−0

@@ -1659,6 +1659,7 @@ static int gen8_emit_flush_render(struct drm_i915_gem_request *request, · 1658 unmodified lines
1659	if (flush_domains) {	1659	if (flush_domains) {
1660	flags \|= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;	1660	flags \|= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
1661	flags \|= PIPE_CONTROL_DEPTH_CACHE_FLUSH;	1661	flags \|= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
		1662	flags \|= PIPE_CONTROL_FLUSH_ENABLE;
1662	}	1663	}
1663		1664
1664	if (invalidate_domains) {	1665	if (invalidate_domains) {

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

 	if (flush_domains) {
 		flags |= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
 		flags |= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
+		flags |= PIPE_CONTROL_FLUSH_ENABLE;
 	}
 	if (invalidate_domains) {
 		flags |= PIPE_CONTROL_TLB_INVALIDATE;
 	if (flush_domains) {
 		flags |= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
 		flags |= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
+		flags |= PIPE_CONTROL_FLUSH_ENABLE;
 	}
 	if (invalidate_domains) {
 		flags |= PIPE_CONTROL_TLB_INVALIDATE;

drivers/gpu/drm/nouveau/nouveau_display.c+5−1

 	if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
 		dev->mode_config.max_width = 4096;
 		dev->mode_config.max_height = 4096;
-	} else {
+	} else
+	if (drm->device.info.family < NV_DEVICE_INFO_V0_FERMI) {
 		dev->mode_config.max_width = 8192;
 		dev->mode_config.max_height = 8192;
+	} else {
+		dev->mode_config.max_width = 16384;
+		dev->mode_config.max_height = 16384;
 	}
 	dev->mode_config.preferred_depth = 24;

drivers/gpu/drm/nouveau/nouveau_fbcon.c+24−0

@@ -178,8 +178,30 @@ nouveau_fbcon_sync(struct fb_info *info) · 177 unmodified lines
178	return 0;	178	return 0;
179	}	179	}
180		180
		181	static int
		182	nouveau_fbcon_open(struct fb_info *info, int user)
		183	{
		184	struct nouveau_fbdev *fbcon = info->par;
		185	struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
		186	int ret = pm_runtime_get_sync(drm->dev->dev);
		187	if (ret < 0 && ret != -EACCES)
		188	return ret;
		189	return 0;
		190	}
		191
		192	static int
		193	nouveau_fbcon_release(struct fb_info *info, int user)
		194	{
		195	struct nouveau_fbdev *fbcon = info->par;
		196	struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
		197	pm_runtime_put(drm->dev->dev);
		198	return 0;
		199	}
		200
181	static struct fb_ops nouveau_fbcon_ops = {	201	static struct fb_ops nouveau_fbcon_ops = {
182	.owner = THIS_MODULE,	202	.owner = THIS_MODULE,
		203	.fb_open = nouveau_fbcon_open,
		204	.fb_release = nouveau_fbcon_release,
183	.fb_check_var = drm_fb_helper_check_var,	205	.fb_check_var = drm_fb_helper_check_var,
184	.fb_set_par = drm_fb_helper_set_par,	206	.fb_set_par = drm_fb_helper_set_par,
185	.fb_fillrect = nouveau_fbcon_fillrect,	207	.fb_fillrect = nouveau_fbcon_fillrect,
@@ -195,6 +217,8 @@ static struct fb_ops nouveau_fbcon_ops = { · 9 unmodified lines
195		217
196	static struct fb_ops nouveau_fbcon_sw_ops = {	218	static struct fb_ops nouveau_fbcon_sw_ops = {
197	.owner = THIS_MODULE,	219	.owner = THIS_MODULE,
		220	.fb_open = nouveau_fbcon_open,
		221	.fb_release = nouveau_fbcon_release,
198	.fb_check_var = drm_fb_helper_check_var,	222	.fb_check_var = drm_fb_helper_check_var,
199	.fb_set_par = drm_fb_helper_set_par,	223	.fb_set_par = drm_fb_helper_set_par,
200	.fb_fillrect = drm_fb_helper_cfb_fillrect,	224	.fb_fillrect = drm_fb_helper_cfb_fillrect,

drivers/gpu/drm/nouveau/nouveau_gem.c+3−2

 	struct nouveau_bo *nvbo = nouveau_gem_object(gem);
 	struct nvkm_vma *vma;
-	if (nvbo->bo.mem.mem_type == TTM_PL_TT)
+	if (is_power_of_2(nvbo->valid_domains))
+		rep->domain = nvbo->valid_domains;
+	else if (nvbo->bo.mem.mem_type == TTM_PL_TT)
 		rep->domain = NOUVEAU_GEM_DOMAIN_GART;
 	else
 		rep->domain = NOUVEAU_GEM_DOMAIN_VRAM;
 	rep->offset = nvbo->bo.offset;
 	if (cli->vm) {
 		vma = nouveau_bo_vma_find(nvbo, cli->vm);

drivers/gpu/drm/nouveau/nvkm/subdev/bios/init.c+6−0

 		index = NVKM_I2C_BUS_PRI;
 		if (init->outp && init->outp->i2c_upper_default)
 			index = NVKM_I2C_BUS_SEC;
+	} else
+	if (index == 0x80) {
+		index = NVKM_I2C_BUS_PRI;
+	} else
+	if (index == 0x81) {
+		index = NVKM_I2C_BUS_SEC;
 	}
 	bus = nvkm_i2c_bus_find(i2c, index);

drivers/gpu/drm/nouveau/nvkm/subdev/bios/priv.h+3−0

 	void *(*init)(struct nvkm_bios *, const char *);
 	void  (*fini)(void *);
 	u32   (*read)(void *, u32 offset, u32 length, struct nvkm_bios *);
+	u32   (*size)(void *);
 	bool rw;
+	bool ignore_checksum;
+	bool no_pcir;
 };
 int nvbios_extend(struct nvkm_bios *, u32 length);

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c+18−9

 		u32 read = mthd->func->read(data, start, limit - start, bios);
 		bios->size = start + read;
 	}
-	return bios->size >= limit;
+	return bios->size >= upto;
 }
 static int
 	struct nvbios_image image;
 	int score = 1;
-	if (!shadow_fetch(bios, mthd, offset + 0x1000)) {
+	if (mthd->func->no_pcir) {
-		nvkm_debug(subdev, "%08x: header fetch failed\n", offset);
+		image.base = 0;
-		return 0;
+		image.type = 0;
-	}
+		image.size = mthd->func->size(mthd->data);
+		image.last = 1;
+	} else {
+		if (!shadow_fetch(bios, mthd, offset + 0x1000)) {
+			nvkm_debug(subdev, "%08x: header fetch failed\n",
+				   offset);
+			return 0;
+		}
-	if (!nvbios_image(bios, idx, &image)) {
+		if (!nvbios_image(bios, idx, &image)) {
-		nvkm_debug(subdev, "image %d invalid\n", idx);
+			nvkm_debug(subdev, "image %d invalid\n", idx);
-		return 0;
+			return 0;
+		}
 	}
 	nvkm_debug(subdev, "%08x: type %02x, %d bytes\n",
 		   image.base, image.type, image.size);
 	switch (image.type) {
 	case 0x00:
-		if (nvbios_checksum(&bios->data[image.base], image.size)) {
+		if (!mthd->func->ignore_checksum &&
+		    nvbios_checksum(&bios->data[image.base], image.size)) {
 			nvkm_debug(subdev, "%08x: checksum failed\n",
 				   image.base);
 			if (mthd->func->rw)

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowof.c+15−2

  *
  */
 #include "priv.h"
 #include <core/pci.h>
 #if defined(__powerpc__)
 of_read(void *data, u32 offset, u32 length, struct nvkm_bios *bios)
 {
 	struct priv *priv = data;
-	if (offset + length <= priv->size) {
+	if (offset < priv->size) {
+		length = min_t(u32, length, priv->size - offset);
 		memcpy_fromio(bios->data + offset, priv->data + offset, length);
 		return length;
 	}
 	return 0;
 }
+static u32
+of_size(void *data)
+{
+	struct priv *priv = data;
+	return priv->size;
+}
 static void *
 of_init(struct nvkm_bios *bios, const char *name)
 {
-	struct pci_dev *pdev = bios->subdev.device->func->pci(bios->subdev.device)->pdev;
+	struct nvkm_device *device = bios->subdev.device;
+	struct pci_dev *pdev = device->func->pci(device)->pdev;
 	struct device_node *dn;
 	struct priv *priv;
 	if (!(dn = pci_device_to_OF_node(pdev)))
 	.init = of_init,
 	.fini = (void(*)(void *))kfree,
 	.read = of_read,
+	.size = of_size,
 	.rw = false,
+	.ignore_checksum = true,
+	.no_pcir = true,
 };
 #else
 const struct nvbios_source

drivers/gpu/drm/nouveau/nvkm/subdev/pci/agp.c+6−2

 nvkm_device_agp_quirks[] = {
 	/* VIA Apollo PRO133x / GeForce FX 5600 Ultra - fdo#20341 */
 	{ PCI_VENDOR_ID_VIA, 0x0691, PCI_VENDOR_ID_NVIDIA, 0x0311, 2 },
+	/* SiS 761 does not support AGP cards, use PCI mode */
+	{ PCI_VENDOR_ID_SI, 0x0761, PCI_ANY_ID, PCI_ANY_ID, 0 },
 	{},
 };
 	while (quirk->hostbridge_vendor) {
 		if (info.device->vendor == quirk->hostbridge_vendor &&
 		    info.device->device == quirk->hostbridge_device &&
-		    pci->pdev->vendor == quirk->chip_vendor &&
+		    (quirk->chip_vendor == (u16)PCI_ANY_ID ||
-		    pci->pdev->device == quirk->chip_device) {
+		    pci->pdev->vendor == quirk->chip_vendor) &&
+		    (quirk->chip_device == (u16)PCI_ANY_ID ||
+		    pci->pdev->device == quirk->chip_device)) {
 			nvkm_info(subdev, "forcing default agp mode to %dX, "
 					  "use NvAGP=<mode> to override\n",
 				  quirk->mode);

drivers/gpu/drm/qxl/qxl_display.c+9−1

 	bo->is_primary = true;
 	ret = qxl_bo_reserve(bo, false);
+	if (ret)
+		return ret;
+	ret = qxl_bo_pin(bo, bo->type, NULL);
+	qxl_bo_unreserve(bo);
 	if (ret)
 		return ret;
 	}
 	drm_vblank_put(dev, qcrtc->index);
-	qxl_bo_unreserve(bo);
+	ret = qxl_bo_reserve(bo, false);
+	if (!ret) {
+		qxl_bo_unpin(bo);
+		qxl_bo_unreserve(bo);
+	}
 	return 0;
 }

drivers/gpu/drm/qxl/qxl_fb.c+11−8

@@ -144,14 +144,17 @@ static void qxl_dirty_update(struct qxl_fbdev *qfbdev, · 143 unmodified lines
144		144
145	spin_lock_irqsave(&qfbdev->dirty.lock, flags);	145	spin_lock_irqsave(&qfbdev->dirty.lock, flags);
146		146
147	if (qfbdev->dirty.y1 < y)	147	if ((qfbdev->dirty.y2 - qfbdev->dirty.y1) &&
148	y = qfbdev->dirty.y1;	148	(qfbdev->dirty.x2 - qfbdev->dirty.x1)) {
149	if (qfbdev->dirty.y2 > y2)	149	if (qfbdev->dirty.y1 < y)
150	y2 = qfbdev->dirty.y2;	150	y = qfbdev->dirty.y1;
151	if (qfbdev->dirty.x1 < x)	151	if (qfbdev->dirty.y2 > y2)
152	x = qfbdev->dirty.x1;	152	y2 = qfbdev->dirty.y2;
153	if (qfbdev->dirty.x2 > x2)	153	if (qfbdev->dirty.x1 < x)
154	x2 = qfbdev->dirty.x2;	154	x = qfbdev->dirty.x1;
		155	if (qfbdev->dirty.x2 > x2)
		156	x2 = qfbdev->dirty.x2;
		157	}
155		158
156	qfbdev->dirty.x1 = x;	159	qfbdev->dirty.x1 = x;
157	qfbdev->dirty.x2 = x2;	160	qfbdev->dirty.x2 = x2;

drivers/gpu/drm/qxl/qxl_release.c+1−3

 		idr_ret = qxl_release_alloc(qdev, QXL_RELEASE_SURFACE_CMD, release);
 		if (idr_ret < 0)
 			return idr_ret;
-		bo = qxl_bo_ref(to_qxl_bo(entry->tv.bo));
+		bo = to_qxl_bo(entry->tv.bo);
 		(*release)->release_offset = create_rel->release_offset + 64;
 		info = qxl_release_map(qdev, *release);
 		info->id = idr_ret;
 		qxl_release_unmap(qdev, *release, info);
-		qxl_bo_unref(&bo);
 		return 0;
 	}

drivers/gpu/drm/radeon/radeon_display.c+2−12

@@ -1633,18 +1633,8 @@ int radeon_modeset_init(struct radeon_device *rdev) · 1632 unmodified lines
1633	radeon_fbdev_init(rdev);	1633	radeon_fbdev_init(rdev);
1634	drm_kms_helper_poll_init(rdev->ddev);	1634	drm_kms_helper_poll_init(rdev->ddev);
1635		1635
1636	if (rdev->pm.dpm_enabled) {	1636	/* do pm late init */
1637	/* do dpm late init */	1637	ret = radeon_pm_late_init(rdev);
1638	ret = radeon_pm_late_init(rdev);
1639	if (ret) {
1640	rdev->pm.dpm_enabled = false;
1641	DRM_ERROR("radeon_pm_late_init failed, disabling dpm\n");
1642	}
1643	/* set the dpm state for PX since there won't be
1644	* a modeset to call this.
1645	*/
1646	radeon_pm_compute_clocks(rdev);
1647	}
1648		1638
1649	return 0;	1639	return 0;
1650	}	1640	}

drivers/gpu/drm/radeon/radeon_dp_mst.c+1−0

@@ -283,6 +283,7 @@ static struct drm_connector *radeon_dp_add_mst_connector(struct drm_dp_mst_topol · 282 unmodified lines
283	radeon_connector->mst_encoder = radeon_dp_create_fake_mst_encoder(master);	283	radeon_connector->mst_encoder = radeon_dp_create_fake_mst_encoder(master);
284		284
285	drm_object_attach_property(&connector->base, dev->mode_config.path_property, 0);	285	drm_object_attach_property(&connector->base, dev->mode_config.path_property, 0);
		286	drm_object_attach_property(&connector->base, dev->mode_config.tile_property, 0);
286	drm_mode_connector_set_path_property(connector, pathprop);	287	drm_mode_connector_set_path_property(connector, pathprop);
287		288
288	return connector;	289	return connector;

drivers/gpu/drm/radeon/radeon_fb.c+16−0

@@ -397,3 +397,19 @@ void radeon_fb_remove_connector(struct radeon_device *rdev, struct drm_connector · 396 unmodified lines
397	{	397	{
398	drm_fb_helper_remove_one_connector(&rdev->mode_info.rfbdev->helper, connector);	398	drm_fb_helper_remove_one_connector(&rdev->mode_info.rfbdev->helper, connector);
399	}	399	}
		400
		401	void radeon_fbdev_restore_mode(struct radeon_device *rdev)
		402	{
		403	struct radeon_fbdev *rfbdev = rdev->mode_info.rfbdev;
		404	struct drm_fb_helper *fb_helper;
		405	int ret;
		406
		407	if (!rfbdev)
		408	return;
		409
		410	fb_helper = &rfbdev->helper;
		411
		412	ret = drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
		413	if (ret)
		414	DRM_DEBUG("failed to restore crtc mode\n");
		415	}

drivers/gpu/drm/radeon/radeon_kms.c+4−1

  * Outdated mess for old drm with Xorg being in charge (void function now).
  */
 /**
- * radeon_driver_firstopen_kms - drm callback for last close
+ * radeon_driver_lastclose_kms - drm callback for last close
  *
  * @dev: drm dev pointer
  *
  */
 void radeon_driver_lastclose_kms(struct drm_device *dev)
 {
+	struct radeon_device *rdev = dev->dev_private;
+	radeon_fbdev_restore_mode(rdev);
 	vga_switcheroo_process_delayed_switch();
 }

drivers/gpu/drm/radeon/radeon_mode.h+1−0

@@ -980,6 +980,7 @@ int radeon_fbdev_init(struct radeon_device *rdev); · 979 unmodified lines
980	void radeon_fbdev_fini(struct radeon_device *rdev);	980	void radeon_fbdev_fini(struct radeon_device *rdev);
981	void radeon_fbdev_set_suspend(struct radeon_device *rdev, int state);	981	void radeon_fbdev_set_suspend(struct radeon_device *rdev, int state);
982	bool radeon_fbdev_robj_is_fb(struct radeon_device rdev, struct radeon_bo robj);	982	bool radeon_fbdev_robj_is_fb(struct radeon_device rdev, struct radeon_bo robj);
		983	void radeon_fbdev_restore_mode(struct radeon_device *rdev);
983		984
984	void radeon_fb_output_poll_changed(struct radeon_device *rdev);	985	void radeon_fb_output_poll_changed(struct radeon_device *rdev);
985		986

drivers/gpu/drm/radeon/radeon_pm.c+44−27

 	struct radeon_device *rdev = dev_get_drvdata(dev);
 	umode_t effective_mode = attr->mode;
-	/* Skip limit attributes if DPM is not enabled */
+	/* Skip attributes if DPM is not enabled */
 	if (rdev->pm.pm_method != PM_METHOD_DPM &&
 	    (attr == &sensor_dev_attr_temp1_crit.dev_attr.attr ||
-	     attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr))
+	     attr == &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_enable.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_max.dev_attr.attr ||
+	     attr == &sensor_dev_attr_pwm1_min.dev_attr.attr))
 		return 0;
 	/* Skip fan attributes if fan is not present */
 	INIT_DELAYED_WORK(&rdev->pm.dynpm_idle_work, radeon_dynpm_idle_work_handler);
 	if (rdev->pm.num_power_states > 1) {
-		/* where's the best place to put these? */
-		ret = device_create_file(rdev->dev, &dev_attr_power_profile);
-		if (ret)
-			DRM_ERROR("failed to create device file for power profile\n");
-		ret = device_create_file(rdev->dev, &dev_attr_power_method);
-		if (ret)
-			DRM_ERROR("failed to create device file for power method\n");
 		if (radeon_debugfs_pm_init(rdev)) {
 			DRM_ERROR("Failed to register debugfs file for PM!\n");
 		}
 		goto dpm_failed;
 	rdev->pm.dpm_enabled = true;
-	ret = device_create_file(rdev->dev, &dev_attr_power_dpm_state);
-	if (ret)
-		DRM_ERROR("failed to create device file for dpm state\n");
-	ret = device_create_file(rdev->dev, &dev_attr_power_dpm_force_performance_level);
-	if (ret)
-		DRM_ERROR("failed to create device file for dpm state\n");
-	/* XXX: these are noops for dpm but are here for backwards compat */
-	ret = device_create_file(rdev->dev, &dev_attr_power_profile);
-	if (ret)
-		DRM_ERROR("failed to create device file for power profile\n");
-	ret = device_create_file(rdev->dev, &dev_attr_power_method);
-	if (ret)
-		DRM_ERROR("failed to create device file for power method\n");
 	if (radeon_debugfs_pm_init(rdev)) {
 		DRM_ERROR("Failed to register debugfs file for dpm!\n");
 	}
 	int ret = 0;
 	if (rdev->pm.pm_method == PM_METHOD_DPM) {
-		mutex_lock(&rdev->pm.mutex);
+		if (rdev->pm.dpm_enabled) {
-		ret = radeon_dpm_late_enable(rdev);
+			ret = device_create_file(rdev->dev, &dev_attr_power_dpm_state);
-		mutex_unlock(&rdev->pm.mutex);
+			if (ret)
+				DRM_ERROR("failed to create device file for dpm state\n");
+			ret = device_create_file(rdev->dev, &dev_attr_power_dpm_force_performance_level);
+			if (ret)
+				DRM_ERROR("failed to create device file for dpm state\n");
+			/* XXX: these are noops for dpm but are here for backwards compat */
+			ret = device_create_file(rdev->dev, &dev_attr_power_profile);
+			if (ret)
+				DRM_ERROR("failed to create device file for power profile\n");
+			ret = device_create_file(rdev->dev, &dev_attr_power_method);
+			if (ret)
+				DRM_ERROR("failed to create device file for power method\n");
+			mutex_lock(&rdev->pm.mutex);
+			ret = radeon_dpm_late_enable(rdev);
+			mutex_unlock(&rdev->pm.mutex);
+			if (ret) {
+				rdev->pm.dpm_enabled = false;
+				DRM_ERROR("radeon_pm_late_init failed, disabling dpm\n");
+			} else {
+				/* set the dpm state for PX since there won't be
+				 * a modeset to call this.
+				 */
+				radeon_pm_compute_clocks(rdev);
+			}
+		}
+	} else {
+		if (rdev->pm.num_power_states > 1) {
+			/* where's the best place to put these? */
+			ret = device_create_file(rdev->dev, &dev_attr_power_profile);
+			if (ret)
+				DRM_ERROR("failed to create device file for power profile\n");
+			ret = device_create_file(rdev->dev, &dev_attr_power_method);
+			if (ret)
+				DRM_ERROR("failed to create device file for power method\n");
+		}
 	}
 	return ret;
 }

drivers/gpu/drm/radeon/si_dpm.c+1−0

@@ -2928,6 +2928,7 @@ static struct si_dpm_quirk si_dpm_quirk_list[] = { · 2927 unmodified lines
2928	{ PCI_VENDOR_ID_ATI, 0x6811, 0x174b, 0xe271, 0, 120000 },	2928	{ PCI_VENDOR_ID_ATI, 0x6811, 0x174b, 0xe271, 0, 120000 },
2929	{ PCI_VENDOR_ID_ATI, 0x6810, 0x174b, 0xe271, 85000, 90000 },	2929	{ PCI_VENDOR_ID_ATI, 0x6810, 0x174b, 0xe271, 85000, 90000 },
2930	{ PCI_VENDOR_ID_ATI, 0x6811, 0x1762, 0x2015, 0, 120000 },	2930	{ PCI_VENDOR_ID_ATI, 0x6811, 0x1762, 0x2015, 0, 120000 },
		2931	{ PCI_VENDOR_ID_ATI, 0x6811, 0x1043, 0x2015, 0, 120000 },
2931	{ 0, 0, 0, 0 },	2932	{ 0, 0, 0, 0 },
2932	};	2933	};
2933		2934

drivers/gpu/drm/virtio/virtgpu_debugfs.c+2−2

@@ -34,8 +34,8 @@ virtio_gpu_debugfs_irq_info(struct seq_file m, void data) · 33 unmodified lines
34	struct drm_info_node node = (struct drm_info_node ) m->private;	34	struct drm_info_node node = (struct drm_info_node ) m->private;
35	struct virtio_gpu_device *vgdev = node->minor->dev->dev_private;	35	struct virtio_gpu_device *vgdev = node->minor->dev->dev_private;
36		36
37	seq_printf(m, "fence %ld %lld\n",	37	seq_printf(m, "fence %llu %lld\n",
38	atomic64_read(&vgdev->fence_drv.last_seq),	38	(u64)atomic64_read(&vgdev->fence_drv.last_seq),
39	vgdev->fence_drv.sync_seq);	39	vgdev->fence_drv.sync_seq);
40	return 0;	40	return 0;
41	}	41	}

drivers/gpu/drm/virtio/virtgpu_fence.c+1−1

@@ -61,7 +61,7 @@ static void virtio_timeline_value_str(struct fence f, char str, int size) · 60 unmodified lines
61	{	61	{
62	struct virtio_gpu_fence *fence = to_virtio_fence(f);	62	struct virtio_gpu_fence *fence = to_virtio_fence(f);
63		63
64	snprintf(str, size, "%lu", atomic64_read(&fence->drv->last_seq));	64	snprintf(str, size, "%llu", (u64)atomic64_read(&fence->drv->last_seq));
65	}	65	}
66		66
67	static const struct fence_ops virtio_fence_ops = {	67	static const struct fence_ops virtio_fence_ops = {

drivers/gpu/drm/vmwgfx/vmwgfx_surface.c+2−1

@@ -657,7 +657,8 @@ static void vmw_user_surface_base_release(struct ttm_base_object **p_base) · 656 unmodified lines
657	struct vmw_resource *res = &user_srf->srf.res;	657	struct vmw_resource *res = &user_srf->srf.res;
658		658
659	*p_base = NULL;	659	*p_base = NULL;
660	ttm_base_object_unref(&user_srf->backup_base);	660	if (user_srf->backup_base)
		661	ttm_base_object_unref(&user_srf->backup_base);
661	vmw_resource_unreference(&res);	662	vmw_resource_unreference(&res);
662	}	663	}
663		664

drivers/i2c/busses/i2c-designware-platdrv.c+27−6

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/dmi.h>
 #include <linux/i2c.h>
 #include <linux/clk.h>
 #include <linux/clk-provider.h>
 }
 #ifdef CONFIG_ACPI
+/*
+ * The HCNT/LCNT information coming from ACPI should be the most accurate
+ * for given platform. However, some systems get it wrong. On such systems
+ * we get better results by calculating those based on the input clock.
+ */
+static const struct dmi_system_id dw_i2c_no_acpi_params[] = {
+	{
+		.ident = "Dell Inspiron 7348",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7348"),
+		},
+	},
+	{ }
+};
 static void dw_i2c_acpi_params(struct platform_device *pdev, char method[],
 			       u16 *hcnt, u16 *lcnt, u32 *sda_hold)
 {
 	acpi_handle handle = ACPI_HANDLE(&pdev->dev);
 	union acpi_object *obj;
+	if (dmi_check_system(dw_i2c_no_acpi_params))
+		return;
 	if (ACPI_FAILURE(acpi_evaluate_object(handle, method, NULL, &buf)))
 		return;
 	adap->dev.parent = &pdev->dev;
 	adap->dev.of_node = pdev->dev.of_node;
-	r = i2c_add_numbered_adapter(adap);
-	if (r) {
-		dev_err(&pdev->dev, "failure adding adapter\n");
-		return r;
-	}
 	if (dev->pm_runtime_disabled) {
 		pm_runtime_forbid(&pdev->dev);
 	} else {
 		pm_runtime_enable(&pdev->dev);
 	}
+	r = i2c_add_numbered_adapter(adap);
+	if (r) {
+		dev_err(&pdev->dev, "failure adding adapter\n");
+		pm_runtime_disable(&pdev->dev);
+		return r;
+	}
 	return 0;
 }

drivers/i2c/busses/i2c-rcar.c+4−3

 		return ret;
 	}
+	pm_runtime_enable(dev);
+	platform_set_drvdata(pdev, priv);
 	ret = i2c_add_numbered_adapter(adap);
 	if (ret < 0) {
 		dev_err(dev, "reg adap failed: %d\n", ret);
+		pm_runtime_disable(dev);
 		return ret;
 	}
-	pm_runtime_enable(dev);
-	platform_set_drvdata(pdev, priv);
 	dev_info(dev, "probed\n");
 	return 0;

drivers/i2c/busses/i2c-s3c2410.c+5−3

 	i2c->adap.nr = i2c->pdata->bus_num;
 	i2c->adap.dev.of_node = pdev->dev.of_node;
+	platform_set_drvdata(pdev, i2c);
+	pm_runtime_enable(&pdev->dev);
 	ret = i2c_add_numbered_adapter(&i2c->adap);
 	if (ret < 0) {
 		dev_err(&pdev->dev, "failed to add bus to i2c core\n");
+		pm_runtime_disable(&pdev->dev);
 		s3c24xx_i2c_deregister_cpufreq(i2c);
 		clk_unprepare(i2c->clk);
 		return ret;
 	}
-	platform_set_drvdata(pdev, i2c);
-	pm_runtime_enable(&pdev->dev);
 	pm_runtime_enable(&i2c->adap.dev);
 	dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));

drivers/i2c/i2c-core.c+6−6

@@ -694,12 +694,12 @@ static int i2c_device_probe(struct device *dev) · 693 unmodified lines
694	goto err_clear_wakeup_irq;	694	goto err_clear_wakeup_irq;
695		695
696	status = dev_pm_domain_attach(&client->dev, true);	696	status = dev_pm_domain_attach(&client->dev, true);
697	if (status != -EPROBE_DEFER) {	697	if (status == -EPROBE_DEFER)
698	status = driver->probe(client, i2c_match_id(driver->id_table,	698	goto err_clear_wakeup_irq;
699	client));	699
700	if (status)	700	status = driver->probe(client, i2c_match_id(driver->id_table, client));
701	goto err_detach_pm_domain;	701	if (status)
702	}	702	goto err_detach_pm_domain;
703		703
704	return 0;	704	return 0;
705		705

drivers/iio/accel/st_accel_core.c+0−6

 #define ST_ACCEL_4_BDU_MASK			0x40
 #define ST_ACCEL_4_DRDY_IRQ_ADDR		0x21
 #define ST_ACCEL_4_DRDY_IRQ_INT1_MASK		0x04
-#define ST_ACCEL_4_IG1_EN_ADDR			0x21
-#define ST_ACCEL_4_IG1_EN_MASK			0x08
 #define ST_ACCEL_4_MULTIREAD_BIT		true
 /* CUSTOM VALUES FOR SENSOR 5 */
 		.drdy_irq = {
 			.addr = ST_ACCEL_4_DRDY_IRQ_ADDR,
 			.mask_int1 = ST_ACCEL_4_DRDY_IRQ_INT1_MASK,
-			.ig1 = {
-				.en_addr = ST_ACCEL_4_IG1_EN_ADDR,
-				.en_mask = ST_ACCEL_4_IG1_EN_MASK,
-			},
 		},
 		.multi_read_bit = ST_ACCEL_4_MULTIREAD_BIT,
 		.bootime = 2, /* guess */

drivers/iio/adc/twl4030-madc.c+34−0

@@ -45,13 +45,18 @@ · 44 unmodified lines
45	#include <linux/types.h>	45	#include <linux/types.h>
46	#include <linux/gfp.h>	46	#include <linux/gfp.h>
47	#include <linux/err.h>	47	#include <linux/err.h>
		48	#include <linux/regulator/consumer.h>
48		49
49	#include <linux/iio/iio.h>	50	#include <linux/iio/iio.h>
50		51
		52	#define TWL4030_USB_SEL_MADC_MCPC (1<<3)
		53	#define TWL4030_USB_CARKIT_ANA_CTRL 0xBB
		54
51	/**	55	/**
52	* struct twl4030_madc_data - a container for madc info	56	* struct twl4030_madc_data - a container for madc info
53	* @dev: Pointer to device structure for madc	57	* @dev: Pointer to device structure for madc
54	* @lock: Mutex protecting this data structure	58	* @lock: Mutex protecting this data structure
		59	* @regulator: Pointer to bias regulator for madc
55	* @requests: Array of request struct corresponding to SW1, SW2 and RT	60	* @requests: Array of request struct corresponding to SW1, SW2 and RT
56	* @use_second_irq: IRQ selection (main or co-processor)	61	* @use_second_irq: IRQ selection (main or co-processor)
57	* @imr: Interrupt mask register of MADC	62	* @imr: Interrupt mask register of MADC
@@ -60,6 +65,7 @@ · 2 unmodified lines
60	struct twl4030_madc_data {	65	struct twl4030_madc_data {
61	struct device *dev;	66	struct device *dev;
62	struct mutex lock; /* mutex protecting this data structure */	67	struct mutex lock; /* mutex protecting this data structure */
		68	struct regulator *usb3v1;
63	struct twl4030_madc_request requests[TWL4030_MADC_NUM_METHODS];	69	struct twl4030_madc_request requests[TWL4030_MADC_NUM_METHODS];
64	bool use_second_irq;	70	bool use_second_irq;
65	u8 imr;	71	u8 imr;
@@ -841,6 +847,32 @@ static int twl4030_madc_probe(struct platform_device *pdev) · 775 unmodified lines
841	}	847	}
842	twl4030_madc = madc;	848	twl4030_madc = madc;
843		849
		850	/* Configure MADC[3:6] */
		851	ret = twl_i2c_read_u8(TWL_MODULE_USB, &regval,
		852	TWL4030_USB_CARKIT_ANA_CTRL);
		853	if (ret) {
		854	dev_err(&pdev->dev, "unable to read reg CARKIT_ANA_CTRL 0x%X\n",
		855	TWL4030_USB_CARKIT_ANA_CTRL);
		856	goto err_i2c;
		857	}
		858	regval \|= TWL4030_USB_SEL_MADC_MCPC;
		859	ret = twl_i2c_write_u8(TWL_MODULE_USB, regval,
		860	TWL4030_USB_CARKIT_ANA_CTRL);
		861	if (ret) {
		862	dev_err(&pdev->dev, "unable to write reg CARKIT_ANA_CTRL 0x%X\n",
		863	TWL4030_USB_CARKIT_ANA_CTRL);
		864	goto err_i2c;
		865	}
		866
		867	/* Enable 3v1 bias regulator for MADC[3:6] */
		868	madc->usb3v1 = devm_regulator_get(madc->dev, "vusb3v1");
		869	if (IS_ERR(madc->usb3v1))
		870	return -ENODEV;
		871
		872	ret = regulator_enable(madc->usb3v1);
		873	if (ret)
		874	dev_err(madc->dev, "could not enable 3v1 bias regulator\n");
		875
844	ret = iio_device_register(iio_dev);	876	ret = iio_device_register(iio_dev);
845	if (ret) {	877	if (ret) {
846	dev_err(&pdev->dev, "could not register iio device\n");	878	dev_err(&pdev->dev, "could not register iio device\n");
@@ -866,6 +898,8 @@ static int twl4030_madc_remove(struct platform_device *pdev) · 19 unmodified lines
866	twl4030_madc_set_current_generator(madc, 0, 0);	898	twl4030_madc_set_current_generator(madc, 0, 0);
867	twl4030_madc_set_power(madc, 0);	899	twl4030_madc_set_power(madc, 0);
868		900
		901	regulator_disable(madc->usb3v1);
		902
869	return 0;	903	return 0;
870	}	904	}
871		905

drivers/infiniband/core/cache.c+1−1

 	memset(&gid_attr, 0, sizeof(gid_attr));
 	gid_attr.ndev = ndev;
+	mutex_lock(&table->lock);
 	ix = find_gid(table, NULL, NULL, true, GID_ATTR_FIND_MASK_DEFAULT);
 	/* Coudn't find default GID location */
 	WARN_ON(ix < 0);
-	mutex_lock(&table->lock);
 	if (!__ib_cache_gid_get(ib_dev, port, ix,
 				&current_gid, &current_gid_attr) &&
 	    mode == IB_CACHE_GID_DEFAULT_MODE_SET &&

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

 	case IB_CM_SIDR_REQ_RCVD:
 		spin_unlock_irq(&cm_id_priv->lock);
 		cm_reject_sidr_req(cm_id_priv, IB_SIDR_REJECT);
+		spin_lock_irq(&cm.lock);
+		if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node))
+			rb_erase(&cm_id_priv->sidr_id_node,
+				 &cm.remote_sidr_table);
+		spin_unlock_irq(&cm.lock);
 		break;
 	case IB_CM_REQ_SENT:
 	case IB_CM_MRA_REQ_RCVD:
 	spin_unlock_irqrestore(&cm_id_priv->lock, flags);
 	spin_lock_irqsave(&cm.lock, flags);
-	rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
+	if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node)) {
+		rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
+		RB_CLEAR_NODE(&cm_id_priv->sidr_id_node);
+	}
 	spin_unlock_irqrestore(&cm.lock, flags);
 	return 0;

drivers/infiniband/core/cma.c+43−17

@@ -1067,14 +1067,14 @@ static int cma_save_req_info(const struct ib_cm_event *ib_event, · 1066 unmodified lines
1067	sizeof(req->local_gid));	1067	sizeof(req->local_gid));
1068	req->has_gid = true;	1068	req->has_gid = true;
1069	req->service_id = req_param->primary_path->service_id;	1069	req->service_id = req_param->primary_path->service_id;
1070	req->pkey = req_param->bth_pkey;	1070	req->pkey = be16_to_cpu(req_param->primary_path->pkey);
1071	break;	1071	break;
1072	case IB_CM_SIDR_REQ_RECEIVED:	1072	case IB_CM_SIDR_REQ_RECEIVED:
1073	req->device = sidr_param->listen_id->device;	1073	req->device = sidr_param->listen_id->device;
1074	req->port = sidr_param->port;	1074	req->port = sidr_param->port;
1075	req->has_gid = false;	1075	req->has_gid = false;
1076	req->service_id = sidr_param->service_id;	1076	req->service_id = sidr_param->service_id;
1077	req->pkey = sidr_param->bth_pkey;	1077	req->pkey = sidr_param->pkey;
1078	break;	1078	break;
1079	default:	1079	default:
1080	return -EINVAL;	1080	return -EINVAL;
@@ -1232,14 +1232,32 @@ static bool cma_match_private_data(struct rdma_id_private *id_priv, · 151 unmodified lines
1232	return true;	1232	return true;
1233	}	1233	}
1234		1234
		1235	static bool cma_protocol_roce_dev_port(struct ib_device *device, int port_num)
		1236	{
		1237	enum rdma_link_layer ll = rdma_port_get_link_layer(device, port_num);
		1238	enum rdma_transport_type transport =
		1239	rdma_node_get_transport(device->node_type);
		1240
		1241	return ll == IB_LINK_LAYER_ETHERNET && transport == RDMA_TRANSPORT_IB;
		1242	}
		1243
		1244	static bool cma_protocol_roce(const struct rdma_cm_id *id)
		1245	{
		1246	struct ib_device *device = id->device;
		1247	const int port_num = id->port_num ?: rdma_start_port(device);
		1248
		1249	return cma_protocol_roce_dev_port(device, port_num);
		1250	}
		1251
1235	static bool cma_match_net_dev(const struct rdma_id_private *id_priv,	1252	static bool cma_match_net_dev(const struct rdma_id_private *id_priv,
1236	const struct net_device *net_dev)	1253	const struct net_device *net_dev)
1237	{	1254	{
1238	const struct rdma_addr *addr = &id_priv->id.route.addr;	1255	const struct rdma_addr *addr = &id_priv->id.route.addr;
1239		1256
1240	if (!net_dev)	1257	if (!net_dev)
1241	/* This request is an AF_IB request */	1258	/* This request is an AF_IB request or a RoCE request */
1242	return addr->src_addr.ss_family == AF_IB;	1259	return addr->src_addr.ss_family == AF_IB \|\|
		1260	cma_protocol_roce(&id_priv->id);
1243		1261
1244	return !addr->dev_addr.bound_dev_if \|\|	1262	return !addr->dev_addr.bound_dev_if \|\|
1245	(net_eq(dev_net(net_dev), &init_net) &&	1263	(net_eq(dev_net(net_dev), &init_net) &&
@@ -1294,6 +1312,10 @@ static struct rdma_id_private cma_id_from_event(struct ib_cm_id cm_id, · 48 unmodified lines
1294	if (PTR_ERR(*net_dev) == -EAFNOSUPPORT) {	1312	if (PTR_ERR(*net_dev) == -EAFNOSUPPORT) {
1295	/* Assuming the protocol is AF_IB */	1313	/* Assuming the protocol is AF_IB */
1296	*net_dev = NULL;	1314	*net_dev = NULL;
		1315	} else if (cma_protocol_roce_dev_port(req.device, req.port)) {
		1316	/* TODO find the net dev matching the request parameters
		1317	* through the RoCE GID table */
		1318	*net_dev = NULL;
1297	} else {	1319	} else {
1298	return ERR_CAST(*net_dev);	1320	return ERR_CAST(*net_dev);
1299	}	1321	}
@@ -1302,7 +1324,7 @@ static struct rdma_id_private cma_id_from_event(struct ib_cm_id cm_id, · 2 unmodified lines
1302	bind_list = cma_ps_find(rdma_ps_from_service_id(req.service_id),	1324	bind_list = cma_ps_find(rdma_ps_from_service_id(req.service_id),
1303	cma_port_from_service_id(req.service_id));	1325	cma_port_from_service_id(req.service_id));
1304	id_priv = cma_find_listener(bind_list, cm_id, ib_event, &req, *net_dev);	1326	id_priv = cma_find_listener(bind_list, cm_id, ib_event, &req, *net_dev);
1305	if (IS_ERR(id_priv)) {	1327	if (IS_ERR(id_priv) && *net_dev) {
1306	dev_put(*net_dev);	1328	dev_put(*net_dev);
1307	*net_dev = NULL;	1329	*net_dev = NULL;
1308	}	1330	}
@@ -1593,11 +1615,16 @@ static struct rdma_id_private cma_new_conn_id(struct rdma_cm_id listen_id, · 284 unmodified lines
1593	if (ret)	1615	if (ret)
1594	goto err;	1616	goto err;
1595	} else {	1617	} else {
1596	/* An AF_IB connection */	1618	if (!cma_protocol_roce(listen_id) &&
1597	WARN_ON_ONCE(ss_family != AF_IB);	1619	cma_any_addr(cma_src_addr(id_priv))) {
1598		1620	rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;
1599	cma_translate_ib((struct sockaddr_ib *)cma_src_addr(id_priv),	1621	rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
1600	&rt->addr.dev_addr);	1622	ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
		1623	} else if (!cma_any_addr(cma_src_addr(id_priv))) {
		1624	ret = cma_translate_addr(cma_src_addr(id_priv), &rt->addr.dev_addr);
		1625	if (ret)
		1626	goto err;
		1627	}
1601	}	1628	}
1602	rdma_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid);	1629	rdma_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid);
1603		1630
@@ -1635,13 +1662,12 @@ static struct rdma_id_private cma_new_udp_id(struct rdma_cm_id listen_id, · 31 unmodified lines
1635	if (ret)	1662	if (ret)
1636	goto err;	1663	goto err;
1637	} else {	1664	} else {
1638	/* An AF_IB connection */	1665	if (!cma_any_addr(cma_src_addr(id_priv))) {
1639	WARN_ON_ONCE(ss_family != AF_IB);	1666	ret = cma_translate_addr(cma_src_addr(id_priv),
1640		1667	&id->route.addr.dev_addr);
1641	if (!cma_any_addr(cma_src_addr(id_priv)))	1668	if (ret)
1642	cma_translate_ib((struct sockaddr_ib *)	1669	goto err;
1643	cma_src_addr(id_priv),	1670	}
1644	&id->route.addr.dev_addr);
1645	}	1671	}
1646		1672
1647	id_priv->state = RDMA_CM_CONNECT;	1673	id_priv->state = RDMA_CM_CONNECT;

drivers/infiniband/core/roce_gid_mgmt.c+27−8

 				 u8 port, struct net_device *ndev)
 {
 	struct in_device *in_dev;
+	struct sin_list {
+		struct list_head	list;
+		struct sockaddr_in	ip;
+	};
+	struct sin_list *sin_iter;
+	struct sin_list *sin_temp;
+	LIST_HEAD(sin_list);
 	if (ndev->reg_state >= NETREG_UNREGISTERING)
 		return;
-	in_dev = in_dev_get(ndev);
+	rcu_read_lock();
-	if (!in_dev)
+	in_dev = __in_dev_get_rcu(ndev);
+	if (!in_dev) {
+		rcu_read_unlock();
 		return;
+	}
 	for_ifa(in_dev) {
-		struct sockaddr_in ip;
+		struct sin_list *entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
-		ip.sin_family = AF_INET;
+		if (!entry) {
-		ip.sin_addr.s_addr = ifa->ifa_address;
+			pr_warn("roce_gid_mgmt: couldn't allocate entry for IPv4 update\n");
-		update_gid_ip(GID_ADD, ib_dev, port, ndev,
+			continue;
-			      (struct sockaddr *)&ip);
+		}
+		entry->ip.sin_family = AF_INET;
+		entry->ip.sin_addr.s_addr = ifa->ifa_address;
+		list_add_tail(&entry->list, &sin_list);
 	}
 	endfor_ifa(in_dev);
+	rcu_read_unlock();
-	in_dev_put(in_dev);
+	list_for_each_entry_safe(sin_iter, sin_temp, &sin_list, list) {
+		update_gid_ip(GID_ADD, ib_dev, port, ndev,
+			      (struct sockaddr *)&sin_iter->ip);
+		list_del(&sin_iter->list);
+		kfree(sin_iter);
+	}
 }
 static void enum_netdev_ipv6_ips(struct ib_device *ib_dev,

drivers/infiniband/core/ucma.c+6−1

 	if (!file)
 		return -ENOMEM;
+	file->close_wq = create_singlethread_workqueue("ucma_close_id");
+	if (!file->close_wq) {
+		kfree(file);
+		return -ENOMEM;
+	}
 	INIT_LIST_HEAD(&file->event_list);
 	INIT_LIST_HEAD(&file->ctx_list);
 	init_waitqueue_head(&file->poll_wait);
 	mutex_init(&file->mut);
-	file->close_wq = create_singlethread_workqueue("ucma_close_id");
 	filp->private_data = file;
 	file->filp = filp;

drivers/infiniband/hw/usnic/usnic.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_abi.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_common_pkt_hdr.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_common_util.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_debugfs.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_debugfs.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_fwd.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_fwd.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_main.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_qp_grp.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_sysfs.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_sysfs.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_verbs.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_ib_verbs.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_log.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_transport.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_transport.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_uiom.c+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	* licenses. You may choose to be licensed under the terms of the GNU	7	* licenses. You may choose to be licensed under the terms of the GNU
8	* General Public License (GPL) Version 2, available from the file	8	* General Public License (GPL) Version 2, available from the file
9	* COPYING in the main directory of this source tree, or the	9	* COPYING in the main directory of this source tree, or the
10	* OpenIB.org BSD license below:	10	* BSD license below:
11	*	11	*
12	* Redistribution and use in source and binary forms, with or	12	* Redistribution and use in source and binary forms, with or
13	* without modification, are permitted provided that the following	13	* without modification, are permitted provided that the following

drivers/infiniband/hw/usnic/usnic_uiom.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2014, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2014, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_vnic.c+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/hw/usnic/usnic_vnic.h+18−3

@@ -1,9 +1,24 @@
1	/*	1	/*
2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.	2	* Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3	*	3	*
4	* This program is free software; you may redistribute it and/or modify	4	* This software is available to you under a choice of one of two
5	* it under the terms of the GNU General Public License as published by	5	* licenses. You may choose to be licensed under the terms of the GNU
6	* the Free Software Foundation; version 2 of the License.	6	* General Public License (GPL) Version 2, available from the file
		7	* COPYING in the main directory of this source tree, or the
		8	* BSD license below:
		9	*
		10	* Redistribution and use in source and binary forms, with or
		11	* without modification, are permitted provided that the following
		12	* conditions are met:
		13	*
		14	* - Redistributions of source code must retain the above
		15	* copyright notice, this list of conditions and the following
		16	* disclaimer.
		17	*
		18	* - Redistributions in binary form must reproduce the above
		19	* copyright notice, this list of conditions and the following
		20	* disclaimer in the documentation and/or other materials
		21	* provided with the distribution.
7	*	22	*
8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

drivers/infiniband/ulp/ipoib/ipoib.h+1−0

@@ -495,6 +495,7 @@ void ipoib_dev_cleanup(struct net_device *dev); · 494 unmodified lines
495	void ipoib_mcast_join_task(struct work_struct *work);	495	void ipoib_mcast_join_task(struct work_struct *work);
496	void ipoib_mcast_carrier_on_task(struct work_struct *work);	496	void ipoib_mcast_carrier_on_task(struct work_struct *work);
497	void ipoib_mcast_send(struct net_device dev, u8 daddr, struct sk_buff *skb);	497	void ipoib_mcast_send(struct net_device dev, u8 daddr, struct sk_buff *skb);
		498	void ipoib_mcast_free(struct ipoib_mcast *mc);
498		499
499	void ipoib_mcast_restart_task(struct work_struct *work);	500	void ipoib_mcast_restart_task(struct work_struct *work);
500	int ipoib_mcast_start_thread(struct net_device *dev);	501	int ipoib_mcast_start_thread(struct net_device *dev);

drivers/infiniband/ulp/ipoib/ipoib_main.c+3−1

 out_unlock:
 	spin_unlock_irqrestore(&priv->lock, flags);
-	list_for_each_entry_safe(mcast, tmcast, &remove_list, list)
+	list_for_each_entry_safe(mcast, tmcast, &remove_list, list) {
 		ipoib_mcast_leave(dev, mcast);
+		ipoib_mcast_free(mcast);
+	}
 }
 static void ipoib_reap_neigh(struct work_struct *work)

drivers/infiniband/ulp/ipoib/ipoib_multicast.c+1−1

@@ -106,7 +106,7 @@ static void __ipoib_mcast_schedule_join_thread(struct ipoib_dev_priv *priv, · 105 unmodified lines
106	queue_delayed_work(priv->wq, &priv->mcast_task, 0);	106	queue_delayed_work(priv->wq, &priv->mcast_task, 0);
107	}	107	}
108		108
109	static void ipoib_mcast_free(struct ipoib_mcast *mcast)	109	void ipoib_mcast_free(struct ipoib_mcast *mcast)
110	{	110	{
111	struct net_device *dev = mcast->dev;	111	struct net_device *dev = mcast->dev;
112	int tx_dropped = 0;	112	int tx_dropped = 0;

drivers/input/mouse/cyapa_gen6.c+3−7

 	memcpy(&cyapa->product_id[13], &resp_data[62], 2);
 	cyapa->product_id[15] = '\0';
+	/* Get the number of Rx electrodes. */
 	rotat_align = resp_data[68];
-	if (rotat_align) {
+	cyapa->electrodes_rx =
-		cyapa->electrodes_rx = cyapa->electrodes_y;
+		rotat_align ? cyapa->electrodes_y : cyapa->electrodes_x;
-		cyapa->electrodes_rx = cyapa->electrodes_y;
-	} else {
-		cyapa->electrodes_rx = cyapa->electrodes_x;
-		cyapa->electrodes_rx = cyapa->electrodes_y;
-	}
 	cyapa->aligned_electrodes_rx = (cyapa->electrodes_rx + 3) & ~3u;
 	if (!cyapa->electrodes_x || !cyapa->electrodes_y ||

drivers/input/touchscreen/ads7846.c+6−2

 static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m)
 {
+	int value;
 	struct spi_transfer *t =
 		list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
 	if (ts->model == 7845) {
-		return be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3;
+		value = be16_to_cpup((__be16 *)&(((char *)t->rx_buf)[1]));
 	} else {
 		/*
 		 * adjust:  on-wire is a must-ignore bit, a BE12 value, then
 		 * padding; built from two 8 bit values written msb-first.
 		 */
-		return be16_to_cpup((__be16 *)t->rx_buf) >> 3;
+		value = be16_to_cpup((__be16 *)t->rx_buf);
 	}
+	/* enforce ADC output is 12 bits width */
+	return (value >> 3) & 0xfff;
 }
 static void ads7846_update_value(struct spi_message *m, int val)

drivers/iommu/Kconfig+1−2

 config IOMMU_IO_PGTABLE_LPAE
 	bool "ARMv7/v8 Long Descriptor Format"
 	select IOMMU_IO_PGTABLE
-	# SWIOTLB guarantees a dma_to_phys() implementation
+	depends on HAS_DMA && (ARM || ARM64 || COMPILE_TEST)
-	depends on ARM || ARM64 || (COMPILE_TEST && SWIOTLB)
 	help
 	  Enable support for the ARM long descriptor pagetable format.
 	  This allocator supports 4K/2M/1G, 16K/32M and 64K/512M page

drivers/iommu/amd_iommu.c+9−0

@@ -2006,6 +2006,15 @@ static void do_detach(struct iommu_dev_data *dev_data) · 2005 unmodified lines
2006	{	2006	{
2007	struct amd_iommu *iommu;	2007	struct amd_iommu *iommu;
2008		2008
		2009	/*
		2010	* First check if the device is still attached. It might already
		2011	* be detached from its domain because the generic
		2012	* iommu_detach_group code detached it and we try again here in
		2013	* our alias handling.
		2014	*/
		2015	if (!dev_data->domain)
		2016	return;
		2017
2009	iommu = amd_iommu_rlookup_table[dev_data->devid];	2018	iommu = amd_iommu_rlookup_table[dev_data->devid];
2010		2019
2011	/* decrease reference counters */	2020	/* decrease reference counters */

drivers/iommu/amd_iommu_init.c+3−0

@@ -1256,6 +1256,9 @@ static int iommu_init_pci(struct amd_iommu *iommu) · 1255 unmodified lines
1256	if (!iommu->dev)	1256	if (!iommu->dev)
1257	return -ENODEV;	1257	return -ENODEV;
1258		1258
		1259	/* Prevent binding other PCI device drivers to IOMMU devices */
		1260	iommu->dev->match_driver = false;
		1261
1259	pci_read_config_dword(iommu->dev, cap_ptr + MMIO_CAP_HDR_OFFSET,	1262	pci_read_config_dword(iommu->dev, cap_ptr + MMIO_CAP_HDR_OFFSET,
1260	&iommu->cap);	1263	&iommu->cap);
1261	pci_read_config_dword(iommu->dev, cap_ptr + MMIO_RANGE_OFFSET,	1264	pci_read_config_dword(iommu->dev, cap_ptr + MMIO_RANGE_OFFSET,

drivers/iommu/arm-smmu-v3.c+15−6

 #define IDR0_TTF_SHIFT			2
 #define IDR0_TTF_MASK			0x3
 #define IDR0_TTF_AARCH64		(2 << IDR0_TTF_SHIFT)
+#define IDR0_TTF_AARCH32_64		(3 << IDR0_TTF_SHIFT)
 #define IDR0_S1P			(1 << 1)
 #define IDR0_S2P			(1 << 0)
 #define CMDQ_TLBI_0_VMID_SHIFT		32
 #define CMDQ_TLBI_0_ASID_SHIFT		48
 #define CMDQ_TLBI_1_LEAF		(1UL << 0)
-#define CMDQ_TLBI_1_ADDR_MASK		~0xfffUL
+#define CMDQ_TLBI_1_VA_MASK		~0xfffUL
+#define CMDQ_TLBI_1_IPA_MASK		0xfffffffff000UL
 #define CMDQ_PRI_0_SSID_SHIFT		12
 #define CMDQ_PRI_0_SSID_MASK		0xfffffUL
 		break;
 	case CMDQ_OP_TLBI_NH_VA:
 		cmd[0] |= (u64)ent->tlbi.asid << CMDQ_TLBI_0_ASID_SHIFT;
-		/* Fallthrough */
+		cmd[1] |= ent->tlbi.leaf ? CMDQ_TLBI_1_LEAF : 0;
+		cmd[1] |= ent->tlbi.addr & CMDQ_TLBI_1_VA_MASK;
+		break;
 	case CMDQ_OP_TLBI_S2_IPA:
 		cmd[0] |= (u64)ent->tlbi.vmid << CMDQ_TLBI_0_VMID_SHIFT;
 		cmd[1] |= ent->tlbi.leaf ? CMDQ_TLBI_1_LEAF : 0;
-		cmd[1] |= ent->tlbi.addr & CMDQ_TLBI_1_ADDR_MASK;
+		cmd[1] |= ent->tlbi.addr & CMDQ_TLBI_1_IPA_MASK;
 		break;
 	case CMDQ_OP_TLBI_NH_ASID:
 		cmd[0] |= (u64)ent->tlbi.asid << CMDQ_TLBI_0_ASID_SHIFT;
 	}
 	/* We only support the AArch64 table format at present */
-	if ((reg & IDR0_TTF_MASK << IDR0_TTF_SHIFT) < IDR0_TTF_AARCH64) {
+	switch (reg & IDR0_TTF_MASK << IDR0_TTF_SHIFT) {
+	case IDR0_TTF_AARCH32_64:
+		smmu->ias = 40;
+		/* Fallthrough */
+	case IDR0_TTF_AARCH64:
+		break;
+	default:
 		dev_err(smmu->dev, "AArch64 table format not supported!\n");
 		return -ENXIO;
 	}
 		dev_warn(smmu->dev,
 			 "failed to set DMA mask for table walker\n");
-	if (!smmu->ias)
+	smmu->ias = max(smmu->ias, smmu->oas);
-		smmu->ias = smmu->oas;
 	dev_info(smmu->dev, "ias %lu-bit, oas %lu-bit (features 0x%08x)\n",
 		 smmu->ias, smmu->oas, smmu->features);

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

 				return -ENOMEM;
 			/* It is large page*/
 			if (largepage_lvl > 1) {
+				unsigned long nr_superpages, end_pfn;
 				pteval |= DMA_PTE_LARGE_PAGE;
 				lvl_pages = lvl_to_nr_pages(largepage_lvl);
+				nr_superpages = sg_res / lvl_pages;
+				end_pfn = iov_pfn + nr_superpages * lvl_pages - 1;
 				/*
 				 * Ensure that old small page tables are
-				 * removed to make room for superpage,
+				 * removed to make room for superpage(s).
-				 * if they exist.
 				 */
-				dma_pte_free_pagetable(domain, iov_pfn,
+				dma_pte_free_pagetable(domain, iov_pfn, end_pfn);
-						       iov_pfn + lvl_pages - 1);
 			} else {
 				pteval &= ~(uint64_t)DMA_PTE_LARGE_PAGE;
 			}
 	if (ret) {
 		spin_unlock_irqrestore(&device_domain_lock, flags);
+		free_devinfo_mem(info);
 		return NULL;
 	}

drivers/iommu/io-pgtable-arm.c+13−11

 static bool selftest_running = false;
-static dma_addr_t __arm_lpae_dma_addr(struct device *dev, void *pages)
+static dma_addr_t __arm_lpae_dma_addr(void *pages)
 {
-	return phys_to_dma(dev, virt_to_phys(pages));
+	return (dma_addr_t)virt_to_phys(pages);
 }
 static void *__arm_lpae_alloc_pages(size_t size, gfp_t gfp,
 			goto out_free;
 		/*
 		 * We depend on the IOMMU being able to work with any physical
-		 * address directly, so if the DMA layer suggests it can't by
+		 * address directly, so if the DMA layer suggests otherwise by
-		 * giving us back some translation, that bodes very badly...
+		 * translating or truncating them, that bodes very badly...
 		 */
-		if (dma != __arm_lpae_dma_addr(dev, pages))
+		if (dma != virt_to_phys(pages))
 			goto out_unmap;
 	}
 static void __arm_lpae_free_pages(void *pages, size_t size,
 				  struct io_pgtable_cfg *cfg)
 {
-	struct device *dev = cfg->iommu_dev;
 	if (!selftest_running)
-		dma_unmap_single(dev, __arm_lpae_dma_addr(dev, pages),
+		dma_unmap_single(cfg->iommu_dev, __arm_lpae_dma_addr(pages),
 				 size, DMA_TO_DEVICE);
 	free_pages_exact(pages, size);
 }
 static void __arm_lpae_set_pte(arm_lpae_iopte *ptep, arm_lpae_iopte pte,
 			       struct io_pgtable_cfg *cfg)
 {
-	struct device *dev = cfg->iommu_dev;
 	*ptep = pte;
 	if (!selftest_running)
-		dma_sync_single_for_device(dev, __arm_lpae_dma_addr(dev, ptep),
+		dma_sync_single_for_device(cfg->iommu_dev,
+					   __arm_lpae_dma_addr(ptep),
 					   sizeof(pte), DMA_TO_DEVICE);
 }
 	if (cfg->oas > ARM_LPAE_MAX_ADDR_BITS)
 		return NULL;
+	if (!selftest_running && cfg->iommu_dev->dma_pfn_offset) {
+		dev_err(cfg->iommu_dev, "Cannot accommodate DMA offset for IOMMU page tables\n");
+		return NULL;
+	}
 	data = kmalloc(sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return NULL;

drivers/md/dm-cache-metadata.c+1−1

 	disk_super = dm_block_data(sblock);
+	disk_super->flags = cpu_to_le32(cmd->flags);
 	if (mutator)
 		update_flags(disk_super, mutator);
-	disk_super->flags = cpu_to_le32(cmd->flags);
 	disk_super->mapping_root = cpu_to_le64(cmd->root);
 	disk_super->hint_root = cpu_to_le64(cmd->hint_root);
 	disk_super->discard_root = cpu_to_le64(cmd->discard_root);

drivers/md/dm-snap-persistent.c+12−3

 static int persistent_ctr(struct dm_exception_store *store, char *options)
 {
 	struct pstore *ps;
+	int r;
 	/* allocate the pstore */
 	ps = kzalloc(sizeof(*ps), GFP_KERNEL);
 	ps->metadata_wq = alloc_workqueue("ksnaphd", WQ_MEM_RECLAIM, 0);
 	if (!ps->metadata_wq) {
-		kfree(ps);
 		DMERR("couldn't start header metadata update thread");
-		return -ENOMEM;
+		r = -ENOMEM;
+		goto err_workqueue;
 	}
 	if (options) {
 			store->userspace_supports_overflow = true;
 		else {
 			DMERR("Unsupported persistent store option: %s", options);
-			return -EINVAL;
+			r = -EINVAL;
+			goto err_options;
 		}
 	}
 	store->context = ps;
 	return 0;
+err_options:
+	destroy_workqueue(ps->metadata_wq);
+err_workqueue:
+	kfree(ps);
+	return r;
 }
 static unsigned persistent_status(struct dm_exception_store *store,

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

@@ -3201,7 +3201,7 @@ static int pool_ctr(struct dm_target ti, unsigned argc, char *argv) · 3200 unmodified lines
3201	metadata_low_callback,	3201	metadata_low_callback,
3202	pool);	3202	pool);
3203	if (r)	3203	if (r)
3204	goto out_free_pt;	3204	goto out_flags_changed;
3205		3205
3206	pt->callbacks.congested_fn = pool_is_congested;	3206	pt->callbacks.congested_fn = pool_is_congested;
3207	dm_table_add_target_callbacks(ti->table, &pt->callbacks);	3207	dm_table_add_target_callbacks(ti->table, &pt->callbacks);

drivers/md/persistent-data/dm-btree-remove.c+11−6

 {
 	int s;
 	uint32_t max_entries = le32_to_cpu(left->header.max_entries);
-	unsigned target = (nr_left + nr_center + nr_right) / 3;
+	unsigned total = nr_left + nr_center + nr_right;
-	BUG_ON(target > max_entries);
+	unsigned target_right = total / 3;
+	unsigned remainder = (target_right * 3) != total;
+	unsigned target_left = target_right + remainder;
+	BUG_ON(target_left > max_entries);
+	BUG_ON(target_right > max_entries);
 	if (nr_left < nr_right) {
-		s = nr_left - target;
+		s = nr_left - target_left;
 		if (s < 0 && nr_center < -s) {
 			/* not enough in central node */
 		} else
 			shift(left, center, s);
-		shift(center, right, target - nr_right);
+		shift(center, right, target_right - nr_right);
 	} else {
-		s = target - nr_right;
+		s = target_right - nr_right;
 		if (s > 0 && nr_center < s) {
 			/* not enough in central node */
 			shift(center, right, nr_center);
 		} else
 			shift(center, right, s);
-		shift(left, center, nr_left - target);
+		shift(left, center, nr_left - target_left);
 	}
 	*key_ptr(parent, c->index) = center->keys[0];

drivers/md/persistent-data/dm-btree.c+1−1

@@ -523,7 +523,7 @@ static int btree_split_beneath(struct shadow_spine *s, uint64_t key) · 522 unmodified lines
523		523
524	r = new_block(s->info, &right);	524	r = new_block(s->info, &right);
525	if (r < 0) {	525	if (r < 0) {
526	/* FIXME: put left */	526	unlock_block(s->info, left);
527	return r;	527	return r;
528	}	528	}
529		529

drivers/media/dvb-frontends/horus3a.h+2−2

@@ -46,8 +46,8 @@ extern struct dvb_frontend horus3a_attach(struct dvb_frontend fe, · 45 unmodified lines
46	const struct horus3a_config *config,	46	const struct horus3a_config *config,
47	struct i2c_adapter *i2c);	47	struct i2c_adapter *i2c);
48	#else	48	#else
49	static inline struct dvb_frontend *horus3a_attach(	49	static inline struct dvb_frontend horus3a_attach(struct dvb_frontend fe,
50	const struct cxd2820r_config *config,	50	const struct horus3a_config *config,
51	struct i2c_adapter *i2c)	51	struct i2c_adapter *i2c)
52	{	52	{
53	printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);	53	printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);

drivers/media/dvb-frontends/lnbh25.h+1−1

@@ -43,7 +43,7 @@ struct dvb_frontend *lnbh25_attach( · 42 unmodified lines
43	struct lnbh25_config *cfg,	43	struct lnbh25_config *cfg,
44	struct i2c_adapter *i2c);	44	struct i2c_adapter *i2c);
45	#else	45	#else
46	static inline dvb_frontend *lnbh25_attach(	46	static inline struct dvb_frontend *lnbh25_attach(
47	struct dvb_frontend *fe,	47	struct dvb_frontend *fe,
48	struct lnbh25_config *cfg,	48	struct lnbh25_config *cfg,
49	struct i2c_adapter *i2c)	49	struct i2c_adapter *i2c)

drivers/media/dvb-frontends/m88ds3103.c+47−26

 static struct dvb_frontend_ops m88ds3103_ops;
+/* write single register with mask */
+static int m88ds3103_update_bits(struct m88ds3103_dev *dev,
+				u8 reg, u8 mask, u8 val)
+{
+	int ret;
+	u8 tmp;
+	/* no need for read if whole reg is written */
+	if (mask != 0xff) {
+		ret = regmap_bulk_read(dev->regmap, reg, &tmp, 1);
+		if (ret)
+			return ret;
+		val &= mask;
+		tmp &= ~mask;
+		val |= tmp;
+	}
+	return regmap_bulk_write(dev->regmap, reg, &val, 1);
+}
 /* write reg val table using reg addr auto increment */
 static int m88ds3103_wr_reg_val_tab(struct m88ds3103_dev *dev,
 		const struct m88ds3103_reg_val *tab, int tab_len)
 			u8tmp2 = 0x00; /* 0b00 */
 			break;
 		}
-		ret = regmap_update_bits(dev->regmap, 0x22, 0xc0, u8tmp1 << 6);
+		ret = m88ds3103_update_bits(dev, 0x22, 0xc0, u8tmp1 << 6);
 		if (ret)
 			goto err;
-		ret = regmap_update_bits(dev->regmap, 0x24, 0xc0, u8tmp2 << 6);
+		ret = m88ds3103_update_bits(dev, 0x24, 0xc0, u8tmp2 << 6);
 		if (ret)
 			goto err;
 	}
 			if (ret)
 				goto err;
 		}
-		ret = regmap_update_bits(dev->regmap, 0x9d, 0x08, 0x08);
+		ret = m88ds3103_update_bits(dev, 0x9d, 0x08, 0x08);
 		if (ret)
 			goto err;
 		ret = regmap_write(dev->regmap, 0xf1, 0x01);
 		if (ret)
 			goto err;
-		ret = regmap_update_bits(dev->regmap, 0x30, 0x80, 0x80);
+		ret = m88ds3103_update_bits(dev, 0x30, 0x80, 0x80);
 		if (ret)
 			goto err;
 	}
 	switch (dev->cfg->ts_mode) {
 	case M88DS3103_TS_SERIAL:
 	case M88DS3103_TS_SERIAL_D7:
-		ret = regmap_update_bits(dev->regmap, 0x29, 0x20, u8tmp1);
+		ret = m88ds3103_update_bits(dev, 0x29, 0x20, u8tmp1);
 		if (ret)
 			goto err;
 		u8tmp1 = 0;
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x4d, 0x02, dev->cfg->spec_inv << 1);
+	ret = m88ds3103_update_bits(dev, 0x4d, 0x02, dev->cfg->spec_inv << 1);
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x30, 0x10, dev->cfg->agc_inv << 4);
+	ret = m88ds3103_update_bits(dev, 0x30, 0x10, dev->cfg->agc_inv << 4);
 	if (ret)
 		goto err;
 	dev->warm = false;
 	/* wake up device from sleep */
-	ret = regmap_update_bits(dev->regmap, 0x08, 0x01, 0x01);
+	ret = m88ds3103_update_bits(dev, 0x08, 0x01, 0x01);
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x04, 0x01, 0x00);
+	ret = m88ds3103_update_bits(dev, 0x04, 0x01, 0x00);
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x23, 0x10, 0x00);
+	ret = m88ds3103_update_bits(dev, 0x23, 0x10, 0x00);
 	if (ret)
 		goto err;
 		utmp = 0x29;
 	else
 		utmp = 0x27;
-	ret = regmap_update_bits(dev->regmap, utmp, 0x01, 0x00);
+	ret = m88ds3103_update_bits(dev, utmp, 0x01, 0x00);
 	if (ret)
 		goto err;
 	/* sleep */
-	ret = regmap_update_bits(dev->regmap, 0x08, 0x01, 0x00);
+	ret = m88ds3103_update_bits(dev, 0x08, 0x01, 0x00);
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x04, 0x01, 0x01);
+	ret = m88ds3103_update_bits(dev, 0x04, 0x01, 0x01);
 	if (ret)
 		goto err;
-	ret = regmap_update_bits(dev->regmap, 0x23, 0x10, 0x10);
+	ret = m88ds3103_update_bits(dev, 0x23, 0x10, 0x10);
 	if (ret)
 		goto err;
 	}
 	utmp = tone << 7 | dev->cfg->envelope_mode << 5;
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0xe0, utmp);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0xe0, utmp);
 	if (ret)
 		goto err;
 	utmp = 1 << 2;
-	ret = regmap_update_bits(dev->regmap, 0xa1, reg_a1_mask, utmp);
+	ret = m88ds3103_update_bits(dev, 0xa1, reg_a1_mask, utmp);
 	if (ret)
 		goto err;
 	voltage_dis ^= dev->cfg->lnb_en_pol;
 	utmp = voltage_dis << 1 | voltage_sel << 0;
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0x03, utmp);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0x03, utmp);
 	if (ret)
 		goto err;
 	}
 	utmp = dev->cfg->envelope_mode << 5;
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0xe0, utmp);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0xe0, utmp);
 	if (ret)
 		goto err;
 	} else {
 		dev_dbg(&client->dev, "diseqc tx timeout\n");
-		ret = regmap_update_bits(dev->regmap, 0xa1, 0xc0, 0x40);
+		ret = m88ds3103_update_bits(dev, 0xa1, 0xc0, 0x40);
 		if (ret)
 			goto err;
 	}
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0xc0, 0x80);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0xc0, 0x80);
 	if (ret)
 		goto err;
 	}
 	utmp = dev->cfg->envelope_mode << 5;
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0xe0, utmp);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0xe0, utmp);
 	if (ret)
 		goto err;
 	} else {
 		dev_dbg(&client->dev, "diseqc tx timeout\n");
-		ret = regmap_update_bits(dev->regmap, 0xa1, 0xc0, 0x40);
+		ret = m88ds3103_update_bits(dev, 0xa1, 0xc0, 0x40);
 		if (ret)
 			goto err;
 	}
-	ret = regmap_update_bits(dev->regmap, 0xa2, 0xc0, 0x80);
+	ret = m88ds3103_update_bits(dev, 0xa2, 0xc0, 0x80);
 	if (ret)
 		goto err;
 		goto err_kfree;
 	/* sleep */
-	ret = regmap_update_bits(dev->regmap, 0x08, 0x01, 0x00);
+	ret = m88ds3103_update_bits(dev, 0x08, 0x01, 0x00);
 	if (ret)
 		goto err_kfree;
-	ret = regmap_update_bits(dev->regmap, 0x04, 0x01, 0x01);
+	ret = m88ds3103_update_bits(dev, 0x04, 0x01, 0x01);
 	if (ret)
 		goto err_kfree;
-	ret = regmap_update_bits(dev->regmap, 0x23, 0x10, 0x10);
+	ret = m88ds3103_update_bits(dev, 0x23, 0x10, 0x10);
 	if (ret)
 		goto err_kfree;

drivers/media/dvb-frontends/si2168.c+4−0

 		/* firmware is in the new format */
 		for (remaining = fw->size; remaining > 0; remaining -= 17) {
 			len = fw->data[fw->size - remaining];
+			if (len > SI2168_ARGLEN) {
+				ret = -EINVAL;
+				break;
+			}
 			memcpy(cmd.args, &fw->data[(fw->size - remaining) + 1], len);
 			cmd.wlen = len;
 			cmd.rlen = 1;

drivers/media/pci/netup_unidvb/netup_unidvb_spi.c+4−8

@@ -80,11 +80,9 @@ irqreturn_t netup_spi_interrupt(struct netup_spi *spi) · 79 unmodified lines
80	u16 reg;	80	u16 reg;
81	unsigned long flags;	81	unsigned long flags;
82		82
83	if (!spi) {	83	if (!spi)
84	dev_dbg(&spi->master->dev,
85	"%s(): SPI not initialized\n", __func__);
86	return IRQ_NONE;	84	return IRQ_NONE;
87	}	85
88	spin_lock_irqsave(&spi->lock, flags);	86	spin_lock_irqsave(&spi->lock, flags);
89	reg = readw(&spi->regs->control_stat);	87	reg = readw(&spi->regs->control_stat);
90	if (!(reg & NETUP_SPI_CTRL_IRQ)) {	88	if (!(reg & NETUP_SPI_CTRL_IRQ)) {
@@ -234,11 +232,9 @@ void netup_spi_release(struct netup_unidvb_dev *ndev) · 143 unmodified lines
234	unsigned long flags;	232	unsigned long flags;
235	struct netup_spi *spi = ndev->spi;	233	struct netup_spi *spi = ndev->spi;
236		234
237	if (!spi) {	235	if (!spi)
238	dev_dbg(&spi->master->dev,
239	"%s(): SPI not initialized\n", __func__);
240	return;	236	return;
241	}	237
242	spin_lock_irqsave(&spi->lock, flags);	238	spin_lock_irqsave(&spi->lock, flags);
243	reg = readw(&spi->regs->control_stat);	239	reg = readw(&spi->regs->control_stat);
244	writew(reg \| NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);	240	writew(reg \| NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);

drivers/media/platform/sti/c8sectpfe/c8sectpfe-core.c+3−4

 	Elf32_Ehdr *ehdr;
 	Elf32_Phdr *phdr;
 	u8 __iomem *dst;
-	int err, i;
+	int err = 0, i;
 	if (!fw || !context)
 		return -EINVAL;
 	phdr = (Elf32_Phdr *)(fw->data + ehdr->e_phoff);
 	/* go through the available ELF segments */
-	for (i = 0; i < ehdr->e_phnum && !err; i++, phdr++) {
+	for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
 		/* Only consider LOAD segments */
 		if (phdr->p_type != PT_LOAD)
 static int load_c8sectpfe_fw_step1(struct c8sectpfei *fei)
 {
-	int ret;
 	int err;
 	dev_info(fei->dev, "Loading firmware: %s\n", FIRMWARE_MEMDMA);
 	if (err) {
 		dev_err(fei->dev, "request_firmware_nowait err: %d.\n", err);
 		complete_all(&fei->fw_ack);
-		return ret;
+		return err;
 	}
 	return 0;

drivers/media/rc/ir-hix5hd2.c+1−1

@@ -257,7 +257,7 @@ static int hix5hd2_ir_probe(struct platform_device *pdev) · 256 unmodified lines
257	goto clkerr;	257	goto clkerr;
258		258
259	if (devm_request_irq(dev, priv->irq, hix5hd2_ir_rx_interrupt,	259	if (devm_request_irq(dev, priv->irq, hix5hd2_ir_rx_interrupt,
260	IRQF_NO_SUSPEND, pdev->name, priv) < 0) {	260	0, pdev->name, priv) < 0) {
261	dev_err(dev, "IRQ %d register failed\n", priv->irq);	261	dev_err(dev, "IRQ %d register failed\n", priv->irq);
262	ret = -EINVAL;	262	ret = -EINVAL;
263	goto regerr;	263	goto regerr;

drivers/media/tuners/si2157.c+4−0

 	for (remaining = fw->size; remaining > 0; remaining -= 17) {
 		len = fw->data[fw->size - remaining];
+		if (len > SI2157_ARGLEN) {
+			dev_err(&client->dev, "Bad firmware length\n");
+			goto err_release_firmware;
+		}
 		memcpy(cmd.args, &fw->data[(fw->size - remaining) + 1], len);
 		cmd.wlen = len;
 		cmd.rlen = 1;

drivers/media/usb/dvb-usb-v2/rtl28xxu.c+13−2

 	unsigned int pipe;
 	u8 requesttype;
+	mutex_lock(&d->usb_mutex);
+	if (req->size > sizeof(dev->buf)) {
+		dev_err(&d->intf->dev, "too large message %u\n", req->size);
+		ret = -EINVAL;
+		goto err_mutex_unlock;
+	}
 	if (req->index & CMD_WR_FLAG) {
 		/* write */
 		memcpy(dev->buf, req->data, req->size);
 	dvb_usb_dbg_usb_control_msg(d->udev, 0, requesttype, req->value,
 			req->index, dev->buf, req->size);
 	if (ret < 0)
-		goto err;
+		goto err_mutex_unlock;
 	/* read request, copy returned data to return buf */
 	if (requesttype == (USB_TYPE_VENDOR | USB_DIR_IN))
 		memcpy(req->data, dev->buf, req->size);
+	mutex_unlock(&d->usb_mutex);
 	return 0;
-err:
+err_mutex_unlock:
+	mutex_unlock(&d->usb_mutex);
 	dev_dbg(&d->intf->dev, "failed=%d\n", ret);
 	return ret;
 }

drivers/media/usb/dvb-usb-v2/rtl28xxu.h+1−1

@@ -71,7 +71,7 @@ · 70 unmodified lines
71		71
72		72
73	struct rtl28xxu_dev {	73	struct rtl28xxu_dev {
74	u8 buf[28];	74	u8 buf[128];
75	u8 chip_id;	75	u8 chip_id;
76	u8 tuner;	76	u8 tuner;
77	char *tuner_name;	77	char *tuner_name;

drivers/media/v4l2-core/Kconfig+1−1

@@ -47,7 +47,7 @@ config V4L2_MEM2MEM_DEV · 46 unmodified lines
47	# Used by LED subsystem flash drivers	47	# Used by LED subsystem flash drivers
48	config V4L2_FLASH_LED_CLASS	48	config V4L2_FLASH_LED_CLASS
49	tristate "V4L2 flash API for LED flash class devices"	49	tristate "V4L2 flash API for LED flash class devices"
50	depends on VIDEO_V4L2_SUBDEV_API	50	depends on VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
51	depends on LEDS_CLASS_FLASH	51	depends on LEDS_CLASS_FLASH
52	---help---	52	---help---
53	Say Y here to enable V4L2 flash API support for LED flash	53	Say Y here to enable V4L2 flash API support for LED flash

drivers/memory/Kconfig+9−3

 	  memory drives like NOR, NAND, OneNAND, SRAM.
 config OMAP_GPMC_DEBUG
-	bool
+	bool "Enable GPMC debug output and skip reset of GPMC during init"
 	depends on OMAP_GPMC
 	help
 	  Enables verbose debugging mostly to decode the bootloader provided
-	  timings. Enable this during development to configure devices
+	  timings. To preserve the bootloader provided timings, the reset
-	  connected to the GPMC bus.
+	  of GPMC is skipped during init. Enable this during development to
+	  configure devices connected to the GPMC bus.
+	  NOTE: In addition to matching the register setup with the bootloader
+	  you also need to match the GPMC FCLK frequency used by the
+	  bootloader or else the GPMC timings won't be identical with the
+	  bootloader timings.
 config MVEBU_DEVBUS
 	bool "Marvell EBU Device Bus Controller"

drivers/memory/omap-gpmc.c+1−1

 	int div;
 	u32 l;
-	gpmc_cs_show_timings(cs, "before gpmc_cs_set_timings");
 	div = gpmc_calc_divider(t->sync_clk);
 	if (div < 0)
 		return div;
 	if (ret < 0)
 		goto err;
+	gpmc_cs_show_timings(cs, "before gpmc_cs_program_settings");
 	ret = gpmc_cs_program_settings(cs, &gpmc_s);
 	if (ret < 0)
 		goto err;

drivers/mfd/intel-lpss.h+2−0

@@ -42,6 +42,8 @@ int intel_lpss_resume(struct device *dev); · 41 unmodified lines
42	.thaw = intel_lpss_resume, \	42	.thaw = intel_lpss_resume, \
43	.poweroff = intel_lpss_suspend, \	43	.poweroff = intel_lpss_suspend, \
44	.restore = intel_lpss_resume,	44	.restore = intel_lpss_resume,
		45	#else
		46	#define INTEL_LPSS_SLEEP_PM_OPS
45	#endif	47	#endif
46		48
47	#define INTEL_LPSS_RUNTIME_PM_OPS \	49	#define INTEL_LPSS_RUNTIME_PM_OPS \

drivers/mfd/max77843.c+1−1

@@ -80,7 +80,7 @@ static int max77843_chg_init(struct max77693_dev *max77843) · 79 unmodified lines
80	if (!max77843->i2c_chg) {	80	if (!max77843->i2c_chg) {
81	dev_err(&max77843->i2c->dev,	81	dev_err(&max77843->i2c->dev,
82	"Cannot allocate I2C device for Charger\n");	82	"Cannot allocate I2C device for Charger\n");
83	return PTR_ERR(max77843->i2c_chg);	83	return -ENODEV;
84	}	84	}
85	i2c_set_clientdata(max77843->i2c_chg, max77843);	85	i2c_set_clientdata(max77843->i2c_chg, max77843);
86		86

drivers/misc/cxl/api.c+1−0

@@ -105,6 +105,7 @@ EXPORT_SYMBOL_GPL(cxl_allocate_afu_irqs); · 104 unmodified lines
105		105
106	void cxl_free_afu_irqs(struct cxl_context *ctx)	106	void cxl_free_afu_irqs(struct cxl_context *ctx)
107	{	107	{
		108	afu_irq_name_free(ctx);
108	cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);	109	cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
109	}	110	}
110	EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);	111	EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);

drivers/misc/cxl/context.c+3−0

@@ -275,6 +275,9 @@ static void reclaim_ctx(struct rcu_head *rcu) · 274 unmodified lines
275	if (ctx->kernelapi)	275	if (ctx->kernelapi)
276	kfree(ctx->mapping);	276	kfree(ctx->mapping);
277		277
		278	if (ctx->irq_bitmap)
		279	kfree(ctx->irq_bitmap);
		280
278	kfree(ctx);	281	kfree(ctx);
279	}	282	}
280		283

drivers/misc/cxl/cxl.h+1−0

@@ -677,6 +677,7 @@ int cxl_register_serr_irq(struct cxl_afu *afu); · 676 unmodified lines
677	void cxl_release_serr_irq(struct cxl_afu *afu);	677	void cxl_release_serr_irq(struct cxl_afu *afu);
678	int afu_register_irqs(struct cxl_context *ctx, u32 count);	678	int afu_register_irqs(struct cxl_context *ctx, u32 count);
679	void afu_release_irqs(struct cxl_context ctx, void cookie);	679	void afu_release_irqs(struct cxl_context ctx, void cookie);
		680	void afu_irq_name_free(struct cxl_context *ctx);
680	irqreturn_t cxl_slice_irq_err(int irq, void *data);	681	irqreturn_t cxl_slice_irq_err(int irq, void *data);
681		682
682	int cxl_debugfs_init(void);	683	int cxl_debugfs_init(void);

drivers/misc/cxl/file.c+10−3

@@ -120,9 +120,16 @@ int afu_release(struct inode inode, struct file file) · 119 unmodified lines
120	__func__, ctx->pe);	120	__func__, ctx->pe);
121	cxl_context_detach(ctx);	121	cxl_context_detach(ctx);
122		122
123	mutex_lock(&ctx->mapping_lock);	123
124	ctx->mapping = NULL;	124	/*
125	mutex_unlock(&ctx->mapping_lock);	125	* Delete the context's mapping pointer, unless it's created by the
		126	* kernel API, in which case leave it so it can be freed by reclaim_ctx()
		127	*/
		128	if (!ctx->kernelapi) {
		129	mutex_lock(&ctx->mapping_lock);
		130	ctx->mapping = NULL;
		131	mutex_unlock(&ctx->mapping_lock);
		132	}
126		133
127	put_device(&ctx->afu->dev);	134	put_device(&ctx->afu->dev);
128		135

drivers/misc/cxl/irq.c+1−3

 	kfree(afu->psl_irq_name);
 }
-static void afu_irq_name_free(struct cxl_context *ctx)
+void afu_irq_name_free(struct cxl_context *ctx)
 {
 	struct cxl_irq_name *irq_name, *tmp;
 	afu_irq_name_free(ctx);
 	cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
-	kfree(ctx->irq_bitmap);
-	ctx->irq_bitmap = NULL;
 	ctx->irq_count = 0;
 }

drivers/misc/cxl/native.c+1−1

 	dev_info(&afu->dev, "Activating AFU directed mode\n");
+	afu->num_procs = afu->max_procs_virtualised;
 	if (afu->spa == NULL) {
 		if (cxl_alloc_spa(afu))
 			return -ENOMEM;
 	cxl_p1n_write(afu, CXL_PSL_ID_An, CXL_PSL_ID_An_F | CXL_PSL_ID_An_L);
 	afu->current_mode = CXL_MODE_DIRECTED;
-	afu->num_procs = afu->max_procs_virtualised;
 	if ((rc = cxl_chardev_m_afu_add(afu)))
 		return rc;

drivers/misc/cxl/pci.c+28−0

@@ -1035,6 +1035,32 @@ static int cxl_read_vsec(struct cxl adapter, struct pci_dev dev) · 1034 unmodified lines
1035	return 0;	1035	return 0;
1036	}	1036	}
1037		1037
		1038	/*
		1039	* Workaround a PCIe Host Bridge defect on some cards, that can cause
		1040	* malformed Transaction Layer Packet (TLP) errors to be erroneously
		1041	* reported. Mask this error in the Uncorrectable Error Mask Register.
		1042	*
		1043	* The upper nibble of the PSL revision is used to distinguish between
		1044	* different cards. The affected ones have it set to 0.
		1045	*/
		1046	static void cxl_fixup_malformed_tlp(struct cxl adapter, struct pci_dev dev)
		1047	{
		1048	int aer;
		1049	u32 data;
		1050
		1051	if (adapter->psl_rev & 0xf000)
		1052	return;
		1053	if (!(aer = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)))
		1054	return;
		1055	pci_read_config_dword(dev, aer + PCI_ERR_UNCOR_MASK, &data);
		1056	if (data & PCI_ERR_UNC_MALF_TLP)
		1057	if (data & PCI_ERR_UNC_INTN)
		1058	return;
		1059	data \|= PCI_ERR_UNC_MALF_TLP;
		1060	data \|= PCI_ERR_UNC_INTN;
		1061	pci_write_config_dword(dev, aer + PCI_ERR_UNCOR_MASK, data);
		1062	}
		1063
1038	static int cxl_vsec_looks_ok(struct cxl adapter, struct pci_dev dev)	1064	static int cxl_vsec_looks_ok(struct cxl adapter, struct pci_dev dev)
1039	{	1065	{
1040	if (adapter->vsec_status & CXL_STATUS_SECOND_PORT)	1066	if (adapter->vsec_status & CXL_STATUS_SECOND_PORT)
@@ -1134,6 +1160,8 @@ static int cxl_configure_adapter(struct cxl adapter, struct pci_dev dev) · 93 unmodified lines
1134	if ((rc = cxl_vsec_looks_ok(adapter, dev)))	1160	if ((rc = cxl_vsec_looks_ok(adapter, dev)))
1135	return rc;	1161	return rc;
1136		1162
		1163	cxl_fixup_malformed_tlp(adapter, dev);
		1164
1137	if ((rc = setup_cxl_bars(dev)))	1165	if ((rc = setup_cxl_bars(dev)))
1138	return rc;	1166	return rc;
1139		1167

drivers/mmc/card/mmc_test.c+3−6

 /*
  * eMMC hardware reset.
  */
-static int mmc_test_hw_reset(struct mmc_test_card *test)
+static int mmc_test_reset(struct mmc_test_card *test)
 {
 	struct mmc_card *card = test->card;
 	struct mmc_host *host = card->host;
 	int err;
-	if (!mmc_card_mmc(card) || !mmc_can_reset(card))
-		return RESULT_UNSUP_CARD;
 	err = mmc_hw_reset(host);
 	if (!err)
 		return RESULT_OK;
 	},
 	{
-		.name = "eMMC hardware reset",
+		.name = "Reset test",
-		.run = mmc_test_hw_reset,
+		.run = mmc_test_reset,
 	},
 };

drivers/mmc/core/mmc.c+0−7

 static int mmc_reset(struct mmc_host *host)
 {
 	struct mmc_card *card = host->card;
-	u32 status;
 	if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
 		return -EOPNOTSUPP;
 	host->ops->hw_reset(host);
-	/* If the reset has happened, then a status command will fail */
-	if (!mmc_send_status(card, &status)) {
-		mmc_host_clk_release(host);
-		return -ENOSYS;
-	}
 	/* Set initial state and call mmc_set_ios */
 	mmc_set_initial_state(host);
 	mmc_host_clk_release(host);

drivers/net/can/sja1000/peak_pci.c+1−0

@@ -87,6 +87,7 @@ static const struct pci_device_id peak_pci_tbl[] = { · 86 unmodified lines
87	{PEAK_PCI_VENDOR_ID, PEAK_PC_104P_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},	87	{PEAK_PCI_VENDOR_ID, PEAK_PC_104P_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
88	{PEAK_PCI_VENDOR_ID, PEAK_PCI_104E_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},	88	{PEAK_PCI_VENDOR_ID, PEAK_PCI_104E_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
89	{PEAK_PCI_VENDOR_ID, PEAK_CPCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},	89	{PEAK_PCI_VENDOR_ID, PEAK_CPCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
		90	{PEAK_PCI_VENDOR_ID, PEAK_PCIE_OEM_ID, PCI_ANY_ID, PCI_ANY_ID,},
90	#ifdef CONFIG_CAN_PEAK_PCIEC	91	#ifdef CONFIG_CAN_PEAK_PCIEC
91	{PEAK_PCI_VENDOR_ID, PEAK_PCIEC_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},	92	{PEAK_PCI_VENDOR_ID, PEAK_PCIEC_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
92	{PEAK_PCI_VENDOR_ID, PEAK_PCIEC34_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},	93	{PEAK_PCI_VENDOR_ID, PEAK_PCIEC34_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},

drivers/net/ethernet/amd/xgbe/xgbe-debugfs.c+4−0

 	pdata->debugfs_xpcs_reg = 0;
 	buf = kasprintf(GFP_KERNEL, "amd-xgbe-%s", pdata->netdev->name);
+	if (!buf)
+		return;
 	pdata->xgbe_debugfs = debugfs_create_dir(buf, NULL);
 	if (!pdata->xgbe_debugfs) {
 		netdev_err(pdata->netdev, "debugfs_create_dir failed\n");
+		kfree(buf);
 		return;
 	}

drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c+7−0

@@ -3351,6 +3351,13 @@ static int bnx2x_set_rss_flags(struct bnx2x bp, struct ethtool_rxnfc info) · 3350 unmodified lines
3351	udp_rss_requested = 0;	3351	udp_rss_requested = 0;
3352	else	3352	else
3353	return -EINVAL;	3353	return -EINVAL;
		3354
		3355	if (CHIP_IS_E1x(bp) && udp_rss_requested) {
		3356	DP(BNX2X_MSG_ETHTOOL,
		3357	"57710, 57711 boards don't support RSS according to UDP 4-tuple\n");
		3358	return -EINVAL;
		3359	}
		3360
3354	if ((info->flow_type == UDP_V4_FLOW) &&	3361	if ((info->flow_type == UDP_V4_FLOW) &&
3355	(bp->rss_conf_obj.udp_rss_v4 != udp_rss_requested)) {	3362	(bp->rss_conf_obj.udp_rss_v4 != udp_rss_requested)) {
3356	bp->rss_conf_obj.udp_rss_v4 = udp_rss_requested;	3363	bp->rss_conf_obj.udp_rss_v4 = udp_rss_requested;

drivers/net/ethernet/broadcom/genet/bcmgenet.c+23−9

 	bcmgenet_intrl2_1_writel(priv, 0, INTRL2_CPU_MASK_CLEAR);
 }
+static void bcmgenet_link_intr_enable(struct bcmgenet_priv *priv)
+{
+	u32 int0_enable = 0;
+	/* Monitor cable plug/unplugged event for internal PHY, external PHY
+	 * and MoCA PHY
+	 */
+	if (priv->internal_phy) {
+		int0_enable |= UMAC_IRQ_LINK_EVENT;
+	} else if (priv->ext_phy) {
+		int0_enable |= UMAC_IRQ_LINK_EVENT;
+	} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
+		if (priv->hw_params->flags & GENET_HAS_MOCA_LINK_DET)
+			int0_enable |= UMAC_IRQ_LINK_EVENT;
+	}
+	bcmgenet_intrl2_0_writel(priv, int0_enable, INTRL2_CPU_MASK_CLEAR);
+}
 static int init_umac(struct bcmgenet_priv *priv)
 {
 	struct device *kdev = &priv->pdev->dev;
 	/* Enable Tx default queue 16 interrupts */
 	int0_enable |= UMAC_IRQ_TXDMA_DONE;
-	/* Monitor cable plug/unplugged event for internal PHY */
+	/* Configure backpressure vectors for MoCA */
-	if (priv->internal_phy) {
+	if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
-		int0_enable |= UMAC_IRQ_LINK_EVENT;
-	} else if (priv->ext_phy) {
-		int0_enable |= UMAC_IRQ_LINK_EVENT;
-	} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
-		if (priv->hw_params->flags & GENET_HAS_MOCA_LINK_DET)
-			int0_enable |= UMAC_IRQ_LINK_EVENT;
 		reg = bcmgenet_bp_mc_get(priv);
 		reg |= BIT(priv->hw_params->bp_in_en_shift);
 	netif_tx_start_all_queues(dev);
+	/* Monitor link interrupts now */
+	bcmgenet_link_intr_enable(priv);
 	phy_start(priv->phydev);
 }

drivers/net/ethernet/emulex/benet/be.h+1−0

@@ -592,6 +592,7 @@ struct be_adapter { · 591 unmodified lines
592	int be_get_temp_freq;	592	int be_get_temp_freq;
593	struct be_hwmon hwmon_info;	593	struct be_hwmon hwmon_info;
594	u8 pf_number;	594	u8 pf_number;
		595	u8 pci_func_num;
595	struct rss_info rss_info;	596	struct rss_info rss_info;
596	/* Filters for packets that need to be sent to BMC */	597	/* Filters for packets that need to be sent to BMC */
597	u32 bmc_filt_mask;	598	u32 bmc_filt_mask;

drivers/net/ethernet/emulex/benet/be_cmds.c+24−7

 		return status;
 	dest_wrb = be_cmd_copy(adapter, wrb);
-	if (!dest_wrb)
+	if (!dest_wrb) {
-		return -EBUSY;
+		status = -EBUSY;
+		goto unlock;
+	}
 	if (use_mcc(adapter))
 		status = be_mcc_notify_wait(adapter);
 	if (!status)
 		memcpy(wrb, dest_wrb, sizeof(*wrb));
+unlock:
 	be_cmd_unlock(adapter);
 	return status;
 }
 			 be_if_cap_flags(adapter));
 	}
 	flags &= be_if_cap_flags(adapter);
+	if (!flags)
+		return -ENOTSUPP;
 	return __be_cmd_rx_filter(adapter, flags, value);
 }
 	if (!status) {
 		attribs = attribs_cmd.va + sizeof(struct be_cmd_resp_hdr);
 		adapter->hba_port_num = attribs->hba_attribs.phy_port;
+		adapter->pci_func_num = attribs->pci_func_num;
 		serial_num = attribs->hba_attribs.controller_serial_number;
 		for (i = 0; i < CNTL_SERIAL_NUM_WORDS; i++)
 			adapter->serial_num[i] = le32_to_cpu(serial_num[i]) &
 			status = -EINVAL;
 			goto err;
 		}
 		adapter->pf_number = desc->pf_num;
 		be_copy_nic_desc(res, desc);
 	}
 	return status;
 }
-/* Will use MBOX only if MCCQ has not been created */
+/* Will use MBOX only if MCCQ has not been created
+ * non-zero domain => a PF is querying this on behalf of a VF
+ * zero domain => a PF or a VF is querying this for itself
+ */
 int be_cmd_get_profile_config(struct be_adapter *adapter,
 			      struct be_resources *res, u8 query, u8 domain)
 {
 			       OPCODE_COMMON_GET_PROFILE_CONFIG,
 			       cmd.size, &wrb, &cmd);
-	req->hdr.domain = domain;
 	if (!lancer_chip(adapter))
 		req->hdr.version = 1;
 	req->type = ACTIVE_PROFILE_TYPE;
+	/* When a function is querying profile information relating to
+	 * itself hdr.pf_number must be set to it's pci_func_num + 1
+	 */
+	req->hdr.domain = domain;
+	if (domain == 0)
+		req->hdr.pf_num = adapter->pci_func_num + 1;
 	/* When QUERY_MODIFIABLE_FIELDS_TYPE bit is set, cmd returns the
 	 * descriptors with all bits set to "1" for the fields which can be
 			vf_if_cap_flags &= ~(BE_IF_FLAGS_RSS |
 					     BE_IF_FLAGS_DEFQ_RSS);
 		}
-		nic_vft->cap_flags = cpu_to_le32(vf_if_cap_flags);
 	} else {
 		num_vf_qs = 1;
 	}
+	if (res_mod.vf_if_cap_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
+		nic_vft->flags |= BIT(IF_CAPS_FLAGS_VALID_SHIFT);
+		vf_if_cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
+	}
+	nic_vft->cap_flags = cpu_to_le32(vf_if_cap_flags);
 	nic_vft->rq_count = cpu_to_le16(num_vf_qs);
 	nic_vft->txq_count = cpu_to_le16(num_vf_qs);
 	nic_vft->rssq_count = cpu_to_le16(num_vf_qs);

drivers/net/ethernet/emulex/benet/be_cmds.h+8−2

 	u32 timeout;		/* dword 1 */
 	u32 request_length;	/* dword 2 */
 	u8 version;		/* dword 3 */
-	u8 rsvd[3];		/* dword 3 */
+	u8 rsvd1;		/* dword 3 */
+	u8 pf_num;		/* dword 3 */
+	u8 rsvd2;		/* dword 3 */
 };
 #define RESP_HDR_INFO_OPCODE_SHIFT	0	/* bits 0 - 7 */
 struct mgmt_controller_attrib {
 	struct mgmt_hba_attribs hba_attribs;
-	u32 rsvd0[10];
+	u32 rsvd0[2];
+	u16 rsvd1;
+	u8 pci_func_num;
+	u8 rsvd2;
+	u32 rsvd3[7];
 } __packed;
 struct be_cmd_req_cntl_attribs {

drivers/net/ethernet/emulex/benet/be_main.c+19−9

 					   struct sk_buff *skb,
 					   struct be_wrb_params *wrb_params)
 {
-	/* Lancer, SH-R ASICs have a bug wherein Packets that are 32 bytes or
+	/* Lancer, SH and BE3 in SRIOV mode have a bug wherein
-	 * less may cause a transmit stall on that port. So the work-around is
+	 * packets that are 32b or less may cause a transmit stall
-	 * to pad short packets (<= 32 bytes) to a 36-byte length.
+	 * on that port. The workaround is to pad such packets
+	 * (len <= 32 bytes) to a minimum length of 36b.
 	 */
-	if (unlikely(!BEx_chip(adapter) && skb->len <= 32)) {
+	if (skb->len <= 32) {
 		if (skb_put_padto(skb, 36))
 			return NULL;
 	}
 	int status, level;
 	u16 profile_id;
-	status = be_cmd_get_cntl_attributes(adapter);
-	if (status)
-		return status;
 	status = be_cmd_query_fw_cfg(adapter);
 	if (status)
 		return status;
 	if (!lancer_chip(adapter))
 		be_cmd_req_native_mode(adapter);
+	/* Need to invoke this cmd first to get the PCI Function Number */
+	status = be_cmd_get_cntl_attributes(adapter);
+	if (status)
+		return status;
 	if (!BE2_chip(adapter) && be_physfn(adapter))
 		be_alloc_sriov_res(adapter);
 		return false;
 	}
-	return (fhdr->asic_type_rev >= adapter->asic_rev);
+	/* In BE3 FW images the "asic_type_rev" field doesn't track the
+	 * asic_rev of the chips it is compatible with.
+	 * When asic_type_rev is 0 the image is compatible only with
+	 * pre-BE3-R chips (asic_rev < 0x10)
+	 */
+	if (BEx_chip(adapter) && fhdr->asic_type_rev == 0)
+		return adapter->asic_rev < 0x10;
+	else
+		return (fhdr->asic_type_rev >= adapter->asic_rev);
 }
 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)

drivers/net/ethernet/freescale/fsl_pq_mdio.c+28−6

 #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
 /*
+ * Return the TBIPA address, starting from the address
+ * of the mapped GFAR MDIO registers (struct gfar)
  * This is mildly evil, but so is our hardware for doing this.
  * Also, we have to cast back to struct gfar because of
  * definition weirdness done in gianfar.h.
  */
-static uint32_t __iomem *get_gfar_tbipa(void __iomem *p)
+static uint32_t __iomem *get_gfar_tbipa_from_mdio(void __iomem *p)
 {
 	struct gfar __iomem *enet_regs = p;
 	return &enet_regs->tbipa;
 }
+/*
+ * Return the TBIPA address, starting from the address
+ * of the mapped GFAR MII registers (gfar_mii_regs[] within struct gfar)
+ */
+static uint32_t __iomem *get_gfar_tbipa_from_mii(void __iomem *p)
+{
+	return get_gfar_tbipa_from_mdio(container_of(p, struct gfar, gfar_mii_regs));
+}
 /*
  * Return the TBIPAR address for an eTSEC2 node
  */
 #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE)
 /*
- * Return the TBIPAR address for a QE MDIO node
+ * Return the TBIPAR address for a QE MDIO node, starting from the address
+ * of the mapped MII registers (struct fsl_pq_mii)
  */
 static uint32_t __iomem *get_ucc_tbipa(void __iomem *p)
 {
-	struct fsl_pq_mdio __iomem *mdio = p;
+	struct fsl_pq_mdio __iomem *mdio = container_of(p, struct fsl_pq_mdio, mii);
 	return &mdio->utbipar;
 }
 		.compatible = "fsl,gianfar-tbi",
 		.data = &(struct fsl_pq_mdio_data) {
 			.mii_offset = 0,
-			.get_tbipa = get_gfar_tbipa,
+			.get_tbipa = get_gfar_tbipa_from_mii,
 		},
 	},
 	{
 		.compatible = "fsl,gianfar-mdio",
 		.data = &(struct fsl_pq_mdio_data) {
 			.mii_offset = 0,
-			.get_tbipa = get_gfar_tbipa,
+			.get_tbipa = get_gfar_tbipa_from_mii,
 		},
 	},
 	{
 		.compatible = "gianfar",
 		.data = &(struct fsl_pq_mdio_data) {
 			.mii_offset = offsetof(struct fsl_pq_mdio, mii),
-			.get_tbipa = get_gfar_tbipa,
+			.get_tbipa = get_gfar_tbipa_from_mdio,
 		},
 	},
 	{
 			tbipa = data->get_tbipa(priv->map);
+			/*
+			 * Add consistency check to make sure TBI is contained
+			 * within the mapped range (not because we would get a
+			 * segfault, rather to catch bugs in computing TBI
+			 * address). Print error message but continue anyway.
+			 */
+			if ((void *)tbipa > priv->map + resource_size(&res) - 4)
+				dev_err(&pdev->dev, "invalid register map (should be at least 0x%04x to contain TBI address)\n",
+					((void *)tbipa - priv->map) + 4);
 			iowrite32be(be32_to_cpup(prop), tbipa);
 		}
 	}

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

 	hw->aq.asq.next_to_use = 0;
 	hw->aq.asq.next_to_clean = 0;
-	hw->aq.asq.count = hw->aq.num_asq_entries;
 	/* allocate the ring memory */
 	ret_code = i40e_alloc_adminq_asq_ring(hw);
 		goto init_adminq_free_rings;
 	/* success! */
+	hw->aq.asq.count = hw->aq.num_asq_entries;
 	goto init_adminq_exit;
 init_adminq_free_rings:
 	hw->aq.arq.next_to_use = 0;
 	hw->aq.arq.next_to_clean = 0;
-	hw->aq.arq.count = hw->aq.num_arq_entries;
 	/* allocate the ring memory */
 	ret_code = i40e_alloc_adminq_arq_ring(hw);
 		goto init_adminq_free_rings;
 	/* success! */
+	hw->aq.arq.count = hw->aq.num_arq_entries;
 	goto init_adminq_exit;
 init_adminq_free_rings:

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

 	netdev->hw_enc_features |= NETIF_F_IP_CSUM	 |
 				  NETIF_F_GSO_UDP_TUNNEL |
+				  NETIF_F_GSO_GRE	 |
 				  NETIF_F_TSO;
 	netdev->features = NETIF_F_SG		       |
 			   NETIF_F_SCTP_CSUM	       |
 			   NETIF_F_HIGHDMA	       |
 			   NETIF_F_GSO_UDP_TUNNEL      |
+			   NETIF_F_GSO_GRE	       |
 			   NETIF_F_HW_VLAN_CTAG_TX     |
 			   NETIF_F_HW_VLAN_CTAG_RX     |
 			   NETIF_F_HW_VLAN_CTAG_FILTER |

drivers/net/ethernet/intel/i40evf/i40e_adminq.c+2−2

 	hw->aq.asq.next_to_use = 0;
 	hw->aq.asq.next_to_clean = 0;
-	hw->aq.asq.count = hw->aq.num_asq_entries;
 	/* allocate the ring memory */
 	ret_code = i40e_alloc_adminq_asq_ring(hw);
 		goto init_adminq_free_rings;
 	/* success! */
+	hw->aq.asq.count = hw->aq.num_asq_entries;
 	goto init_adminq_exit;
 init_adminq_free_rings:
 	hw->aq.arq.next_to_use = 0;
 	hw->aq.arq.next_to_clean = 0;
-	hw->aq.arq.count = hw->aq.num_arq_entries;
 	/* allocate the ring memory */
 	ret_code = i40e_alloc_adminq_arq_ring(hw);
 		goto init_adminq_free_rings;
 	/* success! */
+	hw->aq.arq.count = hw->aq.num_arq_entries;
 	goto init_adminq_exit;
 init_adminq_free_rings:

drivers/net/ethernet/mellanox/mlx4/eq.c+4−0

 	 * and performing a NOP command
 	 */
 	for(i = 0; !err && (i < dev->caps.num_comp_vectors); ++i) {
+		/* Make sure request_irq was called */
+		if (!priv->eq_table.eq[i].have_irq)
+			continue;
 		/* Temporary use polling for command completions */
 		mlx4_cmd_use_polling(dev);

drivers/net/ethernet/mellanox/mlx4/main.c+2−8

 	if (msi_x) {
 		int nreq = dev->caps.num_ports * num_online_cpus() + 1;
-		bool shared_ports = false;
 		nreq = min_t(int, dev->caps.num_eqs - dev->caps.reserved_eqs,
 			     nreq);
-		if (nreq > MAX_MSIX) {
+		if (nreq > MAX_MSIX)
 			nreq = MAX_MSIX;
-			shared_ports = true;
-		}
 		entries = kcalloc(nreq, sizeof *entries, GFP_KERNEL);
 		if (!entries)
 		bitmap_zero(priv->eq_table.eq[MLX4_EQ_ASYNC].actv_ports.ports,
 			    dev->caps.num_ports);
-		if (MLX4_IS_LEGACY_EQ_MODE(dev->caps))
-			shared_ports = true;
 		for (i = 0; i < dev->caps.num_comp_vectors + 1; i++) {
 			if (i == MLX4_EQ_ASYNC)
 				continue;
 			priv->eq_table.eq[i].irq =
 				entries[i + 1 - !!(i > MLX4_EQ_ASYNC)].vector;
-			if (shared_ports) {
+			if (MLX4_IS_LEGACY_EQ_MODE(dev->caps)) {
 				bitmap_fill(priv->eq_table.eq[i].actv_ports.ports,
 					    dev->caps.num_ports);
 				/* We don't set affinity hint when there

drivers/net/ethernet/mellanox/mlx5/core/en_flow_table.c+14−2

 		return;
 	priv->vlan.filter_disabled = false;
+	if (priv->netdev->flags & IFF_PROMISC)
+		return;
 	mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 }
 		return;
 	priv->vlan.filter_disabled = true;
+	if (priv->netdev->flags & IFF_PROMISC)
+		return;
 	mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 }
 	bool enable_broadcast  = !ea->broadcast_enabled &&  broadcast_enabled;
 	bool disable_broadcast =  ea->broadcast_enabled && !broadcast_enabled;
-	if (enable_promisc)
+	if (enable_promisc) {
 		mlx5e_add_eth_addr_rule(priv, &ea->promisc, MLX5E_PROMISC);
+		if (!priv->vlan.filter_disabled)
+			mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
+					    0);
+	}
 	if (enable_allmulti)
 		mlx5e_add_eth_addr_rule(priv, &ea->allmulti, MLX5E_ALLMULTI);
 	if (enable_broadcast)
 		mlx5e_del_eth_addr_from_flow_table(priv, &ea->broadcast);
 	if (disable_allmulti)
 		mlx5e_del_eth_addr_from_flow_table(priv, &ea->allmulti);
-	if (disable_promisc)
+	if (disable_promisc) {
+		if (!priv->vlan.filter_disabled)
+			mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
+					    0);
 		mlx5e_del_eth_addr_from_flow_table(priv, &ea->promisc);
+	}
 	ea->promisc_enabled   = promisc_enabled;
 	ea->allmulti_enabled  = allmulti_enabled;

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

@@ -311,7 +311,7 @@ static int mlx5_query_port_pvlc(struct mlx5_core_dev dev, u32 pvlc, · 310 unmodified lines
311	int err;	311	int err;
312		312
313	memset(in, 0, sizeof(in));	313	memset(in, 0, sizeof(in));
314	MLX5_SET(ptys_reg, in, local_port, local_port);	314	MLX5_SET(pvlc_reg, in, local_port, local_port);
315		315
316	err = mlx5_core_access_reg(dev, in, sizeof(in), pvlc,	316	err = mlx5_core_access_reg(dev, in, sizeof(in), pvlc,
317	pvlc_size, MLX5_REG_PVLC, 0, 0);	317	pvlc_size, MLX5_REG_PVLC, 0, 0);

drivers/net/ethernet/mellanox/mlxsw/core.c+9−4

 	int err;
 	int ret;
+	mlxsw_core->emad.trans_active = true;
 	err = mlxsw_core_skb_transmit(mlxsw_core->driver_priv, skb, tx_info);
 	if (err) {
 		dev_err(mlxsw_core->bus_info->dev, "Failed to transmit EMAD (tid=%llx)\n",
 			mlxsw_core->emad.tid);
 		dev_kfree_skb(skb);
-		return err;
+		goto trans_inactive_out;
 	}
-	mlxsw_core->emad.trans_active = true;
 	ret = wait_event_timeout(mlxsw_core->emad.wait,
 				 !(mlxsw_core->emad.trans_active),
 				 msecs_to_jiffies(MLXSW_EMAD_TIMEOUT_MS));
 	if (!ret) {
 		dev_warn(mlxsw_core->bus_info->dev, "EMAD timed-out (tid=%llx)\n",
 			 mlxsw_core->emad.tid);
-		mlxsw_core->emad.trans_active = false;
+		err = -EIO;
-		return -EIO;
+		goto trans_inactive_out;
 	}
 	return 0;
+trans_inactive_out:
+	mlxsw_core->emad.trans_active = false;
+	return err;
 }
 static int mlxsw_emad_process_status(struct mlxsw_core *mlxsw_core,

drivers/net/ethernet/mellanox/mlxsw/item.h+3−1

 {
 	u16 max_index, be_index;
 	u16 offset;		/* byte offset inside the array */
+	u8 in_byte_index;
 	BUG_ON(index && !item->element_size);
 	if (item->offset % sizeof(u32) != 0 ||
 	max_index = (item->size.bytes << 3) / item->element_size - 1;
 	be_index = max_index - index;
 	offset = be_index * item->element_size >> 3;
-	*shift = index % (BITS_PER_BYTE / item->element_size) << 1;
+	in_byte_index  = index % (BITS_PER_BYTE / item->element_size);
+	*shift = in_byte_index * item->element_size;
 	return item->offset + offset;
 }

drivers/net/ethernet/mellanox/mlxsw/pci.c+4−4

@@ -1582,11 +1582,11 @@ static int mlxsw_pci_cmd_exec(void *bus_priv, u16 opcode, u8 opcode_mod, · 1581 unmodified lines
1582		1582
1583	if (in_mbox)	1583	if (in_mbox)
1584	memcpy(mlxsw_pci->cmd.in_mbox.buf, in_mbox, in_mbox_size);	1584	memcpy(mlxsw_pci->cmd.in_mbox.buf, in_mbox, in_mbox_size);
1585	mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_HI, in_mapaddr >> 32);	1585	mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_HI, upper_32_bits(in_mapaddr));
1586	mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_LO, in_mapaddr);	1586	mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_LO, lower_32_bits(in_mapaddr));
1587		1587
1588	mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_HI, out_mapaddr >> 32);	1588	mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_HI, upper_32_bits(out_mapaddr));
1589	mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_LO, out_mapaddr);	1589	mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_LO, lower_32_bits(out_mapaddr));
1590		1590
1591	mlxsw_pci_write32(mlxsw_pci, CIR_IN_MODIFIER, in_mod);	1591	mlxsw_pci_write32(mlxsw_pci, CIR_IN_MODIFIER, in_mod);
1592	mlxsw_pci_write32(mlxsw_pci, CIR_TOKEN, 0);	1592	mlxsw_pci_write32(mlxsw_pci, CIR_TOKEN, 0);

drivers/net/ethernet/mellanox/mlxsw/switchx2.c+1−1

 	return 0;
 err_register_netdev:
-err_port_admin_status_set:
 err_port_mac_learning_mode_set:
 err_port_stp_state_set:
+err_port_admin_status_set:
 err_port_mtu_set:
 err_port_speed_set:
 err_port_swid_set:

drivers/net/ethernet/nxp/lpc_eth.c+6−7

 	mac[5] = tmp >> 8;
 }
-static void __lpc_eth_clock_enable(struct netdata_local *pldat,
+static void __lpc_eth_clock_enable(struct netdata_local *pldat, bool enable)
-				   bool enable)
 {
 	if (enable)
-		clk_enable(pldat->clk);
+		clk_prepare_enable(pldat->clk);
 	else
-		clk_disable(pldat->clk);
+		clk_disable_unprepare(pldat->clk);
 }
 static void __lpc_params_setup(struct netdata_local *pldat)
 err_out_iounmap:
 	iounmap(pldat->net_base);
 err_out_disable_clocks:
-	clk_disable(pldat->clk);
+	clk_disable_unprepare(pldat->clk);
 	clk_put(pldat->clk);
 err_out_free_dev:
 	free_netdev(ndev);
 	iounmap(pldat->net_base);
 	mdiobus_unregister(pldat->mii_bus);
 	mdiobus_free(pldat->mii_bus);
-	clk_disable(pldat->clk);
+	clk_disable_unprepare(pldat->clk);
 	clk_put(pldat->clk);
 	free_netdev(ndev);
 		if (netif_running(ndev)) {
 			netif_device_detach(ndev);
 			__lpc_eth_shutdown(pldat);
-			clk_disable(pldat->clk);
+			clk_disable_unprepare(pldat->clk);
 			/*
 			 * Reset again now clock is disable to be sure

drivers/net/ethernet/via/via-rhine.c+2−1

@@ -2134,10 +2134,11 @@ static int rhine_rx(struct net_device *dev, int limit) · 2133 unmodified lines
2134	}	2134	}
2135		2135
2136	skb_put(skb, pkt_len);	2136	skb_put(skb, pkt_len);
2137	skb->protocol = eth_type_trans(skb, dev);
2138		2137
2139	rhine_rx_vlan_tag(skb, desc, data_size);	2138	rhine_rx_vlan_tag(skb, desc, data_size);
2140		2139
		2140	skb->protocol = eth_type_trans(skb, dev);
		2141
2141	netif_receive_skb(skb);	2142	netif_receive_skb(skb);
2142		2143
2143	u64_stats_update_begin(&rp->rx_stats.syncp);	2144	u64_stats_update_begin(&rp->rx_stats.syncp);

drivers/net/geneve.c+6−6

@@ -870,14 +870,14 @@ static int geneve_newlink(struct net net, struct net_device dev, · 869 unmodified lines
870	__be16 dst_port = htons(GENEVE_UDP_PORT);	870	__be16 dst_port = htons(GENEVE_UDP_PORT);
871	__u8 ttl = 0, tos = 0;	871	__u8 ttl = 0, tos = 0;
872	bool metadata = false;	872	bool metadata = false;
873	__be32 rem_addr;	873	__be32 rem_addr = 0;
874	__u32 vni;	874	__u32 vni = 0;
875		875
876	if (!data[IFLA_GENEVE_ID] \|\| !data[IFLA_GENEVE_REMOTE])	876	if (data[IFLA_GENEVE_ID])
877	return -EINVAL;	877	vni = nla_get_u32(data[IFLA_GENEVE_ID]);
878		878
879	vni = nla_get_u32(data[IFLA_GENEVE_ID]);	879	if (data[IFLA_GENEVE_REMOTE])
880	rem_addr = nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);	880	rem_addr = nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
881		881
882	if (data[IFLA_GENEVE_TTL])	882	if (data[IFLA_GENEVE_TTL])
883	ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);	883	ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);

drivers/net/phy/Kconfig+0−2

@@ -168,8 +168,6 @@ config MDIO_OCTEON · 167 unmodified lines
168	busses. It is required by the Octeon and ThunderX ethernet device	168	busses. It is required by the Octeon and ThunderX ethernet device
169	drivers.	169	drivers.
170		170
171	If in doubt, say Y.
172
173	config MDIO_SUN4I	171	config MDIO_SUN4I
174	tristate "Allwinner sun4i MDIO interface support"	172	tristate "Allwinner sun4i MDIO interface support"
175	depends on ARCH_SUNXI	173	depends on ARCH_SUNXI

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

@@ -313,7 +313,6 @@ static void pppoe_flush_dev(struct net_device *dev) · 312 unmodified lines
313	if (po->pppoe_dev == dev &&	313	if (po->pppoe_dev == dev &&
314	sk->sk_state & (PPPOX_CONNECTED \| PPPOX_BOUND \| PPPOX_ZOMBIE)) {	314	sk->sk_state & (PPPOX_CONNECTED \| PPPOX_BOUND \| PPPOX_ZOMBIE)) {
315	pppox_unbind_sock(sk);	315	pppox_unbind_sock(sk);
316	sk->sk_state = PPPOX_ZOMBIE;
317	sk->sk_state_change(sk);	316	sk->sk_state_change(sk);
318	po->pppoe_dev = NULL;	317	po->pppoe_dev = NULL;
319	dev_put(dev);	318	dev_put(dev);

drivers/net/usb/Kconfig+1−0

@@ -164,6 +164,7 @@ config USB_NET_AX8817X · 163 unmodified lines
164	* Aten UC210T	164	* Aten UC210T
165	* ASIX AX88172	165	* ASIX AX88172
166	* Billionton Systems, USB2AR	166	* Billionton Systems, USB2AR
		167	* Billionton Systems, GUSB2AM-1G-B
167	* Buffalo LUA-U2-KTX	168	* Buffalo LUA-U2-KTX
168	* Corega FEther USB2-TX	169	* Corega FEther USB2-TX
169	* D-Link DUB-E100	170	* D-Link DUB-E100

drivers/net/usb/asix_common.c+3−1

 			}
 			rx->ax_skb = netdev_alloc_skb_ip_align(dev->net,
 							       rx->size);
-			if (!rx->ax_skb)
+			if (!rx->ax_skb) {
+				rx->size = 0;
 				return 0;
+			}
 		}
 		if (rx->size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) {

drivers/net/usb/asix_devices.c+4−0

 	// Billionton Systems, USB2AR
 	USB_DEVICE (0x08dd, 0x90ff),
 	.driver_info =  (unsigned long) &ax8817x_info,
+}, {
+	// Billionton Systems, GUSB2AM-1G-B
+	USB_DEVICE(0x08dd, 0x0114),
+	.driver_info =  (unsigned long) &ax88178_info,
 }, {
 	// ATEN UC210T
 	USB_DEVICE (0x0557, 0x2009),

drivers/net/vxlan.c+3−4

@@ -2745,11 +2745,10 @@ static int vxlan_newlink(struct net src_net, struct net_device dev, · 2744 unmodified lines
2745	struct vxlan_config conf;	2745	struct vxlan_config conf;
2746	int err;	2746	int err;
2747		2747
2748	if (!data[IFLA_VXLAN_ID])
2749	return -EINVAL;
2750
2751	memset(&conf, 0, sizeof(conf));	2748	memset(&conf, 0, sizeof(conf));
2752	conf.vni = nla_get_u32(data[IFLA_VXLAN_ID]);	2749
		2750	if (data[IFLA_VXLAN_ID])
		2751	conf.vni = nla_get_u32(data[IFLA_VXLAN_ID]);
2753		2752
2754	if (data[IFLA_VXLAN_GROUP]) {	2753	if (data[IFLA_VXLAN_GROUP]) {
2755	conf.remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);	2754	conf.remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);

drivers/net/wireless/ath/ath10k/hw.h+2−2

@@ -337,7 +337,7 @@ enum ath10k_hw_rate_cck { · 336 unmodified lines
337	#define TARGET_10X_MAX_FRAG_ENTRIES 0	337	#define TARGET_10X_MAX_FRAG_ENTRIES 0
338		338
339	/* 10.2 parameters */	339	/* 10.2 parameters */
340	#define TARGET_10_2_DMA_BURST_SIZE 1	340	#define TARGET_10_2_DMA_BURST_SIZE 0
341		341
342	/* Target specific defines for WMI-TLV firmware */	342	/* Target specific defines for WMI-TLV firmware */
343	#define TARGET_TLV_NUM_VDEVS 4	343	#define TARGET_TLV_NUM_VDEVS 4
@@ -391,7 +391,7 @@ enum ath10k_hw_rate_cck { · 47 unmodified lines
391		391
392	#define TARGET_10_4_TX_DBG_LOG_SIZE 1024	392	#define TARGET_10_4_TX_DBG_LOG_SIZE 1024
393	#define TARGET_10_4_NUM_WDS_ENTRIES 32	393	#define TARGET_10_4_NUM_WDS_ENTRIES 32
394	#define TARGET_10_4_DMA_BURST_SIZE 1	394	#define TARGET_10_4_DMA_BURST_SIZE 0
395	#define TARGET_10_4_MAC_AGGR_DELIM 0	395	#define TARGET_10_4_MAC_AGGR_DELIM 0
396	#define TARGET_10_4_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK 1	396	#define TARGET_10_4_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK 1
397	#define TARGET_10_4_VOW_CONFIG 0	397	#define TARGET_10_4_VOW_CONFIG 0

drivers/net/wireless/ath/ath9k/init.c+1−0

@@ -880,6 +880,7 @@ static void ath9k_set_hw_capab(struct ath_softc sc, struct ieee80211_hw hw) · 879 unmodified lines
880	hw->max_rate_tries = 10;	880	hw->max_rate_tries = 10;
881	hw->sta_data_size = sizeof(struct ath_node);	881	hw->sta_data_size = sizeof(struct ath_node);
882	hw->vif_data_size = sizeof(struct ath_vif);	882	hw->vif_data_size = sizeof(struct ath_vif);
		883	hw->extra_tx_headroom = 4;
883		884
884	hw->wiphy->available_antennas_rx = BIT(ah->caps.max_rxchains) - 1;	885	hw->wiphy->available_antennas_rx = BIT(ah->caps.max_rxchains) - 1;
885	hw->wiphy->available_antennas_tx = BIT(ah->caps.max_txchains) - 1;	886	hw->wiphy->available_antennas_tx = BIT(ah->caps.max_txchains) - 1;

drivers/net/wireless/b43/main.c+1−0

@@ -120,6 +120,7 @@ MODULE_PARM_DESC(allhwsupport, "Enable support for all hardware (even it if over · 119 unmodified lines
120	#ifdef CONFIG_B43_BCMA	120	#ifdef CONFIG_B43_BCMA
121	static const struct bcma_device_id b43_bcma_tbl[] = {	121	static const struct bcma_device_id b43_bcma_tbl[] = {
122	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x11, BCMA_ANY_CLASS),	122	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x11, BCMA_ANY_CLASS),
		123	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x15, BCMA_ANY_CLASS),
123	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x17, BCMA_ANY_CLASS),	124	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x17, BCMA_ANY_CLASS),
124	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x18, BCMA_ANY_CLASS),	125	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x18, BCMA_ANY_CLASS),
125	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x1C, BCMA_ANY_CLASS),	126	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x1C, BCMA_ANY_CLASS),

drivers/net/wireless/iwlwifi/dvm/lib.c+1−1

@@ -1020,7 +1020,7 @@ static void iwlagn_wowlan_program_keys(struct ieee80211_hw *hw, · 1019 unmodified lines
1020	u8 *pn = seq.ccmp.pn;	1020	u8 *pn = seq.ccmp.pn;
1021		1021
1022	ieee80211_get_key_rx_seq(key, i, &seq);	1022	ieee80211_get_key_rx_seq(key, i, &seq);
1023	aes_sc->pn = cpu_to_le64(	1023	aes_sc[i].pn = cpu_to_le64(
1024	(u64)pn[5] \|	1024	(u64)pn[5] \|
1025	((u64)pn[4] << 8) \|	1025	((u64)pn[4] << 8) \|
1026	((u64)pn[3] << 16) \|	1026	((u64)pn[3] << 16) \|

drivers/net/wireless/iwlwifi/iwl-7000.c+1−1

@@ -348,6 +348,6 @@ const struct iwl_cfg iwl7265d_n_cfg = { · 347 unmodified lines
348	};	348	};
349		349
350	MODULE_FIRMWARE(IWL7260_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));	350	MODULE_FIRMWARE(IWL7260_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));
351	MODULE_FIRMWARE(IWL3160_MODULE_FIRMWARE(IWL3160_UCODE_API_OK));	351	MODULE_FIRMWARE(IWL3160_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));
352	MODULE_FIRMWARE(IWL7265_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));	352	MODULE_FIRMWARE(IWL7265_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));
353	MODULE_FIRMWARE(IWL7265D_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));	353	MODULE_FIRMWARE(IWL7265D_MODULE_FIRMWARE(IWL7260_UCODE_API_OK));

drivers/net/wireless/iwlwifi/mvm/d3.c+11−16

 		break;
 	case WLAN_CIPHER_SUITE_CCMP:
 		if (sta) {
-			u8 *pn = seq.ccmp.pn;
+			u64 pn64;
 			aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
 			aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
-			ieee80211_get_key_tx_seq(key, &seq);
+			pn64 = atomic64_read(&key->tx_pn);
-			aes_tx_sc->pn = cpu_to_le64((u64)pn[5] |
+			aes_tx_sc->pn = cpu_to_le64(pn64);
-						    ((u64)pn[4] << 8) |
-						    ((u64)pn[3] << 16) |
-						    ((u64)pn[2] << 24) |
-						    ((u64)pn[1] << 32) |
-						    ((u64)pn[0] << 40));
 		} else {
 			aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
 		}
 			u8 *pn = seq.ccmp.pn;
 			ieee80211_get_key_rx_seq(key, i, &seq);
-			aes_sc->pn = cpu_to_le64((u64)pn[5] |
+			aes_sc[i].pn = cpu_to_le64((u64)pn[5] |
-						 ((u64)pn[4] << 8) |
+						   ((u64)pn[4] << 8) |
-						 ((u64)pn[3] << 16) |
+						   ((u64)pn[3] << 16) |
-						 ((u64)pn[2] << 24) |
+						   ((u64)pn[2] << 24) |
-						 ((u64)pn[1] << 32) |
+						   ((u64)pn[1] << 32) |
-						 ((u64)pn[0] << 40));
+						   ((u64)pn[0] << 40));
 		}
 		data->use_rsc_tsc = true;
 		break;
 		switch (key->cipher) {
 		case WLAN_CIPHER_SUITE_CCMP:
-			iwl_mvm_aes_sc_to_seq(&sc->aes.tsc, &seq);
 			iwl_mvm_set_aes_rx_seq(sc->aes.unicast_rsc, key);
+			atomic64_set(&key->tx_pn, le64_to_cpu(sc->aes.tsc.pn));
 			break;
 		case WLAN_CIPHER_SUITE_TKIP:
 			iwl_mvm_tkip_sc_to_seq(&sc->tkip.tsc, &seq);
 			iwl_mvm_set_tkip_rx_seq(sc->tkip.unicast_rsc, key);
+			ieee80211_set_key_tx_seq(key, &seq);
 			break;
 		}
-		ieee80211_set_key_tx_seq(key, &seq);
 		/* that's it for this key */
 		return;

drivers/net/wireless/iwlwifi/mvm/fw.c+2−2

@@ -703,7 +703,7 @@ int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm) · 702 unmodified lines
703	* abort after reading the nvm in case RF Kill is on, we will complete	703	* abort after reading the nvm in case RF Kill is on, we will complete
704	* the init seq later when RF kill will switch to off	704	* the init seq later when RF kill will switch to off
705	*/	705	*/
706	if (iwl_mvm_is_radio_killed(mvm)) {	706	if (iwl_mvm_is_radio_hw_killed(mvm)) {
707	IWL_DEBUG_RF_KILL(mvm,	707	IWL_DEBUG_RF_KILL(mvm,
708	"jump over all phy activities due to RF kill\n");	708	"jump over all phy activities due to RF kill\n");
709	iwl_remove_notification(&mvm->notif_wait, &calib_wait);	709	iwl_remove_notification(&mvm->notif_wait, &calib_wait);
@@ -736,7 +736,7 @@ int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm) · 26 unmodified lines
736	ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,	736	ret = iwl_wait_notification(&mvm->notif_wait, &calib_wait,
737	MVM_UCODE_CALIB_TIMEOUT);	737	MVM_UCODE_CALIB_TIMEOUT);
738		738
739	if (ret && iwl_mvm_is_radio_killed(mvm)) {	739	if (ret && iwl_mvm_is_radio_hw_killed(mvm)) {
740	IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");	740	IWL_DEBUG_RF_KILL(mvm, "RFKILL while calibrating.\n");
741	ret = 1;	741	ret = 1;
742	}	742	}

drivers/net/wireless/iwlwifi/mvm/mac80211.c+1−0

@@ -2388,6 +2388,7 @@ static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw, · 2387 unmodified lines
2388	iwl_mvm_remove_time_event(mvm, mvmvif,	2388	iwl_mvm_remove_time_event(mvm, mvmvif,
2389	&mvmvif->time_event_data);	2389	&mvmvif->time_event_data);
2390	RCU_INIT_POINTER(mvm->csa_vif, NULL);	2390	RCU_INIT_POINTER(mvm->csa_vif, NULL);
		2391	mvmvif->csa_countdown = false;
2391	}	2392	}
2392		2393
2393	if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {	2394	if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {

drivers/net/wireless/iwlwifi/mvm/mvm.h+5−0

 	       test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status);
 }
+static inline bool iwl_mvm_is_radio_hw_killed(struct iwl_mvm *mvm)
+{
+	return test_bit(IWL_MVM_STATUS_HW_RFKILL, &mvm->status);
+}
 /* Must be called with rcu_read_lock() held and it can only be
  * released when mvmsta is not needed anymore.
  */

drivers/net/wireless/iwlwifi/mvm/ops.c+1−0

@@ -590,6 +590,7 @@ iwl_op_mode_mvm_start(struct iwl_trans trans, const struct iwl_cfg cfg, · 589 unmodified lines
590	ieee80211_unregister_hw(mvm->hw);	590	ieee80211_unregister_hw(mvm->hw);
591	iwl_mvm_leds_exit(mvm);	591	iwl_mvm_leds_exit(mvm);
592	out_free:	592	out_free:
		593	flush_delayed_work(&mvm->fw_dump_wk);
593	iwl_phy_db_free(mvm->phy_db);	594	iwl_phy_db_free(mvm->phy_db);
594	kfree(mvm->scan_cmd);	595	kfree(mvm->scan_cmd);
595	if (!cfg->no_power_up_nic_in_init \|\| !mvm->nvm_file_name)	596	if (!cfg->no_power_up_nic_in_init \|\| !mvm->nvm_file_name)

drivers/net/wireless/iwlwifi/pcie/drv.c+5−0

 	{IWL_PCI_DEVICE(0x095A, 0x5590, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095B, 0x5290, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x095A, 0x5490, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095A, 0x5F10, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095B, 0x5212, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095B, 0x520A, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095A, 0x9000, iwl7265_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x095A, 0x9400, iwl7265_2ac_cfg)},
 /* 8000 Series */
 	{IWL_PCI_DEVICE(0x24F3, 0x0010, iwl8260_2ac_cfg)},

drivers/net/wireless/rt2x00/rt2800usb.c+1−0

@@ -1114,6 +1114,7 @@ static struct usb_device_id rt2800usb_device_table[] = { · 1113 unmodified lines
1114	{ USB_DEVICE(0x0db0, 0x871c) },	1114	{ USB_DEVICE(0x0db0, 0x871c) },
1115	{ USB_DEVICE(0x0db0, 0x899a) },	1115	{ USB_DEVICE(0x0db0, 0x899a) },
1116	/* Ovislink */	1116	/* Ovislink */
		1117	{ USB_DEVICE(0x1b75, 0x3070) },
1117	{ USB_DEVICE(0x1b75, 0x3071) },	1118	{ USB_DEVICE(0x1b75, 0x3071) },
1118	{ USB_DEVICE(0x1b75, 0x3072) },	1119	{ USB_DEVICE(0x1b75, 0x3072) },
1119	{ USB_DEVICE(0x1b75, 0xa200) },	1120	{ USB_DEVICE(0x1b75, 0xa200) },

drivers/net/wireless/rtlwifi/pci.h+2−0

@@ -247,6 +247,8 @@ struct rtl_pci { · 246 unmodified lines
247	/* MSI support */	247	/* MSI support */
248	bool msi_support;	248	bool msi_support;
249	bool using_msi;	249	bool using_msi;
		250	/* interrupt clear before set */
		251	bool int_clear;
250	};	252	};
251		253
252	struct mp_adapter {	254	struct mp_adapter {

drivers/net/wireless/rtlwifi/rtl8821ae/hw.c+17−0

@@ -2253,11 +2253,28 @@ void rtl8821ae_set_qos(struct ieee80211_hw *hw, int aci) · 2252 unmodified lines
2253	}	2253	}
2254	}	2254	}
2255		2255
		2256	static void rtl8821ae_clear_interrupt(struct ieee80211_hw *hw)
		2257	{
		2258	struct rtl_priv *rtlpriv = rtl_priv(hw);
		2259	u32 tmp = rtl_read_dword(rtlpriv, REG_HISR);
		2260
		2261	rtl_write_dword(rtlpriv, REG_HISR, tmp);
		2262
		2263	tmp = rtl_read_dword(rtlpriv, REG_HISRE);
		2264	rtl_write_dword(rtlpriv, REG_HISRE, tmp);
		2265
		2266	tmp = rtl_read_dword(rtlpriv, REG_HSISR);
		2267	rtl_write_dword(rtlpriv, REG_HSISR, tmp);
		2268	}
		2269
2256	void rtl8821ae_enable_interrupt(struct ieee80211_hw *hw)	2270	void rtl8821ae_enable_interrupt(struct ieee80211_hw *hw)
2257	{	2271	{
2258	struct rtl_priv *rtlpriv = rtl_priv(hw);	2272	struct rtl_priv *rtlpriv = rtl_priv(hw);
2259	struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));	2273	struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
2260		2274
		2275	if (!rtlpci->int_clear)
		2276	rtl8821ae_clear_interrupt(hw);/clear it here first/
		2277
2261	rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF);	2278	rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF);
2262	rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF);	2279	rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF);
2263	rtlpci->irq_enabled = true;	2280	rtlpci->irq_enabled = true;

drivers/net/wireless/rtlwifi/rtl8821ae/sw.c+5−0

 	rtl8821ae_bt_reg_init(hw);
 	rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support;
+	rtlpci->int_clear = rtlpriv->cfg->mod_params->int_clear;
 	rtlpriv->btcoexist.btc_ops = rtl_btc_get_ops_pointer();
 	rtlpriv->dm.dm_initialgain_enable = 1;
 	rtlpriv->psc.swctrl_lps = rtlpriv->cfg->mod_params->swctrl_lps;
 	rtlpriv->psc.fwctrl_lps = rtlpriv->cfg->mod_params->fwctrl_lps;
 	rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support;
+	rtlpci->msi_support = rtlpriv->cfg->mod_params->int_clear;
 	if (rtlpriv->cfg->mod_params->disable_watchdog)
 		pr_info("watchdog disabled\n");
 	rtlpriv->psc.reg_fwctrl_lps = 3;
 	.swctrl_lps = false,
 	.fwctrl_lps = true,
 	.msi_support = true,
+	.int_clear = true,
 	.debug = DBG_EMERG,
 	.disable_watchdog = 0,
 };
 module_param_named(msi, rtl8821ae_mod_params.msi_support, bool, 0444);
 module_param_named(disable_watchdog, rtl8821ae_mod_params.disable_watchdog,
 		   bool, 0444);
+module_param_named(int_clear, rtl8821ae_mod_params.int_clear, bool, 0444);
 MODULE_PARM_DESC(swenc, "Set to 1 for software crypto (default 0)\n");
 MODULE_PARM_DESC(ips, "Set to 0 to not use link power save (default 1)\n");
 MODULE_PARM_DESC(swlps, "Set to 1 to use SW control power save (default 0)\n");
 MODULE_PARM_DESC(msi, "Set to 1 to use MSI interrupts mode (default 1)\n");
 MODULE_PARM_DESC(debug, "Set debug level (0-5) (default 0)");
 MODULE_PARM_DESC(disable_watchdog, "Set to 1 to disable the watchdog (default 0)\n");
+MODULE_PARM_DESC(int_clear, "Set to 1 to disable interrupt clear before set (default 0)\n");
 static SIMPLE_DEV_PM_OPS(rtlwifi_pm_ops, rtl_pci_suspend, rtl_pci_resume);

drivers/net/wireless/rtlwifi/wifi.h+3−0

@@ -2249,6 +2249,9 @@ struct rtl_mod_params { · 2248 unmodified lines
2249		2249
2250	/* default 0: 1 means disable */	2250	/* default 0: 1 means disable */
2251	bool disable_watchdog;	2251	bool disable_watchdog;
		2252
		2253	/* default 0: 1 means do not disable interrupts */
		2254	bool int_clear;
2252	};	2255	};
2253		2256
2254	struct rtl_hal_usbint_cfg {	2257	struct rtl_hal_usbint_cfg {

drivers/net/xen-netback/xenbus.c+6−0

 	/* Use the number of queues requested by the frontend */
 	be->vif->queues = vzalloc(requested_num_queues *
 				  sizeof(struct xenvif_queue));
+	if (!be->vif->queues) {
+		xenbus_dev_fatal(dev, -ENOMEM,
+				 "allocating queues");
+		return;
+	}
 	be->vif->num_queues = requested_num_queues;
 	be->vif->stalled_queues = requested_num_queues;

drivers/pci/msi.c+4−0

 	BUG_ON(!chip);
 	if (!chip->irq_write_msi_msg)
 		chip->irq_write_msi_msg = pci_msi_domain_write_msg;
+	if (!chip->irq_mask)
+		chip->irq_mask = pci_msi_mask_irq;
+	if (!chip->irq_unmask)
+		chip->irq_unmask = pci_msi_unmask_irq;
 }
 /**

drivers/perf/arm_pmu.c+8−2

 		}
 		/* Now look up the logical CPU number */
-		for_each_possible_cpu(cpu)
+		for_each_possible_cpu(cpu) {
-			if (dn == of_cpu_device_node_get(cpu))
+			struct device_node *cpu_dn;
+			cpu_dn = of_cpu_device_node_get(cpu);
+			of_node_put(cpu_dn);
+			if (dn == cpu_dn)
 				break;
+		}
 		if (cpu >= nr_cpu_ids) {
 			pr_warn("Failed to find logical CPU for %s\n",

drivers/pinctrl/freescale/pinctrl-imx25.c+3−1

 #include "pinctrl-imx.h"
 enum imx25_pads {
-	MX25_PAD_RESERVE0 = 1,
+	MX25_PAD_RESERVE0 = 0,
+	MX25_PAD_RESERVE1 = 1,
 	MX25_PAD_A10 = 2,
 	MX25_PAD_A13 = 3,
 	MX25_PAD_A14 = 4,
 /* Pad names for the pinmux subsystem */
 static const struct pinctrl_pin_desc imx25_pinctrl_pads[] = {
 	IMX_PINCTRL_PIN(MX25_PAD_RESERVE0),
+	IMX_PINCTRL_PIN(MX25_PAD_RESERVE1),
 	IMX_PINCTRL_PIN(MX25_PAD_A10),
 	IMX_PINCTRL_PIN(MX25_PAD_A13),
 	IMX_PINCTRL_PIN(MX25_PAD_A14),

drivers/pinctrl/sunxi/pinctrl-sun5i-a10s.c+1−1

@@ -653,7 +653,7 @@ static const struct sunxi_desc_pin sun5i_a10s_pins[] = { · 652 unmodified lines
653	SUNXI_FUNCTION(0x0, "gpio_in"),	653	SUNXI_FUNCTION(0x0, "gpio_in"),
654	SUNXI_FUNCTION(0x1, "gpio_out"),	654	SUNXI_FUNCTION(0x1, "gpio_out"),
655	SUNXI_FUNCTION(0x2, "spi1"), /* CS1 */	655	SUNXI_FUNCTION(0x2, "spi1"), /* CS1 */
656	SUNXI_FUNCTION(0x3, "uart3"), /* PWM1 */	656	SUNXI_FUNCTION(0x3, "pwm"), /* PWM1 */
657	SUNXI_FUNCTION(0x5, "uart2"), /* CTS */	657	SUNXI_FUNCTION(0x5, "uart2"), /* CTS */
658	SUNXI_FUNCTION_IRQ(0x6, 13)), /* EINT13 */	658	SUNXI_FUNCTION_IRQ(0x6, 13)), /* EINT13 */
659	};	659	};

drivers/pinctrl/uniphier/pinctrl-ph1-sld8.c+113−113

@@ -22,49 +22,49 @@ · 21 unmodified lines
22	#define DRIVER_NAME "ph1-sld8-pinctrl"	22	#define DRIVER_NAME "ph1-sld8-pinctrl"
23		23
24	static const struct pinctrl_pin_desc ph1_sld8_pins[] = {	24	static const struct pinctrl_pin_desc ph1_sld8_pins[] = {
25	UNIPHIER_PINCTRL_PIN(0, "PCA00", UNIPHIER_PIN_IECTRL_NONE,	25	UNIPHIER_PINCTRL_PIN(0, "PCA00", 0,
26	15, UNIPHIER_PIN_DRV_4_8,	26	15, UNIPHIER_PIN_DRV_4_8,
27	15, UNIPHIER_PIN_PULL_DOWN),	27	15, UNIPHIER_PIN_PULL_DOWN),
28	UNIPHIER_PINCTRL_PIN(1, "PCA01", UNIPHIER_PIN_IECTRL_NONE,	28	UNIPHIER_PINCTRL_PIN(1, "PCA01", 0,
29	16, UNIPHIER_PIN_DRV_4_8,	29	16, UNIPHIER_PIN_DRV_4_8,
30	16, UNIPHIER_PIN_PULL_DOWN),	30	16, UNIPHIER_PIN_PULL_DOWN),
31	UNIPHIER_PINCTRL_PIN(2, "PCA02", UNIPHIER_PIN_IECTRL_NONE,	31	UNIPHIER_PINCTRL_PIN(2, "PCA02", 0,
32	17, UNIPHIER_PIN_DRV_4_8,	32	17, UNIPHIER_PIN_DRV_4_8,
33	17, UNIPHIER_PIN_PULL_DOWN),	33	17, UNIPHIER_PIN_PULL_DOWN),
34	UNIPHIER_PINCTRL_PIN(3, "PCA03", UNIPHIER_PIN_IECTRL_NONE,	34	UNIPHIER_PINCTRL_PIN(3, "PCA03", 0,
35	18, UNIPHIER_PIN_DRV_4_8,	35	18, UNIPHIER_PIN_DRV_4_8,
36	18, UNIPHIER_PIN_PULL_DOWN),	36	18, UNIPHIER_PIN_PULL_DOWN),
37	UNIPHIER_PINCTRL_PIN(4, "PCA04", UNIPHIER_PIN_IECTRL_NONE,	37	UNIPHIER_PINCTRL_PIN(4, "PCA04", 0,
38	19, UNIPHIER_PIN_DRV_4_8,	38	19, UNIPHIER_PIN_DRV_4_8,
39	19, UNIPHIER_PIN_PULL_DOWN),	39	19, UNIPHIER_PIN_PULL_DOWN),
40	UNIPHIER_PINCTRL_PIN(5, "PCA05", UNIPHIER_PIN_IECTRL_NONE,	40	UNIPHIER_PINCTRL_PIN(5, "PCA05", 0,
41	20, UNIPHIER_PIN_DRV_4_8,	41	20, UNIPHIER_PIN_DRV_4_8,
42	20, UNIPHIER_PIN_PULL_DOWN),	42	20, UNIPHIER_PIN_PULL_DOWN),
43	UNIPHIER_PINCTRL_PIN(6, "PCA06", UNIPHIER_PIN_IECTRL_NONE,	43	UNIPHIER_PINCTRL_PIN(6, "PCA06", 0,
44	21, UNIPHIER_PIN_DRV_4_8,	44	21, UNIPHIER_PIN_DRV_4_8,
45	21, UNIPHIER_PIN_PULL_DOWN),	45	21, UNIPHIER_PIN_PULL_DOWN),
46	UNIPHIER_PINCTRL_PIN(7, "PCA07", UNIPHIER_PIN_IECTRL_NONE,	46	UNIPHIER_PINCTRL_PIN(7, "PCA07", 0,
47	22, UNIPHIER_PIN_DRV_4_8,	47	22, UNIPHIER_PIN_DRV_4_8,
48	22, UNIPHIER_PIN_PULL_DOWN),	48	22, UNIPHIER_PIN_PULL_DOWN),
49	UNIPHIER_PINCTRL_PIN(8, "PCA08", UNIPHIER_PIN_IECTRL_NONE,	49	UNIPHIER_PINCTRL_PIN(8, "PCA08", 0,
50	23, UNIPHIER_PIN_DRV_4_8,	50	23, UNIPHIER_PIN_DRV_4_8,
51	23, UNIPHIER_PIN_PULL_DOWN),	51	23, UNIPHIER_PIN_PULL_DOWN),
52	UNIPHIER_PINCTRL_PIN(9, "PCA09", UNIPHIER_PIN_IECTRL_NONE,	52	UNIPHIER_PINCTRL_PIN(9, "PCA09", 0,
53	24, UNIPHIER_PIN_DRV_4_8,	53	24, UNIPHIER_PIN_DRV_4_8,
54	24, UNIPHIER_PIN_PULL_DOWN),	54	24, UNIPHIER_PIN_PULL_DOWN),
55	UNIPHIER_PINCTRL_PIN(10, "PCA10", UNIPHIER_PIN_IECTRL_NONE,	55	UNIPHIER_PINCTRL_PIN(10, "PCA10", 0,
56	25, UNIPHIER_PIN_DRV_4_8,	56	25, UNIPHIER_PIN_DRV_4_8,
57	25, UNIPHIER_PIN_PULL_DOWN),	57	25, UNIPHIER_PIN_PULL_DOWN),
58	UNIPHIER_PINCTRL_PIN(11, "PCA11", UNIPHIER_PIN_IECTRL_NONE,	58	UNIPHIER_PINCTRL_PIN(11, "PCA11", 0,
59	26, UNIPHIER_PIN_DRV_4_8,	59	26, UNIPHIER_PIN_DRV_4_8,
60	26, UNIPHIER_PIN_PULL_DOWN),	60	26, UNIPHIER_PIN_PULL_DOWN),
61	UNIPHIER_PINCTRL_PIN(12, "PCA12", UNIPHIER_PIN_IECTRL_NONE,	61	UNIPHIER_PINCTRL_PIN(12, "PCA12", 0,
62	27, UNIPHIER_PIN_DRV_4_8,	62	27, UNIPHIER_PIN_DRV_4_8,
63	27, UNIPHIER_PIN_PULL_DOWN),	63	27, UNIPHIER_PIN_PULL_DOWN),
64	UNIPHIER_PINCTRL_PIN(13, "PCA13", UNIPHIER_PIN_IECTRL_NONE,	64	UNIPHIER_PINCTRL_PIN(13, "PCA13", 0,
65	28, UNIPHIER_PIN_DRV_4_8,	65	28, UNIPHIER_PIN_DRV_4_8,
66	28, UNIPHIER_PIN_PULL_DOWN),	66	28, UNIPHIER_PIN_PULL_DOWN),
67	UNIPHIER_PINCTRL_PIN(14, "PCA14", UNIPHIER_PIN_IECTRL_NONE,	67	UNIPHIER_PINCTRL_PIN(14, "PCA14", 0,
68	29, UNIPHIER_PIN_DRV_4_8,	68	29, UNIPHIER_PIN_DRV_4_8,
69	29, UNIPHIER_PIN_PULL_DOWN),	69	29, UNIPHIER_PIN_PULL_DOWN),
70	UNIPHIER_PINCTRL_PIN(15, "XNFRE_GB", UNIPHIER_PIN_IECTRL_NONE,	70	UNIPHIER_PINCTRL_PIN(15, "XNFRE_GB", UNIPHIER_PIN_IECTRL_NONE,
@@ -118,199 +118,199 @@ static const struct pinctrl_pin_desc ph1_sld8_pins[] = { · 47 unmodified lines
118	UNIPHIER_PINCTRL_PIN(31, "NFD7_GB", UNIPHIER_PIN_IECTRL_NONE,	118	UNIPHIER_PINCTRL_PIN(31, "NFD7_GB", UNIPHIER_PIN_IECTRL_NONE,
119	36, UNIPHIER_PIN_DRV_8_12_16_20,	119	36, UNIPHIER_PIN_DRV_8_12_16_20,
120	128, UNIPHIER_PIN_PULL_UP),	120	128, UNIPHIER_PIN_PULL_UP),
121	UNIPHIER_PINCTRL_PIN(32, "SDCLK", UNIPHIER_PIN_IECTRL_NONE,	121	UNIPHIER_PINCTRL_PIN(32, "SDCLK", 8,
122	40, UNIPHIER_PIN_DRV_8_12_16_20,	122	40, UNIPHIER_PIN_DRV_8_12_16_20,
123	-1, UNIPHIER_PIN_PULL_NONE),	123	-1, UNIPHIER_PIN_PULL_NONE),
124	UNIPHIER_PINCTRL_PIN(33, "SDCMD", UNIPHIER_PIN_IECTRL_NONE,	124	UNIPHIER_PINCTRL_PIN(33, "SDCMD", 8,
125	44, UNIPHIER_PIN_DRV_8_12_16_20,	125	44, UNIPHIER_PIN_DRV_8_12_16_20,
126	-1, UNIPHIER_PIN_PULL_NONE),	126	-1, UNIPHIER_PIN_PULL_NONE),
127	UNIPHIER_PINCTRL_PIN(34, "SDDAT0", UNIPHIER_PIN_IECTRL_NONE,	127	UNIPHIER_PINCTRL_PIN(34, "SDDAT0", 8,
128	48, UNIPHIER_PIN_DRV_8_12_16_20,	128	48, UNIPHIER_PIN_DRV_8_12_16_20,
129	-1, UNIPHIER_PIN_PULL_NONE),	129	-1, UNIPHIER_PIN_PULL_NONE),
130	UNIPHIER_PINCTRL_PIN(35, "SDDAT1", UNIPHIER_PIN_IECTRL_NONE,	130	UNIPHIER_PINCTRL_PIN(35, "SDDAT1", 8,
131	52, UNIPHIER_PIN_DRV_8_12_16_20,	131	52, UNIPHIER_PIN_DRV_8_12_16_20,
132	-1, UNIPHIER_PIN_PULL_NONE),	132	-1, UNIPHIER_PIN_PULL_NONE),
133	UNIPHIER_PINCTRL_PIN(36, "SDDAT2", UNIPHIER_PIN_IECTRL_NONE,	133	UNIPHIER_PINCTRL_PIN(36, "SDDAT2", 8,
134	56, UNIPHIER_PIN_DRV_8_12_16_20,	134	56, UNIPHIER_PIN_DRV_8_12_16_20,
135	-1, UNIPHIER_PIN_PULL_NONE),	135	-1, UNIPHIER_PIN_PULL_NONE),
136	UNIPHIER_PINCTRL_PIN(37, "SDDAT3", UNIPHIER_PIN_IECTRL_NONE,	136	UNIPHIER_PINCTRL_PIN(37, "SDDAT3", 8,
137	60, UNIPHIER_PIN_DRV_8_12_16_20,	137	60, UNIPHIER_PIN_DRV_8_12_16_20,
138	-1, UNIPHIER_PIN_PULL_NONE),	138	-1, UNIPHIER_PIN_PULL_NONE),
139	UNIPHIER_PINCTRL_PIN(38, "SDCD", UNIPHIER_PIN_IECTRL_NONE,	139	UNIPHIER_PINCTRL_PIN(38, "SDCD", 8,
140	-1, UNIPHIER_PIN_DRV_FIXED_4,	140	-1, UNIPHIER_PIN_DRV_FIXED_4,
141	129, UNIPHIER_PIN_PULL_DOWN),	141	129, UNIPHIER_PIN_PULL_DOWN),
142	UNIPHIER_PINCTRL_PIN(39, "SDWP", UNIPHIER_PIN_IECTRL_NONE,	142	UNIPHIER_PINCTRL_PIN(39, "SDWP", 8,
143	-1, UNIPHIER_PIN_DRV_FIXED_4,	143	-1, UNIPHIER_PIN_DRV_FIXED_4,
144	130, UNIPHIER_PIN_PULL_DOWN),	144	130, UNIPHIER_PIN_PULL_DOWN),
145	UNIPHIER_PINCTRL_PIN(40, "SDVOLC", UNIPHIER_PIN_IECTRL_NONE,	145	UNIPHIER_PINCTRL_PIN(40, "SDVOLC", 9,
146	-1, UNIPHIER_PIN_DRV_FIXED_4,	146	-1, UNIPHIER_PIN_DRV_FIXED_4,
147	131, UNIPHIER_PIN_PULL_DOWN),	147	131, UNIPHIER_PIN_PULL_DOWN),
148	UNIPHIER_PINCTRL_PIN(41, "USB0VBUS", UNIPHIER_PIN_IECTRL_NONE,	148	UNIPHIER_PINCTRL_PIN(41, "USB0VBUS", 0,
149	37, UNIPHIER_PIN_DRV_4_8,	149	37, UNIPHIER_PIN_DRV_4_8,
150	37, UNIPHIER_PIN_PULL_DOWN),	150	37, UNIPHIER_PIN_PULL_DOWN),
151	UNIPHIER_PINCTRL_PIN(42, "USB0OD", UNIPHIER_PIN_IECTRL_NONE,	151	UNIPHIER_PINCTRL_PIN(42, "USB0OD", 0,
152	38, UNIPHIER_PIN_DRV_4_8,	152	38, UNIPHIER_PIN_DRV_4_8,
153	38, UNIPHIER_PIN_PULL_DOWN),	153	38, UNIPHIER_PIN_PULL_DOWN),
154	UNIPHIER_PINCTRL_PIN(43, "USB1VBUS", UNIPHIER_PIN_IECTRL_NONE,	154	UNIPHIER_PINCTRL_PIN(43, "USB1VBUS", 0,
155	39, UNIPHIER_PIN_DRV_4_8,	155	39, UNIPHIER_PIN_DRV_4_8,
156	39, UNIPHIER_PIN_PULL_DOWN),	156	39, UNIPHIER_PIN_PULL_DOWN),
157	UNIPHIER_PINCTRL_PIN(44, "USB1OD", UNIPHIER_PIN_IECTRL_NONE,	157	UNIPHIER_PINCTRL_PIN(44, "USB1OD", 0,
158	40, UNIPHIER_PIN_DRV_4_8,	158	40, UNIPHIER_PIN_DRV_4_8,
159	40, UNIPHIER_PIN_PULL_DOWN),	159	40, UNIPHIER_PIN_PULL_DOWN),
160	UNIPHIER_PINCTRL_PIN(45, "PCRESET", UNIPHIER_PIN_IECTRL_NONE,	160	UNIPHIER_PINCTRL_PIN(45, "PCRESET", 0,
161	41, UNIPHIER_PIN_DRV_4_8,	161	41, UNIPHIER_PIN_DRV_4_8,
162	41, UNIPHIER_PIN_PULL_DOWN),	162	41, UNIPHIER_PIN_PULL_DOWN),
163	UNIPHIER_PINCTRL_PIN(46, "PCREG", UNIPHIER_PIN_IECTRL_NONE,	163	UNIPHIER_PINCTRL_PIN(46, "PCREG", 0,
164	42, UNIPHIER_PIN_DRV_4_8,	164	42, UNIPHIER_PIN_DRV_4_8,
165	42, UNIPHIER_PIN_PULL_DOWN),	165	42, UNIPHIER_PIN_PULL_DOWN),
166	UNIPHIER_PINCTRL_PIN(47, "PCCE2", UNIPHIER_PIN_IECTRL_NONE,	166	UNIPHIER_PINCTRL_PIN(47, "PCCE2", 0,
167	43, UNIPHIER_PIN_DRV_4_8,	167	43, UNIPHIER_PIN_DRV_4_8,
168	43, UNIPHIER_PIN_PULL_DOWN),	168	43, UNIPHIER_PIN_PULL_DOWN),
169	UNIPHIER_PINCTRL_PIN(48, "PCVS1", UNIPHIER_PIN_IECTRL_NONE,	169	UNIPHIER_PINCTRL_PIN(48, "PCVS1", 0,
170	44, UNIPHIER_PIN_DRV_4_8,	170	44, UNIPHIER_PIN_DRV_4_8,
171	44, UNIPHIER_PIN_PULL_DOWN),	171	44, UNIPHIER_PIN_PULL_DOWN),
172	UNIPHIER_PINCTRL_PIN(49, "PCCD2", UNIPHIER_PIN_IECTRL_NONE,	172	UNIPHIER_PINCTRL_PIN(49, "PCCD2", 0,
173	45, UNIPHIER_PIN_DRV_4_8,	173	45, UNIPHIER_PIN_DRV_4_8,
174	45, UNIPHIER_PIN_PULL_DOWN),	174	45, UNIPHIER_PIN_PULL_DOWN),
175	UNIPHIER_PINCTRL_PIN(50, "PCCD1", UNIPHIER_PIN_IECTRL_NONE,	175	UNIPHIER_PINCTRL_PIN(50, "PCCD1", 0,
176	46, UNIPHIER_PIN_DRV_4_8,	176	46, UNIPHIER_PIN_DRV_4_8,
177	46, UNIPHIER_PIN_PULL_DOWN),	177	46, UNIPHIER_PIN_PULL_DOWN),
178	UNIPHIER_PINCTRL_PIN(51, "PCREADY", UNIPHIER_PIN_IECTRL_NONE,	178	UNIPHIER_PINCTRL_PIN(51, "PCREADY", 0,
179	47, UNIPHIER_PIN_DRV_4_8,	179	47, UNIPHIER_PIN_DRV_4_8,
180	47, UNIPHIER_PIN_PULL_DOWN),	180	47, UNIPHIER_PIN_PULL_DOWN),
181	UNIPHIER_PINCTRL_PIN(52, "PCDOE", UNIPHIER_PIN_IECTRL_NONE,	181	UNIPHIER_PINCTRL_PIN(52, "PCDOE", 0,
182	48, UNIPHIER_PIN_DRV_4_8,	182	48, UNIPHIER_PIN_DRV_4_8,
183	48, UNIPHIER_PIN_PULL_DOWN),	183	48, UNIPHIER_PIN_PULL_DOWN),
184	UNIPHIER_PINCTRL_PIN(53, "PCCE1", UNIPHIER_PIN_IECTRL_NONE,	184	UNIPHIER_PINCTRL_PIN(53, "PCCE1", 0,
185	49, UNIPHIER_PIN_DRV_4_8,	185	49, UNIPHIER_PIN_DRV_4_8,
186	49, UNIPHIER_PIN_PULL_DOWN),	186	49, UNIPHIER_PIN_PULL_DOWN),
187	UNIPHIER_PINCTRL_PIN(54, "PCWE", UNIPHIER_PIN_IECTRL_NONE,	187	UNIPHIER_PINCTRL_PIN(54, "PCWE", 0,
188	50, UNIPHIER_PIN_DRV_4_8,	188	50, UNIPHIER_PIN_DRV_4_8,
189	50, UNIPHIER_PIN_PULL_DOWN),	189	50, UNIPHIER_PIN_PULL_DOWN),
190	UNIPHIER_PINCTRL_PIN(55, "PCOE", UNIPHIER_PIN_IECTRL_NONE,	190	UNIPHIER_PINCTRL_PIN(55, "PCOE", 0,
191	51, UNIPHIER_PIN_DRV_4_8,	191	51, UNIPHIER_PIN_DRV_4_8,
192	51, UNIPHIER_PIN_PULL_DOWN),	192	51, UNIPHIER_PIN_PULL_DOWN),
193	UNIPHIER_PINCTRL_PIN(56, "PCWAIT", UNIPHIER_PIN_IECTRL_NONE,	193	UNIPHIER_PINCTRL_PIN(56, "PCWAIT", 0,
194	52, UNIPHIER_PIN_DRV_4_8,	194	52, UNIPHIER_PIN_DRV_4_8,
195	52, UNIPHIER_PIN_PULL_DOWN),	195	52, UNIPHIER_PIN_PULL_DOWN),
196	UNIPHIER_PINCTRL_PIN(57, "PCIOWR", UNIPHIER_PIN_IECTRL_NONE,	196	UNIPHIER_PINCTRL_PIN(57, "PCIOWR", 0,
197	53, UNIPHIER_PIN_DRV_4_8,	197	53, UNIPHIER_PIN_DRV_4_8,
198	53, UNIPHIER_PIN_PULL_DOWN),	198	53, UNIPHIER_PIN_PULL_DOWN),
199	UNIPHIER_PINCTRL_PIN(58, "PCIORD", UNIPHIER_PIN_IECTRL_NONE,	199	UNIPHIER_PINCTRL_PIN(58, "PCIORD", 0,
200	54, UNIPHIER_PIN_DRV_4_8,	200	54, UNIPHIER_PIN_DRV_4_8,
201	54, UNIPHIER_PIN_PULL_DOWN),	201	54, UNIPHIER_PIN_PULL_DOWN),
202	UNIPHIER_PINCTRL_PIN(59, "HS0DIN0", UNIPHIER_PIN_IECTRL_NONE,	202	UNIPHIER_PINCTRL_PIN(59, "HS0DIN0", 0,
203	55, UNIPHIER_PIN_DRV_4_8,	203	55, UNIPHIER_PIN_DRV_4_8,
204	55, UNIPHIER_PIN_PULL_DOWN),	204	55, UNIPHIER_PIN_PULL_DOWN),
205	UNIPHIER_PINCTRL_PIN(60, "HS0DIN1", UNIPHIER_PIN_IECTRL_NONE,	205	UNIPHIER_PINCTRL_PIN(60, "HS0DIN1", 0,
206	56, UNIPHIER_PIN_DRV_4_8,	206	56, UNIPHIER_PIN_DRV_4_8,
207	56, UNIPHIER_PIN_PULL_DOWN),	207	56, UNIPHIER_PIN_PULL_DOWN),
208	UNIPHIER_PINCTRL_PIN(61, "HS0DIN2", UNIPHIER_PIN_IECTRL_NONE,	208	UNIPHIER_PINCTRL_PIN(61, "HS0DIN2", 0,
209	57, UNIPHIER_PIN_DRV_4_8,	209	57, UNIPHIER_PIN_DRV_4_8,
210	57, UNIPHIER_PIN_PULL_DOWN),	210	57, UNIPHIER_PIN_PULL_DOWN),
211	UNIPHIER_PINCTRL_PIN(62, "HS0DIN3", UNIPHIER_PIN_IECTRL_NONE,	211	UNIPHIER_PINCTRL_PIN(62, "HS0DIN3", 0,
212	58, UNIPHIER_PIN_DRV_4_8,	212	58, UNIPHIER_PIN_DRV_4_8,
213	58, UNIPHIER_PIN_PULL_DOWN),	213	58, UNIPHIER_PIN_PULL_DOWN),
214	UNIPHIER_PINCTRL_PIN(63, "HS0DIN4", UNIPHIER_PIN_IECTRL_NONE,	214	UNIPHIER_PINCTRL_PIN(63, "HS0DIN4", 0,
215	59, UNIPHIER_PIN_DRV_4_8,	215	59, UNIPHIER_PIN_DRV_4_8,
216	59, UNIPHIER_PIN_PULL_DOWN),	216	59, UNIPHIER_PIN_PULL_DOWN),
217	UNIPHIER_PINCTRL_PIN(64, "HS0DIN5", UNIPHIER_PIN_IECTRL_NONE,	217	UNIPHIER_PINCTRL_PIN(64, "HS0DIN5", 0,
218	60, UNIPHIER_PIN_DRV_4_8,	218	60, UNIPHIER_PIN_DRV_4_8,
219	60, UNIPHIER_PIN_PULL_DOWN),	219	60, UNIPHIER_PIN_PULL_DOWN),
220	UNIPHIER_PINCTRL_PIN(65, "HS0DIN6", UNIPHIER_PIN_IECTRL_NONE,	220	UNIPHIER_PINCTRL_PIN(65, "HS0DIN6", 0,
221	61, UNIPHIER_PIN_DRV_4_8,	221	61, UNIPHIER_PIN_DRV_4_8,
222	61, UNIPHIER_PIN_PULL_DOWN),	222	61, UNIPHIER_PIN_PULL_DOWN),
223	UNIPHIER_PINCTRL_PIN(66, "HS0DIN7", UNIPHIER_PIN_IECTRL_NONE,	223	UNIPHIER_PINCTRL_PIN(66, "HS0DIN7", 0,
224	62, UNIPHIER_PIN_DRV_4_8,	224	62, UNIPHIER_PIN_DRV_4_8,
225	62, UNIPHIER_PIN_PULL_DOWN),	225	62, UNIPHIER_PIN_PULL_DOWN),
226	UNIPHIER_PINCTRL_PIN(67, "HS0BCLKIN", UNIPHIER_PIN_IECTRL_NONE,	226	UNIPHIER_PINCTRL_PIN(67, "HS0BCLKIN", 0,
227	63, UNIPHIER_PIN_DRV_4_8,	227	63, UNIPHIER_PIN_DRV_4_8,
228	63, UNIPHIER_PIN_PULL_DOWN),	228	63, UNIPHIER_PIN_PULL_DOWN),
229	UNIPHIER_PINCTRL_PIN(68, "HS0VALIN", UNIPHIER_PIN_IECTRL_NONE,	229	UNIPHIER_PINCTRL_PIN(68, "HS0VALIN", 0,
230	64, UNIPHIER_PIN_DRV_4_8,	230	64, UNIPHIER_PIN_DRV_4_8,
231	64, UNIPHIER_PIN_PULL_DOWN),	231	64, UNIPHIER_PIN_PULL_DOWN),
232	UNIPHIER_PINCTRL_PIN(69, "HS0SYNCIN", UNIPHIER_PIN_IECTRL_NONE,	232	UNIPHIER_PINCTRL_PIN(69, "HS0SYNCIN", 0,
233	65, UNIPHIER_PIN_DRV_4_8,	233	65, UNIPHIER_PIN_DRV_4_8,
234	65, UNIPHIER_PIN_PULL_DOWN),	234	65, UNIPHIER_PIN_PULL_DOWN),
235	UNIPHIER_PINCTRL_PIN(70, "HSDOUT0", UNIPHIER_PIN_IECTRL_NONE,	235	UNIPHIER_PINCTRL_PIN(70, "HSDOUT0", 0,
236	66, UNIPHIER_PIN_DRV_4_8,	236	66, UNIPHIER_PIN_DRV_4_8,
237	66, UNIPHIER_PIN_PULL_DOWN),	237	66, UNIPHIER_PIN_PULL_DOWN),
238	UNIPHIER_PINCTRL_PIN(71, "HSDOUT1", UNIPHIER_PIN_IECTRL_NONE,	238	UNIPHIER_PINCTRL_PIN(71, "HSDOUT1", 0,
239	67, UNIPHIER_PIN_DRV_4_8,	239	67, UNIPHIER_PIN_DRV_4_8,
240	67, UNIPHIER_PIN_PULL_DOWN),	240	67, UNIPHIER_PIN_PULL_DOWN),
241	UNIPHIER_PINCTRL_PIN(72, "HSDOUT2", UNIPHIER_PIN_IECTRL_NONE,	241	UNIPHIER_PINCTRL_PIN(72, "HSDOUT2", 0,
242	68, UNIPHIER_PIN_DRV_4_8,	242	68, UNIPHIER_PIN_DRV_4_8,
243	68, UNIPHIER_PIN_PULL_DOWN),	243	68, UNIPHIER_PIN_PULL_DOWN),
244	UNIPHIER_PINCTRL_PIN(73, "HSDOUT3", UNIPHIER_PIN_IECTRL_NONE,	244	UNIPHIER_PINCTRL_PIN(73, "HSDOUT3", 0,
245	69, UNIPHIER_PIN_DRV_4_8,	245	69, UNIPHIER_PIN_DRV_4_8,
246	69, UNIPHIER_PIN_PULL_DOWN),	246	69, UNIPHIER_PIN_PULL_DOWN),
247	UNIPHIER_PINCTRL_PIN(74, "HSDOUT4", UNIPHIER_PIN_IECTRL_NONE,	247	UNIPHIER_PINCTRL_PIN(74, "HSDOUT4", 0,
248	70, UNIPHIER_PIN_DRV_4_8,	248	70, UNIPHIER_PIN_DRV_4_8,
249	70, UNIPHIER_PIN_PULL_DOWN),	249	70, UNIPHIER_PIN_PULL_DOWN),
250	UNIPHIER_PINCTRL_PIN(75, "HSDOUT5", UNIPHIER_PIN_IECTRL_NONE,	250	UNIPHIER_PINCTRL_PIN(75, "HSDOUT5", 0,
251	71, UNIPHIER_PIN_DRV_4_8,	251	71, UNIPHIER_PIN_DRV_4_8,
252	71, UNIPHIER_PIN_PULL_DOWN),	252	71, UNIPHIER_PIN_PULL_DOWN),
253	UNIPHIER_PINCTRL_PIN(76, "HSDOUT6", UNIPHIER_PIN_IECTRL_NONE,	253	UNIPHIER_PINCTRL_PIN(76, "HSDOUT6", 0,
254	72, UNIPHIER_PIN_DRV_4_8,	254	72, UNIPHIER_PIN_DRV_4_8,
255	72, UNIPHIER_PIN_PULL_DOWN),	255	72, UNIPHIER_PIN_PULL_DOWN),
256	UNIPHIER_PINCTRL_PIN(77, "HSDOUT7", UNIPHIER_PIN_IECTRL_NONE,	256	UNIPHIER_PINCTRL_PIN(77, "HSDOUT7", 0,
257	73, UNIPHIER_PIN_DRV_4_8,	257	73, UNIPHIER_PIN_DRV_4_8,
258	73, UNIPHIER_PIN_PULL_DOWN),	258	73, UNIPHIER_PIN_PULL_DOWN),
259	UNIPHIER_PINCTRL_PIN(78, "HSBCLKOUT", UNIPHIER_PIN_IECTRL_NONE,	259	UNIPHIER_PINCTRL_PIN(78, "HSBCLKOUT", 0,
260	74, UNIPHIER_PIN_DRV_4_8,	260	74, UNIPHIER_PIN_DRV_4_8,
261	74, UNIPHIER_PIN_PULL_DOWN),	261	74, UNIPHIER_PIN_PULL_DOWN),
262	UNIPHIER_PINCTRL_PIN(79, "HSVALOUT", UNIPHIER_PIN_IECTRL_NONE,	262	UNIPHIER_PINCTRL_PIN(79, "HSVALOUT", 0,
263	75, UNIPHIER_PIN_DRV_4_8,	263	75, UNIPHIER_PIN_DRV_4_8,
264	75, UNIPHIER_PIN_PULL_DOWN),	264	75, UNIPHIER_PIN_PULL_DOWN),
265	UNIPHIER_PINCTRL_PIN(80, "HSSYNCOUT", UNIPHIER_PIN_IECTRL_NONE,	265	UNIPHIER_PINCTRL_PIN(80, "HSSYNCOUT", 0,
266	76, UNIPHIER_PIN_DRV_4_8,	266	76, UNIPHIER_PIN_DRV_4_8,
267	76, UNIPHIER_PIN_PULL_DOWN),	267	76, UNIPHIER_PIN_PULL_DOWN),
268	UNIPHIER_PINCTRL_PIN(81, "HS1DIN0", UNIPHIER_PIN_IECTRL_NONE,	268	UNIPHIER_PINCTRL_PIN(81, "HS1DIN0", 0,
269	77, UNIPHIER_PIN_DRV_4_8,	269	77, UNIPHIER_PIN_DRV_4_8,
270	77, UNIPHIER_PIN_PULL_DOWN),	270	77, UNIPHIER_PIN_PULL_DOWN),
271	UNIPHIER_PINCTRL_PIN(82, "HS1DIN1", UNIPHIER_PIN_IECTRL_NONE,	271	UNIPHIER_PINCTRL_PIN(82, "HS1DIN1", 0,
272	78, UNIPHIER_PIN_DRV_4_8,	272	78, UNIPHIER_PIN_DRV_4_8,
273	78, UNIPHIER_PIN_PULL_DOWN),	273	78, UNIPHIER_PIN_PULL_DOWN),
274	UNIPHIER_PINCTRL_PIN(83, "HS1DIN2", UNIPHIER_PIN_IECTRL_NONE,	274	UNIPHIER_PINCTRL_PIN(83, "HS1DIN2", 0,
275	79, UNIPHIER_PIN_DRV_4_8,	275	79, UNIPHIER_PIN_DRV_4_8,
276	79, UNIPHIER_PIN_PULL_DOWN),	276	79, UNIPHIER_PIN_PULL_DOWN),
277	UNIPHIER_PINCTRL_PIN(84, "HS1DIN3", UNIPHIER_PIN_IECTRL_NONE,	277	UNIPHIER_PINCTRL_PIN(84, "HS1DIN3", 0,
278	80, UNIPHIER_PIN_DRV_4_8,	278	80, UNIPHIER_PIN_DRV_4_8,
279	80, UNIPHIER_PIN_PULL_DOWN),	279	80, UNIPHIER_PIN_PULL_DOWN),
280	UNIPHIER_PINCTRL_PIN(85, "HS1DIN4", UNIPHIER_PIN_IECTRL_NONE,	280	UNIPHIER_PINCTRL_PIN(85, "HS1DIN4", 0,
281	81, UNIPHIER_PIN_DRV_4_8,	281	81, UNIPHIER_PIN_DRV_4_8,
282	81, UNIPHIER_PIN_PULL_DOWN),	282	81, UNIPHIER_PIN_PULL_DOWN),
283	UNIPHIER_PINCTRL_PIN(86, "HS1DIN5", UNIPHIER_PIN_IECTRL_NONE,	283	UNIPHIER_PINCTRL_PIN(86, "HS1DIN5", 0,
284	82, UNIPHIER_PIN_DRV_4_8,	284	82, UNIPHIER_PIN_DRV_4_8,
285	82, UNIPHIER_PIN_PULL_DOWN),	285	82, UNIPHIER_PIN_PULL_DOWN),
286	UNIPHIER_PINCTRL_PIN(87, "HS1DIN6", UNIPHIER_PIN_IECTRL_NONE,	286	UNIPHIER_PINCTRL_PIN(87, "HS1DIN6", 0,
287	83, UNIPHIER_PIN_DRV_4_8,	287	83, UNIPHIER_PIN_DRV_4_8,
288	83, UNIPHIER_PIN_PULL_DOWN),	288	83, UNIPHIER_PIN_PULL_DOWN),
289	UNIPHIER_PINCTRL_PIN(88, "HS1DIN7", UNIPHIER_PIN_IECTRL_NONE,	289	UNIPHIER_PINCTRL_PIN(88, "HS1DIN7", 0,
290	84, UNIPHIER_PIN_DRV_4_8,	290	84, UNIPHIER_PIN_DRV_4_8,
291	84, UNIPHIER_PIN_PULL_DOWN),	291	84, UNIPHIER_PIN_PULL_DOWN),
292	UNIPHIER_PINCTRL_PIN(89, "HS1BCLKIN", UNIPHIER_PIN_IECTRL_NONE,	292	UNIPHIER_PINCTRL_PIN(89, "HS1BCLKIN", 0,
293	85, UNIPHIER_PIN_DRV_4_8,	293	85, UNIPHIER_PIN_DRV_4_8,
294	85, UNIPHIER_PIN_PULL_DOWN),	294	85, UNIPHIER_PIN_PULL_DOWN),
295	UNIPHIER_PINCTRL_PIN(90, "HS1VALIN", UNIPHIER_PIN_IECTRL_NONE,	295	UNIPHIER_PINCTRL_PIN(90, "HS1VALIN", 0,
296	86, UNIPHIER_PIN_DRV_4_8,	296	86, UNIPHIER_PIN_DRV_4_8,
297	86, UNIPHIER_PIN_PULL_DOWN),	297	86, UNIPHIER_PIN_PULL_DOWN),
298	UNIPHIER_PINCTRL_PIN(91, "HS1SYNCIN", UNIPHIER_PIN_IECTRL_NONE,	298	UNIPHIER_PINCTRL_PIN(91, "HS1SYNCIN", 0,
299	87, UNIPHIER_PIN_DRV_4_8,	299	87, UNIPHIER_PIN_DRV_4_8,
300	87, UNIPHIER_PIN_PULL_DOWN),	300	87, UNIPHIER_PIN_PULL_DOWN),
301	UNIPHIER_PINCTRL_PIN(92, "AGCI", UNIPHIER_PIN_IECTRL_NONE,	301	UNIPHIER_PINCTRL_PIN(92, "AGCI", 3,
302	-1, UNIPHIER_PIN_DRV_FIXED_4,	302	-1, UNIPHIER_PIN_DRV_FIXED_4,
303	132, UNIPHIER_PIN_PULL_DOWN),	303	132, UNIPHIER_PIN_PULL_DOWN),
304	UNIPHIER_PINCTRL_PIN(93, "AGCR", UNIPHIER_PIN_IECTRL_NONE,	304	UNIPHIER_PINCTRL_PIN(93, "AGCR", 4,
305	-1, UNIPHIER_PIN_DRV_FIXED_4,	305	-1, UNIPHIER_PIN_DRV_FIXED_4,
306	133, UNIPHIER_PIN_PULL_DOWN),	306	133, UNIPHIER_PIN_PULL_DOWN),
307	UNIPHIER_PINCTRL_PIN(94, "AGCBS", UNIPHIER_PIN_IECTRL_NONE,	307	UNIPHIER_PINCTRL_PIN(94, "AGCBS", 5,
308	-1, UNIPHIER_PIN_DRV_FIXED_4,	308	-1, UNIPHIER_PIN_DRV_FIXED_4,
309	134, UNIPHIER_PIN_PULL_DOWN),	309	134, UNIPHIER_PIN_PULL_DOWN),
310	UNIPHIER_PINCTRL_PIN(95, "IECOUT", UNIPHIER_PIN_IECTRL_NONE,	310	UNIPHIER_PINCTRL_PIN(95, "IECOUT", 0,
311	88, UNIPHIER_PIN_DRV_4_8,	311	88, UNIPHIER_PIN_DRV_4_8,
312	88, UNIPHIER_PIN_PULL_DOWN),	312	88, UNIPHIER_PIN_PULL_DOWN),
313	UNIPHIER_PINCTRL_PIN(96, "ASMCK", UNIPHIER_PIN_IECTRL_NONE,	313	UNIPHIER_PINCTRL_PIN(96, "ASMCK", 0,
314	89, UNIPHIER_PIN_DRV_4_8,	314	89, UNIPHIER_PIN_DRV_4_8,
315	89, UNIPHIER_PIN_PULL_DOWN),	315	89, UNIPHIER_PIN_PULL_DOWN),
316	UNIPHIER_PINCTRL_PIN(97, "ABCKO", UNIPHIER_PIN_IECTRL_NONE,	316	UNIPHIER_PINCTRL_PIN(97, "ABCKO", UNIPHIER_PIN_IECTRL_NONE,
@@ -325,31 +325,31 @@ static const struct pinctrl_pin_desc ph1_sld8_pins[] = { · 8 unmodified lines
325	UNIPHIER_PINCTRL_PIN(100, "ASDOUT1", UNIPHIER_PIN_IECTRL_NONE,	325	UNIPHIER_PINCTRL_PIN(100, "ASDOUT1", UNIPHIER_PIN_IECTRL_NONE,
326	93, UNIPHIER_PIN_DRV_4_8,	326	93, UNIPHIER_PIN_DRV_4_8,
327	93, UNIPHIER_PIN_PULL_UP),	327	93, UNIPHIER_PIN_PULL_UP),
328	UNIPHIER_PINCTRL_PIN(101, "ARCOUT", UNIPHIER_PIN_IECTRL_NONE,	328	UNIPHIER_PINCTRL_PIN(101, "ARCOUT", 0,
329	94, UNIPHIER_PIN_DRV_4_8,	329	94, UNIPHIER_PIN_DRV_4_8,
330	94, UNIPHIER_PIN_PULL_DOWN),	330	94, UNIPHIER_PIN_PULL_DOWN),
331	UNIPHIER_PINCTRL_PIN(102, "SDA0", UNIPHIER_PIN_IECTRL_NONE,	331	UNIPHIER_PINCTRL_PIN(102, "SDA0", 10,
332	-1, UNIPHIER_PIN_DRV_FIXED_4,	332	-1, UNIPHIER_PIN_DRV_FIXED_4,
333	-1, UNIPHIER_PIN_PULL_NONE),	333	-1, UNIPHIER_PIN_PULL_NONE),
334	UNIPHIER_PINCTRL_PIN(103, "SCL0", UNIPHIER_PIN_IECTRL_NONE,	334	UNIPHIER_PINCTRL_PIN(103, "SCL0", 10,
335	-1, UNIPHIER_PIN_DRV_FIXED_4,	335	-1, UNIPHIER_PIN_DRV_FIXED_4,
336	-1, UNIPHIER_PIN_PULL_NONE),	336	-1, UNIPHIER_PIN_PULL_NONE),
337	UNIPHIER_PINCTRL_PIN(104, "SDA1", UNIPHIER_PIN_IECTRL_NONE,	337	UNIPHIER_PINCTRL_PIN(104, "SDA1", 11,
338	-1, UNIPHIER_PIN_DRV_FIXED_4,	338	-1, UNIPHIER_PIN_DRV_FIXED_4,
339	-1, UNIPHIER_PIN_PULL_NONE),	339	-1, UNIPHIER_PIN_PULL_NONE),
340	UNIPHIER_PINCTRL_PIN(105, "SCL1", UNIPHIER_PIN_IECTRL_NONE,	340	UNIPHIER_PINCTRL_PIN(105, "SCL1", 11,
341	-1, UNIPHIER_PIN_DRV_FIXED_4,	341	-1, UNIPHIER_PIN_DRV_FIXED_4,
342	-1, UNIPHIER_PIN_PULL_NONE),	342	-1, UNIPHIER_PIN_PULL_NONE),
343	UNIPHIER_PINCTRL_PIN(106, "DMDSDA0", UNIPHIER_PIN_IECTRL_NONE,	343	UNIPHIER_PINCTRL_PIN(106, "DMDSDA0", 12,
344	-1, UNIPHIER_PIN_DRV_FIXED_4,	344	-1, UNIPHIER_PIN_DRV_FIXED_4,
345	-1, UNIPHIER_PIN_PULL_NONE),	345	-1, UNIPHIER_PIN_PULL_NONE),
346	UNIPHIER_PINCTRL_PIN(107, "DMDSCL0", UNIPHIER_PIN_IECTRL_NONE,	346	UNIPHIER_PINCTRL_PIN(107, "DMDSCL0", 12,
347	-1, UNIPHIER_PIN_DRV_FIXED_4,	347	-1, UNIPHIER_PIN_DRV_FIXED_4,
348	-1, UNIPHIER_PIN_PULL_NONE),	348	-1, UNIPHIER_PIN_PULL_NONE),
349	UNIPHIER_PINCTRL_PIN(108, "DMDSDA1", UNIPHIER_PIN_IECTRL_NONE,	349	UNIPHIER_PINCTRL_PIN(108, "DMDSDA1", 13,
350	-1, UNIPHIER_PIN_DRV_FIXED_4,	350	-1, UNIPHIER_PIN_DRV_FIXED_4,
351	-1, UNIPHIER_PIN_PULL_NONE),	351	-1, UNIPHIER_PIN_PULL_NONE),
352	UNIPHIER_PINCTRL_PIN(109, "DMDSCL1", UNIPHIER_PIN_IECTRL_NONE,	352	UNIPHIER_PINCTRL_PIN(109, "DMDSCL1", 13,
353	-1, UNIPHIER_PIN_DRV_FIXED_4,	353	-1, UNIPHIER_PIN_DRV_FIXED_4,
354	-1, UNIPHIER_PIN_PULL_NONE),	354	-1, UNIPHIER_PIN_PULL_NONE),
355	UNIPHIER_PINCTRL_PIN(110, "SBO0", UNIPHIER_PIN_IECTRL_NONE,	355	UNIPHIER_PINCTRL_PIN(110, "SBO0", UNIPHIER_PIN_IECTRL_NONE,
@@ -358,76 +358,76 @@ static const struct pinctrl_pin_desc ph1_sld8_pins[] = { · 2 unmodified lines
358	UNIPHIER_PINCTRL_PIN(111, "SBI0", UNIPHIER_PIN_IECTRL_NONE,	358	UNIPHIER_PINCTRL_PIN(111, "SBI0", UNIPHIER_PIN_IECTRL_NONE,
359	96, UNIPHIER_PIN_DRV_4_8,	359	96, UNIPHIER_PIN_DRV_4_8,
360	96, UNIPHIER_PIN_PULL_UP),	360	96, UNIPHIER_PIN_PULL_UP),
361	UNIPHIER_PINCTRL_PIN(112, "SBO1", UNIPHIER_PIN_IECTRL_NONE,	361	UNIPHIER_PINCTRL_PIN(112, "SBO1", 0,
362	97, UNIPHIER_PIN_DRV_4_8,	362	97, UNIPHIER_PIN_DRV_4_8,
363	97, UNIPHIER_PIN_PULL_UP),	363	97, UNIPHIER_PIN_PULL_UP),
364	UNIPHIER_PINCTRL_PIN(113, "SBI1", UNIPHIER_PIN_IECTRL_NONE,	364	UNIPHIER_PINCTRL_PIN(113, "SBI1", 0,
365	98, UNIPHIER_PIN_DRV_4_8,	365	98, UNIPHIER_PIN_DRV_4_8,
366	98, UNIPHIER_PIN_PULL_UP),	366	98, UNIPHIER_PIN_PULL_UP),
367	UNIPHIER_PINCTRL_PIN(114, "TXD1", UNIPHIER_PIN_IECTRL_NONE,	367	UNIPHIER_PINCTRL_PIN(114, "TXD1", 0,
368	99, UNIPHIER_PIN_DRV_4_8,	368	99, UNIPHIER_PIN_DRV_4_8,
369	99, UNIPHIER_PIN_PULL_UP),	369	99, UNIPHIER_PIN_PULL_UP),
370	UNIPHIER_PINCTRL_PIN(115, "RXD1", UNIPHIER_PIN_IECTRL_NONE,	370	UNIPHIER_PINCTRL_PIN(115, "RXD1", 0,
371	100, UNIPHIER_PIN_DRV_4_8,	371	100, UNIPHIER_PIN_DRV_4_8,
372	100, UNIPHIER_PIN_PULL_UP),	372	100, UNIPHIER_PIN_PULL_UP),
373	UNIPHIER_PINCTRL_PIN(116, "HIN", UNIPHIER_PIN_IECTRL_NONE,	373	UNIPHIER_PINCTRL_PIN(116, "HIN", 1,
374	-1, UNIPHIER_PIN_DRV_FIXED_5,	374	-1, UNIPHIER_PIN_DRV_FIXED_5,
375	-1, UNIPHIER_PIN_PULL_NONE),	375	-1, UNIPHIER_PIN_PULL_NONE),
376	UNIPHIER_PINCTRL_PIN(117, "VIN", UNIPHIER_PIN_IECTRL_NONE,	376	UNIPHIER_PINCTRL_PIN(117, "VIN", 2,
377	-1, UNIPHIER_PIN_DRV_FIXED_5,	377	-1, UNIPHIER_PIN_DRV_FIXED_5,
378	-1, UNIPHIER_PIN_PULL_NONE),	378	-1, UNIPHIER_PIN_PULL_NONE),
379	UNIPHIER_PINCTRL_PIN(118, "TCON0", UNIPHIER_PIN_IECTRL_NONE,	379	UNIPHIER_PINCTRL_PIN(118, "TCON0", 0,
380	101, UNIPHIER_PIN_DRV_4_8,	380	101, UNIPHIER_PIN_DRV_4_8,
381	101, UNIPHIER_PIN_PULL_DOWN),	381	101, UNIPHIER_PIN_PULL_DOWN),
382	UNIPHIER_PINCTRL_PIN(119, "TCON1", UNIPHIER_PIN_IECTRL_NONE,	382	UNIPHIER_PINCTRL_PIN(119, "TCON1", 0,
383	102, UNIPHIER_PIN_DRV_4_8,	383	102, UNIPHIER_PIN_DRV_4_8,
384	102, UNIPHIER_PIN_PULL_DOWN),	384	102, UNIPHIER_PIN_PULL_DOWN),
385	UNIPHIER_PINCTRL_PIN(120, "TCON2", UNIPHIER_PIN_IECTRL_NONE,	385	UNIPHIER_PINCTRL_PIN(120, "TCON2", 0,
386	103, UNIPHIER_PIN_DRV_4_8,	386	103, UNIPHIER_PIN_DRV_4_8,
387	103, UNIPHIER_PIN_PULL_DOWN),	387	103, UNIPHIER_PIN_PULL_DOWN),
388	UNIPHIER_PINCTRL_PIN(121, "TCON3", UNIPHIER_PIN_IECTRL_NONE,	388	UNIPHIER_PINCTRL_PIN(121, "TCON3", 0,
389	104, UNIPHIER_PIN_DRV_4_8,	389	104, UNIPHIER_PIN_DRV_4_8,
390	104, UNIPHIER_PIN_PULL_DOWN),	390	104, UNIPHIER_PIN_PULL_DOWN),
391	UNIPHIER_PINCTRL_PIN(122, "TCON4", UNIPHIER_PIN_IECTRL_NONE,	391	UNIPHIER_PINCTRL_PIN(122, "TCON4", 0,
392	105, UNIPHIER_PIN_DRV_4_8,	392	105, UNIPHIER_PIN_DRV_4_8,
393	105, UNIPHIER_PIN_PULL_DOWN),	393	105, UNIPHIER_PIN_PULL_DOWN),
394	UNIPHIER_PINCTRL_PIN(123, "TCON5", UNIPHIER_PIN_IECTRL_NONE,	394	UNIPHIER_PINCTRL_PIN(123, "TCON5", 0,
395	106, UNIPHIER_PIN_DRV_4_8,	395	106, UNIPHIER_PIN_DRV_4_8,
396	106, UNIPHIER_PIN_PULL_DOWN),	396	106, UNIPHIER_PIN_PULL_DOWN),
397	UNIPHIER_PINCTRL_PIN(124, "TCON6", UNIPHIER_PIN_IECTRL_NONE,	397	UNIPHIER_PINCTRL_PIN(124, "TCON6", 0,
398	107, UNIPHIER_PIN_DRV_4_8,	398	107, UNIPHIER_PIN_DRV_4_8,
399	107, UNIPHIER_PIN_PULL_DOWN),	399	107, UNIPHIER_PIN_PULL_DOWN),
400	UNIPHIER_PINCTRL_PIN(125, "TCON7", UNIPHIER_PIN_IECTRL_NONE,	400	UNIPHIER_PINCTRL_PIN(125, "TCON7", 0,
401	108, UNIPHIER_PIN_DRV_4_8,	401	108, UNIPHIER_PIN_DRV_4_8,
402	108, UNIPHIER_PIN_PULL_DOWN),	402	108, UNIPHIER_PIN_PULL_DOWN),
403	UNIPHIER_PINCTRL_PIN(126, "TCON8", UNIPHIER_PIN_IECTRL_NONE,	403	UNIPHIER_PINCTRL_PIN(126, "TCON8", 0,
404	109, UNIPHIER_PIN_DRV_4_8,	404	109, UNIPHIER_PIN_DRV_4_8,
405	109, UNIPHIER_PIN_PULL_DOWN),	405	109, UNIPHIER_PIN_PULL_DOWN),
406	UNIPHIER_PINCTRL_PIN(127, "PWMA", UNIPHIER_PIN_IECTRL_NONE,	406	UNIPHIER_PINCTRL_PIN(127, "PWMA", 0,
407	110, UNIPHIER_PIN_DRV_4_8,	407	110, UNIPHIER_PIN_DRV_4_8,
408	110, UNIPHIER_PIN_PULL_DOWN),	408	110, UNIPHIER_PIN_PULL_DOWN),
409	UNIPHIER_PINCTRL_PIN(128, "XIRQ0", UNIPHIER_PIN_IECTRL_NONE,	409	UNIPHIER_PINCTRL_PIN(128, "XIRQ0", 0,
410	111, UNIPHIER_PIN_DRV_4_8,	410	111, UNIPHIER_PIN_DRV_4_8,
411	111, UNIPHIER_PIN_PULL_DOWN),	411	111, UNIPHIER_PIN_PULL_DOWN),
412	UNIPHIER_PINCTRL_PIN(129, "XIRQ1", UNIPHIER_PIN_IECTRL_NONE,	412	UNIPHIER_PINCTRL_PIN(129, "XIRQ1", 0,
413	112, UNIPHIER_PIN_DRV_4_8,	413	112, UNIPHIER_PIN_DRV_4_8,
414	112, UNIPHIER_PIN_PULL_DOWN),	414	112, UNIPHIER_PIN_PULL_DOWN),
415	UNIPHIER_PINCTRL_PIN(130, "XIRQ2", UNIPHIER_PIN_IECTRL_NONE,	415	UNIPHIER_PINCTRL_PIN(130, "XIRQ2", 0,
416	113, UNIPHIER_PIN_DRV_4_8,	416	113, UNIPHIER_PIN_DRV_4_8,
417	113, UNIPHIER_PIN_PULL_DOWN),	417	113, UNIPHIER_PIN_PULL_DOWN),
418	UNIPHIER_PINCTRL_PIN(131, "XIRQ3", UNIPHIER_PIN_IECTRL_NONE,	418	UNIPHIER_PINCTRL_PIN(131, "XIRQ3", 0,
419	114, UNIPHIER_PIN_DRV_4_8,	419	114, UNIPHIER_PIN_DRV_4_8,
420	114, UNIPHIER_PIN_PULL_DOWN),	420	114, UNIPHIER_PIN_PULL_DOWN),
421	UNIPHIER_PINCTRL_PIN(132, "XIRQ4", UNIPHIER_PIN_IECTRL_NONE,	421	UNIPHIER_PINCTRL_PIN(132, "XIRQ4", 0,
422	115, UNIPHIER_PIN_DRV_4_8,	422	115, UNIPHIER_PIN_DRV_4_8,
423	115, UNIPHIER_PIN_PULL_DOWN),	423	115, UNIPHIER_PIN_PULL_DOWN),
424	UNIPHIER_PINCTRL_PIN(133, "XIRQ5", UNIPHIER_PIN_IECTRL_NONE,	424	UNIPHIER_PINCTRL_PIN(133, "XIRQ5", 0,
425	116, UNIPHIER_PIN_DRV_4_8,	425	116, UNIPHIER_PIN_DRV_4_8,
426	116, UNIPHIER_PIN_PULL_DOWN),	426	116, UNIPHIER_PIN_PULL_DOWN),
427	UNIPHIER_PINCTRL_PIN(134, "XIRQ6", UNIPHIER_PIN_IECTRL_NONE,	427	UNIPHIER_PINCTRL_PIN(134, "XIRQ6", 0,
428	117, UNIPHIER_PIN_DRV_4_8,	428	117, UNIPHIER_PIN_DRV_4_8,
429	117, UNIPHIER_PIN_PULL_DOWN),	429	117, UNIPHIER_PIN_PULL_DOWN),
430	UNIPHIER_PINCTRL_PIN(135, "XIRQ7", UNIPHIER_PIN_IECTRL_NONE,	430	UNIPHIER_PINCTRL_PIN(135, "XIRQ7", 0,
431	118, UNIPHIER_PIN_DRV_4_8,	431	118, UNIPHIER_PIN_DRV_4_8,
432	118, UNIPHIER_PIN_PULL_DOWN),	432	118, UNIPHIER_PIN_PULL_DOWN),
433	};	433	};

drivers/staging/iio/accel/sca3000_ring.c+1−1

@@ -116,7 +116,7 @@ static int sca3000_read_first_n_hw_rb(struct iio_buffer *r, · 115 unmodified lines
116	if (ret)	116	if (ret)
117	goto error_ret;	117	goto error_ret;
118		118
119	for (i = 0; i < num_read; i++)	119	for (i = 0; i < num_read / sizeof(u16); i++)
120	(((u16 )rx) + i) = be16_to_cpup((__be16 *)rx + i);	120	(((u16 )rx) + i) = be16_to_cpup((__be16 *)rx + i);
121		121
122	if (copy_to_user(buf, rx, num_read))	122	if (copy_to_user(buf, rx, num_read))

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

 	case IIO_CHAN_INFO_OFFSET:
 		if (chan->type == IIO_TEMP) {
 			/* The calculated value from the ADC is in Kelvin, we
-			 * want Celsius for hwmon so the offset is
+			 * want Celsius for hwmon so the offset is -273.15
-			 * -272.15 * scale
+			 * The offset is applied before scaling so it is
+			 * actually -213.15 * 4 / 1.012 = -1079.644268
 			 */
-			*val = -1075;
+			*val = -1079;
-			*val2 = 691699;
+			*val2 = 644268;
 			return IIO_VAL_INT_PLUS_MICRO;
 		}

drivers/staging/lustre/lustre/llite/dir.c+1−1

@@ -224,7 +224,7 @@ static int ll_dir_filler(void _hash, struct page page0) · 223 unmodified lines
224		224
225	prefetchw(&page->flags);	225	prefetchw(&page->flags);
226	ret = add_to_page_cache_lru(page, inode->i_mapping, offset,	226	ret = add_to_page_cache_lru(page, inode->i_mapping, offset,
227	GFP_KERNEL);	227	GFP_NOFS);
228	if (ret == 0) {	228	if (ret == 0) {
229	unlock_page(page);	229	unlock_page(page);
230	} else {	230	} else {

drivers/thermal/samsung/exynos_tmu.c+1−1

@@ -932,7 +932,7 @@ static void exynos4412_tmu_set_emulation(struct exynos_tmu_data *data, · 931 unmodified lines
932		932
933	if (data->soc == SOC_ARCH_EXYNOS5260)	933	if (data->soc == SOC_ARCH_EXYNOS5260)
934	emul_con = EXYNOS5260_EMUL_CON;	934	emul_con = EXYNOS5260_EMUL_CON;
935	if (data->soc == SOC_ARCH_EXYNOS5433)	935	else if (data->soc == SOC_ARCH_EXYNOS5433)
936	emul_con = EXYNOS5433_TMU_EMUL_CON;	936	emul_con = EXYNOS5433_TMU_EMUL_CON;
937	else if (data->soc == SOC_ARCH_EXYNOS7)	937	else if (data->soc == SOC_ARCH_EXYNOS7)
938	emul_con = EXYNOS7_TMU_REG_EMUL_CON;	938	emul_con = EXYNOS7_TMU_REG_EMUL_CON;

drivers/tty/serial/8250/8250_dma.c+0−4

 		return 0;
 	dma->tx_size = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
-	if (dma->tx_size < p->port.fifosize) {
-		ret = -EINVAL;
-		goto err;
-	}
 	desc = dmaengine_prep_slave_single(dma->txchan,
 					   dma->tx_addr + xmit->tail,

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

@@ -147,6 +147,7 @@ static void xhci_pci_quirks(struct device dev, struct xhci_hcd xhci) · 146 unmodified lines
147	if (pdev->vendor == PCI_VENDOR_ID_INTEL &&	147	if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
148	pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI) {	148	pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI) {
149	xhci->quirks \|= XHCI_SPURIOUS_REBOOT;	149	xhci->quirks \|= XHCI_SPURIOUS_REBOOT;
		150	xhci->quirks \|= XHCI_SPURIOUS_WAKEUP;
150	}	151	}
151	if (pdev->vendor == PCI_VENDOR_ID_INTEL &&	152	if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
152	(pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI \|\|	153	(pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI \|\|

drivers/usb/host/xhci-ring.c+25−5

 		}
 	/* Fast path - was this the last TRB in the TD for this URB? */
 	} else if (event_trb == td->last_trb) {
+		if (td->urb_length_set && trb_comp_code == COMP_SHORT_TX)
+			return finish_td(xhci, td, event_trb, event, ep,
+					 status, false);
 		if (EVENT_TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
 			td->urb->actual_length =
 				td->urb->transfer_buffer_length -
 			td->urb->actual_length +=
 				TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
 				EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));
+		if (trb_comp_code == COMP_SHORT_TX) {
+			xhci_dbg(xhci, "mid bulk/intr SP, wait for last TRB event\n");
+			td->urb_length_set = true;
+			return 0;
+		}
 	}
 	return finish_td(xhci, td, event_trb, event, ep, status, false);
 	u32 trb_comp_code;
 	int ret = 0;
 	int td_num = 0;
+	bool handling_skipped_tds = false;
 	slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
 	xdev = xhci->devs[slot_id];
 		ep->skip = true;
 		xhci_dbg(xhci, "Miss service interval error, set skip flag\n");
 		goto cleanup;
+	case COMP_PING_ERR:
+		ep->skip = true;
+		xhci_dbg(xhci, "No Ping response error, Skip one Isoc TD\n");
+		goto cleanup;
 	default:
 		if (xhci_is_vendor_info_code(xhci, trb_comp_code)) {
 			status = 0;
 						 ep, &status);
 cleanup:
+		handling_skipped_tds = ep->skip &&
+			trb_comp_code != COMP_MISSED_INT &&
+			trb_comp_code != COMP_PING_ERR;
 		/*
-		 * Do not update event ring dequeue pointer if ep->skip is set.
+		 * Do not update event ring dequeue pointer if we're in a loop
-		 * Will roll back to continue process missed tds.
+		 * processing missed tds.
 		 */
-		if (trb_comp_code == COMP_MISSED_INT || !ep->skip) {
+		if (!handling_skipped_tds)
 			inc_deq(xhci, xhci->event_ring);
-		}
 		if (ret) {
 			urb = td->urb;
 	 * Process them as short transfer until reach the td pointed by
 	 * the event.
 	 */
-	} while (ep->skip && trb_comp_code != COMP_MISSED_INT);
+	} while (handling_skipped_tds);
 	return 0;
 }

drivers/video/console/fbcon.c+1−0

@@ -1093,6 +1093,7 @@ static void fbcon_init(struct vc_data *vc, int init) · 1092 unmodified lines
1093	con_copy_unimap(vc, svc);	1093	con_copy_unimap(vc, svc);
1094		1094
1095	ops = info->fbcon_par;	1095	ops = info->fbcon_par;
		1096	ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms);
1096	p->con_rotate = initial_rotation;	1097	p->con_rotate = initial_rotation;
1097	set_blitting_type(vc, info);	1098	set_blitting_type(vc, info);
1098		1099

fs/btrfs/backref.c+3−5

 	int found = 0;
 	struct extent_buffer *eb;
 	struct btrfs_inode_extref *extref;
-	struct extent_buffer *leaf;
 	u32 item_size;
 	u32 cur_offset;
 	unsigned long ptr;
 		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
 		btrfs_release_path(path);
-		leaf = path->nodes[0];
+		item_size = btrfs_item_size_nr(eb, slot);
-		item_size = btrfs_item_size_nr(leaf, slot);
+		ptr = btrfs_item_ptr_offset(eb, slot);
-		ptr = btrfs_item_ptr_offset(leaf, slot);
 		cur_offset = 0;
 		while (cur_offset < item_size) {
 			if (ret)
 				break;
-			cur_offset += btrfs_inode_extref_name_len(leaf, extref);
+			cur_offset += btrfs_inode_extref_name_len(eb, extref);
 			cur_offset += sizeof(*extref);
 		}
 		btrfs_tree_read_unlock_blocking(eb);

fs/btrfs/file.c+1−1

@@ -2584,7 +2584,7 @@ static long btrfs_fallocate(struct file *file, int mode, · 2583 unmodified lines
2584	alloc_start);	2584	alloc_start);
2585	if (ret)	2585	if (ret)
2586	goto out;	2586	goto out;
2587	} else {	2587	} else if (offset + len > inode->i_size) {
2588	/*	2588	/*
2589	* If we are fallocating from the end of the file onward we	2589	* If we are fallocating from the end of the file onward we
2590	* need to zero out the end of the page if i_size lands in the	2590	* need to zero out the end of the page if i_size lands in the

fs/btrfs/ioctl.c+8−0

 		bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
 	}
+	if (bctl->flags & ~(BTRFS_BALANCE_ARGS_MASK | BTRFS_BALANCE_TYPE_MASK)) {
+		ret = -EINVAL;
+		goto out_bctl;
+	}
 do_balance:
 	/*
 	 * Ownership of bctl and mutually_exclusive_operation_running
 	need_unlock = false;
 	ret = btrfs_balance(bctl, bargs);
+	bctl = NULL;
 	if (arg) {
 		if (copy_to_user(arg, bargs, sizeof(*bargs)))
 			ret = -EFAULT;
 	}
+out_bctl:
+	kfree(bctl);
 out_bargs:
 	kfree(bargs);
 out_unlock:

fs/btrfs/volumes.h+8−0

@@ -376,6 +376,14 @@ struct map_lookup { · 375 unmodified lines
376	#define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)	376	#define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)
377	#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)	377	#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
378		378
		379	#define BTRFS_BALANCE_ARGS_MASK \
		380	(BTRFS_BALANCE_ARGS_PROFILES \| \
		381	BTRFS_BALANCE_ARGS_USAGE \| \
		382	BTRFS_BALANCE_ARGS_DEVID \| \
		383	BTRFS_BALANCE_ARGS_DRANGE \| \
		384	BTRFS_BALANCE_ARGS_VRANGE \| \
		385	BTRFS_BALANCE_ARGS_LIMIT)
		386
379	/*	387	/*
380	* Profile changing flags. When SOFT is set we won't relocate chunk if	388	* Profile changing flags. When SOFT is set we won't relocate chunk if
381	* it already has the target profile (even though it may be	389	* it already has the target profile (even though it may be

fs/cifs/file.c+3−3

 	struct page *page, *tpage;
 	unsigned int expected_index;
 	int rc;
+	gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(mapping);
 	INIT_LIST_HEAD(tmplist);
 	 */
 	__set_page_locked(page);
 	rc = add_to_page_cache_locked(page, mapping,
-				      page->index, GFP_KERNEL);
+				      page->index, gfp);
 	/* give up if we can't stick it in the cache */
 	if (rc) {
 			break;
 		__set_page_locked(page);
-		if (add_to_page_cache_locked(page, mapping, page->index,
+		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
-								GFP_KERNEL)) {
 			__clear_page_locked(page);
 			break;
 		}

fs/dax.c+29−41

 static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
 			struct vm_area_struct *vma, struct vm_fault *vmf)
 {
+	struct address_space *mapping = inode->i_mapping;
 	sector_t sector = bh->b_blocknr << (inode->i_blkbits - 9);
 	unsigned long vaddr = (unsigned long)vmf->virtual_address;
 	void __pmem *addr;
 	pgoff_t size;
 	int error;
+	i_mmap_lock_read(mapping);
 	/*
 	 * Check truncate didn't happen while we were allocating a block.
 	 * If it did, this block may or may not be still allocated to the
 	error = vm_insert_mixed(vma, vaddr, pfn);
  out:
+	i_mmap_unlock_read(mapping);
 	return error;
 }
 			 * from a read fault and we've raced with a truncate
 			 */
 			error = -EIO;
-			goto unlock;
+			goto unlock_page;
 		}
-	} else {
-		i_mmap_lock_write(mapping);
 	}
 	error = get_block(inode, block, &bh, 0);
 	if (!error && (bh.b_size < PAGE_SIZE))
 		error = -EIO;		/* fs corruption? */
 	if (error)
-		goto unlock;
+		goto unlock_page;
 	if (!buffer_mapped(&bh) && !buffer_unwritten(&bh) && !vmf->cow_page) {
 		if (vmf->flags & FAULT_FLAG_WRITE) {
 			if (!error && (bh.b_size < PAGE_SIZE))
 				error = -EIO;
 			if (error)
-				goto unlock;
+				goto unlock_page;
 		} else {
-			i_mmap_unlock_write(mapping);
 			return dax_load_hole(mapping, page, vmf);
 		}
 	}
 		else
 			clear_user_highpage(new_page, vaddr);
 		if (error)
-			goto unlock;
+			goto unlock_page;
 		vmf->page = page;
 		if (!page) {
+			i_mmap_lock_read(mapping);
 			/* Check we didn't race with truncate */
 			size = (i_size_read(inode) + PAGE_SIZE - 1) >>
 								PAGE_SHIFT;
 			if (vmf->pgoff >= size) {
+				i_mmap_unlock_read(mapping);
 				error = -EIO;
-				goto unlock;
+				goto out;
 			}
 		}
 		return VM_FAULT_LOCKED;
 			WARN_ON_ONCE(!(vmf->flags & FAULT_FLAG_WRITE));
 	}
-	if (!page)
-		i_mmap_unlock_write(mapping);
  out:
 	if (error == -ENOMEM)
 		return VM_FAULT_OOM | major;
 		return VM_FAULT_SIGBUS | major;
 	return VM_FAULT_NOPAGE | major;
- unlock:
+ unlock_page:
 	if (page) {
 		unlock_page(page);
 		page_cache_release(page);
-	} else {
-		i_mmap_unlock_write(mapping);
 	}
 	goto out;
 }
 EXPORT_SYMBOL(__dax_fault);
 	block = (sector_t)pgoff << (PAGE_SHIFT - blkbits);
 	bh.b_size = PMD_SIZE;
-	i_mmap_lock_write(mapping);
 	length = get_block(inode, block, &bh, write);
 	if (length)
 		return VM_FAULT_SIGBUS;
+	i_mmap_lock_read(mapping);
 	/*
 	 * If the filesystem isn't willing to tell us the length of a hole,
 	if (!buffer_size_valid(&bh) || bh.b_size < PMD_SIZE)
 		goto fallback;
-	sector = bh.b_blocknr << (blkbits - 9);
-	if (buffer_unwritten(&bh) || buffer_new(&bh)) {
-		int i;
-		length = bdev_direct_access(bh.b_bdev, sector, &kaddr, &pfn,
-						bh.b_size);
-		if (length < 0) {
-			result = VM_FAULT_SIGBUS;
-			goto out;
-		}
-		if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
-			goto fallback;
-		for (i = 0; i < PTRS_PER_PMD; i++)
-			clear_pmem(kaddr + i * PAGE_SIZE, PAGE_SIZE);
-		wmb_pmem();
-		count_vm_event(PGMAJFAULT);
-		mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
-		result |= VM_FAULT_MAJOR;
-	}
 	/*
 	 * If we allocated new storage, make sure no process has any
 	 * zero pages covering this hole
 	 */
 	if (buffer_new(&bh)) {
-		i_mmap_unlock_write(mapping);
+		i_mmap_unlock_read(mapping);
 		unmap_mapping_range(mapping, pgoff << PAGE_SHIFT, PMD_SIZE, 0);
-		i_mmap_lock_write(mapping);
+		i_mmap_lock_read(mapping);
 	}
 	/*
 		result = VM_FAULT_NOPAGE;
 		spin_unlock(ptl);
 	} else {
+		sector = bh.b_blocknr << (blkbits - 9);
 		length = bdev_direct_access(bh.b_bdev, sector, &kaddr, &pfn,
 						bh.b_size);
 		if (length < 0) {
 		if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
 			goto fallback;
+		if (buffer_unwritten(&bh) || buffer_new(&bh)) {
+			int i;
+			for (i = 0; i < PTRS_PER_PMD; i++)
+				clear_pmem(kaddr + i * PAGE_SIZE, PAGE_SIZE);
+			wmb_pmem();
+			count_vm_event(PGMAJFAULT);
+			mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
+			result |= VM_FAULT_MAJOR;
+		}
 		result |= vmf_insert_pfn_pmd(vma, address, pmd, pfn, write);
 	}
  out:
+	i_mmap_unlock_read(mapping);
 	if (buffer_unwritten(&bh))
 		complete_unwritten(&bh, !(result & VM_FAULT_ERROR));
-	i_mmap_unlock_write(mapping);
 	return result;
  fallback:

fs/ext4/Kconfig+1−1

@@ -63,7 +63,7 @@ config EXT4_FS · 62 unmodified lines
63	If unsure, say N.	63	If unsure, say N.
64		64
65	config EXT4_USE_FOR_EXT2	65	config EXT4_USE_FOR_EXT2
66	bool "Use ext4 for ext2/ext3 file systems"	66	bool "Use ext4 for ext2 file systems"
67	depends on EXT4_FS	67	depends on EXT4_FS
68	depends on EXT2_FS=n	68	depends on EXT2_FS=n
69	default y	69	default y

fs/ext4/readpage.c+2−2

@@ -165,8 +165,8 @@ int ext4_mpage_readpages(struct address_space *mapping, · 164 unmodified lines
165	if (pages) {	165	if (pages) {
166	page = list_entry(pages->prev, struct page, lru);	166	page = list_entry(pages->prev, struct page, lru);
167	list_del(&page->lru);	167	list_del(&page->lru);
168	if (add_to_page_cache_lru(page, mapping,	168	if (add_to_page_cache_lru(page, mapping, page->index,
169	page->index, GFP_KERNEL))	169	GFP_KERNEL & mapping_gfp_mask(mapping)))
170	goto next_page;	170	goto next_page;
171	}	171	}
172		172

fs/fs-writeback.c+24−11

 				  struct wb_writeback_work *base_work,
 				  bool skip_if_busy)
 {
-	int next_memcg_id = 0;
+	struct bdi_writeback *last_wb = NULL;
-	struct bdi_writeback *wb;
+	struct bdi_writeback *wb = list_entry_rcu(&bdi->wb_list,
-	struct wb_iter iter;
+						struct bdi_writeback, bdi_node);
 	might_sleep();
 restart:
 	rcu_read_lock();
-	bdi_for_each_wb(wb, bdi, &iter, next_memcg_id) {
+	list_for_each_entry_continue_rcu(wb, &bdi->wb_list, bdi_node) {
 		DEFINE_WB_COMPLETION_ONSTACK(fallback_work_done);
 		struct wb_writeback_work fallback_work;
 		struct wb_writeback_work *work;
 		long nr_pages;
+		if (last_wb) {
+			wb_put(last_wb);
+			last_wb = NULL;
+		}
 		/* SYNC_ALL writes out I_DIRTY_TIME too */
 		if (!wb_has_dirty_io(wb) &&
 		    (base_work->sync_mode == WB_SYNC_NONE ||
 		wb_queue_work(wb, work);
-		next_memcg_id = wb->memcg_css->id + 1;
+		/*
+		 * Pin @wb so that it stays on @bdi->wb_list.  This allows
+		 * continuing iteration from @wb after dropping and
+		 * regrabbing rcu read lock.
+		 */
+		wb_get(wb);
+		last_wb = wb;
 		rcu_read_unlock();
 		wb_wait_for_completion(bdi, &fallback_work_done);
 		goto restart;
 	}
 	rcu_read_unlock();
+	if (last_wb)
+		wb_put(last_wb);
 }
 #else	/* CONFIG_CGROUP_WRITEBACK */
 	rcu_read_lock();
 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
 		struct bdi_writeback *wb;
-		struct wb_iter iter;
 		if (!bdi_has_dirty_io(bdi))
 			continue;
-		bdi_for_each_wb(wb, bdi, &iter, 0)
+		list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
 			wb_start_writeback(wb, wb_split_bdi_pages(wb, nr_pages),
 					   false, reason);
 	}
 	rcu_read_lock();
 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {
 		struct bdi_writeback *wb;
-		struct wb_iter iter;
-		bdi_for_each_wb(wb, bdi, &iter, 0)
+		list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
-			if (!list_empty(&bdi->wb.b_dirty_time))
+			if (!list_empty(&wb->b_dirty_time))
-				wb_wakeup(&bdi->wb);
+				wb_wakeup(wb);
 	}
 	rcu_read_unlock();
 	schedule_delayed_work(&dirtytime_work, dirtytime_expire_interval * HZ);

fs/mpage.c+9−6

 static struct bio *
 do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
 		sector_t *last_block_in_bio, struct buffer_head *map_bh,
-		unsigned long *first_logical_block, get_block_t get_block)
+		unsigned long *first_logical_block, get_block_t get_block,
+		gfp_t gfp)
 {
 	struct inode *inode = page->mapping->host;
 	const unsigned blkbits = inode->i_blkbits;
 				goto out;
 		}
 		bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
-				min_t(int, nr_pages, BIO_MAX_PAGES),
+				min_t(int, nr_pages, BIO_MAX_PAGES), gfp);
-				GFP_KERNEL);
 		if (bio == NULL)
 			goto confused;
 	}
 	sector_t last_block_in_bio = 0;
 	struct buffer_head map_bh;
 	unsigned long first_logical_block = 0;
+	gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(mapping);
 	map_bh.b_state = 0;
 	map_bh.b_size = 0;
 		prefetchw(&page->flags);
 		list_del(&page->lru);
 		if (!add_to_page_cache_lru(page, mapping,
-					page->index, GFP_KERNEL)) {
+					page->index,
+					gfp)) {
 			bio = do_mpage_readpage(bio, page,
 					nr_pages - page_idx,
 					&last_block_in_bio, &map_bh,
 					&first_logical_block,
-					get_block);
+					get_block, gfp);
 		}
 		page_cache_release(page);
 	}
 	sector_t last_block_in_bio = 0;
 	struct buffer_head map_bh;
 	unsigned long first_logical_block = 0;
+	gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(page->mapping);
 	map_bh.b_state = 0;
 	map_bh.b_size = 0;
 	bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio,
-			&map_bh, &first_logical_block, get_block);
+			&map_bh, &first_logical_block, get_block, gfp);
 	if (bio)
 		mpage_bio_submit(READ, bio);
 	return 0;

fs/nfsd/blocklayout.c+0−8

@@ -56,14 +56,6 @@ nfsd4_block_proc_layoutget(struct inode inode, const struct svc_fh fhp, · 55 unmodified lines
56	u32 device_generation = 0;	56	u32 device_generation = 0;
57	int error;	57	int error;
58		58
59	/*
60	* We do not attempt to support I/O smaller than the fs block size,
61	* or not aligned to it.
62	*/
63	if (args->lg_minlength < block_size) {
64	dprintk("pnfsd: I/O too small\n");
65	goto out_layoutunavailable;
66	}
67	if (seg->offset & (block_size - 1)) {	59	if (seg->offset & (block_size - 1)) {
68	dprintk("pnfsd: I/O misaligned\n");	60	dprintk("pnfsd: I/O misaligned\n");
69	goto out_layoutunavailable;	61	goto out_layoutunavailable;

fs/ocfs2/dlm/dlmmaster.c+2−1

 		if (ret < 0) {
 			mlog(ML_ERROR, "failed to dispatch assert master work\n");
 			response = DLM_MASTER_RESP_ERROR;
+			spin_unlock(&res->spinlock);
 			dlm_lockres_put(res);
 		} else {
 			dispatched = 1;
 			__dlm_lockres_grab_inflight_worker(dlm, res);
+			spin_unlock(&res->spinlock);
 		}
-		spin_unlock(&res->spinlock);
 	} else {
 		if (res)
 			dlm_lockres_put(res);

fs/ocfs2/dlm/dlmrecovery.c+1−1

 			} else {
 				dispatched = 1;
 				__dlm_lockres_grab_inflight_worker(dlm, res);
+				spin_unlock(&res->spinlock);
 			}
-			spin_unlock(&res->spinlock);
 		} else {
 			/* put.. incase we are not the master */
 			spin_unlock(&res->spinlock);

fs/ramfs/file-nommu.c+3−2

 	unsigned order;
 	void *data;
 	int ret;
+	gfp_t gfp = mapping_gfp_mask(inode->i_mapping);
 	/* make various checks */
 	order = get_order(newsize);
 	/* allocate enough contiguous pages to be able to satisfy the
 	 * request */
-	pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order);
+	pages = alloc_pages(gfp, order);
 	if (!pages)
 		return -ENOMEM;
 		struct page *page = pages + loop;
 		ret = add_to_page_cache_lru(page, inode->i_mapping, loop,
-					GFP_KERNEL);
+					gfp);
 		if (ret < 0)
 			goto add_error;

include/drm/drm_dp_mst_helper.h+2−1

 	u8 *bytes;
 };
+#define DP_REMOTE_I2C_READ_MAX_TRANSACTIONS 4
 struct drm_dp_remote_i2c_read {
 	u8 num_transactions;
 	u8 port_number;
 		u8 *bytes;
 		u8 no_stop_bit;
 		u8 i2c_transaction_delay;
-	} transactions[4];
+	} transactions[DP_REMOTE_I2C_READ_MAX_TRANSACTIONS];
 	u8 read_i2c_device_id;
 	u8 num_bytes_read;
 };

include/linux/backing-dev-defs.h+3−0

 	struct list_head work_list;
 	struct delayed_work dwork;	/* work item used for writeback */
+	struct list_head bdi_node;	/* anchored at bdi->wb_list */
 #ifdef CONFIG_CGROUP_WRITEBACK
 	struct percpu_ref refcnt;	/* used only for !root wb's */
 	struct fprop_local_percpu memcg_completions;
 	atomic_long_t tot_write_bandwidth;
 	struct bdi_writeback wb;  /* the root writeback info for this bdi */
+	struct list_head wb_list; /* list of all wbs */
 #ifdef CONFIG_CGROUP_WRITEBACK
 	struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */
 	struct rb_root cgwb_congested_tree; /* their congested states */

include/linux/backing-dev.h+5−64

@@ -19,13 +19,17 @@ · 18 unmodified lines
19	#include <linux/slab.h>	19	#include <linux/slab.h>
20		20
21	int __must_check bdi_init(struct backing_dev_info *bdi);	21	int __must_check bdi_init(struct backing_dev_info *bdi);
22	void bdi_destroy(struct backing_dev_info *bdi);	22	void bdi_exit(struct backing_dev_info *bdi);
23		23
24	__printf(3, 4)	24	__printf(3, 4)
25	int bdi_register(struct backing_dev_info bdi, struct device parent,	25	int bdi_register(struct backing_dev_info bdi, struct device parent,
26	const char *fmt, ...);	26	const char *fmt, ...);
27	int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);	27	int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
		28	void bdi_unregister(struct backing_dev_info *bdi);
		29
28	int __must_check bdi_setup_and_register(struct backing_dev_info , char );	30	int __must_check bdi_setup_and_register(struct backing_dev_info , char );
		31	void bdi_destroy(struct backing_dev_info *bdi);
		32
29	void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,	33	void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
30	bool range_cyclic, enum wb_reason reason);	34	bool range_cyclic, enum wb_reason reason);
31	void wb_start_background_writeback(struct bdi_writeback *wb);	35	void wb_start_background_writeback(struct bdi_writeback *wb);
@@ -408,61 +412,6 @@ static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked) · 376 unmodified lines
408	rcu_read_unlock();	412	rcu_read_unlock();
409	}	413	}
410		414
411	struct wb_iter {
412	int start_memcg_id;
413	struct radix_tree_iter tree_iter;
414	void **slot;
415	};
416
417	static inline struct bdi_writeback __wb_iter_next(struct wb_iter iter,
418	struct backing_dev_info *bdi)
419	{
420	struct radix_tree_iter *titer = &iter->tree_iter;
421
422	WARN_ON_ONCE(!rcu_read_lock_held());
423
424	if (iter->start_memcg_id >= 0) {
425	iter->slot = radix_tree_iter_init(titer, iter->start_memcg_id);
426	iter->start_memcg_id = -1;
427	} else {
428	iter->slot = radix_tree_next_slot(iter->slot, titer, 0);
429	}
430
431	if (!iter->slot)
432	iter->slot = radix_tree_next_chunk(&bdi->cgwb_tree, titer, 0);
433	if (iter->slot)
434	return *iter->slot;
435	return NULL;
436	}
437
438	static inline struct bdi_writeback __wb_iter_init(struct wb_iter iter,
439	struct backing_dev_info *bdi,
440	int start_memcg_id)
441	{
442	iter->start_memcg_id = start_memcg_id;
443
444	if (start_memcg_id)
445	return __wb_iter_next(iter, bdi);
446	else
447	return &bdi->wb;
448	}
449
450	/**
451	* bdi_for_each_wb - walk all wb's of a bdi in ascending memcg ID order
452	* @wb_cur: cursor struct bdi_writeback pointer
453	* @bdi: bdi to walk wb's of
454	* @iter: pointer to struct wb_iter to be used as iteration buffer
455	* @start_memcg_id: memcg ID to start iteration from
456	*
457	* Iterate @wb_cur through the wb's (bdi_writeback's) of @bdi in ascending
458	* memcg ID order starting from @start_memcg_id. @iter is struct wb_iter
459	* to be used as temp storage during iteration. rcu_read_lock() must be
460	* held throughout iteration.
461	*/
462	#define bdi_for_each_wb(wb_cur, bdi, iter, start_memcg_id) \
463	for ((wb_cur) = __wb_iter_init(iter, bdi, start_memcg_id); \
464	(wb_cur); (wb_cur) = __wb_iter_next(iter, bdi))
465
466	#else /* CONFIG_CGROUP_WRITEBACK */	415	#else /* CONFIG_CGROUP_WRITEBACK */
467		416
468	static inline bool inode_cgwb_enabled(struct inode *inode)	417	static inline bool inode_cgwb_enabled(struct inode *inode)
@@ -522,14 +471,6 @@ static inline void wb_blkcg_offline(struct blkcg *blkcg) · 53 unmodified lines
522	{	471	{
523	}	472	}
524		473
525	struct wb_iter {
526	int next_id;
527	};
528
529	#define bdi_for_each_wb(wb_cur, bdi, iter, start_blkcg_id) \
530	for ((iter)->next_id = (start_blkcg_id); \
531	({ (wb_cur) = !(iter)->next_id++ ? &(bdi)->wb : NULL; }); )
532
533	static inline int inode_congested(struct inode *inode, int cong_bits)	474	static inline int inode_congested(struct inode *inode, int cong_bits)
534	{	475	{
535	return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);	476	return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);

include/linux/cma.h+1−1

@@ -26,6 +26,6 @@ extern int __init cma_declare_contiguous(phys_addr_t base, · 25 unmodified lines
26	extern int cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,	26	extern int cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
27	unsigned int order_per_bit,	27	unsigned int order_per_bit,
28	struct cma **res_cma);	28	struct cma **res_cma);
29	extern struct page cma_alloc(struct cma cma, unsigned int count, unsigned int align);	29	extern struct page cma_alloc(struct cma cma, size_t count, unsigned int align);
30	extern bool cma_release(struct cma cma, const struct page pages, unsigned int count);	30	extern bool cma_release(struct cma cma, const struct page pages, unsigned int count);
31	#endif	31	#endif

include/linux/compiler-gcc.h+13−0

@@ -237,12 +237,25 @@ · 236 unmodified lines
237	#define KASAN_ABI_VERSION 3	237	#define KASAN_ABI_VERSION 3
238	#endif	238	#endif
239		239
		240	#if GCC_VERSION >= 40902
		241	/*
		242	* Tell the compiler that address safety instrumentation (KASAN)
		243	* should not be applied to that function.
		244	* Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
		245	*/
		246	#define __no_sanitize_address __attribute__((no_sanitize_address))
		247	#endif
		248
240	#endif /* gcc version >= 40000 specific checks */	249	#endif /* gcc version >= 40000 specific checks */
241		250
242	#if !defined(__noclone)	251	#if !defined(__noclone)
243	#define __noclone /* not needed */	252	#define __noclone /* not needed */
244	#endif	253	#endif
245		254
		255	#if !defined(__no_sanitize_address)
		256	#define __no_sanitize_address
		257	#endif
		258
246	/*	259	/*
247	* A trick to suppress uninitialized variable warning without generating any	260	* A trick to suppress uninitialized variable warning without generating any
248	* code	261	* code

include/linux/compiler.h+53−13

@@ -198,19 +198,45 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect); · 197 unmodified lines
198		198
199	#include <uapi/linux/types.h>	199	#include <uapi/linux/types.h>
200		200
201	static __always_inline void __read_once_size(const volatile void p, void res, int size)	201	#define __READ_ONCE_SIZE \
		202	({ \
		203	switch (size) { \
		204	case 1: (__u8 )res = (volatile __u8 )p; break; \
		205	case 2: (__u16 )res = (volatile __u16 )p; break; \
		206	case 4: (__u32 )res = (volatile __u32 )p; break; \
		207	case 8: (__u64 )res = (volatile __u64 )p; break; \
		208	default: \
		209	barrier(); \
		210	__builtin_memcpy((void )res, (const void )p, size); \
		211	barrier(); \
		212	} \
		213	})
		214
		215	static __always_inline
		216	void __read_once_size(const volatile void p, void res, int size)
202	{	217	{
203	switch (size) {	218	__READ_ONCE_SIZE;
204	case 1: (__u8 )res = (volatile __u8 )p; break;	219	}
205	case 2: (__u16 )res = (volatile __u16 )p; break;	220
206	case 4: (__u32 )res = (volatile __u32 )p; break;	221	#ifdef CONFIG_KASAN
207	case 8: (__u64 )res = (volatile __u64 )p; break;	222	/*
208	default:	223	* This function is not 'inline' because __no_sanitize_address confilcts
209	barrier();	224	* with inlining. Attempt to inline it may cause a build failure.
210	__builtin_memcpy((void )res, (const void )p, size);	225	* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
211	barrier();	226	* '__maybe_unused' allows us to avoid defined-but-not-used warnings.
212	}	227	*/
		228	static __no_sanitize_address __maybe_unused
		229	void __read_once_size_nocheck(const volatile void p, void res, int size)
		230	{
		231	__READ_ONCE_SIZE;
		232	}
		233	#else
		234	static __always_inline
		235	void __read_once_size_nocheck(const volatile void p, void res, int size)
		236	{
		237	__READ_ONCE_SIZE;
213	}	238	}
		239	#endif
214		240
215	static __always_inline void __write_once_size(volatile void p, void res, int size)	241	static __always_inline void __write_once_size(volatile void p, void res, int size)
216	{	242	{
@@ -248,8 +274,22 @@ static __always_inline void __write_once_size(volatile void p, void res, int s · 31 unmodified lines
248	* required ordering.	274	* required ordering.
249	*/	275	*/
250		276
251	#define READ_ONCE(x) \	277	#define __READ_ONCE(x, check) \
252	({ union { typeof(x) __val; char __c[1]; } __u; __read_once_size(&(x), __u.__c, sizeof(x)); __u.__val; })	278	({ \
		279	union { typeof(x) __val; char __c[1]; } __u; \
		280	if (check) \
		281	__read_once_size(&(x), __u.__c, sizeof(x)); \
		282	else \
		283	__read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \
		284	__u.__val; \
		285	})
		286	#define READ_ONCE(x) __READ_ONCE(x, 1)
		287
		288	/*
		289	* Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
		290	* to hide memory access from KASAN.
		291	*/
		292	#define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
253		293
254	#define WRITE_ONCE(x, val) \	294	#define WRITE_ONCE(x, val) \
255	({ \	295	({ \

include/linux/dma-contiguous.h+2−2

@@ -111,7 +111,7 @@ static inline int dma_declare_contiguous(struct device *dev, phys_addr_t size, · 110 unmodified lines
111	return ret;	111	return ret;
112	}	112	}
113		113
114	struct page dma_alloc_from_contiguous(struct device dev, int count,	114	struct page dma_alloc_from_contiguous(struct device dev, size_t count,
115	unsigned int order);	115	unsigned int order);
116	bool dma_release_from_contiguous(struct device dev, struct page pages,	116	bool dma_release_from_contiguous(struct device dev, struct page pages,
117	int count);	117	int count);
@@ -144,7 +144,7 @@ int dma_declare_contiguous(struct device *dev, phys_addr_t size, · 26 unmodified lines
144	}	144	}
145		145
146	static inline	146	static inline
147	struct page dma_alloc_from_contiguous(struct device dev, int count,	147	struct page dma_alloc_from_contiguous(struct device dev, size_t count,
148	unsigned int order)	148	unsigned int order)
149	{	149	{
150	return NULL;	150	return NULL;

include/linux/memcontrol.h+5−3

 struct list_head *mem_cgroup_cgwb_list(struct mem_cgroup *memcg);
 struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
-void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pavail,
+void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
-			 unsigned long *pdirty, unsigned long *pwriteback);
+			 unsigned long *pheadroom, unsigned long *pdirty,
+			 unsigned long *pwriteback);
 #else	/* CONFIG_CGROUP_WRITEBACK */
 }
 static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
-				       unsigned long *pavail,
+				       unsigned long *pfilepages,
+				       unsigned long *pheadroom,
 				       unsigned long *pdirty,
 				       unsigned long *pwriteback)
 {

include/net/af_unix.h+1−1

@@ -64,7 +64,7 @@ struct unix_sock { · 63 unmodified lines
64	struct socket_wq peer_wq;	64	struct socket_wq peer_wq;
65	};	65	};
66		66
67	static inline struct unix_sock unix_sk(struct sock sk)	67	static inline struct unix_sock unix_sk(const struct sock sk)
68	{	68	{
69	return (struct unix_sock *)sk;	69	return (struct unix_sock *)sk;
70	}	70	}

include/net/inet_timewait_sock.h+2−2

@@ -113,12 +113,12 @@ void __inet_twsk_hashdance(struct inet_timewait_sock tw, struct sock sk, · 112 unmodified lines
113	void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo,	113	void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo,
114	bool rearm);	114	bool rearm);
115		115
116	static void inline inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo)	116	static inline void inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo)
117	{	117	{
118	__inet_twsk_schedule(tw, timeo, false);	118	__inet_twsk_schedule(tw, timeo, false);
119	}	119	}
120		120
121	static void inline inet_twsk_reschedule(struct inet_timewait_sock *tw, int timeo)	121	static inline void inet_twsk_reschedule(struct inet_timewait_sock *tw, int timeo)
122	{	122	{
123	__inet_twsk_schedule(tw, timeo, true);	123	__inet_twsk_schedule(tw, timeo, true);
124	}	124	}

include/net/sock.h+8−0

@@ -828,6 +828,14 @@ static inline __must_check int sk_add_backlog(struct sock sk, struct sk_buff s · 827 unmodified lines
828	if (sk_rcvqueues_full(sk, limit))	828	if (sk_rcvqueues_full(sk, limit))
829	return -ENOBUFS;	829	return -ENOBUFS;
830		830
		831	/*
		832	* If the skb was allocated from pfmemalloc reserves, only
		833	* allow SOCK_MEMALLOC sockets to use it as this socket is
		834	* helping free memory
		835	*/
		836	if (skb_pfmemalloc(skb) && !sock_flag(sk, SOCK_MEMALLOC))
		837	return -ENOMEM;
		838
831	__sk_add_backlog(sk, skb);	839	__sk_add_backlog(sk, skb);
832	sk->sk_backlog.len += skb->truesize;	840	sk->sk_backlog.len += skb->truesize;
833	return 0;	841	return 0;

include/sound/soc.h+4−2

 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 	.tlv.p  = (tlv_array),\
-	.info = snd_soc_info_volsw, \
+	.info = snd_soc_info_volsw_sx, \
 	.get = snd_soc_get_volsw_sx,\
 	.put = snd_soc_put_volsw_sx, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
 	.tlv.p  = (tlv_array), \
-	.info = snd_soc_info_volsw, \
+	.info = snd_soc_info_volsw_sx, \
 	.get = snd_soc_get_volsw_sx, \
 	.put = snd_soc_put_volsw_sx, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
+int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
+			  struct snd_ctl_elem_info *uinfo);
 #define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);

include/sound/wm8904.h+1−1

@@ -119,7 +119,7 @@ · 118 unmodified lines
119	#define WM8904_MIC_REGS 2	119	#define WM8904_MIC_REGS 2
120	#define WM8904_GPIO_REGS 4	120	#define WM8904_GPIO_REGS 4
121	#define WM8904_DRC_REGS 4	121	#define WM8904_DRC_REGS 4
122	#define WM8904_EQ_REGS 25	122	#define WM8904_EQ_REGS 24
123		123
124	/**	124	/**
125	* DRC configurations are specified with a label and a set of register	125	* DRC configurations are specified with a label and a set of register

include/uapi/asm-generic/signal.h+2−0

  *	SA_RESTORER	0x04000000
  */
+#if !defined MINSIGSTKSZ || !defined SIGSTKSZ
 #define MINSIGSTKSZ	2048
 #define SIGSTKSZ	8192
+#endif
 #ifndef __ASSEMBLY__
 typedef struct {

include/uapi/linux/openvswitch.h+15−21

 	OVS_KEY_ATTR_MPLS,      /* array of struct ovs_key_mpls.
 				 * The implementation may restrict
 				 * the accepted length of the array. */
-	OVS_KEY_ATTR_CT_STATE,	/* u8 bitmask of OVS_CS_F_* */
+	OVS_KEY_ATTR_CT_STATE,	/* u32 bitmask of OVS_CS_F_* */
 	OVS_KEY_ATTR_CT_ZONE,	/* u16 connection tracking zone. */
 	OVS_KEY_ATTR_CT_MARK,	/* u32 connection tracking mark */
-	OVS_KEY_ATTR_CT_LABEL,	/* 16-octet connection tracking label */
+	OVS_KEY_ATTR_CT_LABELS,	/* 16-octet connection tracking label */
 #ifdef __KERNEL__
 	OVS_KEY_ATTR_TUNNEL_INFO,  /* struct ip_tunnel_info */
 	__u8	nd_tll[ETH_ALEN];
 };
-#define OVS_CT_LABEL_LEN	16
+#define OVS_CT_LABELS_LEN	16
-struct ovs_key_ct_label {
+struct ovs_key_ct_labels {
-	__u8	ct_label[OVS_CT_LABEL_LEN];
+	__u8	ct_labels[OVS_CT_LABELS_LEN];
 };
 /* OVS_KEY_ATTR_CT_STATE flags */
 #define OVS_CS_F_ESTABLISHED       0x02 /* Part of an existing connection. */
 #define OVS_CS_F_RELATED           0x04 /* Related to an established
 					 * connection. */
-#define OVS_CS_F_INVALID           0x20 /* Could not track connection. */
+#define OVS_CS_F_REPLY_DIR         0x08 /* Flow is in the reply direction. */
-#define OVS_CS_F_REPLY_DIR         0x40 /* Flow is in the reply direction. */
+#define OVS_CS_F_INVALID           0x10 /* Could not track connection. */
-#define OVS_CS_F_TRACKED           0x80 /* Conntrack has occurred. */
+#define OVS_CS_F_TRACKED           0x20 /* Conntrack has occurred. */
 /**
  * enum ovs_flow_attr - attributes for %OVS_FLOW_* commands.
 /**
  * enum ovs_ct_attr - Attributes for %OVS_ACTION_ATTR_CT action.
- * @OVS_CT_ATTR_FLAGS: u32 connection tracking flags.
+ * @OVS_CT_ATTR_COMMIT: If present, commits the connection to the conntrack
+ * table. This allows future packets for the same connection to be identified
+ * as 'established' or 'related'.
  * @OVS_CT_ATTR_ZONE: u16 connection tracking zone.
  * @OVS_CT_ATTR_MARK: u32 value followed by u32 mask. For each bit set in the
  * mask, the corresponding bit in the value is copied to the connection
  * tracking mark field in the connection.
- * @OVS_CT_ATTR_LABEL: %OVS_CT_LABEL_LEN value followed by %OVS_CT_LABEL_LEN
+ * @OVS_CT_ATTR_LABEL: %OVS_CT_LABELS_LEN value followed by %OVS_CT_LABELS_LEN
  * mask. For each bit set in the mask, the corresponding bit in the value is
  * copied to the connection tracking label field in the connection.
  * @OVS_CT_ATTR_HELPER: variable length string defining conntrack ALG.
  */
 enum ovs_ct_attr {
 	OVS_CT_ATTR_UNSPEC,
-	OVS_CT_ATTR_FLAGS,      /* u8 bitmask of OVS_CT_F_*. */
+	OVS_CT_ATTR_COMMIT,     /* No argument, commits connection. */
 	OVS_CT_ATTR_ZONE,       /* u16 zone id. */
 	OVS_CT_ATTR_MARK,       /* mark to associate with this connection. */
-	OVS_CT_ATTR_LABEL,      /* label to associate with this connection. */
+	OVS_CT_ATTR_LABELS,     /* labels to associate with this connection. */
 	OVS_CT_ATTR_HELPER,     /* netlink helper to assist detection of
 				   related connections. */
 	__OVS_CT_ATTR_MAX
 #define OVS_CT_ATTR_MAX (__OVS_CT_ATTR_MAX - 1)
-/*
- * OVS_CT_ATTR_FLAGS flags - bitmask of %OVS_CT_F_*
- * @OVS_CT_F_COMMIT: Commits the flow to the conntrack table. This allows
- * future packets for the same connection to be identified as 'established'
- * or 'related'.
- */
-#define OVS_CT_F_COMMIT		0x01
 /**
  * enum ovs_action_attr - Action types.
  *
 				       * data immediately followed by a mask.
 				       * The data must be zero for the unmasked
 				       * bits. */
-	OVS_ACTION_ATTR_CT,           /* One nested OVS_CT_ATTR_* . */
+	OVS_ACTION_ATTR_CT,           /* Nested OVS_CT_ATTR_* . */
 	__OVS_ACTION_ATTR_MAX,	      /* Nothing past this will be accepted
 				       * from userspace. */

include/uapi/linux/rtnetlink.h+1−1

@@ -160,7 +160,7 @@ struct rtattr { · 159 unmodified lines
160		160
161	/* Macros to handle rtattributes */	161	/* Macros to handle rtattributes */
162		162
163	#define RTA_ALIGNTO 4	163	#define RTA_ALIGNTO 4U
164	#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )	164	#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
165	#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \	165	#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
166	(rta)->rta_len >= sizeof(struct rtattr) && \	166	(rta)->rta_len >= sizeof(struct rtattr) && \

kernel/irq/msi.c+1−5

 {
 	struct irq_chip *chip = info->chip;
-	BUG_ON(!chip);
+	BUG_ON(!chip || !chip->irq_mask || !chip->irq_unmask);
-	if (!chip->irq_mask)
-		chip->irq_mask = pci_msi_mask_irq;
-	if (!chip->irq_unmask)
-		chip->irq_unmask = pci_msi_unmask_irq;
 	if (!chip->irq_set_affinity)
 		chip->irq_set_affinity = msi_domain_set_affinity;
 }

kernel/kmod.c+6−2

@@ -327,9 +327,13 @@ static void call_usermodehelper_exec_work(struct work_struct *work) · 326 unmodified lines
327	call_usermodehelper_exec_sync(sub_info);	327	call_usermodehelper_exec_sync(sub_info);
328	} else {	328	} else {
329	pid_t pid;	329	pid_t pid;
330		330	/*
		331	* Use CLONE_PARENT to reparent it to kthreadd; we do not
		332	* want to pollute current->children, and we need a parent
		333	* that always ignores SIGCHLD to ensure auto-reaping.
		334	*/
331	pid = kernel_thread(call_usermodehelper_exec_async, sub_info,	335	pid = kernel_thread(call_usermodehelper_exec_async, sub_info,
332	SIGCHLD);	336	CLONE_PARENT \| SIGCHLD);
333	if (pid < 0) {	337	if (pid < 0) {
334	sub_info->retval = pid;	338	sub_info->retval = pid;
335	umh_complete(sub_info);	339	umh_complete(sub_info);

kernel/sched/core.c+8−4

 	trace_sched_wakeup_new(p);
 	check_preempt_curr(rq, p, WF_FORK);
 #ifdef CONFIG_SMP
-	if (p->sched_class->task_woken)
+	if (p->sched_class->task_woken) {
+		/*
+		 * Nothing relies on rq->lock after this, so its fine to
+		 * drop it.
+		 */
+		lockdep_unpin_lock(&rq->lock);
 		p->sched_class->task_woken(rq, p);
+		lockdep_pin_lock(&rq->lock);
+	}
 #endif
 	task_rq_unlock(rq, p, &flags);
 }
 	alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
 	alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
-	/* nohz_full won't take effect without isolating the cpus. */
-	tick_nohz_full_add_cpus_to(cpu_isolated_map);
 	sched_init_numa();
 	/*

kernel/sched/deadline.c+13−4

 	 * Queueing this task back might have overloaded rq, check if we need
 	 * to kick someone away.
 	 */
-	if (has_pushable_dl_tasks(rq))
+	if (has_pushable_dl_tasks(rq)) {
+		/*
+		 * Nothing relies on rq->lock after this, so its safe to drop
+		 * rq->lock.
+		 */
+		lockdep_unpin_lock(&rq->lock);
 		push_dl_task(rq);
+		lockdep_pin_lock(&rq->lock);
+	}
 #endif
 unlock:
 		int target = find_later_rq(p);
 		if (target != -1 &&
-				dl_time_before(p->dl.deadline,
+				(dl_time_before(p->dl.deadline,
-					cpu_rq(target)->dl.earliest_dl.curr))
+					cpu_rq(target)->dl.earliest_dl.curr) ||
+				(cpu_rq(target)->dl.dl_nr_running == 0)))
 			cpu = target;
 	}
 	rcu_read_unlock();
 		later_rq = cpu_rq(cpu);
-		if (!dl_time_before(task->dl.deadline,
+		if (later_rq->dl.dl_nr_running &&
+		    !dl_time_before(task->dl.deadline,
 					later_rq->dl.earliest_dl.curr)) {
 			/*
 			 * Target rq has tasks of equal or earlier deadline,

kernel/sched/fair.c+5−4

 	 */
 	tg_weight = atomic_long_read(&tg->load_avg);
 	tg_weight -= cfs_rq->tg_load_avg_contrib;
-	tg_weight += cfs_rq_load_avg(cfs_rq);
+	tg_weight += cfs_rq->load.weight;
 	return tg_weight;
 }
 	long tg_weight, load, shares;
 	tg_weight = calc_tg_weight(tg, cfs_rq);
-	load = cfs_rq_load_avg(cfs_rq);
+	load = cfs_rq->load.weight;
 	shares = (tg->shares * load);
 	if (tg_weight)
 /* Group cfs_rq's load_avg is used for task_h_load and update_cfs_share */
 static inline int update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)
 {
-	int decayed;
 	struct sched_avg *sa = &cfs_rq->avg;
+	int decayed, removed = 0;
 	if (atomic_long_read(&cfs_rq->removed_load_avg)) {
 		long r = atomic_long_xchg(&cfs_rq->removed_load_avg, 0);
 		sa->load_avg = max_t(long, sa->load_avg - r, 0);
 		sa->load_sum = max_t(s64, sa->load_sum - r * LOAD_AVG_MAX, 0);
+		removed = 1;
 	}
 	if (atomic_long_read(&cfs_rq->removed_util_avg)) {
 	cfs_rq->load_last_update_time_copy = sa->last_update_time;
 #endif
-	return decayed;
+	return decayed || removed;
 }
 /* Update task and its cfs_rq load average */

kernel/sched/idle.c+2−0

 	rcu_idle_enter();
 	trace_cpu_idle_rcuidle(0, smp_processor_id());
 	local_irq_enable();
+	stop_critical_timings();
 	while (!tif_need_resched() &&
 		(cpu_idle_force_poll || tick_check_broadcast_expired()))
 		cpu_relax();
+	start_critical_timings();
 	trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
 	rcu_idle_exit();
 	return 1;

kernel/time/timekeeping.c+1−1

@@ -1251,7 +1251,7 @@ void __init timekeeping_init(void) · 1250 unmodified lines
1251	set_normalized_timespec64(&tmp, -boot.tv_sec, -boot.tv_nsec);	1251	set_normalized_timespec64(&tmp, -boot.tv_sec, -boot.tv_nsec);
1252	tk_set_wall_to_mono(tk, tmp);	1252	tk_set_wall_to_mono(tk, tmp);
1253		1253
1254	timekeeping_update(tk, TK_MIRROR);	1254	timekeeping_update(tk, TK_MIRROR \| TK_CLOCK_WAS_SET);
1255		1255
1256	write_seqcount_end(&tk_core.seq);	1256	write_seqcount_end(&tk_core.seq);
1257	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);	1257	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);

kernel/trace/trace_stack.c+11−0

 	if (!object_is_on_stack(stack))
 		return;
+	/* Can't do this from NMI context (can cause deadlocks) */
+	if (in_nmi())
+		return;
 	local_irq_save(flags);
 	arch_spin_lock(&max_stack_lock);
+	/*
+	 * RCU may not be watching, make it see us.
+	 * The stack trace code uses rcu_sched.
+	 */
+	rcu_irq_enter();
 	/* In case another CPU set the tracer_frame on us */
 	if (unlikely(!frame_size))
 		this_size -= tracer_frame;
 	}
  out:
+	rcu_irq_exit();
 	arch_spin_unlock(&max_stack_lock);
 	local_irq_restore(flags);
 }

kernel/workqueue.c+4−4

 	timer_stats_timer_set_start_info(&dwork->timer);
 	dwork->wq = wq;
+	/* timer isn't guaranteed to run in this cpu, record earlier */
+	if (cpu == WORK_CPU_UNBOUND)
+		cpu = raw_smp_processor_id();
 	dwork->cpu = cpu;
 	timer->expires = jiffies + delay;
-	if (unlikely(cpu != WORK_CPU_UNBOUND))
+	add_timer_on(timer, cpu);
-		add_timer_on(timer, cpu);
-	else
-		add_timer(timer);
 }
 /**

lib/Kconfig+1−0

@@ -220,6 +220,7 @@ config ZLIB_INFLATE · 219 unmodified lines
220		220
221	config ZLIB_DEFLATE	221	config ZLIB_DEFLATE
222	tristate	222	tristate
		223	select BITREVERSE
223		224
224	config LZO_COMPRESS	225	config LZO_COMPRESS
225	tristate	226	tristate

lib/Kconfig.debug+1−0

@@ -197,6 +197,7 @@ config ENABLE_MUST_CHECK · 196 unmodified lines
197	config FRAME_WARN	197	config FRAME_WARN
198	int "Warn for stack frames larger than (needs gcc 4.4)"	198	int "Warn for stack frames larger than (needs gcc 4.4)"
199	range 0 8192	199	range 0 8192
		200	default 0 if KASAN
200	default 1024 if !64BIT	201	default 1024 if !64BIT
201	default 2048 if 64BIT	202	default 2048 if 64BIT
202	help	203	help

lib/fault-inject.c+1−1

@@ -44,7 +44,7 @@ static void fail_dump(struct fault_attr *attr) · 43 unmodified lines
44	printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure.\n"	44	printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure.\n"
45	"name %pd, interval %lu, probability %lu, "	45	"name %pd, interval %lu, probability %lu, "
46	"space %d, times %d\n", attr->dname,	46	"space %d, times %d\n", attr->dname,
47	attr->probability, attr->interval,	47	attr->interval, attr->probability,
48	atomic_read(&attr->space),	48	atomic_read(&attr->space),
49	atomic_read(&attr->times));	49	atomic_read(&attr->times));
50	if (attr->verbose > 1)	50	if (attr->verbose > 1)

mm/backing-dev.c+30−6

 						release_work);
 	struct backing_dev_info *bdi = wb->bdi;
+	spin_lock_irq(&cgwb_lock);
+	list_del_rcu(&wb->bdi_node);
+	spin_unlock_irq(&cgwb_lock);
 	wb_shutdown(wb);
 	css_put(wb->memcg_css);
 		ret = radix_tree_insert(&bdi->cgwb_tree, memcg_css->id, wb);
 		if (!ret) {
 			atomic_inc(&bdi->usage_cnt);
+			list_add_tail_rcu(&wb->bdi_node, &bdi->wb_list);
 			list_add(&wb->memcg_node, memcg_cgwb_list);
 			list_add(&wb->blkcg_node, blkcg_cgwb_list);
 			css_get(memcg_css);
 static void cgwb_bdi_destroy(struct backing_dev_info *bdi)
 {
 	struct radix_tree_iter iter;
-	struct bdi_writeback_congested *congested, *congested_n;
+	struct rb_node *rbn;
 	void **slot;
 	WARN_ON(test_bit(WB_registered, &bdi->wb.state));
 	radix_tree_for_each_slot(slot, &bdi->cgwb_tree, &iter, 0)
 		cgwb_kill(*slot);
-	rbtree_postorder_for_each_entry_safe(congested, congested_n,
+	while ((rbn = rb_first(&bdi->cgwb_congested_tree))) {
-					&bdi->cgwb_congested_tree, rb_node) {
+		struct bdi_writeback_congested *congested =
-		rb_erase(&congested->rb_node, &bdi->cgwb_congested_tree);
+			rb_entry(rbn, struct bdi_writeback_congested, rb_node);
+		rb_erase(rbn, &bdi->cgwb_congested_tree);
 		congested->bdi = NULL;	/* mark @congested unlinked */
 	}
 int bdi_init(struct backing_dev_info *bdi)
 {
+	int ret;
 	bdi->dev = NULL;
 	bdi->min_ratio = 0;
 	bdi->max_ratio = 100;
 	bdi->max_prop_frac = FPROP_FRAC_BASE;
 	INIT_LIST_HEAD(&bdi->bdi_list);
+	INIT_LIST_HEAD(&bdi->wb_list);
 	init_waitqueue_head(&bdi->wb_waitq);
-	return cgwb_bdi_init(bdi);
+	ret = cgwb_bdi_init(bdi);
+	list_add_tail_rcu(&bdi->wb.bdi_node, &bdi->wb_list);
+	return ret;
 }
 EXPORT_SYMBOL(bdi_init);
 	synchronize_rcu_expedited();
 }
-void bdi_destroy(struct backing_dev_info *bdi)
+void bdi_unregister(struct backing_dev_info *bdi)
 {
 	/* make sure nobody finds us on the bdi_list anymore */
 	bdi_remove_from_list(bdi);
 		device_unregister(bdi->dev);
 		bdi->dev = NULL;
 	}
+}
+void bdi_exit(struct backing_dev_info *bdi)
+{
+	WARN_ON_ONCE(bdi->dev);
 	wb_exit(&bdi->wb);
 }
+void bdi_destroy(struct backing_dev_info *bdi)
+{
+	bdi_unregister(bdi);
+	bdi_exit(bdi);
+}
 EXPORT_SYMBOL(bdi_destroy);
 /*

mm/cma.c+2−2

@@ -361,7 +361,7 @@ err: · 360 unmodified lines
361	* This function allocates part of contiguous memory on specific	361	* This function allocates part of contiguous memory on specific
362	* contiguous memory area.	362	* contiguous memory area.
363	*/	363	*/
364	struct page cma_alloc(struct cma cma, unsigned int count, unsigned int align)	364	struct page cma_alloc(struct cma cma, size_t count, unsigned int align)
365	{	365	{
366	unsigned long mask, offset, pfn, start = 0;	366	unsigned long mask, offset, pfn, start = 0;
367	unsigned long bitmap_maxno, bitmap_no, bitmap_count;	367	unsigned long bitmap_maxno, bitmap_no, bitmap_count;
@@ -371,7 +371,7 @@ struct page cma_alloc(struct cma cma, unsigned int count, unsigned int align) · 3 unmodified lines
371	if (!cma \|\| !cma->count)	371	if (!cma \|\| !cma->count)
372	return NULL;	372	return NULL;
373		373
374	pr_debug("%s(cma %p, count %d, align %d)\n", __func__, (void *)cma,	374	pr_debug("%s(cma %p, count %zu, align %d)\n", __func__, (void *)cma,
375	count, align);	375	count, align);
376		376
377	if (!count)	377	if (!count)

mm/filemap.c+5−4

 			break;
 		}
+		if (fatal_signal_pending(current)) {
+			status = -EINTR;
+			break;
+		}
 		status = a_ops->write_begin(file, mapping, pos, bytes, flags,
 						&page, &fsdata);
 		if (unlikely(status < 0))
 		written += copied;
 		balance_dirty_pages_ratelimited(mapping);
-		if (fatal_signal_pending(current)) {
-			status = -EINTR;
-			break;
-		}
 	} while (iov_iter_count(i));
 	return written ? written : status;

mm/huge_memory.c+2−1

 	for (_pte = pte; _pte < pte+HPAGE_PMD_NR;
 	     _pte++, address += PAGE_SIZE) {
 		pte_t pteval = *_pte;
-		if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) {
+		if (pte_none(pteval) || (pte_present(pteval) &&
+				is_zero_pfn(pte_pfn(pteval)))) {
 			if (!userfaultfd_armed(vma) &&
 			    ++none_or_zero <= khugepaged_max_ptes_none)
 				continue;

mm/memcontrol.c+18−18

 	ret = page_counter_memparse(args, "-1", &threshold);
 	if (ret)
 		return ret;
+	threshold <<= PAGE_SHIFT;
 	mutex_lock(&memcg->thresholds_lock);
 /**
  * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg
  * @wb: bdi_writeback in question
- * @pavail: out parameter for number of available pages
+ * @pfilepages: out parameter for number of file pages
+ * @pheadroom: out parameter for number of allocatable pages according to memcg
  * @pdirty: out parameter for number of dirty pages
  * @pwriteback: out parameter for number of pages under writeback
  *
- * Determine the numbers of available, dirty, and writeback pages in @wb's
+ * Determine the numbers of file, headroom, dirty, and writeback pages in
- * memcg.  Dirty and writeback are self-explanatory.  Available is a bit
+ * @wb's memcg.  File, dirty and writeback are self-explanatory.  Headroom
- * more involved.
+ * is a bit more involved.
  *
- * A memcg's headroom is "min(max, high) - used".  The available memory is
+ * A memcg's headroom is "min(max, high) - used".  In the hierarchy, the
- * calculated as the lowest headroom of itself and the ancestors plus the
+ * headroom is calculated as the lowest headroom of itself and the
- * number of pages already being used for file pages.  Note that this
+ * ancestors.  Note that this doesn't consider the actual amount of
- * doesn't consider the actual amount of available memory in the system.
+ * available memory in the system.  The caller should further cap
- * The caller should further cap *@pavail accordingly.
+ * *@pheadroom accordingly.
  */
-void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pavail,
+void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
-			 unsigned long *pdirty, unsigned long *pwriteback)
+			 unsigned long *pheadroom, unsigned long *pdirty,
+			 unsigned long *pwriteback)
 {
 	struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
 	struct mem_cgroup *parent;
-	unsigned long head_room = PAGE_COUNTER_MAX;
-	unsigned long file_pages;
 	*pdirty = mem_cgroup_read_stat(memcg, MEM_CGROUP_STAT_DIRTY);
 	/* this should eventually include NR_UNSTABLE_NFS */
 	*pwriteback = mem_cgroup_read_stat(memcg, MEM_CGROUP_STAT_WRITEBACK);
+	*pfilepages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) |
+						     (1 << LRU_ACTIVE_FILE));
+	*pheadroom = PAGE_COUNTER_MAX;
-	file_pages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) |
-						    (1 << LRU_ACTIVE_FILE));
 	while ((parent = parent_mem_cgroup(memcg))) {
 		unsigned long ceiling = min(memcg->memory.limit, memcg->high);
 		unsigned long used = page_counter_read(&memcg->memory);
-		head_room = min(head_room, ceiling - min(ceiling, used));
+		*pheadroom = min(*pheadroom, ceiling - min(ceiling, used));
 		memcg = parent;
 	}
-	*pavail = file_pages + head_room;
 }
 #else	/* CONFIG_CGROUP_WRITEBACK */

mm/memory.c+2−0

@@ -2426,6 +2426,8 @@ void unmap_mapping_range(struct address_space *mapping, · 2425 unmodified lines
2426	if (details.last_index < details.first_index)	2426	if (details.last_index < details.first_index)
2427	details.last_index = ULONG_MAX;	2427	details.last_index = ULONG_MAX;
2428		2428
		2429
		2430	/* DAX uses i_mmap_lock to serialise file truncate vs page fault */
2429	i_mmap_lock_write(mapping);	2431	i_mmap_lock_write(mapping);
2430	if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap)))	2432	if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap)))
2431	unmap_mapping_range_tree(&mapping->i_mmap, &details);	2433	unmap_mapping_range_tree(&mapping->i_mmap, &details);

mm/page-writeback.c+32−22

@@ -145,9 +145,6 @@ struct dirty_throttle_control { · 144 unmodified lines
145	unsigned long pos_ratio;	145	unsigned long pos_ratio;
146	};	146	};
147		147
148	#define DTC_INIT_COMMON(__wb) .wb = (__wb), \
149	.wb_completions = &(__wb)->completions
150
151	/*	148	/*
152	* Length of period for aging writeout fractions of bdis. This is an	149	* Length of period for aging writeout fractions of bdis. This is an
153	* arbitrarily chosen number. The longer the period, the slower fractions will	150	* arbitrarily chosen number. The longer the period, the slower fractions will
@@ -157,12 +154,16 @@ struct dirty_throttle_control { · 3 unmodified lines
157		154
158	#ifdef CONFIG_CGROUP_WRITEBACK	155	#ifdef CONFIG_CGROUP_WRITEBACK
159		156
160	#define GDTC_INIT(__wb) .dom = &global_wb_domain, \	157	#define GDTC_INIT(__wb) .wb = (__wb), \
161	DTC_INIT_COMMON(__wb)	158	.dom = &global_wb_domain, \
		159	.wb_completions = &(__wb)->completions
		160
162	#define GDTC_INIT_NO_WB .dom = &global_wb_domain	161	#define GDTC_INIT_NO_WB .dom = &global_wb_domain
163	#define MDTC_INIT(__wb, __gdtc) .dom = mem_cgroup_wb_domain(__wb), \	162
164	.gdtc = __gdtc, \	163	#define MDTC_INIT(__wb, __gdtc) .wb = (__wb), \
165	DTC_INIT_COMMON(__wb)	164	.dom = mem_cgroup_wb_domain(__wb), \
		165	.wb_completions = &(__wb)->memcg_completions, \
		166	.gdtc = __gdtc
166		167
167	static bool mdtc_valid(struct dirty_throttle_control *dtc)	168	static bool mdtc_valid(struct dirty_throttle_control *dtc)
168	{	169	{
@@ -213,7 +214,8 @@ static void wb_min_max_ratio(struct bdi_writeback *wb, · 44 unmodified lines
213		214
214	#else /* CONFIG_CGROUP_WRITEBACK */	215	#else /* CONFIG_CGROUP_WRITEBACK */
215		216
216	#define GDTC_INIT(__wb) DTC_INIT_COMMON(__wb)	217	#define GDTC_INIT(__wb) .wb = (__wb), \
		218	.wb_completions = &(__wb)->completions
217	#define GDTC_INIT_NO_WB	219	#define GDTC_INIT_NO_WB
218	#define MDTC_INIT(__wb, __gdtc)	220	#define MDTC_INIT(__wb, __gdtc)
219		221
@@ -682,13 +684,19 @@ static unsigned long hard_dirty_limit(struct wb_domain *dom, · 462 unmodified lines
682	return max(thresh, dom->dirty_limit);	684	return max(thresh, dom->dirty_limit);
683	}	685	}
684		686
685	/* memory available to a memcg domain is capped by system-wide clean memory */	687	/*
686	static void mdtc_cap_avail(struct dirty_throttle_control *mdtc)	688	* Memory which can be further allocated to a memcg domain is capped by
		689	* system-wide clean memory excluding the amount being used in the domain.
		690	*/
		691	static void mdtc_calc_avail(struct dirty_throttle_control *mdtc,
		692	unsigned long filepages, unsigned long headroom)
687	{	693	{
688	struct dirty_throttle_control *gdtc = mdtc_gdtc(mdtc);	694	struct dirty_throttle_control *gdtc = mdtc_gdtc(mdtc);
689	unsigned long clean = gdtc->avail - min(gdtc->avail, gdtc->dirty);	695	unsigned long clean = filepages - min(filepages, mdtc->dirty);
		696	unsigned long global_clean = gdtc->avail - min(gdtc->avail, gdtc->dirty);
		697	unsigned long other_clean = global_clean - min(global_clean, clean);
690		698
691	mdtc->avail = min(mdtc->avail, clean);	699	mdtc->avail = filepages + min(headroom, other_clean);
692	}	700	}
693		701
694	/**	702	/**
@@ -1562,16 +1570,16 @@ static void balance_dirty_pages(struct address_space *mapping, · 867 unmodified lines
1562	}	1570	}
1563		1571
1564	if (mdtc) {	1572	if (mdtc) {
1565	unsigned long writeback;	1573	unsigned long filepages, headroom, writeback;
1566		1574
1567	/*	1575	/*
1568	* If @wb belongs to !root memcg, repeat the same	1576	* If @wb belongs to !root memcg, repeat the same
1569	* basic calculations for the memcg domain.	1577	* basic calculations for the memcg domain.
1570	*/	1578	*/
1571	mem_cgroup_wb_stats(wb, &mdtc->avail, &mdtc->dirty,	1579	mem_cgroup_wb_stats(wb, &filepages, &headroom,
1572	&writeback);	1580	&mdtc->dirty, &writeback);
1573	mdtc_cap_avail(mdtc);
1574	mdtc->dirty += writeback;	1581	mdtc->dirty += writeback;
		1582	mdtc_calc_avail(mdtc, filepages, headroom);
1575		1583
1576	domain_dirty_limits(mdtc);	1584	domain_dirty_limits(mdtc);
1577		1585
@@ -1893,10 +1901,11 @@ bool wb_over_bg_thresh(struct bdi_writeback *wb) · 315 unmodified lines
1893	return true;	1901	return true;
1894		1902
1895	if (mdtc) {	1903	if (mdtc) {
1896	unsigned long writeback;	1904	unsigned long filepages, headroom, writeback;
1897		1905
1898	mem_cgroup_wb_stats(wb, &mdtc->avail, &mdtc->dirty, &writeback);	1906	mem_cgroup_wb_stats(wb, &filepages, &headroom, &mdtc->dirty,
1899	mdtc_cap_avail(mdtc);	1907	&writeback);
		1908	mdtc_calc_avail(mdtc, filepages, headroom);
1900	domain_dirty_limits(mdtc); /* ditto, ignore writeback */	1909	domain_dirty_limits(mdtc); /* ditto, ignore writeback */
1901		1910
1902	if (mdtc->dirty > mdtc->bg_thresh)	1911	if (mdtc->dirty > mdtc->bg_thresh)
@@ -1956,7 +1965,6 @@ void laptop_mode_timer_fn(unsigned long data) · 53 unmodified lines
1956	int nr_pages = global_page_state(NR_FILE_DIRTY) +	1965	int nr_pages = global_page_state(NR_FILE_DIRTY) +
1957	global_page_state(NR_UNSTABLE_NFS);	1966	global_page_state(NR_UNSTABLE_NFS);
1958	struct bdi_writeback *wb;	1967	struct bdi_writeback *wb;
1959	struct wb_iter iter;
1960		1968
1961	/*	1969	/*
1962	* We want to write everything out, not just down to the dirty	1970	* We want to write everything out, not just down to the dirty
@@ -1965,10 +1973,12 @@ void laptop_mode_timer_fn(unsigned long data) · 2 unmodified lines
1965	if (!bdi_has_dirty_io(&q->backing_dev_info))	1973	if (!bdi_has_dirty_io(&q->backing_dev_info))
1966	return;	1974	return;
1967		1975
1968	bdi_for_each_wb(wb, &q->backing_dev_info, &iter, 0)	1976	rcu_read_lock();
		1977	list_for_each_entry_rcu(wb, &q->backing_dev_info.wb_list, bdi_node)
1969	if (wb_has_dirty_io(wb))	1978	if (wb_has_dirty_io(wb))
1970	wb_start_writeback(wb, nr_pages, true,	1979	wb_start_writeback(wb, nr_pages, true,
1971	WB_REASON_LAPTOP_TIMER);	1980	WB_REASON_LAPTOP_TIMER);
		1981	rcu_read_unlock();
1972	}	1982	}
1973		1983
1974	/*	1984	/*

mm/readahead.c+4−4

@@ -89,8 +89,8 @@ int read_cache_pages(struct address_space mapping, struct list_head pages, · 88 unmodified lines
89	while (!list_empty(pages)) {	89	while (!list_empty(pages)) {
90	page = list_to_page(pages);	90	page = list_to_page(pages);
91	list_del(&page->lru);	91	list_del(&page->lru);
92	if (add_to_page_cache_lru(page, mapping,	92	if (add_to_page_cache_lru(page, mapping, page->index,
93	page->index, GFP_KERNEL)) {	93	GFP_KERNEL & mapping_gfp_mask(mapping))) {
94	read_cache_pages_invalidate_page(mapping, page);	94	read_cache_pages_invalidate_page(mapping, page);
95	continue;	95	continue;
96	}	96	}
@@ -127,8 +127,8 @@ static int read_pages(struct address_space mapping, struct file filp, · 30 unmodified lines
127	for (page_idx = 0; page_idx < nr_pages; page_idx++) {	127	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
128	struct page *page = list_to_page(pages);	128	struct page *page = list_to_page(pages);
129	list_del(&page->lru);	129	list_del(&page->lru);
130	if (!add_to_page_cache_lru(page, mapping,	130	if (!add_to_page_cache_lru(page, mapping, page->index,
131	page->index, GFP_KERNEL)) {	131	GFP_KERNEL & mapping_gfp_mask(mapping))) {
132	mapping->a_ops->readpage(filp, page);	132	mapping->a_ops->readpage(filp, page);
133	}	133	}
134	page_cache_release(page);	134	page_cache_release(page);

mm/vmstat.c+4−3

 static void vmstat_update(struct work_struct *w)
 {
-	if (refresh_cpu_vm_stats())
+	if (refresh_cpu_vm_stats()) {
 		/*
 		 * Counters were updated so we expect more updates
 		 * to occur in the future. Keep on running the
 		 * update worker thread.
 		 */
-		schedule_delayed_work(this_cpu_ptr(&vmstat_work),
+		schedule_delayed_work_on(smp_processor_id(),
+			this_cpu_ptr(&vmstat_work),
 			round_jiffies_relative(sysctl_stat_interval));
-	else {
+	} else {
 		/*
 		 * We did not update any counters so the app may be in
 		 * a mode where it does not cause counter updates.

net/bluetooth/hci_conn.c+71−28

@@ -91,10 +91,50 @@ static void hci_connect_le_scan_cleanup(struct hci_conn *conn) · 90 unmodified lines
91	* autoconnect action, remove them completely. If they are, just unmark	91	* autoconnect action, remove them completely. If they are, just unmark
92	* them as waiting for connection, by clearing explicit_connect field.	92	* them as waiting for connection, by clearing explicit_connect field.
93	*/	93	*/
94	if (params->auto_connect == HCI_AUTO_CONN_EXPLICIT)	94	params->explicit_connect = false;
		95
		96	list_del_init(&params->action);
		97
		98	switch (params->auto_connect) {
		99	case HCI_AUTO_CONN_EXPLICIT:
95	hci_conn_params_del(conn->hdev, bdaddr, bdaddr_type);	100	hci_conn_params_del(conn->hdev, bdaddr, bdaddr_type);
96	else	101	/* return instead of break to avoid duplicate scan update */
97	params->explicit_connect = false;	102	return;
		103	case HCI_AUTO_CONN_DIRECT:
		104	case HCI_AUTO_CONN_ALWAYS:
		105	list_add(&params->action, &conn->hdev->pend_le_conns);
		106	break;
		107	case HCI_AUTO_CONN_REPORT:
		108	list_add(&params->action, &conn->hdev->pend_le_reports);
		109	break;
		110	default:
		111	break;
		112	}
		113
		114	hci_update_background_scan(conn->hdev);
		115	}
		116
		117	static void hci_conn_cleanup(struct hci_conn *conn)
		118	{
		119	struct hci_dev *hdev = conn->hdev;
		120
		121	if (test_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags))
		122	hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);
		123
		124	hci_chan_list_flush(conn);
		125
		126	hci_conn_hash_del(hdev, conn);
		127
		128	if (hdev->notify)
		129	hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
		130
		131	hci_conn_del_sysfs(conn);
		132
		133	debugfs_remove_recursive(conn->debugfs);
		134
		135	hci_dev_put(hdev);
		136
		137	hci_conn_put(conn);
98	}	138	}
99		139
100	/* This function requires the caller holds hdev->lock */	140	/* This function requires the caller holds hdev->lock */
@@ -102,8 +142,13 @@ static void hci_connect_le_scan_remove(struct hci_conn *conn) · 1 unmodified line
102	{	142	{
103	hci_connect_le_scan_cleanup(conn);	143	hci_connect_le_scan_cleanup(conn);
104		144
105	hci_conn_hash_del(conn->hdev, conn);	145	/* We can't call hci_conn_del here since that would deadlock
106	hci_update_background_scan(conn->hdev);	146	* with trying to call cancel_delayed_work_sync(&conn->disc_work).
		147	* Instead, call just hci_conn_cleanup() which contains the bare
		148	* minimum cleanup operations needed for a connection in this
		149	* state.
		150	*/
		151	hci_conn_cleanup(conn);
107	}	152	}
108		153
109	static void hci_acl_create_connection(struct hci_conn *conn)	154	static void hci_acl_create_connection(struct hci_conn *conn)
@@ -581,27 +626,17 @@ int hci_conn_del(struct hci_conn *conn) · 471 unmodified lines
581	}	626	}
582	}	627	}
583		628
584	hci_chan_list_flush(conn);
585
586	if (conn->amp_mgr)	629	if (conn->amp_mgr)
587	amp_mgr_put(conn->amp_mgr);	630	amp_mgr_put(conn->amp_mgr);
588		631
589	hci_conn_hash_del(hdev, conn);
590	if (hdev->notify)
591	hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
592
593	skb_queue_purge(&conn->data_q);	632	skb_queue_purge(&conn->data_q);
594		633
595	hci_conn_del_sysfs(conn);	634	/* Remove the connection from the list and cleanup its remaining
596		635	* state. This is a separate function since for some cases like
597	debugfs_remove_recursive(conn->debugfs);	636	* BT_CONNECT_SCAN we only want the cleanup part without the
598		637	* rest of hci_conn_del.
599	if (test_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags))	638	*/
600	hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);	639	hci_conn_cleanup(conn);
601
602	hci_dev_put(hdev);
603
604	hci_conn_put(conn);
605		640
606	return 0;	641	return 0;
607	}	642	}
@@ -973,15 +1008,23 @@ static int hci_explicit_conn_params_set(struct hci_request *req, · 365 unmodified lines
973	if (is_connected(hdev, addr, addr_type))	1008	if (is_connected(hdev, addr, addr_type))
974	return -EISCONN;	1009	return -EISCONN;
975		1010
976	params = hci_conn_params_add(hdev, addr, addr_type);	1011	params = hci_conn_params_lookup(hdev, addr, addr_type);
977	if (!params)	1012	if (!params) {
978	return -EIO;	1013	params = hci_conn_params_add(hdev, addr, addr_type);
		1014	if (!params)
		1015	return -ENOMEM;
979		1016
980	/* If we created new params, or existing params were marked as disabled,	1017	/* If we created new params, mark them to be deleted in
981	* mark them to be used just once to connect.	1018	* hci_connect_le_scan_cleanup. It's different case than
982	*/	1019	* existing disabled params, those will stay after cleanup.
983	if (params->auto_connect == HCI_AUTO_CONN_DISABLED) {	1020	*/
984	params->auto_connect = HCI_AUTO_CONN_EXPLICIT;	1021	params->auto_connect = HCI_AUTO_CONN_EXPLICIT;
		1022	}
		1023
		1024	/* We're trying to connect, so make sure params are at pend_le_conns */
		1025	if (params->auto_connect == HCI_AUTO_CONN_DISABLED \|\|
		1026	params->auto_connect == HCI_AUTO_CONN_REPORT \|\|
		1027	params->auto_connect == HCI_AUTO_CONN_EXPLICIT) {
985	list_del_init(&params->action);	1028	list_del_init(&params->action);
986	list_add(&params->action, &hdev->pend_le_conns);	1029	list_add(&params->action, &hdev->pend_le_conns);
987	}	1030	}

net/bluetooth/hci_core.c+0−7

@@ -2861,13 +2861,6 @@ struct hci_conn_params hci_explicit_connect_lookup(struct hci_dev hdev, · 2860 unmodified lines
2861	return param;	2861	return param;
2862	}	2862	}
2863		2863
2864	list_for_each_entry(param, &hdev->pend_le_reports, action) {
2865	if (bacmp(&param->addr, addr) == 0 &&
2866	param->addr_type == addr_type &&
2867	param->explicit_connect)
2868	return param;
2869	}
2870
2871	return NULL;	2864	return NULL;
2872	}	2865	}
2873		2866

net/bluetooth/hci_event.c+8−3

@@ -55,7 +55,12 @@ static void hci_cc_inquiry_cancel(struct hci_dev hdev, struct sk_buff skb) · 54 unmodified lines
55	wake_up_bit(&hdev->flags, HCI_INQUIRY);	55	wake_up_bit(&hdev->flags, HCI_INQUIRY);
56		56
57	hci_dev_lock(hdev);	57	hci_dev_lock(hdev);
58	hci_discovery_set_state(hdev, DISCOVERY_STOPPED);	58	/* Set discovery state to stopped if we're not doing LE active
		59	* scanning.
		60	*/
		61	if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) \|\|
		62	hdev->le_scan_type != LE_SCAN_ACTIVE)
		63	hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
59	hci_dev_unlock(hdev);	64	hci_dev_unlock(hdev);
60		65
61	hci_conn_check_pending(hdev);	66	hci_conn_check_pending(hdev);
@@ -4648,8 +4653,8 @@ static struct hci_conn check_pending_le_conn(struct hci_dev hdev, · 4586 unmodified lines
4648	/* If we're not connectable only connect devices that we have in	4653	/* If we're not connectable only connect devices that we have in
4649	* our pend_le_conns list.	4654	* our pend_le_conns list.
4650	*/	4655	*/
4651	params = hci_explicit_connect_lookup(hdev, addr, addr_type);	4656	params = hci_pend_le_action_lookup(&hdev->pend_le_conns, addr,
4652		4657	addr_type);
4653	if (!params)	4658	if (!params)
4654	return NULL;	4659	return NULL;
4655		4660

net/bluetooth/mgmt.c+20−4

 				       auth_type);
 	} else {
 		u8 addr_type;
+		struct hci_conn_params *p;
 		/* Convert from L2CAP channel address type to HCI address type
 		 */
 		 * If connection parameters already exist, then they
 		 * will be kept and this function does nothing.
 		 */
-		hci_conn_params_add(hdev, &cp->addr.bdaddr, addr_type);
+		p = hci_conn_params_add(hdev, &cp->addr.bdaddr, addr_type);
+		if (p->auto_connect == HCI_AUTO_CONN_EXPLICIT)
+			p->auto_connect = HCI_AUTO_CONN_DISABLED;
 		conn = hci_connect_le_scan(hdev, &cp->addr.bdaddr,
 					   addr_type, sec_level,
 		__hci_update_background_scan(req);
 		break;
 	case HCI_AUTO_CONN_REPORT:
-		list_add(&params->action, &hdev->pend_le_reports);
+		if (params->explicit_connect)
+			list_add(&params->action, &hdev->pend_le_conns);
+		else
+			list_add(&params->action, &hdev->pend_le_reports);
 		__hci_update_background_scan(req);
 		break;
 	case HCI_AUTO_CONN_DIRECT:
 	case HCI_AUTO_CONN_ALWAYS:
 		if (!is_connected(hdev, addr, addr_type)) {
 			list_add(&params->action, &hdev->pend_le_conns);
-			__hci_update_background_scan(req);
+			/* If we are in scan phase of connecting, we were
+			 * already added to pend_le_conns and scanning.
+			 */
+			if (params->auto_connect != HCI_AUTO_CONN_EXPLICIT)
+				__hci_update_background_scan(req);
 		}
 		break;
 	}
 			goto unlock;
 		}
-		if (params->auto_connect == HCI_AUTO_CONN_DISABLED) {
+		if (params->auto_connect == HCI_AUTO_CONN_DISABLED ||
+		    params->auto_connect == HCI_AUTO_CONN_EXPLICIT) {
 			err = cmd->cmd_complete(cmd,
 						MGMT_STATUS_INVALID_PARAMS);
 			mgmt_pending_remove(cmd);
 			if (p->auto_connect == HCI_AUTO_CONN_DISABLED)
 				continue;
 			device_removed(sk, hdev, &p->addr, p->addr_type);
+			if (p->explicit_connect) {
+				p->auto_connect = HCI_AUTO_CONN_EXPLICIT;
+				continue;
+			}
 			list_del(&p->action);
 			list_del(&p->list);
 			kfree(p);

net/ceph/osd_client.c+9−4

 	switch (op->op) {
 	case CEPH_OSD_OP_READ:
 	case CEPH_OSD_OP_WRITE:
+	case CEPH_OSD_OP_WRITEFULL:
 		ceph_osd_data_release(&op->extent.osd_data);
 		break;
 	case CEPH_OSD_OP_CALL:
 	size_t payload_len = 0;
 	BUG_ON(opcode != CEPH_OSD_OP_READ && opcode != CEPH_OSD_OP_WRITE &&
-	       opcode != CEPH_OSD_OP_ZERO && opcode != CEPH_OSD_OP_TRUNCATE);
+	       opcode != CEPH_OSD_OP_WRITEFULL && opcode != CEPH_OSD_OP_ZERO &&
+	       opcode != CEPH_OSD_OP_TRUNCATE);
 	op->extent.offset = offset;
 	op->extent.length = length;
 	op->extent.truncate_size = truncate_size;
 	op->extent.truncate_seq = truncate_seq;
-	if (opcode == CEPH_OSD_OP_WRITE)
+	if (opcode == CEPH_OSD_OP_WRITE || opcode == CEPH_OSD_OP_WRITEFULL)
 		payload_len += length;
 	op->payload_len = payload_len;
 		break;
 	case CEPH_OSD_OP_READ:
 	case CEPH_OSD_OP_WRITE:
+	case CEPH_OSD_OP_WRITEFULL:
 	case CEPH_OSD_OP_ZERO:
 	case CEPH_OSD_OP_TRUNCATE:
-		if (src->op == CEPH_OSD_OP_WRITE)
+		if (src->op == CEPH_OSD_OP_WRITE ||
+		    src->op == CEPH_OSD_OP_WRITEFULL)
 			request_data_len = src->extent.length;
 		dst->extent.offset = cpu_to_le64(src->extent.offset);
 		dst->extent.length = cpu_to_le64(src->extent.length);
 		dst->extent.truncate_seq =
 			cpu_to_le32(src->extent.truncate_seq);
 		osd_data = &src->extent.osd_data;
-		if (src->op == CEPH_OSD_OP_WRITE)
+		if (src->op == CEPH_OSD_OP_WRITE ||
+		    src->op == CEPH_OSD_OP_WRITEFULL)
 			ceph_osdc_msg_data_add(req->r_request, osd_data);
 		else
 			ceph_osdc_msg_data_add(req->r_reply, osd_data);

net/core/ethtool.c+1−1

@@ -1284,7 +1284,7 @@ static int ethtool_get_strings(struct net_device dev, void __user useraddr) · 1283 unmodified lines
1284		1284
1285	gstrings.len = ret;	1285	gstrings.len = ret;
1286		1286
1287	data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);	1287	data = kcalloc(gstrings.len, ETH_GSTRING_LEN, GFP_USER);
1288	if (!data)	1288	if (!data)
1289	return -ENOMEM;	1289	return -ENOMEM;
1290		1290

net/core/filter.c+6−1

 		return dev_forward_skb(dev, skb2);
 	skb2->dev = dev;
+	skb_sender_cpu_clear(skb2);
 	return dev_queue_xmit(skb2);
 }
 		goto out;
 	/* We're copying the filter that has been originally attached,
-	 * so no conversion/decode needed anymore.
+	 * so no conversion/decode needed anymore. eBPF programs that
+	 * have no original program cannot be dumped through this.
 	 */
+	ret = -EACCES;
 	fprog = filter->prog->orig_prog;
+	if (!fprog)
+		goto out;
 	ret = fprog->len;
 	if (!len)

net/dsa/dsa.c+59−11

 #include <linux/of_platform.h>
 #include <linux/of_net.h>
 #include <linux/sysfs.h>
+#include <linux/phy_fixed.h>
 #include "dsa_priv.h"
 char dsa_driver_version[] = "0.1";
 	if (ret < 0)
 		goto out;
-	ds->slave_mii_bus = mdiobus_alloc();
+	ds->slave_mii_bus = devm_mdiobus_alloc(parent);
 	if (ds->slave_mii_bus == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	ret = mdiobus_register(ds->slave_mii_bus);
 	if (ret < 0)
-		goto out_free;
+		goto out;
 	/*
 	return ret;
-out_free:
-	mdiobus_free(ds->slave_mii_bus);
 out:
-	kfree(ds);
 	return ret;
 }
 	/*
 	 * Allocate and initialise switch state.
 	 */
-	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
+	ds = devm_kzalloc(parent, sizeof(*ds) + drv->priv_size, GFP_KERNEL);
 	if (ds == NULL)
 		return ERR_PTR(-ENOMEM);
 static void dsa_switch_destroy(struct dsa_switch *ds)
 {
+	struct device_node *port_dn;
+	struct phy_device *phydev;
+	struct dsa_chip_data *cd = ds->pd;
+	int port;
 #ifdef CONFIG_NET_DSA_HWMON
 	if (ds->hwmon_dev)
 		hwmon_device_unregister(ds->hwmon_dev);
 #endif
+	/* Disable configuration of the CPU and DSA ports */
+	for (port = 0; port < DSA_MAX_PORTS; port++) {
+		if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port)))
+			continue;
+		port_dn = cd->port_dn[port];
+		if (of_phy_is_fixed_link(port_dn)) {
+			phydev = of_phy_find_device(port_dn);
+			if (phydev) {
+				int addr = phydev->addr;
+				phy_device_free(phydev);
+				of_node_put(port_dn);
+				fixed_phy_del(addr);
+			}
+		}
+	}
+	/* Destroy network devices for physical switch ports. */
+	for (port = 0; port < DSA_MAX_PORTS; port++) {
+		if (!(ds->phys_port_mask & (1 << port)))
+			continue;
+		if (!ds->ports[port])
+			continue;
+		unregister_netdev(ds->ports[port]);
+		free_netdev(ds->ports[port]);
+	}
+	mdiobus_unregister(ds->slave_mii_bus);
 }
 #ifdef CONFIG_PM_SLEEP
 }
 #endif
-static void dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev,
+static int dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev,
-			  struct device *parent, struct dsa_platform_data *pd)
+			 struct device *parent, struct dsa_platform_data *pd)
 {
 	int i;
+	unsigned configured = 0;
 	dst->pd = pd;
 	dst->master_netdev = dev;
 		dst->ds[i] = ds;
 		if (ds->drv->poll_link != NULL)
 			dst->link_poll_needed = 1;
+		++configured;
 	}
+	/*
+	 * If no switch was found, exit cleanly
+	 */
+	if (!configured)
+		return -EPROBE_DEFER;
 	/*
 	 * If we use a tagging format that doesn't have an ethertype
 	 * field, make sure that all packets from this point on get
 		dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
 		add_timer(&dst->link_poll_timer);
 	}
+	return 0;
 }
 static int dsa_probe(struct platform_device *pdev)
 		goto out;
 	}
-	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
+	dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL);
 	if (dst == NULL) {
 		dev_put(dev);
 		ret = -ENOMEM;
 	platform_set_drvdata(pdev, dst);
-	dsa_setup_dst(dst, dev, &pdev->dev, pd);
+	ret = dsa_setup_dst(dst, dev, &pdev->dev, pd);
+	if (ret)
+		goto out;
 	return 0;
 	for (i = 0; i < dst->pd->nr_chips; i++) {
 		struct dsa_switch *ds = dst->ds[i];
-		if (ds != NULL)
+		if (ds)
 			dsa_switch_destroy(ds);
 	}
 }

net/ipv4/arp.c+5−3

 	if (!skb)
 		return;
-	skb_dst_set(skb, dst);
+	skb_dst_set(skb, dst_clone(dst));
 	arp_xmit(skb);
 }
 	}
 	if (skb && !(dev->priv_flags & IFF_XMIT_DST_RELEASE))
-		dst = dst_clone(skb_dst(skb));
+		dst = skb_dst(skb);
 	arp_send_dst(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
 		     dst_hw, dev->dev_addr, NULL, dst);
 }
 				} else {
 					pneigh_enqueue(&arp_tbl,
 						       in_dev->arp_parms, skb);
-					return 0;
+					goto out_free_dst;
 				}
 				goto out;
 			}
 out:
 	consume_skb(skb);
+out_free_dst:
+	dst_release(reply_dst);
 	return 0;
 }

net/ipv4/inet_connection_sock.c+10−9

@@ -577,21 +577,22 @@ EXPORT_SYMBOL(inet_rtx_syn_ack); · 576 unmodified lines
577	static bool reqsk_queue_unlink(struct request_sock_queue *queue,	577	static bool reqsk_queue_unlink(struct request_sock_queue *queue,
578	struct request_sock *req)	578	struct request_sock *req)
579	{	579	{
580	struct listen_sock *lopt = queue->listen_opt;
581	struct request_sock **prev;	580	struct request_sock **prev;
		581	struct listen_sock *lopt;
582	bool found = false;	582	bool found = false;
583		583
584	spin_lock(&queue->syn_wait_lock);	584	spin_lock(&queue->syn_wait_lock);
585		585	lopt = queue->listen_opt;
586	for (prev = &lopt->syn_table[req->rsk_hash]; *prev != NULL;	586	if (lopt) {
587	prev = &(*prev)->dl_next) {	587	for (prev = &lopt->syn_table[req->rsk_hash]; *prev != NULL;
588	if (*prev == req) {	588	prev = &(*prev)->dl_next) {
589	*prev = req->dl_next;	589	if (*prev == req) {
590	found = true;	590	*prev = req->dl_next;
591	break;	591	found = true;
		592	break;
		593	}
592	}	594	}
593	}	595	}
594
595	spin_unlock(&queue->syn_wait_lock);	596	spin_unlock(&queue->syn_wait_lock);
596	if (timer_pending(&req->rsk_timer) && del_timer_sync(&req->rsk_timer))	597	if (timer_pending(&req->rsk_timer) && del_timer_sync(&req->rsk_timer))
597	reqsk_put(req);	598	reqsk_put(req);

net/ipv6/addrconf.c+2−0

@@ -3119,6 +3119,8 @@ static void addrconf_gre_config(struct net_device *dev) · 3118 unmodified lines
3119	}	3119	}
3120		3120
3121	addrconf_addr_gen(idev, true);	3121	addrconf_addr_gen(idev, true);
		3122	if (dev->flags & IFF_POINTOPOINT)
		3123	addrconf_add_mroute(dev);
3122	}	3124	}
3123	#endif	3125	#endif
3124		3126

net/ipv6/ip6_output.c+3−0

@@ -376,6 +376,9 @@ int ip6_forward(struct sk_buff *skb) · 375 unmodified lines
376	if (skb->pkt_type != PACKET_HOST)	376	if (skb->pkt_type != PACKET_HOST)
377	goto drop;	377	goto drop;
378		378
		379	if (unlikely(skb->sk))
		380	goto drop;
		381
379	if (skb_warn_if_lro(skb))	382	if (skb_warn_if_lro(skb))
380	goto drop;	383	goto drop;
381		384

net/ipv6/route.c+23−26

 	struct net_device *loopback_dev = net->loopback_dev;
 	int cpu;
+	if (dev == loopback_dev)
+		return;
 	for_each_possible_cpu(cpu) {
 		struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
 		struct rt6_info *rt;
 			struct inet6_dev *rt_idev = rt->rt6i_idev;
 			struct net_device *rt_dev = rt->dst.dev;
-			if (rt_idev && (rt_idev->dev == dev || !dev) &&
+			if (rt_idev->dev == dev) {
-			    rt_idev->dev != loopback_dev) {
 				rt->rt6i_idev = in6_dev_get(loopback_dev);
 				in6_dev_put(rt_idev);
 			}
-			if (rt_dev && (rt_dev == dev || !dev) &&
+			if (rt_dev == dev) {
-			    rt_dev != loopback_dev) {
 				rt->dst.dev = loopback_dev;
 				dev_hold(rt->dst.dev);
 				dev_put(rt_dev);
 {
 }
-static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
-					 unsigned long old)
-{
-	return NULL;
-}
 static struct dst_ops ip6_dst_blackhole_ops = {
 	.family			=	AF_INET6,
 	.destroy		=	ip6_dst_destroy,
 	.default_advmss		=	ip6_default_advmss,
 	.update_pmtu		=	ip6_rt_blackhole_update_pmtu,
 	.redirect		=	ip6_rt_blackhole_redirect,
-	.cow_metrics		=	ip6_rt_blackhole_cow_metrics,
+	.cow_metrics		=	dst_cow_metrics_generic,
 	.neigh_lookup		=	ip6_neigh_lookup,
 };
 #endif
+static void rt6_info_init(struct rt6_info *rt)
+{
+	struct dst_entry *dst = &rt->dst;
+	memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
+	INIT_LIST_HEAD(&rt->rt6i_siblings);
+	INIT_LIST_HEAD(&rt->rt6i_uncached);
+}
 /* allocate dst with ip6_dst_ops */
 static struct rt6_info *__ip6_dst_alloc(struct net *net,
 					struct net_device *dev,
 	struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
 					0, DST_OBSOLETE_FORCE_CHK, flags);
-	if (rt) {
+	if (rt)
-		struct dst_entry *dst = &rt->dst;
+		rt6_info_init(rt);
-		memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
-		INIT_LIST_HEAD(&rt->rt6i_siblings);
-		INIT_LIST_HEAD(&rt->rt6i_uncached);
-	}
 	return rt;
 }
 	rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
 	if (rt) {
-		new = &rt->dst;
+		rt6_info_init(rt);
-		memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
+		new = &rt->dst;
 		new->__use = 1;
 		new->input = dst_discard;
 		new->output = dst_discard_sk;
-		if (dst_metrics_read_only(&ort->dst))
+		dst_copy_metrics(new, &ort->dst);
-			new->_metrics = ort->dst._metrics;
-		else
-			dst_copy_metrics(new, &ort->dst);
 		rt->rt6i_idev = ort->rt6i_idev;
 		if (rt->rt6i_idev)
 			in6_dev_hold(rt->rt6i_idev);
 		rt->rt6i_gateway = ort->rt6i_gateway;
-		rt->rt6i_flags = ort->rt6i_flags;
+		rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
 		rt->rt6i_metric = 0;
 		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
 	fib6_clean_all(net, fib6_ifdown, &adn);
 	icmp6_clean_all(fib6_ifdown, &adn);
-	rt6_uncached_list_flush_dev(net, dev);
+	if (dev)
+		rt6_uncached_list_flush_dev(net, dev);
 }
 struct rt6_mtu_change_arg {

net/ipv6/xfrm6_policy.c+1−0

@@ -37,6 +37,7 @@ static struct dst_entry xfrm6_dst_lookup(struct net net, int tos, int oif, · 36 unmodified lines
37		37
38	memset(&fl6, 0, sizeof(fl6));	38	memset(&fl6, 0, sizeof(fl6));
39	fl6.flowi6_oif = oif;	39	fl6.flowi6_oif = oif;
		40	fl6.flowi6_flags = FLOWI_FLAG_SKIP_NH_OIF;
40	memcpy(&fl6.daddr, daddr, sizeof(fl6.daddr));	41	memcpy(&fl6.daddr, daddr, sizeof(fl6.daddr));
41	if (saddr)	42	if (saddr)
42	memcpy(&fl6.saddr, saddr, sizeof(fl6.saddr));	43	memcpy(&fl6.saddr, saddr, sizeof(fl6.saddr));

net/mac80211/debugfs.c+1−1

@@ -149,7 +149,7 @@ static ssize_t hwflags_read(struct file file, char __user user_buf, · 148 unmodified lines
149		149
150	for (i = 0; i < NUM_IEEE80211_HW_FLAGS; i++) {	150	for (i = 0; i < NUM_IEEE80211_HW_FLAGS; i++) {
151	if (test_bit(i, local->hw.flags))	151	if (test_bit(i, local->hw.flags))
152	pos += scnprintf(pos, end - pos, "%s",	152	pos += scnprintf(pos, end - pos, "%s\n",
153	hw_flag_names[i]);	153	hw_flag_names[i]);
154	}	154	}
155		155

net/mac80211/status.c+1−0

@@ -101,6 +101,7 @@ static void ieee80211_handle_filtered_frame(struct ieee80211_local *local, · 100 unmodified lines
101	* when it wakes up for the next time.	101	* when it wakes up for the next time.
102	*/	102	*/
103	set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);	103	set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
		104	ieee80211_clear_fast_xmit(sta);
104		105
105	/*	106	/*
106	* This code races in the following way:	107	* This code races in the following way:

net/mac80211/tx.c+5−2

 	if (!tx->sta)
 		info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
-	else if (test_and_clear_sta_flag(tx->sta, WLAN_STA_CLEAR_PS_FILT))
+	else if (test_and_clear_sta_flag(tx->sta, WLAN_STA_CLEAR_PS_FILT)) {
 		info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
+		ieee80211_check_fast_xmit(tx->sta);
+	}
 	info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
 	if (test_sta_flag(sta, WLAN_STA_PS_STA) ||
 	    test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
-	    test_sta_flag(sta, WLAN_STA_PS_DELIVER))
+	    test_sta_flag(sta, WLAN_STA_PS_DELIVER) ||
+	    test_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT))
 		goto out;
 	if (sdata->noack_map)

net/netlink/af_netlink.c+22−12

@@ -2785,6 +2785,7 @@ static int netlink_dump(struct sock *sk) · 2784 unmodified lines
2785	struct sk_buff *skb = NULL;	2785	struct sk_buff *skb = NULL;
2786	struct nlmsghdr *nlh;	2786	struct nlmsghdr *nlh;
2787	int len, err = -ENOBUFS;	2787	int len, err = -ENOBUFS;
		2788	int alloc_min_size;
2788	int alloc_size;	2789	int alloc_size;
2789		2790
2790	mutex_lock(nlk->cb_mutex);	2791	mutex_lock(nlk->cb_mutex);
@@ -2793,9 +2794,6 @@ static int netlink_dump(struct sock *sk) · 2 unmodified lines
2793	goto errout_skb;	2794	goto errout_skb;
2794	}	2795	}
2795		2796
2796	cb = &nlk->cb;
2797	alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
2798
2799	if (!netlink_rx_is_mmaped(sk) &&	2797	if (!netlink_rx_is_mmaped(sk) &&
2800	atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)	2798	atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
2801	goto errout_skb;	2799	goto errout_skb;
@@ -2805,23 +2803,35 @@ static int netlink_dump(struct sock *sk) · 3 unmodified lines
2805	* to reduce number of system calls on dump operations, if user	2803	* to reduce number of system calls on dump operations, if user
2806	* ever provided a big enough buffer.	2804	* ever provided a big enough buffer.
2807	*/	2805	*/
2808	if (alloc_size < nlk->max_recvmsg_len) {	2806	cb = &nlk->cb;
2809	skb = netlink_alloc_skb(sk,	2807	alloc_min_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
2810	nlk->max_recvmsg_len,	2808
2811	nlk->portid,	2809	if (alloc_min_size < nlk->max_recvmsg_len) {
		2810	alloc_size = nlk->max_recvmsg_len;
		2811	skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,
2812	GFP_KERNEL \|	2812	GFP_KERNEL \|
2813	__GFP_NOWARN \|	2813	__GFP_NOWARN \|
2814	__GFP_NORETRY);	2814	__GFP_NORETRY);
2815	/* available room should be exact amount to avoid MSG_TRUNC */
2816	if (skb)
2817	skb_reserve(skb, skb_tailroom(skb) -
2818	nlk->max_recvmsg_len);
2819	}	2815	}
2820	if (!skb)	2816	if (!skb) {
		2817	alloc_size = alloc_min_size;
2821	skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,	2818	skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,
2822	GFP_KERNEL);	2819	GFP_KERNEL);
		2820	}
2823	if (!skb)	2821	if (!skb)
2824	goto errout_skb;	2822	goto errout_skb;
		2823
		2824	/* Trim skb to allocated size. User is expected to provide buffer as
		2825	* large as max(min_dump_alloc, 16KiB (mac_recvmsg_len capped at
		2826	* netlink_recvmsg())). dump will pack as many smaller messages as
		2827	* could fit within the allocated skb. skb is typically allocated
		2828	* with larger space than required (could be as much as near 2x the
		2829	* requested size with align to next power of 2 approach). Allowing
		2830	* dump to use the excess space makes it difficult for a user to have a
		2831	* reasonable static buffer based on the expected largest dump of a
		2832	* single netdev. The outcome is MSG_TRUNC error.
		2833	*/
		2834	skb_reserve(skb, skb_tailroom(skb) - alloc_size);
2825	netlink_skb_set_owner_r(skb, sk);	2835	netlink_skb_set_owner_r(skb, sk);
2826		2836
2827	len = cb->dump(skb, cb);	2837	len = cb->dump(skb, cb);

net/openvswitch/actions.c+14−5

 {
 	if (skb_network_offset(skb) > MAX_L2_LEN) {
 		OVS_NLERR(1, "L2 header too long to fragment");
-		return;
+		goto err;
 	}
 	if (ethertype == htons(ETH_P_IP)) {
 		struct rt6_info ovs_rt;
 		if (!v6ops) {
-			kfree_skb(skb);
+			goto err;
-			return;
 		}
 		prepare_frag(vport, skb);
 		WARN_ONCE(1, "Failed fragment ->%s: eth=%04x, MRU=%d, MTU=%d.",
 			  ovs_vport_name(vport), ntohs(ethertype), mru,
 			  vport->dev->mtu);
-		kfree_skb(skb);
+		goto err;
 	}
+	return;
+err:
+	kfree_skb(skb);
 }
 static void do_output(struct datapath *dp, struct sk_buff *skb, int out_port,
 	case OVS_KEY_ATTR_CT_STATE:
 	case OVS_KEY_ATTR_CT_ZONE:
 	case OVS_KEY_ATTR_CT_MARK:
-	case OVS_KEY_ATTR_CT_LABEL:
+	case OVS_KEY_ATTR_CT_LABELS:
 		err = -EINVAL;
 		break;
 	}
 			break;
 		case OVS_ACTION_ATTR_CT:
+			if (!is_flow_key_valid(key)) {
+				err = ovs_flow_key_update(skb, key);
+				if (err)
+					return err;
+			}
 			err = ovs_ct_execute(ovs_dp_get_net(dp), skb, key,
 					     nla_data(a));

net/openvswitch/conntrack.c+44−45

 };
 /* Metadata label for masked write to conntrack label. */
-struct md_label {
+struct md_labels {
-	struct ovs_key_ct_label value;
+	struct ovs_key_ct_labels value;
-	struct ovs_key_ct_label mask;
+	struct ovs_key_ct_labels mask;
 };
 /* Conntrack action context for execution. */
 	struct nf_conntrack_helper *helper;
 	struct nf_conntrack_zone zone;
 	struct nf_conn *ct;
-	u32 flags;
+	u8 commit : 1;
 	u16 family;
 	struct md_mark mark;
-	struct md_label label;
+	struct md_labels labels;
 };
 static u16 key_to_nfproto(const struct sw_flow_key *key)
 #endif
 }
-static void ovs_ct_get_label(const struct nf_conn *ct,
+static void ovs_ct_get_labels(const struct nf_conn *ct,
-			     struct ovs_key_ct_label *label)
+			      struct ovs_key_ct_labels *labels)
 {
 	struct nf_conn_labels *cl = ct ? nf_ct_labels_find(ct) : NULL;
 	if (cl) {
 		size_t len = cl->words * sizeof(long);
-		if (len > OVS_CT_LABEL_LEN)
+		if (len > OVS_CT_LABELS_LEN)
-			len = OVS_CT_LABEL_LEN;
+			len = OVS_CT_LABELS_LEN;
-		else if (len < OVS_CT_LABEL_LEN)
+		else if (len < OVS_CT_LABELS_LEN)
-			memset(label, 0, OVS_CT_LABEL_LEN);
+			memset(labels, 0, OVS_CT_LABELS_LEN);
-		memcpy(label, cl->bits, len);
+		memcpy(labels, cl->bits, len);
 	} else {
-		memset(label, 0, OVS_CT_LABEL_LEN);
+		memset(labels, 0, OVS_CT_LABELS_LEN);
 	}
 }
 	key->ct.state = state;
 	key->ct.zone = zone->id;
 	key->ct.mark = ovs_ct_get_mark(ct);
-	ovs_ct_get_label(ct, &key->ct.label);
+	ovs_ct_get_labels(ct, &key->ct.labels);
 }
 /* Update 'key' based on skb->nfct. If 'post_ct' is true, then OVS has
 int ovs_ct_put_key(const struct sw_flow_key *key, struct sk_buff *skb)
 {
-	if (nla_put_u8(skb, OVS_KEY_ATTR_CT_STATE, key->ct.state))
+	if (nla_put_u32(skb, OVS_KEY_ATTR_CT_STATE, key->ct.state))
 		return -EMSGSIZE;
 	if (IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES) &&
 		return -EMSGSIZE;
 	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
-	    nla_put(skb, OVS_KEY_ATTR_CT_LABEL, sizeof(key->ct.label),
+	    nla_put(skb, OVS_KEY_ATTR_CT_LABELS, sizeof(key->ct.labels),
-		    &key->ct.label))
+		    &key->ct.labels))
 		return -EMSGSIZE;
 	return 0;
 #endif
 }
-static int ovs_ct_set_label(struct sk_buff *skb, struct sw_flow_key *key,
+static int ovs_ct_set_labels(struct sk_buff *skb, struct sw_flow_key *key,
-			    const struct ovs_key_ct_label *label,
+			     const struct ovs_key_ct_labels *labels,
-			    const struct ovs_key_ct_label *mask)
+			     const struct ovs_key_ct_labels *mask)
 {
 	enum ip_conntrack_info ctinfo;
 	struct nf_conn_labels *cl;
 		nf_ct_labels_ext_add(ct);
 		cl = nf_ct_labels_find(ct);
 	}
-	if (!cl || cl->words * sizeof(long) < OVS_CT_LABEL_LEN)
+	if (!cl || cl->words * sizeof(long) < OVS_CT_LABELS_LEN)
 		return -ENOSPC;
-	err = nf_connlabels_replace(ct, (u32 *)label, (u32 *)mask,
+	err = nf_connlabels_replace(ct, (u32 *)labels, (u32 *)mask,
-				    OVS_CT_LABEL_LEN / sizeof(u32));
+				    OVS_CT_LABELS_LEN / sizeof(u32));
 	if (err)
 		return err;
-	ovs_ct_get_label(ct, &key->ct.label);
+	ovs_ct_get_labels(ct, &key->ct.labels);
 	return 0;
 }
 	return 0;
 }
-static bool label_nonzero(const struct ovs_key_ct_label *label)
+static bool labels_nonzero(const struct ovs_key_ct_labels *labels)
 {
 	size_t i;
-	for (i = 0; i < sizeof(*label); i++)
+	for (i = 0; i < sizeof(*labels); i++)
-		if (label->ct_label[i])
+		if (labels->ct_labels[i])
 			return true;
 	return false;
 			return err;
 	}
-	if (info->flags & OVS_CT_F_COMMIT)
+	if (info->commit)
 		err = ovs_ct_commit(net, key, info, skb);
 	else
 		err = ovs_ct_lookup(net, key, info, skb);
 		if (err)
 			goto err;
 	}
-	if (label_nonzero(&info->label.mask))
+	if (labels_nonzero(&info->labels.mask))
-		err = ovs_ct_set_label(skb, key, &info->label.value,
+		err = ovs_ct_set_labels(skb, key, &info->labels.value,
-				       &info->label.mask);
+					&info->labels.mask);
 err:
 	skb_push(skb, nh_ofs);
 	return err;
 }
 static const struct ovs_ct_len_tbl ovs_ct_attr_lens[OVS_CT_ATTR_MAX + 1] = {
-	[OVS_CT_ATTR_FLAGS]	= { .minlen = sizeof(u32),
+	[OVS_CT_ATTR_COMMIT]	= { .minlen = 0, .maxlen = 0 },
-				    .maxlen = sizeof(u32) },
 	[OVS_CT_ATTR_ZONE]	= { .minlen = sizeof(u16),
 				    .maxlen = sizeof(u16) },
 	[OVS_CT_ATTR_MARK]	= { .minlen = sizeof(struct md_mark),
 				    .maxlen = sizeof(struct md_mark) },
-	[OVS_CT_ATTR_LABEL]	= { .minlen = sizeof(struct md_label),
+	[OVS_CT_ATTR_LABELS]	= { .minlen = sizeof(struct md_labels),
-				    .maxlen = sizeof(struct md_label) },
+				    .maxlen = sizeof(struct md_labels) },
 	[OVS_CT_ATTR_HELPER]	= { .minlen = 1,
 				    .maxlen = NF_CT_HELPER_NAME_LEN }
 };
 		}
 		switch (type) {
-		case OVS_CT_ATTR_FLAGS:
+		case OVS_CT_ATTR_COMMIT:
-			info->flags = nla_get_u32(a);
+			info->commit = true;
 			break;
 #ifdef CONFIG_NF_CONNTRACK_ZONES
 		case OVS_CT_ATTR_ZONE:
 		}
 #endif
 #ifdef CONFIG_NF_CONNTRACK_LABELS
-		case OVS_CT_ATTR_LABEL: {
+		case OVS_CT_ATTR_LABELS: {
-			struct md_label *label = nla_data(a);
+			struct md_labels *labels = nla_data(a);
-			info->label = *label;
+			info->labels = *labels;
 			break;
 		}
 #endif
 	    attr == OVS_KEY_ATTR_CT_MARK)
 		return true;
 	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
-	    attr == OVS_KEY_ATTR_CT_LABEL) {
+	    attr == OVS_KEY_ATTR_CT_LABELS) {
 		struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
 		return ovs_net->xt_label;
 	if (!start)
 		return -EMSGSIZE;
-	if (nla_put_u32(skb, OVS_CT_ATTR_FLAGS, ct_info->flags))
+	if (ct_info->commit && nla_put_flag(skb, OVS_CT_ATTR_COMMIT))
 		return -EMSGSIZE;
 	if (IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES) &&
 	    nla_put_u16(skb, OVS_CT_ATTR_ZONE, ct_info->zone.id))
 		    &ct_info->mark))
 		return -EMSGSIZE;
 	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
-	    nla_put(skb, OVS_CT_ATTR_LABEL, sizeof(ct_info->label),
+	    nla_put(skb, OVS_CT_ATTR_LABELS, sizeof(ct_info->labels),
-		    &ct_info->label))
+		    &ct_info->labels))
 		return -EMSGSIZE;
 	if (ct_info->helper) {
 		if (nla_put_string(skb, OVS_CT_ATTR_HELPER,
 void ovs_ct_init(struct net *net)
 {
-	unsigned int n_bits = sizeof(struct ovs_key_ct_label) * BITS_PER_BYTE;
+	unsigned int n_bits = sizeof(struct ovs_key_ct_labels) * BITS_PER_BYTE;
 	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
 	if (nf_connlabels_get(net, n_bits)) {

net/openvswitch/conntrack.h+13−1

 void ovs_ct_fill_key(const struct sk_buff *skb, struct sw_flow_key *key);
 int ovs_ct_put_key(const struct sw_flow_key *key, struct sk_buff *skb);
 void ovs_ct_free_action(const struct nlattr *a);
+static inline bool ovs_ct_state_supported(u32 state)
+{
+	return !(state & ~(OVS_CS_F_NEW | OVS_CS_F_ESTABLISHED |
+			 OVS_CS_F_RELATED | OVS_CS_F_REPLY_DIR |
+			 OVS_CS_F_INVALID | OVS_CS_F_TRACKED));
+}
 #else
 #include <linux/errno.h>
 	return false;
 }
+static inline bool ovs_ct_state_supported(u32 state)
+{
+	return false;
+}
 static inline int ovs_ct_copy_action(struct net *net, const struct nlattr *nla,
 				     const struct sw_flow_key *key,
 				     struct sw_flow_actions **acts, bool log)
 	key->ct.state = 0;
 	key->ct.zone = 0;
 	key->ct.mark = 0;
-	memset(&key->ct.label, 0, sizeof(key->ct.label));
+	memset(&key->ct.labels, 0, sizeof(key->ct.labels));
 }
 static inline int ovs_ct_put_key(const struct sw_flow_key *key,

net/openvswitch/flow.h+1−1

@@ -116,7 +116,7 @@ struct sw_flow_key { · 115 unmodified lines
116	u16 zone;	116	u16 zone;
117	u32 mark;	117	u32 mark;
118	u8 state;	118	u8 state;
119	struct ovs_key_ct_label label;	119	struct ovs_key_ct_labels labels;
120	} ct;	120	} ct;
121		121
122	} __aligned(BITS_PER_LONG/8); /* Ensure that we can do comparisons as longs. */	122	} __aligned(BITS_PER_LONG/8); /* Ensure that we can do comparisons as longs. */

net/openvswitch/flow_netlink.c+18−12

 		+ nla_total_size(4)   /* OVS_KEY_ATTR_SKB_MARK */
 		+ nla_total_size(4)   /* OVS_KEY_ATTR_DP_HASH */
 		+ nla_total_size(4)   /* OVS_KEY_ATTR_RECIRC_ID */
-		+ nla_total_size(1)   /* OVS_KEY_ATTR_CT_STATE */
+		+ nla_total_size(4)   /* OVS_KEY_ATTR_CT_STATE */
 		+ nla_total_size(2)   /* OVS_KEY_ATTR_CT_ZONE */
 		+ nla_total_size(4)   /* OVS_KEY_ATTR_CT_MARK */
-		+ nla_total_size(16)  /* OVS_KEY_ATTR_CT_LABEL */
+		+ nla_total_size(16)  /* OVS_KEY_ATTR_CT_LABELS */
 		+ nla_total_size(12)  /* OVS_KEY_ATTR_ETHERNET */
 		+ nla_total_size(2)   /* OVS_KEY_ATTR_ETHERTYPE */
 		+ nla_total_size(4)   /* OVS_KEY_ATTR_VLAN */
 	[OVS_KEY_ATTR_TUNNEL]	 = { .len = OVS_ATTR_NESTED,
 				     .next = ovs_tunnel_key_lens, },
 	[OVS_KEY_ATTR_MPLS]	 = { .len = sizeof(struct ovs_key_mpls) },
-	[OVS_KEY_ATTR_CT_STATE]	 = { .len = sizeof(u8) },
+	[OVS_KEY_ATTR_CT_STATE]	 = { .len = sizeof(u32) },
 	[OVS_KEY_ATTR_CT_ZONE]	 = { .len = sizeof(u16) },
 	[OVS_KEY_ATTR_CT_MARK]	 = { .len = sizeof(u32) },
-	[OVS_KEY_ATTR_CT_LABEL]	 = { .len = sizeof(struct ovs_key_ct_label) },
+	[OVS_KEY_ATTR_CT_LABELS] = { .len = sizeof(struct ovs_key_ct_labels) },
 };
 static bool check_attr_len(unsigned int attr_len, unsigned int expected_len)
 	if (*attrs & (1 << OVS_KEY_ATTR_CT_STATE) &&
 	    ovs_ct_verify(net, OVS_KEY_ATTR_CT_STATE)) {
-		u8 ct_state = nla_get_u8(a[OVS_KEY_ATTR_CT_STATE]);
+		u32 ct_state = nla_get_u32(a[OVS_KEY_ATTR_CT_STATE]);
+		if (!is_mask && !ovs_ct_state_supported(ct_state)) {
+			OVS_NLERR(log, "ct_state flags %08x unsupported",
+				  ct_state);
+			return -EINVAL;
+		}
 		SW_FLOW_KEY_PUT(match, ct.state, ct_state, is_mask);
 		*attrs &= ~(1ULL << OVS_KEY_ATTR_CT_STATE);
 		SW_FLOW_KEY_PUT(match, ct.mark, mark, is_mask);
 		*attrs &= ~(1ULL << OVS_KEY_ATTR_CT_MARK);
 	}
-	if (*attrs & (1 << OVS_KEY_ATTR_CT_LABEL) &&
+	if (*attrs & (1 << OVS_KEY_ATTR_CT_LABELS) &&
-	    ovs_ct_verify(net, OVS_KEY_ATTR_CT_LABEL)) {
+	    ovs_ct_verify(net, OVS_KEY_ATTR_CT_LABELS)) {
-		const struct ovs_key_ct_label *cl;
+		const struct ovs_key_ct_labels *cl;
-		cl = nla_data(a[OVS_KEY_ATTR_CT_LABEL]);
+		cl = nla_data(a[OVS_KEY_ATTR_CT_LABELS]);
-		SW_FLOW_KEY_MEMCPY(match, ct.label, cl->ct_label,
+		SW_FLOW_KEY_MEMCPY(match, ct.labels, cl->ct_labels,
 				   sizeof(*cl), is_mask);
-		*attrs &= ~(1ULL << OVS_KEY_ATTR_CT_LABEL);
+		*attrs &= ~(1ULL << OVS_KEY_ATTR_CT_LABELS);
 	}
 	return 0;
 }
 	case OVS_KEY_ATTR_PRIORITY:
 	case OVS_KEY_ATTR_SKB_MARK:
 	case OVS_KEY_ATTR_CT_MARK:
-	case OVS_KEY_ATTR_CT_LABEL:
+	case OVS_KEY_ATTR_CT_LABELS:
 	case OVS_KEY_ATTR_ETHERNET:
 		break;

net/openvswitch/flow_table.c+2−1

@@ -93,7 +93,8 @@ struct sw_flow *ovs_flow_alloc(void) · 92 unmodified lines
93		93
94	/* Initialize the default stat node. */	94	/* Initialize the default stat node. */
95	stats = kmem_cache_alloc_node(flow_stats_cache,	95	stats = kmem_cache_alloc_node(flow_stats_cache,
96	GFP_KERNEL \| __GFP_ZERO, 0);	96	GFP_KERNEL \| __GFP_ZERO,
		97	node_online(0) ? 0 : NUMA_NO_NODE);
97	if (!stats)	98	if (!stats)
98	goto err;	99	goto err;
99		100

net/openvswitch/vport.c+22−29

@@ -280,35 +280,19 @@ void ovs_vport_del(struct vport *vport) · 279 unmodified lines
280	*/	280	*/
281	void ovs_vport_get_stats(struct vport vport, struct ovs_vport_stats stats)	281	void ovs_vport_get_stats(struct vport vport, struct ovs_vport_stats stats)
282	{	282	{
283	struct net_device *dev = vport->dev;	283	const struct rtnl_link_stats64 *dev_stats;
284	int i;	284	struct rtnl_link_stats64 temp;
285		285
286	memset(stats, 0, sizeof(*stats));	286	dev_stats = dev_get_stats(vport->dev, &temp);
287	stats->rx_errors = dev->stats.rx_errors;	287	stats->rx_errors = dev_stats->rx_errors;
288	stats->tx_errors = dev->stats.tx_errors;	288	stats->tx_errors = dev_stats->tx_errors;
289	stats->tx_dropped = dev->stats.tx_dropped;	289	stats->tx_dropped = dev_stats->tx_dropped;
290	stats->rx_dropped = dev->stats.rx_dropped;	290	stats->rx_dropped = dev_stats->rx_dropped;
291		291
292	stats->rx_dropped += atomic_long_read(&dev->rx_dropped);	292	stats->rx_bytes = dev_stats->rx_bytes;
293	stats->tx_dropped += atomic_long_read(&dev->tx_dropped);	293	stats->rx_packets = dev_stats->rx_packets;
294		294	stats->tx_bytes = dev_stats->tx_bytes;
295	for_each_possible_cpu(i) {	295	stats->tx_packets = dev_stats->tx_packets;
296	const struct pcpu_sw_netstats *percpu_stats;
297	struct pcpu_sw_netstats local_stats;
298	unsigned int start;
299
300	percpu_stats = per_cpu_ptr(dev->tstats, i);
301
302	do {
303	start = u64_stats_fetch_begin_irq(&percpu_stats->syncp);
304	local_stats = *percpu_stats;
305	} while (u64_stats_fetch_retry_irq(&percpu_stats->syncp, start));
306
307	stats->rx_bytes += local_stats.rx_bytes;
308	stats->rx_packets += local_stats.rx_packets;
309	stats->tx_bytes += local_stats.tx_bytes;
310	stats->tx_packets += local_stats.tx_packets;
311	}
312	}	296	}
313		297
314	/**	298	/**
@@ -460,6 +444,15 @@ int ovs_vport_receive(struct vport vport, struct sk_buff skb, · 145 unmodified lines
460		444
461	OVS_CB(skb)->input_vport = vport;	445	OVS_CB(skb)->input_vport = vport;
462	OVS_CB(skb)->mru = 0;	446	OVS_CB(skb)->mru = 0;
		447	if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) {
		448	u32 mark;
		449
		450	mark = skb->mark;
		451	skb_scrub_packet(skb, true);
		452	skb->mark = mark;
		453	tun_info = NULL;
		454	}
		455
463	/* Extract flow from 'skb' into 'key'. */	456	/* Extract flow from 'skb' into 'key'. */
464	error = ovs_flow_key_extract(tun_info, skb, &key);	457	error = ovs_flow_key_extract(tun_info, skb, &key);
465	if (unlikely(error)) {	458	if (unlikely(error)) {

net/sched/act_mirred.c+14−4

@@ -31,13 +31,17 @@ · 30 unmodified lines
31		31
32	#define MIRRED_TAB_MASK 7	32	#define MIRRED_TAB_MASK 7
33	static LIST_HEAD(mirred_list);	33	static LIST_HEAD(mirred_list);
		34	static DEFINE_SPINLOCK(mirred_list_lock);
34		35
35	static void tcf_mirred_release(struct tc_action *a, int bind)	36	static void tcf_mirred_release(struct tc_action *a, int bind)
36	{	37	{
37	struct tcf_mirred *m = to_mirred(a);	38	struct tcf_mirred *m = to_mirred(a);
38	struct net_device *dev = rcu_dereference_protected(m->tcfm_dev, 1);	39	struct net_device *dev = rcu_dereference_protected(m->tcfm_dev, 1);
39		40
		41	/* We could be called either in a RCU callback or with RTNL lock held. */
		42	spin_lock_bh(&mirred_list_lock);
40	list_del(&m->tcfm_list);	43	list_del(&m->tcfm_list);
		44	spin_unlock_bh(&mirred_list_lock);
41	if (dev)	45	if (dev)
42	dev_put(dev);	46	dev_put(dev);
43	}	47	}
@@ -103,10 +107,10 @@ static int tcf_mirred_init(struct net net, struct nlattr nla, · 59 unmodified lines
103	} else {	107	} else {
104	if (bind)	108	if (bind)
105	return 0;	109	return 0;
106	if (!ovr) {	110
107	tcf_hash_release(a, bind);	111	tcf_hash_release(a, bind);
		112	if (!ovr)
108	return -EEXIST;	113	return -EEXIST;
109	}
110	}	114	}
111	m = to_mirred(a);	115	m = to_mirred(a);
112		116
@@ -123,7 +127,9 @@ static int tcf_mirred_init(struct net net, struct nlattr nla, · 10 unmodified lines
123	}	127	}
124		128
125	if (ret == ACT_P_CREATED) {	129	if (ret == ACT_P_CREATED) {
		130	spin_lock_bh(&mirred_list_lock);
126	list_add(&m->tcfm_list, &mirred_list);	131	list_add(&m->tcfm_list, &mirred_list);
		132	spin_unlock_bh(&mirred_list_lock);
127	tcf_hash_insert(a);	133	tcf_hash_insert(a);
128	}	134	}
129		135
@@ -173,6 +179,7 @@ static int tcf_mirred(struct sk_buff skb, const struct tc_action a, · 43 unmodified lines
173		179
174	skb2->skb_iif = skb->dev->ifindex;	180	skb2->skb_iif = skb->dev->ifindex;
175	skb2->dev = dev;	181	skb2->dev = dev;
		182	skb_sender_cpu_clear(skb2);
176	err = dev_queue_xmit(skb2);	183	err = dev_queue_xmit(skb2);
177		184
178	if (err) {	185	if (err) {
@@ -221,7 +228,8 @@ static int mirred_device_event(struct notifier_block *unused, · 42 unmodified lines
221	struct tcf_mirred *m;	228	struct tcf_mirred *m;
222		229
223	ASSERT_RTNL();	230	ASSERT_RTNL();
224	if (event == NETDEV_UNREGISTER)	231	if (event == NETDEV_UNREGISTER) {
		232	spin_lock_bh(&mirred_list_lock);
225	list_for_each_entry(m, &mirred_list, tcfm_list) {	233	list_for_each_entry(m, &mirred_list, tcfm_list) {
226	if (rcu_access_pointer(m->tcfm_dev) == dev) {	234	if (rcu_access_pointer(m->tcfm_dev) == dev) {
227	dev_put(dev);	235	dev_put(dev);
@@ -231,6 +239,8 @@ static int mirred_device_event(struct notifier_block *unused, · 3 unmodified lines
231	RCU_INIT_POINTER(m->tcfm_dev, NULL);	239	RCU_INIT_POINTER(m->tcfm_dev, NULL);
232	}	240	}
233	}	241	}
		242	spin_unlock_bh(&mirred_list_lock);
		243	}
234		244
235	return NOTIFY_DONE;	245	return NOTIFY_DONE;
236	}	246	}

net/sched/sch_hhf.c+10−1

 	return bucket - q->buckets;
 }
+static unsigned int hhf_qdisc_drop(struct Qdisc *sch)
+{
+	unsigned int prev_backlog;
+	prev_backlog = sch->qstats.backlog;
+	hhf_drop(sch);
+	return prev_backlog - sch->qstats.backlog;
+}
 static int hhf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
 	struct hhf_sched_data *q = qdisc_priv(sch);
 	.enqueue	=	hhf_enqueue,
 	.dequeue	=	hhf_dequeue,
 	.peek		=	qdisc_peek_dequeued,
-	.drop		=	hhf_drop,
+	.drop		=	hhf_qdisc_drop,
 	.init		=	hhf_init,
 	.reset		=	hhf_reset,
 	.destroy	=	hhf_destroy,

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c+1−1

@@ -533,7 +533,7 @@ static int rdma_read_complete(struct svc_rqst *rqstp, · 532 unmodified lines
533	rqstp->rq_arg.page_base = head->arg.page_base;	533	rqstp->rq_arg.page_base = head->arg.page_base;
534		534
535	/* rq_respages starts after the last arg page */	535	/* rq_respages starts after the last arg page */
536	rqstp->rq_respages = &rqstp->rq_arg.pages[page_no];	536	rqstp->rq_respages = &rqstp->rq_pages[page_no];
537	rqstp->rq_next_page = rqstp->rq_respages + 1;	537	rqstp->rq_next_page = rqstp->rq_respages + 1;
538		538
539	/* Rebuild rq_arg head and tail. */	539	/* Rebuild rq_arg head and tail. */

net/sunrpc/xprtrdma/verbs.c+3−5

 	}
 	if (memreg == RPCRDMA_FRMR) {
-		/* Requires both frmr reg and local dma lkey */
+		if (!(devattr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS) ||
-		if (((devattr->device_cap_flags &
+		    (devattr->max_fast_reg_page_list_len == 0)) {
-		     (IB_DEVICE_MEM_MGT_EXTENSIONS|IB_DEVICE_LOCAL_DMA_LKEY)) !=
-		    (IB_DEVICE_MEM_MGT_EXTENSIONS|IB_DEVICE_LOCAL_DMA_LKEY)) ||
-		      (devattr->max_fast_reg_page_list_len == 0)) {
 			dprintk("RPC:       %s: FRMR registration "
 				"not supported by HCA\n", __func__);
 			memreg = RPCRDMA_MTHCAFMR;
 		if (!ia->ri_device->alloc_fmr) {
 			dprintk("RPC:       %s: MTHCAFMR registration "
 				"not supported by HCA\n", __func__);
+			rc = -EINVAL;
 			goto out3;
 		}
 	}

net/switchdev/switchdev.c+3−0

 #include <linux/notifier.h>
 #include <linux/netdevice.h>
 #include <linux/if_bridge.h>
+#include <linux/if_vlan.h>
 #include <net/ip_fib.h>
 #include <net/switchdev.h>
 		if (nla_len(attr) != sizeof(struct bridge_vlan_info))
 			return -EINVAL;
 		vinfo = nla_data(attr);
+		if (!vinfo->vid || vinfo->vid >= VLAN_VID_MASK)
+			return -EINVAL;
 		vlan->flags = vinfo->flags;
 		if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
 			if (vlan->vid_begin)

net/tipc/msg.h+2−2

@@ -357,7 +357,7 @@ static inline u32 msg_importance(struct tipc_msg *m) · 356 unmodified lines
357	if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m)))	357	if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m)))
358	return usr;	358	return usr;
359	if ((usr == MSG_FRAGMENTER) \|\| (usr == MSG_BUNDLER))	359	if ((usr == MSG_FRAGMENTER) \|\| (usr == MSG_BUNDLER))
360	return msg_bits(m, 5, 13, 0x7);	360	return msg_bits(m, 9, 0, 0x7);
361	return TIPC_SYSTEM_IMPORTANCE;	361	return TIPC_SYSTEM_IMPORTANCE;
362	}	362	}
363		363
@@ -366,7 +366,7 @@ static inline void msg_set_importance(struct tipc_msg *m, u32 i) · 2 unmodified lines
366	int usr = msg_user(m);	366	int usr = msg_user(m);
367		367
368	if (likely((usr == MSG_FRAGMENTER) \|\| (usr == MSG_BUNDLER)))	368	if (likely((usr == MSG_FRAGMENTER) \|\| (usr == MSG_BUNDLER)))
369	msg_set_bits(m, 5, 13, 0x7, i);	369	msg_set_bits(m, 9, 0, 0x7, i);
370	else if (i < TIPC_SYSTEM_IMPORTANCE)	370	else if (i < TIPC_SYSTEM_IMPORTANCE)
371	msg_set_user(m, i);	371	msg_set_user(m, i);
372	else	372	else

net/tipc/node.c+3−3

@@ -1116,7 +1116,7 @@ static bool tipc_node_check_state(struct tipc_node n, struct sk_buff skb, · 1115 unmodified lines
1116	}	1116	}
1117		1117
1118	/* Ignore duplicate packets */	1118	/* Ignore duplicate packets */
1119	if (less(oseqno, rcv_nxt))	1119	if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
1120	return true;	1120	return true;
1121		1121
1122	/* Initiate or update failover mode if applicable */	1122	/* Initiate or update failover mode if applicable */
@@ -1146,8 +1146,8 @@ static bool tipc_node_check_state(struct tipc_node n, struct sk_buff skb, · 23 unmodified lines
1146	if (!pl \|\| !tipc_link_is_up(pl))	1146	if (!pl \|\| !tipc_link_is_up(pl))
1147	return true;	1147	return true;
1148		1148
1149	/* Initiate or update synch mode if applicable */	1149	/* Initiate synch mode if applicable */
1150	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) {	1150	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
1151	syncpt = iseqno + exp_pkts - 1;	1151	syncpt = iseqno + exp_pkts - 1;
1152	if (!tipc_link_is_up(l)) {	1152	if (!tipc_link_is_up(l)) {
1153	tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT);	1153	tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT);

net/unix/af_unix.c+7−5

 		goto out;
 	}
+	if (flags & MSG_PEEK)
+		skip = sk_peek_offset(sk, flags);
+	else
+		skip = 0;
 	do {
 		int chunk;
 		struct sk_buff *skb, *last;
 			break;
 		}
-		skip = sk_peek_offset(sk, flags);
 		while (skip >= unix_skb_len(skb)) {
 			skip -= unix_skb_len(skb);
 			last = skb;
 			if (UNIXCB(skb).fp)
 				scm.fp = scm_fp_dup(UNIXCB(skb).fp);
-			if (skip) {
+			sk_peek_offset_fwd(sk, chunk);
-				sk_peek_offset_fwd(sk, chunk);
-				skip -= chunk;
-			}
 			if (UNIXCB(skb).fp)
 				break;
+			skip = 0;
 			last = skb;
 			last_len = skb->len;
 			unix_state_lock(sk);

scripts/package/builddeb+2−2

@@ -115,7 +115,7 @@ esac · 114 unmodified lines
115	BUILD_DEBUG="$(grep -s '^CONFIG_DEBUG_INFO=y' $KCONFIG_CONFIG \|\| true)"	115	BUILD_DEBUG="$(grep -s '^CONFIG_DEBUG_INFO=y' $KCONFIG_CONFIG \|\| true)"
116		116
117	# Setup the directory structure	117	# Setup the directory structure
118	rm -rf "$tmpdir" "$fwdir" "$kernel_headers_dir" "$libc_headers_dir" "$dbg_dir"	118	rm -rf "$tmpdir" "$fwdir" "$kernel_headers_dir" "$libc_headers_dir" "$dbg_dir" $objtree/debian/files
119	mkdir -m 755 -p "$tmpdir/DEBIAN"	119	mkdir -m 755 -p "$tmpdir/DEBIAN"
120	mkdir -p "$tmpdir/lib" "$tmpdir/boot"	120	mkdir -p "$tmpdir/lib" "$tmpdir/boot"
121	mkdir -p "$fwdir/lib/firmware/$version/"	121	mkdir -p "$fwdir/lib/firmware/$version/"
@@ -408,7 +408,7 @@ binary-arch: · 286 unmodified lines
408	\$(MAKE) KDEB_SOURCENAME=${sourcename} KDEB_PKGVERSION=${packageversion} bindeb-pkg	408	\$(MAKE) KDEB_SOURCENAME=${sourcename} KDEB_PKGVERSION=${packageversion} bindeb-pkg
409		409
410	clean:	410	clean:
411	rm -rf debian/*tmp	411	rm -rf debian/*tmp debian/files
412	mv debian/ debian.backup # debian/ might be cleaned away	412	mv debian/ debian.backup # debian/ might be cleaned away
413	\$(MAKE) clean	413	\$(MAKE) clean
414	mv debian.backup debian	414	mv debian.backup debian

security/keys/gc.c+4−2

 		kdebug("- %u", key->serial);
 		key_check(key);
-		/* Throw away the key data */
+		/* Throw away the key data if the key is instantiated */
-		if (key->type->destroy)
+		if (test_bit(KEY_FLAG_INSTANTIATED, &key->flags) &&
+		    !test_bit(KEY_FLAG_NEGATIVE, &key->flags) &&
+		    key->type->destroy)
 			key->type->destroy(key);
 		security_key_free(key);

security/keys/request_key.c+3−0

@@ -440,6 +440,9 @@ static struct key construct_key_and_link(struct keyring_search_context ctx, · 439 unmodified lines
440		440
441	kenter("");	441	kenter("");
442		442
		443	if (ctx->index_key.type == &key_type_keyring)
		444	return ERR_PTR(-EPERM);
		445
443	user = key_user_lookup(current_fsuid());	446	user = key_user_lookup(current_fsuid());
444	if (!user)	447	if (!user)
445	return ERR_PTR(-ENOMEM);	448	return ERR_PTR(-ENOMEM);

sound/hda/ext/hdac_ext_bus.c+1−0

@@ -19,6 +19,7 @@ · 18 unmodified lines
19		19
20	#include <linux/module.h>	20	#include <linux/module.h>
21	#include <linux/slab.h>	21	#include <linux/slab.h>
		22	#include <linux/io.h>
22	#include <sound/hdaudio_ext.h>	23	#include <sound/hdaudio_ext.h>
23		24
24	MODULE_DESCRIPTION("HDA extended core");	25	MODULE_DESCRIPTION("HDA extended core");

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

 	int dev, err;
 	err = snd_hda_codec_parse_pcms(codec);
-	if (err < 0) {
+	if (err < 0)
-		snd_hda_codec_reset(codec);
 		return err;
-	}
 	/* attach a new PCM streams */
 	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {

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

@@ -819,6 +819,7 @@ static const struct snd_pci_quirk cxt5066_fixups[] = { · 818 unmodified lines
819	SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT_PINCFG_LENOVO_TP410),	819	SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT_PINCFG_LENOVO_TP410),
820	SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT_PINCFG_LENOVO_TP410),	820	SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT_PINCFG_LENOVO_TP410),
821	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo IdeaPad Z560", CXT_FIXUP_MUTE_LED_EAPD),	821	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo IdeaPad Z560", CXT_FIXUP_MUTE_LED_EAPD),
		822	SND_PCI_QUIRK(0x17aa, 0x390b, "Lenovo G50-80", CXT_FIXUP_STEREO_DMIC),
822	SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),	823	SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
823	SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),	824	SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),
824	SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),	825	SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),

sound/soc/codecs/rt298.c+13−13

@@ -50,24 +50,24 @@ struct rt298_priv { · 49 unmodified lines
50	};	50	};
51		51
52	static struct reg_default rt298_index_def[] = {	52	static struct reg_default rt298_index_def[] = {
53	{ 0x01, 0xaaaa },	53	{ 0x01, 0xa5a8 },
54	{ 0x02, 0x8aaa },	54	{ 0x02, 0x8e95 },
55	{ 0x03, 0x0002 },	55	{ 0x03, 0x0002 },
56	{ 0x04, 0xaf01 },	56	{ 0x04, 0xaf67 },
57	{ 0x08, 0x000d },	57	{ 0x08, 0x200f },
58	{ 0x09, 0xd810 },	58	{ 0x09, 0xd010 },
59	{ 0x0a, 0x0120 },	59	{ 0x0a, 0x0100 },
60	{ 0x0b, 0x0000 },	60	{ 0x0b, 0x0000 },
61	{ 0x0d, 0x2800 },	61	{ 0x0d, 0x2800 },
62	{ 0x0f, 0x0000 },	62	{ 0x0f, 0x0022 },
63	{ 0x19, 0x0a17 },	63	{ 0x19, 0x0217 },
64	{ 0x20, 0x0020 },	64	{ 0x20, 0x0020 },
65	{ 0x33, 0x0208 },	65	{ 0x33, 0x0208 },
66	{ 0x46, 0x0300 },	66	{ 0x46, 0x0300 },
67	{ 0x49, 0x0004 },	67	{ 0x49, 0x4004 },
68	{ 0x4f, 0x50e9 },	68	{ 0x4f, 0x50c9 },
69	{ 0x50, 0x2000 },	69	{ 0x50, 0x3000 },
70	{ 0x63, 0x2902 },	70	{ 0x63, 0x1b02 },
71	{ 0x67, 0x1111 },	71	{ 0x67, 0x1111 },
72	{ 0x68, 0x1016 },	72	{ 0x68, 0x1016 },
73	{ 0x69, 0x273f },	73	{ 0x69, 0x273f },
@@ -1214,7 +1214,7 @@ static int rt298_i2c_probe(struct i2c_client *i2c, · 1140 unmodified lines
1214	mdelay(10);	1214	mdelay(10);
1215		1215
1216	if (!rt298->pdata.gpio2_en)	1216	if (!rt298->pdata.gpio2_en)
1217	regmap_write(rt298->regmap, RT298_SET_DMIC2_DEFAULT, 0x4000);	1217	regmap_write(rt298->regmap, RT298_SET_DMIC2_DEFAULT, 0x40);
1218	else	1218	else
1219	regmap_write(rt298->regmap, RT298_SET_DMIC2_DEFAULT, 0);	1219	regmap_write(rt298->regmap, RT298_SET_DMIC2_DEFAULT, 0);
1220		1220

sound/soc/codecs/wm8962.c+2−0

@@ -3808,6 +3808,8 @@ static int wm8962_runtime_resume(struct device *dev) · 3807 unmodified lines
3808		3808
3809	wm8962_reset(wm8962);	3809	wm8962_reset(wm8962);
3810		3810
		3811	regcache_mark_dirty(wm8962->regmap);
		3812
3811	/* SYSCLK defaults to on; make sure it is off so we can safely	3813	/* SYSCLK defaults to on; make sure it is off so we can safely
3812	* write to registers if the device is declocked.	3814	* write to registers if the device is declocked.
3813	*/	3815	*/

sound/soc/soc-ops.c+28−0

@@ -206,6 +206,34 @@ int snd_soc_info_volsw(struct snd_kcontrol *kcontrol, · 205 unmodified lines
206	}	206	}
207	EXPORT_SYMBOL_GPL(snd_soc_info_volsw);	207	EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
208		208
		209	/**
		210	* snd_soc_info_volsw_sx - Mixer info callback for SX TLV controls
		211	* @kcontrol: mixer control
		212	* @uinfo: control element information
		213	*
		214	* Callback to provide information about a single mixer control, or a double
		215	* mixer control that spans 2 registers of the SX TLV type. SX TLV controls
		216	* have a range that represents both positive and negative values either side
		217	* of zero but without a sign bit.
		218	*
		219	* Returns 0 for success.
		220	*/
		221	int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
		222	struct snd_ctl_elem_info *uinfo)
		223	{
		224	struct soc_mixer_control *mc =
		225	(struct soc_mixer_control *)kcontrol->private_value;
		226
		227	snd_soc_info_volsw(kcontrol, uinfo);
		228	/* Max represents the number of levels in an SX control not the
		229	* maximum value, so add the minimum value back on
		230	*/
		231	uinfo->value.integer.max += mc->min;
		232
		233	return 0;
		234	}
		235	EXPORT_SYMBOL_GPL(snd_soc_info_volsw_sx);
		236
209	/**	237	/**
210	* snd_soc_get_volsw - single mixer get callback	238	* snd_soc_get_volsw - single mixer get callback
211	* @kcontrol: mixer control	239	* @kcontrol: mixer control

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c+9−0

 #define FIXUP_SECTION ".ex_fixup"
+static inline unsigned long __fls(unsigned long x);
 #include "word-at-a-time.h"
 #include "utils.h"
+static inline unsigned long __fls(unsigned long x)
+{
+	int lz;
+	asm (PPC_CNTLZL "%0,%1" : "=r" (lz) : "r" (x));
+	return sizeof(unsigned long) - 1 - lz;
+}
 static int page_size;
 static char *mem_region;

virt/kvm/arm/arch_timer.c+19−0

@@ -137,6 +137,8 @@ bool kvm_timer_should_fire(struct kvm_vcpu *vcpu) · 136 unmodified lines
137	void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)	137	void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
138	{	138	{
139	struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;	139	struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
		140	bool phys_active;
		141	int ret;
140		142
141	/*	143	/*
142	* We're about to run this vcpu again, so there is no need to	144	* We're about to run this vcpu again, so there is no need to
@@ -151,6 +153,23 @@ void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu) · 8 unmodified lines
151	*/	153	*/
152	if (kvm_timer_should_fire(vcpu))	154	if (kvm_timer_should_fire(vcpu))
153	kvm_timer_inject_irq(vcpu);	155	kvm_timer_inject_irq(vcpu);
		156
		157	/*
		158	* We keep track of whether the edge-triggered interrupt has been
		159	* signalled to the vgic/guest, and if so, we mask the interrupt and
		160	* the physical distributor to prevent the timer from raising a
		161	* physical interrupt whenever we run a guest, preventing forward
		162	* VCPU progress.
		163	*/
		164	if (kvm_vgic_get_phys_irq_active(timer->map))
		165	phys_active = true;
		166	else
		167	phys_active = false;
		168
		169	ret = irq_set_irqchip_state(timer->map->irq,
		170	IRQCHIP_STATE_ACTIVE,
		171	phys_active);
		172	WARN_ON(ret);
154	}	173	}
155		174
156	/**	175	/**

virt/kvm/arm/vgic.c+55−40

 	return false;
 }
+/*
+ * If a mapped interrupt's state has been modified by the guest such that it
+ * is no longer active or pending, without it have gone through the sync path,
+ * then the map->active field must be cleared so the interrupt can be taken
+ * again.
+ */
+static void vgic_handle_clear_mapped_irq(struct kvm_vcpu *vcpu)
+{
+	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;
+	struct list_head *root;
+	struct irq_phys_map_entry *entry;
+	struct irq_phys_map *map;
+	rcu_read_lock();
+	/* Check for PPIs */
+	root = &vgic_cpu->irq_phys_map_list;
+	list_for_each_entry_rcu(entry, root, entry) {
+		map = &entry->map;
+		if (!vgic_dist_irq_is_pending(vcpu, map->virt_irq) &&
+		    !vgic_irq_is_active(vcpu, map->virt_irq))
+			map->active = false;
+	}
+	rcu_read_unlock();
+}
 bool vgic_handle_clear_pending_reg(struct kvm *kvm,
 				   struct kvm_exit_mmio *mmio,
 				   phys_addr_t offset, int vcpu_id)
 					  vcpu_id, offset);
 		vgic_reg_access(mmio, reg, offset, mode);
+		vgic_handle_clear_mapped_irq(kvm_get_vcpu(kvm, vcpu_id));
 		vgic_update_state(kvm);
 		return true;
 	}
 			ACCESS_READ_VALUE | ACCESS_WRITE_CLEARBIT);
 	if (mmio->is_write) {
+		vgic_handle_clear_mapped_irq(kvm_get_vcpu(kvm, vcpu_id));
 		vgic_update_state(kvm);
 		return true;
 	}
 	pend_percpu = vcpu->arch.vgic_cpu.pending_percpu;
 	pend_shared = vcpu->arch.vgic_cpu.pending_shared;
+	if (!dist->enabled) {
+		bitmap_zero(pend_percpu, VGIC_NR_PRIVATE_IRQS);
+		bitmap_zero(pend_shared, nr_shared);
+		return 0;
+	}
 	pending = vgic_bitmap_get_cpu_map(&dist->irq_pending, vcpu_id);
 	enabled = vgic_bitmap_get_cpu_map(&dist->irq_enabled, vcpu_id);
 	bitmap_and(pend_percpu, pending, enabled, VGIC_NR_PRIVATE_IRQS);
 	struct kvm_vcpu *vcpu;
 	int c;
-	if (!dist->enabled) {
-		set_bit(0, dist->irq_pending_on_cpu);
-		return;
-	}
 	kvm_for_each_vcpu(c, vcpu, kvm) {
 		if (compute_pending_for_cpu(vcpu))
 			set_bit(c, dist->irq_pending_on_cpu);
 	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;
 	struct vgic_lr vlr = vgic_get_lr(vcpu, lr_nr);
+	/*
+	 * We must transfer the pending state back to the distributor before
+	 * retiring the LR, otherwise we may loose edge-triggered interrupts.
+	 */
+	if (vlr.state & LR_STATE_PENDING) {
+		vgic_dist_irq_set_pending(vcpu, irq);
+		vlr.hwirq = 0;
+	}
 	vlr.state = 0;
 	vgic_set_lr(vcpu, lr_nr, vlr);
 	clear_bit(lr_nr, vgic_cpu->lr_used);
 		kvm_debug("Set active, clear distributor: 0x%x\n", vlr.state);
 		vgic_irq_clear_active(vcpu, irq);
 		vgic_update_state(vcpu->kvm);
-	} else if (vgic_dist_irq_is_pending(vcpu, irq)) {
+	} else {
+		WARN_ON(!vgic_dist_irq_is_pending(vcpu, irq));
 		vlr.state |= LR_STATE_PENDING;
 		kvm_debug("Set pending: 0x%x\n", vlr.state);
 	}
 	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;
 	struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
 	unsigned long *pa_percpu, *pa_shared;
-	int i, vcpu_id, lr, ret;
+	int i, vcpu_id;
 	int overflow = 0;
 	int nr_shared = vgic_nr_shared_irqs(dist);
 		 */
 		clear_bit(vcpu_id, dist->irq_pending_on_cpu);
 	}
-	for (lr = 0; lr < vgic->nr_lr; lr++) {
-		struct vgic_lr vlr;
-		if (!test_bit(lr, vgic_cpu->lr_used))
-			continue;
-		vlr = vgic_get_lr(vcpu, lr);
-		/*
-		 * If we have a mapping, and the virtual interrupt is
-		 * presented to the guest (as pending or active), then we must
-		 * set the state to active in the physical world. See
-		 * Documentation/virtual/kvm/arm/vgic-mapped-irqs.txt.
-		 */
-		if (vlr.state & LR_HW) {
-			struct irq_phys_map *map;
-			map = vgic_irq_map_search(vcpu, vlr.irq);
-			ret = irq_set_irqchip_state(map->irq,
-						    IRQCHIP_STATE_ACTIVE,
-						    true);
-			WARN_ON(ret);
-		}
-	}
 }
 static bool vgic_process_maintenance(struct kvm_vcpu *vcpu)
 		return 0;
 	map = vgic_irq_map_search(vcpu, vlr.irq);
-	BUG_ON(!map || !map->active);
+	BUG_ON(!map);
 	ret = irq_get_irqchip_state(map->irq,
 				    IRQCHIP_STATE_ACTIVE,
 	WARN_ON(ret);
-	if (map->active) {
+	if (map->active)
-		ret = irq_set_irqchip_state(map->irq,
-					    IRQCHIP_STATE_ACTIVE,
-					    false);
-		WARN_ON(ret);
 		return 0;
-	}
 	return 1;
 }
 	} else {
 		if (level_triggered) {
 			vgic_dist_irq_clear_level(vcpu, irq_num);
-			if (!vgic_dist_irq_soft_pend(vcpu, irq_num))
+			if (!vgic_dist_irq_soft_pend(vcpu, irq_num)) {
 				vgic_dist_irq_clear_pending(vcpu, irq_num);
+				vgic_cpu_irq_clear(vcpu, irq_num);
+				if (!compute_pending_for_cpu(vcpu))
+					clear_bit(cpuid, dist->irq_pending_on_cpu);
+			}
 		}
 		ret = false;