lael-labs/linux

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

@@ -866,6 +866,15 @@ · 865 unmodified lines
866		866
867	dscc4.setup= [NET]	867	dscc4.setup= [NET]
868		868
		869	dt_cpu_ftrs= [PPC]
		870	Format: {"off" \| "known"}
		871	Control how the dt_cpu_ftrs device-tree binding is
		872	used for CPU feature discovery and setup (if it
		873	exists).
		874	off: Do not use it, fall back to legacy cpu table.
		875	known: Do not pass through unknown features to guests
		876	or userspace, only those that the kernel is aware of.
		877
869	dump_apple_properties [X86]	878	dump_apple_properties [X86]
870	Dump name and content of EFI device properties on	879	Dump name and content of EFI device properties on
871	x86 Macs. Useful for driver authors to determine	880	x86 Macs. Useful for driver authors to determine

Documentation/devicetree/bindings/usb/dwc2.txt+1−0

@@ -10,6 +10,7 @@ Required properties: · 9 unmodified lines
10	- "rockchip,rk3288-usb", "rockchip,rk3066-usb", "snps,dwc2": for rk3288 Soc;	10	- "rockchip,rk3288-usb", "rockchip,rk3066-usb", "snps,dwc2": for rk3288 Soc;
11	- "lantiq,arx100-usb": The DWC2 USB controller instance in Lantiq ARX SoCs;	11	- "lantiq,arx100-usb": The DWC2 USB controller instance in Lantiq ARX SoCs;
12	- "lantiq,xrx200-usb": The DWC2 USB controller instance in Lantiq XRX SoCs;	12	- "lantiq,xrx200-usb": The DWC2 USB controller instance in Lantiq XRX SoCs;
		13	- "amlogic,meson8-usb": The DWC2 USB controller instance in Amlogic Meson8 SoCs;
13	- "amlogic,meson8b-usb": The DWC2 USB controller instance in Amlogic Meson8b SoCs;	14	- "amlogic,meson8b-usb": The DWC2 USB controller instance in Amlogic Meson8b SoCs;
14	- "amlogic,meson-gxbb-usb": The DWC2 USB controller instance in Amlogic S905 SoCs;	15	- "amlogic,meson-gxbb-usb": The DWC2 USB controller instance in Amlogic S905 SoCs;
15	- "amcc,dwc-otg": The DWC2 USB controller instance in AMCC Canyonlands 460EX SoCs;	16	- "amcc,dwc-otg": The DWC2 USB controller instance in AMCC Canyonlands 460EX SoCs;

Documentation/networking/scaling.txt+1−1

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

MAINTAINERS+11−12

 ARM/CIRRUS LOGIC EP93XX ARM ARCHITECTURE
 M:	Hartley Sweeten <hsweeten@visionengravers.com>
-M:	Ryan Mallon <rmallon@gmail.com>
+M:	Alexander Sverdlin <alexander.sverdlin@gmail.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
 F:	arch/arm/mach-ep93xx/
 M:	Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:	Maintained
-F:	arch/arm/mach-mvebu/
-F:	drivers/rtc/rtc-armada38x.c
 F:	arch/arm/boot/dts/armada*
 F:	arch/arm/boot/dts/kirkwood*
+F:	arch/arm/configs/mvebu_*_defconfig
+F:	arch/arm/mach-mvebu/
 F:	arch/arm64/boot/dts/marvell/armada*
 F:	drivers/cpufreq/mvebu-cpufreq.c
-F:	arch/arm/configs/mvebu_*_defconfig
+F:	drivers/irqchip/irq-armada-370-xp.c
+F:	drivers/irqchip/irq-mvebu-*
+F:	drivers/rtc/rtc-armada38x.c
 ARM/Marvell Berlin SoC support
 M:	Jisheng Zhang <jszhang@marvell.com>
 ARM/SAMSUNG EXYNOS ARM ARCHITECTURES
 M:	Kukjin Kim <kgene@kernel.org>
 M:	Krzysztof Kozlowski <krzk@kernel.org>
-R:	Javier Martinez Canillas <javier@osg.samsung.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
 Q:	https://patchwork.kernel.org/project/linux-samsung-soc/list/
 ARM/STI ARCHITECTURE
 M:	Patrice Chotard <patrice.chotard@st.com>
 L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
-L:	kernel@stlinux.com
 W:	http://www.stlinux.com
 S:	Maintained
 F:	arch/arm/mach-sti/
 GENWQE (IBM Generic Workqueue Card)
 M:	Frank Haverkamp <haver@linux.vnet.ibm.com>
-M:	Gabriel Krisman Bertazi <krisman@linux.vnet.ibm.com>
+M:	Guilherme G. Piccoli <gpiccoli@linux.vnet.ibm.com>
 S:	Supported
 F:	drivers/misc/genwqe/
 GPIO SUBSYSTEM
 M:	Linus Walleij <linus.walleij@linaro.org>
-M:	Alexandre Courbot <gnurou@gmail.com>
 L:	linux-gpio@vger.kernel.org
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio.git
 S:	Maintained
 LIVE PATCHING
 M:	Josh Poimboeuf <jpoimboe@redhat.com>
-M:	Jessica Yu <jeyu@redhat.com>
+M:	Jessica Yu <jeyu@kernel.org>
 M:	Jiri Kosina <jikos@kernel.org>
 M:	Miroslav Benes <mbenes@suse.cz>
 R:	Petr Mladek <pmladek@suse.com>
 F:	drivers/media/dvb-frontends/mn88473*
 MODULE SUPPORT
-M:	Jessica Yu <jeyu@redhat.com>
+M:	Jessica Yu <jeyu@kernel.org>
 M:	Rusty Russell <rusty@rustcorp.com.au>
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jeyu/linux.git modules-next
 S:	Maintained
 STI CEC DRIVER
 M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
-L:	kernel@stlinux.com
 S:	Maintained
 F:	drivers/staging/media/st-cec/
 F:	Documentation/devicetree/bindings/media/stih-cec.txt
 S:	Supported
 F:	arch/arm/mach-davinci/
 F:	drivers/i2c/busses/i2c-davinci.c
+F:	arch/arm/boot/dts/da850*
 TI DAVINCI SERIES MEDIA DRIVER
 M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
 F:	drivers/net/wireless/wl3501*
 WOLFSON MICROELECTRONICS DRIVERS
-L:	patches@opensource.wolfsonmicro.com
+L:	patches@opensource.cirrus.com
 T:	git https://github.com/CirrusLogic/linux-drivers.git
 W:	https://github.com/CirrusLogic/linux-drivers/wiki
 S:	Supported

Makefile+1−1

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

arch/arm/boot/dts/bcm283x.dtsi+5−0

 #include <dt-bindings/clock/bcm2835-aux.h>
 #include <dt-bindings/gpio/gpio.h>
+/* firmware-provided startup stubs live here, where the secondary CPUs are
+ * spinning.
+ */
+/memreserve/ 0x00000000 0x00001000;
 /* This include file covers the common peripherals and configuration between
  * bcm2835 and bcm2836 implementations, leaving the CPU configuration to
  * bcm2835.dtsi and bcm2836.dtsi.

arch/arm/boot/dts/keystone-k2l-netcp.dtsi+2−2

@@ -137,8 +137,8 @@ netcp: netcp@26000000 { · 136 unmodified lines
137	/* NetCP address range */	137	/* NetCP address range */
138	ranges = <0 0x26000000 0x1000000>;	138	ranges = <0 0x26000000 0x1000000>;
139		139
140	clocks = <&clkpa>, <&clkcpgmac>, <&chipclk12>, <&clkosr>;	140	clocks = <&clkpa>, <&clkcpgmac>, <&chipclk12>;
141	clock-names = "pa_clk", "ethss_clk", "cpts", "osr_clk";	141	clock-names = "pa_clk", "ethss_clk", "cpts";
142	dma-coherent;	142	dma-coherent;
143		143
144	ti,navigator-dmas = <&dma_gbe 0>,	144	ti,navigator-dmas = <&dma_gbe 0>,

arch/arm/boot/dts/keystone-k2l.dtsi+8−0

@@ -232,6 +232,14 @@ · 231 unmodified lines
232	};	232	};
233	};	233	};
234		234
		235	osr: sram@70000000 {
		236	compatible = "mmio-sram";
		237	reg = <0x70000000 0x10000>;
		238	#address-cells = <1>;
		239	#size-cells = <1>;
		240	clocks = <&clkosr>;
		241	};
		242
235	dspgpio0: keystone_dsp_gpio@02620240 {	243	dspgpio0: keystone_dsp_gpio@02620240 {
236	compatible = "ti,keystone-dsp-gpio";	244	compatible = "ti,keystone-dsp-gpio";
237	gpio-controller;	245	gpio-controller;

arch/arm/boot/dts/versatile-pb.dts+1−1

@@ -1,4 +1,4 @@
1	#include <versatile-ab.dts>	1	#include "versatile-ab.dts"
2		2
3	/ {	3	/ {
4	model = "ARM Versatile PB";	4	model = "ARM Versatile PB";

arch/arm/include/asm/device.h+2−1

@@ -19,7 +19,8 @@ struct dev_archdata { · 18 unmodified lines
19	#ifdef CONFIG_XEN	19	#ifdef CONFIG_XEN
20	const struct dma_map_ops *dev_dma_ops;	20	const struct dma_map_ops *dev_dma_ops;
21	#endif	21	#endif
22	bool dma_coherent;	22	unsigned int dma_coherent:1;
		23	unsigned int dma_ops_setup:1;
23	};	24	};
24		25
25	struct omap_device;	26	struct omap_device;

arch/arm/kvm/init.S+2−3

 	@  - Write permission implies XN: disabled
 	@  - Instruction cache: enabled
 	@  - Data/Unified cache: enabled
-	@  - Memory alignment checks: enabled
 	@  - MMU: enabled (this code must be run from an identity mapping)
 	mrc	p15, 4, r0, c1, c0, 0	@ HSCR
 	ldr	r2, =HSCTLR_MASK
 	mrc	p15, 0, r1, c1, c0, 0	@ SCTLR
 	ldr	r2, =(HSCTLR_EE | HSCTLR_FI | HSCTLR_I | HSCTLR_C)
 	and	r1, r1, r2
- ARM(	ldr	r2, =(HSCTLR_M | HSCTLR_A)			)
+ ARM(	ldr	r2, =(HSCTLR_M)					)
- THUMB(	ldr	r2, =(HSCTLR_M | HSCTLR_A | HSCTLR_TE)		)
+ THUMB(	ldr	r2, =(HSCTLR_M | HSCTLR_TE)			)
 	orr	r1, r1, r2
 	orr	r0, r0, r1
 	mcr	p15, 4, r0, c1, c0, 0	@ HSCR

arch/arm/mach-at91/Kconfig+1−0

@@ -1,6 +1,7 @@
1	menuconfig ARCH_AT91	1	menuconfig ARCH_AT91
2	bool "Atmel SoCs"	2	bool "Atmel SoCs"
3	depends on ARCH_MULTI_V4T \|\| ARCH_MULTI_V5 \|\| ARCH_MULTI_V7	3	depends on ARCH_MULTI_V4T \|\| ARCH_MULTI_V5 \|\| ARCH_MULTI_V7
		4	select ARM_CPU_SUSPEND if PM
4	select COMMON_CLK_AT91	5	select COMMON_CLK_AT91
5	select GPIOLIB	6	select GPIOLIB
6	select PINCTRL	7	select PINCTRL

arch/arm/mach-davinci/pm.c+6−1

 	davinci_sram_suspend = sram_alloc(davinci_cpu_suspend_sz, NULL);
 	if (!davinci_sram_suspend) {
 		pr_err("PM: cannot allocate SRAM memory\n");
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto no_sram_mem;
 	}
 	davinci_sram_push(davinci_sram_suspend, davinci_cpu_suspend,
 	suspend_set_ops(&davinci_pm_ops);
+	return 0;
+no_sram_mem:
+	iounmap(pm_config.ddrpsc_reg_base);
 no_ddrpsc_mem:
 	iounmap(pm_config.ddrpll_reg_base);
 no_ddrpll_mem:

arch/arm/mm/dma-mapping.c+14−15

 }
 EXPORT_SYMBOL_GPL(arm_iommu_attach_device);
-static void __arm_iommu_detach_device(struct device *dev)
+/**
+ * arm_iommu_detach_device
+ * @dev: valid struct device pointer
+ *
+ * Detaches the provided device from a previously attached map.
+ * This voids the dma operations (dma_map_ops pointer)
+ */
+void arm_iommu_detach_device(struct device *dev)
 {
 	struct dma_iommu_mapping *mapping;
 	iommu_detach_device(mapping->domain, dev);
 	kref_put(&mapping->kref, release_iommu_mapping);
 	to_dma_iommu_mapping(dev) = NULL;
+	set_dma_ops(dev, NULL);
 	pr_debug("Detached IOMMU controller from %s device.\n", dev_name(dev));
 }
-/**
- * arm_iommu_detach_device
- * @dev: valid struct device pointer
- *
- * Detaches the provided device from a previously attached map.
- * This voids the dma operations (dma_map_ops pointer)
- */
-void arm_iommu_detach_device(struct device *dev)
-{
-	__arm_iommu_detach_device(dev);
-	set_dma_ops(dev, NULL);
-}
 EXPORT_SYMBOL_GPL(arm_iommu_detach_device);
 static const struct dma_map_ops *arm_get_iommu_dma_map_ops(bool coherent)
 	if (!mapping)
 		return;
-	__arm_iommu_detach_device(dev);
+	arm_iommu_detach_device(dev);
 	arm_iommu_release_mapping(mapping);
 }
 		dev->dma_ops = xen_dma_ops;
 	}
 #endif
+	dev->archdata.dma_ops_setup = true;
 }
 void arch_teardown_dma_ops(struct device *dev)
 {
+	if (!dev->archdata.dma_ops_setup)
+		return;
 	arm_teardown_iommu_dma_ops(dev);
 }

arch/arm64/Kconfig+0−4

@@ -1084,10 +1084,6 @@ config SYSVIPC_COMPAT · 1083 unmodified lines
1084	def_bool y	1084	def_bool y
1085	depends on COMPAT && SYSVIPC	1085	depends on COMPAT && SYSVIPC
1086		1086
1087	config KEYS_COMPAT
1088	def_bool y
1089	depends on COMPAT && KEYS
1090
1091	endmenu	1087	endmenu
1092		1088
1093	menu "Power management options"	1089	menu "Power management options"

arch/arm64/boot/dts/marvell/armada-cp110-master.dtsi+1−2

 			cpm_crypto: crypto@800000 {
 				compatible = "inside-secure,safexcel-eip197";
 				reg = <0x800000 0x200000>;
-				interrupts = <GIC_SPI 34 (IRQ_TYPE_EDGE_RISING
+				interrupts = <GIC_SPI 34 IRQ_TYPE_LEVEL_HIGH>,
-				| IRQ_TYPE_LEVEL_HIGH)>,
 					     <GIC_SPI 54 IRQ_TYPE_LEVEL_HIGH>,
 					     <GIC_SPI 55 IRQ_TYPE_LEVEL_HIGH>,
 					     <GIC_SPI 56 IRQ_TYPE_LEVEL_HIGH>,

arch/arm64/boot/dts/marvell/armada-cp110-slave.dtsi+1−2

 			cps_crypto: crypto@800000 {
 				compatible = "inside-secure,safexcel-eip197";
 				reg = <0x800000 0x200000>;
-				interrupts = <GIC_SPI 34 (IRQ_TYPE_EDGE_RISING
+				interrupts = <GIC_SPI 34 IRQ_TYPE_LEVEL_HIGH>,
-				| IRQ_TYPE_LEVEL_HIGH)>,
 					     <GIC_SPI 278 IRQ_TYPE_LEVEL_HIGH>,
 					     <GIC_SPI 279 IRQ_TYPE_LEVEL_HIGH>,
 					     <GIC_SPI 280 IRQ_TYPE_LEVEL_HIGH>,

arch/arm64/configs/defconfig+10−0

 CONFIG_PCIE_ARMADA_8K=y
 CONFIG_PCI_AARDVARK=y
 CONFIG_PCIE_RCAR=y
+CONFIG_PCIE_ROCKCHIP=m
 CONFIG_PCI_HOST_GENERIC=y
 CONFIG_PCI_XGENE=y
 CONFIG_ARM64_VA_BITS_48=y
 CONFIG_WL18XX=m
 CONFIG_WLCORE_SDIO=m
 CONFIG_INPUT_EVDEV=y
+CONFIG_KEYBOARD_ADC=m
+CONFIG_KEYBOARD_CROS_EC=y
 CONFIG_KEYBOARD_GPIO=y
 CONFIG_INPUT_MISC=y
 CONFIG_INPUT_PM8941_PWRKEY=y
 CONFIG_SPI_ORION=y
 CONFIG_SPI_PL022=y
 CONFIG_SPI_QUP=y
+CONFIG_SPI_ROCKCHIP=y
 CONFIG_SPI_S3C64XX=y
 CONFIG_SPI_SPIDEV=m
 CONFIG_SPMI=y
 CONFIG_CPU_THERMAL=y
 CONFIG_THERMAL_EMULATION=y
 CONFIG_EXYNOS_THERMAL=y
+CONFIG_ROCKCHIP_THERMAL=m
 CONFIG_WATCHDOG=y
 CONFIG_S3C2410_WATCHDOG=y
 CONFIG_MESON_GXBB_WATCHDOG=m
 CONFIG_BCM2835_WDT=y
 CONFIG_MFD_CROS_EC=y
 CONFIG_MFD_CROS_EC_I2C=y
+CONFIG_MFD_CROS_EC_SPI=y
 CONFIG_MFD_EXYNOS_LPASS=m
 CONFIG_MFD_HI655X_PMIC=y
 CONFIG_MFD_MAX77620=y
 CONFIG_MFD_SPMI_PMIC=y
 CONFIG_MFD_RK808=y
 CONFIG_MFD_SEC_CORE=y
+CONFIG_REGULATOR_FAN53555=y
 CONFIG_REGULATOR_FIXED_VOLTAGE=y
 CONFIG_REGULATOR_GPIO=y
 CONFIG_REGULATOR_HI655X=y
 CONFIG_EXTCON_USB_GPIO=y
 CONFIG_IIO=y
 CONFIG_EXYNOS_ADC=y
+CONFIG_ROCKCHIP_SARADC=m
 CONFIG_PWM=y
 CONFIG_PWM_BCM2835=m
+CONFIG_PWM_CROS_EC=m
 CONFIG_PWM_MESON=m
 CONFIG_PWM_ROCKCHIP=y
 CONFIG_PWM_SAMSUNG=y
 CONFIG_PHY_SUN4I_USB=y
 CONFIG_PHY_ROCKCHIP_INNO_USB2=y
 CONFIG_PHY_ROCKCHIP_EMMC=y
+CONFIG_PHY_ROCKCHIP_PCIE=m
 CONFIG_PHY_XGENE=y
 CONFIG_PHY_TEGRA_XUSB=y
 CONFIG_ARM_SCPI_PROTOCOL=y

arch/arm64/include/asm/sysreg.h+4−0

@@ -286,6 +286,10 @@ · 285 unmodified lines
286	#define SCTLR_ELx_A (1 << 1)	286	#define SCTLR_ELx_A (1 << 1)
287	#define SCTLR_ELx_M 1	287	#define SCTLR_ELx_M 1
288		288
		289	#define SCTLR_EL2_RES1 ((1 << 4) \| (1 << 5) \| (1 << 11) \| (1 << 16) \| \
		290	(1 << 16) \| (1 << 18) \| (1 << 22) \| (1 << 23) \| \
		291	(1 << 28) \| (1 << 29))
		292
289	#define SCTLR_ELx_FLAGS (SCTLR_ELx_M \| SCTLR_ELx_A \| SCTLR_ELx_C \| \	293	#define SCTLR_ELx_FLAGS (SCTLR_ELx_M \| SCTLR_ELx_A \| SCTLR_ELx_C \| \
290	SCTLR_ELx_SA \| SCTLR_ELx_I)	294	SCTLR_ELx_SA \| SCTLR_ELx_I)
291		295

arch/arm64/kvm/hyp-init.S+7−4

 	tlbi	alle2
 	dsb	sy
-	mrs	x4, sctlr_el2
+	/*
-	and	x4, x4, #SCTLR_ELx_EE	// preserve endianness of EL2
+	 * Preserve all the RES1 bits while setting the default flags,
-	ldr	x5, =SCTLR_ELx_FLAGS
+	 * as well as the EE bit on BE. Drop the A flag since the compiler
-	orr	x4, x4, x5
+	 * is allowed to generate unaligned accesses.
+	 */
+	ldr	x4, =(SCTLR_EL2_RES1 | (SCTLR_ELx_FLAGS & ~SCTLR_ELx_A))
+CPU_BE(	orr	x4, x4, #SCTLR_ELx_EE)
 	msr	sctlr_el2, x4
 	isb

arch/arm64/kvm/vgic-sys-reg-v3.c+5−5

@@ -65,8 +65,8 @@ static bool access_gic_ctlr(struct kvm_vcpu vcpu, struct sys_reg_params p, · 64 unmodified lines
65	* Here set VMCR.CTLR in ICC_CTLR_EL1 layout.	65	* Here set VMCR.CTLR in ICC_CTLR_EL1 layout.
66	* The vgic_set_vmcr() will convert to ICH_VMCR layout.	66	* The vgic_set_vmcr() will convert to ICH_VMCR layout.
67	*/	67	*/
68	vmcr.ctlr = val & ICC_CTLR_EL1_CBPR_MASK;	68	vmcr.cbpr = (val & ICC_CTLR_EL1_CBPR_MASK) >> ICC_CTLR_EL1_CBPR_SHIFT;
69	vmcr.ctlr \|= val & ICC_CTLR_EL1_EOImode_MASK;	69	vmcr.eoim = (val & ICC_CTLR_EL1_EOImode_MASK) >> ICC_CTLR_EL1_EOImode_SHIFT;
70	vgic_set_vmcr(vcpu, &vmcr);	70	vgic_set_vmcr(vcpu, &vmcr);
71	} else {	71	} else {
72	val = 0;	72	val = 0;
@@ -83,8 +83,8 @@ static bool access_gic_ctlr(struct kvm_vcpu vcpu, struct sys_reg_params p, · 10 unmodified lines
83	* The VMCR.CTLR value is in ICC_CTLR_EL1 layout.	83	* The VMCR.CTLR value is in ICC_CTLR_EL1 layout.
84	* Extract it directly using ICC_CTLR_EL1 reg definitions.	84	* Extract it directly using ICC_CTLR_EL1 reg definitions.
85	*/	85	*/
86	val \|= vmcr.ctlr & ICC_CTLR_EL1_CBPR_MASK;	86	val \|= (vmcr.cbpr << ICC_CTLR_EL1_CBPR_SHIFT) & ICC_CTLR_EL1_CBPR_MASK;
87	val \|= vmcr.ctlr & ICC_CTLR_EL1_EOImode_MASK;	87	val \|= (vmcr.eoim << ICC_CTLR_EL1_EOImode_SHIFT) & ICC_CTLR_EL1_EOImode_MASK;
88		88
89	p->regval = val;	89	p->regval = val;
90	}	90	}
@@ -135,7 +135,7 @@ static bool access_gic_bpr1(struct kvm_vcpu vcpu, struct sys_reg_params p, · 44 unmodified lines
135	p->regval = 0;	135	p->regval = 0;
136		136
137	vgic_get_vmcr(vcpu, &vmcr);	137	vgic_get_vmcr(vcpu, &vmcr);
138	if (!((vmcr.ctlr & ICH_VMCR_CBPR_MASK) >> ICH_VMCR_CBPR_SHIFT)) {	138	if (!vmcr.cbpr) {
139	if (p->is_write) {	139	if (p->is_write) {
140	vmcr.abpr = (p->regval & ICC_BPR1_EL1_MASK) >>	140	vmcr.abpr = (p->regval & ICC_BPR1_EL1_MASK) >>
141	ICC_BPR1_EL1_SHIFT;	141	ICC_BPR1_EL1_SHIFT;

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

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

arch/hexagon/mm/uaccess.c+2−3

 	long uncleared;
 	while (count > PAGE_SIZE) {
-		uncleared = __copy_to_user_hexagon(dest, &empty_zero_page,
+		uncleared = raw_copy_to_user(dest, &empty_zero_page, PAGE_SIZE);
-						PAGE_SIZE);
 		if (uncleared)
 			return count - (PAGE_SIZE - uncleared);
 		count -= PAGE_SIZE;
 		dest += PAGE_SIZE;
 	}
 	if (count)
-		count = __copy_to_user_hexagon(dest, &empty_zero_page, count);
+		count = raw_copy_to_user(dest, &empty_zero_page, count);
 	return count;
 }

arch/powerpc/Kconfig+0−21

@@ -380,22 +380,6 @@ source "arch/powerpc/platforms/Kconfig" · 379 unmodified lines
380		380
381	menu "Kernel options"	381	menu "Kernel options"
382		382
383	config PPC_DT_CPU_FTRS
384	bool "Device-tree based CPU feature discovery & setup"
385	depends on PPC_BOOK3S_64
386	default n
387	help
388	This enables code to use a new device tree binding for describing CPU
389	compatibility and features. Saying Y here will attempt to use the new
390	binding if the firmware provides it. Currently only the skiboot
391	firmware provides this binding.
392	If you're not sure say Y.
393
394	config PPC_CPUFEATURES_ENABLE_UNKNOWN
395	bool "cpufeatures pass through unknown features to guest/userspace"
396	depends on PPC_DT_CPU_FTRS
397	default y
398
399	config HIGHMEM	383	config HIGHMEM
400	bool "High memory support"	384	bool "High memory support"
401	depends on PPC32	385	depends on PPC32
@@ -1215,11 +1199,6 @@ source "arch/powerpc/Kconfig.debug" · 813 unmodified lines
1215		1199
1216	source "security/Kconfig"	1200	source "security/Kconfig"
1217		1201
1218	config KEYS_COMPAT
1219	bool
1220	depends on COMPAT && KEYS
1221	default y
1222
1223	source "crypto/Kconfig"	1202	source "crypto/Kconfig"
1224		1203
1225	config PPC_LIB_RHEAP	1204	config PPC_LIB_RHEAP

arch/powerpc/include/asm/book3s/64/hash-4k.h+1−1

@@ -8,7 +8,7 @@ · 7 unmodified lines
8	#define H_PTE_INDEX_SIZE 9	8	#define H_PTE_INDEX_SIZE 9
9	#define H_PMD_INDEX_SIZE 7	9	#define H_PMD_INDEX_SIZE 7
10	#define H_PUD_INDEX_SIZE 9	10	#define H_PUD_INDEX_SIZE 9
11	#define H_PGD_INDEX_SIZE 12	11	#define H_PGD_INDEX_SIZE 9
12		12
13	#ifndef __ASSEMBLY__	13	#ifndef __ASSEMBLY__
14	#define H_PTE_TABLE_SIZE (sizeof(pte_t) << H_PTE_INDEX_SIZE)	14	#define H_PTE_TABLE_SIZE (sizeof(pte_t) << H_PTE_INDEX_SIZE)

arch/powerpc/include/asm/cputable.h+1−2

 #define CPU_FTR_DAWR			LONG_ASM_CONST(0x0400000000000000)
 #define CPU_FTR_DABRX			LONG_ASM_CONST(0x0800000000000000)
 #define CPU_FTR_PMAO_BUG		LONG_ASM_CONST(0x1000000000000000)
-#define CPU_FTR_SUBCORE			LONG_ASM_CONST(0x2000000000000000)
 #define CPU_FTR_POWER9_DD1		LONG_ASM_CONST(0x4000000000000000)
 #ifndef __ASSEMBLY__
 	    CPU_FTR_STCX_CHECKS_ADDRESS | CPU_FTR_POPCNTB | CPU_FTR_POPCNTD | \
 	    CPU_FTR_ICSWX | CPU_FTR_CFAR | CPU_FTR_HVMODE | CPU_FTR_VMX_COPY | \
 	    CPU_FTR_DBELL | CPU_FTR_HAS_PPR | CPU_FTR_DAWR | \
-	    CPU_FTR_ARCH_207S | CPU_FTR_TM_COMP | CPU_FTR_SUBCORE)
+	    CPU_FTR_ARCH_207S | CPU_FTR_TM_COMP)
 #define CPU_FTRS_POWER8E (CPU_FTRS_POWER8 | CPU_FTR_PMAO_BUG)
 #define CPU_FTRS_POWER8_DD1 (CPU_FTRS_POWER8 & ~CPU_FTR_DBELL)
 #define CPU_FTRS_POWER9 (CPU_FTR_USE_TB | CPU_FTR_LWSYNC | \

arch/powerpc/include/asm/processor.h+12−13

 #define TASK_SIZE_128TB (0x0000800000000000UL)
 #define TASK_SIZE_512TB (0x0002000000000000UL)
-#ifdef CONFIG_PPC_BOOK3S_64
+/*
+ * For now 512TB is only supported with book3s and 64K linux page size.
+ */
+#if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_PPC_64K_PAGES)
 /*
  * Max value currently used:
  */
-#define TASK_SIZE_USER64	TASK_SIZE_512TB
+#define TASK_SIZE_USER64		TASK_SIZE_512TB
+#define DEFAULT_MAP_WINDOW_USER64	TASK_SIZE_128TB
 #else
-#define TASK_SIZE_USER64	TASK_SIZE_64TB
+#define TASK_SIZE_USER64		TASK_SIZE_64TB
+#define DEFAULT_MAP_WINDOW_USER64	TASK_SIZE_64TB
 #endif
 /*
  * space during mmap's.
  */
 #define TASK_UNMAPPED_BASE_USER32 (PAGE_ALIGN(TASK_SIZE_USER32 / 4))
-#define TASK_UNMAPPED_BASE_USER64 (PAGE_ALIGN(TASK_SIZE_128TB / 4))
+#define TASK_UNMAPPED_BASE_USER64 (PAGE_ALIGN(DEFAULT_MAP_WINDOW_USER64 / 4))
 #define TASK_UNMAPPED_BASE ((is_32bit_task()) ? \
 		TASK_UNMAPPED_BASE_USER32 : TASK_UNMAPPED_BASE_USER64 )
  * with 128TB and conditionally enable upto 512TB
  */
 #ifdef CONFIG_PPC_BOOK3S_64
-#define DEFAULT_MAP_WINDOW	((is_32bit_task()) ? \
+#define DEFAULT_MAP_WINDOW	((is_32bit_task()) ?			\
-				 TASK_SIZE_USER32 : TASK_SIZE_128TB)
+				 TASK_SIZE_USER32 : DEFAULT_MAP_WINDOW_USER64)
 #else
 #define DEFAULT_MAP_WINDOW	TASK_SIZE
 #endif
 #ifdef __powerpc64__
-#ifdef CONFIG_PPC_BOOK3S_64
+#define STACK_TOP_USER64 DEFAULT_MAP_WINDOW_USER64
-/* Limit stack to 128TB */
-#define STACK_TOP_USER64 TASK_SIZE_128TB
-#else
-#define STACK_TOP_USER64 TASK_SIZE_USER64
-#endif
 #define STACK_TOP_USER32 TASK_SIZE_USER32
 #define STACK_TOP (is_32bit_task() ? \

arch/powerpc/include/asm/topology.h+14−0

@@ -44,8 +44,22 @@ extern void __init dump_numa_cpu_topology(void); · 43 unmodified lines
44	extern int sysfs_add_device_to_node(struct device *dev, int nid);	44	extern int sysfs_add_device_to_node(struct device *dev, int nid);
45	extern void sysfs_remove_device_from_node(struct device *dev, int nid);	45	extern void sysfs_remove_device_from_node(struct device *dev, int nid);
46		46
		47	static inline int early_cpu_to_node(int cpu)
		48	{
		49	int nid;
		50
		51	nid = numa_cpu_lookup_table[cpu];
		52
		53	/*
		54	* Fall back to node 0 if nid is unset (it should be, except bugs).
		55	* This allows callers to safely do NODE_DATA(early_cpu_to_node(cpu)).
		56	*/
		57	return (nid < 0) ? 0 : nid;
		58	}
47	#else	59	#else
48		60
		61	static inline int early_cpu_to_node(int cpu) { return 0; }
		62
49	static inline void dump_numa_cpu_topology(void) {}	63	static inline void dump_numa_cpu_topology(void) {}
50		64
51	static inline int sysfs_add_device_to_node(struct device *dev, int nid)	65	static inline int sysfs_add_device_to_node(struct device *dev, int nid)

arch/powerpc/kernel/dt_cpu_ftrs.c+48−10

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#include <linux/export.h>	8	#include <linux/export.h>
9	#include <linux/init.h>	9	#include <linux/init.h>
10	#include <linux/jump_label.h>	10	#include <linux/jump_label.h>
		11	#include <linux/libfdt.h>
11	#include <linux/memblock.h>	12	#include <linux/memblock.h>
12	#include <linux/printk.h>	13	#include <linux/printk.h>
13	#include <linux/sched.h>	14	#include <linux/sched.h>
@@ -642,7 +643,6 @@ static struct dt_cpu_feature_match __initdata · 628 unmodified lines
642	{"processor-control-facility", feat_enable_dbell, CPU_FTR_DBELL},	643	{"processor-control-facility", feat_enable_dbell, CPU_FTR_DBELL},
643	{"processor-control-facility-v3", feat_enable_dbell, CPU_FTR_DBELL},	644	{"processor-control-facility-v3", feat_enable_dbell, CPU_FTR_DBELL},
644	{"processor-utilization-of-resources-register", feat_enable_purr, 0},	645	{"processor-utilization-of-resources-register", feat_enable_purr, 0},
645	{"subcore", feat_enable, CPU_FTR_SUBCORE},
646	{"no-execute", feat_enable, 0},	646	{"no-execute", feat_enable, 0},
647	{"strong-access-ordering", feat_enable, CPU_FTR_SAO},	647	{"strong-access-ordering", feat_enable, CPU_FTR_SAO},
648	{"cache-inhibited-large-page", feat_enable_large_ci, 0},	648	{"cache-inhibited-large-page", feat_enable_large_ci, 0},
@@ -671,12 +671,24 @@ static struct dt_cpu_feature_match __initdata · 22 unmodified lines
671	{"wait-v3", feat_enable, 0},	671	{"wait-v3", feat_enable, 0},
672	};	672	};
673		673
674	/* XXX: how to configure this? Default + boot time? */	674	static bool __initdata using_dt_cpu_ftrs;
675	#ifdef CONFIG_PPC_CPUFEATURES_ENABLE_UNKNOWN	675	static bool __initdata enable_unknown = true;
676	#define CPU_FEATURE_ENABLE_UNKNOWN 1	676
677	#else	677	static int __init dt_cpu_ftrs_parse(char *str)
678	#define CPU_FEATURE_ENABLE_UNKNOWN 0	678	{
679	#endif	679	if (!str)
		680	return 0;
		681
		682	if (!strcmp(str, "off"))
		683	using_dt_cpu_ftrs = false;
		684	else if (!strcmp(str, "known"))
		685	enable_unknown = false;
		686	else
		687	return 1;
		688
		689	return 0;
		690	}
		691	early_param("dt_cpu_ftrs", dt_cpu_ftrs_parse);
680		692
681	static void __init cpufeatures_setup_start(u32 isa)	693	static void __init cpufeatures_setup_start(u32 isa)
682	{	694	{
@@ -707,7 +719,7 @@ static bool __init cpufeatures_process_feature(struct dt_cpu_feature *f) · 24 unmodified lines
707	}	719	}
708	}	720	}
709		721
710	if (!known && CPU_FEATURE_ENABLE_UNKNOWN) {	722	if (!known && enable_unknown) {
711	if (!feat_try_enable_unknown(f)) {	723	if (!feat_try_enable_unknown(f)) {
712	pr_info("not enabling: %s (unknown and unsupported by kernel)\n",	724	pr_info("not enabling: %s (unknown and unsupported by kernel)\n",
713	f->name);	725	f->name);
@@ -756,6 +768,26 @@ static void __init cpufeatures_setup_finished(void) · 42 unmodified lines
756	cur_cpu_spec->cpu_features, cur_cpu_spec->mmu_features);	768	cur_cpu_spec->cpu_features, cur_cpu_spec->mmu_features);
757	}	769	}
758		770
		771	static int __init disabled_on_cmdline(void)
		772	{
		773	unsigned long root, chosen;
		774	const char *p;
		775
		776	root = of_get_flat_dt_root();
		777	chosen = of_get_flat_dt_subnode_by_name(root, "chosen");
		778	if (chosen == -FDT_ERR_NOTFOUND)
		779	return false;
		780
		781	p = of_get_flat_dt_prop(chosen, "bootargs", NULL);
		782	if (!p)
		783	return false;
		784
		785	if (strstr(p, "dt_cpu_ftrs=off"))
		786	return true;
		787
		788	return false;
		789	}
		790
759	static int __init fdt_find_cpu_features(unsigned long node, const char *uname,	791	static int __init fdt_find_cpu_features(unsigned long node, const char *uname,
760	int depth, void *data)	792	int depth, void *data)
761	{	793	{
@@ -766,8 +798,6 @@ static int __init fdt_find_cpu_features(unsigned long node, const char *uname, · 4 unmodified lines
766	return 0;	798	return 0;
767	}	799	}
768		800
769	static bool __initdata using_dt_cpu_ftrs = false;
770
771	bool __init dt_cpu_ftrs_in_use(void)	801	bool __init dt_cpu_ftrs_in_use(void)
772	{	802	{
773	return using_dt_cpu_ftrs;	803	return using_dt_cpu_ftrs;
@@ -775,6 +805,8 @@ bool __init dt_cpu_ftrs_in_use(void) · 1 unmodified line
775		805
776	bool __init dt_cpu_ftrs_init(void *fdt)	806	bool __init dt_cpu_ftrs_init(void *fdt)
777	{	807	{
		808	using_dt_cpu_ftrs = false;
		809
778	/* Setup and verify the FDT, if it fails we just bail */	810	/* Setup and verify the FDT, if it fails we just bail */
779	if (!early_init_dt_verify(fdt))	811	if (!early_init_dt_verify(fdt))
780	return false;	812	return false;
@@ -782,6 +814,9 @@ bool __init dt_cpu_ftrs_init(void *fdt) · 1 unmodified line
782	if (!of_scan_flat_dt(fdt_find_cpu_features, NULL))	814	if (!of_scan_flat_dt(fdt_find_cpu_features, NULL))
783	return false;	815	return false;
784		816
		817	if (disabled_on_cmdline())
		818	return false;
		819
785	cpufeatures_setup_cpu();	820	cpufeatures_setup_cpu();
786		821
787	using_dt_cpu_ftrs = true;	822	using_dt_cpu_ftrs = true;
@@ -1027,5 +1062,8 @@ static int __init dt_cpu_ftrs_scan_callback(unsigned long node, const char · 239 unmodified lines
1027		1062
1028	void __init dt_cpu_ftrs_scan(void)	1063	void __init dt_cpu_ftrs_scan(void)
1029	{	1064	{
		1065	if (!using_dt_cpu_ftrs)
		1066	return;
		1067
1030	of_scan_flat_dt(dt_cpu_ftrs_scan_callback, NULL);	1068	of_scan_flat_dt(dt_cpu_ftrs_scan_callback, NULL);
1031	}	1069	}

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

 #ifdef CONFIG_VSX
 	current->thread.used_vsr = 0;
 #endif
+	current->thread.load_fp = 0;
 	memset(&current->thread.fp_state, 0, sizeof(current->thread.fp_state));
 	current->thread.fp_save_area = NULL;
 #ifdef CONFIG_ALTIVEC
 	current->thread.vr_save_area = NULL;
 	current->thread.vrsave = 0;
 	current->thread.used_vr = 0;
+	current->thread.load_vec = 0;
 #endif /* CONFIG_ALTIVEC */
 #ifdef CONFIG_SPE
 	memset(current->thread.evr, 0, sizeof(current->thread.evr));
 	current->thread.tm_tfhar = 0;
 	current->thread.tm_texasr = 0;
 	current->thread.tm_tfiar = 0;
+	current->thread.load_tm = 0;
 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
 }
 EXPORT_SYMBOL(start_thread);

arch/powerpc/kernel/setup-common.c+1−1

@@ -928,7 +928,7 @@ void __init setup_arch(char **cmdline_p) · 927 unmodified lines
928		928
929	#ifdef CONFIG_PPC_MM_SLICES	929	#ifdef CONFIG_PPC_MM_SLICES
930	#ifdef CONFIG_PPC64	930	#ifdef CONFIG_PPC64
931	init_mm.context.addr_limit = TASK_SIZE_128TB;	931	init_mm.context.addr_limit = DEFAULT_MAP_WINDOW_USER64;
932	#else	932	#else
933	#error "context.addr_limit not initialized."	933	#error "context.addr_limit not initialized."
934	#endif	934	#endif

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

@@ -661,7 +661,7 @@ void __init emergency_stack_init(void) · 660 unmodified lines
661		661
662	static void * __init pcpu_fc_alloc(unsigned int cpu, size_t size, size_t align)	662	static void * __init pcpu_fc_alloc(unsigned int cpu, size_t size, size_t align)
663	{	663	{
664	return __alloc_bootmem_node(NODE_DATA(cpu_to_node(cpu)), size, align,	664	return __alloc_bootmem_node(NODE_DATA(early_cpu_to_node(cpu)), size, align,
665	__pa(MAX_DMA_ADDRESS));	665	__pa(MAX_DMA_ADDRESS));
666	}	666	}
667		667
@@ -672,7 +672,7 @@ static void __init pcpu_fc_free(void *ptr, size_t size) · 4 unmodified lines
672		672
673	static int pcpu_cpu_distance(unsigned int from, unsigned int to)	673	static int pcpu_cpu_distance(unsigned int from, unsigned int to)
674	{	674	{
675	if (cpu_to_node(from) == cpu_to_node(to))	675	if (early_cpu_to_node(from) == early_cpu_to_node(to))
676	return LOCAL_DISTANCE;	676	return LOCAL_DISTANCE;
677	else	677	else
678	return REMOTE_DISTANCE;	678	return REMOTE_DISTANCE;

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

@@ -99,7 +99,7 @@ static int hash__init_new_context(struct mm_struct *mm) · 98 unmodified lines
99	* mm->context.addr_limit. Default to max task size so that we copy the	99	* mm->context.addr_limit. Default to max task size so that we copy the
100	* default values to paca which will help us to handle slb miss early.	100	* default values to paca which will help us to handle slb miss early.
101	*/	101	*/
102	mm->context.addr_limit = TASK_SIZE_128TB;	102	mm->context.addr_limit = DEFAULT_MAP_WINDOW_USER64;
103		103
104	/*	104	/*
105	* The old code would re-promote on fork, we don't do that when using	105	* The old code would re-promote on fork, we don't do that when using

arch/powerpc/perf/power9-pmu.c+2−2

arch/powerpc/platforms/Kconfig+11−0

@@ -59,6 +59,17 @@ config PPC_OF_BOOT_TRAMPOLINE · 58 unmodified lines
59		59
60	In case of doubt, say Y	60	In case of doubt, say Y
61		61
		62	config PPC_DT_CPU_FTRS
		63	bool "Device-tree based CPU feature discovery & setup"
		64	depends on PPC_BOOK3S_64
		65	default y
		66	help
		67	This enables code to use a new device tree binding for describing CPU
		68	compatibility and features. Saying Y here will attempt to use the new
		69	binding if the firmware provides it. Currently only the skiboot
		70	firmware provides this binding.
		71	If you're not sure say Y.
		72
62	config UDBG_RTAS_CONSOLE	73	config UDBG_RTAS_CONSOLE
63	bool "RTAS based debug console"	74	bool "RTAS based debug console"
64	depends on PPC_RTAS	75	depends on PPC_RTAS

arch/powerpc/platforms/cell/spufs/coredump.c+2−0

@@ -175,6 +175,8 @@ static int spufs_arch_write_note(struct spu_context *ctx, int i, · 174 unmodified lines
175	skip = roundup(cprm->pos - total + sz, 4) - cprm->pos;	175	skip = roundup(cprm->pos - total + sz, 4) - cprm->pos;
176	if (!dump_skip(cprm, skip))	176	if (!dump_skip(cprm, skip))
177	goto Eio;	177	goto Eio;
		178
		179	rc = 0;
178	out:	180	out:
179	free_page((unsigned long)buf);	181	free_page((unsigned long)buf);
180	return rc;	182	return rc;

arch/powerpc/platforms/powernv/subcore.c+7−1

 static int subcore_init(void)
 {
-	if (!cpu_has_feature(CPU_FTR_SUBCORE))
+	unsigned pvr_ver;
+	pvr_ver = PVR_VER(mfspr(SPRN_PVR));
+	if (pvr_ver != PVR_POWER8 &&
+	    pvr_ver != PVR_POWER8E &&
+	    pvr_ver != PVR_POWER8NVL)
 		return 0;
 	/*

arch/powerpc/platforms/pseries/hotplug-memory.c+2−0

 	for (i = 0; i < num_lmbs; i++) {
 		lmbs[i].base_addr = be64_to_cpu(lmbs[i].base_addr);
 		lmbs[i].drc_index = be32_to_cpu(lmbs[i].drc_index);
+		lmbs[i].aa_index = be32_to_cpu(lmbs[i].aa_index);
 		lmbs[i].flags = be32_to_cpu(lmbs[i].flags);
 	}
 	for (i = 0; i < num_lmbs; i++) {
 		lmbs[i].base_addr = cpu_to_be64(lmbs[i].base_addr);
 		lmbs[i].drc_index = cpu_to_be32(lmbs[i].drc_index);
+		lmbs[i].aa_index = cpu_to_be32(lmbs[i].aa_index);
 		lmbs[i].flags = cpu_to_be32(lmbs[i].flags);
 	}

arch/powerpc/sysdev/simple_gpio.c+2−1

@@ -75,7 +75,8 @@ static int u8_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) · 74 unmodified lines
75		75
76	static void u8_gpio_save_regs(struct of_mm_gpio_chip *mm_gc)	76	static void u8_gpio_save_regs(struct of_mm_gpio_chip *mm_gc)
77	{	77	{
78	struct u8_gpio_chip *u8_gc = gpiochip_get_data(&mm_gc->gc);	78	struct u8_gpio_chip *u8_gc =
		79	container_of(mm_gc, struct u8_gpio_chip, mm_gc);
79		80
80	u8_gc->data = in_8(mm_gc->regs);	81	u8_gc->data = in_8(mm_gc->regs);
81	}	82	}

arch/s390/Kconfig+0−3

@@ -363,9 +363,6 @@ config COMPAT · 362 unmodified lines
363	config SYSVIPC_COMPAT	363	config SYSVIPC_COMPAT
364	def_bool y if COMPAT && SYSVIPC	364	def_bool y if COMPAT && SYSVIPC
365		365
366	config KEYS_COMPAT
367	def_bool y if COMPAT && KEYS
368
369	config SMP	366	config SMP
370	def_bool y	367	def_bool y
371	prompt "Symmetric multi-processing support"	368	prompt "Symmetric multi-processing support"

arch/s390/configs/default_defconfig+33−6

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

arch/s390/configs/gcov_defconfig+24−4

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

arch/s390/configs/performance_defconfig+23−4

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

arch/s390/configs/zfcpdump_defconfig+4−2

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

arch/s390/defconfig+3−5

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

arch/s390/include/asm/kvm_host.h+0−1

@@ -541,7 +541,6 @@ struct kvm_s390_float_interrupt { · 540 unmodified lines
541	struct mutex ais_lock;	541	struct mutex ais_lock;
542	u8 simm;	542	u8 simm;
543	u8 nimm;	543	u8 nimm;
544	int ais_enabled;
545	};	544	};
546		545
547	struct kvm_hw_wp_info_arch {	546	struct kvm_hw_wp_info_arch {

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

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

arch/s390/kvm/interrupt.c+2−2

@@ -2160,7 +2160,7 @@ static int modify_ais_mode(struct kvm kvm, struct kvm_device_attr attr) · 2159 unmodified lines
2160	struct kvm_s390_ais_req req;	2160	struct kvm_s390_ais_req req;
2161	int ret = 0;	2161	int ret = 0;
2162		2162
2163	if (!fi->ais_enabled)	2163	if (!test_kvm_facility(kvm, 72))
2164	return -ENOTSUPP;	2164	return -ENOTSUPP;
2165		2165
2166	if (copy_from_user(&req, (void __user *)attr->addr, sizeof(req)))	2166	if (copy_from_user(&req, (void __user *)attr->addr, sizeof(req)))
@@ -2204,7 +2204,7 @@ static int kvm_s390_inject_airq(struct kvm *kvm, · 37 unmodified lines
2204	};	2204	};
2205	int ret = 0;	2205	int ret = 0;
2206		2206
2207	if (!fi->ais_enabled \|\| !adapter->suppressible)	2207	if (!test_kvm_facility(kvm, 72) \|\| !adapter->suppressible)
2208	return kvm_s390_inject_vm(kvm, &s390int);	2208	return kvm_s390_inject_vm(kvm, &s390int);
2209		2209
2210	mutex_lock(&fi->ais_lock);	2210	mutex_lock(&fi->ais_lock);

arch/s390/kvm/kvm-s390.c+0−2

 		} else {
 			set_kvm_facility(kvm->arch.model.fac_mask, 72);
 			set_kvm_facility(kvm->arch.model.fac_list, 72);
-			kvm->arch.float_int.ais_enabled = 1;
 			r = 0;
 		}
 		mutex_unlock(&kvm->lock);
 	mutex_init(&kvm->arch.float_int.ais_lock);
 	kvm->arch.float_int.simm = 0;
 	kvm->arch.float_int.nimm = 0;
-	kvm->arch.float_int.ais_enabled = 0;
 	spin_lock_init(&kvm->arch.float_int.lock);
 	for (i = 0; i < FIRQ_LIST_COUNT; i++)
 		INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]);

arch/sparc/Kconfig+0−3

@@ -577,9 +577,6 @@ config SYSVIPC_COMPAT · 576 unmodified lines
577	depends on COMPAT && SYSVIPC	577	depends on COMPAT && SYSVIPC
578	default y	578	default y
579		579
580	config KEYS_COMPAT
581	def_bool y if COMPAT && KEYS
582
583	endmenu	580	endmenu
584		581
585	source "net/Kconfig"	582	source "net/Kconfig"

arch/x86/Kconfig+0−4

 config SYSVIPC_COMPAT
 	def_bool y
 	depends on SYSVIPC
-config KEYS_COMPAT
-	def_bool y
-	depends on KEYS
 endif
 endmenu

arch/x86/kernel/cpu/cyrix.c+1−0

@@ -255,6 +255,7 @@ static void init_cyrix(struct cpuinfo_x86 *c) · 254 unmodified lines
255	break;	255	break;
256		256
257	case 4: /* MediaGX/GXm or Geode GXM/GXLV/GX1 */	257	case 4: /* MediaGX/GXm or Geode GXM/GXLV/GX1 */
		258	case 11: /* GX1 with inverted Device ID */
258	#ifdef CONFIG_PCI	259	#ifdef CONFIG_PCI
259	{	260	{
260	u32 vendor, device;	261	u32 vendor, device;

arch/x86/kernel/cpu/microcode/intel.c+3−0

@@ -619,6 +619,9 @@ int __init save_microcode_in_initrd_intel(void) · 618 unmodified lines
619		619
620	show_saved_mc();	620	show_saved_mc();
621		621
		622	/* initrd is going away, clear patch ptr. */
		623	intel_ucode_patch = NULL;
		624
622	return 0;	625	return 0;
623	}	626	}
624		627

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

 			 */
 			rcu_irq_exit();
 			native_safe_halt();
-			rcu_irq_enter();
 			local_irq_disable();
+			rcu_irq_enter();
 		}
 	}
 	if (!n.halted)

arch/x86/kvm/cpuid.c+11−9

@@ -780,18 +780,20 @@ out: · 779 unmodified lines
780	static int move_to_next_stateful_cpuid_entry(struct kvm_vcpu *vcpu, int i)	780	static int move_to_next_stateful_cpuid_entry(struct kvm_vcpu *vcpu, int i)
781	{	781	{
782	struct kvm_cpuid_entry2 *e = &vcpu->arch.cpuid_entries[i];	782	struct kvm_cpuid_entry2 *e = &vcpu->arch.cpuid_entries[i];
783	int j, nent = vcpu->arch.cpuid_nent;	783	struct kvm_cpuid_entry2 *ej;
		784	int j = i;
		785	int nent = vcpu->arch.cpuid_nent;
784		786
785	e->flags &= ~KVM_CPUID_FLAG_STATE_READ_NEXT;	787	e->flags &= ~KVM_CPUID_FLAG_STATE_READ_NEXT;
786	/* when no next entry is found, the current entry[i] is reselected */	788	/* when no next entry is found, the current entry[i] is reselected */
787	for (j = i + 1; ; j = (j + 1) % nent) {	789	do {
788	struct kvm_cpuid_entry2 *ej = &vcpu->arch.cpuid_entries[j];	790	j = (j + 1) % nent;
789	if (ej->function == e->function) {	791	ej = &vcpu->arch.cpuid_entries[j];
790	ej->flags \|= KVM_CPUID_FLAG_STATE_READ_NEXT;	792	} while (ej->function != e->function);
791	return j;	793
792	}	794	ej->flags \|= KVM_CPUID_FLAG_STATE_READ_NEXT;
793	}	795
794	return 0; /* silence gcc, even though control never reaches here */	796	return j;
795	}	797	}
796		798
797	/* find an entry with matching function, matching index (if needed), and that	799	/* find an entry with matching function, matching index (if needed), and that

arch/x86/kvm/mmu.c+5−2

 	return kvm_setup_async_pf(vcpu, gva, kvm_vcpu_gfn_to_hva(vcpu, gfn), &arch);
 }
-static bool can_do_async_pf(struct kvm_vcpu *vcpu)
+bool kvm_can_do_async_pf(struct kvm_vcpu *vcpu)
 {
 	if (unlikely(!lapic_in_kernel(vcpu) ||
 		     kvm_event_needs_reinjection(vcpu)))
 		return false;
+	if (is_guest_mode(vcpu))
+		return false;
 	return kvm_x86_ops->interrupt_allowed(vcpu);
 }
 	if (!async)
 		return false; /* *pfn has correct page already */
-	if (!prefault && can_do_async_pf(vcpu)) {
+	if (!prefault && kvm_can_do_async_pf(vcpu)) {
 		trace_kvm_try_async_get_page(gva, gfn);
 		if (kvm_find_async_pf_gfn(vcpu, gfn)) {
 			trace_kvm_async_pf_doublefault(gva, gfn);

arch/x86/kvm/mmu.h+1−0

@@ -76,6 +76,7 @@ int handle_mmio_page_fault(struct kvm_vcpu *vcpu, u64 addr, bool direct); · 75 unmodified lines
76	void kvm_init_shadow_mmu(struct kvm_vcpu *vcpu);	76	void kvm_init_shadow_mmu(struct kvm_vcpu *vcpu);
77	void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, bool execonly,	77	void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, bool execonly,
78	bool accessed_dirty);	78	bool accessed_dirty);
		79	bool kvm_can_do_async_pf(struct kvm_vcpu *vcpu);
79		80
80	static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm)	81	static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm)
81	{	82	{

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

@@ -2425,7 +2425,7 @@ static int nested_vmx_check_exception(struct kvm_vcpu *vcpu, unsigned nr) · 2424 unmodified lines
2425	if (!(vmcs12->exception_bitmap & (1u << nr)))	2425	if (!(vmcs12->exception_bitmap & (1u << nr)))
2426	return 0;	2426	return 0;
2427		2427
2428	nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason,	2428	nested_vmx_vmexit(vcpu, EXIT_REASON_EXCEPTION_NMI,
2429	vmcs_read32(VM_EXIT_INTR_INFO),	2429	vmcs_read32(VM_EXIT_INTR_INFO),
2430	vmcs_readl(EXIT_QUALIFICATION));	2430	vmcs_readl(EXIT_QUALIFICATION));
2431	return 1;	2431	return 1;

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

@@ -8607,8 +8607,7 @@ bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) · 8606 unmodified lines
8607	if (!(vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED))	8607	if (!(vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED))
8608	return true;	8608	return true;
8609	else	8609	else
8610	return !kvm_event_needs_reinjection(vcpu) &&	8610	return kvm_can_do_async_pf(vcpu);
8611	kvm_x86_ops->interrupt_allowed(vcpu);
8612	}	8611	}
8613		8612
8614	void kvm_arch_start_assignment(struct kvm *kvm)	8613	void kvm_arch_start_assignment(struct kvm *kvm)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

block/bfq-cgroup.c+93−23

 BFQG_FLAG_FNS(empty)
 #undef BFQG_FLAG_FNS
-/* This should be called with the queue_lock held. */
+/* This should be called with the scheduler lock held. */
 static void bfqg_stats_update_group_wait_time(struct bfqg_stats *stats)
 {
 	unsigned long long now;
 	bfqg_stats_clear_waiting(stats);
 }
-/* This should be called with the queue_lock held. */
+/* This should be called with the scheduler lock held. */
 static void bfqg_stats_set_start_group_wait_time(struct bfq_group *bfqg,
 						 struct bfq_group *curr_bfqg)
 {
 	bfqg_stats_mark_waiting(stats);
 }
-/* This should be called with the queue_lock held. */
+/* This should be called with the scheduler lock held. */
 static void bfqg_stats_end_empty_time(struct bfqg_stats *stats)
 {
 	unsigned long long now;
 static void bfqg_get(struct bfq_group *bfqg)
 {
-	return blkg_get(bfqg_to_blkg(bfqg));
+	bfqg->ref++;
 }
 void bfqg_put(struct bfq_group *bfqg)
 {
-	return blkg_put(bfqg_to_blkg(bfqg));
+	bfqg->ref--;
+	if (bfqg->ref == 0)
+		kfree(bfqg);
+}
+static void bfqg_and_blkg_get(struct bfq_group *bfqg)
+{
+	/* see comments in bfq_bic_update_cgroup for why refcounting bfqg */
+	bfqg_get(bfqg);
+	blkg_get(bfqg_to_blkg(bfqg));
+}
+void bfqg_and_blkg_put(struct bfq_group *bfqg)
+{
+	bfqg_put(bfqg);
+	blkg_put(bfqg_to_blkg(bfqg));
 }
 void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
 	if (bfqq) {
 		bfqq->ioprio = bfqq->new_ioprio;
 		bfqq->ioprio_class = bfqq->new_ioprio_class;
-		bfqg_get(bfqg);
+		/*
+		 * Make sure that bfqg and its associated blkg do not
+		 * disappear before entity.
+		 */
+		bfqg_and_blkg_get(bfqg);
 	}
 	entity->parent = bfqg->my_entity; /* NULL for root group */
 	entity->sched_data = &bfqg->sched_data;
 		return NULL;
 	}
+	/* see comments in bfq_bic_update_cgroup for why refcounting */
+	bfqg_get(bfqg);
 	return &bfqg->pd;
 }
 	struct bfq_group *bfqg = pd_to_bfqg(pd);
 	bfqg_stats_exit(&bfqg->stats);
-	return kfree(bfqg);
+	bfqg_put(bfqg);
 }
 void bfq_pd_reset_stats(struct blkg_policy_data *pd)
  * Move @bfqq to @bfqg, deactivating it from its old group and reactivating
  * it on the new one.  Avoid putting the entity on the old group idle tree.
  *
- * Must be called under the queue lock; the cgroup owning @bfqg must
+ * Must be called under the scheduler lock, to make sure that the blkg
- * not disappear (by now this just means that we are called under
+ * owning @bfqg does not disappear (see comments in
- * rcu_read_lock()).
+ * bfq_bic_update_cgroup on guaranteeing the consistency of blkg
+ * objects).
  */
 void bfq_bfqq_move(struct bfq_data *bfqd, struct bfq_queue *bfqq,
 		   struct bfq_group *bfqg)
 		bfq_deactivate_bfqq(bfqd, bfqq, false, false);
 	else if (entity->on_st)
 		bfq_put_idle_entity(bfq_entity_service_tree(entity), entity);
-	bfqg_put(bfqq_group(bfqq));
+	bfqg_and_blkg_put(bfqq_group(bfqq));
-	/*
-	 * Here we use a reference to bfqg.  We don't need a refcounter
-	 * as the cgroup reference will not be dropped, so that its
-	 * destroy() callback will not be invoked.
-	 */
 	entity->parent = bfqg->my_entity;
 	entity->sched_data = &bfqg->sched_data;
-	bfqg_get(bfqg);
+	/* pin down bfqg and its associated blkg  */
+	bfqg_and_blkg_get(bfqg);
 	if (bfq_bfqq_busy(bfqq)) {
 		bfq_pos_tree_add_move(bfqd, bfqq);
  * @bic: the bic to move.
  * @blkcg: the blk-cgroup to move to.
  *
- * Move bic to blkcg, assuming that bfqd->queue is locked; the caller
+ * Move bic to blkcg, assuming that bfqd->lock is held; which makes
- * has to make sure that the reference to cgroup is valid across the call.
+ * sure that the reference to cgroup is valid across the call (see
+ * comments in bfq_bic_update_cgroup on this issue)
  *
  * NOTE: an alternative approach might have been to store the current
  * cgroup in bfqq and getting a reference to it, reducing the lookup
 		goto out;
 	bfqg = __bfq_bic_change_cgroup(bfqd, bic, bio_blkcg(bio));
+	/*
+	 * Update blkg_path for bfq_log_* functions. We cache this
+	 * path, and update it here, for the following
+	 * reasons. Operations on blkg objects in blk-cgroup are
+	 * protected with the request_queue lock, and not with the
+	 * lock that protects the instances of this scheduler
+	 * (bfqd->lock). This exposes BFQ to the following sort of
+	 * race.
+	 *
+	 * The blkg_lookup performed in bfq_get_queue, protected
+	 * through rcu, may happen to return the address of a copy of
+	 * the original blkg. If this is the case, then the
+	 * bfqg_and_blkg_get performed in bfq_get_queue, to pin down
+	 * the blkg, is useless: it does not prevent blk-cgroup code
+	 * from destroying both the original blkg and all objects
+	 * directly or indirectly referred by the copy of the
+	 * blkg.
+	 *
+	 * On the bright side, destroy operations on a blkg invoke, as
+	 * a first step, hooks of the scheduler associated with the
+	 * blkg. And these hooks are executed with bfqd->lock held for
+	 * BFQ. As a consequence, for any blkg associated with the
+	 * request queue this instance of the scheduler is attached
+	 * to, we are guaranteed that such a blkg is not destroyed, and
+	 * that all the pointers it contains are consistent, while we
+	 * are holding bfqd->lock. A blkg_lookup performed with
+	 * bfqd->lock held then returns a fully consistent blkg, which
+	 * remains consistent until this lock is held.
+	 *
+	 * Thanks to the last fact, and to the fact that: (1) bfqg has
+	 * been obtained through a blkg_lookup in the above
+	 * assignment, and (2) bfqd->lock is being held, here we can
+	 * safely use the policy data for the involved blkg (i.e., the
+	 * field bfqg->pd) to get to the blkg associated with bfqg,
+	 * and then we can safely use any field of blkg. After we
+	 * release bfqd->lock, even just getting blkg through this
+	 * bfqg may cause dangling references to be traversed, as
+	 * bfqg->pd may not exist any more.
+	 *
+	 * In view of the above facts, here we cache, in the bfqg, any
+	 * blkg data we may need for this bic, and for its associated
+	 * bfq_queue. As of now, we need to cache only the path of the
+	 * blkg, which is used in the bfq_log_* functions.
+	 *
+	 * Finally, note that bfqg itself needs to be protected from
+	 * destruction on the blkg_free of the original blkg (which
+	 * invokes bfq_pd_free). We use an additional private
+	 * refcounter for bfqg, to let it disappear only after no
+	 * bfq_queue refers to it any longer.
+	 */
+	blkg_path(bfqg_to_blkg(bfqg), bfqg->blkg_path, sizeof(bfqg->blkg_path));
 	bic->blkcg_serial_nr = serial_nr;
 out:
 	rcu_read_unlock();
  * @bfqd: the device data structure with the root group.
  * @bfqg: the group to move from.
  * @st: the service tree with the entities.
- *
- * Needs queue_lock to be taken and reference to be valid over the call.
  */
 static void bfq_reparent_active_entities(struct bfq_data *bfqd,
 					 struct bfq_group *bfqg,
 		/*
 		 * The idle tree may still contain bfq_queues belonging
 		 * to exited task because they never migrated to a different
-		 * cgroup from the one being destroyed now.  No one else
+		 * cgroup from the one being destroyed now.
-		 * can access them so it's safe to act without any lock.
 		 */
 		bfq_flush_idle_tree(st);

block/bfq-iosched.c+1−1

@@ -3665,7 +3665,7 @@ void bfq_put_queue(struct bfq_queue *bfqq) · 3664 unmodified lines
3665		3665
3666	kmem_cache_free(bfq_pool, bfqq);	3666	kmem_cache_free(bfq_pool, bfqq);
3667	#ifdef CONFIG_BFQ_GROUP_IOSCHED	3667	#ifdef CONFIG_BFQ_GROUP_IOSCHED
3668	bfqg_put(bfqg);	3668	bfqg_and_blkg_put(bfqg);
3669	#endif	3669	#endif
3670	}	3670	}
3671		3671

block/bfq-iosched.h+11−12

 	/* must be the first member */
 	struct blkg_policy_data pd;
+	/* cached path for this blkg (see comments in bfq_bic_update_cgroup) */
+	char blkg_path[128];
+	/* reference counter (see comments in bfq_bic_update_cgroup) */
+	int ref;
 	struct bfq_entity entity;
 	struct bfq_sched_data sched_data;
 struct blkcg_gq *bfqg_to_blkg(struct bfq_group *bfqg);
 struct bfq_group *bfqq_group(struct bfq_queue *bfqq);
 struct bfq_group *bfq_create_group_hierarchy(struct bfq_data *bfqd, int node);
-void bfqg_put(struct bfq_group *bfqg);
+void bfqg_and_blkg_put(struct bfq_group *bfqg);
 #ifdef CONFIG_BFQ_GROUP_IOSCHED
 extern struct cftype bfq_blkcg_legacy_files[];
 struct bfq_group *bfqq_group(struct bfq_queue *bfqq);
 #define bfq_log_bfqq(bfqd, bfqq, fmt, args...)	do {			\
-	char __pbuf[128];						\
+	blk_add_trace_msg((bfqd)->queue, "bfq%d%c %s " fmt, (bfqq)->pid,\
-									\
-	blkg_path(bfqg_to_blkg(bfqq_group(bfqq)), __pbuf, sizeof(__pbuf)); \
-	blk_add_trace_msg((bfqd)->queue, "bfq%d%c %s " fmt, (bfqq)->pid, \
 			bfq_bfqq_sync((bfqq)) ? 'S' : 'A',		\
-			  __pbuf, ##args);				\
+			bfqq_group(bfqq)->blkg_path, ##args);		\
 } while (0)
-#define bfq_log_bfqg(bfqd, bfqg, fmt, args...)	do {			\
+#define bfq_log_bfqg(bfqd, bfqg, fmt, args...)	\
-	char __pbuf[128];						\
+	blk_add_trace_msg((bfqd)->queue, "%s " fmt, (bfqg)->blkg_path, ##args)
-									\
-	blkg_path(bfqg_to_blkg(bfqg), __pbuf, sizeof(__pbuf));		\
-	blk_add_trace_msg((bfqd)->queue, "%s " fmt, __pbuf, ##args);	\
-} while (0)
 #else /* CONFIG_BFQ_GROUP_IOSCHED */

block/bio-integrity.c+3−0

@@ -175,6 +175,9 @@ bool bio_integrity_enabled(struct bio *bio) · 174 unmodified lines
175	if (bio_op(bio) != REQ_OP_READ && bio_op(bio) != REQ_OP_WRITE)	175	if (bio_op(bio) != REQ_OP_READ && bio_op(bio) != REQ_OP_WRITE)
176	return false;	176	return false;
177		177
		178	if (!bio_sectors(bio))
		179	return false;
		180
178	/* Already protected? */	181	/* Already protected? */
179	if (bio_integrity(bio))	182	if (bio_integrity(bio))
180	return false;	183	return false;

block/blk-mq.c+17−8

 	return blk_tag_to_qc_t(rq->internal_tag, hctx->queue_num, true);
 }
-static void __blk_mq_try_issue_directly(struct request *rq, blk_qc_t *cookie,
+static void __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
-				      bool may_sleep)
+					struct request *rq,
+					blk_qc_t *cookie, bool may_sleep)
 {
 	struct request_queue *q = rq->q;
 	struct blk_mq_queue_data bd = {
 		.rq = rq,
 		.last = true,
 	};
-	struct blk_mq_hw_ctx *hctx;
 	blk_qc_t new_cookie;
 	int ret;
+	bool run_queue = true;
+	if (blk_mq_hctx_stopped(hctx)) {
+		run_queue = false;
+		goto insert;
+	}
 	if (q->elevator)
 		goto insert;
-	if (!blk_mq_get_driver_tag(rq, &hctx, false))
+	if (!blk_mq_get_driver_tag(rq, NULL, false))
 		goto insert;
 	new_cookie = request_to_qc_t(hctx, rq);
 	__blk_mq_requeue_request(rq);
 insert:
-	blk_mq_sched_insert_request(rq, false, true, false, may_sleep);
+	blk_mq_sched_insert_request(rq, false, run_queue, false, may_sleep);
 }
 static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
 {
 	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
 		rcu_read_lock();
-		__blk_mq_try_issue_directly(rq, cookie, false);
+		__blk_mq_try_issue_directly(hctx, rq, cookie, false);
 		rcu_read_unlock();
 	} else {
 		unsigned int srcu_idx;
 		might_sleep();
 		srcu_idx = srcu_read_lock(&hctx->queue_rq_srcu);
-		__blk_mq_try_issue_directly(rq, cookie, true);
+		__blk_mq_try_issue_directly(hctx, rq, cookie, true);
 		srcu_read_unlock(&hctx->queue_rq_srcu, srcu_idx);
 	}
 }
 		blk_mq_put_ctx(data.ctx);
-		if (same_queue_rq)
+		if (same_queue_rq) {
+			data.hctx = blk_mq_map_queue(q,
+					same_queue_rq->mq_ctx->cpu);
 			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
 					&cookie);
+		}
 	} else if (q->nr_hw_queues > 1 && is_sync) {
 		blk_mq_put_ctx(data.ctx);
 		blk_mq_bio_to_request(rq, bio);

block/blk-throttle.c+18−4

 #define MIN_THROTL_IOPS (10)
 #define DFL_LATENCY_TARGET (-1L)
 #define DFL_IDLE_THRESHOLD (0)
+#define DFL_HD_BASELINE_LATENCY (4000L) /* 4ms */
+#define LATENCY_FILTERED_SSD (0)
+/*
+ * For HD, very small latency comes from sequential IO. Such IO is helpless to
+ * help determine if its IO is impacted by others, hence we ignore the IO
+ */
+#define LATENCY_FILTERED_HD (1000L) /* 1ms */
 #define SKIP_LATENCY (((u64)1) << BLK_STAT_RES_SHIFT)
 	struct avg_latency_bucket avg_buckets[LATENCY_BUCKET_SIZE];
 	struct latency_bucket __percpu *latency_buckets;
 	unsigned long last_calculate_time;
+	unsigned long filtered_latency;
 	bool track_bio_latency;
 };
 static void throtl_schedule_pending_timer(struct throtl_service_queue *sq,
 					  unsigned long expires)
 {
-	unsigned long max_expire = jiffies + 8 * sq_to_tg(sq)->td->throtl_slice;
+	unsigned long max_expire = jiffies + 8 * sq_to_td(sq)->throtl_slice;
 	/*
 	 * Since we are adjusting the throttle limit dynamically, the sleep
 		throtl_track_latency(tg->td, blk_stat_size(&bio->bi_issue_stat),
 			bio_op(bio), lat);
-	if (tg->latency_target) {
+	if (tg->latency_target && lat >= tg->td->filtered_latency) {
 		int bucket;
 		unsigned int threshold;
 void blk_throtl_register_queue(struct request_queue *q)
 {
 	struct throtl_data *td;
+	int i;
 	td = q->td;
 	BUG_ON(!td);
-	if (blk_queue_nonrot(q))
+	if (blk_queue_nonrot(q)) {
 		td->throtl_slice = DFL_THROTL_SLICE_SSD;
-	else
+		td->filtered_latency = LATENCY_FILTERED_SSD;
+	} else {
 		td->throtl_slice = DFL_THROTL_SLICE_HD;
+		td->filtered_latency = LATENCY_FILTERED_HD;
+		for (i = 0; i < LATENCY_BUCKET_SIZE; i++)
+			td->avg_buckets[i].latency = DFL_HD_BASELINE_LATENCY;
+	}
 #ifndef CONFIG_BLK_DEV_THROTTLING_LOW
 	/* if no low limit, use previous default */
 	td->throtl_slice = DFL_THROTL_SLICE_HD;

crypto/asymmetric_keys/public_key.c+1−1

@@ -141,7 +141,7 @@ int public_key_verify_signature(const struct public_key *pkey, · 140 unmodified lines
141	* signature and returns that to us.	141	* signature and returns that to us.
142	*/	142	*/
143	ret = crypto_akcipher_verify(req);	143	ret = crypto_akcipher_verify(req);
144	if (ret == -EINPROGRESS) {	144	if ((ret == -EINPROGRESS) \|\| (ret == -EBUSY)) {
145	wait_for_completion(&compl.completion);	145	wait_for_completion(&compl.completion);
146	ret = compl.err;	146	ret = compl.err;
147	}	147	}

crypto/asymmetric_keys/verify_pefile.c+2−2

@@ -381,7 +381,7 @@ static int pefile_digest_pe(const void *pebuf, unsigned int pelen, · 380 unmodified lines
381	}	381	}
382		382
383	error:	383	error:
384	kfree(desc);	384	kzfree(desc);
385	error_no_desc:	385	error_no_desc:
386	crypto_free_shash(tfm);	386	crypto_free_shash(tfm);
387	kleave(" = %d", ret);	387	kleave(" = %d", ret);
@@ -450,6 +450,6 @@ int verify_pefile_signature(const void *pebuf, unsigned pelen, · 62 unmodified lines
450	ret = pefile_digest_pe(pebuf, pelen, &ctx);	450	ret = pefile_digest_pe(pebuf, pelen, &ctx);
451		451
452	error:	452	error:
453	kfree(ctx.digest);	453	kzfree(ctx.digest);
454	return ret;	454	return ret;
455	}	455	}

crypto/asymmetric_keys/x509_cert_parser.c+1−0

@@ -102,6 +102,7 @@ struct x509_certificate x509_cert_parse(const void data, size_t datalen) · 101 unmodified lines
102	}	102	}
103	}	103	}
104		104
		105	ret = -ENOMEM;
105	cert->pub->key = kmemdup(ctx->key, ctx->key_size, GFP_KERNEL);	106	cert->pub->key = kmemdup(ctx->key, ctx->key_size, GFP_KERNEL);
106	if (!cert->pub->key)	107	if (!cert->pub->key)
107	goto error_decode;	108	goto error_decode;

crypto/drbg.c+2−3

 			break;
 		case -EINPROGRESS:
 		case -EBUSY:
-			ret = wait_for_completion_interruptible(
+			wait_for_completion(&drbg->ctr_completion);
-				&drbg->ctr_completion);
+			if (!drbg->ctr_async_err) {
-			if (!ret && !drbg->ctr_async_err) {
 				reinit_completion(&drbg->ctr_completion);
 				break;
 			}

crypto/gcm.c+2−4

 	err = crypto_skcipher_encrypt(&data->req);
 	if (err == -EINPROGRESS || err == -EBUSY) {
-		err = wait_for_completion_interruptible(
+		wait_for_completion(&data->result.completion);
-			&data->result.completion);
+		err = data->result.err;
-		if (!err)
-			err = data->result.err;
 	}
 	if (err)

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

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

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

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

drivers/acpi/arm64/iort.c+14−8

 	int ret = -ENODEV;
 	struct fwnode_handle *iort_fwnode;
-	/*
-	 * If we already translated the fwspec there
-	 * is nothing left to do, return the iommu_ops.
-	 */
-	ops = iort_fwspec_iommu_ops(dev->iommu_fwspec);
-	if (ops)
-		return ops;
 	if (node) {
 		iort_fwnode = iort_get_fwnode(node);
 		if (!iort_fwnode)
 	u32 streamid = 0;
 	int err;
+	/*
+	 * If we already translated the fwspec there
+	 * is nothing left to do, return the iommu_ops.
+	 */
+	ops = iort_fwspec_iommu_ops(dev->iommu_fwspec);
+	if (ops)
+		return ops;
 	if (dev_is_pci(dev)) {
 		struct pci_bus *bus = to_pci_dev(dev)->bus;
 		u32 rid;
 	if (err)
 		ops = ERR_PTR(err);
+	/* Ignore all other errors apart from EPROBE_DEFER */
+	if (IS_ERR(ops) && (PTR_ERR(ops) != -EPROBE_DEFER)) {
+		dev_dbg(dev, "Adding to IOMMU failed: %ld\n", PTR_ERR(ops));
+		ops = NULL;
+	}
 	return ops;
 }

drivers/acpi/battery.c+1−1

@@ -782,7 +782,7 @@ static int acpi_battery_update(struct acpi_battery *battery, bool resume) · 781 unmodified lines
782	if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) \|\|	782	if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) \|\|
783	(test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&	783	(test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
784	(battery->capacity_now <= battery->alarm)))	784	(battery->capacity_now <= battery->alarm)))
785	pm_wakeup_hard_event(&battery->device->dev);	785	pm_wakeup_event(&battery->device->dev, 0);
786		786
787	return result;	787	return result;
788	}	788	}

drivers/acpi/button.c+2−3

 	}
 	if (state)
-		pm_wakeup_hard_event(&device->dev);
+		pm_wakeup_event(&device->dev, 0);
 	ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
 	if (ret == NOTIFY_DONE)
 		} else {
 			int keycode;
-			pm_wakeup_hard_event(&device->dev);
+			pm_wakeup_event(&device->dev, 0);
 			if (button->suspended)
 				break;
 		lid_device = device;
 	}
-	device_init_wakeup(&device->dev, true);
 	printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
 	return 0;

drivers/acpi/device_pm.c+1−2

 #include <linux/pm_qos.h>
 #include <linux/pm_domain.h>
 #include <linux/pm_runtime.h>
-#include <linux/suspend.h>
 #include "internal.h"
 	mutex_lock(&acpi_pm_notifier_lock);
 	if (adev->wakeup.flags.notifier_present) {
-		pm_wakeup_ws_event(adev->wakeup.ws, 0, true);
+		__pm_wakeup_event(adev->wakeup.ws, 0);
 		if (adev->wakeup.context.work.func)
 			queue_pm_work(&adev->wakeup.context.work);
 	}

drivers/acpi/scan.c+2−2

@@ -1371,8 +1371,8 @@ int acpi_dma_configure(struct device *dev, enum dev_dma_attr attr) · 1370 unmodified lines
1371	iort_set_dma_mask(dev);	1371	iort_set_dma_mask(dev);
1372		1372
1373	iommu = iort_iommu_configure(dev);	1373	iommu = iort_iommu_configure(dev);
1374	if (IS_ERR(iommu))	1374	if (IS_ERR(iommu) && PTR_ERR(iommu) == -EPROBE_DEFER)
1375	return PTR_ERR(iommu);	1375	return -EPROBE_DEFER;
1376		1376
1377	size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);	1377	size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
1378	/*	1378	/*

drivers/acpi/sleep.c+0−28

@@ -663,40 +663,14 @@ static int acpi_freeze_prepare(void) · 662 unmodified lines
663	acpi_os_wait_events_complete();	663	acpi_os_wait_events_complete();
664	if (acpi_sci_irq_valid())	664	if (acpi_sci_irq_valid())
665	enable_irq_wake(acpi_sci_irq);	665	enable_irq_wake(acpi_sci_irq);
666
667	return 0;	666	return 0;
668	}	667	}
669		668
670	static void acpi_freeze_wake(void)
671	{
672	/*
673	* If IRQD_WAKEUP_ARMED is not set for the SCI at this point, it means
674	* that the SCI has triggered while suspended, so cancel the wakeup in
675	* case it has not been a wakeup event (the GPEs will be checked later).
676	*/
677	if (acpi_sci_irq_valid() &&
678	!irqd_is_wakeup_armed(irq_get_irq_data(acpi_sci_irq)))
679	pm_system_cancel_wakeup();
680	}
681
682	static void acpi_freeze_sync(void)
683	{
684	/*
685	* Process all pending events in case there are any wakeup ones.
686	*
687	* The EC driver uses the system workqueue, so that one needs to be
688	* flushed too.
689	*/
690	acpi_os_wait_events_complete();
691	flush_scheduled_work();
692	}
693
694	static void acpi_freeze_restore(void)	669	static void acpi_freeze_restore(void)
695	{	670	{
696	acpi_disable_wakeup_devices(ACPI_STATE_S0);	671	acpi_disable_wakeup_devices(ACPI_STATE_S0);
697	if (acpi_sci_irq_valid())	672	if (acpi_sci_irq_valid())
698	disable_irq_wake(acpi_sci_irq);	673	disable_irq_wake(acpi_sci_irq);
699
700	acpi_enable_all_runtime_gpes();	674	acpi_enable_all_runtime_gpes();
701	}	675	}
702		676
@@ -708,8 +682,6 @@ static void acpi_freeze_end(void) · 5 unmodified lines
708	static const struct platform_freeze_ops acpi_freeze_ops = {	682	static const struct platform_freeze_ops acpi_freeze_ops = {
709	.begin = acpi_freeze_begin,	683	.begin = acpi_freeze_begin,
710	.prepare = acpi_freeze_prepare,	684	.prepare = acpi_freeze_prepare,
711	.wake = acpi_freeze_wake,
712	.sync = acpi_freeze_sync,
713	.restore = acpi_freeze_restore,	685	.restore = acpi_freeze_restore,
714	.end = acpi_freeze_end,	686	.end = acpi_freeze_end,
715	};	687	};

drivers/base/power/main.c+5−0

 	if (async_error)
 		goto Complete;
+	if (pm_wakeup_pending()) {
+		async_error = -EBUSY;
+		goto Complete;
+	}
 	if (dev->power.syscore || dev->power.direct_complete)
 		goto Complete;

drivers/base/power/wakeup.c+6−12

 /* First wakeup IRQ seen by the kernel in the last cycle. */
 unsigned int pm_wakeup_irq __read_mostly;
-/* If greater than 0 and the system is suspending, terminate the suspend. */
+/* If set and the system is suspending, terminate the suspend. */
-static atomic_t pm_abort_suspend __read_mostly;
+static bool pm_abort_suspend __read_mostly;
 /*
  * Combined counters of registered wakeup events and wakeup events in progress.
 		pm_print_active_wakeup_sources();
 	}
-	return ret || atomic_read(&pm_abort_suspend) > 0;
+	return ret || pm_abort_suspend;
 }
 void pm_system_wakeup(void)
 {
-	atomic_inc(&pm_abort_suspend);
+	pm_abort_suspend = true;
 	freeze_wake();
 }
 EXPORT_SYMBOL_GPL(pm_system_wakeup);
-void pm_system_cancel_wakeup(void)
+void pm_wakeup_clear(void)
-{
-	atomic_dec(&pm_abort_suspend);
-}
-void pm_wakeup_clear(bool reset)
 {
+	pm_abort_suspend = false;
 	pm_wakeup_irq = 0;
-	if (reset)
-		atomic_set(&pm_abort_suspend, 0);
 }
 void pm_system_irq_wakeup(unsigned int irq_number)

drivers/block/loop.c+3−0

  */
 static int loop_flush(struct loop_device *lo)
 {
+	/* loop not yet configured, no running thread, nothing to flush */
+	if (lo->lo_state != Lo_bound)
+		return 0;
 	return loop_switch(lo, NULL);
 }

drivers/char/mem.c+1−1

@@ -343,7 +343,7 @@ static int mmap_mem(struct file file, struct vm_area_struct vma) · 342 unmodified lines
343	phys_addr_t offset = (phys_addr_t)vma->vm_pgoff << PAGE_SHIFT;	343	phys_addr_t offset = (phys_addr_t)vma->vm_pgoff << PAGE_SHIFT;
344		344
345	/* It's illegal to wrap around the end of the physical address space. */	345	/* It's illegal to wrap around the end of the physical address space. */
346	if (offset + (phys_addr_t)size < offset)	346	if (offset + (phys_addr_t)size - 1 < offset)
347	return -EINVAL;	347	return -EINVAL;
348		348
349	if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))	349	if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))

drivers/char/random.c+43−6

 /*
  * random.c -- A strong random number generator
  *
+ * Copyright (C) 2017 Jason A. Donenfeld <Jason@zx2c4.com>. All
+ * Rights Reserved.
+ *
  * Copyright Matt Mackall <mpm@selenic.com>, 2003, 2004, 2005
  *
  * Copyright Theodore Ts'o, 1994, 1995, 1996, 1997, 1998, 1999.  All
 static struct crng_state **crng_node_pool __read_mostly;
 #endif
+static void invalidate_batched_entropy(void);
 static void crng_initialize(struct crng_state *crng)
 {
 	int		i;
 		cp++; crng_init_cnt++; len--;
 	}
 	if (crng_init_cnt >= CRNG_INIT_CNT_THRESH) {
+		invalidate_batched_entropy();
 		crng_init = 1;
 		wake_up_interruptible(&crng_init_wait);
 		pr_notice("random: fast init done\n");
 	memzero_explicit(&buf, sizeof(buf));
 	crng->init_time = jiffies;
 	if (crng == &primary_crng && crng_init < 2) {
+		invalidate_batched_entropy();
 		crng_init = 2;
 		process_random_ready_list();
 		wake_up_interruptible(&crng_init_wait);
 static __u32 get_reg(struct fast_pool *f, struct pt_regs *regs)
 {
 	__u32 *ptr = (__u32 *) regs;
-	unsigned long flags;
+	unsigned int idx;
 	if (regs == NULL)
 		return 0;
-	local_irq_save(flags);
+	idx = READ_ONCE(f->reg_idx);
-	if (f->reg_idx >= sizeof(struct pt_regs) / sizeof(__u32))
+	if (idx >= sizeof(struct pt_regs) / sizeof(__u32))
-		f->reg_idx = 0;
+		idx = 0;
-	ptr += f->reg_idx++;
+	ptr += idx++;
-	local_irq_restore(flags);
+	WRITE_ONCE(f->reg_idx, idx);
 	return *ptr;
 }
 	};
 	unsigned int position;
 };
+static rwlock_t batched_entropy_reset_lock = __RW_LOCK_UNLOCKED(batched_entropy_reset_lock);
 /*
  * Get a random word for internal kernel use only. The quality of the random
 u64 get_random_u64(void)
 {
 	u64 ret;
+	bool use_lock = crng_init < 2;
+	unsigned long flags;
 	struct batched_entropy *batch;
 #if BITS_PER_LONG == 64
 #endif
 	batch = &get_cpu_var(batched_entropy_u64);
+	if (use_lock)
+		read_lock_irqsave(&batched_entropy_reset_lock, flags);
 	if (batch->position % ARRAY_SIZE(batch->entropy_u64) == 0) {
 		extract_crng((u8 *)batch->entropy_u64);
 		batch->position = 0;
 	}
 	ret = batch->entropy_u64[batch->position++];
+	if (use_lock)
+		read_unlock_irqrestore(&batched_entropy_reset_lock, flags);
 	put_cpu_var(batched_entropy_u64);
 	return ret;
 }
 u32 get_random_u32(void)
 {
 	u32 ret;
+	bool use_lock = crng_init < 2;
+	unsigned long flags;
 	struct batched_entropy *batch;
 	if (arch_get_random_int(&ret))
 		return ret;
 	batch = &get_cpu_var(batched_entropy_u32);
+	if (use_lock)
+		read_lock_irqsave(&batched_entropy_reset_lock, flags);
 	if (batch->position % ARRAY_SIZE(batch->entropy_u32) == 0) {
 		extract_crng((u8 *)batch->entropy_u32);
 		batch->position = 0;
 	}
 	ret = batch->entropy_u32[batch->position++];
+	if (use_lock)
+		read_unlock_irqrestore(&batched_entropy_reset_lock, flags);
 	put_cpu_var(batched_entropy_u32);
 	return ret;
 }
 EXPORT_SYMBOL(get_random_u32);
+/* It's important to invalidate all potential batched entropy that might
+ * be stored before the crng is initialized, which we can do lazily by
+ * simply resetting the counter to zero so that it's re-extracted on the
+ * next usage. */
+static void invalidate_batched_entropy(void)
+{
+	int cpu;
+	unsigned long flags;
+	write_lock_irqsave(&batched_entropy_reset_lock, flags);
+	for_each_possible_cpu (cpu) {
+		per_cpu_ptr(&batched_entropy_u32, cpu)->position = 0;
+		per_cpu_ptr(&batched_entropy_u64, cpu)->position = 0;
+	}
+	write_unlock_irqrestore(&batched_entropy_reset_lock, flags);
+}
 /**
  * randomize_page - Generate a random, page aligned address
  * @start:	The smallest acceptable address the caller will take.

drivers/cpufreq/cpufreq_conservative.c+2−2

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

drivers/cpufreq/intel_pstate.c+3−2

 static int min_perf_pct_min(void)
 {
 	struct cpudata *cpu = all_cpu_data[0];
+	int turbo_pstate = cpu->pstate.turbo_pstate;
-	return DIV_ROUND_UP(cpu->pstate.min_pstate * 100,
+	return turbo_pstate ?
-			    cpu->pstate.turbo_pstate);
+		DIV_ROUND_UP(cpu->pstate.min_pstate * 100, turbo_pstate) : 0;
 }
 static s16 intel_pstate_get_epb(struct cpudata *cpu_data)

drivers/cpuidle/dt_idle_states.c+3−1

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

drivers/dax/super.c+7−2

 static struct inode *dax_alloc_inode(struct super_block *sb)
 {
 	struct dax_device *dax_dev;
+	struct inode *inode;
 	dax_dev = kmem_cache_alloc(dax_cache, GFP_KERNEL);
-	return &dax_dev->inode;
+	inode = &dax_dev->inode;
+	inode->i_rdev = 0;
+	return inode;
 }
 static struct dax_device *to_dax_dev(struct inode *inode)
 	kfree(dax_dev->host);
 	dax_dev->host = NULL;
-	ida_simple_remove(&dax_minor_ida, MINOR(inode->i_rdev));
+	if (inode->i_rdev)
+		ida_simple_remove(&dax_minor_ida, MINOR(inode->i_rdev));
 	kmem_cache_free(dax_cache, dax_dev);
 }
 	struct dax_device *dax_dev = _dax_dev;
 	struct inode *inode = &dax_dev->inode;
+	memset(dax_dev, 0, sizeof(*dax_dev));
 	inode_init_once(inode);
 }

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

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

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

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

drivers/firmware/efi/efi-bgrt.c+25−1

@@ -27,6 +27,26 @@ struct bmp_header { · 26 unmodified lines
27	u32 size;	27	u32 size;
28	} __packed;	28	} __packed;
29		29
		30	static bool efi_bgrt_addr_valid(u64 addr)
		31	{
		32	efi_memory_desc_t *md;
		33
		34	for_each_efi_memory_desc(md) {
		35	u64 size;
		36	u64 end;
		37
		38	if (md->type != EFI_BOOT_SERVICES_DATA)
		39	continue;
		40
		41	size = md->num_pages << EFI_PAGE_SHIFT;
		42	end = md->phys_addr + size;
		43	if (addr >= md->phys_addr && addr < end)
		44	return true;
		45	}
		46
		47	return false;
		48	}
		49
30	void __init efi_bgrt_init(struct acpi_table_header *table)	50	void __init efi_bgrt_init(struct acpi_table_header *table)
31	{	51	{
32	void *image;	52	void *image;
@@ -36,7 +56,7 @@ void __init efi_bgrt_init(struct acpi_table_header *table) · 3 unmodified lines
36	if (acpi_disabled)	56	if (acpi_disabled)
37	return;	57	return;
38		58
39	if (!efi_enabled(EFI_BOOT))	59	if (!efi_enabled(EFI_MEMMAP))
40	return;	60	return;
41		61
42	if (table->length < sizeof(bgrt_tab)) {	62	if (table->length < sizeof(bgrt_tab)) {
@@ -65,6 +85,10 @@ void __init efi_bgrt_init(struct acpi_table_header *table) · 22 unmodified lines
65	goto out;	85	goto out;
66	}	86	}
67		87
		88	if (!efi_bgrt_addr_valid(bgrt->image_address)) {
		89	pr_notice("Ignoring BGRT: invalid image address\n");
		90	goto out;
		91	}
68	image = early_memremap(bgrt->image_address, sizeof(bmp_header));	92	image = early_memremap(bgrt->image_address, sizeof(bmp_header));
69	if (!image) {	93	if (!image) {
70	pr_notice("Ignoring BGRT: failed to map image header memory\n");	94	pr_notice("Ignoring BGRT: failed to map image header memory\n");

drivers/firmware/google/vpd.c+4−4

 	info->value = value;
 	INIT_LIST_HEAD(&info->list);
-	list_add_tail(&info->list, &sec->attribs);
 	ret = sysfs_create_bin_file(sec->kobj, &info->bin_attr);
 	if (ret)
 		goto free_info_key;
+	list_add_tail(&info->list, &sec->attribs);
 	return 0;
 free_info_key:
 	struct vpd_attrib_info *temp;
 	list_for_each_entry_safe(info, temp, &sec->attribs, list) {
-		kfree(info->key);
 		sysfs_remove_bin_file(sec->kobj, &info->bin_attr);
+		kfree(info->key);
 		kfree(info);
 	}
 }
 {
 	if (sec->enabled) {
 		vpd_section_attrib_destroy(sec);
-		kobject_del(sec->kobj);
+		kobject_put(sec->kobj);
 		sysfs_remove_bin_file(vpd_kobj, &sec->bin_attr);
 		kfree(sec->raw_name);
 		iounmap(sec->baseaddr);
 {
 	vpd_section_destroy(&ro_vpd);
 	vpd_section_destroy(&rw_vpd);
-	kobject_del(vpd_kobj);
+	kobject_put(vpd_kobj);
 }
 module_init(vpd_platform_init);

drivers/gpio/gpio-aspeed.c+3−0

@@ -646,6 +646,9 @@ static int enable_debounce(struct gpio_chip *chip, unsigned int offset, · 645 unmodified lines
646	int rc;	646	int rc;
647	int i;	647	int i;
648		648
		649	if (!gpio->clk)
		650	return -EINVAL;
		651
649	rc = usecs_to_cycles(gpio, usecs, &requested_cycles);	652	rc = usecs_to_cycles(gpio, usecs, &requested_cycles);
650	if (rc < 0) {	653	if (rc < 0) {
651	dev_warn(chip->parent, "Failed to convert %luus to cycles at %luHz: %d\n",	654	dev_warn(chip->parent, "Failed to convert %luus to cycles at %luHz: %d\n",

drivers/gpio/gpio-crystalcove.c+36−18

 {
 	int reg;
-	if (gpio == 94)
+	if (gpio >= CRYSTALCOVE_GPIO_NUM) {
-		return GPIOPANELCTL;
+		/*
+		 * Virtual GPIO called from ACPI, for now we only support
+		 * the panel ctl.
+		 */
+		switch (gpio) {
+		case 0x5e:
+			return GPIOPANELCTL;
+		default:
+			return -EOPNOTSUPP;
+		}
+	}
 	if (reg_type == CTRL_IN) {
 		if (gpio < 8)
 static int crystalcove_gpio_dir_in(struct gpio_chip *chip, unsigned gpio)
 {
 	struct crystalcove_gpio *cg = gpiochip_get_data(chip);
+	int reg = to_reg(gpio, CTRL_OUT);
-	if (gpio > CRYSTALCOVE_VGPIO_NUM)
+	if (reg < 0)
 		return 0;
-	return regmap_write(cg->regmap, to_reg(gpio, CTRL_OUT),
+	return regmap_write(cg->regmap, reg, CTLO_INPUT_SET);
-			    CTLO_INPUT_SET);
 }
 static int crystalcove_gpio_dir_out(struct gpio_chip *chip, unsigned gpio,
 				    int value)
 {
 	struct crystalcove_gpio *cg = gpiochip_get_data(chip);
+	int reg = to_reg(gpio, CTRL_OUT);
-	if (gpio > CRYSTALCOVE_VGPIO_NUM)
+	if (reg < 0)
 		return 0;
-	return regmap_write(cg->regmap, to_reg(gpio, CTRL_OUT),
+	return regmap_write(cg->regmap, reg, CTLO_OUTPUT_SET | value);
-			    CTLO_OUTPUT_SET | value);
 }
 static int crystalcove_gpio_get(struct gpio_chip *chip, unsigned gpio)
 {
 	struct crystalcove_gpio *cg = gpiochip_get_data(chip);
-	int ret;
 	unsigned int val;
+	int ret, reg = to_reg(gpio, CTRL_IN);
-	if (gpio > CRYSTALCOVE_VGPIO_NUM)
+	if (reg < 0)
 		return 0;
-	ret = regmap_read(cg->regmap, to_reg(gpio, CTRL_IN), &val);
+	ret = regmap_read(cg->regmap, reg, &val);
 	if (ret)
 		return ret;
 				 unsigned gpio, int value)
 {
 	struct crystalcove_gpio *cg = gpiochip_get_data(chip);
+	int reg = to_reg(gpio, CTRL_OUT);
-	if (gpio > CRYSTALCOVE_VGPIO_NUM)
+	if (reg < 0)
 		return;
 	if (value)
-		regmap_update_bits(cg->regmap, to_reg(gpio, CTRL_OUT), 1, 1);
+		regmap_update_bits(cg->regmap, reg, 1, 1);
 	else
-		regmap_update_bits(cg->regmap, to_reg(gpio, CTRL_OUT), 1, 0);
+		regmap_update_bits(cg->regmap, reg, 1, 0);
 }
 static int crystalcove_irq_type(struct irq_data *data, unsigned type)
 	struct crystalcove_gpio *cg =
 		gpiochip_get_data(irq_data_get_irq_chip_data(data));
+	if (data->hwirq >= CRYSTALCOVE_GPIO_NUM)
+		return 0;
 	switch (type) {
 	case IRQ_TYPE_NONE:
 		cg->intcnt_value = CTLI_INTCNT_DIS;
 	struct crystalcove_gpio *cg =
 		gpiochip_get_data(irq_data_get_irq_chip_data(data));
-	cg->set_irq_mask = false;
+	if (data->hwirq < CRYSTALCOVE_GPIO_NUM) {
-	cg->update |= UPDATE_IRQ_MASK;
+		cg->set_irq_mask = false;
+		cg->update |= UPDATE_IRQ_MASK;
+	}
 }
 static void crystalcove_irq_mask(struct irq_data *data)
 	struct crystalcove_gpio *cg =
 		gpiochip_get_data(irq_data_get_irq_chip_data(data));
-	cg->set_irq_mask = true;
+	if (data->hwirq < CRYSTALCOVE_GPIO_NUM) {
-	cg->update |= UPDATE_IRQ_MASK;
+		cg->set_irq_mask = true;
+		cg->update |= UPDATE_IRQ_MASK;
+	}
 }
 static struct irq_chip crystalcove_irqchip = {

drivers/gpio/gpio-mvebu.c+8−1

 		set = U32_MAX;
 	else
 		return -EINVAL;
-	writel_relaxed(0, mvebu_gpioreg_blink_counter_select(mvchip));
+	writel_relaxed(set, mvebu_gpioreg_blink_counter_select(mvchip));
 	mvpwm = devm_kzalloc(dev, sizeof(struct mvebu_pwm), GFP_KERNEL);
 	if (!mvpwm)
 	mvpwm->chip.dev = dev;
 	mvpwm->chip.ops = &mvebu_pwm_ops;
 	mvpwm->chip.npwm = mvchip->chip.ngpio;
+	/*
+	 * There may already be some PWM allocated, so we can't force
+	 * mvpwm->chip.base to a fixed point like mvchip->chip.base.
+	 * So, we let pwmchip_add() do the numbering and take the next free
+	 * region.
+	 */
+	mvpwm->chip.base = -1;
 	spin_lock_init(&mvpwm->lock);

drivers/gpu/drm/drm_atomic_helper.c+11−0

 		bool has_connectors =
 			!!new_crtc_state->connector_mask;
+		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
 		if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
 			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n",
 					 crtc->base.id, crtc->name);
 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
+		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 		/*
 		 * This only sets crtc->connectors_changed for routing changes,
 		 * drivers must set crtc->connectors_changed themselves when
 	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
 		const struct drm_plane_helper_funcs *funcs;
+		WARN_ON(!drm_modeset_is_locked(&plane->mutex));
 		funcs = plane->helper_private;
 		drm_atomic_helper_plane_changed(state, old_plane_state, new_plane_state, plane);
 	drm_modeset_acquire_init(&ctx, 0);
 	while (1) {
+		err = drm_modeset_lock_all_ctx(dev, &ctx);
+		if (err)
+			goto out;
 		err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
+out:
 		if (err != -EDEADLK)
 			break;

drivers/gpu/drm/drm_drv.c+6−1

 void drm_unplug_dev(struct drm_device *dev)
 {
 	/* for a USB device */
-	drm_dev_unregister(dev);
+	if (drm_core_check_feature(dev, DRIVER_MODESET))
+		drm_modeset_unregister_all(dev);
+	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
+	drm_minor_unregister(dev, DRM_MINOR_RENDER);
+	drm_minor_unregister(dev, DRM_MINOR_CONTROL);
 	mutex_lock(&drm_global_mutex);

drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c+1−1

@@ -760,7 +760,7 @@ static int dsi_parse_dt(struct platform_device pdev, struct dw_dsi dsi) · 759 unmodified lines
760	* Get the endpoint node. In our case, dsi has one output port1	760	* Get the endpoint node. In our case, dsi has one output port1
761	* to which the external HDMI bridge is connected.	761	* to which the external HDMI bridge is connected.
762	*/	762	*/
763	ret = drm_of_find_panel_or_bridge(np, 0, 0, NULL, &dsi->bridge);	763	ret = drm_of_find_panel_or_bridge(np, 1, 0, NULL, &dsi->bridge);
764	if (ret)	764	if (ret)
765	return ret;	765	return ret;
766		766

drivers/gpu/drm/i915/i915_drv.c+9−0

@@ -1235,6 +1235,15 @@ int i915_driver_load(struct pci_dev pdev, const struct pci_device_id ent) · 1234 unmodified lines
1235	goto out_fini;	1235	goto out_fini;
1236		1236
1237	pci_set_drvdata(pdev, &dev_priv->drm);	1237	pci_set_drvdata(pdev, &dev_priv->drm);
		1238	/*
		1239	* Disable the system suspend direct complete optimization, which can
		1240	* leave the device suspended skipping the driver's suspend handlers
		1241	* if the device was already runtime suspended. This is needed due to
		1242	* the difference in our runtime and system suspend sequence and
		1243	* becaue the HDA driver may require us to enable the audio power
		1244	* domain during system suspend.
		1245	*/
		1246	pdev->dev_flags \|= PCI_DEV_FLAGS_NEEDS_RESUME;
1238		1247
1239	ret = i915_driver_init_early(dev_priv, ent);	1248	ret = i915_driver_init_early(dev_priv, ent);
1240	if (ret < 0)	1249	if (ret < 0)

drivers/gpu/drm/i915/i915_drv.h+10−0

@@ -2991,6 +2991,16 @@ static inline bool intel_scanout_needs_vtd_wa(struct drm_i915_private *dev_priv) · 2990 unmodified lines
2991	return false;	2991	return false;
2992	}	2992	}
2993		2993
		2994	static inline bool
		2995	intel_ggtt_update_needs_vtd_wa(struct drm_i915_private *dev_priv)
		2996	{
		2997	#ifdef CONFIG_INTEL_IOMMU
		2998	if (IS_BROXTON(dev_priv) && intel_iommu_gfx_mapped)
		2999	return true;
		3000	#endif
		3001	return false;
		3002	}
		3003
2994	int intel_sanitize_enable_ppgtt(struct drm_i915_private *dev_priv,	3004	int intel_sanitize_enable_ppgtt(struct drm_i915_private *dev_priv,
2995	int enable_ppgtt);	3005	int enable_ppgtt);
2996		3006

drivers/gpu/drm/i915/i915_gem.c+4−0

@@ -3298,6 +3298,10 @@ int i915_gem_wait_for_idle(struct drm_i915_private *i915, unsigned int flags) · 3297 unmodified lines
3298	{	3298	{
3299	int ret;	3299	int ret;
3300		3300
		3301	/* If the device is asleep, we have no requests outstanding */
		3302	if (!READ_ONCE(i915->gt.awake))
		3303	return 0;
		3304
3301	if (flags & I915_WAIT_LOCKED) {	3305	if (flags & I915_WAIT_LOCKED) {
3302	struct i915_gem_timeline *tl;	3306	struct i915_gem_timeline *tl;
3303		3307

drivers/gpu/drm/i915/i915_gem_gtt.c+105−1

@@ -2191,6 +2191,101 @@ static void gen8_ggtt_clear_range(struct i915_address_space *vm, · 2190 unmodified lines
2191	gen8_set_pte(&gtt_base[i], scratch_pte);	2191	gen8_set_pte(&gtt_base[i], scratch_pte);
2192	}	2192	}
2193		2193
		2194	static void bxt_vtd_ggtt_wa(struct i915_address_space *vm)
		2195	{
		2196	struct drm_i915_private *dev_priv = vm->i915;
		2197
		2198	/*
		2199	* Make sure the internal GAM fifo has been cleared of all GTT
		2200	* writes before exiting stop_machine(). This guarantees that
		2201	* any aperture accesses waiting to start in another process
		2202	* cannot back up behind the GTT writes causing a hang.
		2203	* The register can be any arbitrary GAM register.
		2204	*/
		2205	POSTING_READ(GFX_FLSH_CNTL_GEN6);
		2206	}
		2207
		2208	struct insert_page {
		2209	struct i915_address_space *vm;
		2210	dma_addr_t addr;
		2211	u64 offset;
		2212	enum i915_cache_level level;
		2213	};
		2214
		2215	static int bxt_vtd_ggtt_insert_page__cb(void *_arg)
		2216	{
		2217	struct insert_page *arg = _arg;
		2218
		2219	gen8_ggtt_insert_page(arg->vm, arg->addr, arg->offset, arg->level, 0);
		2220	bxt_vtd_ggtt_wa(arg->vm);
		2221
		2222	return 0;
		2223	}
		2224
		2225	static void bxt_vtd_ggtt_insert_page__BKL(struct i915_address_space *vm,
		2226	dma_addr_t addr,
		2227	u64 offset,
		2228	enum i915_cache_level level,
		2229	u32 unused)
		2230	{
		2231	struct insert_page arg = { vm, addr, offset, level };
		2232
		2233	stop_machine(bxt_vtd_ggtt_insert_page__cb, &arg, NULL);
		2234	}
		2235
		2236	struct insert_entries {
		2237	struct i915_address_space *vm;
		2238	struct sg_table *st;
		2239	u64 start;
		2240	enum i915_cache_level level;
		2241	};
		2242
		2243	static int bxt_vtd_ggtt_insert_entries__cb(void *_arg)
		2244	{
		2245	struct insert_entries *arg = _arg;
		2246
		2247	gen8_ggtt_insert_entries(arg->vm, arg->st, arg->start, arg->level, 0);
		2248	bxt_vtd_ggtt_wa(arg->vm);
		2249
		2250	return 0;
		2251	}
		2252
		2253	static void bxt_vtd_ggtt_insert_entries__BKL(struct i915_address_space *vm,
		2254	struct sg_table *st,
		2255	u64 start,
		2256	enum i915_cache_level level,
		2257	u32 unused)
		2258	{
		2259	struct insert_entries arg = { vm, st, start, level };
		2260
		2261	stop_machine(bxt_vtd_ggtt_insert_entries__cb, &arg, NULL);
		2262	}
		2263
		2264	struct clear_range {
		2265	struct i915_address_space *vm;
		2266	u64 start;
		2267	u64 length;
		2268	};
		2269
		2270	static int bxt_vtd_ggtt_clear_range__cb(void *_arg)
		2271	{
		2272	struct clear_range *arg = _arg;
		2273
		2274	gen8_ggtt_clear_range(arg->vm, arg->start, arg->length);
		2275	bxt_vtd_ggtt_wa(arg->vm);
		2276
		2277	return 0;
		2278	}
		2279
		2280	static void bxt_vtd_ggtt_clear_range__BKL(struct i915_address_space *vm,
		2281	u64 start,
		2282	u64 length)
		2283	{
		2284	struct clear_range arg = { vm, start, length };
		2285
		2286	stop_machine(bxt_vtd_ggtt_clear_range__cb, &arg, NULL);
		2287	}
		2288
2194	static void gen6_ggtt_clear_range(struct i915_address_space *vm,	2289	static void gen6_ggtt_clear_range(struct i915_address_space *vm,
2195	u64 start, u64 length)	2290	u64 start, u64 length)
2196	{	2291	{
@@ -2785,6 +2880,14 @@ static int gen8_gmch_probe(struct i915_ggtt *ggtt) · 588 unmodified lines
2785		2880
2786	ggtt->base.insert_entries = gen8_ggtt_insert_entries;	2881	ggtt->base.insert_entries = gen8_ggtt_insert_entries;
2787		2882
		2883	/* Serialize GTT updates with aperture access on BXT if VT-d is on. */
		2884	if (intel_ggtt_update_needs_vtd_wa(dev_priv)) {
		2885	ggtt->base.insert_entries = bxt_vtd_ggtt_insert_entries__BKL;
		2886	ggtt->base.insert_page = bxt_vtd_ggtt_insert_page__BKL;
		2887	if (ggtt->base.clear_range != nop_clear_range)
		2888	ggtt->base.clear_range = bxt_vtd_ggtt_clear_range__BKL;
		2889	}
		2890
2788	ggtt->invalidate = gen6_ggtt_invalidate;	2891	ggtt->invalidate = gen6_ggtt_invalidate;
2789		2892
2790	return ggtt_probe_common(ggtt, size);	2893	return ggtt_probe_common(ggtt, size);
@@ -2997,7 +3100,8 @@ void i915_ggtt_enable_guc(struct drm_i915_private *i915) · 206 unmodified lines
2997		3100
2998	void i915_ggtt_disable_guc(struct drm_i915_private *i915)	3101	void i915_ggtt_disable_guc(struct drm_i915_private *i915)
2999	{	3102	{
3000	i915->ggtt.invalidate = gen6_ggtt_invalidate;	3103	if (i915->ggtt.invalidate == guc_ggtt_invalidate)
		3104	i915->ggtt.invalidate = gen6_ggtt_invalidate;
3001	}	3105	}
3002		3106
3003	void i915_gem_restore_gtt_mappings(struct drm_i915_private *dev_priv)	3107	void i915_gem_restore_gtt_mappings(struct drm_i915_private *dev_priv)

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

@@ -278,7 +278,7 @@ i915_gem_object_set_tiling(struct drm_i915_gem_object *obj, · 277 unmodified lines
278	obj->mm.quirked = false;	278	obj->mm.quirked = false;
279	}	279	}
280	if (!i915_gem_object_is_tiled(obj)) {	280	if (!i915_gem_object_is_tiled(obj)) {
281	GEM_BUG_ON(!obj->mm.quirked);	281	GEM_BUG_ON(obj->mm.quirked);
282	__i915_gem_object_pin_pages(obj);	282	__i915_gem_object_pin_pages(obj);
283	obj->mm.quirked = true;	283	obj->mm.quirked = true;
284	}	284	}

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

 static const struct intel_device_info intel_ironlake_m_info = {
 	GEN5_FEATURES,
 	.platform = INTEL_IRONLAKE,
-	.is_mobile = 1,
+	.is_mobile = 1, .has_fbc = 1,
 };
 #define GEN6_FEATURES \
 	.has_hw_contexts = 1, \
 	.has_logical_ring_contexts = 1, \
 	.has_guc = 1, \
-	.has_decoupled_mmio = 1, \
 	.has_aliasing_ppgtt = 1, \
 	.has_full_ppgtt = 1, \
 	.has_full_48bit_ppgtt = 1, \

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

@@ -12203,6 +12203,15 @@ static void update_scanline_offset(struct intel_crtc *crtc) · 12202 unmodified lines
12203	* type. For DP ports it behaves like most other platforms, but on HDMI	12203	* type. For DP ports it behaves like most other platforms, but on HDMI
12204	* there's an extra 1 line difference. So we need to add two instead of	12204	* there's an extra 1 line difference. So we need to add two instead of
12205	* one to the value.	12205	* one to the value.
		12206	*
		12207	* On VLV/CHV DSI the scanline counter would appear to increment
		12208	* approx. 1/3 of a scanline before start of vblank. Unfortunately
		12209	* that means we can't tell whether we're in vblank or not while
		12210	* we're on that particular line. We must still set scanline_offset
		12211	* to 1 so that the vblank timestamps come out correct when we query
		12212	* the scanline counter from within the vblank interrupt handler.
		12213	* However if queried just before the start of vblank we'll get an
		12214	* answer that's slightly in the future.
12206	*/	12215	*/
12207	if (IS_GEN2(dev_priv)) {	12216	if (IS_GEN2(dev_priv)) {
12208	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;	12217	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;

drivers/gpu/drm/i915/intel_engine_cs.c+17−3

 	return 0;
 }
+static bool ring_is_idle(struct intel_engine_cs *engine)
+{
+	struct drm_i915_private *dev_priv = engine->i915;
+	bool idle = true;
+	intel_runtime_pm_get(dev_priv);
+	/* No bit for gen2, so assume the CS parser is idle */
+	if (INTEL_GEN(dev_priv) > 2 && !(I915_READ_MODE(engine) & MODE_IDLE))
+		idle = false;
+	intel_runtime_pm_put(dev_priv);
+	return idle;
+}
 /**
  * intel_engine_is_idle() - Report if the engine has finished process all work
  * @engine: the intel_engine_cs
  */
 bool intel_engine_is_idle(struct intel_engine_cs *engine)
 {
-	struct drm_i915_private *dev_priv = engine->i915;
 	/* Any inflight/incomplete requests? */
 	if (!i915_seqno_passed(intel_engine_get_seqno(engine),
 			       intel_engine_last_submit(engine)))
 		return false;
 	/* Ring stopped? */
-	if (INTEL_GEN(dev_priv) > 2 && !(I915_READ_MODE(engine) & MODE_IDLE))
+	if (!ring_is_idle(engine))
 		return false;
 	return true;

drivers/gpu/drm/i915/intel_fbc.c+7−12

 static void intel_fbc_get_plane_source_size(struct intel_fbc_state_cache *cache,
 					    int *width, int *height)
 {
-	int w, h;
-	if (drm_rotation_90_or_270(cache->plane.rotation)) {
-		w = cache->plane.src_h;
-		h = cache->plane.src_w;
-	} else {
-		w = cache->plane.src_w;
-		h = cache->plane.src_h;
-	}
 	if (width)
-		*width = w;
+		*width = cache->plane.src_w;
 	if (height)
-		*height = h;
+		*height = cache->plane.src_h;
 }
 static int intel_fbc_calculate_cfb_size(struct drm_i915_private *dev_priv,
 		cache->crtc.hsw_bdw_pixel_rate = crtc_state->pixel_rate;
 	cache->plane.rotation = plane_state->base.rotation;
+	/*
+	 * Src coordinates are already rotated by 270 degrees for
+	 * the 90/270 degree plane rotation cases (to match the
+	 * GTT mapping), hence no need to account for rotation here.
+	 */
 	cache->plane.src_w = drm_rect_width(&plane_state->base.src) >> 16;
 	cache->plane.src_h = drm_rect_height(&plane_state->base.src) >> 16;
 	cache->plane.visible = plane_state->base.visible;

drivers/gpu/drm/i915/intel_pm.c+9−0

 	struct drm_crtc_state *cstate;
 	struct intel_atomic_state *intel_state = to_intel_atomic_state(state);
 	struct skl_wm_values *results = &intel_state->wm_results;
+	struct drm_device *dev = state->dev;
 	struct skl_pipe_wm *pipe_wm;
 	bool changed = false;
 	int ret, i;
+	/*
+	 * When we distrust bios wm we always need to recompute to set the
+	 * expected DDB allocations for each CRTC.
+	 */
+	if (to_i915(dev)->wm.distrust_bios_wm)
+		changed = true;
 	/*
 	 * If this transaction isn't actually touching any CRTC's, don't
 	 * bother with watermark calculation.  Note that if we pass this
 	 */
 	for_each_new_crtc_in_state(state, crtc, cstate, i)
 		changed = true;
 	if (!changed)
 		return 0;

drivers/gpu/drm/i915/intel_psr.c+3−2

 	}
 	/* PSR2 is restricted to work with panel resolutions upto 3200x2000 */
-	if (intel_crtc->config->pipe_src_w > 3200 ||
+	if (dev_priv->psr.psr2_support &&
-				intel_crtc->config->pipe_src_h > 2000) {
+	    (intel_crtc->config->pipe_src_w > 3200 ||
+	     intel_crtc->config->pipe_src_h > 2000)) {
 		dev_priv->psr.psr2_support = false;
 		return false;
 	}

drivers/gpu/drm/i915/intel_sprite.c+21−0

@@ -83,10 +83,13 @@ int intel_usecs_to_scanlines(const struct drm_display_mode *adjusted_mode, · 82 unmodified lines
83	*/	83	*/
84	void intel_pipe_update_start(struct intel_crtc *crtc)	84	void intel_pipe_update_start(struct intel_crtc *crtc)
85	{	85	{
		86	struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
86	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;	87	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;
87	long timeout = msecs_to_jiffies_timeout(1);	88	long timeout = msecs_to_jiffies_timeout(1);
88	int scanline, min, max, vblank_start;	89	int scanline, min, max, vblank_start;
89	wait_queue_head_t *wq = drm_crtc_vblank_waitqueue(&crtc->base);	90	wait_queue_head_t *wq = drm_crtc_vblank_waitqueue(&crtc->base);
		91	bool need_vlv_dsi_wa = (IS_VALLEYVIEW(dev_priv) \|\| IS_CHERRYVIEW(dev_priv)) &&
		92	intel_crtc_has_type(crtc->config, INTEL_OUTPUT_DSI);
90	DEFINE_WAIT(wait);	93	DEFINE_WAIT(wait);
91		94
92	vblank_start = adjusted_mode->crtc_vblank_start;	95	vblank_start = adjusted_mode->crtc_vblank_start;
@@ -139,6 +142,24 @@ void intel_pipe_update_start(struct intel_crtc *crtc) · 46 unmodified lines
139		142
140	drm_crtc_vblank_put(&crtc->base);	143	drm_crtc_vblank_put(&crtc->base);
141		144
		145	/*
		146	* On VLV/CHV DSI the scanline counter would appear to
		147	* increment approx. 1/3 of a scanline before start of vblank.
		148	* The registers still get latched at start of vblank however.
		149	* This means we must not write any registers on the first
		150	* line of vblank (since not the whole line is actually in
		151	* vblank). And unfortunately we can't use the interrupt to
		152	* wait here since it will fire too soon. We could use the
		153	* frame start interrupt instead since it will fire after the
		154	* critical scanline, but that would require more changes
		155	* in the interrupt code. So for now we'll just do the nasty
		156	* thing and poll for the bad scanline to pass us by.
		157	*
		158	* FIXME figure out if BXT+ DSI suffers from this as well
		159	*/
		160	while (need_vlv_dsi_wa && scanline == vblank_start)
		161	scanline = intel_get_crtc_scanline(crtc);
		162
142	crtc->debug.scanline_start = scanline;	163	crtc->debug.scanline_start = scanline;
143	crtc->debug.start_vbl_time = ktime_get();	164	crtc->debug.start_vbl_time = ktime_get();
144	crtc->debug.start_vbl_count = intel_crtc_get_vblank_counter(crtc);	165	crtc->debug.start_vbl_count = intel_crtc_get_vblank_counter(crtc);

drivers/gpu/drm/i915/intel_uc.h+0−2

  *                available in the work queue (note, the queue is shared,
  *                not per-engine). It is OK for this to be nonzero, but
  *                it should not be huge!
- *   q_fail: failed to enqueue a work item. This should never happen,
- *           because we check for space beforehand.
  *   b_fail: failed to ring the doorbell. This should never happen, unless
  *           somehow the hardware misbehaves, or maybe if the GuC firmware
  *           crashes? We probably need to reset the GPU to recover.

drivers/gpu/drm/imx/imx-ldb.c+1−1

@@ -673,7 +673,7 @@ static int imx_ldb_bind(struct device dev, struct device master, void *data) · 672 unmodified lines
673	ret = drm_of_find_panel_or_bridge(child,	673	ret = drm_of_find_panel_or_bridge(child,
674	imx_ldb->lvds_mux ? 4 : 2, 0,	674	imx_ldb->lvds_mux ? 4 : 2, 0,
675	&channel->panel, &channel->bridge);	675	&channel->panel, &channel->bridge);
676	if (ret)	676	if (ret && ret != -ENODEV)
677	return ret;	677	return ret;
678		678
679	/* panel ddc only if there is no bridge */	679	/* panel ddc only if there is no bridge */

drivers/gpu/drm/mediatek/mtk_dsi.c+6−9

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <drm/drm_of.h>	19	#include <drm/drm_of.h>
20	#include <linux/clk.h>	20	#include <linux/clk.h>
21	#include <linux/component.h>	21	#include <linux/component.h>
		22	#include <linux/iopoll.h>
22	#include <linux/irq.h>	23	#include <linux/irq.h>
23	#include <linux/of.h>	24	#include <linux/of.h>
24	#include <linux/of_platform.h>	25	#include <linux/of_platform.h>
@@ -900,16 +901,12 @@ static int mtk_dsi_host_detach(struct mipi_dsi_host *host, · 875 unmodified lines
900		901
901	static void mtk_dsi_wait_for_idle(struct mtk_dsi *dsi)	902	static void mtk_dsi_wait_for_idle(struct mtk_dsi *dsi)
902	{	903	{
903	u32 timeout_ms = 500000; /* total 1s ~ 2s timeout */	904	int ret;
904		905	u32 val;
905	while (timeout_ms--) {
906	if (!(readl(dsi->regs + DSI_INTSTA) & DSI_BUSY))
907	break;
908
909	usleep_range(2, 4);
910	}
911		906
912	if (timeout_ms == 0) {	907	ret = readl_poll_timeout(dsi->regs + DSI_INTSTA, val, !(val & DSI_BUSY),
		908	4, 2000000);
		909	if (ret) {
913	DRM_WARN("polling dsi wait not busy timeout!\n");	910	DRM_WARN("polling dsi wait not busy timeout!\n");
914		911
915	mtk_dsi_enable(dsi);	912	mtk_dsi_enable(dsi);

drivers/gpu/drm/mediatek/mtk_hdmi.c+1−1

@@ -1062,7 +1062,7 @@ static int mtk_hdmi_setup_vendor_specific_infoframe(struct mtk_hdmi *hdmi, · 1061 unmodified lines
1062	}	1062	}
1063		1063
1064	err = hdmi_vendor_infoframe_pack(&frame, buffer, sizeof(buffer));	1064	err = hdmi_vendor_infoframe_pack(&frame, buffer, sizeof(buffer));
1065	if (err) {	1065	if (err < 0) {
1066	dev_err(hdmi->dev, "Failed to pack vendor infoframe: %zd\n",	1066	dev_err(hdmi->dev, "Failed to pack vendor infoframe: %zd\n",
1067	err);	1067	err);
1068	return err;	1068	return err;

drivers/gpu/drm/meson/meson_drv.c+15−5

 	.max_register   = 0x1000,
 };
-static int meson_drv_bind(struct device *dev)
+static int meson_drv_bind_master(struct device *dev, bool has_components)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct meson_drm *priv;
 	if (ret)
 		goto free_drm;
-	ret = component_bind_all(drm->dev, drm);
+	if (has_components) {
-	if (ret) {
+		ret = component_bind_all(drm->dev, drm);
-		dev_err(drm->dev, "Couldn't bind all components\n");
+		if (ret) {
-		goto free_drm;
+			dev_err(drm->dev, "Couldn't bind all components\n");
+			goto free_drm;
+		}
 	}
 	ret = meson_plane_create(priv);
 	return ret;
 }
+static int meson_drv_bind(struct device *dev)
+{
+	return meson_drv_bind_master(dev, true);
+}
 static void meson_drv_unbind(struct device *dev)
 {
 	struct drm_device *drm = dev_get_drvdata(dev);
 		count += meson_probe_remote(pdev, &match, np, remote);
 	}
+	if (count && !match)
+		return meson_drv_bind_master(&pdev->dev, false);
 	/* If some endpoints were found, initialize the nodes */
 	if (count) {
 		dev_info(&pdev->dev, "Queued %d outputs on vpu\n", count);

drivers/gpu/drm/nouveau/include/nvkm/subdev/timer.h+1−0

@@ -4,6 +4,7 @@ · 3 unmodified lines
4		4
5	struct nvkm_alarm {	5	struct nvkm_alarm {
6	struct list_head head;	6	struct list_head head;
		7	struct list_head exec;
7	u64 timestamp;	8	u64 timestamp;
8	void (func)(struct nvkm_alarm );	9	void (func)(struct nvkm_alarm );
9	};	10	};

drivers/gpu/drm/nouveau/nouveau_drm.c+17−21

 module_param_named(modeset, nouveau_modeset, int, 0400);
 MODULE_PARM_DESC(runpm, "disable (0), force enable (1), optimus only default (-1)");
-int nouveau_runtime_pm = -1;
+static int nouveau_runtime_pm = -1;
 module_param_named(runpm, nouveau_runtime_pm, int, 0400);
 static struct drm_driver driver_stub;
 	nouveau_fbcon_init(dev);
 	nouveau_led_init(dev);
-	if (nouveau_runtime_pm != 0) {
+	if (nouveau_pmops_runtime()) {
 		pm_runtime_use_autosuspend(dev->dev);
 		pm_runtime_set_autosuspend_delay(dev->dev, 5000);
 		pm_runtime_set_active(dev->dev);
 {
 	struct nouveau_drm *drm = nouveau_drm(dev);
-	if (nouveau_runtime_pm != 0) {
+	if (nouveau_pmops_runtime()) {
 		pm_runtime_get_sync(dev->dev);
 		pm_runtime_forbid(dev->dev);
 	}
 	return nouveau_do_resume(drm_dev, false);
 }
+bool
+nouveau_pmops_runtime()
+{
+	if (nouveau_runtime_pm == -1)
+		return nouveau_is_optimus() || nouveau_is_v1_dsm();
+	return nouveau_runtime_pm == 1;
+}
 static int
 nouveau_pmops_runtime_suspend(struct device *dev)
 {
 	struct drm_device *drm_dev = pci_get_drvdata(pdev);
 	int ret;
-	if (nouveau_runtime_pm == 0) {
+	if (!nouveau_pmops_runtime()) {
-		pm_runtime_forbid(dev);
-		return -EBUSY;
-	}
-	/* are we optimus enabled? */
-	if (nouveau_runtime_pm == -1 && !nouveau_is_optimus() && !nouveau_is_v1_dsm()) {
-		DRM_DEBUG_DRIVER("failing to power off - not optimus\n");
 		pm_runtime_forbid(dev);
 		return -EBUSY;
 	}
 	struct nvif_device *device = &nouveau_drm(drm_dev)->client.device;
 	int ret;
-	if (nouveau_runtime_pm == 0)
+	if (!nouveau_pmops_runtime()) {
-		return -EINVAL;
+		pm_runtime_forbid(dev);
+		return -EBUSY;
+	}
 	pci_set_power_state(pdev, PCI_D0);
 	pci_restore_state(pdev);
 	struct nouveau_drm *drm = nouveau_drm(drm_dev);
 	struct drm_crtc *crtc;
-	if (nouveau_runtime_pm == 0) {
+	if (!nouveau_pmops_runtime()) {
-		pm_runtime_forbid(dev);
-		return -EBUSY;
-	}
-	/* are we optimus enabled? */
-	if (nouveau_runtime_pm == -1 && !nouveau_is_optimus() && !nouveau_is_v1_dsm()) {
-		DRM_DEBUG_DRIVER("failing to power off - not optimus\n");
 		pm_runtime_forbid(dev);
 		return -EBUSY;
 	}

drivers/gpu/drm/nouveau/nouveau_drv.h+1−2

 #include <nvif/object.h>
 #include <nvif/device.h>
-extern int nouveau_runtime_pm;
 struct nouveau_drm {
 	struct nouveau_cli client;
 	struct drm_device *dev;
 int nouveau_pmops_suspend(struct device *);
 int nouveau_pmops_resume(struct device *);
+bool nouveau_pmops_runtime(void);
 #include <nvkm/core/tegra.h>

drivers/gpu/drm/nouveau/nouveau_vga.c+2−11

 nouveau_vga_init(struct nouveau_drm *drm)
 {
 	struct drm_device *dev = drm->dev;
-	bool runtime = false;
+	bool runtime = nouveau_pmops_runtime();
 	/* only relevant for PCI devices */
 	if (!dev->pdev)
 	if (pci_is_thunderbolt_attached(dev->pdev))
 		return;
-	if (nouveau_runtime_pm == 1)
-		runtime = true;
-	if ((nouveau_runtime_pm == -1) && (nouveau_is_optimus() || nouveau_is_v1_dsm()))
-		runtime = true;
 	vga_switcheroo_register_client(dev->pdev, &nouveau_switcheroo_ops, runtime);
 	if (runtime && nouveau_is_v1_dsm() && !nouveau_is_optimus())
 nouveau_vga_fini(struct nouveau_drm *drm)
 {
 	struct drm_device *dev = drm->dev;
-	bool runtime = false;
+	bool runtime = nouveau_pmops_runtime();
 	vga_client_register(dev->pdev, NULL, NULL, NULL);
 	if (pci_is_thunderbolt_attached(dev->pdev))
 		return;
-	if (nouveau_runtime_pm == 1)
-		runtime = true;
-	if ((nouveau_runtime_pm == -1) && (nouveau_is_optimus() || nouveau_is_v1_dsm()))
-		runtime = true;
 	vga_switcheroo_unregister_client(dev->pdev);
 	if (runtime && nouveau_is_v1_dsm() && !nouveau_is_optimus())
 		vga_switcheroo_fini_domain_pm_ops(drm->dev->dev);

drivers/gpu/drm/nouveau/nv50_display.c+2−1

@@ -2107,7 +2107,8 @@ nv50_head_atomic_check(struct drm_crtc crtc, struct drm_crtc_state state) · 2106 unmodified lines
2107	asyc->set.dither = true;	2107	asyc->set.dither = true;
2108	}	2108	}
2109	} else {	2109	} else {
2110	asyc->set.mask = ~0;	2110	if (asyc)
		2111	asyc->set.mask = ~0;
2111	asyh->set.mask = ~0;	2112	asyh->set.mask = ~0;
2112	}	2113	}
2113		2114

drivers/gpu/drm/nouveau/nvkm/subdev/timer/base.c+4−3

 		/* Move to completed list.  We'll drop the lock before
 		 * executing the callback so it can reschedule itself.
 		 */
-		list_move_tail(&alarm->head, &exec);
+		list_del_init(&alarm->head);
+		list_add(&alarm->exec, &exec);
 	}
 	/* Shut down interrupt if no more pending alarms. */
 	spin_unlock_irqrestore(&tmr->lock, flags);
 	/* Execute completed callbacks. */
-	list_for_each_entry_safe(alarm, atemp, &exec, head) {
+	list_for_each_entry_safe(alarm, atemp, &exec, exec) {
-		list_del_init(&alarm->head);
+		list_del(&alarm->exec);
 		alarm->func(alarm);
 	}
 }

drivers/gpu/drm/rockchip/analogix_dp-rockchip.c+0−12

 				      struct drm_connector_state *conn_state)
 {
 	struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state);
-	struct rockchip_dp_device *dp = to_dp(encoder);
-	int ret;
 	/*
 	 * The hardware IC designed that VOP must output the RGB10 video
 	s->output_mode = ROCKCHIP_OUT_MODE_AAAA;
 	s->output_type = DRM_MODE_CONNECTOR_eDP;
-	if (dp->data->chip_type == RK3399_EDP) {
-		/*
-		 * For RK3399, VOP Lit must code the out mode to RGB888,
-		 * VOP Big must code the out mode to RGB10.
-		 */
-		ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node,
-							encoder);
-		if (ret > 0)
-			s->output_mode = ROCKCHIP_OUT_MODE_P888;
-	}
 	return 0;
 }

drivers/gpu/drm/rockchip/cdn-dp-core.c+2−7

 {
 	struct cdn_dp_device *dp = encoder_to_dp(encoder);
 	int ret, val;
-	struct rockchip_crtc_state *state;
 	ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder);
 	if (ret < 0) {
 	DRM_DEV_DEBUG_KMS(dp->dev, "vop %s output to cdn-dp\n",
 			  (ret) ? "LIT" : "BIG");
-	state = to_rockchip_crtc_state(encoder->crtc->state);
+	if (ret)
-	if (ret) {
 		val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16);
-		state->output_mode = ROCKCHIP_OUT_MODE_P888;
+	else
-	} else {
 		val = DP_SEL_VOP_LIT << 16;
-		state->output_mode = ROCKCHIP_OUT_MODE_AAAA;
-	}
 	ret = cdn_dp_grf_write(dp, GRF_SOC_CON9, val);
 	if (ret)

drivers/gpu/drm/rockchip/rockchip_drm_vop.c+8−0

 static void vop_crtc_enable(struct drm_crtc *crtc)
 {
 	struct vop *vop = to_vop(crtc);
+	const struct vop_data *vop_data = vop->data;
 	struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc->state);
 	struct drm_display_mode *adjusted_mode = &crtc->state->adjusted_mode;
 	u16 hsync_len = adjusted_mode->hsync_end - adjusted_mode->hsync_start;
 		DRM_DEV_ERROR(vop->dev, "unsupported connector_type [%d]\n",
 			      s->output_type);
 	}
+	/*
+	 * if vop is not support RGB10 output, need force RGB10 to RGB888.
+	 */
+	if (s->output_mode == ROCKCHIP_OUT_MODE_AAAA &&
+	    !(vop_data->feature & VOP_FEATURE_OUTPUT_RGB10))
+		s->output_mode = ROCKCHIP_OUT_MODE_P888;
 	VOP_CTRL_SET(vop, out_mode, s->output_mode);
 	VOP_CTRL_SET(vop, htotal_pw, (htotal << 16) | hsync_len);

drivers/gpu/drm/rockchip/rockchip_drm_vop.h+3−0

@@ -142,6 +142,9 @@ struct vop_data { · 141 unmodified lines
142	const struct vop_intr *intr;	142	const struct vop_intr *intr;
143	const struct vop_win_data *win;	143	const struct vop_win_data *win;
144	unsigned int win_size;	144	unsigned int win_size;
		145
		146	#define VOP_FEATURE_OUTPUT_RGB10 BIT(0)
		147	u64 feature;
145	};	148	};
146		149
147	/* interrupt define */	150	/* interrupt define */

drivers/gpu/drm/rockchip/rockchip_vop_reg.c+2−0

 static const struct vop_data rk3288_vop = {
 	.init_table = rk3288_init_reg_table,
 	.table_size = ARRAY_SIZE(rk3288_init_reg_table),
+	.feature = VOP_FEATURE_OUTPUT_RGB10,
 	.intr = &rk3288_vop_intr,
 	.ctrl = &rk3288_ctrl_data,
 	.win = rk3288_vop_win_data,
 static const struct vop_data rk3399_vop_big = {
 	.init_table = rk3399_init_reg_table,
 	.table_size = ARRAY_SIZE(rk3399_init_reg_table),
+	.feature = VOP_FEATURE_OUTPUT_RGB10,
 	.intr = &rk3399_vop_intr,
 	.ctrl = &rk3399_ctrl_data,
 	/*

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h+2−2

@@ -41,9 +41,9 @@ · 40 unmodified lines
41	#include <drm/ttm/ttm_module.h>	41	#include <drm/ttm/ttm_module.h>
42	#include "vmwgfx_fence.h"	42	#include "vmwgfx_fence.h"
43		43
44	#define VMWGFX_DRIVER_DATE "20170221"	44	#define VMWGFX_DRIVER_DATE "20170607"
45	#define VMWGFX_DRIVER_MAJOR 2	45	#define VMWGFX_DRIVER_MAJOR 2
46	#define VMWGFX_DRIVER_MINOR 12	46	#define VMWGFX_DRIVER_MINOR 13
47	#define VMWGFX_DRIVER_PATCHLEVEL 0	47	#define VMWGFX_DRIVER_PATCHLEVEL 0
48	#define VMWGFX_FILE_PAGE_OFFSET 0x00100000	48	#define VMWGFX_FILE_PAGE_OFFSET 0x00100000
49	#define VMWGFX_FIFO_STATIC_SIZE (1024*1024)	49	#define VMWGFX_FIFO_STATIC_SIZE (1024*1024)

drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c+2−0

 				return fifo_state->static_buffer;
 			else {
 				fifo_state->dynamic_buffer = vmalloc(bytes);
+				if (!fifo_state->dynamic_buffer)
+					goto out_err;
 				return fifo_state->dynamic_buffer;
 			}
 		}

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c+1−114

@@ -274,108 +274,6 @@ void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv) · 273 unmodified lines
274	}	274	}
275		275
276		276
277
278	/**
279	* vmw_du_cursor_plane_update() - Update cursor image and location
280	*
281	* @plane: plane object to update
282	* @crtc: owning CRTC of @plane
283	* @fb: framebuffer to flip onto plane
284	* @crtc_x: x offset of plane on crtc
285	* @crtc_y: y offset of plane on crtc
286	* @crtc_w: width of plane rectangle on crtc
287	* @crtc_h: height of plane rectangle on crtc
288	* @src_x: Not used
289	* @src_y: Not used
290	* @src_w: Not used
291	* @src_h: Not used
292	*
293	*
294	* RETURNS:
295	* Zero on success, error code on failure
296	*/
297	int vmw_du_cursor_plane_update(struct drm_plane *plane,
298	struct drm_crtc *crtc,
299	struct drm_framebuffer *fb,
300	int crtc_x, int crtc_y,
301	unsigned int crtc_w,
302	unsigned int crtc_h,
303	uint32_t src_x, uint32_t src_y,
304	uint32_t src_w, uint32_t src_h)
305	{
306	struct vmw_private *dev_priv = vmw_priv(crtc->dev);
307	struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
308	struct vmw_surface *surface = NULL;
309	struct vmw_dma_buffer *dmabuf = NULL;
310	s32 hotspot_x, hotspot_y;
311	int ret;
312
313	hotspot_x = du->hotspot_x + fb->hot_x;
314	hotspot_y = du->hotspot_y + fb->hot_y;
315
316	/* A lot of the code assumes this */
317	if (crtc_w != 64 \|\| crtc_h != 64) {
318	ret = -EINVAL;
319	goto out;
320	}
321
322	if (vmw_framebuffer_to_vfb(fb)->dmabuf)
323	dmabuf = vmw_framebuffer_to_vfbd(fb)->buffer;
324	else
325	surface = vmw_framebuffer_to_vfbs(fb)->surface;
326
327	if (surface && !surface->snooper.image) {
328	DRM_ERROR("surface not suitable for cursor\n");
329	ret = -EINVAL;
330	goto out;
331	}
332
333	/* setup new image */
334	ret = 0;
335	if (surface) {
336	/* vmw_user_surface_lookup takes one reference */
337	du->cursor_surface = surface;
338
339	du->cursor_age = du->cursor_surface->snooper.age;
340
341	ret = vmw_cursor_update_image(dev_priv, surface->snooper.image,
342	64, 64, hotspot_x, hotspot_y);
343	} else if (dmabuf) {
344	/* vmw_user_surface_lookup takes one reference */
345	du->cursor_dmabuf = dmabuf;
346
347	ret = vmw_cursor_update_dmabuf(dev_priv, dmabuf, crtc_w, crtc_h,
348	hotspot_x, hotspot_y);
349	} else {
350	vmw_cursor_update_position(dev_priv, false, 0, 0);
351	goto out;
352	}
353
354	if (!ret) {
355	du->cursor_x = crtc_x + du->set_gui_x;
356	du->cursor_y = crtc_y + du->set_gui_y;
357
358	vmw_cursor_update_position(dev_priv, true,
359	du->cursor_x + hotspot_x,
360	du->cursor_y + hotspot_y);
361	}
362
363	out:
364	return ret;
365	}
366
367
368	int vmw_du_cursor_plane_disable(struct drm_plane *plane)
369	{
370	if (plane->fb) {
371	drm_framebuffer_unreference(plane->fb);
372	plane->fb = NULL;
373	}
374
375	return -EINVAL;
376	}
377
378
379	void vmw_du_cursor_plane_destroy(struct drm_plane *plane)	277	void vmw_du_cursor_plane_destroy(struct drm_plane *plane)
380	{	278	{
381	vmw_cursor_update_position(plane->dev->dev_private, false, 0, 0);	279	vmw_cursor_update_position(plane->dev->dev_private, false, 0, 0);
@@ -472,18 +370,6 @@ vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane, · 90 unmodified lines
472	}	370	}
473		371
474		372
475	void
476	vmw_du_cursor_plane_atomic_disable(struct drm_plane *plane,
477	struct drm_plane_state *old_state)
478	{
479	struct drm_crtc *crtc = plane->state->crtc ?: old_state->crtc;
480	struct vmw_private *dev_priv = vmw_priv(crtc->dev);
481
482	drm_atomic_set_fb_for_plane(plane->state, NULL);
483	vmw_cursor_update_position(dev_priv, false, 0, 0);
484	}
485
486
487	void	373	void
488	vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,	374	vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,
489	struct drm_plane_state *old_state)	375	struct drm_plane_state *old_state)
@@ -1498,6 +1384,7 @@ vmw_kms_new_framebuffer(struct vmw_private *dev_priv, · 1008 unmodified lines
1498	*/	1384	*/
1499	if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height) &&	1385	if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height) &&
1500	dmabuf && only_2d &&	1386	dmabuf && only_2d &&
		1387	mode_cmd->width > 64 && /* Don't create a proxy for cursor */
1501	dev_priv->active_display_unit == vmw_du_screen_target) {	1388	dev_priv->active_display_unit == vmw_du_screen_target) {
1502	ret = vmw_create_dmabuf_proxy(dev_priv->dev, mode_cmd,	1389	ret = vmw_create_dmabuf_proxy(dev_priv->dev, mode_cmd,
1503	dmabuf, &surface);	1390	dmabuf, &surface);

drivers/gpu/drm/vmwgfx/vmwgfx_kms.h+0−15

 			   u16 *r, u16 *g, u16 *b,
 			   uint32_t size,
 			   struct drm_modeset_acquire_ctx *ctx);
-int vmw_du_crtc_cursor_set2(struct drm_crtc *crtc, struct drm_file *file_priv,
-			    uint32_t handle, uint32_t width, uint32_t height,
-			    int32_t hot_x, int32_t hot_y);
-int vmw_du_crtc_cursor_move(struct drm_crtc *crtc, int x, int y);
 int vmw_du_connector_set_property(struct drm_connector *connector,
 				  struct drm_property *property,
 				  uint64_t val);
 /* Universal Plane Helpers */
 void vmw_du_primary_plane_destroy(struct drm_plane *plane);
 void vmw_du_cursor_plane_destroy(struct drm_plane *plane);
-int vmw_du_cursor_plane_disable(struct drm_plane *plane);
-int vmw_du_cursor_plane_update(struct drm_plane *plane,
-			       struct drm_crtc *crtc,
-			       struct drm_framebuffer *fb,
-			       int crtc_x, int crtc_y,
-			       unsigned int crtc_w,
-			       unsigned int crtc_h,
-			       uint32_t src_x, uint32_t src_y,
-			       uint32_t src_w, uint32_t src_h);
 /* Atomic Helpers */
 int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
 				     struct drm_plane_state *state);
 void vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,
 				       struct drm_plane_state *old_state);
-void vmw_du_cursor_plane_atomic_disable(struct drm_plane *plane,
-					struct drm_plane_state *old_state);
 int vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane,
 				   struct drm_plane_state *new_state);
 void vmw_du_plane_cleanup_fb(struct drm_plane *plane,

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c+22−5

  * @right: Right side of bounding box.
  * @top: Top side of bounding box.
  * @bottom: Bottom side of bounding box.
+ * @fb_left: Left side of the framebuffer/content bounding box
+ * @fb_top: Top of the framebuffer/content bounding box
  * @buf: DMA buffer when DMA-ing between buffer and screen targets.
  * @sid: Surface ID when copying between surface and screen targets.
  */
 	struct vmw_kms_dirty base;
 	SVGA3dTransferType  transfer;
 	s32 left, right, top, bottom;
+	s32 fb_left, fb_top;
 	u32 pitch;
 	union {
 		struct vmw_dma_buffer *buf;
  *
  * @dirty: The closure structure.
  *
- * This function calculates the bounding box for all the incoming clips
+ * This function calculates the bounding box for all the incoming clips.
  */
 static void vmw_stdu_dmabuf_cpu_clip(struct vmw_kms_dirty *dirty)
 {
 	dirty->num_hits = 1;
-	/* Calculate bounding box */
+	/* Calculate destination bounding box */
 	ddirty->left = min_t(s32, ddirty->left, dirty->unit_x1);
 	ddirty->top = min_t(s32, ddirty->top, dirty->unit_y1);
 	ddirty->right = max_t(s32, ddirty->right, dirty->unit_x2);
 	ddirty->bottom = max_t(s32, ddirty->bottom, dirty->unit_y2);
+	/*
+	 * Calculate content bounding box.  We only need the top-left
+	 * coordinate because width and height will be the same as the
+	 * destination bounding box above
+	 */
+	ddirty->fb_left = min_t(s32, ddirty->fb_left, dirty->fb_x);
+	ddirty->fb_top  = min_t(s32, ddirty->fb_top, dirty->fb_y);
 }
 	/* Assume we are blitting from Host (display_srf) to Guest (dmabuf) */
 	src_pitch = stdu->display_srf->base_size.width * stdu->cpp;
 	src = ttm_kmap_obj_virtual(&stdu->host_map, &not_used);
-	src += dirty->unit_y1 * src_pitch + dirty->unit_x1 * stdu->cpp;
+	src += ddirty->top * src_pitch + ddirty->left * stdu->cpp;
 	dst_pitch = ddirty->pitch;
 	dst = ttm_kmap_obj_virtual(&stdu->guest_map, &not_used);
-	dst += dirty->fb_y * dst_pitch + dirty->fb_x * stdu->cpp;
+	dst += ddirty->fb_top * dst_pitch + ddirty->fb_left * stdu->cpp;
 	/* Figure out the real direction */
 	}
 out_cleanup:
-	ddirty->left = ddirty->top = S32_MAX;
+	ddirty->left = ddirty->top = ddirty->fb_left = ddirty->fb_top = S32_MAX;
 	ddirty->right = ddirty->bottom = S32_MIN;
 }
 		SVGA3D_READ_HOST_VRAM;
 	ddirty.left = ddirty.top = S32_MAX;
 	ddirty.right = ddirty.bottom = S32_MIN;
+	ddirty.fb_left = ddirty.fb_top = S32_MAX;
 	ddirty.pitch = vfb->base.pitches[0];
 	ddirty.buf = buf;
 	ddirty.base.fifo_commit = vmw_stdu_dmabuf_fifo_commit;
 		DRM_ERROR("Failed to bind surface to STDU.\n");
 	else
 		crtc->primary->fb = plane->state->fb;
+	ret = vmw_stdu_update_st(dev_priv, stdu);
+	if (ret)
+		DRM_ERROR("Failed to update STDU.\n");
 }

drivers/gpu/drm/vmwgfx/vmwgfx_surface.c+15−8

 	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 	int ret;
 	uint32_t size;
-	uint32_t backup_handle;
+	uint32_t backup_handle = 0;
 	if (req->multisample_count != 0)
 		return -EINVAL;
+	if (req->mip_levels > DRM_VMW_MAX_MIP_LEVELS)
+		return -EINVAL;
 	if (unlikely(vmw_user_surface_size == 0))
 		vmw_user_surface_size = ttm_round_pot(sizeof(*user_srf)) +
 			128;
 		ret = vmw_user_dmabuf_lookup(tfile, req->buffer_handle,
 					     &res->backup,
 					     &user_srf->backup_base);
-		if (ret == 0 && res->backup->base.num_pages * PAGE_SIZE <
+		if (ret == 0) {
-		    res->backup_size) {
+			if (res->backup->base.num_pages * PAGE_SIZE <
-			DRM_ERROR("Surface backup buffer is too small.\n");
+			    res->backup_size) {
-			vmw_dmabuf_unreference(&res->backup);
+				DRM_ERROR("Surface backup buffer is too small.\n");
-			ret = -EINVAL;
+				vmw_dmabuf_unreference(&res->backup);
-			goto out_unlock;
+				ret = -EINVAL;
+				goto out_unlock;
+			} else {
+				backup_handle = req->buffer_handle;
+			}
 		}
 	} else if (req->drm_surface_flags & drm_vmw_surface_flag_create_buffer)
 		ret = vmw_user_dmabuf_alloc(dev_priv, tfile,
 				 dev_priv->stdu_max_height);
 		if (size.width > max_width || size.height > max_height) {
-			DRM_ERROR("%ux%u\n, exeeds max surface size %ux%u",
+			DRM_ERROR("%ux%u\n, exceeds max surface size %ux%u",
 				  size.width, size.height,
 				  max_width, max_height);
 			return -EINVAL;

drivers/gpu/ipu-v3/ipu-common.c+8−7

@@ -725,15 +725,16 @@ void ipu_set_ic_src_mux(struct ipu_soc *ipu, int csi_id, bool vdi) · 724 unmodified lines
725	spin_lock_irqsave(&ipu->lock, flags);	725	spin_lock_irqsave(&ipu->lock, flags);
726		726
727	val = ipu_cm_read(ipu, IPU_CONF);	727	val = ipu_cm_read(ipu, IPU_CONF);
728	if (vdi) {	728	if (vdi)
729	val \|= IPU_CONF_IC_INPUT;	729	val \|= IPU_CONF_IC_INPUT;
730	} else {	730	else
731	val &= ~IPU_CONF_IC_INPUT;	731	val &= ~IPU_CONF_IC_INPUT;
732	if (csi_id == 1)	732
733	val \|= IPU_CONF_CSI_SEL;	733	if (csi_id == 1)
734	else	734	val \|= IPU_CONF_CSI_SEL;
735	val &= ~IPU_CONF_CSI_SEL;	735	else
736	}	736	val &= ~IPU_CONF_CSI_SEL;
		737
737	ipu_cm_write(ipu, val, IPU_CONF);	738	ipu_cm_write(ipu, val, IPU_CONF);
738		739
739	spin_unlock_irqrestore(&ipu->lock, flags);	740	spin_unlock_irqrestore(&ipu->lock, flags);

drivers/gpu/ipu-v3/ipu-pre.c+5−8

 	if (pre->in_use)
 		return -EBUSY;
-	clk_prepare_enable(pre->clk_axi);
 	/* first get the engine out of reset and remove clock gating */
 	writel(0, pre->regs + IPU_PRE_CTRL);
 void ipu_pre_put(struct ipu_pre *pre)
 {
-	u32 val;
+	writel(IPU_PRE_CTRL_SFTRST, pre->regs + IPU_PRE_CTRL);
-	val = IPU_PRE_CTRL_SFTRST | IPU_PRE_CTRL_CLKGATE;
-	writel(val, pre->regs + IPU_PRE_CTRL);
-	clk_disable_unprepare(pre->clk_axi);
 	pre->in_use = false;
 }
 	if (!pre->buffer_virt)
 		return -ENOMEM;
+	clk_prepare_enable(pre->clk_axi);
 	pre->dev = dev;
 	platform_set_drvdata(pdev, pre);
 	mutex_lock(&ipu_pre_list_mutex);
 	available_pres--;
 	mutex_unlock(&ipu_pre_list_mutex);
+	clk_disable_unprepare(pre->clk_axi);
 	if (pre->buffer_virt)
 		gen_pool_free(pre->iram, (unsigned long)pre->buffer_virt,
 			      IPU_PRE_MAX_WIDTH * IPU_PRE_NUM_SCANLINES * 4);

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

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

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

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

drivers/iio/adc/bcm_iproc_adc.c+4−4

 	iproc_adc_dbg_reg(dev, adc_priv, IPROC_SOFT_BYPASS_DATA);
 }
-static irqreturn_t iproc_adc_interrupt_handler(int irq, void *data)
+static irqreturn_t iproc_adc_interrupt_thread(int irq, void *data)
 {
 	u32 channel_intr_status;
 	u32 intr_status;
 	return IRQ_NONE;
 }
-static irqreturn_t iproc_adc_interrupt_thread(int irq, void *data)
+static irqreturn_t iproc_adc_interrupt_handler(int irq, void *data)
 {
 	irqreturn_t retval = IRQ_NONE;
 	struct iproc_adc_priv *adc_priv;
 	adc_priv = iio_priv(indio_dev);
 	regmap_read(adc_priv->regmap, IPROC_INTERRUPT_STATUS, &intr_status);
-	dev_dbg(&indio_dev->dev, "iproc_adc_interrupt_thread(),INTRPT_STS:%x\n",
+	dev_dbg(&indio_dev->dev, "iproc_adc_interrupt_handler(),INTRPT_STS:%x\n",
 			intr_status);
 	intr_channels = (intr_status & IPROC_ADC_INTR_MASK) >> IPROC_ADC_INTR;
 	}
 	ret = devm_request_threaded_irq(&pdev->dev, adc_priv->irqno,
-				iproc_adc_interrupt_thread,
 				iproc_adc_interrupt_handler,
+				iproc_adc_interrupt_thread,
 				IRQF_SHARED, "iproc-adc", indio_dev);
 	if (ret) {
 		dev_err(&pdev->dev, "request_irq error %d\n", ret);

drivers/iio/adc/max9611.c+5−5

@@ -438,10 +438,10 @@ static ssize_t max9611_shunt_resistor_show(struct device *dev, · 437 unmodified lines
438	struct max9611_dev *max9611 = iio_priv(dev_to_iio_dev(dev));	438	struct max9611_dev *max9611 = iio_priv(dev_to_iio_dev(dev));
439	unsigned int i, r;	439	unsigned int i, r;
440		440
441	i = max9611->shunt_resistor_uohm / 1000;	441	i = max9611->shunt_resistor_uohm / 1000000;
442	r = max9611->shunt_resistor_uohm % 1000;	442	r = max9611->shunt_resistor_uohm % 1000000;
443		443
444	return sprintf(buf, "%u.%03u\n", i, r);	444	return sprintf(buf, "%u.%06u\n", i, r);
445	}	445	}
446		446
447	static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444,	447	static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444,
@@ -536,8 +536,8 @@ static int max9611_probe(struct i2c_client *client, · 88 unmodified lines
536	int ret;	536	int ret;
537		537
538	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*max9611));	538	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*max9611));
539	if (IS_ERR(indio_dev))	539	if (!indio_dev)
540	return PTR_ERR(indio_dev);	540	return -ENOMEM;
541		541
542	i2c_set_clientdata(client, indio_dev);	542	i2c_set_clientdata(client, indio_dev);
543		543

drivers/iio/adc/sun4i-gpadc-iio.c+24−14

@@ -105,6 +105,8 @@ struct sun4i_gpadc_iio { · 104 unmodified lines
105	bool no_irq;	105	bool no_irq;
106	/* prevents concurrent reads of temperature and ADC */	106	/* prevents concurrent reads of temperature and ADC */
107	struct mutex mutex;	107	struct mutex mutex;
		108	struct thermal_zone_device *tzd;
		109	struct device *sensor_device;
108	};	110	};
109		111
110	#define SUN4I_GPADC_ADC_CHANNEL(_channel, _name) { \	112	#define SUN4I_GPADC_ADC_CHANNEL(_channel, _name) { \
@@ -502,7 +504,6 @@ static int sun4i_gpadc_probe_dt(struct platform_device *pdev, · 391 unmodified lines
502	{	504	{
503	struct sun4i_gpadc_iio *info = iio_priv(indio_dev);	505	struct sun4i_gpadc_iio *info = iio_priv(indio_dev);
504	const struct of_device_id *of_dev;	506	const struct of_device_id *of_dev;
505	struct thermal_zone_device *tzd;
506	struct resource *mem;	507	struct resource *mem;
507	void __iomem *base;	508	void __iomem *base;
508	int ret;	509	int ret;
@@ -532,13 +533,14 @@ static int sun4i_gpadc_probe_dt(struct platform_device *pdev, · 23 unmodified lines
532	if (!IS_ENABLED(CONFIG_THERMAL_OF))	533	if (!IS_ENABLED(CONFIG_THERMAL_OF))
533	return 0;	534	return 0;
534		535
535	tzd = devm_thermal_zone_of_sensor_register(&pdev->dev, 0, info,	536	info->sensor_device = &pdev->dev;
536	&sun4i_ts_tz_ops);	537	info->tzd = thermal_zone_of_sensor_register(info->sensor_device, 0,
537	if (IS_ERR(tzd))	538	info, &sun4i_ts_tz_ops);
		539	if (IS_ERR(info->tzd))
538	dev_err(&pdev->dev, "could not register thermal sensor: %ld\n",	540	dev_err(&pdev->dev, "could not register thermal sensor: %ld\n",
539	PTR_ERR(tzd));	541	PTR_ERR(info->tzd));
540		542
541	return PTR_ERR_OR_ZERO(tzd);	543	return PTR_ERR_OR_ZERO(info->tzd);
542	}	544	}
543		545
544	static int sun4i_gpadc_probe_mfd(struct platform_device *pdev,	546	static int sun4i_gpadc_probe_mfd(struct platform_device *pdev,
@@ -584,15 +586,15 @@ static int sun4i_gpadc_probe_mfd(struct platform_device *pdev, · 39 unmodified lines
584	* of_node, and the device from this driver as third argument to	586	* of_node, and the device from this driver as third argument to
585	* return the temperature.	587	* return the temperature.
586	*/	588	*/
587	struct thermal_zone_device *tzd;	589	info->sensor_device = pdev->dev.parent;
588	tzd = devm_thermal_zone_of_sensor_register(pdev->dev.parent, 0,	590	info->tzd = thermal_zone_of_sensor_register(info->sensor_device,
589	info,	591	0, info,
590	&sun4i_ts_tz_ops);	592	&sun4i_ts_tz_ops);
591	if (IS_ERR(tzd)) {	593	if (IS_ERR(info->tzd)) {
592	dev_err(&pdev->dev,	594	dev_err(&pdev->dev,
593	"could not register thermal sensor: %ld\n",	595	"could not register thermal sensor: %ld\n",
594	PTR_ERR(tzd));	596	PTR_ERR(info->tzd));
595	return PTR_ERR(tzd);	597	return PTR_ERR(info->tzd);
596	}	598	}
597	} else {	599	} else {
598	indio_dev->num_channels =	600	indio_dev->num_channels =
@@ -688,7 +690,13 @@ static int sun4i_gpadc_remove(struct platform_device *pdev) · 89 unmodified lines
688		690
689	pm_runtime_put(&pdev->dev);	691	pm_runtime_put(&pdev->dev);
690	pm_runtime_disable(&pdev->dev);	692	pm_runtime_disable(&pdev->dev);
691	if (!info->no_irq && IS_ENABLED(CONFIG_THERMAL_OF))	693
		694	if (!IS_ENABLED(CONFIG_THERMAL_OF))
		695	return 0;
		696
		697	thermal_zone_of_sensor_unregister(info->sensor_device, info->tzd);
		698
		699	if (!info->no_irq)
692	iio_map_array_unregister(indio_dev);	700	iio_map_array_unregister(indio_dev);
693		701
694	return 0;	702	return 0;
@@ -700,6 +708,7 @@ static const struct platform_device_id sun4i_gpadc_id[] = { · 5 unmodified lines
700	{ "sun6i-a31-gpadc-iio", (kernel_ulong_t)&sun6i_gpadc_data },	708	{ "sun6i-a31-gpadc-iio", (kernel_ulong_t)&sun6i_gpadc_data },
701	{ /* sentinel */ },	709	{ /* sentinel */ },
702	};	710	};
		711	MODULE_DEVICE_TABLE(platform, sun4i_gpadc_id);
703		712
704	static struct platform_driver sun4i_gpadc_driver = {	713	static struct platform_driver sun4i_gpadc_driver = {
705	.driver = {	714	.driver = {
@@ -711,6 +720,7 @@ static struct platform_driver sun4i_gpadc_driver = { · 5 unmodified lines
711	.probe = sun4i_gpadc_probe,	720	.probe = sun4i_gpadc_probe,
712	.remove = sun4i_gpadc_remove,	721	.remove = sun4i_gpadc_remove,
713	};	722	};
		723	MODULE_DEVICE_TABLE(of, sun4i_gpadc_of_id);
714		724
715	module_platform_driver(sun4i_gpadc_driver);	725	module_platform_driver(sun4i_gpadc_driver);
716		726

drivers/iio/adc/ti_am335x_adc.c+1−1

@@ -614,7 +614,7 @@ static int tiadc_probe(struct platform_device *pdev) · 613 unmodified lines
614	return -EINVAL;	614	return -EINVAL;
615	}	615	}
616		616
617	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*indio_dev));	617	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc_dev));
618	if (indio_dev == NULL) {	618	if (indio_dev == NULL) {
619	dev_err(&pdev->dev, "failed to allocate iio device\n");	619	dev_err(&pdev->dev, "failed to allocate iio device\n");
620	return -ENOMEM;	620	return -ENOMEM;

drivers/iio/industrialio-trigger.c+2−1

@@ -451,7 +451,8 @@ static ssize_t iio_trigger_write_current(struct device *dev, · 450 unmodified lines
451	return len;	451	return len;
452		452
453	out_trigger_put:	453	out_trigger_put:
454	iio_trigger_put(trig);	454	if (trig)
		455	iio_trigger_put(trig);
455	return ret;	456	return ret;
456	}	457	}
457		458

drivers/iio/light/ltr501.c+2−2

 static const struct reg_field reg_field_it =
 				REG_FIELD(LTR501_ALS_MEAS_RATE, 3, 4);
 static const struct reg_field reg_field_als_intr =
-				REG_FIELD(LTR501_INTR, 0, 0);
-static const struct reg_field reg_field_ps_intr =
 				REG_FIELD(LTR501_INTR, 1, 1);
+static const struct reg_field reg_field_ps_intr =
+				REG_FIELD(LTR501_INTR, 0, 0);
 static const struct reg_field reg_field_als_rate =
 				REG_FIELD(LTR501_ALS_MEAS_RATE, 0, 2);
 static const struct reg_field reg_field_ps_rate =

drivers/iio/proximity/as3935.c+6−8

 #define AS3935_AFE_PWR_BIT	BIT(0)
 #define AS3935_INT		0x03
-#define AS3935_INT_MASK		0x07
+#define AS3935_INT_MASK		0x0f
 #define AS3935_EVENT_INT	BIT(3)
-#define AS3935_NOISE_INT	BIT(1)
+#define AS3935_NOISE_INT	BIT(0)
 #define AS3935_DATA		0x07
 #define AS3935_DATA_MASK	0x3F
 	st->buffer[0] = val & AS3935_DATA_MASK;
 	iio_push_to_buffers_with_timestamp(indio_dev, &st->buffer,
-					   pf->timestamp);
+					   iio_get_time_ns(indio_dev));
 err_read:
 	iio_trigger_notify_done(indio_dev->trig);
 	switch (val) {
 	case AS3935_EVENT_INT:
-		iio_trigger_poll(st->trig);
+		iio_trigger_poll_chained(st->trig);
 		break;
 	case AS3935_NOISE_INT:
 		dev_warn(&st->spi->dev, "noise level is too high\n");
 static void calibrate_as3935(struct as3935_state *st)
 {
-	mutex_lock(&st->lock);
 	/* mask disturber interrupt bit */
 	as3935_write(st, AS3935_INT, BIT(5));
 	mdelay(2);
 	as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));
-	mutex_unlock(&st->lock);
 }
 #ifdef CONFIG_PM_SLEEP
 	val &= ~AS3935_AFE_PWR_BIT;
 	ret = as3935_write(st, AS3935_AFE_GAIN, val);
+	calibrate_as3935(st);
 err_resume:
 	mutex_unlock(&st->lock);

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

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

drivers/input/mouse/elantech.c+16−0

  * Asus UX32VD             0x361f02        00, 15, 0e      clickpad
  * Avatar AVIU-145A2       0x361f00        ?               clickpad
  * Fujitsu LIFEBOOK E544   0x470f00        d0, 12, 09      2 hw buttons
+ * Fujitsu LIFEBOOK E546   0x470f00        50, 12, 09      2 hw buttons
  * Fujitsu LIFEBOOK E547   0x470f00        50, 12, 09      2 hw buttons
  * Fujitsu LIFEBOOK E554   0x570f01        40, 14, 0c      2 hw buttons
+ * Fujitsu LIFEBOOK E557   0x570f01        40, 14, 0c      2 hw buttons
  * Fujitsu T725            0x470f01        05, 12, 09      2 hw buttons
  * Fujitsu H730            0x570f00        c0, 14, 0c      3 hw buttons (**)
  * Gigabyte U2442          0x450f01        58, 17, 0c      2 hw buttons
 			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E544"),
 		},
 	},
+	{
+		/* Fujitsu LIFEBOOK E546  does not work with crc_enabled == 0 */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E546"),
+		},
+	},
 	{
 		/* Fujitsu LIFEBOOK E547 does not work with crc_enabled == 0 */
 		.matches = {
 			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E556"),
 		},
 	},
+	{
+		/* Fujitsu LIFEBOOK E557 does not work with crc_enabled == 0 */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E557"),
+		},
+	},
 	{
 		/* Fujitsu LIFEBOOK U745 does not work with crc_enabled == 0 */
 		.matches = {

drivers/input/rmi4/rmi_f03.c+1−1

@@ -146,7 +146,7 @@ static int rmi_f03_register_pt(struct f03_data *f03) · 145 unmodified lines
146	if (!serio)	146	if (!serio)
147	return -ENOMEM;	147	return -ENOMEM;
148		148
149	serio->id.type = SERIO_8042;	149	serio->id.type = SERIO_PS_PSTHRU;
150	serio->write = rmi_f03_pt_write;	150	serio->write = rmi_f03_pt_write;
151	serio->port_data = f03;	151	serio->port_data = f03;
152		152

drivers/iommu/of_iommu.c+7−0

 	ops = iommu_ops_from_fwnode(fwnode);
 	if ((ops && !ops->of_xlate) ||
+	    !of_device_is_available(iommu_spec->np) ||
 	    (!ops && !of_iommu_driver_present(iommu_spec->np)))
 		return NULL;
 			ops = ERR_PTR(err);
 	}
+	/* Ignore all other errors apart from EPROBE_DEFER */
+	if (IS_ERR(ops) && (PTR_ERR(ops) != -EPROBE_DEFER)) {
+		dev_dbg(dev, "Adding to IOMMU failed: %ld\n", PTR_ERR(ops));
+		ops = NULL;
+	}
 	return ops;
 }

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

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

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

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

drivers/md/md.c+12−4

 static void no_op(struct percpu_ref *r) {}
+int mddev_init_writes_pending(struct mddev *mddev)
+{
+	if (mddev->writes_pending.percpu_count_ptr)
+		return 0;
+	if (percpu_ref_init(&mddev->writes_pending, no_op, 0, GFP_KERNEL) < 0)
+		return -ENOMEM;
+	/* We want to start with the refcount at zero */
+	percpu_ref_put(&mddev->writes_pending);
+	return 0;
+}
+EXPORT_SYMBOL_GPL(mddev_init_writes_pending);
 static int md_alloc(dev_t dev, char *name)
 {
 	/*
 	blk_queue_make_request(mddev->queue, md_make_request);
 	blk_set_stacking_limits(&mddev->queue->limits);
-	if (percpu_ref_init(&mddev->writes_pending, no_op, 0, GFP_KERNEL) < 0)
-		goto abort;
-	/* We want to start with the refcount at zero */
-	percpu_ref_put(&mddev->writes_pending);
 	disk = alloc_disk(1 << shift);
 	if (!disk) {
 		blk_cleanup_queue(mddev->queue);

drivers/md/md.h+1−0

@@ -648,6 +648,7 @@ extern void md_unregister_thread(struct md_thread **threadp); · 647 unmodified lines
648	extern void md_wakeup_thread(struct md_thread *thread);	648	extern void md_wakeup_thread(struct md_thread *thread);
649	extern void md_check_recovery(struct mddev *mddev);	649	extern void md_check_recovery(struct mddev *mddev);
650	extern void md_reap_sync_thread(struct mddev *mddev);	650	extern void md_reap_sync_thread(struct mddev *mddev);
		651	extern int mddev_init_writes_pending(struct mddev *mddev);
651	extern void md_write_start(struct mddev mddev, struct bio bi);	652	extern void md_write_start(struct mddev mddev, struct bio bi);
652	extern void md_write_inc(struct mddev mddev, struct bio bi);	653	extern void md_write_inc(struct mddev mddev, struct bio bi);
653	extern void md_write_end(struct mddev *mddev);	654	extern void md_write_end(struct mddev *mddev);

drivers/md/raid1.c+2−0

 			mdname(mddev));
 		return -EIO;
 	}
+	if (mddev_init_writes_pending(mddev) < 0)
+		return -ENOMEM;
 	/*
 	 * copy the already verified devices into our private RAID1
 	 * bookkeeping area. [whatever we allocate in run(),

drivers/md/raid10.c+3−0

@@ -3611,6 +3611,9 @@ static int raid10_run(struct mddev *mddev) · 3610 unmodified lines
3611	int first = 1;	3611	int first = 1;
3612	bool discard_supported = false;	3612	bool discard_supported = false;
3613		3613
		3614	if (mddev_init_writes_pending(mddev) < 0)
		3615	return -ENOMEM;
		3616
3614	if (mddev->private == NULL) {	3617	if (mddev->private == NULL) {
3615	conf = setup_conf(mddev);	3618	conf = setup_conf(mddev);
3616	if (IS_ERR(conf))	3619	if (IS_ERR(conf))

drivers/md/raid5.c+3−0

@@ -7118,6 +7118,9 @@ static int raid5_run(struct mddev *mddev) · 7117 unmodified lines
7118	long long min_offset_diff = 0;	7118	long long min_offset_diff = 0;
7119	int first = 1;	7119	int first = 1;
7120		7120
		7121	if (mddev_init_writes_pending(mddev) < 0)
		7122	return -ENOMEM;
		7123
7121	if (mddev->recovery_cp != MaxSector)	7124	if (mddev->recovery_cp != MaxSector)
7122	pr_notice("md/raid:%s: not clean -- starting background reconstruction\n",	7125	pr_notice("md/raid:%s: not clean -- starting background reconstruction\n",
7123	mdname(mddev));	7126	mdname(mddev));

drivers/media/cec/Kconfig+1−0

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

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

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

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

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

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

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

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

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

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

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

drivers/memory/atmel-ebi.c+1−1

@@ -581,7 +581,7 @@ static int atmel_ebi_probe(struct platform_device *pdev) · 580 unmodified lines
581	return of_platform_populate(np, NULL, NULL, dev);	581	return of_platform_populate(np, NULL, NULL, dev);
582	}	582	}
583		583
584	static int atmel_ebi_resume(struct device *dev)	584	static __maybe_unused int atmel_ebi_resume(struct device *dev)
585	{	585	{
586	struct atmel_ebi *ebi = dev_get_drvdata(dev);	586	struct atmel_ebi *ebi = dev_get_drvdata(dev);
587	struct atmel_ebi_dev *ebid;	587	struct atmel_ebi_dev *ebid;

drivers/misc/cxl/file.c+2−5

 	/* Do this outside the status_mutex to avoid a circular dependency with
 	 * the locking in cxl_mmap_fault() */
-	if (copy_from_user(&work, uwork,
+	if (copy_from_user(&work, uwork, sizeof(work)))
-			   sizeof(struct cxl_ioctl_start_work))) {
+		return -EFAULT;
-		rc = -EFAULT;
-		goto out;
-	}
 	mutex_lock(&ctx->status_mutex);
 	if (ctx->status != OPENED) {

drivers/misc/cxl/native.c+11−3

 void cxl_native_release_psl_err_irq(struct cxl *adapter)
 {
-	if (adapter->native->err_virq != irq_find_mapping(NULL, adapter->native->err_hwirq))
+	if (adapter->native->err_virq == 0 ||
+	    adapter->native->err_virq !=
+	    irq_find_mapping(NULL, adapter->native->err_hwirq))
 		return;
 	cxl_p1_write(adapter, CXL_PSL_ErrIVTE, 0x0000000000000000);
 	cxl_unmap_irq(adapter->native->err_virq, adapter);
 	cxl_ops->release_one_irq(adapter, adapter->native->err_hwirq);
 	kfree(adapter->irq_name);
+	adapter->native->err_virq = 0;
 }
 int cxl_native_register_serr_irq(struct cxl_afu *afu)
 void cxl_native_release_serr_irq(struct cxl_afu *afu)
 {
-	if (afu->serr_virq != irq_find_mapping(NULL, afu->serr_hwirq))
+	if (afu->serr_virq == 0 ||
+	    afu->serr_virq != irq_find_mapping(NULL, afu->serr_hwirq))
 		return;
 	cxl_p1n_write(afu, CXL_PSL_SERR_An, 0x0000000000000000);
 	cxl_unmap_irq(afu->serr_virq, afu);
 	cxl_ops->release_one_irq(afu->adapter, afu->serr_hwirq);
 	kfree(afu->err_irq_name);
+	afu->serr_virq = 0;
 }
 int cxl_native_register_psl_irq(struct cxl_afu *afu)
 void cxl_native_release_psl_irq(struct cxl_afu *afu)
 {
-	if (afu->native->psl_virq != irq_find_mapping(NULL, afu->native->psl_hwirq))
+	if (afu->native->psl_virq == 0 ||
+	    afu->native->psl_virq !=
+	    irq_find_mapping(NULL, afu->native->psl_hwirq))
 		return;
 	cxl_unmap_irq(afu->native->psl_virq, afu);
 	cxl_ops->release_one_irq(afu->adapter, afu->native->psl_hwirq);
 	kfree(afu->psl_irq_name);
+	afu->native->psl_virq = 0;
 }
 static void recover_psl_err(struct cxl_afu *afu, u64 errstat)

drivers/misc/mei/bus.c+3−1

 {
 	struct mei_cl_device *cldev = to_mei_cl_device(dev);
 	const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
+	u8 version = mei_me_cl_ver(cldev->me_cl);
-	return scnprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid);
+	return scnprintf(buf, PAGE_SIZE, "mei:%s:%pUl:%02X:",
+			 cldev->name, uuid, version);
 }
 static DEVICE_ATTR_RO(modalias);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

drivers/net/dummy.c+2−2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c+1−1

@@ -4668,7 +4668,7 @@ static void dummy_setup(struct net_device *dev) · 4667 unmodified lines
4668	/* Initialize the device structure. */	4668	/* Initialize the device structure. */
4669	dev->netdev_ops = &cxgb4_mgmt_netdev_ops;	4669	dev->netdev_ops = &cxgb4_mgmt_netdev_ops;
4670	dev->ethtool_ops = &cxgb4_mgmt_ethtool_ops;	4670	dev->ethtool_ops = &cxgb4_mgmt_ethtool_ops;
4671	dev->destructor = free_netdev;	4671	dev->needs_free_netdev = true;
4672	}	4672	}
4673		4673
4674	static int config_mgmt_dev(struct pci_dev *pdev)	4674	static int config_mgmt_dev(struct pci_dev *pdev)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 	/* disable cmdif checksum */
 	MLX5_SET(cmd_hca_cap, set_hca_cap, cmdif_checksum, 0);
-	/* If the HCA supports 4K UARs use it */
+	/* Enable 4K UAR only when HCA supports it and page size is bigger
-	if (MLX5_CAP_GEN_MAX(dev, uar_4k))
+	 * than 4K.
+	 */
+	if (MLX5_CAP_GEN_MAX(dev, uar_4k) && PAGE_SIZE > 4096)
 		MLX5_SET(cmd_hca_cap, set_hca_cap, uar_4k, 1);
 	MLX5_SET(cmd_hca_cap, set_hca_cap, log_uar_page_sz, PAGE_SHIFT - 12);

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

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

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

 		return;
 	/* check tx tstamp status */
-	if (!priv->hw->desc->get_tx_timestamp_status(p)) {
+	if (priv->hw->desc->get_tx_timestamp_status(p)) {
 		/* get the valid tstamp */
 		ns = priv->hw->desc->get_timestamp(p, priv->adv_ts);
 		memset(&shhwtstamp, 0, sizeof(struct skb_shared_hwtstamps));
 		shhwtstamp.hwtstamp = ns_to_ktime(ns);
-		netdev_info(priv->dev, "get valid TX hw timestamp %llu\n", ns);
+		netdev_dbg(priv->dev, "get valid TX hw timestamp %llu\n", ns);
 		/* pass tstamp to stack */
 		skb_tstamp_tx(skb, &shhwtstamp);
 	}
 		return;
 	/* Check if timestamp is available */
-	if (!priv->hw->desc->get_rx_timestamp_status(p, priv->adv_ts)) {
+	if (priv->hw->desc->get_rx_timestamp_status(p, priv->adv_ts)) {
 		/* For GMAC4, the valid timestamp is from CTX next desc. */
 		if (priv->plat->has_gmac4)
 			ns = priv->hw->desc->get_timestamp(np, priv->adv_ts);
 		else
 			ns = priv->hw->desc->get_timestamp(p, priv->adv_ts);
-		netdev_info(priv->dev, "get valid RX hw timestamp %llu\n", ns);
+		netdev_dbg(priv->dev, "get valid RX hw timestamp %llu\n", ns);
 		shhwtstamp = skb_hwtstamps(skb);
 		memset(shhwtstamp, 0, sizeof(struct skb_shared_hwtstamps));
 		shhwtstamp->hwtstamp = ns_to_ktime(ns);
 	} else  {
-		netdev_err(priv->dev, "cannot get RX hw timestamp\n");
+		netdev_dbg(priv->dev, "cannot get RX hw timestamp\n");
 	}
 }
 			/* PTP v1, UDP, any kind of event packet */
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_EVENT;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_EVENT;
 			ptp_v2 = PTP_TCR_TSVER2ENA;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;
 			config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
 			ptp_v2 = PTP_TCR_TSVER2ENA;
 			/* take time stamp for all event messages */
-			snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
+			if (priv->plat->has_gmac4)
+				snap_type_sel = PTP_GMAC4_TCR_SNAPTYPSEL_1;
+			else
+				snap_type_sel = PTP_TCR_SNAPTYPSEL_1;
 			ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA;
 			ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA;

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

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

drivers/net/geneve.c+1−1

@@ -1019,7 +1019,7 @@ static void geneve_setup(struct net_device *dev) · 1018 unmodified lines
1019		1019
1020	dev->netdev_ops = &geneve_netdev_ops;	1020	dev->netdev_ops = &geneve_netdev_ops;
1021	dev->ethtool_ops = &geneve_ethtool_ops;	1021	dev->ethtool_ops = &geneve_ethtool_ops;
1022	dev->destructor = free_netdev;	1022	dev->needs_free_netdev = true;
1023		1023
1024	SET_NETDEV_DEVTYPE(dev, &geneve_type);	1024	SET_NETDEV_DEVTYPE(dev, &geneve_type);
1025		1025

drivers/net/gtp.c+1−1

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

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

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

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

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

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

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

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

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

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

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

drivers/net/ifb.c+2−2

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

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

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

drivers/net/loopback.c+2−2

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

drivers/net/macsec.c+2−2

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

drivers/net/macvlan.c+1−1

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

drivers/net/netconsole.c+1−1

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

drivers/net/nlmon.c+1−1

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

drivers/net/phy/Kconfig+1−0

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

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

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

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

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

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

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

drivers/net/tun.c+2−2

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

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

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

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

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

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

@@ -4454,6 +4454,8 @@ static u8 rtl_get_version(struct usb_interface *intf) · 4453 unmodified lines
4454	break;	4454	break;
4455	}	4455	}
4456		4456
		4457	dev_dbg(&intf->dev, "Detected version 0x%04x\n", version);
		4458
4457	return version;	4459	return version;
4458	}	4460	}
4459		4461

drivers/net/veth.c+2−2

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

drivers/net/vrf.c+33−5

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

drivers/net/vsockmon.c+1−1

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

drivers/net/vxlan.c+1−1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

drivers/net/wireless/quantenna/qtnfmac/core.c+1−1

@@ -316,7 +316,7 @@ int qtnf_core_net_attach(struct qtnf_wmac mac, struct qtnf_vif vif, · 315 unmodified lines
316	vif->netdev = dev;	316	vif->netdev = dev;
317		317
318	dev->netdev_ops = &qtnf_netdev_ops;	318	dev->netdev_ops = &qtnf_netdev_ops;
319	dev->destructor = free_netdev;	319	dev->needs_free_netdev = true;
320	dev_net_set(dev, wiphy_net(wiphy));	320	dev_net_set(dev, wiphy_net(wiphy));
321	dev->ieee80211_ptr = &vif->wdev;	321	dev->ieee80211_ptr = &vif->wdev;
322	dev->ieee80211_ptr->iftype = iftype;	322	dev->ieee80211_ptr->iftype = iftype;

drivers/nvme/host/core.c+14−7

 static int nvme_char_major;
 module_param(nvme_char_major, int, 0);
-static unsigned long default_ps_max_latency_us = 25000;
+static unsigned long default_ps_max_latency_us = 100000;
 module_param(default_ps_max_latency_us, ulong, 0644);
 MODULE_PARM_DESC(default_ps_max_latency_us,
 		 "max power saving latency for new devices; use PM QOS to change per device");
 	 * transitioning between power states.  Therefore, when running
 	 * in any given state, we will enter the next lower-power
 	 * non-operational state after waiting 50 * (enlat + exlat)
-	 * microseconds, as long as that state's total latency is under
+	 * microseconds, as long as that state's exit latency is under
 	 * the requested maximum latency.
 	 *
 	 * We will not autonomously enter any non-operational state for
 		 * lowest-power state, not the number of states.
 		 */
 		for (state = (int)ctrl->npss; state >= 0; state--) {
-			u64 total_latency_us, transition_ms;
+			u64 total_latency_us, exit_latency_us, transition_ms;
 			if (target)
 				table->entries[state] = target;
 			      NVME_PS_FLAGS_NON_OP_STATE))
 				continue;
-			total_latency_us =
+			exit_latency_us =
-				(u64)le32_to_cpu(ctrl->psd[state].entry_lat) +
+				(u64)le32_to_cpu(ctrl->psd[state].exit_lat);
-				+ le32_to_cpu(ctrl->psd[state].exit_lat);
+			if (exit_latency_us > ctrl->ps_max_latency_us)
-			if (total_latency_us > ctrl->ps_max_latency_us)
 				continue;
+			total_latency_us =
+				exit_latency_us +
+				le32_to_cpu(ctrl->psd[state].entry_lat);
 			/*
 			 * This state is good.  Use it as the APST idle
 			 * target for higher power states.
 	struct nvme_ns *ns;
 	mutex_lock(&ctrl->namespaces_mutex);
+	/* Forcibly start all queues to avoid having stuck requests */
+	blk_mq_start_hw_queues(ctrl->admin_q);
 	list_for_each_entry(ns, &ctrl->namespaces, list) {
 		/*
 		 * Revalidating a dead namespace sets capacity to 0. This will

drivers/nvme/host/fc.c+18−2

 /* *********************** NVME Ctrl Routines **************************** */
 static void __nvme_fc_final_op_cleanup(struct request *rq);
+static void nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl, char *errmsg);
 static int
 nvme_fc_reinit_request(void *data, struct request *rq)
 	struct nvme_command *sqe = &op->cmd_iu.sqe;
 	__le16 status = cpu_to_le16(NVME_SC_SUCCESS << 1);
 	union nvme_result result;
-	bool complete_rq;
+	bool complete_rq, terminate_assoc = true;
 	/*
 	 * WARNING:
 	 * fabricate a CQE, the following fields will not be set as they
 	 * are not referenced:
 	 *      cqe.sqid,  cqe.sqhd,  cqe.command_id
+	 *
+	 * Failure or error of an individual i/o, in a transport
+	 * detected fashion unrelated to the nvme completion status,
+	 * potentially cause the initiator and target sides to get out
+	 * of sync on SQ head/tail (aka outstanding io count allowed).
+	 * Per FC-NVME spec, failure of an individual command requires
+	 * the connection to be terminated, which in turn requires the
+	 * association to be terminated.
 	 */
 	fc_dma_sync_single_for_cpu(ctrl->lport->dev, op->fcp_req.rspdma,
 		goto done;
 	}
+	terminate_assoc = false;
 done:
 	if (op->flags & FCOP_FLAGS_AEN) {
 		nvme_complete_async_event(&queue->ctrl->ctrl, status, &result);
 		atomic_set(&op->state, FCPOP_STATE_IDLE);
 		op->flags = FCOP_FLAGS_AEN;	/* clear other flags */
 		nvme_fc_ctrl_put(ctrl);
-		return;
+		goto check_error;
 	}
 	complete_rq = __nvme_fc_fcpop_chk_teardowns(ctrl, op);
 		nvme_end_request(rq, status, result);
 	} else
 		__nvme_fc_final_op_cleanup(rq);
+check_error:
+	if (terminate_assoc)
+		nvme_fc_error_recovery(ctrl, "transport detected io error");
 }
 static int
 		ctrl->ctrl.opts = NULL;
 		/* initiate nvme ctrl ref counting teardown */
 		nvme_uninit_ctrl(&ctrl->ctrl);
+		nvme_put_ctrl(&ctrl->ctrl);
 		/* as we're past the point where we transition to the ref
 		 * counting teardown path, if we return a bad pointer here,

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

 	bool nssro = dev->subsystem && (csts & NVME_CSTS_NSSRO);
 	/* If there is a reset ongoing, we shouldn't reset again. */
-	if (work_busy(&dev->reset_work))
+	if (dev->ctrl.state == NVME_CTRL_RESETTING)
 		return false;
 	/* We shouldn't reset unless the controller is on fatal error state
 	bool was_suspend = !!(dev->ctrl.ctrl_config & NVME_CC_SHN_NORMAL);
 	int result = -ENODEV;
-	if (WARN_ON(dev->ctrl.state == NVME_CTRL_RESETTING))
+	if (WARN_ON(dev->ctrl.state != NVME_CTRL_RESETTING))
 		goto out;
 	/*
 	if (dev->ctrl.ctrl_config & NVME_CC_ENABLE)
 		nvme_dev_disable(dev, false);
-	if (!nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_RESETTING))
-		goto out;
 	result = nvme_pci_enable(dev);
 	if (result)
 		goto out;
 {
 	if (!dev->ctrl.admin_q || blk_queue_dying(dev->ctrl.admin_q))
 		return -ENODEV;
-	if (work_busy(&dev->reset_work))
+	if (!nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_RESETTING))
-		return -ENODEV;
+		return -EBUSY;
 	if (!queue_work(nvme_workq, &dev->reset_work))
 		return -EBUSY;
 	return 0;
 	if (result)
 		goto release_pools;
+	nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_RESETTING);
 	dev_info(dev->ctrl.device, "pci function %s\n", dev_name(&pdev->dev));
 	queue_work(nvme_workq, &dev->reset_work);
 	nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_DELETING);
+	cancel_work_sync(&dev->reset_work);
 	pci_set_drvdata(pdev, NULL);
 	if (!pci_device_is_present(pdev)) {

drivers/nvme/host/rdma.c+29−15

 	if (ret)
 		goto requeue;
-	blk_mq_start_stopped_hw_queues(ctrl->ctrl.admin_q, true);
 	ret = nvmf_connect_admin_queue(&ctrl->ctrl);
 	if (ret)
-		goto stop_admin_q;
+		goto requeue;
 	set_bit(NVME_RDMA_Q_LIVE, &ctrl->queues[0].flags);
 	ret = nvme_enable_ctrl(&ctrl->ctrl, ctrl->cap);
 	if (ret)
-		goto stop_admin_q;
+		goto requeue;
 	nvme_start_keep_alive(&ctrl->ctrl);
 	if (ctrl->queue_count > 1) {
 		ret = nvme_rdma_init_io_queues(ctrl);
 		if (ret)
-			goto stop_admin_q;
+			goto requeue;
 		ret = nvme_rdma_connect_io_queues(ctrl);
 		if (ret)
-			goto stop_admin_q;
+			goto requeue;
 	}
 	changed = nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_LIVE);
 	ctrl->ctrl.opts->nr_reconnects = 0;
 	if (ctrl->queue_count > 1) {
-		nvme_start_queues(&ctrl->ctrl);
 		nvme_queue_scan(&ctrl->ctrl);
 		nvme_queue_async_events(&ctrl->ctrl);
 	}
 	return;
-stop_admin_q:
-	blk_mq_stop_hw_queues(ctrl->ctrl.admin_q);
 requeue:
 	dev_info(ctrl->ctrl.device, "Failed reconnect attempt %d\n",
 			ctrl->ctrl.opts->nr_reconnects);
 	blk_mq_tagset_busy_iter(&ctrl->admin_tag_set,
 				nvme_cancel_request, &ctrl->ctrl);
+	/*
+	 * queues are not a live anymore, so restart the queues to fail fast
+	 * new IO
+	 */
+	blk_mq_start_stopped_hw_queues(ctrl->ctrl.admin_q, true);
+	nvme_start_queues(&ctrl->ctrl);
 	nvme_rdma_reconnect_or_remove(ctrl);
 }
 /*
  * We cannot accept any other command until the Connect command has completed.
  */
-static inline bool nvme_rdma_queue_is_ready(struct nvme_rdma_queue *queue,
+static inline int nvme_rdma_queue_is_ready(struct nvme_rdma_queue *queue,
 		struct request *rq)
 {
 	if (unlikely(!test_bit(NVME_RDMA_Q_LIVE, &queue->flags))) {
 		if (!blk_rq_is_passthrough(rq) ||
 		    cmd->common.opcode != nvme_fabrics_command ||
-		    cmd->fabrics.fctype != nvme_fabrics_type_connect)
+		    cmd->fabrics.fctype != nvme_fabrics_type_connect) {
-			return false;
+			/*
+			 * reconnecting state means transport disruption, which
+			 * can take a long time and even might fail permanently,
+			 * so we can't let incoming I/O be requeued forever.
+			 * fail it fast to allow upper layers a chance to
+			 * failover.
+			 */
+			if (queue->ctrl->ctrl.state == NVME_CTRL_RECONNECTING)
+				return -EIO;
+			else
+				return -EAGAIN;
+		}
 	}
-	return true;
+	return 0;
 }
 static int nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
 	WARN_ON_ONCE(rq->tag < 0);
-	if (!nvme_rdma_queue_is_ready(queue, rq))
+	ret = nvme_rdma_queue_is_ready(queue, rq);
-		return BLK_MQ_RQ_QUEUE_BUSY;
+	if (unlikely(ret))
+		goto err;
 	dev = queue->device->dev;
 	ib_dma_sync_single_for_cpu(dev, sqe->dma,

drivers/of/device.c+2−2

@@ -144,8 +144,8 @@ int of_dma_configure(struct device dev, struct device_node np) · 143 unmodified lines
144	coherent ? " " : " not ");	144	coherent ? " " : " not ");
145		145
146	iommu = of_iommu_configure(dev, np);	146	iommu = of_iommu_configure(dev, np);
147	if (IS_ERR(iommu))	147	if (IS_ERR(iommu) && PTR_ERR(iommu) == -EPROBE_DEFER)
148	return PTR_ERR(iommu);	148	return -EPROBE_DEFER;
149		149
150	dev_dbg(dev, "device is%sbehind an iommu\n",	150	dev_dbg(dev, "device is%sbehind an iommu\n",
151	iommu ? " " : " not ");	151	iommu ? " " : " not ");

drivers/phy/phy-qcom-qmp.c+7−7

@@ -844,7 +844,7 @@ static int qcom_qmp_phy_vreg_init(struct device *dev) · 843 unmodified lines
844	int num = qmp->cfg->num_vregs;	844	int num = qmp->cfg->num_vregs;
845	int i;	845	int i;
846		846
847	qmp->vregs = devm_kcalloc(dev, num, sizeof(qmp->vregs), GFP_KERNEL);	847	qmp->vregs = devm_kcalloc(dev, num, sizeof(*qmp->vregs), GFP_KERNEL);
848	if (!qmp->vregs)	848	if (!qmp->vregs)
849	return -ENOMEM;	849	return -ENOMEM;
850		850
@@ -983,16 +983,16 @@ int qcom_qmp_phy_create(struct device dev, struct device_node np, int id) · 132 unmodified lines
983	* Resources are indexed as: tx -> 0; rx -> 1; pcs -> 2.	983	* Resources are indexed as: tx -> 0; rx -> 1; pcs -> 2.
984	*/	984	*/
985	qphy->tx = of_iomap(np, 0);	985	qphy->tx = of_iomap(np, 0);
986	if (IS_ERR(qphy->tx))	986	if (!qphy->tx)
987	return PTR_ERR(qphy->tx);	987	return -ENOMEM;
988		988
989	qphy->rx = of_iomap(np, 1);	989	qphy->rx = of_iomap(np, 1);
990	if (IS_ERR(qphy->rx))	990	if (!qphy->rx)
991	return PTR_ERR(qphy->rx);	991	return -ENOMEM;
992		992
993	qphy->pcs = of_iomap(np, 2);	993	qphy->pcs = of_iomap(np, 2);
994	if (IS_ERR(qphy->pcs))	994	if (!qphy->pcs)
995	return PTR_ERR(qphy->pcs);	995	return -ENOMEM;
996		996
997	/*	997	/*
998	* Get PHY's Pipe clock, if any. USB3 and PCIe are PIPE3	998	* Get PHY's Pipe clock, if any. USB3 and PCIe are PIPE3

drivers/platform/goldfish/goldfish_pipe.c+1−1

@@ -704,7 +704,7 @@ static int get_free_pipe_id_locked(struct goldfish_pipe_dev *dev) · 703 unmodified lines
704	/* Reallocate the array */	704	/* Reallocate the array */
705	u32 new_capacity = 2 * dev->pipes_capacity;	705	u32 new_capacity = 2 * dev->pipes_capacity;
706	struct goldfish_pipe **pipes =	706	struct goldfish_pipe **pipes =
707	kcalloc(new_capacity, sizeof(*pipes), GFP_KERNEL);	707	kcalloc(new_capacity, sizeof(*pipes), GFP_ATOMIC);
708	if (!pipes)	708	if (!pipes)
709	return -ENOMEM;	709	return -ENOMEM;
710	memcpy(pipes, dev->pipes, sizeof(pipes) dev->pipes_capacity);	710	memcpy(pipes, dev->pipes, sizeof(pipes) dev->pipes_capacity);

drivers/reset/hisilicon/hi6220_reset.c+2−0

@@ -155,3 +155,5 @@ static int __init hi6220_reset_init(void) · 154 unmodified lines
155	}	155	}
156		156
157	postcore_initcall(hi6220_reset_init);	157	postcore_initcall(hi6220_reset_init);
		158
		159	MODULE_LICENSE("GPL v2");

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

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

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

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

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

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

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

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

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

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

drivers/scsi/bnx2fc/bnx2fc.h+1−0

@@ -191,6 +191,7 @@ struct bnx2fc_hba { · 190 unmodified lines
191	struct bnx2fc_cmd_mgr *cmd_mgr;	191	struct bnx2fc_cmd_mgr *cmd_mgr;
192	spinlock_t hba_lock;	192	spinlock_t hba_lock;
193	struct mutex hba_mutex;	193	struct mutex hba_mutex;
		194	struct mutex hba_stats_mutex;
194	unsigned long adapter_state;	195	unsigned long adapter_state;
195	#define ADAPTER_STATE_UP 0	196	#define ADAPTER_STATE_UP 0
196	#define ADAPTER_STATE_GOING_DOWN 1	197	#define ADAPTER_STATE_GOING_DOWN 1

drivers/scsi/bnx2fc/bnx2fc_fcoe.c+8−2

 	if (!fw_stats)
 		return NULL;
+	mutex_lock(&hba->hba_stats_mutex);
 	bnx2fc_stats = fc_get_host_stats(shost);
 	init_completion(&hba->stat_req_done);
 	if (bnx2fc_send_stat_req(hba))
-		return bnx2fc_stats;
+		goto unlock_stats_mutex;
 	rc = wait_for_completion_timeout(&hba->stat_req_done, (2 * HZ));
 	if (!rc) {
 		BNX2FC_HBA_DBG(lport, "FW stat req timed out\n");
-		return bnx2fc_stats;
+		goto unlock_stats_mutex;
 	}
 	BNX2FC_STATS(hba, rx_stat2, fc_crc_cnt);
 	bnx2fc_stats->invalid_crc_count += hba->bfw_stats.fc_crc_cnt;
 	memcpy(&hba->prev_stats, hba->stats_buffer,
 	       sizeof(struct fcoe_statistics_params));
+unlock_stats_mutex:
+	mutex_unlock(&hba->hba_stats_mutex);
 	return bnx2fc_stats;
 }
 	}
 	spin_lock_init(&hba->hba_lock);
 	mutex_init(&hba->hba_mutex);
+	mutex_init(&hba->hba_stats_mutex);
 	hba->cnic = cnic;

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c+0−1

@@ -1597,7 +1597,6 @@ static void release_offload_resources(struct cxgbi_sock *csk) · 1596 unmodified lines
1597	cxgbi_sock_put(csk);	1597	cxgbi_sock_put(csk);
1598	}	1598	}
1599	csk->dst = NULL;	1599	csk->dst = NULL;
1600	csk->cdev = NULL;
1601	}	1600	}
1602		1601
1603	static int init_act_open(struct cxgbi_sock *csk)	1602	static int init_act_open(struct cxgbi_sock *csk)

drivers/scsi/cxgbi/libcxgbi.c+22−7

@@ -867,7 +867,8 @@ static void need_active_close(struct cxgbi_sock *csk) · 866 unmodified lines
867	log_debug(1 << CXGBI_DBG_SOCK, "csk 0x%p,%u,0x%lx,%u.\n",	867	log_debug(1 << CXGBI_DBG_SOCK, "csk 0x%p,%u,0x%lx,%u.\n",
868	csk, (csk)->state, (csk)->flags, (csk)->tid);	868	csk, (csk)->state, (csk)->flags, (csk)->tid);
869	spin_lock_bh(&csk->lock);	869	spin_lock_bh(&csk->lock);
870	dst_confirm(csk->dst);	870	if (csk->dst)
		871	dst_confirm(csk->dst);
871	data_lost = skb_queue_len(&csk->receive_queue);	872	data_lost = skb_queue_len(&csk->receive_queue);
872	__skb_queue_purge(&csk->receive_queue);	873	__skb_queue_purge(&csk->receive_queue);
873		874
@@ -882,7 +883,8 @@ static void need_active_close(struct cxgbi_sock *csk) · 8 unmodified lines
882	}	883	}
883		884
884	if (close_req) {	885	if (close_req) {
885	if (data_lost)	886	if (!cxgbi_sock_flag(csk, CTPF_LOGOUT_RSP_RCVD) \|\|
		887	data_lost)
886	csk->cdev->csk_send_abort_req(csk);	888	csk->cdev->csk_send_abort_req(csk);
887	else	889	else
888	csk->cdev->csk_send_close_req(csk);	890	csk->cdev->csk_send_close_req(csk);
@@ -1186,9 +1188,10 @@ static int cxgbi_sock_send_pdus(struct cxgbi_sock csk, struct sk_buff skb) · 297 unmodified lines
1186	cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));	1188	cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));
1187	skb = next;	1189	skb = next;
1188	}	1190	}
1189	done:	1191
1190	if (likely(skb_queue_len(&csk->write_queue)))	1192	if (likely(skb_queue_len(&csk->write_queue)))
1191	cdev->csk_push_tx_frames(csk, 1);	1193	cdev->csk_push_tx_frames(csk, 1);
		1194	done:
1192	spin_unlock_bh(&csk->lock);	1195	spin_unlock_bh(&csk->lock);
1193	return copied;	1196	return copied;
1194		1197
@@ -1568,9 +1571,12 @@ static inline int read_pdu_skb(struct iscsi_conn *conn, · 373 unmodified lines
1568	}	1571	}
1569	}	1572	}
1570		1573
1571	static int skb_read_pdu_bhs(struct iscsi_conn conn, struct sk_buff skb)	1574	static int
		1575	skb_read_pdu_bhs(struct cxgbi_sock csk, struct iscsi_conn conn,
		1576	struct sk_buff *skb)
1572	{	1577	{
1573	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	1578	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
		1579	int err;
1574		1580
1575	log_debug(1 << CXGBI_DBG_PDU_RX,	1581	log_debug(1 << CXGBI_DBG_PDU_RX,
1576	"conn 0x%p, skb 0x%p, len %u, flag 0x%lx.\n",	1582	"conn 0x%p, skb 0x%p, len %u, flag 0x%lx.\n",
@@ -1608,7 +1614,16 @@ static int skb_read_pdu_bhs(struct iscsi_conn conn, struct sk_buff skb) · 31 unmodified lines
1608	}	1614	}
1609	}	1615	}
1610		1616
1611	return read_pdu_skb(conn, skb, 0, 0);	1617	err = read_pdu_skb(conn, skb, 0, 0);
		1618	if (likely(err >= 0)) {
		1619	struct iscsi_hdr hdr = (struct iscsi_hdr )skb->data;
		1620	u8 opcode = hdr->opcode & ISCSI_OPCODE_MASK;
		1621
		1622	if (unlikely(opcode == ISCSI_OP_LOGOUT_RSP))
		1623	cxgbi_sock_set_flag(csk, CTPF_LOGOUT_RSP_RCVD);
		1624	}
		1625
		1626	return err;
1612	}	1627	}
1613		1628
1614	static int skb_read_pdu_data(struct iscsi_conn conn, struct sk_buff lskb,	1629	static int skb_read_pdu_data(struct iscsi_conn conn, struct sk_buff lskb,
@@ -1713,7 +1728,7 @@ void cxgbi_conn_pdu_ready(struct cxgbi_sock *csk) · 98 unmodified lines
1713	cxgbi_skcb_rx_pdulen(skb));	1728	cxgbi_skcb_rx_pdulen(skb));
1714		1729
1715	if (cxgbi_skcb_test_flag(skb, SKCBF_RX_COALESCED)) {	1730	if (cxgbi_skcb_test_flag(skb, SKCBF_RX_COALESCED)) {
1716	err = skb_read_pdu_bhs(conn, skb);	1731	err = skb_read_pdu_bhs(csk, conn, skb);
1717	if (err < 0) {	1732	if (err < 0) {
1718	pr_err("coalesced bhs, csk 0x%p, skb 0x%p,%u, "	1733	pr_err("coalesced bhs, csk 0x%p, skb 0x%p,%u, "
1719	"f 0x%lx, plen %u.\n",	1734	"f 0x%lx, plen %u.\n",
@@ -1731,7 +1746,7 @@ void cxgbi_conn_pdu_ready(struct cxgbi_sock *csk) · 11 unmodified lines
1731	cxgbi_skcb_flags(skb),	1746	cxgbi_skcb_flags(skb),
1732	cxgbi_skcb_rx_pdulen(skb));	1747	cxgbi_skcb_rx_pdulen(skb));
1733	} else {	1748	} else {
1734	err = skb_read_pdu_bhs(conn, skb);	1749	err = skb_read_pdu_bhs(csk, conn, skb);
1735	if (err < 0) {	1750	if (err < 0) {
1736	pr_err("bhs, csk 0x%p, skb 0x%p,%u, "	1751	pr_err("bhs, csk 0x%p, skb 0x%p,%u, "
1737	"f 0x%lx, plen %u.\n",	1752	"f 0x%lx, plen %u.\n",

drivers/scsi/cxgbi/libcxgbi.h+1−0

@@ -187,6 +187,7 @@ enum cxgbi_sock_flags { · 186 unmodified lines
187	CTPF_HAS_ATID, /* reserved atid */	187	CTPF_HAS_ATID, /* reserved atid */
188	CTPF_HAS_TID, /* reserved hw tid */	188	CTPF_HAS_TID, /* reserved hw tid */
189	CTPF_OFFLOAD_DOWN, /* offload function off */	189	CTPF_OFFLOAD_DOWN, /* offload function off */
		190	CTPF_LOGOUT_RSP_RCVD, /* received logout response */
190	};	191	};
191		192
192	struct cxgbi_skb_rx_cb {	193	struct cxgbi_skb_rx_cb {

drivers/scsi/lpfc/lpfc_crtn.h+1−1

@@ -127,7 +127,7 @@ int lpfc_disc_state_machine(struct lpfc_vport , struct lpfc_nodelist , void *, · 126 unmodified lines
127	void lpfc_do_scr_ns_plogi(struct lpfc_hba , struct lpfc_vport );	127	void lpfc_do_scr_ns_plogi(struct lpfc_hba , struct lpfc_vport );
128	int lpfc_check_sparm(struct lpfc_vport , struct lpfc_nodelist ,	128	int lpfc_check_sparm(struct lpfc_vport , struct lpfc_nodelist ,
129	struct serv_parm *, uint32_t, int);	129	struct serv_parm *, uint32_t, int);
130	int lpfc_els_abort(struct lpfc_hba , struct lpfc_nodelist );	130	void lpfc_els_abort(struct lpfc_hba , struct lpfc_nodelist );
131	void lpfc_more_plogi(struct lpfc_vport *);	131	void lpfc_more_plogi(struct lpfc_vport *);
132	void lpfc_more_adisc(struct lpfc_vport *);	132	void lpfc_more_adisc(struct lpfc_vport *);
133	void lpfc_end_rscn(struct lpfc_vport *);	133	void lpfc_end_rscn(struct lpfc_vport *);

drivers/scsi/lpfc/lpfc_ct.c+3−2

 					 ndlp, did, ndlp->nlp_fc4_type,
 					 FC_TYPE_FCP, FC_TYPE_NVME);
 			ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
+			lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
+			lpfc_issue_els_prli(vport, ndlp, 0);
 		}
-		lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
-		lpfc_issue_els_prli(vport, ndlp, 0);
 	} else
 		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 				 "3065 GFT_ID failed x%08x\n", irsp->ulpStatus);

drivers/scsi/lpfc/lpfc_nportdisc.c+5−2

  * associated with a LPFC_NODELIST entry. This
  * routine effectively results in a "software abort".
  */
-int
+void
 lpfc_els_abort(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
 	LIST_HEAD(abort_list);
 	pring = lpfc_phba_elsring(phba);
+	/* In case of error recovery path, we might have a NULL pring here */
+	if (!pring)
+		return;
 	/* Abort outstanding I/O on NPort <nlp_DID> */
 	lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_DISCOVERY,
 			 "2819 Abort outstanding I/O on NPort x%x "
 			      IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
 	lpfc_cancel_retry_delay_tmo(phba->pport, ndlp);
-	return 0;
 }
 static int

drivers/scsi/lpfc/lpfc_nvmet.c+2−2

@@ -799,8 +799,8 @@ lpfc_nvmet_xmt_fcp_release(struct nvmet_fc_target_port *tgtport, · 798 unmodified lines
799	}	799	}
800	spin_unlock_irqrestore(&ctxp->ctxlock, flags);	800	spin_unlock_irqrestore(&ctxp->ctxlock, flags);
801		801
802	lpfc_nvmeio_data(phba, "NVMET FCP FREE: xri x%x ste %d\n", ctxp->oxid,	802	lpfc_nvmeio_data(phba, "NVMET FCP FREE: xri x%x ste %d abt %d\n", ctxp->oxid,
803	ctxp->state, 0);	803	ctxp->state, aborting);
804		804
805	atomic_inc(&lpfc_nvmep->xmt_fcp_release);	805	atomic_inc(&lpfc_nvmep->xmt_fcp_release);
806		806

drivers/scsi/qla2xxx/qla_bsg.c+5−4

 		return -EIO;
 	}
+	memset(&elreq, 0, sizeof(elreq));
 	elreq.req_sg_cnt = dma_map_sg(&ha->pdev->dev,
 		bsg_job->request_payload.sg_list, bsg_job->request_payload.sg_cnt,
 		DMA_TO_DEVICE);
 	if (atomic_read(&vha->loop_state) == LOOP_READY &&
 	    (ha->current_topology == ISP_CFG_F ||
-	    ((IS_QLA81XX(ha) || IS_QLA8031(ha) || IS_QLA8044(ha)) &&
+	    (le32_to_cpu(*(uint32_t *)req_data) == ELS_OPCODE_BYTE &&
-	    le32_to_cpu(*(uint32_t *)req_data) == ELS_OPCODE_BYTE
+	     req_data_len == MAX_ELS_FRAME_PAYLOAD)) &&
-	    && req_data_len == MAX_ELS_FRAME_PAYLOAD)) &&
+	    elreq.options == EXTERNAL_LOOPBACK) {
-		elreq.options == EXTERNAL_LOOPBACK) {
 		type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
 		ql_dbg(ql_dbg_user, vha, 0x701e,
 		    "BSG request type: %s.\n", type);

drivers/scsi/qla2xxx/qla_dbg.c+2−2

@@ -1131,7 +1131,7 @@ qla24xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked) · 1130 unmodified lines
1131		1131
1132	/* Mailbox registers. */	1132	/* Mailbox registers. */
1133	mbx_reg = &reg->mailbox0;	1133	mbx_reg = &reg->mailbox0;
1134	for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, dmp_reg++)	1134	for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
1135	fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));	1135	fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
1136		1136
1137	/* Transfer sequence registers. */	1137	/* Transfer sequence registers. */
@@ -2090,7 +2090,7 @@ qla83xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked) · 952 unmodified lines
2090		2090
2091	/* Mailbox registers. */	2091	/* Mailbox registers. */
2092	mbx_reg = &reg->mailbox0;	2092	mbx_reg = &reg->mailbox0;
2093	for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, dmp_reg++)	2093	for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
2094	fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));	2094	fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
2095		2095
2096	/* Transfer sequence registers. */	2096	/* Transfer sequence registers. */

drivers/scsi/qla2xxx/qla_def.h+1−0

@@ -3425,6 +3425,7 @@ struct qla_hw_data { · 3424 unmodified lines
3425	uint8_t max_req_queues;	3425	uint8_t max_req_queues;
3426	uint8_t max_rsp_queues;	3426	uint8_t max_rsp_queues;
3427	uint8_t max_qpairs;	3427	uint8_t max_qpairs;
		3428	uint8_t num_qpairs;
3428	struct qla_qpair *base_qpair;	3429	struct qla_qpair *base_qpair;
3429	struct qla_npiv_entry *npiv_info;	3430	struct qla_npiv_entry *npiv_info;
3430	uint16_t nvram_npiv_size;	3431	uint16_t nvram_npiv_size;

drivers/scsi/qla2xxx/qla_init.c+4−1

 		/* Assign available que pair id */
 		mutex_lock(&ha->mq_lock);
 		qpair_id = find_first_zero_bit(ha->qpair_qid_map, ha->max_qpairs);
-		if (qpair_id >= ha->max_qpairs) {
+		if (ha->num_qpairs >= ha->max_qpairs) {
 			mutex_unlock(&ha->mq_lock);
 			ql_log(ql_log_warn, vha, 0x0183,
 			    "No resources to create additional q pair.\n");
 			goto fail_qid_map;
 		}
+		ha->num_qpairs++;
 		set_bit(qpair_id, ha->qpair_qid_map);
 		ha->queue_pair_map[qpair_id] = qpair;
 		qpair->id = qpair_id;
 fail_msix:
 	ha->queue_pair_map[qpair_id] = NULL;
 	clear_bit(qpair_id, ha->qpair_qid_map);
+	ha->num_qpairs--;
 	mutex_unlock(&ha->mq_lock);
 fail_qid_map:
 	kfree(qpair);
 	mutex_lock(&ha->mq_lock);
 	ha->queue_pair_map[qpair->id] = NULL;
 	clear_bit(qpair->id, ha->qpair_qid_map);
+	ha->num_qpairs--;
 	list_del(&qpair->qp_list_elem);
 	if (list_empty(&vha->qp_list))
 		vha->flags.qpairs_available = 0;

drivers/scsi/qla2xxx/qla_inline.h+7−19

 }
 static inline void
-qla2x00_clean_dsd_pool(struct qla_hw_data *ha, srb_t *sp,
+qla2x00_clean_dsd_pool(struct qla_hw_data *ha, struct crc_context *ctx)
-	struct qla_tgt_cmd *tc)
 {
-	struct dsd_dma *dsd_ptr, *tdsd_ptr;
+	struct dsd_dma *dsd, *tdsd;
-	struct crc_context *ctx;
-	if (sp)
-		ctx = (struct crc_context *)GET_CMD_CTX_SP(sp);
-	else if (tc)
-		ctx = (struct crc_context *)tc->ctx;
-	else {
-		BUG();
-		return;
-	}
 	/* clean up allocated prev pool */
-	list_for_each_entry_safe(dsd_ptr, tdsd_ptr,
+	list_for_each_entry_safe(dsd, tdsd, &ctx->dsd_list, list) {
-	    &ctx->dsd_list, list) {
+		dma_pool_free(ha->dl_dma_pool, dsd->dsd_addr,
-		dma_pool_free(ha->dl_dma_pool, dsd_ptr->dsd_addr,
+		    dsd->dsd_list_dma);
-		    dsd_ptr->dsd_list_dma);
+		list_del(&dsd->list);
-		list_del(&dsd_ptr->list);
+		kfree(dsd);
-		kfree(dsd_ptr);
 	}
 	INIT_LIST_HEAD(&ctx->dsd_list);
 }

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

@@ -3282,7 +3282,7 @@ msix_register_fail: · 3281 unmodified lines
3282	}	3282	}
3283		3283
3284	/* Enable MSI-X vector for response queue update for queue 0 */	3284	/* Enable MSI-X vector for response queue update for queue 0 */
3285	if (IS_QLA83XX(ha) \|\| IS_QLA27XX(ha)) {	3285	if (IS_QLA25XX(ha) \|\| IS_QLA83XX(ha) \|\| IS_QLA27XX(ha)) {
3286	if (ha->msixbase && ha->mqiobase &&	3286	if (ha->msixbase && ha->mqiobase &&
3287	(ha->max_rsp_queues > 1 \|\| ha->max_req_queues > 1 \|\|	3287	(ha->max_rsp_queues > 1 \|\| ha->max_req_queues > 1 \|\|
3288	ql2xmqsupport))	3288	ql2xmqsupport))

drivers/scsi/qla2xxx/qla_mbx.c+2−11

 				qlt_update_host_map(vha, id);
 			}
-			fc_host_port_name(vha->host) =
-			    wwn_to_u64(vha->port_name);
-			if (qla_ini_mode_enabled(vha))
-				ql_dbg(ql_dbg_mbx, vha, 0x1018,
-				    "FA-WWN portname %016llx (%x)\n",
-				    fc_host_port_name(vha->host),
-				    rptid_entry->vp_status);
 			set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 			set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 		} else {
 	memset(mcp->mb, 0 , sizeof(mcp->mb));
 	mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
-	mcp->mb[1] = mreq->options | BIT_6;	/* BIT_6 specifies 64bit address */
+	/* BIT_6 specifies 64bit address */
+	mcp->mb[1] = mreq->options | BIT_15 | BIT_6;
 	if (IS_CNA_CAPABLE(ha)) {
-		mcp->mb[1] |= BIT_15;
 		mcp->mb[2] = vha->fcoe_fcf_idx;
 	}
 	mcp->mb[16] = LSW(mreq->rcv_dma);

drivers/scsi/qla2xxx/qla_os.c+29−17

@@ -630,29 +630,34 @@ qla2x00_sp_free_dma(void *ptr) · 629 unmodified lines
630	sp->flags &= ~SRB_CRC_PROT_DMA_VALID;	630	sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
631	}	631	}
632		632
		633	if (!ctx)
		634	goto end;
		635
633	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {	636	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
634	/* List assured to be having elements */	637	/* List assured to be having elements */
635	qla2x00_clean_dsd_pool(ha, sp, NULL);	638	qla2x00_clean_dsd_pool(ha, ctx);
636	sp->flags &= ~SRB_CRC_CTX_DSD_VALID;	639	sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
637	}	640	}
638		641
639	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {	642	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
640	dma_pool_free(ha->dl_dma_pool, ctx,	643	struct crc_context *ctx0 = ctx;
641	((struct crc_context *)ctx)->crc_ctx_dma);	644
		645	dma_pool_free(ha->dl_dma_pool, ctx0, ctx0->crc_ctx_dma);
642	sp->flags &= ~SRB_CRC_CTX_DMA_VALID;	646	sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
643	}	647	}
644		648
645	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {	649	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
646	struct ct6_dsd ctx1 = (struct ct6_dsd )ctx;	650	struct ct6_dsd *ctx1 = ctx;
647		651
648	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,	652	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
649	ctx1->fcp_cmnd_dma);	653	ctx1->fcp_cmnd_dma);
650	list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);	654	list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
651	ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;	655	ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
652	ha->gbl_dsd_avail += ctx1->dsd_use_cnt;	656	ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
653	mempool_free(ctx1, ha->ctx_mempool);	657	mempool_free(ctx1, ha->ctx_mempool);
654	}	658	}
655		659
		660	end:
656	CMD_SP(cmd) = NULL;	661	CMD_SP(cmd) = NULL;
657	qla2x00_rel_sp(sp);	662	qla2x00_rel_sp(sp);
658	}	663	}
@@ -699,21 +704,24 @@ qla2xxx_qpair_sp_free_dma(void *ptr) · 40 unmodified lines
699	sp->flags &= ~SRB_CRC_PROT_DMA_VALID;	704	sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
700	}	705	}
701		706
		707	if (!ctx)
		708	goto end;
		709
702	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {	710	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
703	/* List assured to be having elements */	711	/* List assured to be having elements */
704	qla2x00_clean_dsd_pool(ha, sp, NULL);	712	qla2x00_clean_dsd_pool(ha, ctx);
705	sp->flags &= ~SRB_CRC_CTX_DSD_VALID;	713	sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
706	}	714	}
707		715
708	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {	716	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
709	dma_pool_free(ha->dl_dma_pool, ctx,	717	struct crc_context *ctx0 = ctx;
710	((struct crc_context *)ctx)->crc_ctx_dma);	718
		719	dma_pool_free(ha->dl_dma_pool, ctx, ctx0->crc_ctx_dma);
711	sp->flags &= ~SRB_CRC_CTX_DMA_VALID;	720	sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
712	}	721	}
713		722
714	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {	723	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
715	struct ct6_dsd ctx1 = (struct ct6_dsd )ctx;	724	struct ct6_dsd *ctx1 = ctx;
716
717	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,	725	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
718	ctx1->fcp_cmnd_dma);	726	ctx1->fcp_cmnd_dma);
719	list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);	727	list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
@@ -721,7 +729,7 @@ qla2xxx_qpair_sp_free_dma(void *ptr) · 1 unmodified line
721	ha->gbl_dsd_avail += ctx1->dsd_use_cnt;	729	ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
722	mempool_free(ctx1, ha->ctx_mempool);	730	mempool_free(ctx1, ha->ctx_mempool);
723	}	731	}
724		732	end:
725	CMD_SP(cmd) = NULL;	733	CMD_SP(cmd) = NULL;
726	qla2xxx_rel_qpair_sp(sp->qpair, sp);	734	qla2xxx_rel_qpair_sp(sp->qpair, sp);
727	}	735	}
@@ -1632,7 +1640,7 @@ qla2x00_loop_reset(scsi_qla_host_t *vha) · 904 unmodified lines
1632	void	1640	void
1633	qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)	1641	qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
1634	{	1642	{
1635	int que, cnt;	1643	int que, cnt, status;
1636	unsigned long flags;	1644	unsigned long flags;
1637	srb_t *sp;	1645	srb_t *sp;
1638	struct qla_hw_data *ha = vha->hw;	1646	struct qla_hw_data *ha = vha->hw;
@@ -1662,8 +1670,12 @@ qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res) · 23 unmodified lines
1662	*/	1670	*/
1663	sp_get(sp);	1671	sp_get(sp);
1664	spin_unlock_irqrestore(&ha->hardware_lock, flags);	1672	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1665	qla2xxx_eh_abort(GET_CMD_SP(sp));	1673	status = qla2xxx_eh_abort(GET_CMD_SP(sp));
1666	spin_lock_irqsave(&ha->hardware_lock, flags);	1674	spin_lock_irqsave(&ha->hardware_lock, flags);
		1675	/* Get rid of extra reference if immediate exit
		1676	* from ql2xxx_eh_abort */
		1677	if (status == FAILED && (qla2x00_isp_reg_stat(ha)))
		1678	atomic_dec(&sp->ref_count);
1667	}	1679	}
1668	req->outstanding_cmds[cnt] = NULL;	1680	req->outstanding_cmds[cnt] = NULL;
1669	sp->done(sp, res);	1681	sp->done(sp, res);
@@ -2623,10 +2635,10 @@ qla2x00_probe_one(struct pci_dev pdev, const struct pci_device_id id) · 953 unmodified lines
2623		2635
2624	if (mem_only) {	2636	if (mem_only) {
2625	if (pci_enable_device_mem(pdev))	2637	if (pci_enable_device_mem(pdev))
2626	goto probe_out;	2638	return ret;
2627	} else {	2639	} else {
2628	if (pci_enable_device(pdev))	2640	if (pci_enable_device(pdev))
2629	goto probe_out;	2641	return ret;
2630	}	2642	}
2631		2643
2632	/* This may fail but that's ok */	2644	/* This may fail but that's ok */
@@ -2636,7 +2648,7 @@ qla2x00_probe_one(struct pci_dev pdev, const struct pci_device_id id) · 3 unmodified lines
2636	if (!ha) {	2648	if (!ha) {
2637	ql_log_pci(ql_log_fatal, pdev, 0x0009,	2649	ql_log_pci(ql_log_fatal, pdev, 0x0009,
2638	"Unable to allocate memory for ha.\n");	2650	"Unable to allocate memory for ha.\n");
2639	goto probe_out;	2651	goto disable_device;
2640	}	2652	}
2641	ql_dbg_pci(ql_dbg_init, pdev, 0x000a,	2653	ql_dbg_pci(ql_dbg_init, pdev, 0x000a,
2642	"Memory allocated for ha=%p.\n", ha);	2654	"Memory allocated for ha=%p.\n", ha);
@@ -3254,7 +3266,7 @@ iospace_config_failed: · 611 unmodified lines
3254	pci_release_selected_regions(ha->pdev, ha->bars);	3266	pci_release_selected_regions(ha->pdev, ha->bars);
3255	kfree(ha);	3267	kfree(ha);
3256		3268
3257	probe_out:	3269	disable_device:
3258	pci_disable_device(pdev);	3270	pci_disable_device(pdev);
3259	return ret;	3271	return ret;
3260	}	3272	}

drivers/scsi/qla2xxx/qla_target.c+5−3

 		pci_unmap_sg(ha->pdev, cmd->prot_sg, cmd->prot_sg_cnt,
 			cmd->dma_data_direction);
+	if (!cmd->ctx)
+		return;
 	if (cmd->ctx_dsd_alloced)
-		qla2x00_clean_dsd_pool(ha, NULL, cmd);
+		qla2x00_clean_dsd_pool(ha, cmd->ctx);
-	if (cmd->ctx)
+	dma_pool_free(ha->dl_dma_pool, cmd->ctx, cmd->ctx->crc_ctx_dma);
-		dma_pool_free(ha->dl_dma_pool, cmd->ctx, cmd->ctx->crc_ctx_dma);
 }
 static int qlt_check_reserve_free_req(struct scsi_qla_host *vha,

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

@@ -371,7 +371,7 @@ qla27xx_fwdt_entry_t262(struct scsi_qla_host *vha, · 370 unmodified lines
371	goto done;	371	goto done;
372	}	372	}
373		373
374	if (end <= start \|\| start == 0 \|\| end == 0) {	374	if (end < start \|\| start == 0 \|\| end == 0) {
375	ql_dbg(ql_dbg_misc, vha, 0xd023,	375	ql_dbg(ql_dbg_misc, vha, 0xd023,
376	"%s: unusable range (start=%x end=%x)\n", __func__,	376	"%s: unusable range (start=%x end=%x)\n", __func__,
377	ent->t262.end_addr, ent->t262.start_addr);	377	ent->t262.end_addr, ent->t262.start_addr);

drivers/scsi/scsi_debug.c+1−1

@@ -1404,7 +1404,7 @@ static int resp_inquiry(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 1403 unmodified lines
1404	arr[4] = SDEBUG_LONG_INQ_SZ - 5;	1404	arr[4] = SDEBUG_LONG_INQ_SZ - 5;
1405	arr[5] = (int)have_dif_prot; /* PROTECT bit */	1405	arr[5] = (int)have_dif_prot; /* PROTECT bit */
1406	if (sdebug_vpd_use_hostno == 0)	1406	if (sdebug_vpd_use_hostno == 0)
1407	arr[5] = 0x10; /* claim: implicit TGPS */	1407	arr[5] \|= 0x10; /* claim: implicit TPGS */
1408	arr[6] = 0x10; /* claim: MultiP */	1408	arr[6] = 0x10; /* claim: MultiP */
1409	/* arr[6] \|= 0x40; ... claim: EncServ (enclosure services) */	1409	/* arr[6] \|= 0x40; ... claim: EncServ (enclosure services) */
1410	arr[7] = 0xa; /* claim: LINKED + CMDQUE */	1410	arr[7] = 0xa; /* claim: LINKED + CMDQUE */

drivers/staging/ccree/Kconfig+1−1

@@ -1,6 +1,6 @@
1	config CRYPTO_DEV_CCREE	1	config CRYPTO_DEV_CCREE
2	tristate "Support for ARM TrustZone CryptoCell C7XX family of Crypto accelerators"	2	tristate "Support for ARM TrustZone CryptoCell C7XX family of Crypto accelerators"
3	depends on CRYPTO_HW && OF && HAS_DMA	3	depends on CRYPTO && CRYPTO_HW && OF && HAS_DMA
4	default n	4	default n
5	select CRYPTO_HASH	5	select CRYPTO_HASH
6	select CRYPTO_BLKCIPHER	6	select CRYPTO_BLKCIPHER

drivers/staging/ccree/ssi_buffer_mgr.c+2−1

@@ -216,7 +216,8 @@ void ssi_buffer_mgr_copy_scatterlist_portion( · 215 unmodified lines
216	uint32_t nents, lbytes;	216	uint32_t nents, lbytes;
217		217
218	nents = ssi_buffer_mgr_get_sgl_nents(sg, end, &lbytes, NULL);	218	nents = ssi_buffer_mgr_get_sgl_nents(sg, end, &lbytes, NULL);
219	sg_copy_buffer(sg, nents, (void *)dest, (end - to_skip), 0, (direct == SSI_SG_TO_BUF));	219	sg_copy_buffer(sg, nents, (void *)dest, (end - to_skip + 1), to_skip,
		220	(direct == SSI_SG_TO_BUF));
220	}	221	}
221		222
222	static inline int ssi_buffer_mgr_render_buff_to_mlli(	223	static inline int ssi_buffer_mgr_render_buff_to_mlli(

drivers/staging/lustre/lustre/lov/lov_pack.c+0−9

 	size_t lmmk_size;
 	size_t lum_size;
 	int rc;
-	mm_segment_t seg;
 	if (!lsm)
 		return -ENODATA;
-	/*
-	 * "Switch to kernel segment" to allow copying from kernel space by
-	 * copy_{to,from}_user().
-	 */
-	seg = get_fs();
-	set_fs(KERNEL_DS);
 	if (lsm->lsm_magic != LOV_MAGIC_V1 && lsm->lsm_magic != LOV_MAGIC_V3) {
 		CERROR("bad LSM MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
 		       lsm->lsm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
 out_free:
 	kvfree(lmmk);
 out:
-	set_fs(seg);
 	return rc;
 }

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

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

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

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

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

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

drivers/usb/chipidea/core.c+4−1

@@ -843,7 +843,10 @@ static ssize_t ci_role_show(struct device dev, struct device_attribute attr, · 842 unmodified lines
843	{	843	{
844	struct ci_hdrc *ci = dev_get_drvdata(dev);	844	struct ci_hdrc *ci = dev_get_drvdata(dev);
845		845
846	return sprintf(buf, "%s\n", ci_role(ci)->name);	846	if (ci->role != CI_ROLE_END)
		847	return sprintf(buf, "%s\n", ci_role(ci)->name);
		848
		849	return 0;
847	}	850	}
848		851
849	static ssize_t ci_role_store(struct device *dev,	852	static ssize_t ci_role_store(struct device *dev,

drivers/usb/chipidea/debug.c+2−1

@@ -294,7 +294,8 @@ static int ci_role_show(struct seq_file s, void data) · 293 unmodified lines
294	{	294	{
295	struct ci_hdrc *ci = s->private;	295	struct ci_hdrc *ci = s->private;
296		296
297	seq_printf(s, "%s\n", ci_role(ci)->name);	297	if (ci->role != CI_ROLE_END)
		298	seq_printf(s, "%s\n", ci_role(ci)->name);
298		299
299	return 0;	300	return 0;
300	}	301	}

drivers/usb/chipidea/udc.c+6−2

 int ci_hdrc_gadget_init(struct ci_hdrc *ci)
 {
 	struct ci_role_driver *rdrv;
+	int ret;
 	if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DC))
 		return -ENXIO;
 	rdrv->stop	= udc_id_switch_for_host;
 	rdrv->irq	= udc_irq;
 	rdrv->name	= "gadget";
-	ci->roles[CI_ROLE_GADGET] = rdrv;
-	return udc_start(ci);
+	ret = udc_start(ci);
+	if (!ret)
+		ci->roles[CI_ROLE_GADGET] = rdrv;
+	return ret;
 }

drivers/usb/chipidea/usbmisc_imx.c+32−9

@@ -108,6 +108,8 @@ struct imx_usbmisc { · 107 unmodified lines
108	const struct usbmisc_ops *ops;	108	const struct usbmisc_ops *ops;
109	};	109	};
110		110
		111	static inline bool is_imx53_usbmisc(struct imx_usbmisc_data *data);
		112
111	static int usbmisc_imx25_init(struct imx_usbmisc_data *data)	113	static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
112	{	114	{
113	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);	115	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
@@ -242,10 +244,15 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data) · 128 unmodified lines
242	val = readl(reg) \| MX53_USB_UHx_CTRL_WAKE_UP_EN	244	val = readl(reg) \| MX53_USB_UHx_CTRL_WAKE_UP_EN
243	\| MX53_USB_UHx_CTRL_ULPI_INT_EN;	245	\| MX53_USB_UHx_CTRL_ULPI_INT_EN;
244	writel(val, reg);	246	writel(val, reg);
245	/* Disable internal 60Mhz clock */	247	if (is_imx53_usbmisc(data)) {
246	reg = usbmisc->base + MX53_USB_CLKONOFF_CTRL_OFFSET;	248	/* Disable internal 60Mhz clock */
247	val = readl(reg) \| MX53_USB_CLKONOFF_CTRL_H2_INT60CKOFF;	249	reg = usbmisc->base +
248	writel(val, reg);	250	MX53_USB_CLKONOFF_CTRL_OFFSET;
		251	val = readl(reg) \|
		252	MX53_USB_CLKONOFF_CTRL_H2_INT60CKOFF;
		253	writel(val, reg);
		254	}
		255
249	}	256	}
250	if (data->disable_oc) {	257	if (data->disable_oc) {
251	reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;	258	reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
@@ -267,10 +274,15 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data) · 15 unmodified lines
267	val = readl(reg) \| MX53_USB_UHx_CTRL_WAKE_UP_EN	274	val = readl(reg) \| MX53_USB_UHx_CTRL_WAKE_UP_EN
268	\| MX53_USB_UHx_CTRL_ULPI_INT_EN;	275	\| MX53_USB_UHx_CTRL_ULPI_INT_EN;
269	writel(val, reg);	276	writel(val, reg);
270	/* Disable internal 60Mhz clock */	277
271	reg = usbmisc->base + MX53_USB_CLKONOFF_CTRL_OFFSET;	278	if (is_imx53_usbmisc(data)) {
272	val = readl(reg) \| MX53_USB_CLKONOFF_CTRL_H3_INT60CKOFF;	279	/* Disable internal 60Mhz clock */
273	writel(val, reg);	280	reg = usbmisc->base +
		281	MX53_USB_CLKONOFF_CTRL_OFFSET;
		282	val = readl(reg) \|
		283	MX53_USB_CLKONOFF_CTRL_H3_INT60CKOFF;
		284	writel(val, reg);
		285	}
274	}	286	}
275	if (data->disable_oc) {	287	if (data->disable_oc) {
276	reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;	288	reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
@@ -456,6 +468,10 @@ static const struct usbmisc_ops imx27_usbmisc_ops = { · 179 unmodified lines
456	.init = usbmisc_imx27_init,	468	.init = usbmisc_imx27_init,
457	};	469	};
458		470
		471	static const struct usbmisc_ops imx51_usbmisc_ops = {
		472	.init = usbmisc_imx53_init,
		473	};
		474
459	static const struct usbmisc_ops imx53_usbmisc_ops = {	475	static const struct usbmisc_ops imx53_usbmisc_ops = {
460	.init = usbmisc_imx53_init,	476	.init = usbmisc_imx53_init,
461	};	477	};
@@ -479,6 +495,13 @@ static const struct usbmisc_ops imx7d_usbmisc_ops = { · 17 unmodified lines
479	.set_wakeup = usbmisc_imx7d_set_wakeup,	495	.set_wakeup = usbmisc_imx7d_set_wakeup,
480	};	496	};
481		497
		498	static inline bool is_imx53_usbmisc(struct imx_usbmisc_data *data)
		499	{
		500	struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
		501
		502	return usbmisc->ops == &imx53_usbmisc_ops;
		503	}
		504
482	int imx_usbmisc_init(struct imx_usbmisc_data *data)	505	int imx_usbmisc_init(struct imx_usbmisc_data *data)
483	{	506	{
484	struct imx_usbmisc *usbmisc;	507	struct imx_usbmisc *usbmisc;
@@ -536,7 +559,7 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = { · 51 unmodified lines
536	},	559	},
537	{	560	{
538	.compatible = "fsl,imx51-usbmisc",	561	.compatible = "fsl,imx51-usbmisc",
539	.data = &imx53_usbmisc_ops,	562	.data = &imx51_usbmisc_ops,
540	},	563	},
541	{	564	{
542	.compatible = "fsl,imx53-usbmisc",	565	.compatible = "fsl,imx53-usbmisc",

drivers/usb/dwc2/params.c+2−0

 	{ .compatible = "lantiq,xrx200-usb", .data = dwc2_set_ltq_params },
 	{ .compatible = "snps,dwc2" },
 	{ .compatible = "samsung,s3c6400-hsotg" },
+	{ .compatible = "amlogic,meson8-usb",
+	  .data = dwc2_set_amlogic_params },
 	{ .compatible = "amlogic,meson8b-usb",
 	  .data = dwc2_set_amlogic_params },
 	{ .compatible = "amlogic,meson-gxbb-usb",

drivers/usb/gadget/function/f_mass_storage.c+11−2

@@ -396,7 +396,11 @@ static int fsg_set_halt(struct fsg_dev fsg, struct usb_ep ep) · 395 unmodified lines
396	/* Caller must hold fsg->lock */	396	/* Caller must hold fsg->lock */
397	static void wakeup_thread(struct fsg_common *common)	397	static void wakeup_thread(struct fsg_common *common)
398	{	398	{
399	smp_wmb(); /* ensure the write of bh->state is complete */	399	/*
		400	* Ensure the reading of thread_wakeup_needed
		401	* and the writing of bh->state are completed
		402	*/
		403	smp_mb();
400	/* Tell the main thread that something has happened */	404	/* Tell the main thread that something has happened */
401	common->thread_wakeup_needed = 1;	405	common->thread_wakeup_needed = 1;
402	if (common->thread_task)	406	if (common->thread_task)
@@ -627,7 +631,12 @@ static int sleep_thread(struct fsg_common *common, bool can_freeze) · 224 unmodified lines
627	}	631	}
628	__set_current_state(TASK_RUNNING);	632	__set_current_state(TASK_RUNNING);
629	common->thread_wakeup_needed = 0;	633	common->thread_wakeup_needed = 0;
630	smp_rmb(); /* ensure the latest bh->state is visible */	634
		635	/*
		636	* Ensure the writing of thread_wakeup_needed
		637	* and the reading of bh->state are completed
		638	*/
		639	smp_mb();
631	return rc;	640	return rc;
632	}	641	}
633		642

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

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

drivers/usb/gadget/udc/renesas_usb3.c+32−13

@@ -623,7 +623,6 @@ static void renesas_usb3_stop_controller(struct renesas_usb3 *usb3) · 622 unmodified lines
623	{	623	{
624	usb3_disconnect(usb3);	624	usb3_disconnect(usb3);
625	usb3_write(usb3, 0, USB3_P0_INT_ENA);	625	usb3_write(usb3, 0, USB3_P0_INT_ENA);
626	usb3_write(usb3, 0, USB3_PN_INT_ENA);
627	usb3_write(usb3, 0, USB3_USB_OTG_INT_ENA);	626	usb3_write(usb3, 0, USB3_USB_OTG_INT_ENA);
628	usb3_write(usb3, 0, USB3_USB_INT_ENA_1);	627	usb3_write(usb3, 0, USB3_USB_INT_ENA_1);
629	usb3_write(usb3, 0, USB3_USB_INT_ENA_2);	628	usb3_write(usb3, 0, USB3_USB_INT_ENA_2);
@@ -1475,7 +1474,13 @@ static void usb3_request_done_pipen(struct renesas_usb3 *usb3, · 845 unmodified lines
1475	struct renesas_usb3_request *usb3_req,	1474	struct renesas_usb3_request *usb3_req,
1476	int status)	1475	int status)
1477	{	1476	{
1478	usb3_pn_stop(usb3);	1477	unsigned long flags;
		1478
		1479	spin_lock_irqsave(&usb3->lock, flags);
		1480	if (usb3_pn_change(usb3, usb3_ep->num))
		1481	usb3_pn_stop(usb3);
		1482	spin_unlock_irqrestore(&usb3->lock, flags);
		1483
1479	usb3_disable_pipe_irq(usb3, usb3_ep->num);	1484	usb3_disable_pipe_irq(usb3, usb3_ep->num);
1480	usb3_request_done(usb3_ep, usb3_req, status);	1485	usb3_request_done(usb3_ep, usb3_req, status);
1481		1486
@@ -1504,30 +1509,46 @@ static void usb3_irq_epc_pipen_bfrdy(struct renesas_usb3 *usb3, int num) · 22 unmodified lines
1504	{	1509	{
1505	struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);	1510	struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);
1506	struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);	1511	struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
		1512	bool done = false;
1507		1513
1508	if (!usb3_req)	1514	if (!usb3_req)
1509	return;	1515	return;
1510		1516
		1517	spin_lock(&usb3->lock);
		1518	if (usb3_pn_change(usb3, num))
		1519	goto out;
		1520
1511	if (usb3_ep->dir_in) {	1521	if (usb3_ep->dir_in) {
1512	/* Do not stop the IN pipe here to detect LSTTR interrupt */	1522	/* Do not stop the IN pipe here to detect LSTTR interrupt */
1513	if (!usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE))	1523	if (!usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE))
1514	usb3_clear_bit(usb3, PN_INT_BFRDY, USB3_PN_INT_ENA);	1524	usb3_clear_bit(usb3, PN_INT_BFRDY, USB3_PN_INT_ENA);
1515	} else {	1525	} else {
1516	if (!usb3_read_pipe(usb3_ep, usb3_req, USB3_PN_READ))	1526	if (!usb3_read_pipe(usb3_ep, usb3_req, USB3_PN_READ))
1517	usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);	1527	done = true;
1518	}	1528	}
		1529
		1530	out:
		1531	/* need to unlock because usb3_request_done_pipen() locks it */
		1532	spin_unlock(&usb3->lock);
		1533
		1534	if (done)
		1535	usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);
1519	}	1536	}
1520		1537
1521	static void usb3_irq_epc_pipen(struct renesas_usb3 *usb3, int num)	1538	static void usb3_irq_epc_pipen(struct renesas_usb3 *usb3, int num)
1522	{	1539	{
1523	u32 pn_int_sta;	1540	u32 pn_int_sta;
1524		1541
1525	if (usb3_pn_change(usb3, num) < 0)	1542	spin_lock(&usb3->lock);
		1543	if (usb3_pn_change(usb3, num) < 0) {
		1544	spin_unlock(&usb3->lock);
1526	return;	1545	return;
		1546	}
1527		1547
1528	pn_int_sta = usb3_read(usb3, USB3_PN_INT_STA);	1548	pn_int_sta = usb3_read(usb3, USB3_PN_INT_STA);
1529	pn_int_sta &= usb3_read(usb3, USB3_PN_INT_ENA);	1549	pn_int_sta &= usb3_read(usb3, USB3_PN_INT_ENA);
1530	usb3_write(usb3, pn_int_sta, USB3_PN_INT_STA);	1550	usb3_write(usb3, pn_int_sta, USB3_PN_INT_STA);
		1551	spin_unlock(&usb3->lock);
1531	if (pn_int_sta & PN_INT_LSTTR)	1552	if (pn_int_sta & PN_INT_LSTTR)
1532	usb3_irq_epc_pipen_lsttr(usb3, num);	1553	usb3_irq_epc_pipen_lsttr(usb3, num);
1533	if (pn_int_sta & PN_INT_BFRDY)	1554	if (pn_int_sta & PN_INT_BFRDY)
@@ -1660,6 +1681,7 @@ static int usb3_disable_pipe_n(struct renesas_usb3_ep *usb3_ep) · 126 unmodified lines
1660		1681
1661	spin_lock_irqsave(&usb3->lock, flags);	1682	spin_lock_irqsave(&usb3->lock, flags);
1662	if (!usb3_pn_change(usb3, usb3_ep->num)) {	1683	if (!usb3_pn_change(usb3, usb3_ep->num)) {
		1684	usb3_write(usb3, 0, USB3_PN_INT_ENA);
1663	usb3_write(usb3, 0, USB3_PN_RAMMAP);	1685	usb3_write(usb3, 0, USB3_PN_RAMMAP);
1664	usb3_clear_bit(usb3, PN_CON_EN, USB3_PN_CON);	1686	usb3_clear_bit(usb3, PN_CON_EN, USB3_PN_CON);
1665	}	1687	}
@@ -1799,6 +1821,9 @@ static int renesas_usb3_start(struct usb_gadget *gadget, · 133 unmodified lines
1799	/* hook up the driver */	1821	/* hook up the driver */
1800	usb3->driver = driver;	1822	usb3->driver = driver;
1801		1823
		1824	pm_runtime_enable(usb3_to_dev(usb3));
		1825	pm_runtime_get_sync(usb3_to_dev(usb3));
		1826
1802	renesas_usb3_init_controller(usb3);	1827	renesas_usb3_init_controller(usb3);
1803		1828
1804	return 0;	1829	return 0;
@@ -1807,14 +1832,14 @@ static int renesas_usb3_start(struct usb_gadget *gadget, · 2 unmodified lines
1807	static int renesas_usb3_stop(struct usb_gadget *gadget)	1832	static int renesas_usb3_stop(struct usb_gadget *gadget)
1808	{	1833	{
1809	struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);	1834	struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);
1810	unsigned long flags;
1811		1835
1812	spin_lock_irqsave(&usb3->lock, flags);
1813	usb3->softconnect = false;	1836	usb3->softconnect = false;
1814	usb3->gadget.speed = USB_SPEED_UNKNOWN;	1837	usb3->gadget.speed = USB_SPEED_UNKNOWN;
1815	usb3->driver = NULL;	1838	usb3->driver = NULL;
1816	renesas_usb3_stop_controller(usb3);	1839	renesas_usb3_stop_controller(usb3);
1817	spin_unlock_irqrestore(&usb3->lock, flags);	1840
		1841	pm_runtime_put(usb3_to_dev(usb3));
		1842	pm_runtime_disable(usb3_to_dev(usb3));
1818		1843
1819	return 0;	1844	return 0;
1820	}	1845	}
@@ -1891,9 +1916,6 @@ static int renesas_usb3_remove(struct platform_device *pdev) · 70 unmodified lines
1891		1916
1892	device_remove_file(&pdev->dev, &dev_attr_role);	1917	device_remove_file(&pdev->dev, &dev_attr_role);
1893		1918
1894	pm_runtime_put(&pdev->dev);
1895	pm_runtime_disable(&pdev->dev);
1896
1897	usb_del_gadget_udc(&usb3->gadget);	1919	usb_del_gadget_udc(&usb3->gadget);
1898		1920
1899	__renesas_usb3_ep_free_request(usb3->ep0_req);	1921	__renesas_usb3_ep_free_request(usb3->ep0_req);
@@ -2099,9 +2121,6 @@ static int renesas_usb3_probe(struct platform_device *pdev) · 199 unmodified lines
2099		2121
2100	usb3->workaround_for_vbus = priv->workaround_for_vbus;	2122	usb3->workaround_for_vbus = priv->workaround_for_vbus;
2101		2123
2102	pm_runtime_enable(&pdev->dev);
2103	pm_runtime_get_sync(&pdev->dev);
2104
2105	dev_info(&pdev->dev, "probed\n");	2124	dev_info(&pdev->dev, "probed\n");
2106		2125
2107	return 0;	2126	return 0;

drivers/usb/musb/musb_dsps.c+5−0

 		dsps_mod_timer_optional(glue);
 		break;
 	case OTG_STATE_A_WAIT_BCON:
+		/* keep VBUS on for host-only mode */
+		if (musb->port_mode == MUSB_PORT_MODE_HOST) {
+			dsps_mod_timer_optional(glue);
+			break;
+		}
 		musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 		skip_session = 1;
 		/* fall */

drivers/xen/privcmd.c+2−2

@@ -362,8 +362,8 @@ static int mmap_batch_fn(void data, int nr, void state) · 361 unmodified lines
362	st->global_error = 1;	362	st->global_error = 1;
363	}	363	}
364	}	364	}
365	st->va += PAGE_SIZE * nr;	365	st->va += XEN_PAGE_SIZE * nr;
366	st->index += nr;	366	st->index += nr / XEN_PFN_PER_PAGE;
367		367
368	return 0;	368	return 0;
369	}	369	}

fs/btrfs/ctree.h+2−2

@@ -2563,7 +2563,7 @@ u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes); · 2562 unmodified lines
2563	static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,	2563	static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
2564	unsigned num_items)	2564	unsigned num_items)
2565	{	2565	{
2566	return fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;	2566	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2567	}	2567	}
2568		2568
2569	/*	2569	/*
@@ -2573,7 +2573,7 @@ static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info, · 3 unmodified lines
2573	static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,	2573	static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
2574	unsigned num_items)	2574	unsigned num_items)
2575	{	2575	{
2576	return fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;	2576	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2577	}	2577	}
2578		2578
2579	int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,	2579	int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,

fs/btrfs/dir-item.c+1−1

@@ -468,7 +468,7 @@ int verify_dir_item(struct btrfs_fs_info *fs_info, · 467 unmodified lines
468		468
469	if (btrfs_dir_name_len(leaf, dir_item) > namelen) {	469	if (btrfs_dir_name_len(leaf, dir_item) > namelen) {
470	btrfs_crit(fs_info, "invalid dir item name len: %u",	470	btrfs_crit(fs_info, "invalid dir item name len: %u",
471	(unsigned)btrfs_dir_data_len(leaf, dir_item));	471	(unsigned)btrfs_dir_name_len(leaf, dir_item));
472	return 1;	472	return 1;
473	}	473	}
474		474

fs/btrfs/disk-io.c+6−4

 		 * we fua the first super.  The others we allow
 		 * to go down lazy.
 		 */
-		if (i == 0)
+		if (i == 0) {
-			ret = btrfsic_submit_bh(REQ_OP_WRITE, REQ_FUA, bh);
+			ret = btrfsic_submit_bh(REQ_OP_WRITE,
-		else
+						REQ_SYNC | REQ_FUA, bh);
+		} else {
 			ret = btrfsic_submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);
+		}
 		if (ret)
 			errors++;
 	}
 	bio->bi_end_io = btrfs_end_empty_barrier;
 	bio->bi_bdev = device->bdev;
-	bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
+	bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH;
 	init_completion(&device->flush_wait);
 	bio->bi_private = &device->flush_wait;
 	device->flush_bio = bio;

fs/btrfs/extent-tree.c+4−3

 				    info->space_info_kobj, "%s",
 				    alloc_name(found->flags));
 	if (ret) {
+		percpu_counter_destroy(&found->total_bytes_pinned);
 		kfree(found);
 		return ret;
 	}
 	spin_unlock(&delayed_rsv->lock);
 commit:
-	trans = btrfs_join_transaction(fs_info->fs_root);
+	trans = btrfs_join_transaction(fs_info->extent_root);
 	if (IS_ERR(trans))
 		return -ENOSPC;
 		       struct btrfs_space_info *space_info, u64 num_bytes,
 		       u64 orig_bytes, int state)
 {
-	struct btrfs_root *root = fs_info->fs_root;
+	struct btrfs_root *root = fs_info->extent_root;
 	struct btrfs_trans_handle *trans;
 	int nr;
 	int ret = 0;
 	int flush_state = FLUSH_DELAYED_ITEMS_NR;
 	spin_lock(&space_info->lock);
-	to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info->fs_root,
+	to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info->extent_root,
 						      space_info);
 	if (!to_reclaim) {
 		spin_unlock(&space_info->lock);

fs/btrfs/extent_io.c+123−3

@@ -2458,7 +2458,7 @@ void end_extent_writepage(struct page *page, int err, u64 start, u64 end) · 2457 unmodified lines
2458	if (!uptodate) {	2458	if (!uptodate) {
2459	ClearPageUptodate(page);	2459	ClearPageUptodate(page);
2460	SetPageError(page);	2460	SetPageError(page);
2461	ret = ret < 0 ? ret : -EIO;	2461	ret = err < 0 ? err : -EIO;
2462	mapping_set_error(page->mapping, ret);	2462	mapping_set_error(page->mapping, ret);
2463	}	2463	}
2464	}	2464	}
@@ -4377,6 +4377,123 @@ static struct extent_map get_extent_skip_holes(struct inode inode, · 1912 unmodified lines
4377	return NULL;	4377	return NULL;
4378	}	4378	}
4379		4379
		4380	/*
		4381	* To cache previous fiemap extent
		4382	*
		4383	* Will be used for merging fiemap extent
		4384	*/
		4385	struct fiemap_cache {
		4386	u64 offset;
		4387	u64 phys;
		4388	u64 len;
		4389	u32 flags;
		4390	bool cached;
		4391	};
		4392
		4393	/*
		4394	* Helper to submit fiemap extent.
		4395	*
		4396	* Will try to merge current fiemap extent specified by @offset, @phys,
		4397	* @len and @flags with cached one.
		4398	* And only when we fails to merge, cached one will be submitted as
		4399	* fiemap extent.
		4400	*
		4401	* Return value is the same as fiemap_fill_next_extent().
		4402	*/
		4403	static int emit_fiemap_extent(struct fiemap_extent_info *fieinfo,
		4404	struct fiemap_cache *cache,
		4405	u64 offset, u64 phys, u64 len, u32 flags)
		4406	{
		4407	int ret = 0;
		4408
		4409	if (!cache->cached)
		4410	goto assign;
		4411
		4412	/*
		4413	* Sanity check, extent_fiemap() should have ensured that new
		4414	* fiemap extent won't overlap with cahced one.
		4415	* Not recoverable.
		4416	*
		4417	* NOTE: Physical address can overlap, due to compression
		4418	*/
		4419	if (cache->offset + cache->len > offset) {
		4420	WARN_ON(1);
		4421	return -EINVAL;
		4422	}
		4423
		4424	/*
		4425	* Only merges fiemap extents if
		4426	* 1) Their logical addresses are continuous
		4427	*
		4428	* 2) Their physical addresses are continuous
		4429	* So truly compressed (physical size smaller than logical size)
		4430	* extents won't get merged with each other
		4431	*
		4432	* 3) Share same flags except FIEMAP_EXTENT_LAST
		4433	* So regular extent won't get merged with prealloc extent
		4434	*/
		4435	if (cache->offset + cache->len == offset &&
		4436	cache->phys + cache->len == phys &&
		4437	(cache->flags & ~FIEMAP_EXTENT_LAST) ==
		4438	(flags & ~FIEMAP_EXTENT_LAST)) {
		4439	cache->len += len;
		4440	cache->flags \|= flags;
		4441	goto try_submit_last;
		4442	}
		4443
		4444	/* Not mergeable, need to submit cached one */
		4445	ret = fiemap_fill_next_extent(fieinfo, cache->offset, cache->phys,
		4446	cache->len, cache->flags);
		4447	cache->cached = false;
		4448	if (ret)
		4449	return ret;
		4450	assign:
		4451	cache->cached = true;
		4452	cache->offset = offset;
		4453	cache->phys = phys;
		4454	cache->len = len;
		4455	cache->flags = flags;
		4456	try_submit_last:
		4457	if (cache->flags & FIEMAP_EXTENT_LAST) {
		4458	ret = fiemap_fill_next_extent(fieinfo, cache->offset,
		4459	cache->phys, cache->len, cache->flags);
		4460	cache->cached = false;
		4461	}
		4462	return ret;
		4463	}
		4464
		4465	/*
		4466	* Sanity check for fiemap cache
		4467	*
		4468	* All fiemap cache should be submitted by emit_fiemap_extent()
		4469	* Iteration should be terminated either by last fiemap extent or
		4470	* fieinfo->fi_extents_max.
		4471	* So no cached fiemap should exist.
		4472	*/
		4473	static int check_fiemap_cache(struct btrfs_fs_info *fs_info,
		4474	struct fiemap_extent_info *fieinfo,
		4475	struct fiemap_cache *cache)
		4476	{
		4477	int ret;
		4478
		4479	if (!cache->cached)
		4480	return 0;
		4481
		4482	/* Small and recoverbale problem, only to info developer */
		4483	#ifdef CONFIG_BTRFS_DEBUG
		4484	WARN_ON(1);
		4485	#endif
		4486	btrfs_warn(fs_info,
		4487	"unhandled fiemap cache detected: offset=%llu phys=%llu len=%llu flags=0x%x",
		4488	cache->offset, cache->phys, cache->len, cache->flags);
		4489	ret = fiemap_fill_next_extent(fieinfo, cache->offset, cache->phys,
		4490	cache->len, cache->flags);
		4491	cache->cached = false;
		4492	if (ret > 0)
		4493	ret = 0;
		4494	return ret;
		4495	}
		4496
4380	int extent_fiemap(struct inode inode, struct fiemap_extent_info fieinfo,	4497	int extent_fiemap(struct inode inode, struct fiemap_extent_info fieinfo,
4381	__u64 start, __u64 len, get_extent_t *get_extent)	4498	__u64 start, __u64 len, get_extent_t *get_extent)
4382	{	4499	{
@@ -4394,6 +4511,7 @@ int extent_fiemap(struct inode inode, struct fiemap_extent_info fieinfo, · 11 unmodified lines
4394	struct extent_state *cached_state = NULL;	4511	struct extent_state *cached_state = NULL;
4395	struct btrfs_path *path;	4512	struct btrfs_path *path;
4396	struct btrfs_root *root = BTRFS_I(inode)->root;	4513	struct btrfs_root *root = BTRFS_I(inode)->root;
		4514	struct fiemap_cache cache = { 0 };
4397	int end = 0;	4515	int end = 0;
4398	u64 em_start = 0;	4516	u64 em_start = 0;
4399	u64 em_len = 0;	4517	u64 em_len = 0;
@@ -4573,8 +4691,8 @@ int extent_fiemap(struct inode inode, struct fiemap_extent_info fieinfo, · 173 unmodified lines
4573	flags \|= FIEMAP_EXTENT_LAST;	4691	flags \|= FIEMAP_EXTENT_LAST;
4574	end = 1;	4692	end = 1;
4575	}	4693	}
4576	ret = fiemap_fill_next_extent(fieinfo, em_start, disko,	4694	ret = emit_fiemap_extent(fieinfo, &cache, em_start, disko,
4577	em_len, flags);	4695	em_len, flags);
4578	if (ret) {	4696	if (ret) {
4579	if (ret == 1)	4697	if (ret == 1)
4580	ret = 0;	4698	ret = 0;
@@ -4582,6 +4700,8 @@ int extent_fiemap(struct inode inode, struct fiemap_extent_info fieinfo, · 1 unmodified line
4582	}	4700	}
4583	}	4701	}
4584	out_free:	4702	out_free:
		4703	if (!ret)
		4704	ret = check_fiemap_cache(root->fs_info, fieinfo, &cache);
4585	free_extent_map(em);	4705	free_extent_map(em);
4586	out:	4706	out:
4587	btrfs_free_path(path);	4707	btrfs_free_path(path);

fs/btrfs/hash.c+4−1

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

fs/btrfs/inode.c+3−3

@@ -2952,7 +2952,7 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) · 2951 unmodified lines
2952		2952
2953	ret = test_range_bit(io_tree, ordered_extent->file_offset,	2953	ret = test_range_bit(io_tree, ordered_extent->file_offset,
2954	ordered_extent->file_offset + ordered_extent->len - 1,	2954	ordered_extent->file_offset + ordered_extent->len - 1,
2955	EXTENT_DEFRAG, 1, cached_state);	2955	EXTENT_DEFRAG, 0, cached_state);
2956	if (ret) {	2956	if (ret) {
2957	u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item);	2957	u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item);
2958	if (0 && last_snapshot >= BTRFS_I(inode)->generation)	2958	if (0 && last_snapshot >= BTRFS_I(inode)->generation)
@@ -7483,8 +7483,8 @@ bool btrfs_page_exists_in_range(struct inode *inode, loff_t start, loff_t end) · 4524 unmodified lines
7483	int found = false;	7483	int found = false;
7484	void **pagep = NULL;	7484	void **pagep = NULL;
7485	struct page *page = NULL;	7485	struct page *page = NULL;
7486	int start_idx;	7486	unsigned long start_idx;
7487	int end_idx;	7487	unsigned long end_idx;
7488		7488
7489	start_idx = start >> PAGE_SHIFT;	7489	start_idx = start >> PAGE_SHIFT;
7490		7490

fs/ext4/acl.c+4−0

  * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
  */
+#include <linux/quotaops.h>
 #include "ext4_jbd2.h"
 #include "ext4.h"
 #include "xattr.h"
 	handle_t *handle;
 	int error, retries = 0;
+	error = dquot_initialize(inode);
+	if (error)
+		return error;
 retry:
 	handle = ext4_journal_start(inode, EXT4_HT_XATTR,
 				    ext4_jbd2_credits_xattr(inode));

fs/ext4/ext4.h+0−2

 			   int buf_size,
 			   struct inode *dir,
 			   struct ext4_filename *fname,
-			   const struct qstr *d_name,
 			   unsigned int offset,
 			   struct ext4_dir_entry_2 **res_dir);
 extern int ext4_generic_delete_entry(handle_t *handle,
 				   int *has_inline_data);
 extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 					struct ext4_filename *fname,
-					const struct qstr *d_name,
 					struct ext4_dir_entry_2 **res_dir,
 					int *has_inline_data);
 extern int ext4_delete_inline_entry(handle_t *handle,

fs/ext4/extents.c+42−43

 	struct ext4_sb_info *sbi;
 	struct ext4_extent_header *eh;
 	struct ext4_map_blocks split_map;
-	struct ext4_extent zero_ex;
+	struct ext4_extent zero_ex1, zero_ex2;
 	struct ext4_extent *ex, *abut_ex;
 	ext4_lblk_t ee_block, eof_block;
 	unsigned int ee_len, depth, map_len = map->m_len;
 	int allocated = 0, max_zeroout = 0;
 	int err = 0;
-	int split_flag = 0;
+	int split_flag = EXT4_EXT_DATA_VALID2;
 	ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical"
 		"block %llu, max_blocks %u\n", inode->i_ino,
 	ex = path[depth].p_ext;
 	ee_block = le32_to_cpu(ex->ee_block);
 	ee_len = ext4_ext_get_actual_len(ex);
-	zero_ex.ee_len = 0;
+	zero_ex1.ee_len = 0;
+	zero_ex2.ee_len = 0;
 	trace_ext4_ext_convert_to_initialized_enter(inode, map, ex);
 	if (ext4_encrypted_inode(inode))
 		max_zeroout = 0;
-	/* If extent is less than s_max_zeroout_kb, zeroout directly */
-	if (max_zeroout && (ee_len <= max_zeroout)) {
-		err = ext4_ext_zeroout(inode, ex);
-		if (err)
-			goto out;
-		zero_ex.ee_block = ex->ee_block;
-		zero_ex.ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex));
-		ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex));
-		err = ext4_ext_get_access(handle, inode, path + depth);
-		if (err)
-			goto out;
-		ext4_ext_mark_initialized(ex);
-		ext4_ext_try_to_merge(handle, inode, path, ex);
-		err = ext4_ext_dirty(handle, inode, path + path->p_depth);
-		goto out;
-	}
 	/*
-	 * four cases:
+	 * five cases:
 	 * 1. split the extent into three extents.
-	 * 2. split the extent into two extents, zeroout the first half.
+	 * 2. split the extent into two extents, zeroout the head of the first
-	 * 3. split the extent into two extents, zeroout the second half.
+	 *    extent.
+	 * 3. split the extent into two extents, zeroout the tail of the second
+	 *    extent.
 	 * 4. split the extent into two extents with out zeroout.
+	 * 5. no splitting needed, just possibly zeroout the head and / or the
+	 *    tail of the extent.
 	 */
 	split_map.m_lblk = map->m_lblk;
 	split_map.m_len = map->m_len;
-	if (max_zeroout && (allocated > map->m_len)) {
+	if (max_zeroout && (allocated > split_map.m_len)) {
 		if (allocated <= max_zeroout) {
-			/* case 3 */
+			/* case 3 or 5 */
-			zero_ex.ee_block =
+			zero_ex1.ee_block =
-					 cpu_to_le32(map->m_lblk);
+				 cpu_to_le32(split_map.m_lblk +
-			zero_ex.ee_len = cpu_to_le16(allocated);
+					     split_map.m_len);
-			ext4_ext_store_pblock(&zero_ex,
+			zero_ex1.ee_len =
-				ext4_ext_pblock(ex) + map->m_lblk - ee_block);
+				cpu_to_le16(allocated - split_map.m_len);
-			err = ext4_ext_zeroout(inode, &zero_ex);
+			ext4_ext_store_pblock(&zero_ex1,
+				ext4_ext_pblock(ex) + split_map.m_lblk +
+				split_map.m_len - ee_block);
+			err = ext4_ext_zeroout(inode, &zero_ex1);
 			if (err)
 				goto out;
-			split_map.m_lblk = map->m_lblk;
 			split_map.m_len = allocated;
-		} else if (map->m_lblk - ee_block + map->m_len < max_zeroout) {
+		}
-			/* case 2 */
+		if (split_map.m_lblk - ee_block + split_map.m_len <
-			if (map->m_lblk != ee_block) {
+								max_zeroout) {
-				zero_ex.ee_block = ex->ee_block;
+			/* case 2 or 5 */
-				zero_ex.ee_len = cpu_to_le16(map->m_lblk -
+			if (split_map.m_lblk != ee_block) {
+				zero_ex2.ee_block = ex->ee_block;
+				zero_ex2.ee_len = cpu_to_le16(split_map.m_lblk -
 							ee_block);
-				ext4_ext_store_pblock(&zero_ex,
+				ext4_ext_store_pblock(&zero_ex2,
 						      ext4_ext_pblock(ex));
-				err = ext4_ext_zeroout(inode, &zero_ex);
+				err = ext4_ext_zeroout(inode, &zero_ex2);
 				if (err)
 					goto out;
 			}
+			split_map.m_len += split_map.m_lblk - ee_block;
 			split_map.m_lblk = ee_block;
-			split_map.m_len = map->m_lblk - ee_block + map->m_len;
 			allocated = map->m_len;
 		}
 	}
 		err = 0;
 out:
 	/* If we have gotten a failure, don't zero out status tree */
-	if (!err)
+	if (!err) {
-		err = ext4_zeroout_es(inode, &zero_ex);
+		err = ext4_zeroout_es(inode, &zero_ex1);
+		if (!err)
+			err = ext4_zeroout_es(inode, &zero_ex2);
+	}
 	return err ? err : allocated;
 }
 	/* Zero out partial block at the edges of the range */
 	ret = ext4_zero_partial_blocks(handle, inode, offset, len);
+	if (ret >= 0)
+		ext4_update_inode_fsync_trans(handle, inode, 1);
 	if (file->f_flags & O_SYNC)
 		ext4_handle_sync(handle);
 		ext4_handle_sync(handle);
 	inode->i_mtime = inode->i_ctime = current_time(inode);
 	ext4_mark_inode_dirty(handle, inode);
+	ext4_update_inode_fsync_trans(handle, inode, 1);
 out_stop:
 	ext4_journal_stop(handle);
 	up_write(&EXT4_I(inode)->i_data_sem);
 	if (IS_SYNC(inode))
 		ext4_handle_sync(handle);
+	if (ret >= 0)
+		ext4_update_inode_fsync_trans(handle, inode, 1);
 out_stop:
 	ext4_journal_stop(handle);

fs/ext4/file.c+16−38

 	endoff = (loff_t)end_blk << blkbits;
 	index = startoff >> PAGE_SHIFT;
-	end = endoff >> PAGE_SHIFT;
+	end = (endoff - 1) >> PAGE_SHIFT;
 	pagevec_init(&pvec, 0);
 	do {
 		int i, num;
 		unsigned long nr_pages;
-		num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
+		num = min_t(pgoff_t, end - index, PAGEVEC_SIZE - 1) + 1;
 		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
 					  (pgoff_t)num);
-		if (nr_pages == 0) {
+		if (nr_pages == 0)
-			if (whence == SEEK_DATA)
-				break;
-			BUG_ON(whence != SEEK_HOLE);
-			/*
-			 * If this is the first time to go into the loop and
-			 * offset is not beyond the end offset, it will be a
-			 * hole at this offset
-			 */
-			if (lastoff == startoff || lastoff < endoff)
-				found = 1;
-			break;
-		}
-		/*
-		 * If this is the first time to go into the loop and
-		 * offset is smaller than the first page offset, it will be a
-		 * hole at this offset.
-		 */
-		if (lastoff == startoff && whence == SEEK_HOLE &&
-		    lastoff < page_offset(pvec.pages[0])) {
-			found = 1;
 			break;
-		}
 		for (i = 0; i < nr_pages; i++) {
 			struct page *page = pvec.pages[i];
 			struct buffer_head *bh, *head;
 			/*
-			 * If the current offset is not beyond the end of given
+			 * If current offset is smaller than the page offset,
-			 * range, it will be a hole.
+			 * there is a hole at this offset.
 			 */
-			if (lastoff < endoff && whence == SEEK_HOLE &&
+			if (whence == SEEK_HOLE && lastoff < endoff &&
-			    page->index > end) {
+			    lastoff < page_offset(pvec.pages[i])) {
 				found = 1;
 				*offset = lastoff;
 				goto out;
 			}
+			if (page->index > end)
+				goto out;
 			lock_page(page);
 			if (unlikely(page->mapping != inode->i_mapping)) {
 			unlock_page(page);
 		}
-		/*
+		/* The no. of pages is less than our desired, we are done. */
-		 * The no. of pages is less than our desired, that would be a
+		if (nr_pages < num)
-		 * hole in there.
-		 */
-		if (nr_pages < num && whence == SEEK_HOLE) {
-			found = 1;
-			*offset = lastoff;
 			break;
-		}
 		index = pvec.pages[i - 1]->index + 1;
 		pagevec_release(&pvec);
 	} while (index <= end);
+	if (whence == SEEK_HOLE && lastoff < endoff) {
+		found = 1;
+		*offset = lastoff;
+	}
 out:
 	pagevec_release(&pvec);
 	return found;

fs/ext4/inline.c+2−3

 struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 					struct ext4_filename *fname,
-					const struct qstr *d_name,
 					struct ext4_dir_entry_2 **res_dir,
 					int *has_inline_data)
 {
 						EXT4_INLINE_DOTDOT_SIZE;
 	inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
 	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
-			      dir, fname, d_name, 0, res_dir);
+			      dir, fname, 0, res_dir);
 	if (ret == 1)
 		goto out_find;
 	if (ret < 0)
 	inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE;
 	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
-			      dir, fname, d_name, 0, res_dir);
+			      dir, fname, 0, res_dir);
 	if (ret == 1)
 		goto out_find;

fs/ext4/inode.c+22−8

 static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
 {
 	int len;
-	loff_t size = i_size_read(mpd->inode);
+	loff_t size;
 	int err;
 	BUG_ON(page->index != mpd->first_page);
+	clear_page_dirty_for_io(page);
+	/*
+	 * We have to be very careful here!  Nothing protects writeback path
+	 * against i_size changes and the page can be writeably mapped into
+	 * page tables. So an application can be growing i_size and writing
+	 * data through mmap while writeback runs. clear_page_dirty_for_io()
+	 * write-protects our page in page tables and the page cannot get
+	 * written to again until we release page lock. So only after
+	 * clear_page_dirty_for_io() we are safe to sample i_size for
+	 * ext4_bio_write_page() to zero-out tail of the written page. We rely
+	 * on the barrier provided by TestClearPageDirty in
+	 * clear_page_dirty_for_io() to make sure i_size is really sampled only
+	 * after page tables are updated.
+	 */
+	size = i_size_read(mpd->inode);
 	if (page->index == size >> PAGE_SHIFT)
 		len = size & ~PAGE_MASK;
 	else
 		len = PAGE_SIZE;
-	clear_page_dirty_for_io(page);
 	err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
 	if (!err)
 		mpd->wbc->nr_to_write--;
 		get_block_func = ext4_dio_get_block_unwritten_async;
 		dio_flags = DIO_LOCKING;
 	}
-#ifdef CONFIG_EXT4_FS_ENCRYPTION
-	BUG_ON(ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode));
-#endif
 	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
 				   get_block_func, ext4_end_io_dio, NULL,
 				   dio_flags);
 	 */
 	inode_lock_shared(inode);
 	ret = filemap_write_and_wait_range(mapping, iocb->ki_pos,
-					   iocb->ki_pos + count);
+					   iocb->ki_pos + count - 1);
 	if (ret)
 		goto out_unlock;
 	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,
 	inode->i_mtime = inode->i_ctime = current_time(inode);
 	ext4_mark_inode_dirty(handle, inode);
+	if (ret >= 0)
+		ext4_update_inode_fsync_trans(handle, inode, 1);
 out_stop:
 	ext4_journal_stop(handle);
 out_dio:
 	/* No extended attributes present */
 	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
 	    header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
-		memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
+		memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE +
-			new_extra_isize);
+		       EXT4_I(inode)->i_extra_isize, 0,
+		       new_extra_isize - EXT4_I(inode)->i_extra_isize);
 		EXT4_I(inode)->i_extra_isize = new_extra_isize;
 		return 0;
 	}

fs/ext4/mballoc.c+14−9

 	err = ext4_mb_load_buddy(sb, group, &e4b);
 	if (err) {
-		ext4_error(sb, "Error loading buddy information for %u", group);
+		ext4_warning(sb, "Error %d loading buddy information for %u",
+			     err, group);
 		put_bh(bitmap_bh);
 		return 0;
 	}
 		BUG_ON(pa->pa_type != MB_INODE_PA);
 		group = ext4_get_group_number(sb, pa->pa_pstart);
-		err = ext4_mb_load_buddy(sb, group, &e4b);
+		err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
+					     GFP_NOFS|__GFP_NOFAIL);
 		if (err) {
-			ext4_error(sb, "Error loading buddy information for %u",
+			ext4_error(sb, "Error %d loading buddy information for %u",
-					group);
+				   err, group);
 			continue;
 		}
 	spin_unlock(&lg->lg_prealloc_lock);
 	list_for_each_entry_safe(pa, tmp, &discard_list, u.pa_tmp_list) {
+		int err;
 		group = ext4_get_group_number(sb, pa->pa_pstart);
-		if (ext4_mb_load_buddy(sb, group, &e4b)) {
+		err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
-			ext4_error(sb, "Error loading buddy information for %u",
+					     GFP_NOFS|__GFP_NOFAIL);
-					group);
+		if (err) {
+			ext4_error(sb, "Error %d loading buddy information for %u",
+				   err, group);
 			continue;
 		}
 		ext4_lock_group(sb, group);
 	ret = ext4_mb_load_buddy(sb, group, &e4b);
 	if (ret) {
-		ext4_error(sb, "Error in loading buddy "
+		ext4_warning(sb, "Error %d loading buddy information for %u",
-				"information for %u", group);
+			     ret, group);
 		return ret;
 	}
 	bitmap = e4b.bd_bitmap;

fs/ext4/namei.c+5−8

 static inline int search_dirblock(struct buffer_head *bh,
 				  struct inode *dir,
 				  struct ext4_filename *fname,
-				  const struct qstr *d_name,
 				  unsigned int offset,
 				  struct ext4_dir_entry_2 **res_dir)
 {
 	return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
-			       fname, d_name, offset, res_dir);
+			       fname, offset, res_dir);
 }
 /*
  */
 int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
 		    struct inode *dir, struct ext4_filename *fname,
-		    const struct qstr *d_name,
 		    unsigned int offset, struct ext4_dir_entry_2 **res_dir)
 {
 	struct ext4_dir_entry_2 * de;
 	if (ext4_has_inline_data(dir)) {
 		int has_inline_data = 1;
-		ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
+		ret = ext4_find_inline_entry(dir, &fname, res_dir,
 					     &has_inline_data);
 		if (has_inline_data) {
 			if (inlined)
 			goto next;
 		}
 		set_buffer_verified(bh);
-		i = search_dirblock(bh, dir, &fname, d_name,
+		i = search_dirblock(bh, dir, &fname,
 			    block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
 		if (i == 1) {
 			EXT4_I(dir)->i_dir_start_lookup = block;
 {
 	struct super_block * sb = dir->i_sb;
 	struct dx_frame frames[2], *frame;
-	const struct qstr *d_name = fname->usr_fname;
 	struct buffer_head *bh;
 	ext4_lblk_t block;
 	int retval;
 		if (IS_ERR(bh))
 			goto errout;
-		retval = search_dirblock(bh, dir, fname, d_name,
+		retval = search_dirblock(bh, dir, fname,
 					 block << EXT4_BLOCK_SIZE_BITS(sb),
 					 res_dir);
 		if (retval == 1)
 	bh = NULL;
 errout:
-	dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
+	dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name));
 success:
 	dx_release(frames);
 	return bh;

fs/ext4/super.c+8−9

 {
 	int type;
-	if (ext4_has_feature_quota(sb)) {
+	/* Use our quota_off function to clear inode flags etc. */
-		dquot_disable(sb, -1,
+	for (type = 0; type < EXT4_MAXQUOTAS; type++)
-			      DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
+		ext4_quota_off(sb, type);
-	} else {
-		/* Use our quota_off function to clear inode flags etc. */
-		for (type = 0; type < EXT4_MAXQUOTAS; type++)
-			ext4_quota_off(sb, type);
-	}
 }
 #else
 static inline void ext4_quota_off_umount(struct super_block *sb)
 		return res;
 	}
+	res = dquot_initialize(inode);
+	if (res)
+		return res;
 retry:
 	handle = ext4_journal_start(inode, EXT4_HT_MISC,
 			ext4_jbd2_credits_xattr(inode));
 		goto out;
 	err = dquot_quota_off(sb, type);
-	if (err)
+	if (err || ext4_has_feature_quota(sb))
 		goto out_put;
 	inode_lock(inode);
 out_unlock:
 	inode_unlock(inode);
 out_put:
+	lockdep_set_quota_inode(inode, I_DATA_SEM_NORMAL);
 	iput(inode);
 	return err;
 out:

fs/ext4/xattr.c+8−0

 			else {
 				u32 ref;
+				WARN_ON_ONCE(dquot_initialize_needed(inode));
 				/* The old block is released after updating
 				   the inode. */
 				error = dquot_alloc_block(inode,
 			/* We need to allocate a new block */
 			ext4_fsblk_t goal, block;
+			WARN_ON_ONCE(dquot_initialize_needed(inode));
 			goal = ext4_group_first_block_no(sb,
 						EXT4_I(inode)->i_block_group);
 		return -EINVAL;
 	if (strlen(name) > 255)
 		return -ERANGE;
 	ext4_write_lock_xattr(inode, &no_expand);
 	error = ext4_reserve_inode_write(handle, inode, &is.iloc);
 	int error, retries = 0;
 	int credits = ext4_jbd2_credits_xattr(inode);
+	error = dquot_initialize(inode);
+	if (error)
+		return error;
 retry:
 	handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
 	if (IS_ERR(handle)) {

fs/f2fs/f2fs.h+4−1

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

fs/jbd2/transaction.c+6−0

 	rwsem_release(&journal->j_trans_commit_map, 1, _THIS_IP_);
 	handle->h_buffer_credits = nblocks;
+	/*
+	 * Restore the original nofs context because the journal restart
+	 * is basically the same thing as journal stop and start.
+	 * start_this_handle will start a new nofs context.
+	 */
+	memalloc_nofs_restore(handle->saved_alloc_context);
 	ret = start_this_handle(journal, handle, gfp_mask);
 	return ret;
 }

fs/quota/dquot.c+16−0

@@ -1512,6 +1512,22 @@ int dquot_initialize(struct inode *inode) · 1511 unmodified lines
1512	}	1512	}
1513	EXPORT_SYMBOL(dquot_initialize);	1513	EXPORT_SYMBOL(dquot_initialize);
1514		1514
		1515	bool dquot_initialize_needed(struct inode *inode)
		1516	{
		1517	struct dquot **dquots;
		1518	int i;
		1519
		1520	if (!dquot_active(inode))
		1521	return false;
		1522
		1523	dquots = i_dquot(inode);
		1524	for (i = 0; i < MAXQUOTAS; i++)
		1525	if (!dquots[i] && sb_has_quota_active(inode->i_sb, i))
		1526	return true;
		1527	return false;
		1528	}
		1529	EXPORT_SYMBOL(dquot_initialize_needed);
		1530
1515	/*	1531	/*
1516	* Release all quotas referenced by inode.	1532	* Release all quotas referenced by inode.
1517	*	1533	*

fs/stat.c+1−0

@@ -672,6 +672,7 @@ void __inode_add_bytes(struct inode *inode, loff_t bytes) · 671 unmodified lines
672	inode->i_bytes -= 512;	672	inode->i_bytes -= 512;
673	}	673	}
674	}	674	}
		675	EXPORT_SYMBOL(__inode_add_bytes);
675		676
676	void inode_add_bytes(struct inode *inode, loff_t bytes)	677	void inode_add_bytes(struct inode *inode, loff_t bytes)
677	{	678	{

fs/ufs/balloc.c+25−1

 			ufs_error (sb, "ufs_free_fragments",
 				   "bit already cleared for fragment %u", i);
 	}
+	inode_sub_bytes(inode, count << uspi->s_fshift);
 	fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
 	uspi->cs_total.cs_nffree += count;
 	fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
 			ufs_error(sb, "ufs_free_blocks", "freeing free fragment");
 		}
 		ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
+		inode_sub_bytes(inode, uspi->s_fpb << uspi->s_fshift);
 		if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
 			ufs_clusteracct (sb, ucpi, blkno, 1);
 	return 0;
 }
+static bool try_add_frags(struct inode *inode, unsigned frags)
+{
+	unsigned size = frags * i_blocksize(inode);
+	spin_lock(&inode->i_lock);
+	__inode_add_bytes(inode, size);
+	if (unlikely((u32)inode->i_blocks != inode->i_blocks)) {
+		__inode_sub_bytes(inode, size);
+		spin_unlock(&inode->i_lock);
+		return false;
+	}
+	spin_unlock(&inode->i_lock);
+	return true;
+}
 static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
 			     unsigned oldcount, unsigned newcount)
 {
 	for (i = oldcount; i < newcount; i++)
 		if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
 			return 0;
+	if (!try_add_frags(inode, count))
+		return 0;
 	/*
 	 * Block can be extended
 	 */
 			ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
 		i = uspi->s_fpb - count;
+		inode_sub_bytes(inode, i << uspi->s_fshift);
 		fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
 		uspi->cs_total.cs_nffree += i;
 		fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, i);
 	result = ufs_bitmap_search (sb, ucpi, goal, allocsize);
 	if (result == INVBLOCK)
 		return 0;
+	if (!try_add_frags(inode, count))
+		return 0;
 	for (i = 0; i < count; i++)
 		ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, result + i);
 		return INVBLOCK;
 	ucpi->c_rotor = result;
 gotit:
+	if (!try_add_frags(inode, uspi->s_fpb))
+		return 0;
 	blkno = ufs_fragstoblks(result);
 	ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
 	if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)

fs/ufs/inode.c+12−16

 	p = ufs_get_direct_data_ptr(uspi, ufsi, block);
 	tmp = ufs_new_fragments(inode, p, lastfrag, ufs_data_ptr_to_cpu(sb, p),
-				new_size, err, locked_page);
+				new_size - (lastfrag & uspi->s_fpbmask), err,
+				locked_page);
 	return tmp != 0;
 }
 			goal += uspi->s_fpb;
 	}
 	tmp = ufs_new_fragments(inode, p, ufs_blknum(new_fragment),
-				goal, uspi->s_fpb, err, locked_page);
+				goal, nfrags, err, locked_page);
 	if (!tmp) {
 		*err = -ENOSPC;
 	if (!create) {
 		phys64 = ufs_frag_map(inode, offsets, depth);
-		goto out;
+		if (phys64)
+			map_bh(bh_result, sb, phys64 + frag);
+		return 0;
 	}
         /* This code entered only while writing ....? */
 	truncate_inode_pages_final(&inode->i_data);
 	if (want_delete) {
 		inode->i_size = 0;
-		if (inode->i_blocks)
+		if (inode->i_blocks &&
+		    (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
+		     S_ISLNK(inode->i_mode)))
 			ufs_truncate_blocks(inode);
+		ufs_update_inode(inode, inode_needs_sync(inode));
 	}
 	invalidate_inode_buffers(inode);
        return err;
 }
-static void __ufs_truncate_blocks(struct inode *inode)
+static void ufs_truncate_blocks(struct inode *inode)
 {
 	struct ufs_inode_info *ufsi = UFS_I(inode);
 	struct super_block *sb = inode->i_sb;
 	truncate_setsize(inode, size);
-	__ufs_truncate_blocks(inode);
+	ufs_truncate_blocks(inode);
 	inode->i_mtime = inode->i_ctime = current_time(inode);
 	mark_inode_dirty(inode);
 out:
 	return err;
 }
-static void ufs_truncate_blocks(struct inode *inode)
-{
-	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
-	      S_ISLNK(inode->i_mode)))
-		return;
-	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
-		return;
-	__ufs_truncate_blocks(inode);
-}
 int ufs_setattr(struct dentry *dentry, struct iattr *attr)
 {
 	struct inode *inode = d_inode(dentry);

fs/ufs/super.c+18−0

@@ -746,6 +746,23 @@ static void ufs_put_super(struct super_block *sb) · 745 unmodified lines
746	return;	746	return;
747	}	747	}
748		748
		749	static u64 ufs_max_bytes(struct super_block *sb)
		750	{
		751	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
		752	int bits = uspi->s_apbshift;
		753	u64 res;
		754
		755	if (bits > 21)
		756	res = ~0ULL;
		757	else
		758	res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
		759	(1LL << (3*bits));
		760
		761	if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
		762	return MAX_LFS_FILESIZE;
		763	return res << uspi->s_bshift;
		764	}
		765
749	static int ufs_fill_super(struct super_block sb, void data, int silent)	766	static int ufs_fill_super(struct super_block sb, void data, int silent)
750	{	767	{
751	struct ufs_sb_info * sbi;	768	struct ufs_sb_info * sbi;
@@ -1211,6 +1228,7 @@ magic_found: · 459 unmodified lines
1211	"fast symlink size (%u)\n", uspi->s_maxsymlinklen);	1228	"fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1212	uspi->s_maxsymlinklen = maxsymlen;	1229	uspi->s_maxsymlinklen = maxsymlen;
1213	}	1230	}
		1231	sb->s_maxbytes = ufs_max_bytes(sb);
1214	sb->s_max_links = UFS_LINK_MAX;	1232	sb->s_max_links = UFS_LINK_MAX;
1215		1233
1216	inode = ufs_iget(sb, UFS_ROOTINO);	1234	inode = ufs_iget(sb, UFS_ROOTINO);

fs/ufs/util.h+7−3

 static inline int _ubh_isblockset_(struct ufs_sb_private_info * uspi,
 	struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
 {
+	u8 mask;
 	switch (uspi->s_fpb) {
 	case 8:
 	    	return (*ubh_get_addr (ubh, begin + block) == 0xff);
 	case 4:
-		return (*ubh_get_addr (ubh, begin + (block >> 1)) == (0x0f << ((block & 0x01) << 2)));
+		mask = 0x0f << ((block & 0x01) << 2);
+		return (*ubh_get_addr (ubh, begin + (block >> 1)) & mask) == mask;
 	case 2:
-		return (*ubh_get_addr (ubh, begin + (block >> 2)) == (0x03 << ((block & 0x03) << 1)));
+		mask = 0x03 << ((block & 0x03) << 1);
+		return (*ubh_get_addr (ubh, begin + (block >> 2)) & mask) == mask;
 	case 1:
-		return (*ubh_get_addr (ubh, begin + (block >> 3)) == (0x01 << (block & 0x07)));
+		mask = 0x01 << (block & 0x07);
+		return (*ubh_get_addr (ubh, begin + (block >> 3)) & mask) == mask;
 	}
 	return 0;
 }

include/acpi/actbl.h+14−0

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

include/linux/compiler-clang.h+2−1

@@ -21,4 +21,5 @@ · 20 unmodified lines
21	* -Wunused-function. This turns out to avoid the need for complex #ifdef	21	* -Wunused-function. This turns out to avoid the need for complex #ifdef
22	* directives. Suppress the warning in clang as well.	22	* directives. Suppress the warning in clang as well.
23	*/	23	*/
24	#define inline inline __attribute__((unused))	24	#undef inline
		25	#define inline inline __attribute__((unused)) notrace

include/linux/dma-iommu.h+1−0

@@ -78,6 +78,7 @@ void iommu_dma_get_resv_regions(struct device dev, struct list_head list); · 77 unmodified lines
78		78
79	struct iommu_domain;	79	struct iommu_domain;
80	struct msi_msg;	80	struct msi_msg;
		81	struct device;
81		82
82	static inline int iommu_dma_init(void)	83	static inline int iommu_dma_init(void)
83	{	84	{

include/linux/elevator.h+1−1

@@ -153,7 +153,7 @@ struct elevator_type · 152 unmodified lines
153	#endif	153	#endif
154		154
155	/* managed by elevator core */	155	/* managed by elevator core */
156	char icq_cache_name[ELV_NAME_MAX + 5]; /* elvname + "_io_cq" */	156	char icq_cache_name[ELV_NAME_MAX + 6]; /* elvname + "_io_cq" */
157	struct list_head list;	157	struct list_head list;
158	};	158	};
159		159

include/linux/irqchip/arm-gic-v3.h+4−0

 #define ICH_HCR_EN			(1 << 0)
 #define ICH_HCR_UIE			(1 << 1)
+#define ICH_VMCR_ACK_CTL_SHIFT		2
+#define ICH_VMCR_ACK_CTL_MASK		(1 << ICH_VMCR_ACK_CTL_SHIFT)
+#define ICH_VMCR_FIQ_EN_SHIFT		3
+#define ICH_VMCR_FIQ_EN_MASK		(1 << ICH_VMCR_FIQ_EN_SHIFT)
 #define ICH_VMCR_CBPR_SHIFT		4
 #define ICH_VMCR_CBPR_MASK		(1 << ICH_VMCR_CBPR_SHIFT)
 #define ICH_VMCR_EOIM_SHIFT		9

include/linux/irqchip/arm-gic.h+25−3

@@ -25,7 +25,18 @@ · 24 unmodified lines
25	#define GICC_ENABLE 0x1	25	#define GICC_ENABLE 0x1
26	#define GICC_INT_PRI_THRESHOLD 0xf0	26	#define GICC_INT_PRI_THRESHOLD 0xf0
27		27
28	#define GIC_CPU_CTRL_EOImodeNS (1 << 9)	28	#define GIC_CPU_CTRL_EnableGrp0_SHIFT 0
		29	#define GIC_CPU_CTRL_EnableGrp0 (1 << GIC_CPU_CTRL_EnableGrp0_SHIFT)
		30	#define GIC_CPU_CTRL_EnableGrp1_SHIFT 1
		31	#define GIC_CPU_CTRL_EnableGrp1 (1 << GIC_CPU_CTRL_EnableGrp1_SHIFT)
		32	#define GIC_CPU_CTRL_AckCtl_SHIFT 2
		33	#define GIC_CPU_CTRL_AckCtl (1 << GIC_CPU_CTRL_AckCtl_SHIFT)
		34	#define GIC_CPU_CTRL_FIQEn_SHIFT 3
		35	#define GIC_CPU_CTRL_FIQEn (1 << GIC_CPU_CTRL_FIQEn_SHIFT)
		36	#define GIC_CPU_CTRL_CBPR_SHIFT 4
		37	#define GIC_CPU_CTRL_CBPR (1 << GIC_CPU_CTRL_CBPR_SHIFT)
		38	#define GIC_CPU_CTRL_EOImodeNS_SHIFT 9
		39	#define GIC_CPU_CTRL_EOImodeNS (1 << GIC_CPU_CTRL_EOImodeNS_SHIFT)
29		40
30	#define GICC_IAR_INT_ID_MASK 0x3ff	41	#define GICC_IAR_INT_ID_MASK 0x3ff
31	#define GICC_INT_SPURIOUS 1023	42	#define GICC_INT_SPURIOUS 1023
@@ -84,8 +95,19 @@ · 52 unmodified lines
84	#define GICH_LR_EOI (1 << 19)	95	#define GICH_LR_EOI (1 << 19)
85	#define GICH_LR_HW (1 << 31)	96	#define GICH_LR_HW (1 << 31)
86		97
87	#define GICH_VMCR_CTRL_SHIFT 0	98	#define GICH_VMCR_ENABLE_GRP0_SHIFT 0
88	#define GICH_VMCR_CTRL_MASK (0x21f << GICH_VMCR_CTRL_SHIFT)	99	#define GICH_VMCR_ENABLE_GRP0_MASK (1 << GICH_VMCR_ENABLE_GRP0_SHIFT)
		100	#define GICH_VMCR_ENABLE_GRP1_SHIFT 1
		101	#define GICH_VMCR_ENABLE_GRP1_MASK (1 << GICH_VMCR_ENABLE_GRP1_SHIFT)
		102	#define GICH_VMCR_ACK_CTL_SHIFT 2
		103	#define GICH_VMCR_ACK_CTL_MASK (1 << GICH_VMCR_ACK_CTL_SHIFT)
		104	#define GICH_VMCR_FIQ_EN_SHIFT 3
		105	#define GICH_VMCR_FIQ_EN_MASK (1 << GICH_VMCR_FIQ_EN_SHIFT)
		106	#define GICH_VMCR_CBPR_SHIFT 4
		107	#define GICH_VMCR_CBPR_MASK (1 << GICH_VMCR_CBPR_SHIFT)
		108	#define GICH_VMCR_EOI_MODE_SHIFT 9
		109	#define GICH_VMCR_EOI_MODE_MASK (1 << GICH_VMCR_EOI_MODE_SHIFT)
		110
89	#define GICH_VMCR_PRIMASK_SHIFT 27	111	#define GICH_VMCR_PRIMASK_SHIFT 27
90	#define GICH_VMCR_PRIMASK_MASK (0x1f << GICH_VMCR_PRIMASK_SHIFT)	112	#define GICH_VMCR_PRIMASK_MASK (0x1f << GICH_VMCR_PRIMASK_SHIFT)
91	#define GICH_VMCR_BINPOINT_SHIFT 21	113	#define GICH_VMCR_BINPOINT_SHIFT 21

include/linux/key.h+0−1

@@ -173,7 +173,6 @@ struct key { · 172 unmodified lines
173	#ifdef KEY_DEBUGGING	173	#ifdef KEY_DEBUGGING
174	unsigned magic;	174	unsigned magic;
175	#define KEY_DEBUG_MAGIC 0x18273645u	175	#define KEY_DEBUG_MAGIC 0x18273645u
176	#define KEY_DEBUG_MAGIC_X 0xf8e9dacbu
177	#endif	176	#endif
178		177
179	unsigned long flags; /* status flags (change with bitops) */	178	unsigned long flags; /* status flags (change with bitops) */

include/linux/netdevice.h+10−5

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

include/linux/quotaops.h+6−0

 void inode_reclaim_rsv_space(struct inode *inode, qsize_t number);
 int dquot_initialize(struct inode *inode);
+bool dquot_initialize_needed(struct inode *inode);
 void dquot_drop(struct inode *inode);
 struct dquot *dqget(struct super_block *sb, struct kqid qid);
 static inline struct dquot *dqgrab(struct dquot *dquot)
 	return 0;
 }
+static inline bool dquot_initialize_needed(struct inode *inode)
+{
+	return false;
+}
 static inline void dquot_drop(struct inode *inode)
 {
 }

include/linux/srcu.h+0−2

 {
 	int retval;
-	preempt_disable();
 	retval = __srcu_read_lock(sp);
-	preempt_enable();
 	rcu_lock_acquire(&(sp)->dep_map);
 	return retval;
 }

include/linux/suspend.h+2−5

 struct platform_freeze_ops {
 	int (*begin)(void);
 	int (*prepare)(void);
-	void (*wake)(void);
-	void (*sync)(void);
 	void (*restore)(void);
 	void (*end)(void);
 };
 extern bool pm_wakeup_pending(void);
 extern void pm_system_wakeup(void);
-extern void pm_system_cancel_wakeup(void);
+extern void pm_wakeup_clear(void);
-extern void pm_wakeup_clear(bool reset);
 extern void pm_system_irq_wakeup(unsigned int irq_number);
 extern bool pm_get_wakeup_count(unsigned int *count, bool block);
 extern bool pm_save_wakeup_count(unsigned int count);
 static inline bool pm_wakeup_pending(void) { return false; }
 static inline void pm_system_wakeup(void) {}
-static inline void pm_wakeup_clear(bool reset) {}
+static inline void pm_wakeup_clear(void) {}
 static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
 static inline void lock_system_sleep(void) {}

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

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

include/media/cec.h+1−1

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

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

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

include/uapi/linux/keyctl.h+2−2

@@ -70,8 +70,8 @@ struct keyctl_dh_params { · 69 unmodified lines
70	};	70	};
71		71
72	struct keyctl_kdf_params {	72	struct keyctl_kdf_params {
73	char *hashname;	73	char __user *hashname;
74	char *otherinfo;	74	char __user *otherinfo;
75	__u32 otherinfolen;	75	__u32 otherinfolen;
76	__u32 __spare[8];	76	__u32 __spare[8];
77	};	77	};

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

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

kernel/cpu.c+2−2

@@ -1658,13 +1658,13 @@ static ssize_t write_cpuhp_target(struct device *dev, · 1657 unmodified lines
1658	ret = !sp->name \|\| sp->cant_stop ? -EINVAL : 0;	1658	ret = !sp->name \|\| sp->cant_stop ? -EINVAL : 0;
1659	mutex_unlock(&cpuhp_state_mutex);	1659	mutex_unlock(&cpuhp_state_mutex);
1660	if (ret)	1660	if (ret)
1661	return ret;	1661	goto out;
1662		1662
1663	if (st->state < target)	1663	if (st->state < target)
1664	ret = do_cpu_up(dev->id, target);	1664	ret = do_cpu_up(dev->id, target);
1665	else	1665	else
1666	ret = do_cpu_down(dev->id, target);	1666	ret = do_cpu_down(dev->id, target);
1667		1667	out:
1668	unlock_device_hotplug();	1668	unlock_device_hotplug();
1669	return ret ? ret : count;	1669	return ret ? ret : count;
1670	}	1670	}

kernel/events/core.c+21−0

@@ -7329,6 +7329,21 @@ int perf_event_account_interrupt(struct perf_event *event) · 7328 unmodified lines
7329	return __perf_event_account_interrupt(event, 1);	7329	return __perf_event_account_interrupt(event, 1);
7330	}	7330	}
7331		7331
		7332	static bool sample_is_allowed(struct perf_event event, struct pt_regs regs)
		7333	{
		7334	/*
		7335	* Due to interrupt latency (AKA "skid"), we may enter the
		7336	* kernel before taking an overflow, even if the PMU is only
		7337	* counting user events.
		7338	* To avoid leaking information to userspace, we must always
		7339	* reject kernel samples when exclude_kernel is set.
		7340	*/
		7341	if (event->attr.exclude_kernel && !user_mode(regs))
		7342	return false;
		7343
		7344	return true;
		7345	}
		7346
7332	/*	7347	/*
7333	* Generic event overflow handling, sampling.	7348	* Generic event overflow handling, sampling.
7334	*/	7349	*/
@@ -7349,6 +7364,12 @@ static int __perf_event_overflow(struct perf_event *event, · 14 unmodified lines
7349		7364
7350	ret = __perf_event_account_interrupt(event, throttle);	7365	ret = __perf_event_account_interrupt(event, throttle);
7351		7366
		7367	/*
		7368	* For security, drop the skid kernel samples if necessary.
		7369	*/
		7370	if (!sample_is_allowed(event, regs))
		7371	return ret;
		7372
7352	/*	7373	/*
7353	* XXX event_limit might not quite work as expected on inherited	7374	* XXX event_limit might not quite work as expected on inherited
7354	* events	7375	* events

kernel/power/process.c+1−1

@@ -132,7 +132,7 @@ int freeze_processes(void) · 131 unmodified lines
132	if (!pm_freezing)	132	if (!pm_freezing)
133	atomic_inc(&system_freezing_cnt);	133	atomic_inc(&system_freezing_cnt);
134		134
135	pm_wakeup_clear(true);	135	pm_wakeup_clear();
136	pr_info("Freezing user space processes ... ");	136	pr_info("Freezing user space processes ... ");
137	pm_freezing = true;	137	pm_freezing = true;
138	error = try_to_freeze_tasks(true);	138	error = try_to_freeze_tasks(true);

kernel/power/suspend.c+4−25

@@ -72,8 +72,6 @@ static void freeze_begin(void) · 71 unmodified lines
72		72
73	static void freeze_enter(void)	73	static void freeze_enter(void)
74	{	74	{
75	trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_FREEZE, true);
76
77	spin_lock_irq(&suspend_freeze_lock);	75	spin_lock_irq(&suspend_freeze_lock);
78	if (pm_wakeup_pending())	76	if (pm_wakeup_pending())
79	goto out;	77	goto out;
@@ -100,27 +98,6 @@ static void freeze_enter(void) · 20 unmodified lines
100	out:	98	out:
101	suspend_freeze_state = FREEZE_STATE_NONE;	99	suspend_freeze_state = FREEZE_STATE_NONE;
102	spin_unlock_irq(&suspend_freeze_lock);	100	spin_unlock_irq(&suspend_freeze_lock);
103
104	trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_FREEZE, false);
105	}
106
107	static void s2idle_loop(void)
108	{
109	do {
110	freeze_enter();
111
112	if (freeze_ops && freeze_ops->wake)
113	freeze_ops->wake();
114
115	dpm_resume_noirq(PMSG_RESUME);
116	if (freeze_ops && freeze_ops->sync)
117	freeze_ops->sync();
118
119	if (pm_wakeup_pending())
120	break;
121
122	pm_wakeup_clear(false);
123	} while (!dpm_suspend_noirq(PMSG_SUSPEND));
124	}	101	}
125		102
126	void freeze_wake(void)	103	void freeze_wake(void)
@@ -394,8 +371,10 @@ static int suspend_enter(suspend_state_t state, bool *wakeup) · 267 unmodified lines
394	* all the devices are suspended.	371	* all the devices are suspended.
395	*/	372	*/
396	if (state == PM_SUSPEND_FREEZE) {	373	if (state == PM_SUSPEND_FREEZE) {
397	s2idle_loop();	374	trace_suspend_resume(TPS("machine_suspend"), state, true);
398	goto Platform_early_resume;	375	freeze_enter();
		376	trace_suspend_resume(TPS("machine_suspend"), state, false);
		377	goto Platform_wake;
399	}	378	}
400		379
401	error = disable_nonboot_cpus();	380	error = disable_nonboot_cpus();

kernel/printk/printk.c+10−36

@@ -269,7 +269,6 @@ static struct console *exclusive_console; · 268 unmodified lines
269	#define MAX_CMDLINECONSOLES 8	269	#define MAX_CMDLINECONSOLES 8
270		270
271	static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];	271	static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
272	static int console_cmdline_cnt;
273		272
274	static int preferred_console = -1;	273	static int preferred_console = -1;
275	int console_set_on_cmdline;	274	int console_set_on_cmdline;
@@ -1906,25 +1905,12 @@ static int __add_preferred_console(char name, int idx, char options, · 1630 unmodified lines
1906	* See if this tty is not yet registered, and	1905	* See if this tty is not yet registered, and
1907	* if we have a slot free.	1906	* if we have a slot free.
1908	*/	1907	*/
1909	for (i = 0, c = console_cmdline; i < console_cmdline_cnt; i++, c++) {	1908	for (i = 0, c = console_cmdline;
		1909	i < MAX_CMDLINECONSOLES && c->name[0];
		1910	i++, c++) {
1910	if (strcmp(c->name, name) == 0 && c->index == idx) {	1911	if (strcmp(c->name, name) == 0 && c->index == idx) {
1911	if (brl_options)	1912	if (!brl_options)
1912	return 0;	1913	preferred_console = i;
1913
1914	/*
1915	* Maintain an invariant that will help to find if
1916	* the matching console is preferred, see
1917	* register_console():
1918	*
1919	* The last non-braille console is always
1920	* the preferred one.
1921	*/
1922	if (i != console_cmdline_cnt - 1)
1923	swap(console_cmdline[i],
1924	console_cmdline[console_cmdline_cnt - 1]);
1925
1926	preferred_console = console_cmdline_cnt - 1;
1927
1928	return 0;	1914	return 0;
1929	}	1915	}
1930	}	1916	}
@@ -1937,7 +1923,6 @@ static int __add_preferred_console(char name, int idx, char options, · 6 unmodified lines
1937	braille_set_options(c, brl_options);	1923	braille_set_options(c, brl_options);
1938		1924
1939	c->index = idx;	1925	c->index = idx;
1940	console_cmdline_cnt++;
1941	return 0;	1926	return 0;
1942	}	1927	}
1943	/*	1928	/*
@@ -2477,23 +2462,12 @@ void register_console(struct console *newcon) · 533 unmodified lines
2477	}	2462	}
2478		2463
2479	/*	2464	/*
2480	* See if this console matches one we selected on the command line.	2465	* See if this console matches one we selected on
2481	*	2466	* the command line.
2482	* There may be several entries in the console_cmdline array matching
2483	* with the same console, one with newcon->match(), another by
2484	* name/index:
2485	*
2486	* pl011,mmio,0x87e024000000,115200 -- added from SPCR
2487	* ttyAMA0 -- added from command line
2488	*
2489	* Traverse the console_cmdline array in reverse order to be
2490	* sure that if this console is preferred then it will be the first
2491	* matching entry. We use the invariant that is maintained in
2492	* __add_preferred_console().
2493	*/	2467	*/
2494	for (i = console_cmdline_cnt - 1; i >= 0; i--) {	2468	for (i = 0, c = console_cmdline;
2495	c = console_cmdline + i;	2469	i < MAX_CMDLINECONSOLES && c->name[0];
2496		2470	i++, c++) {
2497	if (!newcon->match \|\|	2471	if (!newcon->match \|\|
2498	newcon->match(newcon, c->name, c->index, c->options) != 0) {	2472	newcon->match(newcon, c->name, c->index, c->options) != 0) {
2499	/* default matching */	2473	/* default matching */

kernel/rcu/srcu.c+2−3

 /*
  * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
+ * srcu_struct.
  * Returns an index that must be passed to the matching srcu_read_unlock().
  */
 int __srcu_read_lock(struct srcu_struct *sp)
 	int idx;
 	idx = READ_ONCE(sp->completed) & 0x1;
-	__this_cpu_inc(sp->per_cpu_ref->lock_count[idx]);
+	this_cpu_inc(sp->per_cpu_ref->lock_count[idx]);
 	smp_mb(); /* B */  /* Avoid leaking the critical section. */
 	return idx;
 }
  * Removes the count for the old reader from the appropriate per-CPU
  * element of the srcu_struct.  Note that this may well be a different
  * CPU than that which was incremented by the corresponding srcu_read_lock().
- * Must be called from process context.
  */
 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 {

kernel/rcu/srcutiny.c+4−3

 /*
  * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
+ * srcu_struct.  Can be invoked from irq/bh handlers, but the matching
- * Returns an index that must be passed to the matching srcu_read_unlock().
+ * __srcu_read_unlock() must be in the same handler instance.  Returns an
+ * index that must be passed to the matching srcu_read_unlock().
  */
 int __srcu_read_lock(struct srcu_struct *sp)
 {
 /*
  * Removes the count for the old reader from the appropriate element of
- * the srcu_struct.  Must be called from process context.
+ * the srcu_struct.
  */
 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 {

kernel/rcu/srcutree.c+2−3

 /*
  * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
+ * srcu_struct.
  * Returns an index that must be passed to the matching srcu_read_unlock().
  */
 int __srcu_read_lock(struct srcu_struct *sp)
 	int idx;
 	idx = READ_ONCE(sp->srcu_idx) & 0x1;
-	__this_cpu_inc(sp->sda->srcu_lock_count[idx]);
+	this_cpu_inc(sp->sda->srcu_lock_count[idx]);
 	smp_mb(); /* B */  /* Avoid leaking the critical section. */
 	return idx;
 }
  * Removes the count for the old reader from the appropriate per-CPU
  * element of the srcu_struct.  Note that this may well be a different
  * CPU than that which was incremented by the corresponding srcu_read_lock().
- * Must be called from process context.
  */
 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 {

kernel/sched/cpufreq_schedutil.c+0−3

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

lib/libcrc32c.c+4−2

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

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

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

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

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

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

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

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

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

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

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

net/bridge/br_device.c+1−1

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

net/caif/caif_socket.c+4−0

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

net/caif/cfpkt_skbuff.c+1−5

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

net/caif/chnl_net.c+2−2

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

net/can/af_can.c+1−2

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

net/core/dev.c+30−12

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

net/core/dst.c+14−0

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

net/core/rtnetlink.c+2−1

 	struct ifla_vf_mac vf_mac;
 	struct ifla_vf_info ivi;
+	memset(&ivi, 0, sizeof(ivi));
 	/* Not all SR-IOV capable drivers support the
 	 * spoofcheck and "RSS query enable" query.  Preset to
 	 * -1 so the user space tool can detect that the driver
 	ivi.spoofchk = -1;
 	ivi.rss_query_en = -1;
 	ivi.trusted = -1;
-	memset(ivi.mac, 0, sizeof(ivi.mac));
 	/* The default value for VF link state is "auto"
 	 * IFLA_VF_LINK_STATE_AUTO which equals zero
 	 */

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

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

net/hsr/hsr_device.c+2−2

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

net/hsr/hsr_forward.c+1−2

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

net/hsr/hsr_framereg.c+7−2

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

net/hsr/hsr_framereg.h+1−1

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

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

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

net/ipv4/icmp.c+6−2

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

net/ipv4/igmp.c+13−8

 static void ip_mc_clear_src(struct ip_mc_list *pmc)
 {
-	struct ip_sf_list *psf, *nextpsf;
+	struct ip_sf_list *psf, *nextpsf, *tomb, *sources;
-	for (psf = pmc->tomb; psf; psf = nextpsf) {
+	spin_lock_bh(&pmc->lock);
+	tomb = pmc->tomb;
+	pmc->tomb = NULL;
+	sources = pmc->sources;
+	pmc->sources = NULL;
+	pmc->sfmode = MCAST_EXCLUDE;
+	pmc->sfcount[MCAST_INCLUDE] = 0;
+	pmc->sfcount[MCAST_EXCLUDE] = 1;
+	spin_unlock_bh(&pmc->lock);
+	for (psf = tomb; psf; psf = nextpsf) {
 		nextpsf = psf->sf_next;
 		kfree(psf);
 	}
-	pmc->tomb = NULL;
+	for (psf = sources; psf; psf = nextpsf) {
-	for (psf = pmc->sources; psf; psf = nextpsf) {
 		nextpsf = psf->sf_next;
 		kfree(psf);
 	}
-	pmc->sources = NULL;
-	pmc->sfmode = MCAST_EXCLUDE;
-	pmc->sfcount[MCAST_INCLUDE] = 0;
-	pmc->sfcount[MCAST_EXCLUDE] = 1;
 }
 /* Join a multicast group

net/ipv4/ip_tunnel.c+2−2

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

net/ipv4/ipmr.c+16−18

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

net/ipv6/icmp.c+1−1

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

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

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

net/ipv6/ip6_gre.c+5−4

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

net/ipv6/ip6_tunnel.c+4−4

 	gro_cells_destroy(&t->gro_cells);
 	dst_cache_destroy(&t->dst_cache);
 	free_percpu(dev->tstats);
-	free_netdev(dev);
 }
 static int ip6_tnl_create2(struct net_device *dev)
 	return t;
 failed_free:
-	ip6_dev_free(dev);
+	free_netdev(dev);
 failed:
 	return ERR_PTR(err);
 }
 static void ip6_tnl_dev_setup(struct net_device *dev)
 {
 	dev->netdev_ops = &ip6_tnl_netdev_ops;
-	dev->destructor = ip6_dev_free;
+	dev->needs_free_netdev = true;
+	dev->priv_destructor = ip6_dev_free;
 	dev->type = ARPHRD_TUNNEL6;
 	dev->flags |= IFF_NOARP;
 	return 0;
 err_register:
-	ip6_dev_free(ip6n->fb_tnl_dev);
+	free_netdev(ip6n->fb_tnl_dev);
 err_alloc_dev:
 	return err;
 }

net/ipv6/ip6_vti.c+4−4

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

net/ipv6/ip6mr.c+1−1

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

net/ipv6/proc.c+1−1

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

net/ipv6/route.c+1−0

@@ -2832,6 +2832,7 @@ static int fib6_ifdown(struct rt6_info rt, void arg) · 2831 unmodified lines
2832	if ((rt->dst.dev == dev \|\| !dev) &&	2832	if ((rt->dst.dev == dev \|\| !dev) &&
2833	rt != adn->net->ipv6.ip6_null_entry &&	2833	rt != adn->net->ipv6.ip6_null_entry &&
2834	(rt->rt6i_nsiblings == 0 \|\|	2834	(rt->rt6i_nsiblings == 0 \|\|
		2835	(dev && netdev_unregistering(dev)) \|\|
2835	!rt->rt6i_idev->cnf.ignore_routes_with_linkdown))	2836	!rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
2836	return -1;	2837	return -1;
2837		2838

net/ipv6/sit.c+3−3

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

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

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

net/l2tp/l2tp_eth.c+8−7

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

net/mac80211/cfg.c+2−0

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

net/mac80211/ieee80211_i.h+1−1

@@ -1523,7 +1523,7 @@ ieee80211_have_rx_timestamp(struct ieee80211_rx_status *status) · 1522 unmodified lines
1523	return true;	1523	return true;
1524	/* can't handle non-legacy preamble yet */	1524	/* can't handle non-legacy preamble yet */
1525	if (status->flag & RX_FLAG_MACTIME_PLCP_START &&	1525	if (status->flag & RX_FLAG_MACTIME_PLCP_START &&
1526	status->encoding != RX_ENC_LEGACY)	1526	status->encoding == RX_ENC_LEGACY)
1527	return true;	1527	return true;
1528	return false;	1528	return false;
1529	}	1529	}

net/mac80211/iface.c+4−3

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

net/mac80211/mlme.c+31−31

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

net/mac80211/rx.c+5−1

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

net/mac80211/wpa.c+5−4

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

net/mac802154/iface.c+3−4

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

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

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

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

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

net/sched/act_pedit.c+3−1

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

net/sched/act_police.c+3−5

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

net/sctp/socket.c+2−2

@@ -4622,13 +4622,13 @@ int sctp_for_each_endpoint(int (cb)(struct sctp_endpoint , void *), · 4621 unmodified lines
4622		4622
4623	for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;	4623	for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
4624	hash++, head++) {	4624	hash++, head++) {
4625	read_lock(&head->lock);	4625	read_lock_bh(&head->lock);
4626	sctp_for_each_hentry(epb, &head->chain) {	4626	sctp_for_each_hentry(epb, &head->chain) {
4627	err = cb(sctp_ep(epb), p);	4627	err = cb(sctp_ep(epb), p);
4628	if (err)	4628	if (err)
4629	break;	4629	break;
4630	}	4630	}
4631	read_unlock(&head->lock);	4631	read_unlock_bh(&head->lock);
4632	}	4632	}
4633		4633
4634	return err;	4634	return err;

net/tipc/msg.c+1−1

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

net/unix/af_unix.c+6−1

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

security/keys/Kconfig+5−1

 	  If you are unsure as to whether this is required, answer N.
+config KEYS_COMPAT
+	def_bool y
+	depends on COMPAT && KEYS
 config PERSISTENT_KEYRINGS
 	bool "Enable register of persistent per-UID keyrings"
 	depends on KEYS
 config KEY_DH_OPERATIONS
        bool "Diffie-Hellman operations on retained keys"
        depends on KEYS
-       select MPILIB
        select CRYPTO
        select CRYPTO_HASH
+       select CRYPTO_DH
        help
 	 This option provides support for calculating Diffie-Hellman
 	 public keys and shared secrets using values stored as keys

security/keys/dh.c+184−116

@@ -8,34 +8,17 @@ · 7 unmodified lines
8	* 2 of the License, or (at your option) any later version.	8	* 2 of the License, or (at your option) any later version.
9	*/	9	*/
10		10
11	#include <linux/mpi.h>
12	#include <linux/slab.h>	11	#include <linux/slab.h>
13	#include <linux/uaccess.h>	12	#include <linux/uaccess.h>
		13	#include <linux/scatterlist.h>
14	#include <linux/crypto.h>	14	#include <linux/crypto.h>
15	#include <crypto/hash.h>	15	#include <crypto/hash.h>
		16	#include <crypto/kpp.h>
		17	#include <crypto/dh.h>
16	#include <keys/user-type.h>	18	#include <keys/user-type.h>
17	#include "internal.h"	19	#include "internal.h"
18		20
19	/*	21	static ssize_t dh_data_from_key(key_serial_t keyid, void **data)
20	* Public key or shared secret generation function [RFC2631 sec 2.1.1]
21	*
22	* ya = g^xa mod p;
23	* or
24	* ZZ = yb^xa mod p;
25	*
26	* where xa is the local private key, ya is the local public key, g is
27	* the generator, p is the prime, yb is the remote public key, and ZZ
28	* is the shared secret.
29	*
30	* Both are the same calculation, so g or yb are the "base" and ya or
31	* ZZ are the "result".
32	*/
33	static int do_dh(MPI result, MPI base, MPI xa, MPI p)
34	{
35	return mpi_powm(result, base, xa, p);
36	}
37
38	static ssize_t mpi_from_key(key_serial_t keyid, size_t maxlen, MPI *mpi)
39	{	22	{
40	struct key *key;	23	struct key *key;
41	key_ref_t key_ref;	24	key_ref_t key_ref;
@@ -56,19 +39,17 @@ static ssize_t mpi_from_key(key_serial_t keyid, size_t maxlen, MPI *mpi) · 14 unmodified lines
56	status = key_validate(key);	39	status = key_validate(key);
57	if (status == 0) {	40	if (status == 0) {
58	const struct user_key_payload *payload;	41	const struct user_key_payload *payload;
		42	uint8_t *duplicate;
59		43
60	payload = user_key_payload_locked(key);	44	payload = user_key_payload_locked(key);
61		45
62	if (maxlen == 0) {	46	duplicate = kmemdup(payload->data, payload->datalen,
63	*mpi = NULL;	47	GFP_KERNEL);
		48	if (duplicate) {
		49	*data = duplicate;
64	ret = payload->datalen;	50	ret = payload->datalen;
65	} else if (payload->datalen <= maxlen) {
66	*mpi = mpi_read_raw_data(payload->data,
67	payload->datalen);
68	if (*mpi)
69	ret = payload->datalen;
70	} else {	51	} else {
71	ret = -EINVAL;	52	ret = -ENOMEM;
72	}	53	}
73	}	54	}
74	up_read(&key->sem);	55	up_read(&key->sem);
@@ -79,6 +60,29 @@ error: · 4 unmodified lines
79	return ret;	60	return ret;
80	}	61	}
81		62
		63	static void dh_free_data(struct dh *dh)
		64	{
		65	kzfree(dh->key);
		66	kzfree(dh->p);
		67	kzfree(dh->g);
		68	}
		69
		70	struct dh_completion {
		71	struct completion completion;
		72	int err;
		73	};
		74
		75	static void dh_crypto_done(struct crypto_async_request *req, int err)
		76	{
		77	struct dh_completion *compl = req->data;
		78
		79	if (err == -EINPROGRESS)
		80	return;
		81
		82	compl->err = err;
		83	complete(&compl->completion);
		84	}
		85
82	struct kdf_sdesc {	86	struct kdf_sdesc {
83	struct shash_desc shash;	87	struct shash_desc shash;
84	char ctx[];	88	char ctx[];
@@ -89,6 +93,7 @@ static int kdf_alloc(struct kdf_sdesc *sdesc_ret, char hashname) · 4 unmodified lines
89	struct crypto_shash *tfm;	93	struct crypto_shash *tfm;
90	struct kdf_sdesc *sdesc;	94	struct kdf_sdesc *sdesc;
91	int size;	95	int size;
		96	int err;
92		97
93	/* allocate synchronous hash */	98	/* allocate synchronous hash */
94	tfm = crypto_alloc_shash(hashname, 0, 0);	99	tfm = crypto_alloc_shash(hashname, 0, 0);
@@ -97,16 +102,25 @@ static int kdf_alloc(struct kdf_sdesc *sdesc_ret, char hashname) · 2 unmodified lines
97	return PTR_ERR(tfm);	102	return PTR_ERR(tfm);
98	}	103	}
99		104
		105	err = -EINVAL;
		106	if (crypto_shash_digestsize(tfm) == 0)
		107	goto out_free_tfm;
		108
		109	err = -ENOMEM;
100	size = sizeof(struct shash_desc) + crypto_shash_descsize(tfm);	110	size = sizeof(struct shash_desc) + crypto_shash_descsize(tfm);
101	sdesc = kmalloc(size, GFP_KERNEL);	111	sdesc = kmalloc(size, GFP_KERNEL);
102	if (!sdesc)	112	if (!sdesc)
103	return -ENOMEM;	113	goto out_free_tfm;
104	sdesc->shash.tfm = tfm;	114	sdesc->shash.tfm = tfm;
105	sdesc->shash.flags = 0x0;	115	sdesc->shash.flags = 0x0;
106		116
107	*sdesc_ret = sdesc;	117	*sdesc_ret = sdesc;
108		118
109	return 0;	119	return 0;
		120
		121	out_free_tfm:
		122	crypto_free_shash(tfm);
		123	return err;
110	}	124	}
111		125
112	static void kdf_dealloc(struct kdf_sdesc *sdesc)	126	static void kdf_dealloc(struct kdf_sdesc *sdesc)
@@ -120,14 +134,6 @@ static void kdf_dealloc(struct kdf_sdesc *sdesc) · 7 unmodified lines
120	kzfree(sdesc);	134	kzfree(sdesc);
121	}	135	}
122		136
123	/* convert 32 bit integer into its string representation */
124	static inline void crypto_kw_cpu_to_be32(u32 val, u8 *buf)
125	{
126	__be32 a = (__be32 )buf;
127
128	*a = cpu_to_be32(val);
129	}
130
131	/*	137	/*
132	* Implementation of the KDF in counter mode according to SP800-108 section 5.1	138	* Implementation of the KDF in counter mode according to SP800-108 section 5.1
133	* as well as SP800-56A section 5.8.1 (Single-step KDF).	139	* as well as SP800-56A section 5.8.1 (Single-step KDF).
@@ -138,25 +144,39 @@ static inline void crypto_kw_cpu_to_be32(u32 val, u8 *buf) · 4 unmodified lines
138	* 5.8.1.2).	144	* 5.8.1.2).
139	*/	145	*/
140	static int kdf_ctr(struct kdf_sdesc sdesc, const u8 src, unsigned int slen,	146	static int kdf_ctr(struct kdf_sdesc sdesc, const u8 src, unsigned int slen,
141	u8 *dst, unsigned int dlen)	147	u8 *dst, unsigned int dlen, unsigned int zlen)
142	{	148	{
143	struct shash_desc *desc = &sdesc->shash;	149	struct shash_desc *desc = &sdesc->shash;
144	unsigned int h = crypto_shash_digestsize(desc->tfm);	150	unsigned int h = crypto_shash_digestsize(desc->tfm);
145	int err = 0;	151	int err = 0;
146	u8 *dst_orig = dst;	152	u8 *dst_orig = dst;
147	u32 i = 1;	153	__be32 counter = cpu_to_be32(1);
148	u8 iteration[sizeof(u32)];
149		154
150	while (dlen) {	155	while (dlen) {
151	err = crypto_shash_init(desc);	156	err = crypto_shash_init(desc);
152	if (err)	157	if (err)
153	goto err;	158	goto err;
154		159
155	crypto_kw_cpu_to_be32(i, iteration);	160	err = crypto_shash_update(desc, (u8 *)&counter, sizeof(__be32));
156	err = crypto_shash_update(desc, iteration, sizeof(u32));
157	if (err)	161	if (err)
158	goto err;	162	goto err;
159		163
		164	if (zlen && h) {
		165	u8 tmpbuffer[h];
		166	size_t chunk = min_t(size_t, zlen, h);
		167	memset(tmpbuffer, 0, chunk);
		168
		169	do {
		170	err = crypto_shash_update(desc, tmpbuffer,
		171	chunk);
		172	if (err)
		173	goto err;
		174
		175	zlen -= chunk;
		176	chunk = min_t(size_t, zlen, h);
		177	} while (zlen);
		178	}
		179
160	if (src && slen) {	180	if (src && slen) {
161	err = crypto_shash_update(desc, src, slen);	181	err = crypto_shash_update(desc, src, slen);
162	if (err)	182	if (err)
@@ -179,7 +199,7 @@ static int kdf_ctr(struct kdf_sdesc sdesc, const u8 src, unsigned int slen, · 16 unmodified lines
179		199
180	dlen -= h;	200	dlen -= h;
181	dst += h;	201	dst += h;
182	i++;	202	counter = cpu_to_be32(be32_to_cpu(counter) + 1);
183	}	203	}
184	}	204	}
185		205
@@ -192,7 +212,7 @@ err: · 6 unmodified lines
192		212
193	static int keyctl_dh_compute_kdf(struct kdf_sdesc *sdesc,	213	static int keyctl_dh_compute_kdf(struct kdf_sdesc *sdesc,
194	char __user *buffer, size_t buflen,	214	char __user *buffer, size_t buflen,
195	uint8_t *kbuf, size_t kbuflen)	215	uint8_t *kbuf, size_t kbuflen, size_t lzero)
196	{	216	{
197	uint8_t *outbuf = NULL;	217	uint8_t *outbuf = NULL;
198	int ret;	218	int ret;
@@ -203,7 +223,7 @@ static int keyctl_dh_compute_kdf(struct kdf_sdesc *sdesc, · 4 unmodified lines
203	goto err;	223	goto err;
204	}	224	}
205		225
206	ret = kdf_ctr(sdesc, kbuf, kbuflen, outbuf, buflen);	226	ret = kdf_ctr(sdesc, kbuf, kbuflen, outbuf, buflen, lzero);
207	if (ret)	227	if (ret)
208	goto err;	228	goto err;
209		229
@@ -221,21 +241,26 @@ long __keyctl_dh_compute(struct keyctl_dh_params __user *params, · 11 unmodified lines
221	struct keyctl_kdf_params *kdfcopy)	241	struct keyctl_kdf_params *kdfcopy)
222	{	242	{
223	long ret;	243	long ret;
224	MPI base, private, prime, result;	244	ssize_t dlen;
225	unsigned nbytes;	245	int secretlen;
		246	int outlen;
226	struct keyctl_dh_params pcopy;	247	struct keyctl_dh_params pcopy;
227	uint8_t *kbuf;	248	struct dh dh_inputs;
228	ssize_t keylen;	249	struct scatterlist outsg;
229	size_t resultlen;	250	struct dh_completion compl;
		251	struct crypto_kpp *tfm;
		252	struct kpp_request *req;
		253	uint8_t *secret;
		254	uint8_t *outbuf;
230	struct kdf_sdesc *sdesc = NULL;	255	struct kdf_sdesc *sdesc = NULL;
231		256
232	if (!params \|\| (!buffer && buflen)) {	257	if (!params \|\| (!buffer && buflen)) {
233	ret = -EINVAL;	258	ret = -EINVAL;
234	goto out;	259	goto out1;
235	}	260	}
236	if (copy_from_user(&pcopy, params, sizeof(pcopy)) != 0) {	261	if (copy_from_user(&pcopy, params, sizeof(pcopy)) != 0) {
237	ret = -EFAULT;	262	ret = -EFAULT;
238	goto out;	263	goto out1;
239	}	264	}
240		265
241	if (kdfcopy) {	266	if (kdfcopy) {
@@ -244,104 +269,147 @@ long __keyctl_dh_compute(struct keyctl_dh_params __user *params, · 2 unmodified lines
244	if (buflen > KEYCTL_KDF_MAX_OUTPUT_LEN \|\|	269	if (buflen > KEYCTL_KDF_MAX_OUTPUT_LEN \|\|
245	kdfcopy->otherinfolen > KEYCTL_KDF_MAX_OI_LEN) {	270	kdfcopy->otherinfolen > KEYCTL_KDF_MAX_OI_LEN) {
246	ret = -EMSGSIZE;	271	ret = -EMSGSIZE;
247	goto out;	272	goto out1;
248	}	273	}
249		274
250	/* get KDF name string */	275	/* get KDF name string */
251	hashname = strndup_user(kdfcopy->hashname, CRYPTO_MAX_ALG_NAME);	276	hashname = strndup_user(kdfcopy->hashname, CRYPTO_MAX_ALG_NAME);
252	if (IS_ERR(hashname)) {	277	if (IS_ERR(hashname)) {
253	ret = PTR_ERR(hashname);	278	ret = PTR_ERR(hashname);
254	goto out;	279	goto out1;
255	}	280	}
256		281
257	/* allocate KDF from the kernel crypto API */	282	/* allocate KDF from the kernel crypto API */
258	ret = kdf_alloc(&sdesc, hashname);	283	ret = kdf_alloc(&sdesc, hashname);
259	kfree(hashname);	284	kfree(hashname);
260	if (ret)	285	if (ret)
261	goto out;	286	goto out1;
262	}	287	}
263		288
264	/*	289	memset(&dh_inputs, 0, sizeof(dh_inputs));
265	* If the caller requests postprocessing with a KDF, allow an	290
266	* arbitrary output buffer size since the KDF ensures proper truncation.	291	dlen = dh_data_from_key(pcopy.prime, &dh_inputs.p);
267	*/	292	if (dlen < 0) {
268	keylen = mpi_from_key(pcopy.prime, kdfcopy ? SIZE_MAX : buflen, &prime);	293	ret = dlen;
269	if (keylen < 0 \|\| !prime) {	294	goto out1;
270	/* buflen == 0 may be used to query the required buffer size,	295	}
271	* which is the prime key length.	296	dh_inputs.p_size = dlen;
272	*/	297
273	ret = keylen;	298	dlen = dh_data_from_key(pcopy.base, &dh_inputs.g);
274	goto out;	299	if (dlen < 0) {
		300	ret = dlen;
		301	goto out2;
275	}	302	}
		303	dh_inputs.g_size = dlen;
276		304
277	/* The result is never longer than the prime */	305	dlen = dh_data_from_key(pcopy.private, &dh_inputs.key);
278	resultlen = keylen;	306	if (dlen < 0) {
		307	ret = dlen;
		308	goto out2;
		309	}
		310	dh_inputs.key_size = dlen;
279		311
280	keylen = mpi_from_key(pcopy.base, SIZE_MAX, &base);	312	secretlen = crypto_dh_key_len(&dh_inputs);
281	if (keylen < 0 \|\| !base) {	313	secret = kmalloc(secretlen, GFP_KERNEL);
282	ret = keylen;	314	if (!secret) {
283	goto error1;	315	ret = -ENOMEM;
		316	goto out2;
284	}	317	}
		318	ret = crypto_dh_encode_key(secret, secretlen, &dh_inputs);
		319	if (ret)
		320	goto out3;
285		321
286	keylen = mpi_from_key(pcopy.private, SIZE_MAX, &private);	322	tfm = crypto_alloc_kpp("dh", CRYPTO_ALG_TYPE_KPP, 0);
287	if (keylen < 0 \|\| !private) {	323	if (IS_ERR(tfm)) {
288	ret = keylen;	324	ret = PTR_ERR(tfm);
289	goto error2;	325	goto out3;
		326	}
		327
		328	ret = crypto_kpp_set_secret(tfm, secret, secretlen);
		329	if (ret)
		330	goto out4;
		331
		332	outlen = crypto_kpp_maxsize(tfm);
		333
		334	if (!kdfcopy) {
		335	/*
		336	* When not using a KDF, buflen 0 is used to read the
		337	* required buffer length
		338	*/
		339	if (buflen == 0) {
		340	ret = outlen;
		341	goto out4;
		342	} else if (outlen > buflen) {
		343	ret = -EOVERFLOW;
		344	goto out4;
		345	}
290	}	346	}
291		347
292	result = mpi_alloc(0);	348	outbuf = kzalloc(kdfcopy ? (outlen + kdfcopy->otherinfolen) : outlen,
293	if (!result) {	349	GFP_KERNEL);
		350	if (!outbuf) {
294	ret = -ENOMEM;	351	ret = -ENOMEM;
295	goto error3;	352	goto out4;
296	}	353	}
297		354
298	/* allocate space for DH shared secret and SP800-56A otherinfo */	355	sg_init_one(&outsg, outbuf, outlen);
299	kbuf = kmalloc(kdfcopy ? (resultlen + kdfcopy->otherinfolen) : resultlen,	356
300	GFP_KERNEL);	357	req = kpp_request_alloc(tfm, GFP_KERNEL);
301	if (!kbuf) {	358	if (!req) {
302	ret = -ENOMEM;	359	ret = -ENOMEM;
303	goto error4;	360	goto out5;
304	}	361	}
305		362
		363	kpp_request_set_input(req, NULL, 0);
		364	kpp_request_set_output(req, &outsg, outlen);
		365	init_completion(&compl.completion);
		366	kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG \|
		367	CRYPTO_TFM_REQ_MAY_SLEEP,
		368	dh_crypto_done, &compl);
		369
306	/*	370	/*
307	* Concatenate SP800-56A otherinfo past DH shared secret -- the	371	* For DH, generate_public_key and generate_shared_secret are
308	* input to the KDF is (DH shared secret \|\| otherinfo)	372	* the same calculation
309	*/	373	*/
310	if (kdfcopy && kdfcopy->otherinfo &&	374	ret = crypto_kpp_generate_public_key(req);
311	copy_from_user(kbuf + resultlen, kdfcopy->otherinfo,	375	if (ret == -EINPROGRESS) {
312	kdfcopy->otherinfolen) != 0) {	376	wait_for_completion(&compl.completion);
313	ret = -EFAULT;	377	ret = compl.err;
314	goto error5;	378	if (ret)
		379	goto out6;
315	}	380	}
316		381
317	ret = do_dh(result, base, private, prime);
318	if (ret)
319	goto error5;
320
321	ret = mpi_read_buffer(result, kbuf, resultlen, &nbytes, NULL);
322	if (ret != 0)
323	goto error5;
324
325	if (kdfcopy) {	382	if (kdfcopy) {
326	ret = keyctl_dh_compute_kdf(sdesc, buffer, buflen, kbuf,	383	/*
327	resultlen + kdfcopy->otherinfolen);	384	* Concatenate SP800-56A otherinfo past DH shared secret -- the
328	} else {	385	* input to the KDF is (DH shared secret \|\| otherinfo)
329	ret = nbytes;	386	*/
330	if (copy_to_user(buffer, kbuf, nbytes) != 0)	387	if (copy_from_user(outbuf + req->dst_len, kdfcopy->otherinfo,
		388	kdfcopy->otherinfolen) != 0) {
331	ret = -EFAULT;	389	ret = -EFAULT;
		390	goto out6;
		391	}
		392
		393	ret = keyctl_dh_compute_kdf(sdesc, buffer, buflen, outbuf,
		394	req->dst_len + kdfcopy->otherinfolen,
		395	outlen - req->dst_len);
		396	} else if (copy_to_user(buffer, outbuf, req->dst_len) == 0) {
		397	ret = req->dst_len;
		398	} else {
		399	ret = -EFAULT;
332	}	400	}
333		401
334	error5:	402	out6:
335	kzfree(kbuf);	403	kpp_request_free(req);
336	error4:	404	out5:
337	mpi_free(result);	405	kzfree(outbuf);
338	error3:	406	out4:
339	mpi_free(private);	407	crypto_free_kpp(tfm);
340	error2:	408	out3:
341	mpi_free(base);	409	kzfree(secret);
342	error1:	410	out2:
343	mpi_free(prime);	411	dh_free_data(&dh_inputs);
344	out:	412	out1:
345	kdf_dealloc(sdesc);	413	kdf_dealloc(sdesc);
346	return ret;	414	return ret;
347	}	415	}

security/keys/encrypted-keys/encrypted.c+74−130

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	#include <linux/scatterlist.h>	30	#include <linux/scatterlist.h>
31	#include <linux/ctype.h>	31	#include <linux/ctype.h>
32	#include <crypto/aes.h>	32	#include <crypto/aes.h>
		33	#include <crypto/algapi.h>
33	#include <crypto/hash.h>	34	#include <crypto/hash.h>
34	#include <crypto/sha.h>	35	#include <crypto/sha.h>
35	#include <crypto/skcipher.h>	36	#include <crypto/skcipher.h>
@@ -54,13 +55,7 @@ static int blksize; · 18 unmodified lines
54	#define MAX_DATA_SIZE 4096	55	#define MAX_DATA_SIZE 4096
55	#define MIN_DATA_SIZE 20	56	#define MIN_DATA_SIZE 20
56		57
57	struct sdesc {	58	static struct crypto_shash *hash_tfm;
58	struct shash_desc shash;
59	char ctx[];
60	};
61
62	static struct crypto_shash *hashalg;
63	static struct crypto_shash *hmacalg;
64		59
65	enum {	60	enum {
66	Opt_err = -1, Opt_new, Opt_load, Opt_update	61	Opt_err = -1, Opt_new, Opt_load, Opt_update
@@ -141,23 +136,22 @@ static int valid_ecryptfs_desc(const char *ecryptfs_desc) · 74 unmodified lines
141	*/	136	*/
142	static int valid_master_desc(const char new_desc, const char orig_desc)	137	static int valid_master_desc(const char new_desc, const char orig_desc)
143	{	138	{
144	if (!memcmp(new_desc, KEY_TRUSTED_PREFIX, KEY_TRUSTED_PREFIX_LEN)) {	139	int prefix_len;
145	if (strlen(new_desc) == KEY_TRUSTED_PREFIX_LEN)	140
146	goto out;	141	if (!strncmp(new_desc, KEY_TRUSTED_PREFIX, KEY_TRUSTED_PREFIX_LEN))
147	if (orig_desc)	142	prefix_len = KEY_TRUSTED_PREFIX_LEN;
148	if (memcmp(new_desc, orig_desc, KEY_TRUSTED_PREFIX_LEN))	143	else if (!strncmp(new_desc, KEY_USER_PREFIX, KEY_USER_PREFIX_LEN))
149	goto out;	144	prefix_len = KEY_USER_PREFIX_LEN;
150	} else if (!memcmp(new_desc, KEY_USER_PREFIX, KEY_USER_PREFIX_LEN)) {	145	else
151	if (strlen(new_desc) == KEY_USER_PREFIX_LEN)	146	return -EINVAL;
152	goto out;	147
153	if (orig_desc)	148	if (!new_desc[prefix_len])
154	if (memcmp(new_desc, orig_desc, KEY_USER_PREFIX_LEN))	149	return -EINVAL;
155	goto out;	150
156	} else	151	if (orig_desc && strncmp(new_desc, orig_desc, prefix_len))
157	goto out;	152	return -EINVAL;
		153
158	return 0;	154	return 0;
159	out:
160	return -EINVAL;
161	}	155	}
162		156
163	/*	157	/*
@@ -321,53 +315,38 @@ error: · 157 unmodified lines
321	return ukey;	315	return ukey;
322	}	316	}
323		317
324	static struct sdesc alloc_sdesc(struct crypto_shash alg)	318	static int calc_hash(struct crypto_shash tfm, u8 digest,
325	{
326	struct sdesc *sdesc;
327	int size;
328
329	size = sizeof(struct shash_desc) + crypto_shash_descsize(alg);
330	sdesc = kmalloc(size, GFP_KERNEL);
331	if (!sdesc)
332	return ERR_PTR(-ENOMEM);
333	sdesc->shash.tfm = alg;
334	sdesc->shash.flags = 0x0;
335	return sdesc;
336	}
337
338	static int calc_hmac(u8 digest, const u8 key, unsigned int keylen,
339	const u8 *buf, unsigned int buflen)	319	const u8 *buf, unsigned int buflen)
340	{	320	{
341	struct sdesc *sdesc;	321	SHASH_DESC_ON_STACK(desc, tfm);
342	int ret;	322	int err;
343		323
344	sdesc = alloc_sdesc(hmacalg);	324	desc->tfm = tfm;
345	if (IS_ERR(sdesc)) {	325	desc->flags = 0;
346	pr_info("encrypted_key: can't alloc %s\n", hmac_alg);
347	return PTR_ERR(sdesc);
348	}
349		326
350	ret = crypto_shash_setkey(hmacalg, key, keylen);	327	err = crypto_shash_digest(desc, buf, buflen, digest);
351	if (!ret)	328	shash_desc_zero(desc);
352	ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest);	329	return err;
353	kfree(sdesc);
354	return ret;
355	}	330	}
356		331
357	static int calc_hash(u8 digest, const u8 buf, unsigned int buflen)	332	static int calc_hmac(u8 digest, const u8 key, unsigned int keylen,
		333	const u8 *buf, unsigned int buflen)
358	{	334	{
359	struct sdesc *sdesc;	335	struct crypto_shash *tfm;
360	int ret;	336	int err;
361		337
362	sdesc = alloc_sdesc(hashalg);	338	tfm = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);
363	if (IS_ERR(sdesc)) {	339	if (IS_ERR(tfm)) {
364	pr_info("encrypted_key: can't alloc %s\n", hash_alg);	340	pr_err("encrypted_key: can't alloc %s transform: %ld\n",
365	return PTR_ERR(sdesc);	341	hmac_alg, PTR_ERR(tfm));
		342	return PTR_ERR(tfm);
366	}	343	}
367		344
368	ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest);	345	err = crypto_shash_setkey(tfm, key, keylen);
369	kfree(sdesc);	346	if (!err)
370	return ret;	347	err = calc_hash(tfm, digest, buf, buflen);
		348	crypto_free_shash(tfm);
		349	return err;
371	}	350	}
372		351
373	enum derived_key_type { ENC_KEY, AUTH_KEY };	352	enum derived_key_type { ENC_KEY, AUTH_KEY };
@@ -385,10 +364,9 @@ static int get_derived_key(u8 *derived_key, enum derived_key_type key_type, · 11 unmodified lines
385	derived_buf_len = HASH_SIZE;	364	derived_buf_len = HASH_SIZE;
386		365
387	derived_buf = kzalloc(derived_buf_len, GFP_KERNEL);	366	derived_buf = kzalloc(derived_buf_len, GFP_KERNEL);
388	if (!derived_buf) {	367	if (!derived_buf)
389	pr_err("encrypted_key: out of memory\n");
390	return -ENOMEM;	368	return -ENOMEM;
391	}	369
392	if (key_type)	370	if (key_type)
393	strcpy(derived_buf, "AUTH_KEY");	371	strcpy(derived_buf, "AUTH_KEY");
394	else	372	else
@@ -396,8 +374,8 @@ static int get_derived_key(u8 *derived_key, enum derived_key_type key_type, · 1 unmodified line
396		374
397	memcpy(derived_buf + strlen(derived_buf) + 1, master_key,	375	memcpy(derived_buf + strlen(derived_buf) + 1, master_key,
398	master_keylen);	376	master_keylen);
399	ret = calc_hash(derived_key, derived_buf, derived_buf_len);	377	ret = calc_hash(hash_tfm, derived_key, derived_buf, derived_buf_len);
400	kfree(derived_buf);	378	kzfree(derived_buf);
401	return ret;	379	return ret;
402	}	380	}
403		381
@@ -480,12 +458,9 @@ static int derived_key_encrypt(struct encrypted_key_payload *epayload, · 76 unmodified lines
480	struct skcipher_request *req;	458	struct skcipher_request *req;
481	unsigned int encrypted_datalen;	459	unsigned int encrypted_datalen;
482	u8 iv[AES_BLOCK_SIZE];	460	u8 iv[AES_BLOCK_SIZE];
483	unsigned int padlen;
484	char pad[16];
485	int ret;	461	int ret;
486		462
487	encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);	463	encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);
488	padlen = encrypted_datalen - epayload->decrypted_datalen;
489		464
490	req = init_skcipher_req(derived_key, derived_keylen);	465	req = init_skcipher_req(derived_key, derived_keylen);
491	ret = PTR_ERR(req);	466	ret = PTR_ERR(req);
@@ -493,11 +468,10 @@ static int derived_key_encrypt(struct encrypted_key_payload *epayload, · 1 unmodified line
493	goto out;	468	goto out;
494	dump_decrypted_data(epayload);	469	dump_decrypted_data(epayload);
495		470
496	memset(pad, 0, sizeof pad);
497	sg_init_table(sg_in, 2);	471	sg_init_table(sg_in, 2);
498	sg_set_buf(&sg_in[0], epayload->decrypted_data,	472	sg_set_buf(&sg_in[0], epayload->decrypted_data,
499	epayload->decrypted_datalen);	473	epayload->decrypted_datalen);
500	sg_set_buf(&sg_in[1], pad, padlen);	474	sg_set_page(&sg_in[1], ZERO_PAGE(0), AES_BLOCK_SIZE, 0);
501		475
502	sg_init_table(sg_out, 1);	476	sg_init_table(sg_out, 1);
503	sg_set_buf(sg_out, epayload->encrypted_data, encrypted_datalen);	477	sg_set_buf(sg_out, epayload->encrypted_data, encrypted_datalen);
@@ -533,6 +507,7 @@ static int datablob_hmac_append(struct encrypted_key_payload *epayload, · 29 unmodified lines
533	if (!ret)	507	if (!ret)
534	dump_hmac(NULL, digest, HASH_SIZE);	508	dump_hmac(NULL, digest, HASH_SIZE);
535	out:	509	out:
		510	memzero_explicit(derived_key, sizeof(derived_key));
536	return ret;	511	return ret;
537	}	512	}
538		513
@@ -561,8 +536,8 @@ static int datablob_hmac_verify(struct encrypted_key_payload *epayload, · 22 unmodified lines
561	ret = calc_hmac(digest, derived_key, sizeof derived_key, p, len);	536	ret = calc_hmac(digest, derived_key, sizeof derived_key, p, len);
562	if (ret < 0)	537	if (ret < 0)
563	goto out;	538	goto out;
564	ret = memcmp(digest, epayload->format + epayload->datablob_len,	539	ret = crypto_memneq(digest, epayload->format + epayload->datablob_len,
565	sizeof digest);	540	sizeof(digest));
566	if (ret) {	541	if (ret) {
567	ret = -EINVAL;	542	ret = -EINVAL;
568	dump_hmac("datablob",	543	dump_hmac("datablob",
@@ -571,6 +546,7 @@ static int datablob_hmac_verify(struct encrypted_key_payload *epayload, · 2 unmodified lines
571	dump_hmac("calc", digest, HASH_SIZE);	546	dump_hmac("calc", digest, HASH_SIZE);
572	}	547	}
573	out:	548	out:
		549	memzero_explicit(derived_key, sizeof(derived_key));
574	return ret;	550	return ret;
575	}	551	}
576		552
@@ -584,9 +560,14 @@ static int derived_key_decrypt(struct encrypted_key_payload *epayload, · 7 unmodified lines
584	struct skcipher_request *req;	560	struct skcipher_request *req;
585	unsigned int encrypted_datalen;	561	unsigned int encrypted_datalen;
586	u8 iv[AES_BLOCK_SIZE];	562	u8 iv[AES_BLOCK_SIZE];
587	char pad[16];	563	u8 *pad;
588	int ret;	564	int ret;
589		565
		566	/* Throwaway buffer to hold the unused zero padding at the end */
		567	pad = kmalloc(AES_BLOCK_SIZE, GFP_KERNEL);
		568	if (!pad)
		569	return -ENOMEM;
		570
590	encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);	571	encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);
591	req = init_skcipher_req(derived_key, derived_keylen);	572	req = init_skcipher_req(derived_key, derived_keylen);
592	ret = PTR_ERR(req);	573	ret = PTR_ERR(req);
@@ -594,13 +575,12 @@ static int derived_key_decrypt(struct encrypted_key_payload *epayload, · 1 unmodified line
594	goto out;	575	goto out;
595	dump_encrypted_data(epayload, encrypted_datalen);	576	dump_encrypted_data(epayload, encrypted_datalen);
596		577
597	memset(pad, 0, sizeof pad);
598	sg_init_table(sg_in, 1);	578	sg_init_table(sg_in, 1);
599	sg_init_table(sg_out, 2);	579	sg_init_table(sg_out, 2);
600	sg_set_buf(sg_in, epayload->encrypted_data, encrypted_datalen);	580	sg_set_buf(sg_in, epayload->encrypted_data, encrypted_datalen);
601	sg_set_buf(&sg_out[0], epayload->decrypted_data,	581	sg_set_buf(&sg_out[0], epayload->decrypted_data,
602	epayload->decrypted_datalen);	582	epayload->decrypted_datalen);
603	sg_set_buf(&sg_out[1], pad, sizeof pad);	583	sg_set_buf(&sg_out[1], pad, AES_BLOCK_SIZE);
604		584
605	memcpy(iv, epayload->iv, sizeof(iv));	585	memcpy(iv, epayload->iv, sizeof(iv));
606	skcipher_request_set_crypt(req, sg_in, sg_out, encrypted_datalen, iv);	586	skcipher_request_set_crypt(req, sg_in, sg_out, encrypted_datalen, iv);
@@ -612,6 +592,7 @@ static int derived_key_decrypt(struct encrypted_key_payload *epayload, · 5 unmodified lines
612	goto out;	592	goto out;
613	dump_decrypted_data(epayload);	593	dump_decrypted_data(epayload);
614	out:	594	out:
		595	kfree(pad);
615	return ret;	596	return ret;
616	}	597	}
617		598
@@ -722,6 +703,7 @@ static int encrypted_key_decrypt(struct encrypted_key_payload *epayload, · 104 unmodified lines
722	out:	703	out:
723	up_read(&mkey->sem);	704	up_read(&mkey->sem);
724	key_put(mkey);	705	key_put(mkey);
		706	memzero_explicit(derived_key, sizeof(derived_key));
725	return ret;	707	return ret;
726	}	708	}
727		709
@@ -828,13 +810,13 @@ static int encrypted_instantiate(struct key *key, · 100 unmodified lines
828	ret = encrypted_init(epayload, key->description, format, master_desc,	810	ret = encrypted_init(epayload, key->description, format, master_desc,
829	decrypted_datalen, hex_encoded_iv);	811	decrypted_datalen, hex_encoded_iv);
830	if (ret < 0) {	812	if (ret < 0) {
831	kfree(epayload);	813	kzfree(epayload);
832	goto out;	814	goto out;
833	}	815	}
834		816
835	rcu_assign_keypointer(key, epayload);	817	rcu_assign_keypointer(key, epayload);
836	out:	818	out:
837	kfree(datablob);	819	kzfree(datablob);
838	return ret;	820	return ret;
839	}	821	}
840		822
@@ -843,8 +825,7 @@ static void encrypted_rcu_free(struct rcu_head *rcu) · 2 unmodified lines
843	struct encrypted_key_payload *epayload;	825	struct encrypted_key_payload *epayload;
844		826
845	epayload = container_of(rcu, struct encrypted_key_payload, rcu);	827	epayload = container_of(rcu, struct encrypted_key_payload, rcu);
846	memset(epayload->decrypted_data, 0, epayload->decrypted_datalen);	828	kzfree(epayload);
847	kfree(epayload);
848	}	829	}
849		830
850	/*	831	/*
@@ -902,7 +883,7 @@ static int encrypted_update(struct key key, struct key_preparsed_payload prep) · 51 unmodified lines
902	rcu_assign_keypointer(key, new_epayload);	883	rcu_assign_keypointer(key, new_epayload);
903	call_rcu(&epayload->rcu, encrypted_rcu_free);	884	call_rcu(&epayload->rcu, encrypted_rcu_free);
904	out:	885	out:
905	kfree(buf);	886	kzfree(buf);
906	return ret;	887	return ret;
907	}	888	}
908		889
@@ -960,33 +941,26 @@ static long encrypted_read(const struct key key, char __user buffer, · 51 unmodified lines
960		941
961	up_read(&mkey->sem);	942	up_read(&mkey->sem);
962	key_put(mkey);	943	key_put(mkey);
		944	memzero_explicit(derived_key, sizeof(derived_key));
963		945
964	if (copy_to_user(buffer, ascii_buf, asciiblob_len) != 0)	946	if (copy_to_user(buffer, ascii_buf, asciiblob_len) != 0)
965	ret = -EFAULT;	947	ret = -EFAULT;
966	kfree(ascii_buf);	948	kzfree(ascii_buf);
967		949
968	return asciiblob_len;	950	return asciiblob_len;
969	out:	951	out:
970	up_read(&mkey->sem);	952	up_read(&mkey->sem);
971	key_put(mkey);	953	key_put(mkey);
		954	memzero_explicit(derived_key, sizeof(derived_key));
972	return ret;	955	return ret;
973	}	956	}
974		957
975	/*	958	/*
976	* encrypted_destroy - before freeing the key, clear the decrypted data	959	* encrypted_destroy - clear and free the key's payload
977	*
978	* Before freeing the key, clear the memory containing the decrypted
979	* key data.
980	*/	960	*/
981	static void encrypted_destroy(struct key *key)	961	static void encrypted_destroy(struct key *key)
982	{	962	{
983	struct encrypted_key_payload *epayload = key->payload.data[0];	963	kzfree(key->payload.data[0]);
984
985	if (!epayload)
986	return;
987
988	memzero_explicit(epayload->decrypted_data, epayload->decrypted_datalen);
989	kfree(key->payload.data[0]);
990	}	964	}
991		965
992	struct key_type key_type_encrypted = {	966	struct key_type key_type_encrypted = {
@@ -999,47 +973,17 @@ struct key_type key_type_encrypted = { · 6 unmodified lines
999	};	973	};
1000	EXPORT_SYMBOL_GPL(key_type_encrypted);	974	EXPORT_SYMBOL_GPL(key_type_encrypted);
1001		975
1002	static void encrypted_shash_release(void)	976	static int __init init_encrypted(void)
1003	{
1004	if (hashalg)
1005	crypto_free_shash(hashalg);
1006	if (hmacalg)
1007	crypto_free_shash(hmacalg);
1008	}
1009
1010	static int __init encrypted_shash_alloc(void)
1011	{	977	{
1012	int ret;	978	int ret;
1013		979
1014	hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);	980	hash_tfm = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
1015	if (IS_ERR(hmacalg)) {	981	if (IS_ERR(hash_tfm)) {
1016	pr_info("encrypted_key: could not allocate crypto %s\n",	982	pr_err("encrypted_key: can't allocate %s transform: %ld\n",
1017	hmac_alg);	983	hash_alg, PTR_ERR(hash_tfm));
1018	return PTR_ERR(hmacalg);	984	return PTR_ERR(hash_tfm);
1019	}
1020
1021	hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
1022	if (IS_ERR(hashalg)) {
1023	pr_info("encrypted_key: could not allocate crypto %s\n",
1024	hash_alg);
1025	ret = PTR_ERR(hashalg);
1026	goto hashalg_fail;
1027	}	985	}
1028		986
1029	return 0;
1030
1031	hashalg_fail:
1032	crypto_free_shash(hmacalg);
1033	return ret;
1034	}
1035
1036	static int __init init_encrypted(void)
1037	{
1038	int ret;
1039
1040	ret = encrypted_shash_alloc();
1041	if (ret < 0)
1042	return ret;
1043	ret = aes_get_sizes();	987	ret = aes_get_sizes();
1044	if (ret < 0)	988	if (ret < 0)
1045	goto out;	989	goto out;
@@ -1048,14 +992,14 @@ static int __init init_encrypted(void) · 2 unmodified lines
1048	goto out;	992	goto out;
1049	return 0;	993	return 0;
1050	out:	994	out:
1051	encrypted_shash_release();	995	crypto_free_shash(hash_tfm);
1052	return ret;	996	return ret;
1053		997
1054	}	998	}
1055		999
1056	static void __exit cleanup_encrypted(void)	1000	static void __exit cleanup_encrypted(void)
1057	{	1001	{
1058	encrypted_shash_release();	1002	crypto_free_shash(hash_tfm);
1059	unregister_key_type(&key_type_encrypted);	1003	unregister_key_type(&key_type_encrypted);
1060	}	1004	}
1061		1005

security/keys/gc.c+1−3

@@ -158,9 +158,7 @@ static noinline void key_gc_unused_keys(struct list_head *keys) · 157 unmodified lines
158		158
159	kfree(key->description);	159	kfree(key->description);
160		160
161	#ifdef KEY_DEBUGGING	161	memzero_explicit(key, sizeof(*key));
162	key->magic = KEY_DEBUG_MAGIC_X;
163	#endif
164	kmem_cache_free(key_jar, key);	162	kmem_cache_free(key_jar, key);
165	}	163	}
166	}	164	}

security/keys/key.c+6−10

 	goto error;
 found:
-	/* pretend it doesn't exist if it is awaiting deletion */
+	/* A key is allowed to be looked up only if someone still owns a
-	if (refcount_read(&key->usage) == 0)
+	 * reference to it - otherwise it's awaiting the gc.
-		goto not_found;
-	/* this races with key_put(), but that doesn't matter since key_put()
-	 * doesn't actually change the key
 	 */
-	__key_get(key);
+	if (!refcount_inc_not_zero(&key->usage))
+		goto not_found;
 error:
 	spin_unlock(&key_serial_lock);
 	/* the key must be writable */
 	ret = key_permission(key_ref, KEY_NEED_WRITE);
 	if (ret < 0)
-		goto error;
+		return ret;
 	/* attempt to update it if supported */
-	ret = -EOPNOTSUPP;
 	if (!key->type->update)
-		goto error;
+		return -EOPNOTSUPP;
 	memset(&prep, 0, sizeof(prep));
 	prep.data = payload;

security/keys/keyctl.c+11−5

 	/* pull the payload in if one was supplied */
 	payload = NULL;
-	if (_payload) {
+	if (plen) {
 		ret = -ENOMEM;
 		payload = kvmalloc(plen, GFP_KERNEL);
 		if (!payload)
 	key_ref_put(keyring_ref);
  error3:
-	kvfree(payload);
+	if (payload) {
+		memzero_explicit(payload, plen);
+		kvfree(payload);
+	}
  error2:
 	kfree(description);
  error:
 	/* pull the payload in if one was supplied */
 	payload = NULL;
-	if (_payload) {
+	if (plen) {
 		ret = -ENOMEM;
 		payload = kmalloc(plen, GFP_KERNEL);
 		if (!payload)
 	key_ref_put(key_ref);
 error2:
-	kfree(payload);
+	kzfree(payload);
 error:
 	return ret;
 }
 		keyctl_change_reqkey_auth(NULL);
 error2:
-	kvfree(payload);
+	if (payload) {
+		memzero_explicit(payload, plen);
+		kvfree(payload);
+	}
 error:
 	return ret;
 }

security/keys/keyring.c+6−6

@@ -706,7 +706,7 @@ descend_to_keyring: · 705 unmodified lines
706	* Non-keyrings avoid the leftmost branch of the root entirely (root	706	* Non-keyrings avoid the leftmost branch of the root entirely (root
707	* slots 1-15).	707	* slots 1-15).
708	*/	708	*/
709	ptr = ACCESS_ONCE(keyring->keys.root);	709	ptr = READ_ONCE(keyring->keys.root);
710	if (!ptr)	710	if (!ptr)
711	goto not_this_keyring;	711	goto not_this_keyring;
712		712
@@ -720,7 +720,7 @@ descend_to_keyring: · 7 unmodified lines
720	if ((shortcut->index_key[0] & ASSOC_ARRAY_FAN_MASK) != 0)	720	if ((shortcut->index_key[0] & ASSOC_ARRAY_FAN_MASK) != 0)
721	goto not_this_keyring;	721	goto not_this_keyring;
722		722
723	ptr = ACCESS_ONCE(shortcut->next_node);	723	ptr = READ_ONCE(shortcut->next_node);
724	node = assoc_array_ptr_to_node(ptr);	724	node = assoc_array_ptr_to_node(ptr);
725	goto begin_node;	725	goto begin_node;
726	}	726	}
@@ -740,7 +740,7 @@ descend_to_node: · 13 unmodified lines
740	if (assoc_array_ptr_is_shortcut(ptr)) {	740	if (assoc_array_ptr_is_shortcut(ptr)) {
741	shortcut = assoc_array_ptr_to_shortcut(ptr);	741	shortcut = assoc_array_ptr_to_shortcut(ptr);
742	smp_read_barrier_depends();	742	smp_read_barrier_depends();
743	ptr = ACCESS_ONCE(shortcut->next_node);	743	ptr = READ_ONCE(shortcut->next_node);
744	BUG_ON(!assoc_array_ptr_is_node(ptr));	744	BUG_ON(!assoc_array_ptr_is_node(ptr));
745	}	745	}
746	node = assoc_array_ptr_to_node(ptr);	746	node = assoc_array_ptr_to_node(ptr);
@@ -752,7 +752,7 @@ begin_node: · 5 unmodified lines
752	ascend_to_node:	752	ascend_to_node:
753	/* Go through the slots in a node */	753	/* Go through the slots in a node */
754	for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) {	754	for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) {
755	ptr = ACCESS_ONCE(node->slots[slot]);	755	ptr = READ_ONCE(node->slots[slot]);
756		756
757	if (assoc_array_ptr_is_meta(ptr) && node->back_pointer)	757	if (assoc_array_ptr_is_meta(ptr) && node->back_pointer)
758	goto descend_to_node;	758	goto descend_to_node;
@@ -790,13 +790,13 @@ ascend_to_node: · 31 unmodified lines
790	/* We've dealt with all the slots in the current node, so now we need	790	/* We've dealt with all the slots in the current node, so now we need
791	* to ascend to the parent and continue processing there.	791	* to ascend to the parent and continue processing there.
792	*/	792	*/
793	ptr = ACCESS_ONCE(node->back_pointer);	793	ptr = READ_ONCE(node->back_pointer);
794	slot = node->parent_slot;	794	slot = node->parent_slot;
795		795
796	if (ptr && assoc_array_ptr_is_shortcut(ptr)) {	796	if (ptr && assoc_array_ptr_is_shortcut(ptr)) {
797	shortcut = assoc_array_ptr_to_shortcut(ptr);	797	shortcut = assoc_array_ptr_to_shortcut(ptr);
798	smp_read_barrier_depends();	798	smp_read_barrier_depends();
799	ptr = ACCESS_ONCE(shortcut->back_pointer);	799	ptr = READ_ONCE(shortcut->back_pointer);
800	slot = shortcut->parent_slot;	800	slot = shortcut->parent_slot;
801	}	801	}
802	if (!ptr)	802	if (!ptr)

security/keys/process_keys.c+4−3

 		ret = PTR_ERR(keyring);
 		goto error2;
 	} else if (keyring == new->session_keyring) {
-		key_put(keyring);
 		ret = 0;
-		goto error2;
+		goto error3;
 	}
 	/* we've got a keyring - now to install it */
 	ret = install_session_keyring_to_cred(new, keyring);
 	if (ret < 0)
-		goto error2;
+		goto error3;
 	commit_creds(new);
 	mutex_unlock(&key_session_mutex);
 okay:
 	return ret;
+error3:
+	key_put(keyring);
 error2:
 	mutex_unlock(&key_session_mutex);
 error:

security/keys/trusted.c+22−28

 	}
 	ret = crypto_shash_digest(&sdesc->shash, data, datalen, digest);
-	kfree(sdesc);
+	kzfree(sdesc);
 	return ret;
 }
 	if (!ret)
 		ret = crypto_shash_final(&sdesc->shash, digest);
 out:
-	kfree(sdesc);
+	kzfree(sdesc);
 	return ret;
 }
 				  paramdigest, TPM_NONCE_SIZE, h1,
 				  TPM_NONCE_SIZE, h2, 1, &c, 0, 0);
 out:
-	kfree(sdesc);
+	kzfree(sdesc);
 	return ret;
 }
 	if (memcmp(testhmac, authdata, SHA1_DIGEST_SIZE))
 		ret = -EINVAL;
 out:
-	kfree(sdesc);
+	kzfree(sdesc);
 	return ret;
 }
 	if (memcmp(testhmac2, authdata2, SHA1_DIGEST_SIZE))
 		ret = -EINVAL;
 out:
-	kfree(sdesc);
+	kzfree(sdesc);
 	return ret;
 }
 		*bloblen = storedsize;
 	}
 out:
-	kfree(td);
+	kzfree(td);
 	return ret;
 }
 	if (ret < 0)
 		pr_info("trusted_key: srkseal failed (%d)\n", ret);
-	kfree(tb);
+	kzfree(tb);
 	return ret;
 }
 		/* pull migratable flag out of sealed key */
 		p->migratable = p->key[--p->key_len];
-	kfree(tb);
+	kzfree(tb);
 	return ret;
 }
 	if (!ret && options->pcrlock)
 		ret = pcrlock(options->pcrlock);
 out:
-	kfree(datablob);
+	kzfree(datablob);
-	kfree(options);
+	kzfree(options);
 	if (!ret)
 		rcu_assign_keypointer(key, payload);
 	else
-		kfree(payload);
+		kzfree(payload);
 	return ret;
 }
 	struct trusted_key_payload *p;
 	p = container_of(rcu, struct trusted_key_payload, rcu);
-	memset(p->key, 0, p->key_len);
+	kzfree(p);
-	kfree(p);
 }
 /*
 	ret = datablob_parse(datablob, new_p, new_o);
 	if (ret != Opt_update) {
 		ret = -EINVAL;
-		kfree(new_p);
+		kzfree(new_p);
 		goto out;
 	}
 	if (!new_o->keyhandle) {
 		ret = -EINVAL;
-		kfree(new_p);
+		kzfree(new_p);
 		goto out;
 	}
 	ret = key_seal(new_p, new_o);
 	if (ret < 0) {
 		pr_info("trusted_key: key_seal failed (%d)\n", ret);
-		kfree(new_p);
+		kzfree(new_p);
 		goto out;
 	}
 	if (new_o->pcrlock) {
 		ret = pcrlock(new_o->pcrlock);
 		if (ret < 0) {
 			pr_info("trusted_key: pcrlock failed (%d)\n", ret);
-			kfree(new_p);
+			kzfree(new_p);
 			goto out;
 		}
 	}
 	rcu_assign_keypointer(key, new_p);
 	call_rcu(&p->rcu, trusted_rcu_free);
 out:
-	kfree(datablob);
+	kzfree(datablob);
-	kfree(new_o);
+	kzfree(new_o);
 	return ret;
 }
 	for (i = 0; i < p->blob_len; i++)
 		bufp = hex_byte_pack(bufp, p->blob[i]);
 	if ((copy_to_user(buffer, ascii_buf, 2 * p->blob_len)) != 0) {
-		kfree(ascii_buf);
+		kzfree(ascii_buf);
 		return -EFAULT;
 	}
-	kfree(ascii_buf);
+	kzfree(ascii_buf);
 	return 2 * p->blob_len;
 }
 /*
- * trusted_destroy - before freeing the key, clear the decrypted data
+ * trusted_destroy - clear and free the key's payload
  */
 static void trusted_destroy(struct key *key)
 {
-	struct trusted_key_payload *p = key->payload.data[0];
+	kzfree(key->payload.data[0]);
-	if (!p)
-		return;
-	memset(p->key, 0, p->key_len);
-	kfree(key->payload.data[0]);
 }
 struct key_type key_type_trusted = {

security/keys/user_defined.c+12−4

  */
 void user_free_preparse(struct key_preparsed_payload *prep)
 {
-	kfree(prep->payload.data[0]);
+	kzfree(prep->payload.data[0]);
 }
 EXPORT_SYMBOL_GPL(user_free_preparse);
+static void user_free_payload_rcu(struct rcu_head *head)
+{
+	struct user_key_payload *payload;
+	payload = container_of(head, struct user_key_payload, rcu);
+	kzfree(payload);
+}
 /*
  * update a user defined key
  * - the key's semaphore is write-locked
 	prep->payload.data[0] = NULL;
 	if (zap)
-		kfree_rcu(zap, rcu);
+		call_rcu(&zap->rcu, user_free_payload_rcu);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(user_update);
 	if (upayload) {
 		rcu_assign_keypointer(key, NULL);
-		kfree_rcu(upayload, rcu);
+		call_rcu(&upayload->rcu, user_free_payload_rcu);
 	}
 }
 {
 	struct user_key_payload *upayload = key->payload.data[0];
-	kfree(upayload);
+	kzfree(upayload);
 }
 EXPORT_SYMBOL_GPL(user_destroy);

sound/core/timer.c+5−2

 	if (err < 0)
 		goto __err;
+	tu->qhead = tu->qtail = tu->qused = 0;
 	kfree(tu->queue);
 	tu->queue = NULL;
 	kfree(tu->tqueue);
 	tu = file->private_data;
 	unit = tu->tread ? sizeof(struct snd_timer_tread) : sizeof(struct snd_timer_read);
+	mutex_lock(&tu->ioctl_lock);
 	spin_lock_irq(&tu->qlock);
 	while ((long)count - result >= unit) {
 		while (!tu->qused) {
 			add_wait_queue(&tu->qchange_sleep, &wait);
 			spin_unlock_irq(&tu->qlock);
+			mutex_unlock(&tu->ioctl_lock);
 			schedule();
+			mutex_lock(&tu->ioctl_lock);
 			spin_lock_irq(&tu->qlock);
 			remove_wait_queue(&tu->qchange_sleep, &wait);
 		tu->qused--;
 		spin_unlock_irq(&tu->qlock);
-		mutex_lock(&tu->ioctl_lock);
 		if (tu->tread) {
 			if (copy_to_user(buffer, &tu->tqueue[qhead],
 					 sizeof(struct snd_timer_tread)))
 					 sizeof(struct snd_timer_read)))
 				err = -EFAULT;
 		}
-		mutex_unlock(&tu->ioctl_lock);
 		spin_lock_irq(&tu->qlock);
 		if (err < 0)
 	}
  _error:
 	spin_unlock_irq(&tu->qlock);
+	mutex_unlock(&tu->ioctl_lock);
 	return result > 0 ? result : err;
 }

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

 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
+	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
+	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
+	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
+	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
+	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
-	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
-	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
+	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
-	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
-	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
-	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),

sound/soc/atmel/atmel-classd.c+9−0

 	return 0;
 }
+static int atmel_classd_codec_resume(struct snd_soc_codec *codec)
+{
+	struct snd_soc_card *card = snd_soc_codec_get_drvdata(codec);
+	struct atmel_classd *dd = snd_soc_card_get_drvdata(card);
+	return regcache_sync(dd->regmap);
+}
 static struct regmap *atmel_classd_codec_get_remap(struct device *dev)
 {
 	return dev_get_regmap(dev, NULL);
 static struct snd_soc_codec_driver soc_codec_dev_classd = {
 	.probe		= atmel_classd_codec_probe,
+	.resume		= atmel_classd_codec_resume,
 	.get_regmap	= atmel_classd_codec_get_remap,
 	.component_driver = {
 		.controls		= atmel_classd_snd_controls,

sound/soc/codecs/da7213.c+1−1

@@ -772,7 +772,7 @@ static int da7213_dai_event(struct snd_soc_dapm_widget *w, · 771 unmodified lines
772	++i;	772	++i;
773	msleep(50);	773	msleep(50);
774	}	774	}
775	} while ((i < DA7213_SRM_CHECK_RETRIES) & (!srm_lock));	775	} while ((i < DA7213_SRM_CHECK_RETRIES) && (!srm_lock));
776		776
777	if (!srm_lock)	777	if (!srm_lock)
778	dev_warn(codec->dev, "SRM failed to lock\n");	778	dev_warn(codec->dev, "SRM failed to lock\n");

sound/soc/codecs/rt286.c+7−0

@@ -1108,6 +1108,13 @@ static const struct dmi_system_id force_combo_jack_table[] = { · 1107 unmodified lines
1108	DMI_MATCH(DMI_PRODUCT_NAME, "Kabylake Client platform")	1108	DMI_MATCH(DMI_PRODUCT_NAME, "Kabylake Client platform")
1109	}	1109	}
1110	},	1110	},
		1111	{
		1112	.ident = "Thinkpad Helix 2nd",
		1113	.matches = {
		1114	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		1115	DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad Helix 2nd")
		1116	}
		1117	},
1111		1118
1112	{ }	1119	{ }
1113	};	1120	};

sound/soc/generic/simple-card.c+1−1

@@ -202,7 +202,7 @@ static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd) · 201 unmodified lines
202	if (ret < 0)	202	if (ret < 0)
203	return ret;	203	return ret;
204		204
205	ret = asoc_simple_card_init_mic(rtd->card, &priv->hp_jack, PREFIX);	205	ret = asoc_simple_card_init_mic(rtd->card, &priv->mic_jack, PREFIX);
206	if (ret < 0)	206	if (ret < 0)
207	return ret;	207	return ret;
208		208

sound/soc/intel/skylake/skl-sst-ipc.c+5−0

 	u32 reply = header.primary & IPC_GLB_REPLY_STATUS_MASK;
 	u64 *ipc_header = (u64 *)(&header);
 	struct skl_sst *skl = container_of(ipc, struct skl_sst, ipc);
+	unsigned long flags;
+	spin_lock_irqsave(&ipc->dsp->spinlock, flags);
 	msg = skl_ipc_reply_get_msg(ipc, *ipc_header);
+	spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
 	if (msg == NULL) {
 		dev_dbg(ipc->dev, "ipc: rx list is empty\n");
 		return;
 		}
 	}
+	spin_lock_irqsave(&ipc->dsp->spinlock, flags);
 	list_del(&msg->list);
 	sst_ipc_tx_msg_reply_complete(ipc, msg);
+	spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
 }
 irqreturn_t skl_dsp_irq_thread_handler(int irq, void *context)

sound/soc/intel/skylake/skl-topology.c+1−1

@@ -2502,7 +2502,7 @@ static int skl_tplg_get_manifest_tkn(struct device *dev, · 2501 unmodified lines
2502		2502
2503	if (ret < 0)	2503	if (ret < 0)
2504	return ret;	2504	return ret;
2505	tkn_count += ret;	2505	tkn_count = ret;
2506		2506
2507	tuple_size += tkn_count *	2507	tuple_size += tkn_count *
2508	sizeof(struct snd_soc_tplg_vendor_string_elem);	2508	sizeof(struct snd_soc_tplg_vendor_string_elem);

sound/soc/intel/skylake/skl.c+88−74

 	struct skl *skl  = ebus_to_skl(ebus);
 	struct hdac_bus *bus = ebus_to_hbus(ebus);
-	skl->init_failed = 1; /* to be sure */
+	skl->init_done = 0; /* to be sure */
 	snd_hdac_ext_stop_streams(ebus);
 	snd_hdac_ext_bus_exit(ebus);
+	cancel_work_sync(&skl->probe_work);
 	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI))
 		snd_hdac_i915_exit(&ebus->bus);
 	return 0;
 }
 	.get_response = snd_hdac_bus_get_response,
 };
+static int skl_i915_init(struct hdac_bus *bus)
+{
+	int err;
+	/*
+	 * The HDMI codec is in GPU so we need to ensure that it is powered
+	 * up and ready for probe
+	 */
+	err = snd_hdac_i915_init(bus);
+	if (err < 0)
+		return err;
+	err = snd_hdac_display_power(bus, true);
+	if (err < 0)
+		dev_err(bus->dev, "Cannot turn on display power on i915\n");
+	return err;
+}
+static void skl_probe_work(struct work_struct *work)
+{
+	struct skl *skl = container_of(work, struct skl, probe_work);
+	struct hdac_ext_bus *ebus = &skl->ebus;
+	struct hdac_bus *bus = ebus_to_hbus(ebus);
+	struct hdac_ext_link *hlink = NULL;
+	int err;
+	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI)) {
+		err = skl_i915_init(bus);
+		if (err < 0)
+			return;
+	}
+	err = skl_init_chip(bus, true);
+	if (err < 0) {
+		dev_err(bus->dev, "Init chip failed with err: %d\n", err);
+		goto out_err;
+	}
+	/* codec detection */
+	if (!bus->codec_mask)
+		dev_info(bus->dev, "no hda codecs found!\n");
+	/* create codec instances */
+	err = skl_codec_create(ebus);
+	if (err < 0)
+		goto out_err;
+	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI)) {
+		err = snd_hdac_display_power(bus, false);
+		if (err < 0) {
+			dev_err(bus->dev, "Cannot turn off display power on i915\n");
+			return;
+		}
+	}
+	/* register platform dai and controls */
+	err = skl_platform_register(bus->dev);
+	if (err < 0)
+		return;
+	/*
+	 * we are done probing so decrement link counts
+	 */
+	list_for_each_entry(hlink, &ebus->hlink_list, list)
+		snd_hdac_ext_bus_link_put(ebus, hlink);
+	/* configure PM */
+	pm_runtime_put_noidle(bus->dev);
+	pm_runtime_allow(bus->dev);
+	skl->init_done = 1;
+	return;
+out_err:
+	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI))
+		err = snd_hdac_display_power(bus, false);
+}
 /*
  * constructor
  */
 	snd_hdac_ext_bus_init(ebus, &pci->dev, &bus_core_ops, io_ops);
 	ebus->bus.use_posbuf = 1;
 	skl->pci = pci;
+	INIT_WORK(&skl->probe_work, skl_probe_work);
 	ebus->bus.bdl_pos_adj = 0;
 	return 0;
 }
-static int skl_i915_init(struct hdac_bus *bus)
-{
-	int err;
-	/*
-	 * The HDMI codec is in GPU so we need to ensure that it is powered
-	 * up and ready for probe
-	 */
-	err = snd_hdac_i915_init(bus);
-	if (err < 0)
-		return err;
-	err = snd_hdac_display_power(bus, true);
-	if (err < 0) {
-		dev_err(bus->dev, "Cannot turn on display power on i915\n");
-		return err;
-	}
-	return err;
-}
 static int skl_first_init(struct hdac_ext_bus *ebus)
 {
 	struct skl *skl = ebus_to_skl(ebus);
 	/* initialize chip */
 	skl_init_pci(skl);
-	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI)) {
+	return skl_init_chip(bus, true);
-		err = skl_i915_init(bus);
-		if (err < 0)
-			return err;
-	}
-	skl_init_chip(bus, true);
-	/* codec detection */
-	if (!bus->codec_mask) {
-		dev_info(bus->dev, "no hda codecs found!\n");
-	}
-	return 0;
 }
 static int skl_probe(struct pci_dev *pci,
 	struct skl *skl;
 	struct hdac_ext_bus *ebus = NULL;
 	struct hdac_bus *bus = NULL;
-	struct hdac_ext_link *hlink = NULL;
 	int err;
 	/* we use ext core ops, so provide NULL for ops here */
 	if (skl->nhlt == NULL) {
 		err = -ENODEV;
-		goto out_display_power_off;
+		goto out_free;
 	}
 	err = skl_nhlt_create_sysfs(skl);
 	if (bus->mlcap)
 		snd_hdac_ext_bus_get_ml_capabilities(ebus);
+	snd_hdac_bus_stop_chip(bus);
 	/* create device for soc dmic */
 	err = skl_dmic_device_register(skl);
 	if (err < 0)
 		goto out_dsp_free;
-	/* register platform dai and controls */
+	schedule_work(&skl->probe_work);
-	err = skl_platform_register(bus->dev);
-	if (err < 0)
-		goto out_dmic_free;
-	/* create codec instances */
-	err = skl_codec_create(ebus);
-	if (err < 0)
-		goto out_unregister;
-	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI)) {
-		err = snd_hdac_display_power(bus, false);
-		if (err < 0) {
-			dev_err(bus->dev, "Cannot turn off display power on i915\n");
-			return err;
-		}
-	}
-	/*
-	 * we are done probling so decrement link counts
-	 */
-	list_for_each_entry(hlink, &ebus->hlink_list, list)
-		snd_hdac_ext_bus_link_put(ebus, hlink);
-	/* configure PM */
-	pm_runtime_put_noidle(bus->dev);
-	pm_runtime_allow(bus->dev);
 	return 0;
-out_unregister:
-	skl_platform_unregister(bus->dev);
-out_dmic_free:
-	skl_dmic_device_unregister(skl);
 out_dsp_free:
 	skl_free_dsp(skl);
 out_mach_free:
 	skl_machine_device_unregister(skl);
 out_nhlt_free:
 	skl_nhlt_free(skl->nhlt);
-out_display_power_off:
-	if (IS_ENABLED(CONFIG_SND_SOC_HDAC_HDMI))
-		snd_hdac_display_power(bus, false);
 out_free:
-	skl->init_failed = 1;
 	skl_free(ebus);
 	return err;
 	skl = ebus_to_skl(ebus);
-	if (skl->init_failed)
+	if (!skl->init_done)
 		return;
 	snd_hdac_ext_stop_streams(ebus);

sound/soc/intel/skylake/skl.h+3−1

 	struct hdac_ext_bus ebus;
 	struct pci_dev *pci;
-	unsigned int init_failed:1; /* delayed init failed */
+	unsigned int init_done:1; /* delayed init status */
 	struct platform_device *dmic_dev;
 	struct platform_device *i2s_dev;
 	struct snd_soc_platform *platform;
 	const struct firmware *tplg;
 	int supend_active;
+	struct work_struct probe_work;
 };
 #define skl_to_ebus(s)	(&(s)->ebus)

sound/soc/sh/rcar/adg.c+4−2

 				rbga = rbgx;
 				adg->rbga_rate_for_441khz = rate / div;
 				ckr |= brg_table[i] << 20;
-				if (req_441kHz_rate)
+				if (req_441kHz_rate &&
+				    !(adg_mode_flags(adg) & AUDIO_OUT_48))
 					parent_clk_name = __clk_get_name(clk);
 			}
 		}
 				rbgb = rbgx;
 				adg->rbgb_rate_for_48khz = rate / div;
 				ckr |= brg_table[i] << 16;
-				if (req_48kHz_rate)
+				if (req_48kHz_rate &&
+				    (adg_mode_flags(adg) & AUDIO_OUT_48))
 					parent_clk_name = __clk_get_name(clk);
 			}
 		}

sound/soc/sh/rcar/cmd.c+1−0

@@ -89,6 +89,7 @@ static int rsnd_cmd_init(struct rsnd_mod *mod, · 88 unmodified lines
89	dev_dbg(dev, "ctu/mix path = 0x%08x", data);	89	dev_dbg(dev, "ctu/mix path = 0x%08x", data);
90		90
91	rsnd_mod_write(mod, CMD_ROUTE_SLCT, data);	91	rsnd_mod_write(mod, CMD_ROUTE_SLCT, data);
		92	rsnd_mod_write(mod, CMD_BUSIF_MODE, rsnd_get_busif_shift(io, mod) \| 1);
92	rsnd_mod_write(mod, CMD_BUSIF_DALIGN, rsnd_get_dalign(mod, io));	93	rsnd_mod_write(mod, CMD_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
93		94
94	rsnd_adg_set_cmd_timsel_gen2(mod, io);	95	rsnd_adg_set_cmd_timsel_gen2(mod, io);

sound/soc/sh/rcar/core.c+51−0

@@ -343,6 +343,57 @@ u32 rsnd_get_dalign(struct rsnd_mod mod, struct rsnd_dai_stream io) · 342 unmodified lines
343	return 0x76543210;	343	return 0x76543210;
344	}	344	}
345		345
		346	u32 rsnd_get_busif_shift(struct rsnd_dai_stream io, struct rsnd_mod mod)
		347	{
		348	enum rsnd_mod_type playback_mods[] = {
		349	RSND_MOD_SRC,
		350	RSND_MOD_CMD,
		351	RSND_MOD_SSIU,
		352	};
		353	enum rsnd_mod_type capture_mods[] = {
		354	RSND_MOD_CMD,
		355	RSND_MOD_SRC,
		356	RSND_MOD_SSIU,
		357	};
		358	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
		359	struct rsnd_mod *tmod = NULL;
		360	enum rsnd_mod_type *mods =
		361	rsnd_io_is_play(io) ?
		362	playback_mods : capture_mods;
		363	int i;
		364
		365	/*
		366	* This is needed for 24bit data
		367	* We need to shift 8bit
		368	*
		369	* Linux 24bit data is located as 0x00******
		370	* HW 24bit data is located as 0x******00
		371	*
		372	*/
		373	switch (runtime->sample_bits) {
		374	case 16:
		375	return 0;
		376	case 32:
		377	break;
		378	}
		379
		380	for (i = 0; i < ARRAY_SIZE(playback_mods); i++) {
		381	tmod = rsnd_io_to_mod(io, mods[i]);
		382	if (tmod)
		383	break;
		384	}
		385
		386	if (tmod != mod)
		387	return 0;
		388
		389	if (rsnd_io_is_play(io))
		390	return (0 << 20) \| /* shift to Left */
		391	(8 << 16); /* 8bit */
		392	else
		393	return (1 << 20) \| /* shift to Right */
		394	(8 << 16); /* 8bit */
		395	}
		396
346	/*	397	/*
347	* rsnd_dai functions	398	* rsnd_dai functions
348	*/	399	*/

sound/soc/sh/rcar/gen.c+1−0

@@ -236,6 +236,7 @@ static int rsnd_gen2_probe(struct rsnd_priv *priv) · 235 unmodified lines
236	RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc, 0x20),	236	RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc, 0x20),
237	RSND_GEN_M_REG(SRC_CTRL, 0x10, 0x20),	237	RSND_GEN_M_REG(SRC_CTRL, 0x10, 0x20),
238	RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18, 0x20),	238	RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18, 0x20),
		239	RSND_GEN_M_REG(CMD_BUSIF_MODE, 0x184, 0x20),
239	RSND_GEN_M_REG(CMD_BUSIF_DALIGN,0x188, 0x20),	240	RSND_GEN_M_REG(CMD_BUSIF_DALIGN,0x188, 0x20),
240	RSND_GEN_M_REG(CMD_ROUTE_SLCT, 0x18c, 0x20),	241	RSND_GEN_M_REG(CMD_ROUTE_SLCT, 0x18c, 0x20),
241	RSND_GEN_M_REG(CMD_CTRL, 0x190, 0x20),	242	RSND_GEN_M_REG(CMD_CTRL, 0x190, 0x20),

sound/soc/sh/rcar/rsnd.h+2−0

 	RSND_REG_SCU_SYS_INT_EN0,
 	RSND_REG_SCU_SYS_INT_EN1,
 	RSND_REG_CMD_CTRL,
+	RSND_REG_CMD_BUSIF_MODE,
 	RSND_REG_CMD_BUSIF_DALIGN,
 	RSND_REG_CMD_ROUTE_SLCT,
 	RSND_REG_CMDOUT_TIMSEL,
 		    u32 mask, u32 data);
 u32 rsnd_get_adinr_bit(struct rsnd_mod *mod, struct rsnd_dai_stream *io);
 u32 rsnd_get_dalign(struct rsnd_mod *mod, struct rsnd_dai_stream *io);
+u32 rsnd_get_busif_shift(struct rsnd_dai_stream *io, struct rsnd_mod *mod);
 /*
  *	R-Car DMA

sound/soc/sh/rcar/src.c+10−2

 	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 	struct device *dev = rsnd_priv_to_dev(priv);
 	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+	int is_play = rsnd_io_is_play(io);
 	int use_src = 0;
 	u32 fin, fout;
 	u32 ifscr, fsrate, adinr;
 	u32 cr, route;
 	u32 bsdsr, bsisr;
+	u32 i_busif, o_busif, tmp;
 	uint ratio;
 	if (!runtime)
 		break;
 	}
+	/* BUSIF_MODE */
+	tmp = rsnd_get_busif_shift(io, mod);
+	i_busif = ( is_play ? tmp : 0) | 1;
+	o_busif = (!is_play ? tmp : 0) | 1;
 	rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
 	rsnd_mod_write(mod, SRC_SRCIR, 1);	/* initialize */
 	rsnd_mod_write(mod, SRC_BSISR, bsisr);
 	rsnd_mod_write(mod, SRC_SRCIR, 0);	/* cancel initialize */
-	rsnd_mod_write(mod, SRC_I_BUSIF_MODE, 1);
+	rsnd_mod_write(mod, SRC_I_BUSIF_MODE, i_busif);
-	rsnd_mod_write(mod, SRC_O_BUSIF_MODE, 1);
+	rsnd_mod_write(mod, SRC_O_BUSIF_MODE, o_busif);
 	rsnd_mod_write(mod, SRC_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
 	rsnd_adg_set_src_timesel_gen2(mod, io, fin, fout);

sound/soc/sh/rcar/ssi.c+15−3

 	 * always use 32bit system word.
 	 * see also rsnd_ssi_master_clk_enable()
 	 */
-	cr_own = FORCE | SWL_32 | PDTA;
+	cr_own = FORCE | SWL_32;
 	if (rdai->bit_clk_inv)
 		cr_own |= SCKP;
 		struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 		u32 *buf = (u32 *)(runtime->dma_area +
 				   rsnd_dai_pointer_offset(io, 0));
+		int shift = 0;
+		switch (runtime->sample_bits) {
+		case 32:
+			shift = 8;
+			break;
+		}
 		/*
 		 * 8/16/32 data can be assesse to TDR/RDR register
 		 * see rsnd_ssi_init()
 		 */
 		if (rsnd_io_is_play(io))
-			rsnd_mod_write(mod, SSITDR, *buf);
+			rsnd_mod_write(mod, SSITDR, (*buf) << shift);
 		else
-			*buf = rsnd_mod_read(mod, SSIRDR);
+			*buf = (rsnd_mod_read(mod, SSIRDR) >> shift);
 		elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));
 	}
 			       struct rsnd_priv *priv)
 {
 	struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
+	struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
+	/* Do nothing for SSI parent mod */
+	if (ssi_parent_mod == mod)
+		return 0;
 	/* PIO will request IRQ again */
 	free_irq(ssi->irq, mod);

sound/soc/sh/rcar/ssiu.c+2−1

 			       (rsnd_io_is_play(io) ?
 				rsnd_runtime_channel_after_ctu(io) :
 				rsnd_runtime_channel_original(io)));
-		rsnd_mod_write(mod, SSI_BUSIF_MODE,  1);
+		rsnd_mod_write(mod, SSI_BUSIF_MODE,
+			       rsnd_get_busif_shift(io, mod) | 1);
 		rsnd_mod_write(mod, SSI_BUSIF_DALIGN,
 			       rsnd_get_dalign(mod, io));
 	}

sound/soc/soc-core.c+3−2

 	list_for_each_entry(rtd, &card->rtd_list, list)
 		flush_delayed_work(&rtd->delayed_work);
+	/* free the ALSA card at first; this syncs with pending operations */
+	snd_card_free(card->snd_card);
 	/* remove and free each DAI */
 	soc_remove_dai_links(card);
 	soc_remove_pcm_runtimes(card);
 	if (card->remove)
 		card->remove(card);
-	snd_card_free(card->snd_card);
 	return 0;
 }
 /* removes a socdev */

tools/perf/Documentation/perf-probe.txt+6−2

  or
  ./perf probe --add='schedule:12 cpu'
- this will add one or more probes which has the name start with "schedule".
+Add one or more probes which has the name start with "schedule".
- Add probes on lines in schedule() function which calls update_rq_clock().
+ ./perf probe schedule*
+ or
+ ./perf probe --add='schedule*'
+Add probes on lines in schedule() function which calls update_rq_clock().
  ./perf probe 'schedule;update_rq_clock*'
  or

tools/perf/Documentation/perf-script-perl.txt+1−1

@@ -39,7 +39,7 @@ EVENT HANDLERS · 38 unmodified lines
39	When perf script is invoked using a trace script, a user-defined	39	When perf script is invoked using a trace script, a user-defined
40	'handler function' is called for each event in the trace. If there's	40	'handler function' is called for each event in the trace. If there's
41	no handler function defined for a given event type, the event is	41	no handler function defined for a given event type, the event is
42	ignored (or passed to a 'trace_handled' function, see below) and the	42	ignored (or passed to a 'trace_unhandled' function, see below) and the
43	next event is processed.	43	next event is processed.
44		44
45	Most of the event's field values are passed as arguments to the	45	Most of the event's field values are passed as arguments to the

tools/perf/Documentation/perf-script-python.txt+9−14

 		print "id=%d, args=%s\n" % \
 		(id, args),
-def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+def trace_unhandled(event_name, context, event_fields_dict):
-		common_pid, common_comm):
+		print ' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())])
-		print_header(event_name, common_cpu, common_secs, common_nsecs,
-		common_pid, common_comm)
 def print_header(event_name, cpu, secs, nsecs, pid, comm):
 	print "%-20s %5u %05u.%09u %8u %-20s " % \
 process can be generalized to any tracepoint or set of tracepoints
 you're interested in - basically find the tracepoint(s) you're
 interested in by looking at the list of available events shown by
-'perf list' and/or look in /sys/kernel/debug/tracing events for
+'perf list' and/or look in /sys/kernel/debug/tracing/events/ for
 detailed event and field info, record the corresponding trace data
 using 'perf record', passing it the list of interesting events,
 generate a skeleton script using 'perf script -g python' and modify the
 scripts listed by the 'perf script -l' command e.g.:
 ----
-root@tropicana:~# perf script -l
+# perf script -l
 List of available trace scripts:
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
 ----
 # ls -al kernel-source/tools/perf/scripts/python
-root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
 total 32
 drwxr-xr-x 4 trz trz 4096 2010-01-26 22:30 .
 drwxr-xr-x 4 trz trz 4096 2010-01-26 22:29 ..
 should show a new entry for your script:
 ----
-root@tropicana:~# perf script -l
+# perf script -l
 List of available trace scripts:
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
 When perf script is invoked using a trace script, a user-defined
 'handler function' is called for each event in the trace.  If there's
 no handler function defined for a given event type, the event is
-ignored (or passed to a 'trace_handled' function, see below) and the
+ignored (or passed to a 'trace_unhandled' function, see below) and the
 next event is processed.
 Most of the event's field values are passed as arguments to the
 gives scripts a chance to do setup tasks:
 ----
-def trace_begin:
+def trace_begin():
     pass
 ----
  as display results:
 ----
-def trace_end:
+def trace_end():
     pass
 ----
  of common arguments are passed into it:
 ----
-def trace_unhandled(event_name, context, common_cpu, common_secs,
+def trace_unhandled(event_name, context, event_fields_dict):
-        common_nsecs, common_pid, common_comm):
     pass
 ----

tools/perf/arch/common.c+1−0

@@ -26,6 +26,7 @@ const char *const arm64_triplets[] = { · 25 unmodified lines
26		26
27	const char *const powerpc_triplets[] = {	27	const char *const powerpc_triplets[] = {
28	"powerpc-unknown-linux-gnu-",	28	"powerpc-unknown-linux-gnu-",
		29	"powerpc-linux-gnu-",
29	"powerpc64-unknown-linux-gnu-",	30	"powerpc64-unknown-linux-gnu-",
30	"powerpc64-linux-gnu-",	31	"powerpc64-linux-gnu-",
31	"powerpc64le-linux-gnu-",	32	"powerpc64le-linux-gnu-",

tools/perf/builtin-stat.c+4−1

 static void print_footer(void)
 {
 	FILE *output = stat_config.output;
+	int n;
 	if (!null_run)
 		fprintf(output, "\n");
 	}
 	fprintf(output, "\n\n");
-	if (print_free_counters_hint)
+	if (print_free_counters_hint &&
+	    sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
+	    n > 0)
 		fprintf(output,
 "Some events weren't counted. Try disabling the NMI watchdog:\n"
 "	echo 0 > /proc/sys/kernel/nmi_watchdog\n"

tools/perf/builtin-trace.c+4−0

 	{ .name	    = "mlockall",   .errmsg = true,
 	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
 	{ .name	    = "mmap",	    .hexret = true,
+/* The standard mmap maps to old_mmap on s390x */
+#if defined(__s390x__)
+	.alias = "old_mmap",
+#endif
 	  .arg_scnprintf = { [0] = SCA_HEX,	  /* addr */
 			     [2] = SCA_MMAP_PROT, /* prot */
 			     [3] = SCA_MMAP_FLAGS, /* flags */ }, },

tools/perf/tests/bp_signal.c+14−0

@@ -288,3 +288,17 @@ int test__bp_signal(int subtest __maybe_unused) · 287 unmodified lines
288	return count1 == 1 && overflows == 3 && count2 == 3 && overflows_2 == 3 && count3 == 2 ?	288	return count1 == 1 && overflows == 3 && count2 == 3 && overflows_2 == 3 && count3 == 2 ?
289	TEST_OK : TEST_FAIL;	289	TEST_OK : TEST_FAIL;
290	}	290	}
		291
		292	bool test__bp_signal_is_supported(void)
		293	{
		294	/*
		295	* The powerpc so far does not have support to even create
		296	* instruction breakpoint using the perf event interface.
		297	* Once it's there we can release this.
		298	*/
		299	#ifdef __powerpc__
		300	return false;
		301	#else
		302	return true;
		303	#endif
		304	}

tools/perf/tests/builtin-test.c+7−0

 	{
 		.desc = "Breakpoint overflow signal handler",
 		.func = test__bp_signal,
+		.is_supported = test__bp_signal_is_supported,
 	},
 	{
 		.desc = "Breakpoint overflow sampling",
 		.func = test__bp_signal_overflow,
+		.is_supported = test__bp_signal_is_supported,
 	},
 	{
 		.desc = "Number of exit events of a simple workload",
 		if (!perf_test__matches(t, curr, argc, argv))
 			continue;
+		if (t->is_supported && !t->is_supported()) {
+			pr_debug("%2d: %-*s: Disabled\n", i, width, t->desc);
+			continue;
+		}
 		pr_info("%2d: %-*s:", i, width, t->desc);
 		if (intlist__find(skiplist, i)) {

tools/perf/tests/code-reading.c+19−1

@@ -229,6 +229,8 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode, · 228 unmodified lines
229	unsigned char buf2[BUFSZ];	229	unsigned char buf2[BUFSZ];
230	size_t ret_len;	230	size_t ret_len;
231	u64 objdump_addr;	231	u64 objdump_addr;
		232	const char *objdump_name;
		233	char decomp_name[KMOD_DECOMP_LEN];
232	int ret;	234	int ret;
233		235
234	pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);	236	pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
@@ -289,9 +291,25 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode, · 54 unmodified lines
289	state->done[state->done_cnt++] = al.map->start;	291	state->done[state->done_cnt++] = al.map->start;
290	}	292	}
291		293
		294	objdump_name = al.map->dso->long_name;
		295	if (dso__needs_decompress(al.map->dso)) {
		296	if (dso__decompress_kmodule_path(al.map->dso, objdump_name,
		297	decomp_name,
		298	sizeof(decomp_name)) < 0) {
		299	pr_debug("decompression failed\n");
		300	return -1;
		301	}
		302
		303	objdump_name = decomp_name;
		304	}
		305
292	/* Read the object code using objdump */	306	/* Read the object code using objdump */
293	objdump_addr = map__rip_2objdump(al.map, al.addr);	307	objdump_addr = map__rip_2objdump(al.map, al.addr);
294	ret = read_via_objdump(al.map->dso->long_name, objdump_addr, buf2, len);	308	ret = read_via_objdump(objdump_name, objdump_addr, buf2, len);
		309
		310	if (dso__needs_decompress(al.map->dso))
		311	unlink(objdump_name);
		312
295	if (ret > 0) {	313	if (ret > 0) {
296	/*	314	/*
297	* The kernel maps are inaccurate - assume objdump is right in	315	* The kernel maps are inaccurate - assume objdump is right in

tools/perf/tests/tests.h+3−0

 		int (*get_nr)(void);
 		const char *(*get_desc)(int subtest);
 	} subtest;
+	bool (*is_supported)(void);
 };
 /* Tests */
 int test__clang_subtest_get_nr(void);
 int test__unit_number__scnprint(int subtest);
+bool test__bp_signal_is_supported(void);
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
 struct thread;

tools/perf/util/annotate.c+43−29

 	const char *s = strchr(ops->raw, '+');
 	const char *c = strchr(ops->raw, ',');
-	if (c++ != NULL)
+	/*
+	 * skip over possible up to 2 operands to get to address, e.g.:
+	 * tbnz	 w0, #26, ffff0000083cd190 <security_file_permission+0xd0>
+	 */
+	if (c++ != NULL) {
 		ops->target.addr = strtoull(c, NULL, 16);
-	else
+		if (!ops->target.addr) {
+			c = strchr(c, ',');
+			if (c++ != NULL)
+				ops->target.addr = strtoull(c, NULL, 16);
+		}
+	} else {
 		ops->target.addr = strtoull(ops->raw, NULL, 16);
+	}
 	if (s++ != NULL) {
 		ops->target.offset = strtoull(s, NULL, 16);
 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
+	const char *c = strchr(ops->raw, ',');
 	if (!ops->target.addr || ops->target.offset < 0)
 		return ins__raw_scnprintf(ins, bf, size, ops);
-	return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset);
+	if (c != NULL) {
+		const char *c2 = strchr(c + 1, ',');
+		/* check for 3-op insn */
+		if (c2 != NULL)
+			c = c2;
+		c++;
+		/* mirror arch objdump's space-after-comma style */
+		if (*c == ' ')
+			c++;
+	}
+	return scnprintf(bf, size, "%-6.6s %.*s%" PRIx64,
+			 ins->name, c ? c - ops->raw : 0, ops->raw,
+			 ops->target.offset);
 }
 static struct ins_ops jump_ops = {
 	char linkname[PATH_MAX];
 	char *build_id_filename;
 	char *build_id_path = NULL;
+	char *pos;
 	if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
 	    !dso__is_kcore(dso))
 	if (!build_id_path)
 		return -1;
-	dirname(build_id_path);
+	/*
+	 * old style build-id cache has name of XX/XXXXXXX.. while
+	 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}.
+	 * extract the build-id part of dirname in the new style only.
+	 */
+	pos = strrchr(build_id_path, '/');
+	if (pos && strlen(pos) < SBUILD_ID_SIZE - 2)
+		dirname(build_id_path);
 	if (dso__is_kcore(dso) ||
 	    readlink(build_id_path, linkname, sizeof(linkname)) < 0 ||
 				sizeof(symfs_filename));
 		}
 	} else if (dso__needs_decompress(dso)) {
-		char tmp[PATH_MAX];
+		char tmp[KMOD_DECOMP_LEN];
-		struct kmod_path m;
-		int fd;
-		bool ret;
-		if (kmod_path__parse_ext(&m, symfs_filename))
-			goto out;
-		snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
-		fd = mkstemp(tmp);
-		if (fd < 0) {
-			free(m.ext);
-			goto out;
-		}
-		ret = decompress_to_file(m.ext, symfs_filename, fd);
-		if (ret)
-			pr_err("Cannot decompress %s %s\n", m.ext, symfs_filename);
-		free(m.ext);
-		close(fd);
-		if (!ret)
+		if (dso__decompress_kmodule_path(dso, symfs_filename,
+						 tmp, sizeof(tmp)) < 0)
 			goto out;
 		strcpy(symfs_filename, tmp);
 	snprintf(command, sizeof(command),
 		 "%s %s%s --start-address=0x%016" PRIx64
 		 " --stop-address=0x%016" PRIx64
-		 " -l -d %s %s -C %s 2>/dev/null|grep -v %s:|expand",
+		 " -l -d %s %s -C \"%s\" 2>/dev/null|grep -v \"%s:\"|expand",
 		 objdump_path ? objdump_path : "objdump",
 		 disassembler_style ? "-M " : "",
 		 disassembler_style ? disassembler_style : "",

tools/perf/util/build-id.c+0−45

@@ -278,51 +278,6 @@ char dso__build_id_filename(const struct dso dso, char *bf, size_t size) · 277 unmodified lines
278	return bf;	278	return bf;
279	}	279	}
280		280
281	bool dso__build_id_is_kmod(const struct dso dso, char bf, size_t size)
282	{
283	char id_name = NULL, ch;
284	struct stat sb;
285	char sbuild_id[SBUILD_ID_SIZE];
286
287	if (!dso->has_build_id)
288	goto err;
289
290	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
291	id_name = build_id_cache__linkname(sbuild_id, NULL, 0);
292	if (!id_name)
293	goto err;
294	if (access(id_name, F_OK))
295	goto err;
296	if (lstat(id_name, &sb) == -1)
297	goto err;
298	if ((size_t)sb.st_size > size - 1)
299	goto err;
300	if (readlink(id_name, bf, size - 1) < 0)
301	goto err;
302
303	bf[sb.st_size] = '\0';
304
305	/*
306	* link should be:
307	* ../../lib/modules/4.4.0-rc4/kernel/net/ipv4/netfilter/nf_nat_ipv4.ko/a09fe3eb3147dafa4e3b31dbd6257e4d696bdc92
308	*/
309	ch = strrchr(bf, '/');
310	if (!ch)
311	goto err;
312	if (ch - 3 < bf)
313	goto err;
314
315	free(id_name);
316	return strncmp(".ko", ch - 3, 3) == 0;
317	err:
318	pr_err("Invalid build id: %s\n", id_name ? :
319	dso->long_name ? :
320	dso->short_name ? :
321	"[unknown]");
322	free(id_name);
323	return false;
324	}
325
326	#define dsos__for_each_with_build_id(pos, head) \	281	#define dsos__for_each_with_build_id(pos, head) \
327	list_for_each_entry(pos, head, node) \	282	list_for_each_entry(pos, head, node) \
328	if (!pos->has_build_id) \	283	if (!pos->has_build_id) \

tools/perf/util/build-id.h+0−1

@@ -17,7 +17,6 @@ char build_id_cache__kallsyms_path(const char sbuild_id, char *bf, · 16 unmodified lines
17	size_t size);	17	size_t size);
18		18
19	char dso__build_id_filename(const struct dso dso, char *bf, size_t size);	19	char dso__build_id_filename(const struct dso dso, char *bf, size_t size);
20	bool dso__build_id_is_kmod(const struct dso dso, char bf, size_t size);
21		20
22	int build_id__mark_dso_hit(struct perf_tool tool, union perf_event event,	21	int build_id__mark_dso_hit(struct perf_tool tool, union perf_event event,
23	struct perf_sample sample, struct perf_evsel evsel,	22	struct perf_sample sample, struct perf_evsel evsel,

tools/perf/util/dso.c+94−6

@@ -248,6 +248,64 @@ bool dso__needs_decompress(struct dso *dso) · 247 unmodified lines
248	dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;	248	dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
249	}	249	}
250		250
		251	static int decompress_kmodule(struct dso dso, const char name, char *tmpbuf)
		252	{
		253	int fd = -1;
		254	struct kmod_path m;
		255
		256	if (!dso__needs_decompress(dso))
		257	return -1;
		258
		259	if (kmod_path__parse_ext(&m, dso->long_name))
		260	return -1;
		261
		262	if (!m.comp)
		263	goto out;
		264
		265	fd = mkstemp(tmpbuf);
		266	if (fd < 0) {
		267	dso->load_errno = errno;
		268	goto out;
		269	}
		270
		271	if (!decompress_to_file(m.ext, name, fd)) {
		272	dso->load_errno = DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE;
		273	close(fd);
		274	fd = -1;
		275	}
		276
		277	out:
		278	free(m.ext);
		279	return fd;
		280	}
		281
		282	int dso__decompress_kmodule_fd(struct dso dso, const char name)
		283	{
		284	char tmpbuf[] = KMOD_DECOMP_NAME;
		285	int fd;
		286
		287	fd = decompress_kmodule(dso, name, tmpbuf);
		288	unlink(tmpbuf);
		289	return fd;
		290	}
		291
		292	int dso__decompress_kmodule_path(struct dso dso, const char name,
		293	char *pathname, size_t len)
		294	{
		295	char tmpbuf[] = KMOD_DECOMP_NAME;
		296	int fd;
		297
		298	fd = decompress_kmodule(dso, name, tmpbuf);
		299	if (fd < 0) {
		300	unlink(tmpbuf);
		301	return -1;
		302	}
		303
		304	strncpy(pathname, tmpbuf, len);
		305	close(fd);
		306	return 0;
		307	}
		308
251	/*	309	/*
252	* Parses kernel module specified in @path and updates	310	* Parses kernel module specified in @path and updates
253	* @m argument like:	311	* @m argument like:
@@ -335,6 +393,21 @@ int __kmod_path__parse(struct kmod_path m, const char path, · 81 unmodified lines
335	return 0;	393	return 0;
336	}	394	}
337		395
		396	void dso__set_module_info(struct dso dso, struct kmod_path m,
		397	struct machine *machine)
		398	{
		399	if (machine__is_host(machine))
		400	dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
		401	else
		402	dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
		403
		404	/* _KMODULE_COMP should be next to _KMODULE */
		405	if (m->kmod && m->comp)
		406	dso->symtab_type++;
		407
		408	dso__set_short_name(dso, strdup(m->name), true);
		409	}
		410
338	/*	411	/*
339	* Global list of open DSOs and the counter.	412	* Global list of open DSOs and the counter.
340	*/	413	*/
@@ -381,7 +454,7 @@ static int do_open(char *name) · 40 unmodified lines
381		454
382	static int __open_dso(struct dso dso, struct machine machine)	455	static int __open_dso(struct dso dso, struct machine machine)
383	{	456	{
384	int fd;	457	int fd = -EINVAL;
385	char root_dir = (char )"";	458	char root_dir = (char )"";
386	char *name = malloc(PATH_MAX);	459	char *name = malloc(PATH_MAX);
387		460
@@ -392,15 +465,30 @@ static int __open_dso(struct dso dso, struct machine machine) · 4 unmodified lines
392	root_dir = machine->root_dir;	465	root_dir = machine->root_dir;
393		466
394	if (dso__read_binary_type_filename(dso, dso->binary_type,	467	if (dso__read_binary_type_filename(dso, dso->binary_type,
395	root_dir, name, PATH_MAX)) {	468	root_dir, name, PATH_MAX))
396	free(name);	469	goto out;
397	return -EINVAL;
398	}
399		470
400	if (!is_regular_file(name))	471	if (!is_regular_file(name))
401	return -EINVAL;	472	goto out;
		473
		474	if (dso__needs_decompress(dso)) {
		475	char newpath[KMOD_DECOMP_LEN];
		476	size_t len = sizeof(newpath);
		477
		478	if (dso__decompress_kmodule_path(dso, name, newpath, len) < 0) {
		479	fd = -dso->load_errno;
		480	goto out;
		481	}
		482
		483	strcpy(name, newpath);
		484	}
402		485
403	fd = do_open(name);	486	fd = do_open(name);
		487
		488	if (dso__needs_decompress(dso))
		489	unlink(name);
		490
		491	out:
404	free(name);	492	free(name);
405	return fd;	493	return fd;
406	}	494	}

tools/perf/util/dso.h+9−0

 bool is_kernel_module(const char *pathname, int cpumode);
 bool decompress_to_file(const char *ext, const char *filename, int output_fd);
 bool dso__needs_decompress(struct dso *dso);
+int dso__decompress_kmodule_fd(struct dso *dso, const char *name);
+int dso__decompress_kmodule_path(struct dso *dso, const char *name,
+				 char *pathname, size_t len);
+#define KMOD_DECOMP_NAME  "/tmp/perf-kmod-XXXXXX"
+#define KMOD_DECOMP_LEN   sizeof(KMOD_DECOMP_NAME)
 struct kmod_path {
 	char *name;
 #define kmod_path__parse_name(__m, __p) __kmod_path__parse(__m, __p, true , false)
 #define kmod_path__parse_ext(__m, __p)  __kmod_path__parse(__m, __p, false, true)
+void dso__set_module_info(struct dso *dso, struct kmod_path *m,
+			  struct machine *machine);
 /*
  * The dso__data_* external interface provides following functions:
  *   dso__data_get_fd

tools/perf/util/header.c+10−2

 		dso__set_build_id(dso, &bev->build_id);
-		if (!is_kernel_module(filename, cpumode))
+		if (dso_type != DSO_TYPE_USER) {
-			dso->kernel = dso_type;
+			struct kmod_path m = { .name = NULL, };
+			if (!kmod_path__parse_name(&m, filename) && m.kmod)
+				dso__set_module_info(dso, &m, machine);
+			else
+				dso->kernel = dso_type;
+			free(m.name);
+		}
 		build_id__sprintf(dso->build_id, sizeof(dso->build_id),
 				  sbuild_id);

tools/perf/util/machine.c+1−10

@@ -572,16 +572,7 @@ static struct dso machine__findnew_module_dso(struct machine machine, · 571 unmodified lines
572	if (dso == NULL)	572	if (dso == NULL)
573	goto out_unlock;	573	goto out_unlock;
574		574
575	if (machine__is_host(machine))	575	dso__set_module_info(dso, m, machine);
576	dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
577	else
578	dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
579
580	/* _KMODULE_COMP should be next to _KMODULE */
581	if (m->kmod && m->comp)
582	dso->symtab_type++;
583
584	dso__set_short_name(dso, strdup(m->name), true);
585	dso__set_long_name(dso, strdup(filename), true);	576	dso__set_long_name(dso, strdup(filename), true);
586	}	577	}
587		578

tools/perf/util/scripting-engines/trace-event-python.c+1−1

@@ -1219,7 +1219,7 @@ static int python_generate_script(struct pevent pevent, const char outfile) · 1218 unmodified lines
1219	fprintf(ofp, "# be retrieved using Python functions of the form "	1219	fprintf(ofp, "# be retrieved using Python functions of the form "
1220	"common_*(context).\n");	1220	"common_*(context).\n");
1221		1221
1222	fprintf(ofp, "# See the perf-trace-python Documentation for the list "	1222	fprintf(ofp, "# See the perf-script-python Documentation for the list "
1223	"of available functions.\n\n");	1223	"of available functions.\n\n");
1224		1224
1225	fprintf(ofp, "import os\n");	1225	fprintf(ofp, "import os\n");

tools/perf/util/symbol-elf.c+3−38

@@ -637,43 +637,6 @@ static int dso__swap_init(struct dso *dso, unsigned char eidata) · 636 unmodified lines
637	return 0;	637	return 0;
638	}	638	}
639		639
640	static int decompress_kmodule(struct dso dso, const char name,
641	enum dso_binary_type type)
642	{
643	int fd = -1;
644	char tmpbuf[] = "/tmp/perf-kmod-XXXXXX";
645	struct kmod_path m;
646
647	if (type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
648	type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP &&
649	type != DSO_BINARY_TYPE__BUILD_ID_CACHE)
650	return -1;
651
652	if (type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
653	name = dso->long_name;
654
655	if (kmod_path__parse_ext(&m, name) \|\| !m.comp)
656	return -1;
657
658	fd = mkstemp(tmpbuf);
659	if (fd < 0) {
660	dso->load_errno = errno;
661	goto out;
662	}
663
664	if (!decompress_to_file(m.ext, name, fd)) {
665	dso->load_errno = DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE;
666	close(fd);
667	fd = -1;
668	}
669
670	unlink(tmpbuf);
671
672	out:
673	free(m.ext);
674	return fd;
675	}
676
677	bool symsrc__possibly_runtime(struct symsrc *ss)	640	bool symsrc__possibly_runtime(struct symsrc *ss)
678	{	641	{
679	return ss->dynsym \|\| ss->opdsec;	642	return ss->dynsym \|\| ss->opdsec;
@@ -705,9 +668,11 @@ int symsrc__init(struct symsrc ss, struct dso dso, const char *name, · 25 unmodified lines
705	int fd;	668	int fd;
706		669
707	if (dso__needs_decompress(dso)) {	670	if (dso__needs_decompress(dso)) {
708	fd = decompress_kmodule(dso, name, type);	671	fd = dso__decompress_kmodule_fd(dso, name);
709	if (fd < 0)	672	if (fd < 0)
710	return -1;	673	return -1;
		674
		675	type = dso->symtab_type;
711	} else {	676	} else {
712	fd = open(name, O_RDONLY);	677	fd = open(name, O_RDONLY);
713	if (fd < 0) {	678	if (fd < 0) {

tools/perf/util/symbol.c+0−4

 	if (!runtime_ss && syms_ss)
 		runtime_ss = syms_ss;
-	if (syms_ss && syms_ss->type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
-		if (dso__build_id_is_kmod(dso, name, PATH_MAX))
-			kmod = true;
 	if (syms_ss)
 		ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
 	else

tools/perf/util/unwind-libdw.c+9−1

 		return 0;
 	mod = dwfl_addrmodule(ui->dwfl, ip);
+	if (mod) {
+		Dwarf_Addr s;
+		dwfl_module_info(mod, NULL, &s, NULL, NULL, NULL, NULL, NULL);
+		if (s != al->map->start)
+			mod = 0;
+	}
 	if (!mod)
 		mod = dwfl_report_elf(ui->dwfl, dso->short_name,
 				      dso->long_name, -1, al->map->start,
 	err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui);
-	if (err && !ui->max_stack)
+	if (err && ui->max_stack != max_stack)
 		err = 0;
 	/*

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

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

virt/kvm/arm/hyp/vgic-v3-sr.c+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22	#include <asm/kvm_hyp.h>	22	#include <asm/kvm_hyp.h>
23		23
24	#define vtr_to_max_lr_idx(v) ((v) & 0xf)	24	#define vtr_to_max_lr_idx(v) ((v) & 0xf)
25	#define vtr_to_nr_pre_bits(v) (((u32)(v) >> 26) + 1)	25	#define vtr_to_nr_pre_bits(v) ((((u32)(v) >> 26) & 7) + 1)
26		26
27	static u64 __hyp_text __gic_v3_get_lr(unsigned int lr)	27	static u64 __hyp_text __gic_v3_get_lr(unsigned int lr)
28	{	28	{

virt/kvm/arm/mmu.c+3−0

@@ -879,6 +879,9 @@ static pmd_t stage2_get_pmd(struct kvm kvm, struct kvm_mmu_memory_cache *cache · 878 unmodified lines
879	pmd_t *pmd;	879	pmd_t *pmd;
880		880
881	pud = stage2_get_pud(kvm, cache, addr);	881	pud = stage2_get_pud(kvm, cache, addr);
		882	if (!pud)
		883	return NULL;
		884
882	if (stage2_pud_none(*pud)) {	885	if (stage2_pud_none(*pud)) {
883	if (!cache)	886	if (!cache)
884	return NULL;	887	return NULL;

virt/kvm/arm/vgic/vgic-mmio-v2.c+14−2

 	switch (addr & 0xff) {
 	case GIC_CPU_CTRL:
-		val = vmcr.ctlr;
+		val = vmcr.grpen0 << GIC_CPU_CTRL_EnableGrp0_SHIFT;
+		val |= vmcr.grpen1 << GIC_CPU_CTRL_EnableGrp1_SHIFT;
+		val |= vmcr.ackctl << GIC_CPU_CTRL_AckCtl_SHIFT;
+		val |= vmcr.fiqen << GIC_CPU_CTRL_FIQEn_SHIFT;
+		val |= vmcr.cbpr << GIC_CPU_CTRL_CBPR_SHIFT;
+		val |= vmcr.eoim << GIC_CPU_CTRL_EOImodeNS_SHIFT;
 		break;
 	case GIC_CPU_PRIMASK:
 		/*
 	switch (addr & 0xff) {
 	case GIC_CPU_CTRL:
-		vmcr.ctlr = val;
+		vmcr.grpen0 = !!(val & GIC_CPU_CTRL_EnableGrp0);
+		vmcr.grpen1 = !!(val & GIC_CPU_CTRL_EnableGrp1);
+		vmcr.ackctl = !!(val & GIC_CPU_CTRL_AckCtl);
+		vmcr.fiqen = !!(val & GIC_CPU_CTRL_FIQEn);
+		vmcr.cbpr = !!(val & GIC_CPU_CTRL_CBPR);
+		vmcr.eoim = !!(val & GIC_CPU_CTRL_EOImodeNS);
 		break;
 	case GIC_CPU_PRIMASK:
 		/*

virt/kvm/arm/vgic/vgic-v2.c+25−3

@@ -177,7 +177,18 @@ void vgic_v2_set_vmcr(struct kvm_vcpu vcpu, struct vgic_vmcr vmcrp) · 176 unmodified lines
177	struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;	177	struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;
178	u32 vmcr;	178	u32 vmcr;
179		179
180	vmcr = (vmcrp->ctlr << GICH_VMCR_CTRL_SHIFT) & GICH_VMCR_CTRL_MASK;	180	vmcr = (vmcrp->grpen0 << GICH_VMCR_ENABLE_GRP0_SHIFT) &
		181	GICH_VMCR_ENABLE_GRP0_MASK;
		182	vmcr \|= (vmcrp->grpen1 << GICH_VMCR_ENABLE_GRP1_SHIFT) &
		183	GICH_VMCR_ENABLE_GRP1_MASK;
		184	vmcr \|= (vmcrp->ackctl << GICH_VMCR_ACK_CTL_SHIFT) &
		185	GICH_VMCR_ACK_CTL_MASK;
		186	vmcr \|= (vmcrp->fiqen << GICH_VMCR_FIQ_EN_SHIFT) &
		187	GICH_VMCR_FIQ_EN_MASK;
		188	vmcr \|= (vmcrp->cbpr << GICH_VMCR_CBPR_SHIFT) &
		189	GICH_VMCR_CBPR_MASK;
		190	vmcr \|= (vmcrp->eoim << GICH_VMCR_EOI_MODE_SHIFT) &
		191	GICH_VMCR_EOI_MODE_MASK;
181	vmcr \|= (vmcrp->abpr << GICH_VMCR_ALIAS_BINPOINT_SHIFT) &	192	vmcr \|= (vmcrp->abpr << GICH_VMCR_ALIAS_BINPOINT_SHIFT) &
182	GICH_VMCR_ALIAS_BINPOINT_MASK;	193	GICH_VMCR_ALIAS_BINPOINT_MASK;
183	vmcr \|= (vmcrp->bpr << GICH_VMCR_BINPOINT_SHIFT) &	194	vmcr \|= (vmcrp->bpr << GICH_VMCR_BINPOINT_SHIFT) &
@@ -195,8 +206,19 @@ void vgic_v2_get_vmcr(struct kvm_vcpu vcpu, struct vgic_vmcr vmcrp) · 11 unmodified lines
195		206
196	vmcr = cpu_if->vgic_vmcr;	207	vmcr = cpu_if->vgic_vmcr;
197		208
198	vmcrp->ctlr = (vmcr & GICH_VMCR_CTRL_MASK) >>	209	vmcrp->grpen0 = (vmcr & GICH_VMCR_ENABLE_GRP0_MASK) >>
199	GICH_VMCR_CTRL_SHIFT;	210	GICH_VMCR_ENABLE_GRP0_SHIFT;
		211	vmcrp->grpen1 = (vmcr & GICH_VMCR_ENABLE_GRP1_MASK) >>
		212	GICH_VMCR_ENABLE_GRP1_SHIFT;
		213	vmcrp->ackctl = (vmcr & GICH_VMCR_ACK_CTL_MASK) >>
		214	GICH_VMCR_ACK_CTL_SHIFT;
		215	vmcrp->fiqen = (vmcr & GICH_VMCR_FIQ_EN_MASK) >>
		216	GICH_VMCR_FIQ_EN_SHIFT;
		217	vmcrp->cbpr = (vmcr & GICH_VMCR_CBPR_MASK) >>
		218	GICH_VMCR_CBPR_SHIFT;
		219	vmcrp->eoim = (vmcr & GICH_VMCR_EOI_MODE_MASK) >>
		220	GICH_VMCR_EOI_MODE_SHIFT;
		221
200	vmcrp->abpr = (vmcr & GICH_VMCR_ALIAS_BINPOINT_MASK) >>	222	vmcrp->abpr = (vmcr & GICH_VMCR_ALIAS_BINPOINT_MASK) >>
201	GICH_VMCR_ALIAS_BINPOINT_SHIFT;	223	GICH_VMCR_ALIAS_BINPOINT_SHIFT;
202	vmcrp->bpr = (vmcr & GICH_VMCR_BINPOINT_MASK) >>	224	vmcrp->bpr = (vmcr & GICH_VMCR_BINPOINT_MASK) >>

virt/kvm/arm/vgic/vgic-v3.c+33−14

 void vgic_v3_set_vmcr(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcrp)
 {
 	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;
+	u32 model = vcpu->kvm->arch.vgic.vgic_model;
 	u32 vmcr;
-	/*
+	if (model == KVM_DEV_TYPE_ARM_VGIC_V2) {
-	 * Ignore the FIQen bit, because GIC emulation always implies
+		vmcr = (vmcrp->ackctl << ICH_VMCR_ACK_CTL_SHIFT) &
-	 * SRE=1 which means the vFIQEn bit is also RES1.
+			ICH_VMCR_ACK_CTL_MASK;
-	 */
+		vmcr |= (vmcrp->fiqen << ICH_VMCR_FIQ_EN_SHIFT) &
-	vmcr = ((vmcrp->ctlr >> ICC_CTLR_EL1_EOImode_SHIFT) <<
+			ICH_VMCR_FIQ_EN_MASK;
-		 ICH_VMCR_EOIM_SHIFT) & ICH_VMCR_EOIM_MASK;
+	} else {
-	vmcr |= (vmcrp->ctlr << ICH_VMCR_CBPR_SHIFT) & ICH_VMCR_CBPR_MASK;
+		/*
+		 * When emulating GICv3 on GICv3 with SRE=1 on the
+		 * VFIQEn bit is RES1 and the VAckCtl bit is RES0.
+		 */
+		vmcr = ICH_VMCR_FIQ_EN_MASK;
+	}
+	vmcr |= (vmcrp->cbpr << ICH_VMCR_CBPR_SHIFT) & ICH_VMCR_CBPR_MASK;
+	vmcr |= (vmcrp->eoim << ICH_VMCR_EOIM_SHIFT) & ICH_VMCR_EOIM_MASK;
 	vmcr |= (vmcrp->abpr << ICH_VMCR_BPR1_SHIFT) & ICH_VMCR_BPR1_MASK;
 	vmcr |= (vmcrp->bpr << ICH_VMCR_BPR0_SHIFT) & ICH_VMCR_BPR0_MASK;
 	vmcr |= (vmcrp->pmr << ICH_VMCR_PMR_SHIFT) & ICH_VMCR_PMR_MASK;
 void vgic_v3_get_vmcr(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcrp)
 {
 	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;
+	u32 model = vcpu->kvm->arch.vgic.vgic_model;
 	u32 vmcr;
 	vmcr = cpu_if->vgic_vmcr;
-	/*
+	if (model == KVM_DEV_TYPE_ARM_VGIC_V2) {
-	 * Ignore the FIQen bit, because GIC emulation always implies
+		vmcrp->ackctl = (vmcr & ICH_VMCR_ACK_CTL_MASK) >>
-	 * SRE=1 which means the vFIQEn bit is also RES1.
+			ICH_VMCR_ACK_CTL_SHIFT;
-	 */
+		vmcrp->fiqen = (vmcr & ICH_VMCR_FIQ_EN_MASK) >>
-	vmcrp->ctlr = ((vmcr >> ICH_VMCR_EOIM_SHIFT) <<
+			ICH_VMCR_FIQ_EN_SHIFT;
-			ICC_CTLR_EL1_EOImode_SHIFT) & ICC_CTLR_EL1_EOImode_MASK;
+	} else {
-	vmcrp->ctlr |= (vmcr & ICH_VMCR_CBPR_MASK) >> ICH_VMCR_CBPR_SHIFT;
+		/*
+		 * When emulating GICv3 on GICv3 with SRE=1 on the
+		 * VFIQEn bit is RES1 and the VAckCtl bit is RES0.
+		 */
+		vmcrp->fiqen = 1;
+		vmcrp->ackctl = 0;
+	}
+	vmcrp->cbpr = (vmcr & ICH_VMCR_CBPR_MASK) >> ICH_VMCR_CBPR_SHIFT;
+	vmcrp->eoim = (vmcr & ICH_VMCR_EOIM_MASK) >> ICH_VMCR_EOIM_SHIFT;
 	vmcrp->abpr = (vmcr & ICH_VMCR_BPR1_MASK) >> ICH_VMCR_BPR1_SHIFT;
 	vmcrp->bpr  = (vmcr & ICH_VMCR_BPR0_MASK) >> ICH_VMCR_BPR0_SHIFT;
 	vmcrp->pmr  = (vmcr & ICH_VMCR_PMR_MASK) >> ICH_VMCR_PMR_SHIFT;

virt/kvm/arm/vgic/vgic.h+8−4

  * registers regardless of the hardware backed GIC used.
  */
 struct vgic_vmcr {
-	u32	ctlr;
+	u32	grpen0;
+	u32	grpen1;
+	u32	ackctl;
+	u32	fiqen;
+	u32	cbpr;
+	u32	eoim;
 	u32	abpr;
 	u32	bpr;
 	u32	pmr;  /* Priority mask field in the GICC_PMR and
 		       * ICC_PMR_EL1 priority field format */
-	/* Below member variable are valid only for GICv3 */
-	u32	grpen0;
-	u32	grpen1;
 };
 struct vgic_reg_attr {

@@ -402,7 +402,7 @@ static struct power_pmu power9_isa207_pmu = { · 401 unmodified lines
402	.name = "POWER9",	402	.name = "POWER9",
403	.n_counter = MAX_PMU_COUNTERS,	403	.n_counter = MAX_PMU_COUNTERS,
404	.add_fields = ISA207_ADD_FIELDS,	404	.add_fields = ISA207_ADD_FIELDS,
405	.test_adder = ISA207_TEST_ADDER,	405	.test_adder = P9_DD1_TEST_ADDER,
406	.compute_mmcr = isa207_compute_mmcr,	406	.compute_mmcr = isa207_compute_mmcr,
407	.config_bhrb = power9_config_bhrb,	407	.config_bhrb = power9_config_bhrb,
408	.bhrb_filter_map = power9_bhrb_filter_map,	408	.bhrb_filter_map = power9_bhrb_filter_map,
@@ -421,7 +421,7 @@ static struct power_pmu power9_pmu = { · 12 unmodified lines
421	.name = "POWER9",	421	.name = "POWER9",
422	.n_counter = MAX_PMU_COUNTERS,	422	.n_counter = MAX_PMU_COUNTERS,
423	.add_fields = ISA207_ADD_FIELDS,	423	.add_fields = ISA207_ADD_FIELDS,
424	.test_adder = P9_DD1_TEST_ADDER,	424	.test_adder = ISA207_TEST_ADDER,
425	.compute_mmcr = isa207_compute_mmcr,	425	.compute_mmcr = isa207_compute_mmcr,
426	.config_bhrb = power9_config_bhrb,	426	.config_bhrb = power9_config_bhrb,
427	.bhrb_filter_map = power9_bhrb_filter_map,	427	.bhrb_filter_map = power9_bhrb_filter_map,